Skip to content

Native Windows video motion capture with ExMR, FlowHMR and GVHMR, contact correction, humanoid retargeting, and FBX/VMD export.

Python
5.6 KB
Raw Blame
"""Sequential actor work within one stage-scoped resident model session."""
from pathlib import Path
import argparse
import gc
import json
import os
import sys
import time
import traceback


def main(argv, emit):
    parser = argparse.ArgumentParser()
    parser.add_argument('stage')
    parser.add_argument('--request',type=Path,required=True)
    parser.add_argument('--project')  # Explicit routing context, validated below.
    parser.add_argument('--result')
    args = parser.parse_args(argv)
    from .queue_groups import validate,MAX_BYTES,PHASES
    if args.request.stat().st_size>MAX_BYTES:raise ValueError('Batch request is too large')
    phase,jobs = validate(json.loads(args.request.read_text(encoding='utf-8')),args.stage)
    from .compute_policy import configure_worker_cpu
    threads=configure_worker_cpu(PHASES[args.stage][phase])
    from .model_session import ModelSession,set_memory_budget
    from .storage import atomic_json
    import torch
    torch.set_num_threads(threads)
    os.environ['RGB_MOCAP_STAGE']=PHASES[args.stage][phase]
    started=time.monotonic();all_cached=True;active=None
    try:
        phases=({'gvhmr_batch':('pose','features','gvhmr'),
                 'flow_batch':('flow_features','flowhmr'),
                 'exmr_batch':('exmr_preprocess','body','hand','exmr')}[args.stage]
                if phase=='all' else (phase,))
        for phase in phases:
            os.environ['RGB_MOCAP_STAGE']=PHASES[args.stage][phase]
            with ModelSession().activate() as session:
                for index,job in enumerate(jobs,1):
                    active=job['project'];stage=PHASES[args.stage][phase]
                    emit('batch_item_start',stage=stage,phase=phase,index=index,count=len(jobs),project=str(active))
                    cached=False
                    def observe(kind,**value):
                        nonlocal cached
                        if kind=='complete':
                            cached=bool(value.get('cached',False));value['batch_inner']=True
                        if kind=='progress':value['phase']=f'{phase}:{index}:'+str(value.get('phase',value.get('message','')))
                        emit(kind,**value)
                    options=dict(force=job['force'])
                    # Reset per-actor randomness, not the loaded model or its weights.
                    torch.manual_seed(0)
                    if args.stage=='exmr_batch':
                        from . import exmr_backend as backend
                        backend.run_stage(active,stage,job['result'],observe,
                            feature_phase=phase if phase in ('body','hand') else None,**options)
                    elif args.stage=='flow_batch':
                        from . import flow_backend as backend
                        backend.run_stage(active,stage,job['result'],observe,**options)
                    elif phase in ('pose','features'):
                        import psutil
                        from .memory_mode import select_stage
                        if not torch.cuda.is_available():raise RuntimeError('GVHMR requires a supported NVIDIA CUDA GPU')
                        free,total=torch.cuda.mem_get_info();set_memory_budget(free,total)
                        select_stage('features',free+session.resident_bytes,total,0,observe)
                        from . import engines
                        # Per-file receipts permit interrupted observation phases to resume.
                        output=engines.features(active,observe,phase=phase)
                    else:
                        from . import worker
                        saved_argv=sys.argv;saved_emit=worker.emit
                        sys.argv=['mocap.worker','gvhmr','--project',str(active),'--result',job['result']]+(['--force'] if job['force'] else [])
                        worker.emit=observe
                        try:
                            code=worker.main()
                            if code:return code
                        finally:sys.argv=saved_argv;worker.emit=saved_emit
                    all_cached &= cached
                    gc.collect()
                    if torch.cuda.is_initialized():torch.cuda.empty_cache()
                    import psutil
                    emit('batch_item_done',stage=stage,project=str(active),index=index,count=len(jobs),
                         resident_models=int(session.value is not None),resident_allocated_bytes=torch.cuda.memory_allocated() if torch.cuda.is_initialized() else 0,
                         peak_cuda_allocated_bytes=torch.cuda.max_memory_allocated() if torch.cuda.is_initialized() else 0,
                         rss_bytes=psutil.Process().memory_info().rss,handles=psutil.Process().num_handles())
            emit('batch_phase_released',phase=phase,allocated_bytes=torch.cuda.memory_allocated() if torch.cuda.is_initialized() else 0)
        emit('complete',stage=args.stage,output=str(jobs[-1]['project']),cached=all_cached,elapsed=time.monotonic()-started)
        return 0
    except Exception as error:
        details=traceback.format_exc();print(details,file=sys.stderr,flush=True)
        if active is not None:
            state=json.loads((active/'project.json').read_text(encoding='utf-8'))
            state.setdefault('stages',{})[PHASES[args.stage][phase]]=dict(status='failed',error=str(error))
            atomic_json(active/'project.json',state)
            (active/(args.stage+'_error.log')).write_text(details,encoding='utf-8')
        message=str(error)
        if isinstance(error,MemoryError) or 'out of memory' in message.lower():
            from .memory_mode import GUIDANCE
            message+=' '+GUIDANCE
        emit('failed',message=message)
        return 1