|
import os
|
|
from pathlib import Path
|
|
|
|
import colorsys
|
|
import numpy as np
|
|
import torch
|
|
import torchvision
|
|
from einops import rearrange
|
|
from torch.utils.data import Dataset
|
|
from PIL import Image as PIL_Image
|
|
from PIL import ImageDraw
|
|
from torchvision import transforms
|
|
import matplotlib.pyplot as plt
|
|
from matplotlib.animation import FuncAnimation
|
|
import matplotlib
|
|
import itertools
|
|
|
|
torchvision.disable_beta_transforms_warning()
|
|
import torchvision.transforms.v2 as transforms
|
|
from torchvision.tv_tensors import (BoundingBoxes, BoundingBoxFormat, Image,
|
|
Mask)
|
|
from flow_viz import flow_to_image
|
|
|
|
categories = ["Action Figures", "Bag", "Board Games", "Bottles and Cans and Cups", "Camera", "Car Seat", "Consumer Goods", "Hat", "Headphones", "Keyboard", "Legos", "Media Cases", "Mouse", "None", "Shoe", "Stuffed Toys", "Toys"]
|
|
|
|
def save_tensor_dict(tensor_dict: dict, path: Path):
|
|
output_dict = {}
|
|
for k, v in tensor_dict.items():
|
|
output_dict[k] = v
|
|
np.savez_compressed(path, **output_dict)
|
|
|
|
def get_n_distinct_colors(n):
|
|
def HSVToRGB(h, s, v):
|
|
(r, g, b) = colorsys.hsv_to_rgb(h, s, v)
|
|
return (int(255 * r), int(255 * g), int(255 * b))
|
|
|
|
huePartition = 1.0 / (n + 1)
|
|
return (HSVToRGB(huePartition * value, 1.0, 1.0) for value in range(0, n))
|
|
|
|
def get_layered_image_from_binary_mask(masks, flip=False):
|
|
if torch.is_tensor(masks):
|
|
masks = masks.float().cpu().detach().numpy()
|
|
if flip:
|
|
masks = np.flipud(masks)
|
|
|
|
masks = masks.astype(np.bool_)
|
|
|
|
colors = np.asarray(list(get_n_distinct_colors(masks.shape[2])))
|
|
img = np.zeros((*masks.shape[:2], 3))
|
|
for i in range(masks.shape[2]):
|
|
img[masks[..., i]] = colors[i]
|
|
|
|
return Image.fromarray(img.astype(np.uint8))
|
|
|
|
def get_max_neighboring_depth(depth, coords):
|
|
|
|
S, H, W, _ = depth.shape
|
|
num_pts = coords.shape[1]
|
|
f_idx = np.tile(np.arange(S)[:, np.newaxis], (1, num_pts))
|
|
x = coords[:, :, 0]
|
|
y = coords[:, :, 1]
|
|
|
|
x0 = x.astype(int)
|
|
x1 = x0 + 1
|
|
y0 = y.astype(int)
|
|
y1 = y0 + 1
|
|
|
|
x0 = np.clip(x0, 0, W-1)
|
|
x1 = np.clip(x1, 0, W-1)
|
|
y0 = np.clip(y0, 0, H-1)
|
|
y1 = np.clip(y1, 0, H-1)
|
|
|
|
sampled_depth = np.max(np.concatenate([depth[f_idx, y0, x0], depth[f_idx, y0, x1], depth[f_idx, y1, x0], depth[f_idx, y1, x1]], axis=-1), axis=-1)
|
|
|
|
return sampled_depth
|
|
|
|
class StandaloneMoviDataset(Dataset):
|
|
def __init__(self, root: Path, dataset: str, split='train', num_frames = 24, augment=False, num_dataset_frames=24, resolution=(512, 512), normalize_img: bool = True, **kwargs):
|
|
super(StandaloneMoviDataset, self).__init__()
|
|
self.root = Path(root)
|
|
self.dataset = dataset
|
|
self.split = split
|
|
self.resolution = tuple(resolution)
|
|
self.root_dir = self.root / self.dataset / split
|
|
self.files = os.listdir(self.root_dir)
|
|
self.files.sort()
|
|
print(self.files)
|
|
self.num_dataset_frames = num_dataset_frames
|
|
self.num_frames = num_frames
|
|
self.augment = augment
|
|
self.normalize_img = normalize_img
|
|
|
|
if self.augment:
|
|
self.transform = transforms.Compose([transforms.RandomResizedCrop(self.resolution, scale=(0.5, 1.0), antialias=True)])
|
|
else:
|
|
self.transform = transforms.Compose([transforms.Resize(self.resolution, antialias=True)])
|
|
|
|
|
|
def __getitem__(self, index):
|
|
video_idx = index
|
|
camera_idx = 0
|
|
|
|
clip_len = 10
|
|
start = 6
|
|
stride = 1
|
|
|
|
path = self.files[video_idx]
|
|
|
|
data = np.load(self.root_dir / path / "data.npz")
|
|
rgb = data["rgb"][camera_idx][start::stride][:clip_len]
|
|
instance = data["segment"][camera_idx][start::stride][:clip_len]
|
|
depth = data["depth"][camera_idx][start::stride][:clip_len]
|
|
f_flow = data["forward_flow"][camera_idx][start::stride][:clip_len]
|
|
object_coordinates = data["object_coordinates"][camera_idx][start::stride][:clip_len]
|
|
|
|
quaternions = data["quaternions"][camera_idx][start::stride][:clip_len]
|
|
positions = data["positions"][camera_idx][start::stride][:clip_len]
|
|
valid = data["valid"][camera_idx, :].squeeze(0)
|
|
categories = data["categories"][camera_idx, :].squeeze(0)
|
|
bboxes_3d = data['bboxes_3d'][camera_idx][valid][:, start::stride][:, :clip_len]
|
|
intrinsics = data['intrinsics'][camera_idx][start::stride][:clip_len]
|
|
matrix_world = data['matrix_world'][camera_idx][start::stride][:clip_len]
|
|
cam_pos = data['cam_positions'][camera_idx][start::stride][:clip_len]
|
|
|
|
rgb = rearrange(rgb, '... h w c -> ... c h w')
|
|
instance = Mask(instance.squeeze(-1))
|
|
rgb, instance = self.transform(Image(rgb), instance)
|
|
rgb = rearrange(rgb, '... c h w -> ... h w c')
|
|
rgb = rgb.numpy()
|
|
|
|
instance = torch.nn.functional.one_hot(instance.long(), num_classes=21).numpy()
|
|
|
|
mask_valid = instance.sum((1,2)) > 0
|
|
num_objects = (mask_valid.sum(0) > 0).sum()
|
|
|
|
ret = {
|
|
"vid_name": path,
|
|
"image": rgb,
|
|
"depth": depth,
|
|
"flow": f_flow,
|
|
'segmentation': instance,
|
|
'object_coordinates': object_coordinates,
|
|
"mask_valid": mask_valid,
|
|
"num_objs": num_objects,
|
|
'categories': categories,
|
|
'valid': valid,
|
|
'bboxes_3d': bboxes_3d,
|
|
'intrinsics': intrinsics,
|
|
'matrix_world': matrix_world,
|
|
'cam_positions': cam_pos,
|
|
}
|
|
|
|
return ret
|
|
|
|
|
|
def __len__(self):
|
|
return len(self.files)
|
|
|
|
def project_point(cam_matrix_world, cam_intrinsics, point3d, image_size):
|
|
"""Compute the image space coordinates [0, 1] for a set of points.
|
|
|
|
Args:
|
|
cam: The camera parameters, as returned by kubric. 'matrix_world' and
|
|
'intrinsics' have a leading axis num_frames.
|
|
point3d: Points in 3D world coordinates. it has shape [num_frames,
|
|
num_points, 3].
|
|
num_frames: The number of frames in the video.
|
|
|
|
Returns:
|
|
Image coordinates in 2D. The last coordinate is an indicator of whether
|
|
the point is behind the camera.
|
|
"""
|
|
|
|
homo_transform = np.linalg.inv(cam_matrix_world)
|
|
homo_intrinsics = np.zeros((cam_intrinsics.shape[0], 3, 1), dtype=np.float32)
|
|
homo_intrinsics = np.concatenate([cam_intrinsics, homo_intrinsics], axis=2)
|
|
|
|
point4d = np.concatenate([point3d, np.ones_like(point3d[:, :, 0:1])], axis=2)
|
|
projected = point4d @ np.transpose(homo_transform, (0, 2, 1))
|
|
projected = projected @ np.transpose(homo_intrinsics, (0, 2, 1))
|
|
image_coords = projected / projected[:, :, 2:3]
|
|
|
|
|
|
|
|
image_coords = image_coords[:, :, 0:2] * np.array(image_size[::-1])[np.newaxis, np.newaxis, :]
|
|
|
|
return image_coords
|
|
|
|
def get_trajs(data):
|
|
|
|
shp = data['image'].shape
|
|
num_frames = shp[0]
|
|
|
|
vid_pix_pts = []
|
|
vid_3d_pts = []
|
|
vid_rgb_pts = []
|
|
vid_2d_pts = []
|
|
occ_pts = []
|
|
|
|
|
|
|
|
frame_idx = 0
|
|
bboxes_3d = data['bboxes_3d']
|
|
obj_coords = data['object_coordinates'][frame_idx]
|
|
grid_x, grid_y = np.meshgrid(np.arange(0, shp[2]), np.arange(0, shp[1]), indexing='ij')
|
|
pix_coords = np.stack([grid_x, grid_y], axis=-1)
|
|
for obj_idx in range(bboxes_3d.shape[0]):
|
|
|
|
obj_mask = (data['segmentation'][frame_idx][:, :, obj_idx+1])
|
|
bbox_3d = bboxes_3d[obj_idx]
|
|
coord_box = list(itertools.product([-.5, .5], [-.5, .5], [-.5, .5]))
|
|
coord_box = np.array([np.array(x) for x in coord_box])
|
|
coord_box = np.concatenate([coord_box, np.ones_like(coord_box[:, 0:1])], axis=1)
|
|
coord_box = np.tile(coord_box[np.newaxis, ...], [num_frames, 1, 1])
|
|
bbox_homo = np.concatenate([bbox_3d, np.ones_like(bbox_3d[:, :, 0:1])], axis=2)
|
|
local_to_world = np.stack([np.linalg.lstsq(coord_box.astype(np.float32)[i], bbox_homo[i], rcond=None)[0] for i in range(num_frames)])
|
|
|
|
obj_3d_coords = obj_coords[obj_mask.astype(bool)]
|
|
obj_3d_coords = obj_3d_coords / np.iinfo(np.uint16).max - .5
|
|
obj_homo_coords = np.concatenate([obj_3d_coords, np.ones_like(obj_3d_coords[:, 0:1])], axis=1).astype(np.float32)
|
|
obj_3d_world_coords = np.stack([obj_homo_coords @ local_to_world[i] for i in range(num_frames)])
|
|
obj_3d_world_coords = obj_3d_world_coords[:, :, 0:3] / obj_3d_world_coords[:, :, 3:]
|
|
|
|
proj_depth = np.sqrt(
|
|
np.sum(
|
|
np.square(obj_3d_world_coords - data['cam_positions'][:, np.newaxis, :]),
|
|
axis=2,
|
|
),)
|
|
|
|
pt_rgb = np.tile(data['image'][0][obj_mask.astype(bool)], [num_frames, 1, 1])
|
|
pix_pts = pix_coords[obj_mask.astype(bool)]
|
|
obj_2d_pix_coords = project_point(data['matrix_world'], data['intrinsics'], obj_3d_world_coords, (shp[1], shp[2]))
|
|
|
|
pix_depth = get_max_neighboring_depth(data['depth'], obj_2d_pix_coords)
|
|
occluded = pix_depth < 0.99 * proj_depth
|
|
|
|
vid_3d_pts.append(obj_3d_world_coords)
|
|
vid_rgb_pts.append(pt_rgb)
|
|
vid_2d_pts.append(obj_2d_pix_coords)
|
|
occ_pts.append(occluded)
|
|
vid_pix_pts.append(pix_pts)
|
|
|
|
vid_3d_pts = np.concatenate(vid_3d_pts, axis=1)
|
|
vid_rgb_pts = np.concatenate(vid_rgb_pts, axis=1)
|
|
vid_2d_pts = np.concatenate(vid_2d_pts, axis=1)
|
|
occ_pts = np.concatenate(occ_pts, axis=1)
|
|
vid_pix_pts = np.concatenate(vid_pix_pts, axis=0)
|
|
|
|
return vid_3d_pts, vid_rgb_pts, vid_2d_pts, occ_pts, vid_pix_pts
|
|
|
|
def vis_data(images, vid_3d_pts, vid_rgb_pts, vid_2d_pts, occ_pts, shp, vis_out_path, v_idx=0):
|
|
|
|
num_frames = shp[0]
|
|
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111, projection = '3d')
|
|
ax.set_xlim(-7, 7)
|
|
ax.set_ylim(-7, 7)
|
|
ax.set_zlim(-1, 3)
|
|
|
|
def update(t):
|
|
ax.cla()
|
|
ax.scatter(vid_3d_pts[t][:, 0], vid_3d_pts[t][:, 1], vid_3d_pts[t][:, 2], c = vid_rgb_pts[t]/255.0, s = 0.25)
|
|
ax.set_xlim(-7, 7)
|
|
ax.set_ylim(-7, 7)
|
|
ax.set_zlim(-1, 3)
|
|
|
|
ani = FuncAnimation(fig = fig, func = update, frames = num_frames, interval = 1000)
|
|
writervideo = matplotlib.animation.PillowWriter(fps=5)
|
|
ani.save(os.path.join(vis_out_path, f'orig_{v_idx:03d}.gif'), writer=writervideo)
|
|
|
|
num_pts = vid_2d_pts.shape[1]
|
|
vis_pt_count = 75
|
|
rand_pt_idxes = np.random.randint(0, num_pts, vis_pt_count)
|
|
rand_colors = np.random.randint(0, 256, (vis_pt_count, 3))
|
|
trajs = []
|
|
for t in range(num_frames):
|
|
traj_vis = PIL_Image.new('RGBA', (shp[1], shp[2]))
|
|
draw = ImageDraw.Draw(traj_vis)
|
|
t_idx = t
|
|
prev_t_idx = t-1 if t > 0 else 0
|
|
for pt, prev_pt, occ, color in zip(vid_2d_pts[t_idx][rand_pt_idxes], vid_2d_pts[prev_t_idx][rand_pt_idxes], occ_pts[t_idx][rand_pt_idxes], rand_colors):
|
|
if occ:
|
|
segments = 5
|
|
delta_x = (pt[0] - prev_pt[0]) / (2*segments-1)
|
|
delta_y = (pt[1] - prev_pt[1]) / (2*segments-1)
|
|
for i in range(segments):
|
|
draw.line((prev_pt[0]+delta_x*2*i, prev_pt[1]+delta_y*2*i, prev_pt[0]+delta_x*(2*i+1), prev_pt[1]+delta_y*(2*i+1)), tuple(color), width=3)
|
|
else:
|
|
draw.line((pt[0], pt[1], prev_pt[0], prev_pt[1]), tuple(color), width=3)
|
|
if len(trajs) > 0:
|
|
traj_vis.paste(trajs[-1], mask=trajs[-1])
|
|
trajs.append(traj_vis)
|
|
|
|
traj_image_list = []
|
|
for t in range(num_frames):
|
|
traj_out = PIL_Image.fromarray(np.uint8(images[t])).convert("RGBA")
|
|
traj_out.paste(trajs[t], mask=trajs[t])
|
|
traj_image_list.append(traj_out)
|
|
traj_image_list[0].save(os.path.join(vis_out_path, f"2d_{v_idx:03d}.gif"), save_all=True, append_images=[traj_image_list[i] for i in range(1, num_frames)], duration=200, loop=0)
|
|
|
|
PIL_Image.fromarray(images[0]).save(os.path.join(vis_out_path, f"kubric_{v_idx:03d}.gif"), save_all=True, append_images=[PIL_Image.fromarray(images[i]) for i in range(1, num_frames)], duration=200, loop=0)
|
|
plt.close('all')
|
|
|
|
if __name__ == "__main__":
|
|
|
|
ROOT_PATH = '/projects/katefgroup/datasets/gs_kubric'
|
|
dataset = StandaloneMoviDataset(root='/projects/katefgroup/datasets/gs_kubric', dataset='for_splatting2', split='subset_50', augment=False, num_frames=24)
|
|
OUT_PATH = os.path.join('/projects/katefgroup/datasets/gs_kubric', 'InpaintingFormat_Set50')
|
|
VIS_OUT_PATH = os.path.join('/projects/katefgroup/datasets/gs_kubric', 'vis')
|
|
os.makedirs(VIS_OUT_PATH, exist_ok=True)
|
|
|
|
midas = torch.hub.load("intel-isl/MiDaS", "DPT_Hybrid")
|
|
midas_transforms = torch.hub.load("intel-isl/MiDaS", "transforms")
|
|
device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
|
|
midas.to(device)
|
|
midas.eval()
|
|
midas_transform = midas_transforms.dpt_transform
|
|
|
|
for i in range(len(dataset)):
|
|
entry = dataset[i]
|
|
num_frames = entry['image'].shape[0]
|
|
|
|
vid_3d_pts, vid_rgb_pts, vid_2d_pts, occ_pts, vid_pix_pts = get_trajs(entry)
|
|
trajs_dict = {
|
|
'3d_traj': vid_3d_pts,
|
|
'3d_rgb': vid_rgb_pts,
|
|
'2d_traj': vid_2d_pts,
|
|
'occluded': occ_pts,
|
|
'pix_pts': vid_pix_pts,
|
|
}
|
|
save_tensor_dict(trajs_dict, os.path.join(dataset.root_dir, dataset.files[i], 'traj_data.npz'))
|
|
|
|
vis_data(entry['image'], vid_3d_pts, vid_rgb_pts, vid_2d_pts, occ_pts, entry['image'].shape, VIS_OUT_PATH, i)
|
|
|
|
os.makedirs(os.path.join(OUT_PATH, "JPEGImages", entry['vid_name']), exist_ok=True)
|
|
os.makedirs(os.path.join(OUT_PATH, "DepthImages", entry['vid_name']), exist_ok=True)
|
|
os.makedirs(os.path.join(OUT_PATH, "OpticalFlow", entry['vid_name']), exist_ok=True)
|
|
os.makedirs(os.path.join(OUT_PATH, "OpticalFlowVis", entry['vid_name']), exist_ok=True)
|
|
|
|
vid_occluder_masks = []
|
|
for t, frame in enumerate(entry['image']):
|
|
frame = entry['image'][t]
|
|
img_save_path = os.path.join(OUT_PATH, "JPEGImages", entry['vid_name'], f'{t:05d}.png')
|
|
PIL_Image.fromarray(frame).save(img_save_path)
|
|
|
|
depth = entry['depth'][t]
|
|
depth_save_path = os.path.join(OUT_PATH, "DepthImages", entry['vid_name'], f'{t:05d}.npy')
|
|
np.save(depth_save_path, depth)
|
|
|
|
flow = entry['flow'][t]
|
|
flow_save_path = os.path.join(OUT_PATH, "OpticalFlow", entry['vid_name'], f'{t:05d}.npy')
|
|
np.save(flow_save_path, flow)
|
|
|
|
flow_vis = flow_to_image(flow)
|
|
flow_vis_save_path = os.path.join(OUT_PATH, "OpticalFlowVis", entry['vid_name'], f'{t:05d}.png')
|
|
PIL_Image.fromarray(flow_vis).save(flow_vis_save_path)
|
|
|
|
with torch.no_grad():
|
|
RESOLUTION = frame.shape[1]
|
|
prediction = midas(midas_transform(np.array(frame).astype(np.uint8))[0].to(device).unsqueeze(0))
|
|
prediction = torch.nn.functional.interpolate(
|
|
prediction.unsqueeze(1),
|
|
size=(RESOLUTION, RESOLUTION),
|
|
mode="bicubic",
|
|
align_corners=False,
|
|
).squeeze()
|
|
prediction = prediction.reshape(RESOLUTION, RESOLUTION).cpu().numpy()
|
|
|
|
binary_masks = entry['segmentation'][t].transpose(2, 0, 1)[:entry['num_objs']]
|
|
inst_depth = np.sum(prediction[np.newaxis] * binary_masks, (-2, -1)) / (np.sum(binary_masks, (-2, -1)) + 1e-6)
|
|
|
|
occluder_masks = np.zeros_like(binary_masks)
|
|
for i in range(entry['num_objs']):
|
|
if i == 0:
|
|
occluder_masks[i] = np.sum(binary_masks[1:], axis=0)
|
|
else:
|
|
for j in range(entry['num_objs']):
|
|
if j == 0 or j == i or inst_depth[i] > inst_depth[j]:
|
|
continue
|
|
else:
|
|
if binary_masks[i].sum() == 0 or binary_masks[j].sum() == 0:
|
|
continue
|
|
rows = np.any(binary_masks[i], axis=1)
|
|
cols = np.any(binary_masks[i], axis=0)
|
|
rmin, rmax = np.where(rows)[0][[0, -1]]
|
|
cmin, cmax = np.where(cols)[0][[0, -1]]
|
|
bbox_i = np.clip(np.array([rmin-10, rmax+10, cmin-10, cmax+10]), 0, RESOLUTION)
|
|
|
|
rows = np.any(binary_masks[j], axis=1)
|
|
cols = np.any(binary_masks[j], axis=0)
|
|
rmin, rmax = np.where(rows)[0][[0, -1]]
|
|
cmin, cmax = np.where(cols)[0][[0, -1]]
|
|
bbox_j = np.clip(np.array([rmin-10, rmax+10, cmin-10, cmax+10]), 0, RESOLUTION)
|
|
|
|
x_left = max(bbox_i[0], bbox_j[0])
|
|
y_top = max(bbox_i[2], bbox_j[2])
|
|
x_right = min(bbox_i[1], bbox_j[1])
|
|
y_bottom = min(bbox_i[3], bbox_j[3])
|
|
|
|
if x_right < x_left or y_bottom < y_top:
|
|
continue
|
|
else:
|
|
occluder_masks[i] += binary_masks[j]
|
|
|
|
occluder_masks = np.clip(occluder_masks, 0, 1)
|
|
vid_occluder_masks.append(occluder_masks)
|
|
|
|
for j in range(entry['num_objs']):
|
|
os.makedirs(os.path.join(OUT_PATH, "Annotations", entry['vid_name'], f'{j:03d}'), exist_ok=True)
|
|
os.makedirs(os.path.join(OUT_PATH, "OccluderAnnotations", entry['vid_name'], f'{j:03d}'), exist_ok=True)
|
|
os.makedirs(os.path.join(OUT_PATH, "ClassLabels", entry['vid_name'], f'{j:03d}'), exist_ok=True)
|
|
|
|
for t, frame in enumerate(entry['segmentation'][:, :, :, j]):
|
|
frame = entry['segmentation'][t, :, :, j]
|
|
mask_save_path = os.path.join(OUT_PATH, "Annotations", entry['vid_name'], f'{j:03d}', f'{t:05d}.png')
|
|
mask = np.repeat(frame[:, :, np.newaxis], 3, axis=2)*255
|
|
PIL_Image.fromarray(mask.astype(np.uint8)).save(mask_save_path)
|
|
|
|
occ_mask_save_path = os.path.join(OUT_PATH, "OccluderAnnotations", entry['vid_name'], f'{j:03d}', f'{t:05d}.png')
|
|
mask = vid_occluder_masks[t][j]
|
|
PIL_Image.fromarray(mask.astype(np.uint8)*255).save(occ_mask_save_path)
|
|
|
|
if j == 0:
|
|
with open(os.path.join(os.path.join(OUT_PATH, 'ClassLabels', entry['vid_name'], f'{j:03d}', 'class_label.txt')), 'w') as class_file:
|
|
class_file.write("background")
|
|
else:
|
|
with open(os.path.join(os.path.join(OUT_PATH, 'ClassLabels', entry['vid_name'], f'{j:03d}', 'class_label.txt')), 'w') as class_file:
|
|
if categories[entry['categories'][j]] != 'None':
|
|
class_file.write(categories[entry['categories'][j]])
|
|
else:
|
|
class_file.write("object")
|
|
|
|
print("Done")
|
|
from ipdb import set_trace; set_trace() |