File size: 4,794 Bytes
fb6f9ba |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 |
import open3d as o3d
import matplotlib.pyplot as plt
import numpy as np
import os
import math
import torch
from PIL import Image
import random
from einops import einsum
@torch.no_grad()
def get_frustum_mask(points, H, W, intrinsics, view_matrices, near = 0.02, far = 10.):
ones = torch.ones_like(points[:, 0]).unsqueeze(-1)
homo_points = torch.cat([points, ones], dim=-1)
view_points = einsum(view_matrices, homo_points, "b c, N c -> N b")
view_points = view_points[:, :3]
uv_points = einsum(intrinsics, view_points, "b c, N c -> N b")
z = uv_points[:, -1:]
uv_points = uv_points[:, :2] / z
u, v = uv_points[:, 0], uv_points[:, 1]
depth = view_points[:, -1]
cull_near_fars = (depth >= near) & (depth <= far)
mask = cull_near_fars & (u >= 0) & (u <= W-1) & (v >= 0) & (v <= H-1)
return mask
def config_parser():
import configargparse
parser = configargparse.ArgumentParser()
# training options
parser.add_argument("--near", type=float, default=0.,
help='near distance')
parser.add_argument("--far", type=float, default=10.,
help='far distance')
parser.add_argument("--camera_height", type=int, default=24,
help='height of the feature map')
parser.add_argument("--camera_width", type=int, default=24,
help='width of the feature map')
parser.add_argument("--feature_fields_search_radius", type=float, default=1.,
help='search radius for near features')
parser.add_argument("--feature_fields_search_num", type=int, default=4,
help='The number of searched near features')
parser.add_argument("--mlp_net_layers", type=int, default=8,
help='layers in mlp network')
parser.add_argument("--mlp_net_width", type=int, default=768,
help='channels per layer in mlp net')
# rendering options
parser.add_argument("--N_samples", type=int, default=512,
help='number of coarse samples per ray')
parser.add_argument("--N_importance", type=int, default=16,
help='number of fine samples per ray')
return parser
parser = config_parser()
args, unknown = parser.parse_known_args() #parser.parse_args()
scene_list = os.listdir('3RScan')
image_list = []
for scene_id in scene_list:
for image_id in range(1000):
image_path = '3RScan/'+scene_id+'/sequence/frame-'+str(image_id).zfill(6)+'.color.jpg'
if not os.path.exists(image_path):
break
image_list.append('3RScan/'+scene_id+'/sequence/frame-'+str(image_id).zfill(6))
random.shuffle(image_list)
image_list = image_list[:30]
#image_list = random.sample(image_list,min(30,len(image_list)))
pcd_all = o3d.geometry.PointCloud()
for image_path in image_list:
intrinsic = np.eye(4)
with open('3RScan/'+scene_id+'/sequence/_info.txt', 'r') as file:
intrinsic_raw = [line.strip() for line in file]
intrinsic_raw = intrinsic_raw[9].split(" ")[2:]
for i in range(4):
for j in range(4):
intrinsic[i][j] = float(intrinsic_raw[i*4+j])
extrinsic = np.eye(4)
with open(image_path+'.pose.txt', 'r') as file:
extrinsic_raw = [line.strip() for line in file]
for i in range(4):
for j in range(4):
extrinsic[i][j] = float(extrinsic_raw[i].split()[j])
R = extrinsic[:3,:3]
T = extrinsic[:3,3:4]
color_raw = o3d.io.read_image(image_path + ".color.jpg")
depth_raw = o3d.geometry.Image(np.asarray(Image.open(image_path + ".depth.pgm")).astype(np.uint16))
#rgbd_image = o3d.geometry.RGBDImage.create_from_color_and_depth(color_raw, depth_raw, depth_scale=1000.0, depth_trunc=1000.0, convert_rgb_to_intensity=False)
#pcd = o3d.geometry.PointCloud.create_from_rgbd_image(rgbd_image,o3d.camera.PinholeCameraIntrinsic(224,172,intrinsic[0][0],intrinsic[1][1],intrinsic[0][2],intrinsic[1][2]))
pcd = o3d.geometry.PointCloud.create_from_depth_image(depth_raw, o3d.camera.PinholeCameraIntrinsic(224,172,intrinsic[0][0],intrinsic[1][1],intrinsic[0][2],intrinsic[1][2]), depth_scale=1000.0, depth_trunc=1000.0)
points = np.asarray(pcd.points)
points = (R @ points.T + T).T
pcd.points = o3d.utility.Vector3dVector(points)
pcd_all += pcd
#o3d.visualization.draw_geometries([pcd_all])
#mask = get_frustum_mask(torch.tensor(np.array(pcd_all.points)), 240, 320, intrinsic[:3,:3], np.linalg.inv(extrinsic), near = 0.02, far = 10.)
o3d.visualization.draw_geometries([pcd_all]) |