def main(unused_argv): if not FLAGS.stack_folder: raise ValueError("stack_folder was not defined") (pano_stack, alignment_params) = stack_io.read_stack(FLAGS.stack_folder) unused_azimuth, lighting_context = stack_io.load_sample_illuminations() lighting_context_factors = tf.constant(lighting_context, dtype=tf.float32) # [0, 1]-ranged panoramas of shape [384, 960]. pano_stack = tf.constant(pano_stack, dtype=tf.float32) alignment_params = tf.constant(alignment_params, dtype=tf.float32) # Align images using parameters. alignment_module = image_alignment.ImageAlignment(regularization=0.3) aligned_stack = alignment_module.align_images(pano_stack, alignment_params) factorize_model = network.FactorizeEncoderDecoder( { "lighting_dim": 32, "permanent_dim": 16 }, is_training=False) stack_factors = factorize_model.compute_decomposition( aligned_stack, single_image_decomposition=False, average_stack=True) recon = network.recomposite_from_log_components( stack_factors["log_reflectance"], stack_factors["log_shading"]) rotate_shading_image = factorize_model.generate_sun_rotation( stack_factors["permanent_factor"][:1], lighting_context_factors[FLAGS.lighting_context_index:FLAGS. lighting_context_index + 1], FLAGS.azimuth_frame_rate) results = network.recomposite_from_log_components( stack_factors["log_reflectance"], rotate_shading_image) # Restore factorization network weights from ckpt. tf.train.init_from_checkpoint( "./factorize_a_city/ckpt/factorize_model.ckpt", {"decomp_internal/": "decomp_internal/"}) sess = tf.Session() sess.run(tf.global_variables_initializer()) saver = tf.train.Saver() out = sess.run(results) stack_io.write_stack_images(FLAGS.output_dir, out / 255.)
def main(unused_argv): if not FLAGS.stack_folder: raise ValueError("stack_folder was not defined") # Load example stacks. Each panorama has shape [384, 960, 3] and has values # between [0, 1]. (permanent_stack, alignment_params) = stack_io.read_stack(FLAGS.stack_folder) # Load example azimuth and illumination samples. azimuth, lighting_context = stack_io.load_sample_illuminations() permanent_stack = tf.constant(permanent_stack, dtype=tf.float32) azimuth_factors = tf.constant(azimuth, dtype=tf.float32) lighting_context_factors = tf.constant(lighting_context, dtype=tf.float32) # Align images using learnt parameters. alignment_module = image_alignment.ImageAlignment(regularization=0.3) aligned_stack = alignment_module.align_images(permanent_stack, alignment_params) factorize_model = network.FactorizeEncoderDecoder( { "lighting_dim": 32, "permanent_dim": 16 }, is_training=False) stack_factors = factorize_model.compute_decomposition(aligned_stack) permanent_factor = stack_factors["permanent_factor"] permanent_factor = tf.tile(permanent_factor[:1], [azimuth.shape[0], 1, 1, 1]) shading_image = factorize_model.generate_shading_image( permanent_factor, lighting_context_factors, azimuth_factors) relit_results = network.recomposite_from_log_components( stack_factors["log_reflectance"], shading_image) # Restore factorization network weights from ckpt. tf.train.init_from_checkpoint( "./factorize_a_city/ckpt/factorize_model.ckpt", {"decomp_internal/": "decomp_internal/"}) sess = tf.Session() sess.run(tf.global_variables_initializer()) out = sess.run(relit_results) stack_io.write_stack_images(FLAGS.output_dir, out / 255.)
def main(unused_argv): if not FLAGS.stack_folder: raise ValueError("stack_folder was not defined") (pano_stack, alignment_params) = stack_io.read_stack(FLAGS.stack_folder) # [0, 1]-ranged panoramas of shape [384, 960]. pano_stack = tf.constant(pano_stack, dtype=tf.float32) alignment_params = tf.constant(alignment_params, dtype=tf.float32) # Align images using parameters. alignment_module = image_alignment.ImageAlignment(regularization=0.3) aligned_stack = alignment_module.align_images(pano_stack, alignment_params) factorize_model = network.FactorizeEncoderDecoder( { "lighting_dim": 32, "permanent_dim": 16 }, is_training=False) stack_factors = factorize_model.compute_decomposition( aligned_stack, single_image_decomposition=False, average_stack=True) # Restore factorization network weights from ckpt. tf.train.init_from_checkpoint("./factorize_a_city/ckpt/factorize_model.ckpt", {"decomp_internal/": "decomp_internal/"}) sess = tf.Session() sess.run(tf.global_variables_initializer()) log_shading, log_reflectance = sess.run( [stack_factors["log_shading"], stack_factors["log_reflectance"]]) stack_io.write_stack_images( FLAGS.output_dir, utils.outlier_normalization(log_shading), prefix="log_shading") stack_io.write_stack_images( FLAGS.output_dir, utils.outlier_normalization(log_reflectance), prefix="log_reflectance")
def main(unused_argv): if not FLAGS.misaligned_stack_folder: raise ValueError("misaligned_stack_folder was not defined") alignment_save_location = os.path.join(FLAGS.misaligned_stack_folder, "alignment.npy") if not FLAGS.overwrite: if os.path.exists(alignment_save_location): raise ValueError("Existing alignment found. " "Pass --overwrite flag to overwrite it.") misaligned_stack = stack_io.read_stack(FLAGS.misaligned_stack_folder, require_alignment=False) # [0, 1]-ranged panoramas of shape [384, 960]. misaligned_stack = tf.constant(misaligned_stack, dtype=tf.float32) # Randomly initialized warp parameters. alignment_params = tf.get_variable( "alignment_params", [8, 8, 32, 2], trainable=True, initializer=tf.random_normal_initializer(0, 1e-3), ) tanh_alignment_params = tf.nn.tanh(alignment_params) # Align images using parameters. alignment_module = image_alignment.ImageAlignment(regularization=0.3) aligned_stack = alignment_module.align_images(misaligned_stack, tanh_alignment_params) # Freeze weight during the decomposition. factorize_model = network.FactorizeEncoderDecoder( { "lighting_dim": 32, "permanent_dim": 16 }, is_training=False) stack_factors = factorize_model.compute_decomposition( aligned_stack, single_image_decomposition=False, average_stack=True) individual_ref = stack_factors["individual_log_reflectance"] stack_size = individual_ref.shape.as_list()[0] ref_consistency_loss = tf.zeros([]) for i in range(stack_size): for j in range(i + 1, stack_size): ref_consistency_loss += tf.reduce_mean( tf.abs(individual_ref[i] - individual_ref[j])) warp_opt = tf.train.AdamOptimizer(1e-4, name="Adam", beta1=0., epsilon=1e-4) warp_train_step = warp_opt.minimize(ref_consistency_loss, var_list=[alignment_params]) # Restore factorization network weights from ckpt. tf.train.init_from_checkpoint( "./factorize_a_city/ckpt/factorize_model.ckpt", {"decomp_internal/": "decomp_internal/"}) sess = tf.Session() sess.run(tf.global_variables_initializer()) for i in range(FLAGS.num_alignment_steps): loss, _ = sess.run([ref_consistency_loss, warp_train_step]) if i % 10 == 0: print("[%d / %d] Steps, Loss: %5f" % (i, FLAGS.num_alignment_steps, loss)) print("[%d / %d] Steps, Loss: %5f" % (FLAGS.num_alignment_steps, FLAGS.num_alignment_steps, loss)) np_alignment_weights = sess.run(tanh_alignment_params) with open(alignment_save_location, "wb") as f: np_alignment_weights.dump(f)