import numpy as np from scipy import signal import huggingface_hub # for loading model import streamlit as st 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) 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) 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) 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) """ # 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) 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) """ # 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) return A ######################################################################################################################## # 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 ######################################################################################################################## # 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 [3, 5, 10, 20]] # Select the Options shape_1 = st.selectbox("Please select a shape", shape_options) # Load the models from existing huggingface model # Load the encoder model encoder_model_boxes = huggingface_hub.from_pretrained_keras("cmudrc/2d-lattice-encoder") # Load the decoder model decoder_model_boxes = huggingface_hub.from_pretrained_keras("cmudrc/2d-lattice-decoder")