def test_presample(): for t in xrange(17): points,labels=read_pkl('data/Semantic3D.Net/pkl/test_presample/MarketplaceFeldkirch_Station4_rgb_intensity-reduced_{}.pkl'.format(t)) print points.shape idxs=libPointUtil.gridDownsampleGPU(points,0.1,False) points=points[idxs] output_points('test_result/{}.txt'.format(t), points)
def test_train_block(): with open('data/ScanNet/scannet_train.pickle', 'rb') as f: points = cPickle.load(f) labels = cPickle.load(f) room_num = len(points) for i in xrange(3): bg = time.time() xyzs, covars, lbls = sample_block_scannet(points[i], labels[i], 0.02, 3.0, 1.5, 128, True, True, True, 0.1) cxyzs, dxyzs, covars, lbls, vlens, vlens_bgs, vcidxs, cidxs, nidxs, nidxs_bgs, nidxs_lens, block_mins=\ normalize_block_scannet(xyzs,covars,lbls,3.0,0.1,0.3,1.0,0.15,0.5,True,0.8,1.0,10240) print 'single cost {} s'.format(time.time() - bg) colors = np.random.randint(0, 256, [21, 3]) for t in xrange(len(cxyzs)): output_points('test_result/{}_{}.txt'.format(i, t), cxyzs[t][0] + block_mins[t], colors[lbls[t]]) print 'point num {} {} {}'.format(cxyzs[t][0].shape[0], cxyzs[t][1].shape[0], cxyzs[t][2].shape[0]) print 'mean neighbor size {} {} {}'.format( float(nidxs[t][0].shape[0]) / cxyzs[t][0].shape[0], float(nidxs[t][1].shape[0]) / cxyzs[t][1].shape[0], float(nidxs[t][2].shape[0]) / cxyzs[t][2].shape[0])
def test_interpolate(): sxyzs = np.asarray([ [0.0, 0.0, 0.0], [0.0, 1.0, 0.0], [1.0, 0.0, 0.0], [1.0, 1.0, 0.0], ], dtype=np.float32) # sxyzs=np.random.uniform(0.0,1.0,[128,3]) sxyzs = np.asarray(sxyzs, dtype=np.float32) sprobs = np.random.uniform(0.0, 255.0, [4, 3]) print sprobs sprobs = np.asarray(sprobs, dtype=np.float32) qxyzs = np.random.uniform(0.0, 1.0, [1024, 3]) qxyzs[:, 2] = 0.0 qxyzs = np.asarray(qxyzs, dtype=np.float32) nidxs = libPointUtil.findNeighborInAnotherGPU(sxyzs, qxyzs, 4, 1) nidxs_lens = np.asarray([len(idxs) for idxs in nidxs], dtype=np.int32) nidxs_bgs = compute_nidxs_bgs(nidxs_lens) nidxs = np.concatenate(nidxs, axis=0) qprobs = libPointUtil.interpolateProbsGPU(sxyzs, qxyzs, sprobs, nidxs, nidxs_lens, nidxs_bgs, 2) print qprobs output_points('test_result/int_rgbs.txt', qxyzs, np.asarray(qprobs, np.int))
def test_prepare_dataset(): points, nidxs, covars, rpoints, labels = read_block( '../data/S3DIS/folding/block/0_Area_1_conferenceRoom_1.h5') print 'points:' print np.min(points, axis=(0, 1)) print np.max(points, axis=(0, 1)) print 'nidixs' print np.min(nidxs, axis=(0, 1)) print np.max(nidxs, axis=(0, 1)) print 'rpoints' print np.min(rpoints, axis=(0, 1)) print np.max(rpoints, axis=(0, 1)) print 'covars' print np.min(np.sum(covars**2, axis=2)), np.max(np.sum(covars**2, axis=2)) print 'labels' print np.min(labels), np.max(labels) from draw_util import output_points ccolors = get_class_colors() for block_i, block_rpoitns in enumerate(rpoints): colors = np.asarray(points[block_i, :, 3:] * 128 + 128, np.int) output_points('colors{}.txt'.format(block_i), block_rpoitns, colors) output_points('labels{}.txt'.format(block_i), block_rpoitns, ccolors[labels[block_i], :])
def test_cluster_covar(xyz, covars, name): from sklearn.cluster import KMeans from draw_util import output_points kmeans = KMeans(5) colors = np.random.randint(0, 256, [5, 3]) preds = kmeans.fit_predict(covars) output_points('test_result/{}.txt'.format(name), xyz, colors[preds])
def test_random_rotate_sample(): from data_util import read_room_pkl, get_block_train_test_split, save_room_pkl from draw_util import output_points import time train_list, test_list = get_block_train_test_split() train_list += test_list idx = 0 for fn in train_list[:1]: begin = time.time() points, labels = read_room_pkl('../data/S3DIS/room_block_10_10/' + '153_Area_4_hallway_3.pkl') # output_points('test.txt',points) labels[labels == 13] = 12 block_points_list, block_labels_list = random_rotate_sample_block( points, labels, block_size=3.0, stride=1.5) for block_points in block_points_list: # print block_points.shape print fn assert block_points.shape[0] != 0 fs = fn.split('.')[0] for pts, lbs in zip(block_points_list, block_labels_list): output_points('test_result/' + fs + '_' + str(idx) + '.txt', pts) idx += 1 print 'cost {} s'.format(time.time() - begin)
def test_one_epoch(ops, pls, sess, saver, testset, epoch_num, feed_dict, summary_writer=None): begin_time = time.time() test_loss = [] all_preds, all_labels = [], [] colors = get_scannet_class_colors() for i, feed_in in enumerate(testset): _, batch_labels, block_mins = fill_feed_dict(feed_in, feed_dict, pls, FLAGS.num_gpus) feed_dict[pls['is_training']] = False all_labels += batch_labels loss, logits = sess.run([ops['total_loss'], ops['logits']], feed_dict) preds = np.argmax(logits[:, 1:], axis=1) + 1 test_loss.append(loss) all_preds.append(preds) # output labels and true if FLAGS.eval and FLAGS.eval_output: cur = 0 for k in xrange(FLAGS.num_gpus): xyzs = feed_dict[pls['cxyzs'][k][0]] lbls = feed_dict[pls['lbls'][k]] xyzs += block_mins[k] output_points('test_result/{}_{}_true.txt'.format(i, k), xyzs, colors[lbls, :]) output_points('test_result/{}_{}_pred.txt'.format(i, k), xyzs, colors[preds[cur:cur + len(xyzs)], :]) cur += len(xyzs) all_preds = np.concatenate(all_preds, axis=0) all_labels = np.concatenate(all_labels, axis=0) mask = all_labels != 0 all_preds = all_preds[mask] all_labels = all_labels[mask] iou, miou, oiou, acc, macc, oacc = compute_iou(all_labels - 1, all_preds - 1, 20) test_loss = np.mean(np.asarray(test_loss)) log_str( 'mean iou {:.5} overall iou {:5} loss {:5} \n mean acc {:5} overall acc {:5} cost {:3} s' .format(miou, oiou, test_loss, macc, oacc, time.time() - begin_time), FLAGS.log_file) if not FLAGS.eval: checkpoint_path = os.path.join(FLAGS.save_dir, 'model{}.ckpt'.format(epoch_num)) saver.save(sess, checkpoint_path) else: names = get_scannet_class_names()[1:] for i in xrange(len(names)): print '{} iou {} acc {}'.format(names[i], iou[i], acc[i])
def test_labels(): import os fss,fns=read_semantic3d_pkl_stems() from io_util import get_semantic3d_class_colors colors=get_semantic3d_class_colors() for fn in os.listdir('data/Semantic3D.Net/block/train'): if fn.startswith(fss[6]) and fn.endswith('_0.pkl'): # or fn.endswith('_3.pkl')): points,labels=read_room_pkl('data/Semantic3D.Net/block/train/'+fn) idxs = libPointUtil.gridDownsampleGPU(points, 0.1, False) output_points('test_result/'+fn[:-4]+'.txt',points[idxs],colors[labels[idxs],:])
def test_single_sample(): xyzs, rgbs, covars, lbls=\ semantic3d_process_block_v2('data/Semantic3D.Net/block/train/bildstein_station1_xyz_intensity_rgb_9_2.pkl') from draw_util import get_semantic3d_class_colors colors=get_semantic3d_class_colors() max_pt_num=0 for i in xrange(len(xyzs)): print xyzs[i].shape max_pt_num=max(xyzs[i].shape[0],max_pt_num) output_points('test_result/{}_rgb.txt'.format(i),xyzs[i],127*rgbs[i]+128) output_points('test_result/{}_lbl.txt'.format(i),xyzs[i],colors[lbls[i],:]) print 'max pn {}'.format(max_pt_num)
def visual_room(): train_list, test_list = get_block_train_test_split() train_list += test_list file_list = [fn for fn in train_list if fn.split('_')[-2] == 'office'] from draw_util import get_class_colors, output_points colors = get_class_colors() for fn in file_list: xyzs, rgbs, covars, labels, block_mins = read_pkl( 'data/S3DIS/office_block/' + fn) for k in xrange(len(xyzs)): xyzs[k] += block_mins[k] xyzs = np.concatenate(xyzs, axis=0) labels = np.concatenate(labels, axis=0) output_points('test_result/{}.txt'.format(fn), xyzs, colors[labels])
def test_fpfh(): import draw_util from sklearn.cluster import KMeans feats,labels=read_points_feats('/home/pal/project/PCDL/pc_seg/data/S3DIS/point/fpfh/0_Area_1_conferenceRoom_1.h5') print np.max(feats,axis=0) print np.min(feats,axis=0) print np.mean(feats,axis=0) kmeans=KMeans(n_clusters=5,n_jobs=-1) preds=kmeans.fit_predict(feats[:,6:]) for i in range(5): mask=preds==i color=np.random.randint(0,255,3) draw_util.output_points("kmeans{}.txt".format(i),feats[mask,0:3],color) colors=get_class_colors() draw_util.output_points("labels.txt",feats[:,:3],colors[labels,:])
def test_radius_covar(): from data_util import downsample_random from draw_util import output_points points, labels = read_room_h5( '../data/S3DIS/room/0_Area_1_conferenceRoom_1.h5') print points.shape points, labels, _ = downsample_random(points, labels, 0.02) print points.shape output_points('test.txt', points) covars = compute_radius_covars(points[:, :3], 0.1) covars /= np.sqrt(np.sum(covars**2, axis=1, keepdims=True)) from sklearn.cluster import KMeans kmeans = KMeans(8, n_jobs=-1) pred = kmeans.fit_predict(covars) print pred.shape colors = np.random.randint(0, 255, [8, 3]) output_points('cluster.txt', points, colors[pred, :])
def test_block(): import os fss,fns=read_semantic3d_pkl_stems() from draw_util import get_semantic3d_class_colors colors=get_semantic3d_class_colors() for fs in fss: all_points,all_labels=[],[] for fn in os.listdir('data/Semantic3D.Net/block/train'): if fn.startswith(fs) and fn.endswith('_0.pkl'): # or fn.endswith('_3.pkl')): points,labels=read_room_pkl('data/Semantic3D.Net/block/train/'+fn) idxs = libPointUtil.gridDownsampleGPU(points, 0.1, False) all_points.append(points[idxs]) all_labels.append(labels[idxs]) all_points = np.concatenate(all_points, axis=0) all_labels = np.concatenate(all_labels, axis=0) output_points('test_result/'+fs+'_labels.txt',all_points,colors[all_labels,:]) output_points('test_result/'+fs+'_colors.txt',all_points)
def generate_anchor(center_num=5): if os.path.exists('cached/centers.txt'): with open('cached/centers.txt', 'r') as f: centers = [] for line in f.readlines(): line = line.strip('\n') subline = line.split(' ') centers.append( [float(subline[0]), float(subline[1]), float(subline[2])]) centers = np.asarray(centers, dtype=np.float32) if centers.shape[0] == center_num: return centers.transpose() pts = np.random.uniform(-1.0, 1.0, [100000, 3]) pts /= np.sqrt(np.sum(pts**2, axis=1, keepdims=True) + 1e-6) kmeans = KMeans(center_num) labels = kmeans.fit_predict(pts) centers = [] for i in xrange(center_num): centers.append(np.mean(pts[labels == i], axis=0)) centers = np.asarray(centers) ang1 = -np.arctan2(centers[0, 0], centers[0, 1]) cosv, sinv = np.cos(ang1), np.sin(ang1) m = np.asarray([[cosv, -sinv, 0], [sinv, cosv, 0], [0, 0, 1]], dtype=np.float64) centers, pts = np.dot(centers, m), np.dot(pts, m) ang2 = -(np.pi / 2 - np.arctan2(centers[0, 2], centers[0, 1])) cosv, sinv = np.cos(ang2), np.sin(ang2) m = np.asarray([[1, 0, 0], [0, cosv, -sinv], [0, sinv, cosv]], dtype=np.float64) centers, pts = np.dot(centers, m), np.dot(pts, m) output_points('cached/centers.txt', centers) return centers.transpose()
def save_results(sxyzs, qxyzs, sprobs, qprobs, prefix, fs): colors = get_semantic3d_class_colors() spreds = np.argmax(sprobs[:, 1:], axis=1) + 1 qpreds = np.argmax(qprobs[:, 1:], axis=1) + 1 dir = 'data/Semantic3D.Net/{}'.format(prefix) if not os.path.exists(dir): os.mkdir(dir) with open('{}/{}.labels'.format(dir, fs), 'w') as f: for pred in qpreds: f.write('{}\n'.format(pred)) idxs = libPointUtil.gridDownsampleGPU(sxyzs, 0.3, False) sxyzs = sxyzs[idxs] spreds = spreds[idxs] output_points('{}/{}_sparse.txt'.format(dir, fs), sxyzs, colors[spreds]) idxs = libPointUtil.gridDownsampleGPU(qxyzs, 0.3, False) qxyzs = qxyzs[idxs] qpreds = qpreds[idxs] output_points('{}/{}_dense.txt'.format(dir, fs), qxyzs, colors[qpreds])
def compare(): from draw_util import output_points from sklearn.cluster import KMeans train_list, test_list = get_block_train_test_split() random.shuffle(train_list) train_list_add = ['data/S3DIS/sampled_train/' + fn for fn in train_list] for fi, fs in enumerate(train_list_add[:3]): cxyzs, dxyzs, rgbs, covars, lbls, vlens, vlens_bgs, vcidxs, cidxs, nidxs, nidxs_bgs, nidxs_lens, block_mins = read_pkl( fs) for i in xrange(len(cxyzs[:10])): print np.sum(np.sum(np.abs(covars[i]), axis=1) < 1e-3) kmeans = KMeans(5) colors = np.random.randint(0, 256, [5, 3]) preds = kmeans.fit_predict(covars[i]) output_points('test_result/{}_{}.txt'.format(fi, i), cxyzs[i][0], colors[preds]) print '//////////////////////////'
def test_prepare_v2(): points, covars, rpoints, labels = read_block_v2( '../data/S3DIS/folding/block_v2/5_Area_1_hallway_3.h5') print 'points:' print np.min(points, axis=(0, 1)) print np.max(points, axis=(0, 1)) print 'rpoints' print np.min(rpoints, axis=(0, 1)) print np.max(rpoints, axis=(0, 1)) print 'covars' print np.min(np.sum(covars**2, axis=2)), np.max(np.sum(covars**2, axis=2)) print 'labels' print np.min(labels), np.max(labels) from draw_util import output_points ccolors = get_class_colors() for block_i, block_rpoitns in enumerate(rpoints): colors = np.asarray(points[block_i, :, 3:] * 128 + 128, np.int) output_points('colors{}.txt'.format(block_i), block_rpoitns, colors) output_points('labels{}.txt'.format(block_i), block_rpoitns, ccolors[labels[block_i], :]) from sklearn.cluster import KMeans kmeans = KMeans(8, n_jobs=-1) covars = np.reshape(covars, [-1, 9]) pred = kmeans.fit_predict(covars) rpoints = np.reshape(rpoints, [-1, 3]) colors = np.random.randint(0, 255, [8, 3]) output_points('cluster.txt', rpoints, colors[pred, :])
def test_block_train(): train_list, test_list = get_block_train_test_split() from draw_util import get_class_colors, output_points # colors=get_class_colors() # for fn in train_list[:1]: # xyzs, rgbs, covars, lbls, block_mins=read_pkl(fn) # # for i in xrange(len(xyzs[:5])): # rgbs[i]+=128 # rgbs[i]*=127 # output_points('test_result/{}clr.txt'.format(i),xyzs[i],rgbs[i]) # output_points('test_result/{}lbl.txt'.format(i),xyzs[i],colors[lbls[i]]) # count=0 # pt_nums=[] # # stem2num={} # for fn in train_list: # xyzs, rgbs, covars, lbls, block_mins=read_pkl('data/S3DIS/sampled_train_nolimits/'+fn) # stem='_'.join(fn.split('_')[1:]) # if stem in stem2num: # stem2num[stem]+=len(xyzs) # else: # stem2num[stem]=len(xyzs) # # print stem,stem2num[stem] # count+=len(xyzs) # pt_nums+=[len(pts) for pts in xyzs] # # print count # print np.max(pt_nums) # print np.histogram(pt_nums) xyzs, rgbs, covars, lbls, block_mins = read_pkl( 'data/S3DIS/sampled_train_nolimits/{}'.format( '1_Area_1_conferenceRoom_2.pkl')) for i in xrange(len(xyzs)): output_points('test_result/{}.txt'.format(i), xyzs[i] + block_mins[i], rgbs[i] * 127 + 128)
def cluster(): from sklearn.cluster import KMeans from draw_util import output_points ops, pls, feats_grad = build_model() xyzs, feats, labels = load_data() all_feats = tf.concat(ops, axis=1) config = tf.ConfigProto() config.gpu_options.allow_growth = True config.allow_soft_placement = True config.log_device_placement = False sess = tf.Session(config=config) saver = tf.train.Saver(tf.trainable_variables()) saver.restore(sess, 'model/gpn_edge_new_v2/model23.ckpt') kmeans = KMeans(n_clusters=5, n_jobs=-1) colors = np.random.randint(0, 256, [5, 3]) for i in xrange(1): all_layer_feats = [] for k in xrange(len(xyzs)): layer_feats = sess.run(all_feats, feed_dict={ pls['xyzs']: xyzs[k], pls['feats']: feats[k], pls['labels']: labels[k], }) all_layer_feats.append(layer_feats) all_layer_feats = np.concatenate(all_layer_feats, axis=0) print i, np.max(all_layer_feats, axis=0), np.mean(all_layer_feats) preds = kmeans.fit_predict(all_layer_feats) cur_loc = 0 for t in xrange(2): output_points('test_result/{}_{}_preds.txt'.format(i, t), xyzs[t], colors[preds[cur_loc:cur_loc + len(xyzs[t])], :]) output_points('test_result/{}_{}_colors.txt'.format(i, t), xyzs[t], feats[t][:, :3] * 127 + 128)
def test_covar(): train_list, test_list = get_block_train_test_split() points, labels = read_pkl('data/S3DIS/room_block_10_10/' + train_list[0]) xyzs, rgbs, covars, lbls = sample_block(points, labels, sstride, bsize, bstride, min_pn=512, use_rescale=False, swap=False, flip_x=False, flip_y=False, covar_ds_stride=0.075, covar_nn_size=0.15) from sklearn.cluster import KMeans from draw_util import output_points for i in xrange(len(xyzs[:5])): kmeans = KMeans(5) colors = np.random.randint(0, 256, [5, 3]) preds = kmeans.fit_predict(covars[i]) output_points('test_result/{}.txt'.format(i), xyzs[i], colors[preds])
def test_normalize(): from draw_util import output_points, get_class_colors from sklearn.cluster import KMeans colors = get_class_colors() train_list, test_list = get_block_train_test_split() random.shuffle(train_list) train_list = ['data/S3DIS/room_block_10_10/' + fn for fn in train_list] # filename=train_list[0] filename = 'data/S3DIS/room_block_10_10/49_Area_1_office_8.pkl' points, labels = read_room_pkl(filename) # [n,6],[n,1] begin = time.time() xyzs, rgbs, covars, lbls = sample_block(points, labels, SAMPLE_STRIDE, BLOCK_SIZE, BLOCK_STRIDE, min_pn=2048, use_rescale=True, use_flip=True, use_rotate=True) print 'sample_block cost {} s'.format(time.time() - begin) # for j in xrange(len(xyzs)): # print np.min(xyzs[j],axis=0),np.max(xyzs[j],axis=0) # print np.min(rgbs[j],axis=0),np.max(rgbs[j],axis=0) # print xyzs[j].shape,lbls[j].shape # output_points('test_result/label_init{}.txt'.format(j),xyzs[j],colors[lbls[j].flatten(),:]) # output_points('test_result/lrgbs_init{}.txt'.format(j),xyzs[j],rgbs[j]) xyzs, rgbs, covars, lbls, nidxs, nidxs_lens, nidxs_bgs, cidxs=\ normalize_block(xyzs,rgbs,covars,lbls,0.2,True,0.8,1.0,True,2.5) for j in xrange(len(xyzs)): print xyzs[j].shape, rgbs[j].shape, covars[j].shape, lbls[ j].shape, nidxs[j].shape, nidxs_lens[j].shape, nidxs_bgs[ j].shape, cidxs[j].shape print np.min(xyzs[j], axis=0), np.max(xyzs[j], axis=0) print np.min(rgbs[j], axis=0), np.max(rgbs[j], axis=0) print 'avg nn size: {}'.format(len(nidxs[j]) / float(len(xyzs[j]))) # print xyzs[j].shape,lbls[j].shape output_points('test_result/label{}.txt'.format(j), xyzs[j], colors[lbls[j].flatten(), :]) output_points('test_result/lrgbs{}.txt'.format(j), xyzs[j], np.asarray(rgbs[j] * 128 + 127, np.int32)) for j in xrange(len(xyzs[0])): output_points( 'test_result/nn{}.txt'.format(j), xyzs[0][nidxs[0][nidxs_bgs[0][j]:nidxs_bgs[0][j] + nidxs_lens[0][j]], :])
def test_sample(): from draw_util import output_points, get_class_colors from sklearn.cluster import KMeans colors = get_class_colors() train_list, test_list = get_block_train_test_split() random.shuffle(train_list) train_list = ['data/S3DIS/room_block_10_10/' + fn for fn in train_list] filename = train_list[0] # filename='data/S3DIS/room_block_10_10/58_Area_2_auditorium_2.pkl' points, labels = read_room_pkl(filename) # [n,6],[n,1] print np.min(points, axis=0) begin = time.time() xyzs, rgbs, covars, lbls = sample_block(points, labels, 0.075, 1.5, 1.5, min_pn=2048 / 2) #use_rescale=True,use_flip=True,use_rotate=True) print 'sample_block cost {} s'.format(time.time() - begin) print np.min(np.concatenate(xyzs, axis=0), axis=0) kc = np.random.randint(0, 255, [5, 3]) for j in xrange(len(xyzs)): # print xyzs[j].shape,lbls[j].shape output_points('test_result/label{}.txt'.format(j), xyzs[j], colors[lbls[j].flatten(), :]) output_points('test_result/lrgbs{}.txt'.format(j), xyzs[j], rgbs[j]) kmeans = KMeans(5) preds = kmeans.fit_predict(np.concatenate(covars, axis=0)) output_points('test_result/kmeans.txt', np.concatenate(xyzs, axis=0), kc[preds.flatten(), :]) pt_num = [len(xyz) for xyz in xyzs] print 'avg pt num: {}'.format(np.mean(pt_num))
:return: covars: n,k,9 ''' nidxs=np.ascontiguousarray(nidxs,dtype=np.int32) points=np.ascontiguousarray(points,dtype=np.float32) covars=PointsUtil.ComputeCovars(points,nidxs,nn_size,gpu_index) return covars if __name__=="__main__": from draw_util import output_points import time points=np.loadtxt('/home/liuyuan/tmp/0_8_true.txt',dtype=np.float32) points[:,:2]+=0.5 print np.min(points,axis=0) print np.max(points,axis=0) output_points('points.txt',points) bg=time.time() points=np.repeat(points[None,:,:],2,axis=0) # print points.shape voxels=PointsUtil.Points2VoxelBatchGPU(points,30) print 'cost {} s'.format(time.time()-bg) voxels=voxels[0] voxel_points= voxel2points(voxels) voxel_points=voxel_points.astype(np.float32) voxel_points[:,:3]/=np.max(voxel_points[:,:3],axis=0,keepdims=True) output_points('voxels.txt',voxel_points)
def test_one_epoch(ops, pls, sess, saver, testset, epoch_num, feed_dict, summary_writer=None): begin_time = time.time() test_loss = [] all_preds, all_labels = [], [] colors = get_class_colors() weights = get_class_loss_weights() for i, feed_in in enumerate(testset): xyzs, rgbs, covars, lbls, nidxs, nidxs_lens, nidxs_bgs, cidxs, block_bgs, block_lens=\ default_unpack_feats_labels(feed_in,FLAGS.num_gpus) for k in xrange(FLAGS.num_gpus): feed_dict[pls['xyzs'][k]] = xyzs[k] feed_dict[pls['rgbs'][k]] = rgbs[k] feed_dict[pls['covars'][k]] = covars[k] feed_dict[pls['lbls'][k]] = lbls[k] feed_dict[pls['nidxs'][k]] = nidxs[k] feed_dict[pls['nidxs_lens'][k]] = nidxs_lens[k] feed_dict[pls['nidxs_bgs'][k]] = nidxs_bgs[k] feed_dict[pls['cidxs'][k]] = cidxs[k] all_labels.append(lbls[k]) if FLAGS.weighted_loss: feed_dict[pls['weights'][k]] = weights[lbls[k]] feed_dict[pls['is_training']] = False if FLAGS.eval and FLAGS.num_monitor: loss, preds, summary = sess.run( [ops['total_loss'], ops['preds'], ops['summary']], feed_dict) summary_writer.add_summary(summary) else: loss, preds = sess.run([ops['total_loss'], ops['preds']], feed_dict) test_loss.append(loss) all_preds.append(preds) # output labels and true if FLAGS.eval and FLAGS.eval_output: cur = 0 for k in xrange(FLAGS.num_gpus): restore_xyzs = xyzs[k] restore_xyzs[:, :2] = restore_xyzs[:, :2] * 1.5 + 1.5 restore_xyzs[:, 2] += 1.0 restore_xyzs[:, 2] *= block_lens[k][2] / 2 restore_xyzs += block_bgs[k] output_points('test_result/{}_{}_true.txt'.format(i, k), restore_xyzs, colors[lbls[k], :]) output_points('test_result/{}_{}_pred.txt'.format(i, k), restore_xyzs, colors[preds[cur:cur + len(xyzs[k])], :]) cur += len(xyzs[k]) if FLAGS.eval and FLAGS.num_monitor and i >= 2: break all_preds = np.concatenate(all_preds, axis=0) all_labels = np.concatenate(all_labels, axis=0) test_loss = np.mean(np.asarray(test_loss)) iou, miou, oiou, acc, macc, oacc = compute_iou(all_labels, all_preds) log_str( 'mean iou {:.5} overall iou {:5} loss {:5} \n mean acc {:5} overall acc {:5} cost {:3} s' .format(miou, oiou, test_loss, macc, oacc, time.time() - begin_time), FLAGS.log_file) if not FLAGS.eval: checkpoint_path = os.path.join(FLAGS.save_dir, 'model{}.ckpt'.format(epoch_num)) saver.save(sess, checkpoint_path) else: names = get_class_names() for i in xrange(len(names)): print '{} iou {} acc {}'.format(names[i], iou[i], acc[i])
spreds = np.argmax(sprobs, axis=1) + 1 if fi <= 5: idxs = libPointUtil.gridDownsampleGPU(sxyzs, 0.01, False) sxyzs = sxyzs[idxs] spreds = spreds[idxs] slbls = slbls[idxs] # output_points('test_result/{}spreds.txt'.format(fi),sxyzs,colors[spreds,:]) # output_points('test_result/{}slabel.txt'.format(fi),sxyzs,colors[slbls,:]) idxs = libPointUtil.gridDownsampleGPU(qxyzs, 0.01, False) qxyzs = qxyzs[idxs] qpreds = qpreds[idxs] labels = labels[idxs] points = points[idxs] output_points('test_result/{}qpreds.txt'.format(fi), qxyzs, colors[qpreds, :]) output_points('test_result/{}qlabel.txt'.format(fi), qxyzs, colors[labels.flatten(), :]) output_points('test_result/{}qcolor.txt'.format(fi), points) else: break labels = labels.flatten() qpreds = qpreds.flatten() mask = labels != 0 qpreds = qpreds[mask] labels = labels[mask] fp, tp, fn = acc_val(labels - 1, qpreds - 1, fp, tp, fn, 20) print 'total cost {} s'.format(time.time() - begin)
qprobs = [] for t in xrange(qrn): beg_idxs = t * rn end_idxs = min((t + 1) * rn, qn) qrprobs = interpolate(sxyzs, sprobs, qxyzs[beg_idxs:end_idxs]) print 'interpolate {} done'.format(t) qprobs.append(qrprobs) qprobs = np.concatenate(qprobs, axis=0) qpreds = np.argmax(qprobs[:, 1:], axis=1) + 1 colors = get_semantic3d_class_colors() spreds = np.argmax(sprobs[:, 1:], axis=1) + 1 print 'total cost {} s'.format(time.time() - begin) with open('data/Semantic3D.Net/{}.labels'.format(fn), 'w') as f: for p in qpreds: f.write('{}\n'.format(p)) idxs = libPointUtil.gridDownsampleGPU(sxyzs, 0.1, False) sxyzs = sxyzs[idxs] spreds = spreds[idxs] output_points('test_result/{}_sparse.txt'.format(fn), sxyzs, colors[spreds, :]) idxs = libPointUtil.gridDownsampleGPU(qxyzs, 0.1, False) qxyzs = qxyzs[idxs] qpreds = qpreds[idxs] output_points('test_result/{}_dense.txt'.format(fn), qxyzs, colors[qpreds, :])
train_provider = Provider(train_list, 'train', 4, read_fn) test_provider = Provider(test_list, 'test', 4, read_fn) try: begin = time.time() i = 0 for data in train_provider: i += 1 cxyzs, rgbs, covars, lbls, = default_unpack_feats_labels(data, 4) for k in xrange(4): print len(cxyzs[k]) print 'batch_num {}'.format(i * 4) print 'train set cost {} s'.format(time.time() - begin) finally: train_provider.close() test_provider.close() if __name__ == "__main__": # data=read_pkl('data/ModelNet40/ply_data_test1.pkl') # print len(data) # test_read_semantic_dataset() cxyzs, rgbs, covars, lbls = read_pkl('tmp_data.pkl') for i in xrange(4): print np.min(lbls[i]), np.max(lbls[i]) print np.min(cxyzs[i], axis=0), np.max(cxyzs[i], axis=0) print np.min(rgbs[i], axis=0), np.max(rgbs[i], axis=0) output_points('test_result/tmp{}.txt'.format(i), cxyzs[i], rgbs[i][:, :3] * 127 + 128)
def output_hierarchy(cxyz1, cxyz2, cxyz3, rgbs, lbls, vlens1, vlens2, dxyz1, dxyz2, vc1, vc2, idx=0, colors=s3dis_colors): output_points('test_result/cxyz1_rgb_{}.txt'.format(idx), cxyz1, rgbs) output_points('test_result/cxyz1_lbl_{}.txt'.format(idx), cxyz1, colors[lbls.flatten(), :]) # test cxyz vidxs = [] for i, l in enumerate(vlens1): vidxs += [i for _ in xrange(l)] colors = np.random.randint(0, 256, [vlens1.shape[0], 3]) vidxs = np.asarray(vidxs, np.int32) output_points('test_result/cxyz1_{}.txt'.format(idx), cxyz1, colors[vidxs, :]) output_points('test_result/cxyz2_{}.txt'.format(idx), cxyz2, colors) vidxs = [] for i, l in enumerate(vlens2): vidxs += [i for _ in xrange(l)] colors = np.random.randint(0, 256, [vlens2.shape[0], 3]) vidxs = np.asarray(vidxs, np.int32) output_points('test_result/cxyz2a_{}.txt'.format(idx), cxyz2, colors[vidxs, :]) output_points('test_result/cxyz3a_{}.txt'.format(idx), cxyz3, colors) # test dxyz c = 0 for k, l in enumerate(vlens1): for t in xrange(l): dxyz1[c + t] *= vc1 dxyz1[c + t] += cxyz2[k] c += l output_points('test_result/dxyz1_{}.txt'.format(idx), dxyz1) c = 0 for k, l in enumerate(vlens2): for t in xrange(l): dxyz2[c + t] *= vc2 dxyz2[c + t] += cxyz3[k] c += l output_points('test_result/dxyz2_{}.txt'.format(idx), dxyz2)