| import argparse |
| import json |
| import math |
| import sys |
| from pathlib import Path |
|
|
| import bpy |
| import numpy as np |
| from mathutils import Vector |
|
|
|
|
| IMPORTERS = { |
| "obj": bpy.ops.wm.obj_import, |
| "ply": bpy.ops.wm.ply_import, |
| "glb": bpy.ops.import_scene.gltf, |
| "gltf": bpy.ops.import_scene.gltf, |
| "fbx": bpy.ops.import_scene.fbx, |
| "stl": bpy.ops.import_mesh.stl, |
| } |
|
|
|
|
| def orthographic_views(num_views: int) -> list[dict[str, float]]: |
| base_views = [ |
| (-0.5 * np.pi, 0.0), |
| (0.0, 0.0), |
| (0.5 * np.pi, 0.0), |
| (np.pi, 0.0), |
| (-0.5 * np.pi, 0.5 * np.pi), |
| (-0.5 * np.pi, -0.5 * np.pi), |
| ] |
| if num_views <= len(base_views): |
| selected = base_views[:num_views] |
| else: |
| selected = base_views[:] |
| for index in range(num_views - len(base_views)): |
| azimuth = 2.0 * np.pi * index / max(1, num_views - len(base_views)) |
| selected.append((azimuth, np.pi / 6.0)) |
| return [{"azimuth": yaw, "elevation": pitch, "distance": 1.5, "fov": 0.6} for yaw, pitch in selected] |
|
|
|
|
| def clear_scene() -> None: |
| for collection in (bpy.data.objects, bpy.data.materials, bpy.data.textures, bpy.data.images): |
| for item in list(collection): |
| collection.remove(item, do_unlink=True) |
|
|
|
|
| def load_model(path: Path) -> None: |
| extension = path.suffix.lower().lstrip(".") |
| if extension not in IMPORTERS: |
| raise ValueError(f"Unsupported model format: {path.suffix}") |
| importer = IMPORTERS[extension] |
| if extension in {"glb", "gltf"}: |
| importer(filepath=str(path), merge_vertices=True, import_shading="NORMALS") |
| else: |
| importer(filepath=str(path)) |
|
|
|
|
| def scene_bbox() -> tuple[Vector, Vector]: |
| bbox_min = Vector((math.inf, math.inf, math.inf)) |
| bbox_max = Vector((-math.inf, -math.inf, -math.inf)) |
| found = False |
| for obj in bpy.context.scene.objects: |
| if not isinstance(obj.data, bpy.types.Mesh): |
| continue |
| found = True |
| for coord in obj.bound_box: |
| world_coord = obj.matrix_world @ Vector(coord) |
| bbox_min = Vector(tuple(min(bbox_min[i], world_coord[i]) for i in range(3))) |
| bbox_max = Vector(tuple(max(bbox_max[i], world_coord[i]) for i in range(3))) |
| if not found: |
| raise RuntimeError("The scene does not contain a mesh object.") |
| return bbox_min, bbox_max |
|
|
|
|
| def normalize_scene() -> tuple[float, Vector]: |
| root_objects = [obj for obj in bpy.context.scene.objects if obj.parent is None] |
| if len(root_objects) > 1: |
| parent = bpy.data.objects.new("SceneRoot", None) |
| bpy.context.scene.collection.objects.link(parent) |
| for obj in root_objects: |
| obj.parent = parent |
| else: |
| parent = root_objects[0] |
|
|
| bbox_min, bbox_max = scene_bbox() |
| scale = 1.0 / max(bbox_max - bbox_min) |
| parent.scale *= scale |
| bpy.context.view_layer.update() |
|
|
| bbox_min, bbox_max = scene_bbox() |
| offset = -(bbox_min + bbox_max) * 0.5 |
| parent.matrix_world.translation += offset |
| bpy.context.view_layer.update() |
| return scale, offset |
|
|
|
|
| def configure_render(resolution: int, engine: str) -> None: |
| scene = bpy.context.scene |
| scene.render.engine = engine |
| scene.render.resolution_x = resolution |
| scene.render.resolution_y = resolution |
| scene.render.resolution_percentage = 100 |
| scene.render.image_settings.file_format = "PNG" |
| scene.render.image_settings.color_mode = "RGBA" |
| scene.render.film_transparent = True |
|
|
| if engine == "CYCLES": |
| scene.cycles.device = "GPU" |
| scene.cycles.samples = 64 |
| scene.cycles.use_denoising = True |
| try: |
| prefs = bpy.context.preferences.addons["cycles"].preferences |
| prefs.compute_device_type = "CUDA" |
| prefs.get_devices() |
| for device in prefs.devices: |
| device.use = device.type == "CUDA" |
| except Exception: |
| pass |
|
|
|
|
| def create_camera() -> bpy.types.Object: |
| camera = bpy.data.objects.new("Camera", bpy.data.cameras.new("Camera")) |
| bpy.context.collection.objects.link(camera) |
| bpy.context.scene.camera = camera |
| camera.data.type = "ORTHO" |
| camera.data.ortho_scale = 1.2 |
|
|
| target = bpy.data.objects.new("CameraTarget", None) |
| bpy.context.collection.objects.link(target) |
| target.location = (0.0, 0.0, 0.0) |
|
|
| constraint = camera.constraints.new(type="TRACK_TO") |
| constraint.track_axis = "TRACK_NEGATIVE_Z" |
| constraint.up_axis = "UP_Y" |
| constraint.target = target |
| return camera |
|
|
|
|
| def add_lighting() -> None: |
| light_specs = [ |
| ("KeyLight", "POINT", 1000.0, (4.0, 1.0, 6.0), (1.0, 1.0, 1.0)), |
| ("TopLight", "AREA", 10000.0, (0.0, 0.0, 10.0), (100.0, 100.0, 100.0)), |
| ("BottomLight", "AREA", 1000.0, (0.0, 0.0, -10.0), (100.0, 100.0, 100.0)), |
| ] |
| for name, kind, energy, location, scale in light_specs: |
| light = bpy.data.objects.new(name, bpy.data.lights.new(name, type=kind)) |
| bpy.context.collection.objects.link(light) |
| light.data.energy = energy |
| light.location = location |
| light.scale = scale |
|
|
|
|
| def apply_neutral_material() -> None: |
| material = bpy.data.materials.new("NeutralMaterial") |
| material.use_nodes = True |
| material.node_tree.nodes.clear() |
| shader = material.node_tree.nodes.new("ShaderNodeBsdfDiffuse") |
| shader.inputs[0].default_value = (0.5, 0.5, 0.5, 1.0) |
| output = material.node_tree.nodes.new("ShaderNodeOutputMaterial") |
| material.node_tree.links.new(shader.outputs["BSDF"], output.inputs["Surface"]) |
| bpy.context.scene.view_layers["ViewLayer"].material_override = material |
|
|
|
|
| def camera_transform(camera: bpy.types.Object) -> list[list[float]]: |
| location, rotation, _ = camera.matrix_world.decompose() |
| rotation = rotation.to_matrix() |
| rows = [] |
| for row_index in range(3): |
| row = [rotation[row_index][col_index] for col_index in range(3)] |
| row.append(location[row_index]) |
| rows.append(row) |
| rows.append([0.0, 0.0, 0.0, 1.0]) |
| return rows |
|
|
|
|
| def export_mesh(path: Path) -> None: |
| bpy.ops.object.select_all(action="DESELECT") |
| mesh_objects = [obj for obj in bpy.context.scene.objects if obj.type == "MESH"] |
| if not mesh_objects: |
| return |
| bpy.context.view_layer.objects.active = mesh_objects[0] |
| for obj in mesh_objects: |
| obj.select_set(True) |
| bpy.ops.object.convert(target="MESH") |
| bpy.ops.object.mode_set(mode="EDIT") |
| bpy.ops.mesh.select_all(action="SELECT") |
| bpy.ops.mesh.quads_convert_to_tris(quad_method="BEAUTY", ngon_method="BEAUTY") |
| bpy.ops.object.mode_set(mode="OBJECT") |
| bpy.ops.wm.ply_export(filepath=str(path), export_triangulated_mesh=True, up_axis="Y", forward_axis="NEGATIVE_Z") |
|
|
|
|
| def render(args: argparse.Namespace) -> None: |
| output_dir = Path(args.output_folder) |
| output_dir.mkdir(parents=True, exist_ok=True) |
|
|
| clear_scene() |
| load_model(Path(args.object)) |
| scale, offset = normalize_scene() |
| configure_render(args.resolution, args.engine) |
| camera = create_camera() |
| add_lighting() |
| apply_neutral_material() |
|
|
| metadata = { |
| "aabb": [[-0.5, -0.5, -0.5], [0.5, 0.5, 0.5]], |
| "scale": scale, |
| "offset": [offset.x, offset.y, offset.z], |
| "frames": [], |
| } |
|
|
| for index, view in enumerate(orthographic_views(args.num_views)): |
| camera.location = ( |
| view["distance"] * np.cos(view["azimuth"]) * np.cos(view["elevation"]), |
| view["distance"] * np.sin(view["azimuth"]) * np.cos(view["elevation"]), |
| view["distance"] * np.sin(view["elevation"]), |
| ) |
| bpy.context.scene.render.filepath = str(output_dir / f"{index:03d}.png") |
| bpy.ops.render.render(write_still=True) |
| metadata["frames"].append( |
| { |
| "file_path": f"{index:03d}.png", |
| "camera_angle_x": view["fov"], |
| "azimuth": view["azimuth"], |
| "elevation": view["elevation"], |
| "cam_dis": view["distance"], |
| "transform_matrix": camera_transform(camera), |
| } |
| ) |
|
|
| with (output_dir / "transforms.json").open("w") as handle: |
| json.dump(metadata, handle, indent=2) |
|
|
| if args.geo_mode: |
| export_mesh(output_dir / "mesh.ply") |
|
|
|
|
| def build_parser() -> argparse.ArgumentParser: |
| parser = argparse.ArgumentParser(description="Render a 3D model from fixed orthographic views.") |
| parser.add_argument("--object", required=True, help="Path to the model file.") |
| parser.add_argument("--output-folder", "--output_folder", dest="output_folder", required=True) |
| parser.add_argument("--resolution", type=int, default=512) |
| parser.add_argument("--num-views", type=int, default=6) |
| parser.add_argument("--engine", default="CYCLES", choices=("CYCLES", "BLENDER_EEVEE_NEXT", "BLENDER_EEVEE")) |
| parser.add_argument("--geo-mode", "--geo_mode", dest="geo_mode", action="store_true") |
| return parser |
|
|
|
|
| if __name__ == "__main__": |
| argv = sys.argv[sys.argv.index("--") + 1 :] if "--" in sys.argv else sys.argv[1:] |
| render(build_parser().parse_args(argv)) |
|
|
