Upload merge.py

merge.py

@@ -0,0 +1,720 @@
+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
+import json
+
+
+# ============================================================
+#  Merge 相关函数
+# ============================================================
+
+def read_ply(ply_path):
+    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_')]
+    sh_rest   = np.stack([vertex[key] for key in sh_keys], axis=1) if sh_keys else None
+
+    # point_id：每个点的唯一标识，原始PLY没有该字段时自动生成 0~N-1
+    if 'point_id' in vertex.data.dtype.names:
+        point_ids = vertex['point_id'].astype(np.int64)
+    else:
+        point_ids = np.arange(len(positions), dtype=np.int64)
+
+    return {
+        'positions': positions, 'opacities': opacities, 'scales': scales,
+        'rotations': rotations, 'dc': dc, 'sh_rest': sh_rest,
+        'plydata': plydata, 'filter_3D': filter_3D,
+        'point_ids': point_ids,  # shape (N,)，每个点的唯一ID
+    }
+
+
+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)
+    return R_mat @ S_mat @ S_mat.T @ R_mat.T
+
+
+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
+    rotation = R.from_matrix(eigenvectors).as_quat()  # [x,y,z,w]
+    return rotation, scale
+
+
+def dc_to_rgb(dc):
+    C0 = 0.28209479177387814
+    return np.clip(dc * C0 + 0.5, 0, 1)
+
+
+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):
+            sub_min = np.array([
+                center[0] if (i & 1)      else bbox_min[0],
+                center[1] if (i >> 1 & 1) else bbox_min[1],
+                center[2] if (i >> 2 & 1) else bbox_min[2],
+            ])
+            sub_max = np.array([
+                bbox_max[0] if (i & 1)      else center[0],
+                bbox_max[1] if (i >> 1 & 1) else center[1],
+                bbox_max[2] if (i >> 2 & 1) 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)
+    subdivide(np.arange(len(positions)), positions.min(axis=0), positions.max(axis=0))
+    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)
+    _, indices = nbrs.kneighbors(positions)
+    rows, cols = [], []
+    for i in range(n_points):
+        for j in range(1, len(indices[i])):
+            rows += [i, indices[i][j]]
+            cols += [indices[i][j], i]
+    return csr_matrix((np.ones(len(rows)), (rows, cols)), shape=(n_points, n_points))
+
+
+def get_connected_clusters(labels, connectivity_matrix):
+    refined_labels = labels.copy()
+    next_label     = labels.max() + 1
+    for cluster_id in np.unique(labels):
+        cluster_indices = np.where(labels == cluster_id)[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):
+                refined_labels[cluster_indices[component_labels == comp_id]] = 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, compress_ratio=4,
+                           id_counter=None):
+    """
+    对单个 cell 内的点进行聚类和合并。
+
+    id_counter: 一个长度为1的列表 [int]，用于跨cell生成全局唯一的新point_id。
+                每产生一个合并点就将其自增1。
+
+    返回：
+        merged_data  : 合并后各属性（含 point_ids 字段）
+        cell_lineage : dict { child_id(int): [parent_id(int), ...] }
+    """
+    if len(cell_indices) < 4:
+        return None, None
+
+    n_clusters = max(1, len(cell_indices) // compress_ratio)
+
+    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]
+    cell_point_ids  = data['point_ids'][cell_indices]   # 父节点的 point_id
+
+    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)
+    labels   = AgglomerativeClustering(n_clusters=n_clusters, linkage='ward').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': [], 'point_ids': []
+    }
+    # 族谱：{child_point_id: [parent_point_id, ...]}
+    cell_lineage = {}
+
+    for cluster_id in np.unique(refined_labels):
+        idx_in_cell = np.where(refined_labels == cluster_id)[0]
+        if len(idx_in_cell) == 0:
+            continue
+
+        # 父节点的 point_id（与顺序无关的唯一标识）
+        parent_ids = [int(x) for x in cell_point_ids[idx_in_cell]]
+
+        # 为本合并点分配新的唯一 point_id
+        child_id = int(id_counter[0])
+        id_counter[0] += 1
+
+        scale_actual       = np.exp(cell_scales[idx_in_cell])
+        approx_volumes     = np.prod(scale_actual, axis=1, keepdims=True)
+        actual_opacities   = 1.0 / (1.0 + np.exp(-cell_opacities[idx_in_cell]))
+        weights            = actual_opacities * approx_volumes
+        normalized_weights = weights / weights.sum()
+
+        merged_position  = (cell_positions[idx_in_cell] * normalized_weights).sum(axis=0)
+        merged_dc        = (cell_dc[idx_in_cell] * normalized_weights).sum(axis=0)
+        merged_filter_3D = (cell_filter_3D[idx_in_cell] * normalized_weights).sum(axis=0)
+
+        if data['sh_rest'] is not None:
+            merged_sh_rest = (data['sh_rest'][cell_indices][idx_in_cell] * normalized_weights).sum(axis=0)
+
+        covariances = np.array([compute_covariance(cell_rotations[i], cell_scales[i]) for i in idx_in_cell])
+        merged_cov  = np.zeros((3, 3))
+        for i, orig_idx in enumerate(idx_in_cell):
+            diff = cell_positions[orig_idx] - merged_position
+            merged_cov += normalized_weights[i, 0] * (covariances[i] + spread_factor * np.outer(diff, diff))
+
+        merged_rotation, merged_scale = covariance_to_rotation_scale(merged_cov)
+
+        min_s = merged_scale.min()
+        if merged_scale.max() / (min_s + 1e-8) > aspect_ratio_threshold:
+            merged_scale = np.clip(merged_scale, None, min_s * aspect_ratio_threshold)
+
+        merged_opacity_actual = (cell_opacities[idx_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)
+        merged_data['point_ids'].append(child_id)
+        if data['sh_rest'] is not None:
+            merged_data['sh_rest'].append(merged_sh_rest)
+        merged_data['filter_3D'].append(merged_filter_3D)
+
+        # 族谱：child_id → parent_ids（均为 point_id，与顺序无关）
+        cell_lineage[child_id] = parent_ids
+
+    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, cell_lineage
+
+
+def validate_data(merged_data):
+    print("\n" + "="*60 + "\n数据验证报告\n" + "="*60)
+    total   = len(merged_data['positions'])
+    has_nan = np.zeros(total, dtype=bool)
+    has_inf = np.zeros(total, dtype=bool)
+    for key in ['positions', 'opacities', 'scales', 'rotations', 'dc']:
+        arr = merged_data[key]
+        if arr.ndim == 1:
+            has_nan |= np.isnan(arr)
+            has_inf |= np.isinf(arr)
+        else:
+            has_nan |= np.isnan(arr).any(axis=1)
+            has_inf |= np.isinf(arr).any(axis=1)
+    print(f"总点数: {total}  NaN点: {has_nan.sum()}  Inf点: {has_inf.sum()}")
+    print("="*60 + "\n")
+    return {'has_nan': has_nan.sum(), 'has_inf': has_inf.sum(), 'total': total}
+
+
+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'),
+        ('point_id', 'i8'),   # 每个点的唯一ID，用于族谱对应，与顺序无关
+    ]
+    n_sh = 0
+    if merged_data['sh_rest'] is not None:
+        n_sh = merged_data['sh_rest'].shape[1]
+        dtype_list += [(f'f_rest_{i}','f4') for i in range(n_sh)]
+    if merged_data.get('filter_3D') is not None:
+        dtype_list.append(('filter_3D','f4'))
+
+    vd = np.empty(n_points, dtype=dtype_list)
+    vd['x']        = merged_data['positions'][:,0]
+    vd['y']        = merged_data['positions'][:,1]
+    vd['z']        = merged_data['positions'][:,2]
+    vd['opacity']  = merged_data['opacities'].flatten()
+    vd['scale_0']  = np.log(merged_data['scales'][:,0])
+    vd['scale_1']  = np.log(merged_data['scales'][:,1])
+    vd['scale_2']  = np.log(merged_data['scales'][:,2])
+    vd['rot_0']    = merged_data['rotations'][:,0]
+    vd['rot_1']    = merged_data['rotations'][:,1]
+    vd['rot_2']    = merged_data['rotations'][:,2]
+    vd['rot_3']    = merged_data['rotations'][:,3]
+    vd['f_dc_0']   = merged_data['dc'][:,0]
+    vd['f_dc_1']   = merged_data['dc'][:,1]
+    vd['f_dc_2']   = merged_data['dc'][:,2]
+    vd['point_id'] = merged_data['point_ids'].astype(np.int64)
+    if merged_data['sh_rest'] is not None:
+        for i in range(n_sh):
+            vd[f'f_rest_{i}'] = merged_data['sh_rest'][:,i]
+    if merged_data.get('filter_3D') is not None:
+        vd['filter_3D'] = merged_data['filter_3D'].flatten()
+
+    PlyData([PlyElement.describe(vd, 'vertex')]).write(output_path)
+
+
+# ============================================================
+#  Merge 主流程（含族谱收集）
+# ============================================================
+
+def run_merge(data, compress_ratio=4, k_neighbors=5,
+              spread_factor=0.0, aspect_ratio_threshold=15.0,
+              id_counter=None):
+    """
+    对整份数据执行一次 merge，返回合并后数据和本级族谱。
+
+    族谱格式（level_lineage）：
+        dict { child_point_id(int): [parent_point_id(int), ...] }
+        与点的存储顺序完全无关，通过 point_id 唯一定位每个点。
+
+    id_counter: [int]，跨 cell 全局唯一ID生成器，由外部传入以保证跨级唯一性。
+    """
+    if id_counter is None:
+        id_counter = [0]
+
+    n_input = len(data['positions'])
+    cells   = build_octree(data['positions'], max_points=5000)
+    print(f"划分为 {len(cells)} 个 cells")
+
+    all_merged = {
+        'positions': [], 'opacities': [], 'scales': [], 'rotations': [],
+        'dc': [], 'sh_rest': [] if data['sh_rest'] is not None else None,
+        'filter_3D': [], 'point_ids': []
+    }
+    level_lineage = {}   # {child_id: [parent_id, ...]}
+
+    for i, cell in enumerate(cells):
+        if i % 100 == 0:
+            print(f"  处理进度: {i}/{len(cells)}")
+
+        merged, cell_lineage = 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,
+            compress_ratio=compress_ratio,
+            id_counter=id_counter,
+        )
+        if merged is None:
+            continue
+
+        for key in all_merged:
+            if all_merged[key] is not None and len(merged[key]) > 0:
+                all_merged[key].append(merged[key])
+
+        level_lineage.update(cell_lineage)   # 合并各cell的族谱dict
+
+    final_data = {
+        key: np.concatenate(all_merged[key], axis=0)
+        for key in all_merged
+        if all_merged[key] is not None and len(all_merged[key]) > 0
+    }
+    n_merged = len(final_data['positions'])
+    print(f"合并后点数: {n_merged}  压缩率: {n_merged/n_input*100:.2f}%")
+
+    return final_data, level_lineage
+
+
+# ============================================================
+#  Fine-tuning 阶段
+# ============================================================
+
+def finetune_merged_gaussians(
+    merged_ply_path,
+    original_source_path,
+    output_ply_path,
+    image_resolution=1,
+    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,
+):
+    """
+    冻结高斯点位置，用下采样 GT 图像对其余参数做 fine-tuning。
+
+    original_source_path : 原始分辨率 COLMAP 目录，程序内部自动 in-memory 下采样。
+    image_resolution     : GT 图像边长缩小倍率（1=原图, 2=1/2边长, 4=1/4边长, 8=1/8边长）。
+    """
+    import torch
+    import torch.nn.functional as F
+    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
+    import random
+
+    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. 加载高斯模型
+    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. 冻结位置
+    gaussians._xyz.requires_grad_(False)
+    optimizer = torch.optim.Adam([
+        {'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'},
+    ], eps=1e-15)
+
+    # 3. 读取相机（原始分辨率）
+    print(f"[Fine-tune] 读取相机，GT 将 in-memory 下采样 1/{image_resolution} 边长...")
+    if os.path.exists(os.path.join(original_source_path, "sparse")):
+        scene_info = sceneLoadTypeCallbacks["Colmap"](
+            original_source_path, "images", eval=False, resolution=1)
+    elif os.path.exists(os.path.join(original_source_path, "transforms_train.json")):
+        scene_info = sceneLoadTypeCallbacks["Blender"](
+            original_source_path, white_background, eval=False, resolution=1)
+    else:
+        raise ValueError(f"[Fine-tune] 无法识别数据集格式: {original_source_path}")
+
+    class _LoadArgs:
+        resolution  = 1
+        data_device = device
+
+    cameras = []
+    for i, ci in enumerate(scene_info.train_cameras):
+        try:
+            cameras.append(loadCam(_LoadArgs(), i, ci, 1.0, load_image=True))
+        except Exception as e:
+            print(f"[Fine-tune] 跳过相机 {i}: {e}")
+
+    if not cameras:
+        raise RuntimeError("[Fine-tune] 没有可用的训练相机。")
+
+    # 4. in-memory 下采样：GT 图像 + 渲染分辨率同步缩小
+    if image_resolution > 1:
+        print(f"[Fine-tune] 对 {len(cameras)} 个相机做 1/{image_resolution} 边长下采样...")
+        for cam in cameras:
+            gt_orig  = cam.original_image.to(device)
+            H, W     = gt_orig.shape[1], gt_orig.shape[2]
+            new_H, new_W = H // image_resolution, W // image_resolution
+            cam.original_image = F.interpolate(
+                gt_orig.unsqueeze(0), size=(new_H, new_W),
+                mode='bilinear', align_corners=False
+            ).squeeze(0).cpu()
+            # FoVx/FoVy 不变，渲染器根据新 image_width/height 自动反算 focal length
+            cam.image_width  = new_W
+            cam.image_height = new_H
+        print(f"[Fine-tune] 下采样后尺寸: {cameras[0].image_height} x {cameras[0].image_width}")
+
+    # 5. 训练循环
+    class _Pipeline:
+        convert_SHs_python = False
+        compute_cov3D_python = False
+        debug = False
+
+    pipeline     = _Pipeline()
+    lambda_dssim = 0.2
+
+    print(f"\n[Fine-tune] 开始优化，共 {num_epochs} epochs，{len(cameras)} 张图像...")
+    for epoch in range(1, num_epochs + 1):
+        random.shuffle(cameras)
+        epoch_loss = 0.0
+        for cam in cameras:
+            optimizer.zero_grad()
+            rendered = render(cam, gaussians, pipeline, background, kernel_size=kernel_size)["render"]
+            gt       = cam.original_image.to(device)
+            if rendered.shape != gt.shape:
+                gt = F.interpolate(gt.unsqueeze(0), size=rendered.shape[1:],
+                                   mode='bilinear', align_corners=False).squeeze(0)
+            loss = (1.0 - lambda_dssim) * l1_loss(rendered, gt) \
+                 + lambda_dssim * (1.0 - ssim(rendered, gt))
+            loss.backward()
+            optimizer.step()
+            epoch_loss += loss.item()
+        if epoch % log_interval == 0 or epoch == 1:
+            print(f"[Fine-tune] Epoch {epoch:4d}/{num_epochs}  avg_loss={epoch_loss/len(cameras):.6f}")
+
+    # 6. 保存
+    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 run_all(
+    input_ply,
+    original_source_path,
+    output_base,
+    # merge 参数
+    k_neighbors=5,
+    spread_factor=0.0,
+    aspect_ratio_threshold=15.0,
+    # fine-tune 参数
+    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 + 族谱保存。
+
+    输出目录结构：
+        output_base/
+        ├── L1/
+        │   ├── merged.ply       # 1/4 点数，merge 后未微调
+        │   └── finetuned.ply    # 1/4 点数，微调后
+        ├── L2/
+        │   ├── merged.ply       # 1/16 点数
+        │   └── finetuned.ply
+        ├── L3/
+        │   ├── merged.ply       # 1/64 点数
+        │   └── finetuned.ply
+        └── lineage.json         # 完整族谱
+
+    族谱结构（lineage.json）：
+        {
+          "L1": [[idx, ...], [idx, ...], ...],
+            // L1[i] = 原始 PLY 中哪些点合并成了 L1 第 i 个点
+
+          "L2": [[idx, ...], ...],
+            // L2[i] = L1 finetuned PLY 中哪些点合并成了 L2 第 i 个点
+
+          "L3": [[idx, ...], ...]
+            // L3[i] = L2 finetuned PLY 中哪些点合并成了 L3 第 i 个点
+        }
+
+    层级恢复示例（从 L3 追溯到原始点）：
+        L3[i] 由 L2 中的 lineage["L3"][i] 合并而来
+        其中 L2[j] 又由 L1 中的 lineage["L2"][j] 合并而来
+        其中 L1[k] 又由原始点中的 lineage["L1"][k] 合并而来
+    """
+
+    # 三级配置：(级别名, image_resolution)
+    # compress_ratio 固定为 4，每级压缩 1/4 点数
+    levels = [
+        ("L1", 2),   # 原始   → 1/4  点，图像边长 1/2
+        ("L2", 4),   # L1结果 → 1/16 点，图像边长 1/4
+        ("L3", 8),   # L2结果 → 1/64 点，图像边长 1/8
+    ]
+
+    finetune_kwargs = dict(
+        original_source_path=original_source_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,
+    )
+
+    merge_kwargs = dict(
+        compress_ratio=4,
+        k_neighbors=k_neighbors,
+        spread_factor=spread_factor,
+        aspect_ratio_threshold=aspect_ratio_threshold,
+    )
+
+    # id_counter 跨三级共享，保证所有点的 point_id 全局唯一：
+    #   原始点   : point_id = 0 ~ N_original-1  (read_ply 自动生成)
+    #   L1合并点 : point_id 从 N_original 开始递增
+    #   L2、L3  : 继续递增，绝不与任何已有 point_id 冲突
+    current_data     = read_ply(input_ply)
+    n_original       = len(current_data['positions'])
+    id_counter       = [n_original]  # 合并点编号从原始点数量之后开始
+    full_lineage     = {}            # {level: {str(child_id): [parent_id, ...]}}
+    current_ply_path = input_ply
+
+    for level, image_resolution in levels:
+        print("\n" + "=" * 70)
+        print(f"级别: {level}  |  本级压缩 1/4  |  图像边长缩小 1/{image_resolution}")
+        print(f"输入 PLY: {current_ply_path}")
+        print("=" * 70)
+
+        level_dir     = os.path.join(output_base, level)
+        merged_ply    = os.path.join(level_dir, "merged.ply")
+        finetuned_ply = os.path.join(level_dir, "finetuned.ply")
+        os.makedirs(level_dir, exist_ok=True)
+
+        # --- Merge ---
+        print(f"\n[{level}] Step 1: Merge")
+        final_data, level_lineage = run_merge(
+            current_data, id_counter=id_counter, **merge_kwargs)
+
+        result = validate_data(final_data)
+        if result['has_nan'] or result['has_inf']:
+            print(f"⚠️  NaN={result['has_nan']}  Inf={result['has_inf']}")
+
+        save_ply(final_data, current_data['plydata'], merged_ply)
+        print(f"[{level}] Merge PLY 已保存: {merged_ply}")
+
+        # 族谱 key 转 str（JSON 要求 key 必须是字符串）
+        # 格式：{"child_point_id": [parent_point_id, ...], ...}
+        full_lineage[level] = {str(k): v for k, v in level_lineage.items()}
+        lineage_path = os.path.join(output_base, "lineage.json")
+        with open(lineage_path, 'w') as f:
+            json.dump(full_lineage, f)
+        print(f"[{level}] 族谱已保存（当前已完成: {list(full_lineage.keys())}）")
+
+        # --- Fine-tune ---
+        print(f"\n[{level}] Step 2: Fine-tune (image_resolution=1/{image_resolution})")
+        finetune_merged_gaussians(
+            merged_ply_path=merged_ply,
+            output_ply_path=finetuned_ply,
+            image_resolution=image_resolution,
+            **finetune_kwargs,
+        )
+
+        # 下一级从 finetuned.ply 出发（fine-tune 不改变点数和 point_id，只改属性）
+        current_ply_path = finetuned_ply
+        current_data     = read_ply(finetuned_ply)
+
+    # 族谱已在每级完成后实时写盘，此处仅做最终确认
+    lineage_path = os.path.join(output_base, "lineage.json")
+    print(f"\n✅  族谱完整保存至: {lineage_path}")
+
+    print("\n🎉  所有级别完成！")
+    print(f"输出目录: {output_base}")
+    print("  L1/merged.ply, L1/finetuned.ply  — 1/4 点数")
+    print("  L2/merged.ply, L2/finetuned.ply  — 1/16 点数")
+    print("  L3/merged.ply, L3/finetuned.ply  — 1/64 点数")
+    print("  lineage.json                      — 完整族谱")
+
+
+# ============================================================
+#  族谱工具函数（供后续训练代码使用）
+# ============================================================
+
+def load_lineage(lineage_path):
+    """加载族谱文件"""
+    with open(lineage_path, 'r') as f:
+        lineage = json.load(f)
+    return lineage
+
+
+def trace_to_original(child_point_id, level, lineage):
+    """
+    从某一级的点（通过 point_id 指定）追溯到原始点的 point_id 集合。
+
+    参数：
+        child_point_id : 要追溯的点的 point_id（int 或 str 均可）
+        level          : 该点所在级别，"L1" / "L2" / "L3"
+        lineage        : load_lineage() 返回的族谱 dict
+
+    返回：
+        List[int]，原始 PLY 中的 point_id 列表（即 0 ~ N_original-1 范围内的值）
+
+    示例：
+        lineage = load_lineage("low_results/lineage.json")
+        # 查询 L3 中 point_id=500100 的点对应的所有原始点
+        orig_ids = trace_to_original(500100, "L3", lineage)
+    """
+    levels    = ["L1", "L2", "L3"]
+    level_idx = levels.index(level)
+
+    # 当前层的父节点 point_id 列表
+    current_ids = lineage[level][str(child_point_id)]
+
+    # 逐级向上追溯，直到 L1 的父节点（即原始点 point_id）
+    for parent_level in reversed(levels[:level_idx]):
+        next_ids = []
+        for pid in current_ids:
+            # 原始点的 point_id 不在族谱里（它们是叶子节点），直接保留
+            key = str(pid)
+            if key in lineage[parent_level]:
+                next_ids.extend(lineage[parent_level][key])
+            else:
+                next_ids.append(pid)
+        current_ids = next_ids
+
+    return [int(x) for x in current_ids]
+
+
+# ============================================================
+#  入口
+# ============================================================
+
+
+
+if __name__ == "__main__":
+
+    run_all(
+        input_ply           = "merge/original_3dgs.ply",
+        original_source_path = "data",   # 唯一需要提供的 COLMAP 目录
+        output_base         = "outputs",
+
+        # merge 参数
+        k_neighbors=5,
+        spread_factor=0.0,
+        aspect_ratio_threshold=15.0,
+
+        # fine-tune 参数
+        sh_degree=3,
+        num_epochs=250,
+        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=2,
+        log_interval=50,
+    )