import numpy as np from plyfile import PlyData, PlyElement from sklearn.cluster import AgglomerativeClustering from scipy.spatial.transform import Rotation as R import os def read_ply(ply_path): """读取3DGS的.ply文件""" plydata = PlyData.read(ply_path) vertex = plydata['vertex'] # 提取基本属性 positions = np.stack([vertex['x'], vertex['y'], vertex['z']], axis=1) # 提取不透明度 opacities = vertex['opacity'][:, np.newaxis] # 提取scale (3个轴) scales = np.stack([vertex['scale_0'], vertex['scale_1'], vertex['scale_2']], axis=1) # 提取rotation (四元数 wxyz或xyzw，需要确认格式) rotations = np.stack([vertex['rot_0'], vertex['rot_1'], vertex['rot_2'], vertex['rot_3']], axis=1) # 提取DC系数 (f_dc_0, f_dc_1, f_dc_2 对应RGB) dc = np.stack([vertex['f_dc_0'], vertex['f_dc_1'], vertex['f_dc_2']], axis=1) # 提取高阶SH系数 (假设存在) sh_keys = [key for key in vertex.data.dtype.names if key.startswith('f_rest_')] if sh_keys: sh_rest = np.stack([vertex[key] for key in sh_keys], axis=1) else: sh_rest = None return { 'positions': positions, 'opacities': opacities, 'scales': scales, 'rotations': rotations, 'dc': dc, 'sh_rest': sh_rest, 'plydata': plydata # 保存原始数据用于后续保存 } def quaternion_to_rotation_matrix(q): """四元数转旋转矩阵，假设q是[w,x,y,z]或[x,y,z,w]格式""" # 尝试两种常见格式 try: # 格式1: [x,y,z,w] rot = R.from_quat(q) except: # 格式2: [w,x,y,z] rot = R.from_quat([q[1], q[2], q[3], q[0]]) return rot.as_matrix() def compute_covariance(rotation, scale): """从旋转和缩放计算协方差矩阵 Σ = R * S * S^T * R^T """ R_mat = quaternion_to_rotation_matrix(rotation) S_mat = np.diag(scale) cov = R_mat @ S_mat @ S_mat.T @ R_mat.T return cov def covariance_to_rotation_scale(cov): """从协方差矩阵分解得到旋转和缩放 使用特征值分解: Σ = V * Λ * V^T 其中 V 是旋转, sqrt(Λ) 是缩放 """ # 特征值分解 eigenvalues, eigenvectors = np.linalg.eigh(cov) # 确保特征值为正 eigenvalues = np.maximum(eigenvalues, 1e-7) # 缩放是特征值的平方根 scale = np.sqrt(eigenvalues) # 旋转矩阵是特征向量 # 确保是右手坐标系 if np.linalg.det(eigenvectors) < 0: eigenvectors[:, 0] *= -1 # 转换为四元数 rot = R.from_matrix(eigenvectors) rotation = rot.as_quat() # [x,y,z,w] return rotation, scale def dc_to_rgb(dc): """将DC系数转换为RGB (0阶球谐)""" C0 = 0.28209479177387814 rgb = dc * C0 + 0.5 return np.clip(rgb, 0, 1) def rgb_to_dc(rgb): """将RGB转换回DC系数""" C0 = 0.28209479177387814 dc = (rgb - 0.5) / C0 return dc def build_octree(positions, max_points=5000): """递归构建八叉树cell""" cells = [] def subdivide(indices, bbox_min, bbox_max, depth=0): if len(indices) <= max_points or depth > 10: # 添加最大深度限制 cells.append({ 'indices': indices, 'bbox_min': bbox_min, 'bbox_max': bbox_max }) return # 计算中心点 center = (bbox_min + bbox_max) / 2 # 8个子空间 for i in range(8): x_flag = i & 1 y_flag = (i >> 1) & 1 z_flag = (i >> 2) & 1 sub_min = np.array([ center[0] if x_flag else bbox_min[0], center[1] if y_flag else bbox_min[1], center[2] if z_flag else bbox_min[2] ]) sub_max = np.array([ bbox_max[0] if x_flag else center[0], bbox_max[1] if y_flag else center[1], bbox_max[2] if z_flag else center[2] ]) # 找到在该子空间内的点 mask = np.all((positions[indices] >= sub_min) & (positions[indices] < sub_max), axis=1) sub_indices = indices[mask] if len(sub_indices) > 0: subdivide(sub_indices, sub_min, sub_max, depth + 1) # 初始边界框 bbox_min = positions.min(axis=0) bbox_max = positions.max(axis=0) all_indices = np.arange(len(positions)) subdivide(all_indices, bbox_min, bbox_max) return cells def cluster_and_merge_cell(data, cell_indices, bbox_min, bbox_max): """对单个cell内的点进行聚类和合并""" if len(cell_indices) < 4: return None # 点数太少，不合并 # 计算聚类数量 n_clusters = max(1, len(cell_indices) // 4) # 提取cell内的数据 positions = data['positions'][cell_indices] dc = data['dc'][cell_indices] opacities = data['opacities'][cell_indices] scales = data['scales'][cell_indices] rotations = data['rotations'][cell_indices] # 计算cell的尺寸 cell_size = bbox_max - bbox_min cell_size = np.maximum(cell_size, 1e-6) # 避免除零 # 归一化位置 (到[0,1]) norm_positions = (positions - bbox_min) / cell_size # 将DC转为RGB并归一化到[0,1] rgb = dc_to_rgb(dc) # 构建聚类特征: [归一化位置 * 0.8权重, RGB * 0.2权重] # 使用权重的平方根，因为距离计算会平方 features = np.concatenate([ norm_positions * np.sqrt(0.8), rgb * np.sqrt(0.2) ], axis=1) # 执行层次聚类 clustering = AgglomerativeClustering( n_clusters=n_clusters, linkage='ward' ) labels = clustering.fit_predict(features) # 合并每个簇 merged_data = { 'positions': [], 'opacities': [], 'scales': [], 'rotations': [], 'dc': [], 'sh_rest': [] if data['sh_rest'] is not None else None } for cluster_id in range(n_clusters): cluster_mask = labels == cluster_id cluster_indices = np.where(cluster_mask)[0] if len(cluster_indices) == 0: continue # 计算合并权重: opacity * scale体积 volumes = scales[cluster_indices].prod(axis=1, keepdims=True) weights = opacities[cluster_indices] * volumes weights_sum = weights.sum() normalized_weights = weights / weights_sum # 加权平均位置 merged_position = (positions[cluster_indices] * normalized_weights).sum(axis=0) # 加权平均DC merged_dc = (dc[cluster_indices] * normalized_weights).sum(axis=0) # 加权平均高阶SH if data['sh_rest'] is not None: sh_rest_cell = data['sh_rest'][cell_indices] merged_sh_rest = (sh_rest_cell[cluster_indices] * normalized_weights).sum(axis=0) # 计算混合协方差矩阵 covariances = [] for idx in cluster_indices: cov = compute_covariance(rotations[idx], scales[idx]) covariances.append(cov) covariances = np.array(covariances) # Σ_new = Σ w_i * (Σ_i + (μ_i - μ_new)(μ_i - μ_new)^T) / Σ w_i merged_cov = np.zeros((3, 3)) for i, idx in enumerate(cluster_indices): diff = positions[idx] - merged_position outer = np.outer(diff, diff) merged_cov += normalized_weights[i, 0] * (covariances[i] + outer) # 从协方差矩阵分解得到旋转和缩放 merged_rotation, merged_scale = covariance_to_rotation_scale(merged_cov) # 质量守恒: opacity_new * volume_new = Σ(opacity_i * volume_i) merged_volume = merged_scale.prod() merged_opacity = weights_sum / merged_volume if merged_volume > 1e-10 else opacities[cluster_indices].mean() merged_opacity = np.clip(merged_opacity, 0, 1) # 保存合并结果 merged_data['positions'].append(merged_position) merged_data['opacities'].append(merged_opacity) merged_data['scales'].append(merged_scale) merged_data['rotations'].append(merged_rotation) merged_data['dc'].append(merged_dc) if data['sh_rest'] is not None: merged_data['sh_rest'].append(merged_sh_rest) # 转换为numpy数组 for key in merged_data: if merged_data[key] is not None and len(merged_data[key]) > 0: merged_data[key] = np.array(merged_data[key]) return merged_data def merge_gaussians(ply_path, output_path): """主函数: 读取、聚类、合并、保存""" print("读取PLY文件...") data = read_ply(ply_path) n_original = len(data['positions']) print(f"原始高斯点数: {n_original}") print("构建八叉树...") cells = build_octree(data['positions'], max_points=5000) print(f"划分为 {len(cells)} 个cells") print("对每个cell进行聚类和合并...") all_merged_data = { 'positions': [], 'opacities': [], 'scales': [], 'rotations': [], 'dc': [], 'sh_rest': [] if data['sh_rest'] is not None else None } for i, cell in enumerate(cells): if i % 100 == 0: print(f"处理进度: {i}/{len(cells)}") merged = cluster_and_merge_cell( data, cell['indices'], cell['bbox_min'], cell['bbox_max'] ) if merged is not None: for key in all_merged_data: if all_merged_data[key] is not None and len(merged[key]) > 0: all_merged_data[key].append(merged[key]) # 合并所有cell的结果 print("合并所有cell的结果...") final_data = {} for key in all_merged_data: if all_merged_data[key] is not None and len(all_merged_data[key]) > 0: final_data[key] = np.concatenate(all_merged_data[key], axis=0) n_merged = len(final_data['positions']) print(f"合并后高斯点数: {n_merged}") print(f"压缩率: {n_merged/n_original*100:.2f}%") # 保存为PLY print("保存PLY文件...") save_ply(final_data, data['plydata'], output_path) print(f"已保存到: {output_path}") def save_ply(merged_data, original_plydata, output_path): """保存合并后的数据为PLY格式""" n_points = len(merged_data['positions']) # 构建新的顶点数据 dtype_list = [ ('x', 'f4'), ('y', 'f4'), ('z', 'f4'), ('opacity', 'f4'), ('scale_0', 'f4'), ('scale_1', 'f4'), ('scale_2', 'f4'), ('rot_0', 'f4'), ('rot_1', 'f4'), ('rot_2', 'f4'), ('rot_3', 'f4'), ('f_dc_0', 'f4'), ('f_dc_1', 'f4'), ('f_dc_2', 'f4'), ] # 添加高阶SH if merged_data['sh_rest'] is not None: n_sh_rest = merged_data['sh_rest'].shape[1] for i in range(n_sh_rest): dtype_list.append((f'f_rest_{i}', 'f4')) vertex_data = np.empty(n_points, dtype=dtype_list) # 填充数据 vertex_data['x'] = merged_data['positions'][:, 0] vertex_data['y'] = merged_data['positions'][:, 1] vertex_data['z'] = merged_data['positions'][:, 2] vertex_data['opacity'] = merged_data['opacities'].flatten() vertex_data['scale_0'] = merged_data['scales'][:, 0] vertex_data['scale_1'] = merged_data['scales'][:, 1] vertex_data['scale_2'] = merged_data['scales'][:, 2] vertex_data['rot_0'] = merged_data['rotations'][:, 0] vertex_data['rot_1'] = merged_data['rotations'][:, 1] vertex_data['rot_2'] = merged_data['rotations'][:, 2] vertex_data['rot_3'] = merged_data['rotations'][:, 3] vertex_data['f_dc_0'] = merged_data['dc'][:, 0] vertex_data['f_dc_1'] = merged_data['dc'][:, 1] vertex_data['f_dc_2'] = merged_data['dc'][:, 2] if merged_data['sh_rest'] is not None: for i in range(n_sh_rest): vertex_data[f'f_rest_{i}'] = merged_data['sh_rest'][:, i] # 创建PLY元素 vertex_element = PlyElement.describe(vertex_data, 'vertex') # 保存 PlyData([vertex_element]).write(output_path) # 使用示例 if __name__ == "__main__": input_ply = "input.ply" # 输入文件路径 output_ply = "output_merged.ply" # 输出文件路径 merge_gaussians(input_ply, output_ply)