Communitygithub.com

ComeOnOliver/skillshub

Importieren, Verarbeiten und Umzielen von Motion-Capture-Daten in Blender mit Python. Arbeiten Sie mit BVH/FBX-Mocap-Dateien, verfolgen Sie Kamera- und Objektbewegungen aus Videomaterial, lösen Sie 3D-Kamerapfade und bereinigen Sie Animationsdaten – alles über das Terminal skriptbar.

Was ist skillshub?

Dieses Skill ermöglicht es KI-Agenten, Motion-Capture-Daten (MoCap) direkt in Blender zu importieren, zu bearbeiten und umzuzielen, ohne die grafische Benutzeroberfläche zu verwenden. Es unterstützt die gängigsten Formate BVH und FBX und bietet Python-Funktionen für das Tracking von Kamera- und Objektbewegungen aus Videomaterial sowie die Bereinigung von Animationsdaten. Der Skill eignet sich besonders für Agenten, die in Pipeline-Umgebungen arbeiten, da alle Vorgänge über das Terminal und Python-Skripte gesteuert werden können. Zu den Hauptfunktionen gehören das Importieren von MoCap-Dateien, das Umzielen von Animationen zwischen verschiedenen Armaturen (z.B. von Mixamo zu Rigify), das Decimieren von Keyframes zur Reduzierung der Datenmenge, das Lösen von Kamerabewegungen aus Videomaterial sowie das Anwenden von Kamera-Tracking-Daten auf 3D-Objekte. Die bereitgestellten Codebeispiele sind direkt ausführbar und decken reale Szenarien ab, wie z.B. das Batch-Scannen einer MoCap-Bibliothek oder das Anwenden einer Animation auf einen Charakter mit anschließendem Rendern.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ComeOnOliver/skillshub/tree/HEAD/skills/TerminalSkills/skills/blender-motion-capture

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Blender Motion Capture

Übersicht

Importieren, Verarbeiten und Umzielen von Motion-Capture-Daten in Blender mit Python. Arbeiten Sie mit BVH/FBX-Mocap-Dateien, verfolgen Sie Kamera- und Objektbewegungen aus Videomaterial, lösen Sie 3D-Kamerapfade und bereinigen Sie Animationsdaten – alles über das Terminal skriptbar.

Anleitung

1. BVH-Motion-Capture-Dateien importieren

import bpy

bpy.ops.import_anim.bvh(
    filepath="/pfad/zu/mocap.bvh",
    target='ARMATURE',
    global_scale=1.0,
    frame_start=1,
    use_fps_scale=False,
    rotate_mode='NATIVE',
    axis_forward='-Z', axis_up='Y'
)

armature = bpy.context.active_object
action = armature.animation_data.action
print(f"Importiert: {armature.name}, Knochen: {len(armature.data.bones)}, Frames: {action.frame_range}")

2. FBX mit Animation importieren

bpy.ops.import_scene.fbx(
    filepath="/pfad/zu/mocap.fbx",
    use_anim=True,
    ignore_leaf_bones=True,
    automatic_bone_orientation=True,
    primary_bone_axis='Y', secondary_bone_axis='X'
)

3. Bewegung zwischen Armaturen umzielen

from mathutils import Matrix

def retarget_motion(source_armature, target_armature, bone_mapping):
    """Animation mit einer Bone-Namenszuordnung umzielen: {target_bone: source_bone}"""
    source_action = source_armature.animation_data.action
    frame_start, frame_end = int(source_action.frame_range[0]), int(source_action.frame_range[1])

    if not target_armature.animation_data:
        target_armature.animation_data_create()
    new_action = bpy.data.actions.new(f"{source_action.name}_retarget")
    target_armature.animation_data.action = new_action

    for frame in range(frame_start, frame_end + 1):
        bpy.context.scene.frame_set(frame)
        for tgt_name, src_name in bone_mapping.items():
            src = source_armature.pose.bones.get(src_name)
            tgt = target_armature.pose.bones.get(tgt_name)
            if not src or not tgt:
                continue
            tgt.rotation_quaternion = src.rotation_quaternion
            tgt.keyframe_insert(data_path="rotation_quaternion", frame=frame)
            # Position nur für den Wurzelknochen kopieren
            if src_name == list(bone_mapping.values())[0]:
                tgt.location = src.location
                tgt.keyframe_insert(data_path="location", frame=frame)

# Beispiel Mixamo → Rigify Zuordnung
mapping = {
    "spine": "mixamorig:Hips", "spine.001": "mixamorig:Spine",
    "spine.004": "mixamorig:Neck", "spine.006": "mixamorig:Head",
    "upper_arm.L": "mixamorig:LeftArm", "forearm.L": "mixamorig:LeftForeArm",
    "upper_arm.R": "mixamorig:RightArm", "forearm.R": "mixamorig:RightForeArm",
    "thigh.L": "mixamorig:LeftUpLeg", "shin.L": "mixamorig:LeftLeg",
    "thigh.R": "mixamorig:RightUpLeg", "shin.R": "mixamorig:RightLeg",
}

4. Motion-Capture-Daten bereinigen

def decimate_fcurve(fcurve, factor=0.5):
    """Keyframes entfernen, um Daten zu reduzieren, dabei die Form erhalten."""
    points = fcurve.keyframe_points
    total = len(points)
    keep_every = max(1, int(1.0 / factor))
    remove_indices = [i for i in range(total) if i % keep_every != 0 and i != 0 and i != total - 1]
    for i in reversed(remove_indices):
        points.remove(points[i])

armature = bpy.context.active_object
action = armature.animation_data.action
for fcurve in action.fcurves:
    decimate_fcurve(fcurve, factor=0.5)
    fcurve.update()

5. Video-Motion-Tracking und Kamera-Solve

# Footage laden
clip = bpy.data.movieclips.load("/pfad/zu/footage.mp4")
scene = bpy.context.scene
scene.active_clip = clip

# Tracking konfigurieren
tracking = clip.tracking
settings = tracking.settings
settings.default_pattern_size = 21
settings.default_search_size = 71
settings.default_motion_model = 'AFFINE'

# Kamera-Einstellungen für das Lösen
camera = tracking.camera
camera.sensor_width = 36.0
camera.focal_length = 50.0

# Kamerabewegung lösen
bpy.ops.clip.solve_camera()
solve_error = tracking.reconstruction.average_error
print(f"Solve-Fehler: {solve_error:.4f} px ({'Gut' if solve_error < 0.5 else 'Erfordert Nachbesserung'})")

# Szene aus gelösten Daten einrichten
bpy.ops.clip.setup_tracking_scene()

6. Verfolgte Bewegung auf Objekte anwenden

obj = bpy.data.objects["MeinObjekt"]
constraint = obj.constraints.new(type='FOLLOW_TRACK')
constraint.clip = clip
constraint.track = tracking.tracks["Marker_01"]
constraint.use_3d_position = True
constraint.camera = scene.camera

# Constraint in Keyframes backen
bpy.context.view_layer.objects.active = obj
obj.select_set(True)
bpy.ops.nla.bake(
    frame_start=1, frame_end=clip.frame_duration,
    only_selected=True, visual_keying=True,
    clear_constraints=True, bake_types={'OBJECT'}
)

7. Animationsdaten exportieren

# Als BVH exportieren
bpy.ops.export_anim.bvh(
    filepath="/tmp/output_mocap.bvh",
    frame_start=int(action.frame_range[0]),
    frame_end=int(action.frame_range[1]),
    rotate_mode='NATIVE'
)

# Als FBX mit gebackener Animation exportieren
bpy.ops.export_scene.fbx(
    filepath="/tmp/output_anim.fbx",
    use_selection=True, bake_anim=True,
    bake_anim_use_all_bones=True, add_leaf_bones=False
)

Beispiele

Beispiel 1: Batch-Scan einer Mocap-Bibliothek

Benutzeranfrage: „Alle BVH-Dateien aus einem Ordner importieren, Knochenanzahl und Framebreich auflisten"

import bpy, glob, os

for filepath in sorted(glob.glob("/pfad/zu/mocap_library/*.bvh")):
    bpy.ops.object.select_all(action='SELECT')
    bpy.ops.object.delete()
    bpy.ops.import_anim.bvh(filepath=filepath, target='ARMATURE', global_scale=0.01, frame_start=1)
    arm = bpy.context.active_object
    if arm and arm.animation_data:
        action = arm.animation_data.action
        duration = (action.frame_range[1] - action.frame_range[0]) / bpy.context.scene.render.fps
        print(f"{os.path.basename(filepath)}: {len(arm.data.bones)} Knochen, {duration:.1f}s")

Ausführen: blender --background --python scan_mocap.py

Beispiel 2: Mocap auf Charakter anwenden und rendern

Benutzeranfrage: „Eine BVH-Datei importieren, auf meinen geriggten Charakter anwenden und eine Vorschau rendern"

import bpy

bpy.ops.wm.open_mainfile(filepath="/pfad/zu/character.blend")
char_armature = bpy.data.objects["Armature"]

bpy.ops.import_anim.bvh(filepath="/pfad/zu/walk_cycle.bvh", target='ARMATURE', global_scale=0.01)
mocap_armature = bpy.context.active_object
mocap_action = mocap_armature.animation_data.action

# Aktion übertragen (funktioniert, wenn Bone-Namen übereinstimmen)
if not char_armature.animation_data:
    char_armature.animation_data_create()
char_armature.animation_data.action = mocap_action

# Temporäre Armatur entfernen, Framebreich setzen, Kamera hinzufügen, rendern
bpy.data.objects.remove(mocap_armature)
scene = bpy.context.scene
scene.frame_start, scene.frame_end = int(mocap_action.frame_range[0]), int(mocap_action.frame_range[1])
scene.render.filepath = "/tmp/mocap_preview/frame_"
bpy.ops.render.render(animation=True)

Richtlinien

  • BVH ist am einfachsten (Klartext mit Hierarchie + Bewegung). FBX unterstützt umfangreichere Daten (Blend Shapes, mehrere Takes).
  • Maßstab ist wichtig: BVH-Dateien verwenden oft Zentimeter. Setzen Sie global_scale=0.01 für cm-basierte Dateien.
  • Die Übereinstimmung der Bone-Namen ist entscheidend für das Umzielen. Erstellen Sie für jedes Quellformat ein Zuordnungswörterbuch.
  • Beim Umzielen Rotationen für alle Knochen kopieren, aber nur die Position für den Wurzel-/Hüftknochen.
  • Importierte Mocap-Daten durch Decimieren von Keyframes bereinigen – Roh-Mocap hat Keyframes für jeden Frame, was die Bearbeitung erschwert.
  • Die Qualität des Kamera-Solves hängt von der Anzahl und Verteilung der Marker ab. Verwenden Sie 8+ gut verteilte Marker, und halten Sie den Fehler unter 0,5px.
  • Verwenden Sie bpy.ops.nla.bake(), um Constraints für den Export in Keyframes umzuwandeln.
  • Exportieren Sie immer mit bake_anim=True in FBX, um NLA-Streifen und Constraints zu glätten.

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

ComeOnOliver/skillshub

Create stunning, animation-rich HTML presentations from scratch or by converting PowerPoint files. Use when the user wants to build a presentation, convert a PPT/PPTX to web, or create slides for a talk/pitch. Helps non-designers discover their aesthetic through visual exploration rather than abstract choices.

ComeOnOliver/skillshub

Next.js 16+ 和 Turbopack — 增量打包、文件系统缓存、开发速度,以及何时使用 Turbopack 与 webpack。

ComeOnOliver/skillshub

SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

ComeOnOliver/skillshub

See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio, video), and create real time alerts for events from live streams or desktop capture.

ComeOnOliver/skillshub

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

ComeOnOliver/skillshub

Next.js 15 애플리케이션을 위한 프론트엔드 개발 가이드라인. React 19, TypeScript, Shadcn/ui, Tailwind CSS를 사용한 모던 패턴. Server Components, Client Components, App Router, 파일 구조, Shadcn/ui 컴포넌트, 성능 최적화, TypeScript 모범 사례 포함. 컴포넌트, 페이지, 기능 생성, 데이터 페칭, 스타일링, 라우팅, 프론트엔드 코드 작업 시 사용.

ComeOnOliver/skillshub

Provides Tamagui patterns for config v4, compiler optimization, styled context, and cross-platform styling. Must use when working with Tamagui projects (tamagui.config.ts, @tamagui imports).

ComeOnOliver/skillshub

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

ComeOnOliver/skillshub

Create high-converting, visually distinctive landing pages. Use when building marketing pages, product launches, SaaS homepages, or any single-page conversion-focused website. Guides section-by-section composition with anti-AI-slop principles.

ComeOnOliver/skillshub

Auto-loaded context for Portfolio Buddy 2 development. Use for ANY task involving: React 19 development, TypeScript, portfolio analysis features, metrics calculations, trading strategy comparison, or working with the Portfolio Buddy 2 codebase. Contains tech stack, known issues, and architectural constraints.

ComeOnOliver/skillshub

Next.js development tooling via MCP. Inspect routes, components, build info, and debug Next.js apps. Use when working on Next.js applications, debugging routing, or inspecting app structure. NOT for general React or non-Next.js projects.

ComeOnOliver/skillshub

Implement UI using Shadcn MCP (atoms/theme) and 21st.dev MCP (complex sections). Use when adding buttons, layouts, or generating landing pages.

ComeOnOliver/skillshub

A conceptual skill for building an API client in Next.js that handles JWT tokens

ComeOnOliver/skillshub

Best practices and patterns for Next.js App Router, Server Actions, and Routing in this project.

ComeOnOliver/skillshub

The Design System, Theme, and UX rules for the Physical AI Hub.

ComeOnOliver/skillshub

Comprehensive frontend development skill for building modern, performant web applications using ReactJS, NextJS, TypeScript, Tailwind CSS. Includes component scaffolding, performance optimization, bundle analysis, and UI best practices. Use when developing frontend features, optimizing performance, implementing UI/UX designs, managing state, or reviewing frontend code.

ComeOnOliver/skillshub

This document captures learnings from fixing keyboard navigation issues when floating components (Select, DropdownMenu, Popover) have CSS open/close animations.

ComeOnOliver/skillshub

Build Next.js 16 applications with correct patterns and distinctive design. Use when creating pages, layouts, dynamic routes, upgrading from Next.js 15, or implementing proxy.ts. Covers breaking changes (async params/searchParams, Turbopack, cacheComponents) and frontend aesthetics. NOT when building non-React or backend-only applications.

ComeOnOliver/skillshub

Comprehensive Framer Motion animation library for React. Covers motion components, variants, gestures, page transitions, and scroll animations. Use when adding animations to React/Next.js applications.

ComeOnOliver/skillshub

Build interfaces that resonate, not just render. This skill enforces bold, intentional

Verwandte Skills