Adding type hints to the functions in these scripts

Data_Generation/Dataset_Generation_Functions.py

@@ -1,11 +1,10 @@
 import numpy as np
-import pandas as pd
-import json
-# from Data_Generation.Shape_Generation_Functions import 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
 from Data_Generation.Piecewise_Box_Functions import basic_box_array, back_slash_array, forward_slash_array, hamburger_array, hot_dog_array
+
+# For Internal Testing
 # from Piecewise_Box_Functions import basic_box_array, back_slash_array, forward_slash_array, hamburger_array, hot_dog_array
+import pandas as pd
+import json
 import matplotlib.pyplot as plt
 from json import JSONEncoder
 
@@ -13,10 +12,10 @@ from json import JSONEncoder
 
 ########################################################################################################################
 # Make the data using all the code in Shape_Generation_Functions.py
-def make_boxes(image_size, densities):
+def make_boxes(image_size: int, densities: list[float]) -> list[tuple]:
     """
     :param image_size: [int] - the pixel height and width of the generated arrays
-    :param densities: [list] - of the values of each of the active pixels in each shape
+    :param densities: [list[float]] - of the desired pixel values to apply to active pixels - Recommend values (0,1]
     :return: [list[tuple]] - [Array, Density, Thickness of each strut type]
     """
 

Data_Generation/Piecewise_Box_Functions.py

@@ -2,28 +2,52 @@ import numpy as np
 from scipy import signal
 
 
-def basic_box_array(image_size, thickness):
+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, thickness):
+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, thickness):
+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, thickness):
+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
@@ -32,7 +56,13 @@ def hot_dog_array(image_size, thickness):
     return A
 
 
-def hamburger_array(image_size, thickness):
+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
@@ -43,7 +73,13 @@ def hamburger_array(image_size, thickness):
 
 ########################################################################################################################
 # The function to add thickness to struts in an array
-def add_thickness(array_original, thickness):
+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
@@ -52,13 +88,14 @@ def add_thickness(array_original, thickness):
         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):
+def combine_arrays(arrays: list[np.ndarray]) -> np.ndarray:
     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

Data_Plotting/Plot_TSNE.py

@@ -3,7 +3,7 @@ import matplotlib.pyplot as plt
 import numpy as np
 
 # Latent Feature Cluster for Training Data using T-SNE
-def TSNE_reduction(latent_points, perplexity=30, learning_rate=20):
+def TSNE_reduction(latent_points: list, perplexity=30, learning_rate=20):
     latent_dimensionality = len(latent_points[0])
     model = TSNE(n_components=2, random_state=0, perplexity=perplexity,
                  learning_rate=learning_rate)  # Perplexity(5-50) | learning_rate(10-1000)
@@ -25,11 +25,14 @@ def TSNE_reduction(latent_points, perplexity=30, learning_rate=20):
 
 def plot_dimensionality_reduction(x, y, label_set, title):
     plt.title(title)
+    # Color points based on their density
     if label_set[0].dtype == float:
         plt.scatter(x, y, c=label_set)
         cbar = plt.colorbar()
         cbar.set_label('Average Density', fontsize=12)
         print("using scatter")
+
+    # Color points based on a discrete label
     else:
         for label in set(label_set):
             cond = np.where(np.array(label_set) == str(label))

app.py

@@ -69,7 +69,7 @@ if st.button('Generate Samples'):  # Generate the samples
 # Output Entire Dataset
 st.write("Click 'Generate Dataset' to generate the dataset based on the conditions set previously:")
 if st.button('Generate Dataset'):  # Generate the dataset
-    boxes = make_boxes(image_size, densities) # Create all of the data points
+    boxes = make_boxes(image_size, densities) # Create all the data points
     # Unpack all of the data
     box_arrays, box_density, basic_box_thickness, forward_slash_box_thickness, back_slash_box_thickness,hot_dog_box_thickness, hamburger_box_thickness\
         = list(zip(*boxes))[0], list(zip(*boxes))[1], list(zip(*boxes))[2], list(zip(*boxes))[3], list(zip(*boxes))[4], list(zip(*boxes))[5], list(zip(*boxes))[6]