Create app.py

app.py

@@ -0,0 +1,359 @@
+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)