Fix/v1 ludo

cellpack/autopack/Analysis.py

@@ -755,10 +755,7 @@ def add_ingredient_positions_to_plot(
                 )
                 # plot the sphere
                 if ingr.use_rbsphere:
-                    (
-                        ext_recipe,
-                        pts,
-                    ) = ingr.getInterpolatedSphere(
+                    (ext_recipe, pts,) = ingr.getInterpolatedSphere(
                         seed_ingredient_positions[-i - 1],
                         seed_ingredient_positions[-i],
                     )
@@ -860,9 +857,9 @@ def update_pairwise_distances(
                 ingr.name,
                 ingr2.name,
             ):
-                pairwise_distance_dict[seed_index][f"{ingr.name}_{ingr2.name}"] = (
-                    self.env.calc_pairwise_distances(ingr.name, ingr2.name).tolist()
-                )
+                pairwise_distance_dict[seed_index][
+                    f"{ingr.name}_{ingr2.name}"
+                ] = self.env.calc_pairwise_distances(ingr.name, ingr2.name).tolist()
 
         return pairwise_distance_dict
 

cellpack/autopack/Compartment.py

@@ -218,6 +218,10 @@ def transformMesh(self, pos, rotation):
 
     def buildSphere(self, mesh_store):
         geom = None
+
+        if self.type == "multi_sphere":
+            _, r_max = self.representations.get_min_max_radius()
+            self.radius = r_max
         geom = mesh_store.create_sphere(self.gname, 4, self.radius)
         self.faces, self.vertices, self.vnormals = mesh_store.decompose_mesh(
             geom, edit=False, copy=False, tri=True
@@ -243,13 +247,17 @@ def initialize_shape(self, mesh_store):
         if self.is_sphere:
             # one sphere, geom is a dictionary
             self.buildSphere(mesh_store)
-        if self.vertices is None and self.type == "mesh":
+        if (
+            self.vertices is None
+            and self.type == "mesh"
+            and mesh_store.get_mesh(self.gname) is not None
+        ):
             self.faces, self.vertices, self.vnormals = self.getMesh(mesh_store)
             self.ref_obj = self.name
         if self.meshType == "raw":
             # need to build the mesh from v,f,n
             self.buildMesh(self.meshFile, mesh_store)
-        if self.type == "mb":
+        if self.type == "multi_sphere":
             # one sphere, geom is a dictionary
             self.buildSphere(mesh_store)
         if self.vertices is not None and len(self.vertices):

cellpack/autopack/DBRecipeHandler.py

@@ -238,9 +238,9 @@ def replace_region_references(self, composition_data):
                     continue
                 for index, item in enumerate(composition_data["regions"][region_name]):
                     if isinstance(item, str):
-                        composition_data["regions"][region_name][index] = (
-                            self.comp_to_path_map.get(item)
-                        )
+                        composition_data["regions"][region_name][
+                            index
+                        ] = self.comp_to_path_map.get(item)
                     elif isinstance(item, dict):
                         # process nested regions recursively
                         if "regions" in item and item["regions"]:
@@ -291,9 +291,9 @@ def convert_representation(doc, db):
                 and doc_value["packing"] is not None
             ):
                 position_value = doc_value["packing"]["positions"]
-                convert_doc["representations"]["packing"]["positions"] = (
-                    ObjectDoc.convert_positions_in_representation(position_value)
-                )
+                convert_doc["representations"]["packing"][
+                    "positions"
+                ] = ObjectDoc.convert_positions_in_representation(position_value)
         return convert_doc
 
     @staticmethod

cellpack/autopack/Environment.py

@@ -628,10 +628,10 @@ def resolve_gradient_data_objects(self, gradient_data):
         """
         # TODO: check if other modes need to be resolved
         if gradient_data["mode"] == "surface":
-            gradient_data["mode_settings"]["object"] = (
-                self.get_compartment_object_by_name(
-                    gradient_data["mode_settings"]["object"]
-                )
+            gradient_data["mode_settings"][
+                "object"
+            ] = self.get_compartment_object_by_name(
+                gradient_data["mode_settings"]["object"]
             )
         return gradient_data
 
@@ -2567,9 +2567,9 @@ def store_asJson(self, resultfilename=None, indent=True):
         if r:
             self.result_json["exteriorRecipe"] = OrderedDict()
             for ingr in r.ingredients:
-                self.result_json["exteriorRecipe"][ingr.composition_name] = (
-                    self.dropOneIngrJson(ingr, self.result_json["exteriorRecipe"])
-                )
+                self.result_json["exteriorRecipe"][
+                    ingr.composition_name
+                ] = self.dropOneIngrJson(ingr, self.result_json["exteriorRecipe"])
 
         # compartment ingr
         for orga in self.compartments:

cellpack/autopack/GeometryTools.py

@@ -165,7 +165,12 @@ def region_2_integrand(self, theta, rho, d):
 
     def region_2(self, rho, d):
         # require scipy
-        i4 = d**3 / 6.0 * (rho**2 / d**2 - 1) * (pi / 4 - self.region_1_2_theta(rho, d))
+        i4 = (
+            d**3
+            / 6.0
+            * (rho**2 / d**2 - 1)
+            * (pi / 4 - self.region_1_2_theta(rho, d))
+        )
         i3 = (
             d**2
             * rho

cellpack/autopack/Graphics.py

@@ -1523,9 +1523,9 @@ def displayCompartmentsIngredients(self):
                         elif self.vi.host == "dejavu":
                             self.orgaToMasterGeom[ingr] = ingr.mesh
                         elif self.vi.host == "softimage":
-                            self.orgaToMasterGeom[ingr] = (
-                                ingr.mesh
-                            )  # self.getMasterInstance(polygon)
+                            self.orgaToMasterGeom[
+                                ingr
+                            ] = ingr.mesh  # self.getMasterInstance(polygon)
                             # polygon already an instance from a different object\
 
                     j += 1

cellpack/autopack/MeshStore.py

@@ -307,24 +307,17 @@ def build_mesh(self, data, geomname):
         vertices = numpy.array(data["verts"]).reshape((nv, 3))
         faces = numpy.array(data["faces"]).reshape((nf, 3))
         vnormals = numpy.array(data["normals"]).reshape((nv, 3))
-        geom = self.create_mesh(geomname, vertices, None, faces)[0]
 
-        autopack.helper.saveDejaVuMesh(
-            autopack.cache_geoms + os.sep + geomname, self.vertices, self.faces
-        )
-        autopack.helper.saveObjMesh(
-            autopack.cache_geoms + os.sep + geomname + ".obj",
-            self.vertices,
-            self.faces,
-        )
-        # self.saveObjMesh(autopack.cache_geoms + os.sep + geomname + ".obj")
+        geom = self.create_mesh(geomname, vertices, None, faces)
         return geom, vertices, faces, vnormals
 
     def get_mesh(self, mesh_name, file_path=None):
         geometry = self.get_object(mesh_name)
-        if geometry is None and file_path is not None:
-            geometry = self.read_mesh_file(file_path)
-            self.add_mesh_to_scene(geometry, mesh_name)
+
+        if geometry is None:
+            if file_path is not None:
+                geometry = self.read_mesh_file(file_path)
+                self.add_mesh_to_scene(geometry, mesh_name)
         return geometry
 
     @staticmethod

cellpack/autopack/ingredient/Ingredient.py

@@ -488,19 +488,16 @@ def initialize_mesh(self, mesh_store):
         # get the collision mesh
         mesh_path = self.representations.get_mesh_path()
         meshName = self.representations.get_mesh_name()
-        meshType = "file"
+        meshFormat = self.representations.get_mesh_format()
         self.mesh = None
+        if meshFormat == ".raw":
+            self.buildMesh(mesh_store)
         if mesh_path is not None:
-            if meshType == "file":
-                self.mesh = self.getMesh(mesh_path, meshName, mesh_store)
-                self.log.info(f"OK got {self.mesh}")
-                if self.mesh is None:
-                    # display a message ?
-                    self.log.warning("no geometries for ingredient " + self.name)
-            # TODO: add back in raw option
-            elif meshType == "raw":
-                # need to build the mesh from v,f,n
-                self.buildMesh(mesh_store)
+            self.mesh = self.getMesh(mesh_path, meshName, mesh_store)
+            self.log.info(f"OK got {self.mesh}")
+            if self.mesh is None:
+                # display a message ?
+                self.log.warning("no geometries for ingredient " + self.name)
 
         if self.mesh is not None:
             self.getEncapsulatingRadius()
@@ -700,7 +697,8 @@ def buildMesh(self, mesh_store):
         Create a polygon mesh object from a dictionary verts,faces,normals
         """
         geom, vertices, faces, vnormals = mesh_store.build_mesh(
-            self.mesh_info["file"], self.mesh_info["name"]
+            self.representations.get_mesh_contents(),
+            self.representations.get_mesh_name(),
         )
         self.vertices = vertices
         self.faces = faces
@@ -1664,6 +1662,7 @@ def get_rotation(self, pt_ind, env, compartment):
                 pt_ind, env.grid.masterGridPositions[pt_ind], env.mesh_store
             )
             try:
+
                 rot_mat = numpy.array(rotVectToVect(v1, v2), "f")
             except Exception as e:
                 print(f"PROBLEM: {self.name}, {e}")

cellpack/autopack/ingredient/agent.py

@@ -25,16 +25,16 @@ def __init__(
         self.partners = partners
         self.packing_mode = packing_mode
 
-        assert self.packing_mode in [
-            "random",
-            "close",
-            "closePartner",
-            "randomPartner",
-            "gradient",
-            "hexatile",
-            "squaretile",
-            "triangletile",
-        ]
+        # assert self.packing_mode in [
+        #     "random",
+        #     "close",
+        #     "closePartner",
+        #     "randomPartner",
+        #     "gradient",
+        #     "hexatile",
+        #     "squaretile",
+        #     "triangletile",
+        # ]
         self.place_method = place_method
         self.mesh_3d = None
         self.is_attractor = is_attractor

cellpack/autopack/ingredient/single_cube.py

@@ -366,7 +366,9 @@ def cube_surface_distance(
                     current_distance = numpy.sqrt(dist_x**2 + dist_y**2)
                 else:
                     # vertex is the closest
-                    current_distance = numpy.sqrt(dist_x**2 + dist_y**2 + dist_z**2)
+                    current_distance = numpy.sqrt(
+                        dist_x**2 + dist_y**2 + dist_z**2
+                    )
         return current_distance
 
     def get_signed_distance(

cellpack/autopack/ingredient/single_sphere.py

@@ -188,10 +188,7 @@ def collision_jitter(
                 distance_to_packing_location - radius_of_ing_being_packed
             )
 
-            (
-                insidePoints,
-                newDistPoints,
-            ) = self.get_new_distances_and_inside_points(
+            (insidePoints, newDistPoints,) = self.get_new_distances_and_inside_points(
                 env,
                 jtrans,
                 rotMat,

cellpack/autopack/interface_objects/representations.py

@@ -82,7 +82,15 @@ def _get_spheres(self):
         # can be passed in directly, or they were just read from a file
         positions = self.packing["positions"]
         radii = self.packing["radii"]
-        if positions is None or positions[0] is None or positions[0][0] is None:
+        if (
+            positions is None
+            or (len(positions) == 1 and positions[0] is None)
+            or (
+                len(positions) == 1
+                and len(positions[0]) == 1
+                and positions[0][0] is None
+            )
+        ):
             positions = [[[0, 0, 0]]]
         if radii is None:
             radii = [[0]]
@@ -108,6 +116,12 @@ def get_mesh_name(self):
         else:
             return self.mesh["name"]
 
+    def get_mesh_contents(self):
+        if not self.has_mesh():
+            return None
+        else:
+            return self.mesh["file"]
+
     def get_mesh_path(self):
         if not self.has_mesh():
             return None