File size: 4,466 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 |
import pickle
from glob import glob
from omegaconf import OmegaConf
from joblib import Parallel, delayed, parallel_backend
import torch
import numpy as np
from tqdm import tqdm
from preprocess.build import ProcessorBase
from preprocess.utils.label_convert import S3D_SCANNET as label_convert
from preprocess.utils.constant import *
PTS_LIMIT = 480000
class S3DProcessor(ProcessorBase):
def record_splits(self, scan_ids):
split_dir = self.save_root / 'split'
split_dir.mkdir(exist_ok=True)
split = {
'train': [],
'val': [],
'test': []}
split['train'] = [scan_id[1] for scan_id in scan_ids if scan_id[0] == 'train']
split['val'] = [scan_id[1] for scan_id in scan_ids if scan_id[0] == 'val']
split['test'] = [scan_id[1] for scan_id in scan_ids if scan_id[0] == 'test']
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 ['train', 'val', 'test']:
scan_paths = glob(str(self.data_root) + f'/{split}/*')
scan_ids.extend([(split, '_'.join(path.split('/')[-1].split('_')[:-2])) for path in scan_paths])
return scan_ids
def process_point_cloud(self, scan_id, plydata, annotations):
vertices = plydata[0]
vertex_colors = (plydata[1][:,:3] + 1) / 2.0 * 255.0
vertex_instance = - np.ones((vertices.shape[0]))
inst_to_label = {}
for _id, _box in enumerate(annotations['gt_boxes_upright_depth']):
if annotations['class'][_id] in [38, 39, 40]:
continue
centroid = _box[:3]
dimension = _box[3:6]
box_max = centroid + dimension/2
box_min = centroid - dimension/2
point_max_mask = np.all(vertices < box_max, axis=1)
point_min_mask = np.all(vertices > box_min, axis=1)
point_mask = np.logical_and(point_max_mask, point_min_mask)
vertex_instance[point_mask] = _id
inst_to_label[_id] = label_convert[annotations['class'][_id]]
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 vertices.shape[0] > PTS_LIMIT:
pcd_idxs = np.random.choice(vertices.shape[0], size=PTS_LIMIT, replace=False)
vertices = vertices[pcd_idxs]
colors = colors[pcd_idxs]
vertex_instance = vertex_instance[pcd_idxs]
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")
def scene_proc(self, scan_id):
split = scan_id[0]
scan_id = scan_id[1]
data_root = self.data_root / split
if not (data_root / f'{scan_id}_1cm_seg.pth').exists():
return
if not (self.data_root.parent / 'anno_mask' / f'{scan_id}_1cm.bin').exists():
return
plydata = torch.load(data_root / f'{scan_id}_1cm_seg.pth')
with open(self.data_root.parent / 'anno_mask' / f'{scan_id}_1cm.bin', 'rb') as f:
annotations = pickle.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__':
# we use the data processing for Structured3D from Swin3D,
# please refer to https://github.com/yuxiaoguo/Uni3DScenes for more details.
cfg = OmegaConf.create({
'data_root': '/path/to/Structured3D/data_out/swin3d_new',
'save_root': '/output/path/to/Structured3D',
'num_workers': 1,
'output': {
'pcd': True,
}
})
processor = S3DProcessor(cfg)
processor.process_scans()
|