void heap_maxHeapify(int current_index, Heap* heap){
int left_child_index;
int right_child_index;
int largest_index = NULL_INDEX;
Vector *vector = heap->vector;
int heapSize = heap->size;
while(largest_index != current_index){
left_child_index = heap_left(current_index);
right_child_index = heap_right(current_index);
HeapNode* current = vector_get(current_index, vector);
HeapNode* left_child = vector_get(left_child_index, vector);
HeapNode* right_child = vector_get(right_child_index, vector);
if(left_child_index <= heapSize-1 && compare(left_child, current, heap) > 0 ) {
largest_index = left_child_index;
} else {
largest_index = current_index;
}
HeapNode* largest = vector_get(largest_index, vector);
if(right_child_index <= heapSize-1 && compare(right_child, largest, heap) > 0 ) {
largest_index = right_child_index;
}
if(largest_index != current_index) {
vector_swap(current_index, largest_index, vector);
current_index = largest_index;
largest_index = NULL_INDEX;
}
}
}
void heap_minHeapify(int current_index, Heap *heap){
int left_child_index;
int right_child_index;
int smallest_index = NULL_INDEX;
Vector *vector = heap->vector;
int heapSize = heap->size;
while(smallest_index != current_index){
left_child_index = heap_left(current_index);
right_child_index = heap_right(current_index);
HeapNode* current = vector_get(current_index, vector);
HeapNode* left_child = vector_get(left_child_index, vector);
HeapNode* right_child = vector_get(right_child_index, vector);
if(left_child_index <= heapSize-1 && (compare(left_child, current, heap) < 0) ) {
smallest_index = left_child_index;
} else {
smallest_index = current_index;
}
HeapNode* smallest = vector_get(smallest_index, vector);
if(right_child_index <= heapSize-1 && (compare(right_child, smallest, heap) < 0) ) {
smallest_index = right_child_index;
}
if(smallest_index != current_index) {
vector_swap(current_index, smallest_index, vector);
current_index = smallest_index;
smallest_index = NULL_INDEX;
}
}
}
void heap_sort_dec(Heap *heap){
heap_buildMinHeap(heap);
int counter;
int heapSize = heap->size;
for(counter = heapSize - 1; counter >= 1; counter--){
vector_swap(0, counter, heap->vector);
heap->size--;
heap_minHeapify(0, heap);
}
heap->size = heapSize;
}
int vector_partition(kld_vector_t * v, int left, int right, int pivot) {
// TODO assert that vector data type is int
int pivot_data = *((int *) vector_get(v, pivot));
// move pivot to end
vector_swap(v, pivot, right);
int index = left;
int i;
for(i=left; i < right; i++) {
void * current = vector_get(v, i);
int current_data = *((int *) current);
if(current_data < pivot_data){
vector_swap(v, i, index);
index++;
}
}
vector_swap(v, index, right);
return index;
}
char *test_swap()
{
vector_p vector = vector_create(sizeof(int));
vector_add(vector, test_data(0));
vector_add(vector, test_data(1));
int swapped = vector_swap(vector, 0, 1);
mu_assert(swapped, "expected to have swapped");
mu_assert(*(int*)vector_get(vector, 0) == 1, "expected 1");
mu_assert(*(int*)vector_get(vector, 1) == 0, "expected 0");
vector_free(vector);
return NULL;
}
void minHeapDecreaseKey(int current_index, Heap *heap){
while(current_index > 0 && compare(vector_get(heap_parent(current_index), heap->vector), vector_get(current_index, heap->vector), heap) > 0){
vector_swap(current_index, heap_parent(current_index), heap->vector);
current_index = heap_parent(current_index);
}
}
int vector_move_assign(Vector* destination, Vector* source) {
vector_swap(destination, source);
return vector_destroy(source);
}
int vectortest(void)
{
VECTOR test;
VECTOR fusetest;
int n = 10, a = 5, b = 0, cnt = 0;
int* thrdVal;
test = makeVECTOR(sizeof(int), 3); //Create VECTOR. Reserve space for 3 integer elements.
fusetest = makeVECTOR(sizeof(int), 3); //Create VECTOR. Reserve space for 3 integer elements.
vectorpush(&fusetest, (void*)&a);
vectorpush(&fusetest, (void*)&b);
vectorpush(&fusetest, (void*)&n);
//Show the VECTOR size and allocated space.
printf("VECTOR size: %i, max: %i\n", test.size, test.maxsize);
//Push 10 values to the VECTOR
do
{
if(vectorpush(&test, &n) < 1)
{
printf("Error pushing element %i\n", cnt);
exit;
}
n += 2;
cnt++;
}while(cnt < 10);
vectorinsert(&test, &a, 5);
vectordelete(&test, 3);
a += 12;
vectorinsert(&test, &a, 3);
vectorpop(&test, &b);
printf("Pop: %i\n", b);
vector_read(&test, &b, 8);
printf("Read 8: %i\n", b);
vector_reverse(&test);
vector_resize(&test, 20);
cnt = 0;
do
{
if(vectorpush(&test, &n) < 1)
{
printf("Error pushing element %i\n", cnt);
exit;
}
n += 2;
cnt++;
}while(cnt < 5);
//Show the new VECTOR size and allocated space.
printf("VECTOR size: %i, max: %i\n", test.size, test.maxsize);
cnt = 0;
//Show every value inside the VECTOR
do
{
thrdVal = (int*)&test.data[sizeof(int)*cnt];
printf("test[%i] = %i\n", cnt,*thrdVal);
cnt++;
}while(cnt < test.size);
vector_shrink_to_fit(&test);
vector_swap(&test, &a, 9);
vector_swap_b(&test, 1, 13);
printf("VECTOR size: %i, max: %i\n", test.size, test.maxsize);
cnt = 0;
//Show every value inside the VECTOR
do
{
thrdVal = (int*)&test.data[sizeof(int)*cnt];
printf("test[%i] = %i\n", cnt,*thrdVal);
cnt++;
}while(cnt < test.size);
printf("\n- vector fuse -\n");
printf("VECTOR size: %i, max: %i\n", fusetest.size, fusetest.maxsize);
printf("fusetest[0] = %i\n", *thrdVal);
vector_fuse(&fusetest, &test);
cnt = 0;
printf("VECTOR size after fuse: %i, max: %i\n", fusetest.size, fusetest.maxsize);
do{
vector_read(&fusetest, thrdVal, cnt);
printf("%i: %i\n", cnt, *thrdVal);
cnt++;
}while(cnt < fusetest.size);
//Vector copy
printf("Before copy...\n");
cnt = 0;
do
{
thrdVal = (int*)&test.data[sizeof(int)*cnt];
printf("test[%i] = %i\n", cnt,*thrdVal);
cnt++;
}while(cnt < test.size);
vector_copy(&test, &fusetest, 1, 4, 2);
printf("After copy...\n");
cnt = 0;
do
{
thrdVal = (int*)&test.data[sizeof(int)*cnt];
printf("test[%i] = %i\n", cnt,*thrdVal);
cnt++;
}while(cnt < test.size);
printf("VECTOR size: %i, max: %i\n", test.size, test.maxsize);
//Clean the memory
vectorclear(&test);
printf("VECTOR size: %i, max: %i\n", test.size, test.maxsize);
return 0;
}
void menu_F7()
{
char * s; /* pointer to menu selector */
printf("\n STEREO (F7) MENU:\n");
printf("\n");
printf(" s red-blue stereoscopic mode\n");
printf(" m color monoscopic mode\n");
printf(" x swap left and right colors in stereoscopic mode\n");
printf(" e set the distance beween the eyes (current value is: %f)\n",
stereo_eye_distance);
printf(" c set the size of the clipping cube for stereo mode (current value is: %f)\n",
clipping_cube_size);
printf("\n lr set the red componnent of the left color (current value is: %f)\n",
stereo_left_color[0]);
printf(" lg set the green componnent of the left color (current value is: %f)\n",
stereo_left_color[1]);
printf(" lb set the blue componnent of the left color (current value is: %f)\n",
stereo_left_color[2]);
printf("\n rr set the red componnent of the right color (current value is: %f)\n",
stereo_right_color[0]);
printf(" rg set the green componnent of the right color (current value is: %f)\n",
stereo_right_color[1]);
printf(" rb set the blue componnent of the right color (current value is: %f)\n",
stereo_right_color[2]);
s=get_menu_selector();
if(strcmp(s,"s")==0){
stereo_mode= True;
printf("STEREO MODE\n");
clip_cube(&clipping_xyz);
}else if(strcmp(s,"m")==0){
stereo_mode= False;
printf("COLOR MODE\n");
}else if(strcmp(s,"x")==0){
{
int i,t;
for(i=0; i<3; i++)
{
t=stereo_left_mask[i];
stereo_left_mask[i]=stereo_right_mask[i];
stereo_right_mask[i]=t;
}
}
vector_swap(stereo_left_color, stereo_right_color);
printf("left and right color swaped\n");
}else if(strcmp(s,"e")==0){
printf("Input new eye distance (between 0 and 20):");
stereo_eye_distance=get_float();
if(stereo_eye_distance<0) stereo_eye_distance=0.0;
if(stereo_eye_distance>20) stereo_eye_distance=20.0;
printf("\n new value of eye distance is: %e\n", stereo_eye_distance );
/* get_anything(); */
}else if(strcmp(s,"c")==0){
printf("Input new clipping_cube_size (between 1 and 200):");
clipping_cube_size =get_float();
if(clipping_cube_size<1) clipping_cube_size=1.0;
if(clipping_cube_size>200) clipping_cube_size=200.0;
printf("\n new value of clipping_cube_size is: %e\n", clipping_cube_size );
clip_cube(&clipping_xyz);
}else if(strcmp(s,"lr")==0){
printf("Input new stereo_left_color[0] (between 0 and 1 ):");
stereo_left_color[0] =get_float();
if(stereo_left_color[0]<0) stereo_left_color[0]=0;
if(stereo_left_color[0]>1) stereo_left_color[0]=1;
printf("\n new value of stereo_left_color[0] is: %e\n", stereo_left_color[0]);
}else if(strcmp(s,"lg")==0){
printf("Input new stereo_left_color[1] (between 0 and 1 ):");
stereo_left_color[1] =get_float();
if(stereo_left_color[1]<0) stereo_left_color[1]=0;
if(stereo_left_color[1]>1) stereo_left_color[1]=1;
printf("\n new value of stereo_left_color[1] is: %e\n", stereo_left_color[1]);
}else if(strcmp(s,"lb")==0){
printf("Input new stereo_left_color[2] (between 0 and 1 ):");
stereo_left_color[2] =get_float();
if(stereo_left_color[2]<0) stereo_left_color[2]=0;
if(stereo_left_color[2]>1) stereo_left_color[2]=1;
printf("\n new value of stereo_left_color[2] is: %e\n", stereo_left_color[2]);
}else if(strcmp(s,"rr")==0){
printf("Input new stereo_right_color[0] (between 0 and 1 ):");
stereo_right_color[0] =get_float();
if(stereo_right_color[0]<0) stereo_right_color[0]=0;
if(stereo_right_color[0]>1) stereo_right_color[0]=1;
printf("\n new value of stereo_right_color[0] is: %e\n", stereo_right_color[0]);
}else if(strcmp(s,"rg")==0){
printf("Input new stereo_right_color[1] (between 0 and 1 ):");
stereo_right_color[1] =get_float();
if(stereo_right_color[1]<0) stereo_right_color[1]=0;
if(stereo_right_color[1]>1) stereo_right_color[1]=1;
printf("\n new value of stereo_right_color[1] is: %e\n", stereo_right_color[1]);
}else if(strcmp(s,"rb")==0){
printf("Input new stereo_right_color[2] (between 0 and 1 ):");
stereo_right_color[2] =get_float();
if(stereo_right_color[2]<0) stereo_right_color[2]=0;
if(stereo_right_color[2]>1) stereo_right_color[2]=1;
printf("\n new value of stereo_right_color[2] is: %e\n", stereo_right_color[2]);
}
}
Bool triangle_triangle_intersection( float A1[3],float A2[3], float A3[3],
float B1[3],float B2[3], float B3[3],
float E1[3],float E2[3]
)
{
float M[3][3], NA[3], NB[3],
B_1[3], B_2[3], B_3[3], X1[3], X2[3],
A_1[3], A_2[3], A_3[3], Y1[3], Y2[3];
double det1,det2, det3, t1, t2;
triangle_normal_vector(A1, A2, A3, NA);
if(scalar_product(NA,NA)==0)
{
return False;
}
triangle_normal_vector(B1, B2, B3, NB);
if(scalar_product(NB,NB)==0)
{
return False;
}
vector_sub(A2,A1, M[0]);
vector_sub(A3,A1, M[1]);
vector_sub(B1,A1, M[2]);
det1=matrix3_det(M);
vector_sub(B2,A1, M[2]);
det2=matrix3_det(M);
vector_sub(B3,A1, M[2]);
det3=matrix3_det(M);
if( (det1<=0 && det2<=0 && det3<=0) ||
(det1>=0 && det2>=0 && det3>=0)
)
{
/* printf("all vertices of B are on the same side of plane A1,A2,A3\n"); */
return False;
}
if( (det1<0 && det2>=0 && det3>=0) ||
(det1>0 && det2<=0 && det3<=0)
)
{
vectorcpy(B_1,B1);
vectorcpy(B_2,B2);
vectorcpy(B_3,B3);
}
else
if( (det2<0 && det1>=0 && det3>=0) ||
(det2>0 && det1<=0 && det3<=0)
)
{
vectorcpy(B_1,B2);
vectorcpy(B_2,B1);
vectorcpy(B_3,B3);
}
else
if( (det3<0 && det2>=0 && det1>=0) ||
(det3>0 && det2<=0 && det1<=0)
)
{
vectorcpy(B_1,B3);
vectorcpy(B_2,B2);
vectorcpy(B_3,B1);
}
/* B_1 is on the other side of the plane A1, A2, A3 than B_2, B_3. */
line_triangle_intersection(B_1,B_2, A1,A2,A3, X1);
line_triangle_intersection(B_1,B_3, A1,A2,A3, X2);
vector_sub(B2,B1, M[0]);
vector_sub(B3,B1, M[1]);
vector_sub(A1,B1, M[2]);
det1=matrix3_det(M);
vector_sub(A2,B1, M[2]);
det2=matrix3_det(M);
vector_sub(A3,B1, M[2]);
det3=matrix3_det(M);
if( (det1<=0 && det2<=0 && det3<=0) ||
(det1>=0 && det2>=0 && det3>=0)
)
{
/* printf("all vertices of A are on the same side of plane B1,B2,B3\n"); */
return False;
}
if( (det1<0 && det2>=0 && det3>=0) ||
(det1>0 && det2<=0 && det3<=0)
)
{
vectorcpy(A_1,A1);
vectorcpy(A_2,A2);
vectorcpy(A_3,A3);
}
else
if( (det2<0 && det1>=0 && det3>=0) ||
(det2>0 && det1<=0 && det3<=0)
)
{
vectorcpy(A_1,A2);
vectorcpy(A_2,A1);
vectorcpy(A_3,A3);
}
else
if( (det3<0 && det2>=0 && det1>=0) ||
(det3>0 && det2<=0 && det1<=0)
)
{
vectorcpy(A_1,A3);
vectorcpy(A_2,A2);
vectorcpy(A_3,A1);
}
/* A_1 is on the other side of the plane B1, B2, B3 than A_2, A_3. */
vector_add(A_1, NA, NA);
line_triangle_solve(X1,X2, A_1,A_2,NA, Y1, &t1);
line_triangle_solve(X1,X2, A_1,A_3,NA, Y2, &t2);
if(t2<t1)
{
double_swap(&t1, &t2);
vector_swap(Y1, Y2);
}
if( t2<=0 || t1>=1 )
{
/* printf("t2==%lf<=0 || t1==%lf>=1\n", t2, t1); */
return False;
}
if(t1>0)
vectorcpy(E1, Y1);
else
vectorcpy(E1, X1);
if(t2<1)
vectorcpy(E2, Y2);
else
vectorcpy(E2, X2);
return True;
/* / DOKONCZ ... */
}
int t_vector()
{
c_vector vt;
__c_vector(&vt, int_comparer);
printf("1.test create vector\n");
create_with_push_back(&vt);
print_vector(&vt);
reverse_print_vector(&vt);
clear_vector(&vt);
printf("\n\n2.test vector assign\n");
create_with_push_back(&vt);
vector_assign(&vt);
clear_vector(&vt);
printf("\n\n3.test erase vector\n");
erase_vector();
printf("\n\n4.test reserve vector\n");
create_with_push_back(&vt);
vector_reserve(&vt);
clear_vector(&vt);
printf("\n\n5.test front back\n");
create_with_push_back(&vt);
vector_front_back(&vt);
clear_vector(&vt);
printf("\n\n6.test swap\n");
create_with_push_back(&vt);
vector_swap(&vt);
clear_vector(&vt);
printf("\n\n7.test insert\n");
vector_insert(&vt);
clear_vector(&vt);
printf("\n\n8.test insert2\n");
create_with_push_back(&vt);
vector_insert2(&vt);
clear_vector(&vt);
printf("\n\n9.test fill insert\n");
create_with_push_back(&vt);
vector_fill_insert(&vt);
clear_vector(&vt);
printf("\n\n10.test resize\n");
create_with_push_back(&vt);
vector_resize(&vt);
clear_vector(&vt);
printf("\n\n11.test equal\n");
create_with_push_back(&vt);
vector_equal(&vt);
clear_vector(&vt);
printf("\n\n12.test less\n");
create_with_push_back(&vt);
vector_less(&vt);
clear_vector(&vt);
__c_rotcev(&vt);
printf("\n\nfinish testing vector!\n");
return 0;
}
