def __init__(self, mode, test_id):
self.name = 'SemanticKITTI'
self.dataset_path = os.path.join(
root_dir, 'data/semantickitti/dataset/sequences_0.06')
self.label_to_names = {
0: 'unlabeled',
1: 'car',
2: 'bicycle',
3: 'motorcycle',
4: 'truck',
5: 'other-vehicle',
6: 'person',
7: 'bicyclist',
8: 'motorcyclist',
9: 'road',
10: 'parking',
11: 'sidewalk',
12: 'other-ground',
13: 'building',
14: 'fence',
15: 'vegetation',
16: 'trunk',
17: 'terrain',
18: 'pole',
19: 'traffic-sign'
}
self.num_classes = len(self.label_to_names)
self.label_values = np.sort(
[k for k, v in self.label_to_names.items()])
self.label_to_idx = {l: i for i, l in enumerate(self.label_values)}
self.ignored_labels = np.sort([0])
self.val_split = '08'
self.seq_list = np.sort(os.listdir(self.dataset_path))
self.test_scan_number = str(test_id)
self.mode = mode
self.train_list, self.val_list, self.test_list = DataProcessing.get_file_list(
self.dataset_path, self.test_scan_number)
if mode == 'training':
self.data_list = self.train_list
elif mode == 'validation':
self.data_list = self.val_list
elif mode == 'test':
self.data_list = self.test_list
# self.data_list = self.data_list[0:1]
self.data_list = DataProcessing.shuffle_list(self.data_list)
self.possibility = []
self.min_possibility = []
if mode == 'test':
for test_file_name in self.data_list:
points = np.load(test_file_name)
self.possibility += [np.random.rand(points.shape[0]) * 1e-3]
self.min_possibility += [float(np.min(self.possibility[-1]))]
ConfigSemanticKITTI.ignored_label_inds = [
self.label_to_idx[ign_label] for ign_label in self.ignored_labels
]
ConfigSemanticKITTI.class_weights = DataProcessing.get_class_weights(
'SemanticKITTI')
def tf_map(self, batch_xyz, batch_features, batch_labels, batch_pc_idx,
batch_cloud_idx):
batch_feature = []
for i in range(batch_xyz.shape[1]):
xyz = batch_xyz[:, i, :]
features = batch_features[:, i, :]
batch_feature.append(self.tf_augment_input([xyz, features]))
batch_feature = torch.stack(batch_feature, dim=1).numpy()
input_points = []
input_neighbors = []
input_pools = []
input_up_samples = []
for i in range(ConfigSemantic3D.num_layers):
# print('queried_pc_xyz shape:',batch_xyz.shape) # (1, N, 3)
neighbour_idx = DataProcessing.knn_search(batch_xyz, batch_xyz,
ConfigSemantic3D.k_n)
# print('neighbour_idx shape:', neighbour_idx.shape) # (1, N, 16)
sub_points = batch_xyz[:, :batch_xyz.shape[1] //
ConfigSemantic3D.sub_sampling_ratio[i], :]
# print('sub_points shape:', sub_points.shape) # (1, N, 16)
pool_i = neighbour_idx[:, :batch_xyz.shape[1] //
ConfigSemantic3D.sub_sampling_ratio[i], :]
up_i = DataProcessing.knn_search(sub_points, batch_xyz, 1)
input_points.append(batch_xyz)
input_neighbors.append(neighbour_idx)
input_pools.append(pool_i)
input_up_samples.append(up_i)
batch_xyz = sub_points
input_list = input_points + input_neighbors + input_pools + input_up_samples
input_list += [
batch_feature, batch_labels, batch_pc_idx, batch_cloud_idx
]
return input_list
def tf_map(batch_pc, batch_label, batch_pc_idx, batch_cloud_idx):
features = batch_pc
input_points = []
input_neighbors = []
input_pools = []
input_up_samples = []
for i in range(ConfigSemanticKITTI.num_layers):
neighbour_idx = DataProcessing.knn_search(batch_pc, batch_pc,
ConfigSemanticKITTI.k_n)
sub_points = batch_pc[:, :batch_pc.shape[1] //
ConfigSemanticKITTI.sub_sampling_ratio[i], :]
pool_i = neighbour_idx[:, :batch_pc.shape[1] //
ConfigSemanticKITTI.
sub_sampling_ratio[i], :]
up_i = DataProcessing.knn_search(sub_points, batch_pc, 1)
input_points.append(batch_pc)
input_neighbors.append(neighbour_idx)
input_pools.append(pool_i)
input_up_samples.append(up_i)
batch_pc = sub_points
input_list = input_points + input_neighbors + input_pools + input_up_samples
input_list += [features, batch_label, batch_pc_idx, batch_cloud_idx]
return input_list
def __init__(self, dataset_name, config):
super(RandLANET, self).__init__()
self.config = config
self.class_weights = DataProcessing.get_class_weights(dataset_name)
self.fc0 = net_utils.conv1d(config.channels,
8,
1,
1,
0,
'fc0',
bias=True,
bn=True)
self.dilated_res_blocks = nn.ModuleList()
d_in = 8
for i in range(self.config.num_layers):
d_out = self.config.d_out[i]
self.dilated_res_blocks.append(Dilated_res_block(d_in, d_out))
d_in = 2 * d_out
d_out = d_in
self.decoder_0 = net_utils.conv2d(d_in,
d_out, (1, 1), (1, 1), (0, 0),
'decoder_0',
bias=True,
bn=True)
self.decoder_blocks = nn.ModuleList()
for j in range(self.config.num_layers):
if j < 3:
d_in = self.config.d_out[-j -
1] * 2 + 2 * self.config.d_out[-j - 2]
d_out = 2 * self.config.d_out[-j - 2]
else:
d_in = self.config.d_out[-j - 1] * 2 + 2 * self.config.d_out[0]
d_out = 2 * self.config.d_out[0]
self.decoder_blocks.append(
net_utils.conv2d_transpose(d_in,
d_out, (1, 1), (1, 1), (0, 0),
'decoder{}'.format(j),
bias=True,
bn=True))
self.fc1 = net_utils.conv2d(d_out,
64, (1, 1), (1, 1), (0, 0),
'fc1',
bias=True,
bn=True)
self.fc2 = net_utils.conv2d(64,
32, (1, 1), (1, 1), (0, 0),
'fc2',
bias=True,
bn=True)
self.dropout = nn.Dropout(0.5)
self.fc3 = net_utils.conv2d(32,
self.config.num_classes, (1, 1), (1, 1),
(0, 0),
'fc3',
bias=True,
bn=False,
activation_fn=None)
def convert_pointcloud2ply(annotations_path, save_path, sub_grid_size=0.04):
"""convert original files(.txt) to ply file(each line is XYZRGBL).
Args:
annotations_path (str): path to annotations
save_path (str): path to save original point clouds (each line is XYZRGBL)
sub_grid_size (float, optional): [description]. Defaults to 0.04.
"""
make_dir(sub_grid_size)
data_list = []
for file in glob.glob(os.path.join(annotations_path, '*.txt')):
class_name = os.path.basename(file).split('_')[0]
if class_name not in ground_truth_class:
class_name = 'clutter'
pointcloud = pd.read_csv(file, header=None,
delim_whitespace=True).values
labels = np.ones(
(pointcloud.shape[0], 1)) * ground_truth_label[class_name]
data = np.concatenate([pointcloud, labels],
axis=1) # x,y,z,r,g,b,label
data_list.append(data)
print(pointcloud)
print(labels)
pointcloud_and_label = np.concatenate([data for data in data_list], axis=0)
xyz_min = np.min(pointcloud_and_label, axis=0)[0:3]
pointcloud_and_label[:, 0:3] = pointcloud_and_label[:, 0:3] - xyz_min
xyz = pointcloud_and_label[:, 0:3].astype(np.float32)
colors = pointcloud_and_label[:, 3:6].astype(np.uint8)
labels = pointcloud_and_label[:, 6].astype(np.uint8)
ply.write_ply(save_path, (xyz, colors, labels),
['x', 'y', 'z', 'red', 'green', 'blue', 'class'])
sub_xyz, sub_colors, sub_labels = DataProcessing.grid_sub_sampling(
xyz, colors, labels, sub_grid_size)
sub_colors = sub_colors / 255.0
sub_ply_file = os.path.join(sub_pointcloud_folder,
save_path.split('/')[-1][:-4] + '.ply')
ply.write_ply(sub_ply_file, [sub_xyz, sub_colors, sub_labels],
['x', 'y', 'z', 'red', 'green', 'blue', 'class'])
search_tree = KDTree(sub_xyz)
kd_tree_file = os.path.join(
sub_pointcloud_folder,
str(save_path.split('/')[-1][:-4]) + '_KDTree.pkl')
with open(kd_tree_file, 'wb') as f:
pickle.dump(search_tree, f)
project_index = np.squeeze(search_tree.query(xyz, return_distance=False))
project_index = project_index.astype(np.int32)
project_save = os.path.join(
sub_pointcloud_folder,
str(save_path.split('/')[-1][:-4]) + '_project.pkl')
with open(project_save, 'wb') as f:
pickle.dump([project_index, labels], f)
def crop_pc(points, labels, search_tree, pick_idx):
# crop a fixed size point cloud for training
center_point = points[pick_idx, :].reshape(1, -1)
select_idx = search_tree.query(center_point,
k=ConfigSemanticKITTI.num_points)[1][0]
select_idx = DataProcessing.shuffle_idx(select_idx)
select_points = points[select_idx]
select_labels = labels[select_idx]
return select_points, select_labels, select_idx
def viewer(data_path):
pointcloud_list = DataProcessing.get_pointcloud_list_semantickitti(
data_path)
label_list = DataProcessing.get_label_list_semantickitti(data_path)
colors = Plot.random_colors(21, seed=2)
for index in range(len(pointcloud_list)):
pointcloud_path = pointcloud_list[index]
label_path = label_list[index]
pointcloud = DataProcessing.load_pc_kitti(pointcloud_path)
label = DataProcessing.load_label_kitti(label_path, remap_lut)
pointcloud_withlabel = np.zeros((pointcloud.shape[0], 6), dtype=np.int)
pointcloud_withlabel[:, 0:3] = pointcloud
pointcloud_withlabel[:, 5] = 1
Plot.draw_pointcloud(pointcloud, "pointcloud:{}".format(index))
Plot.draw_pointcloud_semantic_instance(
pointcloud, label, "pointcloud_label:{}".format(index))
def convert_pointcloud2ply(annotations_path, save_path, sub_grid_size=0.04):
"""convert original files(.txt) to ply file(each line is XYZRGBL).
Args:
annotations_path (str): path to annotations
save_path (str): path to save original point clouds (each line is XYZRGBL)
sub_grid_size (float, optional): [description]. Defaults to 0.04.
"""
make_dir(sub_grid_size)
class_name = os.path.basename(annotations_path).split('/')[0][:-9]
pointcloud = np.loadtxt(annotations_path, delimiter=',').astype(np.float32)
labels = np.ones((pointcloud.shape[0], 1)) * ground_truth_label[class_name]
pointcloud_and_label = np.concatenate([pointcloud, labels], axis=1)
xyz_min = np.min(pointcloud_and_label, axis=0)[0:3]
pointcloud_and_label[:, 0:3] = pointcloud_and_label[:, 0:3] - xyz_min
xyz = pointcloud_and_label[:, 0:3].astype(np.float32)
colors = pointcloud_and_label[:, 3:6].astype(np.uint8)
labels = pointcloud_and_label[:, 6].astype(np.uint8)
print(save_path)
ply.write_ply(save_path, (xyz, colors, labels),
['x', 'y', 'z', 'red', 'green', 'blue', 'class'])
sub_xyz, sub_colors, sub_labels = DataProcessing.grid_sub_sampling(
xyz, colors, labels, sub_grid_size)
sub_colors = sub_colors / 255.0
sub_ply_file = os.path.join(sub_pointcloud_folder,
save_path.split('/')[-1][:-4] + '.ply')
print(sub_ply_file)
ply.write_ply(sub_ply_file, [sub_xyz, sub_colors, sub_labels],
['x', 'y', 'z', 'red', 'green', 'blue', 'class'])
search_tree = KDTree(sub_xyz)
kd_tree_file = os.path.join(
sub_pointcloud_folder,
str(save_path.split('/')[-1][:-4]) + '_KDTree.pkl')
print(kd_tree_file)
with open(kd_tree_file, 'wb') as f:
pickle.dump(search_tree, f)
project_index = np.squeeze(search_tree.query(xyz, return_distance=False))
project_index = project_index.astype(np.int32)
project_save = os.path.join(
sub_pointcloud_folder,
str(save_path.split('/')[-1][:-4]) + '_project.pkl')
print(project_save)
with open(project_save, 'wb') as f:
pickle.dump([project_index, labels], f)
def spatially_regular_gen(self, item):
# Generator loop
cloud_idx = int(np.argmin(self.min_possibility[self.mode]))
# choose the point with the minimum of possibility in the cloud as query point
point_ind = np.argmin(self.possibility[self.mode][cloud_idx])
# Get all points within the cloud from tree structure
points = np.array(self.input_trees[self.mode][cloud_idx].data,
copy=False)
# Center point of input region
center_point = points[point_ind, :].reshape(1, -1)
# Add noise to the center point
noise = np.random.normal(scale=ConfigSemantic3D.noise_init / 10,
size=center_point.shape)
pick_point = center_point + noise.astype(center_point.dtype)
query_idx = self.input_trees[self.mode][cloud_idx].query(
pick_point, k=ConfigSemantic3D.num_points)[1][0]
# Shuffle index
query_idx = DataProcessing.shuffle_idx(query_idx)
# Get corresponding points and colors based on the index
queried_pc_xyz = points[query_idx]
queried_pc_xyz[:, 0:2] = queried_pc_xyz[:, 0:2] - pick_point[:, 0:2]
queried_pc_colors = self.input_colors[self.mode][cloud_idx][query_idx]
if self.mode == 'test':
queried_pc_labels = np.zeros(queried_pc_xyz.shape[0])
queried_pt_weight = 1
else:
queried_pc_labels = self.input_labels[
self.mode][cloud_idx][query_idx]
queried_pc_labels = np.array(
[self.label_to_idx[l] for l in queried_pc_labels])
queried_pt_weight = np.array([
self.class_weight[self.mode][0][n] for n in queried_pc_labels
])
# Update the possibility of the selected points
dists = np.sum(np.square(
(points[query_idx] - pick_point).astype(np.float32)),
axis=1)
delta = np.square(1 - dists / np.max(dists)) * queried_pt_weight
self.possibility[self.mode][cloud_idx][query_idx] += delta
self.min_possibility[self.mode][cloud_idx] = float(
np.min(self.possibility[self.mode][cloud_idx]))
return queried_pc_xyz, queried_pc_colors.astype(
np.float32), queried_pc_labels, query_idx.astype(
np.int32), np.array([cloud_idx], dtype=np.int32)
pc_path_out = os.path.join(seq_path_out, 'velodyne')
KDTree_path_out = os.path.join(seq_path_out, 'KDTree')
os.makedirs(seq_path_out) if not os.path.exists(seq_path_out) else None
os.makedirs(pc_path_out) if not os.path.exists(pc_path_out) else None
os.makedirs(
KDTree_path_out) if not os.path.exists(KDTree_path_out) else None
if int(seq_id) < 11:
label_path = os.path.join(seq_path, 'labels')
label_path_out = os.path.join(seq_path_out, 'labels')
os.makedirs(
label_path_out) if not os.path.exists(label_path_out) else None
scan_list = np.sort(os.listdir(pc_path))
for scan_id in scan_list:
print(scan_id)
points = DataProcessing.load_pc_kitti(
os.path.join(pc_path, scan_id))
labels = DataProcessing.load_label_kitti(
os.path.join(label_path,
str(scan_id[:-4]) + '.label'), remap_lut)
sub_points, sub_labels = DataProcessing.grid_sub_sampling(
points, labels=labels, grid_size=sub_grid_size)
search_tree = KDTree(sub_points)
KDTree_save = os.path.join(KDTree_path_out,
str(scan_id[:-4]) + '.pkl')
np.save(os.path.join(pc_path_out, scan_id)[:-4], sub_points)
np.save(os.path.join(label_path_out, scan_id)[:-4], sub_labels)
with open(KDTree_save, 'wb') as f:
pickle.dump(search_tree, f)
if seq_id == '08':
proj_path = os.path.join(seq_path_out, 'proj')
os.makedirs(
def convert_txt2ply(save_path=None, sub_grid_size=0.06):
"""convert original files to ply file(each line is XYZRGBL).
Args:
save_path ([type], optional): [description]. Defaults to None.
sub_grid_size (float, optional): [description]. Defaults to 0.06.
"""
make_dir(sub_grid_size)
for pointcloud_path in glob.glob(
os.path.join(semantic3d_data_path, '*.txt')):
print(pointcloud_path)
filename = pointcloud_path.split('/')[-1][:-4]
if os.path.exists(
os.path.join(sub_pointcloud_folder, filename + '_KDTree.pkl')):
continue
pointcloud = DataProcessing.load_pc_semantic3d(pointcloud_path)
label_path = pointcloud_path[:-4] + '.labels'
print(label_path)
if os.path.exists(label_path):
labels = DataProcessing.load_label_semantic3d(label_path)
full_ply_path = os.path.join(original_pointcloud_folder,
filename + '.ply')
sub_points, sub_colors, sub_labels = DataProcessing.grid_sub_sampling(
pointcloud[:, :3].astype(np.float32),
pointcloud[:, 4:7].astype(np.uint8), labels, 0.01)
sub_labels = np.squeeze(sub_labels)
ply.write_ply(full_ply_path, (sub_points, sub_colors, sub_labels),
['x', 'y', 'z', 'red', 'green', 'blue', 'class'])
sub_xyz, sub_colors, sub_labels = DataProcessing.grid_sub_sampling(
sub_points, sub_colors, sub_labels, sub_grid_size)
sub_colors = sub_colors / 255.0
sub_labels = np.squeeze(sub_labels)
sub_ply_file = os.path.join(sub_pointcloud_folder,
filename + '.ply')
ply.write_ply(sub_ply_file, [sub_xyz, sub_colors, sub_labels],
['x', 'y', 'z', 'red', 'green', 'blue', 'class'])
search_tree = KDTree(sub_xyz, leaf_size=50)
kd_tree_file = os.path.join(sub_pointcloud_folder,
filename + '_KDTree.pkl')
with open(kd_tree_file, 'wb') as f:
pickle.dump(search_tree, f)
proj_idx = np.squeeze(
search_tree.query(sub_points, return_distance=False))
proj_idx = proj_idx.astype(np.int32)
proj_save = os.path.join(sub_pointcloud_folder,
filename + '_proj.pkl')
with open(proj_save, 'wb') as f:
pickle.dump([proj_idx, labels], f)
else:
fully_ply_path = os.path.join(original_pointcloud_folder,
filename + '.ply')
ply.write_ply(fully_ply_path, (pointcloud[:, :3].astype(
np.float32), pointcloud[:, 4:7].astype(np.uint8)),
['x', 'y', 'z', 'red', 'green', 'blue'])
sub_xyz, sub_colors = DataProcessing.grid_sub_sampling(
pointcloud[:, :3].astype(np.float32),
pointcloud[:, 4:7].astype(np.uint8),
grid_size=sub_grid_size)
sub_colors = sub_colors / 255.0
sub_ply_file = os.path.join(sub_pointcloud_folder,
filename + '.ply')
ply.write_ply(sub_ply_file, [sub_xyz, sub_colors],
['x', 'y', 'z', 'red', 'green', 'blue'])
labels = np.zeros(pointcloud.shape[0], dtype=np.uint8)
search_tree = KDTree(sub_xyz, leaf_size=50)
kd_tree_file = os.path.join(sub_pointcloud_folder,
filename + '_KDTree.pkl')
with open(kd_tree_file, 'wb') as f:
pickle.dump(search_tree, f)
proj_idx = np.squeeze(
search_tree.query(pointcloud[:, :3].astype(np.float32),
return_distance=False))
proj_idx = proj_idx.astype(np.int32)
proj_save = os.path.join(sub_pointcloud_folder,
filename + '_proj.pkl')
with open(proj_save, 'wb') as f:
pickle.dump([proj_idx, labels], f)
def detect_pc(self):
colors = Plot.random_colors(21, seed=2)
# for batch_idx, batch_data in enumerate(self.test_dataloader):
# for key in batch_data:
# if type(batch_data[key]) is list:
# for i in range(len(batch_data[key])):
# batch_data[key][i] = batch_data[key][i].cuda()
# else:
# batch_data[key] = batch_data[key].cuda()
# xyz = batch_data['xyz'] # (batch,N,3)
# neigh_idx = batch_data['neigh_idx'] # (batch,N,16)
# sub_idx = batch_data['sub_idx'] # (batch,N/4,16)
# interp_idx = batch_data['interp_idx'] # (batch,N,1)
# features = batch_data['features'] # (batch, 3, N)
# labels = batch_data['labels'] # (batch, N)
# input_inds = batch_data['input_inds'] # (batch, N)
# cloud_inds = batch_data['cloud_inds'] # (batch, 1)
# with torch.no_grad():
# self.out = self.net(xyz, neigh_idx, sub_idx, interp_idx,
# features, labels, input_inds, cloud_inds)
# Plot.draw_pointcloud(xyz[0].squeeze().cpu().numpy(),
# "pointcloud:{}".format(batch_idx))
# Plot.draw_pointcloud_semantic_instance(
# xyz[0].squeeze().cpu().numpy(),
# labels.cpu().numpy()[0],
# "pointcloud_label:{}".format(batch_idx), colors)
# Plot.draw_pointcloud_semantic_instance(
# xyz[0].squeeze().cpu().numpy(),
# self.out.argmax(dim=1).cpu().numpy().squeeze(),
# "pointcloud_label:{}".format(batch_idx), colors)
# print(self.out.argmax(dim=1).cpu().numpy().squeeze())
# print(labels.cpu().numpy()[0])
for seq_id in sequence_list:
print('sequence' + seq_id + ' start')
seq_path = os.path.join(dataset_path, seq_id)
pc_path = os.path.join(seq_path, 'velodyne')
label_path = os.path.join(seq_path, 'labels')
scan_list = np.sort(os.listdir(pc_path))
for scan_id in scan_list:
print(scan_id)
points = DataProcessing.load_pc_kitti(
os.path.join(pc_path, scan_id))
labels = DataProcessing.load_label_kitti(
os.path.join(label_path,
str(scan_id[:-4]) + '.label'), remap_lut)
# label_ = labels
search_tree = KDTree(points)
pick_idx = np.random.choice(len(points), 1)
print(pick_idx)
selected_pc_, selected_labels_, selected_idx_, cloud_ind_ = [],[],[],[]
# selected_pc, selected_labels, selected_idx = SemanticKITTI.crop_pc(
# points, labels, search_tree, pick_idx)
# selected_pc = selected_pc.astype(np.float32)
# selected_labels = selected_labels.astype(np.int32)
# selected_idx = selected_idx.astype(np.int32)
selected_pc = points.astype(np.float32)
selected_labels = labels.astype(np.int32)
selected_idx = pick_idx.astype(np.int32)
selected_pc_.append(selected_pc) # (N,3)
selected_labels_.append(selected_labels) # (N,)
selected_idx_.append(selected_idx) # (N,)
cloud_ind_.append(np.array([scan_id[:-4]],
dtype=np.int32)) # (1,)
selected_pc_ = np.stack(selected_pc_) # (batch,N,3)
selected_labels_ = np.stack(selected_labels_) # (batch,N)
selected_idx_ = np.stack(selected_idx_) # (batch,N)
cloud_ind_ = np.stack(cloud_ind_) # (batch,1)
flat_inputs = SemanticKITTI.tf_map(selected_pc_,
selected_labels_,
selected_idx_, cloud_ind_)
num_layers = ConfigSemanticKITTI.num_layers
inputs = {}
inputs['xyz'] = [] # (batch,N,3)
for tmp in flat_inputs[:num_layers]:
inputs['xyz'].append(torch.from_numpy(tmp).float().cuda())
inputs['neigh_idx'] = [] # (batch,N,16)
for tmp in flat_inputs[num_layers:2 * num_layers]:
inputs['neigh_idx'].append(
torch.from_numpy(tmp).long().cuda())
inputs['sub_idx'] = [] # (batch,N/4,16)
for tmp in flat_inputs[2 * num_layers:3 * num_layers]:
inputs['sub_idx'].append(
torch.from_numpy(tmp).long().cuda())
inputs['interp_idx'] = [] # (batch,N,1)
for tmp in flat_inputs[3 * num_layers:4 * num_layers]:
inputs['interp_idx'].append(
torch.from_numpy(tmp).long().cuda())
inputs['features'] = torch.from_numpy(
flat_inputs[4 * num_layers]).transpose(
1, 2).float().cuda() # (batch, N, 3)->(batch, 3, N)
inputs['labels'] = torch.from_numpy(
flat_inputs[4 * num_layers +
1]).long().cuda() # (batch, N)
inputs['input_inds'] = torch.from_numpy(
flat_inputs[4 * num_layers +
2]).long().cuda() # (batch, N)
inputs['cloud_inds'] = torch.from_numpy(
flat_inputs[4 * num_layers +
3]).long().cuda() # (batch, 1)
xyz = inputs['xyz'] # (batch,N,3)
neigh_idx = inputs['neigh_idx'] # (batch,N,16)
sub_idx = inputs['sub_idx'] # (batch,N/4,16)
interp_idx = inputs['interp_idx'] # (batch,N,1)
features = inputs['features'] # (batch, 3, N)
labels = inputs['labels'] # (batch, N)
input_inds = inputs['input_inds'] # (batch, N)
cloud_inds = inputs['cloud_inds'] # (batch, 1)
with torch.no_grad():
# labels = labels.reshape(-1)
self.out = self.net(
xyz, neigh_idx, sub_idx, interp_idx, features, labels,
input_inds,
cloud_inds).argmax(dim=1).cpu().numpy().squeeze()
print(self.out)
pred = self.out.astype(np.uint32)
upper_half = pred >> 16
lower_half = pred & 0xFFFF
lower_half = remap_lut[lower_half]
pred = (upper_half << 16) + lower_half
pred = pred.astype(np.uint32)
print(pred)
# logits = self.out.transpose(1, 2).reshape(
# -1, ConfigSemanticKITTI.num_classes)
# ignored_bool = labels == 0
# for ign_label in ConfigSemanticKITTI.ignored_label_inds:
# ignored_bool = ignored_bool | (labels == ign_label)
# valid_idx = ignored_bool == 0
# valid_logits = logits[valid_idx, :]
# valid_labels_init = labels[valid_idx]
# print(valid_logits.shape)
# print(self.out.argmax(dim=1).cpu().numpy().squeeze().shape)
# Plot.draw_pointcloud(xyz[0].squeeze().cpu().numpy(),
# "pointcloud:{}".format(scan_id))
# Plot.draw_pointcloud_semantic_instance(
# xyz[0].squeeze().cpu().numpy(), pred,
# "pointcloud_label:{}".format(scan_id))
# print(self.out.argmax(dim=1).cpu().numpy().squeeze())
print(labels.cpu().numpy()[0])
Plot.draw_pointcloud_semantic_instance(
xyz[0].squeeze().cpu().numpy(),
labels.cpu().numpy()[0],
"pointcloud_label:{}".format(scan_id))
def __init__(self, mode):
self.name = 'Semantic3D'
self.mode = mode
self.path = os.path.join(root_dir, 'data/semantic3d')
self.label_to_names = {
0: 'unlabeled',
1: 'man-made terrain',
2: 'natural terrain',
3: 'high vegetation',
4: 'low vegetation',
5: 'buildings',
6: 'hard scape',
7: 'scanning artefacts',
8: 'cars'
}
self.num_classes = len(self.label_to_names)
self.label_values = np.sort(
[k for k, v in self.label_to_names.items()])
self.label_to_idx = {l: i for i, l in enumerate(self.label_values)}
self.ignored_labels = np.sort([0])
self.original_folder = os.path.join(self.path, 'original_data')
self.full_pc_folder = os.path.join(self.path, 'original_ply')
self.sub_pc_folder = os.path.join(
self.path, 'input_{:.3f}'.format(ConfigSemantic3D.sub_grid_size))
# Following KPConv to do the train-validation split
self.all_splits = [0, 1, 4, 5, 3, 4, 3, 0, 1, 2, 3, 4, 2, 0, 5]
self.val_split = 1
# Initial training-validation-testing files
self.train_files = []
self.val_files = []
self.test_files = []
cloud_names = [
file_name[:-4] for file_name in os.listdir(self.original_folder)
if file_name[-4:] == '.txt'
]
for pc_name in cloud_names:
if os.path.exists(
os.path.join(self.original_folder, pc_name + '.labels')):
self.train_files.append(
os.path.join(self.sub_pc_folder, pc_name + '.ply'))
else:
self.test_files.append(
os.path.join(self.full_pc_folder, pc_name + '.ply'))
self.train_files = np.sort(self.train_files)
self.test_files = np.sort(self.test_files)
for i, file_path in enumerate(self.train_files):
if self.all_splits[i] == self.val_split:
self.val_files.append(file_path)
self.train_files = np.sort(
[x for x in self.train_files if x not in self.val_files])
# Initiate containers
self.val_proj = []
self.val_labels = []
self.test_proj = []
self.test_labels = []
self.possibility = {'training': [], 'validation': [], 'test': []}
self.min_possibility = {'training': [], 'validation': [], 'test': []}
self.class_weight = {'training': [], 'validation': [], 'test': []}
self.input_trees = {'training': [], 'validation': [], 'test': []}
self.input_colors = {'training': [], 'validation': [], 'test': []}
self.input_labels = {'training': [], 'validation': []}
# Ascii files dict for testing
self.ascii_files = {
'MarketplaceFeldkirch_Station4_rgb_intensity-reduced.ply':
'marketsquarefeldkirch4-reduced.labels',
'sg27_station10_rgb_intensity-reduced.ply':
'sg27_10-reduced.labels',
'sg28_Station2_rgb_intensity-reduced.ply':
'sg28_2-reduced.labels',
'StGallenCathedral_station6_rgb_intensity-reduced.ply':
'stgallencathedral6-reduced.labels',
'birdfountain_station1_xyz_intensity_rgb.ply':
'birdfountain1.labels',
'castleblatten_station1_intensity_rgb.ply':
'castleblatten1.labels',
'castleblatten_station5_xyz_intensity_rgb.ply':
'castleblatten5.labels',
'marketplacefeldkirch_station1_intensity_rgb.ply':
'marketsquarefeldkirch1.labels',
'marketplacefeldkirch_station4_intensity_rgb.ply':
'marketsquarefeldkirch4.labels',
'marketplacefeldkirch_station7_intensity_rgb.ply':
'marketsquarefeldkirch7.labels',
'sg27_station10_intensity_rgb.ply':
'sg27_10.labels',
'sg27_station3_intensity_rgb.ply':
'sg27_3.labels',
'sg27_station6_intensity_rgb.ply':
'sg27_6.labels',
'sg27_station8_intensity_rgb.ply':
'sg27_8.labels',
'sg28_station2_intensity_rgb.ply':
'sg28_2.labels',
'sg28_station5_xyz_intensity_rgb.ply':
'sg28_5.labels',
'stgallencathedral_station1_intensity_rgb.ply':
'stgallencathedral1.labels',
'stgallencathedral_station3_intensity_rgb.ply':
'stgallencathedral3.labels',
'stgallencathedral_station6_intensity_rgb.ply':
'stgallencathedral6.labels'
}
ConfigSemantic3D.ignored_label_inds = [
self.label_to_idx[ign_label] for ign_label in self.ignored_labels
]
ConfigSemantic3D.class_weights = DataProcessing.get_class_weights(
'Semantic3D')
self.load_sub_sampled_clouds(ConfigSemantic3D.sub_grid_size)