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

coralnet_toolbox/SeeAnything/QtDeployGenerator.py

@@ -416,7 +416,7 @@ class DeployGeneratorDialog(QDialog):
 
         # Image size control
         self.imgsz_spinbox = QSpinBox()
-        self.imgsz_spinbox.setRange(512, 65536)
+        self.imgsz_spinbox.setRange(1024, 65536)
         self.imgsz_spinbox.setSingleStep(1024)
         self.imgsz_spinbox.setValue(self.imgsz)
         layout.addRow("Image Size (imgsz):", self.imgsz_spinbox)
@@ -502,8 +502,13 @@ class DeployGeneratorDialog(QDialog):
 
         main_layout.addLayout(button_row)
 
-        # Second row: Save VPE button + Show VPE button side by side
+        # Second row: VPE action buttons
         vpe_row = QHBoxLayout()
+        
+        generate_vpe_button = QPushButton("Generate VPEs")
+        generate_vpe_button.clicked.connect(self.generate_vpes_from_references)
+        vpe_row.addWidget(generate_vpe_button)
+
         save_vpe_button = QPushButton("Save VPE")
         save_vpe_button.clicked.connect(self.save_vpe)
         vpe_row.addWidget(save_vpe_button)
@@ -810,80 +815,75 @@ class DeployGeneratorDialog(QDialog):
             
     def save_vpe(self):
         """
-        Save the combined collection of VPEs (imported and reference-generated) to disk.
+        Saves the combined collection of VPEs (imported and pre-generated from references) to disk.
         """
-        # Always sync with the live UI selection before saving.
-        self.update_stashed_references_from_ui()
-
-        # Create a list to hold all VPEs
-        all_vpes = []
-        
-        # Add imported VPEs if available
-        if self.imported_vpes:
-            all_vpes.extend(self.imported_vpes)
+        QApplication.setOverrideCursor(Qt.WaitCursor)
         
-        # Check if we should generate new VPEs from reference images
-        references_dict = self._get_references()
-        if references_dict:
-            # Reload the model to ensure clean state
-            self.reload_model()
+        try:
+            # Create a list to hold all VPEs to be saved
+            all_vpes = []
             
-            # Convert references to VPEs without updating self.reference_vpes yet
-            new_vpes = self.references_to_vpe(references_dict, update_reference_vpes=False)
+            # Add imported VPEs if available
+            if self.imported_vpes:
+                all_vpes.extend(self.imported_vpes)
             
-            if new_vpes:
-                # Add new VPEs to collection
-                all_vpes.extend(new_vpes)
-                # Update reference_vpes with the new ones
-                self.reference_vpes = new_vpes
-        else:
-            # Include existing reference VPEs if we have them
+            # Add pre-generated reference VPEs if available
             if self.reference_vpes:
                 all_vpes.extend(self.reference_vpes)
-        
-        # Check if we have any VPEs to save
-        if not all_vpes:
-            QMessageBox.warning(
+            
+            # Check if we have any VPEs to save
+            if not all_vpes:
+                QApplication.restoreOverrideCursor()
+                QMessageBox.warning(
+                    self,
+                    "No VPEs Available",
+                    "No VPEs available to save. "
+                    "Please either load a VPE file or generate VPEs from reference images first."
+                )
+                return
+            
+            QApplication.restoreOverrideCursor()
+            
+            file_path, _ = QFileDialog.getSaveFileName(
                 self,
-                "No VPEs Available",
-                "No VPEs available to save. Please either load a VPE file or select reference images."
+                "Save VPE Collection",
+                "",
+                "PyTorch Tensor (*.pt);;All Files (*)"
             )
-            return
-        
-        # Open file dialog to select save location
-        file_path, _ = QFileDialog.getSaveFileName(
-            self,
-            "Save VPE Collection",
-            "",
-            "PyTorch Tensor (*.pt);;All Files (*)"
-        )
-        
-        if not file_path:
-            return  # User canceled the dialog
-        
-        # Add .pt extension if not present
-        if not file_path.endswith('.pt'):
-            file_path += '.pt'
-        
-        try:
-            # Move tensors to CPU before saving
+            
+            if not file_path:
+                return
+            
+            QApplication.setOverrideCursor(Qt.WaitCursor)
+            
+            if not file_path.endswith('.pt'):
+                file_path += '.pt'
+            
             vpe_list_cpu = [vpe.cpu() for vpe in all_vpes]
             
-            # Save the list of tensors
             torch.save(vpe_list_cpu, file_path)
             
             self.status_bar.setText(f"Saved {len(all_vpes)} VPE tensors to {os.path.basename(file_path)}")
+            
+            QApplication.restoreOverrideCursor()
             QMessageBox.information(
                 self,
                 "VPE Saved",
                 f"Saved {len(all_vpes)} VPE tensors to {file_path}"
             )
+            
         except Exception as e:
+            QApplication.restoreOverrideCursor()
             QMessageBox.critical(
                 self,
                 "Error Saving VPE",
                 f"Failed to save VPE: {str(e)}"
             )
+        finally:
+            try:
+                QApplication.restoreOverrideCursor()
+            except:
+                pass
 
     def load_model(self):
         """
@@ -1156,6 +1156,59 @@ class DeployGeneratorDialog(QDialog):
         
         return [[combined_results]]
     
+    def generate_vpes_from_references(self):
+        """
+        Calculates VPEs from the currently highlighted reference images and
+        stores them in self.reference_vpes, overwriting any previous ones.
+        """
+        if not self.loaded_model:
+            QMessageBox.warning(self, "No Model Loaded", "A model must be loaded before generating VPEs.")
+            return
+
+        # Always sync with the live UI selection before generating.
+        self.update_stashed_references_from_ui()
+        references_dict = self._get_references()
+
+        if not references_dict:
+            QMessageBox.information(
+                self,
+                "No References Selected",
+                "Please highlight one or more reference images in the table to generate VPEs."
+            )
+            return
+
+        QApplication.setOverrideCursor(Qt.WaitCursor)
+        progress_bar = ProgressBar(self, title="Generating VPEs")
+        progress_bar.show()
+
+        try:
+            # Make progress bar busy
+            progress_bar.set_busy_mode("Generating VPEs...")
+            # Reload the model to ensure a clean state for VPE generation
+            self.reload_model()
+
+            # The references_to_vpe method will calculate and update self.reference_vpes
+            new_vpes = self.references_to_vpe(references_dict, update_reference_vpes=True)
+
+            if new_vpes:
+                num_vpes = len(new_vpes)
+                num_images = len(references_dict)
+                message = f"Successfully generated {num_vpes} VPEs from {num_images} reference image(s)."
+                self.status_bar.setText(message)
+                QMessageBox.information(self, "VPEs Generated", message)
+            else:
+                message = "Could not generate VPEs. Ensure annotations are valid."
+                self.status_bar.setText(message)
+                QMessageBox.warning(self, "Generation Failed", message)
+
+        except Exception as e:
+            QMessageBox.critical(self, "Error Generating VPEs", f"An unexpected error occurred: {str(e)}")
+            self.status_bar.setText("Error during VPE generation.")
+        finally:
+            QApplication.restoreOverrideCursor()
+            progress_bar.stop_progress()
+            progress_bar.close()
+    
     def references_to_vpe(self, reference_dict, update_reference_vpes=True):
         """
         Converts the contents of a reference dictionary to VPEs (Visual Prompt Embeddings).
@@ -1197,14 +1250,13 @@ class DeployGeneratorDialog(QDialog):
             
         return vpe_list
 
-    def _apply_model_using_vpe(self, inputs, references_dict):
+    def _apply_model_using_vpe(self, inputs):
         """
-        Apply the model to the inputs using combined VPEs from both imported files
-        and reference annotations.
+        Apply the model to the inputs using pre-calculated VPEs from imported files
+        and/or generated from reference annotations.
         
         Args:
             inputs (list): List of input images.
-            references_dict (dict): Dictionary containing reference annotations for each image.
             
         Returns:
             list: List of prediction results.
@@ -1219,23 +1271,17 @@ class DeployGeneratorDialog(QDialog):
         if self.imported_vpes:
             combined_vpes.extend(self.imported_vpes)
             
-        # Process reference images to VPEs if any exist
-        if references_dict:
-            # Only update reference_vpes if references_dict is not empty
-            reference_vpes = self.references_to_vpe(references_dict, update_reference_vpes=True)
-            if reference_vpes:
-                combined_vpes.extend(reference_vpes)
-        else:
-            # Use existing reference_vpes if we have them
-            if self.reference_vpes:
-                combined_vpes.extend(self.reference_vpes)
+        # Add pre-generated reference VPEs if available
+        if self.reference_vpes:
+            combined_vpes.extend(self.reference_vpes)
         
         # Check if we have any VPEs to use
         if not combined_vpes:
             QMessageBox.warning(
                 self,
                 "No VPEs Available",
-                "No VPEs available for prediction. Please either load a VPE file or select reference images."
+                "No VPEs are available for prediction. "
+                "Please either load a VPE file or generate VPEs from reference images."
             )
             return []
         
@@ -1260,7 +1306,7 @@ class DeployGeneratorDialog(QDialog):
                                             retina_masks=self.task == "segment")
 
         return [results]
-        
+
     def _apply_model(self, inputs):
         """
         Apply the model to the target inputs. This method handles both image-based 
@@ -1278,21 +1324,9 @@ class DeployGeneratorDialog(QDialog):
         
         # Check if the user is using VPE or Reference Images
         if self.reference_method_combo_box.currentText() == "VPE":
-            # Check if we have any VPEs available (imported or reference-generated)
-            has_vpes = bool(self.imported_vpes or self.reference_vpes)
-            
-            # If we have reference images selected but no imported VPEs yet,
-            # warn the user only if we also don't have any reference images
-            if not has_vpes and not references_dict:
-                QMessageBox.warning(
-                    self,
-                    "No VPEs Available",
-                    "No VPEs available for prediction. Please either load a VPE file or select reference images."
-                )
-                return []
-                
-            # Use the VPE method, which will combine imported and reference VPEs
-            results = self._apply_model_using_vpe(inputs, references_dict)
+            # The VPE method will use pre-loaded/pre-generated VPEs.
+            # The internal checks for whether any VPEs exist are now inside _apply_model_using_vpe.
+            results = self._apply_model_using_vpe(inputs)
         else:  
             # Use Reference Images method - requires reference images
             if not references_dict:
@@ -1405,16 +1439,9 @@ class DeployGeneratorDialog(QDialog):
         
     def show_vpe(self):
         """
-        Show a visualization of the VPEs using PyQtGraph.
-        This method now always recalculates VPEs from the currently highlighted reference images.
+        Show a visualization of the currently stored VPEs using PyQtGraph.
         """
-        # Set cursor to busy while loading VPEs
-        QApplication.setOverrideCursor(Qt.WaitCursor)
-        
         try:
-            # Always sync with the live UI selection before visualizing.
-            self.update_stashed_references_from_ui()
-
             vpes_with_source = []
 
             # 1. Add any VPEs that were loaded from a file
@@ -1422,37 +1449,35 @@ class DeployGeneratorDialog(QDialog):
                 for vpe in self.imported_vpes:
                     vpes_with_source.append((vpe, "Import"))
 
-            # 2. Get the currently selected reference images from the stashed list
-            references_dict = self._get_references()
-
-            # 3. If there are reference images, calculate their VPEs and add with source type
-            if references_dict:
-                self.reload_model()
-                new_reference_vpes = self.references_to_vpe(references_dict, update_reference_vpes=True)
-                if new_reference_vpes:
-                    for vpe in new_reference_vpes:
-                        vpes_with_source.append((vpe, "Reference"))
+            # 2. Add any pre-generated VPEs from reference images
+            if self.reference_vpes:
+                for vpe in self.reference_vpes:
+                    vpes_with_source.append((vpe, "Reference"))
 
-            # 4. Check if there is anything to visualize
+            # 3. Check if there is anything to visualize
             if not vpes_with_source:
                 QMessageBox.warning(
                     self,
                     "No VPEs Available",
-                    "No VPEs available to visualize. Please either load a VPE file or select reference images."
+                    "No VPEs available to visualize. Please load a VPE file or generate VPEs from references first."
                 )
                 return
 
-            # 5. Create the visualization dialog, passing the list of tuples
+            # 4. Create the visualization dialog
             all_vpe_tensors = [vpe for vpe, source in vpes_with_source]
             averaged_vpe = torch.cat(all_vpe_tensors).mean(dim=0, keepdim=True)
             final_vpe = torch.nn.functional.normalize(averaged_vpe, p=2, dim=-1)
 
+            QApplication.setOverrideCursor(Qt.WaitCursor)
+            
             dialog = VPEVisualizationDialog(vpes_with_source, final_vpe, self)
+            QApplication.restoreOverrideCursor()
+            
             dialog.exec_()
             
-        finally:
-            # Always restore cursor, even if an exception occurs
+        except Exception as e:
             QApplication.restoreOverrideCursor()
+            QMessageBox.critical(self, "Error Visualizing VPE", f"An error occurred: {str(e)}")
         
     def deactivate_model(self):
         """

coralnet_toolbox/SeeAnything/QtDeployPredictor.py

@@ -171,7 +171,7 @@ class DeployPredictorDialog(QDialog):
         # Image size control
         self.imgsz_spinbox = QSpinBox()
         self.imgsz_spinbox.setRange(512, 65536)
-        self.imgsz_spinbox.setSingleStep(256)
+        self.imgsz_spinbox.setSingleStep(1024)
         self.imgsz_spinbox.setValue(self.imgsz)
         layout.addRow("Image Size (imgsz)", self.imgsz_spinbox)
 
@@ -322,6 +322,7 @@ class DeployPredictorDialog(QDialog):
     def is_sam_model_deployed(self):
         """
         Check if the SAM model is deployed and update the checkbox state accordingly.
+        If SAM is enabled for polygons, sync and disable the imgsz spinbox.
 
         :return: Boolean indicating whether the SAM model is deployed
         """
@@ -334,9 +335,48 @@ class DeployPredictorDialog(QDialog):
             self.use_sam_dropdown.setCurrentText("False")
             QMessageBox.critical(self, "Error", "Please deploy the SAM model first.")
             return False
+        
+        # Check if SAM polygons are enabled
+        if self.use_sam_dropdown.currentText() == "True":
+            # Sync the imgsz spinbox with SAM's value
+            self.imgsz_spinbox.setValue(self.sam_dialog.imgsz_spinbox.value())
+            # Disable the spinbox
+            self.imgsz_spinbox.setEnabled(False)
+            
+            # Connect SAM's imgsz_spinbox valueChanged signal to update our value
+            # First disconnect any existing connection to avoid duplicates
+            try:
+                self.sam_dialog.imgsz_spinbox.valueChanged.disconnect(self.update_from_sam_imgsz)
+            except TypeError:
+                # No connection exists yet
+                pass
+            
+            # Connect the signal
+            self.sam_dialog.imgsz_spinbox.valueChanged.connect(self.update_from_sam_imgsz)
+        else:
+            # Re-enable the spinbox when SAM polygons are disabled
+            self.imgsz_spinbox.setEnabled(True)
+            
+            # Disconnect the signal when SAM is disabled
+            try:
+                self.sam_dialog.imgsz_spinbox.valueChanged.disconnect(self.update_from_sam_imgsz)
+            except TypeError:
+                # No connection exists
+                pass
 
         return True
 
+    def update_from_sam_imgsz(self, value):
+        """
+        Update the SeeAnything image size when SAM's image size changes.
+        Only takes effect when SAM polygons are enabled.
+        
+        Args:
+            value (int): The new image size value from SAM dialog
+        """
+        if self.use_sam_dropdown.currentText() == "True":
+            self.imgsz_spinbox.setValue(value)
+
     def load_model(self):
         """
         Load the selected model.
@@ -372,7 +412,9 @@ class DeployPredictorDialog(QDialog):
                 imgsz=640,
                 conf=0.99,
             )
-
+            # Finish the progress bar
+            progress_bar.finish_progress()
+            # Update the status bar
             self.status_bar.setText(f"Loaded ({self.model_path}")
             QMessageBox.information(self.annotation_window, "Model Loaded", "Model loaded successfully")
 
@@ -388,7 +430,7 @@ class DeployPredictorDialog(QDialog):
             progress_bar.stop_progress()
             progress_bar.close()
             progress_bar = None
-
+            
     def resize_image(self, image):
         """
         Resize the image to the specified size.

coralnet_toolbox/Tools/QtPolygonTool.py

@@ -133,12 +133,51 @@ class PolygonTool(Tool):
             return None
 
         # Create the annotation with current points
-        # The polygon simplification is now handled inside the PolygonAnnotation class
         if finished and len(self.points) > 2:
             # Close the polygon
             self.points.append(self.points[0])
-
-        # Create the annotation - will be simplified in the constructor
+            
+            # --- Validation for polygon size and shape ---
+            # Step 1: Remove duplicate or near-duplicate points
+            filtered_points = []
+            MIN_DISTANCE = 2.0  # Minimum distance between points in pixels
+            
+            for i, point in enumerate(self.points):
+                # Skip if this point is too close to the previous one
+                if i > 0:
+                    prev_point = filtered_points[-1]
+                    distance = ((point.x() - prev_point.x())**2 + (point.y() - prev_point.y())**2)**0.5
+                    if distance < MIN_DISTANCE:
+                        continue
+                filtered_points.append(point)
+            
+            # Step 2: Ensure we have enough points for a valid polygon
+            if len(filtered_points) < 4:  # Need at least 3 + 1 closing point
+                # Create a small triangle/square if we don't have enough points
+                if len(filtered_points) > 0:
+                    center_x = sum(p.x() for p in filtered_points) / len(filtered_points)
+                    center_y = sum(p.y() for p in filtered_points) / len(filtered_points)
+                    
+                    # Create a small polygon centered on the average of existing points
+                    MIN_SIZE = 5.0
+                    filtered_points = [
+                        QPointF(center_x - MIN_SIZE, center_y - MIN_SIZE),
+                        QPointF(center_x + MIN_SIZE, center_y - MIN_SIZE),
+                        QPointF(center_x + MIN_SIZE, center_y + MIN_SIZE),
+                        QPointF(center_x - MIN_SIZE, center_y + MIN_SIZE),
+                        QPointF(center_x - MIN_SIZE, center_y - MIN_SIZE)  # Close the polygon
+                    ]
+                    
+                    QMessageBox.information(
+                        self.annotation_window, 
+                        "Polygon Adjusted",
+                        "The polygon had too few unique points and has been adjusted to a minimum size."
+                    )
+            
+            # Use the filtered points list instead of the original
+            self.points = filtered_points
+
+        # Create the annotation with validated points
         annotation = PolygonAnnotation(self.points,
                                        self.annotation_window.selected_label.short_label_code,
                                        self.annotation_window.selected_label.long_label_code,

coralnet_toolbox/Tools/QtRectangleTool.py

@@ -113,6 +113,36 @@ class RectangleTool(Tool):
         # Ensure top_left and bottom_right are correctly calculated
         top_left = QPointF(min(self.start_point.x(), end_point.x()), min(self.start_point.y(), end_point.y()))
         bottom_right = QPointF(max(self.start_point.x(), end_point.x()), max(self.start_point.y(), end_point.y()))
+        
+        # Calculate width and height of the rectangle
+        width = bottom_right.x() - top_left.x()
+        height = bottom_right.y() - top_left.y()
+        
+        # Define minimum dimensions for a valid rectangle (e.g., 3x3 pixels)
+        MIN_DIMENSION = 3.0
+        
+        # If rectangle is too small and we're finalizing it, enforce minimum size
+        if finished and (width < MIN_DIMENSION or height < MIN_DIMENSION):
+            if width < MIN_DIMENSION:
+                # Expand width while maintaining center
+                center_x = (top_left.x() + bottom_right.x()) / 2
+                top_left.setX(center_x - MIN_DIMENSION / 2)
+                bottom_right.setX(center_x + MIN_DIMENSION / 2)
+                
+            if height < MIN_DIMENSION:
+                # Expand height while maintaining center
+                center_y = (top_left.y() + bottom_right.y()) / 2
+                top_left.setY(center_y - MIN_DIMENSION / 2)
+                bottom_right.setY(center_y + MIN_DIMENSION / 2)
+            
+            # Show a message if we had to adjust a very small rectangle
+            if width < 1 or height < 1:
+                QMessageBox.information(
+                    self.annotation_window, 
+                    "Rectangle Adjusted",
+                    f"The rectangle was too small and has been adjusted to a minimum size of "
+                    f"{MIN_DIMENSION}x{MIN_DIMENSION} pixels."
+                )
 
         # Create the rectangle annotation
         annotation = RectangleAnnotation(top_left,

coralnet_toolbox/__init__.py

@@ -1,6 +1,6 @@
 """Top-level package for CoralNet-Toolbox."""
 
-__version__ = "0.0.74"
+__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

@@ -571,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()

{coralnet_toolbox-0.0.74.dist-info → coralnet_toolbox-0.0.75.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coralnet-toolbox
-Version: 0.0.74
+Version: 0.0.75
 Summary: Tools for annotating and developing ML models for benthic imagery
 Author-email: Jordan Pierce <jordan.pierce@noaa.gov>
 License: MIT License
@@ -27,7 +27,8 @@ Requires-Dist: pycocotools
 Requires-Dist: ujson
 Requires-Dist: timm==0.9.2
 Requires-Dist: autodistill
-Requires-Dist: transformers>=4.5.0
+Requires-Dist: transformers>=4.55.4
+Requires-Dist: hf_xet
 Requires-Dist: x-segment-anything>=0.0.8
 Requires-Dist: yolo-tiling>=0.0.19
 Requires-Dist: roboflow
@@ -308,7 +309,9 @@ uv pip install -U coralnet-toolbox==[latest_version]
 ### 🏗️ **Repository Structure**
 
 <div align="center">
-![Visualization of the codebase](./diagram.svg)
+  <a href="https://raw.githubusercontent.com/Jordan-Pierce/CoralNet-Toolbox/refs/heads/main/diagram.svg">
+    <img src="https://raw.githubusercontent.com/Jordan-Pierce/CoralNet-Toolbox/refs/heads/main/diagram.svg" alt="Visualization of the codebase" width="80%">
+  </a>
 </div>
 
 ---