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

coralnet_toolbox/Rasters/RasterTableModel.py

@@ -89,7 +89,7 @@ class RasterTableModel(QAbstractTableModel):
                 
         elif role == Qt.TextAlignmentRole:
             return Qt.AlignCenter
-            
+        
         elif role == Qt.FontRole:
             # Bold the selected raster's text
             if raster.is_selected:
@@ -106,12 +106,40 @@ class RasterTableModel(QAbstractTableModel):
                 
         elif role == Qt.ToolTipRole:
             if index.column() == self.FILENAME_COL:
-                # Include full path and metadata in tooltip
                 dimensions = raster.metadata.get('dimensions', f"{raster.width}x{raster.height}")
-                return (f"Path: {path}\n"
-                        f"Dimensions: {dimensions}\n"
-                        f"Has Annotations: {'Yes' if raster.has_annotations else 'No'}\n"
-                        f"Has Predictions: {'Yes' if raster.has_predictions else 'No'}")
+                
+                tooltip_parts = [
+                    f"<b>Path:</b> {path}",
+                    f"<b>Dimensions:</b> {dimensions}",
+                    f"<b>Annotations:</b> {'Yes' if raster.has_annotations else 'No'}",
+                    f"<b>Predictions:</b> {'Yes' if raster.has_predictions else 'No'}"
+                ]
+
+                if raster.has_work_areas():
+                    tooltip_parts.append(f"<b>Work Areas:</b> {raster.count_work_items()}")
+
+                return "<br>".join(tooltip_parts)
+
+            elif index.column() == self.ANNOTATION_COUNT_COL and raster.annotation_count > 0:
+                tooltip_text = f"<b>Total annotations:</b> {raster.annotation_count}"
+                
+                # Add annotation counts per label using a for loop
+                if hasattr(raster, 'label_counts') and raster.label_counts:
+                    label_items = []
+                    for label, count in raster.label_counts.items():
+                        label_items.append(f"<li>{label}: {count}</li>")
+                    label_counts_text = "".join(label_items)
+                    tooltip_text += f"<br><br><b>Annotations by label:</b><ul>{label_counts_text}</ul>"
+                
+                # Add annotation counts per type using a for loop
+                if hasattr(raster, 'annotation_types') and raster.annotation_types:
+                    type_items = []
+                    for type_name, count in raster.annotation_types.items():
+                        type_items.append(f"<li>{type_name}: {count}</li>")
+                    type_counts_text = "".join(type_items)
+                    tooltip_text += f"<br><b>Annotations by type:</b><ul>{type_counts_text}</ul>"
+                
+                return tooltip_text
                 
         return None
         

coralnet_toolbox/SAM/QtBatchInference.py

@@ -35,8 +35,6 @@ class BatchInferenceDialog(QDialog):
         self.deploy_model_dialog = None
         self.loaded_model = None
 
-        self.annotations = []
-        self.prepared_patches = []
         self.image_paths = []
 
         self.layout = QVBoxLayout(self)

coralnet_toolbox/SAM/QtDeployGenerator.py

@@ -384,18 +384,29 @@ class DeployGeneratorDialog(QDialog):
 
     def update_sam_task_state(self):
         """
-        Centralized method to check if SAM is loaded and update task and dropdown accordingly.
+        Centralized method to check if SAM is loaded and update task accordingly.
+        If the user has selected to use SAM, this function ensures the task is set to 'segment'.
+        Crucially, it does NOT alter the task if SAM is not selected, respecting the
+        user's choice from the 'Task' dropdown.
         """
-        sam_active = (
-            self.sam_dialog is not None and 
-            self.sam_dialog.loaded_model is not None and
-            self.use_sam_dropdown.currentText() == "True"
-        )
-        if sam_active:
-            self.task = 'segment'
-        else:
-            self.task = 'detect'
-            self.use_sam_dropdown.setCurrentText("False")
+        # Check if the user wants to use the SAM model
+        if self.use_sam_dropdown.currentText() == "True":
+            # SAM is requested. Check if it's actually available.
+            sam_is_available = (
+                hasattr(self, 'sam_dialog') and
+                self.sam_dialog is not None and
+                self.sam_dialog.loaded_model is not None
+            )
+
+            if sam_is_available:
+                # If SAM is wanted and available, the task must be segmentation.
+                self.task = 'segment'
+            else:
+                # If SAM is wanted but not available, revert the dropdown and do nothing else.
+                # The 'is_sam_model_deployed' function already handles showing an error message.
+                self.use_sam_dropdown.setCurrentText("False")
+
+        # If use_sam_dropdown is "False", do nothing. Let self.task be whatever the user set.
 
     def load_model(self):
         """

coralnet_toolbox/SeeAnything/QtBatchInference.py

@@ -40,23 +40,17 @@ class BatchInferenceDialog(QDialog):
 
         self.setWindowIcon(get_icon("eye.png"))
         self.setWindowTitle("Batch Inference")
-        self.resize(600, 100)
+        self.resize(400, 100)
 
-        self.deploy_model_dialog = None
+        self.deploy_generator_dialog = None
         self.loaded_model = None
 
-        # Reference image and label
-        self.source_image_path = None
-        self.source_label = None
-        # Target images
-        self.target_images = []
+        self.image_paths = []
 
         self.layout = QVBoxLayout(self)
 
         # Setup the info layout
         self.setup_info_layout()
-        # Setup the source layout
-        self.setup_source_layout()
         # Setup the image options layout
         self.setup_options_layout()
         # Setup the buttons layout
@@ -69,11 +63,8 @@ class BatchInferenceDialog(QDialog):
         :param event: Show event
         """
         super().showEvent(event)
-        self.deploy_model_dialog = self.main_window.see_anything_deploy_predictor_dialog
-        self.loaded_model = self.deploy_model_dialog.loaded_model
-
-        # Update the source images (now assuming sources are valid)
-        self.update_source_images()
+        self.deploy_generator_dialog = self.main_window.see_anything_deploy_generator_dialog
+        self.loaded_model = self.deploy_generator_dialog.loaded_model
 
     def setup_info_layout(self):
         """
@@ -92,26 +83,6 @@ class BatchInferenceDialog(QDialog):
         group_box.setLayout(layout)
         self.layout.addWidget(group_box)
 
-    def setup_source_layout(self):
-        """
-        Set up the layout with source image and label selection.
-        Contains dropdown combo boxes for selecting the source image and label.
-        """
-        group_box = QGroupBox("Source Selection")
-        layout = QFormLayout()
-
-        # Create the source image combo box
-        self.source_image_combo_box = QComboBox()
-        self.source_image_combo_box.currentIndexChanged.connect(self.update_source_labels)
-        layout.addRow("Source Image:", self.source_image_combo_box)
-
-        # Create the source label combo box
-        self.source_label_combo_box = QComboBox()
-        layout.addRow("Source Label:", self.source_label_combo_box)
-
-        group_box.setLayout(layout)
-        self.layout.addWidget(group_box)
-
     def setup_options_layout(self):
         """
         Set up the layout with image options.
@@ -159,202 +130,37 @@ class BatchInferenceDialog(QDialog):
 
         self.layout.addWidget(button_box)
 
-    def has_valid_sources(self):
-        """
-        Check if there are any valid source images with polygon or rectangle annotations.
-
-        :return: True if valid sources exist, False otherwise
-        """
-        # Check if there are any images
-        if not self.image_window.raster_manager.image_paths:
-            QMessageBox.information(None,
-                                    "No Images",
-                                    "No images available for batch inference.")
-            return False
-
-        # Check for images with valid annotations
-        for image_path in self.image_window.raster_manager.image_paths:
-            # Get annotations for this image
-            annotations = self.annotation_window.get_image_annotations(image_path)
-
-            # Check if there's at least one valid polygon/rectangle annotation
-            for annotation in annotations:
-                if isinstance(annotation, PolygonAnnotation) or isinstance(annotation, RectangleAnnotation):
-                    return True
-
-        QMessageBox.information(None,
-                                "No Valid Annotations",
-                                "No images have polygon or rectangle annotations for batch inference.")
-        return False
-
-    def check_valid_sources(self):
-        """
-        Check if there are any valid source images with polygon or rectangle annotations.
-
-        :return: True if valid sources exist, False otherwise
-        """
-        # Check if there are any images
-        if not self.image_window.raster_manager.image_paths:
-            QMessageBox.information(self,
-                                    "No Images",
-                                    "No images available for batch inference.")
-            return False
-
-        # Check for images with valid annotations
-        for image_path in self.image_window.raster_manager.image_paths:
-            # Get annotations for this image
-            annotations = self.annotation_window.get_image_annotations(image_path)
-
-            # Check if there's at least one valid polygon/rectangle annotation
-            for annotation in annotations:
-                if isinstance(annotation, PolygonAnnotation) or isinstance(annotation, RectangleAnnotation):
-                    return True
-
-        QMessageBox.information(self,
-                                "No Valid Annotations",
-                                "No images have polygon or rectangle annotations for batch inference.")
-        return False
-
-    def update_source_images(self):
-        """
-        Updates the source image combo box with images that have at least one label
-        with a valid polygon or rectangle annotation.
-
-        :return: True if valid source images were found, False otherwise
-        """
-        self.source_image_combo_box.clear()
-        valid_images_found = False
-
-        # Get all image paths from the raster_manager
-        for image_path in self.image_window.raster_manager.image_paths:
-            # Get annotations for this image
-            annotations = self.annotation_window.get_image_annotations(image_path)
-
-            # Check if there's at least one valid polygon/rectangle annotation
-            valid_annotation_found = False
-            for annotation in annotations:
-                if isinstance(annotation, PolygonAnnotation) or isinstance(annotation, RectangleAnnotation):
-                    valid_annotation_found = True
-                    break
-
-            if valid_annotation_found:
-                # Get the basename (filename)
-                basename = os.path.basename(image_path)
-                # Add item to combo box with full path as data
-                self.source_image_combo_box.addItem(basename, image_path)
-                valid_images_found = True
-
-        if not valid_images_found:
-            QMessageBox.information(self,
-                                    "No Source Images",
-                                    "No images available for batch inference.")
-            # Close the dialog since batch inference can't proceed
-            QApplication.processEvents()  # Process pending events
-            self.reject()
-            return False
-
-        # Update the combo box to have the selected image first
-        if self.annotation_window.current_image_path in self.image_window.raster_manager.image_paths:
-            self.source_image_combo_box.setCurrentText(os.path.basename(self.annotation_window.current_image_path))
-
-        # Update the source labels given changes in the source images
-        return self.update_source_labels()
-
-    def update_source_labels(self):
-        """
-        Updates the source label combo box with labels that have at least one
-        polygon or rectangle annotation from the current image.
-
-        :return: True if valid source labels were found, False otherwise
-        """
-        self.source_label_combo_box.clear()
-
-        source_image_path = self.source_image_combo_box.currentData()
-        if not source_image_path:
-            return False
-
-        # Get annotations for this image
-        annotations = self.annotation_window.get_image_annotations(source_image_path)
-
-        # Create a dict of labels with valid annotations
-        valid_labels = {}
-        for annotation in annotations:
-            if isinstance(annotation, PolygonAnnotation) or isinstance(annotation, RectangleAnnotation):
-                valid_labels[annotation.label.short_label_code] = annotation.label
-
-        # Add valid labels to combo box
-        for label_code, label_obj in valid_labels.items():
-            self.source_label_combo_box.addItem(label_code, label_obj)
-
-        if not valid_labels:
-            QMessageBox.information(self,
-                                    "No Valid Labels",
-                                    "No labels with polygon or rectangle annotations available for batch inference.")
-            # Close the dialog since batch inference can't proceed
-            QApplication.processEvents()  # Process pending events
-            self.reject()
-            return False
-
-        return True
-
-    def get_source_annotations(self):
-        """Return a list of polygon and rectangle annotations for the
-        source image belonging to the selected label."""
-        source_image_path = self.source_image_combo_box.currentData()
-        source_label = self.source_label_combo_box.currentData()
-
-        # Get annotations for this image
-        annotations = self.annotation_window.get_image_annotations(source_image_path)
-
-        # Filter annotations by label
-        source_annotations = []
-        for annotation in annotations:
-            if annotation.label.short_label_code == source_label.short_label_code:
-                source_annotations.append(annotation.cropped_bbox)
-
-        return np.array(source_annotations)
-
     def get_selected_image_paths(self):
         """
         Get the selected image paths based on the options.
-        Excludes the source image path if present.
-    
+
         :return: List of selected image paths
         """
-        # Get the source image path to exclude
-        source_image_path = self.source_image_combo_box.currentData()
-        
         # Current image path showing
         current_image_path = self.annotation_window.current_image_path
         if not current_image_path:
             return []
-    
+
         # Determine which images to export annotations for
         if self.apply_filtered_checkbox.isChecked():
-            selected_paths = self.image_window.table_model.filtered_paths.copy()
+            return self.image_window.table_model.filtered_paths
         elif self.apply_prev_checkbox.isChecked():
             if current_image_path in self.image_window.table_model.filtered_paths:
                 current_index = self.image_window.table_model.get_row_for_path(current_image_path)
-                selected_paths = self.image_window.table_model.filtered_paths[:current_index + 1].copy()
+                return self.image_window.table_model.filtered_paths[:current_index + 1]
             else:
-                selected_paths = [current_image_path]
+                return [current_image_path]
         elif self.apply_next_checkbox.isChecked():
             if current_image_path in self.image_window.table_model.filtered_paths:
                 current_index = self.image_window.table_model.get_row_for_path(current_image_path)
-                selected_paths = self.image_window.table_model.filtered_paths[current_index:].copy()
+                return self.image_window.table_model.filtered_paths[current_index:]
             else:
-                selected_paths = [current_image_path]
+                return [current_image_path]
         elif self.apply_all_checkbox.isChecked():
-            selected_paths = self.image_window.raster_manager.image_paths.copy()
+            return self.image_window.raster_manager.image_paths
         else:
             # Only apply to the current image
-            selected_paths = [current_image_path]
-    
-        # Remove the source image path if it's in the selected paths
-        if source_image_path and source_image_path in selected_paths:
-            selected_paths.remove(source_image_path)
-    
-        return selected_paths
+            return [current_image_path]
 
     def apply(self):
         """
@@ -364,14 +170,8 @@ class BatchInferenceDialog(QDialog):
         QApplication.setOverrideCursor(Qt.WaitCursor)
 
         try:
-            # Get the source image path and label
-            self.source_image_path = self.source_image_combo_box.currentData()
-            self.source_label = self.source_label_combo_box.currentData()
-            # Get the source annotations
-            self.source_annotations = self.get_source_annotations()
             # Get the selected image paths
-            self.target_images = self.get_selected_image_paths()
-            # Perform batch inference
+            self.image_paths = self.get_selected_image_paths()
             self.batch_inference()
 
         except Exception as e:
@@ -385,17 +185,15 @@ class BatchInferenceDialog(QDialog):
     def batch_inference(self):
         """
         Perform batch inference on the selected images.
-
         """
         # Make predictions on each image's annotations
         progress_bar = ProgressBar(self, title="Batch Inference")
         progress_bar.show()
-        progress_bar.start_progress(len(self.target_images))
+        progress_bar.start_progress(len(self.image_paths))
 
         if self.loaded_model is not None:
-            self.deploy_model_dialog.predict_from_annotations(refer_image=self.source_image_path,
-                                                              refer_label=self.source_label,
-                                                              refer_annotations=self.source_annotations,
-                                                              target_images=self.target_images)
+            self.deploy_generator_dialog.predict(image_paths=self.image_paths)
+
         progress_bar.stop_progress()
         progress_bar.close()
+