lazylabel-gui 1.3.4__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/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))

lazylabel/ui/workers/single_view_sam_init_worker.py

@@ -0,0 +1,61 @@
+"""Worker thread for initializing single-view SAM model in background."""
+
+import os
+
+from PyQt6.QtCore import QThread, pyqtSignal
+
+
+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)}")

{lazylabel_gui-1.3.4.dist-info → lazylabel_gui-1.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lazylabel-gui
-Version: 1.3.4
+Version: 1.3.5
 Summary: An image segmentation GUI for generating ML ready mask tensors and annotations.
 Author-email: "Deniz N. Cakan" <deniz.n.cakan@gmail.com>
 License: MIT License