OOP code with comments

Author: Nivedha-Ramesh

boxes.py

@@ -1,43 +1,51 @@
 import random
 
+class BoxGenerator:
+    """
+    A class to generate boxes with specified dimensions and constraints.
+    """
+    def __init__(self, min_dim=11, split_dim_min=5):
+        self.min_dim = min_dim
+        self.split_dim_min = split_dim_min
 
-def generateboxes(container, num):
-    retry = 500 * num
-    while num > 1:
-        cuboid = random.choice(container)
-        while cuboid[3] <= 11 or cuboid[4] <= 11 or cuboid[5] <= 11:
-            retry -= 1
-            if retry == 0:
-                print("Cannot partition into packages. Please try again")
-                return
-            cuboid = random.choice(container)
-        container.remove(cuboid)
-        prob = random.uniform(0, 1)
-        x1 = cuboid[0]
-        y1 = cuboid[1]
-        z1 = cuboid[2]
-        x2 = cuboid[3]
-        y2 = cuboid[4]
-        z2 = cuboid[5]
-        if prob < 0.35:
-            # Split in length
-            t = random.randint(5, int(x2 / 2))
-            package1 = [x1 + t, y1, z1, x2 - t, y2, z2]
-            package2 = [x1, y1, z1, t, y2, z2]
-        elif prob < 0.65:
-            # Split in width
-            t = random.randint(5, int(y2 / 2))
-            package1 = [x1, y1 + t, z1, x2, y2 - t, z2]
-            package2 = [x1, y1, z1, x2, t, z2]
-
-        else:
-            # Split in height
-            t = random.randint(5, int(z2 / 2))
-            package1 = [x1, y1, z1 + t, x2, y2, z2 - t]
-            package2 = [x1, y1, z1, x2, y2, t]
+    def generate_boxes(self, container, num):
+        """
+        Generates a list of boxes within a container based on the specified conditions.
 
-        container.append(package1)
-        container.append(package2)
-        num -= 1
+        Parameters:
+        - container (list): A list of cuboids where each cuboid is represented by six integers.
+        - num (int): The number of boxes to generate.
 
-    return container
+        Returns:
+        - A list of generated boxes with their dimensions.
+        """
+        retry = 500 * num
+        while num > 1:
+            cuboid = random.choice(container)
+            while cuboid[3] <= self.min_dim or cuboid[4] <= self.min_dim or cuboid[5] <= self.min_dim:
+                retry -= 1
+                if retry == 0:
+                    print("Cannot partition into packages. Please try again")
+                    return
+                cuboid = random.choice(container)
+            container.remove(cuboid)
+            prob = random.uniform(0, 1)
+            x1, y1, z1, x2, y2, z2 = cuboid
+            
+            # Splitting the cuboid based on the random probability generated
+            if prob < 0.35:
+                t = random.randint(self.split_dim_min, int(x2 / 2))
+                package1 = [x1 + t, y1, z1, x2 - t, y2, z2]
+                package2 = [x1, y1, z1, t, y2, z2]
+            elif prob < 0.65:
+                t = random.randint(self.split_dim_min, int(y2 / 2))
+                package1 = [x1, y1 + t, z1, x2, y2 - t, z2]
+                package2 = [x1, y1, z1, x2, t, z2]
+            else:
+                t = random.randint(self.split_dim_min, int(z2 / 2))
+                package1 = [x1, y1, z1 + t, x2, y2, z2 - t]
+                package2 = [x1, y1, z1, x2, y2, t]
+            container.append(package1)
+            container.append(package2)
+            num -= 1
+        return container

create_dataset.py

@@ -1,43 +1,61 @@
-"""
-This function is used to create the data-set
-"""
-
 import json
 import random
-import boxes as bx
+from boxes import BoxGenerator
+
+class DatasetCreator:
+    """
+    A class to create a dataset for the box packing problem, including truck dimensions and box parameters.
+    """
+    def __init__(self, min_boxes=10, max_boxes=36, min_value=50, max_value=500,
+                 max_truck_dim=(600, 600, 600), min_truck_dim=(50, 50, 50)):
+        """
+        Initializes the DatasetCreator with parameters for box and truck dimension ranges.
+
+        Parameters:
+        - min_boxes, max_boxes (int): The minimum and maximum number of boxes.
+        - min_value, max_value (int): The minimum and maximum value associated with each box.
+        - max_truck_dim, min_truck_dim (tuple): The maximum and minimum dimensions for the trucks.
+        """
+        self.min_boxes = min_boxes
+        self.max_boxes = max_boxes
+        self.min_value = min_value
+        self.max_value = max_value
+        self.max_truck_len, self.max_truck_wid, self.max_truck_ht = max_truck_dim
+        self.min_truck_len, self.min_truck_wid, self.min_truck_ht = min_truck_dim
+        self.box_generator = BoxGenerator()
 
-MIN_BOXES = 10
-MAX_BOXES = 36
-MIN_VALUE = 50
-MAX_VALUE = 500
-MAX_TRUCK_LEN = 600
-MIN_TRUCK_LEN = 50
-MAX_TRUCK_WID = 600
-MIN_TRUCK_WID = 50
-MAX_TRUCK_HT = 600
-MIN_TRUCK_HT = 50
+    def generate_dataset(self):
+        """
+        Generates a dataset of packing scenarios, each with a set of boxes and a truck.
 
-truck_dim = [[random.randint(MIN_TRUCK_LEN, MAX_TRUCK_LEN), random.randint(MIN_TRUCK_WID, MAX_TRUCK_WID),
-              random.randint(MIN_TRUCK_HT, MAX_TRUCK_HT)] for _ in range(5)]
-NUM_BOXES = [
-    [random.randint(MIN_BOXES, MAX_BOXES), random.randint(MIN_BOXES, MAX_BOXES), random.randint(MIN_BOXES, MAX_BOXES),
-     random.randint(MIN_BOXES, MAX_BOXES), random.randint(MIN_BOXES, MAX_BOXES)] for _ in range(5)]
-dataset = {}
-i = 0
-for cont, counts in zip(truck_dim, NUM_BOXES):
-    for number in counts:
-        packages = bx.generateboxes([[0, 0, 0] + cont], number)
-        boxes = []
-        total_value = 0
-        for each in packages:
-            l, w, h = each[3:]
-            vol = l * w * h
-            value = random.randint(MIN_VALUE, MAX_VALUE)
-            total_value += value
-            boxes.append([l, w, h, vol, value])
-        dataset[i] = {'truck dimension': cont, 'number': number, 'boxes': boxes, 'solution': packages,
-                      'total value': total_value}
-        i += 1
+        Returns:
+        - A dictionary representing the dataset, where each key is a scenario with truck dimensions,
+          box parameters, and total value.
+        """
+        truck_dim = [[random.randint(self.min_truck_len, self.max_truck_len),
+                      random.randint(self.min_truck_wid, self.max_truck_wid),
+                      random.randint(self.min_truck_ht, self.max_truck_ht)] for _ in range(5)]
+        num_boxes = [[random.randint(self.min_boxes, self.max_boxes) for _ in range(5)] for _ in range(5)]
+        dataset = {}
+        i = 0
+        origin = [0,0,0]
+        for truck_dimensions, box_counts in zip(truck_dim, num_boxes):
+            for number_of_boxes in box_counts:
+                # Generate boxes within the truck's volume, defined by starting at the origin [0, 0, 0] and truck_dimensions [length, width, height]
+                packages = self.box_generator.generate_boxes([origin + truck_dimensions], number_of_boxes)
+                boxes = []
+                total_value = 0
+                for each in packages:
+                    l, w, h = each[3:]
+                    vol = l * w * h
+                    value = random.randint(self.min_value, self.max_value)
+                    total_value += value
+                    boxes.append([l, w, h, vol, value])
+                dataset[str(i)] = {'truck dimension': truck_dimensions, 'number': number_of_boxes, 'boxes': boxes, 'solution': packages,
+                                   'total value': total_value}
+                i += 1
+        return dataset
 
-with open('input.json', 'w') as outfile:
-    json.dump(dataset, outfile)
+    def save_to_file(self, dataset, filename='input.json'):
+        with open(filename, 'w') as outfile:
+            json.dump(dataset, outfile)