Upload 206 files

indoor_motor/bpy_render_views.py

@@ -0,0 +1,193 @@
+import argparse
+import os
+import json
+from math import radians
+import bpy
+import numpy as np
+
+COLOR_SPACES = ["display", "linear"]
+DEVICES = ["cpu", "cuda", "optix"]
+
+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):
+    b_empty = bpy.data.objects.new("Empty", None)
+    b_empty.location = origin
+    b_camera.parent = b_empty
+
+    scn = bpy.context.scene
+    scn.collection.objects.link(b_empty)
+    bpy.context.view_layer.objects.active = b_empty
+
+    return b_empty
+
+def main(args):
+    bpy.ops.wm.open_mainfile(filepath=args.blend_path)
+
+    scene = bpy.data.scenes["Scene"]
+    scene.render.engine = "CYCLES"
+    scene.render.use_persistent_data = True
+    scene.cycles.samples = 256
+    bpy.context.scene.unit_settings.scale_length = 0.01
+    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()
+    
+    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")
+
+    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"
+
+    if args.depth:
+        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"
+
+        links = tree.links
+        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:
+        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"
+
+        links = tree.links
+        combine_color.mode = "RGB"
+        links.new(render_layers.outputs["Normal"], normal_output.inputs["Image"])
+
+    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.0, -3.5 , 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, (0, -4.0, 1.0))
+    cam_constraint.target = b_empty
+
+    args.renders_path = os.path.normpath(args.renders_path)
+    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")
+
+    stepsize = 360.0 / args.num_views
+    out_data = {
+        "camera_angle_x": cam.data.angle_x,
+        "frames": []
+    }
+
+    for i in range(args.num_views):
+        if args.random_views:
+            if args.upper_views:
+                # 从上半球随机采样视图
+                # 限制 x 轴（pitch）的旋转范围以避免向下拍摄
+                pitch = radians(np.random.uniform(-15.0 , 15.0))  # 限制俯仰角在 0 到 90 度之间
+                yaw = radians(np.random.uniform(0, 360))   # 随机偏航角
+                b_empty.rotation_euler = (pitch, 0, yaw)
+            else:
+                # 完全随机采样视图
+                b_empty.rotation_euler = (
+                    radians(np.random.uniform(0, 180)),
+                    0,
+                    radians(np.random.uniform(0, 360))
+                )
+        else:
+            # 等间隔采样视图
+            b_empty.rotation_euler[2] = radians(i * stepsize)
+
+        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)
+
+        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(i * stepsize),
+            "transform_matrix": listify_matrix(cam.matrix_world)
+        }
+        out_data["frames"].append(frame_data)
+
+    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, default=[1080, 720], 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="cuda", 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)
+# python bpy_render_views.py /home/falcary/workstation/blender_env_indoors_dataset/outputs/Capsule/Capsule_Trajetory/C ./test/ 200 800 800 --color_space display --device cuda --random_views --depth --normal
+# python bpy_render_views.py /home/falcary/workstation/blender_env_indoors_dataset/indoors_car/car_obj/Lighting Scene-1_Trajectory.blend ./val/ 10 800 800 --color_space display --device optix  --depth --normal
+    

indoor_motor/get_trajectory_in_blender.py

@@ -0,0 +1,67 @@
+import bpy
+import csv
+from math import pi
+
+# 设置导出文件的路径
+export_file = "/home/falcary/workstation/blender_env_indoors_dataset/outputs/Capsule/output_in_blender.csv"
+
+# 假设动画以24帧每秒的速度播放
+# 每帧之间的时间间隔（秒）
+frame_duration = 1 / 10
+
+# 获取当前激活的相机对象
+camera = bpy.context.scene.camera
+
+# 如果存在相机且相机类型是'CAMERA'
+if camera is not None and camera.type == 'CAMERA':
+    # 获取当前场景的起始和结束帧
+    start_frame = bpy.context.scene.frame_start
+    end_frame = bpy.context.scene.frame_end
+    
+    # 准备存储相机变换数据的列表
+    camera_transforms = []
+    
+    # 遍历指定的帧范围内的每一帧
+    for frame in range(start_frame, end_frame + 1):
+        # 设置当前帧
+        bpy.context.scene.frame_set(frame)
+        # 更新场景以获取最新数据
+        bpy.context.view_layer.update()
+        bpy.context.evaluated_depsgraph_get().update()
+        
+        # 获取相机的世界坐标位置
+        loc = camera.matrix_world.to_translation()
+        # 获取相机的世界旋转（欧拉角）
+        rot = camera.matrix_world.to_euler('XYZ')
+        
+        # 计算时间戳，假设帧率为24fps，将帧转换为微秒
+        timestamp = (frame - start_frame) * frame_duration * 1e7
+        scale = 1.0
+        # 添加位置和旋转数据到列表
+        camera_transforms.append({
+            'timestamp': int(timestamp),  # 时间戳为整数微秒
+            'x': loc.x * scale,
+            'y': loc.y * scale,
+            'z': loc.z * scale,
+            # 将旋转角度转换为弧度，确保在[0, 2*pi)范围内
+            'rx': (rot.x + 2 * pi) % (2 * pi),
+            'ry': (rot.y + 2 * pi) % (2 * pi),
+            'rz': (rot.z + 2 * pi) % (2 * pi),
+        })
+    
+    # 导出到CSV文件
+    with open(export_file, 'w', newline='') as csvfile:
+        fieldnames = ['timestamp', 'x', 'y', 'z', 'rx', 'ry', 'rz']
+        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+        
+        # 写入表头
+        csvfile.write('# ' + ', '.join(fieldnames) + '\n')
+        
+        # 写入变换数据
+        for transform in camera_transforms:
+            writer.writerow(transform)
+    
+    print(f"Camera transforms exported to {export_file}")
+else:
+    print("No camera selected or active object is not a camera.")
+

indoor_motor/get_trajectory_in_blender_quan.py

@@ -0,0 +1,68 @@
+import bpy
+import csv
+from math import pi
+
+# 设置导出文件的路
+export_file = "/home/falcary/workstation/blender_env_indoors_dataset/outputs/AI58_002/output_in_blender_quan.csv"
+  
+# 假设动画以24帧每秒的速度播放
+# 每帧之间的时间间隔（秒）
+frame_duration = 1 / 10
+
+# 获取当前激活的相机对象
+camera = bpy.context.scene.camera
+bpy.context.scene.unit_settings.scale_length = 1.00
+
+# 如果存在相机且相机类型是'CAMERA'
+if camera is not None and camera.type == 'CAMERA':
+    # 获取当前场景的起始和结束帧
+    start_frame = bpy.context.scene.frame_start
+    end_frame = bpy.context.scene.frame_end
+    
+    # 准备存储相机变换数据的列表
+    camera_transforms = []
+    
+    # 遍历指定的帧范围内的每一帧
+    for frame in range(start_frame, end_frame + 1):
+        # 设置当前帧
+        bpy.context.scene.frame_set(frame)
+        # 更新场景以获取最新数据
+        bpy.context.view_layer.update()
+        bpy.context.evaluated_depsgraph_get().update()
+        
+        # 获取相机的世界坐标位置
+        loc = camera.matrix_world.to_translation()
+        # 获取相机的世界旋转（四元数）
+        quat = camera.matrix_world.to_quaternion()
+        
+        # 计算时间戳，假设帧率为24fps，将帧转换为微秒
+        timestamp = (frame - start_frame) * frame_duration * 1e7
+        scale = bpy.context.scene.unit_settings.scale_length
+        # 添加位置和旋转数据到列表
+        camera_transforms.append({
+            'timestamp': int(timestamp),  # 时间戳为整数微秒
+            'x': loc.x * scale,
+            'y': loc.y * scale,
+            'z': loc.z * scale,
+            'qx': quat.x,
+            'qy': quat.y,
+            'qz': quat.z,
+            'qw': quat.w,
+        })
+    
+    # 导出到CSV文件
+    with open(export_file, 'w', newline='') as csvfile:
+        fieldnames = ['timestamp', 'x', 'y', 'z', 'qx', 'qy', 'qz', 'qw']
+        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+        
+        # 写入表头
+        csvfile.write('# ' + ', '.join(fieldnames) + '\n')
+        
+        # 写入变换数据
+        for transform in camera_transforms:
+            writer.writerow(transform)
+    
+    print(f"Camera transforms exported to {export_file}")
+else:
+    print("No camera selected or active object is not a camera.")
+