cc-collection

┌─────────────────────────────────────────────────────────────────────┐
│                         cc-collection                                │
├─────────────────────────────────────────────────────────────────────┤
│  Protocol Layer          │  Fusion Layer         │  Output Layer    │
│  ┌──────────────────┐   │  ┌─────────────────┐  │  ┌────────────┐  │
│  │  MocopiParser    │───┼─▶│  FusionEngine   │──┼─▶│ To25D      │  │
│  │  (UDP/JSON)      │   │  │  (EKF per limb) │  │  │ Transform  │  │
│  └──────────────────┘   │  └─────────────────┘  │  └────────────┘  │
│  ┌──────────────────┐   │  ┌─────────────────┐  │  ┌────────────┐  │
│  │  MediaPipeParser │───┼─▶│  TemporalAlign  │──┼─▶│ To63D      │  │
│  │  (JSON/WS)       │   │  │  (Clock Sync)   │  │  │ Transform  │  │
│  └──────────────────┘   │  └─────────────────┘  │  └────────────┘  │
├─────────────────────────┴───────────────────────┴──────────────────┤
│  Bindings: Python (PyO3) │ WebAssembly │ C FFI                      │
└─────────────────────────────────────────────────────────────────────┘

[dependencies]
cc-collection = { path = "../core/cc-collection" }

# Install maturin
pip install maturin

# Build and install
cd core/cc-collection
maturin develop --features python

# Or install from wheel
maturin build --features python --release
pip install target/wheels/cc_collection-*.whl

use cc_collection::{
    FusionEngine, FusionConfig, To25DTransform,
    MocopiParser, MediaPipeParser,
};

// Create fusion engine
let config = FusionConfig::default();
let mut engine = FusionEngine::new(config);

// Create parsers
let mut mocopi_parser = MocopiParser::new();
let mut mediapipe_parser = MediaPipeParser::new();

// Process frames
let mocopi_frame = mocopi_parser.parse(&udp_packet)?;
let mediapipe_frame = mediapipe_parser.parse_json(&json_data)?;

let skeleton = engine.process_frame(
    Some(&mocopi_frame),
    Some(&mediapipe_frame),
    1.0 / 60.0,  // dt
);

// Transform to motion vector
let mut transform = To25DTransform::new(60.0);
let motion_25d = transform.transform(&skeleton, beat_phase);

import cc_collection

# Create fusion engine
engine = cc_collection.FusionEngine(session_id="dance_001")

# Process frame
skeleton = engine.process(
    mocopi_json=mocopi_data,
    mediapipe_json=mediapipe_data,
    dt=1/60
)

# Access limb data
hip_pos = skeleton.get_position("hip")        # [x, y, z]
positions = skeleton.positions_array()         # NumPy (14, 3)
quaternions = skeleton.quaternions_array()     # NumPy (14, 4)

# Transform to motion vector
transform = cc_collection.To25DTransform(frame_rate=60.0)
motion = transform.transform(skeleton, beat_phase=0.5)  # NumPy (25,)

# Validate quality
validator = cc_collection.MotionValidator()
report = validator.validate(skeleton)
print(f"Quality: {report.quality:.2f}, Valid: {report.is_valid}")

Index   Description
─────   ───────────────────────────────
0-2     Hip position (x, y, z)
3-5     Hip velocity (vx, vy, vz)
6-8     Head orientation (yaw, pitch, roll)
9-11    Left hand position relative to hip
12-14   Right hand position relative to hip
15-17   Left foot position relative to hip
18-20   Right foot position relative to hip
21-22   Arm extension (left, right) [0-1]
23      Overall confidence [0-1]
24      Beat phase [0-1]

Index   Description
─────   ───────────────────────────────
0-24    Core 25D features
25-34   Face state (10 features)
35-48   Left hand (14 features)
49-62   Right hand (14 features)

FusionConfig {
    session_id: String,           // Session identifier
    min_confidence: f32,          // Minimum confidence [0-1], default 0.3
    enable_smoothing: bool,       // Enable Kalman smoothing, default true
}

# Run all tests
cargo test

# Run with Python feature
cargo test --features python

# Run benchmarks
cargo bench

# Run specific test
cargo test fusion_engine

from cc_collection.compat import StreamProcessor

processor = StreamProcessor(
    session_id="live_session",
    min_confidence=0.6,
    enable_smoothing=True,
)

while True:
    result = processor.process_frame(
        mocopi_json=get_mocopi_data(),
        mediapipe_json=get_mediapipe_data(),
    )

    if result["is_valid"]:
        motion_vector = result["motion_25d"]
        # Send to ML model or visualization

from cc_collection.compat import TrainingDataCollector

collector = TrainingDataCollector(
    session_name="dance_training_001",
    min_quality=0.7,
    target_bpm=120.0,
)

collector.start_recording()

for frame in frame_source:
    skeleton = engine.process(frame.mocopi, frame.mediapipe)
    collector.record_frame(skeleton, frame.beat_phase, frame.quality)

collector.stop_recording()

# Export for training
data = collector.export_numpy()
np.savez("training_data.npz", **data)

from cc_collection.compat import MotionDataLoader

loader = MotionDataLoader(
    frame_rate=60.0,
    normalize=True,
    include_velocity=True,
)

for batch in loader.iter_batches(frames, batch_size=32):
    motion_vectors = batch["motion_25d"]  # (32, 25)
    positions = batch["positions"]         # (32, 14, 3)
    # Train model...