test

app.py

@@ -8,13 +8,12 @@ import numpy as np
 from pathlib import Path
 from PIL import Image
 import time
-from typing import Tuple, Optional
-import glob
+from typing import Tuple, List
+import asyncio
+import warnings
 
 from model_api.models import Model
 from model_api.visualizer import Visualizer
-import asyncio
-import warnings
 
 warnings.filterwarnings("ignore", message=".*Invalid file descriptor.*")
 
@@ -37,10 +36,7 @@ def get_available_models():
     Returns:
         list: List of model names (without .xml extension)
     """
-    models_dir = Path("models")
-    if not models_dir.exists():
-        return []
-    
+    models_dir = Path("models")   
     xml_files = list(models_dir.glob("*.xml"))
     model_names = [f.stem for f in xml_files]
     return sorted(model_names)
@@ -58,8 +54,6 @@ def load_model(model_name: str, device: str = "CPU"):
         Model instance from model_api
     """
     global current_model, current_model_name
-    
-    # Check if model is already loaded
     if current_model is not None and current_model_name == model_name:
         return current_model
     
@@ -70,14 +64,6 @@ def load_model(model_name: str, device: str = "CPU"):
     
     print(f"Loading model: {model_name}")
     model = Model.create_model(str(model_path), device=device)
-    
-    # Warm-up inference
-    print("Warming up model...")
-    dummy_image = np.ones((224, 224, 3), dtype=np.uint8)
-    for _ in range(3):
-        _ = model(dummy_image)
-    
-    # Reset metrics after warm-up
     model.get_performance_metrics().reset()
     
     current_model = model
@@ -87,13 +73,13 @@ def load_model(model_name: str, device: str = "CPU"):
     return model
 
 
-def classify_image(
+def run_inference(
     image: np.ndarray,
     model_name: str,
     confidence_threshold: float
 ) -> Tuple[Image.Image, str, str]:
     """
-    Perform image classification and return visualized result with metrics.
+    Perform inference and return visualized result with metrics.
     
     Args:
         image: Input image as numpy array
@@ -101,23 +87,20 @@ def classify_image(
         confidence_threshold: Confidence threshold for filtering predictions
     
     Returns:
-        Tuple of (visualized_image, detections_text, metrics_text)
+        Tuple of (visualized_image, results_text, metrics_text)
     """
+    # Input validation
+    if image is None:
+        return None, "⚠️ Please upload an image first.", ""
+    
+    if model_name is None or model_name == "No models available":
+        return None, "⚠️ No model selected or available.", ""
+    
     try:
-        # Load model
         model = load_model(model_name)
         
-        # Convert numpy array to PIL Image if needed
-        if isinstance(image, np.ndarray):
-            pil_image = Image.fromarray(image)
-        else:
-            pil_image = image
-        
-        # Convert PIL to numpy for model_api
-        image_np = np.array(pil_image)
-        
         # Run inference
-        result = model(image_np)
+        result = model(image)
         
         # Get performance metrics
         metrics = model.get_performance_metrics()
@@ -138,33 +121,76 @@ def classify_image(
 📈 Total Frames:   {inference_time.count}
 """
         
-        # Filter predictions by confidence threshold
-        detections_text = "🔍 Detected Objects:\n"
-        detections_text += "━" * 50 + "\n"
-        
-        if result.top_labels and len(result.top_labels) > 0:
-            filtered_labels = [
-                label for label in result.top_labels 
-                if label.confidence >= confidence_threshold
-            ]
-            
-            if filtered_labels:
-                for i, label in enumerate(filtered_labels, 1):
-                    detections_text += f"{i}. {label.name}: {label.confidence:.3f}\n"
-            else:
-                detections_text += f"No detections above confidence threshold {confidence_threshold:.2f}\n"
-        else:
-            detections_text += "No detections found\n"
+        # Format results based on model type
+        results_text = format_results(result, confidence_threshold)
         
         # Visualize results using model_api's visualizer
-        visualized_image = visualizer.render(pil_image, result)
+        visualized_image = visualizer.render(image, result)
         
-        return visualized_image, detections_text, metrics_text
+        return visualized_image, metrics_text, metrics_text
         
     except Exception as e:
         error_msg = f"Error during inference: {str(e)}"
-        print(error_msg)
-        return image, error_msg, "Error: Could not compute metrics"
+        return None, error_msg, "Error: Could not compute metrics"
+
+
+def format_results(result, confidence_threshold: float) -> str:
+    """
+    Format model results (classification or detection) as text.
+    
+    Args:
+        result: Result object from model_api
+        confidence_threshold: Confidence threshold for filtering
+    
+    Returns:
+        Formatted results text
+    """
+    # Check if it's a classification result
+    if hasattr(result, 'top_labels') and result.top_labels:
+        results_text = "🔍 Classification Results:\n"
+        results_text += "━" * 50 + "\n"
+        
+        filtered_labels = [
+            label for label in result.top_labels 
+            if label.confidence >= confidence_threshold
+        ]
+        
+        if filtered_labels:
+            for i, label in enumerate(filtered_labels, 1):
+                results_text += f"{i}. {label.name}: {label.confidence:.3f}\n"
+        else:
+            results_text += f"No predictions above confidence threshold {confidence_threshold:.2f}\n"
+    
+    # Check if it's a detection result
+    elif hasattr(result, 'segmentedObjects') and result.segmentedObjects:
+        results_text = "🔍 Detected Objects:\n"
+        results_text += "━" * 50 + "\n"
+        
+        # Filter by confidence
+        filtered_objects = [
+            obj for obj in result.segmentedObjects
+            if obj.score >= confidence_threshold
+        ]
+        
+        if filtered_objects:
+            from collections import Counter
+            label_counts = Counter(obj.str_label for obj in filtered_objects)
+            
+            for i, obj in enumerate(filtered_objects, 1):
+                x1, y1 = int(obj.xmin), int(obj.ymin)
+                x2, y2 = int(obj.xmax), int(obj.ymax)
+                results_text += f"{i}. {obj.str_label}: {obj.score:.3f} @ [{x1}, {y1}, {x2}, {y2}]\n"
+            
+            results_text += "\n📊 Summary:\n"
+            for label, count in label_counts.most_common():
+                results_text += f"  • {label}: {count}\n"
+        else:
+            results_text += f"No detections above confidence threshold {confidence_threshold:.2f}\n"
+    
+    else:
+        results_text = "No results available\n"
+    
+    return results_text
 
 
 def create_gradio_interface():
@@ -214,6 +240,7 @@ def create_gradio_interface():
                 output_image = gr.Image(
                     label="Detection Result",
                     type="pil",
+                    show_label=False,
                     height=400
                 )
                 
@@ -233,20 +260,20 @@ def create_gradio_interface():
         gr.Markdown("## 📸 Examples")
         gr.Examples(
             examples=[
-                ["examples/image1.jpg", available_models[0] if available_models else "resnet18", 0.3],
-                ["examples/people-walking.png", available_models[0] if available_models else "resnet50", 0.4],
-                ["examples/vehicles.png", available_models[0] if available_models else "resnet18", 0.5],
-                ["examples/zidane.jpg", available_models[0] if available_models else "resnet18", 0.5],
+                ["examples/image1.jpg", "maskrcnn_resnet50_fpn_v2" if "maskrcnn_resnet50_fpn_v2" in available_models else available_models[0], 0.5],
+                ["examples/people-walking.png", "maskrcnn_resnet50_fpn_v2" if "maskrcnn_resnet50_fpn_v2" in available_models else available_models[0], 0.5],
+                ["examples/vehicles.png", "maskrcnn_resnet50_fpn_v2" if "maskrcnn_resnet50_fpn_v2" in available_models else available_models[0], 0.5],
+                ["examples/zidane.jpg", "maskrcnn_resnet50_fpn_v2" if "maskrcnn_resnet50_fpn_v2" in available_models else available_models[0], 0.5],
             ],
             inputs=[input_image, model_dropdown, confidence_slider],
             outputs=[output_image, detections_output, metrics_output],
-            fn=classify_image,
+            fn=run_inference,
             cache_examples=False
         )
         
         # Connect the button to the inference function
         classify_btn.click(
-            fn=classify_image,
+            fn=run_inference,
             inputs=[input_image, model_dropdown, confidence_slider],
             outputs=[output_image, detections_output, metrics_output]
         )

models/serialized.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:91eab2c806de2b61101cdeabbe97d091b8dda14fbb7ee8b8db3b9e54e4b8b72e
+size 10566189

requirements.txt

@@ -2,4 +2,5 @@ gradio>=4.0.0
 numpy>=1.21.0
 pillow>=9.0.0
 openvino>=2024.0.0
-git+https://github.com/open-edge-platform/model_api.git
+opencv-python-headless>=4.5.0
+git+https://github.com/open-edge-platform/model_api.git@mgumowsk/add-models-to-tool-converter