lazylabel-gui 1.2.1__py3-none-any.whl → 1.3.1__py3-none-any.whl

lazylabel/ui/modes/single_view_mode.py

@@ -0,0 +1,299 @@
+"""Single view mode handler."""
+
+from PyQt6.QtCore import QPointF, Qt
+from PyQt6.QtGui import QBrush, QColor, QPen, QPolygonF
+from PyQt6.QtWidgets import QGraphicsEllipseItem
+
+from ...utils import mask_to_pixmap
+from ..hoverable_pixelmap_item import HoverablePixmapItem
+from ..hoverable_polygon_item import HoverablePolygonItem
+from .base_mode import BaseModeHandler
+
+
+class SingleViewModeHandler(BaseModeHandler):
+    """Handler for single view mode operations."""
+
+    def handle_ai_click(self, pos, event):
+        """Handle AI mode click in single view."""
+        # Implementation moved from main_window._add_point
+        positive = event.button() == Qt.MouseButton.LeftButton
+
+        # Check if SAM model is updating
+        if self.main_window.sam_is_updating:
+            self.main_window._show_warning_notification(
+                "AI model is updating, please wait..."
+            )
+            return
+
+        # Ensure SAM model is updated
+        self.main_window._ensure_sam_updated()
+
+        # Check again if model is now updating
+        if self.main_window.sam_is_updating:
+            self.main_window._show_warning_notification(
+                "AI model is loading, please wait..."
+            )
+            return
+
+        # Transform coordinates and add point
+        sam_x, sam_y = self.main_window._transform_display_coords_to_sam_coords(pos)
+
+        point_list = (
+            self.main_window.positive_points
+            if positive
+            else self.main_window.negative_points
+        )
+        point_list.append([sam_x, sam_y])
+
+        # Add visual point
+        point_color = (
+            QColor(Qt.GlobalColor.green) if positive else QColor(Qt.GlobalColor.red)
+        )
+        point_color.setAlpha(150)
+        point_diameter = self.main_window.point_radius * 2
+
+        point_item = QGraphicsEllipseItem(
+            pos.x() - self.main_window.point_radius,
+            pos.y() - self.main_window.point_radius,
+            point_diameter,
+            point_diameter,
+        )
+        point_item.setBrush(QBrush(point_color))
+        point_item.setPen(QPen(Qt.PenStyle.NoPen))
+        self.main_window.viewer.scene().addItem(point_item)
+        self.main_window.point_items.append(point_item)
+
+        # Record the action for undo
+        self.main_window.action_history.append(
+            {
+                "type": "add_point",
+                "point_type": "positive" if positive else "negative",
+                "point_coords": [int(pos.x()), int(pos.y())],
+                "sam_coords": [sam_x, sam_y],
+                "point_item": point_item,
+                "viewer_mode": "single",
+            }
+        )
+        # Clear redo history when a new action is performed
+        self.main_window.redo_history.clear()
+
+        # Generate prediction
+        self.main_window._update_segmentation()
+
+    def handle_polygon_click(self, pos):
+        """Handle polygon mode click in single view."""
+        # Check if clicking near first point to close polygon
+        if self.main_window.polygon_points and len(self.main_window.polygon_points) > 2:
+            first_point = self.main_window.polygon_points[0]
+            distance_squared = (pos.x() - first_point.x()) ** 2 + (
+                pos.y() - first_point.y()
+            ) ** 2
+            if distance_squared < self.main_window.polygon_join_threshold**2:
+                self._finalize_polygon()
+                return
+
+        # Add point to polygon
+        self.main_window.polygon_points.append(pos)
+
+        # Add visual point
+        point_item = QGraphicsEllipseItem(pos.x() - 3, pos.y() - 3, 6, 6)
+        point_item.setBrush(QBrush(QColor(0, 255, 255)))  # Cyan
+        point_item.setPen(QPen(Qt.PenStyle.NoPen))
+        self.main_window.viewer.scene().addItem(point_item)
+        self.main_window.polygon_preview_items.append(point_item)
+
+    def handle_bbox_start(self, pos):
+        """Handle bbox mode start in single view."""
+        from PyQt6.QtWidgets import QGraphicsRectItem
+
+        self.main_window.drag_start_pos = pos
+
+        # Create rubber band rectangle
+        self.main_window.rubber_band_rect = QGraphicsRectItem()
+        self.main_window.rubber_band_rect.setPen(
+            QPen(QColor(255, 0, 0), 2, Qt.PenStyle.DashLine)
+        )
+        self.main_window.viewer.scene().addItem(self.main_window.rubber_band_rect)
+
+    def handle_bbox_drag(self, pos):
+        """Handle bbox mode drag in single view."""
+        if (
+            hasattr(self.main_window, "drag_start_pos")
+            and self.main_window.drag_start_pos
+            and hasattr(self.main_window, "rubber_band_rect")
+            and self.main_window.rubber_band_rect
+        ):
+            from PyQt6.QtCore import QRectF
+
+            # Update rubber band rectangle
+            rect = QRectF(self.main_window.drag_start_pos, pos).normalized()
+            self.main_window.rubber_band_rect.setRect(rect)
+
+    def handle_bbox_complete(self, pos):
+        """Handle bbox mode completion in single view."""
+        # Implementation from main_window._scene_mouse_release bbox handling
+        if (
+            hasattr(self.main_window, "rubber_band_rect")
+            and self.main_window.rubber_band_rect
+        ):
+            # Remove rubber band
+            self.main_window.viewer.scene().removeItem(
+                self.main_window.rubber_band_rect
+            )
+            self.main_window.rubber_band_rect = None
+
+            # Create polygon from bbox
+            start_pos = self.main_window.drag_start_pos
+            from PyQt6.QtCore import QRectF
+
+            rect = QRectF(start_pos, pos).normalized()
+            if rect.width() > 10 and rect.height() > 10:
+                # Convert to polygon
+                vertices = [
+                    [rect.left(), rect.top()],
+                    [rect.right(), rect.top()],
+                    [rect.right(), rect.bottom()],
+                    [rect.left(), rect.bottom()],
+                ]
+
+                new_segment = {
+                    "vertices": vertices,
+                    "type": "Polygon",
+                    "mask": None,
+                }
+
+                self.segment_manager.add_segment(new_segment)
+
+                # Record action for undo
+                self.main_window.action_history.append(
+                    {
+                        "type": "add_segment",
+                        "segment_index": len(self.segment_manager.segments) - 1,
+                    }
+                )
+                self.main_window.redo_history.clear()
+
+                self.main_window._update_all_lists()
+
+    def display_all_segments(self):
+        """Display all segments in single view."""
+        # Clear existing segment items
+        for _i, items in self.main_window.segment_items.items():
+            for item in items:
+                if item.scene():
+                    self.main_window.viewer.scene().removeItem(item)
+        self.main_window.segment_items.clear()
+        self.main_window._clear_edit_handles()
+
+        # Display segments from segment manager
+        for i, segment in enumerate(self.segment_manager.segments):
+            self.main_window.segment_items[i] = []
+            class_id = segment.get("class_id")
+            base_color = self.main_window._get_color_for_class(class_id)
+
+            if segment["type"] == "Polygon" and segment.get("vertices"):
+                # Convert stored list of lists back to QPointF objects
+                qpoints = [QPointF(p[0], p[1]) for p in segment["vertices"]]
+
+                poly_item = HoverablePolygonItem(QPolygonF(qpoints))
+                default_brush = QBrush(
+                    QColor(base_color.red(), base_color.green(), base_color.blue(), 70)
+                )
+                hover_brush = QBrush(
+                    QColor(base_color.red(), base_color.green(), base_color.blue(), 170)
+                )
+                poly_item.set_brushes(default_brush, hover_brush)
+                poly_item.setPen(QPen(Qt.GlobalColor.transparent))
+                self.main_window.viewer.scene().addItem(poly_item)
+                self.main_window.segment_items[i].append(poly_item)
+
+            elif segment.get("mask") is not None:
+                default_pixmap = mask_to_pixmap(
+                    segment["mask"], base_color.getRgb()[:3], alpha=70
+                )
+                hover_pixmap = mask_to_pixmap(
+                    segment["mask"], base_color.getRgb()[:3], alpha=170
+                )
+                pixmap_item = HoverablePixmapItem()
+                pixmap_item.set_pixmaps(default_pixmap, hover_pixmap)
+                self.main_window.viewer.scene().addItem(pixmap_item)
+                pixmap_item.setZValue(i + 1)
+                self.main_window.segment_items[i].append(pixmap_item)
+
+    def clear_all_points(self):
+        """Clear all temporary points in single view."""
+        if (
+            hasattr(self.main_window, "rubber_band_line")
+            and self.main_window.rubber_band_line
+        ):
+            self.main_window.viewer.scene().removeItem(
+                self.main_window.rubber_band_line
+            )
+            self.main_window.rubber_band_line = None
+
+        self.main_window.positive_points.clear()
+        self.main_window.negative_points.clear()
+
+        for item in self.main_window.point_items:
+            self.main_window.viewer.scene().removeItem(item)
+        self.main_window.point_items.clear()
+
+        self.main_window.polygon_points.clear()
+        for item in self.main_window.polygon_preview_items:
+            self.main_window.viewer.scene().removeItem(item)
+        self.main_window.polygon_preview_items.clear()
+
+        # Clear polygon lasso lines
+        if (
+            hasattr(self.main_window, "polygon_lasso_lines")
+            and self.main_window.polygon_lasso_lines
+        ):
+            for line in self.main_window.polygon_lasso_lines:
+                if line.scene():
+                    self.main_window.viewer.scene().removeItem(line)
+            self.main_window.polygon_lasso_lines.clear()
+
+        if (
+            hasattr(self.main_window, "preview_mask_item")
+            and self.main_window.preview_mask_item
+        ):
+            self.main_window.viewer.scene().removeItem(
+                self.main_window.preview_mask_item
+            )
+            self.main_window.preview_mask_item = None
+
+    def _finalize_polygon(self):
+        """Finalize polygon drawing in single view."""
+        if len(self.main_window.polygon_points) < 3:
+            return
+
+        # Clear lasso lines when finalizing
+        if (
+            hasattr(self.main_window, "polygon_lasso_lines")
+            and self.main_window.polygon_lasso_lines
+        ):
+            for line in self.main_window.polygon_lasso_lines:
+                if line.scene():
+                    self.main_window.viewer.scene().removeItem(line)
+            self.main_window.polygon_lasso_lines.clear()
+
+        new_segment = {
+            "vertices": [[p.x(), p.y()] for p in self.main_window.polygon_points],
+            "type": "Polygon",
+            "mask": None,
+        }
+
+        self.segment_manager.add_segment(new_segment)
+
+        # Record action for undo
+        self.main_window.action_history.append(
+            {
+                "type": "add_segment",
+                "segment_index": len(self.segment_manager.segments) - 1,
+            }
+        )
+        self.main_window.redo_history.clear()
+
+        self.main_window.polygon_points.clear()
+        self.clear_all_points()
+        self.main_window._update_all_lists()

lazylabel/ui/photo_viewer.py

@@ -1,11 +1,15 @@
 import cv2
 import numpy as np
-from PyQt6.QtCore import QRectF, Qt
+from PyQt6.QtCore import QRectF, Qt, pyqtSignal
 from PyQt6.QtGui import QCursor, QImage, QPixmap
 from PyQt6.QtWidgets import QGraphicsPixmapItem, QGraphicsScene, QGraphicsView
 
 
 class PhotoViewer(QGraphicsView):
+    # Signals for multi-view synchronization
+    zoom_changed = pyqtSignal(float)  # Emits zoom factor
+    view_changed = pyqtSignal()  # Emits when view (pan/zoom) changes
+
     def __init__(self, parent=None):
         super().__init__(parent)
         self._scene = QGraphicsScene(self)
@@ -18,6 +22,7 @@ class PhotoViewer(QGraphicsView):
         self.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
         self.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
         self.setDragMode(QGraphicsView.DragMode.NoDrag)
+        self.setMouseTracking(True)  # Enable mouse tracking for hover events
 
         self._original_image = None
         self._adjusted_pixmap = None
@@ -41,6 +46,10 @@ class PhotoViewer(QGraphicsView):
         if pixmap and not pixmap.isNull():
             self._original_image = pixmap.toImage()
             self._adjusted_pixmap = pixmap
+            # Check if _pixmap_item still exists, recreate if deleted
+            if self._pixmap_item not in self._scene.items():
+                self._pixmap_item = QGraphicsPixmapItem()
+                self._scene.addItem(self._pixmap_item)
             self._pixmap_item.setPixmap(pixmap)
 
             # Convert QImage to ARGB32 for consistent processing
@@ -61,12 +70,21 @@ class PhotoViewer(QGraphicsView):
             self._original_image = None
             self._adjusted_pixmap = None
             self._original_image_bgr = None
+            # Check if _pixmap_item still exists, recreate if deleted
+            if self._pixmap_item not in self._scene.items():
+                self._pixmap_item = QGraphicsPixmapItem()
+                self._scene.addItem(self._pixmap_item)
             self._pixmap_item.setPixmap(QPixmap())
 
     def set_image_adjustments(self, brightness: float, contrast: float, gamma: float):
-        if self._original_image_bgr is None:
+        if self._original_image_bgr is None or self._original_image is None:
             return
 
+        # Ensure _pixmap_item exists and is valid
+        if self._pixmap_item not in self._scene.items():
+            self._pixmap_item = QGraphicsPixmapItem()
+            self._scene.addItem(self._pixmap_item)
+
         img_bgr = self._original_image_bgr.copy()
 
         # Apply brightness and contrast
@@ -90,7 +108,10 @@ class PhotoViewer(QGraphicsView):
             adjusted_img.data, w, h, bytes_per_line, QImage.Format.Format_BGR888
         )
         self._adjusted_pixmap = QPixmap.fromImage(adjusted_qimage)
-        self._pixmap_item.setPixmap(self._adjusted_pixmap)
+
+        # Ensure the pixmap is valid before setting it
+        if not self._adjusted_pixmap.isNull():
+            self._pixmap_item.setPixmap(self._adjusted_pixmap)
 
     def set_cursor(self, cursor_shape):
         self.viewport().setCursor(QCursor(cursor_shape))
@@ -103,3 +124,10 @@ class PhotoViewer(QGraphicsView):
         if not self._pixmap_item.pixmap().isNull():
             factor = 1.25 if event.angleDelta().y() > 0 else 0.8
             self.scale(factor, factor)
+            # Emit zoom signal for multi-view synchronization
+            self.zoom_changed.emit(factor)
+
+    def sync_zoom(self, factor):
+        """Synchronize zoom from another viewer."""
+        if not self._pixmap_item.pixmap().isNull():
+            self.scale(factor, factor)

lazylabel/ui/test_hover.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+"""
+Test script to check hover functionality.
+Run this before starting LazyLabel to enable debug logging.
+"""
+
+# First, enable debug logging
+import logging
+import os
+import sys
+
+# Add the src directory to path so we can import LazyLabel modules
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "src"))
+
+from lazylabel.utils.logger import logger
+
+# Set logger to DEBUG level
+logger.setLevel(logging.DEBUG)
+
+# Add console handler if not already present
+if not logger.handlers:
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.DEBUG)
+    formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+
+print("=" * 50)
+print("HOVER DEBUG MODE ENABLED")
+print("=" * 50)
+print("Logger level:", logger.level)
+print("Logger handlers:", len(logger.handlers))
+print()
+print("Now run LazyLabel and test hover functionality:")
+print("1. Load images in multi-view mode")
+print("2. Create some segments (AI or polygon)")
+print("3. Try hovering over segments")
+print("4. Watch the console for debug messages")
+print()
+print("Expected debug messages:")
+print("- HoverablePolygonItem.set_segment_info")
+print("- HoverablePixmapItem.set_segment_info")
+print("- HoverablePolygonItem.hoverEnterEvent")
+print("- HoverablePixmapItem.hoverEnterEvent")
+print("- _trigger_segment_hover called")
+print("=" * 50)

lazylabel/ui/widgets/adjustments_widget.py

@@ -50,9 +50,9 @@ class AdjustmentsWidget(QWidget):
                 Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter
             )
 
-            # Text edit with smaller width
+            # Text edit with width to show numbers like 1.00 and -1.00
             text_edit = QLineEdit(str(default_value))
-            text_edit.setFixedWidth(35)
+            text_edit.setFixedWidth(45)  # Increased from 35 to 45
 
             # Slider takes remaining space
             slider = QSlider(Qt.Orientation.Horizontal)

lazylabel/ui/widgets/border_crop_widget.py

@@ -188,6 +188,17 @@ class BorderCropWidget(QWidget):
         """Check if crop coordinates are set."""
         return self.get_crop_coordinates() is not None
 
+    def disable_thresholding_for_multi_view(self):
+        """Disable thresholding controls for multi-view mode."""
+        # This method is called when entering multi-view mode
+        # to handle mixed BW/RGB images
+        pass
+
+    def enable_thresholding(self):
+        """Re-enable thresholding controls when exiting multi-view mode."""
+        # This method is called when exiting multi-view mode
+        pass
+
     def _get_button_style(self):
         """Get consistent button styling."""
         return """

lazylabel/ui/widgets/channel_threshold_widget.py

@@ -70,7 +70,12 @@ class MultiIndicatorSlider(QWidget):
         slider_rect = self.get_slider_rect()
         ratio = (x - slider_rect.left()) / slider_rect.width()
         ratio = max(0, min(1, ratio))  # Clamp to [0, 1]
-        return int(self.minimum + ratio * (self.maximum - self.minimum))
+        value = self.minimum + ratio * (self.maximum - self.minimum)
+        # Use integer values for channel thresholds (0-255) and intensity sliders, float for frequency sliders (0-10000)
+        if self.maximum <= 255 or self.maximum == 256:
+            return int(value)
+        else:
+            return value
 
     def paintEvent(self, event):
         """Paint the slider."""
@@ -138,7 +143,8 @@ class MultiIndicatorSlider(QWidget):
                 painter.setPen(QPen(Qt.GlobalColor.transparent))
                 painter.drawRoundedRect(segment_rect, 5, 5)
 
-        # Draw indicators
+        # Draw indicators and collect label positions to avoid overlaps
+        label_positions = []
         for i, value in enumerate(self.indicators):
             x = self.value_to_x(value)
 
@@ -157,9 +163,47 @@ class MultiIndicatorSlider(QWidget):
 
             painter.drawRoundedRect(handle_rect, 3, 3)
 
-            # Value label
-            painter.setPen(QPen(QColor(255, 255, 255)))
-            painter.drawText(x - 15, slider_rect.bottom() + 15, f"{value}")
+            # Store label info for non-overlapping positioning
+            label_text = f"{int(value)}"
+            label_positions.append((x, label_text))
+
+        # Draw labels with overlap prevention
+        self._draw_non_overlapping_labels(painter, slider_rect, label_positions)
+
+    def _draw_non_overlapping_labels(self, painter, slider_rect, label_positions):
+        """Draw labels with spacing to prevent overlaps."""
+        if not label_positions:
+            return
+
+        painter.setPen(QPen(QColor(255, 255, 255)))
+
+        # Sort by x position
+        sorted_labels = sorted(label_positions, key=lambda item: item[0])
+
+        # Minimum spacing between labels (in pixels)
+        min_spacing = 30
+
+        # Adjust positions to prevent overlaps
+        adjusted_positions = []
+        for i, (x, text) in enumerate(sorted_labels):
+            if i == 0:
+                adjusted_positions.append((x, text))
+            else:
+                prev_x = adjusted_positions[-1][0]
+                if x - prev_x < min_spacing:
+                    # Move this label to maintain minimum spacing
+                    new_x = prev_x + min_spacing
+                    # But don't go beyond the slider bounds
+                    slider_right = slider_rect.right() - 15
+                    if new_x > slider_right:
+                        new_x = slider_right
+                    adjusted_positions.append((new_x, text))
+                else:
+                    adjusted_positions.append((x, text))
+
+        # Draw the adjusted labels
+        for x, text in adjusted_positions:
+            painter.drawText(int(x - 15), slider_rect.bottom() + 15, text)
 
     def mousePressEvent(self, event):
         """Handle mouse press events."""
@@ -352,7 +396,7 @@ class ChannelThresholdWidget(QWidget):
 
         # Instructions
         instructions = QLabel(
-            "✓ Check to enable • Double-click to add threshold • Right-click to remove"
+            "✓ Check to enable\n• Double-click to add threshold\n• Right-click to remove"
         )
         instructions.setStyleSheet("color: #888; font-size: 9px;")
         instructions.setWordWrap(True)