DetectionModel

class DetectionModelInterface(ABC):
    @abstractmethod
    def inference(self, image: np.ndarray) -> Tuple[Results, Dict[int, str]]:
        pass

class DetectionModel(DetectionModelInterface):
    def __init__(self)

def inference(self, image: np.ndarray) -> tuple[list[Results], Dict[int, str]]

import cv2
import numpy as np
from arm_system.perception.vision.detection.main import DetectionModel

# Initialize model
model = DetectionModel()

# Load image
image = cv2.imread('test_image.jpg')

# Run inference
results, class_names = model.inference(image)

# Process results
for result in results:
    boxes = result.boxes
    
    if boxes.shape[0] > 0:
        for i in range(boxes.shape[0]):
            # Get detection data
            confidence = boxes.conf.cpu().numpy()[i]
            class_id = int(boxes.cls[i])
            box = boxes.xyxy.cpu().numpy()[i]
            class_name = class_names[class_id]
            
            print(f"Detected: {class_name}")
            print(f"Confidence: {confidence:.2f}")
            print(f"Box: {box}")

# In ImageProcessor.__init__
self.detection: DetectionModelInterface = DetectionModel()

# In ImageProcessor.process_image
object_results, object_classes = self.detection.inference(copy_image)

# Process each result
for res in object_results:
    boxes = res.boxes
    if boxes.shape[0] == 0:
        continue
    
    confidence = boxes.conf.cpu().numpy()[0]
    class_id = int(boxes.cls[0])
    box_data = boxes.xyxy.cpu().numpy()[0]
    detected_class = object_classes[class_id]

DetectionModel
    |
    └── ModelLoader (loads YOLO11s NCNN model)
            |
            └── YOLO (Ultralytics)