Computer vision that keeps your code visible.

"""Example 1: open and display the camera."""

import cvgo as go


camera = go.Camera()

while True:
    frame = camera.read()

    if frame is None:
        break

    if not camera.show(frame):
        break

camera.close()

"""CLI example 1: read camera information without a preview window."""

import cvgo as go


camera = go.Camera()
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        height, width = frame.shape[:2]
        info = f"Camera: ON | Size: {width}x{height} | FPS: {fps.read():.1f}"
        print(f"\r{info:<70}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close(windows=False)

"""CLI Web example 1: monitor the camera from a browser."""

import cvgo as go


camera = go.Camera()
viewer = go.WebViewer("CVGO Camera")
fps = go.FPS()

print(f"Web monitor: http://IP-STB:{viewer.port}")
print("Press Ctrl+C to stop the CLI process.")

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        height, width = frame.shape[:2]
        viewer.update(
            frame,
            status={
                "Camera": "ON",
                "Resolution": f"{width}x{height}",
                "Loop FPS": f"{fps.read():.1f}",
            },
        )
except KeyboardInterrupt:
    pass
finally:
    viewer.close()
    camera.close(windows=False)

"""Example 2: detect faces."""

import cvgo as go


camera = go.Camera()
detector = go.FaceDetector()

while True:
    frame = camera.read()

    if frame is None:
        break

    faces = detector.detect(frame)

    for face in faces:
        face.draw(frame)

    if not camera.show(frame):
        break

camera.close()
detector.close()

"""CLI example 2: print face detection status."""

import cvgo as go


camera = go.Camera()
detector = go.FaceDetector()
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        faces = detector.detect(frame)
        status = "DETECTED" if faces else "NOT DETECTED"
        info = (
            f"Face: {status} | Count: {len(faces)} | "
            f"FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<70}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close(windows=False)
    detector.close()

"""CLI Web example 2: show detected face boxes in a browser."""

import cvgo as go


camera = go.Camera()
detector = go.FaceDetector()
viewer = go.WebViewer("CVGO Face Detection")
fps = go.FPS()

print(f"Web monitor: http://IP-STB:{viewer.port}")
print("The detection loop keeps running when the browser is closed.")

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        faces = detector.detect(frame)

        for face in faces:
            face.draw(frame)

        viewer.update(
            frame,
            status={
                "Face": "DETECTED" if faces else "NOT DETECTED",
                "Count": len(faces),
                "Loop FPS": f"{fps.read():.1f}",
            },
        )
except KeyboardInterrupt:
    pass
finally:
    viewer.close()
    camera.close(windows=False)
    detector.close()

"""Example 3: display face landmarks."""

import cvgo as go


camera = go.Camera()
landmarker = go.FaceLandmarks()

while True:
    frame = camera.read()

    if frame is None:
        break

    faces = landmarker.detect(frame)

    for face in faces:
        face.draw(frame)

    if not camera.show(frame):
        break

camera.close()
landmarker.close()

"""CLI example 3: print face and landmark counts."""

import cvgo as go


camera = go.Camera()
landmarker = go.FaceLandmarks()
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        faces = landmarker.detect(frame)
        points = sum(len(face) for face in faces)
        info = (
            f"Faces: {len(faces)} | Landmarks: {points} | "
            f"FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<70}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close(windows=False)
    landmarker.close()

"""CLI Web example 3: show face landmarks in a browser."""

import cvgo as go


camera = go.Camera()
landmarker = go.FaceLandmarks()
viewer = go.WebViewer("CVGO Face Landmarks")
fps = go.FPS()

print(f"Web monitor: http://IP-STB:{viewer.port}")

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        faces = landmarker.detect(frame)

        for face in faces:
            face.draw(frame)

        viewer.update(
            frame,
            status={
                "Faces": len(faces),
                "Landmarks": sum(len(face) for face in faces),
                "Loop FPS": f"{fps.read():.1f}",
            },
        )
except KeyboardInterrupt:
    pass
finally:
    viewer.close()
    camera.close(windows=False)
    landmarker.close()

"""Example 4: read EAR, yaw, and pitch."""

import cvgo as go


camera = go.Camera()
landmarker = go.FaceLandmarks()

while True:
    frame = camera.read()

    if frame is None:
        break

    faces = landmarker.detect(frame)

    if faces:
        face = faces[0]

        ear = go.eye_ratio(face)
        yaw = go.yaw_ratio(face)
        pitch = go.pitch_ratio(face)

        go.put_text(frame, f"EAR: {ear:.3f}")
        go.put_text(frame, f"Yaw: {yaw:.3f}", (20, 70))
        go.put_text(frame, f"Pitch: {pitch:.3f}", (20, 105))

        face.draw(frame)

    if not camera.show(frame):
        break

camera.close()
landmarker.close()

"""CLI example 4: print EAR, yaw, and pitch values."""

import cvgo as go


camera = go.Camera()
landmarker = go.FaceLandmarks()
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        faces = landmarker.detect(frame)

        if faces:
            face = faces[0]
            ear = f"{go.eye_ratio(face):.3f}"
            yaw = f"{go.yaw_ratio(face):.3f}"
            pitch = f"{go.pitch_ratio(face):.3f}"
        else:
            ear = yaw = pitch = "---"

        info = (
            f"EAR: {ear} | Yaw: {yaw} | Pitch: {pitch} | "
            f"FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<80}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close(windows=False)
    landmarker.close()

"""CLI Web example 4: monitor EAR, yaw, and pitch in a browser."""

import cvgo as go


camera = go.Camera()
landmarker = go.FaceLandmarks()
viewer = go.WebViewer("CVGO Face Metrics")
fps = go.FPS()

print(f"Web monitor: http://IP-STB:{viewer.port}")

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        faces = landmarker.detect(frame)
        ear_text = "-"
        yaw_text = "-"
        pitch_text = "-"

        if faces:
            face = faces[0]
            ear = go.eye_ratio(face)
            yaw = go.yaw_ratio(face)
            pitch = go.pitch_ratio(face)
            ear_text = f"{ear:.3f}"
            yaw_text = f"{yaw:.3f}"
            pitch_text = f"{pitch:.3f}"

            face.draw(frame)
            go.put_text(frame, f"EAR: {ear_text}")
            go.put_text(frame, f"Yaw: {yaw_text}", (20, 70))
            go.put_text(frame, f"Pitch: {pitch_text}", (20, 105))

        viewer.update(
            frame,
            status={
                "Face": "DETECTED" if faces else "NOT DETECTED",
                "EAR": ear_text,
                "Yaw": yaw_text,
                "Pitch": pitch_text,
                "Loop FPS": f"{fps.read():.1f}",
            },
        )
except KeyboardInterrupt:
    pass
finally:
    viewer.close()
    camera.close(windows=False)
    landmarker.close()

"""Example 5: send one value to Arduino and report the result."""

import time
import cvgo as go


arduino = go.Serial(
    settle_time=4.0,
)

try:
    if not arduino.connected:
        print("Arduino: NOT CONNECTED")
    else:
        print(f"Arduino: CONNECTED | Port: {arduino.port}")
        sent = arduino.send("1")
        status = "SENT" if sent else "FAILED"
        print(f"{status}: 1")

        if sent:
            # Give the sketch time to process a one-shot command before close.
            time.sleep(0.5)
finally:
    arduino.close()

"""CLI example 5: send terminal input to Arduino."""

import cvgo as go


arduino = go.Serial()

try:
    if not arduino.connected:
        print("Arduino: NOT CONNECTED")
    else:
        print(f"Arduino: CONNECTED | Port: {arduino.port}")
        print("Type a value and press Enter. Type q to quit.")

        while True:
            value = input("Send > ").strip()

            if value.lower() == "q":
                break

            if value:
                status = "SENT" if arduino.send(value) else "FAILED"
                print(f"{status}: {value}")
except KeyboardInterrupt:
    print()
finally:
    arduino.close()

"""CLI Web example 5: show one-shot Arduino send status in a browser."""

import time
import cvgo as go


viewer = go.WebViewer("CVGO Serial Arduino")
arduino = go.Serial(settle_time=4.0)

if arduino.connected:
    sent = arduino.send("1")
    status = "SENT" if sent else "FAILED"
else:
    sent = False
    status = "NOT CONNECTED"

viewer.update(
    status={
        "Arduino": "CONNECTED" if arduino.connected else "NOT CONNECTED",
        "Port": arduino.port or "-",
        "Command": "1",
        "Send": status,
    }
)

print(f"Web monitor: http://IP-STB:{viewer.port}")
print("Press Ctrl+C to stop the CLI process.")

try:
    while True:
        time.sleep(1)
except KeyboardInterrupt:
    pass
finally:
    viewer.close()
    arduino.close()

"""Example 6: send face detection status to Arduino."""

import cvgo as go


camera = go.Camera()
detector = go.FaceDetector()
arduino = go.Serial()
last_status = None

while True:
    frame = camera.read()

    if frame is None:
        break

    faces = detector.detect(frame)
    status = 1 if faces else 0

    if status != last_status:
        if arduino.send(status):
            last_status = status

    for face in faces:
        face.draw(frame)

    if not camera.show(frame):
        break

camera.close()
detector.close()
arduino.close()

"""CLI example 6: send face presence to Arduino."""

import cvgo as go


camera = go.Camera()
detector = go.FaceDetector()
arduino = go.Serial()
fps = go.FPS()
last_status = None

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        faces = detector.detect(frame)
        status = 1 if faces else 0

        if status != last_status and arduino.send(status):
            last_status = status

        face_text = "DETECTED" if status else "NOT DETECTED"
        serial_text = "CONNECTED" if arduino.connected else "DISCONNECTED"
        info = (
            f"Face: {face_text} | Arduino: {serial_text} | "
            f"Sent: {last_status} | FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<100}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close(windows=False)
    detector.close()
    arduino.close()

"""CLI Web example 6: monitor face-to-Arduino status in a browser."""

import cvgo as go


camera = go.Camera()
detector = go.FaceDetector()
arduino = go.Serial()
viewer = go.WebViewer("CVGO Face to Arduino")
fps = go.FPS()
last_status = None

print(f"Web monitor: http://IP-STB:{viewer.port}")

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        faces = detector.detect(frame)
        value = 1 if faces else 0

        if value != last_status and arduino.send(value):
            last_status = value

        for face in faces:
            face.draw(frame)

        viewer.update(
            frame,
            status={
                "Face": "DETECTED" if faces else "NOT DETECTED",
                "Count": len(faces),
                "Arduino": "CONNECTED" if arduino.connected else "NOT CONNECTED",
                "Sent Value": last_status if last_status is not None else "-",
                "Loop FPS": f"{fps.read():.1f}",
            },
        )
except KeyboardInterrupt:
    pass
finally:
    viewer.close()
    camera.close(windows=False)
    detector.close()
    arduino.close()

"""Example 7: detect drowsiness based on EAR and duration."""

import cvgo as go


EAR_THRESHOLD = 0.20

camera = go.Camera()
landmarker = go.FaceLandmarks()
eye_timer = go.Timer(1.5)
ear_smoother = go.Smoother()
alarm = go.Alarm()

while True:
    frame = camera.read()

    if frame is None:
        break

    faces = landmarker.detect(frame)
    drowsy = False

    if faces:
        face = faces[0]
        ear = ear_smoother.update(go.eye_ratio(face))
        eyes_closed = ear < EAR_THRESHOLD
        drowsy = eye_timer.check(eyes_closed)

        status = "DROWSY" if drowsy else "NORMAL"
        color = (0, 0, 255) if drowsy else (0, 255, 0)

        go.put_text(frame, f"Status: {status}", color=color)
        go.put_text(frame, f"EAR: {ear:.3f}", (20, 70))
        face.draw(frame, color=color)
    else:
        eye_timer.reset()
        ear_smoother.reset()

    alarm.trigger(drowsy)

    if not camera.show(frame):
        break

camera.close()
landmarker.close()

"""CLI example 7: detect drowsiness and print the result."""

import cvgo as go


EAR_THRESHOLD = 0.30

camera = go.Camera()
landmarker = go.FaceLandmarks()
eye_timer = go.Timer(0.5)
ear_smoother = go.Smoother()
alarm = go.Alarm()
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        faces = landmarker.detect(frame)
        drowsy = False
        status = "NO FACE"
        ear_text = "---"

        if faces:
            ear = ear_smoother.update(go.eye_ratio(faces[0]))
            drowsy = eye_timer.check(ear < EAR_THRESHOLD)
            status = "DROWSY" if drowsy else "NORMAL"
            ear_text = f"{ear:.3f}"
        else:
            eye_timer.reset()
            ear_smoother.reset()

        alarm.trigger(drowsy)

        info = (
            f"Status: {status} | EAR: {ear_text} | "
            f"FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<70}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close(windows=False)
    landmarker.close()

"""CLI Web example 7: show drowsiness detection in a browser."""

import cvgo as go


EAR_THRESHOLD = 0.20

camera = go.Camera()
landmarker = go.FaceLandmarks()
eye_timer = go.Timer(1.5)
ear_smoother = go.Smoother()
alarm = go.Alarm()
viewer = go.WebViewer("CVGO Drowsiness Detection")
fps = go.FPS()

print(f"Web monitor: http://IP-STB:{viewer.port}")

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        faces = landmarker.detect(frame)
        drowsy = False
        status = "NO FACE"
        ear_text = "-"

        if faces:
            face = faces[0]
            ear = ear_smoother.update(go.eye_ratio(face))
            drowsy = eye_timer.check(ear < EAR_THRESHOLD)
            status = "DROWSY" if drowsy else "NORMAL"
            ear_text = f"{ear:.3f}"
            color = (0, 0, 255) if drowsy else (0, 255, 0)

            face.draw(frame, color=color)
            go.put_text(frame, f"Status: {status}", color=color)
            go.put_text(frame, f"EAR: {ear_text}", (20, 70))
        else:
            eye_timer.reset()
            ear_smoother.reset()

        alarm.trigger(drowsy)
        viewer.update(
            frame,
            status={
                "Status": status,
                "EAR": ear_text,
                "Threshold": EAR_THRESHOLD,
                "Loop FPS": f"{fps.read():.1f}",
            },
        )
except KeyboardInterrupt:
    pass
finally:
    viewer.close()
    camera.close(windows=False)
    landmarker.close()

"""Example 8: final driver monitor project that is still easy to study."""

import cvgo as go


# Detection thresholds
EAR_THRESHOLD = 0.20
YAW_NORMAL = 0.50
YAW_LIMIT = 0.12
PITCH_NORMAL = 0.50
PITCH_LIMIT = 0.055

# Components
camera = go.Camera()
landmarker = go.FaceLandmarks()
arduino = go.Serial()
alarm = go.Alarm()
fps_counter = go.FPS()

# Condition timers
eye_timer = go.Timer(1.5)
turn_timer = go.Timer(0.7)
down_timer = go.Timer(0.7)
missing_timer = go.Timer(2.0)

# Eye value smoother
ear_smoother = go.Smoother()

# Last serial status
last_mask = None

while True:
    frame = camera.read()

    if frame is None:
        break

    faces = landmarker.detect(frame)
    fps = fps_counter.read()

    ear = None
    yaw = None
    pitch = None

    drowsy = False
    looking_away = False
    head_down = False
    face_missing = False

    if faces:
        face = faces[0]

        ear = ear_smoother.update(go.eye_ratio(face))
        yaw = go.yaw_ratio(face)
        pitch = go.pitch_ratio(face)

        eyes_closed = ear < EAR_THRESHOLD
        turn_condition = abs(yaw - YAW_NORMAL) > YAW_LIMIT
        down_condition = pitch - PITCH_NORMAL > PITCH_LIMIT

        drowsy = eye_timer.check(eyes_closed)
        looking_away = turn_timer.check(turn_condition)
        head_down = down_timer.check(down_condition)

        missing_timer.reset()
        face.draw(frame)
    else:
        eye_timer.reset()
        turn_timer.reset()
        down_timer.reset()
        ear_smoother.reset()

        face_missing = missing_timer.check(True)

    mask = 0

    if drowsy:
        mask |= go.BIT_DROWSY

    if looking_away:
        mask |= go.BIT_LOOKING_AWAY

    if head_down:
        mask |= go.BIT_HEAD_DOWN

    if face_missing:
        mask |= go.BIT_FACE_MISSING

    if mask != last_mask:
        if arduino.send(f"{mask:X}"):
            last_mask = mask

    alerts = []

    if drowsy:
        alerts.append("DROWSY")

    if looking_away:
        alerts.append("LOOKING_AWAY")

    if head_down:
        alerts.append("HEAD_DOWN")

    if face_missing:
        alerts.append("FACE_MISSING")

    status = " | ".join(alerts) if alerts else "NORMAL"
    color = (0, 0, 255) if alerts else (0, 255, 0)

    ear_text = "-" if ear is None else f"{ear:.3f}"
    yaw_text = "-" if yaw is None else f"{yaw:.3f}"
    pitch_text = "-" if pitch is None else f"{pitch:.3f}"

    go.put_text(
        frame,
        f"Status: {status}",
        (20, 35),
        color=color,
        background=True,
    )
    go.put_text(frame, f"EAR: {ear_text}", (20, 70))
    go.put_text(frame, f"Yaw: {yaw_text}", (20, 105))
    go.put_text(frame, f"Pitch: {pitch_text}", (20, 140))
    go.put_text(frame, f"FPS: {fps:.1f} | Mask: {mask:X}", (20, 175))

    alarm.trigger(mask != 0)

    if not camera.show(frame, title="CVGO Driver Monitor"):
        break

camera.close()
landmarker.close()
arduino.close()

"""CLI example 8: complete modular driver monitoring."""

import cvgo as go


EAR_THRESHOLD = 0.20
YAW_NORMAL = 0.50
YAW_LIMIT = 0.12
PITCH_NORMAL = 0.50
PITCH_LIMIT = 0.055

camera = go.Camera()
landmarker = go.FaceLandmarks()
arduino = go.Serial()
alarm = go.Alarm()
fps = go.FPS()

eye_timer = go.Timer(1.5)
turn_timer = go.Timer(0.7)
down_timer = go.Timer(0.7)
missing_timer = go.Timer(2.0)
ear_smoother = go.Smoother()
last_mask = None

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        faces = landmarker.detect(frame)
        ear = yaw = pitch = None
        drowsy = looking_away = head_down = face_missing = False

        if faces:
            face = faces[0]
            ear = ear_smoother.update(go.eye_ratio(face))
            yaw = go.yaw_ratio(face)
            pitch = go.pitch_ratio(face)

            drowsy = eye_timer.check(ear < EAR_THRESHOLD)
            looking_away = turn_timer.check(
                abs(yaw - YAW_NORMAL) > YAW_LIMIT
            )
            head_down = down_timer.check(
                pitch - PITCH_NORMAL > PITCH_LIMIT
            )
            missing_timer.reset()
        else:
            eye_timer.reset()
            turn_timer.reset()
            down_timer.reset()
            ear_smoother.reset()
            face_missing = missing_timer.check(True)

        mask = 0

        if drowsy:
            mask |= go.BIT_DROWSY
        if looking_away:
            mask |= go.BIT_LOOKING_AWAY
        if head_down:
            mask |= go.BIT_HEAD_DOWN
        if face_missing:
            mask |= go.BIT_FACE_MISSING

        if mask != last_mask and arduino.send(f"{mask:X}"):
            last_mask = mask

        alerts = []

        if drowsy:
            alerts.append("DROWSY")
        if looking_away:
            alerts.append("LOOKING AWAY")
        if head_down:
            alerts.append("HEAD DOWN")
        if face_missing:
            alerts.append("FACE MISSING")

        status = ", ".join(alerts) if alerts else "NORMAL"
        ear_text = "---" if ear is None else f"{ear:.3f}"
        yaw_text = "---" if yaw is None else f"{yaw:.3f}"
        pitch_text = "---" if pitch is None else f"{pitch:.3f}"
        alarm.trigger(mask != 0)

        info = (
            f"Status: {status} | EAR: {ear_text} | Yaw: {yaw_text} | "
            f"Pitch: {pitch_text} | FPS: {fps.read():.1f} | Mask: {mask:X}"
        )
        print(f"\r{info:<130}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close(windows=False)
    landmarker.close()
    arduino.close()

"""CLI Web example 8: monitor driver alerts from a headless server."""

import cvgo as go


monitor = go.DriverMonitor(serial=True, sound=True)
viewer = go.WebViewer("CVGO Driver Monitor")

print(f"Web monitor: http://IP-STB:{viewer.port}")

try:
    while True:
        result = monitor.read()

        if result is None:
            break

        alerts = []
        if result.drowsy:
            alerts.append("DROWSY")
        if result.looking_away:
            alerts.append("LOOKING_AWAY")
        if result.head_down:
            alerts.append("HEAD_DOWN")
        if result.face_missing:
            alerts.append("FACE_MISSING")

        status = " | ".join(alerts) if alerts else "NORMAL"
        color = (0, 0, 255) if alerts else (0, 255, 0)
        ear = "-" if result.ear is None else f"{result.ear:.3f}"
        yaw = "-" if result.yaw is None else f"{result.yaw:.3f}"
        pitch = "-" if result.pitch is None else f"{result.pitch:.3f}"

        if result.landmarks is not None:
            result.landmarks.draw(result.frame)

        go.put_text(result.frame, f"Status: {status}", color=color, background=True)
        go.put_text(result.frame, f"EAR: {ear}", (20, 70))
        go.put_text(result.frame, f"Yaw: {yaw}", (20, 105))
        go.put_text(result.frame, f"Pitch: {pitch}", (20, 140))
        go.put_text(
            result.frame,
            f"FPS: {result.fps:.1f} | Mask: {result.mask_hex}",
            (20, 175),
        )

        viewer.update(
            result.frame,
            status={
                "Status": status,
                "EAR": ear,
                "Yaw": yaw,
                "Pitch": pitch,
                "Mask": result.mask_hex,
                "Loop FPS": f"{result.fps:.1f}",
            },
        )
except KeyboardInterrupt:
    pass
finally:
    viewer.close()
    monitor.close(windows=False)

"""Example 9: hand tracking, hand labels, and FPS."""

import cvgo as go


camera = go.Camera()
tracker = go.HandTracker()
fps = go.FPS()

while True:
    frame = camera.read()

    if frame is None:
        break

    hands = tracker.detect(frame)

    for hand in hands:
        hand.draw(frame)
        label = f"{hand.handedness}: {hand.confidence:.2f}"
        hand.box().draw(frame, label=label)

    go.put_text(frame, f"Hands: {len(hands)}")
    go.put_text(frame, f"FPS: {fps.read():.1f}", (20, 70))

    if not camera.show(frame, title="CVGO Hand Tracking"):
        break

camera.close()
tracker.close()

"""CLI example 9: print hand tracking results."""

import cvgo as go


camera = go.Camera()
tracker = go.HandTracker()
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        hands = tracker.detect(frame)
        labels = [
            f"{hand.handedness} ({hand.confidence:.2f})"
            for hand in hands
        ]
        details = ", ".join(labels) if labels else "NONE"
        info = (
            f"Hands: {len(hands)} | Detail: {details} | "
            f"FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<100}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close(windows=False)
    tracker.close()

"""CLI Web example 9: show hand landmarks and boxes in a browser."""

import cvgo as go


camera = go.Camera()
tracker = go.HandTracker()
viewer = go.WebViewer("CVGO Hand Tracking")
fps = go.FPS()

print(f"Web monitor: http://IP-STB:{viewer.port}")

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        hands = tracker.detect(frame)

        for hand in hands:
            hand.draw(frame)
            label = f"{hand.handedness}: {hand.confidence:.2f}"
            hand.box().draw(frame, label=label)

        viewer.update(
            frame,
            status={
                "Hands": len(hands),
                "Labels": [hand.handedness for hand in hands] or "-",
                "Loop FPS": f"{fps.read():.1f}",
            },
        )
except KeyboardInterrupt:
    pass
finally:
    viewer.close()
    camera.close(windows=False)
    tracker.close()

"""Example 10: body pose tracking."""

import cvgo as go


camera = go.Camera()
tracker = go.PoseTracker()
fps = go.FPS()

while True:
    frame = camera.read()

    if frame is None:
        break

    pose = tracker.detect(frame)
    person_detected = pose is not None

    if pose:
        pose.draw(frame)

    status = "POSE DETECTED" if person_detected else "NO POSE"
    color = (0, 255, 0) if person_detected else (0, 0, 255)

    go.put_text(frame, status, color=color)
    go.put_text(frame, f"FPS: {fps.read():.1f}", (20, 70))

    if not camera.show(frame, title="CVGO Pose Tracking"):
        break

camera.close()
tracker.close()

"""CLI example 10: print body pose status."""

import cvgo as go


camera = go.Camera()
tracker = go.PoseTracker()
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        pose = tracker.detect(frame)
        status = "DETECTED" if pose else "NOT DETECTED"
        points = len(pose) if pose else 0
        info = (
            f"Pose: {status} | Landmarks: {points} | "
            f"FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<80}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close(windows=False)
    tracker.close()

"""CLI Web example 10: show body pose tracking in a browser."""

import cvgo as go


camera = go.Camera()
tracker = go.PoseTracker()
viewer = go.WebViewer("CVGO Pose Tracking")
fps = go.FPS()

print(f"Web monitor: http://IP-STB:{viewer.port}")

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        pose = tracker.detect(frame)

        if pose:
            pose.draw(frame)

        viewer.update(
            frame,
            status={
                "Pose": "DETECTED" if pose else "NOT DETECTED",
                "Loop FPS": f"{fps.read():.1f}",
            },
        )
except KeyboardInterrupt:
    pass
finally:
    viewer.close()
    camera.close(windows=False)
    tracker.close()

"""Example 11: lightweight person security with a pose bounding box."""

import cvgo as go


camera = go.Camera()
tracker = go.PoseTracker(model_complexity=0)
presence_timer = go.Timer(0.5)
alarm = go.Alarm()
fps = go.FPS()

while True:
    frame = camera.read()

    if frame is None:
        break

    pose = tracker.detect(frame)
    person_detected = pose is not None
    alert = presence_timer.check(person_detected)

    status = "ALERT" if alert else "SAFE"
    color = (0, 0, 255) if alert else (0, 255, 0)

    if pose:
        pose.box(
            padding=30,
        ).draw(
            frame,
            color=color,
            label="Person",
        )

    go.put_text(frame, f"Status: {status}", color=color)
    go.put_text(frame, f"FPS: {fps.read():.1f}", (20, 70))
    alarm.trigger(alert)

    if not camera.show(frame, title="CVGO Person Security Lite"):
        break

camera.close()
tracker.close()

"""CLI example 11: run lightweight person security with Pose Lite."""

import cvgo as go


camera = go.Camera()
tracker = go.PoseTracker(model_complexity=0)
presence_timer = go.Timer(0.5)
alarm = go.Alarm()
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        pose = tracker.detect(frame)
        alert = presence_timer.check(pose is not None)
        status = "ALERT" if alert else "SAFE"
        info = f"Security: {status} | FPS: {fps.read():.1f}"

        alarm.trigger(alert)
        print(f"\r{info:<60}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close(windows=False)
    tracker.close()

"""CLI Web example 11: monitor Pose Lite security in a browser."""

import cvgo as go


camera = go.Camera()
tracker = go.PoseTracker(model_complexity=0)
presence_timer = go.Timer(0.5)
alarm = go.Alarm()
viewer = go.WebViewer("CVGO Pose Security")
fps = go.FPS()

print(f"Web monitor: http://IP-STB:{viewer.port}")

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        pose = tracker.detect(frame)
        alert = presence_timer.check(pose is not None)
        status = "ALERT" if alert else "SAFE"
        color = (0, 0, 255) if alert else (0, 255, 0)

        if pose:
            pose.box(padding=30).draw(
                frame,
                color=color,
                label="Person",
            )

        go.put_text(frame, f"Status: {status}", color=color)
        alarm.trigger(alert)
        viewer.update(
            frame,
            status={
                "Security": status,
                "Person": "DETECTED" if pose else "NOT DETECTED",
                "Loop FPS": f"{fps.read():.1f}",
            },
        )
except KeyboardInterrupt:
    pass
finally:
    viewer.close()
    camera.close(windows=False)
    tracker.close()

"""Example 12: general object detection."""

import cvgo as go


camera = go.Camera()
detector = go.ObjectDetector()
fps = go.FPS()

while True:
    frame = camera.read()

    if frame is None:
        break

    objects = detector.detect(frame)

    for item in objects:
        item.draw(frame)

    go.put_text(frame, f"Objects: {len(objects)}")
    go.put_text(frame, f"Loop FPS: {fps.read():.1f}", (20, 70))

    if not camera.show(frame, title="CVGO Object Detection"):
        break

camera.close()
detector.close()

"""CLI example 12: print detected object labels and scores."""

import cvgo as go


camera = go.Camera()
detector = go.ObjectDetector()
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        objects = detector.detect(frame)
        labels = [
            f"{item.label} ({item.score:.2f})"
            for item in objects[:3]
        ]
        details = ", ".join(labels) if labels else "NONE"
        info = (
            f"Objects: {len(objects)} | Top: {details} | "
            f"Loop FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<120}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close(windows=False)
    detector.close()

"""CLI Web example 12: show object boxes and labels in a browser."""

import cvgo as go


camera = go.Camera()
detector = go.ObjectDetector(mode="live")
viewer = go.WebViewer("CVGO Object Detection")
fps = go.FPS()

print(f"Web monitor: http://IP-STB:{viewer.port}")

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        objects = detector.detect(frame)

        for item in objects:
            item.draw(frame)

        labels = [item.label for item in objects]
        go.put_text(frame, f"Objects: {len(objects)}")
        viewer.update(
            frame,
            status={
                "Objects": len(objects),
                "Labels": labels or "-",
                "Result Ready": detector.result_ready,
                "Loop FPS": f"{fps.read():.1f}",
            },
        )
except KeyboardInterrupt:
    pass
finally:
    viewer.close()
    camera.close(windows=False)
    detector.close()

"""Example 13: detect multiple people for simple security."""

import cvgo as go


camera = go.Camera()
detector = go.ObjectDetector(allow=["person"])
presence_timer = go.Timer(0.5)
alarm = go.Alarm()

while True:
    frame = camera.read()

    if frame is None:
        break

    people = detector.detect(frame)
    alert = presence_timer.check(bool(people))

    for person in people:
        person.draw(frame, color=(0, 0, 255))

    status = "ALERT" if alert else "SAFE"
    color = (0, 0, 255) if alert else (0, 255, 0)

    go.put_text(frame, f"Status: {status}", color=color)
    go.put_text(frame, f"Count: {len(people)}", (20, 70))
    alarm.trigger(alert)

    if not camera.show(frame, title="CVGO Person Security"):
        break

camera.close()
detector.close()

"""CLI example 13: detect people for a terminal security monitor."""

import cvgo as go


camera = go.Camera()
detector = go.ObjectDetector(allow=["person"])
presence_timer = go.Timer(0.5)
alarm = go.Alarm()
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        people = detector.detect(frame)
        alert = presence_timer.check(bool(people))
        status = "ALERT" if alert else "SAFE"
        info = (
            f"Security: {status} | People: {len(people)} | "
            f"Loop FPS: {fps.read():.1f}"
        )

        alarm.trigger(alert)
        print(f"\r{info:<70}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close(windows=False)
    detector.close()

"""CLI Web example 13: monitor person security in a browser."""

import cvgo as go


camera = go.Camera()
detector = go.ObjectDetector(allow=["person"], mode="live")
presence_timer = go.Timer(0.5)
alarm = go.Alarm()
viewer = go.WebViewer("CVGO Person Security")
fps = go.FPS()

print(f"Web monitor: http://IP-STB:{viewer.port}")

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        people = detector.detect(frame)
        alert = presence_timer.check(bool(people))
        status = "ALERT" if alert else "SAFE"
        color = (0, 0, 255) if alert else (0, 255, 0)

        for person in people:
            person.draw(frame, color=color)

        go.put_text(frame, f"Status: {status}", color=color)
        go.put_text(frame, f"Count: {len(people)}", (20, 70))
        alarm.trigger(alert)
        viewer.update(
            frame,
            status={
                "Security": status,
                "People": len(people),
                "Result Ready": detector.result_ready,
                "Loop FPS": f"{fps.read():.1f}",
            },
        )
except KeyboardInterrupt:
    pass
finally:
    viewer.close()
    camera.close(windows=False)
    detector.close()

"""Example 14: hand gesture recognition."""

import cvgo as go


camera = go.Camera()
recognizer = go.GestureRecognizer()

while True:
    frame = camera.read()

    if frame is None:
        break

    gestures = recognizer.detect(frame)

    for gesture in gestures:
        gesture.draw(frame)

    if not camera.show(frame, title="CVGO Gesture Recognition"):
        break

camera.close()
recognizer.close()

"""CLI example 14: print recognized hand gestures."""

import cvgo as go


camera = go.Camera()
recognizer = go.GestureRecognizer()
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        gestures = recognizer.detect(frame)
        labels = [
            f"{gesture.label} ({gesture.score:.2f})"
            for gesture in gestures
            if gesture.recognized
        ]
        details = ", ".join(labels) if labels else "NONE"
        info = f"Gestures: {details} | Loop FPS: {fps.read():.1f}"
        print(f"\r{info:<100}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close(windows=False)
    recognizer.close()

"""CLI Web example 14: show hand gesture results in a browser."""

import cvgo as go


camera = go.Camera()
recognizer = go.GestureRecognizer(mode="live")
viewer = go.WebViewer("CVGO Gesture Recognition")
fps = go.FPS()

print(f"Web monitor: http://IP-STB:{viewer.port}")

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        gestures = recognizer.detect(frame)

        for gesture in gestures:
            gesture.draw(frame)

        labels = [
            f"{gesture.label} ({gesture.score:.2f})"
            for gesture in gestures
            if gesture.recognized
        ]
        viewer.update(
            frame,
            status={
                "Gestures": len(gestures),
                "Labels": labels or "-",
                "Result Ready": recognizer.result_ready,
                "Loop FPS": f"{fps.read():.1f}",
            },
        )
except KeyboardInterrupt:
    pass
finally:
    viewer.close()
    camera.close(windows=False)
    recognizer.close()

"""Example 15: face, pose, and hands in one pipeline."""

import cvgo as go


camera = go.Camera()
tracker = go.HolisticTracker()

while True:
    frame = camera.read()

    if frame is None:
        break

    result = tracker.detect(frame)
    result.draw(frame)

    if not camera.show(frame, title="CVGO Holistic Tracking"):
        break

camera.close()
tracker.close()

"""CLI example 15: print face, pose, and hand status."""

import cvgo as go


camera = go.Camera()
tracker = go.HolisticTracker()
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        result = tracker.detect(frame)
        face = "YES" if result.face else "NO"
        pose = "YES" if result.pose else "NO"
        info = (
            f"Face: {face} | Pose: {pose} | Hands: {len(result.hands)} | "
            f"FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<80}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close(windows=False)
    tracker.close()

"""CLI Web example 15: show face, pose, and hands in a browser."""

import cvgo as go


camera = go.Camera()
tracker = go.HolisticTracker()
viewer = go.WebViewer("CVGO Holistic Tracking")
fps = go.FPS()

print(f"Web monitor: http://IP-STB:{viewer.port}")

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        result = tracker.detect(frame)
        if result:
            result.draw(frame)

        viewer.update(
            frame,
            status={
                "Face": "YES" if result.face else "NO",
                "Pose": "YES" if result.pose else "NO",
                "Hands": len(result.hands),
                "Loop FPS": f"{fps.read():.1f}",
            },
        )
except KeyboardInterrupt:
    pass
finally:
    viewer.close()
    camera.close(windows=False)
    tracker.close()

"""Example 16: blur the webcam background."""

import cvgo as go


camera = go.Camera()
segmenter = go.SelfieSegmenter()

while True:
    frame = camera.read()

    if frame is None:
        break

    result = segmenter.segment(frame)
    frame = result.blur(frame)

    if not camera.show(frame, title="CVGO Selfie Segmentation"):
        break

camera.close()
segmenter.close()

"""CLI example 16: print foreground coverage from segmentation."""

import cvgo as go


camera = go.Camera()
segmenter = go.SelfieSegmenter()
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        result = segmenter.segment(frame)
        coverage = result.foreground().mean() * 100
        info = (
            f"Person coverage: {coverage:.1f}% | "
            f"FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<70}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close(windows=False)
    segmenter.close()

"""CLI Web example 16: show background blur in a browser."""

import cvgo as go


camera = go.Camera()
segmenter = go.SelfieSegmenter()
viewer = go.WebViewer("CVGO Selfie Segmentation")
fps = go.FPS()

print(f"Web monitor: http://IP-STB:{viewer.port}")

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        result = segmenter.segment(frame)
        coverage = result.foreground().mean() * 100
        output = result.blur(frame)
        go.put_text(output, f"Person coverage: {coverage:.1f}%")

        viewer.update(
            output,
            status={
                "Person Coverage": f"{coverage:.1f}%",
                "Loop FPS": f"{fps.read():.1f}",
            },
        )
except KeyboardInterrupt:
    pass
finally:
    viewer.close()
    camera.close(windows=False)
    segmenter.close()

"""Example 17: send a Telegram photo when a pose is detected."""

import cvgo as go


camera = go.Camera()
tracker = go.PoseTracker(model_complexity=0)
telegram = go.Telegram()
presence_timer = go.Timer(0.5)
notified = False
pending = None

while True:
    frame = camera.read()

    if frame is None:
        break

    pose = tracker.detect(frame)
    alert = presence_timer.check(pose is not None)

    if pending is not None and pending.done():
        if not pending.result():
            print(f"Telegram: {telegram.last_error}")
        pending = None

    if pose:
        pose.box(padding=30).draw(frame, color=(0, 0, 255), label="Person")

    status = "PERSON DETECTED" if alert else "SAFE"
    color = (0, 0, 255) if alert else (0, 255, 0)
    go.put_text(frame, f"Status: {status}", color=color)

    if alert and not notified and pending is None:
        pending = telegram.send_photo_async(frame, "Warning: person detected.", key="security")

    notified = alert

    if not camera.show(frame, title="CVGO Telegram Security"):
        break

camera.close()
tracker.close()
telegram.close()

"""CLI example 17: send a Telegram photo when a pose is detected."""

import cvgo as go


camera = go.Camera()
tracker = go.PoseTracker(model_complexity=0)
telegram = go.Telegram()
presence_timer = go.Timer(0.5)
fps = go.FPS()
notified = False
telegram_status = "WAITING"
pending = None

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        pose = tracker.detect(frame)
        alert = presence_timer.check(pose is not None)

        if pending is not None and pending.done():
            sent = pending.result()
            telegram_status = "SENT" if sent else "FAILED"
            pending = None

        if alert and not notified and pending is None:
            pending = telegram.send_photo_async(
                frame,
                "Warning: person detected.",
                key="security",
            )
            telegram_status = "QUEUED"
            notified = True
        elif not alert:
            notified = False
            telegram_status = "WAITING"

        status = "PERSON DETECTED" if alert else "SAFE"
        info = (
            f"Security: {status} | Pose: {'YES' if pose else 'NO'} | "
            f"Telegram: {telegram_status} | "
            f"Loop FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<110}", end="", flush=True)

        if telegram_status == "FAILED":
            print(f"\nTelegram: {telegram.last_error}")
            telegram_status = "ERROR SHOWN"
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close(windows=False)
    tracker.close()
    telegram.close()

"""CLI Web example 17: monitor pose security and Telegram status."""

import cvgo as go


camera = go.Camera()
tracker = go.PoseTracker(model_complexity=0)
telegram = go.Telegram()
presence_timer = go.Timer(0.5)
viewer = go.WebViewer("CVGO Telegram Security")
fps = go.FPS()
notified = False
telegram_status = "WAITING"
pending = None

print(f"Web monitor: http://IP-STB:{viewer.port}")

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        pose = tracker.detect(frame)
        alert = presence_timer.check(pose is not None)

        if pending is not None and pending.done():
            telegram_status = "SENT" if pending.result() else "FAILED"
            pending = None

        if pose:
            pose.box(padding=30).draw(
                frame,
                color=(0, 0, 255),
                label="Person",
            )

        if alert and not notified and pending is None:
            pending = telegram.send_photo_async(
                frame,
                "Warning: person detected.",
                key="security",
            )
            telegram_status = "QUEUED"
            notified = True
        elif not alert:
            notified = False
            telegram_status = "WAITING"

        status = "PERSON DETECTED" if alert else "SAFE"
        color = (0, 0, 255) if alert else (0, 255, 0)
        go.put_text(frame, f"Status: {status}", color=color)
        viewer.update(
            frame,
            status={
                "Security": status,
                "Telegram": telegram_status,
                "Telegram Error": telegram.last_error or "-",
                "Loop FPS": f"{fps.read():.1f}",
            },
        )
except KeyboardInterrupt:
    pass
finally:
    viewer.close()
    camera.close(windows=False)
    tracker.close()
    telegram.close()

"""Example 18: send a Telegram photo when people are detected."""

import cvgo as go


camera = go.Camera()
detector = go.ObjectDetector(allow=["person"])
telegram = go.Telegram()
presence_timer = go.Timer(0.5)
notified = False
pending = None

while True:
    frame = camera.read()

    if frame is None:
        break

    people = detector.detect(frame)
    alert = presence_timer.check(bool(people))

    if pending is not None and pending.done():
        if not pending.result():
            print(f"Telegram: {telegram.last_error}")
        pending = None

    for person in people:
        person.draw(frame, color=(0, 0, 255))

    status = "PEOPLE DETECTED" if alert else "SAFE"
    color = (0, 0, 255) if alert else (0, 255, 0)
    go.put_text(frame, f"Status: {status}", color=color)
    go.put_text(frame, f"Count: {len(people)}", (20, 70))

    if alert and not notified and pending is None:
        pending = telegram.send_photo_async(
            frame,
            f"Warning: {len(people)} person(s) detected.",
            key="person-security",
        )

    notified = alert

    if not camera.show(frame, title="CVGO Telegram Person Security"):
        break

camera.close()
detector.close()
telegram.close()

"""CLI example 18: send a Telegram photo when people are detected."""

import cvgo as go


camera = go.Camera()
detector = go.ObjectDetector(allow=["person"])
telegram = go.Telegram()
presence_timer = go.Timer(0.5)
fps = go.FPS()
notified = False
telegram_status = "WAITING"
pending = None

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        people = detector.detect(frame)
        alert = presence_timer.check(bool(people))

        if pending is not None and pending.done():
            sent = pending.result()
            telegram_status = "SENT" if sent else "FAILED"
            pending = None

        if alert and not notified and pending is None:
            pending = telegram.send_photo_async(
                frame,
                f"Warning: {len(people)} person(s) detected.",
                key="person-security",
            )
            telegram_status = "QUEUED"
            notified = True
        elif not alert:
            notified = False
            telegram_status = "WAITING"

        status = "PEOPLE DETECTED" if alert else "SAFE"
        info = (
            f"Security: {status} | People: {len(people)} | "
            f"Telegram: {telegram_status} | "
            f"Loop FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<110}", end="", flush=True)

        if telegram_status == "FAILED":
            print(f"\nTelegram: {telegram.last_error}")
            telegram_status = "ERROR SHOWN"
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close(windows=False)
    detector.close()
    telegram.close()

"""CLI Web example 18: monitor people and Telegram status."""

import cvgo as go


camera = go.Camera()
detector = go.ObjectDetector(allow=["person"], mode="live")
telegram = go.Telegram()
presence_timer = go.Timer(0.5)
viewer = go.WebViewer("CVGO Telegram Person Security")
fps = go.FPS()
notified = False
telegram_status = "WAITING"
pending = None

print(f"Web monitor: http://IP-STB:{viewer.port}")

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        people = detector.detect(frame)
        alert = presence_timer.check(bool(people))

        if pending is not None and pending.done():
            telegram_status = "SENT" if pending.result() else "FAILED"
            pending = None

        for person in people:
            person.draw(frame, color=(0, 0, 255))

        if alert and not notified and pending is None:
            pending = telegram.send_photo_async(
                frame,
                f"Warning: {len(people)} person(s) detected.",
                key="person-security",
            )
            telegram_status = "QUEUED"
            notified = True
        elif not alert:
            notified = False
            telegram_status = "WAITING"

        status = "PEOPLE DETECTED" if alert else "SAFE"
        color = (0, 0, 255) if alert else (0, 255, 0)
        go.put_text(frame, f"Status: {status}", color=color)
        go.put_text(frame, f"Count: {len(people)}", (20, 70))
        viewer.update(
            frame,
            status={
                "Security": status,
                "People": len(people),
                "Telegram": telegram_status,
                "Telegram Error": telegram.last_error or "-",
                "Loop FPS": f"{fps.read():.1f}",
            },
        )
except KeyboardInterrupt:
    pass
finally:
    viewer.close()
    camera.close(windows=False)
    detector.close()
    telegram.close()

"""Example 19: publish pose status to an MQTT robot topic."""

import cvgo as go


camera = go.Camera()
tracker = go.PoseTracker(model_complexity=0)
mqtt = go.MqttClient(host="localhost", client_id="cvgo-camera", connect=True)
last_detected = None
pending = None

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        pose = tracker.detect(frame)
        detected = pose is not None

        if pending is not None and pending.done():
            if not pending.result():
                print(f"MQTT: {mqtt.last_error}")
            pending = None

        if detected != last_detected and pending is None:
            pending = mqtt.publish_async(
                "robot/camera/pose",
                {"person_detected": detected},
            )
            last_detected = detected

        if pose:
            pose.box(padding=30).draw(frame, label="Person")
        go.put_text(frame, f"Person detected: {detected}")

        if not camera.show(frame, title="CVGO MQTT Robot"):
            break
finally:
    camera.close()
    tracker.close()
    mqtt.close()

"""CLI example 19: publish pose status to an MQTT robot topic."""

import cvgo as go


camera = go.Camera()
tracker = go.PoseTracker(model_complexity=0)
mqtt = go.MqttClient(host="localhost", client_id="cvgo-camera", connect=True)
fps = go.FPS()
last_detected = None

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        pose = tracker.detect(frame)
        detected = pose is not None

        if detected != last_detected:
            mqtt.publish(
                "robot/camera/pose",
                {"person_detected": detected},
            )
            last_detected = detected

        info = (
            f"MQTT: {'DETECTED' if detected else 'CLEAR'} | "
            f"FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<70}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close(windows=False)
    tracker.close()
    mqtt.close()

"""CLI Web example 19: monitor pose and MQTT publishing."""

import cvgo as go


camera = go.Camera()
tracker = go.PoseTracker(model_complexity=0)
mqtt = go.MqttClient(host="localhost", client_id="cvgo-camera", connect=True)
viewer = go.WebViewer("CVGO MQTT Robot")
fps = go.FPS()
last_detected = None
mqtt_status = "CONNECTED" if mqtt.connected else "NOT CONNECTED"
pending = None

print(f"Web monitor: http://IP-STB:{viewer.port}")

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        pose = tracker.detect(frame)
        detected = pose is not None

        if pending is not None and pending.done():
            mqtt_status = "PUBLISHED" if pending.result() else "FAILED"
            pending = None

        if detected != last_detected and pending is None:
            pending = mqtt.publish_async(
                "robot/camera/pose",
                {"person_detected": detected},
            )
            mqtt_status = "QUEUED"
            last_detected = detected

        if pose:
            pose.box(padding=30).draw(frame, label="Person")
        go.put_text(frame, f"Person detected: {detected}")

        viewer.update(
            frame,
            status={
                "Person": "DETECTED" if detected else "CLEAR",
                "MQTT": mqtt_status,
                "MQTT Error": mqtt.last_error or "-",
                "Loop FPS": f"{fps.read():.1f}",
            },
        )
except KeyboardInterrupt:
    pass
finally:
    viewer.close()
    camera.close(windows=False)
    tracker.close()
    mqtt.close()

"""Example 20: send pose status to a WebSocket robot service."""

import cvgo as go


camera = go.Camera()
tracker = go.PoseTracker(model_complexity=0)
websocket = go.WebSocketClient("ws://localhost:8080", connect=True)
last_detected = None
pending = None

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        pose = tracker.detect(frame)
        detected = pose is not None

        if pending is not None and pending.done():
            if not pending.result():
                print(f"WebSocket: {websocket.last_error}")
            pending = None

        if detected != last_detected and pending is None:
            pending = websocket.send_async({"person_detected": detected})
            last_detected = detected

        if pose:
            pose.box(padding=30).draw(frame, label="Person")
        go.put_text(frame, f"Person detected: {detected}")

        if not camera.show(frame, title="CVGO WebSocket Robot"):
            break
finally:
    camera.close()
    tracker.close()
    websocket.close()

"""CLI example 20: send pose status to a WebSocket robot service."""

import cvgo as go


camera = go.Camera()
tracker = go.PoseTracker(model_complexity=0)
websocket = go.WebSocketClient("ws://localhost:8080", connect=True)
fps = go.FPS()
last_detected = None

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        pose = tracker.detect(frame)
        detected = pose is not None

        if detected != last_detected:
            websocket.send({"person_detected": detected})
            last_detected = detected

        info = (
            f"WebSocket: {'DETECTED' if detected else 'CLEAR'} | "
            f"FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<70}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close(windows=False)
    tracker.close()
    websocket.close()

"""CLI Web example 20: monitor pose and WebSocket sending."""

import cvgo as go


camera = go.Camera()
tracker = go.PoseTracker(model_complexity=0)
websocket = go.WebSocketClient("ws://localhost:8080", connect=True)
viewer = go.WebViewer("CVGO WebSocket Robot")
fps = go.FPS()
last_detected = None
websocket_status = "CONNECTED" if websocket.connected else "NOT CONNECTED"
pending = None

print(f"Web monitor: http://IP-STB:{viewer.port}")

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        pose = tracker.detect(frame)
        detected = pose is not None

        if pending is not None and pending.done():
            websocket_status = "SENT" if pending.result() else "FAILED"
            pending = None

        if detected != last_detected and pending is None:
            pending = websocket.send_async({"person_detected": detected})
            websocket_status = "QUEUED"
            last_detected = detected

        if pose:
            pose.box(padding=30).draw(frame, label="Person")
        go.put_text(frame, f"Person detected: {detected}")

        viewer.update(
            frame,
            status={
                "Person": "DETECTED" if detected else "CLEAR",
                "WebSocket": websocket_status,
                "WebSocket Error": websocket.last_error or "-",
                "Loop FPS": f"{fps.read():.1f}",
            },
        )
except KeyboardInterrupt:
    pass
finally:
    viewer.close()
    camera.close(windows=False)
    tracker.close()
    websocket.close()

"""Example 21: recognize known faces without blocking the camera GUI."""

import cvgo as go


camera = go.Camera()
detector = go.FaceDetector(
    engine="fast",
    model=0,
    detection_confidence=0.5,
)
recognizer = go.FaceRecognizer(
    "faces",
    mode="live",
    model_name="Facenet512",
    detector_backend="mediapipe",
)
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        faces = detector.detect(frame)
        matches = recognizer.recognize(frame) if faces else []

        for index, face in enumerate(faces):
            if index < len(matches):
                match = matches[index]
                label = match.name
                if match.recognized and match.confidence is not None:
                    label = f"{label} {match.confidence:.0%}"
                color = (0, 255, 0) if match.recognized else (0, 0, 255)
            else:
                label = "Recognizing..." if recognizer.busy else "Face"
                color = (0, 200, 255)
            face.draw(frame, label=label, color=color)

        if recognizer.last_error:
            status = f"Error: {recognizer.last_error}"
        elif not faces:
            status = "No face"
        elif not recognizer.result_ready:
            status = "Loading face recognition..."
        elif recognizer.busy and not matches:
            status = "Recognizing..."
        elif matches:
            status = ", ".join(match.name for match in matches)
        else:
            status = "Face detected"

        go.put_text(frame, status)
        go.put_text(
            frame,
            f"Loop FPS: {fps.read():.1f}",
            (20, 70),
        )

        if not camera.show(
            frame,
            title="CVGO Face Recognition",
        ):
            break
finally:
    camera.close()
    detector.close()
    recognizer.close()

"""CLI example 21: recognize known faces without opening a GUI."""

import cvgo as go


camera = go.Camera()
detector = go.FaceDetector(
    engine="fast",
    model=0,
    detection_confidence=0.5,
)
recognizer = go.FaceRecognizer(
    "faces",
    mode="live",
    model_name="Facenet512",
    detector_backend="mediapipe",
)
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        faces = detector.detect(frame)
        matches = recognizer.recognize(frame) if faces else []

        if recognizer.last_error:
            status = f"Error: {recognizer.last_error}"
        elif not faces:
            status = "No face"
        elif not recognizer.result_ready:
            status = "Loading face recognition..."
        elif recognizer.busy and not matches:
            status = "Recognizing..."
        elif matches:
            status = ", ".join(match.name for match in matches)
        else:
            status = "Face detected"

        info = (
            f"Face: {status} | Count: {len(faces)} | "
            f"Busy: {recognizer.busy} | Loop FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<100}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close(windows=False)
    detector.close()
    recognizer.close()

"""CLI Web example 21: show DeepFace recognition boxes in a browser."""

import cvgo as go


camera = go.Camera()
detector = go.FaceDetector(
    engine="fast",
    model=0,
    detection_confidence=0.5,
)
recognizer = go.FaceRecognizer(
    "faces",
    mode="live",
    model_name="Facenet512",
    detector_backend="mediapipe",
)
viewer = go.WebViewer("CVGO Face Recognition")
fps = go.FPS()

print(f"Web monitor: http://IP-STB:{viewer.port}")

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        faces = detector.detect(frame)
        matches = recognizer.recognize(frame) if faces else []

        for index, face in enumerate(faces):
            if index < len(matches):
                match = matches[index]
                label = match.name
                if match.recognized and match.confidence is not None:
                    label = f"{label} {match.confidence:.0%}"
                color = (0, 255, 0) if match.recognized else (0, 0, 255)
            else:
                label = "RECOGNIZING" if recognizer.busy else "FACE"
                color = (0, 200, 255)
            face.draw(frame, label=label, color=color)

        if recognizer.last_error:
            status = f"ERROR: {recognizer.last_error}"
        elif not faces:
            status = "NO FACE"
        elif not recognizer.result_ready:
            status = "LOADING MODEL"
        elif recognizer.busy and not matches:
            status = "RECOGNIZING"
        elif matches:
            status = ", ".join(match.name for match in matches)
        else:
            status = "FACE DETECTED"

        go.put_text(frame, f"Recognition: {status}")
        viewer.update(
            frame,
            status={
                "Recognition": status,
                "Faces": len(faces),
                "Matches": len(matches),
                "Busy": recognizer.busy,
                "Loop FPS": f"{fps.read():.1f}",
            },
        )
except KeyboardInterrupt:
    pass
finally:
    viewer.close()
    camera.close(windows=False)
    detector.close()
    recognizer.close()

"""Example 22: capture a face dataset and train a reusable model."""

from pathlib import Path

import cv2
import cvgo as go


PERSON_NAME = "Ajang"
PHOTO_COUNT = 5
MIN_IMAGES = 3
DATASET_PATH = Path("faces")
MODEL_PATH = Path("face_model.pkl")

person_path = DATASET_PATH / PERSON_NAME
person_path.mkdir(parents=True, exist_ok=True)
next_number = len(list(person_path.glob("*.jpg"))) + 1

camera = go.Camera()
detector = go.FaceDetector(
    engine="fast",
    model=0,
    detection_confidence=0.5,
)
capture_timer = go.Timer(0.7)
captured = 0

try:
    while captured < PHOTO_COUNT:
        frame = camera.read()

        if frame is None:
            break

        clean_frame = frame.copy()
        faces = detector.detect(frame)

        if capture_timer.check(len(faces) == 1):
            while (person_path / f"{next_number:03d}.jpg").exists():
                next_number += 1
            photo_path = person_path / f"{next_number:03d}.jpg"
            if not cv2.imwrite(str(photo_path), clean_frame):
                raise OSError(f"Failed to save {photo_path}")
            captured += 1
            next_number += 1
            capture_timer.reset()

        for face in faces:
            face.draw(frame, label=PERSON_NAME)

        go.put_text(frame, f"Hold one face still: {captured}/{PHOTO_COUNT}")

        if not camera.show(frame, title="CVGO Face Training"):
            break
finally:
    camera.close()
    detector.close()

if captured >= MIN_IMAGES:
    print("Training face model...")
    result = go.train_faces(
        DATASET_PATH,
        MODEL_PATH,
        detector_backend="mediapipe",
        min_images=MIN_IMAGES,
        progress=lambda done, total, image_path: print(
            f"Embedding: {done}/{total} | {image_path.name}"
        ),
    )
    print(
        f"MODEL READY: {result.model_path} | "
        f"{result.identity_count} people | {result.images} photos | "
        f"detector: {result.detector_backend}"
    )
    for message in result.skipped:
        print(f"SKIPPED: {message}")
else:
    print(f"Training canceled: capture at least {MIN_IMAGES} photos.")

"""CLI example 22: capture a face dataset and train a reusable model."""

from pathlib import Path

import cv2
import cvgo as go


PERSON_NAME = "Ajang"
PHOTO_COUNT = 5
MIN_IMAGES = 3
DATASET_PATH = Path("faces")
MODEL_PATH = Path("face_model.pkl")

person_path = DATASET_PATH / PERSON_NAME
person_path.mkdir(parents=True, exist_ok=True)
next_number = len(list(person_path.glob("*.jpg"))) + 1

camera = go.Camera()
detector = go.FaceDetector(
    engine="fast",
    model=0,
    detection_confidence=0.5,
)
capture_timer = go.Timer(0.7)
captured = 0

try:
    while captured < PHOTO_COUNT:
        frame = camera.read()

        if frame is None:
            break

        faces = detector.detect(frame)

        if capture_timer.check(len(faces) == 1):
            while (person_path / f"{next_number:03d}.jpg").exists():
                next_number += 1
            photo_path = person_path / f"{next_number:03d}.jpg"
            if not cv2.imwrite(str(photo_path), frame):
                raise OSError(f"Failed to save {photo_path}")
            captured += 1
            next_number += 1
            capture_timer.reset()

        status = "READY" if len(faces) == 1 else "SHOW ONE FACE"
        info = f"Capture: {captured}/{PHOTO_COUNT} | {status}"
        print(f"\r{info:<70}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close(windows=False)
    detector.close()

if captured >= MIN_IMAGES:
    print("Training face model...")
    result = go.train_faces(
        DATASET_PATH,
        MODEL_PATH,
        detector_backend="mediapipe",
        min_images=MIN_IMAGES,
        progress=lambda done, total, _path: print(
            f"\rEmbedding: {done}/{total}",
            end="",
            flush=True,
        ),
    )
    print()
    print(
        f"MODEL READY: {result.model_path} | "
        f"{result.identity_count} people | {result.images} photos | "
        f"detector: {result.detector_backend}"
    )
    for message in result.skipped:
        print(f"SKIPPED: {message}")
else:
    print(f"Training canceled: capture at least {MIN_IMAGES} photos.")

"""CLI Web example 22: configure, capture, and train faces from a browser."""

from pathlib import Path
import time

import cv2
import cvgo as go


MIN_IMAGES = 3
DATASET_PATH = Path("faces")
MODEL_PATH = Path("face_model.pkl")

viewer = go.WebViewer("CVGO Face Training")
viewer.set_form(
    {
        "person_name": {
            "label": "Person name",
            "value": "Ajang",
            "required": True,
            "max_length": 60,
        },
        "photo_count": {
            "label": "Number of photos",
            "type": "number",
            "value": 5,
            "min": MIN_IMAGES,
            "max": 30,
            "step": 1,
            "required": True,
        },
        "camera_index": {
            "label": "Camera index",
            "type": "number",
            "value": 0,
            "min": 0,
            "max": 16,
            "step": 1,
            "required": True,
        },
    },
    submit_label="Start face training",
    description="Set the identity and camera, then keep exactly one face visible.",
)
viewer.update(
    status={
        "Stage": "WAITING FOR FORM",
        "Detector": "MediaPipe",
        "Confidence": 0.5,
    }
)

camera = None
detector = None
last_frame = None

print(f"Web monitor: http://IP-STB:{viewer.port}")
print("Complete the training form in a browser.")
print("After submission, training continues even if the browser is closed.")

try:
    settings = None
    while settings is None:
        submission = viewer.poll_form()
        if submission is None:
            time.sleep(0.1)
            continue

        person_name = " ".join(submission["person_name"].split())
        if (
            not person_name
            or person_name in {".", ".."}
            or Path(person_name).name != person_name
            or "/" in person_name
            or "\\" in person_name
        ):
            message = "Use a name without / or \\."
            print(f"Invalid person name: {message}")
            viewer.update(status={"Stage": "FORM ERROR", "Message": message})
            continue
        settings = submission

    photo_count = int(settings["photo_count"])
    camera_index = int(settings["camera_index"])
    viewer.clear_form()

    person_path = DATASET_PATH / person_name
    person_path.mkdir(parents=True, exist_ok=True)
    next_number = len(list(person_path.glob("*.jpg"))) + 1
    camera = go.Camera(camera_index)
    detector = go.FaceDetector(
        engine="fast",
        model=0,
        detection_confidence=0.5,
    )
    capture_timer = go.Timer(0.7)
    captured = 0

    while captured < photo_count:
        frame = camera.read()

        if frame is None:
            break

        clean_frame = frame.copy()
        faces = detector.detect(frame)

        if capture_timer.check(len(faces) == 1):
            while (person_path / f"{next_number:03d}.jpg").exists():
                next_number += 1
            photo_path = person_path / f"{next_number:03d}.jpg"
            if not cv2.imwrite(str(photo_path), clean_frame):
                raise OSError(f"Failed to save {photo_path}")
            captured += 1
            next_number += 1
            capture_timer.reset()

        for face in faces:
            face.draw(frame, label=person_name)

        last_frame = frame
        viewer.update(
            frame,
            status={
                "Stage": "CAPTURE",
                "Person": person_name,
                "Photos": f"{captured}/{photo_count}",
                "Face count": len(faces),
                "Detector": "MediaPipe 0.5",
            },
        )

    if captured >= MIN_IMAGES:
        print("Training face model...")
        if last_frame is not None:
            viewer.update(last_frame, status={"Stage": "TRAINING MODEL"})

        def show_training_progress(done, total, image_path):
            print(
                f"\rEmbedding: {done}/{total} | {image_path.name:<30}",
                end="",
                flush=True,
            )
            if last_frame is not None:
                viewer.update(
                    last_frame,
                    status={
                        "Stage": "TRAINING MODEL",
                        "Embedding": f"{done}/{total}",
                        "File": image_path.name,
                        "Detector": "mediapipe",
                    },
                )

        result = go.train_faces(
            DATASET_PATH,
            MODEL_PATH,
            detector_backend="mediapipe",
            min_images=MIN_IMAGES,
            progress=show_training_progress,
        )
        print()
        print(
            f"MODEL READY: {result.model_path} | "
            f"detector: {result.detector_backend}"
        )
        for message in result.skipped:
            print(f"SKIPPED: {message}")
        if last_frame is not None:
            viewer.update(
                last_frame,
                status={
                    "Stage": "MODEL READY",
                    "People": result.identity_count,
                    "Photos": result.images,
                    "Detector": result.detector_backend,
                },
            )
        print("Press Ctrl+C to stop the web monitor.")
        while True:
            time.sleep(1)
    else:
        print(f"Training canceled: capture at least {MIN_IMAGES} photos.")
except KeyboardInterrupt:
    pass
finally:
    viewer.close()
    if camera is not None:
        camera.close(windows=False)
    if detector is not None:
        detector.close()

"""Example 23: recognize faces with a trained CVGO model."""

import cvgo as go


camera = go.Camera()
detector = go.FaceDetector(
    engine="fast",
    model=0,
    detection_confidence=0.5,
)
recognizer = go.FaceRecognizer.from_model(
    "face_model.pkl",
    mode="live",
)
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        faces = detector.detect(frame)
        matches = recognizer.recognize(frame) if faces else []

        for index, face in enumerate(faces):
            if index < len(matches):
                match = matches[index]
                label = match.name
                if match.recognized and match.confidence is not None:
                    label = f"{label} {match.confidence:.0%}"
                color = (0, 255, 0) if match.recognized else (0, 0, 255)
            else:
                label = "Recognizing..." if recognizer.busy else "Face"
                color = (0, 200, 255)
            face.draw(frame, label=label, color=color)

        if recognizer.last_error:
            status = f"Error: {recognizer.last_error}"
        elif not faces:
            status = "No face"
        elif not recognizer.result_ready:
            status = "Loading face model..."
        elif recognizer.busy and not matches:
            status = "Recognizing..."
        elif matches:
            status = ", ".join(match.name for match in matches)
        else:
            status = "Face detected"

        go.put_text(frame, f"Model: {status}")
        go.put_text(frame, f"Loop FPS: {fps.read():.1f}", (20, 70))

        if not camera.show(frame, title="CVGO Face Model"):
            break
finally:
    camera.close()
    detector.close()
    recognizer.close()

"""CLI example 23: recognize faces with a trained CVGO model."""

import cvgo as go


camera = go.Camera()
detector = go.FaceDetector(
    engine="fast",
    model=0,
    detection_confidence=0.5,
)
recognizer = go.FaceRecognizer.from_model(
    "face_model.pkl",
    mode="live",
)
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        faces = detector.detect(frame)
        matches = recognizer.recognize(frame) if faces else []

        if recognizer.last_error:
            status = f"Error: {recognizer.last_error}"
        elif not faces:
            status = "No face"
        elif not recognizer.result_ready:
            status = "Loading face model..."
        elif recognizer.busy and not matches:
            status = "Recognizing..."
        elif matches:
            status = ", ".join(match.name for match in matches)
        else:
            status = "Face detected"

        info = (
            f"Model: {status} | Faces: {len(faces)} | "
            f"Busy: {recognizer.busy} | Loop FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<100}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close(windows=False)
    detector.close()
    recognizer.close()

"""CLI Web example 23: monitor trained face recognition in a browser."""

import cvgo as go


camera = go.Camera()
detector = go.FaceDetector(
    engine="fast",
    model=0,
    detection_confidence=0.5,
)
recognizer = go.FaceRecognizer.from_model(
    "face_model.pkl",
    mode="live",
)
viewer = go.WebViewer("CVGO Face Model")
fps = go.FPS()

print(f"Web monitor: http://IP-STB:{viewer.port}")
print("The recognition loop keeps running when the browser is closed.")

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        faces = detector.detect(frame)
        matches = recognizer.recognize(frame) if faces else []

        for index, face in enumerate(faces):
            if index < len(matches):
                match = matches[index]
                label = match.name
                if match.recognized and match.confidence is not None:
                    label = f"{label} {match.confidence:.0%}"
                color = (0, 255, 0) if match.recognized else (0, 0, 255)
            else:
                label = "RECOGNIZING" if recognizer.busy else "FACE"
                color = (0, 200, 255)
            face.draw(frame, label=label, color=color)

        if recognizer.last_error:
            status = f"ERROR: {recognizer.last_error}"
        elif not faces:
            status = "NO FACE"
        elif not recognizer.result_ready:
            status = "LOADING MODEL"
        elif recognizer.busy and not matches:
            status = "RECOGNIZING"
        elif matches:
            status = ", ".join(match.name for match in matches)
        else:
            status = "FACE DETECTED"

        go.put_text(frame, f"Model: {status}")
        viewer.update(
            frame,
            status={
                "Recognition": status,
                "Faces": len(faces),
                "Matches": len(matches),
                "Busy": recognizer.busy,
                "Loop FPS": f"{fps.read():.1f}",
            },
        )
except KeyboardInterrupt:
    pass
finally:
    viewer.close()
    camera.close(windows=False)
    detector.close()
    recognizer.close()