Upload sensAI-Generic-Object-Detection with upload_repo.py

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.deb filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,25 @@
+# syntax=docker/dockerfile:1
+FROM python:3.11
+
+RUN apt-get update && apt-get install -y ffmpeg libopenblas-dev libopencv-dev qt6-base-dev qt6-multimedia-dev libssl-dev mesa-opencl-icd libboost-all-dev libturbojpeg0-dev ocl-icd-opencl-dev clinfo ocl-icd-libopencl1 && rm -rf /var/lib/apt/lists
+
+ARG HF_TOKEN=""
+
+RUN pip install --no-cache-dir huggingface-hub
+COPY install_eve.py /tmp/install_eve.py
+RUN --mount=type=secret,id=MODEL_ACCESS_TOKEN \
+    HF_TOKEN="$HF_TOKEN" python /tmp/install_eve.py && rm /tmp/install_eve.py
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+RUN mkdir -p /home/user/.config
+
+COPY --chown=user . /app
+CMD ["python", "app.py"]

README.md

@@ -1,10 +1,65 @@
----
-title: SensAI Generic Object Detection
-emoji: 💻
-colorFrom: pink
-colorTo: purple
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Lattice sensAI Generic Object Detection
+slug: sensAI-Generic-Object-Detection
+short_description: Object detection — GMOD-80 / AMOD-8 / OMOD on the EVE SDK
+emoji: 📦
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+pinned: false
+tags:
+    - computer-vision
+    - real-time
+    - edge-ai
+    - on-device
+    - embedded
+    - low-power
+    - object-detection
+    - gmod
+    - amod
+    - omod
+    - npu
+    - soc
+---
+
+The Lattice sensAI Generic Object Detection demo runs the EVE SDK's MOD
+(Multi-Object Detection) subsystem against a frame from an uploaded image,
+an uploaded video, or a live webcam feed. Pick exactly one of three models:
+
+| Model | Description |
+| --- | --- |
+| **GMOD-80** | Generic 80-class object detector (active baseline) |
+| **AMOD-8**  | 8-class automotive object detector — person, bicycle, car, motorcycle, bus, truck, traffic light, stop sign *(preview — placeholder)* |
+| **OMOD**    | Many-class office-objects detector *(preview — placeholder)* |
+
+> **Preview note.** AMOD and OMOD currently fall back to GMOD-80 weights —
+> the EVE C SDK ships a single hardcoded MOD model and does not yet expose a
+> runtime model-switch entry point. Once the SDK gains
+> `EveLoadObjectDetectionModel(...)` (or equivalent), the placeholders go
+> live without any UI changes — only the EVE wrapper and
+> `download_models.py` need updates.
+
+To preview the demo, use the tabs:
+
+- <u>Live Inference</u> — webcam → annotated frames in real time.
+- <u>Offline Inference</u> — upload an image **or** a video; mutually
+  exclusive accordions keep the UI focused on one input at a time.
+
+> Note: For demo purposes, the AI pipeline and image-draw operations run on
+> a Hugging Face CPU server. Performance varies with concurrent users.
+
+For SDK access, fill the form on
+[this page](https://huggingface.co/LatticeSemi/sensAI-Edge-Vision-Engine-SDK-Packages)
+and follow the download instructions. Support: evehelp@latticesemi.com.
+
+## About
+
+This demo is maintained by **Lattice Semiconductor** (LatticeSemi).
+
+## License
+
+Proprietary - Lattice Semiconductor Corporation. All rights reserved.
+
+## Need a Longer or Commercial License?
+
+- **Email**: evehelp@latticesemi.com

app.py

@@ -0,0 +1,335 @@
+import atexit
+import os
+import sys
+from pathlib import Path
+
+import gradio as gr
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent / "shared"))
+sys.path.insert(0, str(Path(__file__).resolve().parent / "shared"))
+
+from env_utils import load_dotenv_if_present, require_secrets
+from eula_tab import build_eula_tab
+from eve_app_tabs import build_image_or_video_offline_tab, build_live_inference_tab
+from eve_inference_handlers import EveAppHandlers, patch_video_for_external_urls
+from eve_worker_pool import EveWorkerPool
+from live_inference import (
+    TAB_SWITCH_AUTO_STOP_JS,
+    RtcConfigProvider,
+    patch_aioice_stun_transaction,
+    patch_aiortc_h264_nvenc,
+    patch_fastrtc_frame_queue,
+    patch_fastrtc_yuv420p_output,
+)
+from live_stream_manager import LiveStreamManager
+from log_utils import log_cpu_info, setup_logger
+from session_tracker import SessionTracker
+from usage_analytics import UsageTracker
+from video_processing import VideoLimits
+
+MOD_MODELS = ["GMOD-80", "AMOD-8", "OMOD"]
+DEFAULT_MOD_MODEL = "GMOD-80"
+
+_IMAGE_EXTS = (".jpg", ".jpeg", ".png", ".bmp", ".webp")
+_VIDEO_EXTS = (".mp4", ".avi", ".mov", ".mkv", ".webm")
+
+
+def _build_feature_radio(hint: str = "") -> gr.Radio:
+    """Build the model-selection radio — exactly one MOD model active at a time."""
+    label = "Object Detection Model"
+    if hint:
+        label += f" — {hint}"
+    return gr.Radio(
+        choices=MOD_MODELS,
+        value=DEFAULT_MOD_MODEL,
+        label=label,
+        info="Only GMOD-80 is active. AMOD-8 / OMOD are placeholders pending an "
+        "EVE SDK update that adds runtime model switching.",
+        interactive=False,
+    )
+
+
+def _scan_examples(folder: Path, exts: tuple[str, ...]) -> list[list[str]]:
+    """Scan ``folder`` for files with any extension in ``exts``."""
+    if not folder.is_dir():
+        return []
+    return [[str(p)] for p in sorted(folder.iterdir()) if p.suffix.lower() in exts]
+
+
+if __name__ == "__main__":
+    patch_fastrtc_frame_queue()
+    patch_fastrtc_yuv420p_output()
+    patch_aioice_stun_transaction()
+    patch_aiortc_h264_nvenc()
+
+    load_dotenv_if_present()
+    logger = setup_logger(name="app")
+    log_cpu_info(logger)
+    require_secrets("MODEL_ACCESS_TOKEN")
+
+    tracker = UsageTracker(
+        repo_id=os.environ.get("ANALYTICS_REPO_ID", "LatticeSemi/PRIVATE-Demo-Analytics-v1.0"),
+    )
+    tracker.log("server", "server_start")
+
+    max_workers = int(os.environ.get("MAX_WORKERS", os.cpu_count()))
+    max_ram_gb = float(os.environ.get("MAX_RAM_GB", 32))
+    pool = EveWorkerPool(max_workers=max_workers, max_ram_gb=max_ram_gb, ram_headroom_gb=2.0)
+
+    max_fps_raw = float(os.environ.get("MAX_TARGET_FPS", "24"))
+    min_fps_raw = float(os.environ.get("MIN_TARGET_FPS", "15"))
+    max_fps: float | None = max_fps_raw if max_fps_raw > 0 else None
+    min_fps: float | None = min_fps_raw if min_fps_raw > 0 else None
+
+    camera_width = int(os.environ.get("CAMERA_WIDTH", 640))
+    camera_height = int(os.environ.get("CAMERA_HEIGHT", 360))
+
+    stream_manager = LiveStreamManager(
+        pool,
+        session_lifetime_seconds=60 * 4,
+        max_fps=max_fps,
+        min_fps=min_fps,
+        tracker=tracker,
+    )
+
+    session_tracker = SessionTracker(pool=pool, tracker=tracker, logger=logger)
+
+    handlers = EveAppHandlers(
+        pool=pool,
+        stream_manager=stream_manager,
+        sessions=session_tracker,
+        logger=logger,
+        max_fps=max_fps,
+        min_fps=min_fps,
+    )
+
+    def _shutdown() -> None:
+        session_tracker.shutdown()
+        stream_manager.shutdown()
+        tracker.log("server", "server_stop")
+        tracker.shutdown()
+
+    atexit.register(_shutdown)
+
+    examples_dir = Path(__file__).resolve().parent / "examples"
+    image_examples = _scan_examples(examples_dir, _IMAGE_EXTS)
+    video_examples = _scan_examples(examples_dir, _VIDEO_EXTS)
+    video_limits = VideoLimits()
+    rtc_config_provider = RtcConfigProvider()
+
+    with gr.Blocks(
+        title="GMOD / AMOD / OMOD Object Detection Demo",
+        theme=gr.themes.Default(
+            text_size=gr.themes.sizes.text_lg,
+            primary_hue=gr.themes.colors.yellow,
+        ),
+        css=(
+            f"#webrtc-stream-col {{ max-width: {camera_width}px !important; margin: 0 auto; }}"
+            " .gradio-container h1, .gradio-container .md h1 { font-size: 2.25rem !important; }"
+            " .gradio-container h2, .gradio-container .md h2 { font-size: 1.75rem !important; }"
+            " .gradio-container h3, .gradio-container .md h3 { font-size: 1.4rem !important; }"
+            " .gradio-container button[role='tab'],"
+            " .gradio-container button[role='tab'] *"
+            " { text-decoration: underline !important; }"
+            " .gradio-container .tab-container {"
+            " height: auto !important;"
+            " overflow: visible !important;"
+            " gap: 4px !important;"
+            " border-bottom: 2px solid var(--border-color-primary) !important; }"
+            " .gradio-container .tab-container::after { display: none !important; }"
+            " .gradio-container button[role='tab'] {"
+            " height: auto !important;"
+            " padding: 10px 20px !important;"
+            " border: 1px solid var(--border-color-primary) !important;"
+            " border-bottom: none !important;"
+            " border-radius: 8px 8px 0 0 !important;"
+            " background: var(--background-fill-secondary) !important;"
+            " margin-bottom: -2px !important; }"
+            " .gradio-container button[role='tab'].selected {"
+            " background: var(--primary-500) !important;"
+            " color: var(--neutral-950) !important;"
+            " border-color: var(--primary-500) !important;"
+            " font-weight: 600 !important; }"
+            " .gradio-container button[role='tab'].selected::after { display: none !important; }"
+        ),
+        head=TAB_SWITCH_AUTO_STOP_JS,
+    ) as demo:
+        gr.Markdown("# Lattice sensAI — Generic Object Detection")
+        gr.Markdown(
+            "Run object detection on images, videos, or a live camera feed using "
+            "one of three EVE SDK models:\n\n"
+            "- **GMOD-80** — generic 80-class detector (active baseline)\n"
+            "- **AMOD-8** — 8-class automotive object detector "
+            "(person, bicycle, car, motorcycle, bus, truck, traffic light, "
+            "stop sign) *(preview)*\n"
+            "- **OMOD** — many-class office-objects detector *(preview)*\n\n"
+            "Only one model is active at a time. Pick the model with the radio "
+            "in each tab.\n\n"
+            "> **Preview note:** AMOD and OMOD slots currently fall back to GMOD-80 "
+            "weights — pending an EVE SDK update that adds runtime model switching."
+        )
+
+        # Required by EveAppHandlers signatures (Face ID gallery state). Empty
+        # for this demo — Face ID is not exposed.
+        session_registry = gr.State(value={})
+        session_hash_state = gr.State(value="unknown")
+        # Constant False states for the four Face/Person/FaceID/Hand flags
+        # that EveAppHandlers expects but this demo does not expose.
+        false_state = gr.State(value=False)
+
+        with gr.Tabs() as tabs:
+            (live_tab, webrtc_stream, live_radio) = build_live_inference_tab(
+                rtc_configuration=lambda: rtc_config_provider.get(),
+                feature_checkbox_builder=_build_feature_radio,
+                max_fps=int(max_fps) if max_fps else 30,
+                width=camera_width,
+                height=camera_height,
+            )
+
+            offline = build_image_or_video_offline_tab(
+                feature_checkbox_builder=_build_feature_radio,
+                image_examples=image_examples,
+                video_examples=video_examples,
+                video_limits=video_limits,
+            )
+            patch_video_for_external_urls(offline.video_output)
+            offline_radio = offline.checkboxes  # gr.Radio in this demo
+
+            build_eula_tab()
+
+        # --- Mutually exclusive accordions on the offline tab ---
+        offline.image_accordion.expand(
+            fn=lambda: gr.update(open=False),
+            outputs=[offline.video_accordion],
+        )
+        offline.video_accordion.expand(
+            fn=lambda: gr.update(open=False),
+            outputs=[offline.image_accordion],
+        )
+
+        # --- Examples wire-up: clicking a sample loads it into the matching input ---
+        if offline.image_example_dataset is not None:
+            offline.image_example_dataset.click(
+                fn=lambda sample: sample[0],
+                inputs=[offline.image_example_dataset],
+                outputs=[offline.image_input],
+            )
+        if offline.video_example_dataset is not None:
+            offline.video_example_dataset.click(
+                fn=lambda sample: sample[0],
+                inputs=[offline.video_example_dataset],
+                outputs=[offline.video_input],
+            )
+
+        # --- Process button gating ---
+        def _on_input_change(image_path: str | None, video_path: str | None) -> dict:
+            return gr.update(interactive=bool(image_path) or bool(video_path))
+
+        for src in (offline.image_input, offline.video_input):
+            src.change(
+                fn=_on_input_change,
+                inputs=[offline.image_input, offline.video_input],
+                outputs=[offline.process_btn],
+            )
+
+        # --- Process dispatcher: image vs video ---
+        def _process_dispatch(
+            image_path: str | None,
+            video_path: str | None,
+            mod_model: str,
+            registry: dict,
+            request: gr.Request,
+            progress: gr.Progress = gr.Progress(),
+        ):
+            if image_path:
+                annotated, registry = handlers.run_eve_image_inference(
+                    image_path,
+                    False,
+                    False,
+                    False,
+                    False,
+                    registry,
+                    mod_model,
+                    request,
+                    progress,
+                )
+                return (
+                    gr.update(value=annotated, visible=True),
+                    gr.update(value=None, visible=False),
+                    registry,
+                )
+            if video_path:
+                output_path, registry = handlers.run_eve_inference(
+                    video_path,
+                    False,
+                    False,
+                    False,
+                    False,
+                    registry,
+                    mod_model,
+                    request,
+                    progress,
+                )
+                return (
+                    gr.update(value=None, visible=False),
+                    gr.update(value=output_path, visible=True),
+                    registry,
+                )
+            raise gr.Error("Please upload an image or video.")
+
+        offline.process_btn.click(
+            fn=_process_dispatch,
+            inputs=[
+                offline.image_input,
+                offline.video_input,
+                offline_radio,
+                session_registry,
+            ],
+            outputs=[
+                offline.image_output,
+                offline.video_output,
+                session_registry,
+            ],
+            concurrency_limit=pool.worker_count,
+        )
+
+        # --- Live feature change tracking ---
+        live_radio.change(
+            fn=handlers.on_live_feature_change,
+            inputs=[false_state, false_state, false_state, false_state, live_radio],
+            outputs=[],
+        )
+
+        # --- Live inference wiring ---
+        webrtc_stream.stream(
+            fn=handlers.process_live_frame,
+            inputs=[
+                webrtc_stream,
+                false_state,
+                false_state,
+                false_state,
+                false_state,
+                session_registry,
+                session_hash_state,
+                live_radio,
+            ],
+            outputs=[webrtc_stream],
+            concurrency_limit=pool.worker_count + 8,
+        )
+
+        # --- Tab switching analytics ---
+        tabs.select(fn=session_tracker.on_tab_switch, inputs=[], outputs=[])
+
+        # --- Session lifecycle ---
+        demo.load(session_tracker.on_load, outputs=[session_hash_state])
+        demo.unload(handlers.cleanup_session)
+
+        if tracker.enabled:
+            gr.HTML(
+                "<p style='font-size:0.8em;color:#888;text-align:center;margin-top:1em'>"
+                "This demo collects anonymous usage data (session activity, feature usage) "
+                "to improve the experience. No personal information is stored.</p>"
+            )
+
+    demo.queue()
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)

download_models.py

@@ -0,0 +1,46 @@
+"""Placeholder downloader for GMOD / AMOD / OMOD .h5 model artifacts.
+
+The EVE C SDK currently ships a single hardcoded MOD model (see
+``EveEthosNpu/Models.h`` -> ``ObjectDetection = "gmod-cpu-...dat"``) and has
+no runtime model-switch entry point. Until that lands, this script is a
+**stub** — it does nothing at runtime, but documents the URLs we plan to
+fetch so the wiring is obvious when the SDK gains the switch API.
+
+When the EVE SDK gains a model-load function:
+
+1. Fill in the real URLs below (likely a public GitHub release, possibly a
+   gated ``LatticeSemi/PRIVATE-*`` HF repo).
+2. Have the Dockerfile invoke this script after ``install_eve.py`` so the
+   ``.h5`` files land in ``/opt/eve_models/`` (or wherever the SDK looks).
+3. Hand-add a binding for the new SDK function in
+   ``src/shared/eve_python/eve_sdk.py`` and update
+   ``eve_wrapper.enable_object_detection`` to call it.
+"""
+
+from __future__ import annotations
+
+import sys
+
+# TODO: replace with real download URLs (GitHub Releases or
+# LatticeSemi/PRIVATE-* HF repo) once available.
+MODELS: dict[str, str] = {
+    # "GMOD-80": "https://github.com/<org>/<repo>/releases/download/<tag>/gmod-80.h5",
+    # "AMOD-8":  "https://github.com/<org>/<repo>/releases/download/<tag>/amod-8.h5",
+    # "OMOD":    "https://github.com/<org>/<repo>/releases/download/<tag>/omod.h5",
+}
+
+
+def main() -> int:
+    if not MODELS:
+        print(
+            "download_models.py: nothing to do — model URLs not yet wired up. "
+            "EVE SDK currently uses its bundled MOD model.",
+            file=sys.stderr,
+        )
+        return 0
+    # When wired up: download each entry to a known target directory.
+    raise NotImplementedError("Fill in the download loop once URLs are known.")
+
+
+if __name__ == "__main__":
+    sys.exit(main())

install_eve.py

@@ -0,0 +1,104 @@
+"""Download and install the Eve SDK .deb package from HuggingFace Hub.
+
+Called during Docker build. Tries authentication in order:
+
+1. Docker BuildKit secret ``MODEL_ACCESS_TOKEN`` (HF Spaces — automatic)
+2. ``HF_TOKEN`` build arg (local builds)
+3. No token (public repos only)
+
+Local usage::
+
+    docker build --build-arg HF_TOKEN=$(cat ~/.cache/huggingface/token) \
+        -t eve ./src/demos/eve_hmi
+"""
+
+import os
+import re
+import shutil
+import subprocess
+import sys
+
+from huggingface_hub import hf_hub_download
+
+EVE_REPO = "LatticeSemi/PRIVATE-Edge-Vision-Engine-EVE-v7.0"
+EVE_DEB = "LINUX_X86-8-7.0-eve-huggingface_7.0.8~git20260408.4a1a3f1_amd64.deb"
+EVE_LICENSE_REPO = "LatticeSemi/PRIVATE-Edge-Vision-Engine-EVE-v7.0-License"
+EVE_LICENSE = "libEveDevLicense.so"
+SECRET_PATH = "/run/secrets/MODEL_ACCESS_TOKEN"
+DOWNLOAD_DIR = "/tmp/eve"
+
+
+def get_token():
+    """Return an HF token from the first available source, or None."""
+    # 1. Docker BuildKit secret (HF Spaces injects MODEL_ACCESS_TOKEN automatically)
+    if os.path.isfile(SECRET_PATH):
+        with open(SECRET_PATH) as f:
+            token = f.read().strip()
+            if token:
+                return token, "build secret (MODEL_ACCESS_TOKEN)"
+
+    # 2. HF_TOKEN build arg forwarded as env var
+    token = os.environ.get("HF_TOKEN", "").strip()
+    if token:
+        return token, "build arg (HF_TOKEN)"
+
+    # 3. No token — will only work for public repos
+    return None, "no auth (will fail for private repos)"
+
+
+def get_license_destination_path() -> str:
+    """Parse the .deb package of EVE to extract the version."""
+    # Alright so regexes are fun, what we want here is to extract the version
+    # of EVE's package since we need to copy the license into EVE's install
+    # folder which is /opt/EVE-version-Source/lib.
+    # For example, in LINUX_X86-531-dev-eve-development_7.0.531~git20260309.c5f1ee6_amd64.deb,
+    # we want the version extracted to be 7.0.531.
+    match = re.search(r"(?<=_)\d+(?:\.\d+)+(?=~)", EVE_DEB)
+    if not match:
+        raise RuntimeError("Could not parse EVE's package version.")
+
+    version = match.group()
+
+    return f"/opt/EVE-{version}-Source/lib"
+
+
+def main():
+    token, auth_source = get_token()
+
+    if token is None and "PRIVATE" in EVE_REPO:
+        print(
+            f"ERROR: No authentication token found.\n"
+            f"  Repo '{EVE_REPO}' is private and requires a token.\n"
+            f"  On HF Spaces: set MODEL_ACCESS_TOKEN as a Space secret.\n"
+            f"  Locally:      docker build --build-arg HF_TOKEN=$(cat ~/.cache/huggingface/token) ...",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    print(f"Downloading Eve SDK from {EVE_REPO} using {auth_source}...")
+
+    deb_path = hf_hub_download(
+        repo_id=EVE_REPO,
+        filename=EVE_DEB,
+        local_dir=DOWNLOAD_DIR,
+        token=token,
+    )
+
+    print(f"Installing {deb_path}...")
+    subprocess.run(["apt-get", "install", "-y", deb_path], check=True)
+
+    license_path = hf_hub_download(
+        repo_id=EVE_LICENSE_REPO, filename=EVE_LICENSE, local_dir=DOWNLOAD_DIR, token=token
+    )
+
+    destination_path = get_license_destination_path()
+
+    print(f"Installing {license_path}...")
+    subprocess.run(["mv", license_path, destination_path], check=True)
+
+    shutil.rmtree(DOWNLOAD_DIR, ignore_errors=True)
+    print("Eve SDK installed successfully.")
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,8 @@
+av
+gradio==5.50.0
+fastrtc==0.0.34
+huggingface-hub==1.5.0
+opencv-python
+dotenv
+twilio
+psutil

shared/assets/EULA.md

@@ -0,0 +1,21 @@
+# DEMO EVALUATION END USER LICENSE AGREEMENT
+
+IMPORTANT: BY DOWNLOADING, INSTALLING, ACTIVATING, ACCESSING, OR USING THE SOFTWARE, YOU AGREE TO THIS AGREEMENT. IF YOU DO NOT AGREE, DO NOT USE THE SOFTWARE.
+
+This Demo Evaluation End User License Agreement ("Agreement") is between Lattice Semiconductor Corporation ("Lattice") and the person or entity using the Software ("Licensee"). The individual accepting this Agreement represents and warrants that they have authority to bind Licensee.
+
+**1. Software.** "Software" means the demo version of the software, in object code form only, together with related documentation, materials, updates, license keys, and any output or data generated by the Software, provided by Lattice.
+
+**2. License Grant.** Subject to this Agreement, Lattice grants Licensee a limited, non-exclusive, non-transferable, non-sublicensable, revocable license to use the Software solely for Licensee's internal, non-commercial evaluation and demonstration purposes, only to assess the Software and determine whether to request a longer-term testing license from Lattice. The Software may be used only by Licensee's employees at a single site. No other rights are granted by implication, estoppel, or otherwise.
+
+**3. License Key; Revocation.** Use of the Software is controlled by a license key or similar activation mechanism. Lattice may revoke, suspend, disable, or refuse to renew any license key at any time, with or without cause, and without notice or liability. Upon expiration, revocation, suspension, or disablement of the license key, Licensee's right to use the Software immediately terminates and Licensee must comply with Section 8(b).
+
+**4. Restrictions.** Licensee may not, and may not permit or enable any third party to: (a) use the Software for production, commercial, or revenue-generating purposes; (b) sell, license, sublicense, rent, lease, lend, distribute, transfer, or disclose the Software or any portion thereof to any third party; (c) copy, modify, adapt, translate, or create derivative works of the Software; (d) reverse engineer, decompile, disassemble, or otherwise attempt to discover the source code, algorithms, data structures, or underlying ideas of the Software, except to the limited extent such restriction is expressly prohibited by applicable law; (e) remove, alter, or obscure any proprietary, copyright, trademark, or other notices; (f) use the Software or any information derived from it to develop, improve, train, or benchmark any competing product, service, or technology; (g) publish or disclose any benchmark, test, performance, or evaluation results related to the Software without Lattice's prior written consent; (h) use the Software in violation of any applicable law or regulation; or (i) circumvent or attempt to circumvent any technical protection measures in the Software.
+
+**5. Ownership; Confidentiality; Feedback.** The Software is licensed, not sold. Lattice and its licensors retain all right, title, and interest in and to the Software, all derivatives and improvements thereof, and all related intellectual property rights worldwide. No license or right is granted to any Lattice patent, trade secret, or trademark. The Software, its features, performance characteristics, and all information relating thereto constitute confidential and proprietary trade secrets of Lattice. Licensee will protect the Software using at least the same degree of care it uses for its own confidential information, but no less than reasonable care, and will not disclose or provide access to the Software except to employees or contractors with a need to know who are bound by written confidentiality obligations no less protective than this Agreement. Any suggestions, ideas, feedback, evaluation results, or other input provided by Licensee regarding the Software ("Feedback") are assigned to Lattice and may be used by Lattice for any purpose without restriction, compensation, or obligation. To the extent such assignment is not enforceable, Licensee grants Lattice a perpetual, irrevocable, worldwide, royalty-free, fully sublicensable license to use and exploit the Feedback.
+
+**6. Disclaimer.** THE SOFTWARE IS PROVIDED "AS IS" AND "AS AVAILABLE," WITHOUT WARRANTY OF ANY KIND. TO THE MAXIMUM EXTENT PERMITTED BY LAW, LATTICE DISCLAIMS ALL EXPRESS, IMPLIED, STATUTORY, AND OTHER WARRANTIES, INCLUDING ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE, NON-INFRINGEMENT, AND ACCURACY. LATTICE DOES NOT WARRANT THAT THE SOFTWARE WILL BE ERROR-FREE, UNINTERRUPTED, SECURE, OR FREE OF HARMFUL COMPONENTS.
+
+**7. Limitation of Liability.** TO THE MAXIMUM EXTENT PERMITTED BY LAW, LATTICE AND ITS LICENSORS, DIRECTORS, OFFICERS, AND EMPLOYEES WILL NOT BE LIABLE FOR ANY INDIRECT, INCIDENTAL, SPECIAL, CONSEQUENTIAL, EXEMPLARY, OR PUNITIVE DAMAGES, OR FOR ANY LOSS OF PROFITS, REVENUE, DATA, BUSINESS, GOODWILL, OR USE, ARISING OUT OF OR RELATED TO THIS AGREEMENT OR THE SOFTWARE, REGARDLESS OF THE THEORY OF LIABILITY AND EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. LATTICE'S TOTAL AGGREGATE LIABILITY ARISING OUT OF OR RELATED TO THIS AGREEMENT OR THE SOFTWARE WILL NOT EXCEED US$100. THESE LIMITATIONS APPLY NOTWITHSTANDING ANY FAILURE OF ESSENTIAL PURPOSE OF ANY LIMITED REMEDY.
+
+**8. Termination.** (a) This Agreement begins upon first use of the Software and terminates automatically upon breach by Licensee, expiration or revocation of the license key, or upon thirty (30) days' notice by Lattice. Lattice may terminate immediately if Licensee breaches Sections 4 or 5. (b) Upon termination, Licensee must immediately cease all use of the Software, permanently delete or destroy all copies (including backups), and certify such destruction in writing to Lattice within five (5) business days.

shared/ctypes_enum.py

@@ -0,0 +1,10 @@
+from enum import IntEnum
+
+
+# Taken from https://v4.chriskrycho.com/2015/ctypes-structures-and-dll-exports.html
+class CtypesEnum(IntEnum):
+    """A ctypes-compatible IntEnum superclass."""
+
+    @classmethod
+    def from_param(cls, obj):
+        return int(obj)

shared/env_utils.py

@@ -0,0 +1,49 @@
+import os
+import sys
+from pathlib import Path
+
+from dotenv import load_dotenv  # type: ignore
+
+
+def load_dotenv_if_present(dotenv_path: str | os.PathLike = ".env.local") -> bool:
+    """
+    Optional convenience for local dev: loads .env if python-dotenv is installed.
+    If python-dotenv is not installed or file doesn't exist, this is a no-op.
+
+    Returns True if a .env was loaded, else False.
+    """
+    p = Path(dotenv_path)
+    if not p.exists():
+        return False
+
+    load_dotenv(dotenv_path=p)
+    return True
+
+
+def require_secrets(*names: str) -> None:
+    """Verify that required HF Space secrets are set, or exit with a clear message.
+
+    Only enforced when ``SPACE_ID`` is present in the environment (i.e. the app
+    is running on Hugging Face Spaces).  Locally, developers authenticate via
+    ``hf auth login`` so secrets like ``MODEL_ACCESS_TOKEN`` are not needed.
+
+    Args:
+        *names: Environment variable names that must be non-empty.
+
+    Raises:
+        SystemExit: If any secret is missing while running on HF Spaces.
+    """
+    space_id = os.environ.get("SPACE_ID", "")
+    if not space_id or not names:
+        return
+
+    missing = [n for n in names if not os.environ.get(n, "").strip()]
+    if not missing:
+        return
+
+    settings_url = f"https://huggingface.co/spaces/{space_id}/settings"
+    print(
+        f"ERROR: Missing required secrets: {', '.join(missing)}\n" f"Set them at: {settings_url}",
+        file=sys.stderr,
+    )
+    sys.exit(1)

shared/eula_tab.py

@@ -0,0 +1,47 @@
+"""EULA tab for Gradio demos.
+
+Displays the End User License Agreement as a read-only Markdown tab.
+The EULA text is loaded from ``shared/assets/EULA.md`` so it can be
+updated without changing any Python code.
+
+Usage::
+
+    with gr.Blocks() as demo:
+        with gr.Tabs():
+            build_eula_tab()
+"""
+
+from pathlib import Path
+
+import gradio as gr
+
+_ASSETS_DIR = Path(__file__).resolve().parent / "assets"
+_DEFAULT_EULA_PATH = _ASSETS_DIR / "EULA.md"
+
+
+def build_eula_tab(
+    eula_path: str | Path | None = None,
+    tab_label: str = "EULA",
+) -> gr.TabItem:
+    """Create a tab displaying the EULA as Markdown.
+
+    Must be called inside a ``gr.Tabs()`` context.
+
+    Args:
+        eula_path: Path to a Markdown file. Defaults to ``shared/assets/EULA.md``.
+        tab_label: Label shown on the tab. Defaults to ``"EULA"``.
+
+    Returns:
+        The ``gr.TabItem`` component.
+    """
+    path = Path(eula_path) if eula_path is not None else _DEFAULT_EULA_PATH
+
+    if path.is_file():
+        content = path.read_text(encoding="utf-8")
+    else:
+        content = f"_EULA file not found. Expected location:_ `{path}`"
+
+    with gr.TabItem(tab_label) as tab:
+        gr.Markdown(content)
+
+    return tab

shared/eve_app_tabs.py

@@ -0,0 +1,276 @@
+"""Tab builders for EVE-based Gradio demos.
+
+Both tabs (Offline Inference, Live Inference) follow the same pattern:
+
+- Outer ``gr.TabItem`` with the demo-supplied label.
+- Demo-specific feature checkboxes built via a caller-provided callable so
+  each demo defines its own feature set (Face Detection / Person /
+  Hand Detection / Face ID / …).
+- Optional ``extras_builder`` hook for demo-specific extras inside the tab
+  (e.g. eve_hmi's Face ID summary thumbnails).
+
+The tab builders return the underlying components so the caller can wire
+events (``process_btn.click``, ``webrtc_stream.stream``, etc.) outside.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, TypeVar
+
+import gradio as gr
+
+from live_inference import RtcConfigurationInput, build_webrtc_stream
+from video_processing import VideoLimits, build_video_constraints_accordion
+
+# The exact tuple of Checkbox components is demo-specific.  We let the
+# caller's checkbox-builder define the shape and return it transparently.
+TCheckboxes = TypeVar("TCheckboxes")
+
+
+def build_offline_inference_tab(
+    *,
+    feature_checkbox_builder: Callable[..., TCheckboxes],
+    example_videos: list,
+    video_limits: VideoLimits,
+    extras_builder: Callable[[], None] | None = None,
+    tab_label: str = "Offline Inference",
+    feature_hint: str = "applied when processing starts",
+) -> tuple[
+    gr.TabItem,
+    gr.Video,
+    gr.Video,
+    TCheckboxes,
+    gr.Button,
+    gr.Dataset,
+]:
+    """Build the Offline Inference tab. Must be called inside a ``gr.Tabs`` context.
+
+    Args:
+        feature_checkbox_builder: Callable that builds the demo's feature
+            checkboxes inside the tab.  Receives the keyword ``hint`` (a
+            short string shown next to the "Features" heading).  Returns a
+            tuple of ``gr.Checkbox`` instances — the same tuple is returned
+            unchanged so the caller can wire events.
+        example_videos: Pre-loaded example videos (list of ``[path]`` rows).
+        video_limits: Upload constraints rendered in the accordion.
+        extras_builder: Optional callable invoked after the input/output
+            video columns to add demo-specific widgets (e.g. a Face ID
+            summary).  Called inside the same row, so it shares horizontal
+            space with the videos.
+        tab_label: Tab label text (default ``"Offline Inference"``).
+        feature_hint: Short hint shown next to the Features heading.
+
+    Returns:
+        ``(tab, input_video, output_video, checkboxes, process_btn, example_dataset)``.
+        ``checkboxes`` is exactly what ``feature_checkbox_builder`` returned.
+    """
+    with gr.TabItem(tab_label) as video_tab:
+        with gr.Accordion("Instructions", open=False):
+            gr.Markdown(
+                "1. Select the features that will be processed on the video\n"
+                "2. Select a video (or upload your own in the Input Video frame)\n"
+                "3. Press the **Process Video** button\n\n"
+                "Once the video has been processed, you can play the video in the "
+                "Output Video frame"
+            )
+
+        checkboxes = feature_checkbox_builder(hint=feature_hint)
+
+        with gr.Accordion("Video Examples", open=True):
+            example_dataset = gr.Dataset(
+                components=[gr.Video(visible=False)],
+                samples=example_videos,
+                show_label=False,
+            )
+
+        process_btn = gr.Button("Process Video", variant="primary", interactive=False)
+
+        build_video_constraints_accordion(video_limits)
+
+        with gr.Row(equal_height=True):
+            with gr.Column(scale=5):
+                input_video = gr.Video(label="Input Video", sources=["upload", "webcam"])
+            with gr.Column(scale=5):
+                output_video = gr.Video(label="Output Video")
+            if extras_builder is not None:
+                extras_builder()
+
+    return video_tab, input_video, output_video, checkboxes, process_btn, example_dataset
+
+
+@dataclass
+class ImageOrVideoOfflineTab:
+    """Components returned by :func:`build_image_or_video_offline_tab`.
+
+    The image/video accordions are exposed so the caller can wire mutual
+    exclusion (expanding one collapses the other) — same pattern as
+    :class:`face_id_tab.FaceIdTab`.
+    """
+
+    tab: gr.TabItem
+    image_input: gr.Image
+    video_input: gr.Video
+    image_output: gr.Image
+    video_output: gr.Video
+    checkboxes: object  # demo-specific (radio, checkbox tuple, etc.)
+    process_btn: gr.Button
+    image_example_dataset: gr.Dataset | None
+    video_example_dataset: gr.Dataset | None
+    image_accordion: gr.Accordion
+    video_accordion: gr.Accordion
+
+
+def build_image_or_video_offline_tab(
+    *,
+    feature_checkbox_builder: Callable[..., TCheckboxes],
+    image_examples: list | None,
+    video_examples: list | None,
+    video_limits: VideoLimits,
+    tab_label: str = "Offline Inference",
+    feature_hint: str = "applied when processing starts",
+) -> ImageOrVideoOfflineTab:
+    """Build an Offline Inference tab that accepts image OR video.
+
+    Pattern: two mutually-exclusive accordions on the input side ("Input
+    from an Image" / "Input from a Video"), one Process button, two
+    output components (image + video) shown side-by-side. Caller is
+    responsible for:
+
+    - Wiring ``image_accordion`` / ``video_accordion`` mutual exclusion
+      (one-liner per side, see ``face_id_tab.FaceIdTab.wire``).
+    - Routing ``process_btn.click`` to a handler that dispatches by
+      which input is populated.
+    - Toggling output visibility based on which branch ran.
+
+    Args:
+        feature_checkbox_builder: Callable that builds the demo's feature
+            checkboxes/radio inside the tab. Called with keyword
+            ``hint=feature_hint``.
+        image_examples: Pre-loaded image examples (list of ``[path]``
+            rows) or ``None`` to skip the examples accordion.
+        video_examples: Same for videos.
+        video_limits: Upload constraints rendered inside the video
+            accordion.
+        tab_label: Tab label text.
+        feature_hint: Short hint shown next to the Features heading.
+    """
+    with gr.TabItem(tab_label) as tab:
+        with gr.Accordion("Instructions", open=False):
+            gr.Markdown(
+                "1. Select the model that will be used for object detection\n"
+                "2. Choose between processing an **Image** or a **Video**:\n"
+                "   - For an image: select an example or upload your own, then press "
+                "**Process**.\n"
+                "   - For a video: expand the video section, select an example or "
+                "upload your own, then press **Process**.\n\n"
+                "Once processing is complete, the annotated result appears on the "
+                "right (image or video, depending on the input)."
+            )
+
+        checkboxes = feature_checkbox_builder(hint=feature_hint)
+
+        with gr.Row():
+            # --- Left column: input ---
+            with gr.Column(scale=5):
+                image_example_dataset: gr.Dataset | None = None
+                video_example_dataset: gr.Dataset | None = None
+
+                with gr.Accordion(
+                    "Input from an Image", open=True
+                ) as image_accordion:
+                    if image_examples:
+                        with gr.Accordion("Image Examples", open=True):
+                            image_example_dataset = gr.Dataset(
+                                components=[gr.Image(visible=False)],
+                                samples=image_examples,
+                                show_label=False,
+                            )
+                    image_input = gr.Image(
+                        label="Input Image",
+                        sources=["upload", "webcam"],
+                        type="filepath",
+                    )
+
+                with gr.Accordion(
+                    "Input from a Video", open=False
+                ) as video_accordion:
+                    if video_examples:
+                        with gr.Accordion("Video Examples", open=True):
+                            video_example_dataset = gr.Dataset(
+                                components=[gr.Video(visible=False)],
+                                samples=video_examples,
+                                show_label=False,
+                            )
+                    build_video_constraints_accordion(video_limits)
+                    video_input = gr.Video(
+                        label="Input Video", sources=["upload", "webcam"]
+                    )
+
+                process_btn = gr.Button(
+                    "Process", variant="primary", interactive=False
+                )
+
+            # --- Right column: output (image OR video, toggled by handler) ---
+            with gr.Column(scale=5):
+                image_output = gr.Image(label="Output Image", visible=True)
+                video_output = gr.Video(label="Output Video", visible=False)
+
+    return ImageOrVideoOfflineTab(
+        tab=tab,
+        image_input=image_input,
+        video_input=video_input,
+        image_output=image_output,
+        video_output=video_output,
+        checkboxes=checkboxes,
+        process_btn=process_btn,
+        image_example_dataset=image_example_dataset,
+        video_example_dataset=video_example_dataset,
+        image_accordion=image_accordion,
+        video_accordion=video_accordion,
+    )
+
+
+def build_live_inference_tab(
+    *,
+    rtc_configuration: RtcConfigurationInput,
+    feature_checkbox_builder: Callable[..., TCheckboxes],
+    extras_builder: Callable[[], None] | None = None,
+    max_fps: int = 15,
+    width: int = 640,
+    height: int = 360,
+    tab_label: str = "Live Inference",
+    description_html: str = (
+        "<p>Use your webcam for real-time inference. "
+        "Select features below, then grant camera access when prompted.</p>"
+    ),
+) -> tuple[gr.TabItem, object, TCheckboxes]:
+    """Build the Live Inference tab with feature checkboxes + WebRTC stream.
+
+    Args:
+        rtc_configuration: ICE configuration dict, callable that returns
+            one, or ``None`` for direct connection.  A callable is invoked
+            per-connection by FastRTC, allowing credential refresh.
+        feature_checkbox_builder: Callable that builds the demo's feature
+            checkboxes (same shape as in the offline tab).
+        extras_builder: Optional callable invoked after the WebRTC stream
+            for demo-specific widgets (e.g. Face ID summary).
+        max_fps: Maximum frame rate requested from the browser camera.
+        width / height: Camera frame dimensions in pixels.
+        tab_label: Tab label text.
+        description_html: Optional HTML shown above the stream.
+
+    Returns:
+        ``(tab, webrtc_stream, checkboxes)``.
+    """
+    with gr.TabItem(tab_label) as tab:
+        if description_html:
+            gr.HTML(description_html)
+        checkboxes = feature_checkbox_builder()
+        webrtc_stream = build_webrtc_stream(
+            rtc_configuration, max_fps=max_fps, width=width, height=height
+        )
+        if extras_builder is not None:
+            extras_builder()
+
+    return tab, webrtc_stream, checkboxes

shared/eve_inference_handlers.py

@@ -0,0 +1,485 @@
+"""Offline + live inference handlers shared by EVE-based Gradio demos.
+
+The two main handlers (``run_eve_inference`` for the Offline Inference tab,
+``process_live_frame`` for the Live Inference tab) used to live in
+``eve_hmi/app.py``.  They are bundled on an ``EveAppHandlers`` instance so
+demos can wire them with one ``handlers = EveAppHandlers(...)`` line and
+re-use them as Gradio callbacks.
+
+Face ID is opt-in: pass an empty / ``None`` ``registry`` and Face ID
+behaviour is bypassed (gallery restore is skipped, the ``face_id`` flag
+still travels through ``FeatureFlags`` so the EVE SDK can act on it).
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import shutil
+import tempfile
+import threading
+import time
+import uuid
+from typing import TYPE_CHECKING
+
+import cv2
+import gradio as gr
+import numpy as np
+
+from eve_messages import FeatureFlags
+from eve_worker_pool import log_worker_activity
+from face_id_tab import FaceEntry  # runtime import: Gradio resolves type hints at wire time
+from frame_drawing import draw_countdown_banner, draw_overlay, draw_session_timer
+
+if TYPE_CHECKING:
+    from eve_worker_pool import EveWorkerPool
+    from live_stream_manager import LiveStreamManager
+    from session_tracker import SessionTracker
+    from video_file_server import VideoFileServer
+
+
+def patch_video_for_external_urls(video_component: gr.Video) -> None:
+    """Patch a ``gr.Video`` so HTTP(S) URLs bypass Gradio's safehttpx download.
+
+    Gradio's default postprocessing fetches HTTP URLs via ``safehttpx``,
+    which refuses localhost / private IPs.  Setting both ``FileData.path``
+    and ``FileData.url`` short-circuits the cache logic in
+    ``async_move_files_to_cache`` so the browser plays the URL directly.
+    """
+    from gradio.components.video import VideoData
+    from gradio.data_classes import FileData
+
+    original = video_component.postprocess
+
+    def _postprocess(value):  # type: ignore[no-untyped-def]
+        if isinstance(value, str) and value.startswith(("http://", "https://")):
+            return VideoData(video=FileData(path=value, url=value))
+        return original(value)
+
+    video_component.postprocess = _postprocess  # type: ignore[assignment]
+
+
+class EveAppHandlers:
+    """Gradio-callable handlers for EVE offline + live inference.
+
+    Args:
+        pool: The shared worker pool.
+        stream_manager: ``LiveStreamManager`` driving WebRTC streams.
+        sessions: ``SessionTracker`` for analytics + idle reaping.
+        logger: Logger used for per-session log lines.
+        max_fps / min_fps: FPS bounds forwarded to ``send_process_video``
+            (controls the worker-side encoding rate).
+        video_server: Optional local HTTP server for processed videos.
+            When set, processed clips are returned as URLs instead of raw
+            paths so Chrome's per-origin connection limit doesn't block
+            playback while SSE is open.
+    """
+
+    def __init__(
+        self,
+        pool: EveWorkerPool,
+        stream_manager: LiveStreamManager,
+        sessions: SessionTracker,
+        logger: logging.Logger,
+        max_fps: float | None,
+        min_fps: float | None,
+        video_server: VideoFileServer | None = None,
+    ) -> None:
+        self._pool = pool
+        self._stream = stream_manager
+        self._sessions = sessions
+        self._logger = logger
+        self._max_fps = max_fps
+        self._min_fps = min_fps
+        self._video_server = video_server
+        self._live_logged: set[str] = set()
+        self._live_logged_lock = threading.Lock()
+
+    # ----- offline inference -------------------------------------------------
+
+    def run_eve_inference(
+        self,
+        input_video: str,
+        face_detection: bool,
+        person_detection: bool,
+        face_id: bool,
+        hand_gesture: bool,
+        registry: dict[int, FaceEntry] | None,
+        mod_model: str | None = None,
+        request: gr.Request | None = None,
+        progress: gr.Progress = gr.Progress(),
+    ) -> tuple[str | None, dict[int, FaceEntry]]:
+        """Process an uploaded video through one EVE worker, end-to-end.
+
+        The whole read → infer → encode → write loop happens inside the
+        worker process so the asyncio event loop stays free for SSE
+        delivery.  The main thread only forwards the path/config and
+        relays small progress dicts.
+
+        Returns ``(output_url_or_path, registry)``.  ``registry`` is
+        returned unchanged when Face ID is disabled, or with ``sdk_id``
+        fields refreshed from the worker's gallery-restore results.
+        """
+        registry = registry or {}
+        session = request.session_hash[:8]
+        self._sessions.track(
+            request.session_hash,
+            "video_process",
+            face_detection=face_detection,
+            person_detection=person_detection,
+            face_id=face_id,
+            hand_gesture=hand_gesture,
+            mod_model=mod_model,
+        )
+
+        fps, width, height, total_frames = _read_video_metadata(input_video)
+        if total_frames <= 0:
+            raise gr.Error("Could not read any frames from the video.")
+
+        features = FeatureFlags(
+            face_detection=face_detection,
+            person_detection=person_detection,
+            face_id=face_id,
+            hand_gesture=hand_gesture,
+            mod_model=mod_model,
+        )
+
+        gallery_paths: list[str] = []
+        remove_all_users = False
+        if face_id and registry:
+            gallery_paths = [entry.path for entry in registry.values()]
+        elif face_id:
+            remove_all_users = True
+
+        # Write directly into Gradio's cache so postprocessing skips the
+        # expensive hash_file + shutil.copy2 that would block the asyncio
+        # event loop.
+        gradio_cache = os.path.join(tempfile.gettempdir(), "gradio")
+        session_out = os.path.join(gradio_cache, f"eve_{request.session_hash}")
+        os.makedirs(session_out, exist_ok=True)
+        output_path = os.path.join(session_out, f"output_{uuid.uuid4().hex[:8]}.mp4")
+
+        self._logger.info(f"[{session}] run_eve_inference: waiting for worker...")
+        # Only emit queue events when we actually have to wait — matches the
+        # live queue behaviour so dashboards don't show phantom peaks.
+        will_wait = self._pool.idle_count == 0
+        if will_wait:
+            self._sessions.track(request.session_hash, "offline_queue_enter")
+        t0 = time.monotonic()
+        worker = self._pool.acquire(
+            request.session_hash,
+            timeout=300.0,
+            progress=progress,
+            eta_fn=self._stream.estimated_wait,
+        )
+        if will_wait:
+            self._sessions.track(
+                request.session_hash,
+                "offline_queue_exit",
+                wait_seconds=round(time.monotonic() - t0, 1),
+            )
+        log_worker_activity(
+            self._logger, "acquired", "video-processing", self._pool, worker.worker_id
+        )
+        try:
+            frames_processed, gallery_results = worker.send_process_video(
+                input_path=input_video,
+                output_path=output_path,
+                features=features,
+                gallery_paths=gallery_paths,
+                remove_all_users=remove_all_users,
+                fps=fps,
+                width=width,
+                height=height,
+                total_frames=total_frames,
+                progress=progress,
+                max_fps=self._max_fps,
+                min_fps=self._min_fps,
+            )
+            self._logger.info(
+                f"[{session}] run_eve_inference: done, {frames_processed} frames processed"
+            )
+        finally:
+            self._pool.release(worker)
+            log_worker_activity(
+                self._logger, "released", "video-processing", self._pool, worker.worker_id
+            )
+            self._sessions.track(
+                request.session_hash,
+                "video_process_complete",
+                duration_seconds=round(time.monotonic() - t0, 1),
+            )
+
+        if gallery_results:
+            for entry, r in zip(registry.values(), gallery_results):
+                entry.sdk_id = r.user_id if r.success else None
+
+        if self._video_server is not None:
+            rel_path = os.path.relpath(output_path, gradio_cache)
+            video_result: str | None = self._video_server.build_url(rel_path, request)
+        else:
+            video_result = output_path
+
+        return video_result, registry
+
+    # ----- offline image inference -------------------------------------------
+
+    def run_eve_image_inference(
+        self,
+        input_image: str | None,
+        face_detection: bool,
+        person_detection: bool,
+        face_id: bool,
+        hand_gesture: bool,
+        registry: dict[int, FaceEntry] | None,
+        mod_model: str | None = None,
+        request: gr.Request | None = None,
+        progress: gr.Progress = gr.Progress(),
+    ) -> tuple[np.ndarray | None, dict[int, FaceEntry]]:
+        """Run a single image through one EVE worker, end-to-end.
+
+        Single-frame variant of :meth:`run_eve_inference`. Loads the image
+        as BGR, sends one ``InferenceCmd`` to the worker (the same path
+        that powers live inference), and returns the annotated result as
+        an RGB ``np.ndarray`` ready for ``gr.Image``.
+
+        Returns ``(annotated_image_rgb_or_None, registry)``. Registry is
+        returned unchanged — single-image inference does not refresh
+        Face ID gallery state.
+        """
+        if not input_image:
+            raise gr.Error("Please upload an image.")
+
+        registry = registry or {}
+        session = request.session_hash[:8] if request is not None else "?"
+        if request is not None:
+            self._sessions.track(
+                request.session_hash,
+                "image_process",
+                face_detection=face_detection,
+                person_detection=person_detection,
+                face_id=face_id,
+                hand_gesture=hand_gesture,
+                mod_model=mod_model,
+            )
+
+        frame = cv2.imread(input_image)
+        if frame is None:
+            raise gr.Error(f"Could not read image: {input_image}")
+
+        features = FeatureFlags(
+            face_detection=face_detection,
+            person_detection=person_detection,
+            face_id=face_id,
+            hand_gesture=hand_gesture,
+            mod_model=mod_model,
+        )
+
+        self._logger.info(f"[{session}] run_eve_image_inference: waiting for worker...")
+        will_wait = self._pool.idle_count == 0
+        if will_wait and request is not None:
+            self._sessions.track(request.session_hash, "offline_queue_enter")
+        t0 = time.monotonic()
+        worker = self._pool.acquire(
+            request.session_hash if request is not None else "image",
+            timeout=300.0,
+            progress=progress,
+            eta_fn=self._stream.estimated_wait,
+        )
+        if will_wait and request is not None:
+            self._sessions.track(
+                request.session_hash,
+                "offline_queue_exit",
+                wait_seconds=round(time.monotonic() - t0, 1),
+            )
+        log_worker_activity(
+            self._logger, "acquired", "image-processing", self._pool, worker.worker_id
+        )
+        try:
+            result = worker.send_inference(frame, features)
+            self._logger.info(f"[{session}] run_eve_image_inference: done")
+        finally:
+            self._pool.release(worker)
+            log_worker_activity(
+                self._logger, "released", "image-processing", self._pool, worker.worker_id
+            )
+            if request is not None:
+                self._sessions.track(
+                    request.session_hash,
+                    "image_process_complete",
+                    duration_seconds=round(time.monotonic() - t0, 1),
+                )
+
+        # Worker returns BGR (matches live-inference frame format); Gradio's
+        # gr.Image expects RGB.
+        result_rgb = cv2.cvtColor(result, cv2.COLOR_BGR2RGB)
+        return result_rgb, registry
+
+    # ----- live inference ----------------------------------------------------
+
+    def process_live_frame(
+        self,
+        frame: np.ndarray,
+        face_detection: bool,
+        person_detection: bool,
+        face_id: bool,
+        hand_gesture: bool,
+        registry: dict[int, FaceEntry] | None,
+        session_hash: str,
+        mod_model: str | None = None,
+    ):
+        # Return type intentionally unannotated: actual return is
+        # ``np.ndarray | fastrtc.CloseStream | None`` but ``CloseStream`` is
+        # only imported lazily inside the function (avoids pulling fastrtc
+        # into module scope), and Gradio/FastRTC may run ``get_type_hints``
+        # on bound handlers — a forward-ref string would break that.
+        """Run a single WebRTC frame through an EVE worker.
+
+        A worker is acquired on the first frame and held for the lifetime of
+        the stream.  Returns the frame with an overlay while waiting for a
+        worker, or a ``CloseStream`` when the session ends so the UI can
+        reset to ``Start Inference``.
+
+        ``gr.Request`` is not available inside FastRTC stream handlers, so
+        the Gradio session hash is passed through ``gr.State``.  FastRTC's
+        per-connection ``webrtc_id`` is still pulled from
+        ``current_context`` to track worker assignment per peer.
+        """
+        if frame is None:
+            return None
+
+        from fastrtc.utils import current_context
+
+        connection_id = current_context.get().webrtc_id
+        worker, reason = self._stream.get_or_acquire(connection_id, session_hash, registry or {})
+        if worker is None:
+            if reason == "waiting":
+                pos, total = self._stream.waiting_position(connection_id)
+                eta = self._stream.estimated_wait(pos)
+                eta_text = ""
+                if eta is not None:
+                    eta_mins = max(0.5, round(eta / 30) * 0.5)
+                    eta_text = f"\nest. wait ~{eta_mins:g} minutes"
+                if total > 1:
+                    return draw_overlay(frame, f"In queue {eta_text}")
+                return draw_overlay(frame, f"Waiting for available worker...{eta_text}")
+            with self._live_logged_lock:
+                self._live_logged.discard(connection_id)
+            from fastrtc import CloseStream
+
+            return CloseStream(reason or "Stream ended")
+
+        bridge = self._stream.get_bridge(connection_id)
+        if bridge is None or not bridge.is_alive:
+            self._stream.release(connection_id)
+            return draw_overlay(frame, "Inference error - retrying...")
+
+        with self._live_logged_lock:
+            first_frame = connection_id not in self._live_logged
+            if first_frame:
+                self._live_logged.add(connection_id)
+        if first_frame:
+            self._sessions.track(
+                session_hash,
+                "live_start",
+                face_detection=face_detection,
+                person_detection=person_detection,
+                face_id=face_id,
+                hand_gesture=hand_gesture,
+                mod_model=mod_model,
+            )
+
+        features = FeatureFlags(
+            face_detection=face_detection,
+            person_detection=person_detection,
+            face_id=face_id,
+            hand_gesture=hand_gesture,
+            mod_model=mod_model,
+        )
+        try:
+            result = bridge.submit_and_get_latest(frame, features)
+            if result is None:
+                # First frame — no inference result yet, show camera feed
+                return frame
+
+            remaining = self._stream.countdown_remaining(connection_id)
+            if remaining is not None:
+                secs = int(remaining) + 1
+                result = draw_countdown_banner(result, f"Other users waiting - stopping in {secs}s")
+
+            session_left = self._stream.session_remaining(connection_id)
+            if session_left is not None:
+                result = draw_session_timer(result, session_left)
+
+            return result
+        except (BrokenPipeError, EOFError, OSError):
+            # Worker pipe is gone (shutdown or crash) — release quietly
+            self._stream.release(connection_id)
+            return None
+        except Exception as exc:
+            self._logger.error(f"Live inference error: {exc}")
+            self._stream.release(connection_id)
+            return draw_overlay(frame, "Inference error - retrying...")
+
+    def on_live_feature_change(
+        self,
+        face_detection: bool,
+        person_detection: bool,
+        face_id: bool,
+        hand_gesture: bool,
+        mod_model: str | None = None,
+        request: gr.Request | None = None,
+    ) -> None:
+        """Track changes to the Live tab's feature checkboxes."""
+        self._sessions.track(
+            request.session_hash,
+            "live_feature_change",
+            face_detection=face_detection,
+            person_detection=person_detection,
+            face_id=face_id,
+            hand_gesture=hand_gesture,
+            mod_model=mod_model,
+        )
+
+    # ----- session cleanup ---------------------------------------------------
+
+    def cleanup_session(self, request: gr.Request) -> None:
+        """Gradio ``demo.unload`` handler — close the session + delete cache."""
+        self._sessions.on_unload(request)
+
+        gradio_cache = os.path.join(tempfile.gettempdir(), "gradio")
+        session_out = os.path.join(gradio_cache, f"eve_{request.session_hash}")
+        if os.path.isdir(session_out):
+            shutil.rmtree(session_out, ignore_errors=True)
+            self._logger.debug(f"Session cleanup: removed {session_out}")
+
+
+def _read_video_metadata(path: str) -> tuple[float, int, int, int]:
+    """Return ``(fps, width, height, total_frames)`` for a video file.
+
+    Webcam-recorded WebM blobs frequently lie in their headers (fps=0,
+    fps=1000 from ms timestamps, or no frame count) so we fall back to a
+    full decode pass when the headers look implausible.
+    """
+    cap = cv2.VideoCapture(path)
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
+    if fps <= 0 or fps > 240 or total_frames <= 0 or width <= 0 or height <= 0:
+        frame_count = 0
+        duration_ms = 0.0
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+            if frame_count == 0:
+                height, width = frame.shape[:2]
+            frame_count += 1
+            duration_ms = cap.get(cv2.CAP_PROP_POS_MSEC)
+        total_frames = frame_count
+        if fps <= 0 or fps > 240:
+            fps = total_frames / (duration_ms / 1000.0) if duration_ms > 0 else 30.0
+    cap.release()
+    return fps, width, height, total_frames

shared/eve_messages.py

@@ -0,0 +1,231 @@
+"""IPC message dataclasses for the Eve worker pool.
+
+All types are picklable and sent over ``multiprocessing.Pipe`` between the
+main Gradio process and Eve SDK worker processes.
+"""
+
+from dataclasses import dataclass
+
+# ---------------------------------------------------------------------------
+# Shared data types
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class CalibrationResultMsg:
+    """Picklable mirror of ``eve_wrapper.CalibrationResult``."""
+
+    success: bool
+    user_id: int
+    message: str
+
+
+@dataclass
+class FeatureFlags:
+    """Feature toggle bundle sent with inference / configure commands."""
+
+    face_detection: bool = True
+    person_detection: bool = True
+    face_id: bool = False
+    hand_gesture: bool = False
+    # None = MOD off. Otherwise a model-name string (e.g. "GMOD-80",
+    # "AMOD-8", "OMOD") that the worker resolves to the EVE SDK MOD model.
+    # Defaulted so existing demos keep their pickle shape unchanged.
+    mod_model: str | None = None
+
+
+@dataclass
+class SerializedFrame:
+    """Picklable representation of a numpy ndarray frame."""
+
+    data: bytes
+    shape: tuple[int, ...]
+    dtype: str
+
+
+# ---------------------------------------------------------------------------
+# Commands (main process → worker process)
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class InferenceCmd:
+    frame_bytes: bytes
+    shape: tuple[int, ...]
+    dtype: str
+    features: FeatureFlags
+
+
+@dataclass
+class ConfigureFeaturesCmd:
+    features: FeatureFlags
+
+
+@dataclass
+class CalibrateNewUserCmd:
+    frames_data: list[SerializedFrame]
+
+
+@dataclass
+class RemoveAllUsersCmd:
+    pass
+
+
+@dataclass
+class RestoreGalleryCmd:
+    frames_per_user_data: list[list[SerializedFrame]]
+
+
+@dataclass
+class EnableFaceIdCmd:
+    enabled: bool
+
+
+@dataclass
+class ProcessVideoCmd:
+    input_path: str
+    output_path: str
+    features: FeatureFlags
+    gallery_paths: list[str]
+    remove_all_users: bool
+    fps: float
+    width: int
+    height: int
+    total_frames: int
+    max_fps: float | None = None
+    min_fps: float | None = None
+
+
+@dataclass
+class ShutdownCmd:
+    pass
+
+
+@dataclass
+class StartProfilingCmd:
+    pass
+
+
+@dataclass
+class StopProfilingCmd:
+    pass
+
+
+@dataclass
+class GetProfileStatsCmd:
+    pass
+
+
+@dataclass
+class GetTimingStatsCmd:
+    reset: bool = True
+
+
+WorkerCmd = (
+    InferenceCmd
+    | ConfigureFeaturesCmd
+    | CalibrateNewUserCmd
+    | RemoveAllUsersCmd
+    | RestoreGalleryCmd
+    | EnableFaceIdCmd
+    | ProcessVideoCmd
+    | ShutdownCmd
+    | StartProfilingCmd
+    | StopProfilingCmd
+    | GetProfileStatsCmd
+    | GetTimingStatsCmd
+)
+
+
+# ---------------------------------------------------------------------------
+# Responses (worker process → main process)
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class ReadyResponse:
+    pid: int
+
+
+@dataclass
+class ErrorResponse:
+    error: str
+
+
+@dataclass
+class HeartbeatResponse:
+    pass
+
+
+@dataclass
+class OkResponse:
+    pass
+
+
+@dataclass
+class InferenceResponse:
+    frame_bytes: bytes
+    shape: tuple[int, ...]
+    dtype: str
+
+
+@dataclass
+class CalibrateOkResponse:
+    result: CalibrationResultMsg
+
+
+@dataclass
+class RemoveUsersOkResponse:
+    result: bool
+
+
+@dataclass
+class RestoreGalleryOkResponse:
+    results: list[CalibrationResultMsg]
+
+
+@dataclass
+class GalleryRestoredResponse:
+    results: list[CalibrationResultMsg]
+
+
+@dataclass
+class ProgressResponse:
+    current: int
+    total: int
+
+
+@dataclass
+class VideoProcessingDoneResponse:
+    frames_processed: int
+    gallery_results: list[CalibrationResultMsg]
+    recycle: bool
+
+
+@dataclass
+class ProfileStatsResponse:
+    stats_data: bytes  # marshalled pstats data
+
+
+@dataclass
+class TimingStatsResponse:
+    """Per-SDK-call timing data from EveWrapper."""
+
+    stats: dict[str, tuple[int, float]]  # {name: (call_count, total_seconds)}
+
+
+WorkerResponse = (
+    ReadyResponse
+    | ErrorResponse
+    | HeartbeatResponse
+    | OkResponse
+    | InferenceResponse
+    | CalibrateOkResponse
+    | RemoveUsersOkResponse
+    | RestoreGalleryOkResponse
+    | GalleryRestoredResponse
+    | ProgressResponse
+    | VideoProcessingDoneResponse
+    | ProfileStatsResponse
+    | TimingStatsResponse
+)

shared/eve_python/eve_sdk.py

@@ -0,0 +1,297 @@
+import ctypes
+from . import eve_sdk_structs as structs
+
+EveProcessingCallbackFn = ctypes.CFUNCTYPE(None, ctypes.POINTER(structs.EveProcessingCallbackReturnData))
+
+class EveSDK:
+    def __init__(self, dll_path: str):
+        self.cdll = ctypes.CDLL(dll_path)
+        # EveCameraApi.h
+        self.cdll.EveGetFormats.restype = structs.EveCameraFormats
+        self.cdll.EveGetFormats.argtypes = [ctypes.c_uint, structs.CCameraFormat]
+        self.cdll.EveGetCamera.restype = structs.EveCamera
+        self.cdll.EveGetCamera.argtypes = [ctypes.c_uint]
+        self.cdll.EveSetCamera.restype = structs.EveError
+        self.cdll.EveSetCamera.argtypes = [ctypes.c_uint, structs.CCameraFormat]
+        # EveControlInterface.h
+        self.cdll.CreateEve.restype = structs.EveError
+        self.cdll.CreateEve.argtypes = [structs.EveStartupParameters]
+        self.cdll.EveRegisterDataCallback.restype = structs.EveError
+        self.cdll.EveRegisterDataCallback.argtypes = [EveProcessingCallbackFn]
+        self.cdll.StartEve.restype = structs.EveError
+        self.cdll.StartEve.argtypes = []
+        self.cdll.StartEveWithParameters.restype = structs.EveError
+        self.cdll.StartEveWithParameters.argtypes = [structs.EveProcessingParameters]
+        self.cdll.EveSendImageForProcessing.restype = structs.EveError
+        self.cdll.EveSendImageForProcessing.argtypes = [structs.EveInputImage]
+        self.cdll.EveSendImageForProcessingWithParams.restype = structs.EveError
+        self.cdll.EveSendImageForProcessingWithParams.argtypes = [structs.EveInputImage, structs.CCameraParameters]        
+        self.cdll.ShutdownEve.restype = structs.EveError
+        self.cdll.ShutdownEve.argtypes = []
+
+        # EveKarolinska.h
+        self.cdll.EveConfigureKarolinska.restype = structs.EveKarolinskaOptions
+        self.cdll.EveConfigureKarolinska.argtypes = [structs.EveKarolinskaOptions]
+
+        self.cdll.EveGetKarolinskaData.restype = structs.EveKarolinskaData
+        self.cdll.EveGetKarolinskaData.argtypes = []
+
+        # EveFaceId.h
+        self.cdll.EveConfigureFaceId.restype = structs.EveFaceIdOptions
+        self.cdll.EveConfigureFaceId.argtypes = [structs.EveFaceIdOptions]
+        self.cdll.EveFaceIdCalibrateCurrent.restype = structs.EveError
+        self.cdll.EveFaceIdCalibrateCurrent.argtypes = []
+        self.cdll.EveFaceIdCalibrateNew.restype = structs.EveError
+        self.cdll.EveFaceIdCalibrateNew.argtypes = []
+        self.cdll.EveFaceIdForceIdentify.restype = structs.EveError
+        self.cdll.EveFaceIdForceIdentify.argtypes = []
+        self.cdll.EveFaceIdRemoveCurrent.restype = structs.EveError
+        self.cdll.EveFaceIdRemoveCurrent.argtypes = []
+        self.cdll.EveFaceIdRemoveAll.restype = structs.EveError
+        self.cdll.EveFaceIdRemoveAll.argtypes = []
+        self.cdll.EveFaceIdReloadGallery.restype = structs.EveError
+        self.cdll.EveFaceIdReloadGallery.argtypes = []
+        self.cdll.EveFaceIdCommandWaiting.restype = ctypes.c_uint
+        self.cdll.EveFaceIdCommandWaiting.argtypes = []
+        self.cdll.EveGetFaceIdData.restype = structs.EveFaceIdData
+        self.cdll.EveGetFaceIdData.argtypes = []
+        self.cdll.EveSendFaceIdCommand.restype = structs.EveFaceIdCommandStruct
+        self.cdll.EveSendFaceIdCommand.argtypes = [structs.EveFaceIdCommandStruct]
+        # EveFaceTracker.h
+        self.cdll.EveConfigureFaceTracker.restype = structs.EveFaceTrackerOptions
+        self.cdll.EveConfigureFaceTracker.argtypes = [structs.EveFaceTrackerOptions]
+        self.cdll.EveGetAllFaceData.restype = structs.EveAllFacesData
+        self.cdll.EveGetAllFaceData.argtypes = []
+        # EveFpga.h
+        self.cdll.EveConfigureFpga.restype = structs.EveFpgaOptions
+        self.cdll.EveConfigureFpga.argtypes = [structs.EveFpgaOptions]
+        self.cdll.EveConfigureFpgaDebug.restype = structs.EveFpgaDebugOptions
+        self.cdll.EveConfigureFpgaDebug.argtypes = [structs.EveFpgaDebugOptions]
+        self.cdll.QueryFpgaSetting.restype = structs.EveError
+        self.cdll.QueryFpgaSetting.argtypes = [structs.pipeline_config_t, ctypes.c_bool]
+        self.cdll.QueryFpgaSettings.restype = structs.EveError
+        self.cdll.QueryFpgaSettings.argtypes = [ctypes.c_uint16, ctypes.c_uint32, ctypes.c_bool]
+        self.cdll.SendSetSetting.restype = structs.EveError
+        self.cdll.SendSetSetting.argtypes = [structs.pipeline_config_t]
+        self.cdll.PopQueuedSetting.restype = structs.CFpgaGetSetting
+        self.cdll.PopQueuedSetting.argtypes = []
+        self.cdll.EveGetFpgaData.restype = structs.EveFpgaData
+        self.cdll.EveGetFpgaData.argtypes = []
+        self.cdll.FpgaReadJson.restype = structs.EveFpgaJsonMetadata
+        self.cdll.FpgaReadJson.argtypes = []
+        self.cdll.EveSendImageForProcessingWithFpgaData.restype = structs.EveError
+        self.cdll.EveSendImageForProcessingWithFpgaData.argtypes = [structs.EveInputImage, structs.EveFpgaManualData]    
+        
+        # EveImageManipulation.h
+        self.cdll.EveConfigureImageManipulation.restype = structs.EveImageManipulationOptions
+        self.cdll.EveConfigureImageManipulation.argtypes = [structs.EveImageManipulationOptions]
+
+        # EveImage.h
+        self.cdll.EveGetProcessedImage.restype = structs.EveProcessedImage
+        self.cdll.EveGetProcessedImage.argtypes = []
+        self.cdll.EveGetProcessedFrameTime.restype = structs.EveProcessedFrameTime
+        self.cdll.EveGetProcessedFrameTime.argtypes = []
+        self.cdll.EveConfigureProcessedImage.restype = structs.EveImageFormatRequest
+        self.cdll.EveConfigureProcessedImage.argtypes = [structs.EveImageFormatRequest]
+        
+        # EveObjectDetection.h
+        self.cdll.EveConfigureObjectDetection.restype = structs.EveObjectDetectionOptions
+        self.cdll.EveConfigureObjectDetection.argtypes = []
+        self.cdll.EveConfigurePersonDetection.restype = structs.EvePersonDetectionOptions
+        self.cdll.EveConfigurePersonDetection.argtypes = []
+        self.cdll.EveGetObjectDetectionData.restype = structs.EveDetectionData
+        self.cdll.EveGetObjectDetectionData.argtypes = []
+        self.cdll.EveCopyObjectDetectionData.restype = structs.EveDetectionData
+        self.cdll.EveCopyObjectDetectionData.argtypes = []
+        self.cdll.EveGetPersonDetectionData.restype = structs.EveDetectionData
+        self.cdll.EveGetPersonDetectionData.argtypes = []
+        self.cdll.EveCopyPersonDetectionData.restype = structs.EveDetectionData
+        self.cdll.EveCopyPersonDetectionData.argtypes = []
+        self.cdll.DeleteDetectionData.restype = structs.EveError
+        self.cdll.DeleteDetectionData.argtypes = [structs.EveDetectionData]
+        # EveROI.h
+        self.cdll.EveConfigureROIs.restype = structs.EveROIOptions
+        self.cdll.EveConfigureROIs.argtypes = [structs.EveROIOptions]
+        self.cdll.EveGetROIScoreData.restype = structs.EveROIScoreData
+        self.cdll.EveGetROIScoreData.argtypes = []
+        # EveHandGesture.h
+        self.cdll.EveConfigureHandGesture.restype = structs.EveHandGestureOptions
+        self.cdll.EveConfigureHandGesture.argtypes = [structs.EveHandGestureOptions]
+        self.cdll.EveGetHandGestureData.restype = structs.EveHandGestureData
+        self.cdll.EveGetHandGestureData.argtypes = []
+        self.cdll.EveCopyHandGestureData.restype = structs.EveHandGestureData
+        self.cdll.EveCopyHandGestureData.argtypes = []
+        self.cdll.EveDeleteHandGestureData.restype = structs.EveError
+        self.cdll.EveDeleteHandGestureData.argtypes = [structs.EveHandGestureData]
+        self.cdll.EveGetStaticGestureDetections.restype = structs.EveStaticGestureData
+        self.cdll.EveGetStaticGestureDetections.argtypes = []
+        self.cdll.EveGetDynamicGestureDetections.restype = structs.EveDynamicGestureData
+        self.cdll.EveGetDynamicGestureDetections.argtypes = []
+
+
+    # EveCamera.h
+    def EveGetFormats(self, cameraId: ctypes.c_uint, filter: structs.CCameraFormat) -> structs.EveCameraFormats:
+        return self.cdll.EveGetFormats(cameraId, filter)
+    
+    def EveGetCamera(self, cameraId: ctypes.c_uint) -> structs.EveCamera:
+        return self.cdll.EveGetCamera(cameraId)
+    
+    def EveSetCamera(self, cameraId: ctypes.c_uint, filter: structs.CCameraFormat) -> structs.EveError:
+        return self.cdll.EveSetCamera(cameraId, filter)
+    
+    # EveControlInterface.h
+    def CreateEve(self, options: structs.EveStartupParameters) -> structs.EveError:
+        return self.cdll.CreateEve(options)
+    
+    def EveRegisterDataCallback(self, callback) -> structs.EveError:
+        return self.cdll.EveRegisterDataCallback(callback)
+    
+    def StartEve(self) -> structs.EveError:
+        return self.cdll.StartEve()
+    
+    def StartEveWithParameters(self, parameters: structs.EveProcessingParameters) -> structs.EveError:
+        return self.cdll.StartEveWithParameters(parameters)
+        
+    def EveSendImageForProcessing(self, image: structs.EveInputImage) -> structs.EveError:
+        return self.cdll.EveSendImageForProcessing(image)
+        
+    def EveSendImageForProcessingWithParams(self, image: structs.EveInputImage, params: structs.CCameraParameters) -> structs.EveError:
+        return self.cdll.EveSendImageForProcessingWithParams(image, params)
+        
+    def EveSendFpgaDataManually(self, image: structs.EveFpgaManualData) -> structs.EveError:
+        return self.cdll.EveSendFpgaDataManually(image)
+    
+    def ShutdownEve(self) -> structs.EveError:
+        return self.cdll.ShutdownEve()    
+
+    # EveFaceId.h
+    def EveConfigureFaceId(self, options: structs.EveFaceIdOptions) -> structs.EveFaceIdOptions:
+        return self.cdll.EveConfigureFaceId(options)
+
+    def EveFaceIdCalibrateCurrent(self) -> structs.EveError:
+        return self.cdll.EveFaceIdCalibrateCurrent()
+    
+    def EveFaceIdCalibrateNew(self) -> structs.EveError:
+        return self.cdll.EveFaceIdCalibrateNew()
+    
+    def EveFaceIdForceIdentify(self) -> structs.EveError:
+        return self.cdll.EveFaceIdForceIdentify()
+    
+    def EveFaceIdRemoveCurrent(self) -> structs.EveError:
+        return self.cdll.EveFaceIdRemoveCurrent()
+    
+    def EveFaceIdRemoveAll(self) -> structs.EveError:
+        return self.cdll.EveFaceIdRemoveAll()
+    
+    def EveFaceIdReloadGallery(self) -> structs.EveError:
+        return self.cdll.EveFaceIdReloadGallery()
+    
+    def EveFaceIdCommandWaiting(self) -> ctypes.c_uint:
+        return self.cdll.EveFaceIdCommandWaiting()
+    
+    def EveGetFaceIdData(self) -> structs.EveFaceIdData:
+        return self.cdll.EveGetFaceIdData()
+
+    def EveSendFaceIdCommand(self, command: structs.EveFaceIdCommandStruct) -> structs.EveFaceIdCommandStruct:
+        return self.cdll.EveSendFaceIdCommand(command)
+
+    # EveFaceTracker.h
+    def EveConfigureFaceTracker(self, options: structs.EveFaceTrackerOptions) -> structs.EveFaceTrackerOptions:
+        return self.cdll.EveConfigureFaceTracker(options)
+
+    def EveGetAllFaceData(self) -> structs.EveAllFacesData:
+        return self.cdll.EveGetAllFaceData()
+
+    # EveFpga.h
+    def EveGetFpgaData(self) -> structs.EveFpgaData:
+        return self.cdll.EveGetFpgaData()
+        
+    def EveConfigureFpga(self, options: structs.EveFpgaOptions) -> structs.EveFpgaOptions:
+        return self.cdll.EveConfigureFpga(options)
+        
+    def EveConfigureFpgaDebug(self, options: structs.EveFpgaDebugOptions) -> structs.EveFpgaDebugOptions:
+        return self.cdll.EveConfigureFpgaDebug(options)
+        
+    def QueryFpgaSetting(self, command: structs.pipeline_config_t, notify: ctypes.c_bool) -> structs.EveError:
+        return self.cdll.QueryFpgaSetting(command, notify)
+
+    def QueryFpgaSettings(self, typeMask: ctypes.c_uint16, settingsMask: ctypes.c_uint32, notify: ctypes.c_bool) -> structs.EveError:
+        return self.cdll.QueryFpgaSettings(typeMask, settingsMask, notify)
+        
+    def SendSetSetting(self, command: structs.pipeline_config_t) -> structs.EveError:
+        return self.cdll.SendSetSetting(command)
+        
+    def PopQueuedSetting(self) -> structs.CFpgaGetSetting:
+        return self.cdll.PopQueuedSetting()
+        
+    def FpgaReadJson(self) -> structs.EveFpgaJsonMetadata:
+        return self.cdll.FpgaReadJson()
+        
+    # EveKarolinksa.h
+    def EveConfigureKarolinska(self, parameters: structs.EveKarolinskaOptions) -> structs.EveKarolinskaOptions:
+        return self.cdll.EveConfigureKarolinska(parameters)
+
+    def EveGetKarolinskaData(self) -> structs.EveKarolinskaData:
+        return self.cdll.EveGetKarolinskaData()
+
+    # EveImageManipulation.h
+    def EveConfigureImageManipulation(self, options: structs.EveImageManipulationOptions) -> structs.EveImageManipulationOptions:
+        return self.cdll.EveConfigureImageManipulation(options)
+
+    # EveImage.h
+    def EveGetProcessedImage(self) -> structs.EveProcessedImage:
+        return self.cdll.EveGetProcessedImage()
+    
+    def EveGetProcessedFrameTime(self) -> structs.EveProcessedFrameTime:
+        return self.cdll.EveGetProcessedFrameTime()
+    
+    def EveConfigureProcessedImage(self, fmt: structs.EveImageFormatRequest) -> structs.EveProcessedFrameTime:
+        return self.cdll.EveConfigureProcessedImage(fmt)
+        
+    # EveObjectDetection.h
+    def EveConfigureObjectDetection(self, enabled: structs.EveObjectDetectionOptions) -> structs.EveObjectDetectionOptions:
+        return self.cdll.EveConfigureObjectDetection(enabled)
+    
+    def EveConfigurePersonDetection(self, enabled: structs.EvePersonDetectionOptions) -> structs.EvePersonDetectionOptions:
+        return self.cdll.EveConfigurePersonDetection(enabled)
+    
+    def EveGetObjectDetectionData(self) -> structs.EveDetectionData:
+        return self.cdll.EveGetObjectDetectionData()
+    
+    def EveCopyObjectDetectionData(self) -> structs.EveDetectionData:
+        return self.cdll.EveCopyObjectDetectionData()
+    
+    def EveGetPersonDetectionData(self) -> structs.EveDetectionData:
+        return self.cdll.EveGetPersonDetectionData()
+    
+    def EveCopyPersonDetectionData(self) -> structs.EveDetectionData:
+        return self.cdll.EveCopyPersonDetectionData()
+    
+    def DeleteDetectionData(self, data: structs.EveDetectionData) -> structs.EveError:
+        return self.cdll.DeleteDetectionData(data)
+    
+    # EveROI.h
+    def EveConfigureROIs(self, options: structs.EveROIOptions) -> structs.EveError:
+        return self.cdll.EveConfigureROIs(options)
+    
+    def EveGetROIScoreData(self) -> structs.EveROIScoreData:
+        return self.cdll.EveGetROIScoreData()
+
+    # EveHandGesture.h
+    def EveConfigureHandGesture(self, options: structs.EveHandGestureOptions) -> structs.EveHandGestureOptions:
+        return self.cdll.EveConfigureHandGesture(options)
+
+    def EveGetHandGestureData(self) -> structs.EveHandGestureData:
+        return self.cdll.EveGetHandGestureData()
+
+    def EveCopyHandGestureData(self) -> structs.EveHandGestureData:
+        return self.cdll.EveGetHandGestureData()
+
+    def EveDeleteHandGestureData(self, data: structs.EveHandGestureData) -> structs.EveError:
+        return self.cdll.EveGetHandGestureData(data)
+
+    def EveGetStaticGestureDetections(self) -> structs.EveStaticGestureData:
+        return self.cdll.EveGetStaticGestureDetections()
+
+    def EveGetDynamicGestureDetections(self) -> structs.EveDynamicGestureData:
+        return self.cdll.EveGetDynamicGestureDetections()

shared/eve_python/eve_sdk_structs.py

@@ -0,0 +1,48 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+#If any of the files below are missing, make sure to run PythonCTypesGenerator.py
+from .structs.CAlgorithms import *
+from .structs.CBasicStructs import *
+from .structs.CCameraStructs import *
+from .structs.CDetectionStructs import *
+from .structs.CFaceData import *
+from .structs.CFaceIdStructs import *
+from .structs.CFpgaData import *
+from .structs.CHandGesture import *
+from .structs.CImageManipulation import *
+from .structs.CKarolinska import *
+from .structs.CROIStructs import *
+from .structs.CScreenLocation import *
+from .structs.CVisualSpeechStructs import *
+from .structs.EveProcessingStatus import *
+from .structs.EveAlgorithm import *
+from .structs.EveAlgorithmStructs import *
+from .structs.EveCallbackReturnData import *
+from .structs.EveCamera import *
+from .structs.EveCameraStructs import *
+from .structs.EveConfigurationParameters import *
+from .structs.EveControlInterface import *
+from .structs.EveControlOption import *
+from .structs.EveErrors import *
+from .structs.EveFaceId import *
+from .structs.EveFaceIdStructs import *
+from .structs.EveFaceTracker import *
+from .structs.EveFaceTrackerStructs import *
+from .structs.EveFpga import *
+from .structs.EveFpgaStructs import *
+from .structs.EveHandGesture import *
+from .structs.EveHandGestureStructs import *
+from .structs.EveImage import *
+from .structs.EveImageManipulation import *
+from .structs.EveImageManipulationStructs import *
+from .structs.EveImageStructs import *
+from .structs.EveKarolinska import *
+from .structs.EveKarolinskaStructs import *
+from .structs.EveObjectDetection import *
+from .structs.EveObjectDetectionStructs import *
+from .structs.EveROI import *
+from .structs.EveROIStructs import *
+from .structs.EveScreenLocation import *
+from .structs.EveScreenLocationStructs import *
+from .structs.EveTiming import *
+from .structs.EveTimingStructs import *

shared/eve_python/structs/CAlgorithms.py

@@ -0,0 +1,27 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+
+
+class EveAlgorithms(CtypesEnum):
+	EVE_ALGO_NONE = 0
+	EVE_ALGO_BACKGROUND_SEGMENTATION = 1
+	EVE_ALGO_OBJECT_DETECTION = 2
+	EVE_ALGO_PERSON_DETECTION = 3
+	EVE_ALGO_HEADPOSE_3D = 4
+	EVE_ALGO_HAND_GESTURE = 5
+	EVE_ALGO_DEPTH = 6
+	EVE_ALGO_EYEWEAR_DETECTION = 7
+	EVE_ALGO_KAROLINSKA = 8
+	EVE_ALGO_GAZE = 9
+	EVE_ALGO_GAZE_SINGLE_OUTPUT = 10
+	EVE_ALGO_FACE_ID = 11
+	EVE_ALGO_ROI_SELECTION = 12
+	EVE_ALGO_FACE_ENHANCEMENT = 13
+	EVE_ALGO_VISUAL_SPEECH_DETECTION = 14
+	EVE_ALGO_BACKGROUND_BLUR = 15
+	EVE_ALGO_BACKGROUND_REPLACEMENT = 16
+	EVE_ALGO_USER_HILIGHT = 17
+	EVE_ALGO_USER_FRAMING = 18
+	EVE_ALGO_MIRROR_IMAGE = 19
+	EVE_ALGO_FPGA_DRAWING = 20
+

shared/eve_python/structs/CBasicStructs.py

@@ -0,0 +1,86 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+
+EVE_ENCODING_SIZE = 9
+EVE_LOCATION_SIZE = 2
+
+class EveVideoFormat(CtypesEnum):
+	EVE_NONE = 0
+	EVE_BGRA = 1
+	EVE_YUY2 = 2
+	EVE_NV12 = 3
+	EVE_MJPG = 4
+	EVE_BGR = 5
+	EVE_GRAYSCALE = 6
+	EVE_RGBA = 7
+	EVE_RGB = 8
+	EVE_ENCODING_SIZE = 9
+
+class EveImageLocation(CtypesEnum):
+	EVE_CPU = 0
+	EVE_GPU = 1
+	EVE_LOCATION_SIZE = 2
+
+class CPoint2i(ctypes.Structure):
+	_fields_ = [
+		("x", ctypes.c_int),
+		("y", ctypes.c_int),
+	]
+
+class CPoint2f(ctypes.Structure):
+	_fields_ = [
+		("x", ctypes.c_float),
+		("y", ctypes.c_float),
+	]
+
+class CPoint3i(ctypes.Structure):
+	_fields_ = [
+		("x", ctypes.c_int),
+		("y", ctypes.c_int),
+		("z", ctypes.c_int),
+	]
+
+class CPoint3f(ctypes.Structure):
+	_fields_ = [
+		("x", ctypes.c_float),
+		("y", ctypes.c_float),
+		("z", ctypes.c_float),
+	]
+
+class CAngles3f(ctypes.Structure):
+	_fields_ = [
+		("pitch", ctypes.c_float),
+		("yaw", ctypes.c_float),
+		("roll", ctypes.c_float),
+	]
+
+class CRect2i(ctypes.Structure):
+	_fields_ = [
+		("left", ctypes.c_int),
+		("top", ctypes.c_int),
+		("right", ctypes.c_int),
+		("bottom", ctypes.c_int),
+	]
+
+class CRect2iWH(ctypes.Structure):
+	_fields_ = [
+		("x", ctypes.c_int),
+		("y", ctypes.c_int),
+		("width", ctypes.c_int),
+		("height", ctypes.c_int),
+	]
+
+class CRect2fWH(ctypes.Structure):
+	_fields_ = [
+		("x", ctypes.c_float),
+		("y", ctypes.c_float),
+		("width", ctypes.c_float),
+		("height", ctypes.c_float),
+	]
+
+class CResolution(ctypes.Structure):
+	_fields_ = [
+		("width", ctypes.c_uint),
+		("height", ctypes.c_uint),
+	]
+

shared/eve_python/structs/CCameraStructs.py

@@ -0,0 +1,48 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+from .CBasicStructs import *
+
+CAMERA_PID_VID_SIZE = 8
+CAMERA_NAME_SIZE = 64
+
+class EveCompare(CtypesEnum):
+	EVE_EQUAL = 0
+	EVE_AT_MOST = 1
+	EVE_AT_LEAST = 2
+
+class CCameraFormat(ctypes.Structure):
+	_fields_ = [
+		("resolution", CResolution),
+		("format", ctypes.c_int),
+		("fps", ctypes.c_float),
+		("compareResolution", ctypes.c_int),
+		("compareFps", ctypes.c_int),
+	]
+
+class CCamera(ctypes.Structure):
+	_fields_ = [
+		("id", ctypes.c_int),
+		("pid", ctypes.c_byte * CAMERA_PID_VID_SIZE),
+		("vid", ctypes.c_byte * CAMERA_PID_VID_SIZE),
+		("name", ctypes.c_byte * CAMERA_NAME_SIZE),
+		("isHardwareCamera", ctypes.c_uint),
+		("isFpgaCamera", ctypes.c_uint),
+		("isIrCamera", ctypes.c_uint),
+	]
+
+class CCameraParameters(ctypes.Structure):
+	_fields_ = [
+		("width", ctypes.c_int),
+		("height", ctypes.c_int),
+		("focalLength", ctypes.c_double),
+		("pixelSizeX", ctypes.c_double),
+		("pixelSizeY", ctypes.c_double),
+		("principalPointX", ctypes.c_double),
+		("principalPointY", ctypes.c_double),
+		("depthMin", ctypes.c_double),
+		("depthMax", ctypes.c_double),
+		("screenLocationXinMM", ctypes.c_float),
+		("screenLocationYinMM", ctypes.c_float),
+		("isInfrared", ctypes.c_uint),
+	]
+

shared/eve_python/structs/CDetectionStructs.py

@@ -0,0 +1,38 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+from .EveProcessingStatus import *
+
+EVE_DETECTIONS_SIZE = 256
+EVE_CLASS_ID_NAME_SIZE = 32
+
+class EveActionStatus(CtypesEnum):
+	EVE_IDLE = 0
+	EVE_INTERPOLATED = 1
+	EVE_COMPUTED = 2
+	EVE_NO_OUTPUT = 3
+
+class FrontalStatus(CtypesEnum):
+	UNKNOWN = 0
+	FRONTAL = 1
+	NON_FRONTAL = 2
+
+class CSingleDetectionData(ctypes.Structure):
+	_fields_ = [
+		("topLeftX", ctypes.c_int),
+		("topLeftY", ctypes.c_int),
+		("bottomRightX", ctypes.c_int),
+		("bottomRightY", ctypes.c_int),
+		("classScore", ctypes.c_float),
+		("classId", ctypes.c_int),
+		("classIdName", ctypes.c_byte * EVE_CLASS_ID_NAME_SIZE),
+		("frontalStatus", ctypes.c_int),
+	]
+
+class CDetectionData(ctypes.Structure):
+	_fields_ = [
+		("processingStatus", ctypes.c_int),
+		("actionStatus", ctypes.c_int),
+		("numberOfDetections", ctypes.c_int),
+		("detections", CSingleDetectionData * EVE_DETECTIONS_SIZE),
+	]
+

shared/eve_python/structs/CFaceData.py

@@ -0,0 +1,55 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+from .CBasicStructs import *
+from .CFaceIdStructs import *
+
+EVE_MAX_FACES = 10
+EVE_EYE_LANDMARK_SIZE = 14
+EVE_PUPIL_LANDMARK_SIZE = 2
+
+class EveEyeLandmark(CtypesEnum):
+	EVE_EYE_RIGHT_CORNER_TEMPORAL = 0
+	EVE_EYE_RIGHT_EYELID_UPPER_1 = 1
+	EVE_EYE_RIGHT_EYELID_UPPER_2 = 2
+	EVE_EYE_RIGHT_CORNER_NASAL = 3
+	EVE_EYE_RIGHT_EYELID_LOWER_1 = 4
+	EVE_EYE_RIGHT_EYELID_LOWER_2 = 5
+	EVE_EYE_LEFT_CORNER_NASAL = 6
+	EVE_EYE_LEFT_EYELID_UPPER_2 = 7
+	EVE_EYE_LEFT_EYELID_UPPER_1 = 8
+	EVE_EYE_LEFT_CORNER_TEMPORAL = 9
+	EVE_EYE_LEFT_EYELID_LOWER_2 = 10
+	EVE_EYE_LEFT_EYELID_LOWER_1 = 11
+	EVE_EYE_RIGHT_PUPIL_CENTER = 12
+	EVE_EYE_LEFT_PUPIL_CENTER = 13
+	EVE_EYE_LANDMARK_SIZE = 14
+
+class EvePupilLandmark(CtypesEnum):
+	EVE_RIGHT_PUPIL_CENTER = 0
+	EVE_LEFT_PUPIL_CENTER = 1
+	EVE_PUPIL_LANDMARK_SIZE = 2
+
+class CEyeLandmarks(ctypes.Structure):
+	_fields_ = [
+		("landmarks", CPoint3f * EVE_EYE_LANDMARK_SIZE),
+	]
+
+class CPupilLandmarks(ctypes.Structure):
+	_fields_ = [
+		("landmarks", CPoint3f * EVE_PUPIL_LANDMARK_SIZE),
+	]
+
+class CFaceData(ctypes.Structure):
+	_fields_ = [
+		("angles", CAngles3f),
+		("faceId", CFaceIdentityData),
+		("depth", ctypes.c_float),
+		("trackNumber", ctypes.c_int),
+	]
+
+class CAllFaces(ctypes.Structure):
+	_fields_ = [
+		("detectedFacesCount", ctypes.c_uint),
+		("faces", CFaceData * EVE_MAX_FACES),
+	]
+

shared/eve_python/structs/CFaceIdStructs.py

@@ -0,0 +1,68 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+from .EveProcessingStatus import *
+
+EVE_FACE_ID_MAX_MISSING_CALIBRATION_POSES = 5
+
+class EveFaceIdActionStatus(CtypesEnum):
+	EVE_FACE_ID_ACTION_IDLE = 0
+	EVE_FACE_ID_ACTION_CALIBRATING = 1
+	EVE_FACE_ID_ACTION_CALIBRATED = 2
+	EVE_FACE_ID_ACTION_IDENTIFIED = 3
+
+class EveFaceIdCalibrationStatus(CtypesEnum):
+	EVE_FACE_ID_CALIB_NONE = 0
+	EVE_FACE_ID_CALIB_RUNNING = 1
+	EVE_FACE_ID_CALIB_SUCCESS = 2
+	EVE_FACE_ID_CALIB_FAILURE_LACK_POSE_MOTION = 3
+	EVE_FACE_ID_CALIB_FAILURE_OTHER = 4
+
+class EveFaceIdIdentificationStatus(CtypesEnum):
+	EVE_FACE_ID_NONE = 0
+	EVE_FACE_ID_SUCCESS = 1
+	EVE_FACE_ID_FAILURE_VERIFICATION = 2
+	EVE_FACE_ID_FAILURE_ANGLE_PITCH = 3
+	EVE_FACE_ID_FAILURE_ANGLE_YAW = 4
+	EVE_FACE_ID_FAILURE_ANGLE_ROLL = 5
+	EVE_FACE_ID_FAILURE_ANGLE_BOTH = 6
+	EVE_FACE_ID_FAILURE_NO_GALLERY = 7
+	EVE_FACE_ID_FAILURE_EXP_SMILE = 8
+	EVE_FACE_ID_FAILURE_EXP_SQUINT = 9
+	EVE_FACE_ID_FAILURE_EXP_EYES_CLOSED = 10
+	EVE_FACE_ID_FAILURE_DEPTH = 11
+	EVE_FACE_ID_FAILURE_OTHER = 12
+
+class EveFaceIdPose(CtypesEnum):
+	EVE_FACE_ID_POSE_FRONTAL = 0
+	EVE_FACE_ID_POSE_LEFT = 1
+	EVE_FACE_ID_POSE_RIGHT = 2
+	EVE_FACE_ID_POSE_UP = 3
+	EVE_FACE_ID_POSE_DOWN = 4
+
+class EveFaceIdCommand(CtypesEnum):
+	EVE_FACE_ID_COMMAND_NONE = 0
+	EVE_FACE_ID_COMMAND_ADD_NEW_USER = 1
+	EVE_FACE_ID_COMMAND_CALIBRATE_CURRENT_USER = 2
+	EVE_FACE_ID_COMMAND_FORCE_ID = 3
+	EVE_FACE_ID_COMMAND_REMOVE_CURRENT_USER = 4
+	EVE_FACE_ID_COMMAND_REMOVE_ALL_USERS = 5
+	EVE_FACE_ID_COMMAND_RELOAD_GALLERY = 6
+
+class CFaceIdentity(ctypes.Structure):
+	_fields_ = [
+		("id", ctypes.c_longlong),
+		("confidence", ctypes.c_float),
+		("similarity", ctypes.c_float),
+	]
+
+class CFaceIdentityData(ctypes.Structure):
+	_fields_ = [
+		("processingStatus", ctypes.c_int),
+		("actionStatus", ctypes.c_int),
+		("calibrationStatus", ctypes.c_int),
+		("identificationStatus", ctypes.c_int),
+		("faceIdentity", CFaceIdentity),
+		("missingCalibrationPosesCount", ctypes.c_uint),
+		("missingCalibrationPoses", ctypes.c_int * EVE_FACE_ID_MAX_MISSING_CALIBRATION_POSES),
+	]
+

shared/eve_python/structs/CFpgaData.py

@@ -0,0 +1,350 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+from .CBasicStructs import *
+
+EVE_FPGA_MAX_USERS = 10
+EVE_FPGA_MAX_PERSONS = 5
+EVE_FPGA_MAX_HAND_LANDMARKS = 11
+EVE_FPGA_HAND_LANDMARKS = 10
+EVE_FPGA_MAX_OBJECT_DETECTION = 50
+PT_SIZE = 6
+MT_SIZE = 4
+RT_SIZE = 4
+
+class EveFpgaConnectionType(CtypesEnum):
+	EVE_FPGA_AUTO_SELECT = 0
+	EVE_FPGA_UART = 1
+	EVE_FPGA_I2C = 2
+	EVE_FPGA_HUB = 3
+	EVE_FPGA_MANUAL = 4
+
+class EveFpgaConnectionRequest(CtypesEnum):
+	EVE_FPGA_STOP = 0
+	EVE_FPGA_CONTINUE = 1
+
+class pipeline_config_type_t(CtypesEnum):
+	PT_FD = 0
+	PT_LM_FV = 1
+	PT_FID = 2
+	PT_PD = 3
+	PT_HD = 4
+	PT_HLMV = 5
+	PT_SIZE = 6
+
+class setting_type_t(CtypesEnum):
+	CS_ENABLED = 0x00
+	CS_IPS = 0x01
+	CS_RESERVED_2_7 = 0x02
+	CS_COMMAND = 0x08
+	CS_CUSTOM = 0x10
+	CS_MAX = 0x11
+
+class message_type_t(CtypesEnum):
+	MT_NONE = 0
+	MT_SET = 1
+	MT_GET = 2
+	MT_GET_BATCH = 3
+	MT_SIZE = 4
+
+class response_type_t(CtypesEnum):
+	RT_NONE = 0
+	RT_DATA = 1
+	RT_GET = 2
+	RT_ACK = 3
+	RT_SIZE = 4
+
+class EveFpgaSerialStatus(CtypesEnum):
+	EVE_FPGA_SUCCESS = 0
+	EVE_FPGA_NO_DATA = 1
+	EVE_FPGA_READ_START_MARKER_FAILED = 2
+	EVE_FPGA_FIND_START_MARKER_FAILED = 3
+	EVE_FPGA_READ_DATA_LENGTH_FAILED = 4
+	EVE_FPGA_READ_DATA_FAILED = 5
+	EVE_FPGA_CORRUPTED_DATA = 6
+	EVE_FPGA_UNEXPECTED_RESPONSE_TYPE = 7
+	EVE_FPGA_API_ERROR_START = 8
+	EVE_FPGA_NO_CALLBACK = 9
+	EVE_FPGA_DATA_ACCESSED_OUTSIDE_CALLBACK = 10
+	EVE_FPGA_INIT_FAILED = 11
+	EVE_FPGA_NOT_INIT = 12
+	EVE_FPGA_NOT_IMPLEMENTED = 13
+	EVE_FPGA_API_ERROR_END = 14
+
+class EveWakeupDetectionType(CtypesEnum):
+	EVE_USER_DETECTION = 0
+	EVE_STRANGER_DETECTION = 1
+
+class EveFpgaPipelineType(CtypesEnum):
+	EVE_UNKNOWN_PIPELINE = 0
+	EVE_HEAD_POSE_PIPELINE = 1
+	EVE_FACE_ID_PIPELINE = 2
+	EVE_HAND_GESTURE_PIPELINE = 3
+	EVE_COMPACT_HEAD_POSE_PIPELINE = 4
+	EVE_HMI_PIPELINE = 5
+	EVE_STANDALONE_HAND_GESTURE_PIPELINE = 6
+
+class EvePersonBodyPose(CtypesEnum):
+	EVE_FRONT = 0
+	EVE_NOT_FRONT = 1
+
+class EveDistanceFromCamera(CtypesEnum):
+	EVE_DISTANCE_CLOSE = 0
+	EVE_DISTANCE_MID = 1
+	EVE_DISTANCE_FAR = 2
+
+class EvePersonRegistrationStatus(CtypesEnum):
+	EVE_REGISTERED = 0
+	EVE_UNREGISTERED = 1
+	EVE_UNKNOWN = 2
+	EVE_REQUIREMENTS_UNMET = 3
+	EVE_DISABLED = 4
+	EVE_NO_GALLERY = 5
+
+class EveFpgaHandGesture(CtypesEnum):
+	EVE_FPGA_HAND_GESTURE_NO_GESTURE = 0
+	EVE_FPGA_HAND_GESTURE_CLOSE = 1
+	EVE_FPGA_HAND_GESTURE_OPEN = 2
+	EVE_FPGA_HAND_GESTURE_OPEN_LEFT = 3
+	EVE_FPGA_HAND_GESTURE_OPEN_RIGHT = 4
+	EVE_FPGA_HAND_GESTURE_INDEX_UP = 5
+	EVE_FPGA_HAND_GESTURE_INDEX_DOWN = 6
+	EVE_FPGA_HAND_GESTURE_TIP_LEFT = 7
+	EVE_FPGA_HAND_GESTURE_TIP_RIGHT = 8
+	EVE_FPGA_HAND_GESTURE_UNKNOWN = 9
+
+class EveFpgaObjectClass(CtypesEnum):
+	EVE_FPGA_OBJECT_CLASS_PERSON = 0
+	EVE_FPGA_OBJECT_CLASS_BICYCLE = 1
+	EVE_FPGA_OBJECT_CLASS_CAR = 2
+	EVE_FPGA_OBJECT_CLASS_MOTORCYCLE = 3
+	EVE_FPGA_OBJECT_CLASS_BUS = 4
+	EVE_FPGA_OBJECT_CLASS_TRUCK = 5
+	EVE_FPGA_OBJECT_CLASS_TRAFFIC_LIGHT = 6
+	EVE_FPGA_OBJECT_CLASS_STOP_SIGN = 7
+
+class pipeline_setting_t(ctypes.Structure):
+	_fields_ = [
+		("settingType", ctypes.c_int),
+		("value", ctypes.c_uint32),
+	]
+
+class pipeline_config_t(ctypes.Structure):
+	_fields_ = [
+		("type", ctypes.c_int),
+		("setting", pipeline_setting_t),
+	]
+
+class CFpgaIdealPersonData(ctypes.Structure):
+	_fields_ = [
+		("valid", ctypes.c_uint),
+		("index", ctypes.c_uint),
+		("status", ctypes.c_int),
+		("faceAngles", CAngles3f),
+		("faceLandmarksConfidence", ctypes.c_float),
+		("isFaceLandmarksConfidenceValid", ctypes.c_bool),
+	]
+
+class CFpgaImageDimensions(ctypes.Structure):
+	_fields_ = [
+		("width", ctypes.c_int),
+		("height", ctypes.c_int),
+		("cropArea", CRect2i),
+		("reserved1", ctypes.c_int),
+		("reserved2", ctypes.c_int),
+	]
+
+class CFpgaDataContent(ctypes.Structure):
+	_fields_ = [
+		("numberOfUsers", ctypes.c_int16),
+		("idealUserIndex", ctypes.c_int16),
+		("numberOfDetectedFaces", ctypes.c_int16),
+		("numberOfFacesConfidence", ctypes.c_float),
+		("numberOfDetectedPersons", ctypes.c_int16),
+		("numberOfPersonsConfidence", ctypes.c_float),
+		("isIdealUserDataAvailable", ctypes.c_bool),
+		("idealUserDetected", ctypes.c_bool),
+		("isIdealUserIndexValid", ctypes.c_bool),
+		("isNumberOfDetectedFacesAvailable", ctypes.c_bool),
+		("isNumberOfFacesConfidenceAvailable", ctypes.c_bool),
+		("isNumberOfDetectedPersonsAvailable", ctypes.c_bool),
+		("isNumberOfPersonsConfidenceAvailable", ctypes.c_bool),
+		("isUsersDataAvilable", ctypes.c_bool),
+		("isFaceIdDataAvailable", ctypes.c_bool),
+		("isObjectDetectionAvailable", ctypes.c_bool),
+		("isCameraStreaming", ctypes.c_bool),
+		("isHandGestureDataAvailable", ctypes.c_bool),
+		("isDefectDetectionAvailable", ctypes.c_bool),
+	]
+
+class CFpgaHandData(ctypes.Structure):
+	_fields_ = [
+		("validationScore", ctypes.c_float),
+		("handBox", CRect2i),
+		("landmarks", CPoint3f * EVE_FPGA_MAX_HAND_LANDMARKS),
+	]
+
+class CFpgaHandsData(ctypes.Structure):
+	_fields_ = [
+		("numberOfHandLandmarkPoints", ctypes.c_int16),
+		("handData", CFpgaHandData),
+		("gesture", ctypes.c_int),
+		("isHandBoxAvailable", ctypes.c_bool),
+		("isHandLandmark3D", ctypes.c_bool),
+	]
+
+class CFpgaDefectData(ctypes.Structure):
+	_fields_ = [
+		("defectBox", CRect2i),
+		("width", ctypes.c_int),
+		("height", ctypes.c_int),
+		("similarity", ctypes.c_float),
+		("isDefective", ctypes.c_bool),
+	]
+
+class CFpgaFaceData(ctypes.Structure):
+	_fields_ = [
+		("faceConfidence", ctypes.c_float),
+		("faceDistance", ctypes.c_int16),
+		("faceCenter", CPoint3i),
+		("anglesICS", CAngles3f),
+		("anglesCCS", CAngles3f),
+		("faceLandmarksConfidence", ctypes.c_float),
+		("faceBox", CRect2i),
+		("faceIDStatus", ctypes.c_int),
+		("faceID", ctypes.c_int16),
+		("isFaceConfidenceAvailable", ctypes.c_bool),
+		("isFaceDistanceAvailable", ctypes.c_bool),
+		("isFacePositionAvailable", ctypes.c_bool),
+		("isEulerAnglesIcsAvailable", ctypes.c_bool),
+		("isEulerAnglesCcsAvailable", ctypes.c_bool),
+		("isFaceLandmark3D", ctypes.c_bool),
+		("isFaceLandmarksConfidenceAvailable", ctypes.c_bool),
+		("isFaceGeometricBoxAvailable", ctypes.c_bool),
+		("isStatusAvailable", ctypes.c_bool),
+	]
+
+class CFpgaPersonData(ctypes.Structure):
+	_fields_ = [
+		("personConfidence", ctypes.c_float),
+		("personDistance", ctypes.c_int),
+		("personPosture", ctypes.c_int),
+		("personFrontalPostureConfidence", ctypes.c_float),
+		("personNotFrontalPostureConfidence", ctypes.c_float),
+		("position", CPoint3i),
+		("personBox", CRect2i),
+		("isPersonDataAvailable", ctypes.c_bool),
+	]
+
+class CFpgaObjectDetection(ctypes.Structure):
+	_fields_ = [
+		("objectClass", ctypes.c_int),
+		("objectConfidence", ctypes.c_float),
+		("objectBox", CRect2i),
+	]
+
+class CFpgaObjectData(ctypes.Structure):
+	_fields_ = [
+		("numberOfObjects", ctypes.c_int16),
+		("objects", CFpgaObjectDetection * EVE_FPGA_MAX_OBJECT_DETECTION),
+	]
+
+class CFpgaUserData(ctypes.Structure):
+	_fields_ = [
+		("id", ctypes.c_int16),
+		("status", ctypes.c_int),
+		("scale", ctypes.c_float),
+		("faceData", CFpgaFaceData),
+		("personData", CFpgaPersonData),
+		("isIdealUser", ctypes.c_bool),
+		("isIdValid", ctypes.c_bool),
+		("isStatusAvailable", ctypes.c_bool),
+		("isScaleAvailable", ctypes.c_bool),
+	]
+
+class CFpgaFaceIdData(ctypes.Structure):
+	_fields_ = [
+		("command", ctypes.c_int16),
+		("userId", ctypes.c_int16),
+		("freeEntry", ctypes.c_int16),
+		("statusCode", ctypes.c_int16),
+		("faceId", ctypes.c_int16),
+		("lastRegisteredFaceID", ctypes.c_int16),
+		("usersInGallery", ctypes.c_int16),
+		("gallerySize", ctypes.c_int16),
+	]
+
+class CFpgaPipelineData(ctypes.Structure):
+	_fields_ = [
+		("pipelineType", ctypes.c_int),
+		("imageDimensions", CFpgaImageDimensions),
+		("dataContent", CFpgaDataContent),
+		("userData", CFpgaUserData * EVE_FPGA_MAX_USERS),
+		("objectData", CFpgaObjectData),
+		("faceId", CFpgaFaceIdData),
+		("handsData", CFpgaHandsData),
+		("defectData", CFpgaDefectData),
+	]
+
+class CFpgaMessage(ctypes.Structure):
+	_fields_ = [
+		("responseType", ctypes.c_int),
+		("responseVersion", ctypes.c_uint8),
+		("serialStatus", ctypes.c_int),
+		("serialReadTimeNano", ctypes.c_longlong),
+	]
+
+class CFpgaData(ctypes.Structure):
+	_fields_ = [
+		("message", CFpgaMessage),
+		("pipelineData", CFpgaPipelineData),
+	]
+
+class CFpgaGetSetting(ctypes.Structure):
+	_fields_ = [
+		("message", CFpgaMessage),
+		("type", ctypes.c_int),
+		("setting", ctypes.c_int),
+		("value", ctypes.c_uint32),
+	]
+
+class CFpgaParameters(ctypes.Structure):
+	_fields_ = [
+		("comport", ctypes.c_uint),
+		("socWakeupDelay", ctypes.c_uint),
+		("wakeupType", ctypes.c_int),
+		("forceCameraOn", ctypes.c_ubyte),
+		("registerNewFace", ctypes.c_ubyte),
+		("clearCurrentFace", ctypes.c_ubyte),
+		("enableFaceId", ctypes.c_ubyte),
+		("allPipelinesSupported", ctypes.c_ubyte),
+		("pipelineVersion", ctypes.c_uint),
+		("connection", ctypes.c_int),
+		("i2cAdapterNumber", ctypes.c_uint),
+		("i2cDeviceNumber", ctypes.c_uint),
+		("i2cIRQPin", ctypes.c_uint),
+	]
+
+class CFpgaCallbackControl(ctypes.Structure):
+	_fields_ = [
+		("request", ctypes.c_int),
+	]
+
+class EveFpgaMetadata(ctypes.Structure):
+	_fields_ = [
+		("data", ctypes.POINTER(CFpgaData)),
+		("errorCode", ctypes.c_int),
+	]
+
+class EveFpgaManualData(ctypes.Structure):
+	_fields_ = [
+		("data", ctypes.POINTER(ctypes.c_ubyte)),
+		("size", ctypes.c_int),
+	]
+
+class EveFpgaJsonMetadata(ctypes.Structure):
+	_fields_ = [
+		("textStart", ctypes.POINTER(ctypes.c_byte)),
+		("textSize", ctypes.c_uint),
+		("errorCode", ctypes.c_int),
+	]
+

shared/eve_python/structs/CHandGesture.py

@@ -0,0 +1,144 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+from .CBasicStructs import *
+from .EveProcessingStatus import *
+
+EVE_MAX_HAND_DETECTIONS = 8
+EVE_MAX_DYNAMIC_GESTURE_SEQUENCE = 8
+EVE_MAX_CUSTOM_STATIC_GESTURES = 20
+EVE_MAX_STATIC_GESTURES = 40
+EVE_HAND_LANDMARKS_SIZE = 2
+EVE_HAND_LANDMARK_SIZE = 11
+EVE_STATIC_GESTURE_SIZE = 22
+EVE_DYNAMIC_GESTURE_SIZE = 12
+
+class EveRunHandLandmarks(CtypesEnum):
+	EVE_HAND_LANDMARKS_ALL_HANDS = 0
+	EVE_HAND_LANDMARKS_MAIN_HAND_ONLY = 1
+	EVE_HAND_LANDMARKS_SIZE = 2
+
+class EveHandLandmark(CtypesEnum):
+	EVE_WRIST = 0
+	EVE_THUMB_IP = 1
+	EVE_THUMB_TIP = 2
+	EVE_INDEX_MCP = 3
+	EVE_INDEX_TIP = 4
+	EVE_MIDDLE_MCP = 5
+	EVE_MIDDLE_TIP = 6
+	EVE_RING_MCP = 7
+	EVE_RING_TIP = 8
+	EVE_PINKY_MCP = 9
+	EVE_PINKY_TIP = 10
+	EVE_HAND_LANDMARK_SIZE = 11
+
+class EveGestureQuality(CtypesEnum):
+	EVE_POOR_QUALITY_LOW_CONFIDENCE = 0
+	EVE_POOR_QUALITY_HAND_OVER_FACE = 1
+	EVE_GOOD_QUALITY = 2
+
+class EveStaticGestureType(CtypesEnum):
+	EVE_STATIC_GESTURE_NONE = 0
+	EVE_OPEN_HAND = 1
+	EVE_OPEN_HAND_LEFT = 2
+	EVE_OPEN_HAND_RIGHT = 3
+	EVE_CLOSED_HAND = 4
+	EVE_THUMBS_LEFT = 5
+	EVE_THUMBS_RIGHT = 6
+	EVE_RESERVED_STATIC_GESTURE_1 = 7
+	EVE_RESERVED_STATIC_GESTURE_2 = 8
+	EVE_RESERVED_STATIC_GESTURE_3 = 9
+	EVE_RESERVED_STATIC_GESTURE_4 = 10
+	EVE_RESERVED_STATIC_GESTURE_5 = 11
+	EVE_CUSTOM_STATIC_GESTURE_1 = 12
+	EVE_CUSTOM_STATIC_GESTURE_2 = 13
+	EVE_CUSTOM_STATIC_GESTURE_3 = 14
+	EVE_CUSTOM_STATIC_GESTURE_4 = 15
+	EVE_CUSTOM_STATIC_GESTURE_5 = 16
+	EVE_CUSTOM_STATIC_GESTURE_6 = 17
+	EVE_CUSTOM_STATIC_GESTURE_7 = 18
+	EVE_CUSTOM_STATIC_GESTURE_8 = 19
+	EVE_CUSTOM_STATIC_GESTURE_9 = 20
+	EVE_CUSTOM_STATIC_GESTURE_10 = 21
+	EVE_STATIC_GESTURE_SIZE = 22
+
+class EveDynamicGestureType(CtypesEnum):
+	EVE_DYNAMIC_GESTURE_NONE = 0
+	EVE_GRAB = 1
+	EVE_RESERVED_DYNAMIC_GESTURE_1 = 2
+	EVE_RESERVED_DYNAMIC_GESTURE_2 = 3
+	EVE_RESERVED_DYNAMIC_GESTURE_3 = 4
+	EVE_RESERVED_DYNAMIC_GESTURE_4 = 5
+	EVE_RESERVED_DYNAMIC_GESTURE_5 = 6
+	EVE_CUSTOM_DYNAMIC_GESTURE_1 = 7
+	EVE_CUSTOM_DYNAMIC_GESTURE_2 = 8
+	EVE_CUSTOM_DYNAMIC_GESTURE_3 = 9
+	EVE_CUSTOM_DYNAMIC_GESTURE_4 = 10
+	EVE_CUSTOM_DYNAMIC_GESTURE_5 = 11
+	EVE_DYNAMIC_GESTURE_SIZE = 12
+
+class EveStaticGesture(ctypes.Structure):
+	_fields_ = [
+		("handId", ctypes.c_int),
+		("isMainUserHand", ctypes.c_int),
+		("type", ctypes.c_int),
+		("confidence", ctypes.c_float),
+		("quality", ctypes.c_int),
+	]
+
+class EveStaticGestures(ctypes.Structure):
+	_fields_ = [
+		("count", ctypes.c_uint),
+		("gestures", EveStaticGesture * EVE_MAX_HAND_DETECTIONS),
+	]
+
+class EveStaticGestureDefinition(ctypes.Structure):
+	_fields_ = [
+		("gestureType", ctypes.c_int),
+		("id", ctypes.c_uint),
+		("landmarksMap", CPoint2f * EVE_HAND_LANDMARK_SIZE),
+	]
+
+class EveDynamicGesture(ctypes.Structure):
+	_fields_ = [
+		("handId", ctypes.c_int),
+		("isMainUserHand", ctypes.c_int),
+		("type", ctypes.c_int),
+		("quality", ctypes.c_int),
+	]
+
+class EveDynamicGestures(ctypes.Structure):
+	_fields_ = [
+		("count", ctypes.c_uint),
+		("gestures", EveDynamicGesture * EVE_MAX_HAND_DETECTIONS),
+	]
+
+class EveDynamicGestureDefinition(ctypes.Structure):
+	_fields_ = [
+		("gestureType", ctypes.c_int),
+		("sequenceCount", ctypes.c_uint),
+		("gestureSequence", ctypes.c_int * EVE_MAX_DYNAMIC_GESTURE_SEQUENCE),
+	]
+
+class EveSingleHandDetection(ctypes.Structure):
+	_fields_ = [
+		("id", ctypes.c_int),
+		("isHandValid", ctypes.c_int),
+		("boundingBox", CRect2iWH),
+		("boundingBoxScore", ctypes.c_float),
+		("landmarksICS", CPoint2f * EVE_HAND_LANDMARK_SIZE),
+		("validationScore", ctypes.c_float),
+		("inPlaneAngle", ctypes.c_float),
+		("depth", ctypes.c_float),
+		("isMainUserHand", ctypes.c_int),
+		("isInCurrentFrame", ctypes.c_int),
+	]
+
+class EveHandDetections(ctypes.Structure):
+	_fields_ = [
+		("status", ctypes.c_int),
+		("hasFaceROI", ctypes.c_int),
+		("faceROI", CRect2fWH),
+		("detectedHandCount", ctypes.c_uint),
+		("hands", EveSingleHandDetection * EVE_MAX_HAND_DETECTIONS),
+	]
+

shared/eve_python/structs/CImageManipulation.py

@@ -0,0 +1,12 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+
+
+class CImageManipulationSettings(ctypes.Structure):
+	_fields_ = [
+		("mirrorImage", ctypes.c_uint),
+		("reserved1", ctypes.c_uint),
+		("reserved2", ctypes.c_uint),
+		("reserved3", ctypes.c_uint),
+	]
+

shared/eve_python/structs/CKarolinska.py

@@ -0,0 +1,57 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+
+
+class EveKarolinskaSleepiness(CtypesEnum):
+	EVE_KAROLINSKA_DISABLED = 0
+	EVE_KAROLINSKA_1 = 1
+	EVE_KAROLINSKA_2 = 2
+	EVE_KAROLINSKA_3 = 3
+	EVE_KAROLINSKA_4 = 4
+	EVE_KAROLINSKA_5 = 5
+	EVE_KAROLINSKA_6 = 6
+	EVE_KAROLINSKA_7 = 7
+	EVE_KAROLINSKA_8 = 8
+	EVE_KAROLINSKA_9 = 9
+	EVE_KAROLINSKA_MAX = 10
+
+class EveEyeClosureState(CtypesEnum):
+	EVE_EYE_STATE_UNKNOWN = 0
+	EVE_EYE_OPEN = 1
+	EVE_EYE_CLOSED = 2
+
+class EveKarolinskaStatus(CtypesEnum):
+	EVE_KAROLINSKA_OFF = 0
+	EVE_KAROLINSKA_NO_FACE = 1
+	EVE_KAROLINSKA_BLINKS_ONLY = 2
+	EVE_KAROLINSKA_ON = 3
+
+class CEyeState(ctypes.Structure):
+	_fields_ = [
+		("state", ctypes.c_int),
+		("closure", ctypes.c_float),
+		("confidence", ctypes.c_float),
+		("eyelidDistanceMM", ctypes.c_float),
+	]
+
+class CEyeStates(ctypes.Structure):
+	_fields_ = [
+		("left", CEyeState),
+		("right", CEyeState),
+		("fused", CEyeState),
+		("blinkCount", ctypes.c_uint),
+	]
+
+class CKarolinskaData(ctypes.Structure):
+	_fields_ = [
+		("status", ctypes.c_int),
+		("scale", ctypes.c_int),
+		("headPitchScale", ctypes.c_int),
+		("yawnScale", ctypes.c_int),
+		("blinkDurationScale", ctypes.c_int),
+		("yawn", ctypes.c_float),
+		("yawnConfidence", ctypes.c_float),
+		("yawnCount", ctypes.c_uint),
+		("eyes", CEyeStates),
+	]
+

shared/eve_python/structs/CLandmarkMaps.py

@@ -0,0 +1,40 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+
+EVE_HMI_P_L_SIZE = 23
+EVE_HMI_S_L_SIZE = 5
+
+class EveHmiPrimaryLandmarks(CtypesEnum):
+	EVE_HMI_P_L_RIGHT_TEMPLE = 0
+	EVE_HMI_P_L_RIGHT_JAW = 1
+	EVE_HMI_P_L_CENTER_JAW = 2
+	EVE_HMI_P_L_LEFT_JAW = 3
+	EVE_HMI_P_L_LEFT_TEMPLE = 4
+	EVE_HMI_P_L_RIGHT_EYEBROW = 5
+	EVE_HMI_P_L_LEFT_EYEBROW = 6
+	EVE_HMI_P_L_NOSE_BRIDGE = 7
+	EVE_HMI_P_L_NOSE_TIP_HIGH = 8
+	EVE_HMI_P_L_NOSE_TIP = 9
+	EVE_HMI_P_L_NOSE_TIP_LOW = 10
+	EVE_HMI_P_L_RIGHT_EYE_1 = 11
+	EVE_HMI_P_L_RIGHT_EYE_2 = 12
+	EVE_HMI_P_L_LEFT_EYE_1 = 13
+	EVE_HMI_P_L_LEFT_EYE_2 = 14
+	EVE_HMI_P_L_MOUTH_RIGHT_CORNER = 15
+	EVE_HMI_P_L_MOUTH_UPPER_LIP = 16
+	EVE_HMI_P_L_MOUTH_LEFT_CORNER = 17
+	EVE_HMI_P_L_MOUTH_LOWER_LIP = 18
+	EVE_HMI_P_L_MOUTH_OPEN_TOP = 19
+	EVE_HMI_P_L_MOUTH_OPEN_BOTTOM = 20
+	EVE_HMI_P_L_RIGHT_PUPIL = 21
+	EVE_HMI_P_L_LEFT_PUPIL = 22
+	EVE_HMI_P_L_SIZE = 23
+
+class EveHmiSecondaryLandmarks(CtypesEnum):
+	EVE_HMI_S_L_RIGHT_PUPIL = 0
+	EVE_HMI_S_L_LEFT_PUPIL = 1
+	EVE_HMI_S_L_NOSE_TIP_LOW = 2
+	EVE_HMI_S_L_RIGHT_MOUTH_CORNER = 3
+	EVE_HMI_S_L_LEFT_MOUTH_CORNER = 4
+	EVE_HMI_S_L_SIZE = 5
+

shared/eve_python/structs/CROIStructs.py

@@ -0,0 +1,29 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+from .EveProcessingStatus import *
+
+EVE_ROI_MAX_SCORE_COUNT = 20
+
+class EveROIState(CtypesEnum):
+	EVE_ROI_STATE_INACTIVE = 0
+	EVE_ROI_STATE_ENTERING = 1
+	EVE_ROI_STATE_LEAVING = 2
+	EVE_ROI_STATE_SELECTED = 3
+
+class CROIScore(ctypes.Structure):
+	_fields_ = [
+		("id", ctypes.c_uint),
+		("intersectionScore", ctypes.c_double),
+		("filteredScore", ctypes.c_double),
+		("state", ctypes.c_int),
+	]
+
+class CROIScoreData(ctypes.Structure):
+	_fields_ = [
+		("processingStatus", ctypes.c_int),
+		("fusedRoiScoresCount", ctypes.c_uint),
+		("fusedRoiScores", CROIScore * EVE_ROI_MAX_SCORE_COUNT),
+		("faceRoiScoresCount", ctypes.c_uint),
+		("faceRoiScores", CROIScore * EVE_ROI_MAX_SCORE_COUNT),
+	]
+

shared/eve_python/structs/CScreenLocation.py

@@ -0,0 +1,10 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+
+
+class CScreenLocation(ctypes.Structure):
+	_fields_ = [
+		("topLeftXInMM", ctypes.c_float),
+		("topLeftYInMM", ctypes.c_float),
+	]
+

shared/eve_python/structs/CVisualSpeechStructs.py

@@ -0,0 +1,18 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+from .EveProcessingStatus import *
+
+
+class EveVisualSpeechState(CtypesEnum):
+	EVE_NOT_SET = 0
+	EVE_NOT_SPEAKING = 1
+	EVE_SPEAKING = 2
+
+class CVisualSpeechData(ctypes.Structure):
+	_fields_ = [
+		("processingStatus", ctypes.c_int),
+		("speechState", ctypes.c_int),
+		("notSpeakingProbability", ctypes.c_double),
+		("speakingProbability", ctypes.c_double),
+	]
+

shared/eve_python/structs/EveAlgorithm.py

@@ -0,0 +1,5 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+from .EveAlgorithmStructs import *
+
+

shared/eve_python/structs/EveAlgorithmStructs.py

@@ -0,0 +1,14 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+from .CAlgorithms import *
+from .EveErrors import *
+
+EVE_ALGORITHMS_SIZE = 20
+
+class EveSupportedAlgorithms(ctypes.Structure):
+	_fields_ = [
+		("errorCode", ctypes.c_int),
+		("count", ctypes.c_uint),
+		("algorithms", ctypes.c_int * EVE_ALGORITHMS_SIZE),
+	]
+

shared/eve_python/structs/EveCallbackReturnData.py

@@ -0,0 +1,13 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+
+
+class EveRequestedProcessingState(CtypesEnum):
+	EVE_REQUESTED_PROCESSING_STATE_CONTINUE = 0
+	EVE_REQUESTED_PROCESSING_STATE_STOP = 1
+
+class EveProcessingCallbackReturnData(ctypes.Structure):
+	_fields_ = [
+		("requestedState", ctypes.c_int),
+	]
+

shared/eve_python/structs/EveCamera.py

@@ -0,0 +1,5 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+from .EveCameraStructs import *
+
+

shared/eve_python/structs/EveCameraStructs.py

@@ -0,0 +1,27 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+from .CCameraStructs import *
+from .EveErrors import *
+
+EVE_CAMERA_FORMATS_SIZE = 20
+
+class EveCameraFormats(ctypes.Structure):
+	_fields_ = [
+		("formats", CCameraFormat * EVE_CAMERA_FORMATS_SIZE),
+		("formatsCount", ctypes.c_uint),
+		("hadMoreFormats", ctypes.c_uint),
+		("error", ctypes.c_int),
+	]
+
+class EveCamera(ctypes.Structure):
+	_fields_ = [
+		("data", CCamera),
+		("error", ctypes.c_int),
+	]
+
+class EveNumberOfCameras(ctypes.Structure):
+	_fields_ = [
+		("count", ctypes.c_uint),
+		("error", ctypes.c_int),
+	]
+

shared/eve_python/structs/EveConfigurationParameters.py

@@ -0,0 +1,36 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+
+EVE_PIPELINE_TYPE_SIZE = 2
+
+class EveImageProvider(CtypesEnum):
+	EVE_CAMERA = 0
+	EVE_CLIENT_PROVIDED = 1
+
+class EveGpuPreference(CtypesEnum):
+	EVE_GPU_LOW_POWER = 0
+	EVE_GPU_HIGH_PERFORMANCE = 1
+	EVE_NO_GPU = 2
+
+class EveStartupType(CtypesEnum):
+	EVE_SYNC = 0
+	EVE_ASYNC = 1
+
+class EveProcessingPipelineType(CtypesEnum):
+	EVE_FULL = 0
+	EVE_HMI = 1
+	EVE_PIPELINE_TYPE_SIZE = 2
+
+class EveStartupParameters(ctypes.Structure):
+	_fields_ = [
+		("gpuPreference", ctypes.c_int),
+		("imageProvider", ctypes.c_int),
+		("startupType", ctypes.c_int),
+		("pathOverride", ctypes.c_byte * 512),
+	]
+
+class EveProcessingParameters(ctypes.Structure):
+	_fields_ = [
+		("type", ctypes.c_int),
+	]
+

shared/eve_python/structs/EveControlInterface.py

@@ -0,0 +1,9 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+from .CCameraStructs import *
+from .EveCallbackReturnData import *
+from .EveConfigurationParameters import *
+from .EveErrors import *
+from .EveImageStructs import *
+
+

shared/eve_python/structs/EveControlOption.py

@@ -0,0 +1,8 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+
+
+class EveOptionEnabled(CtypesEnum):
+	EVE_OPTION_DISABLED = 0
+	EVE_OPTION_ENABLED = 1
+

shared/eve_python/structs/EveErrors.py

@@ -0,0 +1,22 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+
+
+class EveError(CtypesEnum):
+	EVE_ERROR_NO_ERROR = 0
+	EVE_ERROR_NOT_CREATED = 1
+	EVE_ERROR_NOT_STARTED = 2
+	EVE_ERROR_PIPELINE_NOT_FOUND = 3
+	EVE_ERROR_CAMERA_MANAGER_NOT_FOUND = 4
+	EVE_ERROR_NO_CALLBACK = 5
+	EVE_ERROR_NOT_ACCESSED_FROM_CALLBACK = 6
+	EVE_INVALID_IMAGE_ENCODING = 7
+	EVE_CALLBACK_WITHOUT_CONNECTING_TO_CAMERA = 8
+	EVE_CAMERA_INTERACTION_WITHOUT_CAMERA = 9
+	EVE_NO_MORE_DATA = 10
+	EVE_INVALID_CAMERA_ID = 11
+	EVE_FACE_ID_INVALID_THRESHOLD = 12
+	EVE_ERROR_NO_CAMERA_INTERACTION_WITH_CAMERA = 13
+	EVE_ERROR_NOT_IMPLEMENTED = 14
+	EVE_ERROR_UNSUPPORTED_FORMAT = 15
+

shared/eve_python/structs/EveFaceId.py

@@ -0,0 +1,5 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+from .EveFaceIdStructs import *
+
+

shared/eve_python/structs/EveFaceIdStructs.py

@@ -0,0 +1,31 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+from .CFaceIdStructs import *
+from .EveControlOption import *
+from .EveErrors import *
+
+
+class EveFaceIdCalibrationPoseMode(CtypesEnum):
+	EVE_FACEID_CALIBRATION_FRONTAL_ONLY = 1
+
+class EveFaceIdCommandStruct(ctypes.Structure):
+	_fields_ = [
+		("command", ctypes.c_int),
+		("errorCode", ctypes.c_int),
+	]
+
+class EveFaceIdOptions(ctypes.Structure):
+	_fields_ = [
+		("enabled", ctypes.c_int),
+		("calibrationPoses", ctypes.c_int),
+		("galleryPath", ctypes.c_byte * 256),
+		("threshold", ctypes.c_float),
+		("error", ctypes.c_int),
+	]
+
+class EveFaceIdData(ctypes.Structure):
+	_fields_ = [
+		("data", CFaceIdentityData),
+		("error", ctypes.c_int),
+	]
+

shared/eve_python/structs/EveFaceTracker.py

@@ -0,0 +1,5 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+from .EveFaceTrackerStructs import *
+
+

shared/eve_python/structs/EveFaceTrackerStructs.py

@@ -0,0 +1,40 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+from .CFaceData import *
+from .EveErrors import *
+
+
+class EveFaceTrackerMinimumMode(CtypesEnum):
+	EVE_FACETRACKER_MINIMUM_MODE_OFF = 0
+	EVE_FACETRACKER_MINIMUM_MODE_MINIMAL = 1
+	EVE_FACETRACKER_MINIMUM_MODE_AVERAGE = 2
+	EVE_FACETRACKER_MINIMUM_MODE_MAXIMAL = 3
+
+class EveFaceTrackerOptions(ctypes.Structure):
+	_fields_ = [
+		("faceTrackerMode", ctypes.c_int),
+		("enableEyeLandmarks", ctypes.c_uint),
+		("enable3DFaceTracking", ctypes.c_uint),
+		("enablePersonDetection", ctypes.c_uint),
+		("fitSecondaryUsers", ctypes.c_uint),
+		("error", ctypes.c_int),
+	]
+
+class EveEyes(ctypes.Structure):
+	_fields_ = [
+		("data", CEyeLandmarks),
+		("errorCode", ctypes.c_int),
+	]
+
+class EvePupils(ctypes.Structure):
+	_fields_ = [
+		("data", CPupilLandmarks),
+		("errorCode", ctypes.c_int),
+	]
+
+class EveAllFacesData(ctypes.Structure):
+	_fields_ = [
+		("faceData", ctypes.POINTER(CAllFaces)),
+		("errorCode", ctypes.c_int),
+	]
+

shared/eve_python/structs/EveFpga.py

@@ -0,0 +1,7 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+from .CFpgaData import *
+from .EveFpgaStructs import *
+from .EveImageStructs import *
+
+

shared/eve_python/structs/EveFpgaStructs.py

@@ -0,0 +1,24 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+from .CFpgaData import *
+from .EveErrors import *
+
+
+class EveFpgaOptions(ctypes.Structure):
+	_fields_ = [
+		("parameters", CFpgaParameters),
+		("error", ctypes.c_int),
+	]
+
+class EveFpgaDebugOptions(ctypes.Structure):
+	_fields_ = [
+		("enableDrawingOnImage", ctypes.c_uint),
+		("error", ctypes.c_int),
+	]
+
+class EveFpgaData(ctypes.Structure):
+	_fields_ = [
+		("data", ctypes.POINTER(CFpgaData)),
+		("error", ctypes.c_int),
+	]
+

shared/eve_python/structs/EveHandGesture.py

@@ -0,0 +1,5 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+from .EveHandGestureStructs import *
+
+

shared/eve_python/structs/EveHandGestureStructs.py

@@ -0,0 +1,48 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+from .CHandGesture import *
+from .EveControlOption import *
+from .EveErrors import *
+
+
+class EveHandGestureOptions(ctypes.Structure):
+	_fields_ = [
+		("enabled", ctypes.c_int),
+		("redetectionDelay", ctypes.c_int),
+		("async", ctypes.c_int),
+		("run", ctypes.c_int),
+		("errorCode", ctypes.c_int),
+	]
+
+class EveHandGestureData(ctypes.Structure):
+	_fields_ = [
+		("hands", ctypes.POINTER(EveHandDetections)),
+		("errorCode", ctypes.c_int),
+	]
+
+class EveStaticGestureData(ctypes.Structure):
+	_fields_ = [
+		("gestures", EveStaticGestures),
+		("errorCode", ctypes.c_int),
+	]
+
+class EveDynamicGestureData(ctypes.Structure):
+	_fields_ = [
+		("gestures", EveDynamicGestures),
+		("errorCode", ctypes.c_int),
+	]
+
+class EveStaticGestureDefinitions(ctypes.Structure):
+	_fields_ = [
+		("count", ctypes.c_uint),
+		("errorCode", ctypes.c_int),
+		("definitions", EveStaticGestureDefinition * EVE_MAX_STATIC_GESTURES),
+	]
+
+class EveDynamicGestureDefinitions(ctypes.Structure):
+	_fields_ = [
+		("count", ctypes.c_uint),
+		("errorCode", ctypes.c_int),
+		("definitions", EveDynamicGestureDefinition * EVE_DYNAMIC_GESTURE_SIZE),
+	]
+

shared/eve_python/structs/EveImage.py

@@ -0,0 +1,5 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+from .EveImageStructs import *
+
+

shared/eve_python/structs/EveImageManipulation.py

@@ -0,0 +1,5 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+from .EveImageManipulationStructs import *
+
+

shared/eve_python/structs/EveImageManipulationStructs.py

@@ -0,0 +1,12 @@
+import ctypes
+from ctypes_enum import CtypesEnum
+from .CImageManipulation import *
+from .EveErrors import *
+
+
+class EveImageManipulationOptions(ctypes.Structure):
+	_fields_ = [
+		("settings", CImageManipulationSettings),
+		("errorCode", ctypes.c_int),
+	]
+