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

edge_detect_method/edge_detect.py

@@ -0,0 +1,841 @@
+import numpy as np
+import pandas as pd
+import spectral
+import cv2
+import os
+from scipy.io import savemat
+from scipy import ndimage
+from scipy.ndimage import gaussian_filter, laplace
+from typing import Optional, Dict, Any, Tuple, List, Union
+from dataclasses import dataclass, field
+import warnings
+warnings.filterwarnings('ignore')
+
+
+@dataclass
+class EdgeDetectionConfig:
+    """边缘检测配置类"""
+
+    # 输入文件配置
+    input_path: Optional[str] = None
+    band_index: int = 0  # 指定的波段索引（从0开始）
+
+    # 输出配置
+    output_path: Optional[str] = None
+    output_dir: Optional[str] = None
+
+    # 边缘检测方法配置
+    method: str = 'canny'
+    kernel_size: int = 3  # 卷积核大小（必须是奇数）
+
+    # 批量处理配置
+    batch_methods: List[str] = field(default_factory=lambda: ['canny'])
+    batch_bands: List[int] = field(default_factory=lambda: [0])
+
+    # Sobel和Scharr参数
+    sobel_dx: int = 1  # x方向导数阶数
+    sobel_dy: int = 0  # y方向导数阶数
+    sobel_ksize: int = -1  # Sobel核大小，-1表示3x3
+
+    # Laplacian参数
+    laplacian_ksize: int = 1  # Laplacian核大小
+    laplacian_scale: float = 1.0  # Laplacian尺度参数
+    laplacian_delta: float = 0.0  # Laplacian delta参数
+
+    # LoG参数
+    log_sigma: float = 1.0  # 高斯标准差
+    log_threshold: float = 0.0  # LoG阈值
+
+    # 梯度算法阈值参数
+    gradient_threshold: float = 0.0  # 梯度阈值（0-255），0表示不使用阈值
+    gradient_use_otsu: bool = False  # 是否对梯度图使用Otsu自动阈值
+    log_mode: str = 'reflect'  # 边界模式：'reflect', 'constant', 'nearest', 'mirror', 'wrap'
+
+    # Canny参数
+    canny_min_threshold: int = 100
+    canny_max_threshold: int = 200
+    canny_aperture_size: int = 3  # Sobel算子孔径大小
+    canny_l2gradient: bool = False  # 是否使用L2范数计算梯度
+
+    # 通用参数
+    normalize_output: bool = False  # 是否将输出归一化到0-255
+    use_blur: bool = False  # 是否预先进行高斯模糊
+    blur_kernel_size: int = 3  # 模糊核大小（必须是奇数）
+    blur_sigma: float = 1.0  # 模糊标准差
+
+    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 not self.output_path and not self.output_dir:
+            raise ValueError("必须指定输出路径(output_path)或输出目录(output_dir)")
+
+        # 校验边缘检测方法
+        supported_methods = self._get_supported_methods()
+        if self.method not in supported_methods:
+            raise ValueError(f"不支持的边缘检测方法: {self.method}。支持的方法: {list(supported_methods.keys())}")
+
+        # 校验批量处理参数
+        if len(self.batch_methods) != len(self.batch_bands):
+            # 如果长度不等，使用广播方式：单个波段对应多个方法，或单个方法对应多个波段
+            if len(self.batch_methods) == 1 and len(self.batch_bands) > 1:
+                # 一个方法应用到多个波段
+                self.batch_methods = self.batch_methods * len(self.batch_bands)
+            elif len(self.batch_bands) == 1 and len(self.batch_methods) > 1:
+                # 一个波段应用多个方法
+                self.batch_bands = self.batch_bands * len(self.batch_methods)
+            else:
+                raise ValueError("batch_methods和batch_bands长度不匹配，请确保其中一个长度为1，或两者长度相等")
+
+        for method in self.batch_methods:
+            if method not in supported_methods:
+                raise ValueError(f"批量处理中包含不支持的方法: {method}")
+
+        # 校验参数
+        self._validate_parameters()
+
+    def _validate_parameters(self):
+        """参数校验"""
+        # 校验核大小
+        if self.kernel_size % 2 == 0 or self.kernel_size < 1:
+            raise ValueError("kernel_size必须是正奇数")
+
+        # 校验Sobel参数
+        if self.sobel_dx < 0 or self.sobel_dy < 0:
+            raise ValueError("sobel_dx和sobel_dy必须是非负整数")
+
+        if self.sobel_dx + self.sobel_dy != 1:
+            raise ValueError(f"sobel_dx({self.sobel_dx}) + sobel_dy({self.sobel_dy}) 必须等于1。有效组合: dx=1,dy=0 或 dx=0,dy=1")
+
+        if self.sobel_ksize != -1 and (self.sobel_ksize % 2 == 0 or self.sobel_ksize < 1):
+            raise ValueError("sobel_ksize必须是正奇数或-1")
+
+        # 校验Laplacian参数
+        if self.laplacian_ksize < 1 or self.laplacian_ksize > 31:
+            raise ValueError("laplacian_ksize必须在1-31之间")
+        if self.laplacian_scale <= 0:
+            raise ValueError("laplacian_scale必须大于0")
+
+        # 校验LoG参数
+        if self.log_sigma <= 0:
+            raise ValueError("log_sigma必须大于0")
+        if self.log_mode not in ['reflect', 'constant', 'nearest', 'mirror', 'wrap']:
+            raise ValueError("log_mode必须是'reflect', 'constant', 'nearest', 'mirror', 'wrap'之一")
+
+        # 校验Canny参数
+        if self.canny_min_threshold < 0 or self.canny_max_threshold < 0:
+            raise ValueError("Canny阈值必须是非负数")
+        if self.canny_min_threshold >= self.canny_max_threshold:
+            raise ValueError("canny_min_threshold必须小于canny_max_threshold")
+        if self.canny_aperture_size not in [3, 5, 7]:
+            raise ValueError("canny_aperture_size必须是3、5或7")
+
+        # 校验梯度阈值参数
+        if self.gradient_threshold < 0 or self.gradient_threshold > 255:
+            raise ValueError("gradient_threshold必须在0-255范围内")
+
+        # 校验通用参数
+        if self.blur_kernel_size % 2 == 0 or self.blur_kernel_size < 1:
+            raise ValueError("blur_kernel_size必须是正奇数")
+        if self.blur_sigma <= 0:
+            raise ValueError("blur_sigma必须大于0")
+
+    def _get_supported_methods(self) -> Dict[str, str]:
+        """获取支持的边缘检测方法列表"""
+        methods = {
+            'sobel': 'Sobel算子',
+            'scharr': 'Scharr算子',
+            'laplacian': 'Laplacian算子',
+            'log': 'Laplacian of Gaussian (LoG)',
+            'canny': 'Canny算子'
+        }
+        return methods
+
+
+class EdgeDetector:
+    """边缘检测处理系统"""
+
+    def __init__(self, config: EdgeDetectionConfig):
+        self.config = config
+
+        # 初始化数据存储
+        self.data = None
+        self.selected_band = None
+        self.original_shape = None
+
+    def load_data(self) -> None:
+        """
+        加载数据文件
+        """
+        print(f"正在加载数据文件: {self.config.input_path}")
+
+        file_ext = os.path.splitext(self.config.input_path)[1].lower()
+
+        if file_ext in ['.dat', '.img', '.hdr']:
+            self._load_hyperspectral_data(self.config.input_path)
+        else:
+            raise ValueError(f"不支持的文件格式: {file_ext}")
+
+        # 提取指定波段
+        self._extract_band(self.config.band_index)
+
+        print("数据加载完成")
+
+    def _load_hyperspectral_data(self, file_path):
+        """加载高光谱图像数据"""
+        base_path = os.path.splitext(file_path)[0]
+        hdr_file = base_path + '.hdr'
+
+        # 读取ENVI格式图像
+        img = spectral.open_image(hdr_file)
+        self.data = img.load()
+        self.original_shape = self.data.shape
+
+        # 转换为二维数组（像素×波段）
+        self.data = self.data.reshape(-1, self.data.shape[2])
+
+    def _extract_band(self, band_index):
+        """提取指定波段"""
+        if band_index >= self.data.shape[1]:
+            raise ValueError(f"波段索引超出范围: {band_index}, 总波段数: {self.data.shape[1]}")
+
+        self.selected_band = self.data[:, band_index].reshape(self.original_shape[0], self.original_shape[1])
+
+    def apply_edge_detection(self) -> Tuple[np.ndarray, Dict[str, Any]]:
+        """
+        应用边缘检测方法
+
+        Returns:
+            Tuple[np.ndarray, Dict[str, Any]]: (边缘检测结果, 附加信息)
+        """
+        print(f"正在应用边缘检测方法: {self.config.method}")
+
+        if self.selected_band is None:
+            raise ValueError("请先加载数据")
+
+        # 归一化图像到0-255范围（大多数OpenCV函数需要）
+        image_normalized = self._normalize_image(self.selected_band)
+
+        # 应用不同的边缘检测方法
+        if self.config.method == 'sobel':
+            result, info = self._sobel_detection(image_normalized)
+
+        elif self.config.method == 'scharr':
+            result, info = self._scharr_detection(image_normalized)
+
+        elif self.config.method == 'laplacian':
+            result, info = self._laplacian_detection(image_normalized)
+
+        elif self.config.method == 'log':
+            result, info = self._log_detection(self.selected_band)  # LoG使用原始数据
+
+        elif self.config.method == 'canny':
+            result, info = self._canny_detection(image_normalized)
+
+        else:
+            raise ValueError(f"不支持的边缘检测方法: {self.config.method}")
+
+        # 归一化输出
+        if self.config.normalize_output:
+            result = self._normalize_output(result)
+
+        return result.astype(np.uint8), info
+
+    def _normalize_image(self, image):
+        """将图像归一化到0-255范围"""
+        image_min, image_max = np.min(image), np.max(image)
+        if image_max > image_min:
+            return ((image - image_min) / (image_max - image_min) * 255).astype(np.uint8)
+        else:
+            return image.astype(np.uint8)
+
+    def _normalize_output(self, image):
+        """将输出归一化到0-255范围"""
+        image_min, image_max = np.min(image), np.max(image)
+        if image_max > image_min:
+            return ((image - image_min) / (image_max - image_min) * 255).astype(np.uint8)
+        else:
+            return (image * 255).astype(np.uint8)
+
+    def _apply_gradient_threshold(self, gradient_image, method_name):
+        """对梯度图像应用阈值处理"""
+        if self.config.gradient_threshold > 0:
+            # 使用固定阈值
+            _, thresholded = cv2.threshold(gradient_image, self.config.gradient_threshold, 255, cv2.THRESH_BINARY)
+            print(f"{method_name} 使用固定阈值: {self.config.gradient_threshold}")
+            return thresholded
+        elif self.config.gradient_use_otsu:
+            # 使用Otsu自动阈值
+            _, thresholded = cv2.threshold(gradient_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+            print(f"{method_name} 使用Otsu自动阈值")
+            return thresholded
+        else:
+            # 不使用阈值，直接返回梯度图像
+            return gradient_image
+
+    def _sobel_detection(self, image):
+        """Sobel边缘检测"""
+        # 预处理：高斯模糊
+        if self.config.use_blur:
+            image = cv2.GaussianBlur(image, (self.config.blur_kernel_size, self.config.blur_kernel_size), self.config.blur_sigma)
+
+        # 校验Sobel参数：OpenCV要求dx+dy == 1
+        if self.config.sobel_dx + self.config.sobel_dy != 1:
+            raise ValueError(f"Sobel参数错误: dx({self.config.sobel_dx}) + dy({self.config.sobel_dy}) 必须等于1。有效组合: dx=1,dy=0 或 dx=0,dy=1")
+
+        # 计算梯度
+        grad = cv2.Sobel(image, cv2.CV_64F, self.config.sobel_dx, self.config.sobel_dy, ksize=self.config.sobel_ksize)
+
+        # 计算梯度幅值（如果是混合梯度）
+        if self.config.sobel_dx == 1 and self.config.sobel_dy == 1:
+            grad_magnitude = cv2.convertScaleAbs(grad)
+        else:
+            # 对于单方向梯度，直接使用绝对值
+            grad_magnitude = cv2.convertScaleAbs(grad)
+
+        # 应用阈值处理（可选）
+        grad_magnitude = self._apply_gradient_threshold(grad_magnitude, 'Sobel')
+
+        info = {
+            'grad': grad,
+            'method': 'Sobel',
+            'parameters': {
+                'dx': self.config.sobel_dx,
+                'dy': self.config.sobel_dy,
+                'ksize': self.config.sobel_ksize,
+                'use_blur': self.config.use_blur,
+                'blur_kernel_size': self.config.blur_kernel_size if self.config.use_blur else None,
+                'blur_sigma': self.config.blur_sigma if self.config.use_blur else None,
+                'gradient_threshold': self.config.gradient_threshold,
+                'gradient_use_otsu': self.config.gradient_use_otsu
+            }
+        }
+
+        return grad_magnitude, info
+
+    def _scharr_detection(self, image):
+        """Scharr边缘检测"""
+        # 预处理：高斯模糊
+        if self.config.use_blur:
+            image = cv2.GaussianBlur(image, (self.config.blur_kernel_size, self.config.blur_kernel_size), self.config.blur_sigma)
+
+        # Scharr算子是特殊的3x3 Sobel算子
+        grad_x = cv2.Scharr(image, cv2.CV_64F, 1, 0)
+        grad_y = cv2.Scharr(image, cv2.CV_64F, 0, 1)
+
+        # 计算梯度幅值
+        grad_magnitude = cv2.magnitude(grad_x, grad_y)
+
+        # 转换为uint8
+        grad_magnitude = cv2.convertScaleAbs(grad_magnitude)
+
+        # 应用阈值处理（可选）
+        grad_magnitude = self._apply_gradient_threshold(grad_magnitude, 'Scharr')
+
+        info = {
+            'grad_x': grad_x,
+            'grad_y': grad_y,
+            'method': 'Scharr',
+            'parameters': {
+                'use_blur': self.config.use_blur,
+                'blur_kernel_size': self.config.blur_kernel_size if self.config.use_blur else None,
+                'blur_sigma': self.config.blur_sigma if self.config.use_blur else None,
+                'gradient_threshold': self.config.gradient_threshold,
+                'gradient_use_otsu': self.config.gradient_use_otsu
+            }
+        }
+
+        return grad_magnitude, info
+
+    def _laplacian_detection(self, image):
+        """Laplacian边缘检测"""
+        # 预处理：高斯模糊
+        if self.config.use_blur:
+            image = cv2.GaussianBlur(image, (self.config.blur_kernel_size, self.config.blur_kernel_size), self.config.blur_sigma)
+
+        # 应用Laplacian算子
+        laplacian = cv2.Laplacian(image, cv2.CV_64F, ksize=self.config.laplacian_ksize,
+                                 scale=self.config.laplacian_scale, delta=self.config.laplacian_delta)
+
+        # 取绝对值并转换为uint8
+        laplacian_abs = cv2.convertScaleAbs(laplacian)
+
+        # 应用阈值处理（可选）
+        laplacian_abs = self._apply_gradient_threshold(laplacian_abs, 'Laplacian')
+
+        info = {
+            'laplacian': laplacian,
+            'method': 'Laplacian',
+            'parameters': {
+                'ksize': self.config.laplacian_ksize,
+                'scale': self.config.laplacian_scale,
+                'delta': self.config.laplacian_delta,
+                'use_blur': self.config.use_blur,
+                'blur_kernel_size': self.config.blur_kernel_size if self.config.use_blur else None,
+                'blur_sigma': self.config.blur_sigma if self.config.use_blur else None,
+                'gradient_threshold': self.config.gradient_threshold,
+                'gradient_use_otsu': self.config.gradient_use_otsu
+            }
+        }
+
+        return laplacian_abs, info
+
+    def _log_detection(self, image):
+        """Laplacian of Gaussian (LoG) 边缘检测"""
+        # 使用指定的边界模式进行高斯滤波
+        gaussian_filtered = gaussian_filter(image.astype(np.float64),
+                                          sigma=self.config.log_sigma,
+                                          mode=self.config.log_mode)
+
+        # 应用Laplacian算子
+        log_result = laplace(gaussian_filtered, mode=self.config.log_mode)
+
+        # 取绝对值
+        log_abs = np.abs(log_result)
+
+        # 应用阈值
+        if self.config.log_threshold > 0:
+            log_abs = (log_abs > self.config.log_threshold).astype(np.uint8) * 255
+        else:
+            # 自动阈值：使用Otsu方法
+            # 先归一化到0-255范围，然后应用Otsu
+            log_min, log_max = np.min(log_abs), np.max(log_abs)
+            if log_max > log_min:
+                log_normalized = ((log_abs - log_min) / (log_max - log_min) * 255).astype(np.uint8)
+            else:
+                log_normalized = log_abs.astype(np.uint8)
+
+            _, log_abs = cv2.threshold(log_normalized, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+
+        info = {
+            'gaussian_filtered': gaussian_filtered,
+            'log_result': log_result,
+            'method': 'LoG',
+            'parameters': {
+                'sigma': self.config.log_sigma,
+                'threshold': self.config.log_threshold,
+                'mode': self.config.log_mode
+            }
+        }
+
+        return log_abs.astype(np.uint8), info
+
+    def _canny_detection(self, image):
+        """Canny边缘检测"""
+        # 预处理：高斯模糊
+        if self.config.use_blur:
+            image = cv2.GaussianBlur(image, (self.config.blur_kernel_size, self.config.blur_kernel_size), self.config.blur_sigma)
+
+        # 应用Canny算子
+        edges = cv2.Canny(image,
+                         self.config.canny_min_threshold,
+                         self.config.canny_max_threshold,
+                         apertureSize=self.config.canny_aperture_size,
+                         L2gradient=self.config.canny_l2gradient)
+
+        info = {
+            'method': 'Canny',
+            'parameters': {
+                'min_threshold': self.config.canny_min_threshold,
+                'max_threshold': self.config.canny_max_threshold,
+                'aperture_size': self.config.canny_aperture_size,
+                'L2gradient': self.config.canny_l2gradient,
+                'use_blur': self.config.use_blur,
+                'blur_kernel_size': self.config.blur_kernel_size if self.config.use_blur else None,
+                'blur_sigma': self.config.blur_sigma if self.config.use_blur else None
+            }
+        }
+
+        return edges, info
+
+    def save_results(self, edge_data, info, output_path, method):
+        """
+        保存边缘检测结果
+
+        参数:
+            edge_data: 边缘检测结果
+            info: 附加信息
+            output_path: 输出路径
+            method: 使用的边缘检测方法
+        """
+        output_base = os.path.splitext(output_path)[0]
+
+        # 保存.dat文件
+        self._save_dat_file(edge_data, output_path)
+
+        # 保存.hdr头文件
+        hdr_path = output_base + '.hdr'
+        self._save_hdr_file(hdr_path, edge_data.shape, method, info)
+
+        print(f"边缘检测结果已保存: {output_path}")
+        print(f"头文件已保存: {hdr_path}")
+        print(f"使用的检测方法: {method}")
+
+    def _save_dat_file(self, data, file_path):
+        """保存.dat文件（二进制格式）"""
+        with open(file_path, 'wb') as f:
+            data.astype(np.uint8).tofile(f)
+
+    def _save_hdr_file(self, hdr_path, data_shape, method, info):
+        """保存ENVI头文件"""
+        header_content = f"""ENVI
+description = {{{method} Edge Detection Result}}
+samples = {data_shape[1]}
+lines = {data_shape[0]}
+bands = 1
+header offset = 0
+file type = ENVI Standard
+data type = 1
+interleave = bsq
+byte order = 0
+band names = {{Edge_Detection_Result}}
+classes = 2
+class names = {{Background, Edges}}
+class lookup = {{0,0,0, 255,255,255}}
+"""
+
+        # 添加方法参数信息
+        if 'parameters' in info and info['parameters']:
+            params_str = ', '.join([f'{k}:{v}' for k, v in info['parameters'].items()])
+            header_content += f"edge_detection_parameters = {{{params_str}}}\n"
+
+        header_content += f"edge_detection_method = {method}\n"
+
+        with open(hdr_path, 'w', encoding='utf-8') as f:
+            f.write(header_content)
+
+    def batch_process(self, methods, bands, output_dir):
+        """
+        批量处理多个边缘检测方法
+
+        参数:
+            methods: 边缘检测方法列表
+            bands: 波段索引列表
+            output_dir: 输出目录
+        """
+        os.makedirs(output_dir, exist_ok=True)
+
+        # 显示数据信息
+        if self.data is not None:
+            print(f"\n=== 数据信息 ===")
+            print(f"图像尺寸: {self.original_shape[0]}x{self.original_shape[1]}")
+            print(f"波段数: {self.original_shape[2]}")
+
+        results = {}
+        for method, band_idx in zip(methods, bands):
+            print(f"\n正在处理: {method} (波段: {band_idx})")
+
+            try:
+                # 临时修改配置以适应当前方法和波段
+                original_method = self.config.method
+                original_band = self.config.band_index
+
+                self.config.method = method
+                self.config.band_index = band_idx
+
+                # 重新提取波段
+                self._extract_band(band_idx)
+
+                # 应用边缘检测
+                edge_data, info = self.apply_edge_detection()
+
+                # 恢复原始配置
+                self.config.method = original_method
+                self.config.band_index = original_band
+
+                # 保存结果
+                output_path = os.path.join(output_dir, f'edge_{method}_band{band_idx}.dat')
+                self.save_results(edge_data, info, output_path, method)
+
+                results[method] = {
+                    'data': edge_data,
+                    'info': info,
+                    'band': band_idx
+                }
+
+            except Exception as e:
+                print(f"处理 {method} 时出错: {str(e)}")
+
+        return results
+
+    @staticmethod
+    def print_method_info():
+        """
+        打印所有可用边缘检测方法的详细信息
+        """
+        method_info = {
+            'sobel': {
+                'name': 'Sobel算子 (Sobel Operator)',
+                'description': '使用Sobel核计算图像梯度，检测边缘',
+                'advantages': ['计算简单', '对噪声有一定抑制', '可以检测边缘方向'],
+                'limitations': ['对噪声敏感', '检测到的边缘较粗'],
+                'best_for': ['一般边缘检测', '需要方向信息的应用'],
+                'parameters': ['sobel_dx', 'sobel_dy', 'sobel_ksize', 'use_blur', 'blur_kernel_size', 'blur_sigma', 'gradient_threshold', 'gradient_use_otsu']
+            },
+            'scharr': {
+                'name': 'Scharr算子 (Scharr Operator)',
+                'description': '改进的Sobel算子，具有更好的旋转不变性',
+                'advantages': ['比Sobel算子更精确', '更好的旋转不变性'],
+                'limitations': ['计算量稍大', '只适用于3x3核'],
+                'best_for': ['需要高精度边缘检测的应用'],
+                'parameters': ['use_blur', 'blur_kernel_size', 'blur_sigma', 'gradient_threshold', 'gradient_use_otsu']
+            },
+            'laplacian': {
+                'name': 'Laplacian算子 (Laplacian Operator)',
+                'description': '基于二阶导数的边缘检测方法，对灰度突变敏感',
+                'advantages': ['对灰度突变敏感', '计算简单'],
+                'limitations': ['对噪声非常敏感', '不能提供边缘方向信息'],
+                'best_for': ['检测灰度突变明显的边缘'],
+                'parameters': ['laplacian_ksize', 'laplacian_scale', 'laplacian_delta', 'use_blur', 'blur_kernel_size', 'blur_sigma', 'gradient_threshold', 'gradient_use_otsu']
+            },
+            'log': {
+                'name': 'Laplacian of Gaussian (LoG)',
+                'description': '先进行高斯平滑，再应用Laplacian算子',
+                'advantages': ['减少噪声影响', '检测不同尺度边缘', '理论基础扎实'],
+                'limitations': ['计算复杂度高', '参数选择重要'],
+                'best_for': ['需要抑制噪声的边缘检测', '学术研究'],
+                'parameters': ['log_sigma', 'log_threshold', 'log_mode']
+            },
+            'canny': {
+                'name': 'Canny算子 (Canny Edge Detector)',
+                'description': '多阶段边缘检测算法，包括平滑、梯度计算、非最大抑制和双阈值处理',
+                'advantages': ['检测精度高', '抗噪声能力强', '单像素边缘'],
+                'limitations': ['计算复杂度较高', '参数调节复杂'],
+                'best_for': ['高质量边缘检测', '计算机视觉应用'],
+                'parameters': ['canny_min_threshold', 'canny_max_threshold', 'canny_aperture_size', 'canny_l2gradient', 'use_blur', 'blur_kernel_size', 'blur_sigma']
+            }
+        }
+
+        print("\n=== 边缘检测方法详细说明 ===\n")
+
+        for method, info in method_info.items():
+            print(f"{method} - {info['name']}")
+            print(f"  描述: {info['description']}")
+            print(f"  优势: {', '.join(info['advantages'])}")
+            print(f"  局限性: {', '.join(info['limitations'])}")
+            print(f"  适用场景: {', '.join(info['best_for'])}")
+            if 'parameters' in info:
+                print(f"  可调参数: {', '.join(info['parameters'])}")
+            print()
+
+def main():
+    """主函数：命令行接口"""
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description='高光谱图像边缘检测工具',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+使用示例:
+  1. 使用Canny算子检测边缘:
+     python edge_detect.py input.hdr -m canny -b 50 -o edge_result.dat
+
+  2. 批量应用多种边缘检测方法:
+     python edge_detect.py input.hdr -m sobel scharr laplacian log canny -B 25 25 25 25 25 -d results/
+
+  3. 使用自定义参数的Sobel检测:
+     python edge_detect.py input.hdr -m sobel -b 30 --sobel-dx 1 --sobel-dy 0 --use-blur --blur-kernel-size 5
+
+支持的边缘检测方法:
+  sobel:    Sobel算子
+  scharr:   Scharr算子
+  laplacian: Laplacian算子
+  log:      Laplacian of Gaussian (LoG)
+  canny:    Canny算子
+
+批量处理:
+  -m 指定多个方法，-B 指定对应波段索引
+  -d 指定输出目录
+        """
+    )
+
+    parser.add_argument('input_path', help='输入高光谱图像文件路径 (.hdr)')
+    parser.add_argument('-m', '--methods', nargs='+', required=True,
+                       choices=['sobel', 'scharr', 'laplacian', 'log', 'canny'],
+                       help='边缘检测方法 (可指定多个)')
+    parser.add_argument('-b', '--band-index', type=int, default=0,
+                       help='波段索引 (默认: 0)')
+    parser.add_argument('-B', '--batch-bands', nargs='+', type=int,
+                       help='批量处理的波段索引列表 (与methods一一对应)')
+    parser.add_argument('-o', '--output', help='单个方法输出文件路径')
+    parser.add_argument('-d', '--output-dir', default='edge_detection_results',
+                       help='批量处理输出目录 (默认: edge_detection_results)')
+
+    # Sobel和Scharr参数
+    parser.add_argument('--sobel-dx', type=int, default=1, choices=[0, 1],
+                       help='Sobel x方向导数阶数，必须与sobel-dy之和等于1 (默认: 1)')
+    parser.add_argument('--sobel-dy', type=int, default=0, choices=[0, 1],
+                       help='Sobel y方向导数阶数，必须与sobel-dx之和等于1 (默认: 0)')
+    parser.add_argument('--sobel-ksize', type=int, default=-1,
+                       help='Sobel核大小，-1表示3x3 (默认: -1)')
+
+    # Laplacian参数
+    parser.add_argument('--laplacian-ksize', type=int, default=1,
+                       help='Laplacian核大小 (默认: 1)')
+    parser.add_argument('--laplacian-scale', type=float, default=1.0,
+                       help='Laplacian尺度参数 (默认: 1.0)')
+    parser.add_argument('--laplacian-delta', type=float, default=0.0,
+                       help='Laplacian delta参数 (默认: 0.0)')
+
+    # LoG参数
+    parser.add_argument('--log-sigma', type=float, default=1.0,
+                       help='LoG高斯标准差 (默认: 1.0)')
+    parser.add_argument('--log-threshold', type=float, default=0.0,
+                       help='LoG阈值，0表示自动阈值 (默认: 0.0)')
+    parser.add_argument('--log-mode', default='reflect',
+                       choices=['reflect', 'constant', 'nearest', 'mirror', 'wrap'],
+                       help='LoG边界模式 (默认: reflect)')
+
+    # 梯度算法阈值参数
+    parser.add_argument('--gradient-threshold', type=float, default=0.0,
+                       help='梯度阈值 (0-255)，0表示不使用阈值 (默认: 0.0)')
+    parser.add_argument('--gradient-use-otsu', action='store_true',
+                       help='对梯度图使用Otsu自动阈值')
+
+    # Canny参数
+    parser.add_argument('--canny-min-threshold', type=int, default=100,
+                       help='Canny最小阈值 (默认: 100)')
+    parser.add_argument('--canny-max-threshold', type=int, default=200,
+                       help='Canny最大阈值 (默认: 200)')
+    parser.add_argument('--canny-aperture-size', type=int, default=3, choices=[3, 5, 7],
+                       help='Canny Sobel算子孔径大小 (默认: 3)')
+    parser.add_argument('--canny-l2gradient', action='store_true',
+                       help='Canny使用L2范数计算梯度')
+
+    # 通用参数
+    parser.add_argument('--normalize-output', action='store_true',
+                       help='将输出归一化到0-255范围')
+    parser.add_argument('--use-blur', action='store_true',
+                       help='预先进行高斯模糊')
+    parser.add_argument('--blur-kernel-size', type=int, default=3,
+                       help='模糊核大小，必须是奇数 (默认: 3)')
+    parser.add_argument('--blur-sigma', type=float, default=1.0,
+                       help='模糊标准差 (默认: 1.0)')
+
+    # 其他选项
+    parser.add_argument('--show-methods', action='store_true',
+                       help='显示所有可用方法的详细信息')
+
+    args = parser.parse_args()
+
+    # 显示方法信息
+    if args.show_methods:
+        EdgeDetector.print_method_info()
+        return 0
+
+    try:
+        print("=" * 60)
+        print("高光谱图像边缘检测工具")
+        print("=" * 60)
+        print(f"输入文件: {args.input_path}")
+        print(f"检测方法: {', '.join(args.methods)}")
+        print(f"波段索引: {args.band_index}")
+        print()
+
+        # 确定是单方法还是批量处理
+        if len(args.methods) == 1:
+            # 单方法处理
+            print("执行单方法边缘检测...")
+
+            config = EdgeDetectionConfig(
+                input_path=args.input_path,
+                band_index=args.band_index,
+                method=args.methods[0],
+                output_path=args.output,
+                # 参数设置
+                sobel_dx=args.sobel_dx,
+                sobel_dy=args.sobel_dy,
+                sobel_ksize=args.sobel_ksize,
+                laplacian_ksize=args.laplacian_ksize,
+                laplacian_scale=args.laplacian_scale,
+                laplacian_delta=args.laplacian_delta,
+                log_sigma=args.log_sigma,
+                log_threshold=args.log_threshold,
+                log_mode=args.log_mode,
+                gradient_threshold=args.gradient_threshold,
+                gradient_use_otsu=args.gradient_use_otsu,
+                canny_min_threshold=args.canny_min_threshold,
+                canny_max_threshold=args.canny_max_threshold,
+                canny_aperture_size=args.canny_aperture_size,
+                canny_l2gradient=args.canny_l2gradient,
+                normalize_output=args.normalize_output,
+                use_blur=args.use_blur,
+                blur_kernel_size=args.blur_kernel_size,
+                blur_sigma=args.blur_sigma
+            )
+
+            detector = EdgeDetector(config)
+            detector.load_data()
+            edge_data, info = detector.apply_edge_detection()
+
+            output_path = args.output or f"edge_{args.methods[0]}_band{args.band_index}.dat"
+            detector.save_results(edge_data, info, output_path, args.methods[0])
+
+        else:
+            # 批量处理
+            print("执行批量边缘检测...")
+
+            # 确定波段列表
+            if args.batch_bands:
+                if len(args.batch_bands) != len(args.methods):
+                    raise ValueError(f"波段数量 ({len(args.batch_bands)}) 必须与方法数量 ({len(args.methods)}) 相等")
+                bands = args.batch_bands
+            else:
+                # 如果没有指定波段，使用默认波段
+                bands = [args.band_index] * len(args.methods)
+
+            # 创建基础配置
+            config = EdgeDetectionConfig(
+                input_path=args.input_path,
+                band_index=args.band_index,  # 这个会被batch_process覆盖
+                method=args.methods[0],  # 这个会被batch_process覆盖
+                output_dir=args.output_dir,
+                # 参数设置
+                sobel_dx=args.sobel_dx,
+                sobel_dy=args.sobel_dy,
+                sobel_ksize=args.sobel_ksize,
+                laplacian_ksize=args.laplacian_ksize,
+                laplacian_scale=args.laplacian_scale,
+                laplacian_delta=args.laplacian_delta,
+                log_sigma=args.log_sigma,
+                log_threshold=args.log_threshold,
+                log_mode=args.log_mode,
+                gradient_threshold=args.gradient_threshold,
+                gradient_use_otsu=args.gradient_use_otsu,
+                canny_min_threshold=args.canny_min_threshold,
+                canny_max_threshold=args.canny_max_threshold,
+                canny_aperture_size=args.canny_aperture_size,
+                canny_l2gradient=args.canny_l2gradient,
+                normalize_output=args.normalize_output,
+                use_blur=args.use_blur,
+                blur_kernel_size=args.blur_kernel_size,
+                blur_sigma=args.blur_sigma
+            )
+
+            detector = EdgeDetector(config)
+            detector.load_data()
+            results = detector.batch_process(args.methods, bands, args.output_dir)
+
+        print("\n" + "=" * 60)
+        print("边缘检测完成!")
+        print("=" * 60)
+
+    except Exception as e:
+        print(f"✗ 处理失败: {e}")
+        import traceback
+        traceback.print_exc()
+        return 1
+
+    return 0
+
+
+
+
+if __name__ == "__main__":
+    main()