Reference for ultralytics/solutions/parking_management.py

def draw_box(self, box: List[Tuple[int, int]]):
    """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 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 on_canvas_click(self, event):
    """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 redraw_canvas(self):
    """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 remove_last_bounding_box(self):
    """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 save_to_json(self):
    """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")

def upload_image(self):
    """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

    self.image = Image.open(self.filedialog.askopenfilename(filetypes=[("Image Files", "*.png *.jpg *.jpeg")]))
    if not self.image:
        return

    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 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
    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
        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
        fs, es = (fs + 1, es - 1) if rg_occupied else (fs, es)
        # 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

    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),
    )