stereo-charuco-pipeline 0.1.0__py3-none-any.whl

recorder/camera.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import re
+from typing import List
+
+from .ffmpeg import FFmpegRunner
+
+
+def list_dshow_devices() -> List[str]:
+    """
+    List DirectShow video devices on Windows using ffmpeg.
+
+    Returns a list of device names that you can pass to:
+      ffmpeg -f dshow -i video="<NAME>"
+    """
+    ffmpeg = FFmpegRunner.resolve_ffmpeg()
+    runner = FFmpegRunner()
+
+    cmd = [ffmpeg, "-hide_banner", "-list_devices", "true", "-f", "dshow", "-i", "dummy"]
+    res = runner.run_capture(cmd)
+
+    # ffmpeg prints devices to stderr in many builds
+    text = (res.stdout or "") + "\n" + (res.stderr or "")
+
+    devices: List[str] = []
+    in_video_section = False
+
+    # Typical lines:
+    # [dshow @ ...] DirectShow video devices
+    # [dshow @ ...]  "3D USB Camera"
+    for line in text.splitlines():
+        if "DirectShow video devices" in line:
+            in_video_section = True
+            continue
+        if "DirectShow audio devices" in line:
+            in_video_section = False
+            continue
+
+        if in_video_section:
+            m = re.search(r'"([^"]+)"', line)
+            if m:
+                devices.append(m.group(1))
+
+    # de-dup preserve order
+    seen = set()
+    out = []
+    for d in devices:
+        if d not in seen:
+            out.append(d)
+            seen.add(d)
+    return out

recorder/cli.py

@@ -0,0 +1,122 @@
+"""
+Command-line entry points for stereo-charuco-pipeline.
+
+After `pip install .`, these commands are available:
+  stereo-pipeline     Full workflow (Project Manager -> Calibration -> Pipeline)
+  stereo-calibrate    Calibration UI only
+  stereo-record       Pipeline UI only (record + reconstruct)
+"""
+import argparse
+import logging
+import sys
+from pathlib import Path
+
+from .paths import resolve_default_config
+
+
+def main():
+    """Full workflow: Project Manager -> Calibration UI -> Pipeline UI."""
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
+
+    parser = argparse.ArgumentParser(description="Unified Stereo Pipeline")
+    parser.add_argument(
+        "--config", type=str, default=None,
+        help="Path to YAML config file (default: built-in default.yaml)",
+    )
+    parser.add_argument(
+        "--projects-base", type=str, default=None,
+        help="Base directory for projects (default: ./projects)",
+    )
+    args = parser.parse_args()
+
+    config_path = _resolve_config(args.config)
+    projects_base = Path(args.projects_base) if args.projects_base else Path.cwd() / "projects"
+
+    # Stage 1: Project Manager
+    from .project_manager import ProjectManagerUI
+
+    pm = ProjectManagerUI(projects_base)
+    pm.mainloop()
+
+    context = pm.result
+    if context is None:
+        print("No project selected. Exiting.")
+        return
+
+    print(f"Project: {context.project_dir}")
+    print(f"  New: {context.is_new}")
+    print(f"  Needs calibration: {context.needs_calibration}")
+
+    # Stage 2: Calibration UI (if needed)
+    if context.needs_calibration:
+        print("\nOpening Calibration Recording UI...")
+        from .calibration_ui import CalibrationUI
+
+        calib_app = CalibrationUI(
+            config_path=config_path,
+            project_dir=context.project_dir,
+            on_complete=lambda: None,
+        )
+        calib_app.mainloop()
+
+    # Stage 3: Pipeline UI
+    print("\nOpening Pipeline UI...")
+    from .pipeline_ui import PipelineUI
+
+    pipeline_app = PipelineUI(
+        config_path=config_path,
+        project_dir=context.project_dir,
+    )
+    pipeline_app.mainloop()
+
+    print("\nPipeline closed.")
+
+
+def calibrate_only():
+    """Calibration UI standalone."""
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
+
+    parser = argparse.ArgumentParser(description="Stereo Calibration UI")
+    parser.add_argument("--config", type=str, default=None)
+    parser.add_argument("--project-dir", type=str, default=None)
+    args = parser.parse_args()
+
+    config_path = _resolve_config(args.config)
+
+    from .calibration_ui import CalibrationUI
+
+    app = CalibrationUI(
+        config_path=config_path,
+        project_dir=Path(args.project_dir) if args.project_dir else None,
+    )
+    app.mainloop()
+
+
+def pipeline_only():
+    """Pipeline UI standalone."""
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
+
+    parser = argparse.ArgumentParser(description="Stereo Pipeline UI")
+    parser.add_argument("--config", type=str, default=None)
+    parser.add_argument("--project-dir", type=str, default=None)
+    args = parser.parse_args()
+
+    config_path = _resolve_config(args.config)
+
+    from .pipeline_ui import PipelineUI
+
+    app = PipelineUI(
+        config_path=config_path,
+        project_dir=Path(args.project_dir) if args.project_dir else None,
+    )
+    app.mainloop()
+
+
+def _resolve_config(user_config):
+    """Resolve config path from user arg or built-in default."""
+    if user_config:
+        p = Path(user_config)
+        if not p.is_absolute():
+            p = Path.cwd() / p
+        return p
+    return resolve_default_config()

recorder/config.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, asdict
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class RecorderConfig:
+    # capture
+    device: str = "3D USB Camera"
+    size: str = "3200x1200"
+    fps: int = 60
+    seconds: int = 120
+
+    # output
+    outdir: str = "."
+    outroot: str = ""  # if empty: script decides session folder
+
+    # optional: pass-through (future)
+    extra_args: Optional[list[str]] = None
+
+    def to_args(self) -> list[str]:
+        """Convert config to CLI args that match scripts/record_and_split.py."""
+        args = [
+            "--device", self.device,
+            "--size", self.size,
+            "--fps", str(int(self.fps)),
+            "--seconds", str(int(self.seconds)),
+            "--outdir", str(self.outdir),
+        ]
+        if self.outroot:
+            args += ["--outroot", str(self.outroot)]
+        if self.extra_args:
+            args += list(self.extra_args)
+        return args
+
+    def as_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+def load_yaml_config(path: str | Path) -> Dict[str, Any]:
+    """
+    Load YAML into dict. If PyYAML isn't installed, raise a clear error.
+    """
+    path = Path(path)
+    try:
+        import yaml  # type: ignore
+    except Exception as e:
+        raise RuntimeError(
+            "PyYAML is required to load YAML config. Please `pip install pyyaml`."
+        ) from e
+
+    if not path.exists():
+        raise FileNotFoundError(f"Config not found: {path}")
+
+    with path.open("r", encoding="utf-8") as f:
+        data = yaml.safe_load(f) or {}
+    if not isinstance(data, dict):
+        raise ValueError(f"YAML root must be a mapping/dict. Got: {type(data)}")
+    return data
+
+
+def config_from_yaml(path: str | Path) -> RecorderConfig:
+    """
+    Create RecorderConfig from YAML mapping. Unknown keys are ignored (safe for future expansion).
+    """
+    data = load_yaml_config(path)
+    cfg = RecorderConfig()
+
+    for k, v in data.items():
+        if hasattr(cfg, k):
+            setattr(cfg, k, v)
+
+    return cfg

recorder/configs/default.yaml

@@ -0,0 +1,38 @@
+camera:
+  device_name: "3D USB Camera"
+  backend: "dshow"
+  video_size: "3200x1200"
+  fps: 60
+
+split:
+  full_w: 3200
+  full_h: 1200
+  xsplit: 1600
+
+recording:
+  min_seconds: 30
+  target_seconds: 120
+  default_seconds: 120
+
+output:
+  base_dir: ""
+  keep_avi: true
+
+ffmpeg:
+  executable: ""
+
+charuco:
+  columns: 10
+  rows: 16
+  board_height_cm: 80.0
+  board_width_cm: 50.0
+  dictionary: "DICT_4X4_100"
+  aruco_scale: 0.7
+  square_size_cm: 5.0
+
+mp4:
+  preset: "veryfast"
+  crf: 18
+
+project:
+  project_dir: ""

recorder/ffmpeg.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable, Optional
+
+
+LogCallback = Callable[[str], None]
+
+
+@dataclass
+class RunResult:
+    returncode: int
+    stdout: str
+    stderr: str
+    cmd: list[str]
+
+
+class FFmpegRunner:
+    """
+    Minimal runner for subprocess-based tools (ffmpeg, python scripts, etc.)
+    - supports live log streaming
+    - supports cancellation
+    """
+
+    def __init__(self, executable: Optional[str] = None):
+        self.executable = executable
+        self._proc: Optional[subprocess.Popen] = None
+
+    @classmethod
+    def resolve_ffmpeg(cls) -> str:
+        """
+        Resolve ffmpeg path:
+        1) System PATH (cross-platform)
+        2) Repo-local bin/ directory (development fallback)
+        """
+        from .paths import resolve_ffmpeg
+        return resolve_ffmpeg()
+
+    def run_capture(
+        self,
+        cmd: list[str],
+        cwd: Optional[str | Path] = None,
+        env: Optional[dict[str, str]] = None,
+        timeout: Optional[int] = None,
+    ) -> RunResult:
+        """
+        Run synchronously and capture stdout/stderr fully.
+        """
+        p = subprocess.run(
+            cmd,
+            cwd=str(cwd) if cwd else None,
+            env=env,
+            text=True,
+            capture_output=True,
+            timeout=timeout,
+        )
+        return RunResult(
+            returncode=p.returncode,
+            stdout=p.stdout or "",
+            stderr=p.stderr or "",
+            cmd=cmd,
+        )
+
+    def run_stream(
+        self,
+        cmd: list[str],
+        on_log: Optional[LogCallback] = None,
+        cwd: Optional[str | Path] = None,
+        env: Optional[dict[str, str]] = None,
+    ) -> int:
+        """
+        Run and stream combined stdout/stderr line-by-line to on_log.
+        Returns process return code.
+        """
+        # Merge env
+        merged_env = os.environ.copy()
+        if env:
+            merged_env.update(env)
+
+        self._proc = subprocess.Popen(
+            cmd,
+            cwd=str(cwd) if cwd else None,
+            env=merged_env,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+            universal_newlines=True,
+        )
+
+        assert self._proc.stdout is not None
+        for line in self._proc.stdout:
+            line = line.rstrip("\n")
+            if on_log:
+                on_log(line)
+
+        rc = self._proc.wait()
+        self._proc = None
+        return rc
+
+    def cancel(self) -> None:
+        """
+        Best-effort termination of the running process.
+        """
+        if not self._proc:
+            return
+
+        try:
+            self._proc.terminate()
+        except Exception:
+            pass
+
+        try:
+            self._proc.wait(timeout=2)
+            self._proc = None
+            return
+        except Exception:
+            pass
+
+        try:
+            self._proc.kill()
+        except Exception:
+            pass
+        finally:
+            self._proc = None
+
+
+def python_executable() -> str:
+    """
+    Always use the current interpreter (e.g. conda env) to run scripts.
+    """
+    return sys.executable

recorder/paths.py

@@ -0,0 +1,87 @@
+"""
+Centralized path resolution for the recorder package.
+
+Handles finding configs and tools in both development mode
+(running from repo clone) and installed mode (pip install).
+"""
+from __future__ import annotations
+
+import shutil
+from importlib import resources
+from pathlib import Path
+
+
+def tool_root() -> Path:
+    """Return the calib_record_tool root directory.
+
+    In dev mode (repo clone), returns the actual calib_record_tool/ dir.
+    After pip install, returns the current working directory.
+    """
+    dev = _dev_root()
+    return dev if dev else Path.cwd()
+
+
+def _dev_root() -> Path | None:
+    """Return calib_record_tool/ root if running from a repo clone."""
+    # __file__ = .../calib_record_tool/src/recorder/paths.py
+    candidate = Path(__file__).resolve().parents[2]
+    if (candidate / "configs" / "default.yaml").exists():
+        return candidate
+    return None
+
+
+def resolve_default_config() -> Path:
+    """Find the default.yaml config file.
+
+    Search order:
+      1. Package data (recorder/configs/default.yaml) — works after pip install
+      2. Repo layout (calib_record_tool/configs/default.yaml) — works in dev
+    """
+    # Try package data first (works after pip install from wheel)
+    try:
+        pkg_configs = resources.files("recorder") / "configs" / "default.yaml"
+        p = Path(str(pkg_configs))
+        if p.exists():
+            return p
+    except (TypeError, FileNotFoundError, AttributeError):
+        pass
+
+    # Fallback: repo layout
+    dev = _dev_root()
+    if dev:
+        p = dev / "configs" / "default.yaml"
+        if p.exists():
+            return p
+
+    raise FileNotFoundError(
+        "Cannot find default.yaml config. "
+        "Pass --config explicitly or run from the repo directory."
+    )
+
+
+def resolve_ffmpeg() -> str:
+    """Find ffmpeg executable.
+
+    Search order:
+      1. System PATH (preferred — works cross-platform)
+      2. Repo-local bin/ directory (development fallback)
+    """
+    # System PATH first
+    which = shutil.which("ffmpeg")
+    if which:
+        return which
+
+    # Dev fallback: bin/ffmpeg/ffmpeg.exe
+    dev = _dev_root()
+    if dev:
+        local = dev / "bin" / "ffmpeg" / "ffmpeg.exe"
+        if local.exists():
+            return str(local)
+
+    raise FileNotFoundError(
+        "ffmpeg not found. Install ffmpeg and ensure it is on your PATH.\n"
+        "  Windows:  winget install ffmpeg  OR  choco install ffmpeg\n"
+        "  Linux:    sudo apt install ffmpeg\n"
+        "  macOS:    brew install ffmpeg\n"
+        "  Conda:    conda install -c conda-forge ffmpeg"
+    )