Source Code for Module fabmetheus_utilities.geometry.geometry_tools.path

  1  """ 
  2  Path. 
  3   
  4  """ 
  5   
  6  from fabmetheus_utilities.geometry.geometry_tools import dictionary 
  7  from fabmetheus_utilities.geometry.geometry_tools import vertex 
  8  from fabmetheus_utilities.geometry.geometry_utilities.evaluate_elements import setting 
  9  from fabmetheus_utilities.geometry.geometry_utilities import evaluate 
 10  from fabmetheus_utilities.geometry.geometry_utilities import matrix 
 11  from fabmetheus_utilities.vector3 import Vector3 
 12  from fabmetheus_utilities import euclidean 
 13  from fabmetheus_utilities import svg_writer 
 14  from fabmetheus_utilities import xml_simple_reader 
 15  from fabmetheus_utilities import xml_simple_writer 
 16   
 17   
 18  __author__ = 'Enrique Perez (perez_enrique@yahoo.com)' 
 19  __credits__ = 'Art of Illusion <http://www.artofillusion.org/>' 
 20  __date__ = '$Date: 2008/02/05 $' 
 21  __license__ = 'GNU Affero General Public License http://www.gnu.org/licenses/agpl.html' 
 22   
 23   
 24 -def convertXMLElementByPath(geometryOutput, xmlElement): 
 25          'Convert the xml element to a path xml element.' 
 26          createLinkPath(xmlElement) 
 27          xmlElement.xmlObject.vertexes = geometryOutput 
 28          vertex.addGeometryList(geometryOutput, xmlElement) 
 29   
 30 -def convertXMLElement(geometryOutput, xmlElement): 
 31          'Convert the xml element by geometryOutput.' 
 32          if geometryOutput == None: 
 33                  return 
 34          if len(geometryOutput) < 1: 
 35                  return 
 36          if len(geometryOutput) == 1: 
 37                  firstLoop = geometryOutput[0] 
 38                  if firstLoop.__class__ == list: 
 39                          geometryOutput = firstLoop 
 40          firstElement = geometryOutput[0] 
 41          if firstElement.__class__ == list: 
 42                  if len(firstElement) > 1: 
 43                          convertXMLElementRenameByPaths(geometryOutput, xmlElement) 
 44                  else: 
 45                          convertXMLElementByPath(firstElement, xmlElement) 
 46          else: 
 47                  convertXMLElementByPath(geometryOutput, xmlElement) 
 48   
 49 -def convertXMLElementRenameByPaths(geometryOutput, xmlElement): 
 50          'Convert the xml element to a path xml element and add paths.' 
 51          createLinkPath(xmlElement) 
 52          for geometryOutputChild in geometryOutput: 
 53                  pathElement = xml_simple_reader.XMLElement() 
 54                  pathElement.setParentAddToChildNodes(xmlElement) 
 55                  convertXMLElementByPath(geometryOutputChild, pathElement) 
 56   
 57 -def createLinkPath(xmlElement): 
 58          'Create and link a path object.' 
 59          xmlElement.localName = 'path' 
 60          xmlElement.linkObject(Path()) 
 61   
 62 -def processXMLElement(xmlElement): 
 63          'Process the xml element.' 
 64          evaluate.processArchivable(Path, xmlElement) 
 65   
 66   
 67 -class Path(dictionary.Dictionary): 
 68          'A path.' 
 69 -        def __init__(self): 
 70                  'Add empty lists.' 
 71                  dictionary.Dictionary.__init__(self) 
 72                  self.matrix4X4 = matrix.Matrix() 
 73                  self.oldChainTetragrid = None 
 74                  self.transformedPath = None 
 75                  self.vertexes = [] 
 76   
 77 -        def addXMLInnerSection(self, depth, output): 
 78                  'Add the xml section for this object.' 
 79                  if self.matrix4X4 != None: 
 80                          self.matrix4X4.addXML(depth, output) 
 81                  xml_simple_writer.addXMLFromVertexes(depth, output, self.vertexes) 
 82   
 83 -        def getFabricationExtension(self): 
 84                  'Get fabrication extension.' 
 85                  return 'svg' 
 86   
 87 -        def getFabricationText(self, addLayerTemplate): 
 88                  'Get fabrication text.' 
 89                  carving = SVGFabricationCarving(addLayerTemplate, self.xmlElement) 
 90                  carving.setCarveLayerThickness(setting.getSheetThickness(self.xmlElement)) 
 91                  carving.processSVGElement(self.xmlElement.getRoot().parser.fileName) 
 92                  return str(carving) 
 93   
 94 -        def getMatrix4X4(self): 
 95                  "Get the matrix4X4." 
 96                  return self.matrix4X4 
 97   
 98 -        def getMatrixChainTetragrid(self): 
 99                  'Get the matrix chain tetragrid.' 
100                  return matrix.getTetragridTimesOther(self.xmlElement.parentNode.xmlObject.getMatrixChainTetragrid(), self.matrix4X4.tetragrid) 
101   
102 -        def getPaths(self): 
103                  'Get all paths.' 
104                  self.transformedPath = None 
105                  if len(self.vertexes) > 0: 
106                          return dictionary.getAllPaths([self.vertexes], self) 
107                  return dictionary.getAllPaths([], self) 
108   
109 -        def getTransformedPaths(self): 
110                  'Get all transformed paths.' 
111                  if self.xmlElement == None: 
112                          return dictionary.getAllPaths([self.vertexes], self) 
113                  chainTetragrid = self.getMatrixChainTetragrid() 
114                  if self.oldChainTetragrid != chainTetragrid: 
115                          self.oldChainTetragrid = chainTetragrid 
116                          self.transformedPath = None 
117                  if self.transformedPath == None: 
118                          self.transformedPath = matrix.getTransformedVector3s(chainTetragrid, self.vertexes) 
119                  if len(self.transformedPath) > 0: 
120                          return dictionary.getAllTransformedPaths([self.transformedPath], self) 
121                  return dictionary.getAllTransformedPaths([], self) 
122   
123   
124 -class SVGFabricationCarving: 
125          'An svg carving.' 
126 -        def __init__(self, addLayerTemplate, xmlElement): 
127                  'Add empty lists.' 
128                  self.addLayerTemplate = addLayerTemplate 
129                  self.layerThickness = 1.0 
130                  self.rotatedLoopLayers = [] 
131                  self.xmlElement = xmlElement 
132   
133 -        def __repr__(self): 
134                  'Get the string representation of this carving.' 
135                  return self.getCarvedSVG() 
136   
137 -        def addXML(self, depth, output): 
138                  'Add xml for this object.' 
139                  xml_simple_writer.addXMLFromObjects(depth, self.rotatedLoopLayers, output) 
140   
141 -        def getCarveCornerMaximum(self): 
142                  'Get the corner maximum of the vertexes.' 
143                  return self.cornerMaximum 
144   
145 -        def getCarveCornerMinimum(self): 
146                  'Get the corner minimum of the vertexes.' 
147                  return self.cornerMinimum 
148   
149 -        def getCarvedSVG(self): 
150                  'Get the carved svg text.' 
151                  return svg_writer.getSVGByLoopLayers(self.addLayerTemplate, self, self.rotatedLoopLayers) 
152   
153 -        def getCarveLayerThickness(self): 
154                  'Get the layer thickness.' 
155                  return self.layerThickness 
156   
157 -        def getCarveRotatedBoundaryLayers(self): 
158                  'Get the rotated boundary layers.' 
159                  return self.rotatedLoopLayers 
160   
161 -        def getFabmetheusXML(self): 
162                  'Return the fabmetheus XML.' 
163                  return self.xmlElement.getParser().getOriginalRoot() 
164   
165 -        def getInterpretationSuffix(self): 
166                  'Return the suffix for a carving.' 
167                  return 'svg' 
168   
169 -        def processSVGElement(self, fileName): 
170                  'Parse SVG element and store the layers.' 
171                  self.fileName = fileName 
172                  paths = self.xmlElement.xmlObject.getPaths() 
173                  oldZ = None 
174                  self.rotatedLoopLayers = [] 
175                  rotatedLoopLayer = None 
176                  for path in paths: 
177                          if len(path) > 0: 
178                                  z = path[0].z 
179                                  if z != oldZ: 
180                                          rotatedLoopLayer = euclidean.RotatedLoopLayer(z) 
181                                          self.rotatedLoopLayers.append(rotatedLoopLayer) 
182                                          oldZ = z 
183                                  rotatedLoopLayer.loops.append(euclidean.getComplexPath(path)) 
184                  if len(self.rotatedLoopLayers) < 1: 
185                          return 
186                  self.cornerMaximum = Vector3(-987654321.0, -987654321.0, -987654321.0) 
187                  self.cornerMinimum = Vector3(987654321.0, 987654321.0, 987654321.0) 
188                  svg_writer.setSVGCarvingCorners(self.cornerMaximum, self.cornerMinimum, self.layerThickness, self.rotatedLoopLayers) 
189   
190 -        def setCarveInfillInDirectionOfBridge( self, infillInDirectionOfBridge ): 
191                  'Set the infill in direction of bridge.' 
192                  pass 
193   
194 -        def setCarveLayerThickness( self, layerThickness ): 
195                  'Set the layer thickness.' 
196                  self.layerThickness = layerThickness 
197   
198 -        def setCarveImportRadius( self, importRadius ): 
199                  'Set the import radius.' 
200                  pass 
201   
202 -        def setCarveIsCorrectMesh( self, isCorrectMesh ): 
203                  'Set the is correct mesh flag.' 
204                  pass 
205