coralnet-toolbox 0.0.73__py2.py3-none-any.whl → 0.0.74__py2.py3-none-any.whl

coralnet_toolbox/Tools/QtSelectTool.py

@@ -11,6 +11,7 @@ from coralnet_toolbox.Tools.QtMoveSubTool import MoveSubTool
 from coralnet_toolbox.Tools.QtResizeSubTool import ResizeSubTool
 from coralnet_toolbox.Tools.QtSelectSubTool import SelectSubTool
 from coralnet_toolbox.Tools.QtCutSubTool import CutSubTool
+from coralnet_toolbox.Tools.QtSubtractSubTool import SubtractSubTool
 
 from coralnet_toolbox.Annotations import (PatchAnnotation, 
                                           PolygonAnnotation, 
@@ -45,6 +46,9 @@ class SelectTool(Tool):
         self.resize_subtool = ResizeSubTool(self)
         self.select_subtool = SelectSubTool(self)
         self.cut_subtool = CutSubTool(self)
+        self.subtract_subtool = SubtractSubTool(self)
+        
+        # --- State for the currently active sub-tool ---
         self.active_subtool: SubTool | None = None
 
         # --- State for transient UI (like resize handles) ---
@@ -175,9 +179,14 @@ class SelectTool(Tool):
             if modifiers & Qt.ShiftModifier and len(self.selected_annotations) == 1:
                 self._show_resize_handles()
             
-            # Ctrl+X: Start cutting mode
-            if event.key() == Qt.Key_X and len(self.selected_annotations) == 1:
-                self.set_active_subtool(self.cut_subtool, event, annotation=self.selected_annotations[0])
+            # --- Ctrl+X Hotkey Overload ---
+            if event.key() == Qt.Key_X:
+                if len(self.selected_annotations) > 1:
+                    # If more than one annotation is selected, perform subtraction.
+                    self.subtract_selected_annotations(event)
+                elif len(self.selected_annotations) == 1:
+                    # If only one is selected, start cutting mode.
+                    self.set_active_subtool(self.cut_subtool, event, annotation=self.selected_annotations[0])
 
             # Ctrl+C: Combine selected annotations
             elif event.key() == Qt.Key_C and len(self.selected_annotations) > 1:
@@ -315,6 +324,16 @@ class SelectTool(Tool):
                 annotation.update_user_confidence(top_label)
         if len(self.selected_annotations) == 1:
             self.annotation_window.main_window.confidence_window.refresh_display()
+            
+    def subtract_selected_annotations(self, event):
+        """
+        Initiates the subtraction operation by activating the SubtractSubTool.
+        """
+        self.set_active_subtool(
+            self.subtract_subtool, 
+            event, 
+            selected_annotations=self.selected_annotations.copy()
+        )
 
     def combine_selected_annotations(self):
         """Combine multiple selected annotations of the same type."""
@@ -437,6 +456,11 @@ class SelectTool(Tool):
         # Add the newly created annotations from the cut.
         for new_anno in new_annotations:
             self.annotation_window.add_annotation_from_tool(new_anno)
+            
+    def cancel_cutting_mode(self):
+        """Safely cancels cutting mode."""
+        if self.active_subtool and isinstance(self.active_subtool, CutSubTool):
+            self.deactivate_subtool()
 
     # --- Convenience Properties ---
     @property

coralnet_toolbox/Tools/QtSubtractSubTool.py

@@ -0,0 +1,66 @@
+from coralnet_toolbox.Tools.QtSubTool import SubTool
+from coralnet_toolbox.Annotations import PolygonAnnotation
+from coralnet_toolbox.Annotations import MultiPolygonAnnotation
+
+
+# ----------------------------------------------------------------------------------------------------------------------
+# Classes
+# ----------------------------------------------------------------------------------------------------------------------    
+
+class SubtractSubTool(SubTool):
+    """
+    A SubTool to perform a "cookie cutter" subtraction operation on selected annotations.
+    This tool activates, performs its action, and immediately deactivates.
+    """
+
+    def __init__(self, parent_tool):
+        super().__init__(parent_tool)
+
+    def activate(self, event, **kwargs):
+        """
+        Activates the subtraction operation.
+        Expects 'selected_annotations' in kwargs.
+        """
+        super().activate(event)
+        
+        selected_annotations = kwargs.get('selected_annotations', [])
+
+        # --- 1. Perform Pre-activation Checks ---
+        if len(selected_annotations) < 2:
+            self.parent_tool.deactivate_subtool()
+            return
+
+        # Check if all annotations are verified Polygon or MultiPolygon Annotations
+        allowed_types = (PolygonAnnotation, MultiPolygonAnnotation)
+        if not all(isinstance(anno, allowed_types) and anno.verified for anno in selected_annotations):
+            self.parent_tool.deactivate_subtool()
+            return
+
+        # --- 2. Identify Base and Cutters ---
+        # The last selected annotation is the base, the rest are cutters.
+        base_annotation = selected_annotations[-1]
+        cutter_annotations = selected_annotations[:-1]
+
+        # --- 3. Perform the Subtraction ---
+        result_annotations = PolygonAnnotation.subtract(base_annotation, cutter_annotations)
+
+        if not result_annotations:
+            self.parent_tool.deactivate_subtool()
+            return
+
+        # --- 4. Update the Annotation Window ---
+        # Delete the original annotations that were used in the operation
+        for anno in selected_annotations:
+            self.annotation_window.delete_annotation(anno.id)
+        
+        # Add the new resulting annotations to the scene
+        for new_anno in result_annotations:
+            self.annotation_window.add_annotation_from_tool(new_anno)
+        
+        # Select the new annotations
+        self.annotation_window.unselect_annotations()
+        for new_anno in result_annotations:
+            self.annotation_window.select_annotation(new_anno, multi_select=True)
+
+        # --- 5. Deactivate Immediately ---
+        self.parent_tool.deactivate_subtool()

coralnet_toolbox/Tools/__init__.py

@@ -14,6 +14,7 @@ from .QtCutSubTool import CutSubTool
 from .QtMoveSubTool import MoveSubTool
 from .QtResizeSubTool import ResizeSubTool
 from .QtSelectSubTool import SelectSubTool
+from .QtSubtractSubTool import SubtractSubTool
 
 __all__ = [
     'PanTool',
@@ -29,4 +30,5 @@ __all__ = [
     'MoveSubTool',
     'ResizeSubTool',
     'SelectSubTool',
+    'SubtractSubTool',
 ]

coralnet_toolbox/__init__.py

@@ -1,6 +1,6 @@
 """Top-level package for CoralNet-Toolbox."""
 
-__version__ = "0.0.73"
+__version__ = "0.0.74"
 __author__ = "Jordan Pierce"
 __email__ = "jordan.pierce@noaa.gov"
 __credits__ = "National Center for Coastal and Ocean Sciences (NCCOS)"

coralnet_toolbox/utilities.py

@@ -9,14 +9,14 @@ import requests
 import traceback
 from functools import lru_cache
 
+import cv2
 import torch
 import numpy as np
 
 import rasterio
 from rasterio.windows import Window
 
-from shapely.validation import make_valid
-from shapely.geometry import Polygon, MultiPolygon, LineString, GeometryCollection
+from shapely.geometry import Polygon
 
 from PyQt5.QtCore import Qt
 from PyQt5.QtGui import QImage
@@ -109,6 +109,19 @@ def rasterio_to_qimage(rasterio_src, longest_edge=None):
         QImage: Scaled image
     """
     try:
+        # Check if the dataset is closed
+        if not rasterio_src or getattr(rasterio_src, 'closed', True):
+            # Attempt to reopen the dataset if we can get the path
+            if hasattr(rasterio_src, 'name'):
+                try:
+                    rasterio_src = rasterio.open(rasterio_src.name)
+                except Exception as reopen_error:
+                    print(f"Error reopening dataset: {str(reopen_error)}")
+                    return QImage()
+            else:
+                print("Cannot read from closed dataset without path information")
+                return QImage()
+                
         # Get the original size of the image
         original_width = rasterio_src.width
         original_height = rasterio_src.height
@@ -190,7 +203,7 @@ def rasterio_to_qimage(rasterio_src, longest_edge=None):
             # Transpose to height, width, channels format
             image = np.transpose(image, (1, 2, 0))
 
-        # Convert to uint8 if not already
+        # Convert to uint8 if image is not already
         if image.dtype != np.uint8:
             if image.max() > 0:  # Avoid division by zero
                 image = image.astype(float) * (255.0 / image.max())
@@ -222,6 +235,19 @@ def rasterio_to_cropped_image(rasterio_src, window):
         QImage: Cropped image as a QImage
     """
     try:
+        # Check if the dataset is closed
+        if not rasterio_src or getattr(rasterio_src, 'closed', True):
+            # Attempt to reopen the dataset if we can get the path
+            if hasattr(rasterio_src, 'name'):
+                try:
+                    rasterio_src = rasterio.open(rasterio_src.name)
+                except Exception as reopen_error:
+                    print(f"Error reopening dataset: {str(reopen_error)}")
+                    return QImage()
+            else:
+                print("Cannot read from closed dataset without path information")
+                return QImage()
+
         # Check for single-band image with colormap
         has_colormap = False
         if rasterio_src.count == 1:
@@ -305,6 +331,19 @@ def rasterio_to_numpy(rasterio_src, longest_edge=None):
         numpy.ndarray: Image as a numpy array in format (h, w, c) for RGB or (h, w) for grayscale
     """
     try:
+        # Check if the dataset is closed
+        if not rasterio_src or getattr(rasterio_src, 'closed', True):
+            # Attempt to reopen the dataset if we can get the path
+            if hasattr(rasterio_src, 'name'):
+                try:
+                    rasterio_src = rasterio.open(rasterio_src.name)
+                except Exception as reopen_error:
+                    print(f"Error reopening dataset: {str(reopen_error)}")
+                    return np.zeros((100, 100, 3), dtype=np.uint8)
+            else:
+                print("Cannot read from closed dataset without path information")
+                return np.zeros((100, 100, 3), dtype=np.uint8)
+                
         # Get the original size of the image
         original_width = rasterio_src.width
         original_height = rasterio_src.height
@@ -412,6 +451,19 @@ def work_area_to_numpy(rasterio_src, work_area):
     """
     if not rasterio_src:
         return None
+        
+    # Check if the dataset is closed
+    if getattr(rasterio_src, 'closed', True):
+        # Attempt to reopen the dataset if we can get the path
+        if hasattr(rasterio_src, 'name'):
+            try:
+                rasterio_src = rasterio.open(rasterio_src.name)
+            except Exception as reopen_error:
+                print(f"Error reopening dataset: {str(reopen_error)}")
+                return None
+        else:
+            print("Cannot read from closed dataset without path information")
+            return None
 
     # If we got a WorkArea object, use its rect
     if hasattr(work_area, 'rect'):
@@ -542,50 +594,6 @@ def scale_pixmap(pixmap, max_size):
     return scaled_pixmap
 
 
-def attempt_download_asset(app, asset_name, asset_url):
-    """
-    Attempt to download an asset from the given URL.
-
-    :param app:
-    :param asset_name:
-    :param asset_url:
-    :return:
-    """
-    # Create a progress dialog
-    progress_dialog = ProgressBar(app, title=f"Downloading {asset_name}")
-
-    try:
-        # Get the asset name
-        asset_name = os.path.basename(asset_name)
-        asset_path = os.path.join(os.getcwd(), asset_name)
-
-        if os.path.exists(asset_path):
-            return
-
-        # Download the asset
-        response = requests.get(asset_url, stream=True)
-        total_size = int(response.headers.get('content-length', 0))
-        block_size = 1024  # 1 Kibibyte
-
-        # Initialize the progress bar
-        progress_dialog.start_progress(total_size // block_size)
-        progress_dialog.show()
-
-        with open(asset_path, 'wb') as f:
-            for data in response.iter_content(block_size):
-                if progress_dialog.wasCanceled():
-                    raise Exception("Download canceled by user")
-                f.write(data)
-                progress_dialog.update_progress()
-
-    except Exception as e:
-        QMessageBox.critical(app, "Error", f"Failed to download {asset_name}.\n{e}")
-
-    # Close the progress dialog
-    progress_dialog.set_value(progress_dialog.max_value)
-    progress_dialog.close()
-
-
 def simplify_polygon(xy_points, simplify_tolerance=0.1):
     """
     Filter a list of points to keep only the largest polygon and simplify it.
@@ -666,6 +674,88 @@ def densify_polygon(xy_points):
         return xy_points.tolist() if isinstance(xy_points, np.ndarray) else xy_points
 
 
+def polygonize_mask_with_holes(mask_tensor):
+    """
+    Converts a boolean mask tensor to an exterior polygon and a list of interior hole polygons.
+
+    Args:
+        mask_tensor (torch.Tensor): A 2D boolean tensor from the prediction results.
+
+    Returns:
+        A tuple containing:
+        - exterior (list of tuples): The (x, y) vertices of the outer boundary.
+        - holes (list of lists of tuples): A list where each element is a list of (x, y) vertices for a hole.
+    """
+    # Convert the tensor to a NumPy array format that OpenCV can use
+    mask_np = mask_tensor.squeeze().cpu().numpy().astype(np.uint8)
+
+    # Find all contours and their hierarchy
+    # cv2.RETR_CCOMP organizes contours into a two-level hierarchy: external boundaries and holes inside them.
+    contours, hierarchy = cv2.findContours(mask_np, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
+
+    if not contours or hierarchy is None:
+        return [], []
+
+    exterior = []
+    holes = []
+
+    # Process the hierarchy to separate the exterior from the holes
+    for i, contour in enumerate(contours):
+        # An external contour's parent in the hierarchy is -1
+        if hierarchy[0][i][3] == -1:
+            # Squeeze to convert from [[x, y]] to [x, y] format
+            exterior = contour.squeeze(axis=1).tolist()
+        else:
+            # Any other contour is treated as a hole
+            holes.append(contour.squeeze(axis=1).tolist())
+
+    return exterior, holes
+
+
+def attempt_download_asset(app, asset_name, asset_url):
+    """
+    Attempt to download an asset from the given URL.
+
+    :param app:
+    :param asset_name:
+    :param asset_url:
+    :return:
+    """
+    # Create a progress dialog
+    progress_dialog = ProgressBar(app, title=f"Downloading {asset_name}")
+
+    try:
+        # Get the asset name
+        asset_name = os.path.basename(asset_name)
+        asset_path = os.path.join(os.getcwd(), asset_name)
+
+        if os.path.exists(asset_path):
+            return
+
+        # Download the asset
+        response = requests.get(asset_url, stream=True)
+        total_size = int(response.headers.get('content-length', 0))
+        block_size = 1024  # 1 Kibibyte
+
+        # Initialize the progress bar
+        progress_dialog.start_progress(total_size // block_size)
+        progress_dialog.show()
+
+        with open(asset_path, 'wb') as f:
+            for data in response.iter_content(block_size):
+                if progress_dialog.wasCanceled():
+                    raise Exception("Download canceled by user")
+                f.write(data)
+                progress_dialog.update_progress()
+
+    except Exception as e:
+        QMessageBox.critical(app, "Error", f"Failed to download {asset_name}.\n{e}")
+
+    # Close the progress dialog
+    progress_dialog.set_value(progress_dialog.max_value)
+    progress_dialog.close()
+    
+
 def console_user(error_msg, parent=None):
     """
     Display an error message to the user via both terminal and GUI dialog.