ultralytics 8.3.15__py3-none-any.whl → 8.3.16__py3-none-any.whl

ultralytics/solutions/parking_management.py

@@ -5,237 +5,232 @@ import json
 import cv2
 import numpy as np
 
-from ultralytics.utils.checks import check_imshow, check_requirements
+from ultralytics.solutions.solutions import LOGGER, BaseSolution, check_requirements
 from ultralytics.utils.plotting import Annotator
 
 
 class ParkingPtsSelection:
-    """Class for selecting and managing parking zone points on images using a Tkinter-based UI."""
+    """
+    A class for selecting and managing parking zone points on images using a Tkinter-based UI.
+
+    This class provides functionality to upload an image, select points to define parking zones, and save the
+    selected points to a JSON file. It uses Tkinter for the graphical user interface.
+
+    Attributes:
+        tk (module): The Tkinter module for GUI operations.
+        filedialog (module): Tkinter's filedialog module for file selection operations.
+        messagebox (module): Tkinter's messagebox module for displaying message boxes.
+        master (tk.Tk): The main Tkinter window.
+        canvas (tk.Canvas): The canvas widget for displaying the image and drawing bounding boxes.
+        image (PIL.Image.Image): The uploaded image.
+        canvas_image (ImageTk.PhotoImage): The image displayed on the canvas.
+        rg_data (List[List[Tuple[int, int]]]): List of bounding boxes, each defined by 4 points.
+        current_box (List[Tuple[int, int]]): Temporary storage for the points of the current bounding box.
+        imgw (int): Original width of the uploaded image.
+        imgh (int): Original height of the uploaded image.
+        canvas_max_width (int): Maximum width of the canvas.
+        canvas_max_height (int): Maximum height of the canvas.
+
+    Methods:
+        setup_ui: Sets up the Tkinter UI components.
+        initialize_properties: Initializes the necessary properties.
+        upload_image: Uploads an image, resizes it to fit the canvas, and displays it.
+        on_canvas_click: Handles mouse clicks to add points for bounding boxes.
+        draw_box: Draws a bounding box on the canvas.
+        remove_last_bounding_box: Removes the last bounding box and redraws the canvas.
+        redraw_canvas: Redraws the canvas with the image and all bounding boxes.
+        save_to_json: Saves the bounding boxes to a JSON file.
+
+    Examples:
+        >>> parking_selector = ParkingPtsSelection()
+        >>> # Use the GUI to upload an image, select parking zones, and save the data
+    """
 
     def __init__(self):
-        """Initializes the UI for selecting parking zone points in a tkinter window."""
+        """Initializes the ParkingPtsSelection class, setting up UI and properties for parking zone point selection."""
         check_requirements("tkinter")
+        import tkinter as tk
+        from tkinter import filedialog, messagebox
 
-        import tkinter as tk  # scope for multi-environment compatibility
+        self.tk, self.filedialog, self.messagebox = tk, filedialog, messagebox
+        self.setup_ui()
+        self.initialize_properties()
+        self.master.mainloop()
 
-        self.tk = tk
-        self.master = tk.Tk()
+    def setup_ui(self):
+        """Sets up the Tkinter UI components for the parking zone points selection interface."""
+        self.master = self.tk.Tk()
         self.master.title("Ultralytics Parking Zones Points Selector")
-
-        # Disable window resizing
         self.master.resizable(False, False)
 
-        # Setup canvas for image display
+        # Canvas for image display
         self.canvas = self.tk.Canvas(self.master, bg="white")
+        self.canvas.pack(side=self.tk.BOTTOM)
 
-        # Setup buttons
+        # Button frame with buttons
         button_frame = self.tk.Frame(self.master)
         button_frame.pack(side=self.tk.TOP)
 
-        self.tk.Button(button_frame, text="Upload Image", command=self.upload_image).grid(row=0, column=0)
-        self.tk.Button(button_frame, text="Remove Last BBox", command=self.remove_last_bounding_box).grid(
-            row=0, column=1
-        )
-        self.tk.Button(button_frame, text="Save", command=self.save_to_json).grid(row=0, column=2)
-
-        # Initialize properties
-        self.image_path = None
-        self.image = None
-        self.canvas_image = None
-        self.rg_data = []  # region coordinates
-        self.current_box = []
-        self.imgw = 0  # image width
-        self.imgh = 0  # image height
+        for text, cmd in [
+            ("Upload Image", self.upload_image),
+            ("Remove Last BBox", self.remove_last_bounding_box),
+            ("Save", self.save_to_json),
+        ]:
+            self.tk.Button(button_frame, text=text, command=cmd).pack(side=self.tk.LEFT)
 
-        # Constants
-        self.canvas_max_width = 1280
-        self.canvas_max_height = 720
-
-        self.master.mainloop()
+    def initialize_properties(self):
+        """Initialize properties for image, canvas, bounding boxes, and dimensions."""
+        self.image = self.canvas_image = None
+        self.rg_data, self.current_box = [], []
+        self.imgw = self.imgh = 0
+        self.canvas_max_width, self.canvas_max_height = 1280, 720
 
     def upload_image(self):
-        """Upload an image and resize it to fit canvas."""
-        from tkinter import filedialog
-
+        """Uploads and displays an image on the canvas, resizing it to fit within specified dimensions."""
         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:
+        self.image = Image.open(self.filedialog.askopenfilename(filetypes=[("Image Files", "*.png;*.jpg;*.jpeg")]))
+        if not self.image:
             return
 
-        self.image = Image.open(self.image_path)
         self.imgw, self.imgh = self.image.size
-
-        # Calculate the aspect ratio and resize image
         aspect_ratio = self.imgw / self.imgh
-        if aspect_ratio > 1:
-            # Landscape orientation
-            canvas_width = min(self.canvas_max_width, self.imgw)
-            canvas_height = int(canvas_width / aspect_ratio)
-        else:
-            # Portrait orientation
-            canvas_height = min(self.canvas_max_height, self.imgh)
-            canvas_width = int(canvas_height * aspect_ratio)
-
-        # Check if canvas is already initialized
-        if self.canvas:
-            self.canvas.destroy()  # Destroy previous canvas
-
-        self.canvas = self.tk.Canvas(self.master, bg="white", width=canvas_width, height=canvas_height)
-        resized_image = self.image.resize((canvas_width, canvas_height), Image.LANCZOS)
-        self.canvas_image = ImageTk.PhotoImage(resized_image)
-        self.canvas.create_image(0, 0, anchor=self.tk.NW, image=self.canvas_image)
+        canvas_width = (
+            min(self.canvas_max_width, self.imgw) if aspect_ratio > 1 else int(self.canvas_max_height * aspect_ratio)
+        )
+        canvas_height = (
+            min(self.canvas_max_height, self.imgh) if aspect_ratio <= 1 else int(canvas_width / aspect_ratio)
+        )
 
-        self.canvas.pack(side=self.tk.BOTTOM)
+        self.canvas.config(width=canvas_width, height=canvas_height)
+        self.canvas_image = ImageTk.PhotoImage(self.image.resize((canvas_width, canvas_height), Image.LANCZOS))
+        self.canvas.create_image(0, 0, anchor=self.tk.NW, image=self.canvas_image)
         self.canvas.bind("<Button-1>", self.on_canvas_click)
 
-        # Reset bounding boxes and current box
-        self.rg_data = []
-        self.current_box = []
+        self.rg_data.clear(), self.current_box.clear()
 
     def on_canvas_click(self, event):
-        """Handle mouse clicks on canvas to create points for bounding boxes."""
+        """Handles mouse clicks to add points for bounding boxes on the canvas."""
         self.current_box.append((event.x, event.y))
         self.canvas.create_oval(event.x - 3, event.y - 3, event.x + 3, event.y + 3, fill="red")
-
         if len(self.current_box) == 4:
-            self.rg_data.append(self.current_box)
-            [
-                self.canvas.create_line(self.current_box[i], self.current_box[(i + 1) % 4], fill="blue", width=2)
-                for i in range(4)
-            ]
-            self.current_box = []
+            self.rg_data.append(self.current_box.copy())
+            self.draw_box(self.current_box)
+            self.current_box.clear()
 
-    def remove_last_bounding_box(self):
-        """Remove the last drawn bounding box from canvas."""
-        from tkinter import messagebox  # scope for multi-environment compatibility
+    def draw_box(self, box):
+        """Draws a bounding box on the canvas using the provided coordinates."""
+        for i in range(4):
+            self.canvas.create_line(box[i], box[(i + 1) % 4], fill="blue", width=2)
 
-        if self.rg_data:
-            self.rg_data.pop()  # Remove the last bounding box
-            self.canvas.delete("all")  # Clear the canvas
-            self.canvas.create_image(0, 0, anchor=self.tk.NW, image=self.canvas_image)  # Redraw the image
+    def remove_last_bounding_box(self):
+        """Removes the last bounding box from the list and redraws the canvas."""
+        if not self.rg_data:
+            self.messagebox.showwarning("Warning", "No bounding boxes to remove.")
+            return
+        self.rg_data.pop()
+        self.redraw_canvas()
 
-            # Redraw all bounding boxes
-            for box in self.rg_data:
-                [self.canvas.create_line(box[i], box[(i + 1) % 4], fill="blue", width=2) for i in range(4)]
-            messagebox.showinfo("Success", "Last bounding box removed.")
-        else:
-            messagebox.showwarning("Warning", "No bounding boxes to remove.")
+    def redraw_canvas(self):
+        """Redraws the canvas with the image and all bounding boxes."""
+        self.canvas.delete("all")
+        self.canvas.create_image(0, 0, anchor=self.tk.NW, image=self.canvas_image)
+        for box in self.rg_data:
+            self.draw_box(box)
 
     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
-
-        rg_data = []  # regions data
-        for box in self.rg_data:
-            rs_box = [
-                (
-                    int(x * self.imgw / self.canvas.winfo_width()),  # width scaling
-                    int(y * self.imgh / self.canvas.winfo_height()),  # height scaling
-                )
-                for x, y in box
-            ]
-            rg_data.append({"points": rs_box})
+        """Saves the selected parking zone points to a JSON file with scaled coordinates."""
+        scale_w, scale_h = self.imgw / self.canvas.winfo_width(), self.imgh / self.canvas.winfo_height()
+        data = [{"points": [(int(x * scale_w), int(y * scale_h)) for x, y in box]} for box in self.rg_data]
         with open("bounding_boxes.json", "w") as f:
-            json.dump(rg_data, f, indent=4)
+            json.dump(data, f, indent=4)
+        self.messagebox.showinfo("Success", "Bounding boxes saved to bounding_boxes.json")
 
-        messagebox.showinfo("Success", "Bounding boxes saved to bounding_boxes.json")
 
+class ParkingManagement(BaseSolution):
+    """
+    Manages parking occupancy and availability using YOLO model for real-time monitoring and visualization.
 
-class ParkingManagement:
-    """Manages parking occupancy and availability using YOLO model for real-time monitoring and visualization."""
+    This class extends BaseSolution to provide functionality for parking lot management, including detection of
+    occupied spaces, visualization of parking regions, and display of occupancy statistics.
 
-    def __init__(
-        self,
-        model,  # Ultralytics YOLO model file path
-        json_file,  # Parking management annotation file created from Parking Annotator
-        occupied_region_color=(0, 0, 255),  # occupied region color
-        available_region_color=(0, 255, 0),  # available region color
-    ):
-        """
-        Initializes the parking management system with a YOLO model and visualization settings.
+    Attributes:
+        json_file (str): Path to the JSON file containing parking region details.
+        json (List[Dict]): Loaded JSON data containing parking region information.
+        pr_info (Dict[str, int]): Dictionary storing parking information (Occupancy and Available spaces).
+        arc (Tuple[int, int, int]): RGB color tuple for available region visualization.
+        occ (Tuple[int, int, int]): RGB color tuple for occupied region visualization.
+        dc (Tuple[int, int, int]): RGB color tuple for centroid visualization of detected objects.
 
-        Args:
-            model (str): Path to the YOLO model.
-            json_file (str): file that have all parking slot points data
-            occupied_region_color (tuple): RGB color tuple for occupied regions.
-            available_region_color (tuple): RGB color tuple for available regions.
-        """
-        # Model initialization
-        from ultralytics import YOLO
+    Methods:
+        process_data: Processes model data for parking lot management and visualization.
 
-        self.model = YOLO(model)
+    Examples:
+        >>> from ultralytics.solutions import ParkingManagement
+        >>> parking_manager = ParkingManagement(model="yolov8n.pt", json_file="parking_regions.json")
+        >>> results = parking_manager(source="parking_lot_video.mp4")
+        >>> print(f"Occupied spaces: {parking_manager.pr_info['Occupancy']}")
+        >>> print(f"Available spaces: {parking_manager.pr_info['Available']}")
+    """
 
-        # Load JSON data
-        with open(json_file) as f:
-            self.json_data = json.load(f)
+    def __init__(self, **kwargs):
+        """Initializes the parking management system with a YOLO model and visualization settings."""
+        super().__init__(**kwargs)
 
-        self.pr_info = {"Occupancy": 0, "Available": 0}  # dictionary for parking information
+        self.json_file = self.CFG["json_file"]  # Load JSON data
+        if self.json_file is None:
+            LOGGER.warning("❌ json_file argument missing. Parking region details required.")
+            raise ValueError("❌ Json file path can not be empty")
 
-        self.occ = occupied_region_color
-        self.arc = available_region_color
+        with open(self.json_file) as f:
+            self.json = json.load(f)
 
-        self.env_check = check_imshow(warn=True)  # check if environment supports imshow
+        self.pr_info = {"Occupancy": 0, "Available": 0}  # dictionary for parking information
 
-    def process_data(self, im0):
-        """
-        Process the model data for parking lot management.
+        self.arc = (0, 0, 255)  # available region color
+        self.occ = (0, 255, 0)  # occupied region color
+        self.dc = (255, 0, 189)  # centroid color for each box
 
-        Args:
-            im0 (ndarray): inference image
+    def process_data(self, im0):
         """
-        results = self.model.track(im0, persist=True, show=False)  # object tracking
+        Processes the model data for parking lot management.
 
-        es, fs = len(self.json_data), 0  # empty slots, filled slots
-        annotator = Annotator(im0)  # init annotator
+        This function analyzes the input image, extracts tracks, and determines the occupancy status of parking
+        regions defined in the JSON file. It annotates the image with occupied and available parking spots,
+        and updates the parking information.
 
-        # extract tracks data
-        if results[0].boxes.id is None:
-            self.display_frames(im0)
-            return im0
+        Args:
+            im0 (np.ndarray): The input inference image.
 
-        boxes = results[0].boxes.xyxy.cpu().tolist()
-        clss = results[0].boxes.cls.cpu().tolist()
+        Examples:
+            >>> parking_manager = ParkingManagement(json_file="parking_regions.json")
+            >>> image = cv2.imread("parking_lot.jpg")
+            >>> parking_manager.process_data(image)
+        """
+        self.extract_tracks(im0)  # extract tracks from im0
+        es, fs = len(self.json), 0  # empty slots, filled slots
+        annotator = Annotator(im0, self.line_width)  # init annotator
 
-        for region in self.json_data:
+        for region in self.json:
             # Convert points to a NumPy array with the correct dtype and reshape properly
             pts_array = np.array(region["points"], dtype=np.int32).reshape((-1, 1, 2))
             rg_occupied = False  # occupied region initialization
-            for box, cls in zip(boxes, clss):
-                xc = int((box[0] + box[2]) / 2)
-                yc = int((box[1] + box[3]) / 2)
-                annotator.display_objects_labels(
-                    im0, self.model.names[int(cls)], (104, 31, 17), (255, 255, 255), xc, yc, 10
-                )
+            for box, cls in zip(self.boxes, self.clss):
+                xc, yc = int((box[0] + box[2]) / 2), int((box[1] + box[3]) / 2)
                 dist = cv2.pointPolygonTest(pts_array, (xc, yc), False)
                 if dist >= 0:
+                    # cv2.circle(im0, (xc, yc), radius=self.line_width * 4, color=self.dc, thickness=-1)
+                    annotator.display_objects_labels(
+                        im0, self.model.names[int(cls)], (104, 31, 17), (255, 255, 255), xc, yc, 10
+                    )
                     rg_occupied = True
                     break
-            if rg_occupied:
-                fs += 1
-                es -= 1
-
+            fs, es = (fs + 1, es - 1) if rg_occupied else (fs, es)
             # Plotting regions
-            color = self.occ if rg_occupied else self.arc
-            cv2.polylines(im0, [pts_array], isClosed=True, color=color, thickness=2)
+            cv2.polylines(im0, [pts_array], isClosed=True, color=self.occ if rg_occupied else self.arc, thickness=2)
 
-        self.pr_info["Occupancy"] = fs
-        self.pr_info["Available"] = es
+        self.pr_info["Occupancy"], self.pr_info["Available"] = fs, es
 
         annotator.display_analytics(im0, self.pr_info, (104, 31, 17), (255, 255, 255), 10)
-
-        self.display_frames(im0)
-        return im0
-
-    def display_frames(self, im0):
-        """
-        Display frame.
-
-        Args:
-            im0 (ndarray): inference image
-        """
-        if self.env_check:
-            cv2.imshow("Ultralytics Parking Manager", im0)
-            # Break Window
-            if cv2.waitKey(1) & 0xFF == ord("q"):
-                return
+        self.display_output(im0)  # display output with base class function
+        return im0  # return output image for more usage

ultralytics/solutions/queue_management.py

@@ -1,16 +1,40 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
-from shapely.geometry import Point
-
-from ultralytics.solutions.solutions import BaseSolution  # Import a parent class
+from ultralytics.solutions.solutions import BaseSolution
 from ultralytics.utils.plotting import Annotator, colors
 
 
 class QueueManager(BaseSolution):
-    """A class to manage the queue in a real-time video stream based on object tracks."""
+    """
+    Manages queue counting in real-time video streams based on object tracks.
+
+    This class extends BaseSolution to provide functionality for tracking and counting objects within a specified
+    region in video frames.
+
+    Attributes:
+        counts (int): The current count of objects in the queue.
+        rect_color (Tuple[int, int, int]): RGB color tuple for drawing the queue region rectangle.
+        region_length (int): The number of points defining the queue region.
+        annotator (Annotator): An instance of the Annotator class for drawing on frames.
+        track_line (List[Tuple[int, int]]): List of track line coordinates.
+        track_history (Dict[int, List[Tuple[int, int]]]): Dictionary storing tracking history for each object.
+
+    Methods:
+        initialize_region: Initializes the queue region.
+        process_queue: Processes a single frame for queue management.
+        extract_tracks: Extracts object tracks from the current frame.
+        store_tracking_history: Stores the tracking history for an object.
+        display_output: Displays the processed output.
+
+    Examples:
+        >>> queue_manager = QueueManager(source="video.mp4", region=[100, 100, 200, 200, 300, 300])
+        >>> for frame in video_stream:
+        ...     processed_frame = queue_manager.process_queue(frame)
+        ...     cv2.imshow("Queue Management", processed_frame)
+    """
 
     def __init__(self, **kwargs):
-        """Initializes the QueueManager with specified parameters for tracking and counting objects."""
+        """Initializes the QueueManager with parameters for tracking and counting objects in a video stream."""
         super().__init__(**kwargs)
         self.initialize_region()
         self.counts = 0  # Queue counts Information
@@ -19,12 +43,31 @@ class QueueManager(BaseSolution):
 
     def process_queue(self, im0):
         """
-        Main function to start the queue management process.
+        Processes the queue management for a single frame of video.
 
         Args:
-            im0 (ndarray): The input image that will be used for processing
-        Returns
-            im0 (ndarray): The processed image for more usage
+            im0 (numpy.ndarray): Input image for processing, typically a frame from a video stream.
+
+        Returns:
+            (numpy.ndarray): Processed image with annotations, bounding boxes, and queue counts.
+
+        This method performs the following steps:
+        1. Resets the queue count for the current frame.
+        2. Initializes an Annotator object for drawing on the image.
+        3. Extracts tracks from the image.
+        4. Draws the counting region on the image.
+        5. For each detected object:
+           - Draws bounding boxes and labels.
+           - Stores tracking history.
+           - Draws centroids and tracks.
+           - Checks if the object is inside the counting region and updates the count.
+        6. Displays the queue count on the image.
+        7. Displays the processed output.
+
+        Examples:
+            >>> queue_manager = QueueManager()
+            >>> frame = cv2.imread("frame.jpg")
+            >>> processed_frame = queue_manager.process_queue(frame)
         """
         self.counts = 0  # Reset counts every frame
         self.annotator = Annotator(im0, line_width=self.line_width)  # Initialize annotator
@@ -48,8 +91,10 @@ class QueueManager(BaseSolution):
             track_history = self.track_history.get(track_id, [])
 
             # store previous position of track and check if the object is inside the counting region
-            prev_position = track_history[-2] if len(track_history) > 1 else None
-            if self.region_length >= 3 and prev_position and self.r_s.contains(Point(self.track_line[-1])):
+            prev_position = None
+            if len(track_history) > 1:
+                prev_position = track_history[-2]
+            if self.region_length >= 3 and prev_position and self.r_s.contains(self.Point(self.track_line[-1])):
                 self.counts += 1
 
         # Display queue counts

ultralytics/solutions/solutions.py

@@ -9,21 +9,51 @@ from ultralytics import YOLO
 from ultralytics.utils import LOGGER, yaml_load
 from ultralytics.utils.checks import check_imshow, check_requirements
 
-check_requirements("shapely>=2.0.0")
-from shapely.geometry import LineString, Polygon
-
 DEFAULT_SOL_CFG_PATH = Path(__file__).resolve().parents[1] / "cfg/solutions/default.yaml"
 
 
 class BaseSolution:
-    """A class to manage all the Ultralytics Solutions: https://docs.ultralytics.com/solutions/."""
+    """
+    A base class for managing Ultralytics Solutions.
+
+    This class provides core functionality for various Ultralytics Solutions, including model loading, object tracking,
+    and region initialization.
+
+    Attributes:
+        LineString (shapely.geometry.LineString): Class for creating line string geometries.
+        Polygon (shapely.geometry.Polygon): Class for creating polygon geometries.
+        Point (shapely.geometry.Point): Class for creating point geometries.
+        CFG (Dict): Configuration dictionary loaded from a YAML file and updated with kwargs.
+        region (List[Tuple[int, int]]): List of coordinate tuples defining a region of interest.
+        line_width (int): Width of lines used in visualizations.
+        model (ultralytics.YOLO): Loaded YOLO model instance.
+        names (Dict[int, str]): Dictionary mapping class indices to class names.
+        env_check (bool): Flag indicating whether the environment supports image display.
+        track_history (collections.defaultdict): Dictionary to store tracking history for each object.
+
+    Methods:
+        extract_tracks: Apply object tracking and extract tracks from an input image.
+        store_tracking_history: Store object tracking history for a given track ID and bounding box.
+        initialize_region: Initialize the counting region and line segment based on configuration.
+        display_output: Display the results of processing, including showing frames or saving results.
+
+    Examples:
+        >>> solution = BaseSolution(model="yolov8n.pt", region=[(0, 0), (100, 0), (100, 100), (0, 100)])
+        >>> solution.initialize_region()
+        >>> image = cv2.imread("image.jpg")
+        >>> solution.extract_tracks(image)
+        >>> solution.display_output(image)
+    """
 
     def __init__(self, **kwargs):
-        """
-        Base initializer for all solutions.
+        """Initializes the BaseSolution class with configuration settings and YOLO model for Ultralytics solutions."""
+        check_requirements("shapely>=2.0.0")
+        from shapely.geometry import LineString, Point, Polygon
+
+        self.LineString = LineString
+        self.Polygon = Polygon
+        self.Point = Point
 
-        Child classes should call this with necessary parameters.
-        """
         # Load config and update with args
         self.CFG = yaml_load(DEFAULT_SOL_CFG_PATH)
         self.CFG.update(kwargs)
@@ -42,10 +72,15 @@ class BaseSolution:
 
     def extract_tracks(self, im0):
         """
-        Apply object tracking and extract tracks.
+        Applies object tracking and extracts tracks from an input image or frame.
 
         Args:
-            im0 (ndarray): The input image or frame
+            im0 (ndarray): The input image or frame.
+
+        Examples:
+            >>> solution = BaseSolution()
+            >>> frame = cv2.imread("path/to/image.jpg")
+            >>> solution.extract_tracks(frame)
         """
         self.tracks = self.model.track(source=im0, persist=True, classes=self.CFG["classes"])
 
@@ -62,11 +97,18 @@ class BaseSolution:
 
     def store_tracking_history(self, track_id, box):
         """
-        Store object tracking history.
+        Stores the tracking history of an object.
+
+        This method updates the tracking history for a given object by appending the center point of its
+        bounding box to the track line. It maintains a maximum of 30 points in the tracking history.
 
         Args:
-            track_id (int): The track ID of the object
-            box (list): Bounding box coordinates of the object
+            track_id (int): The unique identifier for the tracked object.
+            box (List[float]): The bounding box coordinates of the object in the format [x1, y1, x2, y2].
+
+        Examples:
+            >>> solution = BaseSolution()
+            >>> solution.store_tracking_history(1, [100, 200, 300, 400])
         """
         # Store tracking history
         self.track_line = self.track_history[track_id]
@@ -75,19 +117,32 @@ class BaseSolution:
             self.track_line.pop(0)
 
     def initialize_region(self):
-        """Initialize the counting region and line segment based on config."""
-        self.region = [(20, 400), (1080, 404), (1080, 360), (20, 360)] if self.region is None else self.region
-        self.r_s = Polygon(self.region) if len(self.region) >= 3 else LineString(self.region)  # region segment
-        self.l_s = LineString(
-            [(self.region[0][0], self.region[0][1]), (self.region[1][0], self.region[1][1])]
-        )  # line segment
+        """Initialize the counting region and line segment based on configuration settings."""
+        if self.region is None:
+            self.region = [(20, 400), (1080, 404), (1080, 360), (20, 360)]
+        self.r_s = (
+            self.Polygon(self.region) if len(self.region) >= 3 else self.LineString(self.region)
+        )  # region or line
 
     def display_output(self, im0):
         """
         Display the results of the processing, which could involve showing frames, printing counts, or saving results.
 
+        This method is responsible for visualizing the output of the object detection and tracking process. It displays
+        the processed frame with annotations, and allows for user interaction to close the display.
+
         Args:
-            im0 (ndarray): The input image or frame
+            im0 (numpy.ndarray): The input image or frame that has been processed and annotated.
+
+        Examples:
+            >>> solution = BaseSolution()
+            >>> frame = cv2.imread("path/to/image.jpg")
+            >>> solution.display_output(frame)
+
+        Notes:
+            - This method will only display output if the 'show' configuration is set to True and the environment
+              supports image display.
+            - The display can be closed by pressing the 'q' key.
         """
         if self.CFG.get("show") and self.env_check:
             cv2.imshow("Ultralytics Solutions", im0)