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

coralnet_toolbox/Explorer/QtDataItem.py

@@ -121,24 +121,45 @@ class AnnotationImageWidget(QWidget):
         self.setToolTip(self.data_item.get_tooltip_text())
 
     def recalculate_aspect_ratio(self):
-        """Calculate aspect ratio from annotation geometry without loading image."""
+        """Calculate and store the annotation's aspect ratio."""
+        annotation = self.data_item.annotation
+        
+        # Try to use the cropped_bbox attribute first
+        if hasattr(annotation, 'cropped_bbox'):
+            min_x, min_y, max_x, max_y = annotation.cropped_bbox
+            width = max_x - min_x
+            height = max_y - min_y
+            
+            if height > 0:
+                self.aspect_ratio = width / height
+                return
+        
+        # Fallback to bounding box methods
         try:
-            if hasattr(self.annotation, 'rect'):  # RectangleAnnotation
-                rect = self.annotation.rect
-                if rect.height() > 0:
-                    self.aspect_ratio = rect.width() / rect.height()
-            elif hasattr(self.annotation, 'size'):  # PatchAnnotation
-                self.aspect_ratio = 1.0
-            elif hasattr(self.annotation, 'polygon'):  # PolygonAnnotation
-                rect = self.annotation.polygon.boundingRect()
-                if rect.height() > 0:
-                    self.aspect_ratio = rect.width() / rect.height()
-            else:
-                # Fallback for other types or if geometry is not available
-                self.aspect_ratio = 1.0
-        except Exception as e:
-            print(f"Could not determine aspect ratio for {self.annotation.id}: {e}")
-            self.aspect_ratio = 1.0
+            top_left = annotation.get_bounding_box_top_left()
+            bottom_right = annotation.get_bounding_box_bottom_right()
+            
+            if top_left and bottom_right:
+                width = bottom_right.x() - top_left.x()
+                height = bottom_right.y() - top_left.y()
+                
+                if height > 0:
+                    self.aspect_ratio = width / height
+                    return
+        except (AttributeError, TypeError):
+            pass
+        
+        # Last resort: try to get aspect ratio from the cropped image
+        try:
+            pixmap = annotation.get_cropped_image()
+            if pixmap and not pixmap.isNull() and pixmap.height() > 0:
+                self.aspect_ratio = pixmap.width() / pixmap.height()
+                return
+        except (AttributeError, TypeError):
+            pass
+        
+        # Default to square if we can't determine aspect ratio
+        self.aspect_ratio = 1.0
 
     def load_image(self):
         """Loads the image pixmap if it hasn't been loaded yet."""
@@ -356,16 +377,25 @@ class AnnotationDataItem:
         return "<br>".join(tooltip_parts)
 
     def get_effective_confidence(self):
-        """Get the effective confidence value."""
+        """
+        Get the effective confidence value, handling scalar, array, and vector predictions.
+        """
         # First check if prediction probabilities are available from model predictions
         if hasattr(self, 'prediction_probabilities') and self.prediction_probabilities is not None:
-            if len(self.prediction_probabilities) > 0:
-                # Use the maximum probability for confidence sorting
-                return float(np.max(self.prediction_probabilities))
-        
+            probs = self.prediction_probabilities
+            try:
+                # This will succeed for lists and multi-element numpy arrays
+                if len(probs) > 0:
+                    return float(np.max(probs))
+            except TypeError:
+                # This will catch the error if `len()` is called on a scalar or 0-D array.
+                # In this case, the value of `probs` itself is the confidence score.
+                return float(probs)
+
         # Fallback to existing confidence values
         if self.annotation.verified and hasattr(self.annotation, 'user_confidence') and self.annotation.user_confidence:
             return list(self.annotation.user_confidence.values())[0]
         elif hasattr(self.annotation, 'machine_confidence') and self.annotation.machine_confidence:
             return list(self.annotation.machine_confidence.values())[0]
+            
         return 0.0