842 lines
34 KiB
Python
842 lines
34 KiB
Python
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()
|