eval/LayoutVLM/utils/blender_render.py

import argparse, sys, os, math, re
import bpy
import bmesh
from bpy_extras.image_utils import load_image
import math
import numpy as np
import os
import bpy
import numpy as np
from scipy.signal import correlate2d
from scipy.ndimage import shift
import json
from mathutils import Vector
from utils.blender_utils import reset_scene, setup_background, create_wall_mesh, add_material, setup_camera, load_hdri, set_rendering_settings, apply_texture_to_object
import utils.transformations as tra
from utils.colors import get_categorical_colors
import trimesh
import cv2
from utils.blender_utils import get_pixel_coordinates, reset_blender
from utils.plot_utils import annotate_image_with_coordinates


def get_visual_marks(floor_vertices, scene, cam, interval=1):
    # The world coordinate we want to project
    visual_marks = dict()
    min_vertices = np.min(floor_vertices, axis=0)
    max_vertices = np.max(floor_vertices, axis=0)
    for min_x in range(math.floor(min_vertices[0]), math.ceil(max_vertices[0])+2, interval):
        for min_y in range(math.floor(min_vertices[1]), math.ceil(max_vertices[1])+2, interval):
            world_coord = Vector((min_x, min_y, 0))
            pixel_x, pixel_y = get_pixel_coordinates(scene, cam, world_coord)
            visual_marks[(min_x, min_y)] = (pixel_x, pixel_y)
    return visual_marks


def create_bounding_box(position, rotation, scale, color, transparency=0.5):
    """

    Example:
    create_bounding_box(position=(0, 0, 0), rotation=(0, 0, 0), scale=(1, 2, 0.5), color=(1, 0, 0), transparency=0.3)

    :param position: xyz coordinates, in meters
    :param rotation: euler angles, in radians
    :param scale: xyz dimensions, in meters
    :param color: rgb values in the range [0, 1]
    :param transparency: alpha value in the range [0, 1]
    :return:
    """

    # Add a cube
    bpy.ops.mesh.primitive_cube_add(size=1, location=position, rotation=rotation)
    bounding_box = bpy.context.object

    # Scale the cube to the desired dimensions
    bounding_box.scale = scale

    # Create a new material with transparency
    mat = bpy.data.materials.new(name="BoundingBoxMaterial")
    mat.use_nodes = True
    bsdf = mat.node_tree.nodes.get("Principled BSDF")
    bsdf.inputs["Base Color"].default_value = (*color, 1)  # Set the color
    bsdf.inputs["Alpha"].default_value = transparency
    mat.blend_method = 'BLEND'

    # Assign the material to the bounding box
    if bounding_box.data.materials:
        bounding_box.data.materials[0] = mat
    else:
        bounding_box.data.materials.append(mat)

    # Optional: Enable backface culling for better visual appearance
    mat.use_backface_culling = True

    return bounding_box


def get_wall_normal(corner1, corner2, add_radian=None):
    """corner1 and corner2 are the two points on the wall, given in counter-clockwise order"""
    vector = np.array([corner2[0] - corner1[0], corner2[1] - corner1[1]], dtype=np.float32)
    if add_radian:
        # Assuming add_radian is the angle to add in radians
        cos_theta = np.cos(add_radian)
        sin_theta = np.sin(add_radian)
        # Construct the rotation matrix
        rotation_matrix = np.array([[cos_theta, -sin_theta],
                                    [sin_theta, cos_theta]], dtype=np.float32)
        # Multiply the rotation vector by the rotation matrix
        vector = np.dot(rotation_matrix, vector)

    vector = vector / np.linalg.norm(vector)
    return vector


def get_obj_dimensions(obj, frame="object"):
    # Ensure the object is of type 'MESH'
    if obj.type != 'MESH':
        raise ValueError(f"The object '{obj.name}' is not a mesh.")

    # Get the bounding box coordinates in local space
    bbox = [Vector(corner) for corner in obj.bound_box]

    # Convert the local bounding box coordinates to world space
    if frame == "world":
        bbox = [obj.matrix_world @ corner for corner in bbox]

    # Calculate the minimum and maximum coordinates along each axis
    min_x = min(corner.x for corner in bbox)
    max_x = max(corner.x for corner in bbox)
    min_y = min(corner.y for corner in bbox)
    max_y = max(corner.y for corner in bbox)
    min_z = min(corner.z for corner in bbox)
    max_z = max(corner.z for corner in bbox)

    # Calculate the dimensions
    width = max_x - min_x
    depth = max_y - min_y
    height = max_z - min_z

    return [width, depth, height]


# Function to create an arrow representing an axis
def create_arrow(start, end, radius=0.02, color=(1, 0, 0, 1), name="Arrow"):
    # Create a cylinder (for the shaft)
    bpy.ops.mesh.primitive_cylinder_add(radius=radius, depth=(end - start).length, location=(start + end) / 2)
    shaft = bpy.context.object
    shaft.name = name + "_shaft"

    # Align the shaft to point towards the end
    direction = end - start
    rot_quat = direction.to_track_quat('Z', 'Y')
    shaft.rotation_euler = rot_quat.to_euler()

    # Create a cone (for the tip)
    tip_length = radius * 2
    bpy.ops.mesh.primitive_cone_add(radius1=radius * 2, depth=tip_length, location=end)
    tip = bpy.context.object
    tip.name = name + "_tip"

    # Align the tip to point towards the end
    tip.rotation_euler = rot_quat.to_euler()

    # Create a material for the arrow
    mat = bpy.data.materials.new(name + "_Material")
    mat.diffuse_color = color
    shaft.data.materials.append(mat)
    tip.data.materials.append(mat)

    # Combine shaft and tip into one object
    bpy.ops.object.select_all(action='DESELECT')
    shaft.select_set(True)
    tip.select_set(True)
    bpy.ops.object.join()


# Function to add a coordinate frame at a specific location
def add_coordinate_frame(location=Vector((0, 0, 0.)), scale=1.0):
    # Define the length and color of each axis
    axis_length = scale
    x_color = (1, 0, 0, 1)  # Red
    y_color = (0, 1, 0, 1)  # Green
    z_color = (0, 0, 1, 1)  # Blue

    # Create the X axis arrow
    create_arrow(location, location + Vector((axis_length, 0, 0)), color=x_color, name="X_Axis")

    # Create the Y axis arrow
    create_arrow(location, location + Vector((0, axis_length, 0)), color=y_color, name="Y_Axis")

    # Create the Z axis arrow
    create_arrow(location, location + Vector((0, 0, axis_length)), color=z_color, name="Z_Axis")


def show_current_render(save_dir):
    render_path = f"{save_dir}/tmp.png"
    bpy.context.scene.render.filepath = render_path
    bpy.ops.render.render(write_still=True)
    img = cv2.imread(render_path)
    cv2.imshow("render", img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()


def render_existing_scene(placed_assets, task, save_dir, add_hdri=True, topdown_save_file=None, sideview_save_file=None, add_coordinate_mark=True,
                          annotate_object=True, annotate_wall=True, render_top_down=True, adjust_top_down_angle=None, high_res=False, rotate_90=True,
                          apply_3dfront_texture=False, recenter_mesh=True, fov_multiplier=1.1, default_font_size=None,
                          combine_obj_components=False, side_view_phi=45, side_view_indices=[3], save_blend=False,
                          add_object_bbox=False, ignore_asset_instance_idx=False, floor_material="Travertine008"):
    """
    :param placed_assets: the set of assets that have been placed in the scene / to be rendered
    :param task: just for getting the boundary
    :param save_dir:
    :param add_hdri:
    :param topdown_save_file:
    :param sideview_save_file:
    :param add_coordinate_mark:
    :param annotate_object:
    :param annotate_wall:
    :param render_top_down:
    :param adjust_top_down_angle:
    :param high_res:
    :param rotate_90:
    :param apply_3dfront_texture: this is needed because loading material directly from .obj will fail
    :param recenter_mesh: whether to re-center the mesh to centroid.
    :param fov_multiplier: a factor for increasing the fov of the camera.
    :param combine_obj_components: whether to combine the components of the obj file into one object.
                                   Recommend to set to True if loading 3d front .obj files.
                                   If set to False, one example failure case is 0003d406-5f27-4bbf-94cd-1cff7c310ba1_LivingRoom-54780
    :param apply_3dfront_orientation_correction: 3d front .obj faces y axis by default, if we want to make it face x axis, set to True.
    :param ignore_asset_instance_idx: useful for generating object renderings for each group of objects
    :return:
    """

    if add_object_bbox:
        assert annotate_object, "add_object_bbox can only be True when annotate_object is True"

    reset_blender()
    setup_background()
    # compute scene boundary
    floor_vertices = np.array(task["boundary"]["floor_vertices"])
    floor_x_values = [point[0] for point in floor_vertices]
    floor_y_values = [point[1] for point in floor_vertices]
    floor_center_x = (max(floor_x_values) + min(floor_x_values)) / 2
    floor_center_y = (max(floor_y_values) + min(floor_y_values)) / 2
    floor_width = max(max(floor_x_values) - min(floor_x_values), max(floor_y_values) - min(floor_y_values))

    wall_height = np.array(task["boundary"]["wall_height"]) if "wall_height" in task["boundary"] else 1
    # Clear existing mesh objects and lights in the scene
    bpy.ops.object.select_all(action='DESELECT')
    bpy.ops.object.select_by_type(type='MESH')
    bpy.ops.object.delete()
    # Create a new empty scene
    # Set the new empty scene as the active scene
    bpy.context.window.scene = bpy.context.scene
    # Update the user interface
    bpy.context.view_layer.update()
    # build floor and walls
    # floor_obj = create_wall_mesh("floor", floor_vertices)
    floor_obj = create_wall_mesh("floor", floor_vertices)
    if adjust_top_down_angle is not None:
        # asset centric rendreing
        floor_material = "Travertine008"
    add_material(floor_obj, os.path.join("/viscam/projects/SceneAug/ambientcg", floor_material))

    bpy.ops.object.select_all(action='DESELECT')
    floor_obj.select_set(True)
    bpy.ops.object.mode_set(mode='EDIT')
    bpy.ops.mesh.select_all(action='SELECT')
    # Unwrap using Smart UV Project
    bpy.ops.uv.smart_project()
    bpy.ops.object.mode_set(mode='OBJECT')

    if annotate_object:
        candidate_colors = get_categorical_colors(20, colormap_name='tab20', color_range="0-1", color_format="rgb")
        asset_count = 0
        asset_dict = {}

    for instance_id, asset in task["assets"].items():
        if instance_id not in placed_assets.keys():
            continue
        objects_before_import = set(bpy.context.scene.objects)
        file_path = asset["path"]
        if ".gltf" in file_path or ".glb" in file_path:
            bpy.ops.import_scene.gltf(filepath=file_path)
        elif ".obj" in file_path:
            bpy.ops.wm.obj_import(filepath=file_path)
        else:
            raise ValueError(f"Unsupported file format: {file_path}")

        if not combine_obj_components:
            loaded = bpy.context.view_layer.objects.active
        else:
            objects_after_import = set(bpy.context.scene.objects)
            new_objects = objects_after_import - objects_before_import
            bpy.ops.object.select_all(action='DESELECT')
            for obj in new_objects:
                obj.select_set(True)
            try:
                bpy.ops.object.join()
            except Exception as e:
                print(f"Error joining objects: {e}, ignoring the join operation")
            loaded = bpy.context.view_layer.objects.active

        # add texture for front 3d objects
        if apply_3dfront_texture:
            texture_path = os.path.join(os.path.split(file_path)[0], "texture.png")
            if os.path.exists(texture_path):
                apply_texture_to_object(loaded, texture_path)

        bpy.ops.object.select_all(action='DESELECT')
        loaded.select_set(True)
        if recenter_mesh:
            bpy.ops.object.origin_set(type='GEOMETRY_ORIGIN', center='BOUNDS')
        # rotate the object according to pose["rotation"] (0, 90, 90)
        # after preprocessing, the object faces -y axis by default
        # make the object face +x by default (Blender rotates the object clockwise!)
        if rotate_90:
            bpy.ops.transform.rotate(value=-math.radians(90), orient_axis='Z')
        # for i in range(3): assert loaded.rotation_euler[i] ==0
        bpy.context.object.rotation_mode = "XYZ"
        if "scale" in placed_assets[instance_id]:
            loaded.scale = placed_assets[instance_id]["scale"]
        #elif "scale" in task["assets"][instance_id]:
        #    loaded.scale = placed_assets[instance_id]["scale"]
        # TODO (Weiyu): Why are we reading both from the `placed_assets` dict and the `task["assets"]` dict? Can we remove one?
        if isinstance(placed_assets[instance_id]["rotation"], float):
            loaded.rotation_euler[-1] += np.deg2rad(placed_assets[instance_id]["rotation"])
        else:
            for i in range(3):
                loaded.rotation_euler[i] += np.deg2rad(placed_assets[instance_id]["rotation"][i])
        bpy.ops.object.transform_apply(location=True, rotation=True, scale=True)
        for i in range(3): assert loaded.rotation_euler[i] ==0 
        #bpy.ops.transform.rotate(value=math.radians(pose['rotation']['y']), orient_axis='Z')
        # dim = get_dimensions_with_hierarchy(loaded)
        # holo_dim = data_holodeck[obj['assetId']]['assetMetadata']['boundingBox']
        xyz_location = placed_assets[instance_id]["position"]
        # default place the object on the floor
        if len(xyz_location) == 2:
            xyz_location = [xyz_location[0], xyz_location[1], placed_assets[instance_id]["scale"] * placed_assets[instance_id]["assetMetadata"]["boundingBox"]["z"]/2]
        loaded.location = xyz_location

        if annotate_object:
            # create obb for the object
            # NOTE: for 3d front assets, the center is at the bottom, but the center of the bbox is at the center
            #asset_location = loaded.location.copy()
            #asset_location[2] = asset_location[2] + asset_scale[2] / 2  # add z
            # extract location, rotation, scale from asset
            asset_position = placed_assets[instance_id]["position"]
            asset_rotation = np.deg2rad(placed_assets[instance_id]["rotation"]) #loaded.rotation_euler
            try:
                asset_scale = get_obj_dimensions(loaded, frame="object")
            except Exception as e:
                print(f"Error getting object dimensions: {e}, using the bounding box instead")
                import pdb;pdb.set_trace()
                continue

            # asset_scale_2 = trimesh.load(file_path).bounding_box.extents
            # asset_tf = tra.euler_matrix(asset_rotation[0], asset_rotation[1], asset_rotation[2])
            # asset_tf = asset_tf @ tra.euler_matrix(0, 0, np.pi/2)
            # asset_rotation = tra.euler_from_matrix(asset_tf)
            if add_object_bbox:
                bbox_rotation = loaded.rotation_euler
                create_bounding_box(asset_position, bbox_rotation, scale=asset_scale, color=candidate_colors[asset_count], transparency=0.3)

            if ignore_asset_instance_idx:
                asset_name = asset["asset_var_name"]
            else:
                asset_name = f"{asset['asset_var_name']}[{asset['instance_idx']}]"

            asset_dict[asset_count] = {
                "position": asset_position, 
                "rotation": asset_rotation,
                "size": asset_scale,
                "name": asset_name,
                "path": file_path, # "texture_path": texture_path,
                "category": asset["category"]
            }
            asset_count += 1

    if add_coordinate_mark:
        # asset-centric mode, add coordinate frame at the bottom left corner of the room
        if adjust_top_down_angle is not None:
            add_coordinate_frame(Vector((floor_center_x-floor_width/2, floor_center_y-floor_width/2, 0)))
        # scene-centric mode, add coordinate frame at the origin
        else:
            add_coordinate_frame()

    ### add light
    if add_hdri:
        load_hdri()

    output_images = []
    set_rendering_settings(high_res=high_res)
    visual_marks = dict()
    ### render top down images
    if render_top_down:
        ### setup camera
        cam, cam_constraint = setup_camera(
            floor_center_x, floor_center_y, floor_width, wall_height,
            fov_multiplier=fov_multiplier, use_damped_track=(adjust_top_down_angle is not None)
        )
        interval = 2
        if adjust_top_down_angle is not None:
            # _phi = math.radians(20)
            cam.rotation_euler = (0, 0, 0)
            original_z = cam.location.z # * 1.5
            theta = 0
            phi = math.radians(adjust_top_down_angle)
            point = (
                floor_center_x + original_z * math.sin(phi) * math.cos(theta),
                floor_center_y + original_z * math.sin(phi) * math.sin(theta),
                original_z * math.cos(phi),
            )
            cam.location = point
            interval = 1
            
        render_path = topdown_save_file if topdown_save_file else f"{save_dir}/top_down_rendering.png" 
        bpy.context.scene.render.filepath = render_path
        bpy.ops.render.render(write_still=True)

        if add_coordinate_mark:
            _visual_marks = get_visual_marks(floor_vertices, bpy.context.scene, cam, interval=interval)
            annotate_image_with_coordinates(image_path=render_path, visual_marks=_visual_marks, output_path=render_path, format="coordinate")

        _visual_marks = []
        if annotate_object:
            for asset_name in asset_dict:
                asset_data = asset_dict[asset_name]
                asset_rotation = asset_data["rotation"]
                pixel_x, pixel_y = get_pixel_coordinates(bpy.context.scene, cam, asset_data["position"])
                end_arrow_pixel_x, end_arrow_pixel_y = get_pixel_coordinates(
                    bpy.context.scene, cam, 
                    [
                        asset_data["position"][0] + 0.75 * math.cos(asset_rotation[-1]),
                        asset_data["position"][1] + 0.75 * math.sin(asset_rotation[-1]),
                        asset_data["position"][2]
                    ]
                )
                _visual_marks.append({ "text": asset_data["name"], "pixel": (pixel_x, pixel_y), "end_arrow_pixel": (end_arrow_pixel_x, end_arrow_pixel_y)})
                print(f"Asset {asset_data['name']} is at pixel ({pixel_x}, {pixel_y})")

        if annotate_wall:
            # Add walls to _visual_marks
            for i, vertex in enumerate(floor_vertices):
                next_vertex = floor_vertices[(i + 1) % len(floor_vertices)]
                # if wall is less than 2 meters, don't annotate
                if np.linalg.norm(np.array(vertex) - np.array(next_vertex)) < 2:
                    continue
                wall_center = [(vertex[0] + next_vertex[0]) / 2, (vertex[1] + next_vertex[1]) / 2, 0]
                # Move the room center 0.5 meters away from [center_x, center_y]
                # direction_vector should be the wall normal direction
                # direction_vector = np.array([floor_center_x, floor_center_y]) - np.array(wall_center[:2])
                # direction_vector = direction_vector / np.linalg.norm(direction_vector)  # Normalize
                direction_vector = get_wall_normal(vertex, next_vertex, add_radian=np.pi/2)
                # get the wall normal
                new_wall_center = np.array(wall_center[:2]) - 0.2 * direction_vector
                wall_center = [new_wall_center[0], new_wall_center[1], 0]
                pixel_x, pixel_y = get_pixel_coordinates(bpy.context.scene, cam, wall_center)
                end_arrow_pixel_x, end_arrow_pixel_y = get_pixel_coordinates(
                    bpy.context.scene, cam, 
                    [
                        wall_center[0] + 0.75 * direction_vector[0],
                        wall_center[1] + 0.75 * direction_vector[1],
                        0
                    ]
                )
                _visual_marks.append({"text": f"walls[{i}]", "pixel": (pixel_x, pixel_y), "end_arrow_pixel": (end_arrow_pixel_x, end_arrow_pixel_y), "color": "white"})

        if adjust_top_down_angle is not None:
            # asset centric mode
            annotate_image_with_coordinates(image_path=render_path, visual_marks=_visual_marks, output_path=render_path, format="text", default_font_size=24)
        else:
            # scene centric mode
            annotate_image_with_coordinates(image_path=render_path, visual_marks=_visual_marks, output_path=render_path, format="text", default_font_size=24 if default_font_size is None else default_font_size)
        output_images.append(render_path)

    ### render side images
    cam, cam_constraint = setup_camera(
        floor_center_x, floor_center_y, floor_width, wall_height,
        fov_multiplier=fov_multiplier, use_damped_track=False
    )
    original_z = cam.location.z
    # remove all cam constraints

    for side_view_index in side_view_indices:
        # set the camera position
        theta = (side_view_index / 4) * math.pi * 2
        _phi = math.radians(side_view_phi)
        point = (
            floor_center_x + original_z * math.sin(_phi) * math.cos(theta),
            floor_center_y + original_z * math.sin(_phi) * math.sin(theta),
            original_z * math.cos(_phi),
        )
        cam.location = point
        # render the image
        render_path = sideview_save_file if sideview_save_file else f"{save_dir}/side_rendering_{side_view_phi}_{side_view_index}.png"
        bpy.context.scene.render.filepath = render_path
        bpy.ops.render.render(write_still=True)
        if add_coordinate_mark:
            visual_marks = get_visual_marks(floor_vertices, bpy.context.scene, cam, interval=2)
            annotate_image_with_coordinates(image_path=render_path, visual_marks=visual_marks, output_path=render_path)
        output_images.append(render_path)

    if save_blend:
        bpy.ops.file.pack_all()
        bpy.ops.wm.save_as_mainfile(filepath=f"{save_dir}/scene.blend")

    return output_images, visual_marks