stereo-charuco-pipeline 0.1.0__tar.gz

stereo_charuco_pipeline-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: stereo-charuco-pipeline
+Version: 0.1.0
+Summary: Stereo ChArUco 3D motion capture pipeline with auto-calibration
+Requires-Python: <3.13,>=3.10
+Requires-Dist: caliscope>=0.6.9
+Requires-Dist: matplotlib>=3.7.0
+Requires-Dist: opencv-contrib-python>=4.8.0.74
+Requires-Dist: pillow>=10.0.0
+Requires-Dist: pyyaml>=6.0

stereo_charuco_pipeline-0.1.0/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: "../../projects/caliscope/caliscope_project/recordings"
+  keep_avi: true
+
+ffmpeg:
+  executable: "bin/ffmpeg/ffmpeg.exe"
+
+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: "../../projects/caliscope/caliscope_project"

stereo_charuco_pipeline-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "stereo-charuco-pipeline"
+version = "0.1.0"
+description = "Stereo ChArUco 3D motion capture pipeline with auto-calibration"
+requires-python = ">=3.10,<3.13"
+
+dependencies = [
+    "caliscope>=0.6.9",
+    "pyyaml>=6.0",
+    "opencv-contrib-python>=4.8.0.74",
+    "Pillow>=10.0.0",
+    "matplotlib>=3.7.0",
+]
+
+[project.scripts]
+stereo-pipeline = "recorder.cli:main"
+stereo-calibrate = "recorder.cli:calibrate_only"
+stereo-record = "recorder.cli:pipeline_only"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/recorder"]
+
+[tool.hatch.build.targets.wheel.sources]
+"src" = ""
+
+[tool.hatch.build.targets.sdist]
+exclude = [
+    "bin/**",
+    "_test/**",
+    "**/*.mp4",
+    "**/*.avi",
+]

stereo_charuco_pipeline-0.1.0/requirements.txt

@@ -0,0 +1,4 @@
+caliscope==0.6.9
+pyyaml==6.0.2
+opencv-python>=4.8.0
+Pillow>=10.0.0

stereo_charuco_pipeline-0.1.0/scripts/_test_config.py

@@ -0,0 +1,32 @@
+"""Quick test: verify AutoCalibConfig from YAML."""
+import sys
+from pathlib import Path
+
+tool_root = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(tool_root / "src"))
+
+from recorder.auto_calibrate import AutoCalibConfig
+from recorder.config import load_yaml_config
+
+yaml_data = load_yaml_config(tool_root / "configs" / "default.yaml")
+project_dir = Path(r"D:\partition3\PHD_reserch\stereo-charuco-3d-pipeline\projects\caliscope\caliscope_project")
+config = AutoCalibConfig.from_yaml(yaml_data, project_dir)
+
+print(f"project_dir: {config.project_dir}")
+print(f"charuco: {config.charuco_columns}x{config.charuco_rows}")
+print(f"image_size: {config.image_size}")
+print(f"ports: {config.ports}")
+print(f"board: {config.board_width_cm}x{config.board_height_cm}cm")
+print(f"dictionary: {config.dictionary}")
+print(f"square_size: {config.square_size_cm}cm")
+
+# Verify video files exist
+intrinsic_dir = config.project_dir / "calibration" / "intrinsic"
+extrinsic_dir = config.project_dir / "calibration" / "extrinsic"
+for port in config.ports:
+    i_path = intrinsic_dir / f"port_{port}.mp4"
+    e_path = extrinsic_dir / f"port_{port}.mp4"
+    print(f"port_{port} intrinsic: {'OK' if i_path.exists() else 'MISSING'} ({i_path})")
+    print(f"port_{port} extrinsic: {'OK' if e_path.exists() else 'MISSING'} ({e_path})")
+
+print("\nAll checks passed!")

stereo_charuco_pipeline-0.1.0/scripts/_test_full_pipeline.py

@@ -0,0 +1,101 @@
+"""Test: run the full auto-calibration pipeline end-to-end."""
+import sys
+import logging
+import time
+from pathlib import Path
+
+logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
+
+tool_root = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(tool_root / "src"))
+
+from recorder.auto_calibrate import AutoCalibConfig, run_auto_calibration
+from recorder.config import load_yaml_config
+
+yaml_data = load_yaml_config(tool_root / "configs" / "default.yaml")
+project_dir = Path(r"D:\partition3\PHD_reserch\stereo-charuco-3d-pipeline\projects\caliscope\caliscope_project")
+config = AutoCalibConfig.from_yaml(yaml_data, project_dir)
+
+print("=" * 60)
+print("FULL AUTO-CALIBRATION PIPELINE TEST")
+print("=" * 60)
+print(f"Project dir: {config.project_dir}")
+print(f"Charuco: {config.charuco_columns}x{config.charuco_rows}")
+print(f"Image size: {config.image_size}")
+print(f"Ports: {config.ports}")
+print(f"Intrinsic subsample: {config.intrinsic_subsample}")
+print(f"Extrinsic subsample: {config.extrinsic_subsample}")
+print()
+
+# Verify all required videos exist
+intrinsic_dir = config.project_dir / "calibration" / "intrinsic"
+extrinsic_dir = config.project_dir / "calibration" / "extrinsic"
+all_ok = True
+for port in config.ports:
+    i_path = intrinsic_dir / f"port_{port}.mp4"
+    e_path = extrinsic_dir / f"port_{port}.mp4"
+    i_ok = i_path.exists()
+    e_ok = e_path.exists()
+    print(f"  port_{port} intrinsic: {'OK' if i_ok else 'MISSING'}")
+    print(f"  port_{port} extrinsic: {'OK' if e_ok else 'MISSING'}")
+    if not i_ok or not e_ok:
+        all_ok = False
+
+if not all_ok:
+    print("\nERROR: Missing video files! Cannot run full pipeline test.")
+    sys.exit(1)
+
+print("\nStarting pipeline...")
+start_time = time.time()
+
+
+def progress_callback(stage, msg, pct):
+    elapsed = time.time() - start_time
+    print(f"  [{elapsed:6.1f}s] [{stage:15s}] ({pct:3d}%) {msg}")
+
+
+result = run_auto_calibration(config, on_progress=progress_callback)
+
+elapsed = time.time() - start_time
+print()
+print("=" * 60)
+print(f"Pipeline finished in {elapsed:.1f}s")
+print(f"Success: {result.success}")
+
+if not result.success:
+    print(f"ERROR: {result.error_message}")
+    sys.exit(1)
+
+print(f"\nIntrinsic RMSE:")
+for port, rmse in result.intrinsic_rmse.items():
+    print(f"  Port {port}: {rmse:.3f}px")
+
+print(f"\nExtrinsic cost: {result.extrinsic_cost:.4f}")
+print(f"Origin sync index: {result.origin_sync_index}")
+
+print(f"\nCamera array ({len(result.camera_array.cameras)} cameras):")
+for port, cam in result.camera_array.cameras.items():
+    print(f"  Port {port}:")
+    print(f"    Size: {cam.size}")
+    print(f"    Matrix:\n      {cam.matrix}")
+    print(f"    Distortions: {cam.distortions}")
+    if cam.translation is not None:
+        print(f"    Translation: {cam.translation.flatten()}")
+    if cam.rotation is not None:
+        print(f"    Rotation: {cam.rotation.flatten()}")
+
+# Verify saved files
+print("\nVerifying saved files:")
+saved_files = [
+    project_dir / "charuco.toml",
+    project_dir / "camera_array.toml",
+    extrinsic_dir / "frame_timestamps.csv",
+    extrinsic_dir / "CHARUCO" / "image_points.csv",
+    extrinsic_dir / "CHARUCO" / "camera_array.toml",
+    extrinsic_dir / "CHARUCO" / "world_points.csv",
+]
+for f in saved_files:
+    status = "OK" if f.exists() else "MISSING"
+    print(f"  {f.name}: {status}")
+
+print("\nFull pipeline test PASSED!")

stereo_charuco_pipeline-0.1.0/scripts/_test_intrinsic.py

@@ -0,0 +1,80 @@
+"""Test: verify charuco detection + intrinsic calibration pipeline."""
+import sys
+import logging
+from pathlib import Path
+
+logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
+
+tool_root = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(tool_root / "src"))
+
+from recorder.auto_calibrate import (
+    AutoCalibConfig,
+    _collect_charuco_points_from_video,
+    _build_image_points_from_packets,
+)
+from recorder.config import load_yaml_config
+from caliscope.core.charuco import Charuco
+from caliscope.trackers.charuco_tracker import CharucoTracker
+from caliscope.cameras.camera_array import CameraData
+from caliscope.core.calibrate_intrinsics import run_intrinsic_calibration
+
+yaml_data = load_yaml_config(tool_root / "configs" / "default.yaml")
+project_dir = Path(r"D:\partition3\PHD_reserch\stereo-charuco-3d-pipeline\projects\caliscope\caliscope_project")
+config = AutoCalibConfig.from_yaml(yaml_data, project_dir)
+
+print("Creating charuco + tracker...")
+charuco = Charuco(
+    columns=config.charuco_columns,
+    rows=config.charuco_rows,
+    board_height=config.board_height_cm,
+    board_width=config.board_width_cm,
+    dictionary=config.dictionary,
+    units=config.units,
+    aruco_scale=config.aruco_scale,
+    square_size_overide_cm=config.square_size_cm,
+)
+tracker = CharucoTracker(charuco)
+print(f"Charuco board: {charuco.columns}x{charuco.rows}, square_size={charuco.square_size_overide_cm}cm")
+
+# Test charuco detection on port 1 intrinsic video (subsample=50 for speed)
+intrinsic_dir = config.project_dir / "calibration" / "intrinsic"
+port = 1
+
+print(f"\nCollecting charuco points from port {port} (subsample=50 for test)...")
+collected = _collect_charuco_points_from_video(
+    intrinsic_dir, port, tracker, subsample=50,
+)
+print(f"Collected {len(collected)} frames with detections")
+
+if not collected:
+    print("ERROR: No charuco corners detected!")
+    sys.exit(1)
+
+# Show sample detection
+first_frame_idx, first_points = collected[0]
+print(f"First detection at frame {first_frame_idx}: {len(first_points.point_id)} corners")
+print(f"  point_ids: {first_points.point_id[:5]}...")
+print(f"  img_loc shape: {first_points.img_loc.shape}")
+print(f"  obj_loc shape: {first_points.obj_loc.shape if first_points.obj_loc is not None else 'None'}")
+
+# Build ImagePoints
+print("\nBuilding ImagePoints DataFrame...")
+image_points = _build_image_points_from_packets(collected, port)
+print(f"ImagePoints: {len(image_points.df)} rows")
+print(f"Columns: {list(image_points.df.columns)}")
+print(f"Unique sync_indices: {image_points.df['sync_index'].nunique()}")
+
+# Run intrinsic calibration
+print("\nRunning intrinsic calibration...")
+camera = CameraData(port=port, size=config.image_size, rotation_count=0)
+output = run_intrinsic_calibration(camera, image_points)
+
+print(f"\nCalibration result for port {port}:")
+print(f"  RMSE: {output.report.rmse:.3f}px")
+print(f"  Frames used: {output.report.frames_used}")
+print(f"  Coverage: {output.report.coverage_fraction:.0%}")
+print(f"  Matrix:\n    {output.camera.matrix}")
+print(f"  Distortions: {output.camera.distortions}")
+
+print("\nIntrinsic calibration test PASSED!")

stereo_charuco_pipeline-0.1.0/scripts/convert_to_mp4.py

@@ -0,0 +1,128 @@
+import argparse
+import os
+import subprocess
+import sys
+
+try:
+    import yaml
+except ImportError:
+    yaml = None
+
+
+def _load_yaml(path: str) -> dict:
+    if not path:
+        return {}
+    if yaml is None:
+        raise RuntimeError("PyYAML is not installed. Please: pip install pyyaml")
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"Config file not found: {path}")
+    with open(path, "r", encoding="utf-8") as f:
+        data = yaml.safe_load(f) or {}
+    if not isinstance(data, dict):
+        raise ValueError("Config YAML root must be a mapping (dict).")
+    return data
+
+
+def _get(cfg: dict, keys: list, default=None):
+    cur = cfg
+    for k in keys:
+        if not isinstance(cur, dict) or k not in cur:
+            return default
+        cur = cur[k]
+    return cur
+
+
+def _resolve_tool_root() -> str:
+    return os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+
+
+def _resolve_ffmpeg(ffmpeg_exe: str, tool_root: str) -> str:
+    if not ffmpeg_exe:
+        return "ffmpeg"
+    if os.path.isabs(ffmpeg_exe):
+        return ffmpeg_exe
+    candidate = os.path.abspath(os.path.join(tool_root, ffmpeg_exe))
+    if os.path.exists(candidate):
+        return candidate
+    return ffmpeg_exe
+
+
+def run():
+    ap = argparse.ArgumentParser(description="Convert AVI (MJPEG) to MP4 (H.264). Supports configs/default.yaml.")
+    ap.add_argument("--config", default="configs/default.yaml", help="path to YAML config (relative to tool root ok)")
+
+    ap.add_argument("--in", dest="inp", required=True, help="input AVI path")
+    ap.add_argument("--out", required=True, help="output MP4 path")
+
+    ap.add_argument("--ffmpeg", default=None, help="ffmpeg executable or relative path")
+    ap.add_argument("--preset", default=None, help="x264 preset")
+    ap.add_argument("--crf", type=int, default=None, help="x264 CRF (lower=better)")
+
+    args = ap.parse_args()
+
+    tool_root = _resolve_tool_root()
+
+    cfg_path = args.config
+    if cfg_path and not os.path.isabs(cfg_path):
+        cfg_path = os.path.join(tool_root, cfg_path)
+    cfg = _load_yaml(cfg_path)
+
+    cfg_ffmpeg = _get(cfg, ["ffmpeg", "executable"], "ffmpeg")
+    cfg_ffmpeg = _resolve_ffmpeg(cfg_ffmpeg, tool_root)
+
+    cfg_preset = _get(cfg, ["mp4", "preset"], _get(cfg, ["encode", "preset"], "veryfast"))
+    cfg_crf = int(_get(cfg, ["mp4", "crf"], _get(cfg, ["encode", "crf"], 18)))
+
+    ffmpeg_exe = args.ffmpeg if args.ffmpeg is not None else cfg_ffmpeg
+    ffmpeg_exe = _resolve_ffmpeg(ffmpeg_exe, tool_root)
+
+    preset = args.preset if args.preset is not None else cfg_preset
+    crf = args.crf if args.crf is not None else cfg_crf
+
+    inp = args.inp
+    outp = args.out
+
+    # resolve output directory
+    outdir = os.path.dirname(os.path.abspath(outp))
+    if outdir:
+        os.makedirs(outdir, exist_ok=True)
+
+    cmd = [
+        ffmpeg_exe, "-hide_banner", "-y",
+        "-i", inp,
+        "-c:v", "libx264", "-preset", preset, "-crf", str(crf),
+        "-pix_fmt", "yuv420p",
+        outp
+    ]
+
+    print("=== Effective Settings ===")
+    print(f"config : {cfg_path}")
+    print(f"ffmpeg : {ffmpeg_exe}")
+    print(f"preset: {preset}")
+    print(f"crf   : {crf}")
+    print(f"in    : {inp}")
+    print(f"out   : {outp}")
+    print("==========================")
+
+    print("[INFO] Converting AVI -> MP4 (H.264).")
+    print("[INFO] Command:")
+    print("       " + " ".join(cmd))
+
+    r = subprocess.run(cmd, check=False)
+    if r.returncode != 0:
+        print(f"[ERROR] convert failed, code={r.returncode}")
+        sys.exit(r.returncode)
+
+    print("[INFO] Done.")
+    print(outp)
+
+
+if __name__ == "__main__":
+    try:
+        run()
+    except FileNotFoundError:
+        print("[ERROR] ffmpeg not found. Check default.yaml ffmpeg.executable or pass --ffmpeg.")
+        sys.exit(1)
+    except Exception as e:
+        print(f"[ERROR] {e}")
+        sys.exit(1)

stereo_charuco_pipeline-0.1.0/scripts/probe_camera.py

@@ -0,0 +1,110 @@
+import cv2
+import time
+
+def fourcc_to_str(v):
+    v = int(v)
+    return "".join([chr((v >> 8 * i) & 0xFF) for i in range(4)])
+
+def probe_camera_force(
+    camera_index=1,
+    backend=cv2.CAP_DSHOW,
+    req_w=3200,
+    req_h=1200,
+    req_fps=60,
+    req_fourcc="MJPG",
+    probe_seconds=5.0,
+    warmup_seconds=0.7,
+):
+    print("=== Camera Probe (Forced Mode) ===")
+    print(f"camera_index = {camera_index}")
+    print(f"backend      = {backend}")
+    print(f"request      = {req_w}x{req_h} @ {req_fps}fps, FOURCC={req_fourcc}")
+
+    cap = cv2.VideoCapture(camera_index, backend)
+    if not cap.isOpened():
+        print("[ERROR] Cannot open camera")
+        return
+
+    # Force codec (critical for your camera to reach 3200x1200@60)
+    cap.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc(*req_fourcc))
+    cap.set(cv2.CAP_PROP_FRAME_WIDTH, req_w)
+    cap.set(cv2.CAP_PROP_FRAME_HEIGHT, req_h)
+    cap.set(cv2.CAP_PROP_FPS, req_fps)
+
+    # Read one frame to finalize negotiation
+    ok, frame = cap.read()
+    if not ok:
+        print("[ERROR] Cannot read frame after setting properties")
+        cap.release()
+        return
+
+    H, W = frame.shape[:2]
+    got_fps = cap.get(cv2.CAP_PROP_FPS)
+    got_fourcc = fourcc_to_str(cap.get(cv2.CAP_PROP_FOURCC))
+
+    print(f"[NEGOTIATED] size   = {W} x {H}")
+    print(f"[NEGOTIATED] fps    = {got_fps} (often 0.0 on some drivers; measured fps below is more reliable)")
+    print(f"[NEGOTIATED] fourcc = {got_fourcc}")
+
+    print("[INFO] Probing... press 'q' to quit")
+
+    t0 = time.perf_counter()
+    n_total = 0
+    n_measured = 0
+    t_measure_start = None
+
+    while True:
+        ok, frame = cap.read()
+        if not ok:
+            print("[WARN] Frame read failed")
+            break
+
+        n_total += 1
+        now = time.perf_counter()
+        elapsed = now - t0
+
+        # Warmup: ignore initial frames for FPS measurement
+        if elapsed >= warmup_seconds:
+            if t_measure_start is None:
+                t_measure_start = now
+            n_measured += 1
+
+        # Draw split line
+        mid_x = frame.shape[1] // 2
+        cv2.line(frame, (mid_x, 0), (mid_x, frame.shape[0]-1), (0, 255, 0), 2)
+
+        # Overlay
+        cv2.putText(frame, f"{frame.shape[1]}x{frame.shape[0]} total={n_total}",
+                    (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (255, 255, 255), 2)
+
+        cv2.imshow("Camera Probe Forced (press q)", frame)
+
+        if cv2.waitKey(1) & 0xFF == ord("q"):
+            break
+
+        if elapsed >= probe_seconds:
+            break
+
+    if t_measure_start is not None:
+        t_end = time.perf_counter()
+        measured_fps = n_measured / max(t_end - t_measure_start, 1e-6)
+        print(f"[MEASURED] FPS ~ {measured_fps:.2f}  (after {warmup_seconds:.1f}s warmup)")
+    else:
+        print("[MEASURED] Not enough time to measure FPS (warmup too long or too short probe)")
+
+    cap.release()
+    cv2.destroyAllWindows()
+    print("=== Probe Finished ===")
+
+
+if __name__ == "__main__":
+    # 你已经确认 FFmpeg 列表支持 3200x1200 mjpeg 60fps，所以这里直接按该模式 probe
+    probe_camera_force(
+        camera_index=1,
+        backend=cv2.CAP_DSHOW,
+        req_w=3200,
+        req_h=1200,
+        req_fps=60,
+        req_fourcc="MJPG",
+        probe_seconds=5.0,
+    )