Datasets:

AIGeeksGroup
/

PhysicalWM

import bpy
import bmesh
import os
import numpy as np
import torch
import math
import mathutils
from mathutils import Vector
import imageio
import imageio.v3 as iio
import glob

def clear_scene():
    """Clear the current scene."""
    bpy.ops.wm.read_homefile(use_empty=True)
    for obj in bpy.data.objects:
        bpy.data.objects.remove(obj, do_unlink=True)

def import_glb(filepath):
    """Import GLB/GLTF file and return mesh objects."""
    bpy.ops.import_scene.gltf(filepath=filepath)
    mesh_objects = [obj for obj in bpy.context.scene.objects if (obj.type == 'MESH' and obj.name != 'Cube' and obj.name != 'Icosphere')]
    if not mesh_objects:
        raise ValueError("No mesh objects found")
    for obj in mesh_objects:
        if obj.animation_data:
            obj.animation_data_clear()
        if obj.data.shape_keys:
            obj.shape_key_clear()
        bpy.context.view_layer.objects.active = obj
        bpy.ops.object.transform_apply(location=True, rotation=True, scale=True)
    print(f"Loaded {len(mesh_objects)} mesh objects")
    for mesh_obj in mesh_objects:
        print(f"Mesh: {mesh_obj.name}, Vertices: {len(mesh_obj.data.vertices)}")
    return mesh_objects

def import_fbx(filepath):
    """Import FBX file and align to trimesh coordinate system."""
    bpy.ops.import_scene.fbx(filepath=filepath)
    mesh_objects = [obj for obj in bpy.context.scene.objects if (obj.type == 'MESH' and obj.name != 'Cube' and obj.name != 'Icosphere')]
    if not mesh_objects:
        raise ValueError("No mesh objects found")
    for obj in mesh_objects:
        if obj.animation_data:
            obj.animation_data_clear()
        if obj.data.shape_keys:
            obj.shape_key_clear()
        bpy.context.view_layer.objects.active = obj
        bpy.ops.object.transform_apply(location=True, rotation=True, scale=True)
        bpy.ops.object.transform_apply(location=True, rotation=True, scale=True)
    print(f"Loaded {len(mesh_objects)} mesh objects from FBX")
    for mesh_obj in mesh_objects:
        print(f"Mesh: {mesh_obj.name}, Vertices: {len(mesh_obj.data.vertices)}")
    return mesh_objects

def get_mesh_vertices(mesh_obj):
    """Extract vertex coordinates from a mesh object."""
    vertices = []
    for vertex in mesh_obj.data.vertices:
        vertices.append([vertex.co[0], vertex.co[1], vertex.co[2]])
    return np.array(vertices)

def get_all_vertices(mesh_objects):
    """Extract vertex coordinates from multiple mesh objects."""
    all_vertices = []
    for mesh_obj in mesh_objects:
        vertices = get_mesh_vertices(mesh_obj)
        all_vertices.append(torch.from_numpy(vertices))
    return all_vertices

def get_mesh_faces(mesh_obj):
    """Extract face indices from a mesh object."""
    faces = []
    for face in mesh_obj.data.polygons:
        faces.append(list(face.vertices))
    return np.array(faces)

def get_all_faces(mesh_objects):
    """Extract face indices from multiple mesh objects, adjusting vertex indices for merged meshes."""
    all_faces = []
    vertex_count = 0
    for mesh_obj in mesh_objects:
        faces = get_mesh_faces(mesh_obj)
        if len(all_faces) > 0:
            faces = faces + vertex_count
        all_faces.append(torch.from_numpy(faces))
        vertex_count += len(mesh_obj.data.vertices)
    return all_faces

def move_vertices_with_trajectory(mesh_obj, frame, trajectories):
    """Move mesh vertices according to trajectory data for a specific frame."""
    bpy.context.view_layer.objects.active = mesh_obj
    bpy.ops.object.mode_set(mode='OBJECT')
    if mesh_obj.data.shape_keys is None:
        basis = mesh_obj.shape_key_add(name='Basis')
        basis.interpolation = 'KEY_LINEAR'  
    
    bpy.context.scene.frame_set(frame)
    shape_key_name = f"Frame_{frame}"
    shape_key = mesh_obj.data.shape_keys.key_blocks.get(shape_key_name)
    if not shape_key:
        shape_key = mesh_obj.shape_key_add(name=shape_key_name)
        shape_key.interpolation = 'KEY_LINEAR'
    if hasattr(trajectories[frame], 'numpy'):
        positions = trajectories[frame].numpy()
    else:
        positions = trajectories[frame]
    for idx, pos in enumerate(positions):
        shape_key.data[idx].co = Vector(pos)
    
    shape_key.value = 1.0
    shape_key.keyframe_insert(data_path="value", frame=frame)
    if frame > 0:
        shape_key.value = 0.0
        shape_key.keyframe_insert(data_path="value", frame=frame - 1)

def drive_mesh_with_trajs_frames(mesh_objects, trajs, output_dir, azi=0.0, ele=0.0, export_format="fbx"):
    """Drive mesh animation with trajectory data and optionally export to various formats."""
    try:
        print(output_dir)
        os.makedirs(output_dir, exist_ok=True)
        print("Setting up animations for all meshes...")
        for i in range(len(mesh_objects)):
            mesh_obj = mesh_objects[i]
            traj = trajs[i]
            num_frames = traj.shape[0]
            print(traj.shape)
            print(traj.max(), traj.min())
            for frame in range(num_frames):
                move_vertices_with_trajectory(mesh_obj, frame, traj)
            # Insert all keyframes first
            for frame in range(num_frames):
                for shape_key in mesh_obj.data.shape_keys.key_blocks[1:]:
                    shape_key.value = 0
                    shape_key.keyframe_insert("value", frame=frame)
                
                current_shape_key = mesh_obj.data.shape_keys.key_blocks[f"Frame_{frame}"]
                current_shape_key.value = 1
                current_shape_key.keyframe_insert("value", frame=frame)
            
            # Set interpolation to CONSTANT for all keyframes at once (AFTER all keyframes are inserted)
            if mesh_obj.data.shape_keys.animation_data and mesh_obj.data.shape_keys.animation_data.action:
                fcurves = mesh_obj.data.shape_keys.animation_data.action.fcurves
                for fc in fcurves:
                    for kf in fc.keyframe_points:
                        kf.interpolation = 'CONSTANT'
            
        print("Setting up scene...")
        bpy.context.scene.frame_start = 0
        bpy.context.scene.frame_end = trajs.shape[1] - 1
        if export_format != "none":
            print(f"Exporting animated mesh to {export_format.upper()} format...")
            bpy.ops.object.select_all(action='DESELECT')
            for obj in mesh_objects:
                obj.select_set(True)
            filename = os.path.basename(output_dir)
            export_path = os.path.join(os.path.dirname(output_dir), f"{filename}.{export_format}")
            if export_format == "abc":
                bpy.ops.wm.alembic_export(
                    filepath=export_path,
                    start=bpy.context.scene.frame_start,
                    end=bpy.context.scene.frame_end,
                    selected=True,
                    uvs=True,           
                    face_sets=True      
                )
            elif export_format == "fbx":
                # Optimized FBX export for shape key animations
                bpy.ops.export_scene.fbx(
                    filepath=export_path,
                    use_selection=True,
                    bake_anim=True,
                    bake_anim_use_all_bones=False,
                    bake_anim_use_nla_strips=False,
                    bake_anim_use_all_actions=False,
                    bake_anim_force_startend_keying=False,  # Disabled: not needed for shape keys
                    bake_anim_step=1.0,  # Set to 1.0 to bake only existing keyframes
                    bake_anim_simplify_factor=0.0,  # Disable simplification for speed
                    add_leaf_bones=False,
                    path_mode='COPY',
                    embed_textures=True,
                    use_mesh_modifiers=True,
                    use_mesh_edges=True,
                    use_tspace=True,
                    use_custom_props=True,
                    use_active_collection=False,
                )
            elif export_format == "glb":
                bpy.ops.export_scene.gltf(
                    filepath=export_path,
                    use_selection=True,
                    export_format='GLB',
                    export_animations=True,
                    export_frame_range=True,
                )
            print(f"Successfully exported animated mesh to: {export_path}")
            bpy.ops.object.select_all(action='DESELECT')
    except Exception as e:
        print(f"Error occurred: {str(e)}")
        raise

def move_vertices_with_trajectory_gt(mesh_obj, frame, trajectories):
    """Move mesh vertices according to ground truth trajectory data for a specific frame."""
    bpy.context.view_layer.objects.active = mesh_obj
    bpy.ops.object.mode_set(mode='OBJECT')
    if mesh_obj.data.shape_keys is None:
        basis = mesh_obj.shape_key_add(name='Basis')
        basis.interpolation = 'KEY_LINEAR'  
    
    shape_key_name = f"Frame_{frame}"
    shape_key = mesh_obj.data.shape_keys.key_blocks.get(shape_key_name)
    if not shape_key:
        shape_key = mesh_obj.shape_key_add(name=shape_key_name)
        shape_key.interpolation = 'KEY_LINEAR'
    if hasattr(trajectories[frame], 'numpy'):
        positions = trajectories[frame].numpy()
    else:
        positions = trajectories[frame]
    for idx, pos in enumerate(positions):
        shape_key.data[idx].co = Vector(pos)

def drive_mesh_with_trajs_frames_gt(mesh_objects, trajs, output_dir, azi=0.0, ele=0.0, export_format="glb"):
    """
    Drive mesh animation by merging multiple meshes into one and using shape keys.
    This approach is most compatible with GLB export as it only requires handling a single object.
    
    Args:
        mesh_objects: List of Blender mesh objects
        trajs: Trajectory data with shape (1, T, N, 3), where N is the total number of vertices
        output_dir: Output directory
        export_format: Export format ('glb', 'fbx', 'abc', 'none')
    """
    try:
        print(output_dir)
        os.makedirs(output_dir, exist_ok=True)
        print("Setting up animations for all meshes (V2 - Merged Mesh with Shape Keys)...")
        
        vertex_counts = []
        for mesh_obj in mesh_objects:
            vertex_counts.append(len(mesh_obj.data.vertices))
        
        print(f"Mesh objects count: {len(mesh_objects)}")
        print(f"Vertex counts per mesh: {vertex_counts}")
        print(f"Total vertices: {sum(vertex_counts)}")
        print(f"Trajectories shape: {trajs.shape}")
        
        total_vertices = sum(vertex_counts)
        if trajs.shape[2] != total_vertices:
            print(f"Warning: Total vertices ({total_vertices}) does not match trajectory points ({trajs.shape[2]})")
        
        num_frames = trajs.shape[1]
        trajs = trajs[0]
        
        print("Merging all meshes into one...")
        bpy.ops.object.select_all(action='DESELECT')
        for obj in mesh_objects:
            obj.select_set(True)
        bpy.context.view_layer.objects.active = mesh_objects[0]
        
        bpy.ops.object.join()
        merged_mesh = bpy.context.active_object
        merged_mesh.name = "MergedAnimatedMesh"
        print(f"Merged mesh created: {merged_mesh.name} with {len(merged_mesh.data.vertices)} vertices")
        
        print("Creating shape keys for merged mesh...")
        bpy.ops.object.mode_set(mode='OBJECT')
        
        basis = merged_mesh.shape_key_add(name='Basis')
        basis.interpolation = 'KEY_LINEAR'
        
        for frame_idx in range(num_frames):
            shape_key_name = f"Frame_{frame_idx}"
            shape_key = merged_mesh.shape_key_add(name=shape_key_name)
            shape_key.interpolation = 'KEY_LINEAR'
            
            if hasattr(trajs[frame_idx], 'numpy'):
                positions = trajs[frame_idx].numpy()
            else:
                positions = trajs[frame_idx]
            
            for vert_idx, pos in enumerate(positions):
                shape_key.data[vert_idx].co = Vector(pos)
        
        print(f"Created {num_frames} shape keys")
        
        print("Setting up shape key animation...")
        for frame_idx in range(num_frames):
            for shape_key in merged_mesh.data.shape_keys.key_blocks[1:]:
                shape_key.value = 0
                shape_key.keyframe_insert("value", frame=frame_idx)
            
            current_shape_key = merged_mesh.data.shape_keys.key_blocks[f"Frame_{frame_idx}"]
            current_shape_key.value = 1
            current_shape_key.keyframe_insert("value", frame=frame_idx)
        
        if merged_mesh.data.shape_keys.animation_data and merged_mesh.data.shape_keys.animation_data.action:
            fcurves = merged_mesh.data.shape_keys.animation_data.action.fcurves
            for fc in fcurves:
                for kf in fc.keyframe_points:
                    kf.interpolation = 'CONSTANT'
        
        print("Shape key animation setup complete")
        
        bpy.context.scene.frame_start = 0
        bpy.context.scene.frame_end = num_frames - 1
        
        print("Setting up scene...")
        
        if export_format != "none":
            print(f"Exporting animated mesh to {export_format.upper()} format...")
            bpy.ops.object.select_all(action='DESELECT')
            merged_mesh.select_set(True)
            filename = os.path.basename(output_dir)
            export_path = os.path.join(os.path.dirname(output_dir), f"{filename}.{export_format}")
            
            if export_format == "abc":
                bpy.ops.wm.alembic_export(
                    filepath=export_path,
                    start=bpy.context.scene.frame_start,
                    end=bpy.context.scene.frame_end,
                    selected=True,
                    uvs=True,
                    face_sets=True
                )
            elif export_format == "glb":
                bpy.ops.export_scene.gltf(
                    filepath=export_path,
                    use_selection=True,
                    export_format='GLB',
                    export_animations=True,
                    export_frame_range=True,
                    export_morph=True,
                    export_morph_animation=True,
                )
            
            print(f"Successfully exported animated mesh to: {export_path}")
            bpy.ops.object.select_all(action='DESELECT')
        
        print("Animation setup complete!")
        
    except Exception as e:
        print(f"Error occurred: {str(e)}")
        import traceback
        traceback.print_exc()
        raise

	import bpy
	import bmesh
	import os
	import numpy as np
	import torch
	import math
	import mathutils
	from mathutils import Vector
	import imageio
	import imageio.v3 as iio
	import glob

	def clear_scene():
	"""Clear the current scene."""
	bpy.ops.wm.read_homefile(use_empty=True)
	for obj in bpy.data.objects:
	bpy.data.objects.remove(obj, do_unlink=True)

	def import_glb(filepath):
	"""Import GLB/GLTF file and return mesh objects."""
	bpy.ops.import_scene.gltf(filepath=filepath)
	mesh_objects = [obj for obj in bpy.context.scene.objects if (obj.type == 'MESH' and obj.name != 'Cube' and obj.name != 'Icosphere')]
	if not mesh_objects:
	raise ValueError("No mesh objects found")
	for obj in mesh_objects:
	if obj.animation_data:
	obj.animation_data_clear()
	if obj.data.shape_keys:
	obj.shape_key_clear()
	bpy.context.view_layer.objects.active = obj
	bpy.ops.object.transform_apply(location=True, rotation=True, scale=True)
	print(f"Loaded {len(mesh_objects)} mesh objects")
	for mesh_obj in mesh_objects:
	print(f"Mesh: {mesh_obj.name}, Vertices: {len(mesh_obj.data.vertices)}")
	return mesh_objects

	def import_fbx(filepath):
	"""Import FBX file and align to trimesh coordinate system."""
	bpy.ops.import_scene.fbx(filepath=filepath)
	mesh_objects = [obj for obj in bpy.context.scene.objects if (obj.type == 'MESH' and obj.name != 'Cube' and obj.name != 'Icosphere')]
	if not mesh_objects:
	raise ValueError("No mesh objects found")
	for obj in mesh_objects:
	if obj.animation_data:
	obj.animation_data_clear()
	if obj.data.shape_keys:
	obj.shape_key_clear()
	bpy.context.view_layer.objects.active = obj
	bpy.ops.object.transform_apply(location=True, rotation=True, scale=True)
	bpy.ops.object.transform_apply(location=True, rotation=True, scale=True)
	print(f"Loaded {len(mesh_objects)} mesh objects from FBX")
	for mesh_obj in mesh_objects:
	print(f"Mesh: {mesh_obj.name}, Vertices: {len(mesh_obj.data.vertices)}")
	return mesh_objects

	def get_mesh_vertices(mesh_obj):
	"""Extract vertex coordinates from a mesh object."""
	vertices = []
	for vertex in mesh_obj.data.vertices:
	vertices.append([vertex.co[0], vertex.co[1], vertex.co[2]])
	return np.array(vertices)

	def get_all_vertices(mesh_objects):
	"""Extract vertex coordinates from multiple mesh objects."""
	all_vertices = []
	for mesh_obj in mesh_objects:
	vertices = get_mesh_vertices(mesh_obj)
	all_vertices.append(torch.from_numpy(vertices))
	return all_vertices

	def get_mesh_faces(mesh_obj):
	"""Extract face indices from a mesh object."""
	faces = []
	for face in mesh_obj.data.polygons:
	faces.append(list(face.vertices))
	return np.array(faces)

	def get_all_faces(mesh_objects):
	"""Extract face indices from multiple mesh objects, adjusting vertex indices for merged meshes."""
	all_faces = []
	vertex_count = 0
	for mesh_obj in mesh_objects:
	faces = get_mesh_faces(mesh_obj)
	if len(all_faces) > 0:
	faces = faces + vertex_count
	all_faces.append(torch.from_numpy(faces))
	vertex_count += len(mesh_obj.data.vertices)
	return all_faces

	def move_vertices_with_trajectory(mesh_obj, frame, trajectories):
	"""Move mesh vertices according to trajectory data for a specific frame."""
	bpy.context.view_layer.objects.active = mesh_obj
	bpy.ops.object.mode_set(mode='OBJECT')
	if mesh_obj.data.shape_keys is None:
	basis = mesh_obj.shape_key_add(name='Basis')
	basis.interpolation = 'KEY_LINEAR'

	bpy.context.scene.frame_set(frame)
	shape_key_name = f"Frame_{frame}"
	shape_key = mesh_obj.data.shape_keys.key_blocks.get(shape_key_name)
	if not shape_key:
	shape_key = mesh_obj.shape_key_add(name=shape_key_name)
	shape_key.interpolation = 'KEY_LINEAR'
	if hasattr(trajectories[frame], 'numpy'):
	positions = trajectories[frame].numpy()
	else:
	positions = trajectories[frame]
	for idx, pos in enumerate(positions):
	shape_key.data[idx].co = Vector(pos)

	shape_key.value = 1.0
	shape_key.keyframe_insert(data_path="value", frame=frame)
	if frame > 0:
	shape_key.value = 0.0
	shape_key.keyframe_insert(data_path="value", frame=frame - 1)

	def drive_mesh_with_trajs_frames(mesh_objects, trajs, output_dir, azi=0.0, ele=0.0, export_format="fbx"):
	"""Drive mesh animation with trajectory data and optionally export to various formats."""
	try:
	print(output_dir)
	os.makedirs(output_dir, exist_ok=True)
	print("Setting up animations for all meshes...")
	for i in range(len(mesh_objects)):
	mesh_obj = mesh_objects[i]
	traj = trajs[i]
	num_frames = traj.shape[0]
	print(traj.shape)
	print(traj.max(), traj.min())
	for frame in range(num_frames):
	move_vertices_with_trajectory(mesh_obj, frame, traj)
	# Insert all keyframes first
	for frame in range(num_frames):
	for shape_key in mesh_obj.data.shape_keys.key_blocks[1:]:
	shape_key.value = 0
	shape_key.keyframe_insert("value", frame=frame)

	current_shape_key = mesh_obj.data.shape_keys.key_blocks[f"Frame_{frame}"]
	current_shape_key.value = 1
	current_shape_key.keyframe_insert("value", frame=frame)

	# Set interpolation to CONSTANT for all keyframes at once (AFTER all keyframes are inserted)
	if mesh_obj.data.shape_keys.animation_data and mesh_obj.data.shape_keys.animation_data.action:
	fcurves = mesh_obj.data.shape_keys.animation_data.action.fcurves
	for fc in fcurves:
	for kf in fc.keyframe_points:
	kf.interpolation = 'CONSTANT'

	print("Setting up scene...")
	bpy.context.scene.frame_start = 0
	bpy.context.scene.frame_end = trajs.shape[1] - 1
	if export_format != "none":
	print(f"Exporting animated mesh to {export_format.upper()} format...")
	bpy.ops.object.select_all(action='DESELECT')
	for obj in mesh_objects:
	obj.select_set(True)
	filename = os.path.basename(output_dir)
	export_path = os.path.join(os.path.dirname(output_dir), f"{filename}.{export_format}")
	if export_format == "abc":
	bpy.ops.wm.alembic_export(
	filepath=export_path,
	start=bpy.context.scene.frame_start,
	end=bpy.context.scene.frame_end,
	selected=True,
	uvs=True,
	face_sets=True
	)
	elif export_format == "fbx":
	# Optimized FBX export for shape key animations
	bpy.ops.export_scene.fbx(
	filepath=export_path,
	use_selection=True,
	bake_anim=True,
	bake_anim_use_all_bones=False,
	bake_anim_use_nla_strips=False,
	bake_anim_use_all_actions=False,
	bake_anim_force_startend_keying=False, # Disabled: not needed for shape keys
	bake_anim_step=1.0, # Set to 1.0 to bake only existing keyframes
	bake_anim_simplify_factor=0.0, # Disable simplification for speed
	add_leaf_bones=False,
	path_mode='COPY',
	embed_textures=True,
	use_mesh_modifiers=True,
	use_mesh_edges=True,
	use_tspace=True,
	use_custom_props=True,
	use_active_collection=False,
	)
	elif export_format == "glb":
	bpy.ops.export_scene.gltf(
	filepath=export_path,
	use_selection=True,
	export_format='GLB',
	export_animations=True,
	export_frame_range=True,
	)
	print(f"Successfully exported animated mesh to: {export_path}")
	bpy.ops.object.select_all(action='DESELECT')
	except Exception as e:
	print(f"Error occurred: {str(e)}")
	raise

	def move_vertices_with_trajectory_gt(mesh_obj, frame, trajectories):
	"""Move mesh vertices according to ground truth trajectory data for a specific frame."""
	bpy.context.view_layer.objects.active = mesh_obj
	bpy.ops.object.mode_set(mode='OBJECT')
	if mesh_obj.data.shape_keys is None:
	basis = mesh_obj.shape_key_add(name='Basis')
	basis.interpolation = 'KEY_LINEAR'

	shape_key_name = f"Frame_{frame}"
	shape_key = mesh_obj.data.shape_keys.key_blocks.get(shape_key_name)
	if not shape_key:
	shape_key = mesh_obj.shape_key_add(name=shape_key_name)
	shape_key.interpolation = 'KEY_LINEAR'
	if hasattr(trajectories[frame], 'numpy'):
	positions = trajectories[frame].numpy()
	else:
	positions = trajectories[frame]
	for idx, pos in enumerate(positions):
	shape_key.data[idx].co = Vector(pos)

	def drive_mesh_with_trajs_frames_gt(mesh_objects, trajs, output_dir, azi=0.0, ele=0.0, export_format="glb"):
	"""
	Drive mesh animation by merging multiple meshes into one and using shape keys.
	This approach is most compatible with GLB export as it only requires handling a single object.

	Args:
	mesh_objects: List of Blender mesh objects
	trajs: Trajectory data with shape (1, T, N, 3), where N is the total number of vertices
	output_dir: Output directory
	export_format: Export format ('glb', 'fbx', 'abc', 'none')
	"""
	try:
	print(output_dir)
	os.makedirs(output_dir, exist_ok=True)
	print("Setting up animations for all meshes (V2 - Merged Mesh with Shape Keys)...")

	vertex_counts = []
	for mesh_obj in mesh_objects:
	vertex_counts.append(len(mesh_obj.data.vertices))

	print(f"Mesh objects count: {len(mesh_objects)}")
	print(f"Vertex counts per mesh: {vertex_counts}")
	print(f"Total vertices: {sum(vertex_counts)}")
	print(f"Trajectories shape: {trajs.shape}")

	total_vertices = sum(vertex_counts)
	if trajs.shape[2] != total_vertices:
	print(f"Warning: Total vertices ({total_vertices}) does not match trajectory points ({trajs.shape[2]})")

	num_frames = trajs.shape[1]
	trajs = trajs[0]

	print("Merging all meshes into one...")
	bpy.ops.object.select_all(action='DESELECT')
	for obj in mesh_objects:
	obj.select_set(True)
	bpy.context.view_layer.objects.active = mesh_objects[0]

	bpy.ops.object.join()
	merged_mesh = bpy.context.active_object
	merged_mesh.name = "MergedAnimatedMesh"
	print(f"Merged mesh created: {merged_mesh.name} with {len(merged_mesh.data.vertices)} vertices")

	print("Creating shape keys for merged mesh...")
	bpy.ops.object.mode_set(mode='OBJECT')

	basis = merged_mesh.shape_key_add(name='Basis')
	basis.interpolation = 'KEY_LINEAR'

	for frame_idx in range(num_frames):
	shape_key_name = f"Frame_{frame_idx}"
	shape_key = merged_mesh.shape_key_add(name=shape_key_name)
	shape_key.interpolation = 'KEY_LINEAR'

	if hasattr(trajs[frame_idx], 'numpy'):
	positions = trajs[frame_idx].numpy()
	else:
	positions = trajs[frame_idx]

	for vert_idx, pos in enumerate(positions):
	shape_key.data[vert_idx].co = Vector(pos)

	print(f"Created {num_frames} shape keys")

	print("Setting up shape key animation...")
	for frame_idx in range(num_frames):
	for shape_key in merged_mesh.data.shape_keys.key_blocks[1:]:
	shape_key.value = 0
	shape_key.keyframe_insert("value", frame=frame_idx)

	current_shape_key = merged_mesh.data.shape_keys.key_blocks[f"Frame_{frame_idx}"]
	current_shape_key.value = 1
	current_shape_key.keyframe_insert("value", frame=frame_idx)

	if merged_mesh.data.shape_keys.animation_data and merged_mesh.data.shape_keys.animation_data.action:
	fcurves = merged_mesh.data.shape_keys.animation_data.action.fcurves
	for fc in fcurves:
	for kf in fc.keyframe_points:
	kf.interpolation = 'CONSTANT'

	print("Shape key animation setup complete")

	bpy.context.scene.frame_start = 0
	bpy.context.scene.frame_end = num_frames - 1

	print("Setting up scene...")

	if export_format != "none":
	print(f"Exporting animated mesh to {export_format.upper()} format...")
	bpy.ops.object.select_all(action='DESELECT')
	merged_mesh.select_set(True)
	filename = os.path.basename(output_dir)
	export_path = os.path.join(os.path.dirname(output_dir), f"{filename}.{export_format}")

	if export_format == "abc":
	bpy.ops.wm.alembic_export(
	filepath=export_path,
	start=bpy.context.scene.frame_start,
	end=bpy.context.scene.frame_end,
	selected=True,
	uvs=True,
	face_sets=True
	)
	elif export_format == "glb":
	bpy.ops.export_scene.gltf(
	filepath=export_path,
	use_selection=True,
	export_format='GLB',
	export_animations=True,
	export_frame_range=True,
	export_morph=True,
	export_morph_animation=True,
	)

	print(f"Successfully exported animated mesh to: {export_path}")
	bpy.ops.object.select_all(action='DESELECT')

	print("Animation setup complete!")

	except Exception as e:
	print(f"Error occurred: {str(e)}")
	import traceback
	traceback.print_exc()
	raise