"""YOLO/ONNX GCVWorker for MLB The Show 26.

Use this after training/exporting configs/models/mlb26_ball.onnx. It keeps the

same 20-byte GCV packet contract as mlb26_gcv.py and mlb26_bridge.gpc.

"""

from __future__ import annotations

import os

import struct

import sys

import time

import ctypes

from pathlib import Path

import cv2

import numpy as np

def _env_roots() -> tuple[Path, ...]:

    extra = os.environ.get("PITCH_TRACKER_CV_ROOT")

    if not extra:

        return ()

    return tuple(Path(p.strip()) for p in extra.split(os.pathsep) if p.strip())

PROJECT_ROOTS = (Path(__file__).resolve().parents[1],) + _env_roots()

PREFERRED_ROOTS = PROJECT_ROOTS

MODEL_NAMES = (

    ("mlb26_ball_320.onnx", 320),

    ("mlb26_ball_416.onnx", 416),

    ("mlb26_ball_512.onnx", 512),

    ("mlb26_ball.onnx", 640),

)

CV2_MODEL_NAMES = (

    ("mlb26_ball_320.onnx", 320),

    ("mlb26_ball_416.onnx", 416),

    ("mlb26_ball_512.onnx", 512),

    ("mlb26_ball.onnx", 640),

)

YOLO_INPUT = 320

YOLO_CONF = 0.18

YOLO_NMS = 0.45

DETECT_X_FRAC = (0.31, 0.66)

DETECT_Y_FRAC = (0.18, 0.84)

ACQUIRE_X_FRAC = (0.40, 0.60)

ACQUIRE_Y_FRAC = (0.20, 0.52)

ACQUIRE_MAX_DIAM_FRAC = 0.0120

MAX_LOCK_STEP_FRAC = 0.090

MAX_LOCK_AGE_MS = 180

MIN_DOWNWARD_STEP_PX = -10.0

SZ_CX_FRAC = 0.492

SZ_CY_FRAC = 0.518

SZ_W_FRAC = 0.203

SZ_H_FRAC = 0.555

SWING_PAD_PX = 0

SWING_MIN_DIAM_FRAC = 0.004

SWING_HOLD_MS = 280

SWING_COOLDOWN_MS = 500

SWING_HIT_DIAM_FRAC = 0.0070

SWING_MIN_GROWTH_PX_S = 3.0

SWING_ETA_FIRE_MS = 180

MIN_TRACK_FRAMES_FOR_SWING = 1

PITCH_END_TIMEOUT_MS = 260

AIM_GAIN_X = 0.19

AIM_GAIN_Y = 0.16

AIM_DEADZONE_PX = 6.0

AIM_MAX_STICK = 92.0

BALL_MEMORY_MS = 130

BALL_SWING_MEMORY_MS = 110

INFER_EVERY_N_FRAMES = 2

DEBUG_FORCE_AIM = False

CUDA_DLL_NAMES = (

    "zlibwapi.dll",

    "cudart64_12.dll",

    "cublas64_12.dll",

    "cublasLt64_12.dll",

    "cufft64_11.dll",

    "cufftw64_11.dll",

    "curand64_10.dll",

    "cusparse64_12.dll",

    "cusolver64_11.dll",

    "cusolverMg64_11.dll",

    "nvJitLink_120_0.dll",

    "nvrtc64_120_0.dll",

    "nvrtc-builtins64_126.dll",

    "cudnn64_9.dll",

    "cudnn_ops64_9.dll",

    "cudnn_adv64_9.dll",

    "cudnn_cnn64_9.dll",

    "cudnn_graph64_9.dll",

    "cudnn_heuristic64_9.dll",

    "cudnn_engines_runtime_compiled64_9.dll",

    "cudnn_engines_precompiled64_9.dll",

)

ORT_DLL_NAMES = ()

def _fix32(value: float) -> bytes:

    v = int(round(value * 65536.0))

    v = max(-2**31, min(2**31 - 1, v))

    return struct.pack(">i", v)

def _int16(value: int) -> bytes:

    v = max(-32768, min(32767, int(value)))

    return struct.pack(">h", v)

class GCVWorker:

    def __init__(self, width, height):

        os.chdir(os.path.dirname(__file__))

        self.width = width

        self.height = height

        self.gcvdata = bytearray(20)

        self.net = None

        self.session = None

        self.input_name = None

        self.backend_name = "none"

        self.model_path = None

        self.yolo_input = YOLO_INPUT

        self.model_error = ""

        self.ort_error = ""

        self.runtime_site = ""

        self.runtime_dll_dirs = []

        self.preload_error = ""

        self.last_swing_ts = 0

        self.swing_hold_until = 0

        self.last_ball = None

        self.prev_ball = None

        self.locked_ball = None

        self.last_ball_vel = (0.0, 0.0)

        self.pitch_active = False

        self.pitch_swinged = False

        self.track_frames = 0

        self.pitch_last_seen_ns = 0

        self.frame_id = 0

        self._load_model()

    def _write_debug(self, message: str) -> None:

        lines = [

            f"time={time.strftime('%Y-%m-%d %H:%M:%S')}",

            f"message={message}",

            f"file={__file__}",

            f"cwd={os.getcwd()}",

            f"python={sys.version}",

            f"executable={sys.executable}",

            f"model_path={self.model_path}",

            f"backend={self.backend_name}",

            f"yolo_input={self.yolo_input}",

            f"runtime_site={self.runtime_site}",

            f"runtime_dll_dirs={self.runtime_dll_dirs}",

            f"preload_error={self.preload_error}",

            f"ort_error={self.ort_error}",

        ]

        for root in PROJECT_ROOTS:

            try:

                if root.exists():

                    (root / "gcv_yolo_runtime_debug.txt").write_text("\n".join(lines), encoding="utf-8")

            except Exception:

                pass

    @staticmethod

    def _runtime_site_candidates():

        seen = set()

        for root in PREFERRED_ROOTS:

            if str(root) in seen:

                continue

            seen.add(str(root))

            yield root / ".venv_yolo" / "Lib" / "site-packages"

            yield root / ".venv" / "Lib" / "site-packages"

    @staticmethod

    def _add_dll_dirs(dll_dirs):

        existing = []

        for dll_dir in dll_dirs:

            if dll_dir and dll_dir.exists() and dll_dir not in existing:

                existing.append(dll_dir)

        if existing:

            os.environ["PATH"] = os.pathsep.join(str(d) for d in existing) + os.pathsep + os.environ.get("PATH", "")

        if hasattr(os, "add_dll_directory"):

            for dll_dir in existing:

                try:

                    os.add_dll_directory(str(dll_dir))

                except Exception:

                    pass

        return existing

    @staticmethod

    def _preload_dlls(dll_dirs, names):

        errors = []

        for name in names:

            for dll_dir in dll_dirs:

                dll_path = dll_dir / name

                if not dll_path.exists():

                    continue

                try:

                    ctypes.WinDLL(str(dll_path))

                except Exception as exc:

                    errors.append(f"{name}:{str(exc)[:70]}")

                break

        return "; ".join(errors[:6])

    def __del__(self):

        try:

            del self.gcvdata

        except Exception:

            pass

    def _load_model(self) -> None:

        try:

            for project_root in PREFERRED_ROOTS:

                model_dir = project_root / "configs" / "models"

                for model_name, input_size in MODEL_NAMES:

                    model_path = model_dir / model_name

                    if model_path.exists():

                        self.model_path = model_path

                        self.yolo_input = input_size

                        break

                if self.model_path is not None:

                    break

            if self.model_path is None:

                self.model_error = "missing mlb26 ball ONNX"

                return

            yolo_site = None

            for candidate in self._runtime_site_candidates():

                if (candidate / "onnxruntime").exists():

                    yolo_site = candidate

                    break

            yolo_capi = yolo_site / "onnxruntime" / "capi" if yolo_site else Path()

            torch_lib = yolo_site / "torch" / "lib" if yolo_site else Path()

            runtime_dlls = Path()

            for root in PREFERRED_ROOTS:

                candidate = root / "runtime_dlls"

                if candidate.exists():

                    runtime_dlls = candidate

                    break

            if yolo_site and str(yolo_site) not in sys.path:

                sys.path.insert(0, str(yolo_site))

            self.runtime_site = str(yolo_site) if yolo_site else ""

            dll_dirs = self._add_dll_dirs((runtime_dlls, torch_lib, yolo_capi))

            self.runtime_dll_dirs = [str(d) for d in dll_dirs]

            preload_errors = []

            cuda_preload = self._preload_dlls(dll_dirs, CUDA_DLL_NAMES)

            if cuda_preload:

                preload_errors.append(cuda_preload)

            ort_preload = self._preload_dlls(dll_dirs, ORT_DLL_NAMES)

            if ort_preload:

                preload_errors.append(ort_preload)

            self.preload_error = " | ".join(preload_errors)[:240]

            try:

                import onnxruntime as ort

                providers = ["CUDAExecutionProvider", "CPUExecutionProvider"]

                self.session = ort.InferenceSession(str(self.model_path), providers=providers)

                self.input_name = self.session.get_inputs()[0].name

                active = self.session.get_providers()

                self.backend_name = "ort" if "CUDAExecutionProvider" in active else "ortcpu"

                self.model_error = ""

                self._write_debug(f"loaded onnxruntime providers={active}")

                return

            except Exception as exc:

                self.ort_error = str(exc)[:120]

                self.session = None

                self.input_name = None

            for project_root in PREFERRED_ROOTS:

                model_dir = project_root / "configs" / "models"

                for model_name, input_size in CV2_MODEL_NAMES:

                    model_path = model_dir / model_name

                    if model_path.exists():

                        self.model_path = model_path

                        self.yolo_input = input_size

                        break

                if self.model_path is not None and self.yolo_input == input_size:

                    break

            self.net = cv2.dnn.readNetFromONNX(str(self.model_path))

            self.net.setPreferableBackend(cv2.dnn.DNN_BACKEND_OPENCV)

            self.net.setPreferableTarget(cv2.dnn.DNN_TARGET_CPU)

            self.backend_name = "cv2"

            self.model_error = ""

            self._write_debug("loaded cv2 fallback")

        except Exception as exc:

            self.net = None

            self.session = None

            self.model_error = str(exc)[:80]

    @staticmethod

    def _rows_from_output(output):

        out = output[0] if isinstance(output, (tuple, list)) else output

        out = np.asarray(out)

        if out.ndim == 3:

            out = out[0]

        if out.ndim != 2:

            return np.empty((0, 0), dtype=np.float32)

        if out.shape[0] <= 85 and out.shape[0] < out.shape[1]:

            out = out.T

        return out

    def _detect_candidates(self, frame):

        if self.net is None and self.session is None:

            return []

        h, w = frame.shape[:2]

        x0 = max(0, int(w * DETECT_X_FRAC[0]))

        x1 = min(w, int(w * DETECT_X_FRAC[1]))

        y0 = max(0, int(h * DETECT_Y_FRAC[0]))

        y1 = min(h, int(h * DETECT_Y_FRAC[1]))

        if x1 <= x0 or y1 <= y0:

            return []

        roi = frame[y0:y1, x0:x1]

        roi_h, roi_w = roi.shape[:2]

        blob = cv2.dnn.blobFromImage(

            roi,

            scalefactor=1.0 / 255.0,

            size=(self.yolo_input, self.yolo_input),

            mean=(0, 0, 0),

            swapRB=True,

            crop=False,

        )

        if self.session is not None:

            output = self.session.run(None, {self.input_name: blob})

        else:

            self.net.setInput(blob)

            output = self.net.forward()

        rows = self._rows_from_output(output)

        boxes = []

        scores = []

        for row in rows:

            if row.shape[0] < 5:

                continue

            if row.shape[0] == 5:

                score = float(row[4])

            elif row.shape[0] == 6:

                score = float(row[4]) if row[5] <= 1.0 else float(row[5])

            else:

                score = float(np.max(row[4:]))

            if score < YOLO_CONF:

                continue

            cx, cy, bw, bh = [float(v) for v in row[:4]]

            aspect = bw / max(1.0, bh)

            if aspect < 0.42 or aspect > 2.35:

                continue

            left = (cx - bw / 2.0) * roi_w / self.yolo_input

            top = (cy - bh / 2.0) * roi_h / self.yolo_input

            ww = bw * roi_w / self.yolo_input

            hh = bh * roi_h / self.yolo_input

            if ww < 3 or hh < 3:

                continue

            if ww > roi_w * 0.16 or hh > roi_h * 0.16:

                continue

            boxes.append([int(left), int(top), int(ww), int(hh)])

            scores.append(score)

        if not boxes:

            return []

        keep = cv2.dnn.NMSBoxes(boxes, scores, YOLO_CONF, YOLO_NMS)

        if len(keep) == 0:

            return []

        candidates = []

        for idx in np.array(keep).reshape(-1):

            bx, by, bw, bh = boxes[int(idx)]

            conf = scores[int(idx)]

            candidates.append((

                float(x0 + bx + bw / 2.0),

                float(y0 + by + bh / 2.0),

                float(bw),

                float(bh),

                float(conf),

            ))

        return candidates

    def _choose_ball(self, candidates, frame_w, frame_h, ts_ns):

        if not candidates:

            if self.last_ball and (ts_ns - self.last_ball[5]) > MAX_LOCK_AGE_MS * 1_000_000:

                self.locked_ball = None

            return None

        acquire_left = frame_w * ACQUIRE_X_FRAC[0]

        acquire_right = frame_w * ACQUIRE_X_FRAC[1]

        acquire_top = frame_h * ACQUIRE_Y_FRAC[0]

        acquire_bottom = frame_h * ACQUIRE_Y_FRAC[1]

        max_step = frame_w * MAX_LOCK_STEP_FRAC

        if self.locked_ball is not None:

            lx, ly, lw, lh, lconf, lts = self.locked_ball

            age_ms = (ts_ns - lts) / 1_000_000

            if age_ms <= MAX_LOCK_AGE_MS:

                scored = []

                for cand in candidates:

                    cx, cy, cw, ch, conf = cand

                    dx = cx - lx

                    dy = cy - ly

                    dist = (dx * dx + dy * dy) ** 0.5

                    size_ratio = max(cw, ch) / max(1.0, max(lw, lh))

                    if dist <= max_step and dy >= MIN_DOWNWARD_STEP_PX and 0.35 <= size_ratio <= 3.25:

                        scored.append((dist - conf * 35.0, cand))

                if scored:

                    chosen = min(scored, key=lambda item: item[0])[1]

                    self.locked_ball = (*chosen, ts_ns)

                    return chosen

        acquire = [

            c for c in candidates

            if acquire_left <= c[0] <= acquire_right and acquire_top <= c[1] <= acquire_bottom

        ]

        if not acquire:

            loose = [

                c for c in candidates

                if c[1] <= frame_h * (ACQUIRE_Y_FRAC[1] + 0.10) and max(c[2], c[3]) <= frame_w * 0.020

            ]

            if not loose:

                return None

            chosen = max(loose, key=lambda c: c[4])

            self.locked_ball = (*chosen, ts_ns)

            return chosen

        chosen = max(acquire, key=lambda c: c[4])

        self.locked_ball = (*chosen, ts_ns)

        return chosen

    @staticmethod

    def _segment_hits_box(prev, cur, left, right, top, bottom):

        if prev is None or cur is None:

            return False

        px, py = prev[:2]

        cx, cy = cur[:2]

        if cy <= py:

            return False

        if left <= px <= right and top <= py <= bottom:

            return True

        if left <= cx <= right and top <= cy <= bottom:

            return True

        if cy < top or py > bottom:

            return False

        for y in (top, bottom):

            if py <= y <= cy:

                t = (y - py) / max(1.0, cy - py)

                x = px + (cx - px) * t

                if left <= x <= right:

                    return True

        return False

    @staticmethod

    def _ball_in_zone(ball, sz_left, sz_right, sz_top, sz_bottom):

        bx, by = ball[0], ball[1]

        return sz_left <= bx <= sz_right and sz_top <= by <= sz_bottom

    def _compute_swing_ready(self, prev_ball, cur_ball, sz_left, sz_right, sz_top, sz_bottom, full_w):

        ball_diam = max(cur_ball[2], cur_ball[3])

        min_track_diam = max(6.0, full_w * SWING_MIN_DIAM_FRAC)

        hit_diam = max(min_track_diam + 2.0, full_w * SWING_HIT_DIAM_FRAC)

        if ball_diam < min_track_diam:

            return False, 0, 0

        if not self._ball_in_zone(cur_ball, sz_left - SWING_PAD_PX, sz_right + SWING_PAD_PX, sz_top - SWING_PAD_PX, sz_bottom + SWING_PAD_PX):

            return False, 0, 0

        close_by_size = ball_diam >= hit_diam

        eta_ms = 0

        pred_good = 0

        if prev_ball is not None:

            prev_diam = max(prev_ball[2], prev_ball[3])

            dt_s = max(1e-6, (cur_ball[5] - prev_ball[5]) / 1e9)

            growth_px_s = (ball_diam - prev_diam) / dt_s

            if growth_px_s >= SWING_MIN_GROWTH_PX_S and ball_diam < hit_diam:

                eta = (hit_diam - ball_diam) * 1000.0 / max(growth_px_s, 1.0)

                if 0.0 <= eta <= 32767.0:

                    eta_ms = int(eta)

                    pred_good = 1

        close_soon = 0 < eta_ms <= SWING_ETA_FIRE_MS

        ready = close_by_size or close_soon

        if close_by_size:

            pred_good = 1

        return ready, eta_ms, pred_good

    @staticmethod

    def _in_acquire_window(ball, full_w, full_h):

        bx, by, bw, bh = ball[0], ball[1], ball[2], ball[3]

        max_d = full_w * ACQUIRE_MAX_DIAM_FRAC

        return (

            full_w * ACQUIRE_X_FRAC[0] <= bx <= full_w * ACQUIRE_X_FRAC[1]

            and full_h * ACQUIRE_Y_FRAC[0] <= by <= full_h * ACQUIRE_Y_FRAC[1]

            and max(bw, bh) <= max_d

        )

    def process(self, frame):

        ts_ns = time.time_ns()

        full_h, full_w = frame.shape[:2]

        self.frame_id += 1

        do_infer = (self.last_ball is None) or (self.frame_id % max(1, INFER_EVERY_N_FRAMES) == 0)

        if do_infer:

            candidates = self._detect_candidates(frame)

            ball = self._choose_ball(candidates, full_w, full_h, ts_ns)

        else:

            candidates = []

            ball = None

        sz_cx = full_w * SZ_CX_FRAC

        sz_cy = full_h * SZ_CY_FRAC

        sz_w = full_w * SZ_W_FRAC

        sz_h = full_h * SZ_H_FRAC

        sz_left = sz_cx - sz_w / 2

        sz_right = sz_cx + sz_w / 2

        sz_top = sz_cy - sz_h / 2

        sz_bottom = sz_cy + sz_h / 2

        aim_x = 0.0

        aim_y = 0.0

        press_contact = 0

        press_power = 0

        eta_ms = 0

        pred_good = 0

        ready = False

        eval_ball = None

        is_real_ball = ball is not None

        if ball is not None:

            bx, by, bw, bh, conf = ball

            if self.last_ball is not None:

                px, py, pw, ph, pconf, pts_ns = self.last_ball

                dt = (ts_ns - pts_ns) / 1e9

                if 0.0 < dt <= BALL_MEMORY_MS / 1000.0:

                    self.last_ball_vel = ((bx - px) / dt, (by - py) / dt)

            if self.pitch_active:

                self.track_frames += 1

            elif (

                self._in_acquire_window((bx, by, bw, bh, conf, ts_ns), full_w, full_h)

                or (by <= (sz_top + 0.62 * sz_h) and max(bw, bh) <= full_w * 0.018)

            ):

                self.pitch_active = True

                self.pitch_swinged = False

                self.track_frames = 1

            else:

                self.track_frames = 0

            self.pitch_last_seen_ns = ts_ns

            if self.pitch_active and by > (sz_bottom + 0.25 * sz_h):

                self.pitch_active = False

                self.pitch_swinged = False

                self.track_frames = 0

            ready, eta_local, pred_local = self._compute_swing_ready(

                self.last_ball,

                (bx, by, bw, bh, conf, ts_ns),

                sz_left,

                sz_right,

                sz_top,

                sz_bottom,

                full_w,

            )

            if eta_local > 0:

                eta_ms = eta_local

            pred_good = max(pred_good, pred_local)

            dx = bx - sz_cx

            dy = by - sz_cy

            if abs(dx) > AIM_DEADZONE_PX:

                aim_x = max(-AIM_MAX_STICK, min(AIM_MAX_STICK, AIM_GAIN_X * dx))

            if abs(dy) > AIM_DEADZONE_PX:

                aim_y = max(-AIM_MAX_STICK, min(AIM_MAX_STICK, AIM_GAIN_Y * dy))

            cooled = (ts_ns - self.last_swing_ts) > SWING_COOLDOWN_MS * 1_000_000

            if (

                ready

                and cooled

                and is_real_ball

                and (not self.pitch_swinged or (ts_ns - self.last_swing_ts) > 900 * 1_000_000)

                and self.track_frames >= MIN_TRACK_FRAMES_FOR_SWING

            ):

                self.last_swing_ts = ts_ns

                self.swing_hold_until = ts_ns + SWING_HOLD_MS * 1_000_000

                self.pitch_swinged = True

            self.prev_ball = self.last_ball

            self.last_ball = (bx, by, bw, bh, conf, ts_ns)

            eval_ball = self.last_ball

        elif self.last_ball is not None:

            if self.pitch_active and self.pitch_last_seen_ns > 0:

                if (ts_ns - self.pitch_last_seen_ns) > PITCH_END_TIMEOUT_MS * 1_000_000:

                    self.pitch_active = False

                    self.pitch_swinged = False

                    self.track_frames = 0

            bx, by, bw, bh, conf, last_ts = self.last_ball

            age_ns = ts_ns - last_ts

            if age_ns <= BALL_MEMORY_MS * 1_000_000:

                age_s = age_ns / 1e9

                vx, vy = self.last_ball_vel

                bx = bx + vx * age_s

                by = by + vy * age_s

                dx = bx - sz_cx

                dy = by - sz_cy

                if abs(dx) > AIM_DEADZONE_PX:

                    aim_x = max(-AIM_MAX_STICK, min(AIM_MAX_STICK, AIM_GAIN_X * dx))

                if abs(dy) > AIM_DEADZONE_PX:

                    aim_y = max(-AIM_MAX_STICK, min(AIM_MAX_STICK, AIM_GAIN_Y * dy))

                eval_ball = (bx, by, bw, bh, conf, ts_ns)

        if ts_ns < self.swing_hold_until:

            press_contact = 1

        if DEBUG_FORCE_AIM:

            aim_x = 25.0

        armed = 1

        in_flight = 1 if eval_ball is not None else 0

        debug_flags = (2 if is_real_ball else 0) | (4 if pred_good else 0) | (8 if self.pitch_active else 0)

        self.gcvdata[0:4] = _fix32(aim_x)

        self.gcvdata[4:8] = _fix32(aim_y)

        self.gcvdata[8:10] = _int16(armed)

        self.gcvdata[10:12] = _int16(in_flight)

        self.gcvdata[12:14] = _int16(press_contact)

        self.gcvdata[14:16] = _int16(press_power)

        self.gcvdata[16:18] = _int16(eta_ms)

        self.gcvdata[18:20] = _int16(debug_flags)

        box_color = (0, 255, 255) if press_contact else ((0, 255, 0) if ready else (190, 190, 190))

        cv2.rectangle(frame, (int(sz_left), int(sz_top)), (int(sz_right), int(sz_bottom)), box_color, 6)

        dx0 = int(full_w * DETECT_X_FRAC[0])

        dx1 = int(full_w * DETECT_X_FRAC[1])

        dy0 = int(full_h * DETECT_Y_FRAC[0])

        dy1 = int(full_h * DETECT_Y_FRAC[1])

        cv2.rectangle(frame, (dx0, dy0), (dx1, dy1), (80, 80, 80), 1)

        if eval_ball is not None:

            bx, by, bw, bh, conf = eval_ball[:5]

            cv2.circle(frame, (int(bx), int(by)), max(8, int(max(bw, bh) / 2)), (0, 255, 255), 2)

            cv2.putText(frame, f"{conf:.2f}", (int(bx) + 10, int(by) - 10),

                        cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 255), 2, cv2.LINE_AA)

        elif candidates:

            for bx, by, bw, bh, conf in candidates[:3]:

                cv2.circle(frame, (int(bx), int(by)), 5, (0, 128, 255), 1)

        status = "NO MODEL" if (self.net is None and self.session is None) else (

            "SWING" if press_contact else "READY" if ready else "TRACK" if eval_ball is not None else "DETECT" if is_real_ball else "WAIT"

        )

        cv2.rectangle(frame, (16, full_h - 92), (500, full_h - 18), (0, 0, 0), -1)

        cv2.putText(frame, f"YOLO v2 {self.backend_name}{self.yolo_input} {status}", (30, full_h - 42),

                    cv2.FONT_HERSHEY_SIMPLEX, 1.35, box_color, 4, cv2.LINE_AA)

        if self.net is None and self.session is None and self.model_error:

            cv2.putText(frame, self.model_error, (30, 44),

                        cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 255), 2, cv2.LINE_AA)

        elif self.backend_name == "cv2" and self.ort_error:

            cv2.putText(frame, f"ORT fail: {self.ort_error[:90]}", (30, 44),

                        cv2.FONT_HERSHEY_SIMPLEX, 0.58, (0, 128, 255), 2, cv2.LINE_AA)

        return frame, self.gcvdata