Drawing

Drawing utils

Paths

Class that draws the paths taken by a set of points of interest defined from the coordinates of each tracker estimation.

Parameters:

Name	Type	Description	Default
get_points_to_draw	Optional[Callable[[np.array], np.array]], optional	Function that takes a list of points (the .estimate attribute of a TrackedObject) and returns a list of points for which we want to draw their paths. By default it is the mean point of all the points in the tracker.	None
thickness	Optional[int], optional	Thickness of the circles representing the paths of interest.	None
color	Optional[Tuple[int, int, int]], optional	Color of the circles representing the paths of interest.	None
radius	Optional[int], optional	Radius of the circles representing the paths of interest.	None
attenuation	float, optional	A float number in [0, 1] that dictates the speed at which the path is erased. if it is 0 then the path is never erased.	0.01

Examples:

>>> from norfair import Tracker, Video, Path
>>> video = Video("video.mp4")
>>> tracker = Tracker(...)
>>> path_drawer = Path()
>>> for frame in video:
>>>    detections = get_detections(frame)  # runs detector and returns Detections
>>>    tracked_objects = tracker.update(detections)
>>>    frame = path_drawer.draw(frame, tracked_objects)
>>>    video.write(frame)

Source code in norfair/drawing.py

class Paths:
    """
    Class that draws the paths taken by a set of points of interest defined from the coordinates of each tracker estimation.

    Parameters
    ----------
    get_points_to_draw : Optional[Callable[[np.array], np.array]], optional
        Function that takes a list of points (the `.estimate` attribute of a [`TrackedObject`][norfair.tracker.TrackedObject])
        and returns a list of points for which we want to draw their paths.

        By default it is the mean point of all the points in the tracker.
    thickness : Optional[int], optional
        Thickness of the circles representing the paths of interest.
    color : Optional[Tuple[int, int, int]], optional
        [Color][norfair.drawing.Color] of the circles representing the paths of interest.
    radius : Optional[int], optional
        Radius of the circles representing the paths of interest.
    attenuation : float, optional
        A float number in [0, 1] that dictates the speed at which the path is erased.
        if it is `0` then the path is never erased.

    Examples
    --------
    >>> from norfair import Tracker, Video, Path
    >>> video = Video("video.mp4")
    >>> tracker = Tracker(...)
    >>> path_drawer = Path()
    >>> for frame in video:
    >>>    detections = get_detections(frame)  # runs detector and returns Detections
    >>>    tracked_objects = tracker.update(detections)
    >>>    frame = path_drawer.draw(frame, tracked_objects)
    >>>    video.write(frame)
    """

    def __init__(
        self,
        get_points_to_draw: Optional[Callable[[np.array], np.array]] = None,
        thickness: Optional[int] = None,
        color: Optional[Tuple[int, int, int]] = None,
        radius: Optional[int] = None,
        attenuation: float = 0.01,
    ):
        if get_points_to_draw is None:

            def get_points_to_draw(points):
                return [np.mean(np.array(points), axis=0)]

        self.get_points_to_draw = get_points_to_draw

        self.radius = radius
        self.thickness = thickness
        self.color = color
        self.mask = None
        self.attenuation_factor = 1 - attenuation

    def draw(
        self, frame: np.ndarray, tracked_objects: Sequence["TrackedObject"]
    ) -> np.array:
        """
        Draw the paths of the points interest on a frame.

        !!! warning
            This method does **not** draw frames in place use the returned one.

        Parameters
        ----------
        frame : np.ndarray
            The OpenCV frame to draw on.
        tracked_objects : Sequence[TrackedObject]
            List of [`TrackedObject`][norfair.tracker.TrackedObject] to get the points of interest in order to update the paths.

        Returns
        -------
        np.array
            The resulting frame.
        """
        if self.mask is None:
            frame_scale = frame.shape[0] / 100

            if self.radius is None:
                self.radius = int(max(frame_scale * 0.7, 1))
            if self.thickness is None:
                self.thickness = int(max(frame_scale / 7, 1))

            self.mask = np.zeros(frame.shape, np.uint8)

        self.mask = (self.mask * self.attenuation_factor).astype("uint8")

        for obj in tracked_objects:
            if obj.abs_to_rel is not None:
                warn_once(
                    "It seems that your using the Path drawer together with MotionEstimator. This is not fully supported and the results will not be what's expected"
                )

            if self.color is None:
                color = Color.random(obj.id)
            else:
                color = self.color

            points_to_draw = self.get_points_to_draw(obj.estimate)

            for point in points_to_draw:
                cv2.circle(
                    self.mask,
                    tuple(point.astype(int)),
                    radius=self.radius,
                    color=color,
                    thickness=self.thickness,
                )

        return cv2.addWeighted(self.mask, 1, frame, 1, 0, frame)

draw(frame, tracked_objects)

Draw the paths of the points interest on a frame.

Warning

This method does not draw frames in place use the returned one.

Parameters:

Name	Type	Description	Default
frame	np.ndarray	The OpenCV frame to draw on.	required
tracked_objects	Sequence[TrackedObject]	List of TrackedObject to get the points of interest in order to update the paths.	required

Returns:

Type	Description
np.array	The resulting frame.

Source code in norfair/drawing.py

def draw(
    self, frame: np.ndarray, tracked_objects: Sequence["TrackedObject"]
) -> np.array:
    """
    Draw the paths of the points interest on a frame.

    !!! warning
        This method does **not** draw frames in place use the returned one.

    Parameters
    ----------
    frame : np.ndarray
        The OpenCV frame to draw on.
    tracked_objects : Sequence[TrackedObject]
        List of [`TrackedObject`][norfair.tracker.TrackedObject] to get the points of interest in order to update the paths.

    Returns
    -------
    np.array
        The resulting frame.
    """
    if self.mask is None:
        frame_scale = frame.shape[0] / 100

        if self.radius is None:
            self.radius = int(max(frame_scale * 0.7, 1))
        if self.thickness is None:
            self.thickness = int(max(frame_scale / 7, 1))

        self.mask = np.zeros(frame.shape, np.uint8)

    self.mask = (self.mask * self.attenuation_factor).astype("uint8")

    for obj in tracked_objects:
        if obj.abs_to_rel is not None:
            warn_once(
                "It seems that your using the Path drawer together with MotionEstimator. This is not fully supported and the results will not be what's expected"
            )

        if self.color is None:
            color = Color.random(obj.id)
        else:
            color = self.color

        points_to_draw = self.get_points_to_draw(obj.estimate)

        for point in points_to_draw:
            cv2.circle(
                self.mask,
                tuple(point.astype(int)),
                radius=self.radius,
                color=color,
                thickness=self.thickness,
            )

    return cv2.addWeighted(self.mask, 1, frame, 1, 0, frame)

Color

Object which represents an OpenCV color.

Its properties are the colors which it can represent. For example, set Color.blue to get the OpenCV tuple representing the color blue.

Source code in norfair/drawing.py

class Color:
    """
    Object which represents an OpenCV color.

    Its properties are the colors which it can represent.
    For example, set `Color.blue` to get the OpenCV tuple representing the color blue.
    """

    green = (0, 128, 0)
    white = (255, 255, 255)
    olive = (0, 128, 128)
    black = (0, 0, 0)
    navy = (128, 0, 0)
    red = (0, 0, 255)
    maroon = (0, 0, 128)
    grey = (128, 128, 128)
    purple = (128, 0, 128)
    yellow = (0, 255, 255)
    lime = (0, 255, 0)
    fuchsia = (255, 0, 255)
    aqua = (255, 255, 0)
    blue = (255, 0, 0)
    teal = (128, 128, 0)
    silver = (192, 192, 192)

    @staticmethod
    def random(obj_id: int) -> Tuple[int, int, int]:
        color_list = [
            c
            for c in Color.__dict__.keys()
            if c[:2] != "__"
            and c not in ("random", "red", "white", "grey", "black", "silver")
        ]
        return getattr(Color, color_list[obj_id % len(color_list)])

draw_points(frame, detections, radius=None, thickness=None, color=None, color_by_label=False, draw_labels=False, label_size=None)

Draw a list of detections on a frame.

Parameters:

Name	Type	Description	Default
frame	np.ndarray	The OpenCV frame to draw on. Modified in place.	required
detections	Sequence[Detection]	List of Detection to be drawn.	required
radius	Optional[int], optional	Radius of the circles representing the detected points.	None
thickness	Optional[int], optional	Thickness of the circles representing the detected points.	None
color	Optional[Tuple[int, int, int]], optional	Color of the circles representing the detected points.	None
color_by_label	bool, optional	If True detections will be colored by label.	False
draw_labels	bool, optional	If True the detection's label will be drawn along with the detected points.	False
label_size	Optional[int], optional	Size of the label being drawn along with the detected points.	None

Source code in norfair/drawing.py

def draw_points(
    frame: np.ndarray,
    detections: Sequence["Detection"],
    radius: Optional[int] = None,
    thickness: Optional[int] = None,
    color: Optional[Tuple[int, int, int]] = None,
    color_by_label: bool = False,
    draw_labels: bool = False,
    label_size: Optional[int] = None,
):
    """
    Draw a list of detections on a frame.

    Parameters
    ----------
    frame : np.ndarray
        The OpenCV frame to draw on. Modified in place.
    detections : Sequence[Detection]
        List of [`Detection`][norfair.tracker.Detection] to be drawn.
    radius : Optional[int], optional
        Radius of the circles representing the detected points.
    thickness : Optional[int], optional
        Thickness of the circles representing the detected points.
    color : Optional[Tuple[int, int, int]], optional
        [Color][norfair.drawing.Color] of the circles representing the detected points.
    color_by_label : bool, optional
        If `True` detections will be colored by label.
    draw_labels : bool, optional
        If `True` the detection's label will be drawn along with the detected points.
    label_size : Optional[int], optional
        Size of the label being drawn along with the detected points.
    """
    if detections is None:
        return
    frame_scale = frame.shape[0] / 100
    if radius is None:
        radius = int(max(frame_scale * 0.7, 1))
    if thickness is None:
        thickness = int(max(frame_scale / 7, 1))
    if label_size is None:
        label_size = int(max(frame_scale / 100, 1))
    if color is None:
        color = Color.red
    for d in detections:
        if color_by_label:
            color = Color.random(abs(hash(d.label)))
        points = d.points
        points = validate_points(points)
        for point in points:
            cv2.circle(
                frame,
                tuple(point.astype(int)),
                radius=radius,
                color=color,
                thickness=thickness,
            )

        if draw_labels:
            label_draw_position = np.array([min(points[:, 0]), min(points[:, 1])])
            label_draw_position -= radius
            cv2.putText(
                frame,
                f"L: {d.label}",
                tuple(label_draw_position.astype(int)),
                cv2.FONT_HERSHEY_SIMPLEX,
                label_size,
                color,
                thickness,
                cv2.LINE_AA,
            )

draw_tracked_objects(frame, objects, radius=None, color=None, id_size=None, id_thickness=None, draw_points=True, color_by_label=False, draw_labels=False, label_size=None)

Draw a list of tracked objects on a frame.

Parameters:

Name	Type	Description	Default
frame	np.ndarray	The OpenCV frame to draw on. Modified in place.	required
objects	Sequence[TrackedObject]	List of TrackedObject to be drawn.	required
radius	Optional[int], optional	Radius of the circles representing the points estimated by the tracked objects.	None
color	Optional[Tuple[int, int, int]], optional	Color of the circles representing the points estimated by the tracked objects.	None
id_size	Optional[float], optional	Size of the id number being drawn on each tracked object. The id wont get drawn if id_size is set to 0.	None
id_thickness	Optional[int], optional	Thickness of the id number being drawn on each tracked object.	None
draw_points	bool, optional	Boolean determining if the function should draw the points estimated by the tracked objects. If set to True the points get drawn, if set to False only the id numbers get drawn.	True
color_by_label	bool, optional	If True objects will be colored by label.	False
draw_labels	bool, optional	If True the objects's label will be drawn along with the tracked points.	False
label_size	Optional[int], optional	Size of the label being drawn along with the tracked points.	None

Source code in norfair/drawing.py

def draw_tracked_objects(
    frame: np.ndarray,
    objects: Sequence["TrackedObject"],
    radius: Optional[int] = None,
    color: Optional[Tuple[int, int, int]] = None,
    id_size: Optional[float] = None,
    id_thickness: Optional[int] = None,
    draw_points: bool = True,
    color_by_label: bool = False,
    draw_labels: bool = False,
    label_size: Optional[int] = None,
):
    """
    Draw a list of tracked objects on a frame.

    Parameters
    ----------
    frame : np.ndarray
        The OpenCV frame to draw on. Modified in place.
    objects : Sequence[TrackedObject]
        List of [`TrackedObject`][norfair.tracker.TrackedObject] to be drawn.
    radius : Optional[int], optional
        Radius of the circles representing the points estimated by the tracked objects.
    color : Optional[Tuple[int, int, int]], optional
        [Color][norfair.drawing.Color] of the circles representing the points estimated by the tracked objects.
    id_size : Optional[float], optional
        Size of the id number being drawn on each tracked object. The id wont get drawn if `id_size` is set to 0.
    id_thickness : Optional[int], optional
        Thickness of the id number being drawn on each tracked object.
    draw_points : bool, optional
        Boolean determining if the function should draw the points estimated by the tracked objects.
        If set to `True` the points get drawn, if set to `False` only the id numbers get drawn.
    color_by_label : bool, optional
        If `True` objects will be colored by label.
    draw_labels : bool, optional
        If `True` the objects's label will be drawn along with the tracked points.
    label_size : Optional[int], optional
        Size of the label being drawn along with the tracked points.
    """
    frame_scale = frame.shape[0] / 100
    if radius is None:
        radius = int(frame_scale * 0.5)
    if id_size is None:
        id_size = frame_scale / 10
    if id_thickness is None:
        id_thickness = int(frame_scale / 5)
    if label_size is None:
        label_size = int(max(frame_scale / 100, 1))

    for obj in objects:
        if not obj.live_points.any():
            continue
        if color_by_label:
            point_color = Color.random(abs(hash(obj.label)))
            id_color = point_color
        elif color is None:
            object_id = obj.id if obj.id is not None else random.randint(0, 999)
            point_color = Color.random(object_id)
            id_color = point_color
        else:
            point_color = color
            id_color = color

        if draw_points:
            for point, live in zip(obj.estimate, obj.live_points):
                if live:
                    cv2.circle(
                        frame,
                        tuple(point.astype(int)),
                        radius=radius,
                        color=point_color,
                        thickness=-1,
                    )

            if draw_labels:
                points = obj.estimate[obj.live_points]
                points = points.astype(int)
                label_draw_position = np.array([min(points[:, 0]), min(points[:, 1])])
                label_draw_position -= radius
                cv2.putText(
                    frame,
                    f"L: {obj.label}",
                    tuple(label_draw_position),
                    cv2.FONT_HERSHEY_SIMPLEX,
                    label_size,
                    point_color,
                    id_thickness,
                    cv2.LINE_AA,
                )

        if id_size > 0:
            id_draw_position = _centroid(obj.estimate[obj.live_points])
            cv2.putText(
                frame,
                str(obj.id),
                id_draw_position,
                cv2.FONT_HERSHEY_SIMPLEX,
                id_size,
                id_color,
                id_thickness,
                cv2.LINE_AA,
            )

draw_debug_metrics(frame, objects, text_size=None, text_thickness=None, color=None, only_ids=None, only_initializing_ids=None, draw_score_threshold=0, color_by_label=False, draw_labels=False)

Draw objects with their debug information

It is recommended to set the input variable objects to your_tracker_object.objects so you can also debug objects wich haven't finished initializing, and you get a more complete view of what your tracker is doing on each step.

Source code in norfair/drawing.py

def draw_debug_metrics(
    frame: np.ndarray,
    objects: Sequence["TrackedObject"],
    text_size: Optional[float] = None,
    text_thickness: Optional[int] = None,
    color: Optional[Tuple[int, int, int]] = None,
    only_ids=None,
    only_initializing_ids=None,
    draw_score_threshold: float = 0,
    color_by_label: bool = False,
    draw_labels: bool = False,
):
    """Draw objects with their debug information

    It is recommended to set the input variable `objects` to `your_tracker_object.objects`
    so you can also debug objects wich haven't finished initializing, and you get a more
    complete view of what your tracker is doing on each step.
    """
    frame_scale = frame.shape[0] / 100
    if text_size is None:
        text_size = frame_scale / 10
    if text_thickness is None:
        text_thickness = int(frame_scale / 5)
    radius = int(frame_scale * 0.5)

    for obj in objects:
        if (
            not (obj.last_detection.scores is None)
            and not (obj.last_detection.scores > draw_score_threshold).any()
        ):
            continue
        if only_ids is not None:
            if obj.id not in only_ids:
                continue
        if only_initializing_ids is not None:
            if obj.initializing_id not in only_initializing_ids:
                continue
        if color_by_label:
            text_color = Color.random(abs(hash(obj.label)))
        elif color is None:
            text_color = Color.random(obj.initializing_id)
        else:
            text_color = color
        draw_position = _centroid(
            obj.estimate[obj.last_detection.scores > draw_score_threshold]
            if obj.last_detection.scores is not None
            else obj.estimate
        )

        for point in obj.estimate:
            cv2.circle(
                frame,
                tuple(point.astype(int)),
                radius=radius,
                color=text_color,
                thickness=-1,
            )

        # Distance to last matched detection
        if obj.last_distance is None:
            last_dist = "-"
        elif obj.last_distance > 999:
            last_dist = ">"
        else:
            last_dist = "{:.2f}".format(obj.last_distance)

        # Distance to currently closest detection
        if obj.current_min_distance is None:
            current_min_dist = "-"
        else:
            current_min_dist = "{:.2f}".format(obj.current_min_distance)

        # No support for multiline text in opencv :facepalm:
        lines_to_draw = [
            "{}|{}".format(obj.id, obj.initializing_id),
            "a:{}".format(obj.age),
            "h:{}".format(obj.hit_counter),
            "ld:{}".format(last_dist),
            "cd:{}".format(current_min_dist),
        ]
        if draw_labels:
            lines_to_draw.append("l:{}".format(obj.label))

        for i, line in enumerate(lines_to_draw):
            draw_position = (
                int(draw_position[0]),
                int(draw_position[1] + i * text_size * 7 + 15),
            )
            cv2.putText(
                frame,
                line,
                draw_position,
                cv2.FONT_HERSHEY_SIMPLEX,
                text_size,
                text_color,
                text_thickness,
                cv2.LINE_AA,
            )

draw_boxes(frame, detections, line_color=None, line_width=None, random_color=False, color_by_label=False, draw_labels=False, label_size=None)

Draw draws a list of detections as boxes on a frame.

This function uses the first 2 points of your Detection instances to draw a box with those points as its corners.

Parameters:

Name	Type	Description	Default
frame	np.ndarray	The OpenCV frame to draw on.	required
detections	Sequence[Detection]	List of Detections to be drawn.	required
line_color	Optional[Tuple[int, int, int]], optional	Color of the boxes representing the detections.	None
line_width	Optional[int], optional	Width of the lines constituting the sides of the boxes representing the detections.	None
random_color	bool, optional	If True each detection will be colored with a random color.	False
color_by_label	bool, optional	If True detections will be colored by label.	False
draw_labels	bool, optional	If True the detection's label will be drawn along with the detected boxes.	False
label_size	Optional[int], optional	Size of the label being drawn along with the detected boxes.	None

Returns:

Type	Description
np.array	The frame.

Source code in norfair/drawing.py

def draw_boxes(
    frame: np.ndarray,
    detections: Sequence["Detection"],
    line_color: Optional[Tuple[int, int, int]] = None,
    line_width: Optional[int] = None,
    random_color: bool = False,
    color_by_label: bool = False,
    draw_labels: bool = False,
    label_size: Optional[int] = None,
):
    """
    Draw draws a list of detections as boxes on a frame.

    This function uses the first 2 points of your [`Detection`][norfair.tracker.Detection]
    instances to draw a box with those points as its corners.

    Parameters
    ----------
    frame : np.ndarray
        The OpenCV frame to draw on.
    detections : Sequence[Detection]
        List of [`Detection`](#detection)s to be drawn.
    line_color : Optional[Tuple[int, int, int]], optional
        [Color][norfair.drawing.Color] of the boxes representing the detections.
    line_width : Optional[int], optional
        Width of the lines constituting the sides of the boxes representing the detections.
    random_color : bool, optional
        If `True` each detection will be colored with a random color.
    color_by_label : bool, optional
        If `True` detections will be colored by label.
    draw_labels : bool, optional
        If `True` the detection's label will be drawn along with the detected boxes.
    label_size : Optional[int], optional
        Size of the label being drawn along with the detected boxes.

    Returns
    -------
    np.array
        The frame.
    """
    frame_scale = frame.shape[0] / 100
    if detections is None:
        return frame
    if line_width is None:
        line_width = int(max(frame_scale / 7, 1))
    if line_color is None:
        line_color = Color.red
    if label_size is None:
        label_size = int(max(frame_scale / 100, 1))
    for d in detections:
        if color_by_label:
            line_color = Color.random(abs(hash(d.label)))
        elif random_color:
            line_color = Color.random(random.randint(0, 20))
        points = d.points
        points = validate_points(points)
        points = points.astype(int)
        cv2.rectangle(
            frame,
            tuple(points[0, :]),
            tuple(points[1, :]),
            color=line_color,
            thickness=line_width,
        )

        if draw_labels:
            label_draw_position = np.array(points[0, :])
            cv2.putText(
                frame,
                f"L: {d.label}",
                tuple(label_draw_position),
                cv2.FONT_HERSHEY_SIMPLEX,
                label_size,
                line_color,
                line_width,
                cv2.LINE_AA,
            )

    return frame

draw_tracked_boxes(frame, objects, border_colors=None, border_width=None, id_size=None, id_thickness=None, draw_box=True, color_by_label=False, draw_labels=False, label_size=None, label_width=None)

Draw draws a list of tracked objects on a frame.

This function uses the first 2 points of your TrackedObject instances to draw a box with those points as its corners.

Parameters:

Name	Type	Description	Default
frame	np.ndarray	The OpenCV frame to draw on.	required
objects	Sequence[TrackedObject]	List of TrackedObject to be drawn.	required
border_colors	Optional[Tuple[int, int, int]], optional	Color of the boxes representing the tracked objects.	None
border_width	Optional[int], optional	Width of the lines constituting the sides of the boxes representing the tracked objects.	None
id_size	Optional[int], optional	Size of the id number being drawn on each tracked object. The id wont get drawn if id_size is set to 0.	None
id_thickness	Optional[int], optional	Thickness of the id number being drawn on each tracked object.	None
draw_box	bool, optional	Boolean determining if the function should draw the boxes estimated by the tracked objects. If set to True the boxes get drawn, if set to False only the id numbers get drawn.	True
color_by_label	bool, optional	If True objects will be colored by label.	False
draw_labels	bool, optional	If True the objects's label will be drawn along with the tracked boxes.	False
label_size	Optional[int], optional	Size of the label being drawn along with the tracked boxes.	None
label_width	Optional[int], optional	Thickness of the label being drawn along with the tracked boxes.	None

Returns:

Type	Description
np.array	The frame

Source code in norfair/drawing.py

def draw_tracked_boxes(
    frame: np.ndarray,
    objects: Sequence["TrackedObject"],
    border_colors: Optional[Tuple[int, int, int]] = None,
    border_width: Optional[int] = None,
    id_size: Optional[int] = None,
    id_thickness: Optional[int] = None,
    draw_box: bool = True,
    color_by_label: bool = False,
    draw_labels: bool = False,
    label_size: Optional[int] = None,
    label_width: Optional[int] = None,
) -> np.array:
    """
    Draw draws a list of tracked objects on a frame.

    This function uses the first 2 points of your [`TrackedObject`][norfair.tracker.TrackedObject]
    instances to draw a box with those points as its corners.

    Parameters
    ----------
    frame : np.ndarray
        The OpenCV frame to draw on.
    objects : Sequence[TrackedObject]
        List of [`TrackedObject`][norfair.tracker.TrackedObject] to be drawn.
    border_colors : Optional[Tuple[int, int, int]], optional
        [Color][norfair.drawing.Color] of the boxes representing the tracked objects.
    border_width : Optional[int], optional
        Width of the lines constituting the sides of the boxes representing the tracked objects.
    id_size : Optional[int], optional
        Size of the id number being drawn on each tracked object. The id wont get drawn if `id_size` is set to 0.
    id_thickness : Optional[int], optional
        Thickness of the id number being drawn on each tracked object.
    draw_box : bool, optional
        Boolean determining if the function should draw the boxes estimated by the tracked objects.

        If set to `True` the boxes get drawn, if set to `False` only the id numbers get drawn.
    color_by_label : bool, optional
        If `True` objects will be colored by label.
    draw_labels : bool, optional
        If `True` the objects's label will be drawn along with the tracked boxes.
    label_size : Optional[int], optional
        Size of the label being drawn along with the tracked boxes.
    label_width : Optional[int], optional
        Thickness of the label being drawn along with the tracked boxes.

    Returns
    -------
    np.array
        The frame
    """

    frame_scale = frame.shape[0] / 100
    if border_width is None:
        border_width = int(frame_scale * 0.5)
    if label_width is None:
        label_width = int(max(frame_scale / 7, 2))
    if label_size is None:
        label_size = int(max(frame_scale / 100, 1))
    if id_size is None:
        id_size = frame_scale / 10
    if id_thickness is None:
        id_thickness = int(frame_scale / 5)
    if isinstance(border_colors, tuple):
        border_colors = [border_colors]

    for n, obj in enumerate(objects):
        if not obj.live_points.any():
            continue
        if color_by_label:
            color = Color.random(abs(hash(obj.label)))
        elif border_colors is None:
            color = Color.random(obj.id)
        else:
            color = border_colors[n % len(border_colors)]

        points = obj.estimate
        if draw_box:
            points = points.astype(int)
            cv2.rectangle(
                frame,
                tuple(points[0, :]),
                tuple(points[1, :]),
                color=color,
                thickness=border_width,
            )

            if draw_labels:
                label_draw_position = np.array(points[0, :])
                cv2.putText(
                    frame,
                    f"L: {obj.label}",
                    tuple(label_draw_position),
                    cv2.FONT_HERSHEY_SIMPLEX,
                    label_size,
                    color,
                    label_width,
                    cv2.LINE_AA,
                )

        if id_size > 0:
            id_draw_position = np.mean(points, axis=0)
            id_draw_position = id_draw_position.astype(int)
            cv2.putText(
                frame,
                str(obj.id),
                tuple(id_draw_position),
                cv2.FONT_HERSHEY_SIMPLEX,
                id_size,
                color,
                id_thickness,
                cv2.LINE_AA,
            )
    return frame