dgenerate-ultralytics-headless 8.3.162__tar.gz → 8.3.163__tar.gz

{dgenerate_ultralytics_headless-8.3.162 → dgenerate_ultralytics_headless-8.3.163}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dgenerate-ultralytics-headless
-Version: 8.3.162
+Version: 8.3.163
 Summary: Automatically built Ultralytics package with python-opencv-headless dependency instead of python-opencv
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>

{dgenerate_ultralytics_headless-8.3.162 → dgenerate_ultralytics_headless-8.3.163}/dgenerate_ultralytics_headless.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dgenerate-ultralytics-headless
-Version: 8.3.162
+Version: 8.3.163
 Summary: Automatically built Ultralytics package with python-opencv-headless dependency instead of python-opencv
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>

{dgenerate_ultralytics_headless-8.3.162 → dgenerate_ultralytics_headless-8.3.163}/ultralytics/__init__.py

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

{dgenerate_ultralytics_headless-8.3.162 → dgenerate_ultralytics_headless-8.3.163}/ultralytics/data/utils.py

@@ -214,8 +214,9 @@ def verify_image_label(args: Tuple) -> List:
                 else:
                     assert lb.shape[1] == 5, f"labels require 5 columns, {lb.shape[1]} columns detected"
                     points = lb[:, 1:]
-                assert points.max() <= 1, f"non-normalized or out of bounds coordinates {points[points > 1]}"
-                assert lb.min() >= 0, f"negative label values {lb[lb < 0]}"
+                # Coordinate points check with 1% tolerance
+                assert points.max() <= 1.01, f"non-normalized or out of bounds coordinates {points[points > 1.01]}"
+                assert lb.min() >= -0.01, f"negative class labels {lb[lb < -0.01]}"
 
                 # All labels
                 if single_cls:

{dgenerate_ultralytics_headless-8.3.162 → dgenerate_ultralytics_headless-8.3.163}/ultralytics/engine/exporter.py

@@ -574,7 +574,7 @@ class Exporter:
         """Export YOLO model to ONNX format."""
         requirements = ["onnx>=1.12.0,<1.18.0"]
         if self.args.simplify:
-            requirements += ["onnxslim>=0.1.56", "onnxruntime" + ("-gpu" if torch.cuda.is_available() else "")]
+            requirements += ["onnxslim>=0.1.59", "onnxruntime" + ("-gpu" if torch.cuda.is_available() else "")]
         check_requirements(requirements)
         import onnx  # noqa
 
@@ -952,7 +952,7 @@ class Exporter:
                 "ai-edge-litert>=1.2.0,<1.4.0",  # required by 'onnx2tf' package
                 "onnx>=1.12.0,<1.18.0",
                 "onnx2tf>=1.26.3",
-                "onnxslim>=0.1.56",
+                "onnxslim>=0.1.59",
                 "onnxruntime-gpu" if cuda else "onnxruntime",
                 "protobuf>=5",
             ),

{dgenerate_ultralytics_headless-8.3.162 → dgenerate_ultralytics_headless-8.3.163}/ultralytics/engine/predictor.py

@@ -452,16 +452,16 @@ class BasePredictor:
         if self.args.show:
             self.show(str(p))
         if self.args.save:
-            self.save_predicted_images(str(self.save_dir / p.name), frame)
+            self.save_predicted_images(self.save_dir / p.name, frame)
 
         return string
 
-    def save_predicted_images(self, save_path: str = "", frame: int = 0):
+    def save_predicted_images(self, save_path: Path, frame: int = 0):
         """
         Save video predictions as mp4 or images as jpg at specified path.
 
         Args:
-            save_path (str): Path to save the results.
+            save_path (Path): Path to save the results.
             frame (int): Frame number for video mode.
         """
         im = self.plotted_img
@@ -469,7 +469,7 @@ class BasePredictor:
         # Save videos and streams
         if self.dataset.mode in {"stream", "video"}:
             fps = self.dataset.fps if self.dataset.mode == "video" else 30
-            frames_path = f"{save_path.split('.', 1)[0]}_frames/"
+            frames_path = self.save_dir / f"{save_path.stem}_frames"  # save frames to a separate directory
             if save_path not in self.vid_writer:  # new video
                 if self.args.save_frames:
                     Path(frames_path).mkdir(parents=True, exist_ok=True)
@@ -484,11 +484,11 @@ class BasePredictor:
             # Save video
             self.vid_writer[save_path].write(im)
             if self.args.save_frames:
-                cv2.imwrite(f"{frames_path}{frame}.jpg", im)
+                cv2.imwrite(f"{frames_path}/{save_path.stem}_{frame}.jpg", im)
 
         # Save images
         else:
-            cv2.imwrite(str(Path(save_path).with_suffix(".jpg")), im)  # save to JPG for best support
+            cv2.imwrite(str(save_path.with_suffix(".jpg")), im)  # save to JPG for best support
 
     def show(self, p: str = ""):
         """Display an image in a window."""

{dgenerate_ultralytics_headless-8.3.162 → dgenerate_ultralytics_headless-8.3.163}/ultralytics/nn/tasks.py

@@ -249,6 +249,8 @@ class BaseModel(torch.nn.Module):
                     m.forward = m.forward_fuse
                 if isinstance(m, v10Detect):
                     m.fuse()  # remove one2many head
+                if isinstance(m, YOLOEDetect) and hasattr(self, "pe"):
+                    m.fuse(self.pe.to(next(self.model.parameters()).device))
             self.info(verbose=verbose)
 
         return self

{dgenerate_ultralytics_headless-8.3.162 → dgenerate_ultralytics_headless-8.3.163}/ultralytics/solutions/region_counter.py

@@ -1,6 +1,6 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
-from typing import Any, List, Tuple
+from typing import Any, Dict, List, Tuple
 
 import numpy as np
 
@@ -26,6 +26,7 @@ class RegionCounter(BaseSolution):
     Methods:
         add_region: Add a new counting region with specified attributes.
         process: Process video frames to count objects in each region.
+        initialize_regions: Initialize zones to count the objects in each one. Zones could be multiple as well.
 
     Examples:
         Initialize a RegionCounter and add a counting region
@@ -42,12 +43,12 @@ class RegionCounter(BaseSolution):
             "name": "Default Region",
             "polygon": None,
             "counts": 0,
-            "dragging": False,
             "region_color": (255, 255, 255),
             "text_color": (0, 0, 0),
         }
         self.region_counts = {}
         self.counting_regions = []
+        self.initialize_regions()
 
     def add_region(
         self,
@@ -55,7 +56,7 @@ class RegionCounter(BaseSolution):
         polygon_points: List[Tuple],
         region_color: Tuple[int, int, int],
         text_color: Tuple[int, int, int],
-    ) -> None:
+    ) -> Dict[str, Any]:
         """
         Add a new region to the counting list based on the provided template with specific attributes.
 
@@ -64,6 +65,9 @@ class RegionCounter(BaseSolution):
             polygon_points (List[Tuple]): List of (x, y) coordinates defining the region's polygon.
             region_color (Tuple[int, int, int]): BGR color for region visualization.
             text_color (Tuple[int, int, int]): BGR color for the text within the region.
+
+        Returns:
+            (Dict[str, any]): Returns a dictionary including the region information i.e. name, region_color etc.
         """
         region = self.region_template.copy()
         region.update(
@@ -75,6 +79,17 @@ class RegionCounter(BaseSolution):
             }
         )
         self.counting_regions.append(region)
+        return region
+
+    def initialize_regions(self):
+        """Initialize regions only once."""
+        if self.region is None:
+            self.initialize_region()
+        if not isinstance(self.region, dict):  # Ensure self.region is initialized and structured as a dictionary
+            self.region = {"Region#01": self.region}
+        for i, (name, pts) in enumerate(self.region.items()):
+            region = self.add_region(name, pts, colors(i, True), (255, 255, 255))
+            region["prepared_polygon"] = self.prep(region["polygon"])
 
     def process(self, im0: np.ndarray) -> SolutionResults:
         """
@@ -90,39 +105,21 @@ class RegionCounter(BaseSolution):
         self.extract_tracks(im0)
         annotator = SolutionAnnotator(im0, line_width=self.line_width)
 
-        # Ensure self.region is initialized and structured as a dictionary
-        if not isinstance(self.region, dict):
-            self.region = {"Region#01": self.region or self.initialize_region()}
-
-        # Draw only valid regions
-        for idx, (region_name, reg_pts) in enumerate(self.region.items(), start=1):
-            color = colors(idx, True)
-            annotator.draw_region(reg_pts, color, self.line_width * 2)
-            self.add_region(region_name, reg_pts, color, annotator.get_txt_color())
-
-        # Prepare regions for containment check (only process valid ones)
-        for region in self.counting_regions:
-            if "prepared_polygon" not in region:
-                region["prepared_polygon"] = self.prep(region["polygon"])
-
-        # Convert bounding boxes to NumPy array for center points
-        boxes_np = np.array([((box[0] + box[2]) / 2, (box[1] + box[3]) / 2) for box in self.boxes], dtype=np.float32)
-        points = [self.Point(pt) for pt in boxes_np]  # Convert centers to Point objects
-
-        # Process bounding boxes & check containment
-        if points:
-            for point, cls, track_id, box, conf in zip(points, self.clss, self.track_ids, self.boxes, self.confs):
-                annotator.box_label(box, label=self.adjust_box_label(cls, conf, track_id), color=colors(track_id, True))
-
-                for region in self.counting_regions:
-                    if region["prepared_polygon"].contains(point):
-                        region["counts"] += 1
-                        self.region_counts[region["name"]] = region["counts"]
+        for box, cls, track_id, conf in zip(self.boxes, self.clss, self.track_ids, self.confs):
+            annotator.box_label(box, label=self.adjust_box_label(cls, conf, track_id), color=colors(track_id, True))
+            center = self.Point(((box[0] + box[2]) / 2, (box[1] + box[3]) / 2))
+            for region in self.counting_regions:
+                if region["prepared_polygon"].contains(center):
+                    region["counts"] += 1
+                    self.region_counts[region["name"]] = region["counts"]
 
         # Display region counts
         for region in self.counting_regions:
+            x1, y1, x2, y2 = map(int, region["polygon"].bounds)
+            pts = [(x1, y1), (x2, y1), (x2, y2), (x1, y2)]
+            annotator.draw_region(pts, region["region_color"], self.line_width * 2)
             annotator.text_label(
-                region["polygon"].bounds,
+                [x1, y1, x2, y2],
                 label=str(region["counts"]),
                 color=region["region_color"],
                 txt_color=region["text_color"],