如果段长度大于特定值，如何递归离散化段

Question

[为了提高python脚本的效率，由于Numpy加快了处理过程，我试图基于点云上的许多“ for循环”操作来转换脚本。

概括地说，我有一个3d模型，表示为np.array中包含的一组3d点（x，y，z坐标）（维度：（188706，3））

[[168.998 167.681   0.]    <-- point 1
 [169.72  167.695   0.]    <-- point 2
 [170.44  167.629   0.]    <-- point 3
 ...
 [148.986 163.271  25.8]    <-- point 188704
 [148.594 163.634  25.8]    <-- point 188705
 [148.547 163.667  25.8]]   <-- point 188706

[[[row x-1] [row x]的每对代表3D片段]

[[168.998 167.681   0.]    [169.72  167.695   0.]    <-- SEGMENT 1 (points 1 & 2)
 [169.72  167.695   0.]    [170.44  167.629   0.]    <-- SEGMENT 2 (points 2 & 3)
 [170.44  167.629   0.]    [171.149 167.483   0.]    <-- SEGMENT 3 (points 3 & 4)
 ...
 [149.328 162.853  25.8]   [148.986 163.271  25.8]    <-- SEGMENT 94351 (points 188703 & 188704)
 [148.986 163.271  25.8]   [148.594 163.634  25.8]    <-- SEGMENT 94352 (points 18874 & 188705)
 [148.594 163.634  25.8]   [148.547 163.667  25.8]]   <-- SEGMENT 94353 (points 188705 & 188706)

我的目标是测量每个有序点//成对的行之间的欧几里得距离（=每个段的长度），以便我可以检测到需要添加更多点以表示更多3d模型表面的位置。换句话说，如果线段长度超过阈值（= 0.5mm），我将不得不用更多点离散化此特定线段，并将这些其他点添加到我的点云中。

由于此代码，我找到了一种方法来递归地测量每行之间的欧几里得距离：

EuclidianDistance = np.linalg.norm(PtCloud[:-1] - PtCloud[1:],axis=1) 

哪个给出此结果：

[0.72213572 0.72301867 0.72387637 ... 0.54008148 0.5342593  0.05742822]

而且我还找到了如何根据段的顶点（末端）对段进行降序处理：

def AddEquidistantPoints(p1, p2, parts):
    return np.stack((np.linspace(p1[0], p2[0], parts + 1), np.linspace(p1[1], p2[1], parts + 1)), axis=-1)

if EuclidianDistance > 0.5mm:
    dist = AddEquidistantPoints(currentRow, previousRow, 10) #10 --> nb subdivisions

但是我的第一个问题是那些欧氏距离仅需在z坐标相等的点上计算即可。当z坐标不相等时，我是否要拆分数组？带有：

PtCloud = np.split(PtCloud, np.where(np.diff(PtCloud[:,2])!=0)[0]+1)

这给了我一个数组列表，所以我想我很遗憾会使用for循环...

这是Excel表示的正确行为：

而且我的第二个问题与递归检查和离散化步骤有关，因为我不知道如何在这种特殊情况下实现它。我想知道是否有没有任何for循环的方法。

因此，如果有人能帮助我解决这一难题，我将感到非常高兴，因为我目前被“困住了”。对我来说，这开始变得非常具有挑战性。

谢谢，埃尔维

Answer 1

与您分享，我刚刚找到一种解决我的问题的方法。这样做可能不是最有效的方法，但它可以起作用。

import numpy as np

print("====================")
print("Initial Points Cloud")
print("====================")

POINTCLOUD = np.array([[168.998, 167.681, 0.],
                       [169.72, 167.695,  0.],
                       [170.44, 167.629,  0.],
                       [171.149, 167.483,  0.],
                       [150.149, 167.483,  4.2],
                       [160.149, 167.483,  4.2],
                       [159.149, 166.483,  4.2],
                       [152.149, 157.483,  7.],
                       [149.328, 162.853, 25.8],
                       [148.986, 163.271, 25.8],
                       [148.594, 163.634, 25.8],
                       [180.547, 170.667, 25.8],
                       [200.547, 190.667, 25.8]])
print(POINTCLOUD)


print("============================================")
print("Reshaped Point Cloud in the form of segments")
print("============================================")
a = np.column_stack((POINTCLOUD[:-1],POINTCLOUD[1:]))
print(a)
b = a.reshape((a.shape[0],2, 3))
#print(b)

print("")
print("*******************************")
print("Non filtered euclidean distance")
print("*******************************")
EuclidianDistance = np.transpose(np.linalg.norm(b[:,0] - b[:,1],axis=1))
print(EuclidianDistance)

print("")
print("****************")
print("Mask computation")
print("****************")
mask = np.transpose([a[:,2] == a[:,5]])
mask2 = [a[:,:] == a[:,:]]*np.transpose([a[:,2] == a[:,5]])



print("")
print(mask2)

print("")
print("***********************************")
print("1rst Filter applyed on points cloud")
print("***********************************")

# b = np.where(mask2,a,0)
# b = np.squeeze(b, axis=0)
b = np.squeeze(np.where(mask2,a,0), axis=0)
print(b)
print("")

b2 = b[np.squeeze(mask2,axis=0),...].reshape((np.sum(mask),b.shape[1]))
print(b2)
print("")
#print(b2.reshape(b2.shape[0],2, 3))

b = b2.reshape(b2.shape[0],2, 3)


print("")
print("***************************************")
print("FIRST EUCLIDEAN DISTANCE FILTERING STEP")
print("***************************************")
EuclidianDistance = np.linalg.norm(b[:,0] - b[:,1],axis=1)
print(EuclidianDistance)

print("")
print("***************************")
print("# THRESHOLD MASK GENERATION")
print("***************************")
threshold = 7
mask_threshold = np.transpose(EuclidianDistance>threshold)
print(mask_threshold)

print("")
print("**********************************")
print("# FINAL FILTERED ECLIDEAN DISTANCE")
print("**********************************")
EuclidianDistance = EuclidianDistance[np.squeeze(mask_threshold),...]
print(EuclidianDistance)

print("")
print("**********************")
print("SEGMENTS TO DISCRETIZE")
print("**********************")
SegmentToDiscretize = b[np.squeeze(mask_threshold),...]
print(SegmentToDiscretize)



print("")
print("******************************")
print("EQUIDISTANT POINTS COMPUTATION")
print("******************************")

nbsubdiv2 = np.transpose(np.ceil(np.array(np.divide(EuclidianDistance,0.7))).astype(int)).reshape((SegmentToDiscretize.shape[0],1))
print(nbsubdiv2)
print(nbsubdiv2.shape)
print(nbsubdiv2[1,0])

print(SegmentToDiscretize.shape)
print(SegmentToDiscretize[:,0])


nbsubdiv = [10,30,10]

addedpoint = np.linspace(SegmentToDiscretize[:,0],SegmentToDiscretize[:,1],nbsubdiv[0], dtype = np.float)
addedpoint = addedpoint.reshape((addedpoint.shape[0]*addedpoint.shape[1],3))
print(np.sort(addedpoint,axis=0))


print("")
print("***********************************")
print("UPDATED POINT CLOUD WITH NEW POINTS")
print("***********************************")
# duplicates are removed with the command np.unique
POINTCLOUD = np.unique(np.append(POINTCLOUD,addedpoint, axis=0),axis=0)
print(POINTCLOUD)

print("")
print("************************")
print("FINAL SORTED POINT CLOUD")
print("************************")
sortedPOINTCLOUD = POINTCLOUD[np.argsort(POINTCLOUD[:, 2])]
print(sortedPOINTCLOUD)
print("***************************")

[如果需要，请随时添加自己的提案以进行改进。非常欢迎！