lazylabel-gui 1.1.4__py3-none-any.whl → 1.1.6__py3-none-any.whl

lazylabel/__main__.py

@@ -0,0 +1,6 @@
+"""Allow LazyLabel to be run as a module with python -m lazylabel."""
+
+from .main import main
+
+if __name__ == "__main__":
+    main()

lazylabel/config/settings.py

@@ -1,65 +1,72 @@
-"""Application settings and configuration."""
-
-import json
-import os
-from dataclasses import asdict, dataclass
-
-
-@dataclass
-class Settings:
-    """Application settings with defaults."""
-
-    # UI Settings
-    window_width: int = 1600
-    window_height: int = 900
-    left_panel_width: int = 250
-    right_panel_width: int = 350
-
-    # Annotation Settings
-    point_radius: float = 0.3
-    line_thickness: float = 0.5
-    pan_multiplier: float = 1.0
-    polygon_join_threshold: int = 2
-
-    # Model Settings
-    default_model_type: str = "vit_h"
-    default_model_filename: str = "sam_vit_h_4b8939.pth"
-
-    # Save Settings
-    auto_save: bool = True
-    save_npz: bool = True
-    save_txt: bool = True
-    save_class_aliases: bool = False
-    yolo_use_alias: bool = True
-
-    # UI State
-    annotation_size_multiplier: float = 1.0
-
-    def save_to_file(self, filepath: str) -> None:
-        """Save settings to JSON file."""
-        os.makedirs(os.path.dirname(filepath), exist_ok=True)
-        with open(filepath, "w") as f:
-            json.dump(asdict(self), f, indent=4)
-
-    @classmethod
-    def load_from_file(cls, filepath: str) -> "Settings":
-        """Load settings from JSON file."""
-        if not os.path.exists(filepath):
-            return cls()
-
-        try:
-            with open(filepath) as f:
-                data = json.load(f)
-            return cls(**data)
-        except (json.JSONDecodeError, TypeError):
-            return cls()
-
-    def update(self, **kwargs) -> None:
-        """Update settings with new values."""
-        for key, value in kwargs.items():
-            if hasattr(self, key):
-                setattr(self, key, value)
-
-
-# Default settings instance
-DEFAULT_SETTINGS = Settings()
+"""Application settings and configuration."""
+
+import json
+import os
+from dataclasses import asdict, dataclass
+
+
+@dataclass
+class Settings:
+    """Application settings with defaults."""
+
+    # UI Settings
+    window_width: int = 1600
+    window_height: int = 900
+    left_panel_width: int = 250
+    right_panel_width: int = 350
+
+    # Annotation Settings
+    point_radius: float = 0.3
+    line_thickness: float = 0.5
+    pan_multiplier: float = 1.0
+    polygon_join_threshold: int = 2
+    fragment_threshold: int = 0
+
+    # Image Adjustment Settings
+    brightness: float = 0.0
+    contrast: float = 0.0
+    gamma: float = 1.0
+
+    # Model Settings
+    default_model_type: str = "vit_h"
+    default_model_filename: str = "sam_vit_h_4b8939.pth"
+    operate_on_view: bool = False
+
+    # Save Settings
+    auto_save: bool = True
+    save_npz: bool = True
+    save_txt: bool = True
+    save_class_aliases: bool = False
+    yolo_use_alias: bool = True
+
+    # UI State
+    annotation_size_multiplier: float = 1.0
+
+    def save_to_file(self, filepath: str) -> None:
+        """Save settings to JSON file."""
+        os.makedirs(os.path.dirname(filepath), exist_ok=True)
+        with open(filepath, "w") as f:
+            json.dump(asdict(self), f, indent=4)
+
+    @classmethod
+    def load_from_file(cls, filepath: str) -> "Settings":
+        """Load settings from JSON file."""
+        if not os.path.exists(filepath):
+            return cls()
+
+        try:
+            with open(filepath) as f:
+                data = json.load(f)
+            return cls(**data)
+        except (json.JSONDecodeError, TypeError):
+            return cls()
+
+    def update(self, **kwargs) -> None:
+        """Update settings with new values."""
+        for key, value in kwargs.items():
+            if hasattr(self, key):
+                setattr(self, key, value)
+
+
+# Default settings instance
+DEFAULT_SETTINGS = Settings()

lazylabel/core/file_manager.py

@@ -1,122 +1,123 @@
-"""File management functionality."""
-
-import json
-import os
-
-import cv2
-import numpy as np
-
-from .segment_manager import SegmentManager
-
-
-class FileManager:
-    """Manages file operations for saving and loading."""
-
-    def __init__(self, segment_manager: SegmentManager):
-        self.segment_manager = segment_manager
-
-    def save_npz(
-        self, image_path: str, image_size: tuple[int, int], class_order: list[int]
-    ) -> str:
-        """Save segments as NPZ file."""
-        final_mask_tensor = self.segment_manager.create_final_mask_tensor(
-            image_size, class_order
-        )
-        npz_path = os.path.splitext(image_path)[0] + ".npz"
-        np.savez_compressed(npz_path, mask=final_mask_tensor.astype(np.uint8))
-        return npz_path
-
-    def save_yolo_txt(
-        self,
-        image_path: str,
-        image_size: tuple[int, int],
-        class_order: list[int],
-        class_labels: list[str],
-    ) -> str | None:
-        """Save segments as YOLO format TXT file."""
-        final_mask_tensor = self.segment_manager.create_final_mask_tensor(
-            image_size, class_order
-        )
-        output_path = os.path.splitext(image_path)[0] + ".txt"
-        h, w = image_size
-
-        yolo_annotations = []
-        for channel in range(final_mask_tensor.shape[2]):
-            single_channel_image = final_mask_tensor[:, :, channel]
-            if not np.any(single_channel_image):
-                continue
-
-            contours, _ = cv2.findContours(
-                single_channel_image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
-            )
-
-            class_label = class_labels[channel]
-            for contour in contours:
-                x, y, width, height = cv2.boundingRect(contour)
-                center_x = (x + width / 2) / w
-                center_y = (y + height / 2) / h
-                normalized_width = width / w
-                normalized_height = height / h
-                yolo_entry = f"{class_label} {center_x} {center_y} {normalized_width} {normalized_height}"
-                yolo_annotations.append(yolo_entry)
-
-        if not yolo_annotations:
-            return None
-
-        os.makedirs(os.path.dirname(output_path), exist_ok=True)
-        with open(output_path, "w") as file:
-            for annotation in yolo_annotations:
-                file.write(annotation + "\n")
-
-        return output_path
-
-    def save_class_aliases(self, image_path: str) -> str:
-        """Save class aliases as JSON file."""
-        aliases_path = os.path.splitext(image_path)[0] + ".json"
-        aliases_to_save = {
-            str(k): v for k, v in self.segment_manager.class_aliases.items()
-        }
-        with open(aliases_path, "w") as f:
-            json.dump(aliases_to_save, f, indent=4)
-        return aliases_path
-
-    def load_class_aliases(self, image_path: str) -> None:
-        """Load class aliases from JSON file."""
-        json_path = os.path.splitext(image_path)[0] + ".json"
-        if os.path.exists(json_path):
-            try:
-                with open(json_path) as f:
-                    loaded_aliases = json.load(f)
-                    self.segment_manager.class_aliases = {
-                        int(k): v for k, v in loaded_aliases.items()
-                    }
-            except (json.JSONDecodeError, ValueError) as e:
-                print(f"Error loading class aliases from {json_path}: {e}")
-                self.segment_manager.class_aliases.clear()
-
-    def load_existing_mask(self, image_path: str) -> None:
-        """Load existing mask from NPZ file."""
-        npz_path = os.path.splitext(image_path)[0] + ".npz"
-        if os.path.exists(npz_path):
-            with np.load(npz_path) as data:
-                if "mask" in data:
-                    mask_data = data["mask"]
-                    if mask_data.ndim == 2:
-                        mask_data = np.expand_dims(mask_data, axis=-1)
-
-                    num_classes = mask_data.shape[2]
-                    for i in range(num_classes):
-                        class_mask = mask_data[:, :, i].astype(bool)
-                        if np.any(class_mask):
-                            self.segment_manager.add_segment(
-                                {
-                                    "mask": class_mask,
-                                    "type": "Loaded",
-                                    "vertices": None,
-                                    "class_id": i,
-                                }
-                            )
-
-    def is_image_file(self, filepath: str) -> bool:
-        """Check if file is a supported image format."""
-        return filepath.lower().endswith((".png", ".jpg", ".jpeg", ".tiff", ".tif"))
+"""File management functionality."""
+
+import json
+import os
+
+import cv2
+import numpy as np
+
+from ..utils.logger import logger
+from .segment_manager import SegmentManager
+
+
+class FileManager:
+    """Manages file operations for saving and loading."""
+
+    def __init__(self, segment_manager: SegmentManager):
+        self.segment_manager = segment_manager
+
+    def save_npz(
+        self, image_path: str, image_size: tuple[int, int], class_order: list[int]
+    ) -> str:
+        """Save segments as NPZ file."""
+        final_mask_tensor = self.segment_manager.create_final_mask_tensor(
+            image_size, class_order
+        )
+        npz_path = os.path.splitext(image_path)[0] + ".npz"
+        np.savez_compressed(npz_path, mask=final_mask_tensor.astype(np.uint8))
+        return npz_path
+
+    def save_yolo_txt(
+        self,
+        image_path: str,
+        image_size: tuple[int, int],
+        class_order: list[int],
+        class_labels: list[str],
+    ) -> str | None:
+        """Save segments as YOLO format TXT file."""
+        final_mask_tensor = self.segment_manager.create_final_mask_tensor(
+            image_size, class_order
+        )
+        output_path = os.path.splitext(image_path)[0] + ".txt"
+        h, w = image_size
+
+        yolo_annotations = []
+        for channel in range(final_mask_tensor.shape[2]):
+            single_channel_image = final_mask_tensor[:, :, channel]
+            if not np.any(single_channel_image):
+                continue
+
+            contours, _ = cv2.findContours(
+                single_channel_image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
+            )
+
+            class_label = class_labels[channel]
+            for contour in contours:
+                x, y, width, height = cv2.boundingRect(contour)
+                center_x = (x + width / 2) / w
+                center_y = (y + height / 2) / h
+                normalized_width = width / w
+                normalized_height = height / h
+                yolo_entry = f"{class_label} {center_x} {center_y} {normalized_width} {normalized_height}"
+                yolo_annotations.append(yolo_entry)
+
+        if not yolo_annotations:
+            return None
+
+        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+        with open(output_path, "w") as file:
+            for annotation in yolo_annotations:
+                file.write(annotation + "\n")
+
+        return output_path
+
+    def save_class_aliases(self, image_path: str) -> str:
+        """Save class aliases as JSON file."""
+        aliases_path = os.path.splitext(image_path)[0] + ".json"
+        aliases_to_save = {
+            str(k): v for k, v in self.segment_manager.class_aliases.items()
+        }
+        with open(aliases_path, "w") as f:
+            json.dump(aliases_to_save, f, indent=4)
+        return aliases_path
+
+    def load_class_aliases(self, image_path: str) -> None:
+        """Load class aliases from JSON file."""
+        json_path = os.path.splitext(image_path)[0] + ".json"
+        if os.path.exists(json_path):
+            try:
+                with open(json_path) as f:
+                    loaded_aliases = json.load(f)
+                    self.segment_manager.class_aliases = {
+                        int(k): v for k, v in loaded_aliases.items()
+                    }
+            except (json.JSONDecodeError, ValueError) as e:
+                logger.error(f"Error loading class aliases from {json_path}: {e}")
+                self.segment_manager.class_aliases.clear()
+
+    def load_existing_mask(self, image_path: str) -> None:
+        """Load existing mask from NPZ file."""
+        npz_path = os.path.splitext(image_path)[0] + ".npz"
+        if os.path.exists(npz_path):
+            with np.load(npz_path) as data:
+                if "mask" in data:
+                    mask_data = data["mask"]
+                    if mask_data.ndim == 2:
+                        mask_data = np.expand_dims(mask_data, axis=-1)
+
+                    num_classes = mask_data.shape[2]
+                    for i in range(num_classes):
+                        class_mask = mask_data[:, :, i].astype(bool)
+                        if np.any(class_mask):
+                            self.segment_manager.add_segment(
+                                {
+                                    "mask": class_mask,
+                                    "type": "Loaded",
+                                    "vertices": None,
+                                    "class_id": i,
+                                }
+                            )
+
+    def is_image_file(self, filepath: str) -> bool:
+        """Check if file is a supported image format."""
+        return filepath.lower().endswith((".png", ".jpg", ".jpeg", ".tiff", ".tif"))

lazylabel/core/model_manager.py

@@ -1,95 +1,96 @@
-"""Model management functionality."""
-
-import os
-from collections.abc import Callable
-
-from ..config import Paths
-from ..models.sam_model import SamModel
-
-
-class ModelManager:
-    """Manages SAM model loading and selection."""
-
-    def __init__(self, paths: Paths):
-        self.paths = paths
-        self.sam_model: SamModel | None = None
-        self.current_models_folder: str | None = None
-        self.on_model_changed: Callable[[str], None] | None = None
-
-    def initialize_default_model(self, model_type: str = "vit_h") -> SamModel | None:
-        """Initialize the default SAM model.
-
-        Returns:
-            SamModel instance if successful, None if failed
-        """
-        try:
-            print(f"[8/20] Loading {model_type.upper()} model...")
-            self.sam_model = SamModel(model_type=model_type)
-            self.current_models_folder = str(self.paths.models_dir)
-            return self.sam_model
-        except Exception as e:
-            print(f"[8/20] Failed to initialize default model: {e}")
-            self.sam_model = None
-            return None
-
-    def get_available_models(self, folder_path: str) -> list[tuple[str, str]]:
-        """Get list of available .pth models in folder.
-
-        Returns:
-            List of (display_name, full_path) tuples
-        """
-        pth_files = []
-        for root, _dirs, files in os.walk(folder_path):
-            for file in files:
-                if file.lower().endswith(".pth"):
-                    full_path = os.path.join(root, file)
-                    rel_path = os.path.relpath(full_path, folder_path)
-                    pth_files.append((rel_path, full_path))
-
-        return sorted(pth_files, key=lambda x: x[0])
-
-    def detect_model_type(self, model_path: str) -> str:
-        """Detect model type from filename."""
-        filename = os.path.basename(model_path).lower()
-        if "vit_l" in filename or "large" in filename:
-            return "vit_l"
-        elif "vit_b" in filename or "base" in filename:
-            return "vit_b"
-        elif "vit_h" in filename or "huge" in filename:
-            return "vit_h"
-        return "vit_h"  # default
-
-    def load_custom_model(self, model_path: str) -> bool:
-        """Load a custom model from path.
-
-        Returns:
-            True if successful, False otherwise
-        """
-        if not self.sam_model:
-            return False
-
-        if not os.path.exists(model_path):
-            return False
-
-        model_type = self.detect_model_type(model_path)
-        success = self.sam_model.load_custom_model(model_path, model_type)
-
-        if success and self.on_model_changed:
-            model_name = os.path.basename(model_path)
-            self.on_model_changed(f"Current: {model_name}")
-
-        return success
-
-    def set_models_folder(self, folder_path: str) -> None:
-        """Set the current models folder."""
-        self.current_models_folder = folder_path
-
-    def get_models_folder(self) -> str | None:
-        """Get the current models folder."""
-        return self.current_models_folder
-
-    def is_model_available(self) -> bool:
-        """Check if a SAM model is loaded and available."""
-        return self.sam_model is not None and getattr(
-            self.sam_model, "is_loaded", False
-        )
+"""Model management functionality."""
+
+import os
+from collections.abc import Callable
+
+from ..config import Paths
+from ..models.sam_model import SamModel
+from ..utils.logger import logger
+
+
+class ModelManager:
+    """Manages SAM model loading and selection."""
+
+    def __init__(self, paths: Paths):
+        self.paths = paths
+        self.sam_model: SamModel | None = None
+        self.current_models_folder: str | None = None
+        self.on_model_changed: Callable[[str], None] | None = None
+
+    def initialize_default_model(self, model_type: str = "vit_h") -> SamModel | None:
+        """Initialize the default SAM model.
+
+        Returns:
+            SamModel instance if successful, None if failed
+        """
+        try:
+            logger.info(f"Step 4/8: Loading {model_type.upper()} model...")
+            self.sam_model = SamModel(model_type=model_type)
+            self.current_models_folder = str(self.paths.models_dir)
+            return self.sam_model
+        except Exception as e:
+            logger.error(f"Step 4/8: Failed to initialize default model: {e}")
+            self.sam_model = None
+            return None
+
+    def get_available_models(self, folder_path: str) -> list[tuple[str, str]]:
+        """Get list of available .pth models in folder.
+
+        Returns:
+            List of (display_name, full_path) tuples
+        """
+        pth_files = []
+        for root, _dirs, files in os.walk(folder_path):
+            for file in files:
+                if file.lower().endswith(".pth"):
+                    full_path = os.path.join(root, file)
+                    rel_path = os.path.relpath(full_path, folder_path)
+                    pth_files.append((rel_path, full_path))
+
+        return sorted(pth_files, key=lambda x: x[0])
+
+    def detect_model_type(self, model_path: str) -> str:
+        """Detect model type from filename."""
+        filename = os.path.basename(model_path).lower()
+        if "vit_l" in filename or "large" in filename:
+            return "vit_l"
+        elif "vit_b" in filename or "base" in filename:
+            return "vit_b"
+        elif "vit_h" in filename or "huge" in filename:
+            return "vit_h"
+        return "vit_h"  # default
+
+    def load_custom_model(self, model_path: str) -> bool:
+        """Load a custom model from path.
+
+        Returns:
+            True if successful, False otherwise
+        """
+        if not self.sam_model:
+            return False
+
+        if not os.path.exists(model_path):
+            return False
+
+        model_type = self.detect_model_type(model_path)
+        success = self.sam_model.load_custom_model(model_path, model_type)
+
+        if success and self.on_model_changed:
+            model_name = os.path.basename(model_path)
+            self.on_model_changed(f"Current: {model_name}")
+
+        return success
+
+    def set_models_folder(self, folder_path: str) -> None:
+        """Set the current models folder."""
+        self.current_models_folder = folder_path
+
+    def get_models_folder(self) -> str | None:
+        """Get the current models folder."""
+        return self.current_models_folder
+
+    def is_model_available(self) -> bool:
+        """Check if a SAM model is loaded and available."""
+        return self.sam_model is not None and getattr(
+            self.sam_model, "is_loaded", False
+        )