def main():
plt.close("all")
tf.enable_eager_execution()
codes = [
"S1_I1", "S1_I2", "S1_I3", "S2_I1", "S2_I2", "S2_I3", "S3_I1", "S3_I2",
"S3_I3", "S4_I1", "S4_I2", "S4_I3"
]
# code = "S1_I1"
for code in codes:
data_folder = "Data_synthesized/"
envDir = data_folder + "EnvMap/"
envName = envDir + code + "_Illum"
if (predict_sphere_envMap[1]):
envFile = envName + "_probe.hdr"
else:
envFile = envName + ".hdr"
albedo_folder = data_folder + "Albedo/"
normal_folder = data_folder + "AppearanceNormal/"
albedo_file = albedo_folder + code + ".png"
normal_file = normal_folder + code + "_Normal_UV.png"
albedoMap = load_rgba(
albedo_file) # "Data02_isomaps/AppearanceMap_test.png")
normalMap = load_rgb(
normal_file) # "Data02_isomaps/NormalMap_test.png")
data_input_folder_name = "Data_to_synthesize"
input_shape = (256, 256, 3)
num_replicate = 1
(dataset_train_input,
num_train_input) = load_input_data_with_normals_and_replicate(
data_input_folder_name, input_shape, True, num_replicate)
envMap = load_rgb(envFile, -1)
print("Before resize : max: {:.3f}, mean: ({:.3f})".format(
np.amax(envMap), np.mean(envMap)))
(mEnv, nEnv, dEnv) = envMap.shape
print((mEnv, nEnv))
plt.imshow(envMap)
plt.show()
albedoMap = cv2.resize(albedoMap, (256, 256))
normalMap = cv2.resize(normalMap, (256, 256))
envMap = cv2.resize(envMap, (64, 32), interpolation=cv2.INTER_LINEAR)
print("After resize : max: {:.3f}, mean: ({:.3f})".format(
np.amax(envMap), np.mean(envMap)))
(mIm, nIm, dIm) = albedoMap.shape
(mEnv, nEnv, dEnv) = envMap.shape
input_shape = albedoMap.shape
d = 3
plt.imshow(envMap)
plt.show()
plt.imshow(albedoMap)
plt.show()
plt.imshow(normalMap)
plt.show()
# cv2.namedWindow('albedo', cv2.WINDOW_NORMAL)
# cv2.imshow('albedo', albedoMap)
# cv2.namedWindow('normal', cv2.WINDOW_NORMAL)
# cv2.imshow('normal', normalMap)
# cv2.namedWindow('envMap', cv2.WINDOW_NORMAL)
# cv2.imshow('envMap', envMap)
# cv2.waitKey(0)
gamma = tf.constant(2.2)
invGamma = tf.constant(1. / 2.2)
normalizingValue = tf.constant(255.)
albedoTensor = tf.constant(albedoMap[:, :, :3], dtype=tf.float32)
normalTensor = tf.constant(normalMap[:, :, :3], dtype=tf.float32)
envMapTensor = tf.constant(envMap, dtype=tf.float32)
albedoTensor = tf.scalar_mul(1. / normalizingValue,
albedoTensor[:, :, :3])
normalTensor = tf.scalar_mul(1. / normalizingValue,
normalTensor[:, :, :3])
# albedoTensor = tf.pow(albedoTensor,gamma)
if (predict_sphere_envMap[1]):
envNormalization = tf.constant(math.pi * mEnv * nEnv / 4.)
else:
envNormalization = tf.constant((float)(mEnv * nEnv))
## Calculate envMap orientations
envVectors = envMapOrientation.envMapOrientation(
mEnv, nEnv, predict_sphere_envMap[1])
envOrientationTensor = tf.constant(envVectors, dtype=tf.float32)
envOrientationTensor = tf.reshape(envOrientationTensor,
[3, mEnv * nEnv])
envMapTensor = tf.reshape(envMapTensor, [mEnv * nEnv, 3])
autoencoder_model = FirstGenerator(input_shape, envOrientationTensor,
envMapTensor, envNormalization,
predict_sphere_envMap,
high_res_mode)
normalTensor = tf.reshape(normalTensor, [1, mIm, nIm, d])
albedoTensor = tf.reshape(albedoTensor, [1, mIm, nIm, d])
# resTensor = autoencoder_model.render(normalTensor,albedoTensor)
resTensor = autoencoder_model.render_with_predicted_envMap(
normalTensor, albedoTensor,
tf.reshape(envMapTensor, [num_replicate, mEnv * nEnv, 3]))
resTensorGamma = tf.pow(resTensor, invGamma)
res_save = 255. * np.array(resTensorGamma[0])
res_save = convert_rgb_to_cv2(res_save)
res_save_temp = np.zeros([res_save.shape[0], res_save.shape[1], 4])
res_save_temp[:, :, :3] = res_save[:, :, :]
res_save_temp[:, :, 3] = albedoMap[:, :, 3]
res_save = res_save_temp.astype(int)
plt.imshow(resTensor[0])
plt.show()
plt.imshow(resTensorGamma[0])
plt.show()
cv2.imwrite(normal_folder + code + "_Appearance_UV.png", res_save)
# x_train_input = dataset_train_input.batch(num_replicate)
# for (batch, (inputs, labels_appearance, labels_normals, masks)) \
# in enumerate(x_train_input):
# resTensor = autoencoder_model.render_with_predicted_envMap(labels_normals, inputs,
# tf.reshape(envMapsTensors,
# [num_replicate, mEnv * nEnv, 3]))
# resTensorGamma = tf.pow(resTensor, invGamma)
# res_save = 255. * np.array(resTensorGamma[0])
# res_save = convert_rgb_to_cv2(res_save)
# res_save_temp = np.zeros([res_save.shape[0], res_save.shape[1], 4])
# res_save_temp[:, :, :3] = res_save[:, :, :]
# res_save_temp[:, :, 3] = albedoMap[:, :, 3]
# res_save = res_save_temp.astype(int)
#
# plt.imshow(envMapsTensors[0])
# plt.show()
# plt.imshow(resTensorGamma[0])
# plt.show()
# plt.imshow(envMapsTensors[1])
# plt.show()
# plt.imshow(resTensorGamma[1])
# plt.show()
#
# return
return
from load_rgb_cv import load_rgb, convert_rgb_to_cv2
import cv2
import matplotlib.pyplot as plt
image_file = "Chicago_albedo.png"
output_file = "Chicago_albedo_test.png"
image1 = load_rgb(image_file)
plt.imshow(image1)
plt.show()
print("image1 : {}".format(image1[150, 150, 1]))
cv2.imwrite(output_file, convert_rgb_to_cv2(image1))
image2 = load_rgb(output_file)
plt.imshow(image2)
plt.show()
print("image2 : {}".format(image2[150, 150, 1]))
autoencoder_model = FirstGenerator(input_shape, envOrientationTensor,
envMapTensor, envNormalization,
predict_sphere_envMap, high_res_mode)
normalTensor = tf.reshape(normalTensor, [1, mIm, nIm, d])
albedoTensor = tf.reshape(albedoTensor, [1, mIm, nIm, d])
# resTensor = autoencoder_model.render(normalTensor,albedoTensor)
resTensor = autoencoder_model.render_with_predicted_envMap(
normalTensor, albedoTensor,
tf.reshape(envMapTensor, [num_replicate, mEnv * nEnv, 3]))
resTensorGamma = tf.pow(resTensor, invGamma)
res_save = 255. * np.array(resTensorGamma[0])
res_save = convert_rgb_to_cv2(res_save)
res_save_temp = np.zeros([res_save.shape[0], res_save.shape[1], 4])
res_save_temp[:, :, :3] = res_save[:, :, :]
res_save_temp[:, :, 3] = albedoMap[:, :, 3]
res_save = res_save_temp.astype(int)
plt.imshow(resTensor[0])
plt.show()
plt.imshow(resTensorGamma[0])
plt.show()
#cv2.imwrite(output_data_folder+ code_write + "_Appearance_UV.png", res_save)
resTensorBoosted = autoencoder_model.render_with_predicted_envMap(
normalTensor, albedo_boosted_Tensor,
tf.reshape(envMapTensor, [num_replicate, mEnv * nEnv, 3]))
def main():
plt.close("all")
tf.enable_eager_execution()
folder_write_name = "Data_synthesized/"
extension_nor_app = "AppearanceNormal/"
extension_env = "EnvMap/"
code_sample = "S4_I3_"
envDir = "EnvMaps/"
envName = envDir + "STUDIOATM_13SN"
if (predict_sphere_envMap[1]):
envFile = envName + "_probe.hdr"
else:
#envFile = folder_write_name + extension_env + code_sample + "Illum.hdr"
envFile = envName + ".hdr"
albedoMap = load_rgb(
"Chicago_albedo.png") #"Data02_isomaps/AppearanceMap_test.png")
normalMap = load_rgb(
"Chicago_normal.png") #"Data02_isomaps/NormalMap_test.png")
envMap = load_rgb(envFile, -1)
print("Before resize : max: {:.3f}, mean: ({:.3f})".format(
np.amax(envMap), np.mean(envMap)))
shutil.copy(
"Chicago_normal.png",
folder_write_name + extension_nor_app + code_sample + "Normal_UV.png")
shutil.copy(envFile,
folder_write_name + extension_env + code_sample + "Illum.hdr")
(mEnv, nEnv, dEnv) = envMap.shape
print((mEnv, nEnv))
plt.imshow(envMap)
plt.show()
albedoMap = cv2.resize(albedoMap, (256, 256))
normalMap = cv2.resize(normalMap, (256, 256))
envMap = cv2.resize(envMap, (3 * 32, 3 * 16),
interpolation=cv2.INTER_LINEAR)
print("After resize : max: {:.3f}, mean: ({:.3f})".format(
np.amax(envMap), np.mean(envMap)))
(mIm, nIm, dIm) = albedoMap.shape
(mEnv, nEnv, dEnv) = envMap.shape
input_shape = albedoMap.shape
d = 3
plt.imshow(envMap)
plt.show()
plt.imshow(albedoMap)
plt.show()
plt.imshow(normalMap)
plt.show()
# cv2.namedWindow('albedo', cv2.WINDOW_NORMAL)
# cv2.imshow('albedo', albedoMap)
# cv2.namedWindow('normal', cv2.WINDOW_NORMAL)
# cv2.imshow('normal', normalMap)
# cv2.namedWindow('envMap', cv2.WINDOW_NORMAL)
# cv2.imshow('envMap', envMap)
# cv2.waitKey(0)
gamma = tf.constant(2.2)
invGamma = tf.constant(1. / 2.2)
normalizingValue = tf.constant(255.)
albedoTensor = tf.constant(albedoMap[:, :, :3], dtype=tf.float32)
normalTensor = tf.constant(normalMap[:, :, :3], dtype=tf.float32)
envMapTensor = tf.constant(envMap, dtype=tf.float32)
albedoTensor = tf.scalar_mul(1. / normalizingValue, albedoTensor[:, :, :3])
normalTensor = tf.scalar_mul(1. / normalizingValue, normalTensor[:, :, :3])
#albedoTensor = tf.pow(albedoTensor,gamma)
if (predict_sphere_envMap[1]):
envNormalization = tf.constant(math.pi * mEnv * nEnv / 4.)
else:
envNormalization = tf.constant((float)(mEnv * nEnv))
## Calculate envMap orientations
envVectors = envMapOrientation.envMapOrientation(mEnv, nEnv,
predict_sphere_envMap[1])
envOrientationTensor = tf.constant(envVectors, dtype=tf.float32)
envOrientationTensor = tf.reshape(envOrientationTensor, [3, mEnv * nEnv])
envMapTensor = tf.reshape(envMapTensor, [mEnv * nEnv, 3])
autoencoder_model = FirstGenerator(input_shape, envOrientationTensor,
envMapTensor, envNormalization,
predict_sphere_envMap, high_res_mode)
normalTensor = tf.reshape(normalTensor, [1, mIm, nIm, d])
albedoTensor = tf.reshape(albedoTensor, [1, mIm, nIm, d])
resTensor = autoencoder_model.render(normalTensor, albedoTensor)
resTensorGamma = tf.pow(resTensor, invGamma)
res_save = 255. * np.array(resTensorGamma[0])
res_save = convert_rgb_to_cv2(res_save)
res_save = res_save.astype(int)
plt.imshow(resTensor[0])
plt.show()
plt.imshow(resTensorGamma[0])
plt.show()
#cv2.imwrite(folder_name+ "envMap_resized.hdr" , envMap)
cv2.imwrite(
folder_write_name + extension_nor_app + code_sample +
"Appearance_UV.png", res_save)
#cv2.imwrite(folder_name+ "normalMap_resized.png" , normalMap)
return
def render_face(envName, input_code, output_code, log_and_show, write_results,
albedo_mode):
if (predict_sphere_envMap[1]):
envFile = envDir + envName + "_probe.hdr"
else:
envFile = envDir + envName + ".hdr"
albedo_file = input_data_folder + input_code + "_Appearance_UV.png"
normal_file = input_data_folder + input_code + "_Normal_UV.png"
# LOAD
albedoMap = load_rgba(
albedo_file) # "Data02_isomaps/AppearanceMap_test.png")
normalMap = load_rgb(normal_file) # "Data02_isomaps/NormalMap_test.png")
envMap = load_rgb(envFile, -1)
if (write_results):
shutil.copy(envFile, output_data_folder + output_code + "_Illum.hdr")
(mEnv_input, nEnv_input, dEnv) = envMap.shape
if (log_and_show):
print("Before resize : max: {:.3f}, mean: ({:.3f})".format(
np.amax(envMap), np.mean(envMap)))
print("Input envmap size : ({:},{:})".format(mEnv_input, nEnv_input))
plt.imshow(envMap)
plt.show()
#RESIZE
albedoMap = cv2.resize(albedoMap, (nIm, mIm))
normalMap = cv2.resize(normalMap, (nIm, mIm))
envMap = cv2.resize(envMap, (nEnv, mEnv), interpolation=cv2.INTER_LINEAR)
if (log_and_show):
print("After resize : max: {:.3f}, mean: ({:.3f})".format(
np.amax(envMap), np.mean(envMap)))
d = 3
albedoTensor = tf.constant(albedoMap[:, :, :3], dtype=tf.float32)
normalTensor = tf.constant(normalMap[:, :, :3], dtype=tf.float32)
envMapTensor = tf.constant(envMap, dtype=tf.float32)
albedoTensor = tf.scalar_mul(1. / normalizingValue, albedoTensor[:, :, :3])
normalTensor = tf.scalar_mul(1. / normalizingValue, normalTensor[:, :, :3])
# Boost albedo
albedo_boosted_Tensor = tf.scalar_mul(tf.constant(albedo_boosting_factor),
tf.pow(albedoTensor, gamma))
if (log_and_show):
plt.imshow(envMapTensor)
plt.show()
plt.imshow(albedoTensor)
plt.show()
plt.imshow(tf.pow(albedo_boosted_Tensor, invGamma))
plt.show()
# plt.imshow(normalTensor)
# plt.show()
envMapTensor = tf.reshape(envMapTensor, [mEnv * nEnv, 3])
normalTensor = tf.reshape(normalTensor, [1, mIm, nIm, d])
albedoTensor = tf.reshape(albedoTensor, [1, mIm, nIm, d])
autoencoder_model = FirstGenerator(input_shape, envOrientationTensor,
envMapTensor, envNormalization,
predict_sphere_envMap, high_res_mode)
# resTensor = autoencoder_model.render(normalTensor,albedoTensor)
if albedo_mode == 0:
albedo_render = albedoTensor
albedo_save = albedoMap
else:
albedo_render = albedo_boosted_Tensor
albedo_save = 255. * np.array(tf.pow(albedo_boosted_Tensor, invGamma))
resTensor = autoencoder_model.render_with_predicted_envMap(
normalTensor, albedo_render,
tf.reshape(envMapTensor, [1, mEnv * nEnv, 3]))
resTensorGamma = tf.pow(resTensor, invGamma)
res_save = 255. * np.array(resTensorGamma[0])
res_save = convert_rgb_to_cv2(res_save)
res_save_temp = np.zeros([res_save.shape[0], res_save.shape[1], 4])
res_save_temp[:, :, :3] = res_save[:, :, :]
res_save_temp[:, :, 3] = albedoMap[:, :, 3]
res_save = res_save_temp.astype(int)
albedo_save = convert_rgb_to_cv2(albedo_save)
albedo_save = albedo_save.astype(int)
if (log_and_show):
# plt.imshow(resTensor[0])
# plt.show()
plt.imshow(resTensorGamma[0])
plt.show()
if (write_results):
cv2.imwrite(output_data_folder + output_code + "_Appearance_UV.png",
res_save)
cv2.imwrite(output_data_folder + output_code + "_Albedo_UV.png",
albedo_save)
cv2.imwrite(output_data_folder + output_code + "_Normal_UV.png",
normalMap)
return