evaluation/visual_metric/render.py

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))