| import os |
| import numpy as np |
| import torch |
| import subprocess |
| import tempfile |
| from PIL import Image |
| import trimesh |
|
|
|
|
| def convert_fbx_to_glb_with_blender(fbx_path, output_glb_path): |
| """ |
| Convert FBX file to GLB using Blender. |
| |
| Args: |
| fbx_path: Input FBX file path |
| output_glb_path: Output GLB file path |
| """ |
| python_script = f""" |
| import bpy |
| import bmesh |
| |
| def reset_scene(): |
| for obj in bpy.data.objects: |
| bpy.data.objects.remove(obj, do_unlink=True) |
| for material in bpy.data.materials: |
| bpy.data.materials.remove(material, do_unlink=True) |
| for texture in bpy.data.textures: |
| bpy.data.textures.remove(texture, do_unlink=True) |
| for image in bpy.data.images: |
| bpy.data.images.remove(image, do_unlink=True) |
| |
| if __name__ == "__main__": |
| reset_scene() |
| bpy.ops.import_scene.fbx(filepath='{fbx_path}') |
| mesh_objs = [obj for obj in bpy.context.scene.objects if obj.type == 'MESH'] |
| |
| for obj in mesh_objs: |
| for mat_slot in obj.data.materials: |
| if not mat_slot.use_nodes: |
| continue |
| nodes = mat_slot.node_tree.nodes |
| img_nodes = [n for n in nodes if n.type == 'TEX_IMAGE'] |
| if img_nodes: |
| base_img = img_nodes[0].image |
| new_mat = bpy.data.materials.new(name="MergedMat") |
| new_mat.use_nodes = True |
| new_nodes = new_mat.node_tree.nodes |
| new_nodes.clear() |
| bsdf = new_nodes.new('ShaderNodeBsdfPrincipled') |
| tex_node = new_nodes.new('ShaderNodeTexImage') |
| tex_node.image = base_img |
| output = new_nodes.new('ShaderNodeOutputMaterial') |
| new_mat.node_tree.links.new(bsdf.outputs['BSDF'], output.inputs['Surface']) |
| new_mat.node_tree.links.new(tex_node.outputs['Color'], bsdf.inputs['Base Color']) |
| obj.data.materials[0] = new_mat |
| |
| bpy.ops.object.select_all(action='DESELECT') |
| for obj in bpy.context.scene.objects: |
| if obj.type != 'MESH': |
| continue |
| obj.select_set(True) |
| bpy.context.view_layer.objects.active = obj |
| if obj.parent: |
| bpy.ops.object.parent_clear(type='CLEAR_KEEP_TRANSFORM') |
| bpy.ops.object.transform_apply(location=True, rotation=True, scale=True) |
| for mod in obj.modifiers: |
| try: |
| bpy.ops.object.modifier_apply(modifier=mod.name) |
| except: |
| pass |
| obj.select_set(False) |
| |
| bpy.ops.export_scene.gltf( |
| filepath='{output_glb_path}', |
| export_format='GLB', |
| export_materials='EXPORT', |
| use_selection=False, |
| export_yup=True, |
| export_apply=True, |
| ) |
| """ |
| |
| with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f: |
| temp_script = f.name |
| f.write(python_script) |
| |
| try: |
| subprocess.run( |
| f'python "{temp_script}"', |
| shell=True, |
| check=True |
| ) |
| print(f"✓ Successfully converted FBX to GLB: {output_glb_path}") |
| except subprocess.CalledProcessError as e: |
| print(f"✗ Blender conversion failed: {e}") |
| raise |
| finally: |
| if os.path.exists(temp_script): |
| os.remove(temp_script) |
|
|
|
|
| def barycentric_coords(tri, p): |
| """ |
| Calculate barycentric coordinates of point p in triangle tri. |
| |
| Args: |
| tri: (3, 3) triangle vertex coordinates |
| p: (3,) point coordinates |
| |
| Returns: |
| (3,) barycentric coordinates [u, v, w] where u+v+w=1 |
| """ |
| v0 = tri[1] - tri[0] |
| v1 = tri[2] - tri[0] |
| v2 = p - tri[0] |
| d00 = np.dot(v0, v0) |
| d01 = np.dot(v0, v1) |
| d11 = np.dot(v1, v1) |
| d20 = np.dot(v2, v0) |
| d21 = np.dot(v2, v1) |
| denom = d00 * d11 - d01 * d01 |
| if denom == 0: |
| return np.array([1/3, 1/3, 1/3]) |
| v = (d11 * d20 - d01 * d21) / denom |
| w = (d00 * d21 - d01 * d20) / denom |
| u = 1 - v - w |
| return np.array([u, v, w]) |
|
|
|
|
| def sample_pointcloud_with_albedo(mesh, num=200000): |
| """ |
| Sample point cloud from mesh with positions, normals, and colors using barycentric interpolation. |
| |
| Args: |
| mesh: trimesh.Trimesh object |
| num: Number of points to sample |
| |
| Returns: |
| points: (num, 3) point cloud coordinates |
| normals: (num, 3) normals |
| colors: (num, 3) RGB colors in range [0, 1] |
| """ |
| points, face_idx = mesh.sample(num, return_index=True) |
| normals = mesh.face_normals[face_idx] |
| colors = None |
|
|
| |
| if hasattr(mesh.visual, "vertex_colors") and len(mesh.visual.vertex_colors) == len(mesh.vertices): |
| vertex_colors = mesh.visual.vertex_colors |
| if vertex_colors.ndim == 2 and vertex_colors.shape[1] >= 3: |
| vertex_colors = vertex_colors[:, :3] / 255.0 |
| tri_colors = vertex_colors[mesh.faces[face_idx]] |
| colors = tri_colors.mean(axis=1) |
|
|
| |
| if colors is None and hasattr(mesh.visual, "material") and hasattr(mesh.visual.material, "baseColorTexture") and mesh.visual.material.baseColorTexture: |
| tex = mesh.visual.material.baseColorTexture |
| image = tex.image if hasattr(tex, "image") else tex |
| |
| if isinstance(image, str): |
| image = Image.open(image) |
| if image.mode not in ["RGB", "RGBA"]: |
| image = image.convert("RGB") |
| tex_np = np.array(image).astype(np.float32) / 255.0 |
| if tex_np.ndim == 2: |
| tex_np = np.stack([tex_np] * 3, axis=-1) |
| elif tex_np.shape[2] > 3: |
| tex_np = tex_np[:, :, :3] |
| tex_w, tex_h = image.size |
|
|
| if hasattr(mesh.visual, "uv") and mesh.visual.uv is not None: |
| uv = mesh.visual.uv % 1.0 |
| tri_uvs = uv[mesh.faces[face_idx]] |
| colors = np.zeros((num, 3), dtype=np.float32) |
| for i in range(num): |
| tri = mesh.triangles[face_idx[i]] |
| p = points[i] |
| w = barycentric_coords(tri, p) |
| uv_sample = w[0] * tri_uvs[i, 0] + w[1] * tri_uvs[i, 1] + w[2] * tri_uvs[i, 2] |
| u = int(np.clip(uv_sample[0] * tex_w, 0, tex_w - 1)) |
| v = int(np.clip((1 - uv_sample[1]) * tex_h, 0, tex_h - 1)) |
| colors[i] = tex_np[v, u, :] |
|
|
| if colors is None: |
| colors = np.full((num, 3), 0.5, dtype=np.float32) |
|
|
| points = torch.from_numpy(points.astype(np.float32)) |
| normals = torch.from_numpy(normals.astype(np.float32)) |
| colors = torch.from_numpy(colors.astype(np.float32)) |
|
|
| return points, normals, colors |
|
|
|
|
| def normalize_mesh(mesh, return_params=False): |
| """ |
| Normalize mesh to fit in a unit cube centered at origin. |
| |
| Args: |
| mesh: trimesh.Trimesh object |
| return_params: If True, return normalization parameters |
| |
| Returns: |
| mesh: Normalized mesh (or vertices if return_params=True) |
| center: Center point (only if return_params=True) |
| scale: Scale factor (only if return_params=True) |
| """ |
| vertices = mesh.vertices.astype(np.float32) |
| center = (vertices.max(axis=0) + vertices.min(axis=0)) / 2 |
| vertices = vertices - center |
| v_max = np.abs(vertices).max() |
| scale = 2 * (v_max + 1e-8) |
| vertices = vertices / scale |
| |
| if return_params: |
| return vertices, center, scale |
| else: |
| mesh.vertices = vertices |
| return mesh |
|
|
|
|
