ultralytics 8.3.121__tar.gz → 8.3.123__tar.gz

{ultralytics-8.3.121/ultralytics.egg-info → ultralytics-8.3.123}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ultralytics
-Version: 8.3.121
+Version: 8.3.123
 Summary: Ultralytics YOLO 🚀 for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification.
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>
@@ -68,8 +68,8 @@ Requires-Dist: tensorflowjs>=2.0.0; extra == "export"
 Requires-Dist: tensorstore>=0.1.63; (platform_machine == "aarch64" and python_version >= "3.9") and extra == "export"
 Requires-Dist: h5py!=3.11.0; platform_machine == "aarch64" and extra == "export"
 Provides-Extra: solutions
-Requires-Dist: shapely<2.1.0,>=2.0.0; extra == "solutions"
-Requires-Dist: streamlit<1.44.0,>=1.29.0; extra == "solutions"
+Requires-Dist: shapely>=2.0.0; extra == "solutions"
+Requires-Dist: streamlit>=1.29.0; extra == "solutions"
 Provides-Extra: logging
 Requires-Dist: wandb; extra == "logging"
 Requires-Dist: tensorboard; extra == "logging"

{ultralytics-8.3.121 → ultralytics-8.3.123}/pyproject.toml

@@ -103,8 +103,8 @@ export = [
     "h5py!=3.11.0; platform_machine == 'aarch64'", # fix h5py build issues due to missing aarch64 wheels in 3.11 release
 ]
 solutions = [
-    "shapely>=2.0.0,<2.1.0",    # shapely for point and polygon data matching
-    "streamlit>=1.29.0,<1.44.0",    # for live inference on web browser, i.e `yolo streamlit-predict`
+    "shapely>=2.0.0",    # shapely for point and polygon data matching
+    "streamlit>=1.29.0",    # for live inference on web browser, i.e `yolo streamlit-predict`
 ]
 logging = [
     "wandb", # https://docs.ultralytics.com/integrations/weights-biases/

{ultralytics-8.3.121 → ultralytics-8.3.123}/tests/test_cuda.py

@@ -115,7 +115,7 @@ def test_utils_benchmarks():
 
     # Pre-export a dynamic engine model to use dynamic inference
     YOLO(MODEL).export(format="engine", imgsz=32, dynamic=True, batch=1)
-    ProfileModels([MODEL], imgsz=32, half=False, min_time=1, num_timed_runs=3, num_warmup_runs=1).profile()
+    ProfileModels([MODEL], imgsz=32, half=False, min_time=1, num_timed_runs=3, num_warmup_runs=1).run()
 
 
 @pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")

{ultralytics-8.3.121 → ultralytics-8.3.123}/tests/test_python.py

@@ -399,18 +399,18 @@ def test_utils_benchmarks():
     """Benchmark model performance using 'ProfileModels' from 'ultralytics.utils.benchmarks'."""
     from ultralytics.utils.benchmarks import ProfileModels
 
-    ProfileModels(["yolo11n.yaml"], imgsz=32, min_time=1, num_timed_runs=3, num_warmup_runs=1).profile()
+    ProfileModels(["yolo11n.yaml"], imgsz=32, min_time=1, num_timed_runs=3, num_warmup_runs=1).run()
 
 
 def test_utils_torchutils():
     """Test Torch utility functions including profiling and FLOP calculations."""
     from ultralytics.nn.modules.conv import Conv
-    from ultralytics.utils.torch_utils import get_flops_with_torch_profiler, profile, time_sync
+    from ultralytics.utils.torch_utils import get_flops_with_torch_profiler, profile_ops, time_sync
 
     x = torch.randn(1, 64, 20, 20)
     m = Conv(64, 64, k=1, s=2)
 
-    profile(x, [m], n=3)
+    profile_ops(x, [m], n=3)
     get_flops_with_torch_profiler(m)
     time_sync()
 

{ultralytics-8.3.121 → ultralytics-8.3.123}/ultralytics/__init__.py

@@ -1,6 +1,6 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
-__version__ = "8.3.121"
+__version__ = "8.3.123"
 
 import os
 

{ultralytics-8.3.121 → ultralytics-8.3.123}/ultralytics/cfg/__init__.py

@@ -701,7 +701,7 @@ def handle_yolo_solutions(args: List[str]) -> None:
         solution_name = "count"  # Default for invalid solution
 
     if solution_name == "inference":
-        checks.check_requirements("streamlit>=1.29.0,<1.44.0")
+        checks.check_requirements("streamlit>=1.29.0")
         LOGGER.info("💡 Loading Ultralytics live inference app...")
         subprocess.run(
             [  # Run subprocess with Streamlit custom argument

{ultralytics-8.3.121 → ultralytics-8.3.123}/ultralytics/cfg/trackers/botsort.yaml

@@ -17,6 +17,6 @@ fuse_score: True # Whether to fuse confidence scores with the iou distances befo
 gmc_method: sparseOptFlow # method of global motion compensation
 # ReID model related thresh
 proximity_thresh: 0.5 # minimum IoU for valid match with ReID
-appearance_thresh: 0.25 # minimum appearance similarity for ReID
+appearance_thresh: 0.8 # minimum appearance similarity for ReID
 with_reid: False
 model: auto # uses native features if detector is YOLO else yolo11n-cls.pt

{ultralytics-8.3.121 → ultralytics-8.3.123}/ultralytics/data/split_dota.py

@@ -30,7 +30,7 @@ def bbox_iof(polygon1, bbox2, eps=1e-6):
         Polygon format: [x1, y1, x2, y2, x3, y3, x4, y4].
         Bounding box format: [x_min, y_min, x_max, y_max].
     """
-    check_requirements("shapely")
+    check_requirements("shapely>=2.0.0")
     from shapely.geometry import Polygon
 
     polygon1 = polygon1.reshape(-1, 4, 2)

{ultralytics-8.3.121 → ultralytics-8.3.123}/ultralytics/engine/exporter.py

@@ -140,7 +140,7 @@ def export_formats():
         ["MNN", "mnn", ".mnn", True, True, ["batch", "half", "int8"]],
         ["NCNN", "ncnn", "_ncnn_model", True, True, ["batch", "half"]],
         ["IMX", "imx", "_imx_model", True, True, ["int8", "fraction"]],
-        ["RKNN", "rknn", "_rknn_model", False, False, ["batch", "name"]],
+        ["RKNN", "rknn", "_rknn_model", False, False, ["batch", "name", "int8"]],
     ]
     return dict(zip(["Format", "Argument", "Suffix", "CPU", "GPU", "Arguments"], zip(*x)))
 
@@ -851,6 +851,9 @@ class Exporter:
         ct_model.license = m.pop("license")
         ct_model.version = m.pop("version")
         ct_model.user_defined_metadata.update({k: str(v) for k, v in m.items()})
+        if self.model.task == "classify":
+            ct_model.user_defined_metadata.update({"com.apple.coreml.model.preview.type": "imageClassifier"})
+
         try:
             ct_model.save(str(f))  # save *.mlpackage
         except Exception as e:
@@ -967,8 +970,9 @@ class Exporter:
             output_integer_quantized_tflite=self.args.int8,
             quant_type="per-tensor",  # "per-tensor" (faster) or "per-channel" (slower but more accurate)
             custom_input_op_name_np_data_path=np_data,
-            disable_group_convolution=True,  # for end-to-end model compatibility
-            enable_batchmatmul_unfold=True,  # for end-to-end model compatibility
+            enable_batchmatmul_unfold=True,  # fix lower no. of detected objects on GPU delegate
+            output_signaturedefs=True,  # fix error with Attention block group convolution
+            optimization_for_gpu_delegate=True,
         )
         yaml_save(f / "metadata.yaml", self.metadata)  # add metadata.yaml
 
@@ -1107,8 +1111,8 @@ class Exporter:
         rknn = RKNN(verbose=False)
         rknn.config(mean_values=[[0, 0, 0]], std_values=[[255, 255, 255]], target_platform=self.args.name)
         rknn.load_onnx(model=f)
-        rknn.build(do_quantization=False)  # TODO: Add quantization support
-        f = f.replace(".onnx", f"-{self.args.name}.rknn")
+        rknn.build(do_quantization=self.args.int8)
+        f = f.replace(".onnx", f"-{self.args.name}-int8.rknn" if self.args.int8 else f"-{self.args.name}-fp16.rknn")
         rknn.export_rknn(f"{export_path / f}")
         yaml_save(export_path / "metadata.yaml", self.metadata)
         return export_path, None

{ultralytics-8.3.121 → ultralytics-8.3.123}/ultralytics/engine/results.py

@@ -662,17 +662,14 @@ class Results(SimpleClass):
             - For classification tasks, it returns the top 5 class probabilities and their corresponding class names.
             - The returned string is comma-separated and ends with a comma and a space.
         """
-        log_string = ""
         probs = self.probs
         if len(self) == 0:
-            return log_string if probs is not None else f"{log_string}(no detections), "
+            return "" if probs is not None else "(no detections), "
         if probs is not None:
-            log_string += f"{', '.join(f'{self.names[j]} {probs.data[j]:.2f}' for j in probs.top5)}, "
+            return f"{', '.join(f'{self.names[j]} {probs.data[j]:.2f}' for j in probs.top5)}, "
         if boxes := self.boxes:
-            for c in boxes.cls.unique():
-                n = (boxes.cls == c).sum()  # detections per class
-                log_string += f"{n} {self.names[int(c)]}{'s' * (n > 1)}, "
-        return log_string
+            counts = boxes.cls.int().bincount()
+            return "".join(f"{n} {self.names[i]}{'s' * (n > 1)}, " for i, n in enumerate(counts) if n > 0)
 
     def save_txt(self, txt_file, save_conf=False):
         """

{ultralytics-8.3.121 → ultralytics-8.3.123}/ultralytics/models/yolo/detect/predict.py

@@ -90,7 +90,7 @@ class DetectionPredictor(BasePredictor):
         obj_feats = torch.cat(
             [x.permute(0, 2, 3, 1).reshape(x.shape[0], -1, s, x.shape[1] // s).mean(dim=-1) for x in feat_maps], dim=1
         )  # mean reduce all vectors to same length
-        return [feats[idx] for feats, idx in zip(obj_feats, idxs)]  # for each image in batch, indexed separately
+        return [feats[idx] if len(idx) else [] for feats, idx in zip(obj_feats, idxs)]  # for each img in batch
 
     def construct_results(self, preds, img, orig_imgs):
         """

{ultralytics-8.3.121 → ultralytics-8.3.123}/ultralytics/nn/autobackend.py

@@ -725,7 +725,7 @@ class AutoBackend(nn.Module):
         else:
             im = im.cpu().numpy()
             if self.saved_model:  # SavedModel
-                y = self.model(im, training=False) if self.keras else self.model(im)
+                y = self.model(im, training=False) if self.keras else self.model.serving_default(im)
                 if not isinstance(y, list):
                     y = [y]
             elif self.pb:  # GraphDef

{ultralytics-8.3.121 → ultralytics-8.3.123}/ultralytics/solutions/solutions.py

@@ -53,7 +53,7 @@ class BaseSolution:
             is_cli (bool): Enables CLI mode if set to True.
             **kwargs (Any): Additional configuration parameters that override defaults.
         """
-        check_requirements("shapely>=2.0.0,<2.1.0")
+        check_requirements("shapely>=2.0.0")
         from shapely.geometry import LineString, Point, Polygon
         from shapely.prepared import prep
 

ultralytics-8.3.123/ultralytics/solutions/speed_estimation.py

@@ -0,0 +1,110 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+from collections import deque
+from math import sqrt
+
+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.
+
+    This class extends the BaseSolution class and provides functionality for estimating object speeds using
+    tracking data in video streams.
+
+    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.
+
+    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.
+
+    Examples:
+        >>> estimator = SpeedEstimator()
+        >>> 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.
+
+        Args:
+            **kwargs (Any): Additional keyword arguments passed to the parent class.
+        """
+        super().__init__(**kwargs)
+
+        self.fps = kwargs.get("fps", 30)  # assumed video FPS
+        self.frame_count = 0  # global frame count
+        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 = kwargs.get("max_hist", 5)  # Required frame history before computing speed
+        self.meter_per_pixel = kwargs.get("meter_per_pixel", 0.05)  # Scene scale, depends on camera details
+        self.max_speed = kwargs.get("max_speed", 120)  # max_speed adjustment
+
+    def process(self, im0):
+        """
+        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.
+
+        Returns:
+            (SolutionResults): Contains processed image `plot_im` and `total_tracks` (number of tracked objects).
+
+        Examples:
+            >>> estimator = SpeedEstimator()
+            >>> image = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8)
+            >>> results = estimator.process(image)
+        """
+        self.frame_count += 1
+        self.extract_tracks(im0)
+        annotator = SolutionAnnotator(im0, line_width=self.line_width)
+
+        for box, track_id, _, _ in zip(self.boxes, self.track_ids, self.clss, self.confs):
+            self.store_tracking_history(track_id, box)
+
+            if track_id not in self.trk_hist:  # Initialize history if new track found
+                self.trk_hist[track_id] = deque(maxlen=self.max_hist)
+                self.trk_frame_ids[track_id] = self.frame_count
+
+            if track_id not in self.locked_ids:  # Update history until speed is locked
+                trk_hist = self.trk_hist[track_id]
+                trk_hist.append(self.track_line[-1])
+
+                # Compute and lock speed once enough history is collected
+                if len(trk_hist) == self.max_hist:
+                    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
+                        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
+
+            if track_id in self.spd:
+                speed_label = f"{self.spd[track_id]} km/h"
+                annotator.box_label(box, label=speed_label, color=colors(track_id, True))  # Draw bounding box
+
+        plot_im = annotator.result()
+        self.display_output(plot_im)  # Display output with base class function
+
+        # Return results with processed image and tracking summary
+        return SolutionResults(plot_im=plot_im, total_tracks=len(self.track_ids))

{ultralytics-8.3.121 → ultralytics-8.3.123}/ultralytics/trackers/bot_sort.py

@@ -255,4 +255,6 @@ class ReID:
     def __call__(self, img, dets):
         """Extract embeddings for detected objects."""
         feats = self.model([save_one_box(det, img, save=False) for det in xywh2xyxy(torch.from_numpy(dets[:, :4]))])
+        if feats.shape[0] != dets.shape[0] and feats[0].shape[0] == dets.shape[0]:
+            feats = feats[0]  # batched prediction with non-PyTorch backend
         return [f.cpu().numpy() for f in feats]

{ultralytics-8.3.121 → ultralytics-8.3.123}/ultralytics/trackers/track.py

@@ -58,10 +58,10 @@ def on_predict_start(predictor: object, persist: bool = False) -> None:
             predictor._feats = None
 
             # Register hook to extract input of Detect layer
-            def capture_io(module, input, output):
-                predictor._feats = input[0]
+            def pre_hook(module, input):
+                predictor._feats = [t.clone() for t in input[0]]
 
-            predictor.model.model.model[-1].register_forward_hook(capture_io)
+            predictor.model.model.model[-1].register_forward_pre_hook(pre_hook)
 
     trackers = []
     for _ in range(predictor.dataset.bs):

{ultralytics-8.3.121 → ultralytics-8.3.123}/ultralytics/utils/autobatch.py

@@ -8,7 +8,7 @@ import numpy as np
 import torch
 
 from ultralytics.utils import DEFAULT_CFG, LOGGER, colorstr
-from ultralytics.utils.torch_utils import autocast, profile
+from ultralytics.utils.torch_utils import autocast, profile_ops
 
 
 def check_train_batch_size(model, imgsz=640, amp=True, batch=-1, max_num_obj=1):
@@ -74,7 +74,7 @@ def autobatch(model, imgsz=640, fraction=0.60, batch_size=DEFAULT_CFG.batch, max
     batch_sizes = [1, 2, 4, 8, 16] if t < 16 else [1, 2, 4, 8, 16, 32, 64]
     try:
         img = [torch.empty(b, 3, imgsz, imgsz) for b in batch_sizes]
-        results = profile(img, model, n=1, device=device, max_num_obj=max_num_obj)
+        results = profile_ops(img, model, n=1, device=device, max_num_obj=max_num_obj)
 
         # Fit a solution
         xy = [

{ultralytics-8.3.121 → ultralytics-8.3.123}/ultralytics/utils/benchmarks.py

@@ -4,7 +4,7 @@ Benchmark a YOLO model formats for speed and accuracy.
 
 Usage:
     from ultralytics.utils.benchmarks import ProfileModels, benchmark
-    ProfileModels(['yolo11n.yaml', 'yolov8s.yaml']).profile()
+    ProfileModels(['yolo11n.yaml', 'yolov8s.yaml']).run()
     benchmark(model='yolo11n.pt', imgsz=160)
 
 Format                  | `format=argument`         | Model
@@ -378,7 +378,7 @@ class ProfileModels:
         Profile models and print results
         >>> from ultralytics.utils.benchmarks import ProfileModels
         >>> profiler = ProfileModels(["yolo11n.yaml", "yolov8s.yaml"], imgsz=640)
-        >>> profiler.profile()
+        >>> profiler.run()
     """
 
     def __init__(
@@ -412,7 +412,7 @@ class ProfileModels:
             Initialize and profile models
             >>> from ultralytics.utils.benchmarks import ProfileModels
             >>> profiler = ProfileModels(["yolo11n.yaml", "yolov8s.yaml"], imgsz=640)
-            >>> profiler.profile()
+            >>> profiler.run()
         """
         self.paths = paths
         self.num_timed_runs = num_timed_runs
@@ -423,7 +423,7 @@ class ProfileModels:
         self.trt = trt  # run TensorRT profiling
         self.device = device or torch.device(0 if torch.cuda.is_available() else "cpu")
 
-    def profile(self):
+    def run(self):
         """
         Profile YOLO models for speed and accuracy across various formats including ONNX and TensorRT.
 
@@ -434,7 +434,7 @@ class ProfileModels:
             Profile models and print results
             >>> from ultralytics.utils.benchmarks import ProfileModels
             >>> profiler = ProfileModels(["yolo11n.yaml", "yolov8s.yaml"])
-            >>> results = profiler.profile()
+            >>> results = profiler.run()
         """
         files = self.get_files()
 

{ultralytics-8.3.121 → ultralytics-8.3.123}/ultralytics/utils/torch_utils.py

@@ -378,7 +378,7 @@ def model_info_for_loggers(trainer):
     if trainer.args.profile:  # profile ONNX and TensorRT times
         from ultralytics.utils.benchmarks import ProfileModels
 
-        results = ProfileModels([trainer.last], device=trainer.device).profile()[0]
+        results = ProfileModels([trainer.last], device=trainer.device).run()[0]
         results.pop("model/name")
     else:  # only return PyTorch times from most recent validation
         results = {
@@ -790,7 +790,7 @@ def cuda_memory_usage(device=None):
         yield cuda_info
 
 
-def profile(input, ops, n=10, device=None, max_num_obj=0):
+def profile_ops(input, ops, n=10, device=None, max_num_obj=0):
     """
     Ultralytics speed, memory and FLOPs profiler.
 
@@ -805,11 +805,11 @@ def profile(input, ops, n=10, device=None, max_num_obj=0):
         (list): Profile results for each operation.
 
     Examples:
-        >>> from ultralytics.utils.torch_utils import profile
+        >>> from ultralytics.utils.torch_utils import profile_ops
         >>> input = torch.randn(16, 3, 640, 640)
         >>> m1 = lambda x: x * torch.sigmoid(x)
         >>> m2 = nn.SiLU()
-        >>> profile(input, [m1, m2], n=100)  # profile over 100 iterations
+        >>> profile_ops(input, [m1, m2], n=100)  # profile over 100 iterations
     """
     results = []
     if not isinstance(device, torch.device):

{ultralytics-8.3.121 → ultralytics-8.3.123/ultralytics.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ultralytics
-Version: 8.3.121
+Version: 8.3.123
 Summary: Ultralytics YOLO 🚀 for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification.
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>
@@ -68,8 +68,8 @@ Requires-Dist: tensorflowjs>=2.0.0; extra == "export"
 Requires-Dist: tensorstore>=0.1.63; (platform_machine == "aarch64" and python_version >= "3.9") and extra == "export"
 Requires-Dist: h5py!=3.11.0; platform_machine == "aarch64" and extra == "export"
 Provides-Extra: solutions
-Requires-Dist: shapely<2.1.0,>=2.0.0; extra == "solutions"
-Requires-Dist: streamlit<1.44.0,>=1.29.0; extra == "solutions"
+Requires-Dist: shapely>=2.0.0; extra == "solutions"
+Requires-Dist: streamlit>=1.29.0; extra == "solutions"
 Provides-Extra: logging
 Requires-Dist: wandb; extra == "logging"
 Requires-Dist: tensorboard; extra == "logging"

{ultralytics-8.3.121 → ultralytics-8.3.123}/ultralytics.egg-info/requires.txt

@@ -56,5 +56,5 @@ tensorboard
 mlflow
 
 [solutions]
-shapely<2.1.0,>=2.0.0
-streamlit<1.44.0,>=1.29.0
+shapely>=2.0.0
+streamlit>=1.29.0

ultralytics-8.3.121/ultralytics/solutions/speed_estimation.py

@@ -1,114 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-from time import time
-
-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.
-
-    This class extends the BaseSolution class and provides functionality for estimating object speeds using
-    tracking data in video streams.
-
-    Attributes:
-        spd (Dict[int, float]): Dictionary storing speed data for tracked objects.
-        trkd_ids (List[int]): List of tracked object IDs that have already been speed-estimated.
-        trk_pt (Dict[int, float]): Dictionary storing previous timestamps for tracked objects.
-        trk_pp (Dict[int, Tuple[float, float]]): Dictionary storing previous positions for tracked objects.
-        region (List[Tuple[int, int]]): List of points defining the speed estimation region.
-        track_line (List[Tuple[float, float]]): List of points representing the object's track.
-        r_s (LineString): LineString object representing the speed estimation region.
-
-    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.
-
-    Examples:
-        >>> estimator = SpeedEstimator()
-        >>> 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.
-
-        Args:
-            **kwargs (Any): Additional keyword arguments passed to the parent class.
-        """
-        super().__init__(**kwargs)
-
-        self.initialize_region()  # Initialize speed region
-
-        self.spd = {}  # Dictionary for speed data
-        self.trkd_ids = []  # List for already speed-estimated and tracked IDs
-        self.trk_pt = {}  # Dictionary for tracks' previous timestamps
-        self.trk_pp = {}  # Dictionary for tracks' previous positions
-
-    def process(self, im0):
-        """
-        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.
-
-        Returns:
-            (SolutionResults): Contains processed image `plot_im` and `total_tracks` (number of tracked objects).
-
-        Examples:
-            >>> estimator = SpeedEstimator()
-            >>> image = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8)
-            >>> results = estimator.process(image)
-        """
-        self.extract_tracks(im0)  # Extract tracks
-        annotator = SolutionAnnotator(im0, line_width=self.line_width)  # Initialize annotator
-
-        # Draw speed estimation region
-        annotator.draw_region(reg_pts=self.region, color=(104, 0, 123), thickness=self.line_width * 2)
-
-        for box, track_id, cls, conf in zip(self.boxes, self.track_ids, self.clss, self.confs):
-            self.store_tracking_history(track_id, box)  # Store track history
-
-            # Initialize tracking data for new objects
-            if track_id not in self.trk_pt:
-                self.trk_pt[track_id] = 0
-            if track_id not in self.trk_pp:
-                self.trk_pp[track_id] = self.track_line[-1]
-
-            speed_label = (
-                f"{int(self.spd[track_id])} km/h"
-                if track_id in self.spd and self.show_labels
-                else self.adjust_box_label(cls, conf, track_id)
-            )
-            annotator.box_label(box, label=speed_label, color=colors(track_id, True))  # Draw bounding box
-
-            # Determine if object is crossing the speed estimation region
-            if self.LineString([self.trk_pp[track_id], self.track_line[-1]]).intersects(self.r_s):
-                direction = "known"
-            else:
-                direction = "unknown"
-
-            # Calculate speed for objects crossing the region for the first time
-            if direction == "known" and track_id not in self.trkd_ids:
-                self.trkd_ids.append(track_id)
-                time_difference = time() - self.trk_pt[track_id]
-                if time_difference > 0:
-                    # Calculate speed based on vertical displacement and time
-                    self.spd[track_id] = abs(self.track_line[-1][1] - self.trk_pp[track_id][1]) / time_difference
-
-            # Update tracking data for next frame
-            self.trk_pt[track_id] = time()
-            self.trk_pp[track_id] = self.track_line[-1]
-
-        plot_im = annotator.result()
-        self.display_output(plot_im)  # Display output with base class function
-
-        # Return results with processed image and tracking summary
-        return SolutionResults(plot_im=plot_im, total_tracks=len(self.track_ids))