ultralytics 8.2.56__tar.gz → 8.2.58__tar.gz

{ultralytics-8.2.56/ultralytics.egg-info → ultralytics-8.2.58}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics
-Version: 8.2.56
+Version: 8.2.58
 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.58/tests/test_solutions.py

@@ -0,0 +1,90 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+import cv2
+import pytest
+
+from ultralytics import YOLO, solutions
+from ultralytics.utils.downloads import safe_download
+
+MAJOR_SOLUTIONS_DEMO = "https://github.com/ultralytics/assets/releases/download/v0.0.0/solutions_ci_demo.mp4"
+WORKOUTS_SOLUTION_DEMO = "https://github.com/ultralytics/assets/releases/download/v0.0.0/solution_ci_pose_demo.mp4"
+
+
+@pytest.mark.slow
+def test_major_solutions():
+    """Test the object counting, heatmap, speed estimation and queue management solution."""
+
+    safe_download(url=MAJOR_SOLUTIONS_DEMO)
+    model = YOLO("yolov8n.pt")
+    names = model.names
+    cap = cv2.VideoCapture("solutions_ci_demo.mp4")
+    assert cap.isOpened(), "Error reading video file"
+    region_points = [(20, 400), (1080, 404), (1080, 360), (20, 360)]
+    counter = solutions.ObjectCounter(reg_pts=region_points, names=names, view_img=False)
+    heatmap = solutions.Heatmap(colormap=cv2.COLORMAP_PARULA, names=names, view_img=False)
+    speed = solutions.SpeedEstimator(reg_pts=region_points, names=names, view_img=False)
+    queue = solutions.QueueManager(names=names, reg_pts=region_points, view_img=False)
+    while cap.isOpened():
+        success, im0 = cap.read()
+        if not success:
+            break
+        original_im0 = im0.copy()
+        tracks = model.track(im0, persist=True, show=False)
+        _ = counter.start_counting(original_im0.copy(), tracks)
+        _ = heatmap.generate_heatmap(original_im0.copy(), tracks)
+        _ = speed.estimate_speed(original_im0.copy(), tracks)
+        _ = queue.process_queue(original_im0.copy(), tracks)
+    cap.release()
+    cv2.destroyAllWindows()
+
+
+@pytest.mark.slow
+def test_aigym():
+    """Test the workouts monitoring solution."""
+
+    safe_download(url=WORKOUTS_SOLUTION_DEMO)
+    model = YOLO("yolov8n-pose.pt")
+    cap = cv2.VideoCapture("solution_ci_pose_demo.mp4")
+    assert cap.isOpened(), "Error reading video file"
+    gym_object = solutions.AIGym(line_thickness=2, pose_type="squat", kpts_to_check=[5, 11, 13])
+    while cap.isOpened():
+        success, im0 = cap.read()
+        if not success:
+            break
+        results = model.track(im0, verbose=False)
+        _ = gym_object.start_counting(im0, results)
+    cap.release()
+    cv2.destroyAllWindows()
+
+
+@pytest.mark.slow
+def test_instance_segmentation():
+    """Test the instance segmentation solution."""
+
+    from ultralytics.utils.plotting import Annotator, colors
+
+    model = YOLO("yolov8n-seg.pt")
+    names = model.names
+    cap = cv2.VideoCapture("solutions_ci_demo.mp4")
+    assert cap.isOpened(), "Error reading video file"
+    while cap.isOpened():
+        success, im0 = cap.read()
+        if not success:
+            break
+        results = model.predict(im0)
+        annotator = Annotator(im0, line_width=2)
+        if results[0].masks is not None:
+            clss = results[0].boxes.cls.cpu().tolist()
+            masks = results[0].masks.xy
+            for mask, cls in zip(masks, clss):
+                color = colors(int(cls), True)
+                annotator.seg_bbox(mask=mask, mask_color=color, label=names[int(cls)])
+    cap.release()
+    cv2.destroyAllWindows()
+
+
+@pytest.mark.slow
+def test_streamlit_predict():
+    """Test streamlit predict live inference solution."""
+
+    solutions.inference()

{ultralytics-8.2.56 → ultralytics-8.2.58}/ultralytics/__init__.py

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

{ultralytics-8.2.56 → ultralytics-8.2.58}/ultralytics/cfg/__init__.py

@@ -512,14 +512,14 @@ def handle_yolo_settings(args: List[str]) -> None:
 
 def handle_explorer():
     """Open the Ultralytics Explorer GUI for dataset exploration and analysis."""
-    checks.check_requirements("streamlit")
+    checks.check_requirements("streamlit>=1.29.0")
     LOGGER.info("💡 Loading Explorer dashboard...")
     subprocess.run(["streamlit", "run", ROOT / "data/explorer/gui/dash.py", "--server.maxMessageSize", "2048"])
 
 
 def handle_streamlit_inference():
     """Open the Ultralytics Live Inference streamlit app for real time object detection."""
-    checks.check_requirements(["streamlit", "opencv-python", "torch"])
+    checks.check_requirements("streamlit>=1.29.0")
     LOGGER.info("💡 Loading Ultralytics Live Inference app...")
     subprocess.run(["streamlit", "run", ROOT / "solutions/streamlit_inference.py", "--server.headless", "true"])
 

{ultralytics-8.2.56 → ultralytics-8.2.58}/ultralytics/data/dataset.py

@@ -15,7 +15,7 @@ from torch.utils.data import ConcatDataset
 
 from ultralytics.utils import LOCAL_RANK, NUM_THREADS, TQDM, colorstr
 from ultralytics.utils.ops import resample_segments
-from ultralytics.utils.torch_utils import TORCH_1_13
+from ultralytics.utils.torch_utils import TORCHVISION_0_18
 
 from .augment import (
     Compose,
@@ -417,7 +417,7 @@ class ClassificationDataset:
         import torchvision  # scope for faster 'import ultralytics'
 
         # Base class assigned as attribute rather than used as base class to allow for scoping slow torchvision import
-        if TORCH_1_13:  # 'allow_empty' argument first introduced in torch 1.13
+        if TORCHVISION_0_18:  # 'allow_empty' argument first introduced in torchvision 0.18
             self.base = torchvision.datasets.ImageFolder(root=root, allow_empty=True)
         else:
             self.base = torchvision.datasets.ImageFolder(root=root)

{ultralytics-8.2.56 → ultralytics-8.2.58}/ultralytics/engine/model.py

@@ -311,11 +311,13 @@ class Model(nn.Module):
             AssertionError: If the model is not a PyTorch model.
         """
         self._check_is_pytorch_model()
+        from copy import deepcopy
         from datetime import datetime
 
         from ultralytics import __version__
 
         updates = {
+            "model": deepcopy(self.model).half() if isinstance(self.model, nn.Module) else self.model,
             "date": datetime.now().isoformat(),
             "version": __version__,
             "license": "AGPL-3.0 License (https://ultralytics.com/license)",

{ultralytics-8.2.56 → ultralytics-8.2.58}/ultralytics/models/fastsam/prompt.py

@@ -7,6 +7,7 @@ import cv2
 import numpy as np
 import torch
 from PIL import Image
+from torch import Tensor
 
 from ultralytics.utils import TQDM, checks
 
@@ -249,7 +250,7 @@ class FastSAMPrompt:
         ax.imshow(show)
 
     @torch.no_grad()
-    def retrieve(self, model, preprocess, elements, search_text: str, device) -> int:
+    def retrieve(self, model, preprocess, elements, search_text: str, device) -> Tensor:
         """Processes images and text with a model, calculates similarity, and returns softmax score."""
         preprocessed_images = [preprocess(image).to(device) for image in elements]
         tokenized_text = self.clip.tokenize([search_text]).to(device)
@@ -269,19 +270,16 @@ class FastSAMPrompt:
         mask_h, mask_w = annotations[0]["segmentation"].shape
         if ori_w != mask_w or ori_h != mask_h:
             image = image.resize((mask_w, mask_h))
-        cropped_boxes = []
         cropped_images = []
-        not_crop = []
         filter_id = []
         for _, mask in enumerate(annotations):
             if np.sum(mask["segmentation"]) <= 100:
                 filter_id.append(_)
                 continue
             bbox = self._get_bbox_from_mask(mask["segmentation"])  # bbox from mask
-            cropped_boxes.append(self._segment_image(image, bbox))  # save cropped image
-            cropped_images.append(bbox)  # save cropped image bbox
+            cropped_images.append(self._segment_image(image, bbox))  # save cropped image
 
-        return cropped_boxes, cropped_images, not_crop, filter_id, annotations
+        return cropped_images, filter_id, annotations
 
     def box_prompt(self, bbox):
         """Modifies the bounding box properties and calculates IoU between masks and bounding box."""
@@ -341,11 +339,10 @@ class FastSAMPrompt:
         """Processes a text prompt, applies it to existing results and returns the updated results."""
         if self.results[0].masks is not None:
             format_results = self._format_results(self.results[0], 0)
-            cropped_boxes, cropped_images, not_crop, filter_id, annotations = self._crop_image(format_results)
+            cropped_images, filter_id, annotations = self._crop_image(format_results)
             clip_model, preprocess = self.clip.load("ViT-B/32", device=self.device)
-            scores = self.retrieve(clip_model, preprocess, cropped_boxes, text, device=self.device)
-            max_idx = scores.argsort()
-            max_idx = max_idx[-1]
+            scores = self.retrieve(clip_model, preprocess, cropped_images, text, device=self.device)
+            max_idx = torch.argmax(scores)
             max_idx += sum(np.array(filter_id) <= int(max_idx))
             self.results[0].masks.data = torch.tensor(np.array([annotations[max_idx]["segmentation"]]))
         return self.results

{ultralytics-8.2.56 → ultralytics-8.2.58}/ultralytics/models/yolo/detect/val.py

@@ -202,13 +202,18 @@ class DetectionValidator(BaseValidator):
         Return correct prediction matrix.
 
         Args:
-            detections (torch.Tensor): Tensor of shape [N, 6] representing detections.
-                Each detection is of the format: x1, y1, x2, y2, conf, class.
-            labels (torch.Tensor): Tensor of shape [M, 5] representing labels.
-                Each label is of the format: class, x1, y1, x2, y2.
+            detections (torch.Tensor): Tensor of shape (N, 6) representing detections where each detection is
+                (x1, y1, x2, y2, conf, class).
+            gt_bboxes (torch.Tensor): Tensor of shape (M, 4) representing ground-truth bounding box coordinates. Each
+                bounding box is of the format: (x1, y1, x2, y2).
+            gt_cls (torch.Tensor): Tensor of shape (M,) representing target class indices.
 
         Returns:
-            (torch.Tensor): Correct prediction matrix of shape [N, 10] for 10 IoU levels.
+            (torch.Tensor): Correct prediction matrix of shape (N, 10) for 10 IoU levels.
+
+        Note:
+            The function does not return any value directly usable for metrics calculation. Instead, it provides an
+            intermediate representation used for evaluating predictions against ground truth.
         """
         iou = box_iou(gt_bboxes, detections[:, :4])
         return self.match_predictions(detections[:, 5], gt_cls, iou)

{ultralytics-8.2.56 → ultralytics-8.2.58}/ultralytics/models/yolo/obb/val.py

@@ -52,17 +52,29 @@ class OBBValidator(DetectionValidator):
 
     def _process_batch(self, detections, gt_bboxes, gt_cls):
         """
-        Return correct prediction matrix.
+        Perform computation of the correct prediction matrix for a batch of detections and ground truth bounding boxes.
 
         Args:
-            detections (torch.Tensor): Tensor of shape [N, 7] representing detections.
-                Each detection is of the format: x1, y1, x2, y2, conf, class, angle.
-            gt_bboxes (torch.Tensor): Tensor of shape [M, 5] representing rotated boxes.
-                Each box is of the format: x1, y1, x2, y2, angle.
-            labels (torch.Tensor): Tensor of shape [M] representing labels.
+            detections (torch.Tensor): A tensor of shape (N, 7) representing the detected bounding boxes and associated
+                data. Each detection is represented as (x1, y1, x2, y2, conf, class, angle).
+            gt_bboxes (torch.Tensor): A tensor of shape (M, 5) representing the ground truth bounding boxes. Each box is
+                represented as (x1, y1, x2, y2, angle).
+            gt_cls (torch.Tensor): A tensor of shape (M,) representing class labels for the ground truth bounding boxes.
 
         Returns:
-            (torch.Tensor): Correct prediction matrix of shape [N, 10] for 10 IoU levels.
+            (torch.Tensor): The correct prediction matrix with shape (N, 10), which includes 10 IoU (Intersection over
+                Union) levels for each detection, indicating the accuracy of predictions compared to the ground truth.
+
+        Example:
+            ```python
+            detections = torch.rand(100, 7)  # 100 sample detections
+            gt_bboxes = torch.rand(50, 5)  # 50 sample ground truth boxes
+            gt_cls = torch.randint(0, 5, (50,))  # 50 ground truth class labels
+            correct_matrix = OBBValidator._process_batch(detections, gt_bboxes, gt_cls)
+            ```
+
+        Note:
+            This method relies on `batch_probiou` to calculate IoU between detections and ground truth bounding boxes.
         """
         iou = batch_probiou(gt_bboxes, torch.cat([detections[:, :4], detections[:, -1:]], dim=-1))
         return self.match_predictions(detections[:, 5], gt_cls, iou)

{ultralytics-8.2.56 → ultralytics-8.2.58}/ultralytics/models/yolo/pose/val.py

@@ -152,19 +152,34 @@ class PoseValidator(DetectionValidator):
 
     def _process_batch(self, detections, gt_bboxes, gt_cls, pred_kpts=None, gt_kpts=None):
         """
-        Return correct prediction matrix.
+        Return correct prediction matrix by computing Intersection over Union (IoU) between detections and ground truth.
 
         Args:
-            detections (torch.Tensor): Tensor of shape [N, 6] representing detections.
-                Each detection is of the format: x1, y1, x2, y2, conf, class.
-            labels (torch.Tensor): Tensor of shape [M, 5] representing labels.
-                Each label is of the format: class, x1, y1, x2, y2.
-            pred_kpts (torch.Tensor, optional): Tensor of shape [N, 51] representing predicted keypoints.
-                51 corresponds to 17 keypoints each with 3 values.
-            gt_kpts (torch.Tensor, optional): Tensor of shape [N, 51] representing ground truth keypoints.
+            detections (torch.Tensor): Tensor with shape (N, 6) representing detection boxes and scores, where each
+                detection is of the format (x1, y1, x2, y2, conf, class).
+            gt_bboxes (torch.Tensor): Tensor with shape (M, 4) representing ground truth bounding boxes, where each
+                box is of the format (x1, y1, x2, y2).
+            gt_cls (torch.Tensor): Tensor with shape (M,) representing ground truth class indices.
+            pred_kpts (torch.Tensor | None): Optional tensor with shape (N, 51) representing predicted keypoints, where
+                51 corresponds to 17 keypoints each having 3 values.
+            gt_kpts (torch.Tensor | None): Optional tensor with shape (N, 51) representing ground truth keypoints.
 
         Returns:
-            torch.Tensor: Correct prediction matrix of shape [N, 10] for 10 IoU levels.
+            torch.Tensor: A tensor with shape (N, 10) representing the correct prediction matrix for 10 IoU levels,
+                where N is the number of detections.
+
+        Example:
+            ```python
+            detections = torch.rand(100, 6)  # 100 predictions: (x1, y1, x2, y2, conf, class)
+            gt_bboxes = torch.rand(50, 4)  # 50 ground truth boxes: (x1, y1, x2, y2)
+            gt_cls = torch.randint(0, 2, (50,))  # 50 ground truth class indices
+            pred_kpts = torch.rand(100, 51)  # 100 predicted keypoints
+            gt_kpts = torch.rand(50, 51)  # 50 ground truth keypoints
+            correct_preds = _process_batch(detections, gt_bboxes, gt_cls, pred_kpts, gt_kpts)
+            ```
+
+        Note:
+            `0.53` scale factor used in area computation is referenced from https://github.com/jin-s13/xtcocoapi/blob/master/xtcocotools/cocoeval.py#L384.
         """
         if pred_kpts is not None and gt_kpts is not None:
             # `0.53` is from https://github.com/jin-s13/xtcocoapi/blob/master/xtcocotools/cocoeval.py#L384

{ultralytics-8.2.56 → ultralytics-8.2.58}/ultralytics/models/yolo/segment/val.py

@@ -164,14 +164,34 @@ class SegmentationValidator(DetectionValidator):
 
     def _process_batch(self, detections, gt_bboxes, gt_cls, pred_masks=None, gt_masks=None, overlap=False, masks=False):
         """
-        Return correct prediction matrix.
+        Compute correct prediction matrix for a batch based on bounding boxes and optional masks.
 
         Args:
-            detections (array[N, 6]), x1, y1, x2, y2, conf, class
-            labels (array[M, 5]), class, x1, y1, x2, y2
+            detections (torch.Tensor): Tensor of shape (N, 6) representing detected bounding boxes and
+                associated confidence scores and class indices. Each row is of the format [x1, y1, x2, y2, conf, class].
+            gt_bboxes (torch.Tensor): Tensor of shape (M, 4) representing ground truth bounding box coordinates.
+                Each row is of the format [x1, y1, x2, y2].
+            gt_cls (torch.Tensor): Tensor of shape (M,) representing ground truth class indices.
+            pred_masks (torch.Tensor | None): Tensor representing predicted masks, if available. The shape should
+                match the ground truth masks.
+            gt_masks (torch.Tensor | None): Tensor of shape (M, H, W) representing ground truth masks, if available.
+            overlap (bool): Flag indicating if overlapping masks should be considered.
+            masks (bool): Flag indicating if the batch contains mask data.
 
         Returns:
-            correct (array[N, 10]), for 10 IoU levels
+            (torch.Tensor): A correct prediction matrix of shape (N, 10), where 10 represents different IoU levels.
+
+        Note:
+            - If `masks` is True, the function computes IoU between predicted and ground truth masks.
+            - If `overlap` is True and `masks` is True, overlapping masks are taken into account when computing IoU.
+
+        Example:
+            ```python
+            detections = torch.tensor([[25, 30, 200, 300, 0.8, 1], [50, 60, 180, 290, 0.75, 0]])
+            gt_bboxes = torch.tensor([[24, 29, 199, 299], [55, 65, 185, 295]])
+            gt_cls = torch.tensor([1, 0])
+            correct_preds = validator._process_batch(detections, gt_bboxes, gt_cls)
+            ```
         """
         if masks:
             if overlap:

{ultralytics-8.2.56 → ultralytics-8.2.58}/ultralytics/solutions/distance_calculation.py

@@ -24,7 +24,7 @@ class DistanceCalculation:
         Initializes the DistanceCalculation class with the given parameters.
 
         Args:
-            names (dict): Dictionary mapping class indices to class names.
+            names (dict): Dictionary of classes names.
             pixels_per_meter (int, optional): Conversion factor from pixels to meters. Defaults to 10.
             view_img (bool, optional): Flag to indicate if the video stream should be displayed. Defaults to False.
             line_thickness (int, optional): Thickness of the lines drawn on the image. Defaults to 2.

{ultralytics-8.2.56 → ultralytics-8.2.58}/ultralytics/solutions/heatmap.py

@@ -18,7 +18,7 @@ class Heatmap:
 
     def __init__(
         self,
-        classes_names,
+        names,
         imw=0,
         imh=0,
         colormap=cv2.COLORMAP_JET,
@@ -44,7 +44,7 @@ class Heatmap:
         self.shape = shape
 
         self.initialized = False
-        self.names = classes_names  # Classes names
+        self.names = names  # Classes names
 
         # Image information
         self.imw = imw

{ultralytics-8.2.56 → ultralytics-8.2.58}/ultralytics/solutions/object_counter.py

@@ -17,7 +17,7 @@ class ObjectCounter:
 
     def __init__(
         self,
-        classes_names,
+        names,
         reg_pts=None,
         count_reg_color=(255, 0, 255),
         count_txt_color=(0, 0, 0),
@@ -37,7 +37,7 @@ class ObjectCounter:
         Initializes the ObjectCounter with various tracking and counting parameters.
 
         Args:
-            classes_names (dict): Dictionary of class names.
+            names (dict): Dictionary of class names.
             reg_pts (list): List of points defining the counting region.
             count_reg_color (tuple): RGB color of the counting region.
             count_txt_color (tuple): RGB color of the count text.
@@ -72,7 +72,7 @@ class ObjectCounter:
         self.view_in_counts = view_in_counts
         self.view_out_counts = view_out_counts
 
-        self.names = classes_names  # Classes names
+        self.names = names  # Classes names
         self.annotator = None  # Annotator
         self.window_name = "Ultralytics YOLOv8 Object Counter"
 

{ultralytics-8.2.56 → ultralytics-8.2.58}/ultralytics/solutions/parking_management.py

@@ -1,11 +1,9 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
 import json
-from tkinter import filedialog, messagebox
 
 import cv2
 import numpy as np
-from PIL import Image, ImageTk
 
 from ultralytics.utils.checks import check_imshow, check_requirements
 from ultralytics.utils.plotting import Annotator
@@ -16,7 +14,7 @@ class ParkingPtsSelection:
         """Initializes the UI for selecting parking zone points in a tkinter window."""
         check_requirements("tkinter")
 
-        import tkinter as tk
+        import tkinter as tk  # scope for multi-environment compatibility
 
         self.tk = tk
         self.master = tk.Tk()
@@ -55,6 +53,10 @@ class ParkingPtsSelection:
 
     def upload_image(self):
         """Upload an image and resize it to fit canvas."""
+        from tkinter import filedialog
+
+        from PIL import Image, ImageTk  # scope because ImageTk requires tkinter package
+
         self.image_path = filedialog.askopenfilename(filetypes=[("Image Files", "*.png;*.jpg;*.jpeg")])
         if not self.image_path:
             return
@@ -115,6 +117,8 @@ class ParkingPtsSelection:
 
     def remove_last_bounding_box(self):
         """Remove the last drawn bounding box from canvas."""
+        from tkinter import messagebox  # scope for multi-environment compatibility
+
         if self.bounding_boxes:
             self.bounding_boxes.pop()  # Remove the last bounding box
             self.canvas.delete("all")  # Clear the canvas
@@ -130,6 +134,8 @@ class ParkingPtsSelection:
 
     def save_to_json(self):
         """Saves rescaled bounding boxes to 'bounding_boxes.json' based on image-to-canvas size ratio."""
+        from tkinter import messagebox  # scope for multi-environment compatibility
+
         canvas_width, canvas_height = self.canvas.winfo_width(), self.canvas.winfo_height()
         width_scaling_factor = self.img_width / canvas_width
         height_scaling_factor = self.img_height / canvas_height
@@ -141,8 +147,8 @@ class ParkingPtsSelection:
                 rescaled_y = int(y * height_scaling_factor)
                 rescaled_box.append((rescaled_x, rescaled_y))
             bounding_boxes_data.append({"points": rescaled_box})
-        with open("bounding_boxes.json", "w") as json_file:
-            json.dump(bounding_boxes_data, json_file, indent=4)
+        with open("bounding_boxes.json", "w") as f:
+            json.dump(bounding_boxes_data, f, indent=4)
 
         messagebox.showinfo("Success", "Bounding boxes saved to bounding_boxes.json")
 
@@ -187,11 +193,10 @@ class ParkingManagement:
         self.env_check = check_imshow(warn=True)
 
     def load_model(self):
-        """Load the Ultralytics YOLOv8 model for inference and analytics."""
+        """Load the Ultralytics YOLO model for inference and analytics."""
         from ultralytics import YOLO
 
-        self.model = YOLO(self.model_path)
-        return self.model
+        return YOLO(self.model_path)
 
     @staticmethod
     def parking_regions_extraction(json_file):
@@ -201,8 +206,8 @@ class ParkingManagement:
         Args:
             json_file (str): file that have all parking slot points
         """
-        with open(json_file, "r") as json_file:
-            return json.load(json_file)
+        with open(json_file, "r") as f:
+            return json.load(f)
 
     def process_data(self, json_data, im0, boxes, clss):
         """
@@ -219,12 +224,9 @@ class ParkingManagement:
             empty_slots (int): total slots that are available in parking lot
         """
         annotator = Annotator(im0)
-        total_slots, filled_slots = len(json_data), 0
-        empty_slots = total_slots
-
+        empty_slots, filled_slots = len(json_data), 0
         for region in json_data:
-            points = region["points"]
-            points_array = np.array(points, dtype=np.int32).reshape((-1, 1, 2))
+            points_array = np.array(region["points"], dtype=np.int32).reshape((-1, 1, 2))
             region_occupied = False
 
             for box, cls in zip(boxes, clss):

{ultralytics-8.2.56 → ultralytics-8.2.58}/ultralytics/solutions/queue_management.py

@@ -17,7 +17,7 @@ class QueueManager:
 
     def __init__(
         self,
-        classes_names,
+        names,
         reg_pts=None,
         line_thickness=2,
         track_thickness=2,
@@ -34,7 +34,7 @@ class QueueManager:
         Initializes the QueueManager with specified parameters for tracking and counting objects.
 
         Args:
-            classes_names (dict): A dictionary mapping class IDs to class names.
+            names (dict): A dictionary mapping class IDs to class names.
             reg_pts (list of tuples, optional): Points defining the counting region polygon. Defaults to a predefined
                 rectangle.
             line_thickness (int, optional): Thickness of the annotation lines. Defaults to 2.
@@ -69,7 +69,7 @@ class QueueManager:
         self.view_queue_counts = view_queue_counts
         self.fontsize = fontsize
 
-        self.names = classes_names  # Class names
+        self.names = names  # Class names
         self.annotator = None  # Annotator
         self.window_name = "Ultralytics YOLOv8 Queue Manager"
 
@@ -139,7 +139,7 @@ class QueueManager:
 
     def display_frames(self):
         """Displays the current frame with annotations."""
-        if self.env_check:
+        if self.env_check and self.view_img:
             self.annotator.draw_region(reg_pts=self.reg_pts, thickness=self.region_thickness, color=self.region_color)
             cv2.namedWindow(self.window_name)
             cv2.imshow(self.window_name, self.im0)

{ultralytics-8.2.56 → ultralytics-8.2.58}/ultralytics/solutions/streamlit_inference.py

@@ -6,13 +6,13 @@ import time
 import cv2
 import torch
 
+from ultralytics.utils.checks import check_requirements
 from ultralytics.utils.downloads import GITHUB_ASSETS_STEMS
 
 
 def inference():
     """Runs real-time object detection on video input using Ultralytics YOLOv8 in a Streamlit application."""
-
-    # Scope imports for faster ultralytics package load speeds
+    check_requirements("streamlit>=1.29.0")  # scope imports for faster ultralytics package load speeds
     import streamlit as st
 
     from ultralytics import YOLO

{ultralytics-8.2.56 → ultralytics-8.2.58}/ultralytics/utils/plotting.py

@@ -726,20 +726,18 @@ class Annotator:
         )
         cv2.putText(self.im, stage_text, stage_text_position, 0, self.sf, txt_color, self.tf)
 
-    def seg_bbox(self, mask, mask_color=(255, 0, 255), det_label=None, track_label=None):
+    def seg_bbox(self, mask, mask_color=(255, 0, 255), label=None, txt_color=(255, 255, 255)):
         """
         Function for drawing segmented object in bounding box shape.
 
         Args:
             mask (list): masks data list for instance segmentation area plotting
-            mask_color (tuple): mask foreground color
-            det_label (str): Detection label text
-            track_label (str): Tracking label text
+            mask_color (RGB): mask foreground color
+            label (str): Detection label text
+            txt_color (RGB): text color
         """
 
         cv2.polylines(self.im, [np.int32([mask])], isClosed=True, color=mask_color, thickness=2)
-
-        label = f"Track ID: {track_label}" if track_label else det_label
         text_size, _ = cv2.getTextSize(label, 0, self.sf, self.tf)
 
         cv2.rectangle(
@@ -750,9 +748,10 @@ class Annotator:
             -1,
         )
 
-        cv2.putText(
-            self.im, label, (int(mask[0][0]) - text_size[0] // 2, int(mask[0][1])), 0, self.sf, (255, 255, 255), self.tf
-        )
+        if label:
+            cv2.putText(
+                self.im, label, (int(mask[0][0]) - text_size[0] // 2, int(mask[0][1])), 0, self.sf, txt_color, self.tf
+            )
 
     def plot_distance_and_line(self, distance_m, distance_mm, centroids, line_color, centroid_color):
         """

{ultralytics-8.2.56 → ultralytics-8.2.58}/ultralytics/utils/torch_utils.py

@@ -40,6 +40,7 @@ TORCH_2_0 = check_version(torch.__version__, "2.0.0")
 TORCHVISION_0_10 = check_version(TORCHVISION_VERSION, "0.10.0")
 TORCHVISION_0_11 = check_version(TORCHVISION_VERSION, "0.11.0")
 TORCHVISION_0_13 = check_version(TORCHVISION_VERSION, "0.13.0")
+TORCHVISION_0_18 = check_version(TORCHVISION_VERSION, "0.18.0")
 
 
 @contextmanager

{ultralytics-8.2.56 → ultralytics-8.2.58/ultralytics.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics
-Version: 8.2.56
+Version: 8.2.58
 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.56 → ultralytics-8.2.58}/ultralytics.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ tests/test_explorer.py
 tests/test_exports.py
 tests/test_integrations.py
 tests/test_python.py
+tests/test_solutions.py
 ultralytics/__init__.py
 ultralytics.egg-info/PKG-INFO
 ultralytics.egg-info/SOURCES.txt
@@ -24,6 +25,7 @@ ultralytics/../tests/test_explorer.py
 ultralytics/../tests/test_exports.py
 ultralytics/../tests/test_integrations.py
 ultralytics/../tests/test_python.py
+ultralytics/../tests/test_solutions.py
 ultralytics/assets/bus.jpg
 ultralytics/assets/zidane.jpg
 ultralytics/cfg/__init__.py