eval/LayoutVLM/utils/blender_utils.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


def setup_background():
    import bpy
    # Set up a new world or modify the existing one
    world = bpy.data.worlds.get("World")
    if world is None:
        world = bpy.data.worlds.new("World")
    bpy.context.scene.world = world
    world.use_nodes = True
    # Clear existing nodes
    nodes = world.node_tree.nodes
    nodes.clear()
    # Create the nodes for the world shader
    output_node = nodes.new(type='ShaderNodeOutputWorld')
    output_node.location = (200, 0)
    background_node = nodes.new(type='ShaderNodeBackground')
    background_node.location = (0, 0)
    # Set background node to emit white light
    background_node.inputs['Color'].default_value = (1, 1, 1, 1)  # Background appears white
    background_node.inputs['Strength'].default_value = 1.0  # Uniform light strength
    # Connect the nodes
    world.node_tree.links.new(background_node.outputs['Background'], output_node.inputs['Surface'])
    print("White background set up.")

def reset_blender():
    bpy.ops.wm.read_factory_settings()
    #for scene in bpy.data.scenes:
    #    for obj in scene.objects:
    #        scene.objects.unlink(obj)
    #for block in bpy.data.orphaned_data:
    #    bpy.data.orphaned_data.remove(block)
    bpy.ops.outliner.orphans_purge(do_recursive=True)
    for scene in bpy.data.scenes:
        if scene.rigidbody_world:
            scene.rigidbody_world.point_cache.frame_start = 1
            bpy.ops.ptcache.free_bake_all()

def clear_render_results():
    for scene in bpy.data.scenes:
        for area in bpy.context.screen.areas:
            if area.type == 'IMAGE_EDITOR':
                for space in area.spaces:
                    if space.type == 'IMAGE_EDITOR' and space.image:
                        space.image = None
    if bpy.data.images.get("Render Result"):
        bpy.data.images.remove(bpy.data.images["Render Result"], do_unlink=True)

def reset_scene():
    # Clear render results first
    #clear_render_results()
    
    # Unlink all objects first
    for obj in bpy.data.objects:
        if obj.type not in {"CAMERA", "LIGHT"}:
            bpy.data.objects.remove(obj, do_unlink=True)

    # Check for users and remove materials
    for material in bpy.data.materials:
        if material.users == 0:
            bpy.data.materials.remove(material, do_unlink=True)

    # Check for users and remove textures
    for texture in bpy.data.textures:
        if texture.users == 0:
            bpy.data.textures.remove(texture, do_unlink=True)

    # Check for users and remove images
    for image in bpy.data.images:
        if image.users == 0:
            bpy.data.images.remove(image, do_unlink=True)
    

def import_glb(file_path, location=(0, 0, 0), rotation=(0, 0, 0), scale=(0.01, 0.01, 0.01),centering=True):
    if not os.path.exists(file_path):
        return None
    # Import GLB file
    bpy.ops.import_scene.gltf(filepath=file_path)

    # Get the imported object
    imported_object = bpy.context.selected_objects[0]

    # Set the location, rotation, and scale
    # imported_object.location = location
    imported_object.rotation_euler = rotation
    imported_object.scale = scale

    # offset = -imported_object.location
    if centering:
        bpy.context.view_layer.objects.active = imported_object
        bpy.ops.object.origin_set(type='GEOMETRY_ORIGIN', center='BOUNDS')

    # Apply the offset to keep the specified location
    # imported_object.location += offset
    imported_object.location = location
    return imported_object


def create_wall_mesh(name, vertices):
    # Create a new mesh
    mesh = bpy.data.meshes.new(name)
    obj = bpy.data.objects.new(name, mesh)

    # Link the object to the scene
    scene = bpy.context.scene
    scene.collection.objects.link(obj)

    # Make the new object the active object
    bpy.context.view_layer.objects.active = obj
    obj.select_set(True)

    # Enter Edit mode to create the wall geometry
    bpy.ops.object.mode_set(mode='EDIT')

    # Create a BMesh
    bm = bmesh.new()

    # Create the vertices
    for v in vertices:
        bm.verts.new(v)

    # Ensure the lookup table is updated
    bm.verts.ensure_lookup_table()


    # Create the edges between consecutive vertices
    for i in range(len(vertices)-1):
        bm.edges.new([bm.verts[i], bm.verts[i+1]])

    # Create the face (assuming a closed loop)
    bm.faces.new(bm.verts)

    bpy.ops.object.mode_set(mode='OBJECT')


    # Update the mesh with the BMesh data
    bm.to_mesh(mesh)
    bm.free()
    return obj 


def create_cube(name, min_xyz, max_xyz,location,rotate=False):
    # Calculate dimensions of the cube
    print(min_xyz)
    print(max_xyz)
    dimensions = [max_xyz[i] - min_xyz[i] for i in range(3)]

    # Calculate location of the cube
    # location = [(max_xyz[i] + min_xyz[i]) / 2 for i in range(3)]

    # Create the cube object
    bpy.ops.mesh.primitive_cube_add(size=1, location=location)
    cube = bpy.context.active_object

    # Resize the cube to the specified dimensions
    cube.dimensions = dimensions

    if rotate:
        bpy.context.view_layer.objects.active = cube
        bpy.ops.transform.rotate(value=math.radians(90), orient_axis='Z')


    # cube.location.x += assetPosition[0]
    # cube.location.y += assetPosition[2]
    # cube.location.z += assetPosition[1]
    # Set the cube name
    cube.name = name
    return cube


def is_image_loaded(image_filepath):
    for image in bpy.data.images:
        if image.filepath == image_filepath:
            return image
    return None


def apply_texture_to_object(obj, texture_path):
    # Create a new material
    mat = bpy.data.materials.new(name="TextureMaterial")
    mat.use_nodes = True
    bsdf = mat.node_tree.nodes.get("Principled BSDF")

    # Load the texture image
    tex_image = mat.node_tree.nodes.new('ShaderNodeTexImage')
    tex_image.image = bpy.data.images.load(texture_path)

    # Connect the texture to the BSDF
    mat.node_tree.links.new(bsdf.inputs['Base Color'], tex_image.outputs['Color'])

    # Assign the material to the object
    if obj.data.materials:
        obj.data.materials[0] = mat
    else:
        obj.data.materials.append(mat)


def add_material(obj, path_texture, add_uv=False, material_pos=-1, texture_scale=(1.8, 1.8), existing_material_name=None):
    material_id = os.path.basename(path_texture)
    if add_uv:
        bpy.ops.object.select_all(action='DESELECT')
        bpy.context.view_layer.objects.active = obj

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

        # Switch back to Object mode
        bpy.ops.object.mode_set(mode='OBJECT')

    bpy.context.view_layer.objects.active = obj

    # Check if the material already exists
    existing_material = bpy.data.materials.get(material_id)
    if existing_material:
        new_material = existing_material
    else:
        # Create a new material
        new_material = bpy.data.materials.new(name=material_id)
        new_material.use_nodes = True
        node_tree = new_material.node_tree

        # Clear default nodes
        for node in node_tree.nodes:
            node_tree.nodes.remove(node)

        principled_node = node_tree.nodes.new(type='ShaderNodeBsdfPrincipled')
# Create an image texture node
        image_texture_node = node_tree.nodes.new(type='ShaderNodeTexImage')
        
        resolutions = ["1K", "2K", "12K"]
        for resolution in resolutions:
            if os.path.exists(f"{path_texture}/{material_id}_{resolution}-JPG_Color.jpg"):
                break
        else:
            print("No texture found for the object.")
            return

        image = is_image_loaded(f"{path_texture}/{material_id}_{resolution}-JPG_Color.jpg")
        if image is None:
            image = load_image(f"{path_texture}/{material_id}_{resolution}-JPG_Color.jpg", new_material)
        image_texture_node.image = image

        # Add Texture Coordinate and Mapping nodes for texture scaling
        tex_coord_node = node_tree.nodes.new(type='ShaderNodeTexCoord')
        mapping_node = node_tree.nodes.new(type='ShaderNodeMapping')
        mapping_node.inputs['Scale'].default_value[0] = texture_scale[0]
        mapping_node.inputs['Scale'].default_value[1] = texture_scale[1]

        # Link nodes
        node_tree.links.new(tex_coord_node.outputs['UV'], mapping_node.inputs['Vector'])
        node_tree.links.new(mapping_node.outputs['Vector'], image_texture_node.inputs['Vector'])

        # normal
        img_normal = is_image_loaded(f"{path_texture}/{material_id}_{resolution}-JPG_NormalGL.jpg")
        if img_normal is None:
            img_normal = load_image(f"{path_texture}/{material_id}_{resolution}-JPG_NormalGL.jpg", new_material)
        image_texture_node_normal = node_tree.nodes.new(type='ShaderNodeTexImage')
        image_texture_node_normal.image = img_normal    
        image_texture_node_normal.image.colorspace_settings.name = 'Non-Color'

        normal_map_node = node_tree.nodes.new(type='ShaderNodeNormalMap')

        node_tree.links.new(normal_map_node.outputs["Normal"], principled_node.inputs["Normal"])
        node_tree.links.new(image_texture_node_normal.outputs["Color"], normal_map_node.inputs["Color"])

        # rough
        if os.path.exists(f"{path_texture}/{material_id}_{resolution}-JPG_Roughness.jpg"):
            img_rough = is_image_loaded(f"{path_texture}/{material_id}_{resolution}-JPG_Roughness.jpg")
            if img_rough is None:
                img_rough = load_image(f"{path_texture}/{material_id}_{resolution}-JPG_Roughness.jpg", new_material)

            image_texture_node_rough = node_tree.nodes.new(type='ShaderNodeTexImage')
            image_texture_node_rough.image = img_rough    
            image_texture_node_rough.image.colorspace_settings.name = 'Non-Color'

            node_tree.links.new(image_texture_node_rough.outputs["Color"], principled_node.inputs["Roughness"])

        # metal
        if os.path.exists(f"{path_texture}/{material_id}_{resolution}-JPG_Metalness.jpg"):
            img_metal = is_image_loaded(f"{path_texture}/{material_id}_{resolution}-JPG_Metalness.jpg")
            if img_metal is None:
                img_metal = load_image(f"{path_texture}/{material_id}_{resolution}-JPG_Metalness.jpg", new_material)

            image_texture_node_metal = node_tree.nodes.new(type='ShaderNodeTexImage')
            image_texture_node_metal.image = img_metal    
            image_texture_node_metal.image.colorspace_settings.name = 'Non-Color'

            node_tree.links.new(image_texture_node_metal.outputs["Color"], principled_node.inputs["Metallic"])

        # connecting
        node_tree.links.new(image_texture_node.outputs["Color"], principled_node.inputs["Base Color"])
        
        material_output_node = node_tree.nodes.new(type='ShaderNodeOutputMaterial')
        node_tree.links.new(principled_node.outputs["BSDF"], material_output_node.inputs["Surface"])

    if existing_material_name is not None:
        # link the part of the object that connects to existing material with the new material
        for slot in obj.material_slots:
            ### case insensitive comparison
            if slot.material and existing_material_name.lower() in slot.material.name.lower():
                # Create a new material slot and assign the new material to it
                obj.data.materials.append(new_material)
                new_slot_index = len(obj.material_slots) - 1
                # Assign the new material slot to the faces that used the old material
                for polygon in obj.data.polygons:
                    if polygon.material_index == obj.material_slots.find(slot.name):
                        polygon.material_index = new_slot_index
    else:
        # Link the material to the object
        if material_pos == -1 or len(obj.data.materials) == 0:
            obj.data.materials.clear()
            obj.data.materials.append(new_material)
        else:
            obj.data.materials[material_pos] = new_material


def load_hdri(hdri_path='./data/HDRIs/studio_small_08_4k.exr', hdri_strength=1, hide=True):  # Replace with the correct path
    # Path to the HDRI file
    # Ensure this path is correct and points to the 'meadow_4k.exr' file on your system

    if not os.path.exists(hdri_path):
        current_file = os.path.abspath(__file__)
        hdri_path = os.path.join(os.path.dirname(os.path.dirname(current_file)), hdri_path)

    # Check if the file exists
    if not os.path.exists(hdri_path):
        print("HDRI file not found:", hdri_path)
    else:
        # Get the world
        world = bpy.data.worlds['World']  # Replace 'World' with your world name if different

        # Enable nodes for the world
        world.use_nodes = True
        nodes = world.node_tree.nodes
        links = world.node_tree.links

        # Clear existing nodes (optional, be careful with this)
        # for node in nodes:
        #     nodes.remove(node)

        # Create a new Environment Texture node
        env_texture = nodes.new(type='ShaderNodeTexEnvironment')

        texture_coord = nodes.new(type="ShaderNodeTexCoord")
        # create a new Mapping node
        mapping_node = nodes.new(type='ShaderNodeMapping')

        # Load the HDRI image
        env_texture.image = bpy.data.images.load(hdri_path)

        # Create a Background node
        background = nodes.new(type='ShaderNodeBackground')
        background.location = (-100, 0)

        # Create a World Output node if it doesn't exist
        if 'World Output' not in nodes:
            world_output = nodes.new(type='ShaderNodeOutputWorld')
            world_output.location = (100, 0)
        else:
            world_output = nodes['World Output']

        if hide:
            # Prevent HDRI from showing in the background
            # Add a Light Path node and mix shader to control the visibility
            light_path = nodes.new(type='ShaderNodeLightPath')
            mix_shader = nodes.new(type='ShaderNodeMixShader')
            bg_transparent = nodes.new(type='ShaderNodeBackground')
            bg_transparent.inputs['Color'].default_value = (0, 0, 0, 1)  # Black, fully transparent
            # Link the nodes to use Light Path for mixing
            links.new(light_path.outputs['Is Camera Ray'], mix_shader.inputs['Fac'])
            links.new(background.outputs['Background'], mix_shader.inputs[1])
            links.new(bg_transparent.outputs['Background'], mix_shader.inputs[2])
            links.new(mix_shader.outputs['Shader'], world_output.inputs['Surface'])
        else:
            links.new(background.outputs['Background'], world_output.inputs['Surface'])

        # Link the nodes
        links.new(texture_coord.outputs['Generated'], mapping_node.inputs['Vector'])
        links.new(mapping_node.outputs['Vector'], env_texture.inputs['Vector'])
        links.new(env_texture.outputs['Color'], background.inputs['Color'])
        background.inputs['Strength'].default_value = hdri_strength
        print("HDRI background set successfully.")


def setup_camera(center_x, center_y, width, wall_height=.1, wide_lens=False, fov_multiplier=1.1, use_damped_track=False):
    # Check if the camera exists, if not, create one
    if "Camera" not in bpy.data.objects:
        bpy.ops.object.camera_add()
        cam = bpy.context.object
    else:
        cam = bpy.data.objects["Camera"]
    bpy.context.scene.camera = cam

    if wide_lens:
        cam.data.lens /= 2 #35/2
    #cam.data.type = 'ORTHO'

    target_width = abs(fov_multiplier * width)  # Target width to cover
    fov = 2 * math.atan((cam.data.sensor_width / (2 * cam.data.lens)))  # Horizontal FoV calculation
    cam.location.x = center_x
    cam.location.y = center_y
    cam.location.z = wall_height + (target_width / 2) / math.tan(fov / 2)  # Z position calculation

    # clear camera constraints
    cam.constraints.clear()
    if use_damped_track:
        cam_constraint = cam.constraints.new(type="DAMPED_TRACK")
        cam_constraint.track_axis = "TRACK_NEGATIVE_Z"
    else:
        cam_constraint = cam.constraints.new(type="TRACK_TO")
        cam_constraint.track_axis = "TRACK_NEGATIVE_Z"
        cam_constraint.up_axis = "UP_Y"

    empty = bpy.data.objects.new("Empty", None)
    empty.location = (center_x, center_y, 0)
    bpy.context.scene.collection.objects.link(empty)
    cam_constraint.target = empty
    # cam_constraint.up_axis = "UP_Y"
    return cam, cam_constraint


def world_to_camera_view(scene, camera, coord):
    """Convert world coordinates to camera view coordinates"""
    co_local = camera.matrix_world.normalized().inverted() @ coord
    z = -co_local.z

    camera_data = camera.data
    frame = [-v for v in camera_data.view_frame(scene=scene)[:3]]
    if camera_data.type != 'ORTHO':
        frame = [(v / (v.z / z)) for v in frame]

    min_x, max_x = frame[1].x, frame[2].x
    min_y, max_y = frame[0].y, frame[1].y
    x = (co_local.x - min_x) / (max_x - min_x)
    y = (co_local.y - min_y) / (max_y - min_y)
    return Vector((x, y, z))


def get_pixel_coordinates(scene, camera, world_coord):
    """Get pixel coordinates for a given world coordinate"""
    if isinstance(world_coord, np.ndarray) or isinstance(world_coord, list):
        world_coord = Vector(world_coord)
    coord_2d = world_to_camera_view(scene, camera, world_coord)
    return (coord_2d.x, 1 - coord_2d.y)
    #import pdb;pdb.set_trace()
    #render = scene.render
    #return (
    #    round(coord_2d.x * render.resolution_x),
    #    round(coord_2d.y * render.resolution_y)
    #)


def set_rendering_settings(panorama=False, high_res=False) -> None:
    render = bpy.context.scene.render
    render.engine = 'CYCLES'
    render.image_settings.file_format = "PNG"
    render.image_settings.color_mode = "RGBA"

    # Enable CUDA and select all CUDA GPUs
    try:
        bpy.context.preferences.addons['cycles'].preferences.compute_device_type = 'CUDA'
        for device in bpy.context.preferences.addons['cycles'].preferences.devices:
            if device.type == 'CUDA':
                device.use = True
    except:
        print('no CUDA devices found')

    render.resolution_x = 512
    render.resolution_y = 512
    #    bpy.context.scene.cycles.samples = 32
    #    bpy.context.scene.cycles.diffuse_bounces = 1
    #    bpy.context.scene.cycles.glossy_bounces = 1
    #    bpy.context.scene.cycles.transparent_max_bounces = 2
    #    bpy.context.scene.cycles.transmission_bounces = 2

    render.resolution_percentage = 50
    if high_res:
        render.resolution_x = 1080 #1920
        render.resolution_y = 1080
        render.resolution_percentage = 100
    bpy.context.scene.cycles.device = "GPU"
    bpy.context.scene.cycles.samples = 128

    bpy.context.scene.cycles.diffuse_bounces = 3
    bpy.context.scene.cycles.glossy_bounces = 3
    bpy.context.scene.cycles.transparent_max_bounces = 5
    bpy.context.scene.cycles.transmission_bounces = 5
    bpy.context.scene.cycles.filter_width = 0.01

    bpy.context.scene.cycles.use_denoising = True
    indoor_camera = False
    if indoor_camera:
        bpy.context.scene.render.film_transparent = False
    else:
        bpy.context.scene.render.film_transparent = True


def display_vertex_color():
    # Ensure we are in object mode
    bpy.ops.object.mode_set(mode='OBJECT')

    # Get the active object
    obj = bpy.context.active_object

    # Create a new material
    material = bpy.data.materials.new(name="ColorAttributeMaterial")
    material.use_nodes = True
    nodes = material.node_tree.nodes

    # Clear all nodes to start clean
    for node in nodes:
        nodes.remove(node)

    # Create Principled BSDF and Material Output nodes
    bsdf = nodes.new(type='ShaderNodeBsdfPrincipled')
    output = nodes.new(type='ShaderNodeOutputMaterial')

    # Link BSDF to Material Output
    material.node_tree.links.new(bsdf.outputs['BSDF'], output.inputs['Surface'])

    # Set the location of the nodes
    bsdf.location = (0, 0)
    output.location = (200, 0)

    # Check if the object has a color attribute
    if "Col" in obj.data.attributes:
        # Create an Attribute node and set it to the color attribute
        attr = nodes.new(type='ShaderNodeAttribute')
        attr.attribute_name = "Col"  # Replace 'Col' with the name of your color attribute

        # Link Attribute node to BSDF
        material.node_tree.links.new(attr.outputs['Color'], bsdf.inputs['Base Color'])
    else:
        print("Object has no color attribute.")

    # Assign the material to the object
    if obj.data.materials:
        obj.data.materials[0] = material
    else:
        obj.data.materials.append(material)


if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='Renders given obj file by rotation a camera around it.')

    parser.add_argument(
        '--output', 
        type=str, 
        default='/viscam/u/sgu33/GenLayout/temp_rendering/',
        help='The path the output will be dumped to.'
    )
    parser.add_argument(
        '--json',
        help='path to the json to load from holodeck'
    )

    parser.add_argument(
        '--content',
        help='path to content for loading windows and doors'
    )

    parser.add_argument(
        '--asset_source',
        help='default should be objaverse'
    )

    parser.add_argument(
        '--asset_dir',
        help='path to the asset respository'
    )

    #parser.add_argument(
    #    '--objaverse_path',
    #    help='objaverse path'
    #)

    # output = '/viscam/u/sgu33/GenLayout/temp_rendering/'
    # data_path = '/viscam/projects/GenLayout/3dfront_processed/3dfront/b59e2e3f-d611-4e62-a72a-b3d7ff4bbd08/Bedroom-15614/scene_revised.json'

    # with open(data_path, 'r') as file:
    #     data = json.load(file)
    # task = data["task"]
    # group = data["group"]
    # render_scene(group, task, output, render_top_down=True, render_pano=True, high_res=False, num_side_images=0, phi=45, save_blend=False)