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

coralnet_toolbox/Tools/QtSAMTool.py

@@ -1,7 +1,7 @@
 import warnings
 import numpy as np
 
-from PyQt5.QtCore import Qt, QPointF, QRectF, QTimer
+from PyQt5.QtCore import Qt, QPointF, QRectF
 from PyQt5.QtGui import QMouseEvent, QKeyEvent, QPen, QColor, QBrush, QPainterPath
 from PyQt5.QtWidgets import QMessageBox, QGraphicsEllipseItem, QGraphicsRectItem, QGraphicsPathItem, QApplication
 
@@ -12,6 +12,7 @@ from coralnet_toolbox.QtWorkArea import WorkArea
 
 from coralnet_toolbox.utilities import pixmap_to_numpy
 from coralnet_toolbox.utilities import simplify_polygon
+from coralnet_toolbox.utilities import polygonize_mask_with_holes
 
 warnings.filterwarnings("ignore", category=DeprecationWarning)
 
@@ -369,40 +370,47 @@ class SAMTool(Tool):
                 QApplication.restoreOverrideCursor()
                 return
 
-            # Get the points of the top1 mask
+            # Get the top confidence prediction's mask tensor
             top1_index = np.argmax(results.boxes.conf)
-            predictions = results[top1_index].masks.xy[0]
+            mask_tensor = results[top1_index].masks.data
 
-            # Safety check: make sure we have predicted points
-            if len(predictions) == 0:
-                QApplication.restoreOverrideCursor()
-                return
+            # Check if holes are allowed from the SAM dialog
+            allow_holes = self.sam_dialog.get_allow_holes()
 
-            # Clean the polygon using Ramer-Douglas-Peucker algorithm
-            predictions = simplify_polygon(predictions, 0.1)
+            # Polygonize the mask to get the exterior and holes
+            exterior_coords, holes_coords_list = polygonize_mask_with_holes(mask_tensor)
 
             # Safety check: need at least 3 points for a valid polygon
-            if len(predictions) < 3:
+            if len(exterior_coords) < 3:
                 QApplication.restoreOverrideCursor()
                 return
 
-            # Move the points back to the original image space
+            # --- Process and Clean the Polygon Points ---
             working_area_top_left = self.working_area.rect.topLeft()
-            points = [(point[0] + working_area_top_left.x(),
-                       point[1] + working_area_top_left.y()) for point in predictions]
+            offset_x, offset_y = working_area_top_left.x(), working_area_top_left.y()
 
-            # Convert to QPointF for graphics
-            self.points = [QPointF(*point) for point in points]
+            # Simplify, offset, and convert the exterior points
+            simplified_exterior = simplify_polygon(exterior_coords, 0.1)
+            self.points = [QPointF(p[0] + offset_x, p[1] + offset_y) for p in simplified_exterior]
 
-            # Create the temporary annotation
+            # Simplify, offset, and convert each hole only if allowed
+            final_holes = []
+            if allow_holes:
+                for hole_coords in holes_coords_list:
+                    if len(hole_coords) >= 3:  # Ensure holes are also valid polygons
+                        simplified_hole = simplify_polygon(hole_coords, 0.1)
+                        final_holes.append([QPointF(p[0] + offset_x, p[1] + offset_y) for p in simplified_hole])
+
+            # Create the temporary annotation, now with holes (or not)
             self.temp_annotation = PolygonAnnotation(
-                self.points,
-                self.annotation_window.selected_label.short_label_code,
-                self.annotation_window.selected_label.long_label_code,
-                self.annotation_window.selected_label.color,
-                self.annotation_window.current_image_path,
-                self.annotation_window.selected_label.id,
-                self.main_window.label_window.active_label.transparency
+                points=self.points,
+                holes=final_holes,
+                short_label_code=self.annotation_window.selected_label.short_label_code,
+                long_label_code=self.annotation_window.selected_label.long_label_code,
+                color=self.annotation_window.selected_label.color,
+                image_path=self.annotation_window.current_image_path,
+                label_id=self.annotation_window.selected_label.id,
+                transparency=self.main_window.label_window.active_label.transparency
             )
 
             # Create the graphics item for the temporary annotation
@@ -611,12 +619,13 @@ class SAMTool(Tool):
                     # Use existing temporary annotation
                     final_annotation = PolygonAnnotation(
                         self.points,
-                        self.annotation_window.selected_label.short_label_code,
-                        self.annotation_window.selected_label.long_label_code,
-                        self.annotation_window.selected_label.color,
-                        self.annotation_window.current_image_path,
-                        self.annotation_window.selected_label.id,
-                        self.main_window.label_window.active_label.transparency
+                        self.temp_annotation.label.short_label_code,
+                        self.temp_annotation.label.long_label_code,
+                        self.temp_annotation.label.color,
+                        self.temp_annotation.image_path,
+                        self.temp_annotation.label.id,
+                        self.temp_annotation.label.transparency,
+                        holes=self.temp_annotation.holes
                     )
 
                     # Copy confidence data
@@ -637,7 +646,7 @@ class SAMTool(Tool):
                     final_annotation = self.create_annotation(True)
                     if final_annotation:
                         self.annotation_window.add_annotation_from_tool(final_annotation)
-                        self.clear_prompt_graphics()
+                        self.clear_prompt_graphics() 
             # If no active prompts, cancel the working area
             else:
                 self.cancel_working_area()
@@ -727,24 +736,36 @@ class SAMTool(Tool):
             QApplication.restoreOverrideCursor()
             return None
 
-        # Get the top confidence prediction
+        # Get the top confidence prediction's mask tensor
         top1_index = np.argmax(results.boxes.conf)
-        predictions = results[top1_index].masks.xy[0]
+        mask_tensor = results[top1_index].masks.data
+
+        # Check if holes are allowed from the SAM dialog
+        allow_holes = self.sam_dialog.get_allow_holes()
 
-        # Safety check for predictions
-        if len(predictions) == 0:
+        # Polygonize the mask using the new method to get the exterior and holes
+        exterior_coords, holes_coords_list = polygonize_mask_with_holes(mask_tensor)
+
+        # Safety check for an empty result
+        if not exterior_coords:
             QApplication.restoreOverrideCursor()
             return None
 
-        # Clean polygon points
-        predictions = simplify_polygon(predictions, 0.1)
-
-        # Move points back to original image space
+        # --- Process and Clean the Polygon Points ---
         working_area_top_left = self.working_area.rect.topLeft()
-        points = [(point[0] + working_area_top_left.x(),
-                   point[1] + working_area_top_left.y()) for point in predictions]
-        # Convert to QPointF for graphics
-        self.points = [QPointF(*point) for point in points]
+        offset_x, offset_y = working_area_top_left.x(), working_area_top_left.y()
+
+        # Simplify, offset, and convert the exterior points
+        simplified_exterior = simplify_polygon(exterior_coords, 0.1)
+        self.points = [QPointF(p[0] + offset_x, p[1] + offset_y) for p in simplified_exterior]
+
+        # Simplify, offset, and convert each hole only if allowed
+        final_holes = []
+        if allow_holes:
+            for hole_coords in holes_coords_list:
+                if len(hole_coords) >= 3:
+                    simplified_hole = simplify_polygon(hole_coords, 0.1)
+                    final_holes.append([QPointF(p[0] + offset_x, p[1] + offset_y) for p in simplified_hole])
 
         # Require at least 3 points for valid polygon
         if len(self.points) < 3:
@@ -754,15 +775,16 @@ class SAMTool(Tool):
         # Get confidence score
         confidence = results.boxes.conf[top1_index].item()
 
-        # Create final annotation
+        # Create final annotation, now passing the holes argument
         annotation = PolygonAnnotation(
-            self.points,
-            self.annotation_window.selected_label.short_label_code,
-            self.annotation_window.selected_label.long_label_code,
-            self.annotation_window.selected_label.color,
-            self.annotation_window.current_image_path,
-            self.annotation_window.selected_label.id,
-            self.main_window.label_window.active_label.transparency
+            points=self.points,
+            holes=final_holes,
+            short_label_code=self.annotation_window.selected_label.short_label_code,
+            long_label_code=self.annotation_window.selected_label.long_label_code,
+            color=self.annotation_window.selected_label.color,
+            image_path=self.annotation_window.current_image_path,
+            label_id=self.annotation_window.selected_label.id,
+            transparency=self.main_window.label_window.active_label.transparency
         )
 
         # Update confidence

coralnet_toolbox/Tools/QtSeeAnythingTool.py

@@ -173,6 +173,7 @@ class SeeAnythingTool(Tool):
 
         # Set the image in the SeeAnything dialog
         self.see_anything_dialog.set_image(self.work_area_image, self.image_path)
+        # self.see_anything_dialog.reload_model()
 
         self.annotation_window.setCursor(Qt.CrossCursor)
         self.annotation_window.scene.update()
@@ -552,9 +553,9 @@ class SeeAnythingTool(Tool):
         # Move the points back to the original image space
         working_area_top_left = self.working_area.rect.topLeft()
 
-        task = self.see_anything_dialog.task_dropdown.currentText()
         masks = None
-        if task == 'segment':
+        # Create masks from the rectangles (these are not polygons)
+        if self.see_anything_dialog.task_dropdown.currentText() == 'segment':
             masks = []
             for r in self.rectangles:
                 x1, y1, x2, y2 = r
@@ -587,8 +588,8 @@ class SeeAnythingTool(Tool):
         # Clear previous annotations if any
         self.clear_annotations()
 
-        # Process results based on the task type
-        if self.see_anything_dialog.task == "segment":
+        # Process results based on the task type (creates polygons or rectangle annotations)
+        if self.see_anything_dialog.task_dropdown.currentText() == "segment":
             if self.results.masks:
                 for i, polygon in enumerate(self.results.masks.xyn):
                     confidence = self.results.boxes.conf[i].item()
@@ -624,7 +625,9 @@ class SeeAnythingTool(Tool):
                     box_abs_work_area = box_norm.detach().cpu().numpy() * np.array(
                         [self.work_area_image.shape[1], self.work_area_image.shape[0],
                          self.work_area_image.shape[1], self.work_area_image.shape[0]])
-                    box_area = (box_abs_work_area[2] - box_abs_work_area[0]) * (box_abs_work_area[3] - box_abs_work_area[1])
+                    # Calculate the area of the bounding box
+                    box_area = (box_abs_work_area[2] - box_abs_work_area[0]) * \
+                               (box_abs_work_area[3] - box_abs_work_area[1])
 
                     # Area filtering
                     min_area = self.main_window.get_area_thresh_min() * image_area

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.75"
 __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'):
@@ -519,6 +571,27 @@ def pixmap_to_numpy(pixmap):
     return numpy_array
 
 
+def pixmap_to_pil(pixmap):
+    """
+    Convert a QPixmap to a PIL Image.
+    
+    :param pixmap: QPixmap to convert
+    :return: PIL Image in RGB format
+    """
+    from PIL import Image
+    
+    # Convert pixmap to numpy array first
+    image_np = pixmap_to_numpy(pixmap)
+    
+    # Convert numpy array to PIL Image
+    if len(image_np.shape) == 2:  # Grayscale
+        pil_image = Image.fromarray(image_np, mode='L').convert('RGB')
+    else:  # RGB
+        pil_image = Image.fromarray(image_np, mode='RGB')
+    
+    return pil_image
+
+
 def scale_pixmap(pixmap, max_size):
     """Scale pixmap and graphic if they exceed max dimension while preserving aspect ratio"""
     width = pixmap.width()
@@ -542,50 +615,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 +695,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.