// Fourier descriptor
int test_fourier_descriptor(vector_t *fd, point_list_t *plist)
{
int i, n;
vector_t *time, *fourier, *fd;
complex_t comp;
assert(fd);
assert(plist);
assert(vecter_get_length(fd) == point_list_get_count(plist));
time = cvector_new_and_copy_point_list(plist);
fourier = vector_new(vector_get_length(time), true);
//fd = vector_new(vector_get_length(time), true);
dft(fourier, time);
n = vector_get_length(time);
// filtering
/*
comp.real = comp.imag = 0.0;
for (i = n / 2 - 16; i < n / 2 + 16; i++) {
cvector_put_value(comp, i, fourier);
}
*/
/////////////////////// Normalization ////////////////////////////
vector_copy(fd, fourier);
// For translation invariance, 0 frequency must have a zero value
cvector_put_value(comp, 0, fd);
// For scale invariance,
// fourier descriptor must be divied by the absolute of 1 frequency component.
cvector_read_value(&comp, 1, fd);
val = complex_get_abs(&comp);
vector_divide_scalar(fd, val);
ivector_divide_scalar(fd, val);
// For rotating and changes in starting point
// remove all phase information and
// consider only absolute values of the descriptor element
//f = fopen("fourier_descriptor.txt", "a+");
//fprintf(f, "%s", fn);
for (i = 0; i < vector_get_length(fd); i++) {
cvector_read_value(&comp, i, fd);
val = complex_get_abs(&comp);
vector_put_value(val, i, fd);
ivector_put_value(0, i, fd);
//fprintf(f, ", %lf", val);
}
//fprintf(f, "\n");
//fclose(f);
///////////////////////////////////////////////////////////////////
// idft(time, fourier);
return n;
}
void allocator_object_write_barrier(Partial_Reveal_Object* p_object, Collector* allocator)
{
if( addr_belongs_to_nos(p_object)) return;
REF* p_slot;
/* scan array object */
if (object_is_array((Partial_Reveal_Object*)p_object)) {
Partial_Reveal_Object* array = p_object;
assert(!obj_is_primitive_array(array));
I_32 array_length = vector_get_length((Vector_Handle) array);
for (int i = 0; i < array_length; i++) {
p_slot = (REF *)vector_get_element_address_ref((Vector_Handle)array, i);
if( read_slot(p_slot) != NULL && addr_belongs_to_nos(read_slot(p_slot))){
collector_remset_add_entry(allocator, (Partial_Reveal_Object**)p_slot);
}
}
return;
}
/* scan non-array object */
Partial_Reveal_Object* p_obj = (Partial_Reveal_Object*)p_object;
unsigned int num_refs = object_ref_field_num(p_obj);
int *ref_iterator = object_ref_iterator_init(p_obj);
for(unsigned int i=0; i<num_refs; i++){
p_slot = object_ref_iterator_get(ref_iterator+i, p_obj);
if( addr_belongs_to_nos(read_slot(p_slot))){
collector_remset_add_entry(allocator, (Partial_Reveal_Object**)p_slot);
}
}
return;
}
void vector_normalize(vector_t *v)
{
float length = vector_get_length(*v);
v->x /= length;
v->y /= length;
v->z /= length;
}
static FORCE_INLINE void scan_object(Collector* collector, Partial_Reveal_Object *p_obj)
{
assert((((POINTER_SIZE_INT)p_obj) % GC_OBJECT_ALIGNMENT) == 0);
if (!object_has_ref_field(p_obj)) return;
REF *p_ref;
/* scan array object */
if (object_is_array(p_obj)) {
Partial_Reveal_Object* array = p_obj;
assert(!obj_is_primitive_array(array));
I_32 array_length = vector_get_length((Vector_Handle) array);
for (int i = 0; i < array_length; i++) {
p_ref= (REF *)vector_get_element_address_ref((Vector_Handle) array, i);
scan_slot(collector, p_ref);
}
return; /* array can't be a reference object, directly return. */
}
/* scan non-array object */
unsigned int num_refs = object_ref_field_num(p_obj);
int *ref_iterator = object_ref_iterator_init(p_obj);
for(unsigned int i=0; i<num_refs; i++){
REF* p_ref = object_ref_iterator_get(ref_iterator+i, p_obj);
scan_slot(collector, p_ref);
}
#ifndef BUILD_IN_REFERENT
scan_weak_reference(collector, p_obj, scan_slot);
#endif
return;
}
/*This function is for concurrent mark.*/
static void write_barrier_rem_obj_snapshot(Managed_Object_Handle p_obj_holding_ref)
{
Mutator *mutator = (Mutator *)gc_get_tls();
REF* p_obj_slot;
if(obj_need_take_snapshot((Partial_Reveal_Object*)p_obj_holding_ref)){
if (object_is_array((Partial_Reveal_Object*)p_obj_holding_ref)) {
Partial_Reveal_Object* array = (Partial_Reveal_Object*)p_obj_holding_ref;
assert(!obj_is_primitive_array(array));
Partial_Reveal_Object* obj_to_snapshot;
I_32 array_length = vector_get_length((Vector_Handle) array);
for (int i = 0; i < array_length; i++) {
p_obj_slot = (REF*)vector_get_element_address_ref((Vector_Handle) array, i);
obj_to_snapshot = (Partial_Reveal_Object*)read_slot(p_obj_slot);
if (obj_to_snapshot != NULL)
mutator_dirtyset_add_entry(mutator, obj_to_snapshot);
}
}else{
/* scan non-array object */
Partial_Reveal_Object* p_obj = (Partial_Reveal_Object*)p_obj_holding_ref;
unsigned int num_refs = object_ref_field_num(p_obj);
int *ref_iterator = object_ref_iterator_init(p_obj);
Partial_Reveal_Object* obj_to_snapshot;
for(unsigned int i=0; i<num_refs; i++){
p_obj_slot = object_ref_iterator_get(ref_iterator+i, p_obj);
obj_to_snapshot = (Partial_Reveal_Object*)read_slot(p_obj_slot);
if (obj_to_snapshot != NULL)
mutator_dirtyset_add_entry(mutator, obj_to_snapshot);
}
if(is_reference_obj(p_obj)){
REF* p_referent_field = obj_get_referent_field(p_obj);
obj_to_snapshot = (Partial_Reveal_Object*)read_slot(p_referent_field);
if (obj_to_snapshot != NULL)
mutator_dirtyset_add_entry(mutator, obj_to_snapshot);
}
}
obj_mark_gray_in_table((Partial_Reveal_Object *) p_obj_holding_ref); // now, the black-only obj (no gray bit been set) will also be scaned by marker, here mark it to gray to prevent this, just a workaround
obj_mark_black_in_table((Partial_Reveal_Object *) p_obj_holding_ref, mutator);
obj_dirty_in_table((Partial_Reveal_Object *) p_obj_holding_ref);
}
}
static void scan_array(Object_With_Header *obj)
{
Vector_Handle vector = (Vector_Handle)obj->start();
int32 length = vector_get_length(vector);
Type_Info_Handle tih = class_get_element_type_info(obj->vt()->gcvt->ch);
if(type_info_is_reference(tih) ||
type_info_is_vector(tih) ||
type_info_is_general_array(tih)) {
Managed_Object_Handle *first_elem_addr =
vector_get_element_address_ref(vector, 0);
if (GC::compressing_references) {
for(int i = 0; i < length; i++) {
COMPRESSED_REFERENCE elem = ((COMPRESSED_REFERENCE *)first_elem_addr)[i];
mark_recursive((void *)elem, /*is_compressed_root*/ true);
}
} else {
for(int i = 0; i < length; i++) {
mark_recursive(first_elem_addr[i], /*is_compressed_root*/ false);
}
}
} else if(type_info_is_primitive(tih)) {
} else if(type_info_is_unboxed(tih)) {
Class_Handle ech = type_info_get_class(tih);
assert(ech);
int first_elem_offset = vector_first_element_offset_unboxed(ech);
int base_offset = 0;//(int)class_get_unboxed_data_offset(ech);
int elem_size = class_element_size(obj->vt()->gcvt->ch);
Vtable_GC *evt = (Vtable_GC *)class_get_vtable(ech);
uint16 *offsets = evt->gcvt->offsets;
int curr_elem_offset = first_elem_offset;
for(int i = 0; i < length; i++) {
uint16 *o = offsets;
while(*o) {
int adjusted_offset = curr_elem_offset + *o - base_offset;
Managed_Object_Handle *slot = (Managed_Object_Handle *)(((Byte *)vector) + adjusted_offset);
mark_recursive(*slot, /*is_compressed_root*/ GC::compressing_references);
o++;
}
curr_elem_offset += elem_size;
}
} else {
ABORT("All possible cases should already be covered");
}
} //scan_array
