lazylabel-gui 1.3.4__py3-none-any.whl → 1.3.6__py3-none-any.whl

lazylabel/ui/photo_viewer.py

@@ -1,7 +1,7 @@
 import cv2
 import numpy as np
 from PyQt6.QtCore import QRectF, Qt, pyqtSignal
-from PyQt6.QtGui import QCursor, QImage, QPixmap
+from PyQt6.QtGui import QCursor, QImage, QPainter, QPixmap
 from PyQt6.QtWidgets import QGraphicsPixmapItem, QGraphicsScene, QGraphicsView
 
 
@@ -17,6 +17,14 @@ class PhotoViewer(QGraphicsView):
         self._scene.addItem(self._pixmap_item)
         self.setScene(self._scene)
 
+        # Enable proper alpha blending for transparency
+        self.setRenderHint(QPainter.RenderHint.Antialiasing)
+        self.setRenderHint(QPainter.RenderHint.SmoothPixmapTransform)
+
+        # Ensure viewport supports transparency
+        self.viewport().setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground, True)
+        self.setStyleSheet("background: transparent;")
+
         self.setTransformationAnchor(QGraphicsView.ViewportAnchor.AnchorUnderMouse)
         self.setResizeAnchor(QGraphicsView.ViewportAnchor.AnchorViewCenter)
         self.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
@@ -26,7 +34,7 @@ class PhotoViewer(QGraphicsView):
 
         self._original_image = None
         self._adjusted_pixmap = None
-        self._original_image_bgr = None
+        self._original_image_bgra = None
 
     def fitInView(self, scale=True):
         rect = QRectF(self._pixmap_item.pixmap().rect())
@@ -50,6 +58,9 @@ class PhotoViewer(QGraphicsView):
             if self._pixmap_item not in self._scene.items():
                 self._pixmap_item = QGraphicsPixmapItem()
                 self._scene.addItem(self._pixmap_item)
+
+            # PNG files are now loaded with proper alpha format at source
+
             self._pixmap_item.setPixmap(pixmap)
 
             # Convert QImage to ARGB32 for consistent processing
@@ -62,14 +73,16 @@ class PhotoViewer(QGraphicsView):
             img_np = np.array(ptr).reshape(
                 converted_image.height(), converted_image.width(), 4
             )
-            # OpenCV expects BGR, so convert from BGRA (QImage ARGB is BGRA in memory)
-            self._original_image_bgr = cv2.cvtColor(img_np, cv2.COLOR_BGRA2BGR)
+            # QImage ARGB32 is stored as BGRA in memory, keep this format
+            self._original_image_bgra = (
+                img_np.copy()
+            )  # Make a copy to avoid memory issues
 
             self.fitInView()
         else:
             self._original_image = None
             self._adjusted_pixmap = None
-            self._original_image_bgr = None
+            self._original_image_bgra = None
             # Check if _pixmap_item still exists, recreate if deleted
             if self._pixmap_item not in self._scene.items():
                 self._pixmap_item = QGraphicsPixmapItem()
@@ -77,7 +90,7 @@ class PhotoViewer(QGraphicsView):
             self._pixmap_item.setPixmap(QPixmap())
 
     def set_image_adjustments(self, brightness: float, contrast: float, gamma: float):
-        if self._original_image_bgr is None or self._original_image is None:
+        if self._original_image_bgra is None or self._original_image is None:
             return
 
         # Ensure _pixmap_item exists and is valid
@@ -85,9 +98,13 @@ class PhotoViewer(QGraphicsView):
             self._pixmap_item = QGraphicsPixmapItem()
             self._scene.addItem(self._pixmap_item)
 
-        img_bgr = self._original_image_bgr.copy()
+        img_bgra = self._original_image_bgra.copy()
 
-        # Apply brightness and contrast
+        # Separate alpha channel for transparency preservation
+        alpha_channel = img_bgra[:, :, 3:4]  # Keep dimensions
+        img_bgr = img_bgra[:, :, :3]  # RGB channels only
+
+        # Apply brightness and contrast to RGB channels only
         # new_image = alpha * old_image + beta
         adjusted_img = cv2.convertScaleAbs(
             img_bgr, alpha=1 + contrast / 100.0, beta=brightness
@@ -101,11 +118,18 @@ class PhotoViewer(QGraphicsView):
             ).astype("uint8")
             adjusted_img = cv2.LUT(adjusted_img, table)
 
-        # Convert back to QImage (BGR to RGB for QImage, then to QPixmap)
-        h, w, ch = adjusted_img.shape
+        # Recombine with alpha channel to preserve transparency
+        adjusted_bgra = np.concatenate([adjusted_img, alpha_channel], axis=2)
+
+        # Convert back to QImage with alpha support
+        h, w, ch = adjusted_bgra.shape
         bytes_per_line = ch * w
         adjusted_qimage = QImage(
-            adjusted_img.data, w, h, bytes_per_line, QImage.Format.Format_BGR888
+            adjusted_bgra.data, w, h, bytes_per_line, QImage.Format.Format_ARGB32
+        )
+        # Convert to premultiplied alpha for proper blending
+        adjusted_qimage = adjusted_qimage.convertToFormat(
+            QImage.Format.Format_ARGB32_Premultiplied
         )
         self._adjusted_pixmap = QPixmap.fromImage(adjusted_qimage)
 

lazylabel/ui/widgets/channel_threshold_widget.py

@@ -372,6 +372,7 @@ class ChannelThresholdWidget(QWidget):
         super().__init__(parent)
         self.current_image_channels = 0  # 0 = no image, 1 = grayscale, 3 = RGB
         self.sliders = {}  # Dictionary of channel name -> slider
+        self.is_dragging = False  # Track if any slider is being dragged
 
         self.setupUI()
 
@@ -434,10 +435,8 @@ class ChannelThresholdWidget(QWidget):
         for channel_name in channel_names:
             slider_widget = ChannelSliderWidget(channel_name, self)
             slider_widget.valueChanged.connect(self._on_slider_changed)
-            slider_widget.dragStarted.connect(
-                self.dragStarted.emit
-            )  # Forward drag signals
-            slider_widget.dragFinished.connect(self.dragFinished.emit)
+            slider_widget.dragStarted.connect(self._on_drag_started)
+            slider_widget.dragFinished.connect(self._on_drag_finished)
             self.sliders[channel_name] = slider_widget
             self.sliders_layout.addWidget(slider_widget)
 
@@ -450,6 +449,21 @@ class ChannelThresholdWidget(QWidget):
 
     def _on_slider_changed(self):
         """Handle slider value change."""
+        # Only emit thresholdChanged if not currently dragging
+        # This prevents expensive calculations during drag operations
+        if not self.is_dragging:
+            self.thresholdChanged.emit()
+
+    def _on_drag_started(self):
+        """Handle drag start - suppress expensive calculations during drag."""
+        self.is_dragging = True
+        self.dragStarted.emit()
+
+    def _on_drag_finished(self):
+        """Handle drag finish - perform final calculation."""
+        self.is_dragging = False
+        self.dragFinished.emit()
+        # Emit threshold changed now that dragging is complete
         self.thresholdChanged.emit()
 
     def get_threshold_settings(self):

lazylabel/ui/workers/__init__.py

@@ -0,0 +1,15 @@
+"""Worker thread classes for background operations."""
+
+from .image_discovery_worker import ImageDiscoveryWorker
+from .multi_view_sam_init_worker import MultiViewSAMInitWorker
+from .multi_view_sam_update_worker import MultiViewSAMUpdateWorker
+from .sam_update_worker import SAMUpdateWorker
+from .single_view_sam_init_worker import SingleViewSAMInitWorker
+
+__all__ = [
+    "ImageDiscoveryWorker",
+    "MultiViewSAMInitWorker",
+    "MultiViewSAMUpdateWorker",
+    "SAMUpdateWorker",
+    "SingleViewSAMInitWorker",
+]

lazylabel/ui/workers/image_discovery_worker.py

@@ -0,0 +1,66 @@
+"""Worker thread for discovering image files in background."""
+
+from PyQt6.QtCore import QThread, pyqtSignal
+
+
+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)}")

lazylabel/ui/workers/multi_view_sam_init_worker.py

@@ -0,0 +1,135 @@
+"""Worker thread for initializing multi-view SAM models in background."""
+
+from PyQt6.QtCore import QThread, pyqtSignal
+
+from ...utils.logger import logger
+
+
+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))

lazylabel/ui/workers/multi_view_sam_update_worker.py

@@ -0,0 +1,158 @@
+"""Worker thread for updating SAM model image in multi-view mode."""
+
+import cv2
+import numpy as np
+from PyQt6.QtCore import Qt, QThread, pyqtSignal
+from PyQt6.QtGui import QPixmap
+
+
+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))

lazylabel/ui/workers/sam_update_worker.py

@@ -0,0 +1,129 @@
+"""Worker thread for updating SAM model in background."""
+
+import cv2
+import numpy as np
+from PyQt6.QtCore import Qt, QThread, pyqtSignal
+from PyQt6.QtGui import QPixmap
+
+
+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))