app.py

import numpy as np
from scipy import signal
import math
import matplotlib.pyplot as plt
from huggingface_hub import from_pretrained_keras
import streamlit as st
from elasticity import elasticity
import io
from voxel_to_SDF_to_STL import voxel_to_sdf, sdf_to_stl, single_body_check
from PIL import Image
import time

# Needed in requirements.txt for importing to use in the transformers model
import tensorflow


# HELLO HUGGING FACE

########################################################################################################################
# Define the piecewise functions to create each of the possible shapes
def basic_box_array(image_size):
    A = np.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 = np.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 = np.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 = np.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 = np.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 = np.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 = np.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


########################################################################################################################
# Create the desired shape using the density and thickness
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


########################################################################################################################
# The function to add thickness to struts in an array
def add_thickness(array_original, thickness: int) -> np.ndarray:
    """
    :param array_original: [ndarray] - an array with thickness 1 of any shape type
    :param thickness: [int] - the number of pixels to be activated surrounding the base shape
    :return: [ndarray] - the output is a unit cell that has been convolved to expand the number of pixels activated
    based on the desired thickness. The activated pixels are 1 (white) and the deactivated pixels are 0 (black)
    """
    A = array_original
    if thickness == 0:  # want an array of all 0's for thickness = 0
        A[A > 0] = 0
    else:
        filter_size = 2*thickness - 1 # the size of the filter needs to extend far enough to reach the base shape
        filter = np.zeros((filter_size, filter_size))
        filter[np.floor((filter_size - 1) / 2).astype(int), :] = filter[:, np.floor((filter_size - 1) / 2).astype(int)] =1
        filter[np.ceil((filter_size - 1) / 2).astype(int), :] = filter[:, np.ceil((filter_size - 1) / 2).astype(int)] = 1
        # The filter is made into a '+' shape using these functions
        convolution = signal.convolve2d(A, filter, mode='same')
        A = np.where(convolution <= 1, convolution, 1)
    return A


# The function to efficiently combine arrays in a list
def combine_arrays(arrays):
    output_array = np.sum(arrays, axis=0)  # Add the list of arrays
    output_array = np.array(output_array > 0, dtype=int)  # Convert all values in array to 1
    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",
"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 np.linspace(0.1, 1, 10)]
thickness_options = [str(int(x)) for x in np.linspace(0, 10, 11)]
interpolation_options = [str(int(x)) for x in np.linspace(2, 20, 19)]

# 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, 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, index=2)


# Define the function to generate unit cells based on user inputs
def generate_unit_cell(shape, density, thickness):
    return globals()[shape](int(thickness), float(density), 28)


def display_arrays(array1, array2, label_1, label_2):
    # A Function to plot two arrays side by side in streamlit
    # Create two columns
    col1, col2 = st.columns(2)

    # Populate the first column with array1
    col1.header(label_1)
    col1.write(array1)

    # Populate the second column with array2
    col2.header(label_2)
    col2.write(array2)


# Generate the endpoints
number_1 = generate_unit_cell(shape_1, density_1, thickness_1)
number_2 = generate_unit_cell(shape_2, density_2, thickness_2)

# Calculate the elasticity for the shapes:
elasticity_1 = elasticity(number_1)
elasticity_2 = elasticity(number_2)

# Display the endpoints to the user
if st.button("Generate Endpoint Images and Elasticity Tensors"):
    plt.figure(1)
    st.header("Endpoints to be generated:")
    plt.subplot(1, 2, 1), plt.imshow(number_1, cmap='gray', vmin=0, vmax=1), plt.title("Shape 1:")
    display_arrays(elasticity_1, elasticity_2, "Elasticity Tensor of Shape 1", "Elasticity Tensor of Shape 2")
    plt.subplot(1, 2, 2), plt.imshow(number_2, cmap='gray', vmin=0, vmax=1), plt.title("Shape 2:")
    plt.figure(1)
    st.pyplot(plt.figure(1))
########################################################################################################################
# Load the models from existing huggingface model
# Load the encoder model
encoder_model_boxes = from_pretrained_keras("cmudrc/2d-lattice-encoder")

# Load the decoder model
decoder_model_boxes = from_pretrained_keras("cmudrc/2d-lattice-decoder")


########################################################################################################################
# Encode the Desired Endpoints
# resize the array to match the prediction size requirement
number_1_expand = np.expand_dims(np.expand_dims(number_1, axis=2), axis=0)
number_2_expand = np.expand_dims(np.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
########################################################################################################################
# Establish the Framework for a LINEAR Interpolation
num_interp = int(interp_length)   # 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 = np.linspace(latent_point_1[column], latent_point_2[column], num_interp)
    latent_matrix.append(new_column)
latent_matrix = np.array(latent_matrix).T  # Transposes the matrix so that each row can be easily indexed


########################################################################################################################
# Create a gif from an interpolation
def interpolate_gif(decoder, latent_endpoint_1, latent_endpoint_2, n=100):
    # z = np.stack([latent_endpoint_1 + (latent_endpoint_2 - latent_endpoint_1) * t for t in np.linspace(0, 1, n)])

    # interpolate_list = decoder.predict(z)
    # interpolate_list = (interpolate_list * 255).astype(np.uint8)

    # images_list = [Image.fromarray(img.reshape(28, 28)).resize((256, 256)) for img in interpolate_list]
    # images_list = images_list + images_list[::-1]  # loop back beginning
    predicted_interps = []
    interp_latent = np.linspace(latent_endpoint_1, latent_endpoint_2, n)

    figure = np.zeros((28, 28 * n))
    for i in range(n):
        generated_image = decoder.predict(np.array([interp_latent[i]]))[0]
        figure[0:28, i * 28:(i + 1) * 28, ] = generated_image[:, :, -1]
        predicted_interps.append(generated_image[:, :, -1])


    # Regular Save for GIF
    # images_list[0].save(f'{filename}.gif',save_all=True,append_images=images_list[1:],loop=1)

    images_list = [Image.fromarray(img.reshape(28, 28)).resize((256, 256)) for img in predicted_interps]
    images_list = images_list + images_list[::-1]  # loop back beginning

    # Create a BytesIO object to hold the GIF data
    gif_bytes = io.BytesIO()
    images_list[0].save(
        gif_bytes,
        format='GIF',
        save_all=True,
        append_images=images_list[1:],
        loop=0, duration=100)  # Set loop to 0 for infinite looping

    # Reset the BytesIO object to the beginning
    gif_bytes.seek(0)

    st.video(gif_bytes)
    # return gif_bytes


########################################################################################################################
# Create an STL file from an interpolation
def convert_to_2_5d_sdf(interpolation, voxel_threshold, pixel_thickness):
    # Thresholding determines the distance from the SDF that is used, the threshold provided is a divisor

    # 1. Convert the interpolation into a 3D structure
    interpolation_3d = [interpolation] * pixel_thickness

    # 2. Convert the voxels into an SDF
    sdf = voxel_to_sdf(interpolation_3d, voxel_threshold)
    return sdf

def convert_sdf_to_stl(sdf, threshold_divisor):
    # 3. Check if the SDF is a single body, then convert into an STL
    if single_body_check(sdf, threshold_divisor):
        # Thresholding determines the distance from the SDF that is used, the thresdhold provided is a divisor
        stl = sdf_to_stl(sdf, threshold_divisor)
        return stl


########################################################################################################################
# Plotting the Interpolation in 2D Using Chosen Points
if st.checkbox("Generate Linear Interpolation"):
    # Generate the set of latent points in the interpolation
    linear_interp_latent = np.linspace(latent_point_1, latent_point_2, num_interp)
    linear_predicted_interps = []
    figure_2 = np.zeros((28, 28 * num_interp))

    # Predict the image for each latent point
    for i in range(num_interp):
        generated_image = decoder_model_boxes.predict(np.array([linear_interp_latent[i]]))[0]
        figure_2[0:28, i * 28:(i + 1) * 28, ] = generated_image[:, :, -1]
        linear_predicted_interps.append(generated_image[:, :, -1])

    st.image(figure_2, width=600)

    # Code to display a gif
    # interpolate_gif(decoder_model_boxes, latent_point_1, latent_point_2)

    # Code for generating the STL file
    st.subheader("Create an STL file from the extruded image!")

    if st.checkbox("Select to begin model generation"):
        # Creating an STL file of the linear interpolation

        pixel_thickness_input = st.number_input("(1) Select a pixel thickness for the 3D model: ", min_value=1, value=28)
        # Set the image threshold for binarization
        voxel_threshold_input = st.slider("(2) Select a value to threshold the image (Recommend <= 0.1) "
                                          "Higher values will result in less defined shapes: ",
                                          min_value=0.0001, max_value=0.999, value=0.1, key='voxel_threshold')

        # Create the SDF File
        linear_sdf = convert_to_2_5d_sdf(figure_2, voxel_threshold_input, pixel_thickness_input)

        # Set the threshold for the Mesh
        threshold_divisor_input = st.slider("(3) Choose a threshold divisor for the SDF: ", min_value=0.0,
                                            max_value=5.0,
                                            value=3.0, key="divisor_threshold")

        linear_sdf_min = np.min(linear_sdf)
        linear_sdf_max = np.max(linear_sdf)
        st.info("Lower SDF Thresholds will result in smoother, but less accurate shapes. Higher thresholds will result in more "
                "rugged shapes, but they are more accurate. Suggested value for threshold is less than: " +
                str((linear_sdf_max - abs(linear_sdf_min)) / 2))

        if st.button("Generate STL Model"):
            # Generate the STL File
            linear_stl = convert_sdf_to_stl(linear_sdf, threshold_divisor=threshold_divisor_input)

            # Download the STL File
            with open(linear_stl, 'rb') as file:
                st.download_button(
                    label='Download STL',
                    data=file,
                    file_name='linear_interpolation.stl',
                    key='stl-download'
                    )

########################################################################################################################
# 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)

# 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 and Elasticity Tensors"):
    plt.figure(1)
    st.header("Endpoints to be generated:")
    elasticity_3 = elasticity(number_3)
    elasticity_4 = elasticity(number_4)
    display_arrays(elasticity_1, elasticity_2, "Elasticity Tensor of Shape 1", "Elasticity Tensor of Shape 2")
    display_arrays(elasticity_3, elasticity_4, "Elasticity Tensor of Shape 3", "Elasticity Tensor of Shape 4")
    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.checkbox("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)
        latent_matrix_2.append(new_column)
    latent_matrix_2 = np.array(latent_matrix_2).T  # Transposes the matrix so that each row can be easily indexed

    mesh = []  # This will create a mesh by interpolating between the two interpolations
    for column in range(num_interp):
        row = np.linspace(latent_matrix[column], latent_matrix_2[column], num_interp)
        mesh.append(row)

    mesh = np.transpose(mesh, axes=(1, 0, 2))  # Transpose the array so it matches the original interpolation
    generator_model = decoder_model_boxes

    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_3[i * 28:(i + 1) * 28, j * 28:(j + 1) * 28, ] = generated_image[:, :, -1]
            mesh_predicted_interps.append(generated_image[:, :, -1])

    st.image(figure_3, width=600)

    # Code for generating the STL file
    st.subheader("Create an STL file from the extruded image!")

    if st.checkbox("Select to begin model generation"):
        # Creating an STL file of the linear interpolation

        mesh_pixel_thickness_input = st.number_input("(1) Select a pixel thickness for the 3D model: ", min_value=1,
                                                value=28)
        # Set the image threshold for binarization
        mesh_voxel_threshold_input = st.slider("(2) Select a value to threshold the image (Recommend <= 0.1) "
                                          "Higher values will result in less defined shapes: ",
                                          min_value=0.0001, max_value=0.999, value=0.1, key='voxel_threshold')

        # Create the SDF File
        mesh_sdf = convert_to_2_5d_sdf(figure_3, mesh_voxel_threshold_input, mesh_pixel_thickness_input)

        # Set the threshold for the Mesh
        mesh_threshold_divisor_input = st.slider("(3) Choose a threshold divisor for the SDF: ", min_value=0.0,
                                            max_value=5.0,
                                            value=3.0, key="divisor_threshold")

        mesh_sdf_min = np.min(mesh_sdf)
        mesh_sdf_max = np.max(mesh_sdf)
        st.info(
            "Lower SDF Thresholds will result in smoother, but less accurate shapes. Higher thresholds will result in more "
            "rugged shapes, but they are more accurate. Suggested value for threshold is less than: " +
            str((mesh_sdf_max - abs(mesh_sdf_min)) / 2))

        if st.button("Generate STL Model"):
            # Generate the STL File
            linear_stl = convert_sdf_to_stl(mesh_sdf, threshold_divisor=mesh_threshold_divisor_input)

            # Download the STL File
            with open(linear_stl, 'rb') as file:
                st.download_button(
                    label='Download STL',
                    data=file,
                    file_name='interpolation.stl',
                    key='stl-download'
                )