ultralytics 8.3.53__py3-none-any.whl → 8.3.55__py3-none-any.whl

ultralytics/models/sam/predict.py

@@ -1377,7 +1377,7 @@ class SAM2VideoPredictor(SAM2Predictor):
             if "maskmem_pos_enc" not in model_constants:
                 assert isinstance(out_maskmem_pos_enc, list)
                 # only take the slice for one object, since it's same across objects
-                maskmem_pos_enc = [x[0:1].clone() for x in out_maskmem_pos_enc]
+                maskmem_pos_enc = [x[:1].clone() for x in out_maskmem_pos_enc]
                 model_constants["maskmem_pos_enc"] = maskmem_pos_enc
             else:
                 maskmem_pos_enc = model_constants["maskmem_pos_enc"]

ultralytics/nn/autobackend.py

@@ -192,14 +192,14 @@ class AutoBackend(nn.Module):
                 check_requirements("numpy==1.23.5")
             import onnxruntime
 
-            providers = onnxruntime.get_available_providers()
-            if not cuda and "CUDAExecutionProvider" in providers:
-                providers.remove("CUDAExecutionProvider")
-            elif cuda and "CUDAExecutionProvider" not in providers:
-                LOGGER.warning("WARNING ⚠️ Failed to start ONNX Runtime session with CUDA. Falling back to CPU...")
+            providers = ["CPUExecutionProvider"]
+            if cuda and "CUDAExecutionProvider" in onnxruntime.get_available_providers():
+                providers.insert(0, "CUDAExecutionProvider")
+            elif cuda:  # Only log warning if CUDA was requested but unavailable
+                LOGGER.warning("WARNING ⚠️ Failed to start ONNX Runtime with CUDA. Using CPU...")
                 device = torch.device("cpu")
                 cuda = False
-            LOGGER.info(f"Preferring ONNX Runtime {providers[0]}")
+            LOGGER.info(f"Using ONNX Runtime {providers[0]}")
             if onnx:
                 session = onnxruntime.InferenceSession(w, providers=providers)
             else:
@@ -429,10 +429,7 @@ class AutoBackend(nn.Module):
 
             import MNN
 
-            config = {}
-            config["precision"] = "low"
-            config["backend"] = "CPU"
-            config["numThread"] = (os.cpu_count() + 1) // 2
+            config = {"precision": "low", "backend": "CPU", "numThread": (os.cpu_count() + 1) // 2}
             rt = MNN.nn.create_runtime_manager((config,))
             net = MNN.nn.load_module_from_file(w, [], [], runtime_manager=rt, rearrange=True)
 

ultralytics/solutions/__init__.py

@@ -10,7 +10,7 @@ from .queue_management import QueueManager
 from .region_counter import RegionCounter
 from .security_alarm import SecurityAlarm
 from .speed_estimation import SpeedEstimator
-from .streamlit_inference import inference
+from .streamlit_inference import Inference
 from .trackzone import TrackZone
 
 __all__ = (
@@ -23,7 +23,7 @@ __all__ = (
     "QueueManager",
     "SpeedEstimator",
     "Analytics",
-    "inference",
+    "Inference",
     "RegionCounter",
     "TrackZone",
     "SecurityAlarm",

ultralytics/solutions/analytics.py

@@ -170,7 +170,7 @@ class Analytics(BaseSolution):
                 for key in count_dict.keys():
                     y_data_dict[key] = np.append(y_data_dict[key], float(count_dict[key]))
                     if len(y_data_dict[key]) < max_length:
-                        y_data_dict[key] = np.pad(y_data_dict[key], (0, max_length - len(y_data_dict[key])), "constant")
+                        y_data_dict[key] = np.pad(y_data_dict[key], (0, max_length - len(y_data_dict[key])))
                 if len(x_data) > self.max_points:
                     x_data = x_data[1:]
                     for key in count_dict.keys():

ultralytics/solutions/distance_calculation.py

@@ -45,6 +45,8 @@ class DistanceCalculation(BaseSolution):
         self.left_mouse_count = 0
         self.selected_boxes = {}
 
+        self.centroids = []  # Initialize empty list to store centroids
+
     def mouse_event_for_distance(self, event, x, y, flags, param):
         """
         Handles mouse events to select regions in a real-time video stream for distance calculation.

ultralytics/solutions/heatmap.py

@@ -41,6 +41,7 @@ class Heatmap(ObjectCounter):
 
         # store colormap
         self.colormap = cv2.COLORMAP_PARULA if self.CFG["colormap"] is None else self.CFG["colormap"]
+        self.heatmap = None
 
     def heatmap_effect(self, box):
         """

ultralytics/solutions/parking_management.py

@@ -5,7 +5,9 @@ import json
 import cv2
 import numpy as np
 
-from ultralytics.solutions.solutions import LOGGER, BaseSolution, check_requirements
+from ultralytics.solutions.solutions import BaseSolution
+from ultralytics.utils import LOGGER
+from ultralytics.utils.checks import check_requirements
 from ultralytics.utils.plotting import Annotator
 
 
@@ -32,7 +34,6 @@ class ParkingPtsSelection:
         canvas_max_height (int): Maximum height of the canvas.
 
     Methods:
-        setup_ui: Sets up the Tkinter UI components.
         initialize_properties: Initializes the necessary properties.
         upload_image: Uploads an image, resizes it to fit the canvas, and displays it.
         on_canvas_click: Handles mouse clicks to add points for bounding boxes.
@@ -53,20 +54,22 @@ class ParkingPtsSelection:
         from tkinter import filedialog, messagebox
 
         self.tk, self.filedialog, self.messagebox = tk, filedialog, messagebox
-        self.setup_ui()
-        self.initialize_properties()
-        self.master.mainloop()
-
-    def setup_ui(self):
-        """Sets up the Tkinter UI components for the parking zone points selection interface."""
-        self.master = self.tk.Tk()
+        self.master = self.tk.Tk()  # Reference to the main application window or parent widget
         self.master.title("Ultralytics Parking Zones Points Selector")
         self.master.resizable(False, False)
 
-        # Canvas for image display
-        self.canvas = self.tk.Canvas(self.master, bg="white")
+        self.canvas = self.tk.Canvas(self.master, bg="white")  # Canvas widget for displaying images or graphics
         self.canvas.pack(side=self.tk.BOTTOM)
 
+        self.image = None  # Variable to store the loaded image
+        self.canvas_image = None  # Reference to the image displayed on the canvas
+        self.canvas_max_width = None  # Maximum allowed width for the canvas
+        self.canvas_max_height = None  # Maximum allowed height for the canvas
+        self.rg_data = None  # Data related to region or annotation management
+        self.current_box = None  # Stores the currently selected or active bounding box
+        self.imgh = None  # Height of the current image
+        self.imgw = None  # Width of the current image
+
         # Button frame with buttons
         button_frame = self.tk.Frame(self.master)
         button_frame.pack(side=self.tk.TOP)
@@ -78,6 +81,9 @@ class ParkingPtsSelection:
         ]:
             self.tk.Button(button_frame, text=text, command=cmd).pack(side=self.tk.LEFT)
 
+        self.initialize_properties()
+        self.master.mainloop()
+
     def initialize_properties(self):
         """Initialize properties for image, canvas, bounding boxes, and dimensions."""
         self.image = self.canvas_image = None
@@ -103,7 +109,7 @@ class ParkingPtsSelection:
         )
 
         self.canvas.config(width=canvas_width, height=canvas_height)
-        self.canvas_image = ImageTk.PhotoImage(self.image.resize((canvas_width, canvas_height), Image.LANCZOS))
+        self.canvas_image = ImageTk.PhotoImage(self.image.resize((canvas_width, canvas_height)))
         self.canvas.create_image(0, 0, anchor=self.tk.NW, image=self.canvas_image)
         self.canvas.bind("<Button-1>", self.on_canvas_click)
 
@@ -142,8 +148,13 @@ class ParkingPtsSelection:
         """Saves the selected parking zone points to a JSON file with scaled coordinates."""
         scale_w, scale_h = self.imgw / self.canvas.winfo_width(), self.imgh / self.canvas.winfo_height()
         data = [{"points": [(int(x * scale_w), int(y * scale_h)) for x, y in box]} for box in self.rg_data]
-        with open("bounding_boxes.json", "w") as f:
-            json.dump(data, f, indent=4)
+
+        from io import StringIO  # Function level import, as it's only required to store coordinates, not every frame
+
+        write_buffer = StringIO()
+        json.dump(data, write_buffer, indent=4)
+        with open("bounding_boxes.json", "w", encoding="utf-8") as f:
+            f.write(write_buffer.getvalue())
         self.messagebox.showinfo("Success", "Bounding boxes saved to bounding_boxes.json")
 
 

ultralytics/solutions/region_counter.py

@@ -1,6 +1,7 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
 from ultralytics.solutions.solutions import BaseSolution
+from ultralytics.utils import LOGGER
 from ultralytics.utils.plotting import Annotator, colors
 
 
@@ -81,6 +82,9 @@ class RegionCounter(BaseSolution):
 
         # Draw regions and process counts for each defined area
         for idx, (region_name, reg_pts) in enumerate(regions.items(), start=1):
+            if not isinstance(reg_pts, list) or not all(isinstance(pt, tuple) for pt in reg_pts):
+                LOGGER.warning(f"Invalid region points for {region_name}: {reg_pts}")
+                continue  # Skip invalid entries
             color = colors(idx, True)
             self.annotator.draw_region(reg_pts=reg_pts, color=color, thickness=self.line_width * 2)
             self.add_region(region_name, reg_pts, color, self.annotator.get_txt_color())

ultralytics/solutions/security_alarm.py

@@ -1,6 +1,7 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
-from ultralytics.solutions.solutions import LOGGER, BaseSolution
+from ultralytics.solutions.solutions import BaseSolution
+from ultralytics.utils import LOGGER
 from ultralytics.utils.plotting import Annotator, colors
 
 
@@ -33,6 +34,9 @@ class SecurityAlarm(BaseSolution):
         super().__init__(**kwargs)
         self.email_sent = False
         self.records = self.CFG["records"]
+        self.server = None
+        self.to_email = ""
+        self.from_email = ""
 
     def authenticate(self, from_email, password, to_email):
         """
@@ -90,7 +94,7 @@ class SecurityAlarm(BaseSolution):
 
         # Add the text message body
         message_body = f"Ultralytics ALERT!!! " f"{records} objects have been detected!!"
-        message.attach(MIMEText(message_body, "plain"))
+        message.attach(MIMEText(message_body))
 
         # Attach the image
         image_attachment = MIMEImage(img_bytes, name="ultralytics.jpg")
@@ -131,10 +135,9 @@ class SecurityAlarm(BaseSolution):
             self.annotator.box_label(box, label=self.names[cls], color=colors(cls, True))
 
         total_det = len(self.clss)
-        if total_det > self.records:  # Only send email If not sent before
-            if not self.email_sent:
-                self.send_email(im0, total_det)
-                self.email_sent = True
+        if total_det > self.records and not self.email_sent:  # Only send email If not sent before
+            self.send_email(im0, total_det)
+            self.email_sent = True
 
         self.display_output(im0)  # display output with base class function
 

ultralytics/solutions/solutions.py

@@ -56,6 +56,14 @@ class BaseSolution:
         self.Polygon = Polygon
         self.Point = Point
         self.prep = prep
+        self.annotator = None  # Initialize annotator
+        self.tracks = None
+        self.track_data = None
+        self.boxes = []
+        self.clss = []
+        self.track_ids = []
+        self.track_line = None
+        self.r_s = None
 
         # Load config and update with args
         DEFAULT_SOL_DICT.update(kwargs)

ultralytics/solutions/streamlit_inference.py

@@ -1,148 +1,195 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
 import io
-import time
+from typing import Any
 
 import cv2
-import torch
 
+from ultralytics import YOLO
+from ultralytics.utils import LOGGER
 from ultralytics.utils.checks import check_requirements
 from ultralytics.utils.downloads import GITHUB_ASSETS_STEMS
 
 
-def inference(model=None):
-    """Performs real-time object detection on video input using YOLO in a Streamlit web application."""
-    check_requirements("streamlit>=1.29.0")  # scope imports for faster ultralytics package load speeds
-    import streamlit as st
-
-    from ultralytics import YOLO
-
-    # Hide main menu style
-    menu_style_cfg = """<style>MainMenu {visibility: hidden;}</style>"""
-
-    # Main title of streamlit application
-    main_title_cfg = """<div><h1 style="color:#FF64DA; text-align:center; font-size:40px; 
-                             font-family: 'Archivo', sans-serif; margin-top:-50px;margin-bottom:20px;">
-                    Ultralytics YOLO Streamlit Application
-                    </h1></div>"""
-
-    # Subtitle of streamlit application
-    sub_title_cfg = """<div><h4 style="color:#042AFF; text-align:center; 
-                    font-family: 'Archivo', sans-serif; margin-top:-15px; margin-bottom:50px;">
-                    Experience real-time object detection on your webcam with the power of Ultralytics YOLO! 🚀</h4>
-                    </div>"""
-
-    # Set html page configuration
-    st.set_page_config(page_title="Ultralytics Streamlit App", layout="wide", initial_sidebar_state="auto")
-
-    # Append the custom HTML
-    st.markdown(menu_style_cfg, unsafe_allow_html=True)
-    st.markdown(main_title_cfg, unsafe_allow_html=True)
-    st.markdown(sub_title_cfg, unsafe_allow_html=True)
-
-    # Add ultralytics logo in sidebar
-    with st.sidebar:
-        logo = "https://raw.githubusercontent.com/ultralytics/assets/main/logo/Ultralytics_Logotype_Original.svg"
-        st.image(logo, width=250)
+class Inference:
+    """
+    A class to perform object detection, image classification, image segmentation and pose estimation inference using
+    Streamlit and Ultralytics YOLO models. It provides the functionalities such as loading models, configuring settings,
+    uploading video files, and performing real-time inference.
+
+    Attributes:
+        st (module): Streamlit module for UI creation.
+        temp_dict (dict): Temporary dictionary to store the model path.
+        model_path (str): Path to the loaded model.
+        model (YOLO): The YOLO model instance.
+        source (str): Selected video source.
+        enable_trk (str): Enable tracking option.
+        conf (float): Confidence threshold.
+        iou (float): IoU threshold for non-max suppression.
+        vid_file_name (str): Name of the uploaded video file.
+        selected_ind (list): List of selected class indices.
+
+    Methods:
+        web_ui: Sets up the Streamlit web interface with custom HTML elements.
+        sidebar: Configures the Streamlit sidebar for model and inference settings.
+        source_upload: Handles video file uploads through the Streamlit interface.
+        configure: Configures the model and loads selected classes for inference.
+        inference: Performs real-time object detection inference.
+
+    Examples:
+        >>> inf = solutions.Inference(model="path/to/model.pt")  # Model is not necessary argument.
+        >>> inf.inference()
+    """
+
+    def __init__(self, **kwargs: Any):
+        """
+        Initializes the Inference class, checking Streamlit requirements and setting up the model path.
+
+        Args:
+            **kwargs (Any): Additional keyword arguments for model configuration.
+        """
+        check_requirements("streamlit>=1.29.0")  # scope imports for faster ultralytics package load speeds
+        import streamlit as st
+
+        self.st = st  # Reference to the Streamlit class instance
+        self.source = None  # Placeholder for video or webcam source details
+        self.enable_trk = False  # Flag to toggle object tracking
+        self.conf = 0.25  # Confidence threshold for detection
+        self.iou = 0.45  # Intersection-over-Union (IoU) threshold for non-maximum suppression
+        self.org_frame = None  # Container for the original frame to be displayed
+        self.ann_frame = None  # Container for the annotated frame to be displayed
+        self.vid_file_name = None  # Holds the name of the video file
+        self.selected_ind = []  # List of selected classes for detection or tracking
+        self.model = None  # Container for the loaded model instance
+
+        self.temp_dict = {"model": None}  # Temporary dict to store the model path
+        self.temp_dict.update(kwargs)
+        self.model_path = None  # Store model file name with path
+        if self.temp_dict["model"] is not None:
+            self.model_path = self.temp_dict["model"]
+
+        LOGGER.info(f"Ultralytics Solutions: ✅ {self.temp_dict}")
+
+    def web_ui(self):
+        """Sets up the Streamlit web interface with custom HTML elements."""
+        menu_style_cfg = """<style>MainMenu {visibility: hidden;}</style>"""  # Hide main menu style
+
+        # Main title of streamlit application
+        main_title_cfg = """<div><h1 style="color:#FF64DA; text-align:center; font-size:40px; margin-top:-50px;
+        font-family: 'Archivo', sans-serif; margin-bottom:20px;">Ultralytics YOLO Streamlit Application</h1></div>"""
+
+        # Subtitle of streamlit application
+        sub_title_cfg = """<div><h4 style="color:#042AFF; text-align:center; font-family: 'Archivo', sans-serif; 
+        margin-top:-15px; margin-bottom:50px;">Experience real-time object detection on your webcam with the power 
+        of Ultralytics YOLO! 🚀</h4></div>"""
+
+        # Set html page configuration and append custom HTML
+        self.st.set_page_config(page_title="Ultralytics Streamlit App", layout="wide")
+        self.st.markdown(menu_style_cfg, unsafe_allow_html=True)
+        self.st.markdown(main_title_cfg, unsafe_allow_html=True)
+        self.st.markdown(sub_title_cfg, unsafe_allow_html=True)
+
+    def sidebar(self):
+        """Configures the Streamlit sidebar for model and inference settings."""
+        with self.st.sidebar:  # Add Ultralytics LOGO
+            logo = "https://raw.githubusercontent.com/ultralytics/assets/main/logo/Ultralytics_Logotype_Original.svg"
+            self.st.image(logo, width=250)
+
+        self.st.sidebar.title("User Configuration")  # Add elements to vertical setting menu
+        self.source = self.st.sidebar.selectbox(
+            "Video",
+            ("webcam", "video"),
+        )  # Add source selection dropdown
+        self.enable_trk = self.st.sidebar.radio("Enable Tracking", ("Yes", "No"))  # Enable object tracking
+        self.conf = float(
+            self.st.sidebar.slider("Confidence Threshold", 0.0, 1.0, self.conf, 0.01)
+        )  # Slider for confidence
+        self.iou = float(self.st.sidebar.slider("IoU Threshold", 0.0, 1.0, self.iou, 0.01))  # Slider for NMS threshold
+
+        col1, col2 = self.st.columns(2)
+        self.org_frame = col1.empty()
+        self.ann_frame = col2.empty()
+
+    def source_upload(self):
+        """Handles video file uploads through the Streamlit interface."""
+        self.vid_file_name = ""
+        if self.source == "video":
+            vid_file = self.st.sidebar.file_uploader("Upload Video File", type=["mp4", "mov", "avi", "mkv"])
+            if vid_file is not None:
+                g = io.BytesIO(vid_file.read())  # BytesIO Object
+                with open("ultralytics.mp4", "wb") as out:  # Open temporary file as bytes
+                    out.write(g.read())  # Read bytes into file
+                self.vid_file_name = "ultralytics.mp4"
+        elif self.source == "webcam":
+            self.vid_file_name = 0
+
+    def configure(self):
+        """Configures the model and loads selected classes for inference."""
+        # Add dropdown menu for model selection
+        available_models = [x.replace("yolo", "YOLO") for x in GITHUB_ASSETS_STEMS if x.startswith("yolo11")]
+        if self.model_path:  # If user provided the custom model, insert model without suffix as *.pt is added later
+            available_models.insert(0, self.model_path.split(".pt")[0])
+        selected_model = self.st.sidebar.selectbox("Model", available_models)
+
+        with self.st.spinner("Model is downloading..."):
+            self.model = YOLO(f"{selected_model.lower()}.pt")  # Load the YOLO model
+            class_names = list(self.model.names.values())  # Convert dictionary to list of class names
+        self.st.success("Model loaded successfully!")
+
+        # Multiselect box with class names and get indices of selected classes
+        selected_classes = self.st.sidebar.multiselect("Classes", class_names, default=class_names[:3])
+        self.selected_ind = [class_names.index(option) for option in selected_classes]
+
+        if not isinstance(self.selected_ind, list):  # Ensure selected_options is a list
+            self.selected_ind = list(self.selected_ind)
+
+    def inference(self):
+        """Performs real-time object detection inference."""
+        self.web_ui()  # Initialize the web interface
+        self.sidebar()  # Create the sidebar
+        self.source_upload()  # Upload the video source
+        self.configure()  # Configure the app
+
+        if self.st.sidebar.button("Start"):
+            stop_button = self.st.button("Stop")  # Button to stop the inference
+            cap = cv2.VideoCapture(self.vid_file_name)  # Capture the video
+            if not cap.isOpened():
+                self.st.error("Could not open webcam.")
+            while cap.isOpened():
+                success, frame = cap.read()
+                if not success:
+                    self.st.warning("Failed to read frame from webcam. Please verify the webcam is connected properly.")
+                    break
+
+                # Store model predictions
+                if self.enable_trk == "Yes":
+                    results = self.model.track(
+                        frame, conf=self.conf, iou=self.iou, classes=self.selected_ind, persist=True
+                    )
+                else:
+                    results = self.model(frame, conf=self.conf, iou=self.iou, classes=self.selected_ind)
+                annotated_frame = results[0].plot()  # Add annotations on frame
+
+                if stop_button:
+                    cap.release()  # Release the capture
+                    self.st.stop()  # Stop streamlit app
+
+                self.org_frame.image(frame, channels="BGR")  # Display original frame
+                self.ann_frame.image(annotated_frame, channels="BGR")  # Display processed frame
+
+            cap.release()  # Release the capture
+        cv2.destroyAllWindows()  # Destroy window
 
-    # Add elements to vertical setting menu
-    st.sidebar.title("User Configuration")
 
-    # Add video source selection dropdown
-    source = st.sidebar.selectbox(
-        "Video",
-        ("webcam", "video"),
-    )
-
-    vid_file_name = ""
-    if source == "video":
-        vid_file = st.sidebar.file_uploader("Upload Video File", type=["mp4", "mov", "avi", "mkv"])
-        if vid_file is not None:
-            g = io.BytesIO(vid_file.read())  # BytesIO Object
-            vid_location = "ultralytics.mp4"
-            with open(vid_location, "wb") as out:  # Open temporary file as bytes
-                out.write(g.read())  # Read bytes into file
-            vid_file_name = "ultralytics.mp4"
-    elif source == "webcam":
-        vid_file_name = 0
-
-    # Add dropdown menu for model selection
-    available_models = [x.replace("yolo", "YOLO") for x in GITHUB_ASSETS_STEMS if x.startswith("yolo11")]
-    if model:
-        available_models.insert(0, model.split(".pt")[0])  # insert model without suffix as *.pt is added later
-
-    selected_model = st.sidebar.selectbox("Model", available_models)
-    with st.spinner("Model is downloading..."):
-        model = YOLO(f"{selected_model.lower()}.pt")  # Load the YOLO model
-        class_names = list(model.names.values())  # Convert dictionary to list of class names
-    st.success("Model loaded successfully!")
-
-    # Multiselect box with class names and get indices of selected classes
-    selected_classes = st.sidebar.multiselect("Classes", class_names, default=class_names[:3])
-    selected_ind = [class_names.index(option) for option in selected_classes]
-
-    if not isinstance(selected_ind, list):  # Ensure selected_options is a list
-        selected_ind = list(selected_ind)
-
-    enable_trk = st.sidebar.radio("Enable Tracking", ("Yes", "No"))
-    conf = float(st.sidebar.slider("Confidence Threshold", 0.0, 1.0, 0.25, 0.01))
-    iou = float(st.sidebar.slider("IoU Threshold", 0.0, 1.0, 0.45, 0.01))
-
-    col1, col2 = st.columns(2)
-    org_frame = col1.empty()
-    ann_frame = col2.empty()
-
-    fps_display = st.sidebar.empty()  # Placeholder for FPS display
-
-    if st.sidebar.button("Start"):
-        videocapture = cv2.VideoCapture(vid_file_name)  # Capture the video
-
-        if not videocapture.isOpened():
-            st.error("Could not open webcam.")
-
-        stop_button = st.button("Stop")  # Button to stop the inference
-
-        while videocapture.isOpened():
-            success, frame = videocapture.read()
-            if not success:
-                st.warning("Failed to read frame from webcam. Please make sure the webcam is connected properly.")
-                break
-
-            prev_time = time.time()  # Store initial time for FPS calculation
-
-            # Store model predictions
-            if enable_trk == "Yes":
-                results = model.track(frame, conf=conf, iou=iou, classes=selected_ind, persist=True)
-            else:
-                results = model(frame, conf=conf, iou=iou, classes=selected_ind)
-            annotated_frame = results[0].plot()  # Add annotations on frame
-
-            # Calculate model FPS
-            curr_time = time.time()
-            fps = 1 / (curr_time - prev_time)
-
-            # display frame
-            org_frame.image(frame, channels="BGR")
-            ann_frame.image(annotated_frame, channels="BGR")
-
-            if stop_button:
-                videocapture.release()  # Release the capture
-                torch.cuda.empty_cache()  # Clear CUDA memory
-                st.stop()  # Stop streamlit app
-
-            # Display FPS in sidebar
-            fps_display.metric("FPS", f"{fps:.2f}")
-
-        # Release the capture
-        videocapture.release()
-
-    # Clear CUDA memory
-    torch.cuda.empty_cache()
+if __name__ == "__main__":
+    import sys  # Import the sys module for accessing command-line arguments
 
-    # Destroy window
-    cv2.destroyAllWindows()
+    model = None  # Initialize the model variable as None
 
+    # Check if a model name is provided as a command-line argument
+    args = len(sys.argv)
+    if args > 1:
+        model = sys.argv[1]  # Assign the first argument as the model name
 
-# Main function call
-if __name__ == "__main__":
-    inference()
+    # Create an instance of the Inference class and run inference
+    Inference(model=model).inference()

ultralytics/utils/benchmarks.py

@@ -440,7 +440,8 @@ class ProfileModels:
         print(f"Profiling: {sorted(files)}")
         return [Path(file) for file in sorted(files)]
 
-    def get_onnx_model_info(self, onnx_file: str):
+    @staticmethod
+    def get_onnx_model_info(onnx_file: str):
         """Extracts metadata from an ONNX model file including parameters, GFLOPs, and input shape."""
         return 0.0, 0.0, 0.0, 0.0  # return (num_layers, num_params, num_gradients, num_flops)
 

ultralytics/utils/downloads.py

@@ -138,7 +138,7 @@ def unzip_file(file, path=None, exclude=(".DS_Store", "__MACOSX"), exist_ok=Fals
     If a path is not provided, the function will use the parent directory of the zipfile as the default path.
 
     Args:
-        file (str): The path to the zipfile to be extracted.
+        file (str | Path): The path to the zipfile to be extracted.
         path (str, optional): The path to extract the zipfile to. Defaults to None.
         exclude (tuple, optional): A tuple of filename strings to be excluded. Defaults to ('.DS_Store', '__MACOSX').
         exist_ok (bool, optional): Whether to overwrite existing contents if they exist. Defaults to False.

ultralytics/utils/instance.py

@@ -28,7 +28,7 @@ to_4tuple = _ntuple(4)
 # `ltwh` means left top and width, height(COCO format)
 _formats = ["xyxy", "xywh", "ltwh"]
 
-__all__ = ("Bboxes",)  # tuple or list
+__all__ = ("Bboxes", "Instances")  # tuple or list
 
 
 class Bboxes:

ultralytics/utils/metrics.py

@@ -372,10 +372,9 @@ class ConfusionMatrix:
             else:
                 self.matrix[self.nc, gc] += 1  # true background
 
-        if n:
-            for i, dc in enumerate(detection_classes):
-                if not any(m1 == i):
-                    self.matrix[dc, self.nc] += 1  # predicted background
+        for i, dc in enumerate(detection_classes):
+            if not any(m1 == i):
+                self.matrix[dc, self.nc] += 1  # predicted background
 
     def matrix(self):
         """Returns the confusion matrix."""

ultralytics/utils/plotting.py

@@ -545,7 +545,8 @@ class Annotator:
         """Save the annotated image to 'filename'."""
         cv2.imwrite(filename, np.asarray(self.im))
 
-    def get_bbox_dimension(self, bbox=None):
+    @staticmethod
+    def get_bbox_dimension(bbox=None):
         """
         Calculate the area of a bounding box.