import numpy as np
import torch
from sklearn.cluster import AgglomerativeClustering
from plyfile import PlyData, PlyElement
import os
from pathlib import Path

# 评估指标库
from skimage.metrics import structural_similarity as ssim
from skimage.metrics import peak_signal_noise_ratio as psnr
import lpips
import cv2

class GaussianMerger:
    """
    3DGS聚类Merge实现
    核心思路:
    1. 空间划分为带padding的cells
    2. 在每个cell内使用AgglomerativeClustering聚类
    3. 使用矩匹配合并高斯参数
    4. 只保留中心在no-padding区域的簇
    """
    def __init__(self, cell_size, padding_ratio=0.1, target_points_per_cluster=3):
        """
        Args:
            cell_size: float, cell边长
            padding_ratio: float, padding占边长的比例
            target_points_per_cluster: int, 目标每簇点数(2-4)
        """
        self.cell_size = cell_size
        self.padding_ratio = padding_ratio
        self.padding_size = cell_size * padding_ratio
        self.target_points_per_cluster = target_points_per_cluster
        
        # 聚类特征权重
        # 归一化位置(3维) + 不透明度(1维) + SH(48维,RGB三阶)
        self.feature_weights = {
            'position': 1.0,    # 空间位置权重
            'opacity': 1.0,     # 不透明度权重
            'sh': 0.2,          # SH系数权重(颜色特征)
        }
    
    def load_ply(self, ply_path):
        """
        加载3DGS的.ply文件
        
        3DGS数据格式:
        - xyz: 3个坐标
        - opacity: 1个不透明度
        - f_dc_0/1/2: DC分量(3维)
        - f_rest_0~44: SH系数(45维,对应RGB各15个三阶SH系数)
        - scale_0/1/2: 3个尺度
        - rot_0/1/2/3: 四元数旋转(4维)
        
        Returns:
            dict: {
                'xyz': (N,3),
                'opacity': (N,1), 
                'dc': (N,3), DC颜色分量
                'sh': (N,45), SH系数
                'scale': (N,3),
                'rotation': (N,4) 四元数 [w,x,y,z]
            }
        """
        print(f"Loading 3DGS from {ply_path}...")
        plydata = PlyData.read(ply_path)
        vertices = plydata['vertex']
        
        # 提取xyz坐标
        xyz = np.stack([vertices['x'], vertices['y'], vertices['z']], axis=1)
        
        # 提取不透明度
        opacity = vertices['opacity'][:, np.newaxis]
        
        # 提取DC分量
        dc = np.stack([vertices['f_dc_0'], vertices['f_dc_1'], vertices['f_dc_2']], axis=1)
        
        # 提取SH系数 (RGB三阶共45维)
        sh_features = []
        for i in range(45):
            sh_features.append(vertices[f'f_rest_{i}'])
        sh = np.stack(sh_features, axis=1)
        
        # 提取scale
        scale = np.stack([vertices['scale_0'], vertices['scale_1'], vertices['scale_2']], axis=1)
        
        # 提取rotation (四元数)
        rotation = np.stack([vertices['rot_0'], vertices['rot_1'], 
                            vertices['rot_2'], vertices['rot_3']], axis=1)
        
        print(f"Loaded {len(xyz)} Gaussians")
        print(f"Scene bounds: {xyz.min(axis=0)} to {xyz.max(axis=0)}")
        
        return {
            'xyz': xyz,
            'opacity': opacity,
            'dc': dc,
            'sh': sh,
            'scale': scale,
            'rotation': rotation
        }
    
    def save_ply(self, gaussians, output_path):
        """
        保存merge后的高斯到.ply文件
        
        Args:
            gaussians: dict, merge后的高斯参数
            output_path: str, 输出路径
        """
        print(f"Saving merged 3DGS to {output_path}...")
        
        xyz = gaussians['xyz']
        opacity = gaussians['opacity'].flatten()
        dc = gaussians['dc']
        sh = gaussians['sh']
        scale = gaussians['scale']
        rotation = gaussians['rotation']
        
        n_points = len(xyz)
        
        # 构建dtype
        dtype_list = [
            ('x', 'f4'), ('y', 'f4'), ('z', 'f4'),
            ('opacity', 'f4'),
            ('f_dc_0', 'f4'), ('f_dc_1', 'f4'), ('f_dc_2', 'f4'),
        ]
        
        # 添加SH系数
        for i in range(45):
            dtype_list.append((f'f_rest_{i}', 'f4'))
        
        # 添加scale和rotation
        dtype_list.extend([
            ('scale_0', 'f4'), ('scale_1', 'f4'), ('scale_2', 'f4'),
            ('rot_0', 'f4'), ('rot_1', 'f4'), ('rot_2', 'f4'), ('rot_3', 'f4')
        ])
        
        # 创建结构化数组
        elements = np.empty(n_points, dtype=dtype_list)
        
        # 填充数据
        elements['x'] = xyz[:, 0]
        elements['y'] = xyz[:, 1]
        elements['z'] = xyz[:, 2]
        elements['opacity'] = opacity
        elements['f_dc_0'] = dc[:, 0]
        elements['f_dc_1'] = dc[:, 1]
        elements['f_dc_2'] = dc[:, 2]
        
        for i in range(45):
            elements[f'f_rest_{i}'] = sh[:, i]
        
        elements['scale_0'] = scale[:, 0]
        elements['scale_1'] = scale[:, 1]
        elements['scale_2'] = scale[:, 2]
        elements['rot_0'] = rotation[:, 0]
        elements['rot_1'] = rotation[:, 1]
        elements['rot_2'] = rotation[:, 2]
        elements['rot_3'] = rotation[:, 3]
        
        # 创建PlyElement
        el = PlyElement.describe(elements, 'vertex')
        
        # 写入文件
        PlyData([el]).write(output_path)
        print(f"Saved {n_points} merged Gaussians")
    
    def partition_space(self, xyz):
        """
        空间划分: 将场景划分为cell网格
        
        策略:
        - 每个cell有padding区域用于聚类
        - 但只保留中心在no-padding区域的簇
        
        Args:
            xyz: (N, 3) 点的位置
        Returns:
            cell_dict: {cell_id: [point_indices]} cell内的点索引(含padding)
            cell_info: {cell_id: {'center', 'bounds_no_padding', 'bounds_with_padding'}}
        """
        print("Partitioning space into cells...")
        
        # 计算场景边界(稍微扩大一点避免边界问题)
        min_bound = xyz.min(axis=0) - self.padding_size
        max_bound = xyz.max(axis=0) + self.padding_size
        
        # 计算每个点所属的cell(基于no-padding边界)
        cell_indices = np.floor((xyz - min_bound) / self.cell_size).astype(int)
        
        # 获取所有唯一的cell
        unique_cells = np.unique(cell_indices, axis=0)
        
        cell_dict = {}
        cell_info = {}
        
        for cell_idx in unique_cells:
            cell_id = tuple(cell_idx)
            
            # Cell的no-padding边界
            cell_min = min_bound + cell_idx * self.cell_size
            cell_max = cell_min + self.cell_size
            
            # Cell的with-padding边界
            cell_min_padded = cell_min - self.padding_size
            cell_max_padded = cell_max + self.padding_size
            
            # 找到所有在padding范围内的点
            mask = np.all((xyz >= cell_min_padded) & (xyz < cell_max_padded), axis=1)
            point_indices = np.where(mask)[0]
            
            if len(point_indices) > 0:
                cell_dict[cell_id] = point_indices
                cell_info[cell_id] = {
                    'center': (cell_min + cell_max) / 2,
                    'bounds_no_padding': (cell_min, cell_max),
                    'bounds_with_padding': (cell_min_padded, cell_max_padded)
                }
        
        print(f"Created {len(cell_dict)} cells")
        points_per_cell = [len(indices) for indices in cell_dict.values()]
        print(f"Points per cell: min={min(points_per_cell)}, max={max(points_per_cell)}, avg={np.mean(points_per_cell):.1f}")
        
        return cell_dict, cell_info
    
    def compute_features_for_clustering(self, gaussians, point_indices, cell_bounds):
        """
        计算聚类特征: 归一化位置(3) + 不透明度(1) + SH系数(48)
        
        注意:
        - 位置需要在padding后的cell内归一化
        - SH系数包含DC(3维)和高阶(45维),共48维
        - 不同特征使用不同权重
        
        Args:
            gaussians: 完整的高斯数据
            point_indices: 当前cell内的点索引
            cell_bounds: (min_xyz, max_xyz) with padding
        Returns:
            features: (N, 52) 归一化后的特征向量
        """
        xyz = gaussians['xyz'][point_indices]
        opacity = gaussians['opacity'][point_indices]
        dc = gaussians['dc'][point_indices]
        sh = gaussians['sh'][point_indices]
        
        cell_min, cell_max = cell_bounds
        cell_size_padded = cell_max - cell_min
        
        # 归一化位置: (xyz - cell_min) / padded_cell_size
        normalized_pos = (xyz - cell_min) / cell_size_padded
        
        # 组合SH特征: DC + 高阶SH
        sh_features = np.concatenate([dc, sh], axis=1)  # (N, 48)
        
        # 组合所有特征并加权
        features = np.concatenate([
            normalized_pos * self.feature_weights['position'],      # (N, 3)
            opacity * self.feature_weights['opacity'],              # (N, 1)
            sh_features * self.feature_weights['sh']                # (N, 48)
        ], axis=1)
        
        return features
    
    def quaternion_to_rotation_matrix(self, q):
        """
        四元数转旋转矩阵
        
        Args:
            q: (4,) [w, x, y, z] 或 (N, 4)
        Returns:
            R: (3, 3) 或 (N, 3, 3)
        """
        if q.ndim == 1:
            w, x, y, z = q
            R = np.array([
                [1-2*(y**2+z**2), 2*(x*y-w*z), 2*(x*z+w*y)],
                [2*(x*y+w*z), 1-2*(x**2+z**2), 2*(y*z-w*x)],
                [2*(x*z-w*y), 2*(y*z+w*x), 1-2*(x**2+y**2)]
            ])
            return R
        else:
            # 批量处理
            w, x, y, z = q[:, 0], q[:, 1], q[:, 2], q[:, 3]
            R = np.zeros((len(q), 3, 3))
            R[:, 0, 0] = 1 - 2*(y**2 + z**2)
            R[:, 0, 1] = 2*(x*y - w*z)
            R[:, 0, 2] = 2*(x*z + w*y)
            R[:, 1, 0] = 2*(x*y + w*z)
            R[:, 1, 1] = 1 - 2*(x**2 + z**2)
            R[:, 1, 2] = 2*(y*z - w*x)
            R[:, 2, 0] = 2*(x*z - w*y)
            R[:, 2, 1] = 2*(y*z + w*x)
            R[:, 2, 2] = 1 - 2*(x**2 + y**2)
            return R
    
    def compute_covariance(self, scale, rotation):
        """
        计算协方差矩阵: Σ = R·S·S^T·R^T
        
        Args:
            scale: (N, 3) 三个轴的尺度
            rotation: (N, 4) 四元数 [w,x,y,z]
        Returns:
            covariances: (N, 3, 3)
        """
        N = len(scale)
        R = self.quaternion_to_rotation_matrix(rotation)  # (N, 3, 3)
        
        # S 是对角矩阵
        S = np.zeros((N, 3, 3))
        S[:, 0, 0] = scale[:, 0]
        S[:, 1, 1] = scale[:, 1]
        S[:, 2, 2] = scale[:, 2]
        
        # Σ = R·S·S^T·R^T
        covariances = np.einsum('nij,njk,nlk,nli->nil', R, S, S, R)
        
        return covariances
    
    def moment_matching(self, means, covariances, opacities, scales):
        """
        矩匹配: 合并多个高斯分布
        
        公式:
        - 权重: wi = opacity_i * volume_i
        - 新均值: μ_new = Σ(wi * μi) / Σwi
        - 新协方差: Σ_new = Σ(wi * (Σi + (μi-μ_new)(μi-μ_new)^T)) / Σwi
        - 新不透明度: 质量守恒,Σ(opacity_i * volume_i) = opacity_new * volume_new
        
        Args:
            means: (K, 3) 各高斯均值
            covariances: (K, 3, 3) 各高斯协方差矩阵
            opacities: (K, 1) 不透明度
            scales: (K, 3) 尺度
        Returns:
            new_mean: (3,)
            new_covariance: (3, 3)
            new_opacity: float
            new_scale: (3,)
            new_rotation: (4,) 四元数
        """
        # 计算权重 wi = opacity * scale_volume
        scale_volumes = np.prod(scales, axis=1, keepdims=True)  # (K, 1)
        weights = opacities * scale_volumes  # (K, 1)
        total_weight = weights.sum()
        weights_normalized = weights / total_weight  # 归一化用于计算均值和协方差
        
        # 计算加权均值
        new_mean = np.sum(weights_normalized * means, axis=0)  # (3,)
        
        # 计算混合协方差
        mean_diff = means - new_mean  # (K, 3)
        outer_products = np.einsum('ki,kj->kij', mean_diff, mean_diff)  # (K, 3, 3)
        
        new_covariance = np.sum(
            weights_normalized[:, :, np.newaxis] * (covariances + outer_products), 
            axis=0
        )  # (3, 3)
        
        # 从协方差矩阵分解得到scale和rotation
        # 特征值分解: Σ = V·Λ·V^T,其中V是旋转矩阵,Λ是特征值对角阵
        eigenvalues, eigenvectors = np.linalg.eigh(new_covariance)
        
        # scale = sqrt(eigenvalues)
        new_scale = np.sqrt(np.abs(eigenvalues))
        new_scale_volume = np.prod(new_scale)
        
        # 质量守恒: Σ(opacity_i * volume_i) = opacity_new * volume_new
        # opacity_new = Σ(opacity_i * volume_i) / volume_new
        if new_scale_volume > 1e-10:
            new_opacity = total_weight / new_scale_volume
            new_opacity = np.clip(new_opacity, 0, 1)  # 限制在[0,1]
        else:
            new_opacity = np.mean(opacities)  # fallback
        
        # rotation matrix = eigenvectors
        R_new = eigenvectors
        
        # 旋转矩阵转四元数
        new_rotation = self.rotation_matrix_to_quaternion(R_new)
        
        return new_mean, new_covariance, new_opacity, new_scale, new_rotation
    
    def rotation_matrix_to_quaternion(self, R):
        """
        旋转矩阵转四元数 [w, x, y, z]
        使用Shepperd方法,数值稳定
        """
        trace = np.trace(R)
        
        if trace > 0:
            s = 0.5 / np.sqrt(trace + 1.0)
            w = 0.25 / s
            x = (R[2, 1] - R[1, 2]) * s
            y = (R[0, 2] - R[2, 0]) * s
            z = (R[1, 0] - R[0, 1]) * s
        elif R[0, 0] > R[1, 1] and R[0, 0] > R[2, 2]:
            s = 2.0 * np.sqrt(1.0 + R[0, 0] - R[1, 1] - R[2, 2])
            w = (R[2, 1] - R[1, 2]) / s
            x = 0.25 * s
            y = (R[0, 1] + R[1, 0]) / s
            z = (R[0, 2] + R[2, 0]) / s
        elif R[1, 1] > R[2, 2]:
            s = 2.0 * np.sqrt(1.0 + R[1, 1] - R[0, 0] - R[2, 2])
            w = (R[0, 2] - R[2, 0]) / s
            x = (R[0, 1] + R[1, 0]) / s
            y = 0.25 * s
            z = (R[1, 2] + R[2, 1]) / s
        else:
            s = 2.0 * np.sqrt(1.0 + R[2, 2] - R[0, 0] - R[1, 1])
            w = (R[1, 0] - R[0, 1]) / s
            x = (R[0, 2] + R[2, 0]) / s
            y = (R[1, 2] + R[2, 1]) / s
            z = 0.25 * s
        
        q = np.array([w, x, y, z])
        q = q / np.linalg.norm(q)  # 归一化
        return q
    
    def cluster_and_merge_cell(self, gaussians, point_indices, cell_info):
        """
        在单个cell内进行聚类和merge
        
        流程:
        1. 提取padding区域内的所有点
        2. 计算聚类特征(归一化位置+不透明度+SH)
        3. 使用AgglomerativeClustering聚类
        4. 对每个簇使用矩匹配合并
        5. 只保留中心在no-padding区域的簇
        
        Args:
            gaussians: 完整的高斯数据dict
            point_indices: 当前cell内的点索引 (包含padding区域)
            cell_info: cell的边界信息
        Returns:
            merged_gaussians: dict, merge后的高斯参数
        """
        if len(point_indices) == 0:
            return None
        
        # 提取cell内的数据
        xyz = gaussians['xyz'][point_indices]
        
        # 计算聚类特征
        cell_bounds = cell_info['bounds_with_padding']
        features = self.compute_features_for_clustering(gaussians, point_indices, cell_bounds)
        
        # 计算聚类数量: n_clusters = n_points // target_points_per_cluster
        n_clusters = max(1, len(point_indices) // self.target_points_per_cluster)
        
        # AgglomerativeClustering
        clustering = AgglomerativeClustering(
            n_clusters=n_clusters,
            metric='euclidean',
            linkage='ward'
        )
        labels = clustering.fit_predict(features)
        
        # 对每个簇进行merge
        merged_results = {
            'xyz': [],
            'opacity': [],
            'dc': [],
            'sh': [],
            'scale': [],
            'rotation': []
        }
        
        no_padding_min, no_padding_max = cell_info['bounds_no_padding']
        
        for cluster_id in range(n_clusters):
            cluster_mask = labels == cluster_id
            cluster_point_indices = point_indices[cluster_mask]
            
            if len(cluster_point_indices) == 0:
                continue
            
            # 提取簇内数据
            cluster_xyz = gaussians['xyz'][cluster_point_indices]
            cluster_opacity = gaussians['opacity'][cluster_point_indices]
            cluster_dc = gaussians['dc'][cluster_point_indices]
            cluster_sh = gaussians['sh'][cluster_point_indices]
            cluster_scale = gaussians['scale'][cluster_point_indices]
            cluster_rotation = gaussians['rotation'][cluster_point_indices]
            
            # 计算协方差矩阵
            cluster_covariances = self.compute_covariance(cluster_scale, cluster_rotation)
            
            # 矩匹配合并位置和协方差
            new_mean, new_cov, new_opacity, new_scale, new_rotation = self.moment_matching(
                cluster_xyz, cluster_covariances, cluster_opacity, cluster_scale
            )
            
            # 只保留中心在no-padding区域的簇
            if np.all(new_mean >= no_padding_min) and np.all(new_mean < no_padding_max):
                # DC和SH使用加权平均
                scale_volumes = np.prod(cluster_scale, axis=1, keepdims=True)
                weights = cluster_opacity * scale_volumes
                weights = weights / weights.sum()
                
                new_dc = np.sum(weights * cluster_dc, axis=0)
                new_sh = np.sum(weights * cluster_sh, axis=0)
                
                # 添加到结果
                merged_results['xyz'].append(new_mean)
                merged_results['opacity'].append([new_opacity])
                merged_results['dc'].append(new_dc)
                merged_results['sh'].append(new_sh)
                merged_results['scale'].append(new_scale)
                merged_results['rotation'].append(new_rotation)
        
        # 转换为numpy数组
        if len(merged_results['xyz']) == 0:
            return None
        
        for key in merged_results:
            merged_results[key] = np.array(merged_results[key])
        
        return merged_results
    
    def merge_all(self, gaussians):
        """
        对所有cell进行聚类merge
        
        Args:
            gaussians: 原始高斯数据
        Returns:
            merged_gaussians: merge后的高斯数据
        """
        # 空间划分
        cell_dict, cell_info = self.partition_space(gaussians['xyz'])
        
        # 对每个cell进行处理
        all_merged = {
            'xyz': [],
            'opacity': [],
            'dc': [],
            'sh': [],
            'scale': [],
            'rotation': []
        }
        
        total_cells = len(cell_dict)
        for idx, (cell_id, point_indices) in enumerate(cell_dict.items()):
            if (idx + 1) % 100 == 0:
                print(f"Processing cell {idx+1}/{total_cells}...")
            
            merged = self.cluster_and_merge_cell(gaussians, point_indices, cell_info[cell_id])
            
            if merged is not None:
                for key in all_merged:
                    all_merged[key].append(merged[key])
        
        # 合并所有cell的结果
        final_merged = {}
        for key in all_merged:
            final_merged[key] = np.concatenate(all_merged[key], axis=0)
        
        print(f"\nMerge Statistics:")
        print(f"  Original points: {len(gaussians['xyz'])}")
        print(f"  Merged points: {len(final_merged['xyz'])}")
        print(f"  Compression ratio: {len(gaussians['xyz']) / len(final_merged['xyz']):.2f}x")
        
        return final_merged


class ImageEvaluator:
    """
    图像质量评估
    支持: PSNR, SSIM, LPIPS, NIQE, FID, MEt3R
    """
    def __init__(self, device='cuda' if torch.cuda.is_available() else 'cpu'):
        self.device = device
        
        # 初始化LPIPS模型
        self.lpips_model = lpips.LPIPS(net='alex').to(device)
        
    def load_image(self, image_path):
        """
        加载图像,支持jpg和png
        Returns:
            img: (H, W, 3) numpy array, range [0, 1]
        """
        img = cv2.imread(image_path)
        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
        img = img.astype(np.float32) / 255.0
        return img
    
    def compute_psnr(self, img1, img2):
        """
        计算PSNR
        """
        return psnr(img1, img2, data_range=1.0)
    
    def compute_ssim(self, img1, img2):
        """
        计算SSIM
        """
        return ssim(img1, img2, multichannel=True, data_range=1.0, channel_axis=2)
    
    def compute_lpips(self, img1, img2):
        """
        计算LPIPS (需要转换为tensor)
        """
        # 转换为tensor: (H,W,3) -> (1,3,H,W)
        img1_t = torch.from_numpy(img1).permute(2, 0, 1).unsqueeze(0).to(self.device)
        img2_t = torch.from_numpy(img2).permute(2, 0, 1).unsqueeze(0).to(self.device)
        
        # LPIPS期望输入范围[-1, 1]
        img1_t = img1_t * 2 - 1
        img2_t = img2_t * 2 - 1
        
        with torch.no_grad():
            lpips_value = self.lpips_model(img1_t, img2_t).item()
        
        return lpips_value
    
    def compute_niqe(self, img):
        """
        计算NIQE (无参考图像质量评估)
        注意: 需要安装piq库或使用opencv实现
        这里使用简化版本
        """
        try:
            import piq
            img_t = torch.from_numpy(img).permute(2, 0, 1).unsqueeze(0).to(self.device)
            niqe_value = piq.niqe(img_t).item()
            return niqe_value
        except:
            print("Warning: NIQE requires 'piq' library. Returning 0.")
            return 0.0
    
    def compute_fid(self, real_images, fake_images):
        """
        计算FID (Frechet Inception Distance)
        需要多张图像,这里提供接口
        
        Args:
            real_images: list of image paths or numpy arrays
            fake_images: list of image paths or numpy arrays
        """
        try:
            from pytorch_fid import fid_score
            # FID需要使用目录路径或特征统计
            print("Warning: FID computation requires pytorch-fid library and image directories.")
            print("Please use fid_score.calculate_fid_given_paths() separately.")
            return 0.0
        except:
            print("Warning: FID computation not available. Install pytorch-fid.")
            return 0.0
    
    def compute_meter(self, img1, img2):
        """
        计算MEt3R (需要MEt3R模型)
        这是一个学习型指标,需要预训练模型
        """
        print("Warning: MEt3R computation requires specific model weights.")
        print("Please refer to MEt3R paper and implementation.")
        return 0.0
    
    def evaluate_image_pair(self, gt_path, rendered_path):
        """
        评估一对图像
        
        Args:
            gt_path: 高分辨率ground truth图像路径
            rendered_path: 渲染的图像路径
        Returns:
            dict: 包含所有评估指标
        """
        print(f"Evaluating: {rendered_path}")
        
        # 加载图像
        gt_img = self.load_image(gt_path)
        rendered_img = self.load_image(rendered_path)
        
        # 确保尺寸一致
        if gt_img.shape != rendered_img.shape:
            print(f"Warning: Image size mismatch. GT: {gt_img.shape}, Rendered: {rendered_img.shape}")
            # 调整rendered_img到gt_img的大小
            rendered_img = cv2.resize(rendered_img, (gt_img.shape[1], gt_img.shape[0]))
        
        # 计算所有指标
        metrics = {
            'PSNR': self.compute_psnr(gt_img, rendered_img),
            'SSIM': self.compute_ssim(gt_img, rendered_img),
            'LPIPS': self.compute_lpips(gt_img, rendered_img),
            'NIQE': self.compute_niqe(rendered_img),  # 无参考指标
        }
        
        return metrics
    
    def evaluate_multiple_views(self, gt_dir, rendered_dir):
        """
        评估多个视角
        
        Args:
            gt_dir: ground truth图像目录
            rendered_dir: 渲染图像目录
        Returns:
            dict: 平均指标
        """
        import glob
        
        # 获取所有图像
        gt_images = sorted(glob.glob(os.path.join(gt_dir, '*.jpg')) + 
                          glob.glob(os.path.join(gt_dir, '*.png')))
        rendered_images = sorted(glob.glob(os.path.join(rendered_dir, '*.jpg')) + 
                                glob.glob(os.path.join(rendered_dir, '*.png')))
        
        if len(gt_images) != len(rendered_images):
            print(f"Warning: Number of images mismatch. GT: {len(gt_images)}, Rendered: {len(rendered_images)}")
        
        all_metrics = []
        
        for gt_path, rendered_path in zip(gt_images, rendered_images):
            metrics = self.evaluate_image_pair(gt_path, rendered_path)
            all_metrics.append(metrics)
        
        # 计算平均值
        avg_metrics = {}
        for key in all_metrics[0].keys():
            avg_metrics[key] = np.mean([m[key] for m in all_metrics])
            avg_metrics[key + '_std'] = np.std([m[key] for m in all_metrics])
        
        return avg_metrics, all_metrics


# ==================== 使用示例 ====================

def main():
    """
    完整流程示例:
    1. 加载原始3DGS
    2. 执行聚类merge
    3. 保存merged模型
    4. 调用渲染(需要外部实现)
    5. 评估图像质量
    """
    
    # ============ Step 1: 配置参数 ============
    config = {
        'original_ply': 'path/to/original_3dgs.ply',
        'merged_ply': 'path/to/merged_3dgs.ply',
        'gt_image_dir': 'path/to/high_res_images',
        'rendered_image_dir': 'path/to/rendered_images',
        'cell_size': 1.0,  # 根据场景大小调整
        'padding_ratio': 0.1,
        'target_points_per_cluster': 3
    }
    
    # ============ Step 2: 执行Merge ============
    print("="*50)
    print("Step 1: Merging Gaussians")
    print("="*50)
    
    merger = GaussianMerger(
        cell_size=config['cell_size'],
        padding_ratio=config['padding_ratio'],
        target_points_per_cluster=config['target_points_per_cluster']
    )
    
    # 加载原始3DGS
    gaussians = merger.load_ply(config['original_ply'])
    
    # 执行merge
    merged_gaussians = merger.merge_all(gaussians)
    
    # 保存结果
    merger.save_ply(merged_gaussians, config['merged_ply'])
    
    # ============ Step 3: 渲染 (需要外部实现) ============
    print("\n" + "="*50)
    print("Step 2: Rendering (Please implement separately)")
    print("="*50)
    print(f"Please use your 3DGS renderer to render images from:")
    print(f"  Model: {config['merged_ply']}")
    print(f"  Output to: {config['rendered_image_dir']}")
    print("\nExample command (using gaussian-splatting):")
    print(f"  python render.py -m {config['merged_ply']} -s <scene_path>")
    
    # ============ Step 4: 评估 ============
    print("\n" + "="*50)
    print("Step 3: Evaluating Image Quality")
    print("="*50)
    
    evaluator = ImageEvaluator()
    
    # 评估多个视角
    avg_metrics, all_metrics = evaluator.evaluate_multiple_views(
        config['gt_image_dir'],
        config['rendered_image_dir']
    )
    
    # 打印结果
    print("\n" + "="*50)
    print("Evaluation Results")
    print("="*50)
    for metric_name, value in avg_metrics.items():
        if not metric_name.endswith('_std'):
            std = avg_metrics.get(metric_name + '_std', 0)
            print(f"{metric_name:10s}: {value:.4f} ± {std:.4f}")
    
    # 保存详细结果
    import json
    results = {
        'config': config,
        'merge_stats': {
            'original_points': len(gaussians['xyz']),
            'merged_points': len(merged_gaussians['xyz']),
            'compression_ratio': len(gaussians['xyz']) / len(merged_gaussians['xyz'])
        },
        'average_metrics': {k: float(v) for k, v in avg_metrics.items()},
        'per_view_metrics': [{k: float(v) for k, v in m.items()} for m in all_metrics]
    }
    
    with open('evaluation_results.json', 'w') as f:
        json.dump(results, f, indent=2)
    
    print(f"\nResults saved to: evaluation_results.json")


if __name__ == "__main__":
    main()