Группировка точек

from scipy import interpolate
from scipy.ndimage import maximum_filter, binary_closing  
import open3d as o3d
import numpy as np
 
#  преобразование файла со скобками в нужный формат для numpy
with open('poimtcloud_crop.txt', 'r') as fp:
    data = fp.readlines()[0]
data=data.replace('], [', '\n')
data=data.replace(']]', '')
data=data.replace('[[', '')
data=data.replace(',', '')
with open('poimtcloud_crop2.txt', 'w') as fp:
    fp.write(data)
list_coord=np.loadtxt('poimtcloud_crop2.txt')
############################
 
coord = np.array(list_coord[0::2]) # каждая вторая?
x, y, z = coord[:,0],coord[:,1],coord[:,2]
x_min = np.min(x)
x_max = np.max(x)
y_min = np.min(y)
y_max = np.max(y)
 
# преобразование в регулярные сетки (интерполяция):
x_grid, y_grid = np.meshgrid(np.linspace(x_min, x_max, 2000), np.linspace(y_min, y_max, 2000))
z_grid = interpolate.griddata((x, y), z, (x_grid, y_grid), method='cubic')  # , fill_value=0.0
 
z_image=np.zeros_like(z_grid, dtype=bool) 
x_idx=(2000-1)*(x-x_min)/(x_max-x_min)
y_idx=(2000-1)*(y-y_min)/(y_max-y_min)
x_idx=x_idx.astype(int)
y_idx=y_idx.astype(int)
z_image[x_idx, y_idx]=1 # бинарная картинка, подобно scatter диаграмме
mask=binary_closing(z_image, structure=np.ones((15,15))) #бинарная маска кластеров
 
z_max = maximum_filter(z_grid, size=80)
pos = np.argwhere(z_grid == z_max)
pos=pos[mask[pos[:,1], pos[:,0]],:] # фильтрация максимумов, только те, которые True на бинарной маске
 
 
print('положения максимумов:')
print(x_grid[0, pos[:, 1]], y_grid[pos[:, 0], 0])
print(len(x_grid[0, pos[:, 1]]))
 
points = [[x[i], y[i], z[i]] for i in range(len(z))]
points_peak = [[x_grid[0, pos[:, 1]][i], y_grid[pos[:, 0], 0][i], -0.5] for i in range(len(y_grid[pos[:, 0], 0]))]
 
points = np.vstack([points, points_peak])
landmarks_3d = o3d.geometry.PointCloud()
landmarks_3d.points = o3d.utility.Vector3dVector(points)
o3d.visualization.draw_geometries([landmarks_3d])

        coord = np.array(list_coord[0::2])
        x, y, z = coord[:, 0], coord[:, 1], coord[:, 2]
        x_min, x_max = np.min(x), np.max(x)
        y_min, y_max = np.min(y), np.max(y)
 
        # преобразование в регулярные сетки (интерполяция):
        x_grid, y_grid = np.meshgrid(np.linspace(x_min, x_max, 2000), np.linspace(y_min, y_max, 2000))
        z_grid = interpolate.griddata((x, y), z, (x_grid, y_grid), method='cubic')  # , fill_value=0.0
 
        # Использовать НЧ фильтр. Фильтр сгладит z_grid и пиков станет меньше.
        z_grid = scipy.ndimage.gaussian_filter(z_grid, sigma=4)
 
        z_image = np.zeros_like(z_grid, dtype=bool)
        x_idx = (2000 - 1) * (x - x_min) / (x_max - x_min)
        y_idx = (2000 - 1) * (y - y_min) / (y_max - y_min)
        x_idx = x_idx.astype(int)
        y_idx = y_idx.astype(int)
        z_image[x_idx, y_idx] = 1  # бинарная картинка, подобно scatter диаграмме
        mask = binary_closing(z_image, structure=np.ones((15, 15)))  # бинарная маска кластеров
 
        z_max = maximum_filter(z_grid, size=80)
        pos = np.argwhere(z_grid == z_max)
        pos = pos[mask[pos[:, 1], pos[:, 0]], :]  # фильтрация максимумов, только те, которые True на бинарной маске
 
        # Получение координат пиков по оси X Y Z
        x_grid_max = x_grid[0, pos[:, 1]]
        y_grid_max = y_grid[pos[:, 0], 0]
        z_grid_max = z_grid[pos[:, 1], pos[:, 0]]
        peak_points = np.column_stack([x_grid_max, y_grid_max, z_grid_max])
 
        # Визуализация
        points = np.vstack([coord, peak_points ])
        landmarks_3d = o3d.geometry.PointCloud()
        landmarks_3d.points = o3d.utility.Vector3dVector(points)
        o3d.visualization.draw_geometries([landmarks_3d])