lulu 0.0.2 → 0.0.3

data/ext/lulu/merger.h

@@ -10,8 +10,6 @@
 
 #include "marker.h"
 
-void merge_markers(MARKER_INFO *info, MARKER *markers, int markers_size);
 int merge_markers_fast(MARKER_INFO *info, MARKER *markers, int markers_size);
-int merge_test(int test_markers_size);
 
 #endif /* MERGER_H_ */

data/ext/lulu/pq.c

@@ -17,228 +17,155 @@
 
 // Move index at heap location j upward until its parent's value is no bigger.
 static void pq_sift_up(PRIORITY_QUEUE *q, int j) {
-	int i = q->heap[j];
-	PRIORITY_QUEUE_VALUE val = q->values[i];
-	while (j > 0) {
-		int j_pnt = (j - 1) / 2;
-		if (q->values[q->heap[j_pnt]] <= val)
-			break;
-		int k = q->heap[j] = q->heap[j_pnt];
-		q->locs[k] = j;
-		j = j_pnt;
-	}
-	int k = q->heap[j] = i;
-	q->locs[k] = j;
+    int i = q->heap[j];
+    PRIORITY_QUEUE_VALUE val = q->values[i];
+    while (j > 0) {
+        int j_pnt = (j - 1) / 2;
+        if (q->values[q->heap[j_pnt]] <= val)
+            break;
+        int k = q->heap[j] = q->heap[j_pnt];
+        q->locs[k] = j;
+        j = j_pnt;
+    }
+    int k = q->heap[j] = i;
+    q->locs[k] = j;
 }
 
 // Move index at heap location j downward until its children's values are no smaller.
 // Pay some attention to efficiency because this is bottleneck code.
 static void pq_sift_down(PRIORITY_QUEUE *q, int j) {
-	int i = q->heap[j];
-	PRIORITY_QUEUE_VALUE val = q->values[i];
-	for (;;) {
-		int j_rgt = 2 * j + 2;
-		if (j_rgt < q->size) {
-			// two children
-			int j_lft = j_rgt - 1;
-			PRIORITY_QUEUE_VALUE val_lft = q->values[q->heap[j_lft]];
-			PRIORITY_QUEUE_VALUE val_rgt = q->values[q->heap[j_rgt]];
-			if (val_lft < val_rgt) {
-				if (val <= val_lft)
-					break;
-				int k = q->heap[j] = q->heap[j_lft];
-				q->locs[k] = j;
-				j = j_lft;
-			} else {
-				if (val <= val_rgt)
-					break;
-				int k = q->heap[j] = q->heap[j_rgt];
-				q->locs[k] = j;
-				j = j_rgt;
-			}
-		} else if (j_rgt == q->size) {
-			// left child only
-			int j_lft = j_rgt - 1;
-			if (val <= q->values[q->heap[j_lft]])
-				break;
-			int k = q->heap[j] = q->heap[j_lft];
-			q->locs[k] = j;
-			j = j_lft;
-			break; // this node has no children
-		} else {
-			break; // no children at all
-		}
-	}
-	int k = q->heap[j] = i;
-	q->locs[k] = j;
+    int i = q->heap[j];
+    PRIORITY_QUEUE_VALUE val = q->values[i];
+    for (;;) {
+        int j_rgt = 2 * j + 2;
+        if (j_rgt < q->size) {
+            // two children
+            int j_lft = j_rgt - 1;
+            PRIORITY_QUEUE_VALUE val_lft = q->values[q->heap[j_lft]];
+            PRIORITY_QUEUE_VALUE val_rgt = q->values[q->heap[j_rgt]];
+            if (val_lft < val_rgt) {
+                if (val <= val_lft)
+                    break;
+                int k = q->heap[j] = q->heap[j_lft];
+                q->locs[k] = j;
+                j = j_lft;
+            } else {
+                if (val <= val_rgt)
+                    break;
+                int k = q->heap[j] = q->heap[j_rgt];
+                q->locs[k] = j;
+                j = j_rgt;
+            }
+        } else if (j_rgt == q->size) {
+            // left child only
+            int j_lft = j_rgt - 1;
+            if (val <= q->values[q->heap[j_lft]])
+                break;
+            int k = q->heap[j] = q->heap[j_lft];
+            q->locs[k] = j;
+            j = j_lft;
+            break; // this node has no children
+        } else {
+            break; // no children at all
+        }
+    }
+    int k = q->heap[j] = i;
+    q->locs[k] = j;
 }
 
 // Initialize a newly allocated priority queue structure.
 void pq_init(PRIORITY_QUEUE *q) {
-	q->max_size = q->size = 0;
-	q->heap = NULL;
-	q->locs = NULL;
-	q->values = NULL;
+    q->max_size = q->size = 0;
+    q->heap = NULL;
+    q->locs = NULL;
+    q->values = NULL;
 }
 
 // Clear a previously initialized and possibly set up priority queue, returning
 // it to the initialized state but with all resourced freed.  Note the values
 // are owned by the user and are not freed here.
 void pq_clear(PRIORITY_QUEUE *q) {
-	Free(q->heap);
-	Free(q->locs);
-	pq_init(q);
+    Free(q->heap);
+    Free(q->locs);
+    pq_init(q);
 }
 
 // Build the queue with given pre-allocated and filled array of values.
 void pq_set_up(PRIORITY_QUEUE *q, PRIORITY_QUEUE_VALUE *values, int size) {
-	q->max_size = q->size = size;
-	q->values = values;
-	NewArray(q->heap, size);
-	NewArray(q->locs, size);
-	for (int i = 0; i < size; i++)
-		q->heap[i] = q->locs[i] = i;
-	// heapify
-	for (int j = size / 2 - 1; j >= 0; j--)
-		pq_sift_down(q, j);
+    q->max_size = q->size = size;
+    q->values = values;
+    NewArray(q->heap, size);
+    NewArray(q->locs, size);
+    for (int i = 0; i < size; i++)
+        q->heap[i] = q->locs[i] = i;
+    // heapify
+    for (int j = size / 2 - 1; j >= 0; j--)
+        pq_sift_down(q, j);
 }
 
 // Build the queue with given pre-allocated and filled array of values
 // and given heap indices.  Note the indices are owned by the heap
 // after set up and will be freed with the heap.
 void pq_set_up_heap(PRIORITY_QUEUE *q, int *heap, int size,
-		PRIORITY_QUEUE_VALUE *values, int max_size) {
-	q->max_size = max_size;
-	q->values = values;
-	q->size = size;
-	q->heap = heap;
-	NewArray(q->locs, max_size);
-	for (int i = 0; i < max_size; i++)
-		q->locs[i] = -1;
-	for (int j = 0; j < size; j++)
-		q->locs[heap[j]] = j;
-	for (int j = size / 2 - 1; j >= 0; j--)
-		pq_sift_down(q, j);
+        PRIORITY_QUEUE_VALUE *values, int max_size) {
+    q->max_size = max_size;
+    q->values = values;
+    q->size = size;
+    q->heap = heap;
+    NewArray(q->locs, max_size);
+    for (int i = 0; i < max_size; i++)
+        q->locs[i] = -1;
+    for (int j = 0; j < size; j++)
+        q->locs[heap[j]] = j;
+    for (int j = size / 2 - 1; j >= 0; j--)
+        pq_sift_down(q, j);
 }
 
 // Return the index of the minimum value on the queue.
 int pq_peek_min(PRIORITY_QUEUE *q) {
-	return q->size <= 0 ? -1 : q->heap[0];
+    return q->size <= 0 ? -1 : q->heap[0];
 }
 
 // Remove and return the index of the minimum value on the queue.
 int pq_get_min(PRIORITY_QUEUE *q) {
-	if (q->size <= 0)
-		return -1;
-	int i = q->heap[0];
-	q->locs[i] = -1;
-	if (--q->size > 0) {
-		q->heap[0] = q->heap[q->size];
-		pq_sift_down(q, 0);
-	}
-	return i;
+    if (q->size <= 0)
+        return -1;
+    int i = q->heap[0];
+    q->locs[i] = -1;
+    if (--q->size > 0) {
+        q->heap[0] = q->heap[q->size];
+        pq_sift_down(q, 0);
+    }
+    return i;
 }
 
 // Add a new value with index i into the queue.
 void pq_add(PRIORITY_QUEUE *q, int i) {
-	if (q->size >= q->max_size)
-		return;
-	int j = q->size++;
-	q->heap[j] = i;
-	pq_sift_up(q, j);
+    if (q->size >= q->max_size)
+        return;
+    int j = q->size++;
+    q->heap[j] = i;
+    pq_sift_up(q, j);
 }
 
 // Restore the heap after the value at index i is changed.
 void pq_update(PRIORITY_QUEUE *q, int i) {
-	int j = q->locs[i];
-	if (j >= 0) {
-		pq_sift_down(q, j);
-		pq_sift_up(q, j);
-	}
+    int j = q->locs[i];
+    if (j >= 0) {
+        pq_sift_down(q, j);
+        pq_sift_up(q, j);
+    }
 }
 
 // Delete index i from the heap, making the corresponding key an orphan.
 void pq_delete(PRIORITY_QUEUE *q, int i) {
-	int j = q->locs[i];
-	if (0 <= j) {
-		q->locs[i] = -1;
-		if (j < --q->size) {
-			q->heap[j] = q->heap[q->size];
-			pq_sift_down(q, j);
-			pq_sift_up(q, j);
-		}
-	}
+    int j = q->locs[i];
+    if (0 <= j) {
+        q->locs[i] = -1;
+        if (j < --q->size) {
+            q->heap[j] = q->heap[q->size];
+            pq_sift_down(q, j);
+            pq_sift_up(q, j);
+        }
+    }
 }
-
-#ifndef EXCLUDE_UNIT_TEST
-
-/* Randomly permute the given distance array. */
-void permute(PRIORITY_QUEUE_VALUE *a, int size) {
-	for (int i = size - 1; i > 0; i--) {
-		int j = rand() % (i + 1);
-		PRIORITY_QUEUE_VALUE tmp = a[i];
-		a[i] = a[j];
-		a[j] = tmp;
-	}
-}
-
-// Run a unit test on a priority queue of random data with given size.
-int pq_test(int size) {
-	PRIORITY_QUEUE q[1];
-	pq_init(q);
-
-	fprintf(stderr, "test: heap_ops (n = %d):\n", size);
-
-	// Build linear pointer array of random keys.
-	PRIORITY_QUEUE_VALUE *dist;
-	NewArray(dist, size);
-	for (int i = 0; i < size; i++)
-		dist[i] = i;
-	permute(dist, size);
-	fprintf(stderr, "  built random data\n");
-
-	pq_set_up(q, dist, size);
-	fprintf(stderr, "  finished set up\n");
-
-	// Pull min repeatedly and verify vals are what they should be.
-	PRIORITY_QUEUE_VALUE should_be = 0;
-	for (int n = 0; n < size; n++) {
-		int i = pq_get_min(q);
-		if (dist[i] != should_be++) {
-			fprintf(stderr, "fail 1: %i -> %g\n", i, dist[i]);
-			return 42;
-		}
-	}
-	fprintf(stderr, "  finished checking heapify\n");
-
-	// Now rebuild the heap by inserting one key at a time.
-	for (int n = 0; n < size; n++)
-		pq_add(q, n);
-	fprintf(stderr, "  finished insertions\n");
-
-	// And verify values again.
-	should_be = 0;
-	for (int n = 0; n < size; n++) {
-		int i = pq_get_min(q);
-		if (dist[i] != should_be++) {
-			fprintf(stderr, "  fail 2: %i -> %g\n", i, dist[i]);
-			return 4242;
-		}
-	}
-	fprintf(stderr, "  finished checking insert\n");
-
-	// Now rebuild the heap by inserting one key at a time in reverse.
-	for (int n = size - 1; n >= 0; n--)
-		pq_add(q, n);
-	fprintf(stderr, "  finished reverse insertions\n");
-
-	// Now delete one by one.
-	for (int n = 0; n < size; n++)
-		pq_delete(q, n);
-	fprintf(stderr, "  finished reverse deletions\n");
-
-	pq_clear(q);
-	return 0;
-}
-
-#endif

data/ext/lulu/pq.h

@@ -11,11 +11,11 @@
 typedef double PRIORITY_QUEUE_VALUE;
 
 typedef struct priority_queue_s {
-	int max_size;					// max number of items in heap
-	int size;						// current number of items in heap
-	int *heap;						// heap of indices to values
-	int *locs;						// map of value indices to heap locations
-	PRIORITY_QUEUE_VALUE *values;	// values referred to by heap
+    int max_size;                   // max number of items in heap
+    int size;                       // current number of items in heap
+    int *heap;                      // heap of indices to values
+    int *locs;                      // map of value indices to heap locations
+    PRIORITY_QUEUE_VALUE *values;   // values referred to by heap
 } PRIORITY_QUEUE;
 
 // Initialize a newly allocated priority queue structure.
@@ -34,8 +34,8 @@ void pq_set_up(PRIORITY_QUEUE *q, PRIORITY_QUEUE_VALUE *values, int size);
 // and given heap indices.  Note the indices are owned by the heap
 // after set up and will be freed with the heap.
 void pq_set_up_heap(PRIORITY_QUEUE *q,
-		int *heap, int size,
-		PRIORITY_QUEUE_VALUE *values, int max_size);
+        int *heap, int size,
+        PRIORITY_QUEUE_VALUE *values, int max_size);
 
 // Return the index of the minimum value on the queue.
 int pq_peek_min(PRIORITY_QUEUE *q);
@@ -53,18 +53,15 @@ void pq_add(PRIORITY_QUEUE *q, int i);
 void pq_delete(PRIORITY_QUEUE *q, int i);
 
 // Return an array containing indices currently in the heap.
-#define pq_index_set(Q)			((Q)->heap)
+#define pq_index_set(Q)         ((Q)->heap)
 
 // Return an array containing indices currently in the heap.
-#define pq_index(Q, I)			((Q)->heap[I])
+#define pq_index(Q, I)          ((Q)->heap[I])
 
 // Return the size of the index array contained above.
-#define pq_index_set_size(Q)	((Q)->size)
+#define pq_index_set_size(Q)    ((Q)->size)
 
 // Return non-zero iff the queue is empty.
 #define pq_empty_p(Q) ((Q)->size <= 0)
 
-// Run the heap module through some unit tests.
-int pq_test(int size);
-
 #endif /* PRIORITY_QUEUE_H_ */

data/ext/lulu/qt.c

@@ -14,31 +14,31 @@
 
 // Declare the given quadrant of a given bounding box.
 #define QUADRANT_DECL(Q, QX, QY, QW, QH, X, Y, W, H) \
-  double QW = W * 0.5; \
-  double QH = H * 0.5; \
-  double QX = (Q & 1) ? X + QW : X; \
-  double QY = (Q & 2) ? Y + QH : Y
+  MARKER_DISTANCE QW = W * 0.5; \
+  MARKER_DISTANCE QH = H * 0.5; \
+  MARKER_COORD QX = (Q & 1) ? X + QW : X; \
+  MARKER_COORD QY = (Q & 2) ? Y + QH : Y
 
 // Initialize a node to an empty leaf.
 static void init_leaf(NODE *node) {
-	node->children = NULL;
-	node->markers = NULL;
-	node->marker_count = node->markers_size = 0;
+    node->children = NULL;
+    node->markers = NULL;
+    node->marker_count = node->markers_size = 0;
 }
 
 // Clear contents of a leaf, returning it to the init_leaf state.
 static void clear_leaf(NODE *node) {
-	Free(node->markers);
-	init_leaf(node);
+    Free(node->markers);
+    init_leaf(node);
 }
 
 // Make a leaf into an internal node with four empty leaves.
 static void subdivide(NODE *node) {
-	if (leaf_p(node)) {
-		NewArray(node->children, 4);
-		for (int i = 0; i < 4; i++)
-			init_leaf(node->children + i);
-	}
+    if (leaf_p(node)) {
+        NewArray(node->children, 4);
+        for (int i = 0; i < 4; i++)
+            init_leaf(node->children + i);
+    }
 }
 
 static void clear_node(NODE *node);
@@ -46,254 +46,198 @@ static void clear_node(NODE *node);
 // Recursively clear an internal node by removing all
 // subtrees, returning this node to the init_leaf state.
 static void clear_internal(NODE *node) {
-	for (int i = 0; i < 4; i++)
-		clear_node(node->children + i);
-	Free(node->children);
-	clear_leaf(node);
+    for (int i = 0; i < 4; i++)
+        clear_node(node->children + i);
+    Free(node->children);
+    clear_leaf(node);
 }
 
 // Clear any node, returning it to the init_leaf state.
 // Recursively removes all subtrees.
 static void clear_node(NODE *node) {
-	if (internal_p(node))
-		clear_internal(node);
-	else
-		clear_leaf(node);
+    if (internal_p(node))
+        clear_internal(node);
+    else
+        clear_leaf(node);
 }
 
 // Add a marker to the given node's marker list.
 static void add_marker(NODE *node, MARKER *marker) {
-	if (node->marker_count == node->markers_size) {
-		node->markers_size = 2 + 2 * node->markers_size;
-		RenewArray(node->markers, node->markers_size);
-	}
-	node->markers[node->marker_count++] = marker;
+    if (node->marker_count == node->markers_size) {
+        node->markers_size = 2 + 2 * node->markers_size;
+        RenewArray(node->markers, node->markers_size);
+    }
+    node->markers[node->marker_count++] = marker;
 }
 
 // Find a marker in the given node's marker list.
 static int find_marker(NODE *node, MARKER *marker) {
-	for (int i = 0; i < node->marker_count; i++)
-		if (node->markers[i] == marker)
-			return i;
-	return -1;
+    for (int i = 0; i < node->marker_count; i++)
+        if (node->markers[i] == marker)
+            return i;
+    return -1;
 }
 
 // Delete a marker from the given node's marker list.
 static int delete_marker(NODE *node, MARKER *marker) {
-	int i = find_marker(node, marker);
-	if (i != -1 && --node->marker_count != 0)
-		node->markers[i] = node->markers[node->marker_count];
-	return i;
+    int i = find_marker(node, marker);
+    if (i != -1 && --node->marker_count != 0)
+        node->markers[i] = node->markers[node->marker_count];
+    return i;
 }
 
 // Return non-zero iff the given bounding box lies inside the marker including its boundary.
-static int bounds_inside_marker(double x, double y, double w, double h, MARKER *marker) {
-	double mx = mr_x(marker);
-	double my = mr_y(marker);
-	double mr = mr_r(marker);
-	return mx - mr <= x && x + w <= mx + mr && my - mr <= y && y + h <= my + mr ;
+static int bounds_inside_marker(MARKER_COORD x, MARKER_COORD y, MARKER_DISTANCE w, MARKER_DISTANCE h, MARKER *marker) {
+    MARKER_COORD mx = mr_x(marker);
+    MARKER_COORD my = mr_y(marker);
+    MARKER_DISTANCE mr = mr_r(marker);
+    return mx - mr <= x && x + w <= mx + mr && my - mr <= y && y + h <= my + mr;
 }
 
 // Return an integer code with bits showing which quadrants of the given
 // bounding box are overlapped by the given marker.
-static int touch_code(double x, double y, double w, double h, MARKER *marker) {
-	double xm = x + 0.5 * w;
-	double ym = y + 0.5 * h;
-	int code = bit(SW) | bit(SE) | bit(NW) | bit(NE);
-	if (mr_e(marker) < xm) code &= ~(bit(NE) | bit(SE));
-	if (mr_w(marker) > xm) code &= ~(bit(NW) | bit(SW));
-	if (mr_n(marker) < ym) code &= ~(bit(NW) | bit(NE));
-	if (mr_s(marker) > ym) code &= ~(bit(SW) | bit(SE));
-	return code;
+static int touch_code(MARKER_COORD x, MARKER_COORD y, MARKER_DISTANCE w, MARKER_DISTANCE h, MARKER *marker) {
+    MARKER_COORD xm = x + 0.5 * w;
+    MARKER_COORD ym = y + 0.5 * h;
+    int code = bit(SW) | bit(SE) | bit(NW) | bit(NE);
+    if (mr_e(marker) < xm) code &= ~(bit(NE) | bit(SE));
+    if (mr_w(marker) > xm) code &= ~(bit(NW) | bit(SW));
+    if (mr_n(marker) < ym) code &= ~(bit(NW) | bit(NE));
+    if (mr_s(marker) > ym) code &= ~(bit(SW) | bit(SE));
+    return code;
 }
 
 // Insert the given marker into the quadtree with given root and corresponding bounding box,
 // subdividing no more than the given number of levels.
-static void insert(NODE *node, int levels, double x, double y, double w, double h, MARKER *marker) {
-	if (bounds_inside_marker(x, y, w, h, marker) || levels == 0)
-		add_marker(node, marker);
-	else {
-		if (leaf_p(node))
-			subdivide(node);
-		int code = touch_code(x, y, w, h, marker);
-		for (int q = 0; q < 4; q++)
-			if (code & bit(q)) {
-				QUADRANT_DECL(q, qx, qy, qw, qh, x, y, w, h);
-				insert(node->children + q, levels - 1, qx, qy, qw, qh, marker);
-			}
-	}
+static void insert(NODE *node, int levels, MARKER_COORD x, MARKER_COORD y, MARKER_DISTANCE w, MARKER_DISTANCE h, MARKER *marker) {
+    if (bounds_inside_marker(x, y, w, h, marker) || levels == 0)
+        add_marker(node, marker);
+    else {
+        if (leaf_p(node))
+            subdivide(node);
+        int code = touch_code(x, y, w, h, marker);
+        for (int q = 0; q < 4; q++)
+            if (code & bit(q)) {
+                QUADRANT_DECL(q, qx, qy, qw, qh, x, y, w, h);
+                insert(node->children + q, levels - 1, qx, qy, qw, qh, marker);
+            }
+    }
 }
 
 // A helper function that returns true iff the given array of 4 child quadtrees are all empty leaves.
 static int empty_leaves_p(NODE *children) {
-	for (int i = 0; i < 4; i++)
-		if (internal_p(children + i) || children[i].marker_count > 0)
-			return 0;
-	return 1;
+    for (int i = 0; i < 4; i++)
+        if (internal_p(children + i) || children[i].marker_count > 0)
+            return 0;
+    return 1;
 }
 
 // Delete the given marker from the quadtree with given root and corresponding bounding box,
 // trimming any remaining empty leaves.
-static void delete(NODE *node, int levels, double x, double y, double w, double h, MARKER *marker) {
-	if (bounds_inside_marker(x, y, w, h, marker) || levels == 0)
-		delete_marker(node, marker);
-	else if (internal_p(node)){
-		int code = touch_code(x, y, w, h, marker);
-		for (int q = 0; q < 4; q++)
-			if (code & bit(q)) {
-				QUADRANT_DECL(q, qx, qy, qw, qh, x, y, w, h);
-				delete(node->children + q, levels - 1, qx, qy, qw, qh, marker);
-			}
-		if (empty_leaves_p(node->children))
-			Free(node->children);
-	}
+static void delete(NODE *node, int levels,
+        MARKER_COORD x, MARKER_COORD y, MARKER_DISTANCE w, MARKER_DISTANCE h,
+        MARKER *marker) {
+    if (bounds_inside_marker(x, y, w, h, marker) || levels == 0)
+        delete_marker(node, marker);
+    else if (internal_p(node)){
+        int code = touch_code(x, y, w, h, marker);
+        for (int q = 0; q < 4; q++)
+            if (code & bit(q)) {
+                QUADRANT_DECL(q, qx, qy, qw, qh, x, y, w, h);
+                delete(node->children + q, levels - 1, qx, qy, qw, qh, marker);
+            }
+        if (empty_leaves_p(node->children))
+            Free(node->children);
+    }
 }
 
 // Local struct to hold information about the nearest marker seen so far in a search.
 struct nearest_info {
     MARKER_INFO *info;
     MARKER *target, *nearest;
-	double distance;
+    MARKER_DISTANCE distance;
 };
 
 // Use the marker list of the given node to update nearest information with
 // respect to the given marker.
 static void update_nearest(NODE *node, struct nearest_info *nearest_info) {
-	for (int i = 0; i < node->marker_count; i++) {
-		// This < assumes the markers are in an array. It sustains the invariant.
-		if (node->markers[i] < nearest_info->target) {
-			double d = mr_distance(nearest_info->info, nearest_info->target, node->markers[i]);
-			if (d < nearest_info->distance) {
-				nearest_info->distance = d;
-				nearest_info->nearest = node->markers[i];
-			}
-		}
-	}
+    for (int i = 0; i < node->marker_count; i++) {
+        // This < assumes the markers are in an array. It sustains the invariant.
+        if (node->markers[i] < nearest_info->target) {
+            MARKER_DISTANCE d = mr_distance(nearest_info->info, nearest_info->target, node->markers[i]);
+            if (d < nearest_info->distance) {
+                nearest_info->distance = d;
+                nearest_info->nearest = node->markers[i];
+            }
+        }
+    }
 }
 
 // Search out the nearest marker that overlaps the given one.  This just visits every
 // quad that overlaps the given marker and remembers the closest marker it sees. The
 // circle distance function renders quite impossible the ruling out of quads as in
 // nearest point neighbor search.
-static void search_for_nearest(NODE *node, double x, double y, double w, double h, struct nearest_info *nearest_info) {
-	update_nearest(node, nearest_info);
-	if (internal_p(node)) {
-		// Search the children that include some part of the marker.
-		int code = touch_code(x, y, w, h, nearest_info->target);
-		for (int q = 0; q < 4; q++)
-			if (code & bit(q)) {
-				QUADRANT_DECL(q, qx, qy, qw, qh, x, y, w, h);
-				search_for_nearest(node->children + q, qx, qy, qw, qh, nearest_info);
-			}
-	}
-}
-
-static MARKER *nearest(MARKER_INFO *info, NODE *node, double x, double y, double w, double h, MARKER *marker) {
-	struct nearest_info nearest_info[1] = {{ info, marker, NULL, 0 }};
-	search_for_nearest(node, x, y, w, h, nearest_info);
-	return nearest_info->nearest;
+static void search_for_nearest(NODE *node,
+        MARKER_COORD x, MARKER_COORD y, MARKER_DISTANCE w, MARKER_DISTANCE h,
+        struct nearest_info *nearest_info) {
+    update_nearest(node, nearest_info);
+    if (internal_p(node)) {
+        // Search the children that include some part of the marker.
+        int code = touch_code(x, y, w, h, nearest_info->target);
+        for (int q = 0; q < 4; q++)
+            if (code & bit(q)) {
+                QUADRANT_DECL(q, qx, qy, qw, qh, x, y, w, h);
+                search_for_nearest(node->children + q, qx, qy, qw, qh, nearest_info);
+            }
+    }
+}
+
+static MARKER *nearest(MARKER_INFO *info, NODE *node,
+        MARKER_COORD x, MARKER_COORD y, MARKER_DISTANCE w, MARKER_DISTANCE h,
+        MARKER *marker) {
+    struct nearest_info nearest_info[1] = {{ info, marker, NULL, 0 }};
+    search_for_nearest(node, x, y, w, h, nearest_info);
+    return nearest_info->nearest;
 }
 
 void qt_init(QUADTREE *qt) {
-	init_leaf(qt->root);
-	qt->x = qt->y = qt->w = qt->h = 0;
+    init_leaf(qt->root);
+    qt->x = qt->y = qt->w = qt->h = 0;
 }
 
-void qt_setup(QUADTREE *qt, int max_depth, double x, double y, double w, double h, MARKER_INFO *info) {
-	qt->x = x;
-	qt->y = y;
-	qt->w = w;
-	qt->h = h;
-	qt->max_depth = max_depth;
-	qt->info = info;
+void qt_setup(QUADTREE *qt, int max_depth,
+        MARKER_COORD x, MARKER_COORD y, MARKER_DISTANCE w, MARKER_DISTANCE h,
+        MARKER_INFO *info) {
+    qt->x = x;
+    qt->y = y;
+    qt->w = w;
+    qt->h = h;
+    qt->max_depth = max_depth;
+    qt->info = info;
 }
 
 void qt_clear(QUADTREE *qt) {
-	clear_node(qt->root);
-	qt_init(qt);
+    clear_node(qt->root);
+    qt_init(qt);
 }
 
 void qt_insert(QUADTREE *qt, MARKER *marker) {
-	double x = mr_x(marker);
-	double y = mr_y(marker);
-	double r = mr_r(marker);
-	if (x + r >= qt->x && x - r <= qt->x + qt->w && y + r >= qt->y && y - r <= qt->y + qt->h)
-		insert(qt->root, qt->max_depth, qt->x, qt->y, qt->w, qt->h, marker);
+    MARKER_COORD x = mr_x(marker);
+    MARKER_COORD y = mr_y(marker);
+    MARKER_DISTANCE r = mr_r(marker);
+    if (x + r >= qt->x && x - r <= qt->x + qt->w && y + r >= qt->y && y - r <= qt->y + qt->h)
+        insert(qt->root, qt->max_depth, qt->x, qt->y, qt->w, qt->h, marker);
 }
 
 void qt_delete(QUADTREE *qt, MARKER *marker) {
-	delete(qt->root, qt->max_depth, qt->x, qt->y, qt->w, qt->h, marker);
+    delete(qt->root, qt->max_depth, qt->x, qt->y, qt->w, qt->h, marker);
 }
 
 MARKER *qt_nearest(QUADTREE *qt, MARKER *marker) {
-	return nearest(qt->info, qt->root, qt->x, qt->y, qt->w, qt->h, marker);
+    return nearest(qt->info, qt->root, qt->x, qt->y, qt->w, qt->h, marker);
 }
 
 int qt_nearest_wrt(MARKER *markers, QUADTREE *qt, int a) {
-	MARKER *nearest = qt_nearest(qt, markers + a);
-	return nearest ? (int)(nearest - markers) : -1;
-}
-
-#ifndef EXCLUDE_UNIT_TEST
-
-static void draw(FILE *f, NODE *node, double x, double y, double w, double h) {
-	emit_rectangle(f, x, y, w, h);
-	emit_marker_ptr_array(f, node->markers, node->marker_count);
-	if (internal_p(node)) {
-		for (int q = 0; q < 4; q++) {
-			QUADRANT_DECL(q, qx, qy, qw, qh, x, y, w, h);
-			draw(f, node->children + q, qx, qy, qw, qh);
-		}
-	}
-}
-
-static void draw_nearest(FILE *f, MARKER *markers, MARKER **nearest_markers, int n_markers) {
-	for (int i = 0; i < n_markers; i++) {
-		if (nearest_markers[i])
-			emit_segment(f, markers + i, nearest_markers[i]);
-	}
+    MARKER *nearest = qt_nearest(qt, markers + a);
+    return nearest ? (int)(nearest - markers) : -1;
 }
-
-int qt_draw(QUADTREE *qt, MARKER *markers, MARKER **nearest_markers, int n_markers, const char *name) {
-	char buf[1024];
-	sprintf(buf, "test/%s.js", name);
-	FILE *f = fopen(buf, "w");
-	if (!f)
-		return -1;
-	fprintf(f, "var %s = [\n", name);
-	draw(f, qt->root, qt->x, qt->y, qt->w, qt->h);
-	draw_nearest(f, markers, nearest_markers, n_markers);
-	fprintf(f, "];\n");
-	fclose(f);
-	return EXIT_SUCCESS;
-}
-
-int qt_test(int size) {
-	QUADTREE_DECL(qt);
-	MARKER_INFO_DECL(info);
-	MARKER *markers, **nearest_markers;
-	NewArray(markers, size);
-	NewArray(nearest_markers, size);
-	set_random_markers(info, markers, size);
-	qt_setup(qt, 5, 0, 0, 1024, 724, info);
-	fprintf(stderr, "inserting %d:\n", size);
-	for (int i = 0; i < size; i++) {
-		qt_insert(qt, markers + i);
-	}
-	fprintf(stderr, "inserted %d\n", size);
-	for (int i = 0; i < size; i++) {
-		nearest_markers[i] = qt_nearest(qt, markers + i);
-	}
-	fprintf(stderr, "looked up %d\n", size);
-	qt_draw(qt, markers, nearest_markers, size, "qt");
-	fprintf(stderr, "drew %d\n", size);
-	for (int i = 0; i < size; i++) {
-		qt_delete(qt, markers + i);
-	}
-	fprintf(stderr, "after delete all, root is %s\n",
-			leaf_p(qt->root) ? "leaf (ok)" : "internal (not ok)");
-
-	return EXIT_SUCCESS;
-}
-
-#endif