def templateTreeVisualization(self, path, **kwargs):
sample = None
if path is not None:
sample = read_sample(path)
exception = kwargs.get('exception', None)
if exception is not None:
self.assertRaises(exception, kdtree_visualizer, kdtree(sample))
self.assertRaises(exception, kdtree_visualizer,
kdtree_balanced(sample))
else:
kdtree_visualizer(kdtree(sample)).visualize()
kdtree_visualizer(kdtree_balanced(sample)).visualize()
def testKDTreeInsertRemoveNode1(self):
array = [[4, 3], [3, 4], [5, 8], [3, 3], [3, 9], [6, 4], [5, 9]]
payload = ['q', 'w', 'e', 'r', 't', 'y', 'u']
tree = kdtree()
for index in range(len(array)):
removed_node = tree.remove(array[index])
self.assertIsNone(
removed_node,
"The point '%s' shouldn't be found in the tree - it wasn't added yet."
% str(array[index]))
node = tree.insert(array[index], payload[index])
self.assertIsNotNone(node)
self.assertEqual(node.data, array[index])
length = len(array)
for index in range(0, length):
node = tree.remove(array[index])
assert len(tree) == length - index - 1
if index + 1 < length: # When root is removed then None will be returned
assert node is not None
else:
assert node is None
# Check other nodes are located in the tree
for k in range(index + 1, length):
node = tree.find_node(array[k])
assert node.data == array[k]
assert node.payload == payload[k]
def process(self):
"""!
@brief Performs cluster analysis in line with rules of DBSCAN algorithm.
@see get_clusters()
@see get_noise()
"""
if self.__ccore is True:
(self.__clusters,
self.__noise) = wrapper.dbscan(self.__pointer_data, self.__eps,
self.__neighbors, self.__data_type)
else:
if self.__data_type == 'points':
self.__kdtree = kdtree(self.__pointer_data,
range(len(self.__pointer_data)))
for i in range(0, len(self.__pointer_data)):
if self.__visited[i] is False:
cluster = self.__expand_cluster(i)
if cluster is not None:
self.__clusters.append(cluster)
else:
self.__noise.append(i)
self.__belong[i] = True
def testKDTreeParentSearch(self):
"Check for right parents"
array = [ [4, 3], [3, 4], [5, 8], [3, 3], [3, 9], [6, 4], [5, 9] ];
tree = kdtree(array);
node = tree.find_node([4, 3]);
assert node.parent == None;
node = tree.find_node([3, 4]);
assert node.parent.data == [4, 3];
node = tree.find_node([5, 8]);
assert node.parent.data == [4, 3];
node = tree.find_node([6, 4]);
assert node.parent.data == [5, 8];
node = tree.find_node([3, 3]);
assert node.parent.data == [3, 4];
node = tree.find_node([5, 9]);
assert node.parent.data == [5, 8];
node = tree.find_node([3, 9]);
assert node.parent.data == [3, 4];
def process(self):
"""!
@brief Performs cluster analysis in line with rules of DBSCAN algorithm.
@see get_clusters()
@see get_noise()
"""
if self.__ccore is True:
(self.__clusters, self.__noise) = wrapper.dbscan(self.__pointer_data, self.__eps, self.__neighbors, self.__data_type)
else:
if self.__data_type == 'points':
self.__kdtree = kdtree(self.__pointer_data, range(len(self.__pointer_data)))
for i in range(0, len(self.__pointer_data)):
if self.__visited[i] is False:
cluster = self.__expand_cluster(i)
if cluster is not None:
self.__clusters.append(cluster)
for i in range(0, len(self.__pointer_data)):
if self.__belong[i] is False:
self.__noise.append(i)
def testKDTreeRemoveLongBranch(self):
# Create only one branch - worth case and remove it
array = [[5, 5], [6, 5], [6, 6], [7, 6], [7, 7]]
tree = kdtree(array)
assert len(tree.traverse()) == len(array)
for index in range(len(array)):
node = tree.remove(array[index])
assert len(tree.traverse()) == len(array) - index - 1
# Remove from other end
tree = kdtree(array)
for index in range(len(array)):
node = tree.remove(array[len(array) - index - 1])
assert len(tree.traverse()) == len(array) - index - 1
def process(self):
"""!
@brief Performs cluster analysis in line with rules of OPTICS algorithm.
@remark Results of clustering can be obtained using corresponding gets methods.
@see get_clusters()
@see get_noise()
@see get_ordering()
"""
if (self.__ccore is True):
(self.__clusters, self.__noise, self.__ordering,
self.__eps) = wrapper.optics(self.__sample_pointer, self.__eps,
self.__minpts,
self.__amount_clusters)
else:
self.__kdtree = kdtree(self.__sample_pointer,
range(len(self.__sample_pointer)))
self.__allocate_clusters()
if ((self.__amount_clusters is not None)
and (self.__amount_clusters != len(self.get_clusters()))):
analyser = ordering_analyser(self.get_ordering())
radius, _ = analyser.calculate_connvectivity_radius(
self.__amount_clusters)
if (radius is not None):
self.__eps = radius
self.__allocate_clusters()
def testKDTreeInsertRemoveNode1(self):
"Create empty k-d tree and insert nodes and after that remove all nodes"
array = [[4, 3], [3, 4], [5, 8], [3, 3], [3, 9], [6, 4], [5, 9]]
payload = ['q', 'w', 'e', 'r', 't', 'y', 'u']
tree = kdtree()
for index in range(len(array)):
node = tree.insert(array[index], payload[index])
length = len(array)
for index in range(0, length):
node = tree.remove(array[index])
assert len(tree.traverse()) == length - index - 1
if (index + 1 <
length): # When root is removed then None will be returned
assert node != None
else:
assert node == None
# Check other nodes are located in the tree
for k in range(index + 1, length):
node = tree.find_node(array[k])
assert node.data == array[k]
assert node.payload == payload[k]
def testKDTreeParentSearch(self):
"Check for right parents"
array = [[4, 3], [3, 4], [5, 8], [3, 3], [3, 9], [6, 4], [5, 9]]
tree = kdtree(array)
node = tree.find_node([4, 3])
assert node.parent == None
node = tree.find_node([3, 4])
assert node.parent.data == [4, 3]
node = tree.find_node([5, 8])
assert node.parent.data == [4, 3]
node = tree.find_node([6, 4])
assert node.parent.data == [5, 8]
node = tree.find_node([3, 3])
assert node.parent.data == [3, 4]
node = tree.find_node([5, 9])
assert node.parent.data == [5, 8]
node = tree.find_node([3, 9])
assert node.parent.data == [3, 4]
def testKDTreeInsertRemoveNode1(self):
"Create empty k-d tree and insert nodes and after that remove all nodes"
array = [ [4, 3], [3, 4], [5, 8], [3, 3], [3, 9], [6, 4], [5, 9] ];
payload = ['q', 'w', 'e', 'r', 't', 'y', 'u'];
tree = kdtree();
for index in range(len(array)):
node = tree.insert(array[index], payload[index]);
length = len(array);
for index in range(0, length):
node = tree.remove(array[index]);
assert len(tree.traverse()) == length - index - 1;
if (index + 1 < length): # When root is removed then None will be returned
assert node != None;
else:
assert node == None;
# Check other nodes are located in the tree
for k in range(index + 1, length):
node = tree.find_node(array[k]);
assert node.data == array[k];
assert node.payload == payload[k];
def process(self):
"""!
@brief Performs cluster analysis in line with rules of DBSCAN algorithm.
@see get_clusters()
@see get_noise()
"""
if (self.__ccore is True):
(self.__clusters,
self.__noise) = wrapper.dbscan(self.__pointer_data, self.__eps,
self.__neighbors, True)
else:
self.__kdtree = kdtree(self.__pointer_data,
range(len(self.__pointer_data)))
for i in range(0, len(self.__pointer_data)):
if (self.__visited[i] == False):
cluster = self.__expand_cluster(i)
# Fast mode
if (cluster != None):
self.__clusters.append(cluster)
else:
self.__noise.append(i)
self.__belong[i] = True
def testKDTreeRemoveLongBranch(self):
# Create only one branch - worth case and remove it
array = [ [5, 5], [6, 5], [6, 6], [7, 6], [7, 7] ];
tree = kdtree(array);
assert len(tree.traverse()) == len(array);
for index in range(len(array)):
node = tree.remove(array[index]);
assert len(tree.traverse()) == len(array) - index - 1;
# Remove from other end
tree = kdtree(array);
for index in range(len(array)):
node = tree.remove(array[len(array) - index - 1]);
assert len(tree.traverse()) == len(array) - index - 1;
def testKDTreeCreateTrivial(self):
"Create k-d tree"
array = [ [3, 4], [5, 6], [9, 8], [7, 3], [1, 2], [2, 4], [2, 5], [3, 2] ];
tree = kdtree(array);
assert len(tree.traverse()) == len(array);
for item in array:
assert tree.find_node(item).data == item;
def testKDTreeCreateTrivial(self):
"Create k-d tree"
array = [[3, 4], [5, 6], [9, 8], [7, 3], [1, 2], [2, 4], [2, 5],
[3, 2]]
tree = kdtree(array)
assert len(tree.traverse()) == len(array)
for item in array:
assert tree.find_node(item).data == item
def testKDTreeRemoveLongBranch(self):
# Create only one branch - worth case and remove it
array = [[5, 5], [6, 5], [6, 6], [7, 6], [7, 7]]
tree = kdtree(array)
self.assertEqual(len(tree), len(array))
for index in range(len(array)):
node = tree.remove(array[index])
if len(tree) != 0:
self.assertIsNotNone(node)
self.assertEqual(len(tree), len(array) - index - 1)
# Remove from other end
tree = kdtree(array)
for index in range(len(array)):
node = tree.remove(array[len(array) - index - 1])
if len(tree) != 0:
self.assertIsNotNone(node)
self.assertEqual(len(tree), len(array) - index - 1)
def testKDTreeCreateWithoutPayload(self):
# Create k-d tree without any payload
array = [ [4, 3], [3, 4], [5, 8], [3, 3], [3, 9], [6, 4], [5, 9] ];
tree = kdtree(array);
assert len(tree.traverse()) == len(array);
for item in array:
node = tree.find_node(item);
assert node != None; # node should exist in the tree.
assert node.payload == None; # because we have created tree without any payloads.
assert node.data == item; # check for valid data.
def testKDTreeInsertFindNode(self):
suite_array = [[[9, 9], [3, 3], [4, 4]], [[9, 9], [3, 3]],
[[9, 9], [4, 4], [10, 10]], [[5, 5]],
[[5, 5], [2, 2], [7, 7]],
[[5, 5], [2, 2], [7, 7], [1, 1], [8, 8]]]
for array in suite_array:
tree = kdtree(array)
for point in array:
node = tree.find_node(point)
self.assertIsNotNone(node)
self.assertEqual(node.data, point)
def templateTextTreeRepresentation(self, sample_path):
sample = read_sample(sample_path)
tree = kdtree(sample)
representation = kdtree_text_visualizer(tree).visualize(False)
assert representation != None
assert len(representation) > 0
amount_lines = representation.count("\n")
expected_lower_edge = math.log2(len(sample)) * len(sample[0])
assert expected_lower_edge <= amount_lines
def testKDTreeInsertRemoveNode2(self):
array = [[9, 9], [3, 3], [4, 4]]
tree = kdtree(array)
assert None is not tree.remove([9, 9])
assert len(tree) == 2
assert None is not tree.remove([4, 4])
assert len(tree) == 1
assert None is tree.remove([3, 3])
assert len(tree) == 0
def __create_kdtree(self):
"""!
@brief Create k-d tree in line with created clusters. At the first iteration contains all points from the input data set.
@return (kdtree) k-d tree that consist of representative points of CURE clusters.
"""
self.__tree = kdtree()
for current_cluster in self.__queue:
for representative_point in current_cluster.rep:
self.__tree.insert(representative_point, current_cluster)
def __create_kdtree(self):
"""!
@brief Create k-d tree in line with created clusters. At the first iteration contains all points from the input data set.
@return (kdtree) k-d tree that consist of representative points of CURE clusters.
"""
self.__tree = kdtree();
for current_cluster in self.__queue:
for representative_point in current_cluster.rep:
self.__tree.insert(representative_point, current_cluster);
def testKDTreeInsertRemoveNode2(self):
# This test simulates situation when a bug (16.01.2014) with removing was occuring
array = [ [9, 9], [3, 3], [4, 4] ];
tree = kdtree(array);
assert None != tree.remove([9, 9]);
assert len(tree.traverse()) == 2;
assert None != tree.remove([4, 4]);
assert len(tree.traverse()) == 1;
assert None == tree.remove([3, 3]);
assert len(tree.traverse()) == 0;
def templateSeachNearestNodeInTree(self, sample_path):
sample = read_sample(sample_path)
tree = kdtree()
for point in sample:
node = tree.find_nearest_dist_node(point, 0.0)
assert node == None
tree.insert(point, None)
node = tree.find_nearest_dist_node(point, 0.0)
assert node != None
assert node.data == point
def testKDTreeCreateWithPayload(self):
# Create k-d tree with payload
array = [[4, 3], [3, 4], [5, 8], [3, 3], [3, 9], [6, 4], [5, 9]]
payload = ['q', 'w', 'e', 'r', 't', 'y', 'u']
tree = kdtree(array, payload)
assert len(tree.traverse()) == len(array)
for index in range(len(array)):
node = tree.find_node(array[index])
assert node != None
assert node.payload == payload[index]
assert node.data == array[index]
def testKDTreeInsertRemoveNode2(self):
# This test simulates situation when a bug (16.01.2014) with removing was occuring
array = [[9, 9], [3, 3], [4, 4]]
tree = kdtree(array)
assert None != tree.remove([9, 9])
assert len(tree.traverse()) == 2
assert None != tree.remove([4, 4])
assert len(tree.traverse()) == 1
assert None == tree.remove([3, 3])
assert len(tree.traverse()) == 0
def testKDTreeCreateWithPayload(self):
# Create k-d tree with payload
array = [ [4, 3], [3, 4], [5, 8], [3, 3], [3, 9], [6, 4], [5, 9] ];
payload = ['q', 'w', 'e', 'r', 't', 'y', 'u'];
tree = kdtree(array, payload);
assert len(tree.traverse()) == len(array);
for index in range(len(array)):
node = tree.find_node(array[index]);
assert node != None;
assert node.payload == payload[index];
assert node.data == array[index];
def templateVerificationInsertRemoveKDTreeTest(self, array):
for perm_array in itertools.permutations(array):
tree = kdtree(array);
length = len(array);
for index in range(len(perm_array)):
#tree.show();
node = tree.remove(perm_array[index]);
if ( index + 1 < length ):
assert node is not None;
assert len(tree.traverse()) == length - index - 1;
def testKDTreeNearestNodeTrivial2(self):
arrays = [
[ [3, 4], [5, 6], [9, 8], [7, 3], [1, 2], [2, 4], [2, 5], [3, 2], [3, 3] ],
[ [5, 6], [1, 3], [7, 3], [1, 1], [9, 9], [4, 7], [0, 3], [3, 5], [1, 2], [9, 3], [9, 8], [5, 5], [6, 6], [0, 0], [-4, -5], [-1, 5], [-8, 3] ]
];
distances = [0.0, 0.5, 1.0, 3.0, 10.0];
for array in arrays:
tree = kdtree(array);
for item in array:
for distance in distances:
assert tree.find_nearest_dist_node(item, distance).data == item;
def testKDTreeCreateWithoutPayload(self):
# Create k-d tree without any payload
array = [[4, 3], [3, 4], [5, 8], [3, 3], [3, 9], [6, 4], [5, 9]]
tree = kdtree(array)
assert len(tree.traverse()) == len(array)
for item in array:
node = tree.find_node(item)
assert node != None
# node should exist in the tree.
assert node.payload == None
# because we have created tree without any payloads.
assert node.data == item
def templateVerificationInsertRemoveKDTreeTest(self, array):
for perm_array in itertools.permutations(array):
tree = kdtree(array)
length = len(array)
for index in range(len(perm_array)):
#tree.show();
node = tree.remove(perm_array[index])
if (index + 1 < length):
assert node is not None
assert len(tree.traverse()) == length - index - 1
def testKDTreeInsertNodes(self):
array = [[4, 3], [3, 4], [5, 8], [3, 3], [3, 9], [6, 4], [5, 9]]
payload = ['q', 'w', 'e', 'r', 't', 'y', 'u']
tree = kdtree()
self.assertEqual(len(tree), 0)
for index in range(len(array)):
node = tree.insert(array[index], payload[index])
self.assertEqual(len(tree), index + 1)
self.assertIsNotNone(node)
self.assertEqual(node.payload, payload[index])
self.assertEqual(node.data, array[index])
def templateSeachNearestNodesInTree(self,
sample_path,
search_radius,
length=None):
sample = read_sample(sample_path)
tree = kdtree(sample)
for point in sample:
nodes = tree.find_nearest_dist_nodes(point, search_radius)
assert nodes != []
if (length is None):
assert len(nodes) > 1
else:
assert len(nodes) == length
def templateSeachNearestNodesInTree(self, sample_path, search_radius, length=None, numpy_usage=False):
sample = read_sample(sample_path);
if numpy_usage is True:
sample = numpy.array(sample)
tree = kdtree(sample);
for point in sample:
nodes = tree.find_nearest_dist_nodes(point, search_radius);
assert nodes != [];
if (length is None):
assert len(nodes) > 1;
else:
assert len(nodes) == length;
def testKDTreeInsertNodes(self):
"Create empty k-d tree and insert nodes"
array = [ [4, 3], [3, 4], [5, 8], [3, 3], [3, 9], [6, 4], [5, 9] ];
payload = ['q', 'w', 'e', 'r', 't', 'y', 'u'];
tree = kdtree();
assert len(tree.traverse()) == 0;
for index in range(len(array)):
node = tree.insert(array[index], payload[index]);
assert len(tree.traverse()) == index + 1;
assert node != None;
assert node.payload == payload[index];
assert node.data == array[index];
def templateTextTreeRepresentation(self, sample_path, numpy_usage=False):
sample = read_sample(sample_path);
if numpy_usage is True:
sample = numpy.array(sample)
tree = kdtree(sample);
representation = kdtree_text_visualizer(tree).visualize(False);
assert representation != None;
assert len(representation) > 0;
amount_lines = representation.count("\n");
expected_lower_edge = math.log2(len(sample)) * len(sample[0]);
assert expected_lower_edge <= amount_lines;
def testKDTreeNearestNodeTrivial1(self):
array = [ [4, 3], [3, 4], [5, 8], [3, 3], [3, 9], [6, 4], [6, 9], [4, 9] ];
tree = kdtree(array);
for item in array:
assert tree.find_nearest_dist_node(item, 0).data == item;
assert tree.find_nearest_dist_node(item, 0.5).data == item;
assert tree.find_nearest_dist_node(item, 1).data == item;
assert tree.find_nearest_dist_node(item, 3).data == item;
assert tree.find_nearest_dist_node(item, 10).data == item;
assert tree.find_nearest_dist_node([6.1, 4.1], 0.5).data == [6, 4];
assert tree.find_nearest_dist_node([6, 12], 0) == None;
assert tree.find_nearest_dist_node([6, 12], 1) == None;
assert tree.find_nearest_dist_node([6, 12], 3).data == [6, 9];
def testKDTreeInsertNodes(self):
"Create empty k-d tree and insert nodes"
array = [[4, 3], [3, 4], [5, 8], [3, 3], [3, 9], [6, 4], [5, 9]]
payload = ['q', 'w', 'e', 'r', 't', 'y', 'u']
tree = kdtree()
assert len(tree.traverse()) == 0
for index in range(len(array)):
node = tree.insert(array[index], payload[index])
assert len(tree.traverse()) == index + 1
assert node != None
assert node.payload == payload[index]
assert node.data == array[index]
def testKDTreeNearestNodeTrivial2(self):
arrays = [[[3, 4], [5, 6], [9, 8], [7, 3], [1, 2], [2, 4], [2, 5],
[3, 2], [3, 3]],
[[5, 6], [1, 3], [7, 3], [1, 1], [9, 9], [4, 7], [0, 3],
[3, 5], [1, 2], [9, 3], [9, 8], [5, 5], [6, 6], [0, 0],
[-4, -5], [-1, 5], [-8, 3]]]
distances = [0.0, 0.5, 1.0, 3.0, 10.0]
for array in arrays:
tree = kdtree(array)
for item in array:
for distance in distances:
assert tree.find_nearest_dist_node(item,
distance).data == item
def testKDTreeNearestNodeTrivial1(self):
array = [[4, 3], [3, 4], [5, 8], [3, 3], [3, 9], [6, 4], [6, 9],
[4, 9]]
tree = kdtree(array)
for item in array:
assert tree.find_nearest_dist_node(item, 0).data == item
assert tree.find_nearest_dist_node(item, 0.5).data == item
assert tree.find_nearest_dist_node(item, 1).data == item
assert tree.find_nearest_dist_node(item, 3).data == item
assert tree.find_nearest_dist_node(item, 10).data == item
assert tree.find_nearest_dist_node([6.1, 4.1], 0.5).data == [6, 4]
assert tree.find_nearest_dist_node([6, 12], 0) == None
assert tree.find_nearest_dist_node([6, 12], 1) == None
assert tree.find_nearest_dist_node([6, 12], 3).data == [6, 9]
def __process_by_python(self):
"""!
@brief Performs cluster analysis using python code.
"""
if self.__data_type == 'points':
self.__kdtree = kdtree(self.__sample_pointer, range(len(self.__sample_pointer)))
self.__allocate_clusters()
if (self.__amount_clusters is not None) and (self.__amount_clusters != len(self.get_clusters())):
analyser = ordering_analyser(self.get_ordering())
radius, _ = analyser.calculate_connvectivity_radius(self.__amount_clusters)
if radius is not None:
self.__eps = radius
self.__allocate_clusters()
def __process_by_python(self):
"""!
@brief Performs cluster analysis using python code.
"""
if self.__data_type == 'points':
self.__kdtree = kdtree(self.__sample_pointer, range(len(self.__sample_pointer)))
self.__allocate_clusters()
if (self.__amount_clusters is not None) and (self.__amount_clusters != len(self.get_clusters())):
analyser = ordering_analyser(self.get_ordering())
radius, _ = analyser.calculate_connvectivity_radius(self.__amount_clusters)
if radius is not None:
self.__eps = radius
self.__allocate_clusters()
def __create_kdtree(self):
"""!
@brief Create k-d tree in line with created clusters. At the first iteration contains all points from the input data set.
@return (kdtree) k-d tree that consist of representative points of CURE clusters.
"""
representatives, payloads = [], []
for current_cluster in self.__queue:
for representative_point in current_cluster.rep:
representatives.append(representative_point)
payloads.append(current_cluster)
# initialize it using constructor to have balanced tree at the beginning to ensure the highest performance
# when we have the biggest amount of nodes in the tree.
self.__tree = kdtree(representatives, payloads)
def templateSeachNearestNodeInTree(self, sample_path, **kwargs):
numpy_usage = kwargs.get('numpy_usage', False)
sample = read_sample(sample_path);
if numpy_usage is True:
sample = numpy.array(sample)
tree = kdtree();
for point in sample:
node = tree.find_nearest_dist_node(point, 0.0);
assert node == None;
tree.insert(point, None);
node = tree.find_nearest_dist_node(point, 0.0);
assert node != None;
assert node.data is point;
def templateSeachNearestNodeInTree(self, sample_path, **kwargs):
numpy_usage = kwargs.get('numpy_usage', False)
sample = read_sample(sample_path)
if numpy_usage is True:
sample = numpy.array(sample)
tree = kdtree()
for point in sample:
node = tree.find_nearest_dist_node(point, 0.0)
assert node == None
tree.insert(point, None)
node = tree.find_nearest_dist_node(point, 0.0)
assert node != None
assert node.data is point
def templateTheSameDataSearchAndRemove(self, points, payloads):
tree = kdtree();
inserted_node = [];
for i in range(len(points)):
inserted_node.append( tree.insert(points[i], payloads[i]) );
for node in inserted_node:
found_node = tree.find_node_with_payload(node.data, node.payload);
assert node == found_node;
for i in range(len(inserted_node)):
tree.remove(inserted_node[i].data, payload=inserted_node[i].payload);
found_node = tree.find_node_with_payload(inserted_node[i].data, inserted_node[i].payload);
assert None == found_node;
for j in range(i + 1, len(inserted_node)):
found_node = tree.find_node_with_payload(inserted_node[j].data, inserted_node[j].payload);
assert inserted_node[j] == found_node;
def templateTheSameDataSearchAndRemove(self, points, payloads):
tree = kdtree()
inserted_node = []
for i in range(len(points)):
inserted_node.append(tree.insert(points[i], payloads[i]))
for node in inserted_node:
found_node = tree.find_node_with_payload(node.data, node.payload)
assert node == found_node
for i in range(len(inserted_node)):
tree.remove(inserted_node[i].data,
payload=inserted_node[i].payload)
found_node = tree.find_node_with_payload(inserted_node[i].data,
inserted_node[i].payload)
assert None == found_node
for j in range(i + 1, len(inserted_node)):
found_node = tree.find_node_with_payload(
inserted_node[j].data, inserted_node[j].payload)
assert inserted_node[j] == found_node
def templateSeachNearestNodeInTree(self, sample_path, **kwargs):
numpy_usage = kwargs.get('numpy_usage', False)
sample = read_sample(sample_path)
if numpy_usage is True:
sample = numpy.array(sample)
tree = kdtree()
for point in sample:
node = tree.find_nearest_dist_node(point, 0.0)
self.assertIsNone(node)
tree.insert(point, None)
node = tree.find_nearest_dist_node(point, 0.0)
self.assertIsNotNone(node)
self.assertIs(node.data, point)
distance_and_node = tree.find_nearest_dist_node(point, 0.0, True)
self.assertIsNotNone(distance_and_node)
self.assertIs(distance_and_node[1].data, point)
self.assertEqual(distance_and_node[0], 0.0)
def template_build_visualize(sample_path):
print("KD Tree for sample: '" + sample_path + "'");
sample = read_sample(sample_path);
tree_instance = kdtree(sample);
kdtree_text_visualizer(tree_instance).visualize(True);
def template_build_visualize(sample_path):
print("KD Tree for sample: '" + sample_path + "'")
sample = read_sample(sample_path)
tree_instance = kdtree(sample)
kdtree_text_visualizer(tree_instance).visualize(True)
