static bool bpqGetMaxSizeTest() {
	SPBPQueue source = NULL;
	SPListElement e1;

	ASSERT_TRUE(-1 == spBPQueueGetMaxSize(source)); //check edge case

	// check that max size is always maxSize
	source = quickQ(0);
	ASSERT_TRUE(maxSize == spBPQueueGetMaxSize(source));

	// insert a new element and check max size
	e1 = spListElementCreate(1, 1.0);
	spBPQueueEnqueue(source, e1);
	ASSERT_TRUE(maxSize == spBPQueueGetMaxSize(source));

	// insert another element and check max size
	spListElementSetIndex(e1, 2);
	spListElementSetValue(e1, 2.0);
	spBPQueueEnqueue(source, e1);
	ASSERT_TRUE(maxSize == spBPQueueGetMaxSize(source));

	// remove an element and check max size
	spBPQueueDequeue(source);
	ASSERT_TRUE(maxSize == spBPQueueGetMaxSize(source));

	// free memory
	spBPQueueDestroy(source);
	spListElementDestroy(e1);
	return true;
}
Пример #2
0
/**
 * internal help method to find the k nearest neighbors
 */
void spKNNSearch(SPPoint queryFeature, const SPKDTreeNode node, SPBPQueue q){
    SPListElement element;
    int index, distance;
    bool distanceFlag = false;
    if(!node){
        return;
    }
    if(node->dim==INVALID){				//** this is a leaf **//
        index = spPointGetIndex(node->data);
        distance = spPointL2SquaredDistance(queryFeature, node->data);
        element = spListElementCreate(index, distance);
        spBPQueueEnqueue(q, element);
        spListElementDestroy(element);
        return;
    }
    			//** go to the left sub tree **//
    if(spPointGetAxisCoor(queryFeature, node->dim)<= node->val){
        spKNNSearch(queryFeature, node->left, q);
        distance = pow((spPointGetAxisCoor(queryFeature,
        									node->dim) - node->val),2);
        distanceFlag = distance < spBPQueueMaxValue(q);
        if(!spBPQueueIsFull(q) || distanceFlag){
            spKNNSearch(queryFeature, node->right, q);
        }
    }else{
        spKNNSearch(queryFeature, node->right, q);
        distance = pow((spPointGetAxisCoor(queryFeature,
        									node->dim) - node->val),2);
        distanceFlag = distance < spBPQueueMaxValue(q);
        if(!spBPQueueIsFull(q) || distanceFlag){
            spKNNSearch(queryFeature, node->left, q);
        }
    }
    return;
}
// tester for spBPQueueCopy
static bool bpqCopyTest() {
	SPBPQueue source, source2, copy, copy2;
	SPListElement e1, e2, e3, e4, epeek;

	ASSERT_TRUE(spBPQueueCopy(NULL) == NULL); // check edge case

	source = spBPQueueCreate(10);
	copy = spBPQueueCopy(source);
	ASSERT_TRUE(copy != NULL);
	ASSERT_TRUE(0 == spBPQueueSize(copy));

	// e1, e2, e3, e4
	CREATE_4_ELEMENTS()

	spBPQueueEnqueue(source, e1);
	ASSERT_TRUE(0 == spBPQueueSize(copy)); // ensure the copy is a NEW COPY

	source2 = quickQ(4, e1, e2, e3, e4);
	copy2 = spBPQueueCopy(source2);
	ASSERT_TRUE(4 == spBPQueueSize(copy2)); // check that size of copy is correct

	// check that all elements copied correctly
	epeek = spBPQueuePeek(copy2);
	ASSERT_TRUE(spListElementCompare(e1, epeek) == 0);
	spBPQueueDequeue(copy2);
	spListElementDestroy(epeek); // free the element

	// repeat
	epeek = spBPQueuePeek(copy2);
	ASSERT_TRUE(spListElementCompare(e2, epeek) == 0);
	spBPQueueDequeue(copy2);
	spListElementDestroy(epeek);

	epeek = spBPQueuePeek(copy2);
	ASSERT_TRUE(spListElementCompare(e3, epeek) == 0);
	spBPQueueDequeue(copy2);
	spListElementDestroy(epeek);

	epeek = spBPQueuePeek(copy2);
	ASSERT_TRUE(spListElementCompare(e4, epeek) == 0);
	spBPQueueDequeue(copy2);
	spListElementDestroy(epeek);

	epeek = spBPQueuePeek(copy2);
	ASSERT_TRUE(epeek == NULL);

	// free all remaining memory
	spListElementDestroy(epeek);
	spBPQueueDestroy(source);
	spBPQueueDestroy(source2);
	spBPQueueDestroy(copy);
	spBPQueueDestroy(copy2);

	// e1, e2, e3, e4
	DESTROY_4_ELEMENTS()
	return true;
}
Пример #4
0
void SPKDTreeKNNRecursive(SPKDTreeNode treeNode, SPPoint p, SPBPQueue bpq, SP_KDTREE_MSG* msg)
{
	SPListElement listElement;
	SPPoint treePoint;
	bool searchedLeft;
	double dist;

	if(bpq == NULL || treeNode == NULL)
	{
		*msg = SP_KDTREE_INVALID_ARGUMENT;
		return;
	}

	// If treeNode is a leaf
	if(treeNode->left == NULL && treeNode->right == NULL)
	{
		treePoint = *(treeNode->data);
		listElement = spListElementCreate(spPointGetIndex(treePoint), spPointL2SquaredDistance(p, treePoint));
		spBPQueueEnqueue(bpq, listElement);
		spListElementDestroy(listElement);
		*msg = SP_KDTREE_SUCCESS;
		return;
	}

	// Turn to search the tree that would've contain the point p (if it was in the tree)
	if(spPointGetAxisCoor(p, treeNode->dim) <= treeNode->val)
	{
		searchedLeft = true;
		SPKDTreeKNNRecursive(treeNode->left, p, bpq, msg);
		if (*msg != SP_KDTREE_SUCCESS)
			return;
	}
	else
	{
		searchedLeft = false;
		SPKDTreeKNNRecursive(treeNode->right, p, bpq, msg);
		if (*msg != SP_KDTREE_SUCCESS)
			return;
	}

	// dist = |treeNode.val - p[treeNode.dim]|
	dist = treeNode->val - spPointGetAxisCoor(p, treeNode->dim);
	if(dist < 0)
		dist *= -1;
	//dist *= dist;

	if(!spBPQueueIsFull(bpq) || dist < spBPQueueMaxValue(bpq))
	{
		if(searchedLeft)
			SPKDTreeKNNRecursive(treeNode->right, p, bpq, msg);
		else
			SPKDTreeKNNRecursive(treeNode->left, p, bpq, msg);
	}
	
}
// create queue of given size, from given elements
static SPBPQueue quickQ(int size, ...) {
	SPBPQueue source;
	va_list items;
	source = spBPQueueCreate(maxSize);

	va_start(items, size);
	for (int i = 0; i < size; i++) {
		spBPQueueEnqueue(source, va_arg(items, SPListElement));
	}
	va_end(items);
	return source;
}
static bool bpqGetSizeTest() {
	SPBPQueue source = NULL;
	SPListElement e1, e;

	ASSERT_TRUE(-1 == spBPQueueSize(source)); //check edge case

	source = quickQ(0);
	ASSERT_TRUE(0 == spBPQueueSize(source));

	// insert a new element and check size
	e1 = spListElementCreate(1, 1.0);
	spBPQueueEnqueue(source, e1);
	ASSERT_TRUE(1 == spBPQueueSize(source));

	// make sure that inserting same element twice works
	spListElementSetIndex(e1, 2);
	spListElementSetValue(e1, 2.0);
	spBPQueueEnqueue(source, e1);
	ASSERT_TRUE(2 == spBPQueueSize(source));

	// remove an element and check size
	spBPQueueDequeue(source);
	ASSERT_TRUE(1 == spBPQueueSize(source));

	// insert more then maxSize elements and check that size is always less then maxSize

	for (int i = 0; i < 2 * maxSize; i++) {
		ASSERT_TRUE(spBPQueueSize(source) <= maxSize);
		e = spListElementCreate(i, 1.0);
		spBPQueueEnqueue(source, e);
		spListElementDestroy(e);
	}

	// free memory
	spBPQueueDestroy(source);
	spListElementDestroy(e1);

	return true;
}
Пример #7
0
/**
 * Given a kd-tree and a point p, the function stores the nearest neighbors of p to bpq
 *
 * @param curr - the kd-tree containing the points
 * @param bpq - the bounded priority queue to store the nearest neighbors in
 * @param p - the point to find the nearest neighbors to
 *
 * does nothing if curr == NULL or bpq == NULL or p == NULL
 */
void nearestNeighbors(KDTreeNode curr, SPBPQueue bpq, SPPoint p) {
	SPListElement node;
	SPPoint q;
	bool isLeft;
	double coorDis;
	if (curr == NULL || bpq == NULL || p == NULL )
		return;

	q = curr->data;

	/* Add the current point to the BPQ. Note that this is a no-op if the
	 * point is not as good as the points we've seen so far.*/
	if (curr->dim == -1) {
		int index;
		double dis;

		index = spPointGetIndex(q);
		dis = spPointL2SquaredDistance(p, curr->data);
		node = spListElementCreate(index, dis);
		spBPQueueEnqueue(bpq, node);
		spListElementDestroy(node);
		return;
	}

	/* Recursively search the half of the tree that contains the test point. */
	if (spPointGetAxisCoor(p, curr->dim) <= curr->val) {
		nearestNeighbors(curr->left, bpq, p);
		isLeft = true;
	} else {
		nearestNeighbors(curr->right, bpq, p);
		isLeft = false;
	}

	/* If the candidate hypersphere crosses this splitting plane, look on the
	 * other side of the plane by examining the other subtree*/
	coorDis = abs(spPointGetAxisCoor(p, curr->dim) - curr->val);
	if (!spBPQueueIsFull(bpq) || coorDis*coorDis < spBPQueueMaxValue(bpq)) {
		if (isLeft)
			nearestNeighbors(curr->right, bpq, p);
		else
			nearestNeighbors(curr->left, bpq, p);
	}

}
static bool bpqFullTest() {
	SPBPQueue source;
	SPListElement e1;
	source = NULL;
	ASSERT_TRUE(spBPQueueIsFull(source) == false); // check edge case

	source = spBPQueueCreate(maxSize);

	// insert maxSize element and check that full at the end
	while (spBPQueueSize(source) < maxSize) {

		ASSERT_TRUE(spBPQueueIsFull(source) == false); // check that not full in the process
		e1 = spListElementCreate(1, 1.0);
		spBPQueueEnqueue(source, e1);
		spListElementDestroy(e1);
	}
	ASSERT_TRUE(spBPQueueIsFull(source) == true);

	// free memory
	spBPQueueDestroy(source);
	return true;
}
static bool bpqDequeueTest() {
	SPBPQueue source;
	SPListElement e;

	ASSERT_TRUE(SP_BPQUEUE_INVALID_ARGUMENT == spBPQueueDequeue(NULL)); // check edge case

	source = spBPQueueCreate(maxSize);
	ASSERT_TRUE(SP_BPQUEUE_INVALID_ARGUMENT == spBPQueueDequeue(source)); // check edge case

	// insert maxSize elements, then remove them
	for (int i = 0; i < maxSize; i++) {
		e = spListElementCreate(i, (double) i);
		spBPQueueEnqueue(source, e);
		spListElementDestroy(e);
	}
	for (int i = 0; i < maxSize; i++) {
		ASSERT_TRUE((int )spBPQueueMinValue(source) == i); // check that the minimum was removed on the last dequeue
		ASSERT_TRUE(spBPQueueDequeue(source) == SP_BPQUEUE_SUCCESS); // check that dequeue succeeded
	}

	// free memory
	spBPQueueDestroy(source);
	return true;
}
static bool bpqEnqueueTest() {
	SPBPQueue source, source2;
	SPListElement e, e1, e2, e3, e4, e5, peek, peekLast;

	ASSERT_TRUE(SP_BPQUEUE_INVALID_ARGUMENT == spBPQueueEnqueue(NULL, NULL)); // check edge case

	CREATE_4_ELEMENTS() // e1, e2, e3, e4
	e5 = spListElementCreate(5, 4.0);
	source = quickQ(3, e2, e1, e4);
	ASSERT_TRUE(SP_BPQUEUE_SUCCESS == spBPQueueEnqueue(source, e3)); // check that enqueue succeeded
	ASSERT_TRUE(SP_BPQUEUE_SUCCESS == spBPQueueEnqueue(source, e5));
	ASSERT_TRUE(5 == spBPQueueSize(source));

	// check that enqueue inserts in order
	peek = spBPQueuePeek(source);
	peekLast = spBPQueuePeekLast(source);
	ASSERT_TRUE(spListElementCompare(e1, peek) == 0);
	// make sure queue sorts by value and then by index
	ASSERT_TRUE(spListElementCompare(e5, peekLast) == 0);

	// e1, e2, e3, e4
	DESTROY_4_ELEMENTS()
	spListElementDestroy(e5);

	// create new queue with maxSize
	source2 = spBPQueueCreate(maxSize);

	// insert 2*maxSize elements from lowest to highest value and check that min and max are correct
	for (int i = 0; i < maxSize; i++) {
		e = spListElementCreate(i, (double) i);
		ASSERT_TRUE(SP_BPQUEUE_SUCCESS == spBPQueueEnqueue(source2, e));
		spListElementDestroy(e);
	}
	for (int i = maxSize; i < 2 * maxSize; i++) {
		e = spListElementCreate(i, (double) i);
		ASSERT_TRUE(SP_BPQUEUE_FULL == spBPQueueEnqueue(source2, e)); // check full when inserting more then maxSize elements
		spListElementDestroy(e);
	}
	ASSERT_TRUE(spBPQueueMinValue(source2) == 0.0);

	// check that all elements with value too high are not in the queue
	ASSERT_TRUE((int )spBPQueueMaxValue(source2) == maxSize - 1);
	spBPQueueClear(source2);

	// insert 2*maxSize elements from highest to lowest value and check that min and max are correct and same as before
	for (int i = 2 * maxSize - 1; i >= 0; i--) {
		e = spListElementCreate(i, (double) i);
		spBPQueueEnqueue(source2, e);
		spListElementDestroy(e);
	}

	// check min value is correct
	ASSERT_TRUE(spBPQueueMinValue(source2) == 0.0);
	ASSERT_TRUE((int )spBPQueueMaxValue(source2) == maxSize - 1);

	// free memory
	spBPQueueDestroy(source);
	spBPQueueDestroy(source2);
	spListElementDestroy(peek);
	spListElementDestroy(peekLast);


	return true;
}