Cura/slice/cura_sf/fabmetheus_utilities/geometry/geometry_tools/path.py

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