bool segments_intersect(segment s1, segment s2) {
line l1, l2; /* lines containing the input segments */
point p; /* intersection point */
points_to_line(s1.p1, s1.p2, &l1);
points_to_line(s2.p1, s2.p2, &l2);
if(same_lineQ(l1, l2)) /* overlapping or disjoint segments */
return( point_in_box(s1.p1, s2.p1, s2.p2) ||
point_in_box(s1.p2, s2.p1, s2.p2) ||
point_in_box(s2.p1, s1.p1, s1.p2) ||
point_in_box(s2.p2, s1.p1, s1.p2) );
if(parallelQ(l1, l2)) return(FALSE);
intersection_point(l1, l2, p);
return( point_in_box(p, s1.p1, s1.p2) && point_in_box(p, s2.p1, s2.p2) );
}
bool segments_intersect(segment s1, segment s2)
{
line l1, l2;
points_to_line(s1.p1, s1.p2, &l1);
points_to_line(s2.p1, s2.p2, &l2);
if (same_lineQ(l1, l2))
return (point_in_box(s1.p1, s2.p1, s2.p2) ||
point_in_box(s1.p2, s2.p1, s2.p2) ||
point_in_box(s2.p1, s1.p1, s1.p2) ||
point_in_box(s2.p1, s1.p1, s1.p2) );
if (parallelQ(l1, l2))
return false;
point2d p; // intersection point
intersection_point(l1, l2, p);
return (point_in_box(p, s1.p1, s1.p2) && point_in_box(p, s2.p1, s2.p2) );
}
void seek(double* a, int n, int k, int* iz){
int i, j, h, *qtreeSize, *perm, currIndex, travIndex, *mapping, *sub_iz, sub_n, sub_k, sub_aIndex;
double radius, *sub_a, tempx, tempy;
Box **qtree, *curr, **trav;
Point temp, *points, p, *restricted_points;
// make points easier to work with.
points = malloc(n * sizeof(Point));
for(i = 0; i < 2*n; i+=2){
temp.x = a[i];
temp.y = a[i+1];
temp.index = i/2;
points[i/2] = temp;
}
// init permutation array
perm = malloc(n * sizeof(int));
for(i = 0; i < n; i++){
perm[i] = i;
}
// build quad tree
qtreeSize = malloc(sizeof(int));
*qtreeSize = 100000;
qtree = calloc(*qtreeSize, sizeof(Box*));
build_tree(points, &qtree, qtreeSize, perm, n, k);
// deeeleeetteee
tree_built = clock();
// traverse quad tree for each point.
for(i = 0; i < n; i++){
p = points[i];
curr = qtree[0];
currIndex = 0;
// find smallest box (leaf) that holds point.
while(1){
if(curr->c1 < 0)
break;
else if(point_in_box(p, *(qtree[curr->c1])))
currIndex = curr->c1;
else if(point_in_box(p, *(qtree[curr->c2])))
currIndex = curr->c2;
else if(point_in_box(p, *(qtree[curr->c3])))
currIndex = curr->c3;
else if(point_in_box(p, *(qtree[curr->c4])))
currIndex = curr->c4;
curr = qtree[currIndex];
}
//generate circle radius, center is Point p.
radius = gen_radius(p, curr, qtree);
// init traversal array to all NULL ptrs
trav = calloc(*qtreeSize, sizeof(Box*));
travIndex = 1; // index of last element in trav + 1.
trav[0] = qtree[0];
// generate sparse arr with only ptrs to leaf's intsct w/ circle
for(j = 0; j < travIndex; j++){
if(trav[j]->c1 > -1){ // not a leaf
trav[travIndex] = qtree[trav[j]->c1];
trav[travIndex+1] = qtree[trav[j]->c2];
trav[travIndex+2] = qtree[trav[j]->c3];
trav[travIndex+3] = qtree[trav[j]->c4];
travIndex += 4;
trav[j] = NULL;
}
// if box and circle don't overlap, set current ptr to NULL
else if(!circle_box_intersect(p, radius, *(trav[j]))){
trav[j] = NULL;
}
}
// compile points from pertinent leafs
mapping = malloc(n * sizeof(int));
sub_n = 0;
sub_a = malloc(2*n * sizeof(double));
sub_aIndex = 0;
for(j = 0; j < travIndex; j++){
if(trav[j]){
for(h = trav[j]->perm_start; h < trav[j]->perm_end; h++){
sub_a[sub_aIndex++] = (points[perm[h]]).x;
sub_a[sub_aIndex++] = (points[perm[h]]).y;
mapping[sub_n] = perm[h];
sub_n++;
}
}
}
sub_iz = malloc(sub_n*k * sizeof(int));
// printf("n = %d\n", sub_n);
seek_naive(sub_a, sub_n, k, sub_iz);
// put pertinent part of sub_iz into iz. for seek_naive
for(j = 0; j < 2*sub_n; j+=2){
if(sub_a[j] == p.x && sub_a[j+1] == p.y){ // got it.
for(h = 0; h < k; h++){
iz[i*k+h] = mapping[sub_iz[(j/2)*k+h]-1];
}
break;
}
}
free(trav);
free(sub_a);
free(sub_iz);
free(mapping);
}
// REMEMBER TO INCREMENT INDICES WHEN FINISHED DEVELOPING
for(i = 0; i < k*n; i++){
iz[i]++;
}
for(i = 0; i < *qtreeSize; i++){
if(qtree[i] != NULL)
free(qtree[i]);
}
free(qtree);
free(qtreeSize);
free(perm);
free(points);
}
// indexes[0] is start of c1, indexes[1] start of c2, [2] start c3 etc
// points ll and ur gives dimensions of box to split into children and sort.
void sort(int* perm, Point* points, int start, int end, int* indexes, Box c1, Box c2, Box c3, Box c4){
int *c1_arr, *c2_arr, *c3_arr, *c4_arr, c1ind, c2ind, c3ind, c4ind, i, indSum;
c1ind = c2ind = c3ind = c4ind = 0;
c1_arr = malloc(REALLY_BIG_NUMBER * sizeof(int));
c2_arr = malloc(REALLY_BIG_NUMBER * sizeof(int));
c3_arr = malloc(REALLY_BIG_NUMBER * sizeof(int));
c4_arr = malloc(REALLY_BIG_NUMBER * sizeof(int));
for(i = start; i < end; i++){
// need else if's otherwise pts included twice.
if(point_in_box(points[perm[i]], c1)){
c1_arr[c1ind++] = perm[i];
}
else if(point_in_box(points[perm[i]], c2)){
c2_arr[c2ind++] = perm[i];
}
else if(point_in_box(points[perm[i]], c3)){
c3_arr[c3ind++] = perm[i];
}
else if(point_in_box(points[perm[i]], c4)){
c4_arr[c4ind++] = perm[i];
}
else{
printf("WHOA THERE THE SORT FUNCTION F****D UP!\n");
exit(1);
}
}
indexes[0] = i = start;
indSum = start;
if(c1ind > 0){
indSum += c1ind;
for(; i < indSum; i++)
perm[i] = c1_arr[i-start];
}
indexes[1] = i;
if(c2ind > 0){
indSum += c2ind;
for(; i < indSum; i++)
perm[i] = c2_arr[i-c1ind-start];
}
indexes[2] = i;
if(c3ind > 0){
indSum += c3ind;
for(; i < indSum; i++)
perm[i] = c3_arr[i-c1ind-c2ind-start];
}
indexes[3] = i;
if(c4ind > 0){
indSum += c4ind;
for(; i < indSum; i++)
perm[i] = c4_arr[i-c1ind-c2ind-c3ind-start];
}
indexes[4] = i;
free(c1_arr);
free(c2_arr);
free(c3_arr);
free(c4_arr);
return;
}
