ultralytics 8.2.92__tar.gz → 8.2.93__tar.gz

{ultralytics-8.2.92/ultralytics.egg-info → ultralytics-8.2.93}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics
-Version: 8.2.92
+Version: 8.2.93
 Summary: Ultralytics YOLOv8 for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification.
 Author: Glenn Jocher, Ayush Chaurasia, Jing Qiu
 Maintainer: Glenn Jocher, Ayush Chaurasia, Jing Qiu

{ultralytics-8.2.92 → ultralytics-8.2.93}/ultralytics/__init__.py

@@ -1,6 +1,6 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
-__version__ = "8.2.92"
+__version__ = "8.2.93"
 
 
 import os

{ultralytics-8.2.92 → ultralytics-8.2.93}/ultralytics/engine/exporter.py

@@ -391,7 +391,7 @@ class Exporter:
         """YOLOv8 ONNX export."""
         requirements = ["onnx>=1.12.0"]
         if self.args.simplify:
-            requirements += ["onnxslim==0.1.32", "onnxruntime" + ("-gpu" if torch.cuda.is_available() else "")]
+            requirements += ["onnxslim==0.1.34", "onnxruntime" + ("-gpu" if torch.cuda.is_available() else "")]
         check_requirements(requirements)
         import onnx  # noqa
 

{ultralytics-8.2.92 → ultralytics-8.2.93}/ultralytics/models/nas/val.py

@@ -44,7 +44,7 @@ class NASValidator(DetectionValidator):
             self.args.iou,
             labels=self.lb,
             multi_label=False,
-            agnostic=self.args.single_cls,
+            agnostic=self.args.single_cls or self.args.agnostic_nms,
             max_det=self.args.max_det,
             max_time_img=0.5,
         )

{ultralytics-8.2.92 → ultralytics-8.2.93}/ultralytics/models/yolo/obb/val.py

@@ -45,7 +45,7 @@ class OBBValidator(DetectionValidator):
             labels=self.lb,
             nc=self.nc,
             multi_label=True,
-            agnostic=self.args.single_cls,
+            agnostic=self.args.single_cls or self.args.agnostic_nms,
             max_det=self.args.max_det,
             rotated=True,
         )

{ultralytics-8.2.92 → ultralytics-8.2.93}/ultralytics/models/yolo/pose/val.py

@@ -69,7 +69,7 @@ class PoseValidator(DetectionValidator):
             self.args.iou,
             labels=self.lb,
             multi_label=True,
-            agnostic=self.args.single_cls,
+            agnostic=self.args.single_cls or self.args.agnostic_nms,
             max_det=self.args.max_det,
             nc=self.nc,
         )

{ultralytics-8.2.92 → ultralytics-8.2.93}/ultralytics/models/yolo/segment/val.py

@@ -76,7 +76,7 @@ class SegmentationValidator(DetectionValidator):
             self.args.iou,
             labels=self.lb,
             multi_label=True,
-            agnostic=self.args.single_cls,
+            agnostic=self.args.single_cls or self.args.agnostic_nms,
             max_det=self.args.max_det,
             nc=self.nc,
         )

{ultralytics-8.2.92 → ultralytics-8.2.93}/ultralytics/nn/tasks.py

@@ -1,6 +1,8 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
 import contextlib
+import pickle
+import types
 from copy import deepcopy
 from pathlib import Path
 
@@ -750,7 +752,35 @@ def temporary_modules(modules=None, attributes=None):
                 del sys.modules[old]
 
 
-def torch_safe_load(weight):
+class SafeClass:
+    """A placeholder class to replace unknown classes during unpickling."""
+
+    def __init__(self, *args, **kwargs):
+        """Initialize SafeClass instance, ignoring all arguments."""
+        pass
+
+
+class SafeUnpickler(pickle.Unpickler):
+    """Custom Unpickler that replaces unknown classes with SafeClass."""
+
+    def find_class(self, module, name):
+        """Attempt to find a class, returning SafeClass if not among safe modules."""
+        safe_modules = (
+            "torch",
+            "collections",
+            "collections.abc",
+            "builtins",
+            "math",
+            "numpy",
+            # Add other modules considered safe
+        )
+        if module in safe_modules:
+            return super().find_class(module, name)
+        else:
+            return SafeClass
+
+
+def torch_safe_load(weight, safe_only=False):
     """
     Attempts to load a PyTorch model with the torch.load() function. If a ModuleNotFoundError is raised, it catches the
     error, logs a warning message, and attempts to install the missing module via the check_requirements() function.
@@ -758,9 +788,18 @@ def torch_safe_load(weight):
 
     Args:
         weight (str): The file path of the PyTorch model.
+        safe_only (bool): If True, replace unknown classes with SafeClass during loading.
+
+    Example:
+    ```python
+    from ultralytics.nn.tasks import torch_safe_load
+
+    ckpt, file = torch_safe_load("path/to/best.pt", safe_only=True)
+    ```
 
     Returns:
-        (dict): The loaded PyTorch model.
+        ckpt (dict): The loaded model checkpoint.
+        file (str): The loaded filename
     """
     from ultralytics.utils.downloads import attempt_download_asset
 
@@ -779,7 +818,15 @@ def torch_safe_load(weight):
                 "ultralytics.utils.loss.v10DetectLoss": "ultralytics.utils.loss.E2EDetectLoss",  # YOLOv10
             },
         ):
-            ckpt = torch.load(file, map_location="cpu")
+            if safe_only:
+                # Load via custom pickle module
+                safe_pickle = types.ModuleType("safe_pickle")
+                safe_pickle.Unpickler = SafeUnpickler
+                safe_pickle.load = lambda file_obj: SafeUnpickler(file_obj).load()
+                with open(file, "rb") as f:
+                    ckpt = torch.load(f, pickle_module=safe_pickle)
+            else:
+                ckpt = torch.load(file, map_location="cpu")
 
     except ModuleNotFoundError as e:  # e.name is missing module name
         if e.name == "models":
@@ -809,7 +856,7 @@ def torch_safe_load(weight):
         )
         ckpt = {"model": ckpt.model}
 
-    return ckpt, file  # load
+    return ckpt, file
 
 
 def attempt_load_weights(weights, device=None, inplace=True, fuse=False):

{ultralytics-8.2.92 → ultralytics-8.2.93}/ultralytics/solutions/queue_management.py

@@ -20,15 +20,8 @@ class QueueManager:
         names,
         reg_pts=None,
         line_thickness=2,
-        track_thickness=2,
         view_img=False,
-        region_color=(255, 0, 255),
-        view_queue_counts=True,
         draw_tracks=False,
-        count_txt_color=(255, 255, 255),
-        track_color=None,
-        region_thickness=5,
-        fontsize=0.7,
     ):
         """
         Initializes the QueueManager with specified parameters for tracking and counting objects.
@@ -38,57 +31,35 @@ class QueueManager:
             reg_pts (list of tuples, optional): Points defining the counting region polygon. Defaults to a predefined
                 rectangle.
             line_thickness (int, optional): Thickness of the annotation lines. Defaults to 2.
-            track_thickness (int, optional): Thickness of the track lines. Defaults to 2.
             view_img (bool, optional): Whether to display the image frames. Defaults to False.
-            region_color (tuple, optional): Color of the counting region lines (BGR). Defaults to (255, 0, 255).
-            view_queue_counts (bool, optional): Whether to display the queue counts. Defaults to True.
             draw_tracks (bool, optional): Whether to draw tracks of the objects. Defaults to False.
-            count_txt_color (tuple, optional): Color of the count text (BGR). Defaults to (255, 255, 255).
-            track_color (tuple, optional): Color of the tracks. If None, different colors will be used for different
-                tracks. Defaults to None.
-            region_thickness (int, optional): Thickness of the counting region lines. Defaults to 5.
-            fontsize (float, optional): Font size for the text annotations. Defaults to 0.7.
         """
-        # Mouse events state
-        self.is_drawing = False
-        self.selected_point = None
-
         # Region & Line Information
         self.reg_pts = reg_pts if reg_pts is not None else [(20, 60), (20, 680), (1120, 680), (1120, 60)]
         self.counting_region = (
             Polygon(self.reg_pts) if len(self.reg_pts) >= 3 else Polygon([(20, 60), (20, 680), (1120, 680), (1120, 60)])
         )
-        self.region_color = region_color
-        self.region_thickness = region_thickness
 
-        # Image and annotation Information
-        self.im0 = None
+        # annotation Information
         self.tf = line_thickness
         self.view_img = view_img
-        self.view_queue_counts = view_queue_counts
-        self.fontsize = fontsize
 
         self.names = names  # Class names
-        self.annotator = None  # Annotator
-        self.window_name = "Ultralytics YOLOv8 Queue Manager"
 
         # Object counting Information
         self.counts = 0
-        self.count_txt_color = count_txt_color
 
         # Tracks info
         self.track_history = defaultdict(list)
-        self.track_thickness = track_thickness
         self.draw_tracks = draw_tracks
-        self.track_color = track_color
 
         # Check if environment supports imshow
         self.env_check = check_imshow(warn=True)
 
-    def extract_and_process_tracks(self, tracks):
+    def extract_and_process_tracks(self, tracks, im0):
         """Extracts and processes tracks for queue management in a video stream."""
         # Initialize annotator and draw the queue region
-        self.annotator = Annotator(self.im0, self.tf, self.names)
+        annotator = Annotator(im0, self.tf, self.names)
         self.counts = 0  # Reset counts every frame
         if tracks[0].boxes.id is not None:
             boxes = tracks[0].boxes.xyxy.cpu()
@@ -98,7 +69,7 @@ class QueueManager:
             # Extract tracks
             for box, track_id, cls in zip(boxes, track_ids, clss):
                 # Draw bounding box
-                self.annotator.box_label(box, label=f"{self.names[cls]}#{track_id}", color=colors(int(track_id), True))
+                annotator.box_label(box, label=self.names[cls], color=colors(int(track_id), True))
 
                 # Update track history
                 track_line = self.track_history[track_id]
@@ -108,10 +79,10 @@ class QueueManager:
 
                 # Draw track trails if enabled
                 if self.draw_tracks:
-                    self.annotator.draw_centroid_and_tracks(
+                    annotator.draw_centroid_and_tracks(
                         track_line,
-                        color=self.track_color or colors(int(track_id), True),
-                        track_thickness=self.track_thickness,
+                        color=colors(int(track_id), True),
+                        track_thickness=self.line_thickness,
                     )
 
                 prev_position = self.track_history[track_id][-2] if len(self.track_history[track_id]) > 1 else None
@@ -125,21 +96,16 @@ class QueueManager:
         # Display queue counts
         label = f"Queue Counts : {str(self.counts)}"
         if label is not None:
-            self.annotator.queue_counts_display(
+            annotator.queue_counts_display(
                 label,
                 points=self.reg_pts,
-                region_color=self.region_color,
-                txt_color=self.count_txt_color,
+                region_color=(255, 0, 255),
+                txt_color=(104, 31, 17),
             )
 
-        self.display_frames()
-
-    def display_frames(self):
-        """Displays the current frame with annotations."""
         if self.env_check and self.view_img:
-            self.annotator.draw_region(reg_pts=self.reg_pts, thickness=self.region_thickness, color=self.region_color)
-            cv2.namedWindow(self.window_name)
-            cv2.imshow(self.window_name, self.im0)
+            annotator.draw_region(reg_pts=self.reg_pts, thickness=self.tf * 2, color=(255, 0, 255))
+            cv2.imshow("Ultralytics YOLOv8 Queue Manager", im0)
             # Close window on 'q' key press
             if cv2.waitKey(1) & 0xFF == ord("q"):
                 return
@@ -152,12 +118,8 @@ class QueueManager:
             im0 (ndarray): Current frame from the video stream.
             tracks (list): List of tracks obtained from the object tracking process.
         """
-        self.im0 = im0  # Store the current frame
-        self.extract_and_process_tracks(tracks)  # Extract and process tracks
-
-        if self.view_img:
-            self.display_frames()  # Display the frame if enabled
-        return self.im0
+        self.extract_and_process_tracks(tracks, im0)  # Extract and process tracks
+        return im0
 
 
 if __name__ == "__main__":

ultralytics-8.2.93/ultralytics/solutions/speed_estimation.py

@@ -0,0 +1,116 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+from collections import defaultdict
+from time import time
+
+import cv2
+import numpy as np
+
+from ultralytics.utils.checks import check_imshow
+from ultralytics.utils.plotting import Annotator, colors
+
+
+class SpeedEstimator:
+    """A class to estimate the speed of objects in a real-time video stream based on their tracks."""
+
+    def __init__(self, names, reg_pts=None, view_img=False, line_thickness=2, spdl_dist_thresh=10):
+        """
+        Initializes the SpeedEstimator with the given parameters.
+
+        Args:
+            names (dict): Dictionary of class names.
+            reg_pts (list, optional): List of region points for speed estimation. Defaults to [(20, 400), (1260, 400)].
+            view_img (bool, optional): Whether to display the image with annotations. Defaults to False.
+            line_thickness (int, optional): Thickness of the lines for drawing boxes and tracks. Defaults to 2.
+            spdl_dist_thresh (int, optional): Distance threshold for speed calculation. Defaults to 10.
+        """
+        # Region information
+        self.reg_pts = reg_pts if reg_pts is not None else [(20, 400), (1260, 400)]
+
+        self.names = names  # Classes names
+
+        # Tracking information
+        self.trk_history = defaultdict(list)
+
+        self.view_img = view_img  # bool for displaying inference
+        self.tf = line_thickness  # line thickness for annotator
+        self.spd = {}  # set for speed data
+        self.trkd_ids = []  # list for already speed_estimated and tracked ID's
+        self.spdl = spdl_dist_thresh  # Speed line distance threshold
+        self.trk_pt = {}  # set for tracks previous time
+        self.trk_pp = {}  # set for tracks previous point
+
+        # Check if the environment supports imshow
+        self.env_check = check_imshow(warn=True)
+
+    def estimate_speed(self, im0, tracks):
+        """
+        Estimates the speed of objects based on tracking data.
+
+        Args:
+            im0 (ndarray): Image.
+            tracks (list): List of tracks obtained from the object tracking process.
+
+        Returns:
+            (ndarray): The image with annotated boxes and tracks.
+        """
+        if tracks[0].boxes.id is None:
+            return im0
+
+        boxes = tracks[0].boxes.xyxy.cpu()
+        clss = tracks[0].boxes.cls.cpu().tolist()
+        t_ids = tracks[0].boxes.id.int().cpu().tolist()
+        annotator = Annotator(im0, line_width=self.tf)
+        annotator.draw_region(reg_pts=self.reg_pts, color=(255, 0, 255), thickness=self.tf * 2)
+
+        for box, t_id, cls in zip(boxes, t_ids, clss):
+            track = self.trk_history[t_id]
+            bbox_center = (float((box[0] + box[2]) / 2), float((box[1] + box[3]) / 2))
+            track.append(bbox_center)
+
+            if len(track) > 30:
+                track.pop(0)
+
+            trk_pts = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
+
+            if t_id not in self.trk_pt:
+                self.trk_pt[t_id] = 0
+
+            speed_label = f"{int(self.spd[t_id])} km/h" if t_id in self.spd else self.names[int(cls)]
+            bbox_color = colors(int(t_id), True)
+
+            annotator.box_label(box, speed_label, bbox_color)
+            cv2.polylines(im0, [trk_pts], isClosed=False, color=bbox_color, thickness=self.tf)
+            cv2.circle(im0, (int(track[-1][0]), int(track[-1][1])), self.tf * 2, bbox_color, -1)
+
+            # Calculation of object speed
+            if not self.reg_pts[0][0] < track[-1][0] < self.reg_pts[1][0]:
+                return
+            if self.reg_pts[1][1] - self.spdl < track[-1][1] < self.reg_pts[1][1] + self.spdl:
+                direction = "known"
+            elif self.reg_pts[0][1] - self.spdl < track[-1][1] < self.reg_pts[0][1] + self.spdl:
+                direction = "known"
+            else:
+                direction = "unknown"
+
+            if self.trk_pt.get(t_id) != 0 and direction != "unknown" and t_id not in self.trkd_ids:
+                self.trkd_ids.append(t_id)
+
+                time_difference = time() - self.trk_pt[t_id]
+                if time_difference > 0:
+                    self.spd[t_id] = np.abs(track[-1][1] - self.trk_pp[t_id][1]) / time_difference
+
+            self.trk_pt[t_id] = time()
+            self.trk_pp[t_id] = track[-1]
+
+        if self.view_img and self.env_check:
+            cv2.imshow("Ultralytics Speed Estimation", im0)
+            if cv2.waitKey(1) & 0xFF == ord("q"):
+                return
+
+        return im0
+
+
+if __name__ == "__main__":
+    names = {0: "person", 1: "car"}  # example class names
+    speed_estimator = SpeedEstimator(names)

{ultralytics-8.2.92 → ultralytics-8.2.93/ultralytics.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics
-Version: 8.2.92
+Version: 8.2.93
 Summary: Ultralytics YOLOv8 for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification.
 Author: Glenn Jocher, Ayush Chaurasia, Jing Qiu
 Maintainer: Glenn Jocher, Ayush Chaurasia, Jing Qiu

ultralytics-8.2.92/ultralytics/solutions/speed_estimation.py

@@ -1,180 +0,0 @@
-# Ultralytics YOLO 🚀, AGPL-3.0 license
-
-from collections import defaultdict
-from time import time
-
-import cv2
-import numpy as np
-
-from ultralytics.utils.checks import check_imshow
-from ultralytics.utils.plotting import Annotator, colors
-
-
-class SpeedEstimator:
-    """A class to estimate the speed of objects in a real-time video stream based on their tracks."""
-
-    def __init__(self, names, reg_pts=None, view_img=False, line_thickness=2, region_thickness=5, spdl_dist_thresh=10):
-        """
-        Initializes the SpeedEstimator with the given parameters.
-
-        Args:
-            names (dict): Dictionary of class names.
-            reg_pts (list, optional): List of region points for speed estimation. Defaults to [(20, 400), (1260, 400)].
-            view_img (bool, optional): Whether to display the image with annotations. Defaults to False.
-            line_thickness (int, optional): Thickness of the lines for drawing boxes and tracks. Defaults to 2.
-            region_thickness (int, optional): Thickness of the region lines. Defaults to 5.
-            spdl_dist_thresh (int, optional): Distance threshold for speed calculation. Defaults to 10.
-        """
-        # Visual & image information
-        self.im0 = None
-        self.annotator = None
-        self.view_img = view_img
-
-        # Region information
-        self.reg_pts = reg_pts if reg_pts is not None else [(20, 400), (1260, 400)]
-        self.region_thickness = region_thickness
-
-        # Tracking information
-        self.clss = None
-        self.names = names
-        self.boxes = None
-        self.trk_ids = None
-        self.trk_pts = None
-        self.line_thickness = line_thickness
-        self.trk_history = defaultdict(list)
-
-        # Speed estimation information
-        self.current_time = 0
-        self.dist_data = {}
-        self.trk_idslist = []
-        self.spdl_dist_thresh = spdl_dist_thresh
-        self.trk_previous_times = {}
-        self.trk_previous_points = {}
-
-        # Check if the environment supports imshow
-        self.env_check = check_imshow(warn=True)
-
-    def extract_tracks(self, tracks):
-        """
-        Extracts results from the provided tracking data.
-
-        Args:
-            tracks (list): List of tracks obtained from the object tracking process.
-        """
-        self.boxes = tracks[0].boxes.xyxy.cpu()
-        self.clss = tracks[0].boxes.cls.cpu().tolist()
-        self.trk_ids = tracks[0].boxes.id.int().cpu().tolist()
-
-    def store_track_info(self, track_id, box):
-        """
-        Stores track data.
-
-        Args:
-            track_id (int): Object track id.
-            box (list): Object bounding box data.
-
-        Returns:
-            (list): Updated tracking history for the given track_id.
-        """
-        track = self.trk_history[track_id]
-        bbox_center = (float((box[0] + box[2]) / 2), float((box[1] + box[3]) / 2))
-        track.append(bbox_center)
-
-        if len(track) > 30:
-            track.pop(0)
-
-        self.trk_pts = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
-        return track
-
-    def plot_box_and_track(self, track_id, box, cls, track):
-        """
-        Plots track and bounding box.
-
-        Args:
-            track_id (int): Object track id.
-            box (list): Object bounding box data.
-            cls (str): Object class name.
-            track (list): Tracking history for drawing tracks path.
-        """
-        speed_label = f"{int(self.dist_data[track_id])} km/h" if track_id in self.dist_data else self.names[int(cls)]
-        bbox_color = colors(int(track_id)) if track_id in self.dist_data else (255, 0, 255)
-
-        self.annotator.box_label(box, speed_label, bbox_color)
-        cv2.polylines(self.im0, [self.trk_pts], isClosed=False, color=(0, 255, 0), thickness=1)
-        cv2.circle(self.im0, (int(track[-1][0]), int(track[-1][1])), 5, bbox_color, -1)
-
-    def calculate_speed(self, trk_id, track):
-        """
-        Calculates the speed of an object.
-
-        Args:
-            trk_id (int): Object track id.
-            track (list): Tracking history for drawing tracks path.
-        """
-        if not self.reg_pts[0][0] < track[-1][0] < self.reg_pts[1][0]:
-            return
-        if self.reg_pts[1][1] - self.spdl_dist_thresh < track[-1][1] < self.reg_pts[1][1] + self.spdl_dist_thresh:
-            direction = "known"
-        elif self.reg_pts[0][1] - self.spdl_dist_thresh < track[-1][1] < self.reg_pts[0][1] + self.spdl_dist_thresh:
-            direction = "known"
-        else:
-            direction = "unknown"
-
-        if self.trk_previous_times.get(trk_id) != 0 and direction != "unknown" and trk_id not in self.trk_idslist:
-            self.trk_idslist.append(trk_id)
-
-            time_difference = time() - self.trk_previous_times[trk_id]
-            if time_difference > 0:
-                dist_difference = np.abs(track[-1][1] - self.trk_previous_points[trk_id][1])
-                speed = dist_difference / time_difference
-                self.dist_data[trk_id] = speed
-
-        self.trk_previous_times[trk_id] = time()
-        self.trk_previous_points[trk_id] = track[-1]
-
-    def estimate_speed(self, im0, tracks, region_color=(255, 0, 0)):
-        """
-        Estimates the speed of objects based on tracking data.
-
-        Args:
-            im0 (ndarray): Image.
-            tracks (list): List of tracks obtained from the object tracking process.
-            region_color (tuple, optional): Color to use when drawing regions. Defaults to (255, 0, 0).
-
-        Returns:
-            (ndarray): The image with annotated boxes and tracks.
-        """
-        self.im0 = im0
-        if tracks[0].boxes.id is None:
-            if self.view_img and self.env_check:
-                self.display_frames()
-            return im0
-
-        self.extract_tracks(tracks)
-        self.annotator = Annotator(self.im0, line_width=self.line_thickness)
-        self.annotator.draw_region(reg_pts=self.reg_pts, color=region_color, thickness=self.region_thickness)
-
-        for box, trk_id, cls in zip(self.boxes, self.trk_ids, self.clss):
-            track = self.store_track_info(trk_id, box)
-
-            if trk_id not in self.trk_previous_times:
-                self.trk_previous_times[trk_id] = 0
-
-            self.plot_box_and_track(trk_id, box, cls, track)
-            self.calculate_speed(trk_id, track)
-
-        if self.view_img and self.env_check:
-            self.display_frames()
-
-        return im0
-
-    def display_frames(self):
-        """Displays the current frame."""
-        cv2.imshow("Ultralytics Speed Estimation", self.im0)
-        if cv2.waitKey(1) & 0xFF == ord("q"):
-            return
-
-
-if __name__ == "__main__":
-    names = {0: "person", 1: "car"}  # example class names
-    speed_estimator = SpeedEstimator(names)