symcad.core.CAD.ModeledCad

  1#!/usr/bin/env python3
  2# Copyright (C) 2022, Will Hedgecock
  3#
  4# This program is free software: you can redistribute it and/or modify
  5# it under the terms of the GNU General Public License as published by
  6# the Free Software Foundation, either version 3 of the License, or
  7# (at your option) any later version.
  8#
  9# This program is distributed in the hope that it will be useful,
 10# but WITHOUT ANY WARRANTY; without even the implied warranty of
 11# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12# GNU General Public License for more details.
 13#
 14# You should have received a copy of the GNU General Public License
 15# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 16
 17from __future__ import annotations
 18from typing import Dict, Literal, Optional, Tuple
 19from PyFreeCAD.FreeCAD import FreeCAD, Mesh, Part
 20from .CadGeneral import is_symbolic
 21from . import CadGeneral
 22from pathlib import Path
 23
 24TESSELATION_VALUE = 1.0
 25
 26class ModeledCad(object):
 27   """Private helper class to connect a `SymPart` to an existing CAD representation."""
 28
 29   # Public attributes ----------------------------------------------------------------------------
 30
 31   cad_file_path: str
 32   """Absolute path of the representative CAD model for a given `SymPart`."""
 33
 34
 35   # Constructor ----------------------------------------------------------------------------------
 36
 37   def __init__(self, cad_file_name: str) -> None:
 38      """Initializes a `ModeledCad` object, where `cad_file_name` indicates a representative
 39      CAD model for a `SymPart` relative to the `src/cad` directory.
 40      """
 41      self._store_absolute_cad_file_path(cad_file_name)
 42
 43
 44   # Built-in method implementations --------------------------------------------------------------
 45
 46   def __eq__(self, other: ModeledCad) -> bool:
 47      return self.cad_file_path == other.cad_file_path
 48
 49
 50   # Private helper methods -----------------------------------------------------------------------
 51
 52   def _store_absolute_cad_file_path(self, cad_file_name: str) -> None:
 53      """Determines and stores the full absolute path to the specified `cad_file_name`, converting
 54      a non-native model into the FreeCAD format if necessary.
 55
 56      Parameters
 57      ----------
 58      cad_file_name : `str`
 59         Name of the representative CAD file model relative to this project's `src/cad` directory.
 60      """
 61
 62      # Create an internal FreeCAD file if importing from another format
 63      file_extension = Path(cad_file_name).suffix.casefold()
 64      if file_extension != '.fcstd':
 65
 66         # Update the target CAD file paths
 67         file_path = Path(cad_file_name).absolute().resolve()
 68         cad_file_name = Path('converted').joinpath(Path(cad_file_name).stem + '.FCStd')
 69         cad_file_path = CadGeneral.CAD_BASE_PATH.joinpath(cad_file_name)
 70         if not cad_file_path.exists():
 71
 72            # Determine the type of file to import
 73            if (file_extension == '.stp') or (file_extension == '.step'):
 74               doc = FreeCAD.newDocument(cad_file_path.stem)
 75               model = doc.addObject(CadGeneral.PART_FEATURE_STRING, 'Model')
 76               shape = Part.Shape()
 77               shape.read(str(file_path))
 78               model.Shape = shape
 79               doc.saveAs(str(cad_file_path))
 80               FreeCAD.closeDocument(doc.Name)
 81
 82            elif file_extension == '.stl':
 83               doc = FreeCAD.newDocument(cad_file_path.stem)
 84               model = doc.addObject('Mesh::Feature', 'Model')
 85               model.Mesh = Mesh.Mesh(str(file_path))
 86               doc.saveAs(str(cad_file_path))
 87               FreeCAD.closeDocument(doc.Name)
 88
 89            else:
 90               raise NotImplementedError('CAD files of type {} are not yet supported!'
 91                                          .format(file_extension))
 92
 93      # Store the absolute CAD file path
 94      self.cad_file_path = \
 95            str(CadGeneral.CAD_BASE_PATH.joinpath(cad_file_name).absolute().resolve()) \
 96               if not Path(cad_file_name).is_absolute() else \
 97            cad_file_name
 98
 99
100   # Public methods -------------------------------------------------------------------------------
101
102   def add_to_assembly(self, model_name: str,
103                             assembly: FreeCAD.Document,
104                             concrete_parameters: Dict[str, float],
105                             placement_point: Tuple[float, float, float],
106                             placement_m: Tuple[float, float, float],
107                             yaw_pitch_roll_deg: Tuple[float, float, float],
108                             fully_displace: Optional[bool] = False) -> None:
109      """Adds a CAD model representation of the `SymPart` to the specified assembly.
110
111      Parameters
112      ----------
113      model_name : `str`
114         Desired name for the CAD model.
115      assembly : `FreeCAD.Document`
116         FreeCAD assembly document to which the CAD model should be added.
117      concrete_parameters : `Dict[str, float]`
118         Dictionary of free variables along with their desired concrete values.
119      placement_point : `Tuple[float, float, float]`
120         Local coordinate (in percent length) to be used for the center of rotation and placement
121         of the CAD model.
122      placement_m : `Tuple[float, float, float]`
123         Global xyz-placement (in `m`) of the `placement_point` of the CAD object in the assembly.
124      yaw_pitch_roll_deg : `Tuple[float, float, float]`
125         Global yaw-, pitch-, and roll-orientation in degrees of the CAD object.
126      fully_displace : `bool`
127         Whether to create a fully solid CAD model for displacement purposes.
128      """
129
130      # Verify that all parameters have concrete representations
131      if is_symbolic(yaw_pitch_roll_deg[0]) or is_symbolic(yaw_pitch_roll_deg[1]) or \
132                                               is_symbolic(yaw_pitch_roll_deg[2]):
133         raise RuntimeError('The orientation of the part ("{}") must not be symbolic to add it '
134                            'to a CAD assembly'.format(yaw_pitch_roll_deg))
135      for key, val in concrete_parameters.items():
136         if key != 'name' and is_symbolic(val):
137            raise RuntimeError('The geometric parameter "{}" of the part must not be symbolic to '
138                               'add it to a CAD assembly'.format(key))
139
140      # Concretize the CAD model if it is parametric
141      doc = FreeCAD.open(self.cad_file_path)
142      CadGeneral.assign_free_parameter_values(self.cad_file_path, doc, concrete_parameters)
143
144      # Determine if the SymPart contains a separate displacement model
145      if fully_displace and len(doc.getObjectsByLabel('DisplacedModel')) > 0:
146         model = doc.getObjectsByLabel('DisplacedModel')[0]
147      else:
148         model = doc.getObjectsByLabel('Model')[0]
149
150      # Parse the CAD model as a solid if it is currently a mesh
151      if hasattr(model, 'Mesh'):
152         shape = Part.Shape()
153         shape.makeShapeFromMesh(model.Mesh.Topology, 0.1)
154         model = doc.addObject(CadGeneral.PART_FEATURE_STRING, 'Model')
155         model.Shape = Part.Solid(shape)
156
157      # Create and add a new CAD model to the assembly
158      cad_object = assembly.addObject(CadGeneral.PART_FEATURE_STRING, model_name)
159      cad_object.Shape = Part.getShape(model, '', needSubElement=False, refine=False)
160      cad_object.Shape.tessellate(TESSELATION_VALUE)
161      assembly.recompute()
162
163      # Properly place and orient the CAD model in the assembly
164      rotation_point = CadGeneral.compute_placement_point(model.Shape, placement_point)
165      placement = FreeCAD.Vector((1000.0 * placement_m[0]) - rotation_point.x,
166                                 (1000.0 * placement_m[1]) - rotation_point.y,
167                                 (1000.0 * placement_m[2]) - rotation_point.z)
168      rotation = FreeCAD.Rotation(*yaw_pitch_roll_deg)
169      cad_object.Placement = FreeCAD.Placement(placement, rotation, rotation_point)
170      cad_object.Shape.tessellate(TESSELATION_VALUE)
171      assembly.recompute()
172      FreeCAD.closeDocument(doc.Name)
173
174
175   def get_physical_properties(self, concrete_parameters: Dict[str, float],
176                                     placement_point: Tuple[float, float, float],
177                                     yaw_pitch_roll_deg: Tuple[float, float, float],
178                                     material_density_kg_m3: float,
179                                     normalize_origin: bool) -> Dict[str, float]:
180      """Returns all physical properties of the CAD model.
181
182      Mass properties will be computed assuming a uniform material density as specified in
183      the `material_density_kg_m3` parameter.
184
185      All free parameters within the CAD model must be concretized by passing in an appropriate
186      `concrete_parameters` dictionary containing the names of the free parameters as its keys,
187      along with their corresponding concrete floating-point values.
188
189      Parameters
190      ----------
191      concrete_parameters : `Dict[str, float]`
192         Dictionary of free variables along with their desired concrete values.
193      placement_point : `Tuple[float, float, float]`
194         Local coordinate (in percent length) to be used for the center of placement
195         of the CAD model.
196      yaw_pitch_roll_deg : `Tuple[float, float, float]`
197         Global yaw-, pitch-, and roll-orientation in degrees of the CAD object.
198      material_density_kg_m3 : `float`
199         Uniform material density to be used in mass property calculations (in `kg/m^3`).
200      normalize_origin : `bool`
201         Return physical properties with respect to the front, left, bottom corner of the
202         underlying CAD model.
203
204      Returns
205      -------
206      `Dict[str, float]`
207         A dictionary containing all physical `SymPart` properties as computed using the
208         underlying CAD model.
209      """
210
211      # Verify that all parameters have concrete representations
212      if is_symbolic(yaw_pitch_roll_deg[0]) or is_symbolic(yaw_pitch_roll_deg[1]) or \
213                                               is_symbolic(yaw_pitch_roll_deg[2]):
214         raise RuntimeError('The orientation of the part ("{}") must not be symbolic to calculate '
215                            'its physical properties from CAD'.format(yaw_pitch_roll_deg))
216      for key, val in concrete_parameters.items():
217         if key != 'name' and is_symbolic(val):
218            raise RuntimeError('The geometric parameter "{}" of the part must not be symbolic to '
219                               'calculate its physical properties from CAD'.format(key))
220      placement_point = [0.0 if is_symbolic(p) else float(p) for p in placement_point]
221
222      # Concretize the CAD model if it is parametric
223      doc = FreeCAD.open(self.cad_file_path)
224      CadGeneral.assign_free_parameter_values(self.cad_file_path, doc, concrete_parameters)
225
226      # Recompute and parse the CAD model as a solid
227      if hasattr(doc.getObjectsByLabel('Model')[0], 'Mesh'):
228         shape = Part.Shape()
229         shape.makeShapeFromMesh(doc.getObjectsByLabel('Model')[0].Mesh.Topology, 0.1)
230         model = doc.addObject(CadGeneral.PART_FEATURE_STRING, 'Model')
231         model.Shape = Part.Solid(shape)
232      else:
233         model = doc.getObjectsByLabel('Model')[0]
234
235      # Orient and tessellate the model
236      rotation_point = CadGeneral.compute_placement_point(model.Shape, placement_point)
237      placement = FreeCAD.Vector(-rotation_point.x, -rotation_point.y, -rotation_point.z)
238      rotation = FreeCAD.Rotation(*yaw_pitch_roll_deg)
239      model.Placement = FreeCAD.Placement(placement, rotation, rotation_point)
240      model.Shape.tessellate(TESSELATION_VALUE)
241      doc.recompute()
242
243      # Determine if the SymPart contains a separate displacement model
244      if len(doc.getObjectsByLabel('DisplacedModel')) > 0:
245         displaced_model = doc.getObjectsByLabel('DisplacedModel')[0]
246         displaced_model.Placement = FreeCAD.Placement(placement, rotation, rotation_point)
247         displaced_model.Shape.tessellate(TESSELATION_VALUE)
248         doc.recompute()
249         displaced_model = displaced_model.Shape
250      else:
251         displaced_model = model.Shape
252      model = model.Shape
253
254      # Retrieve all physical model properties
255      properties = CadGeneral.fetch_model_physical_properties(model,
256                                                              displaced_model,
257                                                              material_density_kg_m3,
258                                                              normalize_origin)
259      FreeCAD.closeDocument(doc.Name)
260      return properties
261
262
263   def export_model(self, file_save_path: str,
264                          model_type: Literal['freecad', 'step', 'stl'],
265                          concrete_parameters: Dict[str, float],
266                          placement_point: Tuple[float, float, float],
267                          yaw_pitch_roll_deg: Tuple[float, float, float]) -> None:
268      """Creates a CAD model of the `SymPart` in the specified format.
269
270      Parameters
271      ----------
272      file_save_path : `str`
273         Output file path at which to store the generated CAD model.
274      model_type : {'freecad', 'step', 'stl'}
275         Format of the CAD model to export.
276      concrete_parameters : `Dict[str, float]`
277         Dictionary of free variables along with their desired concrete values.
278      placement_point : `Tuple[float, float, float]`
279         Local coordinate (in percent length) to be used for the center of placement
280         of the CAD model.
281      yaw_pitch_roll_deg : `Tuple[float, float, float]`
282         Global yaw-, pitch-, and roll-orientation in degrees of the CAD object.
283      """
284
285      # Verify that all parameters have concrete representations
286      if is_symbolic(yaw_pitch_roll_deg[0]) or is_symbolic(yaw_pitch_roll_deg[1]) or \
287                                               is_symbolic(yaw_pitch_roll_deg[2]):
288         raise RuntimeError('The orientation of the part ("{}") must not be symbolic to export '
289                            'it as a CAD model'.format(yaw_pitch_roll_deg))
290      for key, val in concrete_parameters.items():
291         if key != 'name' and is_symbolic(val):
292            raise RuntimeError('The geometric parameter "{}" of the part must not be symbolic to '
293                               'export it as a CAD model'.format(key))
294      placement_point = [0.0 if is_symbolic(p) else float(p) for p in placement_point]
295
296      # Create any necessary path directories
297      file_path = Path(file_save_path).absolute().resolve()
298      if not file_path.parent.exists():
299         file_path.parent.mkdir()
300
301      # Concretize the CAD model if it is parametric
302      doc = FreeCAD.open(self.cad_file_path)
303      CadGeneral.assign_free_parameter_values(self.cad_file_path, doc, concrete_parameters)
304
305      # Orient and tessellate the model
306      model = doc.getObjectsByLabel('Model')[0]
307      model.Shape.tessellate(TESSELATION_VALUE)
308      rotation_point = CadGeneral.compute_placement_point(model.Shape, placement_point)
309      placement = FreeCAD.Vector(-rotation_point.x, -rotation_point.y, -rotation_point.z)
310      rotation = FreeCAD.Rotation(*yaw_pitch_roll_deg)
311      model.Placement = FreeCAD.Placement(placement, rotation, rotation_point)
312      model.Shape.tessellate(TESSELATION_VALUE)
313      doc.recompute()
314
315      # Create the requested CAD format of the model
316      doc_clean = FreeCAD.newDocument('Clean')
317      clean_model = doc_clean.addObject('Part::Feature', 'Model')
318      clean_model.Shape = model.Shape.removeSplitter()
319      doc_clean.recompute()
320      CadGeneral.save_model(file_path, model_type, clean_model)
321      FreeCAD.closeDocument(doc_clean.Name)
322      FreeCAD.closeDocument(doc.Name)