ultralytics-opencv-headless 8.3.246__py3-none-any.whl

ultralytics/solutions/parking_management.py

@@ -0,0 +1,280 @@
+# 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
+
+from ultralytics.solutions.solutions import BaseSolution, SolutionAnnotator, SolutionResults
+from ultralytics.utils import LOGGER
+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.
+
+    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:
+        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) -> None:
+        """Initialize the ParkingPtsSelection class, setting up UI and properties for parking zone point selection."""
+        try:  # Check if tkinter is installed
+            import tkinter as tk
+            from tkinter import filedialog, messagebox
+        except ImportError:  # Display error with recommendations
+            import platform
+
+            install_cmd = {
+                "Linux": "sudo apt install python3-tk (Debian/Ubuntu) | sudo dnf install python3-tkinter (Fedora) | "
+                "sudo pacman -S tk (Arch)",
+                "Windows": "reinstall Python and enable the checkbox `tcl/tk and IDLE` on **Optional Features** during installation",
+                "Darwin": "reinstall Python from https://www.python.org/downloads/macos/ or `brew install python-tk`",
+            }.get(platform.system(), "Unknown OS. Check your Python installation.")
+
+            LOGGER.warning(f" Tkinter is not configured or supported. Potential fix: {install_cmd}")
+            return
+
+        if not check_imshow(warn=True):
+            return
+
+        self.tk, self.filedialog, self.messagebox = tk, filedialog, messagebox
+        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
+        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 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
+
+        # Button frame with buttons
+        button_frame = self.tk.Frame(self.master)
+        button_frame.pack(side=self.tk.TOP)
+
+        for text, cmd in [
+            ("Upload Image", self.upload_image),
+            ("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)
+
+        self.initialize_properties()
+        self.master.mainloop()
+
+    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) -> None:
+        """Upload and display an image on the canvas, resizing it to fit within specified dimensions."""
+        from PIL import Image, ImageTk  # Scoped import because ImageTk requires tkinter package
+
+        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 = (
+            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.config(width=canvas_width, height=canvas_height)
+        self.canvas_image = ImageTk.PhotoImage(self.image.resize((canvas_width, canvas_height)))
+        self.canvas.create_image(0, 0, anchor=self.tk.NW, image=self.canvas_image)
+        self.canvas.bind("<Button-1>", self.on_canvas_click)
+
+        self.rg_data.clear(), self.current_box.clear()
+
+    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")
+        if len(self.current_box) == 4:
+            self.rg_data.append(self.current_box.copy())
+            self.draw_box(self.current_box)
+            self.current_box.clear()
+
+    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) -> 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.")
+            return
+        self.rg_data.pop()
+        self.redraw_canvas()
+
+    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) -> 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
+
+        write_buffer = StringIO()
+        json.dump(data, write_buffer, indent=4)
+        with open("bounding_boxes.json", "w", encoding="utf-8") as f:
+            f.write(write_buffer.getvalue())
+        self.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.
+
+    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]): 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")
+        >>> print(f"Occupied spaces: {parking_manager.pr_info['Occupancy']}")
+        >>> print(f"Available spaces: {parking_manager.pr_info['Available']}")
+    """
+
+    def __init__(self, **kwargs: Any) -> None:
+        """Initialize the parking management system with a YOLO model and visualization settings."""
+        super().__init__(**kwargs)
+
+        self.json_file = self.CFG["json_file"]  # Load parking regions JSON data
+        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, encoding="utf-8") as f:
+            self.json = json.load(f)
+
+        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
+
+    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.
+
+        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).
+
+        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
+        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
+            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)
+                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
+                    )
+                    region_occupied = True
+                    break
+            if region_occupied:
+                occupied_slots += 1
+                available_slots -= 1
+            # Plot regions
+            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"] = occupied_slots, available_slots
+
+        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
+
+        # Return SolutionResults
+        return SolutionResults(
+            plot_im=plot_im,
+            filled_slots=self.pr_info["Occupancy"],
+            available_slots=self.pr_info["Available"],
+            total_tracks=len(self.track_ids),
+        )

ultralytics/solutions/queue_management.py

@@ -0,0 +1,93 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+from typing import Any
+
+from ultralytics.solutions.solutions import BaseSolution, SolutionAnnotator, SolutionResults
+from ultralytics.utils.plotting import colors
+
+
+class QueueManager(BaseSolution):
+    """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]): 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.
+
+    Methods:
+        initialize_region: Initialize the queue region.
+        process: Process a single frame for queue management.
+        extract_tracks: Extract object tracks from the current frame.
+        store_tracking_history: Store the tracking history for an object.
+        display_output: Display the processed output.
+
+    Examples:
+        >>> 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)
+    """
+
+    def __init__(self, **kwargs: Any) -> None:
+        """Initialize 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
+        self.rect_color = (255, 255, 255)  # Rectangle color for visualization
+        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.
+
+        Args:
+            im0 (np.ndarray): Input image for processing, typically a frame from a video stream.
+
+        Returns:
+            (SolutionResults): Contains processed image `im0`, 'queue_count' (int, number of objects in the queue) and
+                'total_tracks' (int, total number of tracked objects).
+
+        Examples:
+            >>> queue_manager = QueueManager()
+            >>> frame = cv2.imread("frame.jpg")
+            >>> results = queue_manager.process(frame)
+        """
+        self.counts = 0  # Reset counts every frame
+        self.extract_tracks(im0)  # Extract tracks from the current frame
+        annotator = SolutionAnnotator(im0, line_width=self.line_width)  # Initialize annotator
+        annotator.draw_region(reg_pts=self.region, color=self.rect_color, thickness=self.line_width * 2)  # Draw region
+
+        for box, track_id, cls, conf in zip(self.boxes, self.track_ids, self.clss, self.confs):
+            # Draw bounding box and counting region
+            annotator.box_label(box, label=self.adjust_box_label(cls, conf, track_id), color=colors(track_id, True))
+            self.store_tracking_history(track_id, box)  # Store track history
+
+            # Cache frequently accessed attributes
+            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 = 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
+        annotator.queue_counts_display(
+            f"Queue Counts : {self.counts}",
+            points=self.region,
+            region_color=self.rect_color,
+            txt_color=(104, 31, 17),
+        )
+        plot_im = annotator.result()
+        self.display_output(plot_im)  # Display output with base class function
+
+        # Return a SolutionResults object with processed data
+        return SolutionResults(plot_im=plot_im, queue_count=self.counts, total_tracks=len(self.track_ids))

ultralytics/solutions/region_counter.py

@@ -0,0 +1,133 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+from ultralytics.solutions.solutions import BaseSolution, SolutionAnnotator, SolutionResults
+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.
+
+    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
+    counting in specified areas, such as monitoring zones or segmented sections.
+
+    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.
+        region_counts (dict): Dictionary storing the count of objects for each named region.
+
+    Methods:
+        add_region: Add a new counting region with specified attributes.
+        process: Process video frames to count objects in each region.
+        initialize_regions: Initialize zones to count the objects in each one. Zones could be multiple as well.
+
+    Examples:
+        Initialize a RegionCounter and add a counting region
+        >>> counter = RegionCounter()
+        >>> counter.add_region("Zone1", [(100, 100), (200, 100), (200, 200), (100, 200)], (255, 0, 0), (255, 255, 255))
+        >>> results = counter.process(frame)
+        >>> print(f"Total tracks: {results.total_tracks}")
+    """
+
+    def __init__(self, **kwargs: Any) -> None:
+        """Initialize the RegionCounter for real-time object counting in user-defined regions."""
+        super().__init__(**kwargs)
+        self.region_template = {
+            "name": "Default Region",
+            "polygon": None,
+            "counts": 0,
+            "region_color": (255, 255, 255),
+            "text_color": (0, 0, 0),
+        }
+        self.region_counts = {}
+        self.counting_regions = []
+        self.initialize_regions()
+
+    def add_region(
+        self,
+        name: str,
+        polygon_points: list[tuple],
+        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.
+
+        Args:
+            name (str): Name assigned to the new region.
+            polygon_points (list[tuple]): List of (x, y) coordinates defining the region's polygon.
+            region_color (tuple[int, int, int]): BGR color for region visualization.
+            text_color (tuple[int, int, int]): BGR color for the text within the region.
+
+        Returns:
+            (dict[str, Any]): Region information including name, polygon, and display colors.
+        """
+        region = self.region_template.copy()
+        region.update(
+            {
+                "name": name,
+                "polygon": self.Polygon(polygon_points),
+                "region_color": region_color,
+                "text_color": text_color,
+            }
+        )
+        self.counting_regions.append(region)
+        return region
+
+    def initialize_regions(self):
+        """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
+            self.region = {"Region#01": self.region}
+        for i, (name, pts) in enumerate(self.region.items()):
+            region = self.add_region(name, pts, colors(i, True), (255, 255, 255))
+            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.
+
+        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).
+        """
+        self.extract_tracks(im0)
+        annotator = SolutionAnnotator(im0, line_width=self.line_width)
+
+        for box, cls, track_id, conf in zip(self.boxes, self.clss, self.track_ids, self.confs):
+            annotator.box_label(box, label=self.adjust_box_label(cls, conf, track_id), color=colors(track_id, True))
+            center = self.Point(((box[0] + box[2]) / 2, (box[1] + box[3]) / 2))
+            for region in self.counting_regions:
+                if region["prepared_polygon"].contains(center):
+                    region["counts"] += 1
+                    self.region_counts[region["name"]] = region["counts"]
+
+        # Display region counts
+        for region in self.counting_regions:
+            poly = region["polygon"]
+            pts = list(map(tuple, np.array(poly.exterior.coords, dtype=np.int32)))
+            (x1, y1), (x2, y2) = [(int(poly.centroid.x), int(poly.centroid.y))] * 2
+            annotator.draw_region(pts, region["region_color"], self.line_width * 2)
+            annotator.adaptive_label(
+                [x1, y1, x2, y2],
+                label=str(region["counts"]),
+                color=region["region_color"],
+                txt_color=region["text_color"],
+                margin=self.line_width * 4,
+                shape="rect",
+            )
+            region["counts"] = 0  # Reset for next frame
+        plot_im = annotator.result()
+        self.display_output(plot_im)
+
+        return SolutionResults(plot_im=plot_im, total_tracks=len(self.track_ids), region_counts=self.region_counts)

ultralytics/solutions/security_alarm.py

@@ -0,0 +1,151 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+from typing import Any
+
+from ultralytics.solutions.solutions import BaseSolution, SolutionAnnotator, SolutionResults
+from ultralytics.utils import LOGGER
+from ultralytics.utils.plotting import colors
+
+
+class SecurityAlarm(BaseSolution):
+    """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
+    visualization.
+
+    Attributes:
+        email_sent (bool): Flag to track if an email has already been sent for the current event.
+        records (int): Threshold for the number of detected objects to trigger an alert.
+        server (smtplib.SMTP): SMTP server connection for sending email alerts.
+        to_email (str): Recipient's email address for alerts.
+        from_email (str): Sender's email address for alerts.
+
+    Methods:
+        authenticate: Set up email server authentication for sending alerts.
+        send_email: Send an email notification with details and an image attachment.
+        process: Monitor the frame, process detections, and trigger alerts if thresholds are crossed.
+
+    Examples:
+        >>> security = SecurityAlarm()
+        >>> security.authenticate("abc@gmail.com", "1111222233334444", "xyz@gmail.com")
+        >>> frame = cv2.imread("frame.jpg")
+        >>> results = security.process(frame)
+    """
+
+    def __init__(self, **kwargs: Any) -> None:
+        """Initialize the SecurityAlarm class with parameters for real-time object monitoring.
+
+        Args:
+            **kwargs (Any): Additional keyword arguments passed to the parent class.
+        """
+        super().__init__(**kwargs)
+        self.email_sent = False
+        self.records = self.CFG["records"]
+        self.server = None
+        self.to_email = ""
+        self.from_email = ""
+
+    def authenticate(self, from_email: str, password: str, to_email: str) -> None:
+        """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.
+
+        Examples:
+            >>> alarm = SecurityAlarm()
+            >>> alarm.authenticate("sender@example.com", "password123", "recipient@example.com")
+        """
+        import smtplib
+
+        self.server = smtplib.SMTP("smtp.gmail.com: 587")
+        self.server.starttls()
+        self.server.login(from_email, password)
+        self.to_email = to_email
+        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.
+
+        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.
+
+        Examples:
+            >>> alarm = SecurityAlarm()
+            >>> frame = cv2.imread("path/to/image.jpg")
+            >>> alarm.send_email(frame, records=10)
+        """
+        from email.mime.image import MIMEImage
+        from email.mime.multipart import MIMEMultipart
+        from email.mime.text import MIMEText
+
+        import cv2
+
+        img_bytes = cv2.imencode(".jpg", im0)[1].tobytes()  # Encode the image as JPEG
+
+        # Create the email
+        message = MIMEMultipart()
+        message["From"] = self.from_email
+        message["To"] = self.to_email
+        message["Subject"] = "Security Alert"
+
+        # Add the text message body
+        message_body = f"Ultralytics alert: {records} object(s) detected."
+        message.attach(MIMEText(message_body))
+
+        # Attach the image
+        image_attachment = MIMEImage(img_bytes, name="ultralytics.jpg")
+        message.attach(image_attachment)
+
+        # Send the email
+        try:
+            self.server.send_message(message)
+            LOGGER.info("Email sent successfully!")
+        except Exception as e:
+            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.
+
+        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.
+
+        Returns:
+            (SolutionResults): Contains processed image `plot_im`, 'total_tracks' (total number of tracked objects) and
+                'email_sent' (whether an email alert was triggered).
+
+        Examples:
+            >>> alarm = SecurityAlarm()
+            >>> frame = cv2.imread("path/to/image.jpg")
+            >>> results = alarm.process(frame)
+        """
+        self.extract_tracks(im0)  # Extract tracks
+        annotator = SolutionAnnotator(im0, line_width=self.line_width)  # Initialize annotator
+
+        # Iterate over bounding boxes and classes index
+        for box, cls in zip(self.boxes, self.clss):
+            # Draw bounding box
+            annotator.box_label(box, label=self.names[cls], color=colors(cls, True))
+
+        total_det = len(self.clss)
+        if total_det >= self.records and not self.email_sent:  # Only send email if not sent before
+            self.send_email(im0, total_det)
+            self.email_sent = True
+
+        plot_im = annotator.result()
+        self.display_output(plot_im)  # Display output with base class function
+
+        # Return a SolutionResults
+        return SolutionResults(plot_im=plot_im, total_tracks=len(self.track_ids), email_sent=self.email_sent)