Should be fully functional :D

app.py

@@ -244,6 +244,13 @@ def combine_arrays(arrays):
     return output_array
 
 
+########################################################################################################################
+# Explain the App
+st.header("Multi-Lattice Generator Through a VAE Model")
+st.write("Shape: the type of shape the lattice will have")
+st.write("Density: the pixel intensity of each activated pixel")
+st.write("Thickness: the additional pixels added to the base shape")
+st.write("Interpolation Length: the number of internal interpolation points that will exist in the interpolation")
 ########################################################################################################################
 # Provide the Options for users to select from
 shape_options = ("basic_box", "diagonal_box_split", "horizontal_vertical_box_split", "back_slash_box", "forward_slash_box",
@@ -254,20 +261,21 @@ thickness_options = [str(int(x)) for x in np.linspace(0, 10, 11)]
 interpolation_options = [str(int(x)) for x in [3, 5, 10, 20]]
 
 # Provide User Options
+st.header("Option 1: Perform a Linear Interpolation")
 # Select Shapes
 shape_1 = st.selectbox("Shape 1", shape_options)
 shape_2 = st.selectbox("Shape 2", shape_options)
 
 # Select Density
-density_1 = st.selectbox("Density 1:", density_options)
-density_2 = st.selectbox("Density 2:", density_options)
+density_1 = st.selectbox("Density 1:", density_options, index=len(density_options)-1)
+density_2 = st.selectbox("Density 2:", density_options, index=len(density_options)-1)
 
 # Select Thickness
 thickness_1 = st.selectbox("Thickness 1", thickness_options)
 thickness_2 = st.selectbox("Thickness 2", thickness_options)
 
 # Select Interpolation Length
-interp_length = st.selectbox("Interpolation Length", interpolation_options)
+interp_length = st.selectbox("Interpolation Length", interpolation_options, index=2)
 
 
 # Define the function to generate unit cells based on user inputs
@@ -318,47 +326,68 @@ for column in range(latent_dimensionality):
 latent_matrix = np.array(latent_matrix).T  # Transposes the matrix so that each row can be easily indexed
 ########################################################################################################################
 # Plotting the Interpolation in 2D Using Chosen Points
-if st.button("Generate Interpolation"):
-    plt.figure(2)
+if st.button("Generate Linear Interpolation"):
+    # plt.figure(2)
 
     linear_interp_latent = np.linspace(latent_point_1, latent_point_2, num_interp)
     print(len(linear_interp_latent))
 
     linear_predicted_interps = []
-    figure = np.zeros((28 * num_interp, 28))
+    figure_2 = np.zeros((28, 28 * num_interp))
     for i in range(num_interp):
         generated_image = decoder_model_boxes.predict(np.array([linear_interp_latent[i]]))[0]
-        figure[i * 28:(i + 1) * 28, 0:28, ] = generated_image[:, :, -1]
+        figure_2[0:28, i * 28:(i + 1) * 28, ] = generated_image[:, :, -1]
         linear_predicted_interps.append(generated_image[:, :, -1])
 
-    plt.figure(figsize=(15, 15))
+    # plt.figure_2(figsize=(15, 15))
     # plt.imshow(figure, cmap='gray')
-    plt.figure(2)
-    st.pyplot(plt.figure(2))
+    # plt.figure(2)
+    # st.pyplot(figure_2)
+    st.image(figure_2)
+########################################################################################################################
+# Provide User Options
+st.header("Option 2: Perform a Mesh Interpolation")
+st.write("The four corners of this mesh are defined using the shapes in both Option 1 and Option 2")
+# Select Shapes
+shape_3 = st.selectbox("Shape 3", shape_options)
+shape_4 = st.selectbox("Shape 4", shape_options)
 
-    """
-    plot_rows = 2
-    plot_columns = num_interp + 2
-
-    # Plot the First Interpolation Point
-    plt.subplot(plot_rows, plot_columns, 1), plt.imshow(number_1, cmap='gray', vmin=0, vmax=1)
-    # plt.title("First Interpolation Point:\n" + str(box_shape_test[number_1]) + "\nPixel Density: " + str(
-    #             box_density_test[number_1]) + "\nAdditional Pixels: " + str(additional_pixels_test[number_1]))
-
-    predicted_interps = []  # Used to store the predicted interpolations
-    # Interpolate the Images and Print out to User
-    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(np.array([latent_matrix[latent_point - 2]]))[0]  # generates an interpolated image based on the latent point
-        predicted_interps.append(generated_image[:, :, -1])
-        plt.subplot(plot_rows, plot_columns, latent_point), plt.imshow(generated_image[:, :, -1], cmap='gray', vmin=0, vmax=1)
-        # plt.axis('off')
-
-    # Plot the Second Interpolation Point
-    plt.subplot(plot_rows, plot_columns, num_interp + 2), plt.imshow(number_2, cmap='gray', vmin=0, vmax=1)
-    # plt.title("Second Interpolation Point:\n" + str(box_shape_test[number_2]) + "\nPixel Density: " + str(
-    #             box_density_test[number_2]) + "\nAdditional Pixels: " + str(additional_pixels_test[number_2]))  # + "\nPredicted Latent Point 2: " + str(latent_point_2)
-    """
-    '''
+# Select Density
+density_3 = st.selectbox("Density 3:", density_options, index=len(density_options)-1)
+density_4 = st.selectbox("Density 4:", density_options, index=len(density_options)-1)
+
+# Select Thickness
+thickness_3 = st.selectbox("Thickness 3", thickness_options)
+thickness_4 = st.selectbox("Thickness 4", thickness_options)
+
+# Generate the endpoints
+number_3 = generate_unit_cell(shape_3, density_3, thickness_3)
+number_4 = generate_unit_cell(shape_4, density_4, thickness_4)
+
+# Display the endpoints to the user
+if st.button("Generate Endpoint Images for Mesh"):
+    plt.figure(1)
+    st.header("Endpoints to be generated:")
+    plt.subplot(2, 2, 1), plt.imshow(number_1, cmap='gray', vmin=0, vmax=1)
+    plt.subplot(2, 2, 2), plt.imshow(number_2, cmap='gray', vmin=0, vmax=1)
+    plt.subplot(2, 2, 3), plt.imshow(number_3, cmap='gray', vmin=0, vmax=1)
+    plt.subplot(2, 2, 4), plt.imshow(number_4, cmap='gray', vmin=0, vmax=1)
+    plt.figure(1)
+    st.pyplot(plt.figure(1))
+########################################################################################################################
+# Encode the Desired Endpoints
+# resize the array to match the prediction size requirement
+number_3_expand = np.expand_dims(np.expand_dims(number_3, axis=2), axis=0)
+number_4_expand = np.expand_dims(np.expand_dims(number_4, axis=2), axis=0)
+
+# Determine the latent point that will represent our desired number
+latent_point_3 = encoder_model_boxes.predict(number_3_expand)[0]
+latent_point_4 = encoder_model_boxes.predict(number_4_expand)[0]
+
+latent_dimensionality = len(latent_point_1)  # define the dimensionality of the latent space
+########################################################################################################################
+# Plot a Mesh Gridded Interpolation
+if st.button("Generate Mesh Interpolation"):
     latent_matrix_2 = []  # This will contain the latent points of the interpolation
     for column in range(latent_dimensionality):
         new_column = np.linspace(latent_point_3[column], latent_point_4[column], num_interp)
@@ -373,15 +402,13 @@ if st.button("Generate Interpolation"):
     mesh = np.transpose(mesh, axes=(1, 0, 2))  # Transpose the array so it matches the original interpolation
     generator_model = decoder_model_boxes
 
-    figure = np.zeros((28 * num_interp, 28 * num_interp))
+    figure_3 = np.zeros((28 * num_interp, 28 * num_interp))
 
     mesh_predicted_interps = []
     for i in range(num_interp):
         for j in range(num_interp):
             generated_image = generator_model.predict(np.array([mesh[i][j]]))[0]
-            figure[i * 28:(i + 1) * 28, j * 28:(j + 1) * 28, ] = generated_image[:, :, -1]
+            figure_3[i * 28:(i + 1) * 28, j * 28:(j + 1) * 28, ] = generated_image[:, :, -1]
             mesh_predicted_interps.append(generated_image[:, :, -1])
 
-    plt.figure(figsize=(15, 15))
-    plt.imshow(figure, cmap='gray')
-    '''
+    st.image(figure_3)