def eval_real_epoch(sess, ops, test_writer): PC_PATH = os.path.join(POINTCLOUD_DIR, 'Dataset/Data/partialface/real_scan/') INPUT_FOLDER = os.path.join(PC_PATH, 'sampled') OUTPUT_FOLDER = os.path.join(PC_PATH, 'pred') from glob import glob is_training = False samples = glob(INPUT_FOLDER + "/*.xyz") samples.sort(reverse=False) total_num = len(samples) for i in range(total_num): filename = samples[i].split('\\')[-1].replace('.xyz', '') print(filename) pointclouds_pl = np.loadtxt(samples[i]) pointclouds_pl = np.expand_dims(pointclouds_pl, axis=0) feed_dict = { ops['pointclouds_pl']: pointclouds_pl, ops['is_training_pl']: is_training, } # loss_val, pred_angle = sess.run([ops['loss'], ops['pred_angle']], feed_dict=feed_dict) pred_angle = sess.run([ops['pred_angle']], feed_dict=feed_dict) pred_angle = np.squeeze(pred_angle) print(pred_angle.shape) print(pred_angle) transform_xyz = Tools3D.quaternion_To_rotation_matrix( np.squeeze(pred_angle)) transform_xyz = np.array(transform_xyz) print(transform_xyz) np.savetxt(os.path.join(INPUT_FOLDER, filename + '.txt'), np.expand_dims(pred_angle, axis=0), fmt='%0.6f') point_cloud_transformed = np.matmul(pointcloud_gt_s, transform_xyz) # _point_cloud_transformed = sess.run(point_cloud_transformed, feed_dict=feed_dict) img_filename = '%d_coarse.png' % ( i) # , datetime.now().strftime('%Y-%m-%d %H:%M:%S')) img_filename = os.path.join(OUTPUT_FOLDER, img_filename) point_input = np.squeeze(pointclouds_pl) points_gt = np.squeeze(pointcloud_gt_s) points_rotated = np.squeeze(point_cloud_transformed) print(points_gt.shape, points_rotated.shape, point_cloud_transformed.shape) info = 'Nothing' pc_util.point_cloud_three_points(point_input, point_cloud_transformed, point_cloud_transformed, img_filename, info)
def eval_one_epoch(sess, ops, test_writer): is_training = False # Make sure batch data is of same size cur_batch_data = np.zeros( (BATCH_SIZE, NUM_POINT, TEST_DATASET.num_channel())) cur_batch_angle = np.zeros((BATCH_SIZE, 4)) cur_batch_label = np.zeros((BATCH_SIZE)) loss_sum = 0 batch_idx = 0 while TEST_DATASET.has_next_batch(): batch_data, batch_angel, batch_data_label = TEST_DATASET.next_batch( augment=True, sess=sess) bsize = batch_data.shape[0] print('Batch: %03d, batch size: %d' % (batch_idx, bsize)) # for the last batch in the epoch, the bsize:end are from last batch cur_batch_label[0:bsize] = batch_data_label # for the last batch in the epoch, the bsize:end are from last batch cur_batch_data[0:bsize, ...] = batch_data cur_batch_angle[0:bsize, ...] = batch_angel[:, :4] feed_dict = { ops['pointclouds_pl']: cur_batch_data, ops['pointclouds_gt']: pointcloud_gt_val, ops['pointclouds_gt_big']: pointcloud_gt_big_val, ops['pointclouds_angle']: cur_batch_angle, ops['is_training_pl']: is_training, } # loss_val, pred_angle = sess.run([ops['loss'], ops['pred_angle']], feed_dict=feed_dict) summary, step, loss_val, pred_angle, cd_dists, knn_dists = sess.run( [ ops['merged'], ops['step'], ops['loss'], ops['pred_angle'], ops['cd_dists'], ops['knn_dists'] ], feed_dict=feed_dict) test_writer.add_summary(summary, step) loss_sum += loss_val batch_idx += 1 transform_xyz_input = Tools3D.batch_quaternion2mat(cur_batch_angle) transform_xyz = Tools3D.batch_quaternion2mat(pred_angle) point_cloud_transformed = np.matmul(pointcloud_gt_val, transform_xyz) point_cloud_gt_transformed = np.matmul(pointcloud_gt_val, transform_xyz_input) # _point_cloud_transformed = sess.run(point_cloud_transformed, feed_dict=feed_dict) for i in range(bsize): index = cur_batch_label[i] img_filename = '%d.png' % ( index) # , datetime.now().strftime('%Y-%m-%d %H:%M:%S')) img_filename = os.path.join(DUMP_DIR, img_filename) points_gt = np.squeeze(point_cloud_gt_transformed[i, :, :]) points_rotated = np.squeeze(cur_batch_data[i, :, :]) points_align = np.squeeze(point_cloud_transformed[i, :, :]) # print(points_rotated.shape) # print(point_cloud_transformed.shape) # print(points_align.shape) info_input = pc_util.log_visu_vec('Input Data %d' % (index), cur_batch_angle[i, :]) pre_angle = pc_util.log_visu_vec('Pred Data', pred_angle[i, :]) matrix_input = pc_util.log_visu_matrix( 'Input Matrix', np.squeeze(transform_xyz_input[i, :, :])) matrix_pred = pc_util.log_visu_matrix( 'Pred Matrix', np.squeeze((transform_xyz[i, :, :]))) # print(point_cloud_transformed[i,:,:].shape) cd_loss = cd_dists[i] knn_loss = knn_dists[i] matloss = np.sum( np.square(transform_xyz_input[i, :, :] - transform_xyz[i, :, :])) / 2 vecloss = np.sum( np.square(pred_angle[i, :] - cur_batch_angle[i, :])) / 2 loss_cd = pc_util.log_visu_loss('CD Loss', cd_loss) loss_knn = pc_util.log_visu_loss('KNN Loss', knn_loss) loss_mat = pc_util.log_visu_loss('MAT Loss', matloss) vec_mat = pc_util.log_visu_loss('VEC Loss', vecloss) info = info_input + pre_angle + matrix_input + matrix_pred + vec_mat + loss_mat + loss_cd + loss_knn pc_util.point_cloud_three_points(points_rotated, points_gt, points_align, img_filename, info) # scipy.misc.imsave(img_filename, output_img) log_string('eval mean loss: %f' % (loss_sum / float(batch_idx))) TEST_DATASET.reset()
def eval_one_frame(self, points, isSampled=False, isNormalized=False, isSaving=False): is_training = False PC_PATH = os.path.join( POINTCLOUD_DIR, 'Dataset/%s/partialface/real_scan/' % (self.model_name)) OUTPUT_FOLDER = os.path.join(PC_PATH, 'pred') #PointCloudOperator.get_pairwise_distance(points) if isSampled: if self.predict_trans is not None: point_temp = np.dot(points.copy(), np.eye(3)) #self.predict_trans.T) else: point_temp = np.dot(points.copy(), np.eye(3)) point_temp_max = np.max(point_temp, axis=0) point_temp_min = np.min(point_temp, axis=0) #print('point_temp_max:',point_temp_max) _clip_ = np.where((point_temp[:, 1] < point_temp_max[1] * 0.9)) points = points[_clip_] # interv = int(points.shape[0]/1024) # print(points.shape[0],interv) # idx = np.arange(points.shape[0]) # # idx_n = [i for i in idx if i % interv == 0] # # idx_n = np.arange(points.shape[0]) # np.random.shuffle(idx_n) # # if points.shape[0]<POINT_NUM: # offset = POINT_NUM - points.shape[0] # idx_n = np.concatenate([np.arange(points.shape[0]), np.random.randint(0, points.shape[0], size=offset)], axis=0) # np.random.shuffle(idx_n) # # #idx_n = np.random.randint(0,points.shape[0],size=POINT_NUM) # # # idx_n = idx_n[:POINT_NUM] # # np.random.shuffle(idx_n) #points = points[idx_n,...] if isNormalized: centroid = np.mean(points, axis=0, keepdims=True) print('------------centroid:', centroid) furthest_distance = np.amax(np.sqrt( np.sum((points - centroid)**2, axis=-1)), keepdims=True) points = (points - centroid) / furthest_distance distance = np.sqrt(np.sum(points**2, axis=-1)) med_distance = np.median(distance) max_distance = np.max(distance) scale = max_distance / med_distance * 0.8 print('med_distance:', med_distance, '--max_distance:', max_distance) _clip_ = np.where(distance < scale * med_distance) points = points[_clip_] centroid = np.mean(points, axis=0, keepdims=True) print('------------centroid:', centroid) furthest_distance = np.amax(np.sqrt( np.sum((points - centroid)**2, axis=-1)), keepdims=True) * 0.89 points = (points - centroid) / furthest_distance pointclouds_pl = np.expand_dims(points, axis=0) # pointclouds_pl[:,:,1:3] = -pointclouds_pl[:,:,1:3] #pointclouds_pl[:,:,2] = -pointclouds_pl[:,:,2] pointcloud_gt_big = np.expand_dims(self.pointcloud_gt_big, axis=0) pointcloud_gt_small = np.expand_dims(self.pointcloud_gt_small, axis=0) feed_dict = { self.ops['pointclouds_pl']: pointclouds_pl, self.ops['pointclouds_pl_big']: pointcloud_gt_big, self.ops['pointclouds_gt_small']: pointcloud_gt_small, self.ops['is_training_pl']: is_training, } # loss_val, pred_angle = sess.run([ops['loss'], ops['pred_angle']], feed_dict=feed_dict) pred_angle = self.sess.run([self.ops['pred_angle']], feed_dict=feed_dict) pred_angle = np.squeeze(pred_angle) pred_angle = pred_angle[:4] print(pred_angle) transform_xyz = Tools3D.quaternion_To_rotation_matrix(pred_angle) transform_xyz = np.array(transform_xyz) if isSaving and (time() - self.startime > 2.5): self.startime = time() point_cloud_transformed = np.matmul(self.pointcloud_gt, transform_xyz) point_input = np.squeeze(pointclouds_pl) points_gt = np.squeeze(self.pointcloud_gt) points_aligned = np.squeeze(point_cloud_transformed) info = 'Nothing' filename = datetime.now().strftime('%Y_%m_%d_%H_%M_%S') pc_filename = os.path.join(OUTPUT_FOLDER, '%s.xyz' % (filename)) np.savetxt(pc_filename, points, fmt='%0.6f') img_filename = os.path.join(OUTPUT_FOLDER, '%s.png' % (filename)) #img_filename = os.path.join(OUTPUT_FOLDER, '1.png') pc_util.point_cloud_three_points(point_input, points_aligned, points_aligned, img_filename, info) # if self.predict_trans is not None: # transform_xyz = 0.2*transform_xyz + 0.8*self.predict_trans self.predict_trans = transform_xyz return transform_xyz, points