File size: 4,970 Bytes
c94c8c9 |
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 123 124 125 126 127 |
import json
from glob import glob
from omegaconf import OmegaConf
from joblib import Parallel, delayed, parallel_backend
import torch
import numpy as np
import trimesh
from tqdm import tqdm
from scipy.spatial.transform import Rotation
from preprocess.build import ProcessorBase
from preprocess.utils.label_convert import ARKITSCENE_SCANNET as label_convert
from preprocess.utils.align_utils import compute_box_3d, calc_align_matrix, rotate_z_axis_by_degrees
from preprocess.utils.constant import *
class ARKitScenesProcessor(ProcessorBase):
def record_splits(self, scan_ids):
split_dir = self.save_root / 'split'
split_dir.mkdir(exist_ok=True)
if (split_dir / 'train_split.txt').exists() and (split_dir / 'val_split.txt').exists():
return
split = {
'train': [],
'val': []}
split['train'] = [scan_id[1] for scan_id in scan_ids if scan_id[0] == 'Training']
split['val'] = [scan_id[1] for scan_id in scan_ids if scan_id[0] == 'Validation']
for _s, _c in split.items():
with open(split_dir / f'{_s}_split.txt', 'w', encoding='utf-8') as fp:
fp.write('\n'.join(_c))
def read_all_scans(self):
scan_ids = []
for split in ['Training', 'Validation']:
scan_paths = glob(str(self.data_root) + f'/{split}/*')
scan_ids.extend([(split, path.split('/')[-1]) for path in scan_paths])
return scan_ids
def process_point_cloud(self, scan_id, plydata, annotations):
vertices = plydata.vertices
vertex_colors = plydata.visual.vertex_colors
vertex_colors = vertex_colors[:, :3]
vertex_instance = np.zeros((vertices.shape[0]))
inst_to_label = {}
bbox_list = []
for _i, label_info in enumerate(annotations["data"]):
obj_label = label_info["label"]
object_id = _i + 1
rotation = np.array(label_info["segments"]["obbAligned"]["normalizedAxes"]).reshape(3, 3)
r = Rotation.from_matrix(rotation)
transform = np.array(label_info["segments"]["obbAligned"]["centroid"]).reshape(-1, 3)
scale = np.array(label_info["segments"]["obbAligned"]["axesLengths"]).reshape(-1, 3)
trns = np.eye(4)
trns[0:3, 3] = transform
trns[0:3, 0:3] = rotation.T
box_trimesh_fmt = trimesh.creation.box(scale.reshape(3,), trns)
obj_containment = np.argwhere(box_trimesh_fmt.contains(vertices))
vertex_instance[obj_containment] = object_id
inst_to_label[object_id] = label_convert[obj_label]
box3d = compute_box_3d(scale.reshape(3).tolist(), transform, rotation)
bbox_list.append(box3d)
if len(bbox_list) == 0:
return
align_angle = calc_align_matrix(bbox_list)
vertices = rotate_z_axis_by_degrees(np.array(vertices), align_angle)
if np.max(vertex_colors) <= 1:
vertex_colors = vertex_colors * 255.0
center_points = np.mean(vertices, axis=0)
center_points[2] = np.min(vertices[:, 2])
vertices = vertices - center_points
assert vertex_colors.shape == vertices.shape
assert vertex_colors.shape[0] == vertex_instance.shape[0]
if self.check_key(self.output.pcd):
torch.save(inst_to_label, self.inst2label_path / f"{scan_id}.pth")
torch.save((vertices, vertex_colors, vertex_instance), self.pcd_path / f"{scan_id}.pth")
np.save(self.pcd_path / f"{scan_id}_align_angle.npy", align_angle)
def scene_proc(self, scan_id):
split = scan_id[0]
scan_id = scan_id[1]
data_root = self.data_root / split / scan_id
if not (data_root / f'{scan_id}_3dod_mesh.ply').exists():
return
if not (data_root / f'{scan_id}_3dod_annotation.json').exists():
return
plydata = trimesh.load(data_root / f'{scan_id}_3dod_mesh.ply', process=False)
with open((data_root / f'{scan_id}_3dod_annotation.json'), "r", encoding='utf-8') as f:
annotations = json.load(f)
# process point cloud
self.process_point_cloud(scan_id, plydata, annotations)
def process_scans(self):
scan_ids = self.read_all_scans()
self.log_starting_info(len(scan_ids))
if self.num_workers > 1:
with parallel_backend('multiprocessing', n_jobs=self.num_workers):
Parallel()(delayed(self.scene_proc)(scan_id) for scan_id in tqdm(scan_ids))
else:
for scan_id in tqdm(scan_ids):
self.scene_proc(scan_id)
if __name__ == '__main__':
cfg = OmegaConf.create({
'data_root': '/path/to/ARKitScenes',
'save_root': '/output/path/to/ARKitScenes',
'num_workers': 1,
'output': {
'pcd': True,
}
})
processor = ARKitScenesProcessor(cfg)
processor.process_scans()
|