import numpy as np from plyfile import PlyData, PlyElement from sklearn.cluster import AgglomerativeClustering from sklearn.neighbors import NearestNeighbors from scipy.spatial.transform import Rotation as R from scipy.sparse import csr_matrix from scipy.sparse.csgraph import connected_components import os # ============================================================ # 以下为原始 merge 相关函数（保持不变） # ============================================================ 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] scales = np.stack([vertex['scale_0'], vertex['scale_1'], vertex['scale_2']], axis=1) rotations = np.stack([vertex['rot_0'], vertex['rot_1'], vertex['rot_2'], vertex['rot_3']], axis=1) filter_3D = np.stack([vertex['filter_3D']], axis=1) dc = np.stack([vertex['f_dc_0'], vertex['f_dc_1'], vertex['f_dc_2']], axis=1) 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, 'filter_3D': filter_3D } def quaternion_to_rotation_matrix(q): try: rot = R.from_quat(q) except: rot = R.from_quat([q[1], q[2], q[3], q[0]]) return rot.as_matrix() def compute_covariance(rotation, scale_log): R_mat = quaternion_to_rotation_matrix(rotation) scale_actual = np.exp(scale_log) S_mat = np.diag(scale_actual) cov = R_mat @ S_mat @ S_mat.T @ R_mat.T return cov def covariance_to_rotation_scale(cov): 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): C0 = 0.28209479177387814 rgb = dc * C0 + 0.5 return np.clip(rgb, 0, 1) def rgb_to_dc(rgb): C0 = 0.28209479177387814 dc = (rgb - 0.5) / C0 return dc def build_octree(positions, max_points=5000): 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 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) subdivide(np.arange(len(positions)), bbox_min, bbox_max) return cells def build_knn_connectivity_graph(positions, k=10): n_points = len(positions) nbrs = NearestNeighbors(n_neighbors=min(k + 1, n_points), algorithm='kd_tree').fit(positions) distances, indices = nbrs.kneighbors(positions) row_indices, col_indices = [], [] for i in range(n_points): for j in range(1, len(indices[i])): neighbor_idx = indices[i][j] row_indices.append(i); col_indices.append(neighbor_idx) row_indices.append(neighbor_idx); col_indices.append(i) data = np.ones(len(row_indices)) connectivity_matrix = csr_matrix((data, (row_indices, col_indices)), shape=(n_points, n_points)) return connectivity_matrix def get_connected_clusters(labels, connectivity_matrix): unique_labels = np.unique(labels) refined_labels = labels.copy() next_label = labels.max() + 1 for cluster_id in unique_labels: cluster_mask = labels == cluster_id cluster_indices = np.where(cluster_mask)[0] if len(cluster_indices) <= 1: continue subgraph = connectivity_matrix[cluster_indices, :][:, cluster_indices] n_components, component_labels = connected_components(subgraph, directed=False, return_labels=True) if n_components > 1: for comp_id in range(1, n_components): comp_mask = component_labels == comp_id comp_indices = cluster_indices[comp_mask] refined_labels[comp_indices] = next_label next_label += 1 return refined_labels def cluster_and_merge_cell(data, cell_indices, bbox_min, bbox_max, k_neighbors=5, spread_factor=0.01, aspect_ratio_threshold=5.0): if len(cell_indices) < 4: return None n_clusters = max(1, len(cell_indices) // 2) cell_positions = data['positions'][cell_indices] cell_dc = data['dc'][cell_indices] cell_opacities = data['opacities'][cell_indices] cell_scales = data['scales'][cell_indices] cell_rotations = data['rotations'][cell_indices] cell_filter_3D = data['filter_3D'][cell_indices] connectivity_matrix = build_knn_connectivity_graph(cell_positions, k=k_neighbors) cell_size = np.maximum(bbox_max - bbox_min, 1e-6) norm_positions = (cell_positions - bbox_min) / cell_size rgb = dc_to_rgb(cell_dc) 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) refined_labels = get_connected_clusters(labels, connectivity_matrix) final_n_clusters = len(np.unique(refined_labels)) print(f" 原始簇数: {n_clusters}, 连通性约束后簇数: {final_n_clusters}") merged_data = { 'positions': [], 'opacities': [], 'scales': [], 'rotations': [], 'dc': [], 'sh_rest': [] if data['sh_rest'] is not None else None, 'filter_3D': [] } for cluster_id in np.unique(refined_labels): cluster_mask = refined_labels == cluster_id cluster_indices_in_cell = np.where(cluster_mask)[0] if len(cluster_indices_in_cell) == 0: continue scale_actual = np.exp(cell_scales[cluster_indices_in_cell]) approximate_volumes = np.prod(scale_actual, axis=1, keepdims=True) actual_opacities = 1.0 / (1.0 + np.exp(-cell_opacities[cluster_indices_in_cell])) weights = actual_opacities * approximate_volumes weights_sum = weights.sum() normalized_weights = weights / weights_sum merged_position = (cell_positions[cluster_indices_in_cell] * normalized_weights).sum(axis=0) merged_dc = (cell_dc[cluster_indices_in_cell] * normalized_weights).sum(axis=0) merged_filter_3D = (cell_filter_3D[cluster_indices_in_cell] * normalized_weights).sum(axis=0) if data['sh_rest'] is not None: sh_rest_cell = data['sh_rest'][cell_indices] merged_sh_rest = (sh_rest_cell[cluster_indices_in_cell] * normalized_weights).sum(axis=0) covariances = [] for idx in cluster_indices_in_cell: cov = compute_covariance(cell_rotations[idx], cell_scales[idx]) covariances.append(cov) covariances = np.array(covariances) merged_cov = np.zeros((3, 3)) for i, idx in enumerate(cluster_indices_in_cell): diff = cell_positions[idx] - merged_position outer = np.outer(diff, diff) merged_cov += normalized_weights[i, 0] * (covariances[i] + spread_factor * outer) merged_rotation, merged_scale = covariance_to_rotation_scale(merged_cov) max_scale = merged_scale.max() min_scale = merged_scale.min() current_ratio = max_scale / (min_scale + 1e-8) if current_ratio > aspect_ratio_threshold: target_max = min_scale * aspect_ratio_threshold merged_scale = np.clip(merged_scale, None, target_max) merged_opacity_actual = (cell_opacities[cluster_indices_in_cell] * normalized_weights).sum(axis=0) merged_opacity_actual = np.clip(merged_opacity_actual, 1e-5, 1.0 - 1e-5) merged_opacity = np.log(merged_opacity_actual / (1.0 - merged_opacity_actual)) 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) merged_data['filter_3D'].append(merged_filter_3D) 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 validate_data(merged_data): print("\n" + "=" * 60) print("数据验证报告") print("=" * 60) total_points = len(merged_data['positions']) print(f"\n总点数: {total_points}") for name, key, ndim in [("位置 (positions)", 'positions', 'multi'), ("不透明度 (opacities)", 'opacities', 'single'), ("缩放 (scales)", 'scales', 'multi'), ("旋转 (rotations)", 'rotations', 'multi'), ("DC系数 (f_dc)", 'dc', 'multi')]: arr = merged_data[key] if ndim == 'multi': nan_c = np.isnan(arr).any(axis=1).sum() inf_c = np.isinf(arr).any(axis=1).sum() else: nan_c = np.isnan(arr).sum() inf_c = np.isinf(arr).sum() print(f"\n【{name}】 NaN: {nan_c} Inf: {inf_c}") has_nan = (np.isnan(merged_data['positions']).any(axis=1) | np.isnan(merged_data['opacities']).ravel() | np.isnan(merged_data['scales']).any(axis=1) | np.isnan(merged_data['rotations']).any(axis=1) | np.isnan(merged_data['dc']).any(axis=1)) has_inf = (np.isinf(merged_data['positions']).any(axis=1) | np.isinf(merged_data['opacities']).ravel() | np.isinf(merged_data['scales']).any(axis=1) | np.isinf(merged_data['rotations']).any(axis=1) | np.isinf(merged_data['dc']).any(axis=1)) print(f"\n包含NaN的点: {has_nan.sum()} 包含Inf的点: {has_inf.sum()}") print("=" * 60 + "\n") return {'has_nan': has_nan.sum(), 'has_inf': has_inf.sum(), 'total': total_points} def save_ply(merged_data, original_plydata, output_path): 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'), ] 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')) if 'filter_3D' in merged_data and merged_data['filter_3D'] is not None: dtype_list.append(('filter_3D', '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'] = np.log(merged_data['scales'][:, 0]) vertex_data['scale_1'] = np.log(merged_data['scales'][:, 1]) vertex_data['scale_2'] = np.log(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] if 'filter_3D' in merged_data and merged_data['filter_3D'] is not None: vertex_data['filter_3D'] = merged_data['filter_3D'].flatten() PlyElement.describe(vertex_data, 'vertex') PlyData([PlyElement.describe(vertex_data, 'vertex')]).write(output_path) # ============================================================ # 新增：Fine-tuning 阶段 # 冻结位置，用下采样图像优化其余参数 500 epoch # ============================================================ def finetune_merged_gaussians( merged_ply_path, source_path, output_ply_path, sh_degree=3, num_epochs=500, lr_opacity=0.05, lr_scaling=0.005, lr_rotation=0.001, lr_features_dc=0.0025, lr_features_rest=0.000125, white_background=False, kernel_size=0.1, gpu_id=0, log_interval=50, ): """ 冻结高斯点的位置，用下采样训练图像对其余参数做fine-tuning。 参数： merged_ply_path : merge 输出的 PLY 文件路径 source_path : 下采样图像的 COLMAP 数据集根目录 （应包含 sparse/ 和 images/ ，images/ 里是你已下采样好的图像） output_ply_path : fine-tuning 完成后保存的 PLY 路径 sh_degree : 球谐阶数，需与 merge 时一致 num_epochs : 优化轮数，默认 500 lr_* : 各参数学习率，与原版 3DGS 训练保持同量级 white_background: 背景颜色 kernel_size : 渲染时的 kernel size（与你的渲染脚本一致） gpu_id : 使用的 GPU 编号 log_interval : 每隔多少 epoch 打印一次 loss """ import torch import torch.nn.functional as F from scene import Scene from gaussian_renderer import render, GaussianModel from scene.dataset_readers import sceneLoadTypeCallbacks from utils.camera_utils import loadCam from utils.loss_utils import l1_loss, ssim device = f'cuda:{gpu_id}' torch.cuda.set_device(device) bg_color = [1, 1, 1] if white_background else [0, 0, 0] background = torch.tensor(bg_color, dtype=torch.float32, device=device) # ---- 1. 加载 merge 后的高斯模型 ---- print("\n[Fine-tune] 加载 merge 后的高斯模型...") gaussians = GaussianModel(sh_degree) gaussians.load_ply(merged_ply_path) print(f"[Fine-tune] 高斯点数: {gaussians.get_xyz.shape[0]}") # ---- 2. 冻结位置，只保留其他参数的梯度 ---- # GaussianModel 内部用 _xyz / _features_dc / _features_rest / # _scaling / _rotation / _opacity 存储（均为 nn.Parameter） gaussians._xyz.requires_grad_(False) # 构建优化器，只包含非位置参数 param_groups = [ {'params': [gaussians._features_dc], 'lr': lr_features_dc, 'name': 'f_dc'}, {'params': [gaussians._features_rest], 'lr': lr_features_rest, 'name': 'f_rest'}, {'params': [gaussians._opacity], 'lr': lr_opacity, 'name': 'opacity'}, {'params': [gaussians._scaling], 'lr': lr_scaling, 'name': 'scaling'}, {'params': [gaussians._rotation], 'lr': lr_rotation, 'name': 'rotation'}, ] optimizer = torch.optim.Adam(param_groups, eps=1e-15) # ---- 3. 读取下采样图像的相机列表 ---- print("[Fine-tune] 读取相机信息...") if os.path.exists(os.path.join(source_path, "sparse")): scene_info = sceneLoadTypeCallbacks["Colmap"]( source_path, "images", eval=False, resolution=1 ) elif os.path.exists(os.path.join(source_path, "transforms_train.json")): scene_info = sceneLoadTypeCallbacks["Blender"]( source_path, white_background, eval=False, resolution=1 ) else: raise ValueError(f"[Fine-tune] 无法识别数据集格式: {source_path}") cam_infos = scene_info.train_cameras print(f"[Fine-tune] 训练相机数量: {len(cam_infos)}") # 预先把所有相机加载到内存（含 GT 图像） class _LoadArgs: resolution = 1 data_device = device cameras = [] for i, ci in enumerate(cam_infos): try: cam = loadCam(_LoadArgs(), i, ci, 1.0, load_image=True) cameras.append(cam) except Exception as e: print(f"[Fine-tune] 跳过相机 {i}: {e}") if len(cameras) == 0: raise RuntimeError("[Fine-tune] 没有可用的训练相机，请检查 source_path。") # pipeline 设置（与你原有渲染脚本保持一致） class _Pipeline: convert_SHs_python = False compute_cov3D_python = False debug = False pipeline = _Pipeline() # ---- 4. Fine-tuning 主循环 ---- print(f"\n[Fine-tune] 开始优化，共 {num_epochs} epochs，{len(cameras)} 张图像...") lambda_dssim = 0.2 # L1 + 0.2 * (1 - SSIM)，与原版 3DGS 一致 import random for epoch in range(1, num_epochs + 1): # 每个 epoch 随机打乱相机顺序，逐张渲染并回传梯度 random.shuffle(cameras) epoch_loss = 0.0 for cam in cameras: optimizer.zero_grad() # 渲染 render_pkg = render(cam, gaussians, pipeline, background, kernel_size=kernel_size) rendered = render_pkg["render"] # (3, H, W) # GT 图像：Camera 对象上的 original_image，已是 [0,1] float tensor gt = cam.original_image.to(device) # (3, H, W) # 确保尺寸一致（下采样图像与渲染尺寸应相同，以防万一做一次 resize） if rendered.shape != gt.shape: gt = F.interpolate( gt.unsqueeze(0), size=(rendered.shape[1], rendered.shape[2]), mode='bilinear', align_corners=False ).squeeze(0) # 损失：L1 + D-SSIM Ll1 = l1_loss(rendered, gt) loss = (1.0 - lambda_dssim) * Ll1 + lambda_dssim * (1.0 - ssim(rendered, gt)) loss.backward() optimizer.step() epoch_loss += loss.item() if epoch % log_interval == 0 or epoch == 1: avg_loss = epoch_loss / len(cameras) print(f"[Fine-tune] Epoch {epoch:4d}/{num_epochs} avg_loss={avg_loss:.6f}") # ---- 5. 保存 fine-tuned PLY ---- print(f"\n[Fine-tune] 优化完成，保存至 {output_ply_path} ...") os.makedirs(os.path.dirname(os.path.abspath(output_ply_path)), exist_ok=True) gaussians.save_ply(output_ply_path) print("[Fine-tune] 保存完成。") # ============================================================ # 主流程 # ============================================================ def merge_and_finetune( ply_path, output_path, # merge 参数 k_neighbors=5, spread_factor=0.0, aspect_ratio_threshold=15.0, # fine-tune 参数 do_finetune=True, source_path=None, finetuned_output_path=None, sh_degree=3, num_epochs=500, lr_opacity=0.05, lr_scaling=0.005, lr_rotation=0.001, lr_features_dc=0.0025, lr_features_rest=0.000125, white_background=False, kernel_size=0.1, gpu_id=0, log_interval=50, ): """ 完整流程：merge -> (可选) fine-tune 参数： ply_path : 原始 3DGS PLY 文件 output_path : merge 后 PLY 的保存路径 do_finetune : 是否执行 fine-tuning 阶段 source_path : 下采样图像的 COLMAP 数据集目录（do_finetune=True 时必填） finetuned_output_path : fine-tuning 后 PLY 的保存路径 （默认在 output_path 同目录下加 _finetuned 后缀） """ # ---------- Step 1: Merge ---------- print("=" * 60) print("Step 1: Merge 高斯点") print("=" * 60) 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, 'filter_3D': [] } 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'], k_neighbors=k_neighbors, spread_factor=spread_factor, aspect_ratio_threshold=aspect_ratio_threshold ) 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]) 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}%") validation_result = validate_data(final_data) if validation_result['has_nan'] > 0 or validation_result['has_inf'] > 0: print(f"\n⚠️ 警告: 发现 {validation_result['has_nan']} 个NaN和 " f"{validation_result['has_inf']} 个Inf!") print("保存 merge 后的PLY文件...") os.makedirs(os.path.dirname(os.path.abspath(output_path)), exist_ok=True) save_ply(final_data, data['plydata'], output_path) print(f"Merge PLY 已保存到: {output_path}") # ---------- Step 2: Fine-tune ---------- if not do_finetune: print("\ndo_finetune=False，跳过 fine-tuning 阶段。") return if source_path is None: raise ValueError("do_finetune=True 时必须提供 source_path（下采样图像的 COLMAP 目录）") if finetuned_output_path is None: base, ext = os.path.splitext(output_path) finetuned_output_path = base + "_finetuned" + ext print("\n" + "=" * 60) print("Step 2: Fine-tune（冻结位置，优化其余参数）") print("=" * 60) finetune_merged_gaussians( merged_ply_path=output_path, source_path=source_path, output_ply_path=finetuned_output_path, sh_degree=sh_degree, num_epochs=num_epochs, lr_opacity=lr_opacity, lr_scaling=lr_scaling, lr_rotation=lr_rotation, lr_features_dc=lr_features_dc, lr_features_rest=lr_features_rest, white_background=white_background, kernel_size=kernel_size, gpu_id=gpu_id, log_interval=log_interval, ) print("\n✅ 全流程完成！") print(f" Merge PLY : {output_path}") print(f" Fine-tuned PLY : {finetuned_output_path}") # ============================================================ # 入口 # ============================================================ if __name__ == "__main__": # ---------- 路径配置 ---------- input_ply = "merge/original_3dgs.ply" merged_ply = "low_results/output_merged.ply" finetuned_ply = "low_results/output_finetuned.ply" # 你提供的下采样图像对应的 COLMAP 数据集目录 # 该目录下需有 sparse/ 和 images/（images/ 里存放下采样后的训练图像） downsampled_source = "dataset/downsampled" merge_and_finetune( # merge 参数 ply_path=input_ply, output_path=merged_ply, k_neighbors=5, spread_factor=0.0, aspect_ratio_threshold=15.0, # fine-tune 开关与参数 do_finetune=True, source_path=downsampled_source, finetuned_output_path=finetuned_ply, sh_degree=3, num_epochs=500, lr_opacity=0.05, lr_scaling=0.005, lr_rotation=0.001, lr_features_dc=0.0025, lr_features_rest=0.000125, white_background=False, kernel_size=0.1, gpu_id=0, log_interval=50, )