Created a strut based dataset generator.

Data_Generation/Dataset_Generation_Functions.py

@@ -1,17 +1,18 @@
 import numpy as np
 
-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.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 Piecewise_Box_Functions import basic_box_array, back_slash_array, forward_slash_array, hamburger_array, hot_dog_array
 import matplotlib.pyplot as plt
 
-from Data_Generation.Piecewise_Box_Functions import add_pixels
+
 
 
 ########################################################################################################################
 # Make the data using all the code in Shape_Generation_Functions.py
-def make_boxes(image_size, densities, shapes):
+def make_boxes(image_size, densities):
     """
     :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
@@ -19,7 +20,7 @@ def make_boxes(image_size, densities, shapes):
     :return: [list[tuple]] - [Array, Density, Thickness, Shape]
     """
 
-    # matrix = []
+    matrix = []
     #
     # for function in shapes:  # Adds different types of shapes
     #
@@ -38,83 +39,165 @@ def make_boxes(image_size, densities, shapes):
     #             # Prevents solids shapes from being appended to the array
     #             else:
     #                 break
-    matrix = []
-    base_shapes = []
-    density_1 = []
-    for function in shapes:  # Create an array of the base shapes
-        thickness = 0
-        Array = function(thickness, 1, image_size)
-        # density_1_tuple = np.array([Array, str(function.__name__), 1, thickness])  # Array, Shape, Density, Thickness
-        # base_shapes.append(density_1_tuple)
-
-        density_1 = np.append(density_1,(np.array([Array, str(function.__name__), 1, thickness])), axis=1)  # Array, Shape, Density, Thickness
-        # Add one to the thickness of the previous array
-        # for j in range(image_size):
-        while (np.where((Array == float(0)))[0] > 0).any():
-            # Checks if there are any 0's left in the array to append
-            # if (np.where((Array == float(0)))[0] > 0).any():
-                # density_1.append(density_1_tuple, axis=0)
-            thickness += 1
-            if np.shape(density_1) == (4,):
-                Array = add_pixels(density_1[0], 1) # will add 1 pixel to each previous array, rather than adding multiple and having to loop
-
-            else:
-                print(np.shape(density_1))
-                print(density_1[-1][0])
-                Array = add_pixels(density_1[-1][0], 1)
-            # print(np.shape(Array))
-            density_1_tuple = np.array([Array, str(function.__name__), 1, thickness])
-            # else:  # Prevents solids shapes from being appended to the array
-            #     break
-            density_1 = np.vstack((density_1, density_1_tuple))
 
-    matrix = []
-    # print(np.shape(density_1[0]))
-    # print(density_1[:][0])
+    # Establish the maximum thickness for each type of strut
+    max_vert = int(np.ceil(1 / 2 * image_size) - 2)
+    max_diag = int(image_size - 3)
+    max_basic = int(np.ceil(1 / 2 * image_size) - 1)
+
+    # Adds different density values
     for i in range(len(densities)):
-        some = np.multiply(density_1[:][0],densities[i]) #,density_1[:1])
-        # print(np.shape(some))
-        matrix.append(tuple(some))
-
-
-        # # Adds different density values
-        # for i in range(len(densities)):
-        #     # Loops through the possible thickness values
-        #     for j in range(image_size):  # Adds additional Pixels
-        #         thickness = j
-        #         Array = (function(thickness, densities[i], image_size))
-        #
-        #         # Checks if there are any 0's left in the array to append
-        #         if (np.where((Array == float(0)))[0] > 0).any():
-        #             the_tuple = (Array, str(function.__name__), densities[i], thickness)
-        #             matrix.append(the_tuple)
-        #
-        #         # Prevents solids shapes from being appended to the array
-        #         else:
-        #             break
+        for j in range(1, max_basic):  # basic box loop, always want a border
+            basic_box_thickness = j
+            array_1 = basic_box_array(image_size, basic_box_thickness)
+            if np.unique([array_1]).all() > 0:  # Checks if there is a solid figure
+                break
+
+            for k in range(0, max_vert):
+                hamburger_box_thickness = k
+                array_2 = hamburger_array(image_size, hamburger_box_thickness) + array_1
+                array_2 =np.array(array_2 > 0, dtype=int)  # Keep all values 0/1
+                if np.unique([array_2]).all() > 0:
+                    break
+
+                for l in range(0, max_vert):
+                    hot_dog_box_thickness = l
+                    array_3 = hot_dog_array(image_size, hot_dog_box_thickness) + array_2
+                    array_3 = np.array(array_3 > 0, dtype=int)
+                    if np.unique([array_3]).all() > 0:
+                        break
+
+                    for m in range(0, max_diag):
+                        forward_slash_box_thickness = m
+                        array_4 = forward_slash_array(image_size, forward_slash_box_thickness) + array_3
+                        array_4 = np.array(array_4 > 0, dtype=int)
+                        if np.unique([array_4]).all() > 0:
+                            break
+
+                        for n in range(0, max_diag):
+                            back_slash_box_thickness = n
+                            array_5 = back_slash_array(image_size, back_slash_box_thickness) + array_4
+                            array_5 = np.array(array_5 > 0, dtype=int)
+                            if np.unique([array_5]).all() > 0:
+                                break
+                            the_tuple = (array_5*densities[i], densities[i], basic_box_thickness,
+                                         forward_slash_box_thickness, back_slash_box_thickness,
+                                         hot_dog_box_thickness, hamburger_box_thickness)
+                            matrix.append(the_tuple)
+
+    # matrix = []
+    # base_shapes = []
+    #
+    #
+    #
+    #
+    #
+    # density_1 = []
+    # for function in shapes:  # Create an array of the base shapes
+    #     thickness = 0
+    #     Array = function(thickness, 1, image_size)
+    #     # density_1_tuple = np.array([Array, str(function.__name__), 1, thickness])  # Array, Shape, Density, Thickness
+    #     # base_shapes.append(density_1_tuple)
+    #
+    #     density_1 = np.append(density_1,(np.array([Array, str(function.__name__), 1, thickness])), axis=1)  # Array, Shape, Density, Thickness
+    #     # Add one to the thickness of the previous array
+    #     # for j in range(image_size):
+    #     while (np.where((Array == float(0)))[0] > 0).any():
+    #         # Checks if there are any 0's left in the array to append
+    #         # if (np.where((Array == float(0)))[0] > 0).any():
+    #             # density_1.append(density_1_tuple, axis=0)
+    #         thickness += 1
+    #         if np.shape(density_1) == (4,):
+    #             Array = add_pixels(density_1[0], 1) # will add 1 pixel to each previous array, rather than adding multiple and having to loop
+    #
+    #         else:
+    #             print(np.shape(density_1))
+    #             print(density_1[-1][0])
+    #             Array = add_pixels(density_1[-1][0], 1)
+    #         # print(np.shape(Array))
+    #         density_1_tuple = np.array([Array, str(function.__name__), 1, thickness])
+    #         # else:  # Prevents solids shapes from being appended to the array
+    #         #     break
+    #         density_1 = np.vstack((density_1, density_1_tuple))
+    #
+    # matrix = []
+    # # print(np.shape(density_1[0]))
+    # # print(density_1[:][0])
+    # for i in range(len(densities)):
+    #     some = np.multiply(density_1[:][0],densities[i]) #,density_1[:1])
+    #     # print(np.shape(some))
+    #     matrix.append(tuple(some))
+    #
+    #
+    #     # # Adds different density values
+    #     # for i in range(len(densities)):
+    #     #     # Loops through the possible thickness values
+    #     #     for j in range(image_size):  # Adds additional Pixels
+    #     #         thickness = j
+    #     #         Array = (function(thickness, densities[i], image_size))
+    #     #
+    #     #         # Checks if there are any 0's left in the array to append
+    #     #         if (np.where((Array == float(0)))[0] > 0).any():
+    #     #             the_tuple = (Array, str(function.__name__), densities[i], thickness)
+    #     #             matrix.append(the_tuple)
+    #     #
+    #     #         # Prevents solids shapes from being appended to the array
+    #     #         else:
+    #     #             break
     return matrix
 
 
+########################################################################################################################
+# # Testing
+# image_size = 9
+# densities = [1]
+# shapes = [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]
+#
+# boxes = make_boxes(image_size, densities, shapes)
+#
+# # print(np.shape(boxes))
+# desired_label = 'basic_box'
+# desired_density = 1
+# desired_thickness = 0
+#
+# box_arrays, box_shape, box_density, box_thickness,  = list(zip(*boxes))[0], list(zip(*boxes))[1], list(zip(*boxes))[2], list(zip(*boxes))[3]
+# # print(np.shape(box_arrays))
+# # print(np.shape(box_shape))
+# # print(np.shape(box_density))
+#
+# indices = [i for i in range(len(box_arrays)) if box_shape[i] == desired_label and box_density[i] == desired_density and box_thickness[i] == desired_thickness]
+# plt.imshow(box_arrays[indices[0]])
+# plt.show()
 ########################################################################################################################
 # Testing
 image_size = 9
 densities = [1]
-shapes = [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]
 
-boxes = make_boxes(image_size, densities, shapes)
+boxes = make_boxes(image_size, densities)
 
-# print(np.shape(boxes))
-desired_label = 'basic_box'
 desired_density = 1
-desired_thickness = 0
+# desired_thickness = 0
+
+desired_basic_box_thickness =1
+desired_forward_slash_box_thickness=2
+desired_back_slash_box_thickness=0
+desired_hot_dog_box_thickness=0
+desired_hamburger_box_thickness=0
+
 
-box_arrays, box_shape, box_density, box_thickness,  = list(zip(*boxes))[0], list(zip(*boxes))[1], list(zip(*boxes))[2], list(zip(*boxes))[3]
+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]
 # print(np.shape(box_arrays))
 # print(np.shape(box_shape))
 # print(np.shape(box_density))
 
-indices = [i for i in range(len(box_arrays)) if box_shape[i] == desired_label and box_density[i] == desired_density and box_thickness[i] == desired_thickness]
+indices = [i for i in range(len(box_arrays)) if box_density[i] == desired_density
+           and basic_box_thickness[i] == desired_basic_box_thickness
+           and forward_slash_box_thickness[i] == desired_forward_slash_box_thickness
+           and back_slash_box_thickness[i] == desired_back_slash_box_thickness
+           and hot_dog_box_thickness[i] == desired_hot_dog_box_thickness
+           and hamburger_box_thickness[i] == desired_hamburger_box_thickness]
 plt.imshow(box_arrays[indices[0]])
 plt.show()