Updating to get the model imports to work

app.py

@@ -7,78 +7,210 @@ from transformers import TFAutoModel
 # Needed for importing torch to use in the transformers model
 import torch
 import tensorflow
+import matplotlib.pyplot as plt
 # HELLO HUGGING FACE
 
 
-def basic_box_array(image_size: int, thickness: int) -> np.ndarray:
-    """
-    :param image_size: [int] - the size of the image that will be produced
-    :param thickness: [int] - the number of pixels to be activated surrounding the base shape
-    :return: [ndarray] - the output is a unit cell with outer pixels activated based on the desired thickness.
-    The activated pixels are 1 (white) and the deactivated pixels are 0 (black)
-    """
-    A = np.ones((int(image_size), int(image_size)))  # Initializes A matrix with 0 values
-    A[1:-1, 1:-1] = 0  # replaces all internal rows/columns with 0's
-    A = add_thickness(A, thickness)
+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: int, thickness: int) -> np.ndarray:
-    """
-    :param image_size: [int] - the size of the image that will be produced
-    :param thickness: [int] - the number of pixels to be activated surrounding the base shape
-    :return: [ndarray] - the output is a unit cell with pixels activated along the downward diagonal based
-    on the desired thickness. The activated pixels are 1 (white) and the deactivated pixels are 0 (black)
-    """
-    A = np.zeros((int(image_size), int(image_size)))  # Initializes A matrix with 0 values
-    np.fill_diagonal(A, 1)  # fills the diagonal with 1 values
-    A = add_thickness(A, thickness)
+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: int, thickness: int) -> np.ndarray:
-    """
-    :param image_size: [int] - the size of the image that will be produced
-    :param thickness: [int] - the number of pixels to be activated surrounding the base shape
-    :return: [ndarray] - the output is a unit cell with pixels activated along the upward diagonal based on the desired
-    thickness. The activated pixels are 1 (white) and the deactivated pixels are 0 (black)
-    """
-    A = np.zeros((int(image_size), int(image_size)))  # Initializes A matrix with 0 values
-    np.fill_diagonal(np.fliplr(A), 1)  # Flips the array to then fill the diagonal the opposite direction
-    A = add_thickness(A, thickness)
+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: int, thickness: int) -> np.ndarray:
-    """
-    :param image_size: [int] - the size of the image that will be produced
-    :param thickness: [int] - the number of pixels to be activated surrounding the base shape
-    :return: [ndarray] - the output is a unit cell with outer pixel activated from the vertical center based on the
-    desired thickness. The activated pixels are 1 (white) and the deactivated pixels are 0 (black)
-    """
+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
-    A[:, np.floor((image_size - 1) / 2).astype(int)] = 1  # accounts for even and odd values of image_size
-    A[:, np.ceil((image_size - 1) / 2).astype(int)] = 1
-    A = add_thickness(A, thickness)
+    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: int, thickness: int) -> np.ndarray:
-    """
-    :param image_size: [int] - the size of the image that will be produced
-    :param thickness: [int] - the number of pixels to be activated surrounding the base shape
-    :return: [ndarray] - the output is a unit cell with outer pixel activated from the horizontal center based on the
-    desired thickness. The activated pixels are 1 (white) and the deactivated pixels are 0 (black)
-    """
+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
-    A[np.floor((image_size - 1) / 2).astype(int), :] = 1  # accounts for even and odd values of image_size
-    A[np.ceil((image_size - 1) / 2).astype(int), :] = 1
-    A = add_thickness(A, thickness)
+    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
+
+
 ########################################################################################################################
 # The function to add thickness to struts in an array
 def add_thickness(array_original, thickness: int) -> np.ndarray:
@@ -135,6 +267,18 @@ thickness_2 = st.selectbox("Thickness 2", thickness_options)
 interp_length = st.selectbox("Interpolation Length", interpolation_options)
 
 
+def generate_unit_cell(shape, density, thickness):
+    return globals()[shape](int(thickness), float(density), 28)
+
+if st.button("Generate Endpoint Images"):
+    plt.figure(1)
+    st.header("Endpoints to be generated:")
+    plt.subplot(1, 2, 1), plt.imshow(generate_unit_cell(shape_1, density_1, thickness_1), cmap='gray', vmin=0, vmax=1)
+    plt.subplot(1, 2, 2), plt.imshow(generate_unit_cell(shape_2, density_2, thickness_2), cmap='gray', vmin=0, vmax=1)
+    plt.figure(1)
+    st.pyplot(plt.figure(1))
+
+'''
 # Load the models from existing huggingface model
 # Load the encoder model
 # encoder_model_boxes = huggingface_hub.from_pretrained_keras("cmudrc/2d-lattice-encoder")
@@ -142,5 +286,5 @@ encoder_model = TFAutoModel.from_pretrained("cmudrc/2d-lattice-encoder")
 # Load the decoder model
 # decoder_model_boxes = huggingface_hub.from_pretrained_keras("cmudrc/2d-lattice-decoder")
 decoder_model = TFAutoModel.from_pretrained("cmudrc/2d-lattice-decoder")
-
+'''
 

requirements.txt

@@ -1,4 +1,5 @@
 huggingface_hub==0.12.0
+matplotlib==3.5.2
 numpy==1.21.5
 scipy==1.9.1
 streamlit==1.18.1