""" Adapted from `360_view.py` & `360_view_test.py` in the original NeRF synthetic Blender dataset blend-files. """ import argparse import os import json from math import radians import bpy import numpy as np COLOR_SPACES = [ "display", "linear" ] DEVICES = [ "cpu", "cuda", "optix" ] CIRCLE_FIXED_START = ( 0, 0, 0 ) CIRCLE_FIXED_END = ( .7, 0, 0 ) def listify_matrix(matrix): matrix_list = [] for row in matrix: matrix_list.append(list(row)) return matrix_list def parent_obj_to_camera(b_camera): origin = (0, 0, 0) b_empty = bpy.data.objects.new("Empty", None) b_empty.location = origin b_camera.parent = b_empty # setup parenting scn = bpy.context.scene scn.collection.objects.link(b_empty) bpy.context.view_layer.objects.active = b_empty return b_empty def main(args): # open the scene blend-file bpy.ops.wm.open_mainfile(filepath=args.blend_path) # initialize render settings scene = bpy.data.scenes["Scene"] scene.render.engine = "CYCLES" scene.render.use_persistent_data = True if args.device == "cpu": bpy.context.preferences.addons["cycles"].preferences \ .compute_device_type = "NONE" bpy.context.scene.cycles.device = "CPU" elif args.device == "cuda": bpy.context.preferences.addons["cycles"].preferences \ .compute_device_type = "CUDA" bpy.context.scene.cycles.device = "GPU" elif args.device == "optix": bpy.context.preferences.addons["cycles"].preferences \ .compute_device_type = "OPTIX" bpy.context.scene.cycles.device = "GPU" bpy.context.preferences.addons["cycles"].preferences.get_devices() # initialize compositing nodes scene.view_layers[0].use_pass_combined = True scene.use_nodes = True tree = scene.node_tree if args.depth: scene.view_layers[0].use_pass_z = True combine_color = tree.nodes.new("CompositorNodeCombineColor") depth_output = tree.nodes.new("CompositorNodeOutputFile") if args.normal: scene.view_layers[0].use_pass_normal = True normal_output = tree.nodes.new("CompositorNodeOutputFile") if args.depth or args.normal: render_layers = tree.nodes.new("CompositorNodeRLayers") # initialize RGB render image output settings scene.render.filepath = args.renders_path scene.render.use_file_extension = True scene.render.use_overwrite = True scene.render.image_settings.color_mode = "RGBA" if args.color_space == "display": scene.render.image_settings.file_format = "PNG" scene.render.image_settings.color_depth = "8" scene.render.image_settings.color_management = "FOLLOW_SCENE" elif args.color_space == "linear": scene.render.image_settings.file_format = "OPEN_EXR" scene.render.image_settings.color_depth = "32" scene.render.image_settings.use_zbuffer = False if args.depth: # initialize depth render image output settings depth_output.base_path = os.path.join(args.renders_path, "depth") depth_output.file_slots[0].use_node_format = True scene.frame_set(0) depth_output.format.file_format = "OPEN_EXR" depth_output.format.color_mode = "RGB" depth_output.format.color_depth = "32" depth_output.format.exr_codec = "NONE" depth_output.format.use_zbuffer = False # link compositing nodes links = tree.links # output depth img (RGB img is output via the existing composite node) combine_color.mode = "RGB" links.new(render_layers.outputs["Depth"], combine_color.inputs["Red"]) combine_color.inputs["Green"].default_value = 0 combine_color.inputs["Blue"].default_value = 0 combine_color.inputs["Alpha"].default_value = 1 links.new(combine_color.outputs["Image"], depth_output.inputs["Image"]) if args.normal: # initialize normal render image output settings normal_output.base_path = os.path.join(args.renders_path, "normal") normal_output.file_slots[0].use_node_format = True scene.frame_set(0) normal_output.format.file_format = "OPEN_EXR" normal_output.format.color_mode = "RGB" normal_output.format.color_depth = "32" normal_output.format.exr_codec = "NONE" normal_output.format.use_zbuffer = False # link compositing nodes links = tree.links # output normal img (RGB img is output via the existing composite node) combine_color.mode = "RGB" links.new(render_layers.outputs["Normal"], normal_output.inputs["Image"]) # initialize camera settings scene.render.dither_intensity = 0.0 scene.render.film_transparent = True scene.render.resolution_percentage = 100 scene.render.resolution_x = args.resolution[0] scene.render.resolution_y = args.resolution[1] cam = bpy.data.objects["Camera"] cam.location = (0, 4.0, 0.5) cam.rotation_mode = "XYZ" cam_constraint = cam.constraints.new(type="TRACK_TO") cam_constraint.track_axis = "TRACK_NEGATIVE_Z" cam_constraint.up_axis = "UP_Y" b_empty = parent_obj_to_camera(cam) cam_constraint.target = b_empty # preprocess & derive paths args.renders_path = os.path.normpath(args.renders_path) # remove trailing slashes folder_name = os.path.basename(args.renders_path) renders_parent_path = os.path.dirname(args.renders_path) transforms_path = os.path.join( renders_parent_path, f"transforms_{folder_name}.json" ) # render novel views stepsize = 360.0 / args.num_views if not args.random_views: vertical_diff = CIRCLE_FIXED_END[0] - CIRCLE_FIXED_START[0] b_empty.rotation_euler = CIRCLE_FIXED_START b_empty.rotation_euler[0] = CIRCLE_FIXED_START[0] + vertical_diff out_data = { "camera_angle_x": cam.data.angle_x, "frames": [] } for i in range(0, args.num_views): if args.random_views: if args.upper_views: rot = np.random.uniform(0, 1, size=3) * (1,0,2*np.pi) rot[0] = np.abs(np.arccos(1 - 2 * rot[0]) - np.pi/2) b_empty.rotation_euler = rot else: b_empty.rotation_euler = np.random.uniform(0, 2*np.pi, size=3) else: print("Rotation {}, {}".format((stepsize * i), radians(stepsize * i))) scene.render.filepath = os.path.join(args.renders_path, f"r_{i}") if args.depth: depth_output.file_slots[0].path = f"r_{i}" if args.normal: normal_output.file_slots[0].path = f"r_{i}" bpy.ops.render.render(write_still=True) # remove the "0000" suffix in the depth & normal map filenames if args.depth: os.rename(os.path.join(depth_output.base_path, f"r_{i}0000.exr"), os.path.join(depth_output.base_path, f"r_{i}.exr")) if args.normal: os.rename(os.path.join(normal_output.base_path, f"r_{i}0000.exr"), os.path.join(normal_output.base_path, f"r_{i}.exr")) frame_data = { "file_path": os.path.join(".", os.path.relpath( scene.render.filepath, start=renders_parent_path )), "rotation": radians(stepsize), "transform_matrix": listify_matrix(cam.matrix_world) } out_data["frames"].append(frame_data) if args.random_views: if args.upper_views: rot = np.random.uniform(0, 1, size=3) * (1,0,2*np.pi) rot[0] = np.abs(np.arccos(1 - 2 * rot[0]) - np.pi/2) b_empty.rotation_euler = rot else: b_empty.rotation_euler = np.random.uniform(0, 2*np.pi, size=3) else: b_empty.rotation_euler[0] = ( CIRCLE_FIXED_START[0] + (np.cos(radians(stepsize*i))+1)/2 * vertical_diff ) b_empty.rotation_euler[2] += radians(2*stepsize) with open(transforms_path, "w") as out_file: json.dump(out_data, out_file, indent=4) if __name__ == "__main__": parser = argparse.ArgumentParser( description=("Script for rendering novel views of" " synthetic Blender scenes.") ) parser.add_argument( "blend_path", type=str, help="Path to the blend-file of the synthetic Blender scene." ) parser.add_argument( "renders_path", type=str, help="Desired path to the novel view renders." ) parser.add_argument( "num_views", type=int, help="Number of novel view renders." ) parser.add_argument( "resolution", type=int, nargs=2, help="Image resolution of the novel view renders." ) parser.add_argument( "--color_space", type=str, choices=COLOR_SPACES, default="display", help="Color space of the output novel view images." ) parser.add_argument( "--device", type=str, choices=DEVICES, default="cpu", help="Compute device type for rendering." ) parser.add_argument( "--random_views", action="store_true", help="Randomly sample novel views." ) parser.add_argument( "--upper_views", action="store_true", help="Only sample novel views from the upper hemisphere." ) parser.add_argument( "--depth", action="store_true", help="Render depth maps too." ) parser.add_argument( "--normal", action="store_true", help="Render normal maps too." ) args = parser.parse_args() main(args)