import random import gradio import numpy import tensorflow import math from tensorflow.python.framework.ops import disable_eager_execution # Because important disable_eager_execution() def basic_box_array(image_size): A = numpy.zeros((int(image_size), int(image_size))) # Initializes A matrix with 0 values # Creates the outside edges of the box for i in range(image_size): for j in range(image_size): if i == 0 or j == 0 or i == image_size - 1 or j == image_size - 1: A[i][j] = 1 return A def back_slash_array(image_size): A = numpy.zeros((int(image_size), int(image_size))) # Initializes A matrix with 0 values for i in range(image_size): for j in range(image_size): if i == j: A[i][j] = 1 return A def forward_slash_array(image_size): A = numpy.zeros((int(image_size), int(image_size))) # Initializes A matrix with 0 values for i in range(image_size): for j in range(image_size): if i == (image_size - 1) - j: A[i][j] = 1 return A def hot_dog_array(image_size): # Places pixels down the vertical axis to split the box A = numpy.zeros((int(image_size), int(image_size))) # Initializes A matrix with 0 values for i in range(image_size): for j in range(image_size): if j == math.floor((image_size - 1) / 2) or j == math.ceil((image_size - 1) / 2): A[i][j] = 1 return A def hamburger_array(image_size): # Places pixels across the horizontal axis to split the box A = numpy.zeros((int(image_size), int(image_size))) # Initializes A matrix with 0 values for i in range(image_size): for j in range(image_size): if i == math.floor((image_size - 1) / 2) or i == math.ceil((image_size - 1) / 2): A[i][j] = 1 return A def center_array(image_size): A = numpy.zeros((int(image_size), int(image_size))) # Initializes A matrix with 0 values for i in range(image_size): for j in range(image_size): if i == math.floor((image_size - 1) / 2) and j == math.ceil((image_size - 1) / 2): A[i][j] = 1 if i == math.floor((image_size - 1) / 2) and j == math.floor((image_size - 1) / 2): A[i][j] = 1 if j == math.ceil((image_size - 1) / 2) and i == math.ceil((image_size - 1) / 2): A[i][j] = 1 if j == math.floor((image_size - 1) / 2) and i == math.ceil((image_size - 1) / 2): A[i][j] = 1 return A def update_array(array_original, array_new, image_size): A = array_original for i in range(image_size): for j in range(image_size): if array_new[i][j] == 1: A[i][j] = 1 return A def add_pixels(array_original, additional_pixels, image_size): # Adds pixels to the thickness of each component of the box A = array_original A_updated = numpy.zeros((int(image_size), int(image_size))) # Initializes A matrix with 0 values for dens in range(additional_pixels): for i in range(1, image_size - 1): for j in range(1, image_size - 1): if A[i - 1][j] + A[i + 1][j] + A[i][j - 1] + A[i][j + 1] > 0: A_updated[i][j] = 1 A = update_array(A, A_updated, image_size) return A def basic_box(additional_pixels, density, image_size): A = basic_box_array(image_size) # Creates the outside edges of the box # Increase the thickness of each part of the box A = add_pixels(A, additional_pixels, image_size) return A * density def horizontal_vertical_box_split(additional_pixels, density, image_size): A = basic_box_array(image_size) # Creates the outside edges of the box # Place pixels across the horizontal and vertical axes to split the box A = update_array(A, hot_dog_array(image_size), image_size) A = update_array(A, hamburger_array(image_size), image_size) # Increase the thickness of each part of the box A = add_pixels(A, additional_pixels, image_size) return A * density def diagonal_box_split(additional_pixels, density, image_size): A = basic_box_array(image_size) # Creates the outside edges of the box # Add pixels along the diagonals of the box A = update_array(A, back_slash_array(image_size), image_size) A = update_array(A, forward_slash_array(image_size), image_size) # Adds pixels to the thickness of each component of the box # Increase the thickness of each part of the box A = add_pixels(A, additional_pixels, image_size) return A * density def back_slash_box(additional_pixels, density, image_size): A = basic_box_array(image_size) # Initializes A matrix with 0 values A = update_array(A, back_slash_array(image_size), image_size) A = add_pixels(A, additional_pixels, image_size) return A * density def forward_slash_box(additional_pixels, density, image_size): A = basic_box_array(image_size) # Initializes A matrix with 0 values A = update_array(A, forward_slash_array(image_size), image_size) A = add_pixels(A, additional_pixels, image_size) return A * density def hot_dog_box(additional_pixels, density, image_size): A = basic_box_array(image_size) # Initializes A matrix with 0 values A = update_array(A, hot_dog_array(image_size), image_size) A = add_pixels(A, additional_pixels, image_size) return A * density def hamburger_box(additional_pixels, density, image_size): A = basic_box_array(image_size) # Initializes A matrix with 0 values A = update_array(A, hamburger_array(image_size), image_size) A = add_pixels(A, additional_pixels, image_size) return A * density def x_plus_box(additional_pixels, density, image_size): A = basic_box_array(image_size) # Initializes A matrix with 0 values A = update_array(A, hot_dog_array(image_size), image_size) A = update_array(A, hamburger_array(image_size), image_size) A = update_array(A, forward_slash_array(image_size), image_size) A = update_array(A, back_slash_array(image_size), image_size) A = add_pixels(A, additional_pixels, image_size) return A * density def forward_slash_plus_box(additional_pixels, density, image_size): A = basic_box_array(image_size) # Initializes A matrix with 0 values A = update_array(A, hot_dog_array(image_size), image_size) A = update_array(A, hamburger_array(image_size), image_size) A = update_array(A, forward_slash_array(image_size), image_size) # A = update_array(A, back_slash_array(image_size), image_size) A = add_pixels(A, additional_pixels, image_size) return A * density def back_slash_plus_box(additional_pixels, density, image_size): A = basic_box_array(image_size) # Initializes A matrix with 0 values A = update_array(A, hot_dog_array(image_size), image_size) A = update_array(A, hamburger_array(image_size), image_size) # A = update_array(A, forward_slash_array(image_size), image_size) A = update_array(A, back_slash_array(image_size), image_size) A = add_pixels(A, additional_pixels, image_size) return A * density def x_hot_dog_box(additional_pixels, density, image_size): A = basic_box_array(image_size) # Initializes A matrix with 0 values A = update_array(A, hot_dog_array(image_size), image_size) # A = update_array(A, hamburger_array(image_size), image_size) A = update_array(A, forward_slash_array(image_size), image_size) A = update_array(A, back_slash_array(image_size), image_size) A = add_pixels(A, additional_pixels, image_size) return A * density def x_hamburger_box(additional_pixels, density, image_size): A = basic_box_array(image_size) # Initializes A matrix with 0 values # A = update_array(A, hot_dog_array(image_size), image_size) A = update_array(A, hamburger_array(image_size), image_size) A = update_array(A, forward_slash_array(image_size), image_size) A = update_array(A, back_slash_array(image_size), image_size) A = add_pixels(A, additional_pixels, image_size) return A * density def center_box(additional_pixels, density, image_size): A = basic_box_array(image_size) # Initializes A matrix with 0 values A = update_array(A, center_array(image_size), image_size) A = add_pixels(A, additional_pixels, image_size) return A * density # import tensorflow as tf # # sess = tf.compat.v1.Session() # # from keras import backend as K # # K.set_session(sess) endpoint_options = ( "basic_box", "diagonal_box_split", "horizontal_vertical_box_split", "back_slash_box", "forward_slash_box", "back_slash_plus_box", "forward_slash_plus_box", "hot_dog_box", "hamburger_box", "x_hamburger_box", "x_hot_dog_box", "x_plus_box") density_options = ["{:.2f}".format(x) for x in numpy.linspace(0.1, 1, 10)] thickness_options = [str(int(x)) for x in numpy.linspace(0, 10, 11)] interpolation_options = [str(int(x)) for x in [3, 5, 10, 20]] def generate_unit_cell(t, d, th): return globals()[t](int(th), float(d), 28) def interpolate(t1, t2, d1, d2, th1, th2, steps): # Load the decoder model decoder_model_boxes = tensorflow.keras.models.load_model('data/decoder_model_boxes', compile=False) # # import the encoder model architecture json_file_loaded = open('data/model.json', 'r') loaded_model_json = json_file_loaded.read() # load model using the saved json file encoder_model_boxes = tensorflow.keras.models.model_from_json(loaded_model_json) # load weights into newly loaded_model encoder_model_boxes.load_weights('data/model_tf') num_internal = int(steps) number_1 = generate_unit_cell(t1, d1, th1) number_2 = generate_unit_cell(t2, d2, th2) # resize the array to match the prediction size requirement number_1_expand = numpy.expand_dims(numpy.expand_dims(number_1, axis=2), axis=0) number_2_expand = numpy.expand_dims(numpy.expand_dims(number_2, axis=2), axis=0) # Determine the latent point that will represent our desired number latent_point_1 = encoder_model_boxes.predict(number_1_expand)[0] latent_point_2 = encoder_model_boxes.predict(number_2_expand)[0] latent_dimensionality = len(latent_point_1) # define the dimensionality of the latent space num_interp = num_internal # the number of images to be pictured latent_matrix = [] # This will contain the latent points of the interpolation for column in range(latent_dimensionality): new_column = numpy.linspace(latent_point_1[column], latent_point_2[column], num_interp) latent_matrix.append(new_column) latent_matrix = numpy.array(latent_matrix).T # Transposes the matrix so that each row can be easily indexed # plot_rows = 2 # plot_columns = num_interp + 2 predicted_interps = [number_1_expand[0, :, :, 0]] for latent_point in range(2, num_interp + 2): # cycles the latent points through the decoder model to create images generated_image = decoder_model_boxes.predict(numpy.array([latent_matrix[latent_point - 2]]))[ 0] # generates an interpolated image based on the latent point predicted_interps.append(generated_image[:, :, -1]) predicted_interps.append(number_2_expand[0, :, :, 0]) transition_region = predicted_interps[0] for i in range(len(predicted_interps) - 1): transition_region = numpy.hstack((transition_region, predicted_interps[i + 1])) return transition_region with gradio.Blocks() as demo: with gradio.Row(): with gradio.Column(min_width=250): t1 = gradio.Dropdown(endpoint_options, label="Type 1", value="hamburger_box") d1 = gradio.Dropdown(density_options, label="Density 1", value="1.00") th1 = gradio.Dropdown(thickness_options, label="Thickness 1", value="2") with gradio.Column(min_width=250): img1 = gradio.Image(label="Endpoint 1", value=generate_unit_cell("hamburger_box", "1.00", "2")) with gradio.Column(min_width=250): t2 = gradio.Dropdown(endpoint_options, label="Type 2", value="hot_dog_box") d2 = gradio.Dropdown(density_options, label="Density 2", value="1.00") th2 = gradio.Dropdown(thickness_options, label="Thickness 2", value="2") with gradio.Column(min_width=250): img2 = gradio.Image(label="Endpoint 2", value=generate_unit_cell("hot_dog_box", "1.00", "2")) lattice_inputs_1 = [t1, d1, th1] [x.change(fn=generate_unit_cell, inputs=lattice_inputs_1, outputs=[img1]) for x in lattice_inputs_1] lattice_inputs_2 = [t2, d2, th2] [x.change(fn=generate_unit_cell, inputs=lattice_inputs_2, outputs=[img2]) for x in lattice_inputs_2] steps = gradio.Dropdown(interpolation_options, label="Interpolation Length", value=random.choice(interpolation_options)) btn = gradio.Button("Run") img = gradio.Image(label="Transition") btn.click(fn=interpolate, inputs=[t1, t2, d1, d2, th1, th2, steps], outputs=[img]) examples = gradio.Examples(examples=[["hamburger_box", "hot_dog_box", "1.00", "1.00", "2", "2", "20"], ["hamburger_box", "hot_dog_box", "0.10", "1.00", "10", "10", "5"]], fn=interpolate, inputs=[t1, t2, d1, d2, th1, th2, steps], outputs=[img], cache_examples=True) demo.launch()