ultralytics 8.2.17__py3-none-any.whl → 8.2.18__py3-none-any.whl

ultralytics/solutions/queue_management.py

@@ -13,49 +13,12 @@ from shapely.geometry import Point, Polygon
 
 
 class QueueManager:
-    """A class to manage the queue management in real-time video stream based on their tracks."""
+    """A class to manage the queue in a real-time video stream based on object tracks."""
 
-    def __init__(self):
-        """Initializes the queue manager with default values for various tracking and counting parameters."""
-
-        # Mouse events
-        self.is_drawing = False
-        self.selected_point = None
-
-        # Region & Line Information
-        self.reg_pts = [(20, 60), (20, 680), (1120, 680), (1120, 60)]
-        self.counting_region = None
-        self.region_color = (255, 0, 255)
-        self.region_thickness = 5
-
-        # Image and annotation Information
-        self.im0 = None
-        self.tf = None
-        self.view_img = False
-        self.view_queue_counts = True
-        self.fontsize = 0.6
-
-        self.names = None  # Classes names
-        self.annotator = None  # Annotator
-        self.window_name = "Ultralytics YOLOv8 Queue Manager"
-
-        # Object counting Information
-        self.counts = 0
-        self.count_txt_color = (255, 255, 255)
-
-        # Tracks info
-        self.track_history = defaultdict(list)
-        self.track_thickness = 2
-        self.draw_tracks = False
-        self.track_color = None
-
-        # Check if environment support imshow
-        self.env_check = check_imshow(warn=True)
-
-    def set_args(
+    def __init__(
         self,
         classes_names,
-        reg_pts,
+        reg_pts=None,
         line_thickness=2,
         track_thickness=2,
         view_img=False,
@@ -68,48 +31,65 @@ class QueueManager:
         fontsize=0.7,
     ):
         """
-        Configures the Counter's image, bounding box line thickness, and counting region points.
+        Initializes the QueueManager with specified parameters for tracking and counting objects.
 
         Args:
-            line_thickness (int): Line thickness for bounding boxes.
-            view_img (bool): Flag to control whether to display the video stream.
-            view_queue_counts (bool): Flag to control whether to display the counts on video stream.
-            reg_pts (list): Initial list of points defining the counting region.
-            classes_names (dict): Classes names
-            region_color (RGB color): Color of queue region
-            track_thickness (int): Track thickness
-            draw_tracks (Bool): draw tracks
-            count_txt_color (RGB color): count text color value
-            track_color (RGB color): color for tracks
-            region_thickness (int): Object counting Region thickness
-            fontsize (float): Text display font size
+            classes_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.
+            track_thickness (int, optional): Thickness of the track lines. Defaults to 2.
+            view_img (bool, optional): Whether to display the image frames. Defaults to False.
+            region_color (tuple, optional): Color of the counting region lines (BGR). Defaults to (255, 0, 255).
+            view_queue_counts (bool, optional): Whether to display the queue counts. Defaults to True.
+            draw_tracks (bool, optional): Whether to draw tracks of the objects. Defaults to False.
+            count_txt_color (tuple, optional): Color of the count text (BGR). Defaults to (255, 255, 255).
+            track_color (tuple, optional): Color of the tracks. If None, different colors will be used for different
+                tracks. Defaults to None.
+            region_thickness (int, optional): Thickness of the counting region lines. Defaults to 5.
+            fontsize (float, optional): Font size for the text annotations. Defaults to 0.7.
         """
+
+        # Mouse events state
+        self.is_drawing = False
+        self.selected_point = None
+
+        # Region & Line Information
+        self.reg_pts = reg_pts if reg_pts is not None else [(20, 60), (20, 680), (1120, 680), (1120, 60)]
+        self.counting_region = (
+            Polygon(self.reg_pts) if len(self.reg_pts) >= 3 else Polygon([(20, 60), (20, 680), (1120, 680), (1120, 60)])
+        )
+        self.region_color = region_color
+        self.region_thickness = region_thickness
+
+        # Image and annotation Information
+        self.im0 = None
         self.tf = line_thickness
         self.view_img = view_img
         self.view_queue_counts = view_queue_counts
-        self.track_thickness = track_thickness
-        self.draw_tracks = draw_tracks
-        self.region_color = region_color
+        self.fontsize = fontsize
 
-        if len(reg_pts) >= 3:
-            print("Queue region initiated...")
-            self.reg_pts = reg_pts
-            self.counting_region = Polygon(self.reg_pts)
-        else:
-            print("Invalid region points provided...")
-            print("Using default region now....")
-            self.counting_region = Polygon(self.reg_pts)
+        self.names = classes_names  # Class names
+        self.annotator = None  # Annotator
+        self.window_name = "Ultralytics YOLOv8 Queue Manager"
 
-        self.names = classes_names
-        self.track_color = track_color
+        # Object counting Information
+        self.counts = 0
         self.count_txt_color = count_txt_color
-        self.region_thickness = region_thickness
-        self.fontsize = fontsize
+
+        # Tracks info
+        self.track_history = defaultdict(list)
+        self.track_thickness = track_thickness
+        self.draw_tracks = draw_tracks
+        self.track_color = track_color
+
+        # Check if environment supports imshow
+        self.env_check = check_imshow(warn=True)
 
     def extract_and_process_tracks(self, tracks):
         """Extracts and processes tracks for queue management in a video stream."""
 
-        # Annotator Init and queue region drawing
+        # Initialize annotator and draw the queue region
         self.annotator = Annotator(self.im0, self.tf, self.names)
 
         if tracks[0].boxes.id is not None:
@@ -122,48 +102,48 @@ class QueueManager:
                 # Draw bounding box
                 self.annotator.box_label(box, label=f"{self.names[cls]}#{track_id}", color=colors(int(track_id), True))
 
-                # Draw Tracks
+                # Update track history
                 track_line = self.track_history[track_id]
                 track_line.append((float((box[0] + box[2]) / 2), float((box[1] + box[3]) / 2)))
                 if len(track_line) > 30:
                     track_line.pop(0)
 
-                # Draw track trails
+                # Draw track trails if enabled
                 if self.draw_tracks:
                     self.annotator.draw_centroid_and_tracks(
                         track_line,
-                        color=self.track_color if self.track_color else colors(int(track_id), True),
+                        color=self.track_color or colors(int(track_id), True),
                         track_thickness=self.track_thickness,
                     )
 
                 prev_position = self.track_history[track_id][-2] if len(self.track_history[track_id]) > 1 else None
 
+                # Check if the object is inside the counting region
                 if len(self.reg_pts) >= 3:
                     is_inside = self.counting_region.contains(Point(track_line[-1]))
                     if prev_position is not None and is_inside:
                         self.counts += 1
 
-        label = "Queue Counts : " + str(self.counts)
-
+        # Display queue counts
+        label = f"Queue Counts : {str(self.counts)}"
         if label is not None:
             self.annotator.queue_counts_display(
                 label,
                 points=self.reg_pts,
                 region_color=self.region_color,
                 txt_color=self.count_txt_color,
-                fontsize=self.fontsize,
             )
 
-        self.counts = 0
+        self.counts = 0  # Reset counts after displaying
         self.display_frames()
 
     def display_frames(self):
-        """Display frame."""
+        """Displays the current frame with annotations."""
         if self.env_check:
             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)
-            # Break Window
+            # Close window on 'q' key press
             if cv2.waitKey(1) & 0xFF == ord("q"):
                 return
 
@@ -175,13 +155,14 @@ class QueueManager:
             im0 (ndarray): Current frame from the video stream.
             tracks (list): List of tracks obtained from the object tracking process.
         """
-        self.im0 = im0  # store image
-        self.extract_and_process_tracks(tracks)  # draw region even if no objects
+        self.im0 = im0  # Store the current frame
+        self.extract_and_process_tracks(tracks)  # Extract and process tracks
 
         if self.view_img:
-            self.display_frames()
+            self.display_frames()  # Display the frame if enabled
         return self.im0
 
 
 if __name__ == "__main__":
-    QueueManager()
+    classes_names = {0: "person", 1: "car"}  # example class names
+    queue_manager = QueueManager(classes_names)

ultralytics/solutions/speed_estimation.py

@@ -11,73 +11,52 @@ from ultralytics.utils.plotting import Annotator, colors
 
 
 class SpeedEstimator:
-    """A class to estimation speed of objects in real-time video stream based on their tracks."""
+    """A class to estimate the speed of objects in a real-time video stream based on their tracks."""
 
-    def __init__(self):
-        """Initializes the speed-estimator class with default values for Visual, Image, track and speed parameters."""
+    def __init__(self, names, reg_pts=None, view_img=False, line_thickness=2, region_thickness=5, spdl_dist_thresh=10):
+        """
+        Initializes the SpeedEstimator with the given parameters.
 
-        # Visual & im0 information
+        Args:
+            names (dict): Dictionary of class names.
+            reg_pts (list, optional): List of region points for speed estimation. Defaults to [(20, 400), (1260, 400)].
+            view_img (bool, optional): Whether to display the image with annotations. Defaults to False.
+            line_thickness (int, optional): Thickness of the lines for drawing boxes and tracks. Defaults to 2.
+            region_thickness (int, optional): Thickness of the region lines. Defaults to 5.
+            spdl_dist_thresh (int, optional): Distance threshold for speed calculation. Defaults to 10.
+        """
+        # Visual & image information
         self.im0 = None
         self.annotator = None
-        self.view_img = False
+        self.view_img = view_img
 
         # Region information
-        self.reg_pts = [(20, 400), (1260, 400)]
-        self.region_thickness = 3
+        self.reg_pts = reg_pts if reg_pts is not None else [(20, 400), (1260, 400)]
+        self.region_thickness = region_thickness
 
-        # Predict/track information
+        # Tracking information
         self.clss = None
-        self.names = None
+        self.names = names
         self.boxes = None
         self.trk_ids = None
         self.trk_pts = None
-        self.line_thickness = 2
+        self.line_thickness = line_thickness
         self.trk_history = defaultdict(list)
 
-        # Speed estimator information
+        # Speed estimation information
         self.current_time = 0
         self.dist_data = {}
         self.trk_idslist = []
-        self.spdl_dist_thresh = 10
+        self.spdl_dist_thresh = spdl_dist_thresh
         self.trk_previous_times = {}
         self.trk_previous_points = {}
 
-        # Check if environment support imshow
+        # Check if the environment supports imshow
         self.env_check = check_imshow(warn=True)
 
-    def set_args(
-        self,
-        reg_pts,
-        names,
-        view_img=False,
-        line_thickness=2,
-        region_thickness=5,
-        spdl_dist_thresh=10,
-    ):
-        """
-        Configures the speed estimation and display parameters.
-
-        Args:
-            reg_pts (list): Initial list of points defining the speed calculation region.
-            names (dict): object detection classes names
-            view_img (bool): Flag indicating frame display
-            line_thickness (int): Line thickness for bounding boxes.
-            region_thickness (int): Speed estimation region thickness
-            spdl_dist_thresh (int): Euclidean distance threshold for speed line
-        """
-        if reg_pts is None:
-            print("Region points not provided, using default values")
-        else:
-            self.reg_pts = reg_pts
-        self.names = names
-        self.view_img = view_img
-        self.line_thickness = line_thickness
-        self.region_thickness = region_thickness
-        self.spdl_dist_thresh = spdl_dist_thresh
-
     def extract_tracks(self, tracks):
         """
-        Extracts results from the provided data.
+        Extracts results from the provided tracking data.
 
         Args:
             tracks (list): List of tracks obtained from the object tracking process.
@@ -88,11 +67,14 @@ class SpeedEstimator:
 
     def store_track_info(self, track_id, box):
         """
-        Store track data.
+        Stores track data.
 
         Args:
-            track_id (int): object track id.
-            box (list): object bounding box data
+            track_id (int): Object track id.
+            box (list): Object bounding box data.
+
+        Returns:
+            (list): Updated tracking history for the given track_id.
         """
         track = self.trk_history[track_id]
         bbox_center = (float((box[0] + box[2]) / 2), float((box[1] + box[3]) / 2))
@@ -106,43 +88,39 @@ class SpeedEstimator:
 
     def plot_box_and_track(self, track_id, box, cls, track):
         """
-        Plot track and bounding box.
+        Plots track and bounding box.
 
         Args:
-            track_id (int): object track id.
-            box (list): object bounding box data
-            cls (str): object class name
-            track (list): tracking history for tracks path drawing
+            track_id (int): Object track id.
+            box (list): Object bounding box data.
+            cls (str): Object class name.
+            track (list): Tracking history for drawing tracks path.
         """
-        speed_label = f"{int(self.dist_data[track_id])}km/ph" if track_id in self.dist_data else self.names[int(cls)]
+        speed_label = f"{int(self.dist_data[track_id])} km/h" if track_id in self.dist_data else self.names[int(cls)]
         bbox_color = colors(int(track_id)) if track_id in self.dist_data else (255, 0, 255)
 
         self.annotator.box_label(box, speed_label, bbox_color)
-
         cv2.polylines(self.im0, [self.trk_pts], isClosed=False, color=(0, 255, 0), thickness=1)
         cv2.circle(self.im0, (int(track[-1][0]), int(track[-1][1])), 5, bbox_color, -1)
 
     def calculate_speed(self, trk_id, track):
         """
-        Calculation of object speed.
+        Calculates the speed of an object.
 
         Args:
-            trk_id (int): object track id.
-            track (list): tracking history for tracks path drawing
+            trk_id (int): Object track id.
+            track (list): Tracking history for drawing tracks path.
         """
-
         if not self.reg_pts[0][0] < track[-1][0] < self.reg_pts[1][0]:
             return
         if self.reg_pts[1][1] - self.spdl_dist_thresh < track[-1][1] < self.reg_pts[1][1] + self.spdl_dist_thresh:
             direction = "known"
-
         elif self.reg_pts[0][1] - self.spdl_dist_thresh < track[-1][1] < self.reg_pts[0][1] + self.spdl_dist_thresh:
             direction = "known"
-
         else:
             direction = "unknown"
 
-        if self.trk_previous_times[trk_id] != 0 and direction != "unknown" and trk_id not in self.trk_idslist:
+        if self.trk_previous_times.get(trk_id) != 0 and direction != "unknown" and trk_id not in self.trk_idslist:
             self.trk_idslist.append(trk_id)
 
             time_difference = time() - self.trk_previous_times[trk_id]
@@ -156,21 +134,24 @@ class SpeedEstimator:
 
     def estimate_speed(self, im0, tracks, region_color=(255, 0, 0)):
         """
-        Calculate object based on tracking data.
+        Estimates the speed of objects based on tracking data.
 
         Args:
-            im0 (nd array): Image
+            im0 (ndarray): Image.
             tracks (list): List of tracks obtained from the object tracking process.
-            region_color (tuple): Color to use when drawing regions.
+            region_color (tuple, optional): Color to use when drawing regions. Defaults to (255, 0, 0).
+
+        Returns:
+            (ndarray): The image with annotated boxes and tracks.
         """
         self.im0 = im0
         if tracks[0].boxes.id is None:
             if self.view_img and self.env_check:
                 self.display_frames()
             return im0
-        self.extract_tracks(tracks)
 
-        self.annotator = Annotator(self.im0, line_width=2)
+        self.extract_tracks(tracks)
+        self.annotator = Annotator(self.im0, line_width=self.line_thickness)
         self.annotator.draw_region(reg_pts=self.reg_pts, color=region_color, thickness=self.region_thickness)
 
         for box, trk_id, cls in zip(self.boxes, self.trk_ids, self.clss):
@@ -188,11 +169,12 @@ class SpeedEstimator:
         return im0
 
     def display_frames(self):
-        """Display frame."""
+        """Displays the current frame."""
         cv2.imshow("Ultralytics Speed Estimation", self.im0)
         if cv2.waitKey(1) & 0xFF == ord("q"):
             return
 
 
 if __name__ == "__main__":
-    SpeedEstimator()
+    names = {0: "person", 1: "car"}  # example class names
+    speed_estimator = SpeedEstimator(names)

ultralytics/utils/plotting.py

@@ -378,7 +378,7 @@ class Annotator:
         cv2.polylines(self.im, [points], isClosed=False, color=color, thickness=track_thickness)
         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):
+    def queue_counts_display(self, label, points=None, region_color=(255, 255, 255), txt_color=(0, 0, 0)):
         """
         Displays queue counts on an image centered at the points with customizable font size and colors.
 
@@ -387,14 +387,14 @@ class Annotator:
             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, 0, fontScale=fontsize, thickness=self.tf)[0]
+        text_size = cv2.getTextSize(label, 0, fontScale=self.sf, thickness=self.tf)[0]
         text_width = text_size[0]
         text_height = text_size[1]
 
@@ -413,13 +413,12 @@ class Annotator:
             label,
             (text_x, text_y),
             0,
-            fontScale=fontsize,
+            fontScale=self.sf,
             color=txt_color,
             thickness=self.tf,
             lineType=cv2.LINE_AA,
         )
 
-    ### Parking management utils
     def display_objects_labels(self, im0, text, txt_color, bg_color, x_center, y_center, margin):
         """
         Display the bounding boxes labels in parking management app.
@@ -445,7 +444,6 @@ class Annotator:
         cv2.rectangle(im0, (rect_x1, rect_y1), (rect_x2, rect_y2), bg_color, -1)
         cv2.putText(im0, text, (text_x, text_y), 0, self.sf, txt_color, self.tf, lineType=cv2.LINE_AA)
 
-    # Parking lot and object counting app
     def display_analytics(self, im0, text, txt_color, bg_color, margin):
         """
         Display the overall statistics for parking lots
@@ -459,12 +457,12 @@ class Annotator:
 
         horizontal_gap = int(im0.shape[1] * 0.02)
         vertical_gap = int(im0.shape[0] * 0.01)
-
         text_y_offset = 0
-
         for label, value in text.items():
             txt = f"{label}: {value}"
-            text_size = cv2.getTextSize(txt, 0, int(self.sf * 1.5), int(self.tf * 1.5))[0]
+            text_size = cv2.getTextSize(txt, 0, self.sf, self.tf)[0]
+            if text_size[0] < 5 or text_size[1] < 5:
+                text_size = (5, 5)
             text_x = im0.shape[1] - text_size[0] - margin * 2 - horizontal_gap
             text_y = text_y_offset + text_size[1] + margin * 2 + vertical_gap
             rect_x1 = text_x - margin * 2
@@ -472,9 +470,7 @@ class Annotator:
             rect_x2 = text_x + text_size[0] + margin * 2
             rect_y2 = text_y + margin * 2
             cv2.rectangle(im0, (rect_x1, rect_y1), (rect_x2, rect_y2), bg_color, -1)
-            cv2.putText(
-                im0, txt, (text_x, text_y), 0, int(self.sf * 1.5), txt_color, int(self.tf * 1.5), lineType=cv2.LINE_AA
-            )
+            cv2.putText(im0, txt, (text_x, text_y), 0, self.sf, txt_color, self.tf, lineType=cv2.LINE_AA)
             text_y_offset = rect_y2
 
     @staticmethod
@@ -518,7 +514,9 @@ class Annotator:
                     cv2.circle(self.im, (int(x_coord), int(y_coord)), radius, (0, 255, 0), -1, lineType=cv2.LINE_AA)
         return self.im
 
-    def plot_angle_and_count_and_stage(self, angle_text, count_text, stage_text, center_kpt, line_thickness=2):
+    def plot_angle_and_count_and_stage(
+        self, angle_text, count_text, stage_text, center_kpt, color=(104, 31, 17), txt_color=(255, 255, 255)
+    ):
         """
         Plot the pose angle, count value and step stage.
 
@@ -527,16 +525,17 @@ class Annotator:
             count_text (str): counts value for workout monitoring
             stage_text (str): stage decision for workout monitoring
             center_kpt (int): centroid pose index for workout monitoring
-            line_thickness (int): thickness for text display
+            color (tuple): text background color for workout monitoring
+            txt_color (tuple): text foreground color for workout monitoring
         """
+
         angle_text, count_text, stage_text = (f" {angle_text:.2f}", f"Steps : {count_text}", f" {stage_text}")
-        font_scale = 0.6 + (line_thickness / 10.0)
 
         # Draw angle
-        (angle_text_width, angle_text_height), _ = cv2.getTextSize(angle_text, 0, font_scale, line_thickness)
+        (angle_text_width, angle_text_height), _ = cv2.getTextSize(angle_text, 0, self.sf, self.tf)
         angle_text_position = (int(center_kpt[0]), int(center_kpt[1]))
         angle_background_position = (angle_text_position[0], angle_text_position[1] - angle_text_height - 5)
-        angle_background_size = (angle_text_width + 2 * 5, angle_text_height + 2 * 5 + (line_thickness * 2))
+        angle_background_size = (angle_text_width + 2 * 5, angle_text_height + 2 * 5 + (self.tf * 2))
         cv2.rectangle(
             self.im,
             angle_background_position,
@@ -544,19 +543,19 @@ class Annotator:
                 angle_background_position[0] + angle_background_size[0],
                 angle_background_position[1] + angle_background_size[1],
             ),
-            (255, 255, 255),
+            color,
             -1,
         )
-        cv2.putText(self.im, angle_text, angle_text_position, 0, font_scale, (0, 0, 0), line_thickness)
+        cv2.putText(self.im, angle_text, angle_text_position, 0, self.sf, txt_color, self.tf)
 
         # Draw Counts
-        (count_text_width, count_text_height), _ = cv2.getTextSize(count_text, 0, font_scale, line_thickness)
+        (count_text_width, count_text_height), _ = cv2.getTextSize(count_text, 0, self.sf, self.tf)
         count_text_position = (angle_text_position[0], angle_text_position[1] + angle_text_height + 20)
         count_background_position = (
             angle_background_position[0],
             angle_background_position[1] + angle_background_size[1] + 5,
         )
-        count_background_size = (count_text_width + 10, count_text_height + 10 + (line_thickness * 2))
+        count_background_size = (count_text_width + 10, count_text_height + 10 + self.tf)
 
         cv2.rectangle(
             self.im,
@@ -565,13 +564,13 @@ class Annotator:
                 count_background_position[0] + count_background_size[0],
                 count_background_position[1] + count_background_size[1],
             ),
-            (255, 255, 255),
+            color,
             -1,
         )
-        cv2.putText(self.im, count_text, count_text_position, 0, font_scale, (0, 0, 0), line_thickness)
+        cv2.putText(self.im, count_text, count_text_position, 0, self.sf, txt_color, self.tf)
 
         # Draw Stage
-        (stage_text_width, stage_text_height), _ = cv2.getTextSize(stage_text, 0, font_scale, line_thickness)
+        (stage_text_width, stage_text_height), _ = cv2.getTextSize(stage_text, 0, self.sf, self.tf)
         stage_text_position = (int(center_kpt[0]), int(center_kpt[1]) + angle_text_height + count_text_height + 40)
         stage_background_position = (stage_text_position[0], stage_text_position[1] - stage_text_height - 5)
         stage_background_size = (stage_text_width + 10, stage_text_height + 10)
@@ -583,10 +582,10 @@ class Annotator:
                 stage_background_position[0] + stage_background_size[0],
                 stage_background_position[1] + stage_background_size[1],
             ),
-            (255, 255, 255),
+            color,
             -1,
         )
-        cv2.putText(self.im, stage_text, stage_text_position, 0, font_scale, (0, 0, 0), line_thickness)
+        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):
         """
@@ -626,29 +625,30 @@ 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", 0, 0.8, 2)
-        cv2.rectangle(self.im, (15, 25), (15 + text_width_m + 10, 25 + text_height_m + 20), (255, 255, 255), -1)
+
+        (text_width_m, text_height_m), _ = cv2.getTextSize(f"Distance M: {distance_m:.2f}m", 0, self.sf, self.tf)
+        cv2.rectangle(self.im, (15, 25), (15 + text_width_m + 10, 25 + text_height_m + 20), line_color, -1)
         cv2.putText(
             self.im,
             f"Distance M: {distance_m:.2f}m",
             (20, 50),
             0,
-            0.8,
-            (0, 0, 0),
-            2,
+            self.sf,
+            centroid_color,
+            self.tf,
             cv2.LINE_AA,
         )
 
-        (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)
+        (text_width_mm, text_height_mm), _ = cv2.getTextSize(f"Distance MM: {distance_mm:.2f}mm", 0, self.sf, self.tf)
+        cv2.rectangle(self.im, (15, 75), (15 + text_width_mm + 10, 75 + text_height_mm + 20), line_color, -1)
         cv2.putText(
             self.im,
             f"Distance MM: {distance_mm:.2f}mm",
             (20, 100),
             0,
-            0.8,
-            (0, 0, 0),
-            2,
+            self.sf,
+            centroid_color,
+            self.tf,
             cv2.LINE_AA,
         )
 
@@ -656,7 +656,7 @@ class Annotator:
         cv2.circle(self.im, centroids[0], 6, centroid_color, -1)
         cv2.circle(self.im, centroids[1], 6, centroid_color, -1)
 
-    def visioneye(self, box, center_point, color=(235, 219, 11), pin_color=(255, 0, 255), thickness=2, pins_radius=10):
+    def visioneye(self, box, center_point, color=(235, 219, 11), pin_color=(255, 0, 255)):
         """
         Function for pinpoint human-vision eye mapping and plotting.
 
@@ -665,13 +665,11 @@ class Annotator:
             center_point (tuple): center point for vision eye view
             color (tuple): object centroid and line color value
             pin_color (tuple): visioneye point color value
-            thickness (int): int value for line thickness
-            pins_radius (int): visioneye point radius value
         """
         center_bbox = int((box[0] + box[2]) / 2), int((box[1] + box[3]) / 2)
-        cv2.circle(self.im, center_point, pins_radius, pin_color, -1)
-        cv2.circle(self.im, center_bbox, pins_radius, color, -1)
-        cv2.line(self.im, center_point, center_bbox, color, thickness)
+        cv2.circle(self.im, center_point, self.tf * 2, pin_color, -1)
+        cv2.circle(self.im, center_bbox, self.tf * 2, color, -1)
+        cv2.line(self.im, center_point, center_bbox, color, self.tf)
 
 
 @TryExcept()  # known issue https://github.com/ultralytics/yolov5/issues/5395