dgenerate-ultralytics-headless 8.3.137__py3-none-any.whl → 8.3.224__py3-none-any.whl

ultralytics/solutions/object_counter.py

@@ -1,14 +1,16 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
+from __future__ import annotations
+
 from collections import defaultdict
+from typing import Any
 
 from ultralytics.solutions.solutions import BaseSolution, SolutionAnnotator, SolutionResults
 from ultralytics.utils.plotting import colors
 
 
 class ObjectCounter(BaseSolution):
-    """
-    A class to manage the counting of objects in a real-time video stream based on their tracks.
+    """A class to manage the counting of objects in a real-time video stream based on their tracks.
 
     This class extends the BaseSolution class and provides functionality for counting objects moving in and out of a
     specified region in a video stream. It supports both polygonal and linear regions for counting.
@@ -16,16 +18,17 @@ class ObjectCounter(BaseSolution):
     Attributes:
         in_count (int): Counter for objects moving inward.
         out_count (int): Counter for objects moving outward.
-        counted_ids (List[int]): List of IDs of objects that have been counted.
-        classwise_counts (Dict[str, Dict[str, int]]): Dictionary for counts, categorized by object class.
+        counted_ids (list[int]): List of IDs of objects that have been counted.
+        classwise_counts (dict[str, dict[str, int]]): Dictionary for counts, categorized by object class.
         region_initialized (bool): Flag indicating whether the counting region has been initialized.
         show_in (bool): Flag to control display of inward count.
         show_out (bool): Flag to control display of outward count.
+        margin (int): Margin for background rectangle size to display counts properly.
 
     Methods:
-        count_objects: Counts objects within a polygonal or linear region.
-        display_counts: Displays object counts on the frame.
-        process: Processes input data (frames or object tracks) and updates counts.
+        count_objects: Count objects within a polygonal or linear region based on their tracks.
+        display_counts: Display object counts on the frame.
+        process: Process input data and update counts.
 
     Examples:
         >>> counter = ObjectCounter()
@@ -34,28 +37,33 @@ class ObjectCounter(BaseSolution):
         >>> print(f"Inward count: {counter.in_count}, Outward count: {counter.out_count}")
     """
 
-    def __init__(self, **kwargs):
-        """Initializes the ObjectCounter class for real-time object counting in video streams."""
+    def __init__(self, **kwargs: Any) -> None:
+        """Initialize the ObjectCounter class for real-time object counting in video streams."""
         super().__init__(**kwargs)
 
         self.in_count = 0  # Counter for objects moving inward
         self.out_count = 0  # Counter for objects moving outward
         self.counted_ids = []  # List of IDs of objects that have been counted
-        self.classwise_counts = defaultdict(lambda: {"IN": 0, "OUT": 0})  # Dictionary for counts, categorized by class
+        self.classwise_count = defaultdict(lambda: {"IN": 0, "OUT": 0})  # Dictionary for counts, categorized by class
         self.region_initialized = False  # Flag indicating whether the region has been initialized
 
         self.show_in = self.CFG["show_in"]
         self.show_out = self.CFG["show_out"]
         self.margin = self.line_width * 2  # Scales the background rectangle size to display counts properly
 
-    def count_objects(self, current_centroid, track_id, prev_position, cls):
-        """
-        Counts objects within a polygonal or linear region based on their tracks.
+    def count_objects(
+        self,
+        current_centroid: tuple[float, float],
+        track_id: int,
+        prev_position: tuple[float, float] | None,
+        cls: int,
+    ) -> None:
+        """Count objects within a polygonal or linear region based on their tracks.
 
         Args:
-            current_centroid (Tuple[float, float]): Current centroid coordinates (x, y) in the current frame.
+            current_centroid (tuple[float, float]): Current centroid coordinates (x, y) in the current frame.
             track_id (int): Unique identifier for the tracked object.
-            prev_position (Tuple[float, float]): Last frame position coordinates (x, y) of the track.
+            prev_position (tuple[float, float], optional): Last frame position coordinates (x, y) of the track.
             cls (int): Class index for classwise count updates.
 
         Examples:
@@ -71,52 +79,46 @@ class ObjectCounter(BaseSolution):
             return
 
         if len(self.region) == 2:  # Linear region (defined as a line segment)
-            line = self.LineString(self.region)  # Check if the line intersects the trajectory of the object
-            if line.intersects(self.LineString([prev_position, current_centroid])):
+            if self.r_s.intersects(self.LineString([prev_position, current_centroid])):
                 # Determine orientation of the region (vertical or horizontal)
                 if abs(self.region[0][0] - self.region[1][0]) < abs(self.region[0][1] - self.region[1][1]):
                     # Vertical region: Compare x-coordinates to determine direction
                     if current_centroid[0] > prev_position[0]:  # Moving right
                         self.in_count += 1
-                        self.classwise_counts[self.names[cls]]["IN"] += 1
+                        self.classwise_count[self.names[cls]]["IN"] += 1
                     else:  # Moving left
                         self.out_count += 1
-                        self.classwise_counts[self.names[cls]]["OUT"] += 1
+                        self.classwise_count[self.names[cls]]["OUT"] += 1
                 # Horizontal region: Compare y-coordinates to determine direction
                 elif current_centroid[1] > prev_position[1]:  # Moving downward
                     self.in_count += 1
-                    self.classwise_counts[self.names[cls]]["IN"] += 1
+                    self.classwise_count[self.names[cls]]["IN"] += 1
                 else:  # Moving upward
                     self.out_count += 1
-                    self.classwise_counts[self.names[cls]]["OUT"] += 1
+                    self.classwise_count[self.names[cls]]["OUT"] += 1
                 self.counted_ids.append(track_id)
 
         elif len(self.region) > 2:  # Polygonal region
-            polygon = self.Polygon(self.region)
-            if polygon.contains(self.Point(current_centroid)):
+            if self.r_s.contains(self.Point(current_centroid)):
                 # Determine motion direction for vertical or horizontal polygons
                 region_width = max(p[0] for p in self.region) - min(p[0] for p in self.region)
                 region_height = max(p[1] for p in self.region) - min(p[1] for p in self.region)
 
-                if (
-                    region_width < region_height
-                    and current_centroid[0] > prev_position[0]
-                    or region_width >= region_height
-                    and current_centroid[1] > prev_position[1]
+                if (region_width < region_height and current_centroid[0] > prev_position[0]) or (
+                    region_width >= region_height and current_centroid[1] > prev_position[1]
                 ):  # Moving right or downward
                     self.in_count += 1
-                    self.classwise_counts[self.names[cls]]["IN"] += 1
+                    self.classwise_count[self.names[cls]]["IN"] += 1
                 else:  # Moving left or upward
                     self.out_count += 1
-                    self.classwise_counts[self.names[cls]]["OUT"] += 1
+                    self.classwise_count[self.names[cls]]["OUT"] += 1
                 self.counted_ids.append(track_id)
 
-    def display_counts(self, plot_im):
-        """
-        Display object counts on the input image or frame.
+    def display_counts(self, plot_im) -> None:
+        """Display object counts on the input image or frame.
 
         Args:
-            plot_im (numpy.ndarray): The image or frame to display counts on.
+            plot_im (np.ndarray): The image or frame to display counts on.
 
         Examples:
             >>> counter = ObjectCounter()
@@ -126,26 +128,25 @@ class ObjectCounter(BaseSolution):
         labels_dict = {
             str.capitalize(key): f"{'IN ' + str(value['IN']) if self.show_in else ''} "
             f"{'OUT ' + str(value['OUT']) if self.show_out else ''}".strip()
-            for key, value in self.classwise_counts.items()
-            if value["IN"] != 0 or value["OUT"] != 0
+            for key, value in self.classwise_count.items()
+            if value["IN"] != 0 or (value["OUT"] != 0 and (self.show_in or self.show_out))
         }
         if labels_dict:
             self.annotator.display_analytics(plot_im, labels_dict, (104, 31, 17), (255, 255, 255), self.margin)
 
-    def process(self, im0):
-        """
-        Process input data (frames or object tracks) and update object counts.
+    def process(self, im0) -> SolutionResults:
+        """Process input data (frames or object tracks) and update object counts.
 
-        This method initializes the counting region, extracts tracks, draws bounding boxes and regions, updates
-        object counts, and displays the results on the input image.
+        This method initializes the counting region, extracts tracks, draws bounding boxes and regions, updates object
+        counts, and displays the results on the input image.
 
         Args:
-            im0 (numpy.ndarray): The input image or frame to be processed.
+            im0 (np.ndarray): The input image or frame to be processed.
 
         Returns:
             (SolutionResults): Contains processed image `im0`, 'in_count' (int, count of objects entering the region),
-                'out_count' (int, count of objects exiting the region), 'classwise_count' (dict, per-class object count),
-                and 'total_tracks' (int, total number of tracked objects).
+                'out_count' (int, count of objects exiting the region), 'classwise_count' (dict, per-class object
+                count), and 'total_tracks' (int, total number of tracked objects).
 
         Examples:
             >>> counter = ObjectCounter()
@@ -159,10 +160,6 @@ class ObjectCounter(BaseSolution):
         self.extract_tracks(im0)  # Extract tracks
         self.annotator = SolutionAnnotator(im0, line_width=self.line_width)  # Initialize annotator
 
-        is_obb = getattr(self.tracks[0], "obb", None) is not None  # True if OBB results exist
-        if is_obb:
-            self.boxes = self.track_data.xyxyxyxy.reshape(-1, 4, 2).cpu()
-
         self.annotator.draw_region(
             reg_pts=self.region, color=(104, 0, 123), thickness=self.line_width * 2
         )  # Draw region
@@ -170,10 +167,8 @@ class ObjectCounter(BaseSolution):
         # Iterate over bounding boxes, track ids and classes index
         for box, track_id, cls, conf in zip(self.boxes, self.track_ids, self.clss, self.confs):
             # Draw bounding box and counting region
-            self.annotator.box_label(
-                box, label=self.adjust_box_label(cls, conf, track_id), color=colors(cls, True), rotated=is_obb
-            )
-            self.store_tracking_history(track_id, box, is_obb=is_obb)  # Store track history
+            self.annotator.box_label(box, label=self.adjust_box_label(cls, conf, track_id), color=colors(cls, True))
+            self.store_tracking_history(track_id, box)  # Store track history
 
             # Store previous position of track for object counting
             prev_position = None
@@ -190,6 +185,6 @@ class ObjectCounter(BaseSolution):
             plot_im=plot_im,
             in_count=self.in_count,
             out_count=self.out_count,
-            classwise_count=dict(self.classwise_counts),
+            classwise_count=dict(self.classwise_count),
             total_tracks=len(self.track_ids),
         )

ultralytics/solutions/object_cropper.py

@@ -2,14 +2,14 @@
 
 import os
 from pathlib import Path
+from typing import Any
 
 from ultralytics.solutions.solutions import BaseSolution, SolutionResults
 from ultralytics.utils.plotting import save_one_box
 
 
 class ObjectCropper(BaseSolution):
-    """
-    A class to manage the cropping of detected objects in a real-time video stream or images.
+    """A class to manage the cropping of detected objects in a real-time video stream or images.
 
     This class extends the BaseSolution class and provides functionality for cropping objects based on detected bounding
     boxes. The cropped images are saved to a specified directory for further analysis or usage.
@@ -21,7 +21,7 @@ class ObjectCropper(BaseSolution):
         conf (float): Confidence threshold for filtering detections.
 
     Methods:
-        process: Crops detected objects from the input image and saves them to the output directory.
+        process: Crop detected objects from the input image and save them to the output directory.
 
     Examples:
         >>> cropper = ObjectCropper()
@@ -30,13 +30,12 @@ class ObjectCropper(BaseSolution):
         >>> print(f"Total cropped objects: {cropper.crop_idx}")
     """
 
-    def __init__(self, **kwargs):
-        """
-        Initialize the ObjectCropper class for cropping objects from detected bounding boxes.
+    def __init__(self, **kwargs: Any) -> None:
+        """Initialize the ObjectCropper class for cropping objects from detected bounding boxes.
 
         Args:
-            **kwargs (Any): Keyword arguments passed to the parent class and used for configuration.
-                crop_dir (str): Path to the directory for saving cropped object images.
+            **kwargs (Any): Keyword arguments passed to the parent class and used for configuration including:
+                - crop_dir (str): Path to the directory for saving cropped object images.
         """
         super().__init__(**kwargs)
 
@@ -51,15 +50,15 @@ class ObjectCropper(BaseSolution):
         self.iou = self.CFG["iou"]
         self.conf = self.CFG["conf"]
 
-    def process(self, im0):
-        """
-        Crop detected objects from the input image and save them as separate images.
+    def process(self, im0) -> SolutionResults:
+        """Crop detected objects from the input image and save them as separate images.
 
         Args:
-            im0 (numpy.ndarray): The input image containing detected objects.
+            im0 (np.ndarray): The input image containing detected objects.
 
         Returns:
-            (SolutionResults): A SolutionResults object containing the total number of cropped objects and processed image.
+            (SolutionResults): A SolutionResults object containing the total number of cropped objects and processed
+                image.
 
         Examples:
             >>> cropper = ObjectCropper()
@@ -67,9 +66,16 @@ class ObjectCropper(BaseSolution):
             >>> results = cropper.process(frame)
             >>> print(f"Total cropped objects: {results.total_crop_objects}")
         """
-        results = self.model.predict(
-            im0, classes=self.classes, conf=self.conf, iou=self.iou, device=self.CFG["device"]
-        )[0]
+        with self.profilers[0]:
+            results = self.model.predict(
+                im0,
+                classes=self.classes,
+                conf=self.conf,
+                iou=self.iou,
+                device=self.CFG["device"],
+                verbose=False,
+            )[0]
+            self.clss = results.boxes.cls.tolist()  # required for logging only.
 
         for box in results.boxes:
             self.crop_idx += 1

ultralytics/solutions/parking_management.py

@@ -1,6 +1,9 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
+from __future__ import annotations
+
 import json
+from typing import Any
 
 import cv2
 import numpy as np
@@ -11,11 +14,10 @@ from ultralytics.utils.checks import check_imshow
 
 
 class ParkingPtsSelection:
-    """
-    A 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.
+    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.
@@ -25,30 +27,30 @@ class ParkingPtsSelection:
         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.
+        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:
-        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.
+        initialize_properties: Initialize properties for image, canvas, bounding boxes, and dimensions.
+        upload_image: Upload and display an image on the canvas, resizing it to fit within specified dimensions.
+        on_canvas_click: Handle mouse clicks to add points for bounding boxes on the canvas.
+        draw_box: Draw a bounding box on the canvas using the provided coordinates.
+        remove_last_bounding_box: Remove the last bounding box from the list and redraw the canvas.
+        redraw_canvas: Redraw the canvas with the image and all bounding boxes.
+        save_to_json: Save the selected parking zone points to a JSON file with scaled coordinates.
 
     Examples:
         >>> parking_selector = ParkingPtsSelection()
         >>> # Use the GUI to upload an image, select parking zones, and save the data
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initialize the ParkingPtsSelection class, setting up UI and properties for parking zone point selection."""
-        try:  # check if tkinter installed
+        try:  # Check if tkinter is installed
             import tkinter as tk
             from tkinter import filedialog, messagebox
         except ImportError:  # Display error with recommendations
@@ -68,19 +70,19 @@ class ParkingPtsSelection:
             return
 
         self.tk, self.filedialog, self.messagebox = tk, filedialog, messagebox
-        self.master = self.tk.Tk()  # Reference to the main application window or parent widget
+        self.master = self.tk.Tk()  # Reference to the main application window
         self.master.title("Ultralytics Parking Zones Points Selector")
         self.master.resizable(False, False)
 
-        self.canvas = self.tk.Canvas(self.master, bg="white")  # Canvas widget for displaying images or graphics
+        self.canvas = self.tk.Canvas(self.master, bg="white")  # Canvas widget for displaying images
         self.canvas.pack(side=self.tk.BOTTOM)
 
         self.image = None  # Variable to store the loaded image
         self.canvas_image = None  # Reference to the image displayed on the canvas
         self.canvas_max_width = None  # Maximum allowed width for the canvas
         self.canvas_max_height = None  # Maximum allowed height for the canvas
-        self.rg_data = None  # Data related to region or annotation management
-        self.current_box = None  # Stores the currently selected or active bounding box
+        self.rg_data = None  # Data for region annotation management
+        self.current_box = None  # Stores the currently selected bounding box
         self.imgh = None  # Height of the current image
         self.imgw = None  # Width of the current image
 
@@ -98,21 +100,23 @@ class ParkingPtsSelection:
         self.initialize_properties()
         self.master.mainloop()
 
-    def initialize_properties(self):
+    def initialize_properties(self) -> None:
         """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):
+    def upload_image(self) -> None:
         """Upload and display an image on the canvas, resizing it to fit within specified dimensions."""
-        from PIL import Image, ImageTk  # scope because ImageTk requires tkinter package
+        from PIL import Image, ImageTk  # Scoped import because ImageTk requires tkinter package
 
-        self.image = Image.open(self.filedialog.askopenfilename(filetypes=[("Image Files", "*.png *.jpg *.jpeg")]))
-        if not self.image:
+        file = self.filedialog.askopenfilename(filetypes=[("Image Files", "*.png *.jpg *.jpeg")])
+        if not file:
+            LOGGER.info("No image selected.")
             return
 
+        self.image = Image.open(file)
         self.imgw, self.imgh = self.image.size
         aspect_ratio = self.imgw / self.imgh
         canvas_width = (
@@ -129,7 +133,7 @@ class ParkingPtsSelection:
 
         self.rg_data.clear(), self.current_box.clear()
 
-    def on_canvas_click(self, event):
+    def on_canvas_click(self, event) -> None:
         """Handle 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")
@@ -138,12 +142,12 @@ class ParkingPtsSelection:
             self.draw_box(self.current_box)
             self.current_box.clear()
 
-    def draw_box(self, box):
+    def draw_box(self, box: list[tuple[int, int]]) -> None:
         """Draw 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)
 
-    def remove_last_bounding_box(self):
+    def remove_last_bounding_box(self) -> None:
         """Remove the last bounding box from the list and redraw the canvas."""
         if not self.rg_data:
             self.messagebox.showwarning("Warning", "No bounding boxes to remove.")
@@ -151,19 +155,19 @@ class ParkingPtsSelection:
         self.rg_data.pop()
         self.redraw_canvas()
 
-    def redraw_canvas(self):
+    def redraw_canvas(self) -> None:
         """Redraw 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):
+    def save_to_json(self) -> None:
         """Save 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]
 
-        from io import StringIO  # Function level import, as it's only required to store coordinates, not every frame
+        from io import StringIO  # Function level import, as it's only required to store coordinates
 
         write_buffer = StringIO()
         json.dump(data, write_buffer, indent=4)
@@ -173,22 +177,21 @@ class ParkingPtsSelection:
 
 
 class ParkingManagement(BaseSolution):
-    """
-    Manages parking occupancy and availability using YOLO model for real-time monitoring and visualization.
+    """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.
+    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.
 
     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.
+        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.
 
     Methods:
-        process: Processes the input image for parking lot management and visualization.
+        process: Process the input image for parking lot management and visualization.
 
     Examples:
         >>> from ultralytics.solutions import ParkingManagement
@@ -197,7 +200,7 @@ class ParkingManagement(BaseSolution):
         >>> print(f"Available spaces: {parking_manager.pr_info['Available']}")
     """
 
-    def __init__(self, **kwargs):
+    def __init__(self, **kwargs: Any) -> None:
         """Initialize the parking management system with a YOLO model and visualization settings."""
         super().__init__(**kwargs)
 
@@ -209,40 +212,40 @@ class ParkingManagement(BaseSolution):
         with open(self.json_file) as f:
             self.json = json.load(f)
 
-        self.pr_info = {"Occupancy": 0, "Available": 0}  # dictionary for parking information
+        self.pr_info = {"Occupancy": 0, "Available": 0}  # Dictionary for parking information
 
-        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
+        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
 
-    def process(self, im0):
-        """
-        Process the input image for parking lot management and visualization.
+    def process(self, im0: np.ndarray) -> SolutionResults:
+        """Process the input image for parking lot management and visualization.
 
-        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.
+        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.
 
         Args:
             im0 (np.ndarray): The input inference image.
 
         Returns:
             (SolutionResults): Contains processed image `plot_im`, 'filled_slots' (number of occupied parking slots),
-                'available_slots' (number of available parking slots), and 'total_tracks' (total number of tracked objects).
+                'available_slots' (number of available parking slots), and 'total_tracks' (total number of
+                tracked objects).
 
         Examples:
             >>> parking_manager = ParkingManagement(json_file="parking_regions.json")
             >>> image = cv2.imread("parking_lot.jpg")
             >>> results = parking_manager.process(image)
         """
-        self.extract_tracks(im0)  # extract tracks from im0
-        es, fs = len(self.json), 0  # empty slots, filled slots
-        annotator = SolutionAnnotator(im0, self.line_width)  # init annotator
+        self.extract_tracks(im0)  # Extract tracks from im0
+        es, fs = len(self.json), 0  # Empty slots, filled slots
+        annotator = SolutionAnnotator(im0, self.line_width)  # Initialize annotator
 
         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
+            rg_occupied = False  # Occupied region initialization
             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)
@@ -254,7 +257,7 @@ class ParkingManagement(BaseSolution):
                     rg_occupied = True
                     break
             fs, es = (fs + 1, es - 1) if rg_occupied else (fs, es)
-            # Plotting regions
+            # Plot regions
             cv2.polylines(im0, [pts_array], isClosed=True, color=self.occ if rg_occupied else self.arc, thickness=2)
 
         self.pr_info["Occupancy"], self.pr_info["Available"] = fs, es
@@ -262,7 +265,7 @@ class ParkingManagement(BaseSolution):
         annotator.display_analytics(im0, self.pr_info, (104, 31, 17), (255, 255, 255), 10)
 
         plot_im = annotator.result()
-        self.display_output(plot_im)  # display output with base class function
+        self.display_output(plot_im)  # Display output with base class function
 
         # Return SolutionResults
         return SolutionResults(