Integration Guide

The Alius Motion Capture System provides multiple integration methods, supporting seamless connection of motion capture data to your applications, game engines, or content creation tools. This document details various integration methods and best practices.

Integration Overview

Alius provides the following integration methods:

Alius Mocap Studio: Official software providing complete motion capture data processing and export functions
SDK Integration: Directly read motion capture data through C++/C#/Python SDK
Standard Protocols: Support WebSocket, UDP, TCP and other standard protocols
File Export: Export to standard formats such as BVH, FBX, CSV
VR Bridging: Directly interface with VR platforms such as SteamVR, OpenXR

Alius Mocap Studio Integration

Software Features

Alius Mocap Studio is the officially provided desktop application with features including:

Real-time motion capture preview
Recording and playback
Data filtering and smoothing
Export to standard formats
Bridging with other software

Integration with Blender

Enable “Blender Real-time Bridge” in Alius Mocap Studio
Install Alius Add-on in Blender
Start real-time data streaming, motion will be mapped to Blender characters in real-time
Can be recorded as keyframe animation or rendered directly

Integration with Unity

Import Alius Unity Package
Add AliusMocap component to the character GameObject in the scene
Configure bone mapping (supports Humanoid standard bones)
Run the scene, the character will respond to motion capture data in real-time

Integration with Unreal Engine

Search and install “Alius Mocap Plugin” in UE Marketplace
Add AliusMocap component in character blueprint
Bind to UE’s Animation Blueprint
Supports Live Link plugin, can be directly used for virtual production

SDK Integration

C++ SDK

Suitable for high-performance applications and custom integration.

Installation:

// Download SDK and include header files
#include "AliusMocap.h"

// Initialize
Alius::MocapSystem system;
system.initialize();

// Register callback
system.setOnDataReceived([](const Alius::MocapFrame& frame) {
    // Process motion capture data
    for (const auto& joint : frame.joints) {
        std::cout << joint.name << ": "
                  << joint.position.x << ", "
                  << joint.rotation.qw << std::endl;
    }
});

// Start receiving data
system.start();

Data Structures:

struct Joint {
    std::string name;
    Vector3 position;     // Position (meters)
    Quaternion rotation;  // Rotation (quaternion)
    float confidence;     // Confidence (0-1)
};

struct MocapFrame {
    uint64_t timestamp;   // Timestamp (microseconds)
    std::vector<Joint> joints;
};

C# SDK

Suitable for Unity and .NET applications.

Installation: Install via NuGet:

Install-Package Alius.Mocap

Usage Example:

using Alius.Mocap;

public class MocapReceiver : MonoBehaviour
{
    private MocapClient client;

    void Start()
    {
        client = new MocapClient();
        client.Connect("127.0.0.1", 8080);
        client.OnFrameReceived += OnMocapFrame;
    }

    void OnMocapFrame(MocapFrame frame)
    {
        foreach (var joint in frame.Joints)
        {
            // Update character bones
            Transform bone = GetBoneTransform(joint.Name);
            bone.position = joint.Position;
            bone.rotation = joint.Rotation;
        }
    }
}

Python SDK

Suitable for scientific research, data analysis, and rapid prototyping.

Installation:

pip install alius-mocap

Usage Example:

import alius_mocap as am

# Connect to Alius system
client = am.MocapClient()
client.connect()

# Receive data in real-time
for frame in client.stream_frames():
    # frame.joints is a dictionary, key is joint name
    head_pos = frame.joints['Head'].position
    left_hand_rot = frame.joints['LeftHand'].rotation

    # Process data...
    process_motion_data(frame)

# Record to file
client.record_to_bvh('output.bvh', duration=10.0)

Standard Protocol Integration

If you prefer to use standard protocols instead of SDK, Alius supports the following protocols:

WebSocket

Suitable for web applications and cross-platform integration.

Connection:

const ws = new WebSocket('ws://localhost:8080/alius');

ws.onmessage = (event) => {
    const frame = JSON.parse(event.data);
    // frame contains joints array
    updateAvatar(frame.joints);
};

Data Format:

{
    "timestamp": 1234567890,
    "joints": [
        {
            "name": "Head",
            "position": [0.0, 1.7, 0.0],
            "rotation": [1.0, 0.0, 0.0, 0.0]
        },
        ...
    ]
}

UDP

Suitable for real-time applications with low latency requirements.

Protocol Description:

Port: 8081 (configurable)
Format: Binary
Frequency: Consistent with tracking frequency (default 90 Hz)

Data Packet Structure:

[Header: 4 bytes]
  - Magic number: 0xA1A2 (2 bytes)
  - Joint count: 1 byte
  - Reserved: 1 byte

[Timestamp: 8 bytes] (microseconds)

[Joint Data: 48 bytes per joint]
  - Joint ID: 1 byte
  - Position (x, y, z): 12 bytes (float32 × 3)
  - Rotation (qw, qx, qy, qz): 16 bytes (float32 × 4)
  - Confidence: 4 bytes (float32)

VR Platform Integration

SteamVR Integration

Alius can be used as a SteamVR compatible device.

Setup Steps:

Enable “SteamVR Driver” in Alius Mocap Studio
SteamVR will automatically recognize Alius trackers
Calibrate ground height in SteamVR room setup
Launch VR applications that support full-body tracking

Notes:

Ensure no conflicts between SteamVR and other motion capture device drivers
If tracking issues occur, try reordering tracker IDs

OpenXR Integration

Alius supports the OpenXR standard and can be used with any OpenXR-compatible VR applications.

Implementation:

Through OpenXR’s XR_EXT_hand_tracking extension
Provide full-body joint data as custom extension

File Export Integration

BVH Format

Biovision Hierarchy (BVH) is the industry standard format for motion capture data.

Export Settings:

Sampling rate: Consistent with tracking frequency
Coordinate system: Y-up or Z-up can be selected
Bone naming: Follows BVH standard naming

Use Cases:

Import to DCC tools such as Maya, 3ds Max
Further processing and editing
Long-term archiving

FBX Format

Filmbox (FBX) format includes skeleton and animation data, suitable for direct use in game engines.

Export Options:

Include skeleton hierarchy
Bake animation to keyframes
Adjustable compression rate

CSV Format

Comma-Separated Values format, suitable for data analysis and custom processing.

Data Columns:

Timestamp, JointName, PosX, PosY, PosZ, RotW, RotX, RotY, RotZ

Best Practices

Performance Optimization

Reduce update frequency: If the application doesn’t need 90 Hz, it can be reduced to 60 Hz or 30 Hz
Filter joints: Only subscribe to needed joint data
Use binary format: Compared to JSON, binary format can reduce bandwidth by 80%

Data Smoothing

IMU data may contain high-frequency noise. It is recommended to:

Apply low-pass filter (cutoff frequency 10-15 Hz)
Use Exponential Moving Average (EMA)
Enable “Smoothing Mode” in Alius Mocap Studio

Coordinate System Unification

Different software use different coordinate systems:

OpenGL/Blender: Y-up, right-handed coordinate system
DirectX/Unity: Y-up, left-handed coordinate system
3ds Max: Z-up, right-handed coordinate system

Alius SDK provides coordinate conversion functions to ensure correct data mapping.

Troubleshooting

Problem: High data latency Solution: Check network settings, ensure wired connection is used; reduce tracking frequency; optimize application rendering performance

Problem: Incorrect bone mapping Solution: Recalibrate bone proportions in Alius Mocap Studio; check if character T-Pose is correct

Problem: SDK connection failure Solution: Ensure Alius Mocap Studio is running and SDK service is enabled; check firewall settings

Technical Support

For further integration support, please:

Consult SDK documentation and example code
Visit the developer forum
Contact the technical support team (support@alius-tech.com)

We provide custom integration services and can develop dedicated interfaces according to your specific needs.