增加模块；增加主调用命令

Anomaly_method/RX.py

@@ -0,0 +1,883 @@
+import numpy as np
+import pandas as pd
+import spectral
+from sklearn.preprocessing import StandardScaler
+from sklearn.covariance import EmpiricalCovariance, MinCovDet
+import os
+import warnings
+from typing import Optional, Dict, Any, Tuple, List, Union
+from dataclasses import dataclass, field
+import argparse
+from pathlib import Path
+from scipy import stats, linalg
+import cv2
+warnings.filterwarnings('ignore')
+
+
+@dataclass
+class RXConfig:
+    """RX异常检测配置类"""
+
+    # 输入文件配置
+    input_path: Optional[str] = None
+    background_path: Optional[str] = None  # 用户指定背景数据
+    label_col: Optional[str] = None
+    spectral_start: Optional[str] = None
+    spectral_end: Optional[str] = None
+    csv_has_header: bool = True
+
+    # 输出配置
+    output_path: Optional[str] = None
+    output_dir: Optional[str] = None
+
+    # 背景模型配置
+    background_model: str = 'global'  # 'global', 'local_row', 'local_square', 'custom'
+    window_size: int = 5  # 局部窗口大小
+    row_window: int = 3  # 行窗口大小（行数）
+
+    # 检测参数
+    threshold: Optional[float] = None  # 异常检测阈值，None表示不进行阈值分割
+    contamination: float = 0.1  # 异常点比例，用于自动确定阈值
+    use_robust_covariance: bool = False  # 是否使用稳健协方差估计
+
+    # 数据预处理配置
+    use_scaling: bool = False  # 是否使用标准化（RX算法通常不使用）
+
+    def __post_init__(self):
+        """参数校验和默认值设置"""
+        # 校验必需的文件路径
+        if not self.input_path:
+            raise ValueError("必须指定输入文件路径(input_path)")
+
+        # 校验文件存在性
+        if not os.path.exists(self.input_path):
+            raise FileNotFoundError(f"输入文件不存在: {self.input_path}")
+
+        if self.background_path and not os.path.exists(self.background_path):
+            raise FileNotFoundError(f"背景文件不存在: {self.background_path}")
+
+        # 校验输出路径
+        if not self.output_path and not self.output_dir:
+            raise ValueError("必须指定输出路径(output_path)或输出目录(output_dir)")
+
+        # 校验背景模型类型
+        supported_models = ['global', 'local_row', 'local_square', 'custom']
+        if self.background_model not in supported_models:
+            raise ValueError(f"不支持的背景模型: {self.background_model}。支持的模型: {supported_models}")
+
+        # 校验参数范围
+        if self.window_size <= 0:
+            raise ValueError("window_size必须大于0")
+
+        if self.row_window <= 0:
+            raise ValueError("row_window必须大于0")
+
+        if self.background_model == 'custom' and not self.background_path:
+            raise ValueError("使用custom背景模型时，必须指定background_path")
+
+
+class RXAnomalyDetector:
+    """
+    Reed-Xiaoli (RX) 异常检测器
+
+    RX算法基于Mahalanobis距离检测高光谱数据中的异常像素。
+    算法计算每个像素相对于背景分布的距离，距离越大的像素越可能是异常。
+
+    数学基础：
+    D(x) = (x - μ)ᵀ K⁻¹ (x - μ)
+
+    其中：
+    - x: 测试像素的光谱向量
+    - μ: 背景数据的均值向量
+    - K: 背景数据的协方差矩阵
+    """
+
+    def __init__(self, config: RXConfig):
+        """
+        初始化RX异常检测器
+
+        Args:
+            config: 配置对象
+        """
+        self.config = config
+        self.data = None
+        self.background_data = None
+        self.wavelengths = None
+        self.data_shape = None
+        self.input_format = None
+
+        # 背景统计量
+        self.background_mean = None
+        self.background_cov = None
+        self.background_inv_cov = None
+
+        # 结果
+        self.distance_map = None  # Mahalanobis距离图
+        self.anomaly_map = None  # 异常检测结果
+
+        # 预处理组件
+        self.scaler = None
+
+    def load_data(self) -> None:
+        """
+        加载高光谱数据文件
+
+        支持CSV和ENVI格式文件
+        """
+        file_path = Path(self.config.input_path)
+        suffix = file_path.suffix.lower()
+
+        print(f"正在读取输入数据: {file_path}")
+
+        if suffix == '.csv':
+            self._load_csv_data(file_path, is_background=False)
+        elif suffix in ['.hdr']:
+            self._load_envi_data(file_path, is_background=False)
+        else:
+            raise ValueError(f"不支持的文件格式: {suffix}。支持的格式: .hdr")
+
+        # 加载背景数据
+        if self.config.background_model == 'custom':
+            self._load_background_data()
+
+    def _load_csv_data(self, file_path: Path, is_background: bool = False) -> None:
+        """加载CSV格式数据"""
+        if self.config.spectral_start is None:
+            raise ValueError("对于CSV文件，必须指定spectral_start参数")
+
+        # 读取数据
+        df = pd.read_csv(file_path, header=0 if self.config.csv_has_header else None)
+
+        # 提取标签列
+        if self.config.label_col and self.config.label_col in df.columns:
+            labels = df[self.config.label_col].values
+            spectral_cols = [col for col in df.columns if col != self.config.label_col]
+        else:
+            labels = None
+            spectral_cols = df.columns.tolist()
+
+        # 提取光谱数据
+        if self.config.spectral_end:
+            end_idx = spectral_cols.index(self.config.spectral_end) + 1
+        else:
+            end_idx = len(spectral_cols)
+
+        start_idx = spectral_cols.index(self.config.spectral_start)
+        spectral_data = df[spectral_cols[start_idx:end_idx]].values
+
+        # 生成波长信息
+        wavelengths = np.arange(len(spectral_cols[start_idx:end_idx]))
+
+        # 存储数据
+        if is_background:
+            self.background_data = spectral_data.astype(np.float32)
+            print(f"背景数据加载完成: {self.background_data.shape} 样本 x {self.background_data.shape[1]} 波段")
+        else:
+            self.data = spectral_data.astype(np.float32)
+            self.data_shape = self.data.shape
+            self.input_format = 'csv'
+            self.wavelengths = wavelengths
+            print(f"输入数据加载完成: {self.data.shape} 样本 x {self.data.shape[1]} 波段")
+
+    def _load_envi_data(self, file_path: Path, is_background: bool = False) -> None:
+        """加载ENVI格式数据"""
+        try:
+            # 确保文件路径存在且可访问
+            file_path = Path(file_path)
+            if not file_path.exists():
+                raise FileNotFoundError(f"ENVI文件不存在: {file_path}")
+
+            # 检查文件是否可读
+            if not os.access(file_path, os.R_OK):
+                raise PermissionError(f"没有读取权限: {file_path}")
+
+            # 使用规范化的路径字符串
+            file_path_str = str(file_path)
+            print(f"尝试使用spectral库读取ENVI文件: {file_path_str}")
+
+            # 检查对应的头文件
+            hdr_path = file_path.with_suffix(file_path.suffix + '.hdr')
+            if not hdr_path.exists():
+                # 尝试 .hdr 格式
+                hdr_path = file_path.with_suffix('.hdr')
+                if not hdr_path.exists():
+                    print(f"警告: 未找到头文件 {file_path.with_suffix(file_path.suffix + '.hdr')} 或 {file_path.with_suffix('.hdr')}")
+
+            # 读取ENVI文件 - 使用规范化的路径
+            envi_data = spectral.open_image(file_path_str)
+
+            # 获取数据数组
+            print("正在加载数据到内存...")
+            data_array = envi_data.load()
+
+            # 获取波长信息
+            if hasattr(envi_data, 'bands') and hasattr(envi_data.bands, 'centers'):
+                wavelengths = np.array(envi_data.bands.centers)
+                print(f"读取到波长信息: {len(wavelengths)} 个波段")
+            else:
+                wavelengths = np.arange(data_array.shape[2])
+                print(f"未找到波长信息，使用默认波长: 0-{len(wavelengths)-1}")
+
+            # 重塑数据为 (samples, bands)
+            rows, cols, bands = data_array.shape
+            spectral_data = data_array.reshape(-1, bands).astype(np.float32)
+
+            # 存储数据
+            if is_background:
+                self.background_data = spectral_data
+                print(f"背景数据加载完成: {rows}x{cols} 像素 x {bands} 波段")
+            else:
+                self.data = spectral_data
+                self.data_shape = (rows, cols, bands)
+                self.input_format = 'envi'
+                self.wavelengths = wavelengths
+                print(f"输入数据加载完成: {rows}x{cols} 像素 x {bands} 波段")
+
+        except Exception as e:
+            raise ValueError(f"读取ENVI文件失败: {str(e)}。请确保spectral库可用且文件格式正确。")
+
+    def _load_background_data(self) -> None:
+        """加载用户指定的背景数据"""
+        if not self.config.background_path:
+            raise ValueError("background_path未指定")
+
+        file_path = Path(self.config.background_path)
+        suffix = file_path.suffix.lower()
+
+        print(f"正在读取背景数据: {file_path}")
+
+        if suffix == '.csv':
+            self._load_csv_data(file_path, is_background=True)
+        elif suffix in ['.bil', '.bsq', '.bip', '.dat']:
+            self._load_envi_data(file_path, is_background=True)
+        else:
+            raise ValueError(f"不支持的背景文件格式: {suffix}")
+
+    def preprocess_data(self) -> None:
+        """
+        数据预处理
+
+        RX算法通常不需要标准化，除非指定
+        """
+        if self.config.use_scaling:
+            print("正在标准化数据...")
+            self.scaler = StandardScaler()
+
+            # 对输入数据进行标准化
+            if self.data is not None:
+                self.data = self.scaler.fit_transform(self.data)
+
+            # 对背景数据进行相同的标准化
+            if self.background_data is not None:
+                self.background_data = self.scaler.transform(self.background_data)
+
+    def compute_background_statistics(self) -> None:
+        """
+        计算背景统计量（均值和协方差矩阵）
+
+        根据不同的背景模型计算相应的统计量
+        """
+        print(f"正在计算背景统计量 (模型: {self.config.background_model})...")
+
+        if self.config.background_model == 'global':
+            self._compute_global_background()
+        elif self.config.background_model == 'custom':
+            self._compute_custom_background()
+        # 局部模型的统计量在检测过程中计算
+
+    def _compute_global_background(self) -> None:
+        """计算全局背景统计量"""
+        # 使用整个数据集作为背景
+        background_data = self.data
+
+        if self.config.use_robust_covariance:
+            # 使用稳健协方差估计
+            cov_estimator = MinCovDet()
+            cov_estimator.fit(background_data)
+            self.background_mean = cov_estimator.location_
+            self.background_cov = cov_estimator.covariance_
+        else:
+            # 使用经验协方差
+            self.background_mean = np.mean(background_data, axis=0)
+            self.background_cov = np.cov(background_data.T)
+
+        # 计算协方差矩阵的逆
+        try:
+            self.background_inv_cov = linalg.inv(self.background_cov)
+        except np.linalg.LinAlgError:
+            print("警告: 协方差矩阵奇异，使用伪逆")
+            self.background_inv_cov = linalg.pinv(self.background_cov)
+
+        print(f"全局背景统计量计算完成，协方差矩阵形状: {self.background_cov.shape}")
+
+    def _compute_custom_background(self) -> None:
+        """计算用户指定背景统计量"""
+        if self.background_data is None:
+            raise ValueError("自定义背景数据未加载")
+
+        background_data = self.background_data
+
+        if self.config.use_robust_covariance:
+            cov_estimator = MinCovDet()
+            cov_estimator.fit(background_data)
+            self.background_mean = cov_estimator.location_
+            self.background_cov = cov_estimator.covariance_
+        else:
+            self.background_mean = np.mean(background_data, axis=0)
+            self.background_cov = np.cov(background_data.T)
+
+        # 计算协方差矩阵的逆
+        try:
+            self.background_inv_cov = linalg.inv(self.background_cov)
+        except np.linalg.LinAlgError:
+            print("警告: 协方差矩阵奇异，使用伪逆")
+            self.background_inv_cov = linalg.pinv(self.background_cov)
+
+        print(f"自定义背景统计量计算完成，协方差矩阵形状: {self.background_cov.shape}")
+
+    def _compute_local_background_stats(self, data_window: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """
+        计算局部背景统计量
+
+        Args:
+            data_window: 局部窗口数据 (n_pixels, n_bands)
+
+        Returns:
+            mean_vector, cov_matrix, inv_cov_matrix
+        """
+        # 移除窗口中的NaN值
+        valid_mask = ~np.isnan(data_window).any(axis=1)
+        valid_data = data_window[valid_mask]
+
+        if len(valid_data) < 2:
+            # 数据不足，返回全局统计量
+            return self.background_mean, self.background_cov, self.background_inv_cov
+
+        if self.config.use_robust_covariance and len(valid_data) > self.background_cov.shape[0]:
+            # 使用稳健协方差估计
+            cov_estimator = MinCovDet()
+            cov_estimator.fit(valid_data)
+            mean_vec = cov_estimator.location_
+            cov_mat = cov_estimator.covariance_
+        else:
+            # 使用经验协方差
+            mean_vec = np.mean(valid_data, axis=0)
+            cov_mat = np.cov(valid_data.T)
+
+        # 计算协方差矩阵的逆
+        try:
+            inv_cov_mat = linalg.inv(cov_mat)
+        except np.linalg.LinAlgError:
+            inv_cov_mat = linalg.pinv(cov_mat)
+
+        return mean_vec, cov_mat, inv_cov_mat
+
+    def compute_mahalanobis_distance(self, x: np.ndarray, mean_vec: np.ndarray,
+                                   inv_cov_mat: np.ndarray) -> float:
+        """
+        计算单个像素的Mahalanobis距离
+
+        Args:
+            x: 像素光谱向量
+            mean_vec: 均值向量
+            inv_cov_mat: 协方差矩阵的逆
+
+        Returns:
+            Mahalanobis距离
+        """
+        diff = x - mean_vec
+        distance = np.dot(np.dot(diff, inv_cov_mat), diff.T)
+
+        # 确保距离为非负实数
+        return max(0, distance)
+
+    def detect_anomalies_global(self) -> np.ndarray:
+        """
+        使用全局背景模型进行异常检测
+
+        Returns:
+            距离图 (n_samples,)
+        """
+        print("正在进行全局RX异常检测...")
+
+        n_samples = self.data.shape[0]
+        distance_map = np.zeros(n_samples, dtype=np.float32)
+
+        # 对每个像素计算Mahalanobis距离
+        for i in range(n_samples):
+            distance_map[i] = self.compute_mahalanobis_distance(
+                self.data[i], self.background_mean, self.background_inv_cov
+            )
+
+        return distance_map
+
+    def detect_anomalies_local_row(self) -> np.ndarray:
+        """
+        使用局部行背景模型进行异常检测
+
+        Returns:
+            距离图 (rows, cols)
+        """
+        print("正在进行局部行RX异常检测...")
+
+        rows, cols, bands = self.data_shape
+        distance_map = np.zeros((rows, cols), dtype=np.float32)
+
+        # 将数据重塑为2D图像
+        image_data = self.data.reshape(rows, cols, bands)
+
+        half_window = self.config.row_window // 2
+
+        for i in range(rows):
+            # 计算行窗口范围
+            row_start = max(0, i - half_window)
+            row_end = min(rows, i + half_window + 1)
+
+            # 提取行窗口数据
+            row_window = image_data[row_start:row_end, :, :].reshape(-1, bands)
+
+            # 计算局部背景统计量
+            local_mean, local_cov, local_inv_cov = self._compute_local_background_stats(row_window)
+
+            # 计算当前行的距离
+            for j in range(cols):
+                pixel = image_data[i, j, :]
+                distance_map[i, j] = self.compute_mahalanobis_distance(
+                    pixel, local_mean, local_inv_cov
+                )
+
+        return distance_map.flatten()
+
+    def detect_anomalies_local_square(self) -> np.ndarray:
+        """
+        使用局部正方形背景模型进行异常检测
+
+        Returns:
+            距离图 (rows, cols)
+        """
+        print("正在进行局部正方形RX异常检测...")
+
+        rows, cols, bands = self.data_shape
+        distance_map = np.zeros((rows, cols), dtype=np.float32)
+
+        # 将数据重塑为2D图像
+        image_data = self.data.reshape(rows, cols, bands)
+
+        half_window = self.config.window_size // 2
+
+        # 使用向量化计算优化性能
+        for i in range(rows):
+            for j in range(cols):
+                # 计算窗口范围
+                row_start = max(0, i - half_window)
+                row_end = min(rows, i + half_window + 1)
+                col_start = max(0, j - half_window)
+                col_end = min(cols, j + half_window + 1)
+
+                # 提取窗口数据
+                window_data = image_data[row_start:row_end, col_start:col_end, :].reshape(-1, bands)
+
+                # 计算局部背景统计量
+                local_mean, local_cov, local_inv_cov = self._compute_local_background_stats(window_data)
+
+                # 计算当前像素的距离
+                pixel = image_data[i, j, :]
+                distance_map[i, j] = self.compute_mahalanobis_distance(
+                    pixel, local_mean, local_inv_cov
+                )
+
+        return distance_map.flatten()
+
+    def detect_anomalies(self) -> np.ndarray:
+        """
+        执行异常检测
+
+        Returns:
+            Mahalanobis距离图
+        """
+        if self.config.background_model == 'global':
+            self.compute_background_statistics()
+            distance_map = self.detect_anomalies_global()
+        elif self.config.background_model == 'local_row':
+            distance_map = self.detect_anomalies_local_row()
+        elif self.config.background_model == 'local_square':
+            distance_map = self.detect_anomalies_local_square()
+        elif self.config.background_model == 'custom':
+            self.compute_background_statistics()
+            distance_map = self.detect_anomalies_global()
+
+        self.distance_map = distance_map
+
+        # 应用阈值分割（如果指定）
+        if self.config.threshold is not None:
+            self.anomaly_map = (distance_map > self.config.threshold).astype(np.int32)
+        else:
+            self.anomaly_map = None
+
+        # 统计信息
+        mean_dist = np.mean(distance_map)
+        std_dist = np.std(distance_map)
+        max_dist = np.max(distance_map)
+
+        print("异常检测完成:")
+        print(".4f")
+        print(".4f")
+        print(".4f")
+
+        if self.anomaly_map is not None:
+            n_anomalies = np.sum(self.anomaly_map)
+            anomaly_ratio = n_anomalies / len(distance_map)
+            print(".3f")
+
+        return distance_map
+
+    def run_analysis_from_config(self) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        从配置运行完整的异常检测分析
+
+        Returns:
+            Tuple[np.ndarray, np.ndarray]: (predictions, scores)
+        """
+        # 执行异常检测，获取距离图作为分数
+        scores = self.detect_anomalies()
+
+        # 生成预测结果（基于阈值或百分位数）
+        if self.config.threshold is not None:
+            predictions = (scores > self.config.threshold).astype(np.int32)
+        else:
+            # 使用contamination参数确定阈值
+            # contamination表示异常比例，所以使用(1-contamination)*100百分位数
+            percentile = (1 - self.config.contamination) * 100
+            threshold = np.percentile(scores, percentile)
+            predictions = (scores > threshold).astype(np.int32)
+
+        return predictions, scores
+
+    def save_results(self, output_path: Optional[str] = None) -> None:
+        """
+        保存异常检测结果为ENVI格式文件
+
+        Args:
+            output_path: 输出文件路径，如果为None则使用配置中的路径
+        """
+        if output_path is None:
+            if self.config.output_path:
+                output_path = self.config.output_path
+            elif self.config.output_dir:
+                base_name = Path(self.config.input_path).stem
+                output_path = os.path.join(self.config.output_dir, f"{base_name}_rx_anomaly.bip")
+            else:
+                raise ValueError("必须指定输出路径")
+
+        print(f"正在保存结果到: {output_path}")
+
+        # 创建输出目录
+        output_dir = os.path.dirname(output_path)
+        os.makedirs(output_dir, exist_ok=True)
+
+        # 根据输入格式决定输出格式
+        if self.input_format == 'envi':
+            self._save_envi_results(output_path)
+        else:
+            # 对于CSV输入，创建虚拟的2D图像
+            self._save_csv_results_as_envi(output_path)
+
+    def _save_envi_results(self, output_path: str) -> None:
+        """保存ENVI格式结果"""
+        # 重塑距离图为原始图像尺寸
+        rows, cols, bands = self.data_shape
+
+        # 创建单波段异常检测结果图像
+        if self.anomaly_map is not None:
+            # 保存异常检测结果 (0/1)
+            anomaly_image = np.zeros((rows, cols, 1), dtype=np.float32)
+            anomaly_image[:, :, 0] = self.anomaly_map.reshape(rows, cols)
+            band_names = ["Anomaly_Map"]
+        else:
+            # 保存距离图
+            anomaly_image = np.zeros((rows, cols, 1), dtype=np.float32)
+            anomaly_image[:, :, 0] = self.distance_map.reshape(rows, cols)
+            band_names = ["Mahalanobis_Distance"]
+
+        # 保存为ENVI格式，参考Covariance.py的方式
+        self._save_envi_data(anomaly_image, output_path, band_names, 'bip')
+
+    def _save_csv_results_as_envi(self, output_path: str) -> None:
+        """将CSV结果保存为ENVI格式"""
+        # 对于CSV数据，创建1xN的单波段图像
+        n_samples = len(self.distance_map)
+        if self.anomaly_map is not None:
+            anomaly_image = np.zeros((1, n_samples, 1), dtype=np.float32)
+            anomaly_image[0, :, 0] = self.anomaly_map
+            band_names = ["Anomaly_Map"]
+        else:
+            anomaly_image = np.zeros((1, n_samples, 1), dtype=np.float32)
+            anomaly_image[0, :, 0] = self.distance_map
+            band_names = ["Mahalanobis_Distance"]
+
+        # 保存为ENVI格式，参考Covariance.py的方式
+        self._save_envi_data(anomaly_image, output_path, band_names, 'bip')
+
+    def _save_envi_data(self, data: np.ndarray, output_path: Union[str, Path],
+                       band_names: List[str], interleave: str = 'bip') -> None:
+        """
+        保存数据为ENVI格式，参考Covariance.py的实现
+
+        参数:
+            data: 要保存的数据数组 (height, width, channels)
+            output_path: 输出文件路径
+            band_names: 波段名称列表
+            interleave: 交织方式 ('bip', 'bil', 'bsq')
+        """
+        output_path = Path(output_path)
+        height, width, channels = data.shape
+
+        # 确保目录存在
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        print(f"保存ENVI文件 - 形状: {data.shape}, 交织方式: {interleave}")
+
+        # 保存.dat文件（二进制格式）
+        self._save_dat_file(data, str(output_path))
+
+        # 保存.hdr头文件
+        hdr_path = str(output_path).replace('.dat', '.hdr')
+        self._save_hdr_file(hdr_path, data.shape, band_names, interleave)
+
+        print(f"RX异常检测结果已保存: {output_path}")
+        print(f"头文件已保存: {hdr_path}")
+        print(f"使用的交织格式: {interleave.upper()}")
+
+    def _save_dat_file(self, data: np.ndarray, file_path: str) -> None:
+        """保存.dat文件（二进制格式），参考Covariance.py"""
+        # 根据数据类型保存
+        if data.dtype == np.float32:
+            # 对于浮点数据，直接保存
+            with open(file_path, 'wb') as f:
+                data.astype(np.float32).tofile(f)
+        else:
+            # 对于其他数据类型，转换为float32保存
+            with open(file_path, 'wb') as f:
+                data.astype(np.float32).tofile(f)
+
+    def _save_hdr_file(self, hdr_path: str, data_shape: Tuple[int, ...],
+                      band_names: List[str], interleave: str) -> None:
+        """保存ENVI头文件，参考Covariance.py并适配RX数据"""
+        height, width, channels = data_shape
+
+        # 确定数据类型编码
+        # ENVI数据类型: 4=float32, 5=float64, 1=uint8, 2=int16, 3=int32, 12=uint16
+        data_type_code = 4  # 默认float32
+
+        header_content = f"""ENVI
+description = {{RX Anomaly Detection Results - Generated by RXAnomalyDetector}}
+samples = {width}
+lines = {height}
+bands = {channels}
+header offset = 0
+file type = ENVI Standard
+data type = {data_type_code}
+interleave = {interleave}
+byte order = 0
+"""
+
+        # 添加波段名称
+        if band_names:
+            header_content += "band names = {\n"
+            for i, name in enumerate(band_names):
+                header_content += f'  "{name}"'
+                if i < len(band_names) - 1:
+                    header_content += ","
+                header_content += "\n"
+            header_content += "}\n"
+
+        # 添加RX相关元数据
+        header_content += f"anomaly_detection_method = rx\n"
+        header_content += f"background_model = {self.config.background_model}\n"
+        if self.config.background_model in ['local_row', 'local_square']:
+            header_content += f"window_size = {self.config.window_size}\n"
+            if self.config.background_model == 'local_row':
+                header_content += f"row_window = {self.config.row_window}\n"
+        if self.config.threshold is not None:
+            header_content += f"threshold = {self.config.threshold}\n"
+        header_content += f"use_robust_covariance = {self.config.use_robust_covariance}\n"
+
+        with open(hdr_path, 'w', encoding='utf-8') as f:
+            f.write(header_content)
+
+    def get_statistics(self) -> Dict[str, Any]:
+        """
+        获取异常检测统计信息
+
+        Returns:
+            包含各种统计信息的字典
+        """
+        if self.distance_map is None:
+            raise ValueError("请先运行异常检测")
+
+        stats = {
+            'total_pixels': len(self.distance_map),
+            'background_model': self.config.background_model,
+            'mean_distance': float(np.mean(self.distance_map)),
+            'std_distance': float(np.std(self.distance_map)),
+            'min_distance': float(np.min(self.distance_map)),
+            'max_distance': float(np.max(self.distance_map)),
+            'median_distance': float(np.median(self.distance_map))
+        }
+
+        # 计算分位数
+        for percentile in [25, 75, 90, 95, 99]:
+            stats[f'percentile_{percentile}'] = float(np.percentile(self.distance_map, percentile))
+
+        if self.anomaly_map is not None:
+            stats['threshold'] = self.config.threshold
+            stats['n_anomalies'] = int(np.sum(self.anomaly_map))
+            stats['anomaly_ratio'] = float(np.sum(self.anomaly_map) / len(self.distance_map))
+
+        return stats
+
+    def suggest_threshold(self, method: str = 'percentile') -> float:
+        """
+        建议异常检测阈值
+
+        Args:
+            method: 阈值建议方法 ('percentile', 'mean_std', 'auto')
+
+        Returns:
+            建议的阈值
+        """
+        if self.distance_map is None:
+            raise ValueError("请先运行异常检测")
+
+        if method == 'percentile':
+            # 使用95%分位数作为阈值
+            threshold = np.percentile(self.distance_map, 95)
+        elif method == 'mean_std':
+            # 使用均值+2倍标准差作为阈值
+            mean_dist = np.mean(self.distance_map)
+            std_dist = np.std(self.distance_map)
+            threshold = mean_dist + 2 * std_dist
+        elif method == 'auto':
+            # 使用自动阈值选择（基于卡方分布）
+            # 对于高维数据，自由度近似为波段数
+            n_bands = self.data.shape[1]
+            # 使用卡方分布的95%分位数
+            threshold = stats.chi2.ppf(0.95, n_bands)
+        else:
+            raise ValueError(f"不支持的阈值建议方法: {method}")
+
+        return float(threshold)
+
+
+def main():
+    """主函数：命令行接口"""
+    parser = argparse.ArgumentParser(
+        description='Reed-Xiaoli (RX) 高光谱异常检测',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+使用示例:
+  python RX.py --input image.bip --background-model global --output results.bip
+  python RX.py --input data.csv --spectral-start 400 --background-model local_square --window-size 7 --output results.bip
+  python RX.py --input image.bip --background-model custom --background background.bip --threshold 10.0 --output results.bip
+
+背景模型说明:
+  global: 使用整个数据集作为背景
+  local_row: 使用像素周围N行的窗口作为背景
+  local_square: 使用固定大小的正方形窗口作为背景
+  custom: 使用外部提供的背景数据
+        """
+    )
+
+    # 输入文件参数
+    parser.add_argument('--input', required=True, help='输入文件路径 (CSV或ENVI格式)')
+    parser.add_argument('--background', help='背景数据路径 (custom模式时必需)')
+    parser.add_argument('--label-col', help='标签列名 (CSV文件)')
+    parser.add_argument('--spectral-start', help='光谱数据起始列名或波长 (CSV文件)')
+    parser.add_argument('--spectral-end', help='光谱数据结束列名或波长 (CSV文件)')
+
+    # 输出参数
+    parser.add_argument('--output', help='输出文件路径')
+    parser.add_argument('--output-dir', help='输出目录 (将自动生成文件名)')
+
+    # 背景模型参数
+    parser.add_argument('--background-model', choices=['global', 'local_row', 'local_square', 'custom'],
+                       default='global', help='背景模型类型，默认global')
+    parser.add_argument('--window-size', type=int, default=5,
+                       help='局部窗口大小，默认5')
+    parser.add_argument('--row-window', type=int, default=3,
+                       help='行窗口大小，默认3')
+
+    # 检测参数
+    parser.add_argument('--threshold', type=float,
+                       help='异常检测阈值，不指定则只输出距离图')
+    parser.add_argument('--robust-covariance', action='store_true',
+                       help='使用稳健协方差估计')
+
+    args = parser.parse_args()
+
+    try:
+        # 创建配置
+        config = RXConfig(
+            input_path=args.input,
+            background_path=args.background,
+            label_col=args.label_col,
+            spectral_start=args.spectral_start,
+            spectral_end=args.spectral_end,
+            output_path=args.output,
+            output_dir=args.output_dir,
+            background_model=args.background_model,
+            window_size=args.window_size,
+            row_window=args.row_window,
+            threshold=args.threshold,
+            use_robust_covariance=args.robust_covariance
+        )
+
+        # 创建检测器
+        detector = RXAnomalyDetector(config)
+
+        # 执行异常检测流程
+        print("=== Reed-Xiaoli (RX) 异常检测 ===")
+        print(f"输入文件: {config.input_path}")
+        print(f"背景模型: {config.background_model}")
+        if config.background_model in ['local_row', 'local_square']:
+            print(f"窗口大小: {config.window_size}")
+        if config.threshold is not None:
+            print(f"检测阈值: {config.threshold}")
+        print("-" * 50)
+
+        # 1. 加载数据
+        detector.load_data()
+
+        # 2. 预处理数据
+        detector.preprocess_data()
+
+        # 3. 执行异常检测
+        distance_map = detector.detect_anomalies()
+
+        # 4. 阈值建议
+        if config.threshold is None:
+            suggested_threshold = detector.suggest_threshold('percentile')
+            print(f"\n建议阈值 (95百分位数): {suggested_threshold:.4f}")
+
+        # 5. 保存结果
+        detector.save_results()
+
+        # 6. 显示统计信息
+        stats = detector.get_statistics()
+        print("\n=== 检测结果统计 ===")
+        for key, value in stats.items():
+            print(f"{key}: {value}")
+
+        print("\n处理完成！")
+
+    except Exception as e:
+        print(f"错误: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    exit(main())