Spaces:
Sleeping
Sleeping
| 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") | |