lazylabel-gui 1.2.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

lazylabel/config/settings.py

@@ -42,6 +42,9 @@ class Settings:
     # UI State
     annotation_size_multiplier: float = 1.0
 
+    # Multi-view Settings
+    multi_view_grid_mode: str = "2_view"  # "2_view" or "4_view"
+
     def save_to_file(self, filepath: str) -> None:
         """Save settings to JSON file."""
         os.makedirs(os.path.dirname(filepath), exist_ok=True)

lazylabel/main.py

@@ -23,6 +23,7 @@ def main():
     logger.info("Step 3/8: Applying dark theme...")
     qdarktheme.setup_theme()
 
+    logger.info("Step 4/8: Setting up main window...")
     main_window = MainWindow()
 
     logger.info("Step 7/8: Showing main window...")

lazylabel/models/sam2_model.py

@@ -1,4 +1,5 @@
 import os
+from pathlib import Path
 
 import cv2
 import numpy as np
@@ -45,8 +46,91 @@ class Sam2Model:
             logger.info(f"SAM2: Loading model from {model_path}...")
             logger.info(f"SAM2: Using config: {config_path}")
 
+            # Ensure config_path is absolute
+            if not os.path.isabs(config_path):
+                # Try to make it absolute if it's relative
+                import sam2
+
+                sam2_dir = os.path.dirname(sam2.__file__)
+                config_path = os.path.join(sam2_dir, "configs", config_path)
+
+            # Verify the config exists before passing to build_sam2
+            if not os.path.exists(config_path):
+                raise FileNotFoundError(f"Config file not found: {config_path}")
+
+            logger.info(f"SAM2: Resolved config path: {config_path}")
+
             # Build SAM2 model
-            self.model = build_sam2(config_path, model_path, device=self.device)
+            # SAM2 uses Hydra for configuration - we need to pass the right config name
+            # Try different approaches based on what's available
+
+            model_filename = Path(model_path).name.lower()
+
+            # First, try using the auto-detected config path directly
+            try:
+                logger.info(f"SAM2: Attempting to load with config path: {config_path}")
+                self.model = self._build_sam2_with_fallback(config_path, model_path)
+                logger.info("SAM2: Successfully loaded with config path")
+            except Exception as e1:
+                logger.debug(f"SAM2: Config path approach failed: {e1}")
+
+                # Second, try just the config filename without path
+                try:
+                    config_filename = Path(config_path).name
+                    logger.info(
+                        f"SAM2: Attempting to load with config filename: {config_filename}"
+                    )
+                    self.model = self._build_sam2_with_fallback(
+                        config_filename, model_path
+                    )
+                    logger.info("SAM2: Successfully loaded with config filename")
+                except Exception as e2:
+                    logger.debug(f"SAM2: Config filename approach failed: {e2}")
+
+                    # Third, try the base config name without version
+                    try:
+                        # Map model sizes to base config names
+                        if (
+                            "tiny" in model_filename
+                            or "_t." in model_filename
+                            or "_t_" in model_filename
+                        ):
+                            base_config = "sam2_hiera_t.yaml"
+                        elif (
+                            "small" in model_filename
+                            or "_s." in model_filename
+                            or "_s_" in model_filename
+                        ):
+                            base_config = "sam2_hiera_s.yaml"
+                        elif (
+                            "base_plus" in model_filename
+                            or "_b+." in model_filename
+                            or "_b+_" in model_filename
+                        ):
+                            base_config = "sam2_hiera_b+.yaml"
+                        elif (
+                            "large" in model_filename
+                            or "_l." in model_filename
+                            or "_l_" in model_filename
+                        ):
+                            base_config = "sam2_hiera_l.yaml"
+                        else:
+                            base_config = "sam2_hiera_l.yaml"
+
+                        logger.info(
+                            f"SAM2: Attempting to load with base config: {base_config}"
+                        )
+                        self.model = self._build_sam2_with_fallback(
+                            base_config, model_path
+                        )
+                        logger.info("SAM2: Successfully loaded with base config")
+                    except Exception as e3:
+                        # All approaches failed
+                        raise Exception(
+                            f"Failed to load SAM2 model with any config approach. "
+                            f"Tried: {config_path}, {config_filename}, {base_config}. "
+                            f"Last error: {e3}"
+                        ) from e3
 
             # Create predictor
             self.predictor = SAM2ImagePredictor(self.model)
@@ -61,14 +145,15 @@ class Sam2Model:
 
     def _auto_detect_config(self, model_path: str) -> str:
         """Auto-detect the appropriate config file based on model filename."""
-        filename = os.path.basename(model_path).lower()
+        model_path = Path(model_path)
+        filename = model_path.name.lower()
 
         # Get the sam2 package directory
         try:
             import sam2
 
-            sam2_dir = os.path.dirname(sam2.__file__)
-            configs_dir = os.path.join(sam2_dir, "configs")
+            sam2_dir = Path(sam2.__file__).parent
+            configs_dir = sam2_dir / "configs"
 
             # Map model types to config files
             if "tiny" in filename or "_t" in filename:
@@ -95,26 +180,89 @@ class Sam2Model:
 
             # Check sam2.1 configs first, then fall back to sam2
             if "2.1" in filename:
-                config_path = os.path.join(configs_dir, "sam2.1", config_file)
+                config_path = configs_dir / "sam2.1" / config_file
             else:
-                config_path = os.path.join(
-                    configs_dir, "sam2", config_file.replace("2.1_", "")
-                )
+                config_path = configs_dir / "sam2" / config_file.replace("2.1_", "")
 
-            if os.path.exists(config_path):
-                return config_path
+            logger.debug(f"SAM2: Checking config path: {config_path}")
+            if config_path.exists():
+                return str(config_path.absolute())
 
             # Fallback to default large config
-            fallback_config = os.path.join(configs_dir, "sam2.1", "sam2.1_hiera_l.yaml")
-            if os.path.exists(fallback_config):
-                return fallback_config
-
-            raise FileNotFoundError(f"No suitable config found for {filename}")
+            fallback_config = configs_dir / "sam2.1" / "sam2.1_hiera_l.yaml"
+            logger.debug(f"SAM2: Checking fallback config: {fallback_config}")
+            if fallback_config.exists():
+                return str(fallback_config.absolute())
+
+            # Try without version subdirectory
+            direct_config = configs_dir / config_file
+            logger.debug(f"SAM2: Checking direct config: {direct_config}")
+            if direct_config.exists():
+                return str(direct_config.absolute())
+
+            raise FileNotFoundError(
+                f"No suitable config found for {filename} in {configs_dir}"
+            )
 
         except Exception as e:
             logger.error(f"SAM2: Failed to auto-detect config: {e}")
-            # Return a reasonable default path
-            return "sam2.1_hiera_l.yaml"
+            # Try to construct a full path even if auto-detection failed
+            try:
+                import sam2
+
+                sam2_dir = Path(sam2.__file__).parent
+                # Return full path to default config
+                return str(sam2_dir / "configs" / "sam2.1" / "sam2.1_hiera_l.yaml")
+            except Exception:
+                # Last resort - return just the config name and let hydra handle it
+                return "sam2.1_hiera_l.yaml"
+
+    def _build_sam2_with_fallback(self, config_path, model_path):
+        """Build SAM2 model with fallback for state_dict compatibility issues."""
+        try:
+            # First, try the standard build_sam2 approach
+            return build_sam2(config_path, model_path, device=self.device)
+        except RuntimeError as e:
+            if "Unexpected key(s) in state_dict" in str(e):
+                logger.warning(f"SAM2: Detected state_dict compatibility issue: {e}")
+                logger.info("SAM2: Attempting to load with state_dict filtering...")
+
+                # Build model without loading weights first
+                model = build_sam2(config_path, None, device=self.device)
+
+                # Load checkpoint and handle nested structure
+                checkpoint = torch.load(model_path, map_location=self.device)
+
+                # Check if checkpoint has nested 'model' key (common in SAM2.1)
+                if "model" in checkpoint and isinstance(checkpoint["model"], dict):
+                    logger.info(
+                        "SAM2: Detected nested checkpoint structure, extracting model weights"
+                    )
+                    model_weights = checkpoint["model"]
+                else:
+                    # Flat structure - filter out the known problematic keys
+                    model_weights = {}
+                    problematic_keys = {
+                        "no_obj_embed_spatial",
+                        "obj_ptr_tpos_proj.weight",
+                        "obj_ptr_tpos_proj.bias",
+                    }
+                    for key, value in checkpoint.items():
+                        if key not in problematic_keys:
+                            model_weights[key] = value
+
+                    logger.info(
+                        f"SAM2: Filtered out problematic keys: {list(problematic_keys & set(checkpoint.keys()))}"
+                    )
+
+                # Load the model weights
+                model.load_state_dict(model_weights, strict=False)
+                logger.info("SAM2: Successfully loaded model with state_dict filtering")
+
+                return model
+            else:
+                # Re-raise if it's a different type of error
+                raise
 
     def set_image_from_path(self, image_path: str) -> bool:
         """Set image for SAM2 model from file path."""
@@ -204,7 +352,7 @@ class Sam2Model:
                 config_path = self._auto_detect_config(model_path)
 
             # Load new model
-            self.model = build_sam2(config_path, model_path, device=self.device)
+            self.model = self._build_sam2_with_fallback(config_path, model_path)
             self.predictor = SAM2ImagePredictor(self.model)
             self.current_model_path = model_path
             self.is_loaded = True

lazylabel/ui/control_panel.py

@@ -48,7 +48,7 @@ class SimpleCollapsible(QWidget):
                 border: 1px solid rgba(120, 120, 120, 0.5);
                 background: rgba(70, 70, 70, 0.6);
                 color: #E0E0E0;
-                font-size: 10px;
+                font-size: 11px;
                 font-weight: bold;
                 border-radius: 2px;
             }
@@ -71,7 +71,7 @@ class SimpleCollapsible(QWidget):
             QLabel {
                 color: #E0E0E0;
                 font-weight: bold;
-                font-size: 11px;
+                font-size: 12px;
                 background: transparent;
                 border: none;
                 padding: 2px;
@@ -202,8 +202,8 @@ class ControlPanel(QWidget):
 
     def __init__(self, parent=None):
         super().__init__(parent)
-        self.setMinimumWidth(260)  # Slightly wider for better layout
-        self.preferred_width = 280
+        self.setMinimumWidth(300)  # Wider for better text fitting
+        self.preferred_width = 320
         self._setup_ui()
         self._connect_signals()
 
@@ -274,9 +274,9 @@ class ControlPanel(QWidget):
                 padding: 4px 8px;
                 margin-right: 1px;
                 color: #B0B0B0;
-                font-size: 9px;
-                min-width: 45px;
-                max-width: 80px;
+                font-size: 11px;
+                min-width: 50px;
+                max-width: 100px;
             }
             QTabBar::tab:selected {
                 background-color: rgba(70, 70, 70, 0.9);
@@ -307,7 +307,7 @@ class ControlPanel(QWidget):
             QLabel {
                 color: #FFA500;
                 font-style: italic;
-                font-size: 9px;
+                font-size: 10px;
                 background: transparent;
                 border: none;
                 padding: 4px;
@@ -389,7 +389,7 @@ class ControlPanel(QWidget):
         button = QPushButton(f"{text} ({key})")
         button.setToolTip(f"{tooltip} ({key})")
         button.setFixedHeight(28)
-        button.setFixedWidth(75)  # Fixed width for consistency
+        button.setFixedWidth(90)  # Wider for better text fitting
         button.setStyleSheet(
             """
             QPushButton {
@@ -398,7 +398,7 @@ class ControlPanel(QWidget):
                 border-radius: 6px;
                 color: #E0E0E0;
                 font-weight: bold;
-                font-size: 10px;
+                font-size: 11px;
                 padding: 4px 8px;
             }
             QPushButton:hover {
@@ -434,7 +434,7 @@ class ControlPanel(QWidget):
         button = QPushButton(button_text)
         button.setToolTip(tooltip_text)
         button.setFixedHeight(28)
-        button.setFixedWidth(75)  # Fixed width for consistency
+        button.setFixedWidth(90)  # Wider for better text fitting
         button.setStyleSheet(
             """
             QPushButton {
@@ -443,7 +443,7 @@ class ControlPanel(QWidget):
                 border-radius: 6px;
                 color: #E0E0E0;
                 font-weight: bold;
-                font-size: 10px;
+                font-size: 11px;
                 padding: 4px 8px;
             }
             QPushButton:hover {
@@ -476,7 +476,7 @@ class ControlPanel(QWidget):
                 border-radius: 6px;
                 color: #E0E0E0;
                 font-weight: bold;
-                font-size: 10px;
+                font-size: 11px;
                 padding: 4px 8px;
                 min-height: 22px;
             }
@@ -497,7 +497,7 @@ class ControlPanel(QWidget):
                 border: 1px solid rgba(100, 100, 100, 0.6);
                 border-radius: 5px;
                 color: #E0E0E0;
-                font-size: 10px;
+                font-size: 11px;
                 padding: 4px 8px;
                 min-height: 22px;
             }
@@ -617,10 +617,11 @@ class ControlPanel(QWidget):
         )
         layout.addWidget(threshold_collapsible)
 
-        # FFT Threshold - collapsible
+        # FFT Threshold - collapsible (default collapsed)
         self.fft_threshold_collapsible = SimpleCollapsible(
             "FFT Threshold", self.fft_threshold_widget
         )
+        self.fft_threshold_collapsible.set_collapsed(True)  # Default to collapsed
         layout.addWidget(self.fft_threshold_collapsible)
 
         # Image Adjustments - collapsible
@@ -761,6 +762,7 @@ class ControlPanel(QWidget):
         # Map internal mode names to buttons
         mode_buttons = {
             "sam_points": self.btn_sam_mode,
+            "ai": self.btn_sam_mode,  # AI mode uses the same button as SAM mode
             "polygon": self.btn_polygon_mode,
             "bbox": self.btn_bbox_mode,
             "selection": self.btn_selection_mode,

lazylabel/ui/editable_vertex.py

@@ -62,3 +62,75 @@ class EditableVertexItem(QGraphicsEllipseItem):
         self.initial_pos = None
         super().mouseReleaseEvent(event)
         event.accept()
+
+
+class MultiViewEditableVertexItem(QGraphicsEllipseItem):
+    """Editable vertex item for multi-view mode that can sync changes across viewers."""
+
+    def __init__(
+        self, main_window, segment_index, vertex_index, viewer_index, x, y, w, h
+    ):
+        super().__init__(x, y, w, h)
+        self.main_window = main_window
+        self.segment_index = segment_index
+        self.vertex_index = vertex_index
+        self.viewer_index = viewer_index
+        self.initial_pos = None
+
+        self.setZValue(200)
+
+        color = QColor(Qt.GlobalColor.cyan)
+        color.setAlpha(180)
+        self.setBrush(QBrush(color))
+
+        self.setPen(QPen(Qt.GlobalColor.transparent))
+
+        # Set flags for dragging
+        self.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIsMovable)
+        self.setFlag(QGraphicsItem.GraphicsItemFlag.ItemSendsGeometryChanges)
+        self.setFlag(QGraphicsItem.GraphicsItemFlag.ItemIsSelectable)
+
+        # Accept mouse events
+        self.setAcceptHoverEvents(True)
+
+    def itemChange(self, change, value):
+        if change == QGraphicsItem.GraphicsItemChange.ItemPositionHasChanged:
+            new_pos = value
+            if hasattr(self.main_window, "update_multi_view_vertex_pos"):
+                self.main_window.update_multi_view_vertex_pos(
+                    self.segment_index,
+                    self.vertex_index,
+                    self.viewer_index,
+                    new_pos,
+                    record_undo=False,
+                )
+        return super().itemChange(change, value)
+
+    def mousePressEvent(self, event):
+        """Handle mouse press events."""
+        self.initial_pos = self.pos()
+        super().mousePressEvent(event)
+        event.accept()
+
+    def mouseMoveEvent(self, event):
+        """Handle mouse move events."""
+        super().mouseMoveEvent(event)
+        event.accept()
+
+    def mouseReleaseEvent(self, event):
+        """Handle mouse release events."""
+        if self.initial_pos and self.initial_pos != self.pos():
+            self.main_window.action_history.append(
+                {
+                    "type": "move_vertex",
+                    "viewer_mode": "multi",
+                    "viewer_index": self.viewer_index,
+                    "segment_index": self.segment_index,
+                    "vertex_index": self.vertex_index,
+                    "old_pos": [self.initial_pos.x(), self.initial_pos.y()],
+                    "new_pos": [self.pos().x(), self.pos().y()],
+                }
+            )
+        self.initial_pos = None
+        super().mouseReleaseEvent(event)
+        event.accept()

lazylabel/ui/hoverable_pixelmap_item.py

@@ -7,16 +7,41 @@ class HoverablePixmapItem(QGraphicsPixmapItem):
         self.setAcceptHoverEvents(True)
         self.default_pixmap = None
         self.hover_pixmap = None
+        self.segment_id = None
+        self.main_window = None
 
     def set_pixmaps(self, default_pixmap, hover_pixmap):
         self.default_pixmap = default_pixmap
         self.hover_pixmap = hover_pixmap
         self.setPixmap(self.default_pixmap)
 
+    def set_segment_info(self, segment_id, main_window):
+        self.segment_id = segment_id
+        self.main_window = main_window
+
+    def set_hover_state(self, hover_state):
+        """Set hover state without triggering hover events."""
+        self.setPixmap(self.hover_pixmap if hover_state else self.default_pixmap)
+
     def hoverEnterEvent(self, event):
         self.setPixmap(self.hover_pixmap)
+        # Trigger hover on mirror segments in multi-view mode
+        if (
+            self.main_window
+            and hasattr(self.main_window, "view_mode")
+            and self.main_window.view_mode == "multi"
+            and hasattr(self.main_window, "_trigger_segment_hover")
+        ):
+            self.main_window._trigger_segment_hover(self.segment_id, True, self)
         super().hoverEnterEvent(event)
 
     def hoverLeaveEvent(self, event):
         self.setPixmap(self.default_pixmap)
+        # Trigger unhover on mirror segments in multi-view mode
+        if (
+            self.main_window
+            and hasattr(self.main_window, "view_mode")
+            and self.main_window.view_mode == "multi"
+        ):
+            self.main_window._trigger_segment_hover(self.segment_id, False, self)
         super().hoverLeaveEvent(event)

lazylabel/ui/hoverable_polygon_item.py

@@ -8,18 +8,44 @@ class HoverablePolygonItem(QGraphicsPolygonItem):
         self.setAcceptHoverEvents(True)
         self.default_brush = QBrush()
         self.hover_brush = QBrush()
+        self.segment_id = None
+        self.main_window = None
 
     def set_brushes(self, default_brush, hover_brush):
         self.default_brush = default_brush
         self.hover_brush = hover_brush
         self.setBrush(self.default_brush)
 
+    def set_segment_info(self, segment_id, main_window):
+        self.segment_id = segment_id
+        self.main_window = main_window
+
+    def set_hover_state(self, hover_state):
+        """Set hover state without triggering hover events."""
+        self.setBrush(self.hover_brush if hover_state else self.default_brush)
+
     def hoverEnterEvent(self, event):
         self.setBrush(self.hover_brush)
+
+        # Trigger hover on mirror segments in multi-view mode
+        if (
+            self.main_window
+            and hasattr(self.main_window, "view_mode")
+            and self.main_window.view_mode == "multi"
+            and hasattr(self.main_window, "_trigger_segment_hover")
+        ):
+            self.main_window._trigger_segment_hover(self.segment_id, True, self)
         super().hoverEnterEvent(event)
 
     def hoverLeaveEvent(self, event):
         self.setBrush(self.default_brush)
+        # Trigger unhover on mirror segments in multi-view mode
+        if (
+            self.main_window
+            and hasattr(self.main_window, "view_mode")
+            and self.main_window.view_mode == "multi"
+        ):
+            self.main_window._trigger_segment_hover(self.segment_id, False, self)
         super().hoverLeaveEvent(event)
 
     def mousePressEvent(self, event):