lazylabel-gui 1.1.0__tar.gz → 1.1.1__tar.gz

{lazylabel_gui-1.1.0 → lazylabel_gui-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lazylabel-gui
-Version: 1.1.0
+Version: 1.1.1
 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

{lazylabel_gui-1.1.0 → lazylabel_gui-1.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lazylabel-gui"
-version = "1.1.0"
+version = "1.1.1"
 authors = [
   { name="Deniz N. Cakan", email="deniz.n.cakan@gmail.com" },
 ]

{lazylabel_gui-1.1.0 → lazylabel_gui-1.1.1}/src/lazylabel/core/model_manager.py

@@ -11,44 +11,45 @@ from ..config import Paths
 
 class ModelManager:
     """Manages SAM model loading and selection."""
-    
+
     def __init__(self, paths: Paths):
         self.paths = paths
         self.sam_model: Optional[SamModel] = None
         self.current_models_folder: Optional[str] = None
         self.on_model_changed: Optional[Callable[[str], None]] = None
-        
+
     def initialize_default_model(self, model_type: str = "vit_h") -> Optional[SamModel]:
         """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"Failed to initialize default model: {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'):
+                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()
@@ -59,36 +60,38 @@ class ModelManager:
         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) -> Optional[str]:
         """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)
+        return self.sam_model is not None and getattr(
+            self.sam_model, "is_loaded", False
+        )

{lazylabel_gui-1.1.0 → lazylabel_gui-1.1.1}/src/lazylabel/core/segment_manager.py

@@ -8,108 +8,122 @@ from PyQt6.QtCore import QPointF
 
 class SegmentManager:
     """Manages image segments and classes."""
-    
+
     def __init__(self):
         self.segments: List[Dict[str, Any]] = []
         self.class_aliases: Dict[int, str] = {}
         self.next_class_id: int = 0
-        
+        self.active_class_id: Optional[int] = None  # Currently active/toggled class
+
     def clear(self) -> None:
         """Clear all segments and reset state."""
         self.segments.clear()
         self.class_aliases.clear()
         self.next_class_id = 0
-    
+        self.active_class_id = None
+
     def add_segment(self, segment_data: Dict[str, Any]) -> None:
         """Add a new segment."""
-        if 'class_id' not in segment_data:
-            segment_data['class_id'] = self.next_class_id
+        if "class_id" not in segment_data:
+            # Use active class if available, otherwise use next class ID
+            if self.active_class_id is not None:
+                segment_data["class_id"] = self.active_class_id
+            else:
+                segment_data["class_id"] = self.next_class_id
         self.segments.append(segment_data)
         self._update_next_class_id()
-    
+
     def delete_segments(self, indices: List[int]) -> None:
         """Delete segments by indices."""
         for i in sorted(indices, reverse=True):
             if 0 <= i < len(self.segments):
                 del self.segments[i]
         self._update_next_class_id()
-    
+
     def assign_segments_to_class(self, indices: List[int]) -> None:
         """Assign selected segments to a class."""
         if not indices:
             return
-            
+
         existing_class_ids = [
             self.segments[i]["class_id"]
             for i in indices
             if i < len(self.segments) and self.segments[i].get("class_id") is not None
         ]
-        
+
         if existing_class_ids:
             target_class_id = min(existing_class_ids)
         else:
             target_class_id = self.next_class_id
-        
+
         for i in indices:
             if i < len(self.segments):
                 self.segments[i]["class_id"] = target_class_id
-        
+
         self._update_next_class_id()
-    
+
     def get_unique_class_ids(self) -> List[int]:
         """Get sorted list of unique class IDs."""
-        return sorted(list({
-            seg.get("class_id")
-            for seg in self.segments
-            if seg.get("class_id") is not None
-        }))
-    
-    def rasterize_polygon(self, vertices: List[QPointF], image_size: Tuple[int, int]) -> Optional[np.ndarray]:
+        return sorted(
+            list(
+                {
+                    seg.get("class_id")
+                    for seg in self.segments
+                    if seg.get("class_id") is not None
+                }
+            )
+        )
+
+    def rasterize_polygon(
+        self, vertices: List[QPointF], image_size: Tuple[int, int]
+    ) -> Optional[np.ndarray]:
         """Convert polygon vertices to binary mask."""
         if not vertices:
             return None
-            
+
         h, w = image_size
         points_np = np.array([[p.x(), p.y()] for p in vertices], dtype=np.int32)
         mask = np.zeros((h, w), dtype=np.uint8)
         cv2.fillPoly(mask, [points_np], 1)
         return mask.astype(bool)
-    
-    def create_final_mask_tensor(self, image_size: Tuple[int, int], class_order: List[int]) -> np.ndarray:
+
+    def create_final_mask_tensor(
+        self, image_size: Tuple[int, int], class_order: List[int]
+    ) -> np.ndarray:
         """Create final mask tensor for saving."""
         h, w = image_size
         id_map = {old_id: new_id for new_id, old_id in enumerate(class_order)}
         num_final_classes = len(class_order)
         final_mask_tensor = np.zeros((h, w, num_final_classes), dtype=np.uint8)
-        
+
         for seg in self.segments:
             class_id = seg.get("class_id")
             if class_id not in id_map:
                 continue
-                
+
             new_channel_idx = id_map[class_id]
-            
+
             if seg["type"] == "Polygon":
                 mask = self.rasterize_polygon(seg["vertices"], image_size)
             else:
                 mask = seg.get("mask")
-                
+
             if mask is not None:
                 final_mask_tensor[:, :, new_channel_idx] = np.logical_or(
                     final_mask_tensor[:, :, new_channel_idx], mask
                 )
-        
+
         return final_mask_tensor
-    
+
     def reassign_class_ids(self, new_order: List[int]) -> None:
         """Reassign class IDs based on new order."""
         id_map = {old_id: new_id for new_id, old_id in enumerate(new_order)}
-        
+
         for seg in self.segments:
             old_id = seg.get("class_id")
             if old_id in id_map:
                 seg["class_id"] = id_map[old_id]
-        
+
         # Update aliases
         new_aliases = {
             id_map[old_id]: self.class_aliases.get(old_id, str(old_id))
@@ -118,15 +132,32 @@ class SegmentManager:
         }
         self.class_aliases = new_aliases
         self._update_next_class_id()
-    
+
     def set_class_alias(self, class_id: int, alias: str) -> None:
         """Set alias for a class."""
         self.class_aliases[class_id] = alias
-    
+
     def get_class_alias(self, class_id: int) -> str:
         """Get alias for a class."""
         return self.class_aliases.get(class_id, str(class_id))
-    
+
+    def set_active_class(self, class_id: Optional[int]) -> None:
+        """Set the active class ID."""
+        self.active_class_id = class_id
+
+    def get_active_class(self) -> Optional[int]:
+        """Get the active class ID."""
+        return self.active_class_id
+
+    def toggle_active_class(self, class_id: int) -> bool:
+        """Toggle a class as active. Returns True if now active, False if deactivated."""
+        if self.active_class_id == class_id:
+            self.active_class_id = None
+            return False
+        else:
+            self.active_class_id = class_id
+            return True
+
     def _update_next_class_id(self) -> None:
         """Update the next available class ID."""
         all_ids = {
@@ -137,4 +168,4 @@ class SegmentManager:
         if not all_ids:
             self.next_class_id = 0
         else:
-            self.next_class_id = max(all_ids) + 1
+            self.next_class_id = max(all_ids) + 1

{lazylabel_gui-1.1.0 → lazylabel_gui-1.1.1}/src/lazylabel/main.py

@@ -9,14 +9,28 @@ from .ui.main_window import MainWindow
 
 def main():
     """Main application entry point."""
+    print("=" * 50)
+    print("LazyLabel - AI-Assisted Image Labeling")
+    print("=" * 50)
+    print()
+
+    print("[1/20] Initializing application...")
     app = QApplication(sys.argv)
+
+    print("[2/20] Applying dark theme...")
     qdarktheme.setup_theme()
-    
+
     main_window = MainWindow()
+
+    print("[19/20] Showing main window...")
     main_window.show()
-    
+
+    print()
+    print("[20/20] LazyLabel is ready! Happy labeling!")
+    print("=" * 50)
+
     sys.exit(app.exec())
 
 
 if __name__ == "__main__":
-    main()
+    main()

{lazylabel_gui-1.1.0 → lazylabel_gui-1.1.1}/src/lazylabel/models/sam_model.py

@@ -9,15 +9,18 @@ from segment_anything import sam_model_registry, SamPredictor
 
 def download_model(url, download_path):
     """Downloads file with a progress bar."""
-    print(
-        f"SAM model not found. Downloading from Meta's GitHub repository to: {download_path}"
-    )
+    print(f"[10/20] SAM model not found. Downloading from Meta's repository...")
+    print(f"        Downloading to: {download_path}")
     try:
+        print(f"[10/20] Connecting to download server...")
         response = requests.get(url, stream=True, timeout=30)
         response.raise_for_status()
         total_size_in_bytes = int(response.headers.get("content-length", 0))
         block_size = 1024  # 1 Kibibyte
 
+        print(
+            f"[10/20] Starting download ({total_size_in_bytes / (1024*1024*1024):.1f} GB)..."
+        )
         progress_bar = tqdm(total=total_size_in_bytes, unit="iB", unit_scale=True)
         with open(download_path, "wb") as file:
             for data in response.iter_content(block_size):
@@ -27,93 +30,131 @@ def download_model(url, download_path):
 
         if total_size_in_bytes != 0 and progress_bar.n != total_size_in_bytes:
             raise RuntimeError("Download incomplete - file size mismatch")
-            
-        print("Model download completed successfully.")
-        
+
+        print("[10/20] Model download completed successfully.")
+
+    except requests.exceptions.ConnectionError as e:
+        raise RuntimeError(
+            f"[10/20] Network connection failed: Check your internet connection"
+        )
+    except requests.exceptions.Timeout as e:
+        raise RuntimeError(f"[10/20] Download timeout: Server took too long to respond")
+    except requests.exceptions.HTTPError as e:
+        raise RuntimeError(
+            f"[10/20] HTTP error {e.response.status_code}: Server rejected request"
+        )
     except requests.exceptions.RequestException as e:
-        raise RuntimeError(f"Network error during download: {e}")
+        raise RuntimeError(f"[10/20] Network error during download: {e}")
+    except PermissionError as e:
+        raise RuntimeError(
+            f"[10/20] Permission denied: Cannot write to {download_path}"
+        )
+    except OSError as e:
+        raise RuntimeError(f"[10/20] Disk error: {e} (check available disk space)")
     except Exception as e:
         # Clean up partial download
         if os.path.exists(download_path):
-            os.remove(download_path)
-        raise RuntimeError(f"Download failed: {e}")
+            try:
+                os.remove(download_path)
+            except:
+                pass
+        raise RuntimeError(f"[10/20] Download failed: {e}")
 
 
 class SamModel:
-    def __init__(self, model_type="vit_h", model_filename="sam_vit_h_4b8939.pth", custom_model_path=None):
+    def __init__(
+        self,
+        model_type="vit_h",
+        model_filename="sam_vit_h_4b8939.pth",
+        custom_model_path=None,
+    ):
         self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        print(f"[9/20] Detected device: {str(self.device).upper()}")
+
         self.current_model_type = model_type
         self.current_model_path = custom_model_path
         self.model = None
         self.predictor = None
         self.image = None
         self.is_loaded = False
-        
+
         try:
             if custom_model_path and os.path.exists(custom_model_path):
                 # Use custom model path
                 model_path = custom_model_path
-                print(f"Loading custom SAM model from {model_path}...")
+                print(f"[10/20] Loading custom SAM model from {model_path}...")
             else:
                 # Use default model with download if needed - store in models folder
-                model_url = f"https://dl.fbaipublicfiles.com/segment_anything/{model_filename}"
-                
+                model_url = (
+                    f"https://dl.fbaipublicfiles.com/segment_anything/{model_filename}"
+                )
+
                 # Use models folder instead of cache folder
                 models_dir = os.path.dirname(__file__)  # Already in models directory
                 os.makedirs(models_dir, exist_ok=True)
                 model_path = os.path.join(models_dir, model_filename)
-                
+
                 # Also check the old cache location and move it if it exists
-                old_cache_dir = os.path.join(os.path.expanduser("~"), ".cache", "lazylabel")
+                old_cache_dir = os.path.join(
+                    os.path.expanduser("~"), ".cache", "lazylabel"
+                )
                 old_model_path = os.path.join(old_cache_dir, model_filename)
-                
+
                 if os.path.exists(old_model_path) and not os.path.exists(model_path):
-                    print(f"Moving existing model from cache to models folder...")
+                    print(
+                        f"[10/20] Moving existing model from cache to models folder..."
+                    )
                     import shutil
+
                     shutil.move(old_model_path, model_path)
                 elif not os.path.exists(model_path):
                     # Download the model if it doesn't exist
                     download_model(model_url, model_path)
-                
-                print(f"Loading default SAM model from {model_path}...")
 
+                print(f"[10/20] Loading default SAM model from {model_path}...")
+
+            print(f"[11/20] Initializing {model_type.upper()} model architecture...")
             self.model = sam_model_registry[model_type](checkpoint=model_path).to(
                 self.device
             )
+
+            print(f"[12/20] Setting up predictor...")
             self.predictor = SamPredictor(self.model)
             self.is_loaded = True
-            print("SAM model loaded successfully.")
-            
+            print("[13/20] SAM model loaded successfully.")
+
         except Exception as e:
-            print(f"Failed to load SAM model: {e}")
-            print("SAM point functionality will be disabled.")
+            print(f"[8/20] Failed to load SAM model: {e}")
+            print(f"[8/20] SAM point functionality will be disabled.")
             self.is_loaded = False
-    
+
     def load_custom_model(self, model_path, model_type="vit_h"):
         """Load a custom model from the specified path."""
         if not os.path.exists(model_path):
             print(f"Model file not found: {model_path}")
             return False
-        
+
         print(f"Loading custom SAM model from {model_path}...")
         try:
             # Clear existing model from memory
-            if hasattr(self, 'model') and self.model is not None:
+            if hasattr(self, "model") and self.model is not None:
                 del self.model
                 del self.predictor
                 torch.cuda.empty_cache() if torch.cuda.is_available() else None
-            
+
             # Load new model
-            self.model = sam_model_registry[model_type](checkpoint=model_path).to(self.device)
+            self.model = sam_model_registry[model_type](checkpoint=model_path).to(
+                self.device
+            )
             self.predictor = SamPredictor(self.model)
             self.current_model_type = model_type
             self.current_model_path = model_path
             self.is_loaded = True
-            
+
             # Re-set image if one was previously loaded
             if self.image is not None:
                 self.predictor.set_image(self.image)
-                
+
             print("Custom SAM model loaded successfully.")
             return True
         except Exception as e: