Spaces:
Sleeping
Sleeping
| import random | |
| import gradio | |
| import numpy | |
| import tensorflow | |
| import math | |
| from tensorflow.python.framework.ops import disable_eager_execution | |
| import huggingface_hub # for loading model | |
| import matplotlib.pyplot | |
| # 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 = huggingface_hub.from_pretrained_keras("cmudrc/2d-lattice-decoder") | |
| # 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') | |
| encoder_model_boxes = huggingface_hub.from_pretrained_keras("cmudrc/2d-lattice-encoder") | |
| 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 numpy.round(transition_region) | |
| 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") | |
| 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") | |
| steps = gradio.Dropdown(interpolation_options, label="Interpolation Length", value=random.choice(interpolation_options)) | |
| img = gradio.Image(label="Transition") | |
| 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]) | |
| lattice_interpolation_inetrface = gradio.Interface( | |
| fn = interpolate, inputs=[t1, t2, d1, d2, th1, th2, steps], outputs=[img] | |
| ) | |
| # Loadin the model | |
| model1 = huggingface_hub.from_pretrained_keras("cmudrc/microstructure-colorization") | |
| # Get the color map by name: | |
| cm = matplotlib.pyplot.get_cmap('RdBu') | |
| #simple image scaling to (nR x nC) size | |
| def scale(im, nR, nC): | |
| nR0 = len(im) # source number of rows | |
| nC0 = len(im[0]) # source number of columns | |
| return numpy.array([[ im[int(nR0 * r / nR)][int(nC0 * c / nC)] | |
| for c in range(nC)] for r in range(nR)]) | |
| # Prediction function | |
| def predict(mask): | |
| print(mask) | |
| scaled_mask = numpy.ones((101, 636)) if mask is None else numpy.round(scale(mask, 101, 636)/255.0) | |
| print(scaled_mask) | |
| X = scaled_mask[numpy.newaxis, :, :, numpy.newaxis] | |
| print(X.shape) | |
| v = model1.predict(X) | |
| print(v) | |
| measure = max(v.max(), -v.min()) | |
| output = (v / measure) | |
| legend = "<h2>Strain</h2><table style=\"width:100%\"><tr>" | |
| for i in range(11): | |
| color = cm(i/10.0)[:3] | |
| value = -measure + i*2*measure/10 | |
| print(sum(list(color))) | |
| hex = matplotlib.colors.to_hex(list(color)) | |
| text_color = "black" if sum(list(color)) > 2.0 else "white" | |
| legend = legend + f"<td style=\"background-color: {hex}; color: {text_color}\">{value:+.2e}</td>" | |
| legend = legend + "</tr></table>" | |
| return cm((numpy.multiply(output[0, :, :, 0], scaled_mask)+1.0)/2.0), cm((numpy.multiply(output[0, :, :, 1], scaled_mask)+1.0)/2.0), cm((numpy.multiply(output[0, :, :, 2], scaled_mask)+1.0)/2.0), legend | |
| mask = gradio.Image(image_mode="L", source="canvas", label="microstructure") | |
| exx = gradio.Image(label="ε-xx") | |
| eyy = gradio.Image(label="ε-yy") | |
| exy = gradio.Image(label="ε-xy") | |
| legend = gradio.HTML(label="", value="") | |
| microstructure_interface = gradio.Interface( | |
| fn=predict, | |
| inputs=[mask], | |
| outputs=[exx, eyy, exy, legend] | |
| ) | |
| gradio.Series( | |
| lattice_interpolation_inetrface, | |
| microstructure_interface | |
| ).launch(debug=True) |