def KDTreeBenchmark(root_dir,
files,
k,
leaf_size,
radius,
feature=None,
feature2=None):
construction_time_sum = 0
knn_time_sum = 0
radius_time_sum = 0
brute_time_sum = 0
iteration_num = 0
for file in files:
if file.find('bin') == -1:
continue
iteration_num += 1
filename = os.path.join(root_dir, file)
db_np = read_velodyne_bin(filename)
begin_t = time.time()
root = kdtree.kdtree_construction(db_np, leaf_size, feature, feature2)
construction_time_sum += time.time() - begin_t
query = db_np[0, :]
begin_t = time.time()
result_set = KNNResultSet(capacity=k)
kdtree.kdtree_knn_search(root, db_np, result_set, query)
print("result set from KD Tree\n", result_set)
knn_time_sum += time.time() - begin_t
# print("--------")
begin_t = time.time()
result_set = RadiusNNResultSet(radius=radius)
kdtree.kdtree_radius_search(root, db_np, result_set, query)
#print(result_set)
radius_time_sum += time.time() - begin_t
#print("--------")
begin_t = time.time()
diff = np.linalg.norm(np.expand_dims(query, 0) - db_np, axis=1)
nn_idx = np.argsort(diff)
nn_dist = diff[nn_idx]
#print(nn_idx[0:k])
#print(nn_dist[0:k])
brute_time_sum += time.time() - begin_t
depth = [0]
max_depth = [0]
kdtree.traverse_kdtree(root, depth, max_depth)
print("tree depth: %d, max depth: %d" % (depth[0], max_depth[0]))
print("Kdtree: build %.3f, knn %.3f, radius %.3f, brute %.3f" %
(construction_time_sum * 1000 / iteration_num, knn_time_sum * 1000 /
iteration_num, radius_time_sum * 1000 / iteration_num,
brute_time_sum * 1000 / iteration_num))
def kdtree_contribute_Matrix(S, K):
N = len(S)
A = np.zeros((N, N))
leaf_size = 4
root = kdtree.kdtree_construction(S, leaf_size=leaf_size)
for i in range(N):
query = S[i]
result_set = KNNResultSet(capacity=K)
kdtree.kdtree_knn_search(root, S, result_set, query)
index = result_set.knn_output_index()
for j in index:
A[i][j] = 1 #
A[j][i] = A[i][j]
if i == j:
A[i][j] = 0
return A
def fit(self,data,method="radius"):
data_num = np.shape(data)[0]
print("number of data ",data_num)
self.simi_graph=np.zeros((data_num,data_num))
if method=="fully_connect":
for i in range(np.shape(data)[0]):
self.simi_graph[i] = get_dist_array(data,data[i])
#self.simi_graph=np.max(self.simi_graph)*2- self.simi_graph
self.simi_graph= gauss(self.simi_graph)
#for i in range(np.shape(data)[0]):
# self.simi_graph[i,i]=0
#print(self.simi_graph)
elif (method=="radius"):
root = kdtree.kdtree_construction(data, 16)
for di, datum in enumerate(data):
#print(datum)
result_set = RadiusNNResultSet(radius=10)
kdtree.kdtree_radius_search(root, data, result_set, datum)
nis = result_set.index_list
ndists = result_set.dist_list
#print("nis",nis)
#print("ndists",ndists)
for ni,ndist in zip(nis,ndists):
self.simi_graph[di][ni]=self.simi_graph[ni][di]=gauss(ndist,0.2)
#print("graph",self.simi_graph)
elif (method=="knn"):
print("knn is implemented")
tree=KDTree(data)
for di, datum in enumerate(data):
ndists,nis = tree.query([datum],20)
nis=nis[0]
ndists = ndists[0]
for ni,ndist in zip(nis,ndists):
if ni==di: continue
#print("HHHHHH",ni,di,ndist)
self.simi_graph[di][ni]=self.simi_graph[ni][di]=gauss(ndist)
else:
print("not available")
def fit(self, data):
#TODO
#step1 随机选取 K个数据点 作为聚类的中心
self.centers_ = data[random.sample(range(data.shape[0]),
self.k_)] #random.sample(list,num)
old_centers = np.copy(self.centers_) #存储old_centers
#step2 E-Step(expectation)：N个点、K个中心，求N个点到K个中心的nearest-neighbor
#kd-tree config
leaf_size = 1
k = 1 # 结果每个点选取属于自己的类中心
for _ in range(self.max_iter_):
labels = [[] for i in range(self.k_)] #用于分类所有数据点
root = kdtree.kdtree_construction(
self.centers_, leaf_size=leaf_size) #对中心点进行构建kd-tree
for i in range(data.shape[0]): #对每一个点在4个中心点中进行 1-NN的搜索
result_set = KNNResultSet(capacity=k)
query = data[i]
kdtree.kdtree_knn_search(root, self.centers_, result_set,
query) #返回对应中心点的索引
# labels[result_set.output_index].append(data[i])
#print(result_set)
output_index = result_set.knn_output_index()[0] #获取最邻近点的索引
labels[output_index].append(data[i]) #将点放入类中
#step3 M-Step(maximization)：更新中心点的位置，把属于同一个类的数据点求一个均值，作为这个类的中心值
for i in range(self.k_): #求K类里，每个类的的中心点
points = np.array(labels[i])
self.centers_[i] = points.mean(axis=0) #取点的均值，作为新的聚类中心
# print(points)
# print(self.centers_[i])
if np.sum(
np.abs(self.centers_ - old_centers)
) < self.tolerance_ * self.k_: # 如果前后聚类中心的距离相差小于self.tolerance_ * self.k_ 输出
break
old_centers = np.copy(self.centers_) #保存旧中心点
self.fitted = True
Point_Show(self.centers_)
def main():
# configuration
leaf_size = 32
min_extent = 0.0001
k = 8
radius = 1
filename = '000000.bin'
db_np = read_velodyne_bin(filename)
iteration_num = 1
cat = []
print("octree --------------")
construction_time_sum = 0
knn_time_sum = 0
radius_time_sum = 0
brute_time_sum = 0
for i in range(iteration_num):
db_np = read_velodyne_bin(filename)
begin_t = time.time()
root = octree.octree_construction(db_np, leaf_size, min_extent)
construction_time_sum += time.time() - begin_t
query = db_np[0, :]
begin_t = time.time()
result_set = KNNResultSet(capacity=k)
octree.octree_knn_search(root, db_np, result_set, query)
knn_time_sum += time.time() - begin_t
begin_t = time.time()
result_set = RadiusNNResultSet(radius=radius)
octree.octree_radius_search_fast(root, db_np, result_set, query)
radius_time_sum += time.time() - begin_t
begin_t = time.time()
diff = np.linalg.norm(np.expand_dims(query, 0) - db_np, axis=1)
nn_idx = np.argsort(diff)
nn_dist = diff[nn_idx]
brute_time_sum += time.time() - begin_t
print("Octree: build %.3f, knn %.3f, radius %.3f, brute %.3f" %
(construction_time_sum * 1000 / iteration_num, knn_time_sum * 1000 /
iteration_num, radius_time_sum * 1000 / iteration_num,
brute_time_sum * 1000 / iteration_num))
print("kdtree --------------")
construction_time_sum = 0
knn_time_sum = 0
radius_time_sum = 0
brute_time_sum = 0
for i in range(iteration_num):
#filename = os.path.join(root_dir, cat[i])
db_np = read_velodyne_bin(filename)
begin_t = time.time()
root = kdtree.kdtree_construction(db_np, leaf_size)
construction_time_sum += time.time() - begin_t
query = db_np[0, :]
begin_t = time.time()
result_set = KNNResultSet(capacity=k)
kdtree.kdtree_knn_search(root, db_np, result_set, query)
knn_time_sum += time.time() - begin_t
begin_t = time.time()
result_set = RadiusNNResultSet(radius=radius)
kdtree.kdtree_radius_search(root, db_np, result_set, query)
radius_time_sum += time.time() - begin_t
begin_t = time.time()
diff = np.linalg.norm(np.expand_dims(query, 0) - db_np, axis=1)
nn_idx = np.argsort(diff)
nn_dist = diff[nn_idx]
brute_time_sum += time.time() - begin_t
print("Kdtree: build %.3f, knn %.3f, radius %.3f, brute %.3f" %
(construction_time_sum * 1000 / iteration_num, knn_time_sum * 1000 /
iteration_num, radius_time_sum * 1000 / iteration_num,
brute_time_sum * 1000 / iteration_num))
def main():
# configuration
leaf_size = 32
min_extent = 0.005
k = 8
radius = 1
nums = 1 # 点的数量（搜索）
abs_path = os.path.abspath(
os.path.dirname(__file__)) # 数据集路径 (数据集直接放在当前路径下)
filename = os.path.join(abs_path, '000000.bin') # 只读取一个文件,如果要读取所有文件,需要循环读入
iteration_num = 1
# 读取数据并进行采样
db_np_origin = read_velodyne_bin(filename) # N*3
db_np_idx = np.random.choice(db_np_origin.shape[0],
size=(30000, )) # 随机采样30000个点
db_np = db_np_origin[db_np_idx]
#root_dir = '/Users/renqian/cloud_lesson/kitti' # 数据集路径
#cat = os.listdir(root_dir)
#iteration_num = len(cat)
print("搜索数据集中的 %d 个点: " % nums)
print(
"---------------------------------Octree ----------------------------------"
)
construction_time_sum = 0
knn_time_sum = 0
radius_time_sum = 0
brute_time_sum = 0
for i in range(iteration_num):
#filename = os.path.join(root_dir, cat[i])
'''
db_np_origin = read_velodyne_bin(filename) # N*3
db_np_idx = np.random.choice(db_np_origin.shape[0],size =(30000,)) # 随机采样30000个点
db_np = db_np_origin[db_np_idx]
'''
begin_t = time.time()
root = octree.octree_construction(db_np, leaf_size,
min_extent) # Octree Construction
construction_time_sum += time.time() - begin_t
print("The sum of the points: ", db_np.shape[0])
nums = db_np.shape[0]
# 查找nums个点
for num in range(nums):
query = db_np[num, :] # 搜索点数组（假设第一个点为搜索点）
# knn search
begin_t = time.time()
result_set = KNNResultSet(capacity=k)
octree.octree_knn_search(root, db_np, result_set, query)
knn_time_sum += time.time() - begin_t
# radius search
begin_t = time.time()
result_set = RadiusNNResultSet(radius=radius)
#octree.octree_radius_search_fast(root, db_np, result_set, query)
octree.octree_radius_search(root,
db_np,
result_set,
query,
search='fast')
radius_time_sum += time.time() - begin_t
# brute search
begin_t = time.time()
diff = np.linalg.norm(np.expand_dims(query, 0) - db_np, axis=1)
nn_idx = np.argsort(diff)
nn_dist = diff[nn_idx]
brute_time_sum += time.time() - begin_t
print("Octree: build %.3f, knn %.3f, radius %.3f, brute %.3f" %
(construction_time_sum * 1000 / iteration_num, knn_time_sum *
1000 / iteration_num, radius_time_sum * 1000 / iteration_num,
brute_time_sum * 1000 / iteration_num))
print(
"---------------------------------Kdtree ----------------------------------"
)
construction_time_sum = 0
knn_time_sum = 0
radius_time_sum = 0
brute_time_sum = 0
knn_scipy_time_sum = 0
radius_scipy_time_sum = 0
for i in range(iteration_num):
#filename = os.path.join(root_dir, cat[i])
#db_np = read_velodyne_bin(filename) # N*3
print("The sum of the points: ", db_np.shape[0])
begin_t = time.time()
root = kdtree.kdtree_construction(db_np,
leaf_size) # kd tree construction
construction_time_sum += time.time() - begin_t
tree = spatial.KDTree(db_np) # 利用spatial库函数构造kdtree
for num in range(nums):
query = db_np[num, :]
# scipy.spatial.KDtree
begin_t = time.time()
tree.query(query, k=k)
knn_scipy_time_sum += time.time() - begin_t
#print(tree.query(query, k=k))
# knn search
begin_t = time.time()
result_set = KNNResultSet(capacity=k)
kdtree.kdtree_knn_search(root, db_np, result_set, query)
knn_time_sum += time.time() - begin_t
#print(result_set)
# scipy.spatial.KDtree (radius search)
begin_t = time.time()
tree.query_ball_point(query, radius)
radius_scipy_time_sum += time.time() - begin_t
# radius search
begin_t = time.time()
result_set = RadiusNNResultSet(radius=radius)
kdtree.kdtree_radius_search(root, db_np, result_set, query)
radius_time_sum += time.time() - begin_t
# print(result_set)
# brute search
begin_t = time.time()
diff = np.linalg.norm(np.expand_dims(query, 0) - db_np, axis=1)
nn_idx = np.argsort(diff)
nn_dist = diff[nn_idx]
brute_time_sum += time.time() - begin_t
print(
"Kdtree: build %.3f, knn_scipy %.3f, knn %.3f, radius_scipy %.3f, radius %.3f, brute %.3f"
%
(construction_time_sum * 1000 / iteration_num, knn_scipy_time_sum *
1000 / iteration_num, knn_time_sum * 1000 / iteration_num,
radius_scipy_time_sum * 1000 / iteration_num, radius_time_sum *
1000 / iteration_num, brute_time_sum * 1000 / iteration_num))
def main():
# configuration
leaf_size = 32
min_extent = 0.0001
k = 8
radius = 1
root_dir = '/home/gc/github_repository/DeepBlue/lesson_2/kitty/' # 数据集路径
cat = os.listdir(root_dir)
iteration_num = len(cat)
print("octree --------------")
construction_time_sum = 0
knn_time_sum = 0
radius_time_sum = 0
brute_time_sum = 0
for i in range(iteration_num):
filename = os.path.join(root_dir, cat[i])
db_np = read_velodyne_bin(filename)
db_np = db_np.T
begin_t = time.time()
root = octree.octree_construction(db_np, leaf_size, min_extent)
construction_time_sum += time.time() - begin_t
query = db_np[0,:]
begin_t = time.time()
result_set = KNNResultSet(capacity=k)
octree.octree_knn_search(root, db_np, result_set, query)
knn_time_sum += time.time() - begin_t
begin_t = time.time()
result_set = RadiusNNResultSet(radius=radius)
octree.octree_radius_search_fast(root, db_np, result_set, query)
radius_time_sum += time.time() - begin_t
begin_t = time.time()
diff = np.linalg.norm(np.expand_dims(query, 0) - db_np, axis=1)
nn_idx = np.argsort(diff)
nn_dist = diff[nn_idx]
brute_time_sum += time.time() - begin_t
print("Octree: build %.3f, knn %.3f, radius %.3f, brute %.3f" % (construction_time_sum*1000/iteration_num,
knn_time_sum*1000/iteration_num,
radius_time_sum*1000/iteration_num,
brute_time_sum*1000/iteration_num))
otc_knn = knn_time_sum*1000
otc_radius = radius_time_sum*1000
otc_brute = brute_time_sum*1000
print("kdtree --------------")
construction_time_sum = 0
knn_time_sum = 0
radius_time_sum = 0
brute_time_sum = 0
for i in range(iteration_num):
filename = os.path.join(root_dir, cat[i])
db_np = read_velodyne_bin(filename)
begin_t = time.time()
root = kdtree.kdtree_construction(db_np, leaf_size)
construction_time_sum += time.time() - begin_t
query = db_np[0,:]
begin_t = time.time()
result_set = KNNResultSet(capacity=k)
kdtree.kdtree_knn_search(root, db_np, result_set, query)
knn_time_sum += time.time() - begin_t
begin_t = time.time()
result_set = RadiusNNResultSet(radius=radius)
kdtree.kdtree_radius_search(root, db_np, result_set, query)
radius_time_sum += time.time() - begin_t
begin_t = time.time()
diff = np.linalg.norm(np.expand_dims(query, 0) - db_np, axis=1)
nn_idx = np.argsort(diff)
nn_dist = diff[nn_idx]
brute_time_sum += time.time() - begin_t
print("Kdtree: build %.3f, knn %.3f, radius %.3f, brute %.3f" % (construction_time_sum * 1000 / iteration_num,
knn_time_sum * 1000 / iteration_num,
radius_time_sum * 1000 / iteration_num,
brute_time_sum * 1000 / iteration_num))
kd_knn = knn_time_sum * 1000
kd_radius = radius_time_sum * 1000
kd_brute = brute_time_sum * 1000
print("Octree knn/brute = %.3f, radius/bruet = %.3f" % (otc_knn/otc_brute, otc_radius/otc_brute) )
print("Kdtree knn/brute = %.3f, radius/bruet = %.3f" % (kd_knn / otc_brute, kd_radius / otc_brute) )
def main():
# configuration
leaf_size = 32
min_extent = 0.0001
k = 8
radius = 1
#root_dir = '/Users/renqian/cloud_lesson/kitti' # 数据集路径
#cat = os.listdir(root_dir)
#iteration_num = len(cat)
# load date
filename = '/home/ljn/SLAM/dateset/000000.bin'
db_np = read_velodyne_bin(filename)
iteration = 1
print("octree -----------------------------------")
construction_time_sum = 0
knn_time_sum = 0
radius_time_sum = 0
brute_time_sum = 0
result_set_knn = KNNResultSet(capacity=k)
query = db_np[95, :]
begin_t = time.time()
root = octree.octree_construction(db_np, leaf_size, min_extent)
construction_time_sum += time.time() - begin_t
begin_t = time.time()
octree.octree_knn_search(root, db_np, result_set_knn, query)
knn_time_sum += time.time() - begin_t
print('knn search result\n', result_set_knn)
begin_t = time.time()
result_set_rnn = RadiusNNResultSet(radius=radius)
octree.octree_radius_search_fast(root, db_np, result_set_rnn, query)
radius_time_sum += time.time() - begin_t
print('rnn search result\n', result_set_rnn)
begin_t = time.time()
diff = np.linalg.norm(np.expand_dims(query, 0) - db_np, axis=1)
nn_idx = np.argsort(diff)
nn_dist = diff[nn_idx]
nn_dist_idx_pre = np.linspace(0, nn_dist.shape[0], nn_dist.shape[0])
nn_dist_idx = nn_dist_idx_pre[nn_idx]
brute_time_sum += time.time() - begin_t
#brute knn search
result_set_knn_brute = KNNResultSet(capacity=k)
for index in range(k):
result_set_knn_brute.add_point(nn_dist[index], nn_dist_idx[index])
# brute radiusNN search
result_set_rnn_brute = RadiusNNResultSet(radius=radius)
for index in range(nn_dist.shape[0]):
if nn_dist[index] < radius:
result_set_rnn_brute.add_point(nn_dist[index], nn_dist_idx[index])
continue
else:
break
print("Octree: build %.3f, knn %.3f, radius %.3f, brute %.3f" %
(construction_time_sum * 1000, knn_time_sum * 1000,
radius_time_sum * 1000, brute_time_sum * 1000))
print("kdtree -----------------------------------")
construction_time_sum = 0
knn_time_sum = 0
radius_time_sum = 0
brute_time_sum = 0
for i in range(iteration):
query = db_np[95, :]
begin_t = time.time()
root = kdtree.kdtree_construction(db_np, leaf_size)
construction_time_sum += time.time() - begin_t
begin_t = time.time()
result_set_knn = KNNResultSet(capacity=k)
kdtree.kdtree_knn_search(root, db_np, result_set_knn, query)
knn_time_sum += time.time() - begin_t
begin_t = time.time()
result_set_rnn = RadiusNNResultSet(radius=radius)
kdtree.kdtree_radius_search(root, db_np, result_set_rnn, query)
radius_time_sum += time.time() - begin_t
begin_t = time.time()
diff = np.linalg.norm(np.expand_dims(query, 0) - db_np, axis=1)
nn_idx = np.argsort(diff)
nn_dist = diff[nn_idx]
brute_time_sum += time.time() - begin_t
nn_dist_idx_pre = np.linspace(0, nn_dist.shape[0] - 1,
nn_dist.shape[0])
nn_dist_idx = nn_dist_idx_pre[nn_idx]
# brute knn search
result_set_knn_brute = KNNResultSet(capacity=k)
for index in range(k):
result_set_knn_brute.add_point(nn_dist[index], nn_dist_idx[index])
# brute radiusNN search
result_set_rnn_brute = RadiusNNResultSet(radius=radius)
for index in range(nn_dist.shape[0]):
if nn_dist[index] < radius:
result_set_rnn_brute.add_point(nn_dist[index],
nn_dist_idx[index])
continue
else:
break
print("Kdtree: build %.3f, knn %.3f, radius %.3f, brute %.3f" %
(construction_time_sum * 1000, knn_time_sum * 1000,
radius_time_sum * 1000, brute_time_sum * 1000))
print("scipy kdtree -----------------------------------")
construction_time_sum = 0
knn_time_sum = 0
radius_time_sum = 0
query = db_np[95, :]
begin_t = time.time()
tree = spatial.KDTree(db_np, leaf_size)
construction_time_sum += time.time() - begin_t
#no knn
begin_t = time.time()
knn_time_sum += time.time() - begin_t
begin_t = time.time()
result_set_rnn = tree.query_ball_point(query, radius)
radius_time_sum += time.time() - begin_t
print('rnn search result\n', result_set_rnn)
print("Octree: build %.3f, knn %.3f, radius %.3f" %
(construction_time_sum * 1000, knn_time_sum * 1000,
radius_time_sum * 1000))
