ultralytics 8.1.42__py3-none-any.whl → 8.1.43__py3-none-any.whl

ultralytics/solutions/heatmap.py

@@ -30,6 +30,7 @@ class Heatmap:
         self.imw = None
         self.imh = None
         self.im0 = None
+        self.tf = 2
         self.view_in_counts = True
         self.view_out_counts = True
 
@@ -56,11 +57,9 @@ class Heatmap:
         self.out_counts = 0
         self.count_ids = []
         self.class_wise_count = {}
-        self.count_txt_thickness = 0
-        self.count_txt_color = (255, 255, 255)
-        self.line_color = (255, 255, 255)
+        self.count_txt_color = (0, 0, 0)
+        self.count_bg_color = (255, 255, 255)
         self.cls_txtdisplay_gap = 50
-        self.fontsize = 0.6
 
         # Decay factor
         self.decay_factor = 0.99
@@ -79,16 +78,14 @@ class Heatmap:
         view_in_counts=True,
         view_out_counts=True,
         count_reg_pts=None,
-        count_txt_thickness=2,
-        count_txt_color=(255, 255, 255),
-        fontsize=0.8,
-        line_color=(255, 255, 255),
+        count_txt_color=(0, 0, 0),
+        count_bg_color=(255, 255, 255),
         count_reg_color=(255, 0, 255),
         region_thickness=5,
         line_dist_thresh=15,
+        line_thickness=2,
         decay_factor=0.99,
         shape="circle",
-        cls_txtdisplay_gap=50,
     ):
         """
         Configures the heatmap colormap, width, height and display parameters.
@@ -98,22 +95,21 @@ class Heatmap:
             imw (int): The width of the frame.
             imh (int): The height of the frame.
             classes_names (dict): Classes names
+            line_thickness (int): Line thickness for bounding boxes.
             heatmap_alpha (float): alpha value for heatmap display
             view_img (bool): Flag indicating frame display
             view_in_counts (bool): Flag to control whether to display the incounts on video stream.
             view_out_counts (bool): Flag to control whether to display the outcounts on video stream.
             count_reg_pts (list): Object counting region points
-            count_txt_thickness (int): Text thickness for object counting display
             count_txt_color (RGB color): count text color value
-            fontsize (float): Text display font size
-            line_color (RGB color): count highlighter line color
+            count_bg_color (RGB color): count highlighter line color
             count_reg_color (RGB color): Color of object counting region
             region_thickness (int): Object counting Region thickness
             line_dist_thresh (int): Euclidean Distance threshold for line counter
             decay_factor (float): value for removing heatmap area after object passed
             shape (str): Heatmap shape, rect or circle shape supported
-            cls_txtdisplay_gap (int): Display gap between each class count
         """
+        self.tf = line_thickness
         self.names = classes_names
         self.imw = imw
         self.imh = imh
@@ -141,16 +137,13 @@ class Heatmap:
         # Heatmap new frame
         self.heatmap = np.zeros((int(self.imh), int(self.imw)), dtype=np.float32)
 
-        self.count_txt_thickness = count_txt_thickness
         self.count_txt_color = count_txt_color
-        self.fontsize = fontsize
-        self.line_color = line_color
+        self.count_bg_color = count_bg_color
         self.region_color = count_reg_color
         self.region_thickness = region_thickness
         self.decay_factor = decay_factor
         self.line_dist_thresh = line_dist_thresh
         self.shape = shape
-        self.cls_txtdisplay_gap = cls_txtdisplay_gap
 
         # shape of heatmap, if not selected
         if self.shape not in {"circle", "rect"}:
@@ -185,7 +178,7 @@ class Heatmap:
             return im0
         self.heatmap *= self.decay_factor  # decay factor
         self.extract_results(tracks)
-        self.annotator = Annotator(self.im0, self.count_txt_thickness, None)
+        self.annotator = Annotator(self.im0, self.tf, None)
 
         if self.count_reg_pts is not None:
             # Draw counting region
@@ -239,11 +232,8 @@ class Heatmap:
 
                 # Count objects using line
                 elif len(self.count_reg_pts) == 2:
-                    is_inside = (box[0] - prev_position[0]) * (self.counting_region.centroid.x - prev_position[0]) > 0
-
-                    if prev_position is not None and is_inside and track_id not in self.count_ids:
+                    if prev_position is not None and track_id not in self.count_ids:
                         distance = Point(track_line[-1]).distance(self.counting_region)
-
                         if distance < self.line_dist_thresh and track_id not in self.count_ids:
                             self.count_ids.append(track_id)
 
@@ -293,11 +283,8 @@ class Heatmap:
         if self.count_reg_pts is not None and label is not None:
             self.annotator.display_counts(
                 counts=label,
-                tf=self.count_txt_thickness,
-                fontScale=self.fontsize,
-                txt_color=self.count_txt_color,
-                line_color=self.line_color,
-                classwise_txtgap=self.cls_txtdisplay_gap,
+                count_txt_color=self.count_txt_color,
+                count_bg_color=self.count_bg_color,
             )
 
         self.im0 = cv2.addWeighted(self.im0, 1 - self.heatmap_alpha, heatmap_colored, self.heatmap_alpha, 0)

ultralytics/solutions/object_counter.py

@@ -1,7 +1,6 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
 from collections import defaultdict
-
 import cv2
 
 from ultralytics.utils.checks import check_imshow, check_requirements
@@ -47,7 +46,7 @@ class ObjectCounter:
         self.class_wise_count = {}
         self.count_txt_thickness = 0
         self.count_txt_color = (255, 255, 255)
-        self.line_color = (255, 255, 255)
+        self.count_bg_color = (255, 255, 255)
         self.cls_txtdisplay_gap = 50
         self.fontsize = 0.6
 
@@ -65,16 +64,14 @@ class ObjectCounter:
         classes_names,
         reg_pts,
         count_reg_color=(255, 0, 255),
+        count_txt_color=(0, 0, 0),
+        count_bg_color=(255, 255, 255),
         line_thickness=2,
         track_thickness=2,
         view_img=False,
         view_in_counts=True,
         view_out_counts=True,
         draw_tracks=False,
-        count_txt_thickness=3,
-        count_txt_color=(255, 255, 255),
-        fontsize=0.8,
-        line_color=(255, 255, 255),
         track_color=None,
         region_thickness=5,
         line_dist_thresh=15,
@@ -92,10 +89,8 @@ class ObjectCounter:
             classes_names (dict): Classes names
             track_thickness (int): Track thickness
             draw_tracks (Bool): draw tracks
-            count_txt_thickness (int): Text thickness for object counting display
             count_txt_color (RGB color): count text color value
-            fontsize (float): Text display font size
-            line_color (RGB color): count highlighter line color
+            count_bg_color (RGB color): count highlighter line color
             count_reg_color (RGB color): Color of object counting region
             track_color (RGB color): color for tracks
             region_thickness (int): Object counting Region thickness
@@ -125,10 +120,8 @@ class ObjectCounter:
 
         self.names = classes_names
         self.track_color = track_color
-        self.count_txt_thickness = count_txt_thickness
         self.count_txt_color = count_txt_color
-        self.fontsize = fontsize
-        self.line_color = line_color
+        self.count_bg_color = count_bg_color
         self.region_color = count_reg_color
         self.region_thickness = region_thickness
         self.line_dist_thresh = line_dist_thresh
@@ -172,6 +165,9 @@ class ObjectCounter:
         # Annotator Init and region drawing
         self.annotator = Annotator(self.im0, self.tf, self.names)
 
+        # Draw region or line
+        self.annotator.draw_region(reg_pts=self.reg_pts, color=self.region_color, thickness=self.region_thickness)
+
         if tracks[0].boxes.id is not None:
             boxes = tracks[0].boxes.xyxy.cpu()
             clss = tracks[0].boxes.cls.cpu().tolist()
@@ -220,17 +216,14 @@ class ObjectCounter:
 
                 # Count objects using line
                 elif len(self.reg_pts) == 2:
-                    is_inside = (box[0] - prev_position[0]) * (self.counting_region.centroid.x - prev_position[0]) > 0
-
-                    if prev_position is not None and is_inside and track_id not in self.count_ids:
+                    if prev_position is not None and track_id not in self.count_ids:
                         distance = Point(track_line[-1]).distance(self.counting_region)
-
                         if distance < self.line_dist_thresh and track_id not in self.count_ids:
                             self.count_ids.append(track_id)
 
                             if (box[0] - prev_position[0]) * (self.counting_region.centroid.x - prev_position[0]) > 0:
                                 self.in_counts += 1
-                                self.class_wise_count[self.names[cls]]["in"] += 1
+                                self.class_wise_count[self.names[cls]]["in"] += 2
                             else:
                                 self.out_counts += 1
                                 self.class_wise_count[self.names[cls]]["out"] += 1
@@ -254,17 +247,13 @@ class ObjectCounter:
         if label is not None:
             self.annotator.display_counts(
                 counts=label,
-                tf=self.count_txt_thickness,
-                fontScale=self.fontsize,
-                txt_color=self.count_txt_color,
-                line_color=self.line_color,
-                classwise_txtgap=self.cls_txtdisplay_gap,
+                count_txt_color=self.count_txt_color,
+                count_bg_color=self.count_bg_color,
             )
 
     def display_frames(self):
         """Display frame."""
         if self.env_check:
-            self.annotator.draw_region(reg_pts=self.reg_pts, color=self.region_color, thickness=self.region_thickness)
             cv2.namedWindow(self.window_name)
             if len(self.reg_pts) == 4:  # only add mouse event If user drawn region
                 cv2.setMouseCallback(self.window_name, self.mouse_event_for_region, {"region_points": self.reg_pts})

ultralytics/utils/__init__.py

@@ -1,6 +1,7 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
 import contextlib
+import importlib.metadata
 import inspect
 import logging.config
 import os
@@ -42,6 +43,8 @@ TQDM_BAR_FORMAT = "{l_bar}{bar:10}{r_bar}" if VERBOSE else None  # tqdm bar form
 LOGGING_NAME = "ultralytics"
 MACOS, LINUX, WINDOWS = (platform.system() == x for x in ["Darwin", "Linux", "Windows"])  # environment booleans
 ARM64 = platform.machine() in {"arm64", "aarch64"}  # ARM64 booleans
+PYTHON_VERSION = platform.python_version()
+TORCHVISION_VERSION = importlib.metadata.version("torchvision")  # faster than importing torchvision
 HELP_MSG = """
     Usage examples for running YOLOv8:
 
@@ -476,7 +479,7 @@ def is_online() -> bool:
 
     for host in "1.1.1.1", "8.8.8.8", "223.5.5.5":  # Cloudflare, Google, AliDNS:
         try:
-            test_connection = socket.create_connection(address=(host, 53), timeout=2)
+            test_connection = socket.create_connection(address=(host, 80), timeout=2)
         except (socket.timeout, socket.gaierror, OSError):
             continue
         else:

ultralytics/utils/benchmarks.py

@@ -69,8 +69,7 @@ def benchmark(
         benchmark(model='yolov8n.pt', imgsz=640)
         ```
     """
-
-    import pandas as pd
+    import pandas as pd  # scope for faster 'import ultralytics'
 
     pd.options.display.max_columns = 10
     pd.options.display.width = 120

ultralytics/utils/callbacks/clearml.py

@@ -7,8 +7,6 @@ try:
     assert SETTINGS["clearml"] is True  # verify integration is enabled
     import clearml
     from clearml import Task
-    from clearml.binding.frameworks.pytorch_bind import PatchPyTorchModelIO
-    from clearml.binding.matplotlib_bind import PatchedMatplotlib
 
     assert hasattr(clearml, "__version__")  # verify package is not directory
 
@@ -61,8 +59,11 @@ def on_pretrain_routine_start(trainer):
     """Runs at start of pretraining routine; initializes and connects/ logs task to ClearML."""
     try:
         if task := Task.current_task():
-            # Make sure the automatic pytorch and matplotlib bindings are disabled!
+            # WARNING: make sure the automatic pytorch and matplotlib bindings are disabled!
             # We are logging these plots and model files manually in the integration
+            from clearml.binding.frameworks.pytorch_bind import PatchPyTorchModelIO
+            from clearml.binding.matplotlib_bind import PatchedMatplotlib
+
             PatchPyTorchModelIO.update_current_task(None)
             PatchedMatplotlib.update_current_task(None)
         else:

ultralytics/utils/callbacks/wb.py

@@ -9,10 +9,6 @@ try:
     import wandb as wb
 
     assert hasattr(wb, "__version__")  # verify package is not directory
-
-    import numpy as np
-    import pandas as pd
-
     _processed_plots = {}
 
 except (ImportError, AssertionError):
@@ -38,7 +34,9 @@ def _custom_table(x, y, classes, title="Precision Recall Curve", x_title="Recall
     Returns:
         (wandb.Object): A wandb object suitable for logging, showcasing the crafted metric visualization.
     """
-    df = pd.DataFrame({"class": classes, "y": y, "x": x}).round(3)
+    import pandas  # scope for faster 'import ultralytics'
+
+    df = pandas.DataFrame({"class": classes, "y": y, "x": x}).round(3)
     fields = {"x": "x", "y": "y", "class": "class"}
     string_fields = {"title": title, "x-axis-title": x_title, "y-axis-title": y_title}
     return wb.plot_table(
@@ -77,6 +75,8 @@ def _plot_curve(
     Note:
         The function leverages the '_custom_table' function to generate the actual visualization.
     """
+    import numpy as np
+
     # Create new x
     if names is None:
         names = []

ultralytics/utils/checks.py

@@ -18,15 +18,16 @@ import cv2
 import numpy as np
 import requests
 import torch
-from matplotlib import font_manager
 
 from ultralytics.utils import (
     ASSETS,
     AUTOINSTALL,
     LINUX,
     LOGGER,
+    PYTHON_VERSION,
     ONLINE,
     ROOT,
+    TORCHVISION_VERSION,
     USER_CONFIG_DIR,
     Retry,
     SimpleNamespace,
@@ -41,13 +42,10 @@ from ultralytics.utils import (
     is_github_action_running,
     is_jupyter,
     is_kaggle,
-    is_online,
     is_pip_package,
     url2file,
 )
 
-PYTHON_VERSION = platform.python_version()
-
 
 def parse_requirements(file_path=ROOT.parent / "requirements.txt", package=""):
     """
@@ -304,9 +302,10 @@ def check_font(font="Arial.ttf"):
     Returns:
         file (Path): Resolved font file path.
     """
-    name = Path(font).name
+    from matplotlib import font_manager
 
     # Check USER_CONFIG_DIR
+    name = Path(font).name
     file = USER_CONFIG_DIR / name
     if file.exists():
         return file
@@ -390,7 +389,7 @@ def check_requirements(requirements=ROOT.parent / "requirements.txt", exclude=()
             LOGGER.info(f"{prefix} Ultralytics requirement{'s' * (n > 1)} {pkgs} not found, attempting AutoUpdate...")
             try:
                 t = time.time()
-                assert is_online(), "AutoUpdate skipped (offline)"
+                assert ONLINE, "AutoUpdate skipped (offline)"
                 with Retry(times=2, delay=1):  # run up to 2 times with 1-second retry delay
                     LOGGER.info(subprocess.check_output(f"pip install --no-cache {s} {cmds}", shell=True).decode())
                 dt = time.time() - t
@@ -419,14 +418,12 @@ def check_torchvision():
     Torchvision versions.
     """
 
-    import torchvision
-
     # Compatibility table
     compatibility_table = {"2.0": ["0.15"], "1.13": ["0.14"], "1.12": ["0.13"]}
 
     # Extract only the major and minor versions
     v_torch = ".".join(torch.__version__.split("+")[0].split(".")[:2])
-    v_torchvision = ".".join(torchvision.__version__.split("+")[0].split(".")[:2])
+    v_torchvision = ".".join(TORCHVISION_VERSION.split("+")[0].split(".")[:2])
 
     if v_torch in compatibility_table:
         compatible_versions = compatibility_table[v_torch]

ultralytics/utils/metrics.py

@@ -395,19 +395,19 @@ class ConfusionMatrix:
             names (tuple): Names of classes, used as labels on the plot.
             on_plot (func): An optional callback to pass plots path and data when they are rendered.
         """
-        import seaborn as sn
+        import seaborn  # scope for faster 'import ultralytics'
 
         array = self.matrix / ((self.matrix.sum(0).reshape(1, -1) + 1e-9) if normalize else 1)  # normalize columns
         array[array < 0.005] = np.nan  # don't annotate (would appear as 0.00)
 
         fig, ax = plt.subplots(1, 1, figsize=(12, 9), tight_layout=True)
         nc, nn = self.nc, len(names)  # number of classes, names
-        sn.set_theme(font_scale=1.0 if nc < 50 else 0.8)  # for label size
+        seaborn.set_theme(font_scale=1.0 if nc < 50 else 0.8)  # for label size
         labels = (0 < nn < 99) and (nn == nc)  # apply names to ticklabels
         ticklabels = (list(names) + ["background"]) if labels else "auto"
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")  # suppress empty matrix RuntimeWarning: All-NaN slice encountered
-            sn.heatmap(
+            seaborn.heatmap(
                 array,
                 ax=ax,
                 annot=nc < 30,

ultralytics/utils/ops.py

@@ -9,7 +9,6 @@ import cv2
 import numpy as np
 import torch
 import torch.nn.functional as F
-import torchvision
 
 from ultralytics.utils import LOGGER
 from ultralytics.utils.metrics import batch_probiou
@@ -206,6 +205,7 @@ def non_max_suppression(
             shape (num_boxes, 6 + num_masks) containing the kept boxes, with columns
             (x1, y1, x2, y2, confidence, class, mask1, mask2, ...).
     """
+    import torchvision  # scope for faster 'import ultralytics'
 
     # Checks
     assert 0 <= conf_thres <= 1, f"Invalid Confidence threshold {conf_thres}, valid values are between 0.0 and 1.0"

ultralytics/utils/plotting.py

@@ -339,6 +339,21 @@ class Annotator:
         """Save the annotated image to 'filename'."""
         cv2.imwrite(filename, np.asarray(self.im))
 
+    def get_bbox_dimension(self, bbox=None):
+        """
+        Calculate the area of a bounding box.
+
+        Args:
+            bbox (tuple): Bounding box coordinates in the format (x_min, y_min, x_max, y_max).
+
+        Returns:
+            angle (degree): Degree value of angle between three points
+        """
+        x_min, y_min, x_max, y_max = bbox
+        width = x_max - x_min
+        height = y_max - y_min
+        return width, height, width * height
+
     def draw_region(self, reg_pts=None, color=(0, 255, 0), thickness=5):
         """
         Draw region line.
@@ -364,13 +379,22 @@ class Annotator:
         cv2.circle(self.im, (int(track[-1][0]), int(track[-1][1])), track_thickness * 2, color, -1)
 
     def queue_counts_display(self, label, points=None, region_color=(255, 255, 255), txt_color=(0, 0, 0), fontsize=0.7):
-        """Displays queue counts on an image centered at the points with customizable font size and colors."""
+        """
+        Displays queue counts on an image centered at the points with customizable font size and colors.
+
+        Args:
+            label (str): queue counts label
+            points (tuple): region points for center point calculation to display text
+            region_color (RGB): queue region color
+            txt_color (RGB): text display color
+            fontsize (float): text fontsize
+        """
         x_values = [point[0] for point in points]
         y_values = [point[1] for point in points]
         center_x = sum(x_values) // len(points)
         center_y = sum(y_values) // len(points)
 
-        text_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, fontScale=fontsize, thickness=self.tf)[0]
+        text_size = cv2.getTextSize(label, 0, fontScale=fontsize, thickness=self.tf)[0]
         text_width = text_size[0]
         text_height = text_size[1]
 
@@ -388,56 +412,63 @@ class Annotator:
             self.im,
             label,
             (text_x, text_y),
-            cv2.FONT_HERSHEY_SIMPLEX,
+            0,
             fontScale=fontsize,
             color=txt_color,
             thickness=self.tf,
             lineType=cv2.LINE_AA,
         )
 
-    def display_counts(
-        self, counts=None, tf=2, fontScale=0.6, line_color=(0, 0, 0), txt_color=(255, 255, 255), classwise_txtgap=55
-    ):
+    def display_counts(self, counts=None, count_bg_color=(0, 0, 0), count_txt_color=(255, 255, 255)):
         """
-        Display counts on im0.
+        Display counts on im0 with text background and border.
 
         Args:
             counts (str): objects count data
-            tf (int): text thickness for display
-            fontScale (float): text fontsize for display
-            line_color (RGB Color): counts highlighter color
-            txt_color (RGB Color): counts display color
-            classwise_txtgap (int): Gap between each class count data
+            count_bg_color (RGB Color): counts highlighter color
+            count_txt_color (RGB Color): counts display color
         """
 
-        tl = tf or round(0.002 * (self.im.shape[0] + self.im.shape[1]) / 2) + 1
+        tl = self.tf or round(0.002 * (self.im.shape[0] + self.im.shape[1]) / 2) + 1
         tf = max(tl - 1, 1)
 
-        t_sizes = [cv2.getTextSize(str(count), 0, fontScale=0.8, thickness=tf)[0] for count in counts]
+        t_sizes = [cv2.getTextSize(str(count), 0, fontScale=self.sf, thickness=self.tf)[0] for count in counts]
 
         max_text_width = max([size[0] for size in t_sizes])
         max_text_height = max([size[1] for size in t_sizes])
 
-        text_x = self.im.shape[1] - max_text_width - 20
-        text_y = classwise_txtgap
+        text_x = self.im.shape[1] - int(self.im.shape[1] * 0.025 + max_text_width)
+        text_y = int(self.im.shape[0] * 0.025)
+
+        # Calculate dynamic gap between each count value based on the width of the image
+        dynamic_gap = max(1, self.im.shape[1] // 100) * tf
 
         for i, count in enumerate(counts):
             text_x_pos = text_x
-            text_y_pos = text_y + i * classwise_txtgap
+            text_y_pos = text_y + i * dynamic_gap  # Adjust vertical position with dynamic gap
 
+            # Draw the border
+            cv2.rectangle(
+                self.im,
+                (text_x_pos - (10 * tf), text_y_pos - (10 * tf)),
+                (text_x_pos + max_text_width + (10 * tf), text_y_pos + max_text_height + (10 * tf)),
+                count_bg_color,
+                -1,
+            )
+
+            # Draw the count text
             cv2.putText(
                 self.im,
                 str(count),
-                (text_x_pos, text_y_pos),
-                cv2.FONT_HERSHEY_SIMPLEX,
-                fontScale=fontScale,
-                color=txt_color,
-                thickness=tf,
+                (text_x_pos, text_y_pos + max_text_height),
+                0,
+                fontScale=self.sf,
+                color=count_txt_color,
+                thickness=self.tf,
                 lineType=cv2.LINE_AA,
             )
 
-            line_y_pos = text_y_pos + max_text_height + 5
-            cv2.line(self.im, (text_x_pos, line_y_pos), (text_x_pos + max_text_width, line_y_pos), line_color, tf)
+            text_y_pos += tf * max_text_height
 
     @staticmethod
     def estimate_pose_angle(a, b, c):
@@ -588,30 +619,26 @@ class Annotator:
             line_color (RGB): Distance line color.
             centroid_color (RGB): Bounding box centroid color.
         """
-        (text_width_m, text_height_m), _ = cv2.getTextSize(
-            f"Distance M: {distance_m:.2f}m", cv2.FONT_HERSHEY_SIMPLEX, 0.8, 2
-        )
+        (text_width_m, text_height_m), _ = cv2.getTextSize(f"Distance M: {distance_m:.2f}m", 0, 0.8, 2)
         cv2.rectangle(self.im, (15, 25), (15 + text_width_m + 10, 25 + text_height_m + 20), (255, 255, 255), -1)
         cv2.putText(
             self.im,
             f"Distance M: {distance_m:.2f}m",
             (20, 50),
-            cv2.FONT_HERSHEY_SIMPLEX,
+            0,
             0.8,
             (0, 0, 0),
             2,
             cv2.LINE_AA,
         )
 
-        (text_width_mm, text_height_mm), _ = cv2.getTextSize(
-            f"Distance MM: {distance_mm:.2f}mm", cv2.FONT_HERSHEY_SIMPLEX, 0.8, 2
-        )
+        (text_width_mm, text_height_mm), _ = cv2.getTextSize(f"Distance MM: {distance_mm:.2f}mm", 0, 0.8, 2)
         cv2.rectangle(self.im, (15, 75), (15 + text_width_mm + 10, 75 + text_height_mm + 20), (255, 255, 255), -1)
         cv2.putText(
             self.im,
             f"Distance MM: {distance_mm:.2f}mm",
             (20, 100),
-            cv2.FONT_HERSHEY_SIMPLEX,
+            0,
             0.8,
             (0, 0, 0),
             2,
@@ -644,8 +671,8 @@ class Annotator:
 @plt_settings()
 def plot_labels(boxes, cls, names=(), save_dir=Path(""), on_plot=None):
     """Plot training labels including class histograms and box statistics."""
-    import pandas as pd
-    import seaborn as sn
+    import pandas  # scope for faster 'import ultralytics'
+    import seaborn  # scope for faster 'import ultralytics'
 
     # Filter matplotlib>=3.7.2 warning and Seaborn use_inf and is_categorical FutureWarnings
     warnings.filterwarnings("ignore", category=UserWarning, message="The figure layout has changed to tight")
@@ -655,10 +682,10 @@ def plot_labels(boxes, cls, names=(), save_dir=Path(""), on_plot=None):
     LOGGER.info(f"Plotting labels to {save_dir / 'labels.jpg'}... ")
     nc = int(cls.max() + 1)  # number of classes
     boxes = boxes[:1000000]  # limit to 1M boxes
-    x = pd.DataFrame(boxes, columns=["x", "y", "width", "height"])
+    x = pandas.DataFrame(boxes, columns=["x", "y", "width", "height"])
 
     # Seaborn correlogram
-    sn.pairplot(x, corner=True, diag_kind="auto", kind="hist", diag_kws=dict(bins=50), plot_kws=dict(pmax=0.9))
+    seaborn.pairplot(x, corner=True, diag_kind="auto", kind="hist", diag_kws=dict(bins=50), plot_kws=dict(pmax=0.9))
     plt.savefig(save_dir / "labels_correlogram.jpg", dpi=200)
     plt.close()
 
@@ -673,8 +700,8 @@ def plot_labels(boxes, cls, names=(), save_dir=Path(""), on_plot=None):
         ax[0].set_xticklabels(list(names.values()), rotation=90, fontsize=10)
     else:
         ax[0].set_xlabel("classes")
-    sn.histplot(x, x="x", y="y", ax=ax[2], bins=50, pmax=0.9)
-    sn.histplot(x, x="width", y="height", ax=ax[3], bins=50, pmax=0.9)
+    seaborn.histplot(x, x="x", y="y", ax=ax[2], bins=50, pmax=0.9)
+    seaborn.histplot(x, x="width", y="height", ax=ax[3], bins=50, pmax=0.9)
 
     # Rectangles
     boxes[:, 0:2] = 0.5  # center
@@ -906,7 +933,7 @@ def plot_results(file="path/to/results.csv", dir="", segment=False, pose=False,
         plot_results('path/to/results.csv', segment=True)
         ```
     """
-    import pandas as pd
+    import pandas as pd  # scope for faster 'import ultralytics'
     from scipy.ndimage import gaussian_filter1d
 
     save_dir = Path(file).parent if file else Path(dir)
@@ -992,7 +1019,7 @@ def plot_tune_results(csv_file="tune_results.csv"):
         >>> plot_tune_results('path/to/tune_results.csv')
     """
 
-    import pandas as pd
+    import pandas as pd  # scope for faster 'import ultralytics'
     from scipy.ndimage import gaussian_filter1d
 
     # Scatter plots for each hyperparameter