Added to incorporate a function to export the STL files directly from the user generated inputs

app.py

@@ -5,6 +5,9 @@ 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
 
 # Needed in requirements.txt for importing to use in the transformers model
 import tensorflow
@@ -344,19 +347,128 @@ 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.button("Generate Linear Interpolation"):
+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.checkbox("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")
@@ -404,7 +516,7 @@ 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"):
+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)
@@ -429,3 +541,44 @@ if st.button("Generate Mesh Interpolation"):
             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.checkbox("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'
+                )