Question about shifting from y up to z up

[bopeng5221]

Hi,

Great open source work on transfer bvh files to smpl files! I have some questions about how to change from y up to z up when intergrating this algorithm with the phc retargeting algorithm. My results look like this:

2025-09-08.165106.mp4

It seems that the problem comes from the up axis problem. However, when I try to solve this, multiple different problems pop up. Can you help me with the general pipeline to do this job? Like where should I change. As far as I understand, I should apply a 90 degrees rotation around the x axis to the root trans and rotation and it should be enough? However, the results are not as expected.

Best

[EmptyBlueBox]

Is this video the result after you've already converted the axis? It does look like an up-axis error.

Generally you need to do two things: apply a 90-degree rotation around the X axis to the root node's orientation, and then apply the same rotation to the root node's translation, that is, swap two of the translation coordinates.

If the result isn't as expected you can try ±90 degrees and try applying the rotation to the original Z axis to see which one works.

[bopeng5221]

I've modify your preprocess code like this:

import os
import numpy as np
import bvh_utils
from scipy.spatial.transform import Rotation as R

def decompose_rotation_with_yaxis(rotation):
    """
    This Python function decomposes a quaternion rotation into a rotation around the y-axis and a
    rotation in the xz plane with the y-axis as the rotation axis.
    
    @param rotation rotation is a quaternion representing a 3D rotation.
    
    @return The function `decompose_rotation_with_yaxis` returns the rotation `Ry` around the y-axis and
    the rotation around the axis in the xz plane, such that the original rotation `R` can be decomposed
    as `R = Ry * Rxz`.
    """
    rot = R.from_quat(rotation)  # Convert quaternion to rotation amount
    rot_matrix = rot.as_matrix()  # Calculate the rotation matrix
    y_new = (rot_matrix@np.array([0, 1, 0])).T  # Calculate the direction after rotation around the y-axis.
    y_ori = np.array([0, 1, 0]).T  # y-axis original direction
    theta_y = np.arccos(np.dot(y_new, y_ori)/(np.linalg.norm(y_new)*np.linalg.norm(y_ori)))  # Calculate the y-axis rotation angle
    rot_axis_y = np.cross(y_new, y_ori) / np.linalg.norm(np.cross(y_new, y_ori))  # Calculate the y-axis rotation axis
    Ry = R.from_rotvec(theta_y*rot_axis_y)*rot  # Calculate the y-axis rotation amount
    return Ry

cur_path= os.path.dirname(os.path.abspath(__file__))
bvh_path= cur_path+"/../bvh/"
bvh_files=["Armchair1.bvh","Desk1.bvh","Sit54.bvh"]
crop_range=[(480,680),(160,360),(100,300)]
for i in range(3):
    bvh=bvh_utils.BVHMotion(bvh_path+bvh_files[i])
    '''Capture the specified number of frames of action'''
    bvh=bvh.sub_sequence(start=crop_range[i][0],end=crop_range[i][1])

    '''Ensure the end joint of each action segment is at the origin.'''
    bvh.joint_position-=bvh.joint_position[-1] # 末尾根关节在原点
    
    '''Ensure the end joint of each action segment is oriented towards the positive direction of the x-axis.'''
    end_frame_root_rotation_y=decompose_rotation_with_yaxis(bvh.joint_rotation[-1,0])
    bvh.joint_rotation[:,0]=(end_frame_root_rotation_y.inv()*R.from_quat(bvh.joint_rotation[:,0])).as_quat()
    bvh.joint_position[:,0]=end_frame_root_rotation_y.inv().apply(bvh.joint_position[:,0])

    '''y up to z up, lift the robot up'''
    bvh.joint_position[:, 0][:, 0:3] = bvh.joint_position[:, 0][:, [0,2,1]]
    bvh.joint_position[:, 0][:, 2] += 0.6


    # Assuming your quaternion array is stored in `quats` with shape (200, 4) in xyzw order
    quats = bvh.joint_rotation[:, 0]  # Shape (200, 4) with [x, y, z, w] components

    # Create 90-degree rotation quaternion around x-axis (xyzw order)
    angle = np.pi / 2  # 90 degrees in radians
    half_angle = angle / 2
    s = np.sin(half_angle)  # sin(π/4) = √2/2
    c = np.cos(half_angle)  # cos(π/4) = √2/2

    # Extract components
    x = quats[:, 0]
    y = quats[:, 1]
    z = quats[:, 2]
    w = quats[:, 3]

    # Apply local rotation: new_quat = original_quat * rotation_quat
    # Using quaternion multiplication for xyzw order
    x_new = s * (w + x)
    y_new = s * (y + z)
    z_new = s * (z - y)
    w_new = s * (w - x)

    # Combine into new quaternion array
    new_quats = np.column_stack((x_new, y_new, z_new, w_new))

    # Normalize to maintain unit quaternions (optional but recommended)
    norms = np.linalg.norm(new_quats, axis=1)
    new_quats = new_quats / norms[:, np.newaxis]

    # Update the original array
    bvh.joint_rotation[:, 0] = new_quats
    
    bvh.print_dims()
    bvh.put_back_bvh("preprocessed")

And here's the retargeting results:

https://github.com/user-attachments/assets/bc2fa1ef-b93a-4119-b367-1d6a16eacaca
I'm not sure whether I did it correct or not. The result doesn't seems as steady and physically plausible like before. Do you have any idea on why this may happen?

[EmptyBlueBox]

It looks like your root joint translation wasn't properly converted. But I can't see where the problem is. 😢