def test_render_offset_vertical_rectangle_rectangular_image(self): line_parameters = tf.constant([0.0, 80.0, 49.0, 16.0, 48.0], dtype=tf.float32) image = line_util.line_to_image(line_parameters, height=130, width=120, falloff=None) target_image_name = 'Offset_Vertical_Rectangle_1.png' baseline_image_path = os.path.join(self.test_data_directory, target_image_name) with self.test_session() as sess: image = image_util.get_pil_formatted_image(sess.run(image)) image_util.expect_image_file_and_image_are_near( self, baseline_image_path, image, target_image_name, '%s does not match.' % target_image_name)
def test_render_rotated_rectangle(self): line_parameters = tf.constant([3.14159 / 4.0, 64.0, 64.0, 16.0, 48.0], dtype=tf.float32) image = line_util.line_to_image(line_parameters, height=128, width=128, falloff=None) target_image_name = 'Rotated_Rectangle_0.png' baseline_image_path = os.path.join(self.test_data_directory, target_image_name) with self.test_session() as sess: image = image_util.get_pil_formatted_image(sess.run(image)) image_util.expect_image_file_and_image_are_near( self, baseline_image_path, image, target_image_name, '%s does not match.' % target_image_name)
def test_render_centered_square_with_blur(self): line_parameters = tf.constant([0.0, 64.0, 64.0, 16.0, 16.0], dtype=tf.float32) image = line_util.line_to_image(line_parameters, height=128, width=128, falloff=10.0) target_image_name = 'Centered_Square_Blur_0.png' baseline_image_path = os.path.join(self.test_data_directory, target_image_name) with self.test_session() as sess: image = image_util.get_pil_formatted_image(sess.run(image)) image_util.expect_image_file_and_image_are_near( self, baseline_image_path, image, target_image_name, '%s does not match.' % target_image_name)
def eval_step(session, global_step, desired_num_examples, eval_tag, eval_checkpoint): """Runs a single eval step. Runs over the full desired eval set, regardless of batch size. Args: session: A tf.Session instance. global_step: The global step tensor. desired_num_examples: The number of examples from the eval dataset to evaluate. eval_tag: A tag to specify the eval type. Defaults to 'eval'. eval_checkpoint: The path of the checkpoint being evaluated. Returns: A list of tf.Summary objects computed during the eval. """ step_start_time = time.time() del eval_tag, desired_num_examples global_step_int = int(global_step) # num_batches = max(1, desired_num_examples // model_config.hparams.bs) big_render_images = [] all_centers_np = [] all_radii_np = [] all_constants_np = [] all_quadrics_np = [] all_iparams_np = [] all_mesh_names_np = [] all_depth_images_np = [] tf.logging.info('The eval checkpoint str is %s', eval_checkpoint) eval_dir = '/'.join(eval_checkpoint.split('/')[:-1]) hparam_path = eval_dir + '/hparam_pickle.txt' if not file_util.exists(hparam_path): hparams.write_hparams(model_config.hparams, hparam_path) output_dir = (eval_dir + '/eval-step-' + str(global_step_int) + '/') def to_uint8(np_im): return (np.clip(255.0 * np_im, 0, 255.0)).astype(np.uint8) ran_count = 0 max_run_count = 500 ious = np.zeros(max_run_count, dtype=np.float32) # Run until the end of the dataset: for vi in range(max_run_count): tf.logging.info( 'Starting eval item %i, total elapsed time is %0.2f...', vi, time.time() - step_start_time) try: vis_start_time = time.time() if vi < vis_count: misc_tensors_to_eval = [ model_config.summary_op, optimization_target, sample_locations, in_out_image_big, training_example.mesh_name, example_iou, ] np_out = session.run( misc_tensors_to_eval + prediction.structured_implicit.tensor_list) (summaries, optimization_target_np, samples_np, in_out_image_big_np, mesh_names_np, example_iou_np) = np_out[:len(misc_tensors_to_eval)] in_out_image_big_np = np.reshape(in_out_image_big_np, [256, 256, 1]) in_out_image_big_np = image_util.get_pil_formatted_image( in_out_image_big_np) tf.logging.info('in_out_image_big_np shape: %s', str(in_out_image_big_np.shape)) in_out_image_big_np = np.reshape(in_out_image_big_np, [1, 256, 256, 4]) implicit_np_list = np_out[len(misc_tensors_to_eval):] tf.logging.info('\tElapsed after first sess run: %0.2f', time.time() - vis_start_time) else: np_out = session.run( [training_example.mesh_name, example_iou] + prediction.structured_implicit.tensor_list) mesh_names_np = np_out[0] example_iou_np = np_out[1] implicit_np_list = np_out[2:] # TODO(kgenova) It would be nice to move all this functionality into # a numpy StructuredImplicitNp class, and hide these internals. ious[ran_count] = example_iou_np ran_count += 1 constants_np, centers_np, radii_np = implicit_np_list[:3] if len(implicit_np_list) == 4: iparams_np = implicit_np_list[3] else: iparams_np = None # For now, just map to quadrics and move on: quadrics_np = np.zeros( [constants_np.shape[0], constants_np.shape[1], 4, 4]) quadrics_np[0, :, 3, 3] = np.reshape(constants_np[0, :], [ model_config.hparams.sc, ]) all_centers_np.append(np.copy(centers_np)) all_radii_np.append(np.copy(radii_np)) all_constants_np.append(np.copy(constants_np)) all_quadrics_np.append(np.copy(quadrics_np)) all_mesh_names_np.append(mesh_names_np) if iparams_np is not None: all_iparams_np.append(iparams_np) # For most of the dataset, just do inference to get the representation. # Everything afterwards is just for tensorboard. if vi >= vis_count: continue visualize_with_marching_cubes = False if visualize_with_marching_cubes: # TODO(kgenova) This code is quite wrong now. If we want to enable it # it should be rewritten to call a structured_implicit_function to # handle evaluation (for instance the lset subtraction is bad). marching_cubes_ims_np, output_volumes = np_util.visualize_prediction( quadrics_np, centers_np, radii_np, renormalize=model_config.hparams.pou == 't', thresh=model_config.hparams.lset) tf.logging.info( '\tElapsed after first visualize_prediction: %0.2f', time.time() - vis_start_time) offset_marching_cubes_ims_np, _ = np_util.visualize_prediction( quadrics_np, centers_np, radii_np, renormalize=model_config.hparams.pou == 't', thresh=0.1, input_volumes=output_volumes) tf.logging.info( '\tElapsed after second visualize_prediction: %0.2f', time.time() - vis_start_time) tf.logging.info('About to concatenate shapes: %s, %s, %s', str(in_out_image_big_np.shape), str(marching_cubes_ims_np.shape), str(offset_marching_cubes_ims_np.shape)) in_out_image_big_np = np.concatenate([ in_out_image_big_np, marching_cubes_ims_np, offset_marching_cubes_ims_np ], axis=2) if do_iterative_update: # This code will fail (it's left unasserted to give a helpful tf error # message). The tensor it creates will now be the wrong size. render_summary, iterated_render_np = refine.refine( structured_implicit_ph, optimization_target_ph, samples_ph, original_vis_ph, gradients, implicit_np_list, optimization_target_np, samples_np, in_out_image_big_np, session, render_summary_op, iterated_render_tf) render_summary = [render_summary] in_out_with_iterated = np.concatenate( [in_out_image_big_np, iterated_render_np], axis=2) big_render_images.append(to_uint8(in_out_with_iterated)) else: big_render_images.append(to_uint8(in_out_image_big_np)) # TODO(kgenova) Is this really the depth image? depth_image_np = in_out_image_big_np[:, :, :256, :] all_depth_images_np.append(depth_image_np) render_summary = [] except tf.errors.OutOfRangeError: break tf.logging.info('Elapsed after vis loop: %0.2f', time.time() - step_start_time) ious = ious[:ran_count] mean_iou_summary, iou_hist_summary = session.run( [mean_iou_summary_op, iou_hist_summary_op], feed_dict={iou_ph: ious}) all_centers_np = np.concatenate(all_centers_np) all_radii_np = np.concatenate(all_radii_np) all_constants_np = np.concatenate(all_constants_np) all_quadrics_np = np.concatenate(all_quadrics_np) all_mesh_names_np = np.concatenate(all_mesh_names_np) all_depth_images_np = np.concatenate(all_depth_images_np) if all_iparams_np: all_iparams_np = np.concatenate(all_iparams_np) file_util.mkdir(output_dir, exist_ok=True) file_util.write_np( '%s/%s-constants.npy' % (output_dir, training_example.split), all_constants_np) file_util.write_np( '%s/%s-quadrics.npy' % (output_dir, training_example.split), all_quadrics_np) file_util.write_np( '%s/%s-centers.npy' % (output_dir, training_example.split), all_centers_np) file_util.write_np( '%s/%s-radii.npy' % (output_dir, training_example.split), all_radii_np) file_util.write_np( '%s/%s-mesh_names.npy' % (output_dir, training_example.split), all_mesh_names_np) # We do an explicit comparison because the type of all_iparams_np might # not be a list at this point: # pylint: disable=g-explicit-bool-comparison if all_iparams_np != []: file_util.write_np( '%s/%s-iparams.npy' % (output_dir, training_example.split), all_iparams_np) # Now that the full set predictions have been saved to disk, scrap # everything after the first vis_count: all_centers_np = all_centers_np[:vis_count, ...] all_radii_np = all_radii_np[:vis_count, ...] all_constants_np = all_constants_np[:vis_count, ...] all_mesh_names_np = all_mesh_names_np[:vis_count, ...] tf.logging.info('Elapsed after .npy save: %0.2f', time.time() - step_start_time) rbf_renders_at_half = np_util.plot_rbfs_at_thresh(all_centers_np, all_radii_np, thresh=0.5) rbf_renders_at_half_summary = session.run( rbf_render_at_half_summary_op, feed_dict={rbf_render_at_half_ph: rbf_renders_at_half}) tf.logging.info('Elapsed after rbf_at_half summary: %0.2f', time.time() - step_start_time) tf.logging.info('All depth images shape: %s', str(all_depth_images_np.shape)) depth_gt_out_summary = session.run( depth_gt_out_summary_op, feed_dict={ depth_gt_out_ph: np.concatenate([all_depth_images_np, all_depth_images_np], axis=2) }) tf.logging.info('Elapsed after depth_gt_out summary: %0.2f', time.time() - step_start_time) big_render_summary = session.run(big_render_summary_op, feed_dict={ big_render_ph: np.concatenate(big_render_images, axis=0) }) tf.logging.info('Evaluated %d batches of size %d.', vis_count, model_config.hparams.bs) tf.logging.info('Elapsed at end of step: %0.2f', time.time() - step_start_time) return [ summaries, big_render_summary, rbf_renders_at_half_summary, depth_gt_out_summary, mean_iou_summary, iou_hist_summary ] + render_summary