ultralytics 8.2.25__tar.gz → 8.2.27__tar.gz

{ultralytics-8.2.25 → ultralytics-8.2.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics
-Version: 8.2.25
+Version: 8.2.27
 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.25 → ultralytics-8.2.27}/pyproject.toml

@@ -102,7 +102,7 @@ export = [
     "openvino>=2024.0.0", # OpenVINO export
     "tensorflow>=2.0.0", # TF bug https://github.com/ultralytics/ultralytics/issues/5161
     "tensorflowjs>=3.9.0", # TF.js export, automatically installs tensorflow
-    "keras",  # not installed auotomatically by tensorflow>=2.16
+    "keras",  # not installed automatically by tensorflow>=2.16
     "flatbuffers>=23.5.26,<100; platform_machine == 'aarch64'", # update old 'flatbuffers' included inside tensorflow package
     "numpy==1.23.5; platform_machine == 'aarch64'", # fix error: `np.bool` was a deprecated alias for the builtin `bool` when using TensorRT models on NVIDIA Jetson
     "h5py!=3.11.0; platform_machine == 'aarch64'", # fix h5py build issues due to missing aarch64 wheels in 3.11 release
@@ -112,9 +112,6 @@ explorer = [
     "duckdb<=0.9.2", # SQL queries, duckdb==0.10.0 bug https://github.com/ultralytics/ultralytics/pull/8181
     "streamlit", # visualizing with GUI
 ]
-# tflite-support  # for TFLite model metadata
-# nvidia-pyindex  # TensorRT export
-# nvidia-tensorrt  # TensorRT export
 logging = [
     "comet", # https://docs.ultralytics.com/integrations/comet/
     "tensorboard>=2.13.0",

{ultralytics-8.2.25 → ultralytics-8.2.27}/tests/test_cli.py

@@ -3,6 +3,7 @@
 import subprocess
 
 import pytest
+from PIL import Image
 
 from tests import CUDA_DEVICE_COUNT, CUDA_IS_AVAILABLE
 from ultralytics.cfg import TASK2DATA, TASK2MODEL, TASKS
@@ -74,26 +75,27 @@ def test_fastsam(task="segment", model=WEIGHTS_DIR / "FastSAM-s.pt", data="coco8
     sam_model = FastSAM(model)  # or FastSAM-x.pt
 
     # Run inference on an image
-    everything_results = sam_model(source, device="cpu", retina_masks=True, imgsz=1024, conf=0.4, iou=0.9)
+    for s in (source, Image.open(source)):
+        everything_results = sam_model(s, device="cpu", retina_masks=True, imgsz=320, conf=0.4, iou=0.9)
 
-    # Remove small regions
-    new_masks, _ = Predictor.remove_small_regions(everything_results[0].masks.data, min_area=20)
+        # Remove small regions
+        new_masks, _ = Predictor.remove_small_regions(everything_results[0].masks.data, min_area=20)
 
-    # Everything prompt
-    prompt_process = FastSAMPrompt(source, everything_results, device="cpu")
-    ann = prompt_process.everything_prompt()
+        # Everything prompt
+        prompt_process = FastSAMPrompt(s, everything_results, device="cpu")
+        ann = prompt_process.everything_prompt()
 
-    # Bbox default shape [0,0,0,0] -> [x1,y1,x2,y2]
-    ann = prompt_process.box_prompt(bbox=[200, 200, 300, 300])
+        # Bbox default shape [0,0,0,0] -> [x1,y1,x2,y2]
+        ann = prompt_process.box_prompt(bbox=[200, 200, 300, 300])
 
-    # Text prompt
-    ann = prompt_process.text_prompt(text="a photo of a dog")
+        # Text prompt
+        ann = prompt_process.text_prompt(text="a photo of a dog")
 
-    # Point prompt
-    # Points default [[0,0]] [[x1,y1],[x2,y2]]
-    # Point_label default [0] [1,0] 0:background, 1:foreground
-    ann = prompt_process.point_prompt(points=[[200, 200]], pointlabel=[1])
-    prompt_process.plot(annotations=ann, output="./")
+        # Point prompt
+        # Points default [[0,0]] [[x1,y1],[x2,y2]]
+        # Point_label default [0] [1,0] 0:background, 1:foreground
+        ann = prompt_process.point_prompt(points=[[200, 200]], pointlabel=[1])
+        prompt_process.plot(annotations=ann, output="./")
 
 
 def test_mobilesam():

{ultralytics-8.2.25 → ultralytics-8.2.27}/tests/test_cuda.py

@@ -41,6 +41,7 @@ def test_export_engine_matrix(task, dynamic, int8, half, batch):
         batch=batch,
         data=TASK2DATA[task],
         workspace=1,  # reduce workspace GB for less resource utilization during testing
+        simplify=True,  # use 'onnxslim'
     )
     YOLO(file)([SOURCE] * batch, imgsz=64 if dynamic else 32)  # exported model inference
     Path(file).unlink()  # cleanup

{ultralytics-8.2.25 → ultralytics-8.2.27}/tests/test_exports.py

@@ -72,8 +72,10 @@ def test_export_openvino_matrix(task, dynamic, int8, half, batch):
 
 
 @pytest.mark.slow
-@pytest.mark.parametrize("task, dynamic, int8, half, batch", product(TASKS, [True, False], [False], [False], [1, 2]))
-def test_export_onnx_matrix(task, dynamic, int8, half, batch):
+@pytest.mark.parametrize(
+    "task, dynamic, int8, half, batch, simplify", product(TASKS, [True, False], [False], [False], [1, 2], [True, False])
+)
+def test_export_onnx_matrix(task, dynamic, int8, half, batch, simplify):
     """Test YOLO exports to ONNX format."""
     file = YOLO(TASK2MODEL[task]).export(
         format="onnx",
@@ -82,6 +84,7 @@ def test_export_onnx_matrix(task, dynamic, int8, half, batch):
         int8=int8,
         half=half,
         batch=batch,
+        simplify=simplify,
     )
     YOLO(file)([SOURCE] * batch, imgsz=64 if dynamic else 32)  # exported model inference
     Path(file).unlink()  # cleanup

{ultralytics-8.2.25 → ultralytics-8.2.27}/ultralytics/__init__.py

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

{ultralytics-8.2.25 → ultralytics-8.2.27}/ultralytics/cfg/default.yaml

@@ -81,7 +81,7 @@ keras: False # (bool) use Kera=s
 optimize: False # (bool) TorchScript: optimize for mobile
 int8: False # (bool) CoreML/TF INT8 quantization
 dynamic: False # (bool) ONNX/TF/TensorRT: dynamic axes
-simplify: False # (bool) ONNX: simplify model
+simplify: False # (bool) ONNX: simplify model using `onnxslim`
 opset: # (int, optional) ONNX: opset version
 workspace: 4 # (int) TensorRT: workspace size (GB)
 nms: False # (bool) CoreML: add NMS

{ultralytics-8.2.25 → ultralytics-8.2.27}/ultralytics/engine/exporter.py

@@ -384,9 +384,7 @@ class Exporter:
         """YOLOv8 ONNX export."""
         requirements = ["onnx>=1.12.0"]
         if self.args.simplify:
-            requirements += ["onnxsim>=0.4.33", "onnxruntime-gpu" if torch.cuda.is_available() else "onnxruntime"]
-            if ARM64:
-                check_requirements("cmake")  # 'cmake' is needed to build onnxsim on aarch64
+            requirements += ["onnxslim==0.1.28", "onnxruntime" + ("-gpu" if torch.cuda.is_available() else "")]
         check_requirements(requirements)
         import onnx  # noqa
 
@@ -423,14 +421,17 @@ class Exporter:
         # Simplify
         if self.args.simplify:
             try:
-                import onnxsim
+                import onnxslim
 
-                LOGGER.info(f"{prefix} simplifying with onnxsim {onnxsim.__version__}...")
-                # subprocess.run(f'onnxsim "{f}" "{f}"', shell=True)
-                model_onnx, check = onnxsim.simplify(model_onnx)
-                assert check, "Simplified ONNX model could not be validated"
+                LOGGER.info(f"{prefix} slimming with onnxslim {onnxslim.__version__}...")
+                model_onnx = onnxslim.slim(model_onnx)
+
+                # ONNX Simplifier (deprecated as must be compiled with 'cmake' in aarch64 and Conda CI environments)
+                # import onnxsim
+                # model_onnx, check = onnxsim.simplify(model_onnx)
+                # assert check, "Simplified ONNX model could not be validated"
             except Exception as e:
-                LOGGER.info(f"{prefix} simplifier failure: {e}")
+                LOGGER.warning(f"{prefix} simplifier failure: {e}")
 
         # Metadata
         for k, v in self.metadata.items():
@@ -674,8 +675,8 @@ class Exporter:
     def export_engine(self, prefix=colorstr("TensorRT:")):
         """YOLOv8 TensorRT export https://developer.nvidia.com/tensorrt."""
         assert self.im.device.type != "cpu", "export running on CPU but must be on GPU, i.e. use 'device=0'"
-        self.args.simplify = True
-        f_onnx, _ = self.export_onnx()  # run before trt import https://github.com/ultralytics/ultralytics/issues/7016
+        # self.args.simplify = True
+        f_onnx, _ = self.export_onnx()  # run before TRT import https://github.com/ultralytics/ultralytics/issues/7016
 
         try:
             import tensorrt as trt  # noqa
@@ -815,15 +816,14 @@ class Exporter:
             version = ">=2.0.0"
             check_requirements(f"tensorflow{suffix}{version}")
             import tensorflow as tf  # noqa
-        if ARM64:
-            check_requirements("cmake")  # 'cmake' is needed to build onnxsim on aarch64
         check_requirements(
             (
-                "keras",
+                "keras",  # required by onnx2tf package
+                "tf_keras",  # required by onnx2tf package
                 "onnx>=1.12.0",
                 "onnx2tf>1.17.5,<=1.22.3",
                 "sng4onnx>=1.0.1",
-                "onnxsim>=0.4.33",
+                "onnxslim==0.1.28",
                 "onnx_graphsurgeon>=0.3.26",
                 "tflite_support<=0.4.3" if IS_JETSON else "tflite_support",  # fix ImportError 'GLIBCXX_3.4.29'
                 "flatbuffers>=23.5.26,<100",  # update old 'flatbuffers' included inside tensorflow package

{ultralytics-8.2.25 → ultralytics-8.2.27}/ultralytics/models/fastsam/prompt.py

@@ -24,6 +24,8 @@ class FastSAMPrompt:
 
     def __init__(self, source, results, device="cuda") -> None:
         """Initializes FastSAMPrompt with given source, results and device, and assigns clip for linear assignment."""
+        if isinstance(source, (str, Path)) and os.path.isdir(source):
+            raise ValueError(f"FastSAM only accepts image paths and PIL Image sources, not directories.")
         self.device = device
         self.results = results
         self.source = source
@@ -261,8 +263,6 @@ class FastSAMPrompt:
 
     def _crop_image(self, format_results):
         """Crops an image based on provided annotation format and returns cropped images and related data."""
-        if os.path.isdir(self.source):
-            raise ValueError(f"'{self.source}' is a directory, not a valid source for this function.")
         image = Image.fromarray(cv2.cvtColor(self.results[0].orig_img, cv2.COLOR_BGR2RGB))
         ori_w, ori_h = image.size
         annotations = format_results
@@ -287,8 +287,6 @@ class FastSAMPrompt:
         """Modifies the bounding box properties and calculates IoU between masks and bounding box."""
         if self.results[0].masks is not None:
             assert bbox[2] != 0 and bbox[3] != 0
-            if os.path.isdir(self.source):
-                raise ValueError(f"'{self.source}' is a directory, not a valid source for this function.")
             masks = self.results[0].masks.data
             target_height, target_width = self.results[0].orig_shape
             h = masks.shape[1]
@@ -321,8 +319,6 @@ class FastSAMPrompt:
     def point_prompt(self, points, pointlabel):  # numpy
         """Adjusts points on detected masks based on user input and returns the modified results."""
         if self.results[0].masks is not None:
-            if os.path.isdir(self.source):
-                raise ValueError(f"'{self.source}' is a directory, not a valid source for this function.")
             masks = self._format_results(self.results[0], 0)
             target_height, target_width = self.results[0].orig_shape
             h = masks[0]["segmentation"].shape[0]

{ultralytics-8.2.25 → ultralytics-8.2.27}/ultralytics/models/yolo/detect/val.py

@@ -32,6 +32,7 @@ class DetectionValidator(BaseValidator):
         """Initialize detection model with necessary variables and settings."""
         super().__init__(dataloader, save_dir, pbar, args, _callbacks)
         self.nt_per_class = None
+        self.nt_per_image = None
         self.is_coco = False
         self.is_lvis = False
         self.class_map = None
@@ -77,7 +78,7 @@ class DetectionValidator(BaseValidator):
         self.confusion_matrix = ConfusionMatrix(nc=self.nc, conf=self.args.conf)
         self.seen = 0
         self.jdict = []
-        self.stats = dict(tp=[], conf=[], pred_cls=[], target_cls=[])
+        self.stats = dict(tp=[], conf=[], pred_cls=[], target_cls=[], target_img=[])
 
     def get_desc(self):
         """Return a formatted string summarizing class metrics of YOLO model."""
@@ -130,6 +131,7 @@ class DetectionValidator(BaseValidator):
             cls, bbox = pbatch.pop("cls"), pbatch.pop("bbox")
             nl = len(cls)
             stat["target_cls"] = cls
+            stat["target_img"] = cls.unique()
             if npr == 0:
                 if nl:
                     for k in self.stats.keys():
@@ -168,11 +170,11 @@ class DetectionValidator(BaseValidator):
     def get_stats(self):
         """Returns metrics statistics and results dictionary."""
         stats = {k: torch.cat(v, 0).cpu().numpy() for k, v in self.stats.items()}  # to numpy
+        self.nt_per_class = np.bincount(stats["target_cls"].astype(int), minlength=self.nc)
+        self.nt_per_image = np.bincount(stats["target_img"].astype(int), minlength=self.nc)
+        stats.pop("target_img", None)
         if len(stats) and stats["tp"].any():
             self.metrics.process(**stats)
-        self.nt_per_class = np.bincount(
-            stats["target_cls"].astype(int), minlength=self.nc
-        )  # number of targets per class
         return self.metrics.results_dict
 
     def print_results(self):
@@ -185,7 +187,9 @@ class DetectionValidator(BaseValidator):
         # Print results per class
         if self.args.verbose and not self.training and self.nc > 1 and len(self.stats):
             for i, c in enumerate(self.metrics.ap_class_index):
-                LOGGER.info(pf % (self.names[c], self.seen, self.nt_per_class[c], *self.metrics.class_result(i)))
+                LOGGER.info(
+                    pf % (self.names[c], self.nt_per_image[c], self.nt_per_class[c], *self.metrics.class_result(i))
+                )
 
         if self.args.plots:
             for normalize in True, False:

{ultralytics-8.2.25 → ultralytics-8.2.27}/ultralytics/models/yolo/pose/val.py

@@ -81,7 +81,7 @@ class PoseValidator(DetectionValidator):
         is_pose = self.kpt_shape == [17, 3]
         nkpt = self.kpt_shape[0]
         self.sigma = OKS_SIGMA if is_pose else np.ones(nkpt) / nkpt
-        self.stats = dict(tp_p=[], tp=[], conf=[], pred_cls=[], target_cls=[])
+        self.stats = dict(tp_p=[], tp=[], conf=[], pred_cls=[], target_cls=[], target_img=[])
 
     def _prepare_batch(self, si, batch):
         """Prepares a batch for processing by converting keypoints to float and moving to device."""
@@ -118,6 +118,7 @@ class PoseValidator(DetectionValidator):
             cls, bbox = pbatch.pop("cls"), pbatch.pop("bbox")
             nl = len(cls)
             stat["target_cls"] = cls
+            stat["target_img"] = cls.unique()
             if npr == 0:
                 if nl:
                     for k in self.stats.keys():

{ultralytics-8.2.25 → ultralytics-8.2.27}/ultralytics/models/yolo/segment/val.py

@@ -51,7 +51,7 @@ class SegmentationValidator(DetectionValidator):
             self.process = ops.process_mask_upsample  # more accurate
         else:
             self.process = ops.process_mask  # faster
-        self.stats = dict(tp_m=[], tp=[], conf=[], pred_cls=[], target_cls=[])
+        self.stats = dict(tp_m=[], tp=[], conf=[], pred_cls=[], target_cls=[], target_img=[])
 
     def get_desc(self):
         """Return a formatted description of evaluation metrics."""
@@ -112,6 +112,7 @@ class SegmentationValidator(DetectionValidator):
             cls, bbox = pbatch.pop("cls"), pbatch.pop("bbox")
             nl = len(cls)
             stat["target_cls"] = cls
+            stat["target_img"] = cls.unique()
             if npr == 0:
                 if nl:
                     for k in self.stats.keys():

{ultralytics-8.2.25 → ultralytics-8.2.27}/ultralytics/nn/modules/__init__.py

@@ -13,7 +13,7 @@ Example:
     m = Conv(128, 128)
     f = f'{m._get_name()}.onnx'
     torch.onnx.export(m, x, f)
-    os.system(f'onnxsim {f} {f} && open {f}')
+    os.system(f'onnxslim {f} {f} && open {f}')  # pip install onnxslim
     ```
 """
 

{ultralytics-8.2.25 → ultralytics-8.2.27}/ultralytics/nn/tasks.py

@@ -425,11 +425,11 @@ class ClassificationModel(BaseModel):
         elif isinstance(m, nn.Sequential):
             types = [type(x) for x in m]
             if nn.Linear in types:
-                i = types.index(nn.Linear)  # nn.Linear index
+                i = len(types) - 1 - types[::-1].index(nn.Linear)  # last nn.Linear index
                 if m[i].out_features != nc:
                     m[i] = nn.Linear(m[i].in_features, nc)
             elif nn.Conv2d in types:
-                i = types.index(nn.Conv2d)  # nn.Conv2d index
+                i = len(types) - 1 - types[::-1].index(nn.Conv2d)  # last nn.Conv2d index
                 if m[i].out_channels != nc:
                     m[i] = nn.Conv2d(m[i].in_channels, nc, m[i].kernel_size, m[i].stride, bias=m[i].bias is not None)
 

{ultralytics-8.2.25 → ultralytics-8.2.27}/ultralytics/solutions/analytics.py

@@ -1,5 +1,6 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
+import warnings
 from itertools import cycle
 
 import cv2
@@ -27,6 +28,7 @@ class Analytics:
         fontsize=13,
         view_img=False,
         save_img=True,
+        max_points=50,
     ):
         """
         Initialize the Analytics class with various chart types.
@@ -45,6 +47,7 @@ class Analytics:
             fontsize (int): Font size for chart text.
             view_img (bool): Whether to display the image.
             save_img (bool): Whether to save the image.
+            max_points (int): Specifies when to remove the oldest points in a graph for multiple lines.
         """
 
         self.bg_color = bg_color
@@ -53,12 +56,14 @@ class Analytics:
         self.save_img = save_img
         self.title = title
         self.writer = writer
+        self.max_points = max_points
 
         # Set figure size based on image shape
         figsize = (im0_shape[0] / 100, im0_shape[1] / 100)
 
         if type == "line":
             # Initialize line plot
+            self.lines = {}
             fig = Figure(facecolor=self.bg_color, figsize=figsize)
             self.canvas = FigureCanvas(fig)
             self.ax = fig.add_subplot(111, facecolor=self.bg_color)
@@ -112,9 +117,53 @@ class Analytics:
         self.ax.autoscale_view()
         self.canvas.draw()
         im0 = np.array(self.canvas.renderer.buffer_rgba())
-        im0 = cv2.cvtColor(im0[:, :, :3], cv2.COLOR_RGBA2BGR)
+        self.write_and_display_line(im0)
 
-        # Display and save the updated graph
+    def update_multiple_lines(self, counts_dict, labels_list, frame_number):
+        """
+        Update the line graph with multiple classes.
+
+        Args:
+            counts_dict (int): Dictionary include each class counts.
+            labels_list (int): list include each classes names.
+            frame_number (int): The current frame number.
+        """
+        warnings.warn("Display is not supported for multiple lines, output will be stored normally!")
+        for obj in labels_list:
+            if obj not in self.lines:
+                (line,) = self.ax.plot([], [], label=obj, marker="o", markersize=15)
+                self.lines[obj] = line
+
+            x_data = self.lines[obj].get_xdata()
+            y_data = self.lines[obj].get_ydata()
+
+            # Remove the initial point if the number of points exceeds max_points
+            if len(x_data) >= self.max_points:
+                x_data = np.delete(x_data, 0)
+                y_data = np.delete(y_data, 0)
+
+            x_data = np.append(x_data, float(frame_number))  # Ensure frame_number is converted to float
+            y_data = np.append(y_data, float(counts_dict.get(obj, 0)))  # Ensure total_count is converted to float
+            self.lines[obj].set_data(x_data, y_data)
+
+        self.ax.relim()
+        self.ax.autoscale_view()
+        self.ax.legend()
+        self.canvas.draw()
+
+        im0 = np.array(self.canvas.renderer.buffer_rgba())
+        self.view_img = False  # for multiple line view_img not supported yet, coming soon!
+        self.write_and_display_line(im0)
+
+    def write_and_display_line(self, im0):
+        """
+        Write and display the line graph
+        Args:
+            im0 (ndarray): Image for processing
+        """
+
+        # convert image to BGR format
+        im0 = cv2.cvtColor(im0[:, :, :3], cv2.COLOR_RGBA2BGR)
         cv2.imshow(self.title, im0) if self.view_img else None
         self.writer.write(im0) if self.save_img else None
 

{ultralytics-8.2.25 → ultralytics-8.2.27}/ultralytics/utils/benchmarks.py

@@ -457,6 +457,8 @@ class ProfileModels:
 
         input_tensor = sess.get_inputs()[0]
         input_type = input_tensor.type
+        dynamic = not all(isinstance(dim, int) and dim >= 0 for dim in input_tensor.shape)  # dynamic input shape
+        input_shape = (1, 3, self.imgsz, self.imgsz) if dynamic else input_tensor.shape
 
         # Mapping ONNX datatype to numpy datatype
         if "float16" in input_type:
@@ -472,7 +474,7 @@ class ProfileModels:
         else:
             raise ValueError(f"Unsupported ONNX datatype {input_type}")
 
-        input_data = np.random.rand(*input_tensor.shape).astype(input_dtype)
+        input_data = np.random.rand(*input_shape).astype(input_dtype)
         input_name = input_tensor.name
         output_name = sess.get_outputs()[0].name
 

{ultralytics-8.2.25 → ultralytics-8.2.27}/ultralytics/utils/checks.py

@@ -33,6 +33,7 @@ from ultralytics.utils import (
     ROOT,
     TORCHVISION_VERSION,
     USER_CONFIG_DIR,
+    Retry,
     SimpleNamespace,
     ThreadingLocked,
     TryExcept,
@@ -381,6 +382,11 @@ def check_requirements(requirements=ROOT.parent / "requirements.txt", exclude=()
         except (AssertionError, metadata.PackageNotFoundError):
             pkgs.append(r)
 
+    @Retry(times=2, delay=1)
+    def attempt_install(packages, commands):
+        """Attempt pip install command with retries on failure."""
+        return subprocess.check_output(f"pip install --no-cache-dir {packages} {commands}", shell=True).decode()
+
     s = " ".join(f'"{x}"' for x in pkgs)  # console string
     if s:
         if install and AUTOINSTALL:  # check environment variable
@@ -389,7 +395,7 @@ def check_requirements(requirements=ROOT.parent / "requirements.txt", exclude=()
             try:
                 t = time.time()
                 assert ONLINE, "AutoUpdate skipped (offline)"
-                LOGGER.info(subprocess.check_output(f"pip install --no-cache-dir {s} {cmds}", shell=True).decode())
+                LOGGER.info(attempt_install(s, cmds))
                 dt = time.time() - t
                 LOGGER.info(
                     f"{prefix} AutoUpdate success ✅ {dt:.1f}s, installed {n} package{'s' * (n > 1)}: {pkgs}\n"

{ultralytics-8.2.25 → ultralytics-8.2.27}/ultralytics/utils/ops.py

@@ -518,59 +518,58 @@ def ltwh2xywh(x):
     return y
 
 
-def xyxyxyxy2xywhr(corners):
+def xyxyxyxy2xywhr(x):
     """
     Convert batched Oriented Bounding Boxes (OBB) from [xy1, xy2, xy3, xy4] to [xywh, rotation]. Rotation values are
     expected in degrees from 0 to 90.
 
     Args:
-        corners (numpy.ndarray | torch.Tensor): Input corners of shape (n, 8).
+        x (numpy.ndarray | torch.Tensor): Input box corners [xy1, xy2, xy3, xy4] of shape (n, 8).
 
     Returns:
         (numpy.ndarray | torch.Tensor): Converted data in [cx, cy, w, h, rotation] format of shape (n, 5).
     """
-    is_torch = isinstance(corners, torch.Tensor)
-    points = corners.cpu().numpy() if is_torch else corners
-    points = points.reshape(len(corners), -1, 2)
+    is_torch = isinstance(x, torch.Tensor)
+    points = x.cpu().numpy() if is_torch else x
+    points = points.reshape(len(x), -1, 2)
     rboxes = []
     for pts in points:
         # NOTE: Use cv2.minAreaRect to get accurate xywhr,
         # especially some objects are cut off by augmentations in dataloader.
-        (x, y), (w, h), angle = cv2.minAreaRect(pts)
-        rboxes.append([x, y, w, h, angle / 180 * np.pi])
-    return (
-        torch.tensor(rboxes, device=corners.device, dtype=corners.dtype)
-        if is_torch
-        else np.asarray(rboxes, dtype=points.dtype)
-    )  # rboxes
+        (cx, cy), (w, h), angle = cv2.minAreaRect(pts)
+        rboxes.append([cx, cy, w, h, angle / 180 * np.pi])
+    return torch.tensor(rboxes, device=x.device, dtype=x.dtype) if is_torch else np.asarray(rboxes)
 
 
-def xywhr2xyxyxyxy(rboxes):
+def xywhr2xyxyxyxy(x):
     """
     Convert batched Oriented Bounding Boxes (OBB) from [xywh, rotation] to [xy1, xy2, xy3, xy4]. Rotation values should
     be in degrees from 0 to 90.
 
     Args:
-        rboxes (numpy.ndarray | torch.Tensor): Boxes in [cx, cy, w, h, rotation] format of shape (n, 5) or (b, n, 5).
+        x (numpy.ndarray | torch.Tensor): Boxes in [cx, cy, w, h, rotation] format of shape (n, 5) or (b, n, 5).
 
     Returns:
         (numpy.ndarray | torch.Tensor): Converted corner points of shape (n, 4, 2) or (b, n, 4, 2).
     """
-    is_numpy = isinstance(rboxes, np.ndarray)
-    cos, sin = (np.cos, np.sin) if is_numpy else (torch.cos, torch.sin)
+    cos, sin, cat, stack = (
+        (torch.cos, torch.sin, torch.cat, torch.stack)
+        if isinstance(x, torch.Tensor)
+        else (np.cos, np.sin, np.concatenate, np.stack)
+    )
 
-    ctr = rboxes[..., :2]
-    w, h, angle = (rboxes[..., i : i + 1] for i in range(2, 5))
+    ctr = x[..., :2]
+    w, h, angle = (x[..., i : i + 1] for i in range(2, 5))
     cos_value, sin_value = cos(angle), sin(angle)
     vec1 = [w / 2 * cos_value, w / 2 * sin_value]
     vec2 = [-h / 2 * sin_value, h / 2 * cos_value]
-    vec1 = np.concatenate(vec1, axis=-1) if is_numpy else torch.cat(vec1, dim=-1)
-    vec2 = np.concatenate(vec2, axis=-1) if is_numpy else torch.cat(vec2, dim=-1)
+    vec1 = cat(vec1, -1)
+    vec2 = cat(vec2, -1)
     pt1 = ctr + vec1 + vec2
     pt2 = ctr + vec1 - vec2
     pt3 = ctr - vec1 - vec2
     pt4 = ctr - vec1 + vec2
-    return np.stack([pt1, pt2, pt3, pt4], axis=-2) if is_numpy else torch.stack([pt1, pt2, pt3, pt4], dim=-2)
+    return stack([pt1, pt2, pt3, pt4], -2)
 
 
 def ltwh2xyxy(x):
@@ -785,7 +784,7 @@ def regularize_rboxes(rboxes):
     Regularize rotated boxes in range [0, pi/2].
 
     Args:
-        rboxes (torch.Tensor): (N, 5), xywhr.
+        rboxes (torch.Tensor): Input boxes of shape(N, 5) in xywhr format.
 
     Returns:
         (torch.Tensor): The regularized boxes.

{ultralytics-8.2.25 → ultralytics-8.2.27}/ultralytics.egg-info/PKG-INFO

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