ultralytics 8.3.32__tar.gz → 8.3.34__tar.gz

{ultralytics-8.3.32/ultralytics.egg-info → ultralytics-8.3.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics
-Version: 8.3.32
+Version: 8.3.34
 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>

{ultralytics-8.3.32 → ultralytics-8.3.34}/ultralytics/__init__.py

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

{ultralytics-8.3.32 → ultralytics-8.3.34}/ultralytics/data/augment.py

@@ -2280,7 +2280,7 @@ def v8_transforms(dataset, imgsz, hyp, stretch=False):
     Args:
         dataset (Dataset): The dataset object containing image data and annotations.
         imgsz (int): The target image size for resizing.
-        hyp (Dict): A dictionary of hyperparameters controlling various aspects of the transformations.
+        hyp (Namespace): A dictionary of hyperparameters controlling various aspects of the transformations.
         stretch (bool): If True, applies stretching to the image. If False, uses LetterBox resizing.
 
     Returns:
@@ -2288,8 +2288,9 @@ def v8_transforms(dataset, imgsz, hyp, stretch=False):
 
     Examples:
         >>> from ultralytics.data.dataset import YOLODataset
+        >>> from ultralytics.utils import IterableSimpleNamespace
         >>> dataset = YOLODataset(img_path="path/to/images", imgsz=640)
-        >>> hyp = {"mosaic": 1.0, "copy_paste": 0.5, "degrees": 10.0, "translate": 0.2, "scale": 0.9}
+        >>> hyp = IterableSimpleNamespace(mosaic=1.0, copy_paste=0.5, degrees=10.0, translate=0.2, scale=0.9)
         >>> transforms = v8_transforms(dataset, imgsz=640, hyp=hyp)
         >>> augmented_data = transforms(dataset[0])
     """

{ultralytics-8.3.32 → ultralytics-8.3.34}/ultralytics/engine/exporter.py

@@ -79,7 +79,6 @@ from ultralytics.utils import (
     ARM64,
     DEFAULT_CFG,
     IS_JETSON,
-    IS_RASPBERRYPI,
     LINUX,
     LOGGER,
     MACOS,
@@ -265,8 +264,6 @@ class Exporter:
                 "WARNING ⚠️ INT8 export requires a missing 'data' arg for calibration. "
                 f"Using default 'data={self.args.data}'."
             )
-        if mnn and (IS_RASPBERRYPI or IS_JETSON):
-            raise SystemError("MNN export not supported on Raspberry Pi and NVIDIA Jetson")
 
         # Input
         im = torch.zeros(self.args.batch, 3, *self.imgsz).to(self.device)

{ultralytics-8.3.32 → ultralytics-8.3.34}/ultralytics/models/fastsam/predict.py

@@ -64,6 +64,9 @@ class FastSAMPredictor(SegmentationPredictor):
         if not isinstance(results, list):
             results = [results]
         for result in results:
+            if len(result) == 0:
+                prompt_results.append(result)
+                continue
             masks = result.masks.data
             if masks.shape[1:] != result.orig_shape:
                 masks = scale_masks(masks[None], result.orig_shape)[0]

{ultralytics-8.3.32 → ultralytics-8.3.34}/ultralytics/models/rtdetr/train.py

@@ -68,8 +68,11 @@ class RTDETRTrainer(DetectionTrainer):
             hyp=self.args,
             rect=False,
             cache=self.args.cache or None,
+            single_cls=self.args.single_cls or False,
             prefix=colorstr(f"{mode}: "),
+            classes=self.args.classes,
             data=self.data,
+            fraction=self.args.fraction if mode == "train" else 1.0,
         )
 
     def get_validator(self):

{ultralytics-8.3.32 → ultralytics-8.3.34}/ultralytics/solutions/heatmap.py

@@ -104,12 +104,12 @@ class Heatmap(ObjectCounter):
                 self.annotator.draw_region(reg_pts=self.region, color=(104, 0, 123), thickness=self.line_width * 2)
                 self.store_tracking_history(track_id, box)  # Store track history
                 self.store_classwise_counts(cls)  # store classwise counts in dict
-
+                current_centroid = ((box[0] + box[2]) / 2, (box[1] + box[3]) / 2)
                 # Store tracking previous position and perform object counting
                 prev_position = None
                 if len(self.track_history[track_id]) > 1:
                     prev_position = self.track_history[track_id][-2]
-                self.count_objects(self.track_line, box, track_id, prev_position, cls)  # Perform object counting
+                self.count_objects(current_centroid, track_id, prev_position, cls)  # Perform object counting
 
         if self.region is not None:
             self.display_counts(im0)  # Display the counts on the frame

{ultralytics-8.3.32 → ultralytics-8.3.34}/ultralytics/solutions/object_counter.py

@@ -46,13 +46,12 @@ class ObjectCounter(BaseSolution):
         self.show_in = self.CFG["show_in"]
         self.show_out = self.CFG["show_out"]
 
-    def count_objects(self, track_line, box, track_id, prev_position, cls):
+    def count_objects(self, current_centroid, track_id, prev_position, cls):
         """
         Counts objects within a polygonal or linear region based on their tracks.
 
         Args:
-            track_line (Dict): Last 30 frame track record for the object.
-            box (List[float]): Bounding box coordinates [x1, y1, x2, y2] for the specific track in the current frame.
+            current_centroid (Tuple[float, float]): Current centroid values in the current frame.
             track_id (int): Unique identifier for the tracked object.
             prev_position (Tuple[float, float]): Last frame position coordinates (x, y) of the track.
             cls (int): Class index for classwise count updates.
@@ -64,34 +63,55 @@ class ObjectCounter(BaseSolution):
             >>> track_id = 1
             >>> prev_position = (120, 220)
             >>> cls = 0
-            >>> counter.count_objects(track_line, box, track_id, prev_position, cls)
+            >>> counter.count_objects(current_centroid, track_id, prev_position, cls)
         """
         if prev_position is None or track_id in self.counted_ids:
             return
 
-        centroid = self.r_s.centroid
-        dx = (box[0] - prev_position[0]) * (centroid.x - prev_position[0])
-        dy = (box[1] - prev_position[1]) * (centroid.y - prev_position[1])
-
-        if len(self.region) >= 3 and self.r_s.contains(self.Point(track_line[-1])):
-            self.counted_ids.append(track_id)
-            # For polygon region
-            if dx > 0:
-                self.in_count += 1
-                self.classwise_counts[self.names[cls]]["IN"] += 1
-            else:
-                self.out_count += 1
-                self.classwise_counts[self.names[cls]]["OUT"] += 1
-
-        elif len(self.region) < 3 and self.LineString([prev_position, box[:2]]).intersects(self.r_s):
-            self.counted_ids.append(track_id)
-            # For linear region
-            if dx > 0 and dy > 0:
-                self.in_count += 1
-                self.classwise_counts[self.names[cls]]["IN"] += 1
-            else:
-                self.out_count += 1
-                self.classwise_counts[self.names[cls]]["OUT"] += 1
+        if len(self.region) == 2:  # Linear region (defined as a line segment)
+            line = self.LineString(self.region)  # Check if the line intersects the trajectory of the object
+            if line.intersects(self.LineString([prev_position, current_centroid])):
+                # Determine orientation of the region (vertical or horizontal)
+                if abs(self.region[0][0] - self.region[1][0]) < abs(self.region[0][1] - self.region[1][1]):
+                    # Vertical region: Compare x-coordinates to determine direction
+                    if current_centroid[0] > prev_position[0]:  # Moving right
+                        self.in_count += 1
+                        self.classwise_counts[self.names[cls]]["IN"] += 1
+                    else:  # Moving left
+                        self.out_count += 1
+                        self.classwise_counts[self.names[cls]]["OUT"] += 1
+                else:
+                    # Horizontal region: Compare y-coordinates to determine direction
+                    if current_centroid[1] > prev_position[1]:  # Moving downward
+                        self.in_count += 1
+                        self.classwise_counts[self.names[cls]]["IN"] += 1
+                    else:  # Moving upward
+                        self.out_count += 1
+                        self.classwise_counts[self.names[cls]]["OUT"] += 1
+                self.counted_ids.append(track_id)
+
+        elif len(self.region) > 2:  # Polygonal region
+            polygon = self.Polygon(self.region)
+            if polygon.contains(self.Point(current_centroid)):
+                # Determine motion direction for vertical or horizontal polygons
+                region_width = max([p[0] for p in self.region]) - min([p[0] for p in self.region])
+                region_height = max([p[1] for p in self.region]) - min([p[1] for p in self.region])
+
+                if region_width < region_height:  # Vertical-oriented polygon
+                    if current_centroid[0] > prev_position[0]:  # Moving right
+                        self.in_count += 1
+                        self.classwise_counts[self.names[cls]]["IN"] += 1
+                    else:  # Moving left
+                        self.out_count += 1
+                        self.classwise_counts[self.names[cls]]["OUT"] += 1
+                else:  # Horizontal-oriented polygon
+                    if current_centroid[1] > prev_position[1]:  # Moving downward
+                        self.in_count += 1
+                        self.classwise_counts[self.names[cls]]["IN"] += 1
+                    else:  # Moving upward
+                        self.out_count += 1
+                        self.classwise_counts[self.names[cls]]["OUT"] += 1
+                self.counted_ids.append(track_id)
 
     def store_classwise_counts(self, cls):
         """
@@ -174,12 +194,12 @@ class ObjectCounter(BaseSolution):
             self.annotator.draw_centroid_and_tracks(
                 self.track_line, color=colors(int(cls), True), track_thickness=self.line_width
             )
-
+            current_centroid = ((box[0] + box[2]) / 2, (box[1] + box[3]) / 2)
             # store previous position of track for object counting
             prev_position = None
             if len(self.track_history[track_id]) > 1:
                 prev_position = self.track_history[track_id][-2]
-            self.count_objects(self.track_line, box, track_id, prev_position, cls)  # Perform object counting
+            self.count_objects(current_centroid, track_id, prev_position, cls)  # Perform object counting
 
         self.display_counts(im0)  # Display the counts on the frame
         self.display_output(im0)  # display output with base class function

{ultralytics-8.3.32 → ultralytics-8.3.34}/ultralytics/utils/benchmarks.py

@@ -114,8 +114,6 @@ def benchmark(
                 assert LINUX or MACOS, "Windows Paddle exports not supported yet"
             if i == 12:  # MNN
                 assert not isinstance(model, YOLOWorld), "YOLOWorldv2 MNN exports not supported yet"
-                assert not IS_RASPBERRYPI, "MNN export not supported on Raspberry Pi"
-                assert not IS_JETSON, "MNN export not supported on NVIDIA Jetson"
             if i == 13:  # NCNN
                 assert not isinstance(model, YOLOWorld), "YOLOWorldv2 NCNN exports not supported yet"
             if i == 14:  # IMX

{ultralytics-8.3.32 → ultralytics-8.3.34}/ultralytics/utils/callbacks/wb.py

@@ -109,7 +109,12 @@ def _log_plots(plots, step):
 
 def on_pretrain_routine_start(trainer):
     """Initiate and start project if module is present."""
-    wb.run or wb.init(project=trainer.args.project or "Ultralytics", name=trainer.args.name, config=vars(trainer.args))
+    if not wb.run:
+        wb.init(
+            project=str(trainer.args.project).replace("/", "-") if trainer.args.project else "Ultralytics",
+            name=str(trainer.args.name).replace("/", "-"),
+            config=vars(trainer.args),
+        )
 
 
 def on_fit_epoch_end(trainer):

{ultralytics-8.3.32 → ultralytics-8.3.34/ultralytics.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics
-Version: 8.3.32
+Version: 8.3.34
 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>