def getArcPath(xmlElement):
"Get the arc path.rx ry x-axis-rotation large-arc-flag sweep-flag"
begin = xmlElement.getPreviousVertex(Vector3())
end = evaluate.getVector3FromXMLElement(xmlElement)
largeArcFlag = evaluate.getEvaluatedBooleanDefault(True, 'largeArcFlag',
xmlElement)
radius = lineation.getComplexByPrefix('radius', complex(1.0, 1.0),
xmlElement)
sweepFlag = evaluate.getEvaluatedBooleanDefault(True, 'sweepFlag',
xmlElement)
xAxisRotation = math.radians(
evaluate.getEvaluatedFloatDefault(0.0, 'xAxisRotation', xmlElement))
arcComplexes = svg_reader.getArcComplexes(begin.dropAxis(), end.dropAxis(),
largeArcFlag, radius, sweepFlag,
xAxisRotation)
path = []
if len(arcComplexes) < 1:
return []
incrementZ = (end.z - begin.z) / float(len(arcComplexes))
z = begin.z
for pointIndex in xrange(len(arcComplexes)):
pointComplex = arcComplexes[pointIndex]
z += incrementZ
path.append(Vector3(pointComplex.real, pointComplex.imag, z))
if len(path) > 0:
path[-1] = end
return path
def processXMLElement(xmlElement):
'Process the xml element.'
fileName = evaluate.getEvaluatedValue('file', xmlElement)
if fileName == None:
return
parserFileName = xmlElement.getRoot().parser.fileName
absoluteFileName = archive.getAbsoluteFolderPath(parserFileName, fileName)
absoluteFileName = os.path.abspath(absoluteFileName)
if 'models/' not in absoluteFileName:
print(
'Warning, models/ was not in the absolute file path, so for security nothing will be done for:'
)
print(xmlElement)
print('For which the absolute file path is:')
print(absoluteFileName)
print(
'The import tool can only read a file which has models/ in the file path.'
)
print(
'To import the file, move the file into a folder called model/ or a subfolder which is inside the model folder tree.'
)
return
xmlText = ''
if fileName.endswith('.xml'):
xmlText = archive.getFileText(absoluteFileName)
else:
xmlText = getXMLFromCarvingFileName(absoluteFileName)
print('The import tool is opening the file:')
print(absoluteFileName)
if xmlText == '':
print(
'The file %s could not be found by processXMLElement in import.' %
fileName)
return
if '_importName' in xmlElement.attributeDictionary:
xmlElement.importName = xmlElement.attributeDictionary['_importName']
else:
xmlElement.importName = archive.getUntilDot(fileName)
if evaluate.getEvaluatedBooleanDefault(True, 'basename', xmlElement):
xmlElement.importName = os.path.basename(xmlElement.importName)
xmlElement.attributeDictionary['_importName'] = xmlElement.importName
importXMLElement = xml_simple_reader.XMLElement()
xml_simple_reader.XMLSimpleReader(parserFileName, importXMLElement,
xmlText)
for child in importXMLElement.children:
child.copyXMLChildren('', xmlElement)
euclidean.removeElementsFromDictionary(child.attributeDictionary,
['id', 'name'])
xmlElement.attributeDictionary.update(child.attributeDictionary)
if evaluate.getEvaluatedBooleanDefault(False, 'overwriteRoot',
xmlElement):
xmlElement.getRoot().attributeDictionary.update(
child.attributeDictionary)
group.processShape(group.Group, xmlElement)
def getManipulatedPaths(close, loop, prefix, sideLength, xmlElement):
"Get path with overhangs removed or filled in."
if len(loop) < 3:
return [loop]
if not evaluate.getEvaluatedBooleanDefault(True, prefix + 'activate',
xmlElement):
return [loop]
overhangAngle = evaluate.getOverhangSupportAngle(xmlElement)
overhangPlaneAngle = euclidean.getWiddershinsUnitPolar(0.5 * math.pi -
overhangAngle)
overhangVerticalAngle = math.radians(
evaluate.getEvaluatedFloatDefault(0.0, prefix + 'inclination',
xmlElement))
if overhangVerticalAngle != 0.0:
overhangVerticalCosine = abs(math.cos(overhangVerticalAngle))
if overhangVerticalCosine == 0.0:
return [loop]
imaginaryTimesCosine = overhangPlaneAngle.imag * overhangVerticalCosine
overhangPlaneAngle = euclidean.getNormalized(
complex(overhangPlaneAngle.real, imaginaryTimesCosine))
alongAway = AlongAway(loop, overhangPlaneAngle)
if euclidean.getIsWiddershinsByVector3(loop):
alterWiddershinsSupportedPath(alongAway, close)
else:
alterClockwiseSupportedPath(alongAway, xmlElement)
return [
euclidean.getLoopWithoutCloseSequentialPoints(close, alongAway.loop)
]
def writeXMLElement(fileNames, target, xmlElement):
"Write target."
object = target.object
if object == None:
print('Warning, writeTarget in write could not get object for:')
print(xmlElement)
return
fileNameRoot = evaluate.getEvaluatedStringDefault('', 'name', target)
fileNameRoot = evaluate.getEvaluatedStringDefault(fileNameRoot, 'id', target)
fileNameRoot = evaluate.getEvaluatedStringDefault(fileNameRoot, 'file', xmlElement)
fileNameRoot += evaluate.getEvaluatedStringDefault('', 'suffix', xmlElement)
extension = evaluate.getEvaluatedStringDefault(object.getFabricationExtension(), 'extension', xmlElement)
fileName = '%s.%s' % (fileNameRoot, extension)
suffixIndex = 1
while fileName in fileNames:
fileName = '%s_%s.%s' % (fileNameRoot, suffixIndex, extension)
suffixIndex += 1
folderName = evaluate.getEvaluatedStringDefault('', 'folder', xmlElement)
absoluteFolderDirectory = os.path.join(os.path.dirname(xmlElement.getRoot().parser.fileName), folderName)
absoluteFileName = os.path.abspath(os.path.join(absoluteFolderDirectory, fileName))
if 'models/' not in absoluteFileName:
print('Warning, models/ was not in the absolute file path, so for security nothing will be done for:')
print(xmlElement)
print('For which the absolute file path is:')
print(absoluteFileName)
print('The write tool can only write a file which has models/ in the file path.')
print('To write the file, move the file into a folder called model/ or a subfolder which is inside the model folder tree.')
return
fileNames.append(fileName)
archive.makeDirectory(absoluteFolderDirectory)
if not evaluate.getEvaluatedBooleanDefault(True, 'writeMatrix', xmlElement):
object.matrix4X4 = matrix.Matrix()
print('The write tool generated the file:')
print(absoluteFileName)
archive.writeFileText(absoluteFileName, object.getFabricationText())
def processXMLElementByGeometry(geometryOutput, xmlElement): "Process the xml element by geometryOutput." if geometryOutput == None: return geometryOutput = evaluate.getVector3ListsRecursively(geometryOutput) if 'target' in xmlElement.attributeDictionary and not evaluate.getEvaluatedBooleanDefault(False, 'copy', xmlElement): target = evaluate.getEvaluatedLinkValue(str(xmlElement.attributeDictionary['target']).strip(), xmlElement) if target.__class__.__name__ == 'XMLElement': target.removeChildrenFromIDNameParent() xmlElement = target if xmlElement.object != None: if xmlElement.parent.object != None: if xmlElement.object in xmlElement.parent.object.archivableObjects: xmlElement.parent.object.archivableObjects.remove(xmlElement.object) firstElement = None if len(geometryOutput) > 0: firstElement = geometryOutput[0] if firstElement.__class__ == list: if len(firstElement) > 1: path.convertXMLElementRenameByPaths(geometryOutput, xmlElement) else: path.convertXMLElementRename(firstElement, xmlElement) else: path.convertXMLElementRename(geometryOutput, xmlElement) path.processXMLElement(xmlElement)
def processXMLElementByGeometry(geometryOutput, xmlElement):
"Process the xml element by geometryOutput."
if geometryOutput == None:
return
geometryOutput = evaluate.getVector3ListsRecursively(geometryOutput)
if 'target' in xmlElement.attributeDictionary and not evaluate.getEvaluatedBooleanDefault(
False, 'copy', xmlElement):
target = evaluate.getEvaluatedLinkValue(
str(xmlElement.attributeDictionary['target']).strip(), xmlElement)
if target.__class__.__name__ == 'XMLElement':
target.removeChildrenFromIDNameParent()
xmlElement = target
if xmlElement.object != None:
if xmlElement.parent.object != None:
if xmlElement.object in xmlElement.parent.object.archivableObjects:
xmlElement.parent.object.archivableObjects.remove(
xmlElement.object)
firstElement = None
if len(geometryOutput) > 0:
firstElement = geometryOutput[0]
if firstElement.__class__ == list:
if len(firstElement) > 1:
path.convertXMLElementRenameByPaths(geometryOutput, xmlElement)
else:
path.convertXMLElementRename(firstElement, xmlElement)
else:
path.convertXMLElementRename(geometryOutput, xmlElement)
path.processXMLElement(xmlElement)
def setToXMLElement(self, xmlElement):
"Set to the xmlElement."
self.inradius = lineation.getComplexByPrefixes(
['demisize', 'inradius'], self.inradius, xmlElement)
self.inradius = lineation.getComplexByMultiplierPrefix(
2.0, 'size', self.inradius, xmlElement)
self.demiwidth = lineation.getFloatByPrefixBeginEnd(
'demiwidth', 'width', self.inradius.real, xmlElement)
self.demiheight = lineation.getFloatByPrefixBeginEnd(
'demiheight', 'height', self.inradius.imag, xmlElement)
self.packingDensity = evaluate.getEvaluatedFloatByKeys(
self.packingDensity, ['packingDensity', 'density'], xmlElement)
self.radius = lineation.getComplexByPrefixBeginEnd(
'elementRadius', 'elementDiameter', self.radius, xmlElement)
self.radius = lineation.getComplexByPrefixBeginEnd(
'radius', 'diameter', self.radius, xmlElement)
self.seed = evaluate.getEvaluatedIntDefault(self.seed, 'seed',
xmlElement)
if len(self.target) < 1:
self.target = evaluate.getTransformedPathsByKey(
'target', xmlElement)
self.typeString = evaluate.getEvaluatedStringDefault(
self.typeString, 'type', xmlElement)
self.zigzag = evaluate.getEvaluatedBooleanDefault(
self.zigzag, 'zigzag', xmlElement)
def __init__(self, xmlElement):
'Initialize.'
self.interpolationDictionary = {}
self.radius = lineation.getRadiusComplex(complex(), xmlElement)
self.tiltFollow = evaluate.getEvaluatedBooleanDefault(
True, 'tiltFollow', xmlElement)
self.tiltTop = evaluate.getVector3ByPrefix(None, 'tiltTop', xmlElement)
self.maximumUnbuckling = evaluate.getEvaluatedFloatDefault(
5.0, 'maximumUnbuckling', xmlElement)
scalePathDefault = [Vector3(1.0, 1.0, 0.0), Vector3(1.0, 1.0, 1.0)]
self.interpolationDictionary['scale'] = Interpolation().getByPrefixZ(
scalePathDefault, 'scale', xmlElement)
self.target = evaluate.getTransformedPathsByKey([], 'target',
xmlElement)
if self.tiltTop == None:
offsetPathDefault = [Vector3(), Vector3(0.0, 0.0, 1.0)]
self.interpolationDictionary['offset'] = Interpolation(
).getByPrefixZ(offsetPathDefault, '', xmlElement)
tiltPathDefault = [Vector3(), Vector3(0.0, 0.0, 1.0)]
self.interpolationDictionary['tilt'] = Interpolation(
).getByPrefixZ(tiltPathDefault, 'tilt', xmlElement)
for point in self.interpolationDictionary['tilt'].path:
point.x = math.radians(point.x)
point.y = math.radians(point.y)
else:
offsetAlongDefault = [Vector3(), Vector3(1.0, 0.0, 0.0)]
self.interpolationDictionary['offset'] = Interpolation(
).getByPrefixAlong(offsetAlongDefault, '', xmlElement)
self.twist = evaluate.getEvaluatedFloatDefault(0.0, 'twist',
xmlElement)
self.twistPathDefault = [Vector3(), Vector3(1.0, self.twist)]
insertTwistPortions(self, xmlElement)
def getOriginalRoot(self):
'Get the original reparsed root element.'
if evaluate.getEvaluatedBooleanDefault(True, 'getOriginalRoot',
self.root):
return XMLSimpleReader(self.fileName, self.parent,
self.xmlText).root
return None
def setToXMLElement(self, xmlElement):
"Set to the xmlElement."
self.radius = lineation.getRadiusComplex(self.radius, xmlElement)
self.tiltFollow = evaluate.getEvaluatedBooleanDefault(self.tiltFollow, "tiltfollow", xmlElement)
self.tiltTop = evaluate.getVector3ByPrefix("tilttop", self.tiltTop, xmlElement)
self.maximumUnbuckling = evaluate.getEvaluatedFloatDefault(
self.maximumUnbuckling, "maximumUnbuckling", xmlElement
)
self.interpolationDictionary["scale"] = Interpolation().getByPrefixZ(self.scalePathDefault, "scale", xmlElement)
if len(self.target) < 1:
self.target = evaluate.getTransformedPathsByKey("target", xmlElement)
if self.tiltTop == None:
self.interpolationDictionary["offset"] = Interpolation().getByPrefixZ(
self.offsetPathDefault, "", xmlElement
)
self.interpolationDictionary["tilt"] = Interpolation().getByPrefixZ(
self.tiltPathDefault, "tilt", xmlElement
)
for point in self.interpolationDictionary["tilt"].path:
point.x = math.radians(point.x)
point.y = math.radians(point.y)
else:
self.interpolationDictionary["offset"] = Interpolation().getByPrefixAlong(
self.offsetAlongDefault, "", xmlElement
)
self.twist = evaluate.getEvaluatedFloatDefault(self.twist, "twist", xmlElement)
if self.twist != 0.0:
self.twistPathDefault = [Vector3(), Vector3(1.0, self.twist)]
insertTwistPortions(self, xmlElement)
def setToXMLElement(self, xmlElement):
"Set to the xmlElement."
self.radius = lineation.getRadiusComplex(self.radius, xmlElement)
self.tiltFollow = evaluate.getEvaluatedBooleanDefault(
self.tiltFollow, 'tiltfollow', xmlElement)
self.tiltTop = evaluate.getVector3ByPrefix(self.tiltTop, 'tilttop',
xmlElement)
self.maximumUnbuckling = evaluate.getEvaluatedFloatDefault(
self.maximumUnbuckling, 'maximumUnbuckling', xmlElement)
self.interpolationDictionary['scale'] = Interpolation().getByPrefixZ(
self.scalePathDefault, 'scale', xmlElement)
if len(self.target) < 1:
self.target = evaluate.getTransformedPathsByKey(
'target', xmlElement)
if self.tiltTop == None:
self.interpolationDictionary['offset'] = Interpolation(
).getByPrefixZ(self.offsetPathDefault, '', xmlElement)
self.interpolationDictionary['tilt'] = Interpolation(
).getByPrefixZ(self.tiltPathDefault, 'tilt', xmlElement)
for point in self.interpolationDictionary['tilt'].path:
point.x = math.radians(point.x)
point.y = math.radians(point.y)
else:
self.interpolationDictionary['offset'] = Interpolation(
).getByPrefixAlong(self.offsetAlongDefault, '', xmlElement)
self.twist = evaluate.getEvaluatedFloatDefault(self.twist, 'twist',
xmlElement)
if self.twist != 0.0:
self.twistPathDefault = [Vector3(), Vector3(1.0, self.twist)]
insertTwistPortions(self, xmlElement)
def setToXMLElement(self, xmlElement):
"Set to the xmlElement."
self.closed = evaluate.getEvaluatedBooleanDefault(False, 'closed', xmlElement)
self.end = evaluate.getVector3ByPrefix('end', self.end, xmlElement)
self.start = evaluate.getVector3ByPrefix('start', self.start, xmlElement)
self.step = evaluate.getEvaluatedFloatDefault(self.step, 'step', xmlElement)
self.steps = evaluate.getEvaluatedFloatDefault(self.steps, 'steps', xmlElement)
self.typeString = evaluate.getEvaluatedStringDefault(self.typeString, 'type', xmlElement)
def __init__(self, xmlElement):
'Set defaults.'
self.closed = evaluate.getEvaluatedBooleanDefault(False, 'closed', xmlElement)
self.end = evaluate.getVector3ByPrefix(Vector3(), 'end', xmlElement)
self.start = evaluate.getVector3ByPrefix(Vector3(), 'start', xmlElement)
self.step = evaluate.getEvaluatedFloatDefault(None, 'step', xmlElement)
self.steps = evaluate.getEvaluatedFloatDefault(None, 'steps', xmlElement)
self.typeMenuRadioStrings = 'average maximum minimum'.split()
self.typeString = evaluate.getEvaluatedStringDefault('minimum', 'type', xmlElement)
def transformIfFromEvaluatorCreation( path, xmlElement ): "Transform the path if the xmlElement came from a EvaluatorCreation." if not evaluate.getEvaluatedBooleanDefault( False, '_fromEvaluatorCreation', xmlElement ): return xmlElementMatrix = matrix4x4.Matrix4X4().getFromXMLElement( xmlElement ) if xmlElementMatrix.getIsDefault(): return for point in path: point.setToVector3( matrix4x4.getVector3TransformedByMatrix( xmlElementMatrix.matrixTetragrid, point ) )
def getArcPath(xmlElement):
"Get the arc path.rx ry x-axis-rotation large-arc-flag sweep-flag"
begin = xmlElement.getPreviousVertex(Vector3())
end = evaluate.getVector3FromXMLElement(xmlElement)
largeArcFlag = evaluate.getEvaluatedBooleanDefault(True, 'largeArcFlag', xmlElement)
radius = lineation.getComplexByPrefix('radius', complex(1.0, 1.0), xmlElement )
sweepFlag = evaluate.getEvaluatedBooleanDefault(True, 'sweepFlag', xmlElement)
xAxisRotation = math.radians(evaluate.getEvaluatedFloatZero('xAxisRotation', xmlElement ))
arcComplexes = svg_reader.getArcComplexes(begin.dropAxis(), end.dropAxis(), largeArcFlag, radius, sweepFlag, xAxisRotation)
path = []
incrementZ = (end.z - begin.z) / float(len(arcComplexes))
z = begin.z
for pointIndex in xrange(len(arcComplexes)):
pointComplex = arcComplexes[pointIndex]
z += incrementZ
path.append(Vector3(pointComplex.real, pointComplex.imag, z))
if len(path) > 0:
path[-1] = end
return path
def processXMLElement(xmlElement):
'Process the xml element.'
fileName = evaluate.getEvaluatedValue('file', xmlElement )
if fileName == None:
return
parserFileName = xmlElement.getRoot().parser.fileName
absoluteFileName = archive.getAbsoluteFolderPath(parserFileName, fileName)
absoluteFileName = os.path.abspath(absoluteFileName)
if 'models/' not in absoluteFileName:
print('Warning, models/ was not in the absolute file path, so for security nothing will be done for:')
print(xmlElement)
print('For which the absolute file path is:')
print(absoluteFileName)
print('The import tool can only read a file which has models/ in the file path.')
print('To import the file, move the file into a folder called model/ or a subfolder which is inside the model folder tree.')
return
xmlText = ''
if fileName.endswith('.xml'):
xmlText = archive.getFileText(absoluteFileName)
else:
xmlText = getXMLFromCarvingFileName(absoluteFileName)
print('The import tool is opening the file:')
print(absoluteFileName)
if xmlText == '':
print('The file %s could not be found by processXMLElement in import.' % fileName)
return
if '_importName' in xmlElement.attributeDictionary:
xmlElement.importName = xmlElement.attributeDictionary['_importName']
else:
xmlElement.importName = archive.getUntilDot(fileName)
if evaluate.getEvaluatedBooleanDefault(True, 'basename', xmlElement):
xmlElement.importName = os.path.basename(xmlElement.importName)
xmlElement.attributeDictionary['_importName'] = xmlElement.importName
importXMLElement = xml_simple_reader.XMLElement()
xml_simple_reader.XMLSimpleReader(parserFileName, importXMLElement, xmlText)
for child in importXMLElement.children:
child.copyXMLChildren('', xmlElement)
euclidean.removeElementsFromDictionary(child.attributeDictionary, ['id', 'name'])
xmlElement.attributeDictionary.update(child.attributeDictionary)
if evaluate.getEvaluatedBooleanDefault(False, 'overwriteRoot', xmlElement):
xmlElement.getRoot().attributeDictionary.update(child.attributeDictionary)
group.processShape(group.Group, xmlElement)
def getManipulatedPaths(close, loop, prefix, sideLength, xmlElement): "Get path with overhangs removed or filled in." if len(loop) < 2: return [loop] isClosed = evaluate.getEvaluatedBooleanDefault(False, prefix + 'closed', xmlElement) radius = lineation.getStrokeRadiusByPrefix(prefix, xmlElement ) loopComplex = euclidean.getComplexPath(loop) if isClosed: loopComplexes = intercircle.getAroundsFromLoop(loopComplex, radius) else: loopComplexes = intercircle.getAroundsFromPath(loopComplex, radius) return euclidean.getVector3Paths(loopComplexes, loop[0].z)
def getGeometryOutput(xmlElement):
"Get vector3 vertices from attribute dictionary."
paths = evaluate.getPathsByKeys(['crosssection', 'section', 'target'],
xmlElement)
if len(euclidean.getConcatenatedList(paths)) == 0:
print('Warning, in extrude there are no paths.')
print(xmlElement.attributeDictionary)
return None
offsetPathDefault = [Vector3(), Vector3(0.0, 0.0, 1.0)]
extrude = Extrude()
extrude.tiltFollow = evaluate.getEvaluatedBooleanDefault(
extrude.tiltFollow, 'tiltfollow', xmlElement)
extrude.tiltTop = evaluate.getVector3ByPrefix('tilttop', extrude.tiltTop,
xmlElement)
extrude.maximumUnbuckling = evaluate.getEvaluatedFloatDefault(
5.0, 'maximumunbuckling', xmlElement)
scalePathDefault = [Vector3(1.0, 1.0, 0.0), Vector3(1.0, 1.0, 1.0)]
extrude.interpolationDictionary['scale'] = evaluate.Interpolation(
).getByPrefixZ(scalePathDefault, 'scale', xmlElement)
if extrude.tiltTop == None:
extrude.interpolationDictionary['offset'] = evaluate.Interpolation(
).getByPrefixZ(offsetPathDefault, '', xmlElement)
tiltPathDefault = [Vector3(), Vector3(0.0, 0.0, 1.0)]
interpolationTilt = evaluate.Interpolation().getByPrefixZ(
tiltPathDefault, 'tilt', xmlElement)
extrude.interpolationDictionary['tilt'] = interpolationTilt
for point in interpolationTilt.path:
point.x = math.radians(point.x)
point.y = math.radians(point.y)
else:
offsetAlongDefault = [Vector3(), Vector3(1.0, 0.0, 0.0)]
extrude.interpolationDictionary['offset'] = evaluate.Interpolation(
).getByPrefixAlong(offsetAlongDefault, '', xmlElement)
insertTwistPortions(extrude.interpolationDictionary, xmlElement)
segments = evaluate.getEvaluatedIntOne('segments', xmlElement)
negatives = []
positives = []
portionDirections = evaluate.getSpacedPortionDirections(
extrude.interpolationDictionary)
for path in paths:
endMultiplier = None
if not euclidean.getIsWiddershinsByVector3(path):
endMultiplier = 1.000001
geometryOutput = getGeometryOutputByPath(endMultiplier, extrude, path,
portionDirections)
if endMultiplier == None:
positives.append(geometryOutput)
else:
negatives.append(geometryOutput)
positiveOutput = trianglemesh.getUnifiedOutput(positives)
if len(negatives) < 1:
return positiveOutput
return {'difference': [positiveOutput] + negatives}
def getManipulatedPaths(close, loop, prefix, sideLength, xmlElement): "Get path with overhangs removed or filled in." if len(loop) < 2: return [loop] isClosed = evaluate.getEvaluatedBooleanDefault(False, prefix + 'closed', xmlElement) radius = lineation.getStrokeRadiusByPrefix(prefix, xmlElement ) loopComplex = euclidean.getComplexPath(loop) if isClosed: loopComplexes = intercircle.getAroundsFromLoop(loopComplex, radius) else: loopComplexes = intercircle.getAroundsFromPath(loopComplex, radius) return euclidean.getVector3Paths(loopComplexes, loop[0].z)
def __init__(self, xmlElement):
'Set defaults.'
self.closed = evaluate.getEvaluatedBooleanDefault(
False, 'closed', xmlElement)
self.end = evaluate.getVector3ByPrefix(Vector3(), 'end', xmlElement)
self.start = evaluate.getVector3ByPrefix(Vector3(), 'start',
xmlElement)
self.step = evaluate.getEvaluatedFloatDefault(None, 'step', xmlElement)
self.steps = evaluate.getEvaluatedFloatDefault(None, 'steps',
xmlElement)
self.typeMenuRadioStrings = 'average maximum minimum'.split()
self.typeString = evaluate.getEvaluatedStringDefault(
'minimum', 'type', xmlElement)
def setToXMLElement(self, xmlElement):
"Set to the xmlElement."
self.closed = evaluate.getEvaluatedBooleanDefault(
False, 'closed', xmlElement)
self.end = evaluate.getVector3ByPrefix(self.end, 'end', xmlElement)
self.start = evaluate.getVector3ByPrefix(self.start, 'start',
xmlElement)
self.step = evaluate.getEvaluatedFloatDefault(self.step, 'step',
xmlElement)
self.steps = evaluate.getEvaluatedFloatDefault(self.steps, 'steps',
xmlElement)
self.typeString = evaluate.getEvaluatedStringDefault(
self.typeString, 'type', xmlElement)
def __init__(self, xmlElement):
'Set defaults.'
self.inradius = lineation.getComplexByPrefixes(['demisize', 'inradius'], complex(10.0, 10.0), xmlElement)
self.inradius = lineation.getComplexByMultiplierPrefix(2.0, 'size', self.inradius, xmlElement)
self.demiwidth = lineation.getFloatByPrefixBeginEnd('demiwidth', 'width', self.inradius.real, xmlElement)
self.demiheight = lineation.getFloatByPrefixBeginEnd('demiheight', 'height', self.inradius.imag, xmlElement)
self.packingDensity = evaluate.getEvaluatedFloatByKeys(0.2, ['packingDensity', 'density'], xmlElement)
self.radius = lineation.getComplexByPrefixBeginEnd('elementRadius', 'elementDiameter', complex(1.0, 1.0), xmlElement)
self.radius = lineation.getComplexByPrefixBeginEnd('radius', 'diameter', self.radius, xmlElement)
self.seed = evaluate.getEvaluatedIntDefault(None, 'seed', xmlElement)
self.target = evaluate.getTransformedPathsByKey([], 'target', xmlElement)
self.typeMenuRadioStrings = 'hexagonal random rectangular'.split()
self.typeString = evaluate.getEvaluatedStringDefault('rectangular', 'type', xmlElement)
self.zigzag = evaluate.getEvaluatedBooleanDefault(True, 'zigzag', xmlElement)
def setToXMLElement(self, xmlElement):
"Set to the xmlElement."
self.inradius = lineation.getComplexByPrefixes(['demisize', 'inradius'], self.inradius, xmlElement)
self.inradius = lineation.getComplexByMultiplierPrefix(2.0, 'size', self.inradius, xmlElement)
self.demiwidth = lineation.getFloatByPrefixBeginEnd('demiwidth', 'width', self.inradius.real, xmlElement)
self.demiheight = lineation.getFloatByPrefixBeginEnd('demiheight', 'height', self.inradius.imag, xmlElement)
self.packingDensity = evaluate.getEvaluatedFloatByKeys(self.packingDensity, ['packingDensity', 'density'], xmlElement)
self.radius = lineation.getComplexByPrefixBeginEnd('elementRadius', 'elementDiameter', self.radius, xmlElement)
self.radius = lineation.getComplexByPrefixBeginEnd('radius', 'diameter', self.radius, xmlElement)
self.seed = evaluate.getEvaluatedIntDefault(self.seed, 'seed', xmlElement)
if len(self.target) < 1:
self.target = evaluate.getTransformedPathsByKey('target', xmlElement)
self.typeString = evaluate.getEvaluatedStringDefault(self.typeString, 'type', xmlElement)
self.zigzag = evaluate.getEvaluatedBooleanDefault(self.zigzag, 'zigzag', xmlElement)
def getGeometryOutput(xmlElement):
"Get vector3 vertexes from attribute dictionary."
start = evaluate.getVector3ByPrefix('start', Vector3(), xmlElement)
end = evaluate.getVector3ByPrefix('end', Vector3(), xmlElement)
endMinusStart = end - start
endMinusStartLength = abs(endMinusStart)
if endMinusStartLength <= 0.0:
print('Warning, end is the same as start in getGeometryOutput in line for:')
print(start)
print(end)
print(xmlElement)
return None
steps = evaluate.getEvaluatedFloatDefault(None, 'steps', xmlElement)
step = evaluate.getEvaluatedFloatDefault(None, 'step', xmlElement)
xmlElement.attributeDictionary['closed'] = str(evaluate.getEvaluatedBooleanDefault(False, 'closed', xmlElement))
if step == None and steps == None:
return lineation.getGeometryOutputByLoop(lineation.SideLoop([start, end]), xmlElement)
loop = [start]
if step != None and steps != None:
stepVector = step / endMinusStartLength * endMinusStart
end = start + stepVector * steps
return getGeometryOutputByStep(end, loop, steps, stepVector, xmlElement)
if step == None:
stepVector = endMinusStart / steps
return getGeometryOutputByStep(end, loop, steps, stepVector, xmlElement)
typeString = evaluate.getEvaluatedStringDefault('minimum', 'type', xmlElement)
endMinusStartLengthOverStep = endMinusStartLength / step
if typeString == 'average':
steps = max(1.0, round(endMinusStartLengthOverStep))
stepVector = step / endMinusStartLength * endMinusStart
end = start + stepVector * steps
return getGeometryOutputByStep(end, loop, steps, stepVector, xmlElement)
if typeString == 'maximum':
steps = math.ceil(endMinusStartLengthOverStep)
if steps < 1.0:
return lineation.getGeometryOutputByLoop(lineation.SideLoop([start, end]), xmlElement)
stepVector = endMinusStart / steps
return getGeometryOutputByStep(end, loop, steps, stepVector, xmlElement)
if typeString == 'minimum':
steps = math.floor(endMinusStartLengthOverStep)
if steps < 1.0:
return lineation.getGeometryOutputByLoop(lineation.SideLoop(loop), xmlElement)
stepVector = endMinusStart / steps
return getGeometryOutputByStep(end, loop, steps, stepVector, xmlElement)
print('Warning, the step type was not one of (average, maximum or minimum) in getGeometryOutput in line for:')
print(typeString)
print(xmlElement)
loop.append(end)
return lineation.getGeometryOutputByLoop(lineation.SideLoop(loop), xmlElement)
def writeXMLElement(fileNames, target, xmlElement):
"Write target."
object = target.object
if object == None:
print('Warning, writeTarget in write could not get object for:')
print(xmlElement)
return
fileNameRoot = evaluate.getEvaluatedStringDefault('', 'name', target)
fileNameRoot = evaluate.getEvaluatedStringDefault(fileNameRoot, 'id',
target)
fileNameRoot = evaluate.getEvaluatedStringDefault(fileNameRoot, 'file',
xmlElement)
fileNameRoot += evaluate.getEvaluatedStringDefault('', 'suffix',
xmlElement)
extension = evaluate.getEvaluatedStringDefault(
object.getFabricationExtension(), 'extension', xmlElement)
fileName = '%s.%s' % (fileNameRoot, extension)
suffixIndex = 1
while fileName in fileNames:
fileName = '%s_%s.%s' % (fileNameRoot, suffixIndex, extension)
suffixIndex += 1
folderName = evaluate.getEvaluatedStringDefault('', 'folder', xmlElement)
absoluteFolderDirectory = os.path.join(
os.path.dirname(xmlElement.getRoot().parser.fileName), folderName)
absoluteFileName = os.path.abspath(
os.path.join(absoluteFolderDirectory, fileName))
if 'models/' not in absoluteFileName:
print(
'Warning, models/ was not in the absolute file path, so for security nothing will be done for:'
)
print(xmlElement)
print('For which the absolute file path is:')
print(absoluteFileName)
print(
'The write tool can only write a file which has models/ in the file path.'
)
print(
'To write the file, move the file into a folder called model/ or a subfolder which is inside the model folder tree.'
)
return
fileNames.append(fileName)
archive.makeDirectory(absoluteFolderDirectory)
if not evaluate.getEvaluatedBooleanDefault(True, 'writeMatrix',
xmlElement):
object.matrix4X4 = matrix.Matrix()
print('The write tool generated the file:')
print(absoluteFileName)
archive.writeFileText(absoluteFileName, object.getFabricationText())
def setToXMLElement(self, xmlElement):
"Set to the xmlElement."
self.tiltFollow = evaluate.getEvaluatedBooleanDefault(self.tiltFollow, 'tiltfollow', xmlElement)
self.tiltTop = evaluate.getVector3ByPrefix('tilttop', self.tiltTop, xmlElement)
self.maximumUnbuckling = evaluate.getEvaluatedFloatDefault(self.maximumUnbuckling, 'maximumUnbuckling', xmlElement)
self.interpolationDictionary['scale'] = Interpolation().getByPrefixZ(self.scalePathDefault, 'scale', xmlElement)
if self.tiltTop == None:
self.interpolationDictionary['offset'] = Interpolation().getByPrefixZ(self.offsetPathDefault, '', xmlElement)
self.interpolationDictionary['tilt'] = Interpolation().getByPrefixZ(self.tiltPathDefault, 'tilt', xmlElement)
for point in self.interpolationDictionary['tilt'].path:
point.x = math.radians(point.x)
point.y = math.radians(point.y)
else:
self.interpolationDictionary['offset'] = Interpolation().getByPrefixAlong(self.offsetAlongDefault, '', xmlElement)
self.twist = evaluate.getEvaluatedFloatDefault(self.twist, 'twist', xmlElement )
if self.twist != 0.0:
self.twistPathDefault = [Vector3(), Vector3(1.0, self.twist) ]
insertTwistPortions(self, xmlElement)
def getGeometryOutput(xmlElement):
"Get triangle mesh from attribute dictionary."
paths = evaluate.getPathsByKeys( ['crosssection', 'section', 'target'], xmlElement )
if len( euclidean.getConcatenatedList( paths ) ) == 0:
print('Warning, in extrude there are no paths.')
print( xmlElement.attributeDictionary )
return None
offsetPathDefault = [ Vector3(), Vector3( 0.0, 0.0, 1.0 ) ]
extrude = Extrude()
extrude.tiltFollow = evaluate.getEvaluatedBooleanDefault( extrude.tiltFollow, 'tiltfollow', xmlElement )
extrude.tiltTop = evaluate.getVector3ByPrefix('tilttop', extrude.tiltTop, xmlElement )
extrude.maximumUnbuckling = evaluate.getEvaluatedFloatDefault( 5.0, 'maximumunbuckling', xmlElement )
scalePathDefault = [ Vector3( 1.0, 1.0, 0.0 ), Vector3( 1.0, 1.0, 1.0 ) ]
extrude.interpolationDictionary['scale'] = Interpolation().getByPrefixZ( scalePathDefault, 'scale', xmlElement )
if extrude.tiltTop == None:
extrude.interpolationDictionary['offset'] = Interpolation().getByPrefixZ( offsetPathDefault, '', xmlElement )
tiltPathDefault = [ Vector3(), Vector3( 0.0, 0.0, 1.0 ) ]
interpolationTilt = Interpolation().getByPrefixZ( tiltPathDefault, 'tilt', xmlElement )
extrude.interpolationDictionary['tilt'] = interpolationTilt
for point in interpolationTilt.path:
point.x = math.radians( point.x )
point.y = math.radians( point.y )
else:
offsetAlongDefault = [ Vector3(), Vector3( 1.0, 0.0, 0.0 ) ]
extrude.interpolationDictionary['offset'] = Interpolation().getByPrefixAlong( offsetAlongDefault, '', xmlElement )
insertTwistPortions( extrude.interpolationDictionary, xmlElement )
segments = evaluate.getEvaluatedIntOne('segments', xmlElement )
negatives = []
positives = []
portionDirections = getSpacedPortionDirections( extrude.interpolationDictionary )
for path in paths:
endMultiplier = None
if not euclidean.getIsWiddershinsByVector3( path ):
endMultiplier = 1.000001
geometryOutput = getGeometryOutputByPath( endMultiplier, extrude, path, portionDirections )
if endMultiplier == None:
positives.append( geometryOutput )
else:
negatives.append( geometryOutput )
positiveOutput = trianglemesh.getUnifiedOutput( positives )
interpolationOffset = extrude.interpolationDictionary['offset']
if len( negatives ) < 1:
return getGeometryOutputWithConnection( positiveOutput, interpolationOffset, xmlElement )
return getGeometryOutputWithConnection( { 'difference' : [ positiveOutput ] + negatives }, interpolationOffset, xmlElement )
def getManipulatedPaths(close, loop, prefix, sideLength, xmlElement): "Get path with overhangs removed or filled in." if len(loop) < 3: return [loop] if not evaluate.getEvaluatedBooleanDefault( True, prefix + 'activate', xmlElement ): return [loop] overhangAngle = math.radians( xmlElement.getCascadeFloat( 45.0, 'overhang.supportangle') ) overhangPlaneAngle = euclidean.getWiddershinsUnitPolar( 0.5 * math.pi - overhangAngle ) overhangVerticalAngle = math.radians( evaluate.getEvaluatedFloatZero( prefix + 'inclination', xmlElement ) ) if overhangVerticalAngle != 0.0: overhangVerticalCosine = abs( math.cos( overhangVerticalAngle ) ) if overhangVerticalCosine == 0.0: return [loop] imaginaryTimesCosine = overhangPlaneAngle.imag * overhangVerticalCosine overhangPlaneAngle = euclidean.getNormalized( complex( overhangPlaneAngle.real, imaginaryTimesCosine ) ) alongAway = AlongAway( loop, overhangPlaneAngle ) if euclidean.getIsWiddershinsByVector3(loop): alterWiddershinsSupportedPath( alongAway, close ) else: alterClockwiseSupportedPath( alongAway, xmlElement ) return [ euclidean.getLoopWithoutCloseSequentialPoints( close, alongAway.loop ) ]
def getGeometryOutput(xmlElement):
"Get vector3 vertexes from attribute dictionary."
inradius = lineation.getComplexByPrefixes(['demisize', 'inradius'], complex(5.0, 5.0), xmlElement)
inradius = lineation.getComplexByMultiplierPrefix(2.0, 'size', inradius, xmlElement)
demiwidth = lineation.getFloatByPrefixBeginEnd('demiwidth', 'width', inradius.real, xmlElement)
demiheight = lineation.getFloatByPrefixBeginEnd('demiheight', 'height', inradius.imag, xmlElement)
radius = lineation.getComplexByPrefixBeginEnd('elementRadius', 'elementDiameter', complex(1.0, 1.0), xmlElement)
radius = lineation.getComplexByPrefixBeginEnd('radius', 'diameter', radius, xmlElement)
diameter = radius + radius
typeString = evaluate.getEvaluatedStringDefault('rectangular', 'type', xmlElement)
typeStringTwoCharacters = typeString.lower()[: 2]
typeStringFirstCharacter = typeStringTwoCharacters[: 1]
zigzag = evaluate.getEvaluatedBooleanDefault(True, 'zigzag', xmlElement)
topRight = complex(demiwidth, demiheight)
bottomLeft = -topRight
loopsComplex = [euclidean.getSquareLoopWiddershins(bottomLeft, topRight)]
paths = evaluate.getTransformedPathsByKey('target', xmlElement)
if len(paths) > 0:
loopsComplex = euclidean.getComplexPaths(paths)
maximumComplex = euclidean.getMaximumByPathsComplex(loopsComplex)
minimumComplex = euclidean.getMinimumByPathsComplex(loopsComplex)
gridPath = None
if typeStringTwoCharacters == 'he':
gridPath = getHexagonalGrid(diameter, loopsComplex, maximumComplex, minimumComplex, zigzag)
elif typeStringTwoCharacters == 'ra' or typeStringFirstCharacter == 'a':
gridPath = getRandomGrid(diameter, loopsComplex, maximumComplex, minimumComplex, xmlElement)
elif typeStringTwoCharacters == 're' or typeStringFirstCharacter == 'e':
gridPath = getRectangularGrid(diameter, loopsComplex, maximumComplex, minimumComplex, zigzag)
if gridPath == None:
print('Warning, the step type was not one of (hexagonal, random or rectangular) in getGeometryOutput in grid for:')
print(typeString)
print(xmlElement)
return []
loop = euclidean.getVector3Path(gridPath)
xmlElement.attributeDictionary['closed'] = 'false'
return lineation.getGeometryOutputByLoop(lineation.SideLoop(loop, 0.5 * math.pi), xmlElement)
def __init__(self, xmlElement):
'Initialize.'
self.interpolationDictionary = {}
self.radius = lineation.getRadiusComplex(complex(), xmlElement)
self.tiltFollow = evaluate.getEvaluatedBooleanDefault(True, 'tiltFollow', xmlElement)
self.tiltTop = evaluate.getVector3ByPrefix(None, 'tiltTop', xmlElement)
self.maximumUnbuckling = evaluate.getEvaluatedFloatDefault(5.0, 'maximumUnbuckling', xmlElement)
scalePathDefault = [Vector3(1.0, 1.0, 0.0), Vector3(1.0, 1.0, 1.0)]
self.interpolationDictionary['scale'] = Interpolation().getByPrefixZ(scalePathDefault, 'scale', xmlElement)
self.target = evaluate.getTransformedPathsByKey([], 'target', xmlElement)
if self.tiltTop == None:
offsetPathDefault = [Vector3(), Vector3(0.0, 0.0, 1.0)]
self.interpolationDictionary['offset'] = Interpolation().getByPrefixZ(offsetPathDefault, '', xmlElement)
tiltPathDefault = [Vector3(), Vector3(0.0, 0.0, 1.0)]
self.interpolationDictionary['tilt'] = Interpolation().getByPrefixZ(tiltPathDefault, 'tilt', xmlElement)
for point in self.interpolationDictionary['tilt'].path:
point.x = math.radians(point.x)
point.y = math.radians(point.y)
else:
offsetAlongDefault = [Vector3(), Vector3(1.0, 0.0, 0.0)]
self.interpolationDictionary['offset'] = Interpolation().getByPrefixAlong(offsetAlongDefault, '', xmlElement)
self.twist = evaluate.getEvaluatedFloatDefault(0.0, 'twist', xmlElement )
self.twistPathDefault = [Vector3(), Vector3(1.0, self.twist) ]
insertTwistPortions(self, xmlElement)
def __init__(self, xmlElement):
'Set defaults.'
self.inradius = lineation.getComplexByPrefixes(
['demisize', 'inradius'], complex(10.0, 10.0), xmlElement)
self.inradius = lineation.getComplexByMultiplierPrefix(
2.0, 'size', self.inradius, xmlElement)
self.demiwidth = lineation.getFloatByPrefixBeginEnd(
'demiwidth', 'width', self.inradius.real, xmlElement)
self.demiheight = lineation.getFloatByPrefixBeginEnd(
'demiheight', 'height', self.inradius.imag, xmlElement)
self.packingDensity = evaluate.getEvaluatedFloatByKeys(
0.2, ['packingDensity', 'density'], xmlElement)
self.radius = lineation.getComplexByPrefixBeginEnd(
'elementRadius', 'elementDiameter', complex(1.0, 1.0), xmlElement)
self.radius = lineation.getComplexByPrefixBeginEnd(
'radius', 'diameter', self.radius, xmlElement)
self.seed = evaluate.getEvaluatedIntDefault(None, 'seed', xmlElement)
self.target = evaluate.getTransformedPathsByKey([], 'target',
xmlElement)
self.typeMenuRadioStrings = 'hexagonal random rectangular'.split()
self.typeString = evaluate.getEvaluatedStringDefault(
'rectangular', 'type', xmlElement)
self.zigzag = evaluate.getEvaluatedBooleanDefault(
True, 'zigzag', xmlElement)
def getGeometryOutput(xmlElement):
"Get vector3 vertexes from attribute dictionary."
start = evaluate.getVector3ByPrefix('start', Vector3(), xmlElement)
end = evaluate.getVector3ByPrefix('end', Vector3(), xmlElement)
endMinusStart = end - start
endMinusStartLength = abs(endMinusStart)
if endMinusStartLength <= 0.0:
print(
'Warning, end is the same as start in getGeometryOutput in line for:'
)
print(start)
print(end)
print(xmlElement)
return None
steps = evaluate.getEvaluatedFloatDefault(None, 'steps', xmlElement)
step = evaluate.getEvaluatedFloatDefault(None, 'step', xmlElement)
xmlElement.attributeDictionary['closed'] = str(
evaluate.getEvaluatedBooleanDefault(False, 'closed', xmlElement))
if step == None and steps == None:
return lineation.getGeometryOutputByLoop(
lineation.SideLoop([start, end]), xmlElement)
loop = [start]
if step != None and steps != None:
stepVector = step / endMinusStartLength * endMinusStart
end = start + stepVector * steps
return getGeometryOutputByStep(end, loop, steps, stepVector,
xmlElement)
if step == None:
stepVector = endMinusStart / steps
return getGeometryOutputByStep(end, loop, steps, stepVector,
xmlElement)
typeString = evaluate.getEvaluatedStringDefault('minimum', 'type',
xmlElement)
endMinusStartLengthOverStep = endMinusStartLength / step
if typeString == 'average':
steps = max(1.0, round(endMinusStartLengthOverStep))
stepVector = step / endMinusStartLength * endMinusStart
end = start + stepVector * steps
return getGeometryOutputByStep(end, loop, steps, stepVector,
xmlElement)
if typeString == 'maximum':
steps = math.ceil(endMinusStartLengthOverStep)
if steps < 1.0:
return lineation.getGeometryOutputByLoop(
lineation.SideLoop([start, end]), xmlElement)
stepVector = endMinusStart / steps
return getGeometryOutputByStep(end, loop, steps, stepVector,
xmlElement)
if typeString == 'minimum':
steps = math.floor(endMinusStartLengthOverStep)
if steps < 1.0:
return lineation.getGeometryOutputByLoop(lineation.SideLoop(loop),
xmlElement)
stepVector = endMinusStart / steps
return getGeometryOutputByStep(end, loop, steps, stepVector,
xmlElement)
print(
'Warning, the step type was not one of (average, maximum or minimum) in getGeometryOutput in line for:'
)
print(typeString)
print(xmlElement)
loop.append(end)
return lineation.getGeometryOutputByLoop(lineation.SideLoop(loop),
xmlElement)
def getShouldReverse(xmlElement): "Determine if the loop should be reversed." return evaluate.getEvaluatedBooleanDefault(True, 'reverse', xmlElement)
def getShouldReverse(prefix, xmlElement):
'Determine if the loop should be reversed.'
return evaluate.getEvaluatedBooleanDefault(True, prefix + 'reverse',
xmlElement)
def getOriginalRoot(self): "Get the original reparsed root element." if evaluate.getEvaluatedBooleanDefault(True, 'getOriginalRoot', self.root): return XMLSimpleReader(self.fileName, self.parent, self.xmlText).root return None
def setClosedAttribute(revolutions, xmlElement): "Set the closed attribute of the xmlElement." xmlElement.attributeDictionary['closed'] = str(evaluate.getEvaluatedBooleanDefault(revolutions <= 1, 'closed', xmlElement)).lower()
def getShouldReverse(prefix, xmlElement): 'Determine if the loop should be reversed.' return evaluate.getEvaluatedBooleanDefault(True, prefix + 'reverse', xmlElement)
def setClosedAttribute(revolutions, xmlElement):
"Set the closed attribute of the xmlElement."
xmlElement.attributeDictionary['closed'] = str(
evaluate.getEvaluatedBooleanDefault(revolutions <= 1, 'closed',
xmlElement)).lower()
def getShouldReverse(xmlElement):
"Determine if the loop should be reversed."
return evaluate.getEvaluatedBooleanDefault(True, 'reverse', xmlElement)
