added downscale when in trouble, adjusted tests to output visuals and corrected catcells

Author: MbBrainz

irregular_object_packing/mesh/sampling.py

@@ -100,7 +100,7 @@ def resample_mesh_by_triangle_area(example_mesh: pv.PolyData, target_mesh: pv.Po
     target_avg_area = compute_average_triangle_area(target_mesh)
 
     # Calculate the desired number of triangles in the target mesh
-    target_num_triangles = int(target_mesh.n_faces * (example_avg_area / target_avg_area))
+    target_num_triangles = int(target_mesh.n_faces * (target_avg_area / example_avg_area))
 
     # Use the decimation algorithm to reduce the number of triangles in the target mesh
     resampled_mesh = resample_pyvista_mesh(target_mesh, target_faces=target_num_triangles)

irregular_object_packing/packing/chordal_axis_transform.py

@@ -235,8 +235,8 @@ def create_faces_3(data: CatData, occ, tet_points: list[TetPoint]):
     bc_point = data.point_id((most[1].vertex + least[0].vertex) / 2)
     bd_point = data.point_id((most[1].vertex + least[1].vertex) / 2)
 
-    most_face_c = [acd_point, ac_point, bcd_point, bc_point]
-    most_face_d = [acd_point, ad_point, bcd_point, bd_point]
+    most_face_c = [acd_point, bcd_point, bc_point, ac_point]
+    most_face_d = [acd_point, bcd_point, bd_point, ad_point]
     n_mfc = compute_face_unit_normal(
         data.get_face(most_face_c), most[0].vertex
     )  # can be both most[0] and most[1]

irregular_object_packing/packing/growth_based_optimisation.py

@@ -161,10 +161,10 @@ def setup(self):
         self.log(
             f"Skipped {skipped} points to avoid overlap with container", LOG_LVL_DEBUG
         )
+        self.log(f"Setup with settings: \n{self.settings}", LOG_LVL_INFO)
         self.log(f"Number of objects: {self.n_objs}", LOG_LVL_INFO)
 
         object_rotations = np.random.uniform(-np.pi, np.pi, (self.n_objs, 3))
-        self.padding = 0.01
 
         # SET TRANSFORM DATA
         self.tf_arrays = np.empty((self.n_objs, 7))
@@ -250,6 +250,9 @@ def resample_meshes(self, scale_factor):
         self.curr_sample_rate = self.sample_rate_mesh(scale_factor)
         self.shape = resample_pyvista_mesh(self.shape0, self.curr_sample_rate)
         self.container = resample_mesh_by_triangle_area(self.shape, self.container0)
+        assert self.shape.is_manifold
+        assert self.container.is_manifold
+
         self.log(f"container: n_faces: {self.container.n_faces}[sampled]/{self.container0.n_faces}[original]", LOG_LVL_INFO)
         self.log(f"mesh: n_faces: {self.curr_sample_rate}[sampled]/{self.shape0.n_faces}[original]", LOG_LVL_INFO)
         # self.padding = avg_mesh_area**(0.5) / 4 # This doenst help
@@ -353,8 +356,17 @@ def process_iteration(self, ib, i):
         cat_viols, con_viols, collisions = compute_all_collisions(p_meshes, cat_meshes, self.container, set_contacts=False)
         self.log_violations((cat_viols, con_viols, collisions))
 
+        violating_ids = set([i for i, v in cat_viols] + [i for i, v in con_viols])
+
+        self.log("reducing scale for violating objects: " + str(violating_ids), LOG_LVL_INFO)
+        for id in violating_ids:
+            self.reduce_scale(id)
+
         self.update_data(ib, i, (cat_viols, con_viols, collisions))
 
+    def reduce_scale(self, id):
+        self.tf_arrays[id][0] *= 0.95
+
     def check_closed_cells(self):
         cat_cells = [
             PolyData(*cat.face_coord_to_points_and_faces(self.cat_data, obj_id))
@@ -379,7 +391,7 @@ def log_violations(self, violations):
     def default_setup() -> "Optimizer":
         DATA_FOLDER = "./../../data/mesh/"
 
-        mesh_volume = 0.3
+        mesh_volume = 0.2
         container_volume = 10
 
         loaded_mesh = pv.read(DATA_FOLDER + "RBC_normal.stl")
@@ -401,7 +413,7 @@ def default_setup() -> "Optimizer":
             # padding=1e-3,
             # sample_rate=1000,
             dynamic_simplification=True,
-            alpha=0.25,
+            alpha=0.2,
             beta=0.5,
         )
         plotter = None
@@ -459,23 +471,25 @@ def simple_shapes_setup() -> "Optimizer":
 
 # %%
 
+reload(plots)
+
 
 def plot_step(optimizer, step):
     plotter = pv.Plotter()
     meshes, cat_meshes, container = optimizer.recreate_scene(step)
-    plots.plot_simulation_scene(plotter, meshes, cat_meshes, container)
+    plots.plot_simulation_scene(plotter, meshes, cat_meshes, container, c_kwargs={"show_edges": True, "edge_color": "purple"})
     plotter.add_text(optimizer.status(step).table_str, position="upper_left")
 
     plotter.show()
     return plotter
 
 
-plot_step(optimizer, 6)
+plot_step(optimizer, 33)
 
 
 # %%
-obj_i, step = 10, 5
-meshes, cat_meshes, container = optimizer.recreate_scene(step)
+obj_i, step = 6, 31
+meshes_before, meshes_after, cat_meshes, container = optimizer.recreate_scene(step)
 # plots.plot_step_comparison(
 #     optimizer.mesh_before,
 #     optimizer.mesh_after(step, obj_i),
@@ -484,8 +498,13 @@ def plot_step(optimizer, step):
 # )
 # %%
 reload(plots)
-
-plotter = plots.plot_step_single(meshes[obj_i], cat_meshes[obj_i], cat_opacity=0.7, mesh_opacity=1 , clipped=True, title="cat overlap")
+obj_i = 6
+plotter = plots.plot_step_single(
+    meshes_before[obj_i], cat_meshes[obj_i], container=container, cat_opacity=0.7, mesh_opacity=1 , clipped=True, title="cat overlap",
+    c_kwargs={"show_edges": True, "edge_color": "purple", "show_vertices": True, "point_size": 10},
+    m_kwargs={"show_edges": True, "show_vertices": True, "point_size": 10, },
+    cat_kwargs={"show_edges": True, "show_vertices": True, "point_size": 5, },
+)
 
 # %%
 # store cat mesh in file
@@ -534,4 +553,5 @@ def profile_optimizer():
         print(f"{ai} {bi}`")
         ax.plot(mesh_simplification_condition(x, ai, bi), label=f"a:{ai:.2f},  b:{bi:.2f}")
 ax.legend()
+
 # %%

irregular_object_packing/packing/nlc_optimisation.py

@@ -149,28 +149,27 @@ def local_constraint_for_point_with_padding(
         face_coords = [np.array(points[p_id]) - obj_coord for p_id in face_p_ids]
 
         # NOTE: Any point on the surface of the object can be used as q_j
-        q_j = face_coords[0] # q_j = np.mean(face_coords, axis=0) -> not necessary
+        q_j = face_coords[0]  # q_j = np.mean(face_coords, axis=0) -> not necessary
 
         # NOTE: The normal vector has unit length [./utils.py:196], no need to divide
         condition = np.dot(transformed_v_i - q_j, n_face)
 
-
         # Return negative value if point is inside surface plus margin,
         dist = condition - padding
         constraints.append(dist)
 
-        # NOTE: alternative implementation: (currently allows point inside margin only)
-        # MARGIN: Compute distance to surface
-        # dist = abs(condition) - padding
-        # if dist < 0:
-        #     dist = 0
-        # # positive value otherwise
-        # if condition < 0:
-        #     constraints.append(-dist)
-        # else:
-        #     constraints.append(dist)
-        # # constraints.append(condition)
     return constraints
+    # NOTE: alternative implementation: (currently allows point inside margin only)
+    # MARGIN: Compute distance to surface
+    # dist = abs(condition) - padding
+    # if dist < 0:
+    #     dist = 0
+    # # positive value otherwise
+    # if condition < 0:
+    #     constraints.append(-dist)
+    # else:
+    #     constraints.append(dist)
+    # # constraints.append(condition)
 
 
 def local_constraint_for_point(
@@ -270,6 +269,8 @@ def local_constraints_from_cat(
 
     # [(vi, [facet_j, facet_j+1, ...]), (vi+1, [facet_k, facet_k+1, ...)]
     items = cat_data.cat_faces[obj_id].items()
+    cat_cell = cat_data.cat_cells[obj_id]
+    _all_faces = [cat_cell] * len(items)
 
     v, sets_of_faces = [*zip(*items, strict=True)]
     return local_constraint_multiple_points(
@@ -284,6 +285,8 @@ def local_constraints_from_cat(
 # -----------------------------------------------------------------------------
 # Visual Tests
 # -----------------------------------------------------------------------------
+
+
 def test_nlcp_facets():
     # Define points
     points = {
@@ -341,7 +344,7 @@ def get_face_coords(facet, points):
         objective, x0, method="SLSQP", bounds=bounds, constraints=constraint_dict
     )
     T = construct_transform_matrix(res.x)
-    ## %%
+    # %%
     # Print the results
     print("Optimal solution:")
     print_transform_array(res.x)
@@ -351,7 +354,7 @@ def get_face_coords(facet, points):
     print(transform_v(points[10], T))
     print(transform_v(points[11], T))
 
-    ## %%
+    # %%
     # Create a 3D plot
     import matplotlib.pyplot as plt
     from mpl_toolkits.mplot3d.art3d import Poly3DCollection

irregular_object_packing/packing/optimizer_data.py

@@ -188,11 +188,13 @@ def reconstruct_delaunay(self, iteration: int):
 
     def recreate_scene(self, iteration: int):
         """Recreate the scene at the given iteration."""
-        meshes = self.meshes_after(iteration)
+        meshes_before = self.meshes_before(iteration)
+        meshes_after = self.meshes_after(iteration)
         cat_meshes = self.cat_meshes(iteration)
-        compute_all_collisions(meshes, cat_meshes, self.container0, set_contacts=True)
+        compute_all_collisions(meshes_before, cat_meshes, self.container0, set_contacts=True)
+        compute_all_collisions(meshes_after, cat_meshes, self.container0, set_contacts=True)
 
-        return meshes, cat_meshes, self.container0
+        return meshes_before, meshes_after, cat_meshes, self.container0
 
     def final_meshes_after(self):
         """Get the meshes of all objects with the most recent transformation."""
@@ -238,8 +240,11 @@ def _report(self, iteration=None):
         )
 
     def print_report(self, notebook=False):
-        tabulate(
+        table = tabulate(
             [self.status(i) for i in range(self.idx)],  # type: ignore
             headers=[field.name for field in fields(IterationData)],
-            tablefmt="html" if notebook else "grid"
+            tablefmt="html" if notebook else "grid",
+            showindex=True,
         )
+        print(table)
+        return table

irregular_object_packing/packing/plots.py

@@ -121,11 +121,13 @@ def plot_step_comparison(
 def plot_step_single(
     mesh,
     cat_cell_mesh_1,
+    container=None,
     mesh_opacity=0.9,
     cat_opacity=0.4,
     plotter=None,
     clipped=False,
     title="Title",
+    c_kwargs={}, m_kwargs={}, cat_kwargs={},
 ):
     if plotter is None:
         plotter = pv.Plotter()
@@ -139,16 +141,19 @@ def plot_step_single(
     )
     if clipped:
         try:
-            plotter.add_mesh_clip_plane(mesh, opacity=mesh_opacity, color="red", cmap='bwr', scalars="collisions", point_size=10, show_vertices=True, show_edges=True)
+            plotter.add_mesh_clip_plane(mesh, opacity=mesh_opacity, color="red", cmap='bwr', scalars="collisions", **m_kwargs)
         except KeyError:
             plotter.add_mesh(mesh, opacity=mesh_opacity, color="blue")
-        plotter.add_mesh_clip_plane(cat_cell_mesh_1, opacity=cat_opacity, color="yellow", show_edges=True, show_vertices=True, point_size=5)
+        plotter.add_mesh_clip_plane(cat_cell_mesh_1, opacity=cat_opacity, color="yellow", **cat_kwargs)
     else:
         try:
-            plotter.add_mesh(mesh, opacity=mesh_opacity, color="red", cmap='bwr', scalars="collisions", point_size=10, show_vertices=True, show_edges=True)
+            plotter.add_mesh(mesh, opacity=mesh_opacity, color="red", cmap='bwr', scalars="collisions", **m_kwargs)
         except KeyError:
-            plotter.add_mesh(mesh, opacity=mesh_opacity, color="blue")
-        plotter.add_mesh(cat_cell_mesh_1, opacity=cat_opacity, color="yellow", show_edges=True, show_vertices=True, point_size=5)
+            plotter.add_mesh(mesh, opacity=mesh_opacity, color="blue", **m_kwargs)
+        plotter.add_mesh(cat_cell_mesh_1, opacity=cat_opacity, color="yellow", **cat_kwargs)
+
+    if container is not None:
+        plotter.add_mesh(container, opacity=0.3, **c_kwargs)
     # plotter.add_mesh(open_edges, color="black", line_width=1, opacity=0.8)
     plotter.show()
 
@@ -225,15 +230,16 @@ def create_packed_scene(
     return plotter
 
 
-def plot_simulation_scene(plotter, meshes, cat_meshes, container):
+def plot_simulation_scene(plotter, meshes, cat_meshes, container, c_kwargs={}, m_kwargs={}, cat_kwargs={},
+                          ):
     for i in range(len(meshes)):
         try:
-            plotter.add_mesh(meshes[i], opacity=0.95, color="red", cmap='bwr', scalars="collisions")
-            plotter.add_mesh(cat_meshes[i], opacity=0.6, color="yellow")
+            plotter.add_mesh(meshes[i], opacity=0.95, color="red", cmap='bwr', scalars="collisions", **m_kwargs)
+            plotter.add_mesh(cat_meshes[i], opacity=0.6, color="yellow", **cat_kwargs)
         except KeyError:
-            plotter.add_mesh(meshes[i], opacity=0.8, color="blue")
-            plotter.add_mesh(cat_meshes[i], opacity=0.4, color="greenyellow")
-    plotter.add_mesh(container, color="white", opacity=0.3)
+            plotter.add_mesh(meshes[i], opacity=0.8, color="blue", **m_kwargs)
+            plotter.add_mesh(cat_meshes[i], opacity=0.4, color="greenyellow", **cat_kwargs)
+    plotter.add_mesh(container, color="white", opacity=0.3, **c_kwargs)
 
 
 def generate_gif(optimizer, save_path, title="Optimization"):