lazylabel-gui 1.3.3__py3-none-any.whl → 1.3.5__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

@@ -270,10 +270,6 @@ class MultiIndicatorSlider(QWidget):
         """Handle right-click to remove indicator."""
         slider_rect = self.get_slider_rect()
 
-        # Only allow removal if more than 1 indicator
-        if len(self.indicators) <= 1:
-            return
-
         # Check if right-clicking on an indicator
         for i, value in enumerate(self.indicators):
             x = self.value_to_x(value)
@@ -473,7 +469,7 @@ class ChannelThresholdWidget(QWidget):
 
         if self.current_image_channels == 1:
             # Grayscale image
-            if "Gray" in self.sliders:
+            if "Gray" in self.sliders and self.sliders["Gray"].is_enabled():
                 result = self._apply_channel_thresholding(
                     result, self.sliders["Gray"].get_indicators()
                 )
@@ -481,7 +477,10 @@ class ChannelThresholdWidget(QWidget):
             # RGB image
             channel_names = ["Red", "Green", "Blue"]
             for i, channel_name in enumerate(channel_names):
-                if channel_name in self.sliders:
+                if (
+                    channel_name in self.sliders
+                    and self.sliders[channel_name].is_enabled()
+                ):
                     result[:, :, i] = self._apply_channel_thresholding(
                         result[:, :, i], self.sliders[channel_name].get_indicators()
                     )
@@ -494,7 +493,7 @@ class ChannelThresholdWidget(QWidget):
         if not indicators:
             return channel_data
 
-            # Sort indicators
+        # Sort indicators
         sorted_indicators = sorted(indicators)
 
         # Create output array
@@ -527,9 +526,9 @@ class ChannelThresholdWidget(QWidget):
         return result
 
     def has_active_thresholding(self):
-        """Check if any channel has active thresholding (indicators present)."""
+        """Check if any channel has active thresholding (enabled and indicators present)."""
         for slider_widget in self.sliders.values():
-            if slider_widget.get_indicators():
+            if slider_widget.is_enabled() and slider_widget.get_indicators():
                 return True
         return False
 

lazylabel/ui/widgets/fft_threshold_widget.py

@@ -308,6 +308,8 @@ class FFTThresholdWidget(QWidget):
                 self.status_label.setStyleSheet(
                     "color: #F44336; font-size: 9px; font-style: italic;"
                 )
+                # Disable FFT processing for color images
+                self.enable_checkbox.setChecked(False)
         else:
             # Unknown format
             self.current_image_channels = 0
@@ -315,6 +317,8 @@ class FFTThresholdWidget(QWidget):
             self.status_label.setStyleSheet(
                 "color: #F44336; font-size: 9px; font-style: italic;"
             )
+            # Disable FFT processing for unsupported formats
+            self.enable_checkbox.setChecked(False)
 
     def is_active(self):
         """Check if FFT processing is active (checkbox enabled and image is grayscale)."""

lazylabel/ui/widgets/model_selection_widget.py

@@ -111,6 +111,15 @@ class CustomDropdown(QToolButton):
             text, _ = self.items[index]
             self.setText(text)
 
+    def count(self):
+        """Get number of items."""
+        return len(self.items)
+
+    def currentData(self):
+        """Get data of currently selected item."""
+        current_idx = self.currentIndex()
+        return self.itemData(current_idx)
+
     def blockSignals(self, block):
         """Block/unblock signals."""
         super().blockSignals(block)

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))