lazylabel-gui 1.3.3__py3-none-any.whl → 1.3.5__py3-none-any.whl

lazylabel/ui/main_window.py

@@ -2,11 +2,12 @@
 
 import hashlib
 import os
+import re
 from pathlib import Path
 
 import cv2
 import numpy as np
-from PyQt6.QtCore import QModelIndex, QPointF, QRectF, Qt, QThread, QTimer, pyqtSignal
+from PyQt6.QtCore import QModelIndex, QPointF, QRectF, Qt, QTimer, pyqtSignal
 from PyQt6.QtGui import (
     QBrush,
     QColor,
@@ -19,12 +20,14 @@ from PyQt6.QtGui import (
     QShortcut,
 )
 from PyQt6.QtWidgets import (
+    QApplication,
     QDialog,
     QFileDialog,
     QGraphicsEllipseItem,
     QGraphicsLineItem,
     QGraphicsPolygonItem,
     QGraphicsRectItem,
+    QGridLayout,
     QHBoxLayout,
     QLabel,
     QMainWindow,
@@ -51,530 +54,13 @@ from .numeric_table_widget_item import NumericTableWidgetItem
 from .photo_viewer import PhotoViewer
 from .right_panel import RightPanel
 from .widgets import StatusBar
-
-
-class SAMUpdateWorker(QThread):
-    """Worker thread for updating SAM model in background."""
-
-    finished = pyqtSignal()
-    error = pyqtSignal(str)
-
-    def __init__(
-        self,
-        model_manager,
-        image_path,
-        operate_on_view,
-        current_image=None,
-        parent=None,
-    ):
-        super().__init__(parent)
-        self.model_manager = model_manager
-        self.image_path = image_path
-        self.operate_on_view = operate_on_view
-        self.current_image = current_image  # Numpy array of current modified image
-        self._should_stop = False
-        self.scale_factor = 1.0  # Track scaling factor for coordinate transformation
-
-    def stop(self):
-        """Request the worker to stop."""
-        self._should_stop = True
-
-    def get_scale_factor(self):
-        """Get the scale factor used for image resizing."""
-        return self.scale_factor
-
-    def run(self):
-        """Run SAM update in background thread."""
-        try:
-            if self._should_stop:
-                return
-
-            if self.operate_on_view and self.current_image is not None:
-                # Use the provided modified image
-                if self._should_stop:
-                    return
-
-                # Optimize image size for faster SAM processing
-                image = self.current_image
-                original_height, original_width = image.shape[:2]
-                max_size = 1024
-
-                if original_height > max_size or original_width > max_size:
-                    # Calculate scaling factor
-                    self.scale_factor = min(
-                        max_size / original_width, max_size / original_height
-                    )
-                    new_width = int(original_width * self.scale_factor)
-                    new_height = int(original_height * self.scale_factor)
-
-                    # Resize using OpenCV for speed
-                    image = cv2.resize(
-                        image, (new_width, new_height), interpolation=cv2.INTER_AREA
-                    )
-                else:
-                    self.scale_factor = 1.0
-
-                if self._should_stop:
-                    return
-
-                # Set image from numpy array (FIXED: use resized image, not original)
-                self.model_manager.set_image_from_array(image)
-            else:
-                # Load original image
-                pixmap = QPixmap(self.image_path)
-                if pixmap.isNull():
-                    self.error.emit("Failed to load image")
-                    return
-
-                if self._should_stop:
-                    return
-
-                original_width = pixmap.width()
-                original_height = pixmap.height()
-
-                # Optimize image size for faster SAM processing
-                max_size = 1024
-                if original_width > max_size or original_height > max_size:
-                    # Calculate scaling factor
-                    self.scale_factor = min(
-                        max_size / original_width, max_size / original_height
-                    )
-
-                    # Scale down while maintaining aspect ratio
-                    scaled_pixmap = pixmap.scaled(
-                        max_size,
-                        max_size,
-                        Qt.AspectRatioMode.KeepAspectRatio,
-                        Qt.TransformationMode.SmoothTransformation,
-                    )
-
-                    # Convert to numpy array for SAM
-                    qimage = scaled_pixmap.toImage()
-                    width = qimage.width()
-                    height = qimage.height()
-                    ptr = qimage.bits()
-                    ptr.setsize(height * width * 4)
-                    arr = np.array(ptr).reshape(height, width, 4)
-                    # Convert RGBA to RGB
-                    image_array = arr[:, :, :3]
-
-                    if self._should_stop:
-                        return
-
-                    # FIXED: Use the resized image array, not original path
-                    self.model_manager.set_image_from_array(image_array)
-                else:
-                    self.scale_factor = 1.0
-                    # For images that don't need resizing, use original path
-                    self.model_manager.set_image_from_path(self.image_path)
-
-            if not self._should_stop:
-                self.finished.emit()
-
-        except Exception as e:
-            if not self._should_stop:
-                self.error.emit(str(e))
-
-
-class SingleViewSAMInitWorker(QThread):
-    """Worker thread for initializing single-view SAM model in background."""
-
-    model_initialized = pyqtSignal(object)  # model_instance
-    finished = pyqtSignal()
-    error = pyqtSignal(str)
-    progress = pyqtSignal(str)  # status message
-
-    def __init__(self, model_manager, default_model_type, custom_model_path=None):
-        super().__init__()
-        self.model_manager = model_manager
-        self.default_model_type = default_model_type
-        self.custom_model_path = custom_model_path
-        self._should_stop = False
-
-    def stop(self):
-        """Stop the worker gracefully."""
-        self._should_stop = True
-
-    def run(self):
-        """Initialize SAM model in background."""
-        try:
-            if self._should_stop:
-                return
-
-            if self.custom_model_path:
-                # Load custom model
-                model_name = os.path.basename(self.custom_model_path)
-                self.progress.emit(f"Loading {model_name}...")
-
-                success = self.model_manager.load_custom_model(self.custom_model_path)
-                if not success:
-                    raise Exception(f"Failed to load custom model: {model_name}")
-
-                sam_model = self.model_manager.sam_model
-            else:
-                # Initialize the default model
-                self.progress.emit("Initializing AI model...")
-                sam_model = self.model_manager.initialize_default_model(
-                    self.default_model_type
-                )
-
-            if self._should_stop:
-                return
-
-            if sam_model and sam_model.is_loaded:
-                self.model_initialized.emit(sam_model)
-                self.progress.emit("AI model initialized")
-            else:
-                self.error.emit("Model failed to load")
-
-        except Exception as e:
-            if not self._should_stop:
-                self.error.emit(f"Failed to load AI model: {str(e)}")
-
-
-class MultiViewSAMInitWorker(QThread):
-    """Worker thread for initializing multi-view SAM models in background."""
-
-    model_initialized = pyqtSignal(int, object)  # viewer_index, model_instance
-    all_models_initialized = pyqtSignal(int)  # total_models_count
-    error = pyqtSignal(str)
-    progress = pyqtSignal(int, int)  # current, total
-
-    def __init__(self, model_manager, parent=None):
-        super().__init__(parent)
-        self.model_manager = model_manager
-        self._should_stop = False
-        self.models_created = []
-
-    def stop(self):
-        """Request the worker to stop."""
-        self._should_stop = True
-
-    def run(self):
-        """Initialize multi-view SAM models in background thread."""
-        try:
-            if self._should_stop:
-                return
-
-            # Import the required model classes
-            from ..models.sam_model import SamModel
-
-            try:
-                from ..models.sam2_model import Sam2Model
-
-                SAM2_AVAILABLE = True
-            except ImportError:
-                Sam2Model = None
-                SAM2_AVAILABLE = False
-
-            # Determine which type of model to create
-            # Get the currently selected model from the GUI
-            parent = self.parent()
-            custom_model_path = None
-            default_model_type = "vit_h"  # fallback
-
-            if parent and hasattr(parent, "control_panel"):
-                # Get the selected model path from the model selection widget
-                model_path = parent.control_panel.model_widget.get_selected_model_path()
-                if model_path:
-                    # User has selected a custom model
-                    custom_model_path = model_path
-                    # Detect model type from filename
-                    default_model_type = self.model_manager.detect_model_type(
-                        model_path
-                    )
-                else:
-                    # Using default model
-                    default_model_type = (
-                        parent.settings.default_model_type
-                        if hasattr(parent, "settings")
-                        else "vit_h"
-                    )
-
-            is_sam2 = default_model_type.startswith("sam2")
-
-            # Create model instances for all viewers - but optimize memory usage
-            config = parent._get_multi_view_config()
-            num_viewers = config["num_viewers"]
-
-            # Warn about performance implications for VIT_H in multi-view
-            if num_viewers > 2 and default_model_type == "vit_h":
-                logger.warning(
-                    f"Using vit_h model with {num_viewers} viewers may cause performance issues. Consider using vit_b for better performance."
-                )
-            for i in range(num_viewers):
-                if self._should_stop:
-                    return
-
-                self.progress.emit(i + 1, num_viewers)
-
-                try:
-                    if is_sam2 and SAM2_AVAILABLE:
-                        # Create SAM2 model instance
-                        if custom_model_path:
-                            model_instance = Sam2Model(custom_model_path)
-                        else:
-                            model_instance = Sam2Model(model_type=default_model_type)
-                    else:
-                        # Create SAM1 model instance
-                        if custom_model_path:
-                            model_instance = SamModel(
-                                model_type=default_model_type,
-                                custom_model_path=custom_model_path,
-                            )
-                        else:
-                            model_instance = SamModel(model_type=default_model_type)
-
-                    if self._should_stop:
-                        return
-
-                    if model_instance and getattr(model_instance, "is_loaded", False):
-                        self.models_created.append(model_instance)
-                        self.model_initialized.emit(i, model_instance)
-
-                        # Synchronize and clear GPU cache after each model for stability
-                        try:
-                            import torch
-
-                            if torch.cuda.is_available():
-                                torch.cuda.synchronize()  # Ensure model is fully loaded
-                                torch.cuda.empty_cache()
-                        except ImportError:
-                            pass  # PyTorch not available
-                    else:
-                        raise Exception(f"Model instance {i + 1} failed to load")
-
-                except Exception as model_error:
-                    logger.error(
-                        f"Error creating model instance {i + 1}: {model_error}"
-                    )
-                    if not self._should_stop:
-                        self.error.emit(
-                            f"Failed to create model instance {i + 1}: {model_error}"
-                        )
-                    return
-
-            if not self._should_stop:
-                self.all_models_initialized.emit(len(self.models_created))
-
-        except Exception as e:
-            if not self._should_stop:
-                self.error.emit(str(e))
-
-
-class ImageDiscoveryWorker(QThread):
-    """Worker thread for discovering all image file paths in background."""
-
-    images_discovered = pyqtSignal(list)  # List of all image file paths
-    progress = pyqtSignal(str)  # Progress message
-    error = pyqtSignal(str)
-
-    def __init__(self, file_model, file_manager, parent=None):
-        super().__init__(parent)
-        self.file_model = file_model
-        self.file_manager = file_manager
-        self._should_stop = False
-
-    def stop(self):
-        """Request the worker to stop."""
-        self._should_stop = True
-
-    def run(self):
-        """Discover all image file paths in background."""
-        try:
-            if self._should_stop:
-                return
-
-            self.progress.emit("Scanning for images...")
-
-            if (
-                not hasattr(self.file_model, "rootPath")
-                or not self.file_model.rootPath()
-            ):
-                self.images_discovered.emit([])
-                return
-
-            all_image_paths = []
-            root_index = self.file_model.index(self.file_model.rootPath())
-
-            def scan_directory(parent_index):
-                if self._should_stop:
-                    return
-
-                for row in range(self.file_model.rowCount(parent_index)):
-                    if self._should_stop:
-                        return
-
-                    index = self.file_model.index(row, 0, parent_index)
-                    if self.file_model.isDir(index):
-                        scan_directory(index)  # Recursively scan subdirectories
-                    else:
-                        path = self.file_model.filePath(index)
-                        if self.file_manager.is_image_file(path):
-                            # Simply add all image file paths without checking for NPZ
-                            all_image_paths.append(path)
-
-            scan_directory(root_index)
-
-            if not self._should_stop:
-                self.progress.emit(f"Found {len(all_image_paths)} images")
-                self.images_discovered.emit(sorted(all_image_paths))
-
-        except Exception as e:
-            if not self._should_stop:
-                self.error.emit(f"Error discovering images: {str(e)}")
-
-
-class MultiViewSAMUpdateWorker(QThread):
-    """Worker thread for updating SAM model image in multi-view mode."""
-
-    finished = pyqtSignal(int)  # viewer_index
-    error = pyqtSignal(int, str)  # viewer_index, error_message
-
-    def __init__(
-        self,
-        viewer_index,
-        model,
-        image_path,
-        operate_on_view=False,
-        current_image=None,
-        parent=None,
-    ):
-        super().__init__(parent)
-        self.viewer_index = viewer_index
-        self.model = model
-        self.image_path = image_path
-        self.operate_on_view = operate_on_view
-        self.current_image = current_image
-        self._should_stop = False
-        self.scale_factor = 1.0
-
-    def stop(self):
-        """Request the worker to stop."""
-        self._should_stop = True
-
-    def get_scale_factor(self):
-        """Get the scale factor used for image resizing."""
-        return self.scale_factor
-
-    def run(self):
-        """Update SAM model image in background thread."""
-        try:
-            if self._should_stop:
-                return
-
-            # Clear GPU cache to reduce memory pressure in multi-view mode
-            try:
-                import torch
-
-                if torch.cuda.is_available():
-                    torch.cuda.empty_cache()
-            except ImportError:
-                pass  # PyTorch not available
-
-            if self.operate_on_view and self.current_image is not None:
-                # Use the provided modified image
-                if self._should_stop:
-                    return
-
-                # Optimize image size for faster SAM processing
-                image = self.current_image
-                original_height, original_width = image.shape[:2]
-                max_size = 1024
-
-                if original_height > max_size or original_width > max_size:
-                    # Calculate scaling factor
-                    self.scale_factor = min(
-                        max_size / original_width, max_size / original_height
-                    )
-                    new_width = int(original_width * self.scale_factor)
-                    new_height = int(original_height * self.scale_factor)
-
-                    # Resize using OpenCV for speed
-                    image = cv2.resize(
-                        image, (new_width, new_height), interpolation=cv2.INTER_AREA
-                    )
-                else:
-                    self.scale_factor = 1.0
-
-                if self._should_stop:
-                    return
-
-                # Set image from numpy array
-                self.model.set_image_from_array(image)
-            else:
-                # Load original image
-                if self._should_stop:
-                    return
-
-                # Optimize image size for faster SAM processing
-                pixmap = QPixmap(self.image_path)
-                if pixmap.isNull():
-                    if not self._should_stop:
-                        self.error.emit(self.viewer_index, "Failed to load image")
-                    return
-
-                original_width = pixmap.width()
-                original_height = pixmap.height()
-                max_size = 1024
-
-                if original_width > max_size or original_height > max_size:
-                    # Calculate scaling factor
-                    self.scale_factor = min(
-                        max_size / original_width, max_size / original_height
-                    )
-
-                    # Scale down while maintaining aspect ratio
-                    scaled_pixmap = pixmap.scaled(
-                        max_size,
-                        max_size,
-                        Qt.AspectRatioMode.KeepAspectRatio,
-                        Qt.TransformationMode.SmoothTransformation,
-                    )
-
-                    # Convert to numpy array for SAM
-                    qimage = scaled_pixmap.toImage()
-                    width = qimage.width()
-                    height = qimage.height()
-                    ptr = qimage.bits()
-                    ptr.setsize(height * width * 4)
-                    arr = np.array(ptr).reshape(height, width, 4)
-                    # Convert RGBA to RGB
-                    image_array = arr[:, :, :3]
-
-                    if self._should_stop:
-                        return
-
-                    # Add CUDA synchronization for multi-model scenarios
-                    try:
-                        import torch
-
-                        if torch.cuda.is_available():
-                            torch.cuda.synchronize()
-                    except ImportError:
-                        pass
-
-                    self.model.set_image_from_array(image_array)
-                else:
-                    self.scale_factor = 1.0
-
-                    # Add CUDA synchronization for multi-model scenarios
-                    try:
-                        import torch
-
-                        if torch.cuda.is_available():
-                            torch.cuda.synchronize()
-                    except ImportError:
-                        pass
-
-                    self.model.set_image_from_path(self.image_path)
-
-            if not self._should_stop:
-                self.finished.emit(self.viewer_index)
-
-        except Exception as e:
-            if not self._should_stop:
-                self.error.emit(self.viewer_index, str(e))
+from .workers import (
+    ImageDiscoveryWorker,
+    MultiViewSAMInitWorker,
+    MultiViewSAMUpdateWorker,
+    SAMUpdateWorker,
+    SingleViewSAMInitWorker,
+)
 
 
 class PanelPopoutWindow(QDialog):
@@ -772,12 +258,32 @@ class MainWindow(QMainWindow):
         logger.info("Step 5/8: Discovering available models...")
         self._setup_model_manager()  # Just setup manager, don't load model
         self._setup_connections()
+        self._fix_fft_connection()  # Workaround for FFT signal connection issue
         self._setup_shortcuts()
         self._load_settings()
 
+    def _get_version(self) -> str:
+        """Get version from pyproject.toml."""
+        try:
+            # Get the project root directory (3 levels up from main_window.py)
+            project_root = Path(__file__).parent.parent.parent.parent
+            pyproject_path = project_root / "pyproject.toml"
+
+            if pyproject_path.exists():
+                with open(pyproject_path, encoding="utf-8") as f:
+                    content = f.read()
+                    # Use regex to find version line
+                    match = re.search(r'version\s*=\s*"([^"]+)"', content)
+                    if match:
+                        return match.group(1)
+        except Exception:
+            pass
+        return "unknown"
+
     def _setup_ui(self):
         """Setup the main user interface."""
-        self.setWindowTitle("LazyLabel by DNC")
+        version = self._get_version()
+        self.setWindowTitle(f"LazyLabel by DNC (version {version})")
         self.setGeometry(
             50, 50, self.settings.window_width, self.settings.window_height
         )
@@ -877,12 +383,7 @@ class MainWindow(QMainWindow):
         grid_widget = QWidget()
 
         # Use grid layout for 4-view, horizontal layout for 2-view
-        if use_grid:
-            from PyQt6.QtWidgets import QGridLayout
-
-            grid_layout = QGridLayout(grid_widget)
-        else:
-            grid_layout = QHBoxLayout(grid_widget)
+        grid_layout = QGridLayout(grid_widget) if use_grid else QHBoxLayout(grid_widget)
         grid_layout.setSpacing(5)
 
         self.multi_view_viewers = []
@@ -951,29 +452,30 @@ class MainWindow(QMainWindow):
         grid_mode_label = QLabel("View Mode:")
         controls_layout.addWidget(grid_mode_label)
 
-        from PyQt6.QtWidgets import QComboBox
+        from lazylabel.ui.widgets.model_selection_widget import CustomDropdown
 
-        self.grid_mode_combo = QComboBox()
+        self.grid_mode_combo = CustomDropdown()
+        self.grid_mode_combo.setText("View Mode")  # Default text
         self.grid_mode_combo.addItem("2 Views (1x2)", "2_view")
         self.grid_mode_combo.addItem("4 Views (2x2)", "4_view")
 
         # Set current selection based on settings
         current_mode = self.settings.multi_view_grid_mode
-        for i in range(self.grid_mode_combo.count()):
+        for i in range(len(self.grid_mode_combo.items)):
             if self.grid_mode_combo.itemData(i) == current_mode:
                 self.grid_mode_combo.setCurrentIndex(i)
                 break
 
-        self.grid_mode_combo.currentTextChanged.connect(self._on_grid_mode_changed)
+        self.grid_mode_combo.activated.connect(self._on_grid_mode_changed)
         controls_layout.addWidget(self.grid_mode_combo)
 
         controls_layout.addStretch()
 
         layout.addWidget(controls_widget)
 
-    def _on_grid_mode_changed(self):
+    def _on_grid_mode_changed(self, index):
         """Handle grid mode change from combo box."""
-        current_data = self.grid_mode_combo.currentData()
+        current_data = self.grid_mode_combo.itemData(index)
         if current_data and current_data != self.settings.multi_view_grid_mode:
             # Update settings
             self.settings.multi_view_grid_mode = current_data
@@ -1062,8 +564,7 @@ class MainWindow(QMainWindow):
                 layout.deleteLater()
             except Exception as e:
                 # If layout clearing fails, just reset the viewer lists
-                print(f"Layout clearing failed: {e}")
-                pass
+                logger.error(f"Layout clearing failed: {e}")
 
     def _clear_multi_view_layout(self):
         """Clear the existing multi-view layout."""
@@ -1121,6 +622,48 @@ class MainWindow(QMainWindow):
             # Switch to polygon mode if SAM is disabled and we're in SAM/AI mode
             self.set_polygon_mode()
 
+    def _fix_fft_connection(self):
+        """Fix FFT signal connection issue - workaround for connection timing problem."""
+        try:
+            # Get the FFT widget directly and connect to its signal
+            fft_widget = self.control_panel.get_fft_threshold_widget()
+            if fft_widget:
+                # Direct connection bypass - connect FFT widget directly to main window handler
+                # This bypasses the control panel signal forwarding which has timing issues
+                # Use a wrapper to ensure the connection works reliably
+                def fft_signal_wrapper():
+                    self._handle_fft_threshold_changed()
+
+                fft_widget.fft_threshold_changed.connect(fft_signal_wrapper)
+
+                logger.info("FFT signal connection bypass established successfully")
+            else:
+                logger.warning("FFT widget not found during connection fix")
+        except Exception as e:
+            logger.warning(f"Failed to establish FFT connection bypass: {e}")
+
+        # Also fix channel threshold connection for RGB images
+        try:
+            channel_widget = self.control_panel.get_channel_threshold_widget()
+            if channel_widget:
+                # Direct connection bypass for channel threshold widget too
+                def channel_signal_wrapper():
+                    self._handle_channel_threshold_changed()
+
+                channel_widget.thresholdChanged.connect(channel_signal_wrapper)
+
+                logger.info(
+                    "Channel threshold signal connection bypass established successfully"
+                )
+            else:
+                logger.warning(
+                    "Channel threshold widget not found during connection fix"
+                )
+        except Exception as e:
+            logger.warning(
+                f"Failed to establish channel threshold connection bypass: {e}"
+            )
+
     def _setup_connections(self):
         """Setup signal connections."""
         # Control panel connections
@@ -1169,9 +712,13 @@ class MainWindow(QMainWindow):
         )
 
         # FFT threshold connections
-        self.control_panel.fft_threshold_changed.connect(
-            self._handle_fft_threshold_changed
-        )
+        try:
+            self.control_panel.fft_threshold_changed.connect(
+                self._handle_fft_threshold_changed
+            )
+            logger.debug("FFT threshold connection established in _setup_connections")
+        except Exception as e:
+            logger.error(f"Failed to establish FFT threshold connection: {e}")
 
         # Right panel connections
         self.right_panel.open_folder_requested.connect(self._open_folder_dialog)
@@ -1466,7 +1013,7 @@ class MainWindow(QMainWindow):
         if not model_text or model_text == "Default (vit_h)":
             # Clear any pending custom model and use default
             self.pending_custom_model_path = None
-            self.control_panel.set_current_model("Current: Default SAM Model")
+            self.control_panel.set_current_model("Selected: Default SAM Model")
             # Clear existing model to free memory until needed
             self._reset_sam_state_for_model_switch()
             return
@@ -1659,7 +1206,17 @@ class MainWindow(QMainWindow):
                 self._save_output_to_npz()
 
             self.current_image_path = path
-            pixmap = QPixmap(self.current_image_path)
+            # Load image with explicit transparency support
+            qimage = QImage(self.current_image_path)
+            if qimage.isNull():
+                return
+            # For PNG files, always ensure proper alpha format handling
+            if self.current_image_path.lower().endswith(".png"):
+                # PNG files can have alpha channels, use ARGB32_Premultiplied for proper handling
+                qimage = qimage.convertToFormat(
+                    QImage.Format.Format_ARGB32_Premultiplied
+                )
+            pixmap = QPixmap.fromImage(qimage)
             if not pixmap.isNull():
                 self._reset_state()
                 self.viewer.set_photo(pixmap)
@@ -1713,6 +1270,11 @@ class MainWindow(QMainWindow):
         ):
             self._save_output_to_npz()
 
+        self.current_image_path = path
+
+        # CRITICAL: Reset state and mark SAM as dirty when loading new image
+        self._reset_state()
+
         self.segment_manager.clear()
         # Remove all scene items except the pixmap
         items_to_remove = [
@@ -1722,7 +1284,6 @@ class MainWindow(QMainWindow):
         ]
         for item in items_to_remove:
             self.viewer.scene().removeItem(item)
-        self.current_image_path = path
 
         # Load the image
         original_image = cv2.imread(path)
@@ -1774,6 +1335,12 @@ class MainWindow(QMainWindow):
         # Update file selection in the file manager
         self.right_panel.select_file(Path(path))
 
+        # CRITICAL: Update SAM model with new image
+        self._update_sam_model_image()
+
+        # Update threshold widgets for new image (this was missing!)
+        self._update_channel_threshold_for_image(pixmap)
+
     def _load_multi_view_from_path(self, path: str):
         """Load multi-view starting from a specific path using FastFileManager."""
         config = self._get_multi_view_config()
@@ -1897,7 +1464,21 @@ class MainWindow(QMainWindow):
                 image_path = self.multi_view_images[i]
 
                 if image_path:
-                    pixmap = QPixmap(image_path)
+                    # Load image with explicit transparency support
+                    qimage = QImage(image_path)
+                    if qimage.isNull():
+                        self.multi_view_viewers[i].set_photo(QPixmap())
+                        self.multi_view_info_labels[i].setText(
+                            f"Image {i + 1}: Failed to load"
+                        )
+                        continue
+                    # For PNG files, always ensure proper alpha format handling
+                    if image_path.lower().endswith(".png"):
+                        # PNG files can have alpha channels, use ARGB32_Premultiplied for proper handling
+                        qimage = qimage.convertToFormat(
+                            QImage.Format.Format_ARGB32_Premultiplied
+                        )
+                    pixmap = QPixmap.fromImage(qimage)
                     if not pixmap.isNull():
                         self.multi_view_viewers[i].set_photo(pixmap)
                         # Apply current image adjustments to the newly loaded image
@@ -1948,6 +1529,9 @@ class MainWindow(QMainWindow):
         if changed_indices:
             self._fast_update_multi_view_images(changed_indices)
 
+        # Update threshold widgets for the loaded images
+        self._update_multi_view_channel_threshold_for_images()
+
         # Load existing segments for all loaded images
         valid_image_paths = [path for path in image_paths if path is not None]
         if valid_image_paths:
@@ -1983,6 +1567,21 @@ class MainWindow(QMainWindow):
         self.action_history.clear()
         self.redo_history.clear()
 
+        # Reset SAM model state - force reload for new images (same as single view)
+        self.current_sam_hash = None  # Invalidate SAM cache
+        self.sam_is_dirty = True  # Mark SAM as needing update
+
+        # Clear cached image data to prevent using previous images
+        self._cached_original_image = None
+        if hasattr(self, "_cached_multi_view_original_images"):
+            self._cached_multi_view_original_images = None
+
+        # Clear SAM embedding cache to ensure fresh processing
+        self.sam_embedding_cache.clear()
+
+        # Reset AI mode state
+        self.ai_click_start_pos = None
+
         # Update UI lists to reflect cleared state
         self._update_all_lists()
 
@@ -2005,7 +1604,9 @@ class MainWindow(QMainWindow):
                         all_segments.extend(viewer_segments)
                         self.segment_manager.segments.clear()
                     except Exception as e:
-                        print(f"Error loading segments for viewer {viewer_index}: {e}")
+                        logger.error(
+                            f"Error loading segments for viewer {viewer_index}: {e}"
+                        )
 
             # Set all segments at once
             self.segment_manager.segments = all_segments
@@ -2025,7 +1626,7 @@ class MainWindow(QMainWindow):
                 self._update_all_lists()
 
         except Exception as e:
-            print(f"Error in _load_multi_view_segments: {e}")
+            logger.error(f"Error in _load_multi_view_segments: {e}")
             self.segment_manager.segments.clear()
 
     def _cancel_multi_view_sam_loading(self):
@@ -2245,9 +1846,18 @@ class MainWindow(QMainWindow):
             # Convert from BGRA to RGB for SAM
             image_rgb = cv2.cvtColor(image_np, cv2.COLOR_BGRA2RGB)
             self.model_manager.sam_model.set_image_from_array(image_rgb)
+            # Update hash to prevent worker thread from re-updating
+            image_hash = self._get_image_hash(image_rgb)
+            self.current_sam_hash = image_hash
         else:
             # Pass the original image path to SAM model
             self.model_manager.sam_model.set_image_from_path(self.current_image_path)
+            # Update hash to prevent worker thread from re-updating
+            image_hash = hashlib.md5(self.current_image_path.encode()).hexdigest()
+            self.current_sam_hash = image_hash
+
+        # Mark SAM as clean since we just updated it
+        self.sam_is_dirty = False
 
     def _load_next_image(self):
         """Load next image in the file list."""
@@ -3353,6 +2963,8 @@ class MainWindow(QMainWindow):
                 valid_paths = [Path(img) for img in self.multi_view_images if img]
                 if valid_paths:
                     self.right_panel.file_manager.batchUpdateFileStatus(valid_paths)
+                    # Force immediate GUI update
+                    QApplication.processEvents()
             # Clear the tracking list for next save
             self._saved_file_paths = []
 
@@ -3401,6 +3013,8 @@ class MainWindow(QMainWindow):
                 )
                 # Update UI immediately when files are deleted
                 self._update_all_lists()
+                # Force immediate GUI update
+                QApplication.processEvents()
             else:
                 self._show_warning_notification("No segments to save.")
             return
@@ -3478,15 +3092,16 @@ class MainWindow(QMainWindow):
                     )
 
             # Update FastFileManager to show NPZ/TXT checkmarks
-            if (
-                (npz_path or txt_path)
-                and hasattr(self, "right_panel")
-                and hasattr(self.right_panel, "file_manager")
+            # Always update file status after save attempt (regardless of what was saved)
+            if hasattr(self, "right_panel") and hasattr(
+                self.right_panel, "file_manager"
             ):
                 # Update the file status in the FastFileManager
                 self.right_panel.file_manager.updateFileStatus(
                     Path(self.current_image_path)
                 )
+                # Force immediate GUI update
+                QApplication.processEvents()
         except Exception as e:
             logger.error(f"Error saving file: {str(e)}", exc_info=True)
             self._show_error_notification(f"Error saving: {str(e)}")
@@ -4179,6 +3794,18 @@ class MainWindow(QMainWindow):
         self.crop_start_pos = None
         self.current_crop_coords = None
 
+        # Reset SAM model state - force reload for new image
+        self.current_sam_hash = None  # Invalidate SAM cache
+        self.sam_is_dirty = True  # Mark SAM as needing update
+
+        # Clear cached image data to prevent using previous image
+        self._cached_original_image = None
+        if hasattr(self, "_cached_multi_view_original_images"):
+            self._cached_multi_view_original_images = None
+
+        # Clear SAM embedding cache to ensure fresh processing
+        self.sam_embedding_cache.clear()
+
         # Reset AI mode state
         self.ai_click_start_pos = None
         self.ai_click_time = 0
@@ -5714,27 +5341,50 @@ class MainWindow(QMainWindow):
 
     def _update_channel_threshold_for_image(self, pixmap):
         """Update channel threshold widget for the given image pixmap."""
-        if pixmap.isNull():
+        if pixmap.isNull() or not self.current_image_path:
             self.control_panel.update_channel_threshold_for_image(None)
             return
 
-        # Convert pixmap to numpy array
-        qimage = pixmap.toImage()
-        ptr = qimage.constBits()
-        ptr.setsize(qimage.bytesPerLine() * qimage.height())
-        image_np = np.array(ptr).reshape(qimage.height(), qimage.width(), 4)
-        # Convert from BGRA to RGB, ignore alpha
-        image_rgb = image_np[:, :, [2, 1, 0]]
+        # Use cv2.imread for more robust loading instead of QPixmap conversion
+        try:
+            import cv2
 
-        # Check if image is grayscale (all channels are the same)
-        if np.array_equal(image_rgb[:, :, 0], image_rgb[:, :, 1]) and np.array_equal(
-            image_rgb[:, :, 1], image_rgb[:, :, 2]
-        ):
-            # Convert to single channel grayscale
-            image_array = image_rgb[:, :, 0]
-        else:
-            # Keep as RGB
-            image_array = image_rgb
+            image_array = cv2.imread(self.current_image_path)
+            if image_array is None:
+                self.control_panel.update_channel_threshold_for_image(None)
+                return
+
+            # Convert from BGR to RGB
+            if len(image_array.shape) == 3 and image_array.shape[2] == 3:
+                image_array = cv2.cvtColor(image_array, cv2.COLOR_BGR2RGB)
+
+            # Check if image is grayscale (all channels are the same)
+            if (
+                len(image_array.shape) == 3
+                and np.array_equal(image_array[:, :, 0], image_array[:, :, 1])
+                and np.array_equal(image_array[:, :, 1], image_array[:, :, 2])
+            ):
+                # Convert to single channel grayscale
+                image_array = image_array[:, :, 0]
+
+        except Exception:
+            # Fallback to QPixmap conversion if cv2 fails
+            qimage = pixmap.toImage()
+            ptr = qimage.constBits()
+            ptr.setsize(qimage.bytesPerLine() * qimage.height())
+            image_np = np.array(ptr).reshape(qimage.height(), qimage.width(), 4)
+            # Convert from BGRA to RGB, ignore alpha
+            image_rgb = image_np[:, :, [2, 1, 0]]
+
+            # Check if image is grayscale (all channels are the same)
+            if np.array_equal(
+                image_rgb[:, :, 0], image_rgb[:, :, 1]
+            ) and np.array_equal(image_rgb[:, :, 1], image_rgb[:, :, 2]):
+                # Convert to single channel grayscale
+                image_array = image_rgb[:, :, 0]
+            else:
+                # Keep as RGB
+                image_array = image_rgb
 
         # Update the channel threshold widget
         self.control_panel.update_channel_threshold_for_image(image_array)
@@ -5762,29 +5412,51 @@ class MainWindow(QMainWindow):
             self.control_panel.update_channel_threshold_for_image(None)
             return
 
-        # Load and convert the first image to update the widget
-        pixmap = QPixmap(first_image_path)
-        if pixmap.isNull():
-            self.control_panel.update_channel_threshold_for_image(None)
-            return
+        # Use cv2.imread for more robust loading instead of QPixmap conversion
+        try:
+            import cv2
 
-        # Convert pixmap to numpy array
-        qimage = pixmap.toImage()
-        ptr = qimage.constBits()
-        ptr.setsize(qimage.bytesPerLine() * qimage.height())
-        image_np = np.array(ptr).reshape(qimage.height(), qimage.width(), 4)
-        # Convert from BGRA to RGB, ignore alpha
-        image_rgb = image_np[:, :, [2, 1, 0]]
+            image_array = cv2.imread(first_image_path)
+            if image_array is None:
+                self.control_panel.update_channel_threshold_for_image(None)
+                return
 
-        # Check if image is grayscale (all channels are the same)
-        if np.array_equal(image_rgb[:, :, 0], image_rgb[:, :, 1]) and np.array_equal(
-            image_rgb[:, :, 1], image_rgb[:, :, 2]
-        ):
-            # Convert to single channel grayscale
-            image_array = image_rgb[:, :, 0]
-        else:
-            # Keep as RGB
-            image_array = image_rgb
+            # Convert from BGR to RGB
+            if len(image_array.shape) == 3 and image_array.shape[2] == 3:
+                image_array = cv2.cvtColor(image_array, cv2.COLOR_BGR2RGB)
+
+            # Check if image is grayscale (all channels are the same)
+            if (
+                len(image_array.shape) == 3
+                and np.array_equal(image_array[:, :, 0], image_array[:, :, 1])
+                and np.array_equal(image_array[:, :, 1], image_array[:, :, 2])
+            ):
+                # Convert to single channel grayscale
+                image_array = image_array[:, :, 0]
+
+        except Exception:
+            # Fallback to QPixmap conversion if cv2 fails
+            pixmap = QPixmap(first_image_path)
+            if pixmap.isNull():
+                self.control_panel.update_channel_threshold_for_image(None)
+                return
+
+            qimage = pixmap.toImage()
+            ptr = qimage.constBits()
+            ptr.setsize(qimage.bytesPerLine() * qimage.height())
+            image_np = np.array(ptr).reshape(qimage.height(), qimage.width(), 4)
+            # Convert from BGRA to RGB, ignore alpha
+            image_rgb = image_np[:, :, [2, 1, 0]]
+
+            # Check if image is grayscale (all channels are the same)
+            if np.array_equal(
+                image_rgb[:, :, 0], image_rgb[:, :, 1]
+            ) and np.array_equal(image_rgb[:, :, 1], image_rgb[:, :, 2]):
+                # Convert to single channel grayscale
+                image_array = image_rgb[:, :, 0]
+            else:
+                # Keep as RGB
+                image_array = image_rgb
 
         # Update the channel threshold widget
         self.control_panel.update_channel_threshold_for_image(image_array)
@@ -7097,7 +6769,6 @@ class MainWindow(QMainWindow):
                 )
 
                 # Load existing segments for the current image
-                print(f"Loading segments for single-view: {self.current_image_path}")
                 try:
                     # Clear any leftover multi-view segments first
                     self.segment_manager.clear()
@@ -7114,7 +6785,7 @@ class MainWindow(QMainWindow):
                     self._update_all_lists()
 
                 except Exception as e:
-                    print(f"Error loading segments for single-view: {e}")
+                    logger.error(f"Error loading segments for single-view: {e}")
 
                 # Redisplay segments for single view
                 if hasattr(self, "single_view_mode_handler"):