find_distance.ROIEditor Class Reference

Interactive polygon editor for defining parking spot ROIs at runtime. More...

Public Member Functions
	__init__ (self)
str	active_cam (self)
	mouse_cb (self, event, x, y, flags, param)
bool	handle_key (self, int key)
	draw_overlay (self, np.ndarray canvas)

Public Attributes
bool	editor_mode = False
list	points = []
tuple	mouse_pos = (0, 0)
int	cam_panel_idx = 0

Static Public Attributes
tuple	POINT_COLOR = (0, 255, 255)
tuple	LINE_COLOR = (0, 200, 255)
tuple	CLOSE_COLOR = (180, 0, 255)
tuple	FILL_COLOR = (0, 180, 255)
tuple	CURSOR_COLOR = (200, 200, 200)
tuple	TEXT_COLOR = (255, 255, 255)
tuple	SHADOW_COLOR = (0, 0, 0)

Protected Member Functions
str	_next_id (self, str cam)
	_finish_polygon (self)

Protected Attributes
dict	_spot_counters = {c: len(ROIS.get(c, [])) for c in CAM_ORDER}

Detailed Description

Interactive polygon editor for defining parking spot ROIs at runtime.

Lives entirely in the display thread — all methods are called from display_loop() and are not thread-safe. The editor is toggled on/off by pressing I in the display window. While active, the user left-clicks to place polygon vertices on the active camera panel, then presses Enter to print the completed polygon's coordinates to the terminal in a copy-pasteable format for hardcoding into ROIS.

Tab cycles between camera panels so both Left and Right ROIs can be defined without restarting. Points are stored in panel-local coordinates and converted to stitched-window coordinates only for rendering.

Note

This editor does NOT automatically apply the polygon to ROIS/SPOT_MASK. Copy the printed output into the ROIS constant at the top of the file.

Interactive polygon editor. Lives entirely in the display thread.

Controls (active when editor_mode=True):
    Left click   - add point
    Right click  - undo last point
    Enter        - finish polygon, print to terminal
    Backspace    - clear current polygon
    Tab          - cycle active camera
    I            - toggle editor on/off

Definition at line 832 of file find_distance.py.

Constructor & Destructor Documentation

__init__()

find_distance.ROIEditor.__init__

(

self

)

Definition at line 853 of file find_distance.py.

    def __init__(self):
        self.editor_mode: bool = False
        self.points: list[tuple[int, int]] = []
        self.mouse_pos: tuple[int, int] = (0, 0)
        # Which camera panel the user is editing (index into DISPLAY_ORDER)
        self.cam_panel_idx: int = 0
        # Running count per camera so auto-IDs don't repeat within a session
        self._spot_counters: dict[str, int] = {c: len(ROIS.get(c, [])) for c in CAM_ORDER}
 

Member Function Documentation

_finish_polygon()

find_distance.ROIEditor._finish_polygon ( self )

protected

Definition at line 943 of file find_distance.py.

    def _finish_polygon(self):
        if len(self.points) < 3:
            print(f"[ROI Editor] Need at least 3 points (have {len(self.points)})")
            return
 
        cam = self.active_cam
        sid = self._next_id(cam)
        poly = list(self.points)
 
        print(f"\n# ── ROI output ──────────────────────────────────────────")
        print(f"# Camera : {cam}   ID : {sid}")
        print(f"{{'id': '{sid}', 'poly': {poly}}},")
        print(f"# ─────────────────────────────────────────────────────────\n")
 
        self.points.clear()
 

Here is the caller graph for this function:

_next_id()

str find_distance.ROIEditor._next_id ( self, str cam )

protected

Definition at line 868 of file find_distance.py.

    def _next_id(self, cam: str) -> str:
        self._spot_counters[cam] += 1
        prefix = cam[0].upper()
        return f"{prefix}{self._spot_counters[cam]}"
 

Here is the caller graph for this function:

active_cam()

str find_distance.ROIEditor.active_cam

(

self

)

Definition at line 865 of file find_distance.py.

    def active_cam(self) -> str:
        return CAM_ORDER[DISPLAY_ORDER[self.cam_panel_idx]]
 

Here is the caller graph for this function:

draw_overlay()

find_distance.ROIEditor.draw_overlay	(		self,
		np.ndarray	canvas )

Definition at line 959 of file find_distance.py.

    def draw_overlay(self, canvas: np.ndarray):
        if not self.editor_mode:
            return
 
        num_panels = len(DISPLAY_ORDER)
        panel_w = DISP_W
        col_start = self.cam_panel_idx * panel_w
 
        # ── translucent panel highlight ───────────────────────────────────────
        overlay = canvas.copy()
        cv2.rectangle(overlay, (col_start, 0), (col_start + panel_w, DISP_H),
                      (0, 60, 100), -1)
        cv2.addWeighted(overlay, 0.15, canvas, 0.85, 0, canvas)
 
        mx, my = self.mouse_pos
        cv2.line(canvas, (mx, 0), (mx, DISP_H), self.CURSOR_COLOR, 1, cv2.LINE_AA)
        cv2.line(canvas, (0, my), (canvas.shape[1], my), self.CURSOR_COLOR, 1, cv2.LINE_AA)
 
        canvas_pts = [(col_start + px, py) for (px, py) in self.points]
 
        if len(canvas_pts) >= 3:
            fill_overlay = canvas.copy()
            cv2.fillPoly(fill_overlay,
                         [np.array(canvas_pts, dtype=np.int32)],
                         self.FILL_COLOR)
            cv2.addWeighted(fill_overlay, 0.25, canvas, 0.75, 0, canvas)
 
        for i in range(1, len(canvas_pts)):
            cv2.line(canvas, canvas_pts[i - 1], canvas_pts[i],
                     self.LINE_COLOR, 2, cv2.LINE_AA)
 
        if len(canvas_pts) >= 3:
            p0, pn = canvas_pts[0], canvas_pts[-1]
 
            dx = p0[0] - pn[0];
            dy = p0[1] - pn[1]
            dist = max(1, int((dx ** 2 + dy ** 2) ** 0.5))
            segs = max(4, dist // 10)
            for s in range(segs):
                if s % 2 == 0:
                    t0 = s / segs
                    t1 = (s + 1) / segs
                    pt0 = (int(pn[0] + dx * t0), int(pn[1] + dy * t0))
                    pt1 = (int(pn[0] + dx * t1), int(pn[1] + dy * t1))
                    cv2.line(canvas, pt0, pt1, self.CLOSE_COLOR, 2, cv2.LINE_AA)
 
        for idx, (cx, cy) in enumerate(canvas_pts):
            cv2.circle(canvas, (cx, cy), 5, self.POINT_COLOR, -1, cv2.LINE_AA)
            cv2.circle(canvas, (cx, cy), 5, (0, 0, 0), 1, cv2.LINE_AA)
            lbl = str(idx)
            (tw, th), _ = cv2.getTextSize(lbl, cv2.FONT_HERSHEY_SIMPLEX, 0.4, 1)
            cv2.putText(canvas, lbl, (cx + 7, cy + 4),
                        cv2.FONT_HERSHEY_SIMPLEX, 0.4, self.SHADOW_COLOR, 2, cv2.LINE_AA)
            cv2.putText(canvas, lbl, (cx + 7, cy + 4),
                        cv2.FONT_HERSHEY_SIMPLEX, 0.4, self.POINT_COLOR, 1, cv2.LINE_AA)
 
        hud_lines = [
            f"ROI EDITOR  |  cam: {self.active_cam}  |  pts: {len(self.points)}",
            "LClick=add  RClick=undo  Enter=done  Bksp=clear  Tab=cam  I=exit",
        ]
        for li, line in enumerate(hud_lines):
            yy = DISP_H - 12 - (len(hud_lines) - 1 - li) * 18
            (tw, th), _ = cv2.getTextSize(line, cv2.FONT_HERSHEY_SIMPLEX, 0.45, 1)
            cv2.rectangle(canvas,
                          (col_start + 4, yy - th - 4),
                          (col_start + tw + 10, yy + 4),
                          (10, 10, 10), -1)
            cv2.putText(canvas, line,
                        (col_start + 7, yy),
                        cv2.FONT_HERSHEY_SIMPLEX, 0.45, self.TEXT_COLOR, 1, cv2.LINE_AA)
 
        if col_start <= mx < col_start + panel_w:
            lx = mx - col_start
            tip = f"({lx}, {my})"
            (tw, th), _ = cv2.getTextSize(tip, cv2.FONT_HERSHEY_SIMPLEX, 0.4, 1)
            tx = min(mx + 10, canvas.shape[1] - tw - 6)
            ty = max(my - 10, th + 4)
            cv2.rectangle(canvas, (tx - 2, ty - th - 2), (tx + tw + 2, ty + 2),
                          (20, 20, 20), -1)
            cv2.putText(canvas, tip, (tx, ty),
                        cv2.FONT_HERSHEY_SIMPLEX, 0.4, self.TEXT_COLOR, 1, cv2.LINE_AA)
 
 

handle_key()

bool find_distance.ROIEditor.handle_key	(		self,
		int	key )

Process a keypress.
Returns True if the key was consumed (caller should not process further).
Returns False if the key should be handled by the normal display loop.

Definition at line 902 of file find_distance.py.

    def handle_key(self, key: int) -> bool:
        """
        Process a keypress.
        Returns True if the key was consumed (caller should not process further).
        Returns False if the key should be handled by the normal display loop.
        """
        if key == ord('i') or key == ord('I'):
            self.editor_mode = not self.editor_mode
            if self.editor_mode:
                print(f"\n[ROI Editor] ON  — camera: {self.active_cam}")
                print("  Left-click to add points  |  Right-click to undo")
                print("  Enter = finish polygon    |  Backspace = clear")
                print("  Tab = switch camera       |  I = exit editor\n")
            else:
                print("[ROI Editor] OFF")
                self.points.clear()
            return True
 
        if not self.editor_mode:
            return False
 
        # Enter — finish polygon
        if key in (13, 10):  # CR or LF
            self._finish_polygon()
            return True
 
        # Backspace — clear
        if key == 8:
            self.points.clear()
            print("[ROI Editor] Points cleared")
            return True
 
        # Tab — cycle camera
        if key == 9:
            self.cam_panel_idx = (self.cam_panel_idx + 1) % len(DISPLAY_ORDER)
            self.points.clear()
            print(f"[ROI Editor] Active camera: {self.active_cam}  (points cleared)")
            return True
 
        return False
 

Here is the call graph for this function:

mouse_cb()

find_distance.ROIEditor.mouse_cb	(		self,
			event,
			x,
			y,
			flags,
			param )

OpenCV mouse callback (runs in display thread).

Definition at line 875 of file find_distance.py.

    def mouse_cb(self, event, x, y, flags, param):
        """OpenCV mouse callback (runs in display thread)."""
        if not self.editor_mode:
            return
 
        # x is in the stitched window; clamp to the active panel column
        panel_w = DISP_W
        # left panel = DISPLAY_ORDER[0], right panel = DISPLAY_ORDER[1]
        # we only care about the panel that matches self.cam_panel_idx
        col_start = self.cam_panel_idx * panel_w
        col_end = col_start + panel_w
 
        # Track mouse regardless of which panel (for crosshair)
        self.mouse_pos = (x, y)
 
        if event == cv2.EVENT_LBUTTONDOWN:
            if col_start <= x < col_end:
                # Convert to panel-local coordinates
                lx = x - col_start
                self.points.append((lx, y))
 
        elif event == cv2.EVENT_RBUTTONDOWN:
            if self.points:
                self.points.pop()
 

Member Data Documentation

_spot_counters

dict find_distance.ROIEditor._spot_counters = {c: len(ROIS.get(c, [])) for c in CAM_ORDER}

protected

Definition at line 860 of file find_distance.py.

cam_panel_idx

int find_distance.ROIEditor.cam_panel_idx = 0

Definition at line 858 of file find_distance.py.

CLOSE_COLOR

find_distance.ROIEditor.CLOSE_COLOR = (180, 0, 255)

static

Definition at line 847 of file find_distance.py.

CURSOR_COLOR

find_distance.ROIEditor.CURSOR_COLOR = (200, 200, 200)

static

Definition at line 849 of file find_distance.py.

editor_mode

bool find_distance.ROIEditor.editor_mode = False

Definition at line 854 of file find_distance.py.

FILL_COLOR

find_distance.ROIEditor.FILL_COLOR = (0, 180, 255)

static

Definition at line 848 of file find_distance.py.

LINE_COLOR

find_distance.ROIEditor.LINE_COLOR = (0, 200, 255)

static

Definition at line 846 of file find_distance.py.

mouse_pos

tuple find_distance.ROIEditor.mouse_pos = (0, 0)

Definition at line 856 of file find_distance.py.

POINT_COLOR

find_distance.ROIEditor.POINT_COLOR = (0, 255, 255)

static

Definition at line 845 of file find_distance.py.

points

find_distance.ROIEditor.points = []

Definition at line 855 of file find_distance.py.

SHADOW_COLOR

find_distance.ROIEditor.SHADOW_COLOR = (0, 0, 0)

static

Definition at line 851 of file find_distance.py.

TEXT_COLOR

find_distance.ROIEditor.TEXT_COLOR = (255, 255, 255)

static

Definition at line 850 of file find_distance.py.

---

The documentation for this class was generated from the following file:

• src/Dashboard/src/backend/find_distance.py