Replaced update array with addition of arrays, use convolution filter to streamline thickness calculation. All for loops were removed from these main functions

Data_Generation/Piecewise_Box_Functions.py

@@ -1,143 +1,55 @@
 import numpy as np
 from scipy import signal
-import math
-import matplotlib.pyplot as plt
-import itertools
-def basic_box_array(image_size):
+
+
+def basic_box_array(image_size, thickness):
     A = np.ones((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
-    # A[1:-1, 1:-1] = 1
-    # np.pad(A[1:-1,1:-1], pad_width=((1, 1), (1, 1)), mode='constant', constant_values=1)
-    A[1:-1, 1:-1] = 0
+    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):
+def back_slash_array(image_size, thickness):
     A = np.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
-    np.fill_diagonal(A, 1)
-
+    np.fill_diagonal(A, 1)  # fills the diagonal with 1 values
+    A = add_thickness(A, thickness)
     return A
 
 
-def forward_slash_array(image_size):
+def forward_slash_array(image_size, thickness):
     A = np.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
-    np.fill_diagonal(np.fliplr(A), 1)
+    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):
+def hot_dog_array(image_size, thickness):
     # 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
-    # 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
-
-    A[:, np.floor((image_size - 1) / 2).astype(int)] = 1
+    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):
+def hamburger_array(image_size, thickness):
     # 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
-    # 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
-    A[np.floor((image_size - 1) / 2).astype(int), :] = 1
+    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 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 update_array(array_original, array_new):
-    A = array_original
-    A[array_new == 1] = 1
-    return A
-
-
-# def add_pixels(array_original, additional_pixels):
-#     # Adds pixels to the thickness of each component of the box
-#     A = array_original
-#     filter = np.array(([0, 1, 0], [1, 1, 1], [0, 1, 0]))  # This filter will only add value where there are pixels on
-#     # the top, bottom, left or right of a pixel
-#
-#     # This filter adds thickness based on the desired number of additional pixels
-#     for item in range(additional_pixels):
-#         convolution = signal.convolve2d(A, filter, mode='same')
-#         A = np.where(convolution <= 1, convolution, 1)
-#     return A
-
-
-def add_pixels(array_original, thickness):
+def add_thickness(array_original, thickness):
     A = array_original
-    # if thickness !=0:
-
-    # filter = np.array(([0, 1, 0], [1, 1, 1], [0, 1, 0]))
-    # filter = np.stack([filter] * additional_pixels, axis=-1)
-    filter_size = 2*thickness+1
-    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
-
-    # filter[0,0] = filter[-1,0] = filter[0,-1] = filter[-1,-1] = 0
-    print(filter)
-    convolution = signal.convolve2d(A, filter, mode='same')
-    A = np.where(convolution <= 1, convolution, 1)
+    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
+        convolution = signal.convolve2d(A, filter, mode='same')
+        A = np.where(convolution <= 1, convolution, 1)
     return A
-
-
-# def create_array(basic_box_thickness, forward_slash_thickness, back_slash_thickness, hamburger_thickness, hot_dog_thickness):
-#
-
-# TESTING
-image_size = 9
-# test = forward_slash_array(image_size)
-test = hamburger_array((image_size))
-back = back_slash_array((image_size))
-hot = hot_dog_array(image_size)
-forward = forward_slash_array(image_size)
-basic = basic_box_array((image_size))
-
-# test = update_array(test, back)
-# test = update_array(test, hot)
-# test = update_array(test, forward)
-test = test + back + forward + hot + basic
-test = np.array(test > 0, dtype=int)
-
-# test = add_pixels(test, 1)
-print(test)
-plt.imshow(test)
-plt.show()
-
-
-# basic_box_thickness = np.linspace(0,14, num=15)
-# print(basic_box_thickness)
-# forward_slash_thickness = np.linspace(0,14, num=15)
-# back_slash_thickness = np.linspace(0,14, num=15)
-# hamburger_thickness = np.linspace(0,14, num=15)
-# hot_dog_thickness =np.linspace(0,14, num=15)
-# print(np.meshgrid((basic_box_thickness, forward_slash_thickness, back_slash_thickness, hamburger_thickness, hot_dog_thickness)))
-
-# all_thicknesses = list(itertools.product(basic_box_thickness, repeat=5))
-# print(all_thicknesses)
-# print(np.shape(all_thicknesses))