Changing cellRange to discrete numbers to allow more flexability when loading geometry (#205)

* moved two methods out of start

* removed unnecessary logger line

* changed cellRange to skip_solids

* improved doc string

* lowercase args pep8

Author: shimwell

docs/usage/python_api_usage.rst

@@ -12,7 +12,8 @@ The example makes use of default  attributes.
 .. code-block:: python
 
     import geouned
-    geo = geouned.CadToCsg(stepFile='cuboid.stp')
+    geo = geouned.CadToCsg()
+    geo.load_step_file(filename='cuboid.stp')
     geo.start()
     geo.export_csg()
 
@@ -43,7 +44,6 @@ The following example shows a usage with every attributes specified.
         debug=False,
         compSolids=True,
         simplify="no",
-        cellRange=[],
         exportSolids="",
         minVoidSize=200.0,
         maxSurf=50,
@@ -90,13 +90,17 @@ The following example shows a usage with every attributes specified.
     )
 
     geo = geouned.CadToCsg(
-        stepFile="cuboid.stp",
         options=my_options,
         settings=my_settings,
         tolerances=my_tolerances,
         numeric_format=my_numeric_format,
     )
 
+    geo.load_step_file(
+        filename="cuboid.stp",
+        skip_solids=[],
+    )
+
     geo.start()
 
     geo.export_csg(

docs/usage/python_cli_usage.rst

@@ -12,7 +12,9 @@ First create a JSON file called "config.json" containing the following.
 .. code-block:: json
 
     {
-        "stepFile": "cuboid.stp"
+        "load_step_file": {
+            "filename":"cuboid.stp"
+        }
     }
 
 Then execute the command line interface tool to convert your STEP file to CSG files with the default configuration.
@@ -32,7 +34,10 @@ Here is a complete JSON file specification
 .. code-block:: json
 
     {
-        "stepFile": "cuboid.stp",
+        "load_step_file": {
+            "filename": "cuboid.stp",
+            "skip_solids": []
+        },
         "Options": {
             "forceCylinder": false,
             "newSplitPlane": true,
@@ -85,7 +90,6 @@ Here is a complete JSON file specification
             "debug": false,
             "compSolids": true,
             "simplify": "no",
-            "cellRange": [],
             "exportSolids": "",
             "minVoidSize": 200.0,
             "maxSurf": 50,

src/geouned/GEOUNED/core.py

@@ -32,8 +32,6 @@ class CadToCsg:
     """Base class for the conversion of CAD to CSG models
 
     Args:
-        stepFile (str, optional): Name of the CAD file (in STEP format) to
-            be converted. Defaults to "".
         options (geouned.Options, optional): An instance of a geouned.Options
             class with the attributes set for the desired conversion. Defaults
             to a geouned.Options with default attributes values.
@@ -53,14 +51,12 @@ class with the attributes set for the desired conversion. Defaults
 
     def __init__(
         self,
-        stepFile: str = "",
         options: Options = Options(),
         tolerances: Tolerances = Tolerances(),
         numeric_format: NumericFormat = NumericFormat(),
         settings: Settings = Settings(),
     ):
 
-        self.stepFile = stepFile
         self.options = options
         self.tolerances = tolerances
         self.numeric_format = numeric_format
@@ -69,16 +65,8 @@ def __init__(
         # define later when running the code
         self.geometry_bounding_box = None
         self.meta_list = []
-
-    @property
-    def stepFile(self):
-        return self._stepFile
-
-    @stepFile.setter
-    def stepFile(self, value: str):
-        if not isinstance(value, str):
-            raise TypeError(f"geouned.CadToCsg.stepFile should be a str, not a {type(value)}")
-        self._stepFile = value
+        self.filename = None
+        self.skip_solids = []
 
     @property
     def options(self):
@@ -209,20 +197,23 @@ def export_csg(
             volCARD=volCARD,
             UCARD=UCARD,
             dummyMat=dummyMat,
-            stepFile=self.stepFile,
+            step_filename=self.filename,
         )
 
         logger.info("End of Monte Carlo code translation phase")
 
     @classmethod
     def from_json(cls, filename: str):
-        """Creates a CadToCsg instance and returns the instance. Populating the
-        Options, Tolerance, Settings and NumericFormat attributes from matching
-        key names in the JSON. If export_to_csg key is present then this method
-        also runs .start() and .export_to_csg() on the instance.
+        """Creates a CadToCsg instance, runs CadToCsg.load_Step_file(), runs
+        CadToCsg.start() and returns the instance. Populating the arguments for
+        the methods that are run by looking for keys with the same name as the
+        method in the JSON file. For example CadToCsg.start() accepts arguments
+        for Options, Tolerance, Settings and NumericFormat and can be populated
+        from matching key names in the JSON. If export_to_csg key is present
+        then this method also runs CadToCsg.export_to_csg() on the instance.
 
         Args:
-            filename str: The filename of the config file. Defaults to "config.json".
+            filename str: The filename of the config file.
 
         Raises:
             FileNotFoundError: If the config file is not found
@@ -238,10 +229,13 @@ def from_json(cls, filename: str):
         with open(filename) as f:
             config = json.load(f)
 
-        cad_to_csg = cls(stepFile=config["stepFile"])
+        cad_to_csg = cls()
+
+        cad_to_csg.load_step_file(**config["load_step_file"])
+
         for key in config.keys():
 
-            if key in ["stepFile", "export_csg"]:
+            if key in ["load_step_file", "export_csg"]:
                 pass  # these two keys are used before or after this loop
 
             elif key == "Tolerances":
@@ -258,7 +252,7 @@ def from_json(cls, filename: str):
 
             else:
                 raise ValueError(
-                    f"Invalid key '{key}' found in config file {filename}. Acceptable key names are 'stepFile', 'export_csg', 'Settings', 'Parameters', 'Tolerances' and 'NumericFormat'"
+                    f"Invalid key '{key}' found in config file {filename}. Acceptable key names are 'load_step_file', 'export_csg', 'Settings', 'Parameters', 'Tolerances' and 'NumericFormat'"
                 )
 
         cad_to_csg.start()
@@ -446,25 +440,39 @@ def set(self, kwrd, value):
             else:
                 self.__dict__["geometryName"] == value[:-4]
 
-    def _load_step_file(
+    def load_step_file(
         self,
-        filename: str,
-        # TODO consider having discrete indexes (1,5,7) instead of range (1,7) as this offers more flexibility to the user
-        cell_range: typing.Union[None, typing.Tuple[int, int]] = None,
+        filename: typing.Union[str, typing.Sequence[str]],
+        skip_solids: typing.Sequence[int] = [],
     ):
         """
         Load STEP file(s) and extract solid volumes and enclosure volumes.
 
         Args:
             filename (str): The path to the STEP file or a list of paths to multiple STEP files.
-            cell_range (tuple[int, int], optional): A tuple representing the range of solids to select from the original STEP solids. Defaults to None.
+            skip_solids (Sequence[int], optional): A sequence (list or tuple) of indexes of solids to not load for conversion.
 
         Returns:
             tuple: A tuple containing the solid volumes list and enclosure volumes list extracted from the STEP files.
         """
-
         logger.info("Start of step file loading phase")
 
+        if not isinstance(skip_solids, (list, tuple)):
+            raise TypeError(f"skip_solids should be a list, tuple of ints, not a {type(skip_solids)}")
+        for entry in skip_solids:
+            if not isinstance(entry, int):
+                raise TypeError(f"skip_solids should contain only ints, not a {type(entry)}")
+
+        if not isinstance(filename, (str, list, tuple)):
+            raise TypeError(f"filename should be a str or a sequence of str, not a {type(filename)}")
+        if isinstance(filename, (list, tuple)):
+            for entry in filename:
+                if not isinstance(entry, str):
+                    raise TypeError(f"filename should contain only str, not a {type(entry)}")
+
+        self.filename = filename
+        self.skip_solids = skip_solids
+
         if isinstance(filename, (list, tuple)):
             step_files = filename
         else:
@@ -484,9 +492,10 @@ def _load_step_file(
         self.meta_list = join_meta_lists(MetaChunk)
         self.enclosure_list = join_meta_lists(EnclosureChunk)
 
-        # Select a specific solid range from original STEP solids
-        if cell_range:
-            self.meta_list = self.meta_list[cell_range[0] : cell_range[1]]
+        # deleting the solid index in reverse order so the indexes don't change for subsequent deletions
+        for solid_index in sorted(skip_solids, reverse=True):
+            logger.info(f"Removing solid index: {solid_index} from list of {len(self.meta_list)} solids")
+            del self.meta_list[solid_index]
 
         logger.info("End of step file loading phase")
 
@@ -501,7 +510,7 @@ def _export_solids(self, filename: str):
         # export in STEP format solids read from input file
         if self.meta_list == []:
             raise ValueError(
-                "No solids in CadToCsg.meta_list to export. Try loading the STEP file first with CadToCsg._load_step_file"
+                "No solids in CadToCsg.meta_list to export. Try loading the STEP file first with CadToCsg.load_step_file"
             )
         solids = []
         for m in self.meta_list:
@@ -552,9 +561,6 @@ def start(self):
 
         startTime = datetime.now()
 
-        # sets the self.meta_list and self.enclosure_list
-        self._load_step_file(filename=self.stepFile, cell_range=self.settings.cellRange)
-
         if self.settings.exportSolids:
             self._export_solids(filename=self.settings.exportSolids)