fff文件导入、居于框选区域进行校色和导出功能

[Link1565]

自己改了一点代码，支持fff文件导入，和添加框选功能，方便直接导入整条的冲扫文件进行校色，然后导出框选部分的图片。如果不嫌弃我代码写的烂的话，我可以提供我的代码供参考：）

[V7CN]

欢迎pull进来！或者贴给我也行，这个功能真的非常非常实用，可能还考虑后续加一个代理照片更新的功能（框选后框选部分提升分辨率）。

[Link1565]

目前项目还没稳定，不好直接提交代码，我这里直接贴上整理好的代码和说明：

框选功能核心代码整理
📋 功能概述
为DiVERE项目实现了完整的交互式框选功能，包括：

• 交互式框选区域创建：按住左键拖拽创建红色虚线框
• 框选区域拖动移动：点击边线拖动整个区域
• 框选区域边角调整大小：点击边角调整区域尺寸
• 实时光标样式变换：专业的视觉反馈
• 框选区域保存裁剪：保存时自动裁剪选定区域

🔧 主要修改文件

1. divere/ui/preview_widget.py- 核心交互逻辑
   PreviewCanvas框选区域绘制相关

class PreviewCanvas(QLabel):
    """自绘制画布：基于 pan/zoom 稳定绘制，不改变自身尺寸"""
    def __init__(self):
        super().__init__()
        self._source_pixmap: Optional[QPixmap] = None
        self._zoom: float = 1.0
        self._pan_x: float = 0.0
        self._pan_y: float = 0.0
        # 简单缩放缓存以提升性能
        self._scaled_pixmap: Optional[QPixmap] = None
        self._scaled_zoom: float = 1.0
        
        # 框选功能相关
        self._selection_rect: Optional[QRect] = None
        self._show_selection: bool = False

    def set_source_pixmap(self, pixmap: QPixmap) -> None:
        self._source_pixmap = pixmap
        # 清空文本避免覆盖
        self.setText("")
        # 源变更需重建缩放缓存
        self._scaled_pixmap = None
        self._scaled_zoom = 1.0
        self.update()

    def set_view(self, zoom: float, pan_x: float, pan_y: float) -> None:
        self._zoom = float(zoom)
        self._pan_x = float(pan_x)
        self._pan_y = float(pan_y)
        self.update()
    
    def set_selection_rect(self, rect: Optional[QRect], show: bool = True) -> None:
        """设置框选区域"""
        self._selection_rect = rect
        self._show_selection = show
        self.update()
    
    def clear_selection(self) -> None:
        """清除框选区域"""
        self._selection_rect = None
        self._show_selection = False
        self.update()

    def _ensure_scaled_cache(self) -> None:
        if self._source_pixmap is None:
            self._scaled_pixmap = None
            return
        # 仅在缩放不为1时缓存
        if abs(self._zoom - 1.0) < 1e-6:
            self._scaled_pixmap = None
            self._scaled_zoom = 1.0
            return
        # 使用不取整的绘制缩放路径，暂不生成缓存，避免滚轮缩放时跳动
        self._scaled_pixmap = None
        return
        # 超大尺寸时放弃缓存，避免内存/卡顿（直接使用绘制时缩放）
        if target_w <= 0 or target_h <= 0:
            self._scaled_pixmap = None
            return
        if target_w > 4096 or target_h > 4096 or target_w * target_h > 16_000_000:
            self._scaled_pixmap = None
            return
        if self._scaled_pixmap is None or self._scaled_zoom != self._zoom:
            self._scaled_pixmap = self._source_pixmap.scaled(
                target_w, target_h,
                Qt.AspectRatioMode.IgnoreAspectRatio,
                Qt.TransformationMode.SmoothTransformation,
            )
            self._scaled_zoom = self._zoom

    def paintEvent(self, event):
        # 先让 QLabel 按样式绘制背景
        super().paintEvent(event)
        if self._source_pixmap is None:
            return
        painter = QPainter(self)
        painter.setRenderHint(QPainter.RenderHint.SmoothPixmapTransform, True)
        painter.translate(QPointF(self._pan_x, self._pan_y))
        # 为避免滚轮缩放时因缓存缩放尺寸取整导致的锚点漂移，这里统一走绘制时缩放路径
        painter.scale(self._zoom, self._zoom)
        painter.drawPixmap(0, 0, self._source_pixmap)
        
        # 绘制框选区域
        if self._show_selection and self._selection_rect is not None:
            # 恢复到屏幕坐标系绘制框选
            painter.resetTransform()
            
            # 将图像坐标转换为屏幕坐标
            screen_rect = QRect(
                int(self._selection_rect.x() * self._zoom + self._pan_x),
                int(self._selection_rect.y() * self._zoom + self._pan_y),
                int(self._selection_rect.width() * self._zoom),
                int(self._selection_rect.height() * self._zoom)
            )
            
            # 绘制虚线边框（只有边框，无填充）
            pen = QPen(QColor(255, 0, 0, 255), 2)  # 红色边框
            pen.setStyle(Qt.PenStyle.DashLine)  # 虚线样式
            painter.setPen(pen)
            painter.setBrush(QBrush())  # 无填充
            painter.drawRect(screen_rect)
            
        painter.end()

新增状态变量（在PreviewWidget的init方法中）

# 框选功能相关状态变量
self.selection_mode = False  # 框选模式开关
self.selecting = False  # 正在框选
self.selection_dragging = False  # 拖动框选区域
self.selection_resizing = False  # 调整框选区域大小
self.selection_start = None  # 框选起始点
self.selection_current = None  # 框选当前点
self.selection_drag_start = None  # 拖动起始点
self.selection_rect_backup = None  # 拖动前的框选区域备份
self.resize_handle = None  # 调整大小的句柄类型

启用鼠标跟踪（在_setup_mouse_controls方法中）

def _setup_mouse_controls(self):
    """设置鼠标控制"""
    # 启用鼠标跟踪，这样即使没有按下鼠标也能接收鼠标移动事件
    self.image_label.setMouseTracking(True)
    
    # 将鼠标事件绑定到image_label而不是scroll_area
    self.image_label.wheelEvent = self._wheel_event
    self.image_label.mousePressEvent = self._mouse_press_event
    self.image_label.mouseMoveEvent = self._mouse_move_event
    self.image_label.mouseReleaseEvent = self._mouse_release_event
    
    # 设置鼠标样式
    self.image_label.setCursor(QCursor(Qt.CursorShape.ArrowCursor))

框选模式设置方法

def set_selection_mode(self, enabled: bool):
    """设置框选模式"""
    print(f"PreviewWidget设置框选模式: {enabled}")  # 调试信息
    self.selection_mode = enabled
    if enabled:
        print("设置十字光标")  # 调试信息
        self.image_label.setCursor(QCursor(Qt.CursorShape.CrossCursor))
    else:
        print("设置箭头光标")  # 调试信息
        self.image_label.setCursor(QCursor(Qt.CursorShape.ArrowCursor))
        self.clear_selection()

清除选择方法

def clear_selection(self):
    """清除当前框选"""
    self.selecting = False
    self.selection_dragging = False
    self.selection_resizing = False
    self.selection_start = None
    self.selection_current = None
    self.selection_drag_start = None
    self.selection_rect_backup = None
    self.resize_handle = None
    if hasattr(self, 'image_label') and hasattr(self.image_label, 'clear_selection'):
        self.image_label.clear_selection()

交互类型检测方法

def _get_selection_interaction_type(self, mouse_pos):
    """检测鼠标在框选区域的交互类型
    返回: ('corner', handle) 边角调整大小
         ('edge', None) 边线移动
         (None, None) 不在边缘
    """
    selection_rect = self._get_current_selection_rect()
    if not selection_rect:
        return None, None
    
    # 转换鼠标坐标到图像坐标
    image_pos = self._screen_to_image_coords(mouse_pos)
    if not image_pos:
        return None, None
    
    x, y = image_pos.x(), image_pos.y()
    
    # 容差设置
    corner_tolerance = 8  # 边角检测容差
    edge_tolerance = 5    # 边线检测容差
    
    rect_left = selection_rect.left()
    rect_top = selection_rect.top()
    rect_right = selection_rect.right()
    rect_bottom = selection_rect.bottom()
    
    # 检测边角（优先级更高）
    # 左上角
    if (abs(x - rect_left) <= corner_tolerance and 
        abs(y - rect_top) <= corner_tolerance):
        return 'corner', 'top-left'
    
    # 右上角
    if (abs(x - rect_right) <= corner_tolerance and 
        abs(y - rect_top) <= corner_tolerance):
        return 'corner', 'top-right'
    
    # 左下角
    if (abs(x - rect_left) <= corner_tolerance and 
        abs(y - rect_bottom) <= corner_tolerance):
        return 'corner', 'bottom-left'
    
    # 右下角
    if (abs(x - rect_right) <= corner_tolerance and 
        abs(y - rect_bottom) <= corner_tolerance):
        return 'corner', 'bottom-right'
    
    # 检测边线
    # 左边线
    if (abs(x - rect_left) <= edge_tolerance and 
        rect_top + corner_tolerance <= y <= rect_bottom - corner_tolerance):
        return 'edge', 'left'
    
    # 右边线
    if (abs(x - rect_right) <= edge_tolerance and 
        rect_top + corner_tolerance <= y <= rect_bottom - corner_tolerance):
        return 'edge', 'right'
    
    # 上边线
    if (abs(y - rect_top) <= edge_tolerance and 
        rect_left + corner_tolerance <= x <= rect_right - corner_tolerance):
        return 'edge', 'top'
    
    # 下边线
    if (abs(y - rect_bottom) <= edge_tolerance and 
        rect_left + corner_tolerance <= x <= rect_right - corner_tolerance):
        return 'edge', 'bottom'
    
    return None, None

光标样式映射方法

def _get_cursor_for_interaction(self, interaction_type, handle):
    """根据交互类型获取对应的光标样式"""
    if interaction_type == 'corner':
        if handle in ['top-left', 'bottom-right']:
            return Qt.CursorShape.SizeFDiagCursor  # 斜向调整大小
        elif handle in ['top-right', 'bottom-left']:
            return Qt.CursorShape.SizeBDiagCursor  # 反斜向调整大小
    elif interaction_type == 'edge':
        # 边线统一使用四方向移动光标
        return Qt.CursorShape.SizeAllCursor    # 四方向移动光标
    
    return Qt.CursorShape.CrossCursor

智能光标更新方法

def _update_cursor_for_current_position(self):
    """根据当前鼠标位置更新光标样式"""
    if not self.selection_mode:
        self.image_label.setCursor(QCursor(Qt.CursorShape.ArrowCursor))
        return
    
    # 获取当前鼠标位置
    current_pos = self.image_label.mapFromGlobal(self.image_label.cursor().pos())
    interaction_type, handle = self._get_selection_interaction_type(current_pos)
    
    if interaction_type:
        # 鼠标在框选区域边缘或边角，显示对应光标
        cursor = self._get_cursor_for_interaction(interaction_type, handle)
        self.image_label.setCursor(QCursor(cursor))
        print(f"释放后光标更新: {interaction_type} - {handle} -> {cursor}")
    else:
        # 鼠标不在边缘，显示十字光标
        self.image_label.setCursor(QCursor(Qt.CursorShape.CrossCursor))
        print("释放后光标更新: CrossCursor")

框选区域大小调整方法

def _resize_selection_rect(self, current_pos):
    """调整框选区域大小"""
    if not self.selection_rect_backup or not self.resize_handle:
        return
    
    # 获取原始矩形的边界
    orig_left = self.selection_rect_backup.left()
    orig_top = self.selection_rect_backup.top()
    orig_right = self.selection_rect_backup.right()
    orig_bottom = self.selection_rect_backup.bottom()
    
    # 根据拖拽的角点调整矩形
    if self.resize_handle == 'top-left':
        new_left = current_pos.x()
        new_top = current_pos.y()
        new_right = orig_right
        new_bottom = orig_bottom
    elif self.resize_handle == 'top-right':
        new_left = orig_left
        new_top = current_pos.y()
        new_right = current_pos.x()
        new_bottom = orig_bottom
    elif self.resize_handle == 'bottom-left':
        new_left = current_pos.x()
        new_top = orig_top
        new_right = orig_right
        new_bottom = current_pos.y()
    elif self.resize_handle == 'bottom-right':
        new_left = orig_left
        new_top = orig_top
        new_right = current_pos.x()
        new_bottom = current_pos.y()
    else:
        return
    
    # 确保矩形有效（最小尺寸10x10）
    if abs(new_right - new_left) < 10 or abs(new_bottom - new_top) < 10:
        return
    
    # 确保左上角在右下角的左上方
    final_left = min(new_left, new_right)
    final_top = min(new_top, new_bottom)
    final_right = max(new_left, new_right)
    final_bottom = max(new_top, new_bottom)
    
    # 更新框选区域坐标
    self.selection_start = QPoint(final_left, final_top)
    self.selection_current = QPoint(final_right, final_bottom)
    
    # 更新显示
    selection_rect = QRect(final_left, final_top, 
                         final_right - final_left, 
                         final_bottom - final_top)
    self.image_label.set_selection_rect(selection_rect, True)

鼠标事件处理方法
鼠标按下事件：

def _mouse_press_event(self, event):
    """鼠标按下事件"""
    if event.button() == Qt.MouseButton.LeftButton:
        if self.selection_mode:
            # 检查鼠标在框选区域的交互类型
            interaction_type, handle = self._get_selection_interaction_type(event.pos())
            
            if interaction_type and self._get_current_selection_rect():
                if interaction_type == 'corner':
                    # 开始调整框选区域大小
                    self.selection_resizing = True
                    self.selection_drag_start = event.pos()
                    self.selection_rect_backup = self._get_current_selection_rect()
                    self.resize_handle = handle
                    cursor = self._get_cursor_for_interaction(interaction_type, handle)
                    self.image_label.setCursor(QCursor(cursor))
                    print(f"开始调整框选区域大小: {handle}")
                elif interaction_type == 'edge':
                    # 开始拖动框选区域
                    self.selection_dragging = True
                    self.selection_drag_start = event.pos()
                    self.selection_rect_backup = self._get_current_selection_rect()
                    self.image_label.setCursor(QCursor(Qt.CursorShape.ClosedHandCursor))
                    print("开始拖动框选区域")
            else:
                # 框选模式：开始新的框选
                # 清除之前的框选显示
                self.clear_selection()
                
                # 转换屏幕坐标到图像坐标
                image_pos = self._screen_to_image_coords(event.pos())
                if image_pos:
                    self.selecting = True
                    self.selection_start = image_pos
                    self.selection_current = image_pos
                    print(f"开始框选: ({image_pos.x()}, {image_pos.y()})")
        else:
            # 普通拖动模式
            self.dragging = True
            self.last_mouse_pos = event.pos()
            self.drag_start_pos = event.pos()
            self.original_pan_pos = (self.pan_x, self.pan_y)
            
            # 设置拖动时的鼠标样式
            self.image_label.setCursor(QCursor(Qt.CursorShape.ClosedHandCursor))
    
    event.accept()

鼠标移动事件：

def _mouse_move_event(self, event):
    """鼠标移动事件"""
    if self.selection_resizing:
        # 调整框选区域大小
        if self.selection_drag_start and self.selection_rect_backup and self.resize_handle:
            current_pos = self._screen_to_image_coords(event.pos())
            if current_pos:
                self._resize_selection_rect(current_pos)
                
    elif self.selection_dragging:
        # 拖动框选区域
        if self.selection_drag_start and self.selection_rect_backup:
            # 计算鼠标移动的偏移量（在图像坐标系中）
            current_pos = self._screen_to_image_coords(event.pos())
            start_pos = self._screen_to_image_coords(self.selection_drag_start)
            
            if current_pos and start_pos:
                dx = current_pos.x() - start_pos.x()
                dy = current_pos.y() - start_pos.y()
                
                # 应用偏移到原始框选区域
                new_left = self.selection_rect_backup.left() + dx
                new_top = self.selection_rect_backup.top() + dy
                
                # 更新框选区域坐标
                self.selection_start = QPoint(new_left, new_top)
                self.selection_current = QPoint(
                    new_left + self.selection_rect_backup.width(),
                    new_top + self.selection_rect_backup.height()
                )
                
                # 更新显示
                selection_rect = QRect(new_left, new_top, 
                                     self.selection_rect_backup.width(),
                                     self.selection_rect_backup.height())
                self.image_label.set_selection_rect(selection_rect, True)
                
    elif self.selecting:
        # 框选模式：更新当前框选区域
        image_pos = self._screen_to_image_coords(event.pos())
        if image_pos:
            self.selection_current = image_pos
            
            # 计算框选区域
            if self.selection_start:
                x1, y1 = self.selection_start.x(), self.selection_start.y()
                x2, y2 = self.selection_current.x(), self.selection_current.y()
                
                left = min(x1, x2)
                top = min(y1, y2)
                width = abs(x2 - x1)
                height = abs(y2 - y1)
                
                # 只有当框选区域足够大时才显示
                if width > 5 and height > 5:
                    # 更新画布上的框选显示
                    selection_rect = QRect(left, top, width, height)
                    self.image_label.set_selection_rect(selection_rect, True)
                
    elif self.dragging and self.last_mouse_pos:
        # 普通拖动模式
        delta = event.pos() - self.last_mouse_pos
        
        # 直接更新平移偏移
        # 使用浮点累加，避免取整抖动
        self.pan_x += float(delta.x())
        self.pan_y += float(delta.y())

        # 边界约束（M3）
        self._clamp_pan()
        
        # 更新显示
        self._update_display()
        
        self.last_mouse_pos = event.pos()
    
    # 在框选模式下实时更新光标样式
    if (self.selection_mode and 
        not self.selection_dragging and 
        not self.selection_resizing and 
        not self.selecting):
        
        interaction_type, handle = self._get_selection_interaction_type(event.pos())
        if interaction_type:
            # 鼠标在框选区域边缘或边角，显示对应光标
            cursor = self._get_cursor_for_interaction(interaction_type, handle)
            self.image_label.setCursor(QCursor(cursor))
            print(f"实时光标变换: {interaction_type} - {handle}")
        else:
            # 鼠标不在边缘，显示十字光标
            current_cursor = self.image_label.cursor().shape()
            if current_cursor != Qt.CursorShape.CrossCursor:
                self.image_label.setCursor(QCursor(Qt.CursorShape.CrossCursor))
                print("实时光标恢复: CrossCursor")
        
    event.accept()

鼠标释放事件：

def _mouse_release_event(self, event):
    """鼠标释放事件"""
    if event.button() == Qt.MouseButton.LeftButton:
        if self.selection_resizing:
            # 框选区域大小调整结束
            self.selection_resizing = False
            self.selection_drag_start = None
            self.selection_rect_backup = None
            self.resize_handle = None
            
            # 发送更新后的区域选择信号
            if self.selection_start and self.selection_current:
                x1, y1 = self.selection_start.x(), self.selection_start.y()
                x2, y2 = self.selection_current.x(), self.selection_current.y()
                
                left = min(x1, x2)
                top = min(y1, y2)
                width = abs(x2 - x1)
                height = abs(y2 - y1)
                
                print(f"调整大小后框选区域: ({left}, {top}, {width}, {height})")
                
                # 发送区域选择信号
                self.region_selected.emit(left, top, width, height)
            
            # 根据当前鼠标位置智能更新光标
            self._update_cursor_for_current_position()
            
        elif self.selection_dragging:
            # 框选区域拖动结束
            self.selection_dragging = False
            self.selection_drag_start = None
            self.selection_rect_backup = None
            
            # 发送更新后的区域选择信号
            if self.selection_start and self.selection_current:
                x1, y1 = self.selection_start.x(), self.selection_start.y()
                x2, y2 = self.selection_current.x(), self.selection_current.y()
                
                left = min(x1, x2)
                top = min(y1, y2)
                width = abs(x2 - x1)
                height = abs(y2 - y1)
                
                print(f"拖动后框选区域: ({left}, {top}, {width}, {height})")
                
                # 发送区域选择信号
                self.region_selected.emit(left, top, width, height)
            
            # 根据当前鼠标位置智能更新光标
            self._update_cursor_for_current_position()
            
        elif self.selecting:
            # 框选模式：完成框选
            if self.selection_start and self.selection_current:
                x1, y1 = self.selection_start.x(), self.selection_start.y()
                x2, y2 = self.selection_current.x(), self.selection_current.y()
                
                # 确保框选区域有效（最小尺寸）
                if abs(x2 - x1) > 10 and abs(y2 - y1) > 10:
                    left = min(x1, x2)
                    top = min(y1, y2)
                    width = abs(x2 - x1)
                    height = abs(y2 - y1)
                    
                    print(f"框选区域: ({left}, {top}, {width}, {height})")
                    
                    # 发送区域选择信号
                    self.region_selected.emit(left, top, width, height)
                else:
                    # 框选区域太小，清除选择
                    self.clear_selection()
            
            self.selecting = False
            # 根据当前鼠标位置智能更新光标
            self._update_cursor_for_current_position()
            
        elif self.dragging:
            # 普通拖动模式
            self.dragging = False
            self.last_mouse_pos = None
            self.drag_start_pos = None
            self.original_pan_pos = None
            
            # 根据当前模式智能更新光标
            self._update_cursor_for_current_position()
        
    event.accept()

2. divere/ui/main_window.py - 保存和旋转处理
   保存图像时支持框选区域裁剪（在_save_image方法中）

  def _save_image(self):
      """保存图像（支持框选区域保存）"""
      if not self.current_image:
          QMessageBox.warning(self, "警告", "没有可保存的图像")
          return
      
      # 检查是否有框选区域
      selected_region = None
      if hasattr(self.parameter_panel, '_selected_region') and self.parameter_panel._selected_region:
          selected_region = self.parameter_panel._selected_region
          print(f"检测到框选区域: {selected_region}")
      
      # 获取可用的色彩空间
      available_spaces = self.color_space_manager.get_available_color_spaces()
      
      # 打开保存设置对话框
      save_dialog = SaveImageDialog(self, available_spaces)
      if save_dialog.exec() != QDialog.DialogCode.Accepted:
          return
      
      # 获取保存设置
      settings = save_dialog.get_settings()
      
      # 确定文件扩展名
      extension = ".tiff" if settings["format"] == "tiff" else ".jpg"
      filter_str = "TIFF文件 (*.tiff *.tif)" if settings["format"] == "tiff" else "JPEG文件 (*.jpg *.jpeg)"
      
      # 生成默认文件名：根据是否有框选区域调整
      original_filename = Path(self.current_image.file_path).stem if self.current_image.file_path else "untitled"
      if selected_region:
          x, y, w, h = selected_region
          default_filename = f"{original_filename}_CC_{settings['color_space']}_crop_{x}_{y}_{w}x{h}{extension}"
      else:
          default_filename = f"{original_filename}_CC_{settings['color_space']}{extension}"
      
      # 获取上次保存的目录
      last_directory = enhanced_config_manager.get_directory("save_image")
      if last_directory:
          default_path = str(Path(last_directory) / default_filename)
      else:
          default_path = default_filename
      
      # 选择保存路径
      file_path, _ = QFileDialog.getSaveFileName(
          self,
          "保存图像",
          default_path,
          filter_str
      )
      
      if file_path:
          # 保存当前目录
          enhanced_config_manager.set_directory("save_image", file_path)
          
          try:
              # 重要：将原图转换到工作色彩空间，保持与预览一致
              print(f"导出前的色彩空间转换:")
              print(f"  原始图像色彩空间: {self.current_image.color_space}")
              print(f"  输入色彩空间设置: {self.input_color_space}")
              
              # 先设置输入色彩空间
              working_image = self.color_space_manager.set_image_color_space(
                  self.current_image, self.input_color_space
              )
              # 转换到工作色彩空间（ACEScg）
              working_image = self.color_space_manager.convert_to_working_space(
                  working_image
              )
              print(f"  转换后工作色彩空间: {working_image.color_space}")
              
              # 应用调色参数到工作空间的图像（根据设置决定是否包含曲线）
              result_image = self.the_enlarger.apply_full_pipeline(
                  working_image, 
                  self.current_params,
                  include_curve=settings["include_curve"]
              )
              
              # 转换到输出色彩空间
              result_image = self.color_space_manager.convert_to_display_space(
                  result_image, settings["color_space"]
              )
              
              # 如果有框选区域，裁剪图像
              if selected_region:
                  proxy_x, proxy_y, proxy_w, proxy_h = selected_region
                  print(f"代理图像框选区域: ({proxy_x}, {proxy_y}, {proxy_w}, {proxy_h})")
                  
                  # 计算代理图像和原始图像的缩放比例
                  if self.current_proxy and self.current_image:
                      proxy_height, proxy_width = self.current_proxy.array.shape[:2]
                      original_height, original_width = self.current_image.array.shape[:2]
                      
                      scale_x = original_width / proxy_width
                      scale_y = original_height / proxy_height
                      
                      print(f"代理图像尺寸: {proxy_width}x{proxy_height}")
                      print(f"原始图像尺寸: {original_width}x{original_height}")
                      print(f"缩放比例: x={scale_x:.3f}, y={scale_y:.3f}")
                      
                      # 将代理图像坐标转换为原始图像坐标
                      x = int(proxy_x * scale_x)
                      y = int(proxy_y * scale_y)
                      w = int(proxy_w * scale_x)
                      h = int(proxy_h * scale_y)
                      
                      print(f"转换后原始图像坐标: ({x}, {y}, {w}, {h})")
                  else:
                      # 如果没有代理图像信息，直接使用原坐标（可能不准确）
                      x, y, w, h = proxy_x, proxy_y, proxy_w, proxy_h
                      print("警告：无法获取代理图像信息，直接使用框选坐标")
                  
                  # 确保裁剪区域在图像范围内
                  img_h, img_w = result_image.array.shape[:2]
                  x = max(0, min(x, img_w - 1))
                  y = max(0, min(y, img_h - 1))
                  w = min(w, img_w - x)
                  h = min(h, img_h - y)
                  
                  print(f"最终裁剪区域: ({x}, {y}, {w}, {h})")
                  
                  # 裁剪图像数组
                  cropped_array = result_image.array[y:y+h, x:x+w]
                  
                  # 创建新的ImageData对象用于保存
                  from divere.core.data_types import ImageData
                  cropped_image = ImageData(
                      array=cropped_array,
                      width=w,
                      height=h,
                      color_space=result_image.color_space,
                      file_path=result_image.file_path
                  )
                  
                  print(f"裁剪后图像尺寸: {cropped_image.width}x{cropped_image.height}")
                  image_to_save = cropped_image
              else:
                  image_to_save = result_image
              
              # 保存图像
              self.image_manager.save_image(
                  image_to_save, 
                  file_path, 
                  bit_depth=settings["bit_depth"],
                  quality=95
              )
              
              # 显示保存成功消息
              if selected_region:
                  x, y, w, h = selected_region
                  region_info = f"框选区域({x},{y},{w}x{h})"
                  self.statusBar().showMessage(
                      f"图像已保存: {Path(file_path).name} "
                      f"({settings['bit_depth']}bit, {settings['color_space']}, {region_info})"
                  )
              else:
                  self.statusBar().showMessage(
                      f"图像已保存: {Path(file_path).name} "
                      f"({settings['bit_depth']}bit, {settings['color_space']})"
                  )
              
          except Exception as e:
              QMessageBox.critical(self, "错误", f"保存图像失败: {str(e)}")

图像旋转时清除框选状态（在_on_image_rotated方法中）

def _on_image_rotated(self, direction):
      """处理图像旋转
      Args:
          direction: 旋转方向，1=左旋，-1=右旋
      """
      if self.current_image and self.current_proxy:
          # 旋转原始图像
          rotated_array = np.rot90(self.current_image.array, direction)
          self.current_image.array = np.ascontiguousarray(rotated_array)
          self.current_image.height, self.current_image.width = self.current_image.width, self.current_image.height
          
          # 旋转代理图像
          rotated_proxy = np.rot90(self.current_proxy.array, direction)
          self.current_proxy.array = np.ascontiguousarray(rotated_proxy)
          self.current_proxy.height, self.current_proxy.width = self.current_proxy.width, self.current_proxy.height
          
          # 清除框选区域并关闭框选模式，因为旋转后坐标系已改变
          if hasattr(self.parameter_panel, '_selected_region') and self.parameter_panel._selected_region:
              print("图像旋转后清除框选区域")
              self.parameter_panel._selected_region = None
              self.parameter_panel.region_auto_color_button.setEnabled(False)
              # 清除预览组件中的框选显示
              self.preview_widget.clear_selection()
          
          # 关闭框选模式
          if hasattr(self.parameter_panel, 'region_selection_button'):
              print("图像旋转后关闭框选模式")
              self.parameter_panel.region_selection_button.setChecked(False)
              self.preview_widget.set_selection_mode(False)
          
          # 重新处理预览
          self._update_preview()
          
          # 自动适应窗口大小
          self.preview_widget.fit_to_window()

🎯 核心特性
实时光标变换
边角：对角调整光标（↖↘ 或 ↙↗）→ 调整框选区域大小
边线：四方向移动光标（✚）→ 移动整个框选区域
普通区域：十字光标（✚）→ 创建新框选区域
精确交互检测
边角检测：8像素容差，优先级更高
边线检测：5像素容差，排除边角区域
实时响应：启用鼠标跟踪，无需按下鼠标即可检测
专业用户体验
最小尺寸限制：10x10像素，避免无效框选
坐标系转换：代理图像坐标自动转换为原始图像坐标
状态管理：图像旋转时自动清除框选状态
📝 使用说明

1. 开启框选模式：点击参数面板中的"开启框选模式"按钮
2. 创建框选区域：在图像上拖拽创建红色虚线框
3. 调整框选大小：鼠标悬停在边角，出现对角调整光标时拖拽
4. 移动框选位置：鼠标悬停在边线，出现四方向移动光标时拖拽
5. 保存框选区域：保存图像时会自动裁剪并保存选定区域

[V7CN]

牛牛牛！我想想怎么合并进来。感谢。

[V7CN]

fff倒入功能已经在v0.1.12支持了，并且会自动选择适合哈苏的输入色彩空间（AdobeRGB_Linear）。框选功能得再思考下怎么做比较好使，想未来扩展成批量操作。

[Link1565]

可以参考一下哈苏FlexColor v4.8.9的框选功能，里面有些简单好用的功能也可以参考

[V7CN]

目前的版本有比较完善的框选功能了，期待反馈。