void test_max_heap(void)
{
BinaryHeap *heap;
int *val;
int i;
heap = binary_heap_new(BINARY_HEAP_TYPE_MAX, int_compare);
/* Push a load of values onto the heap */
for (i=0; i<NUM_TEST_VALUES; ++i) {
test_array[i] = i;
assert(binary_heap_insert(heap, &test_array[i]) != 0);
}
/* Pop values off the heap and check they are in order */
i = NUM_TEST_VALUES;
while (binary_heap_num_entries(heap) > 0) {
val = (int *) binary_heap_pop(heap);
assert(*val == i - 1);
i = *val;
}
binary_heap_free(heap);
}
void test_min_heap(void)
{
BinaryHeap *heap;
int *val;
int i;
heap = binary_heap_new(BINARY_HEAP_TYPE_MIN, int_compare);
/* Push a load of values onto the heap */
for (i=0; i<NUM_TEST_VALUES; ++i) {
test_array[i] = i;
assert(binary_heap_insert(heap, &test_array[i]) != 0);
}
/* Pop values off the heap and check they are in order */
i = -1;
while (binary_heap_num_entries(heap) > 0) {
val = (int *) binary_heap_pop(heap);
assert(*val == i + 1);
i = *val;
}
/* Test popping from an empty heap */
assert(binary_heap_num_entries(heap) == 0);
assert(binary_heap_pop(heap) == BINARY_HEAP_NULL);
binary_heap_free(heap);
}
void test_binary_heap_insert(void)
{
BinaryHeap *heap;
int i;
heap = binary_heap_new(BINARY_HEAP_TYPE_MIN, int_compare);
for (i=0; i<NUM_TEST_VALUES; ++i) {
test_array[i] = i;
assert(binary_heap_insert(heap, &test_array[i]) != 0);
}
assert(binary_heap_num_entries(heap) == NUM_TEST_VALUES);
binary_heap_free(heap);
}
void test_binary_heap_new_free(void)
{
BinaryHeap *heap;
int i;
for (i=0; i<NUM_TEST_VALUES; ++i) {
heap = binary_heap_new(BINARY_HEAP_TYPE_MIN, int_compare);
binary_heap_free(heap);
}
/* Test low memory scenario */
alloc_test_set_limit(0);
heap = binary_heap_new(BINARY_HEAP_TYPE_MIN, int_compare);
assert(heap == NULL);
alloc_test_set_limit(1);
heap = binary_heap_new(BINARY_HEAP_TYPE_MIN, int_compare);
assert(heap == NULL);
}
void test_out_of_memory(void)
{
BinaryHeap *heap;
int *value;
int values[] = { 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
int i;
/* Allocate a heap and fill to the default limit */
heap = binary_heap_new(BINARY_HEAP_TYPE_MIN, int_compare);
alloc_test_set_limit(0);
for (i=0; i<16; ++i) {
assert(binary_heap_insert(heap, &values[i]) != 0);
}
assert(binary_heap_num_entries(heap) == 16);
/* Check that we cannot add new values */
for (i=0; i<16; ++i) {
assert(binary_heap_insert(heap, &values[i]) == 0);
assert(binary_heap_num_entries(heap) == 16);
}
/* Check that we can read the values back out again and they
* are in the right order. */
for (i=0; i<16; ++i) {
value = binary_heap_pop(heap);
assert(*value == i);
}
assert(binary_heap_num_entries(heap) == 0);
binary_heap_free(heap);
}
/* douglas-peucker algorithm which simplifies a line to a line with
* at most reduction% of points.
* returns the number of points in the output line. It is approx
* reduction/100 * Points->n_points.
*/
int douglas_peucker_reduction(struct line_pnts *Points, double thresh,
double reduction, int with_z)
{
int i;
int n = Points->n_points;
/* the maximum number of points which may be
* included in the output */
int nexp = n * (reduction / (double)100.0);
/* line too short */
if (n < 3)
return n;
/* indicates which point were selected by the algorithm */
int *sel;
sel = G_calloc(sizeof(int), n);
if (sel == NULL) {
G_fatal_error(_("Out of memory"));
return n;
}
/* array used for storing the indices of line segments+furthest point */
int *index;
index = G_malloc(sizeof(int) * 3 * n);
if (index == NULL) {
G_fatal_error(_("Out of memory"));
G_free(sel);
return n;
}
int indices;
indices = 0;
/* preserve first and last point */
sel[0] = sel[n - 1] = 1;
nexp -= 2;
thresh *= thresh;
double d;
int mid = get_furthest(Points, 0, n - 1, with_z, &d);
int em;
/* priority queue of line segments,
* key is the distance of the furthest point */
binary_heap pq;
if (!binary_heap_init(n, &pq)) {
G_fatal_error(_("Out of memory"));
G_free(sel);
G_free(index);
return n;
}
if (d > thresh) {
index[0] = 0;
index[1] = n - 1;
index[2] = mid;
binary_heap_push(d, 0, &pq);
indices = 3;
}
/* while we can add new points and queue is non-empty */
while (nexp > 0) {
/* empty heap */
if (!binary_heap_extract_max(&pq, &em))
break;
int left = index[em];
int right = index[em + 1];
int furt = index[em + 2];
/*mark the furthest point */
sel[furt] = 1;
nexp--;
/* consider left and right segment */
mid = get_furthest(Points, left, furt, with_z, &d);
if (d > thresh) {
binary_heap_push(d, indices, &pq);
index[indices++] = left;
index[indices++] = furt;
index[indices++] = mid;
}
mid = get_furthest(Points, furt, right, with_z, &d);
if (d > thresh) {
binary_heap_push(d, indices, &pq);
index[indices++] = furt;
index[indices++] = right;
index[indices++] = mid;
}
}
/* copy selected points */
int selected = 0;
for (i = 0; i < n; i++) {
if (sel[i]) {
Points->x[selected] = Points->x[i];
Points->y[selected] = Points->y[i];
Points->z[selected] = Points->z[i];
selected++;
}
}
G_free(sel);
G_free(index);
binary_heap_free(&pq);
Points->n_points = selected;
return Points->n_points;
}
static void test_binary_heap (void) {
BinaryHeap* heap;
heap = binary_heap_new (BINARY_HEAP_TYPE_MAX, string_compare);
binary_heap_free (heap);
}
