dgenerate-ultralytics-headless 8.3.214__py3-none-any.whl → 8.4.7__py3-none-any.whl

ultralytics/solutions/parking_management.py

@@ -14,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.
@@ -93,7 +92,7 @@ class ParkingPtsSelection:
 
         for text, cmd in [
             ("Upload Image", self.upload_image),
-            ("Remove Last BBox", self.remove_last_bounding_box),
+            ("Remove Last Bounding Box", self.remove_last_bounding_box),
             ("Save", self.save_to_json),
         ]:
             self.tk.Button(button_frame, text=text, command=cmd).pack(side=self.tk.LEFT)
@@ -178,26 +177,25 @@ 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.
+        arc (tuple[int, int, int]): BGR color tuple for available region visualization.
+        occ (tuple[int, int, int]): BGR color tuple for occupied region visualization.
+        dc (tuple[int, int, int]): BGR color tuple for centroid visualization of detected objects.
 
     Methods:
         process: Process the input image for parking lot management and visualization.
 
     Examples:
         >>> from ultralytics.solutions import ParkingManagement
-        >>> parking_manager = ParkingManagement(model="yolo11n.pt", json_file="parking_regions.json")
+        >>> parking_manager = ParkingManagement(model="yolo26n.pt", json_file="parking_regions.json")
         >>> print(f"Occupied spaces: {parking_manager.pr_info['Occupancy']}")
         >>> print(f"Available spaces: {parking_manager.pr_info['Available']}")
     """
@@ -207,11 +205,11 @@ class ParkingManagement(BaseSolution):
         super().__init__(**kwargs)
 
         self.json_file = self.CFG["json_file"]  # Load parking regions 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")
+        if not self.json_file:
+            LOGGER.warning("ParkingManagement requires `json_file` with parking region coordinates.")
+            raise ValueError("❌ JSON file path cannot be empty.")
 
-        with open(self.json_file) as f:
+        with open(self.json_file, encoding="utf-8") as f:
             self.json = json.load(f)
 
         self.pr_info = {"Occupancy": 0, "Available": 0}  # Dictionary for parking information
@@ -221,19 +219,19 @@ class ParkingManagement(BaseSolution):
         self.dc = (255, 0, 189)  # Centroid color for each box
 
     def process(self, im0: np.ndarray) -> SolutionResults:
-        """
-        Process the input image for parking lot management and visualization.
+        """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")
@@ -241,28 +239,32 @@ class ParkingManagement(BaseSolution):
             >>> results = parking_manager.process(image)
         """
         self.extract_tracks(im0)  # Extract tracks from im0
-        es, fs = len(self.json), 0  # Empty slots, filled slots
+        available_slots, occupied_slots = len(self.json), 0
         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
+            region_polygon = np.array(region["points"], dtype=np.int32).reshape((-1, 1, 2))
+            region_occupied = False
             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:
+                inside_distance = cv2.pointPolygonTest(region_polygon, (xc, yc), False)
+                if inside_distance >= 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
+                    region_occupied = True
                     break
-            fs, es = (fs + 1, es - 1) if rg_occupied else (fs, es)
+            if region_occupied:
+                occupied_slots += 1
+                available_slots -= 1
             # Plot regions
-            cv2.polylines(im0, [pts_array], isClosed=True, color=self.occ if rg_occupied else self.arc, thickness=2)
+            cv2.polylines(
+                im0, [region_polygon], isClosed=True, color=self.occ if region_occupied else self.arc, thickness=2
+            )
 
-        self.pr_info["Occupancy"], self.pr_info["Available"] = fs, es
+        self.pr_info["Occupancy"], self.pr_info["Available"] = occupied_slots, available_slots
 
         annotator.display_analytics(im0, self.pr_info, (104, 31, 17), (255, 255, 255), 10)
 

ultralytics/solutions/queue_management.py

@@ -7,15 +7,14 @@ from ultralytics.utils.plotting import colors
 
 
 class QueueManager(BaseSolution):
-    """
-    Manages queue counting in real-time video streams 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.
+    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.
+        rect_color (tuple[int, int, int]): BGR color tuple for drawing the queue region rectangle.
         region_length (int): The number of points defining the queue region.
         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.
@@ -31,10 +30,10 @@ class QueueManager(BaseSolution):
         >>> cap = cv2.VideoCapture("path/to/video.mp4")
         >>> queue_manager = QueueManager(region=[100, 100, 200, 200, 300, 300])
         >>> while cap.isOpened():
-        >>>     success, im0 = cap.read()
-        >>>     if not success:
-        >>>         break
-        >>>     results = queue_manager.process(im0)
+        ...     success, im0 = cap.read()
+        ...     if not success:
+        ...         break
+        ...     results = queue_manager.process(im0)
     """
 
     def __init__(self, **kwargs: Any) -> None:
@@ -46,8 +45,7 @@ class QueueManager(BaseSolution):
         self.region_length = len(self.region)  # Store region length for further usage
 
     def process(self, im0) -> SolutionResults:
-        """
-        Process queue management for a single frame of video.
+        """Process queue management for a single frame of video.
 
         Args:
             im0 (np.ndarray): Input image for processing, typically a frame from a video stream.
@@ -83,7 +81,7 @@ class QueueManager(BaseSolution):
 
         # Display queue counts
         annotator.queue_counts_display(
-            f"Queue Counts : {str(self.counts)}",
+            f"Queue Counts : {self.counts}",
             points=self.region,
             region_color=self.rect_color,
             txt_color=(104, 31, 17),

ultralytics/solutions/region_counter.py

@@ -11,8 +11,7 @@ from ultralytics.utils.plotting import colors
 
 
 class RegionCounter(BaseSolution):
-    """
-    A class for real-time counting of objects within user-defined regions in a video stream.
+    """A class for real-time counting of objects within user-defined regions in a video stream.
 
     This class inherits from `BaseSolution` and provides functionality to define polygonal regions in a video frame,
     track objects, and count those objects that pass through each defined region. Useful for applications requiring
@@ -21,8 +20,8 @@ class RegionCounter(BaseSolution):
     Attributes:
         region_template (dict): Template for creating new counting regions with default attributes including name,
             polygon coordinates, and display colors.
-        counting_regions (list): List storing all defined regions, where each entry is based on `region_template`
-            and includes specific region settings like name, coordinates, and color.
+        counting_regions (list): List storing all defined regions, where each entry is based on `region_template` and
+            includes specific region settings like name, coordinates, and color.
         region_counts (dict): Dictionary storing the count of objects for each named region.
 
     Methods:
@@ -59,8 +58,7 @@ class RegionCounter(BaseSolution):
         region_color: tuple[int, int, int],
         text_color: tuple[int, int, int],
     ) -> dict[str, Any]:
-        """
-        Add a new region to the counting list based on the provided template with specific attributes.
+        """Add a new region to the counting list based on the provided template with specific attributes.
 
         Args:
             name (str): Name assigned to the new region.
@@ -69,7 +67,7 @@ class RegionCounter(BaseSolution):
             text_color (tuple[int, int, int]): BGR color for the text within the region.
 
         Returns:
-            (dict[str, any]): Returns a dictionary including the region information i.e. name, region_color etc.
+            (dict[str, Any]): Region information including name, polygon, and display colors.
         """
         region = self.region_template.copy()
         region.update(
@@ -84,7 +82,7 @@ class RegionCounter(BaseSolution):
         return region
 
     def initialize_regions(self):
-        """Initialize regions only once."""
+        """Initialize regions from `self.region` only once."""
         if self.region is None:
             self.initialize_region()
         if not isinstance(self.region, dict):  # Ensure self.region is initialized and structured as a dictionary
@@ -94,15 +92,14 @@ class RegionCounter(BaseSolution):
             region["prepared_polygon"] = self.prep(region["polygon"])
 
     def process(self, im0: np.ndarray) -> SolutionResults:
-        """
-        Process the input frame to detect and count objects within each defined region.
+        """Process the input frame to detect and count objects within each defined region.
 
         Args:
             im0 (np.ndarray): Input image frame where objects and regions are annotated.
 
         Returns:
-            (SolutionResults): Contains processed image `plot_im`, 'total_tracks' (int, total number of tracked objects),
-                and 'region_counts' (dict, counts of objects per region).
+            (SolutionResults): Contains processed image `plot_im`, 'total_tracks' (int, total number of tracked
+                objects), and 'region_counts' (dict, counts of objects per region).
         """
         self.extract_tracks(im0)
         annotator = SolutionAnnotator(im0, line_width=self.line_width)

ultralytics/solutions/security_alarm.py

@@ -8,8 +8,7 @@ from ultralytics.utils.plotting import colors
 
 
 class SecurityAlarm(BaseSolution):
-    """
-    A class to manage security alarm functionalities for real-time monitoring.
+    """A class to manage security alarm functionalities for real-time monitoring.
 
     This class extends the BaseSolution class and provides features to monitor objects in a frame, send email
     notifications when specific thresholds are exceeded for total detections, and annotate the output frame for
@@ -35,8 +34,7 @@ class SecurityAlarm(BaseSolution):
     """
 
     def __init__(self, **kwargs: Any) -> None:
-        """
-        Initialize the SecurityAlarm class with parameters for real-time object monitoring.
+        """Initialize the SecurityAlarm class with parameters for real-time object monitoring.
 
         Args:
             **kwargs (Any): Additional keyword arguments passed to the parent class.
@@ -49,16 +47,15 @@ class SecurityAlarm(BaseSolution):
         self.from_email = ""
 
     def authenticate(self, from_email: str, password: str, to_email: str) -> None:
-        """
-        Authenticate the email server for sending alert notifications.
+        """Authenticate the email server for sending alert notifications.
+
+        This method initializes a secure connection with the SMTP server and logs in using the provided credentials.
 
         Args:
             from_email (str): Sender's email address.
             password (str): Password for the sender's email account.
             to_email (str): Recipient's email address.
 
-        This method initializes a secure connection with the SMTP server and logs in using the provided credentials.
-
         Examples:
             >>> alarm = SecurityAlarm()
             >>> alarm.authenticate("sender@example.com", "password123", "recipient@example.com")
@@ -72,16 +69,15 @@ class SecurityAlarm(BaseSolution):
         self.from_email = from_email
 
     def send_email(self, im0, records: int = 5) -> None:
-        """
-        Send an email notification with an image attachment indicating the number of objects detected.
+        """Send an email notification with an image attachment indicating the number of objects detected.
+
+        This method encodes the input image, composes the email message with details about the detection, and sends it
+        to the specified recipient.
 
         Args:
             im0 (np.ndarray): The input image or frame to be attached to the email.
             records (int, optional): The number of detected objects to be included in the email message.
 
-        This method encodes the input image, composes the email message with details about the detection, and sends it
-        to the specified recipient.
-
         Examples:
             >>> alarm = SecurityAlarm()
             >>> frame = cv2.imread("path/to/image.jpg")
@@ -102,7 +98,7 @@ class SecurityAlarm(BaseSolution):
         message["Subject"] = "Security Alert"
 
         # Add the text message body
-        message_body = f"Ultralytics ALERT!!! {records} objects have been detected!!"
+        message_body = f"Ultralytics alert: {records} object(s) detected."
         message.attach(MIMEText(message_body))
 
         # Attach the image
@@ -117,8 +113,11 @@ class SecurityAlarm(BaseSolution):
             LOGGER.error(f"Failed to send email: {e}")
 
     def process(self, im0) -> SolutionResults:
-        """
-        Monitor the frame, process object detections, and trigger alerts if thresholds are exceeded.
+        """Monitor the frame, process object detections, and trigger alerts if thresholds are exceeded.
+
+        This method processes the input frame, extracts detections, annotates the frame with bounding boxes, and sends
+        an email notification if the number of detected objects surpasses the specified threshold and an alert has not
+        already been sent.
 
         Args:
             im0 (np.ndarray): The input image or frame to be processed and annotated.
@@ -127,10 +126,6 @@ class SecurityAlarm(BaseSolution):
             (SolutionResults): Contains processed image `plot_im`, 'total_tracks' (total number of tracked objects) and
                 'email_sent' (whether an email alert was triggered).
 
-        This method processes the input frame, extracts detections, annotates the frame with bounding boxes, and sends
-        an email notification if the number of detected objects surpasses the specified threshold and an alert has not
-        already been sent.
-
         Examples:
             >>> alarm = SecurityAlarm()
             >>> frame = cv2.imread("path/to/image.jpg")

ultralytics/solutions/similarity_search.py

@@ -18,8 +18,7 @@ os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"  # Avoid OpenMP conflict on some sys
 
 
 class VisualAISearch:
-    """
-    A semantic image search system that leverages OpenCLIP for generating high-quality image and text embeddings and
+    """A semantic image search system that leverages OpenCLIP for generating high-quality image and text embeddings and
     FAISS for fast similarity-based retrieval.
 
     This class aligns image and text embeddings in a shared semantic space, enabling users to search large collections
@@ -78,15 +77,14 @@ class VisualAISearch:
 
     def extract_image_feature(self, path: Path) -> np.ndarray:
         """Extract CLIP image embedding from the given image path."""
-        return self.model.encode_image(Image.open(path)).cpu().numpy()
+        return self.model.encode_image(Image.open(path)).detach().cpu().numpy()
 
     def extract_text_feature(self, text: str) -> np.ndarray:
         """Extract CLIP text embedding from the given text query."""
-        return self.model.encode_text(self.model.tokenize([text])).cpu().numpy()
+        return self.model.encode_text(self.model.tokenize([text])).detach().cpu().numpy()
 
     def load_or_build_index(self) -> None:
-        """
-        Load existing FAISS index or build a new one from image features.
+        """Load existing FAISS index or build a new one from image features.
 
         Checks if FAISS index and image paths exist on disk. If found, loads them directly. Otherwise, builds a new
         index by extracting features from all images in the data directory, normalizes the features, and saves both the
@@ -130,8 +128,7 @@ class VisualAISearch:
         LOGGER.info(f"Indexed {len(self.image_paths)} images.")
 
     def search(self, query: str, k: int = 30, similarity_thresh: float = 0.1) -> list[str]:
-        """
-        Return top-k semantically similar images to the given query.
+        """Return top-k semantically similar images to the given query.
 
         Args:
             query (str): Natural language text query to search for.
@@ -167,11 +164,10 @@ class VisualAISearch:
 
 
 class SearchApp:
-    """
-    A Flask-based web interface for semantic image search with natural language queries.
+    """A Flask-based web interface for semantic image search with natural language queries.
 
-    This class provides a clean, responsive frontend that enables users to input natural language queries and
-    instantly view the most relevant images retrieved from the indexed database.
+    This class provides a clean, responsive frontend that enables users to input natural language queries and instantly
+    view the most relevant images retrieved from the indexed database.
 
     Attributes:
         render_template: Flask template rendering function.
@@ -189,9 +185,8 @@ class SearchApp:
         >>> app.run(debug=True)
     """
 
-    def __init__(self, data: str = "images", device: str = None) -> None:
-        """
-        Initialize the SearchApp with VisualAISearch backend.
+    def __init__(self, data: str = "images", device: str | None = None) -> None:
+        """Initialize the SearchApp with VisualAISearch backend.
 
         Args:
             data (str, optional): Path to directory containing images to index and search.