dgenerate-ultralytics-headless 8.3.137__py3-none-any.whl → 8.3.224__py3-none-any.whl

ultralytics/solutions/speed_estimation.py

@@ -2,61 +2,64 @@
 
 from collections import deque
 from math import sqrt
+from typing import Any
 
 from ultralytics.solutions.solutions import BaseSolution, SolutionAnnotator, SolutionResults
 from ultralytics.utils.plotting import colors
 
 
 class SpeedEstimator(BaseSolution):
-    """
-    A class to estimate the speed of objects in a real-time video stream based on their tracks.
+    """A class to estimate the speed of objects in a real-time video stream based on their tracks.
 
-    This class extends the BaseSolution class and provides functionality for estimating object speeds using
-    tracking data in video streams.
+    This class extends the BaseSolution class and provides functionality for estimating object speeds using tracking
+    data in video streams. Speed is calculated based on pixel displacement over time and converted to real-world units
+    using a configurable meters-per-pixel scale factor.
 
     Attributes:
-        spd (Dict[int, float]): Dictionary storing speed data for tracked objects.
-        trk_hist (Dict[int, float]): Dictionary storing the object tracking data.
-        max_hist (int): maximum track history before computing speed
-        meters_per_pixel (float): Real-world meters represented by one pixel (e.g., 0.04 for 4m over 100px).
-        max_speed (int): Maximum allowed object speed; values above this will be capped at 120 km/h.
+        fps (float): Video frame rate for time calculations.
+        frame_count (int): Global frame counter for tracking temporal information.
+        trk_frame_ids (dict): Maps track IDs to their first frame index.
+        spd (dict): Final speed per object in km/h once locked.
+        trk_hist (dict): Maps track IDs to deque of position history.
+        locked_ids (set): Track IDs whose speed has been finalized.
+        max_hist (int): Required frame history before computing speed.
+        meter_per_pixel (float): Real-world meters represented by one pixel for scene scale conversion.
+        max_speed (int): Maximum allowed object speed; values above this will be capped.
 
     Methods:
-        initialize_region: Initializes the speed estimation region.
-        process: Processes input frames to estimate object speeds.
-        store_tracking_history: Stores the tracking history for an object.
-        extract_tracks: Extracts tracks from the current frame.
-        display_output: Displays the output with annotations.
+        process: Process input frames to estimate object speeds based on tracking data.
+        store_tracking_history: Store the tracking history for an object.
+        extract_tracks: Extract tracks from the current frame.
+        display_output: Display the output with annotations.
 
     Examples:
-        >>> estimator = SpeedEstimator()
+        Initialize speed estimator and process a frame
+        >>> estimator = SpeedEstimator(meter_per_pixel=0.04, max_speed=120)
         >>> frame = cv2.imread("frame.jpg")
         >>> results = estimator.process(frame)
         >>> cv2.imshow("Speed Estimation", results.plot_im)
     """
 
-    def __init__(self, **kwargs):
-        """
-        Initialize the SpeedEstimator object with speed estimation parameters and data structures.
+    def __init__(self, **kwargs: Any) -> None:
+        """Initialize the SpeedEstimator object with speed estimation parameters and data structures.
 
         Args:
             **kwargs (Any): Additional keyword arguments passed to the parent class.
         """
         super().__init__(**kwargs)
 
-        self.fps = self.CFG["fps"]  # assumed video FPS
-        self.frame_count = 0  # global frame count
+        self.fps = self.CFG["fps"]  # Video frame rate for time calculations
+        self.frame_count = 0  # Global frame counter
         self.trk_frame_ids = {}  # Track ID → first frame index
         self.spd = {}  # Final speed per object (km/h), once locked
         self.trk_hist = {}  # Track ID → deque of (time, position)
         self.locked_ids = set()  # Track IDs whose speed has been finalized
         self.max_hist = self.CFG["max_hist"]  # Required frame history before computing speed
         self.meter_per_pixel = self.CFG["meter_per_pixel"]  # Scene scale, depends on camera details
-        self.max_speed = self.CFG["max_speed"]  # max_speed adjustment
+        self.max_speed = self.CFG["max_speed"]  # Maximum speed adjustment
 
-    def process(self, im0):
-        """
-        Process an input frame to estimate object speeds based on tracking data.
+    def process(self, im0) -> SolutionResults:
+        """Process an input frame to estimate object speeds based on tracking data.
 
         Args:
             im0 (np.ndarray): Input image for processing with shape (H, W, C) for RGB images.
@@ -65,6 +68,7 @@ class SpeedEstimator(BaseSolution):
             (SolutionResults): Contains processed image `plot_im` and `total_tracks` (number of tracked objects).
 
         Examples:
+            Process a frame for speed estimation
             >>> estimator = SpeedEstimator()
             >>> image = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8)
             >>> results = estimator.process(image)
@@ -89,15 +93,15 @@ class SpeedEstimator(BaseSolution):
                     p0, p1 = trk_hist[0], trk_hist[-1]  # First and last points of track
                     dt = (self.frame_count - self.trk_frame_ids[track_id]) / self.fps  # Time in seconds
                     if dt > 0:
-                        dx, dy = p1[0] - p0[0], p1[1] - p0[1]  # pixel displacement
-                        pixel_distance = sqrt(dx * dx + dy * dy)  # get pixel distance
-                        meters = pixel_distance * self.meter_per_pixel  # convert to meters
+                        dx, dy = p1[0] - p0[0], p1[1] - p0[1]  # Pixel displacement
+                        pixel_distance = sqrt(dx * dx + dy * dy)  # Calculate pixel distance
+                        meters = pixel_distance * self.meter_per_pixel  # Convert to meters
                         self.spd[track_id] = int(
                             min((meters / dt) * 3.6, self.max_speed)
-                        )  # convert to km/h and store final speed
-                        self.locked_ids.add(track_id)  # prevent further updates
-                        self.trk_hist.pop(track_id, None)  # free memory
-                        self.trk_frame_ids.pop(track_id, None)  # optional: remove frame start too
+                        )  # Convert to km/h and store final speed
+                        self.locked_ids.add(track_id)  # Prevent further updates
+                        self.trk_hist.pop(track_id, None)  # Free memory
+                        self.trk_frame_ids.pop(track_id, None)  # Remove frame start reference
 
             if track_id in self.spd:
                 speed_label = f"{self.spd[track_id]} km/h"

ultralytics/solutions/streamlit_inference.py

@@ -1,19 +1,22 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
 import io
+import os
 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
 
+torch.classes.__path__ = []  # Torch module __path__._path issue: https://github.com/datalab-to/marker/issues/442
+
 
 class Inference:
-    """
-    A class to perform object detection, image classification, image segmentation and pose estimation inference.
+    """A class to perform object detection, image classification, image segmentation and pose estimation inference.
 
     This class provides functionalities for loading models, configuring settings, uploading video files, and performing
     real-time inference using Streamlit and Ultralytics YOLO models.
@@ -24,29 +27,33 @@ class Inference:
         model_path (str): Path to the loaded model.
         model (YOLO): The YOLO model instance.
         source (str): Selected video source (webcam or video file).
-        enable_trk (str): Enable tracking option ("Yes" or "No").
+        enable_trk (bool): Enable tracking option.
         conf (float): Confidence threshold for detection.
         iou (float): IoU threshold for non-maximum suppression.
         org_frame (Any): Container for the original frame to be displayed.
         ann_frame (Any): Container for the annotated frame to be displayed.
         vid_file_name (str | int): Name of the uploaded video file or webcam index.
-        selected_ind (List[int]): List of selected class indices for detection.
+        selected_ind (list[int]): List of selected class indices for detection.
 
     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.
+        web_ui: Set up the Streamlit web interface with custom HTML elements.
+        sidebar: Configure the Streamlit sidebar for model and inference settings.
+        source_upload: Handle video file uploads through the Streamlit interface.
+        configure: Configure the model and load selected classes for inference.
+        inference: Perform real-time object detection inference.
 
     Examples:
-        >>> inf = Inference(model="path/to/model.pt")  # Model is an optional argument
+        Create an Inference instance with a custom model
+        >>> inf = Inference(model="path/to/model.pt")
+        >>> inf.inference()
+
+        Create an Inference instance with default settings
+        >>> inf = Inference()
         >>> inf.inference()
     """
 
-    def __init__(self, **kwargs: Any):
-        """
-        Initialize the Inference class, checking Streamlit requirements and setting up the model path.
+    def __init__(self, **kwargs: Any) -> None:
+        """Initialize the Inference class, checking Streamlit requirements and setting up the model path.
 
         Args:
             **kwargs (Any): Additional keyword arguments for model configuration.
@@ -56,13 +63,14 @@ class Inference:
 
         self.st = st  # Reference to the Streamlit module
         self.source = None  # Video source selection (webcam or video file)
+        self.img_file_names = []  # List of image file names
         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 display
         self.ann_frame = None  # Container for the annotated frame display
         self.vid_file_name = None  # Video file name or webcam index
-        self.selected_ind = []  # List of selected class indices for detection
+        self.selected_ind: list[int] = []  # List of selected class indices for detection
         self.model = None  # YOLO model instance
 
         self.temp_dict = {"model": None, **kwargs}
@@ -72,18 +80,18 @@ class Inference:
 
         LOGGER.info(f"Ultralytics Solutions: ✅ {self.temp_dict}")
 
-    def web_ui(self):
-        """Sets up the Streamlit web interface with custom HTML elements."""
+    def web_ui(self) -> None:
+        """Set 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;
+        main_title_cfg = """<div><h1 style="color:#111F68; 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>"""
+        sub_title_cfg = """<div><h5 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, videos, and images
+        with the power of Ultralytics YOLO! 🚀</h5></div>"""
 
         # Set html page configuration and append custom HTML
         self.st.set_page_config(page_title="Ultralytics Streamlit App", layout="wide")
@@ -91,7 +99,7 @@ class Inference:
         self.st.markdown(main_title_cfg, unsafe_allow_html=True)
         self.st.markdown(sub_title_cfg, unsafe_allow_html=True)
 
-    def sidebar(self):
+    def sidebar(self) -> None:
         """Configure 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"
@@ -99,24 +107,28 @@ class Inference:
 
         self.st.sidebar.title("User Configuration")  # Add elements to vertical setting menu
         self.source = self.st.sidebar.selectbox(
-            "Video",
-            ("webcam", "video"),
+            "Source",
+            ("webcam", "video", "image"),
         )  # Add source selection dropdown
-        self.enable_trk = self.st.sidebar.radio("Enable Tracking", ("Yes", "No"))  # Enable object tracking
+        if self.source in ["webcam", "video"]:
+            self.enable_trk = self.st.sidebar.radio("Enable Tracking", ("Yes", "No")) == "Yes"  # 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)  # Create two columns for displaying frames
-        self.org_frame = col1.empty()  # Container for original frame
-        self.ann_frame = col2.empty()  # Container for annotated frame
+        if self.source != "image":  # Only create columns for video/webcam
+            col1, col2 = self.st.columns(2)  # Create two columns for displaying frames
+            self.org_frame = col1.empty()  # Container for original frame
+            self.ann_frame = col2.empty()  # Container for annotated frame
 
-    def source_upload(self):
+    def source_upload(self) -> None:
         """Handle video file uploads through the Streamlit interface."""
+        from ultralytics.data.utils import IMG_FORMATS, VID_FORMATS  # scope import
+
         self.vid_file_name = ""
         if self.source == "video":
-            vid_file = self.st.sidebar.file_uploader("Upload Video File", type=["mp4", "mov", "avi", "mkv"])
+            vid_file = self.st.sidebar.file_uploader("Upload Video File", type=VID_FORMATS)
             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
@@ -124,17 +136,41 @@ class Inference:
                 self.vid_file_name = "ultralytics.mp4"
         elif self.source == "webcam":
             self.vid_file_name = 0  # Use webcam index 0
-
-    def configure(self):
+        elif self.source == "image":
+            import tempfile  # scope import
+
+            if imgfiles := self.st.sidebar.file_uploader(
+                "Upload Image Files", type=IMG_FORMATS, accept_multiple_files=True
+            ):
+                for imgfile in imgfiles:  # Save each uploaded image to a temporary file
+                    with tempfile.NamedTemporaryFile(delete=False, suffix=f".{imgfile.name.split('.')[-1]}") as tf:
+                        tf.write(imgfile.read())
+                        self.img_file_names.append({"path": tf.name, "name": imgfile.name})
+
+    def configure(self) -> None:
         """Configure the model and load 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])
+        M_ORD, T_ORD = ["yolo11n", "yolo11s", "yolo11m", "yolo11l", "yolo11x"], ["", "-seg", "-pose", "-obb", "-cls"]
+        available_models = sorted(
+            [
+                x.replace("yolo", "YOLO")
+                for x in GITHUB_ASSETS_STEMS
+                if any(x.startswith(b) for b in M_ORD) and "grayscale" not in x
+            ],
+            key=lambda x: (M_ORD.index(x[:7].lower()), T_ORD.index(x[7:].lower() or "")),
+        )
+        if self.model_path:  # Insert user provided custom model in available_models
+            available_models.insert(0, self.model_path)
         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
+            if selected_model.endswith((".pt", ".onnx", ".torchscript", ".mlpackage", ".engine")) or any(
+                fmt in selected_model for fmt in ("openvino_model", "rknn_model")
+            ):
+                model_path = selected_model
+            else:
+                model_path = f"{selected_model.lower()}.pt"  # Default to .pt if no model provided during function call.
+            self.model = YOLO(model_path)  # Load the YOLO model
             class_names = list(self.model.names.values())  # Convert dictionary to list of class names
         self.st.success("Model loaded successfully!")
 
@@ -145,7 +181,28 @@ class Inference:
         if not isinstance(self.selected_ind, list):  # Ensure selected_options is a list
             self.selected_ind = list(self.selected_ind)
 
-    def inference(self):
+    def image_inference(self) -> None:
+        """Perform inference on uploaded images."""
+        for img_info in self.img_file_names:
+            img_path = img_info["path"]
+            image = cv2.imread(img_path)  # Load and display the original image
+            if image is not None:
+                self.st.markdown(f"#### Processed: {img_info['name']}")
+                col1, col2 = self.st.columns(2)
+                with col1:
+                    self.st.image(image, channels="BGR", caption="Original Image")
+                results = self.model(image, conf=self.conf, iou=self.iou, classes=self.selected_ind)
+                annotated_image = results[0].plot()
+                with col2:
+                    self.st.image(annotated_image, channels="BGR", caption="Predicted Image")
+                try:  # Clean up temporary file
+                    os.unlink(img_path)
+                except FileNotFoundError:
+                    pass  # File doesn't exist, ignore
+            else:
+                self.st.error("Could not load the uploaded image.")
+
+    def inference(self) -> None:
         """Perform real-time object detection inference on video or webcam feed."""
         self.web_ui()  # Initialize the web interface
         self.sidebar()  # Create the sidebar
@@ -153,7 +210,14 @@ class Inference:
         self.configure()  # Configure the app
 
         if self.st.sidebar.button("Start"):
-            stop_button = self.st.button("Stop")  # Button to stop the inference
+            if self.source == "image":
+                if self.img_file_names:
+                    self.image_inference()
+                else:
+                    self.st.info("Please upload an image file to perform inference.")
+                return
+
+            stop_button = self.st.sidebar.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 or video source.")
@@ -166,7 +230,7 @@ class Inference:
                     break
 
                 # Process frame with model
-                if self.enable_trk == "Yes":
+                if self.enable_trk:
                     results = self.model.track(
                         frame, conf=self.conf, iou=self.iou, classes=self.selected_ind, persist=True
                     )
@@ -179,8 +243,8 @@ class Inference:
                     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
+                self.org_frame.image(frame, channels="BGR", caption="Original Frame")  # Display original frame
+                self.ann_frame.image(annotated_frame, channels="BGR", caption="Predicted Frame")  # Display processed
 
             cap.release()  # Release the capture
         cv2.destroyAllWindows()  # Destroy all OpenCV windows

ultralytics/solutions/templates/similarity-search.html

@@ -35,7 +35,6 @@
         align-items: center;
         gap: 1rem;
         margin-bottom: 3rem;
-        animation: fadeIn 1s ease-in-out;
       }
 
       input[type="text"] {
@@ -78,7 +77,6 @@
         gap: 1.5rem;
         max-width: 1600px;
         margin: auto;
-        animation: fadeInUp 1s ease-in-out;
       }
 
       .card {
@@ -102,30 +100,22 @@
         object-fit: cover;
         display: block;
       }
-
-      @keyframes fadeIn {
-        0% {
-          opacity: 0;
-          transform: scale(0.95);
-        }
-        100% {
-          opacity: 1;
-          transform: scale(1);
-        }
-      }
-
-      @keyframes fadeInUp {
-        0% {
-          opacity: 0;
-          transform: translateY(20px);
-        }
-        100% {
-          opacity: 1;
-          transform: translateY(0);
-        }
-      }
     </style>
   </head>
+  <script>
+    function filterResults(k) {
+      const cards = document.querySelectorAll(".grid .card");
+      cards.forEach((card, idx) => {
+        card.style.display = idx < k ? "block" : "none";
+      });
+      const buttons = document.querySelectorAll(".topk-btn");
+      buttons.forEach((btn) => btn.classList.remove("active"));
+      event.target.classList.add("active");
+    }
+    document.addEventListener("DOMContentLoaded", () => {
+      filterResults(10);
+    });
+  </script>
   <body>
     <div style="text-align: center; margin-bottom: 1rem">
       <img
@@ -146,6 +136,23 @@
         required
       />
       <button type="submit">Search</button>
+      {% if results %}
+      <div class="top-k-buttons">
+        <button type="button" class="topk-btn" onclick="filterResults(5)">
+          Top 5
+        </button>
+        <button
+          type="button"
+          class="topk-btn active"
+          onclick="filterResults(10)"
+        >
+          Top 10
+        </button>
+        <button type="button" class="topk-btn" onclick="filterResults(30)">
+          Top 30
+        </button>
+      </div>
+      {% endif %}
     </form>
 
     <!-- Search results grid -->

ultralytics/solutions/trackzone.py

@@ -1,5 +1,7 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
+from typing import Any
+
 import cv2
 import numpy as np
 
@@ -8,8 +10,7 @@ from ultralytics.utils.plotting import colors
 
 
 class TrackZone(BaseSolution):
-    """
-    A class to manage region-based object tracking in a video stream.
+    """A class to manage region-based object tracking in a video stream.
 
     This class extends the BaseSolution class and provides functionality for tracking objects within a specific region
     defined by a polygonal area. Objects outside the region are excluded from tracking.
@@ -17,15 +18,15 @@ class TrackZone(BaseSolution):
     Attributes:
         region (np.ndarray): The polygonal region for tracking, represented as a convex hull of points.
         line_width (int): Width of the lines used for drawing bounding boxes and region boundaries.
-        names (List[str]): List of class names that the model can detect.
-        boxes (List[np.ndarray]): Bounding boxes of tracked objects.
-        track_ids (List[int]): Unique identifiers for each tracked object.
-        clss (List[int]): Class indices of tracked objects.
+        names (list[str]): List of class names that the model can detect.
+        boxes (list[np.ndarray]): Bounding boxes of tracked objects.
+        track_ids (list[int]): Unique identifiers for each tracked object.
+        clss (list[int]): Class indices of tracked objects.
 
     Methods:
-        process: Processes each frame of the video, applying region-based tracking.
-        extract_tracks: Extracts tracking information from the input frame.
-        display_output: Displays the processed output.
+        process: Process each frame of the video, applying region-based tracking.
+        extract_tracks: Extract tracking information from the input frame.
+        display_output: Display the processed output.
 
     Examples:
         >>> tracker = TrackZone()
@@ -34,9 +35,8 @@ class TrackZone(BaseSolution):
         >>> cv2.imshow("Tracked Frame", results.plot_im)
     """
 
-    def __init__(self, **kwargs):
-        """
-        Initialize the TrackZone class for tracking objects within a defined region in video streams.
+    def __init__(self, **kwargs: Any) -> None:
+        """Initialize the TrackZone class for tracking objects within a defined region in video streams.
 
         Args:
             **kwargs (Any): Additional keyword arguments passed to the parent class.
@@ -44,20 +44,20 @@ class TrackZone(BaseSolution):
         super().__init__(**kwargs)
         default_region = [(75, 75), (565, 75), (565, 285), (75, 285)]
         self.region = cv2.convexHull(np.array(self.region or default_region, dtype=np.int32))
+        self.mask = None
 
-    def process(self, im0):
-        """
-        Process the input frame to track objects within a defined region.
+    def process(self, im0: np.ndarray) -> SolutionResults:
+        """Process the input frame to track objects within a defined region.
 
-        This method initializes the annotator, creates a mask for the specified region, extracts tracks
-        only from the masked area, and updates tracking information. Objects outside the region are ignored.
+        This method initializes the annotator, creates a mask for the specified region, extracts tracks only from the
+        masked area, and updates tracking information. Objects outside the region are ignored.
 
         Args:
             im0 (np.ndarray): The input image or frame to be processed.
 
         Returns:
-            (SolutionResults): Contains processed image `plot_im` and `total_tracks` (int) representing the
-                               total number of tracked objects within the defined region.
+            (SolutionResults): Contains processed image `plot_im` and `total_tracks` (int) representing the total number
+                of tracked objects within the defined region.
 
         Examples:
             >>> tracker = TrackZone()
@@ -66,10 +66,10 @@ class TrackZone(BaseSolution):
         """
         annotator = SolutionAnnotator(im0, line_width=self.line_width)  # Initialize annotator
 
-        # Create a mask for the region and extract tracks from the masked image
-        mask = np.zeros_like(im0[:, :, 0])
-        mask = cv2.fillPoly(mask, [self.region], 255)
-        masked_frame = cv2.bitwise_and(im0, im0, mask=mask)
+        if self.mask is None:  # Create a mask for the region
+            self.mask = np.zeros_like(im0[:, :, 0])
+            cv2.fillPoly(self.mask, [self.region], 255)
+        masked_frame = cv2.bitwise_and(im0, im0, mask=self.mask)
         self.extract_tracks(masked_frame)
 
         # Draw the region boundary
@@ -82,7 +82,7 @@ class TrackZone(BaseSolution):
             )
 
         plot_im = annotator.result()
-        self.display_output(plot_im)  # display output with base class function
+        self.display_output(plot_im)  # Display output with base class function
 
         # Return a SolutionResults
         return SolutionResults(plot_im=plot_im, total_tracks=len(self.track_ids))

ultralytics/solutions/vision_eye.py

@@ -1,18 +1,19 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
+from typing import Any
+
 from ultralytics.solutions.solutions import BaseSolution, SolutionAnnotator, SolutionResults
 from ultralytics.utils.plotting import colors
 
 
 class VisionEye(BaseSolution):
-    """
-    A class to manage object detection and vision mapping in images or video streams.
+    """A class to manage object detection and vision mapping in images or video streams.
 
-    This class extends the BaseSolution class and provides functionality for detecting objects,
-    mapping vision points, and annotating results with bounding boxes and labels.
+    This class extends the BaseSolution class and provides functionality for detecting objects, mapping vision points,
+    and annotating results with bounding boxes and labels.
 
     Attributes:
-        vision_point (Tuple[int, int]): Coordinates (x, y) where vision will view objects and draw tracks.
+        vision_point (tuple[int, int]): Coordinates (x, y) where vision will view objects and draw tracks.
 
     Methods:
         process: Process the input image to detect objects, annotate them, and apply vision mapping.
@@ -24,9 +25,8 @@ class VisionEye(BaseSolution):
         >>> print(f"Total detected instances: {results.total_tracks}")
     """
 
-    def __init__(self, **kwargs):
-        """
-        Initialize the VisionEye class for detecting objects and applying vision mapping.
+    def __init__(self, **kwargs: Any) -> None:
+        """Initialize the VisionEye class for detecting objects and applying vision mapping.
 
         Args:
             **kwargs (Any): Keyword arguments passed to the parent class and for configuring vision_point.
@@ -35,12 +35,11 @@ class VisionEye(BaseSolution):
         # Set the vision point where the system will view objects and draw tracks
         self.vision_point = self.CFG["vision_point"]
 
-    def process(self, im0):
-        """
-        Perform object detection, vision mapping, and annotation on the input image.
+    def process(self, im0) -> SolutionResults:
+        """Perform object detection, vision mapping, and annotation on the input image.
 
         Args:
-            im0 (numpy.ndarray): The input image for detection and annotation.
+            im0 (np.ndarray): The input image for detection and annotation.
 
         Returns:
             (SolutionResults): Object containing the annotated image and tracking statistics.

ultralytics/trackers/__init__.py

@@ -4,4 +4,4 @@ from .bot_sort import BOTSORT
 from .byte_tracker import BYTETracker
 from .track import register_tracker
 
-__all__ = "register_tracker", "BOTSORT", "BYTETracker"  # allow simpler import
+__all__ = "BOTSORT", "BYTETracker", "register_tracker"  # allow simpler import