def getManipulatedGeometryOutput(elementNode, geometryOutput, prefix): 'Get inset geometryOutput.' derivation = InsetDerivation(elementNode, prefix) if derivation.radius == 0.0: return geometryOutput halfLayerHeight = 0.5 * derivation.radius importRadius = 0.5 * derivation.radius * setting.getImportCoarseness(elementNode) loopLayers = solid.getLoopLayersSetCopy(elementNode, geometryOutput, importRadius, derivation.radius) triangleAltitude = math.sqrt(0.75) * derivation.radius loops = [] vertexes = [] for loopLayerIndex in xrange(1, len(loopLayers), 2): loopLayer = loopLayers[loopLayerIndex] loopLayer.loops[0] = intercircle.getLargestInsetLoopFromLoop(loopLayer.loops[0], triangleAltitude) for loopLayerIndex in xrange(0, len(loopLayers), 2): loopLayer = loopLayers[loopLayerIndex] loopLists = [[solid.getLoopOrEmpty(loopLayerIndex - 2, loopLayers)]] loopLists.append([solid.getLoopOrEmpty(loopLayerIndex - 1, loopLayers)]) loopLists.append([intercircle.getLargestInsetLoopFromLoop(loopLayer.loops[0], derivation.radius)]) if evaluate.getEvaluatedBoolean(True, elementNode, prefix + 'insetTop'): loopLists.append([solid.getLoopOrEmpty(loopLayerIndex + 1, loopLayers)]) loopLists.append([solid.getLoopOrEmpty(loopLayerIndex + 2, loopLayers)]) largestLoop = euclidean.getLargestLoop(boolean_solid.getLoopsIntersection(importRadius, loopLists)) triangle_mesh.addVector3Loop(largestLoop, loops, vertexes, loopLayer.z) if evaluate.getEvaluatedBoolean(False, elementNode, prefix + 'addExtraTopLayer') and len(loops) > 0: topLoop = loops[-1] vector3Loop = [] loops.append(vector3Loop) z = topLoop[0].z + derivation.radius for point in topLoop: vector3Index = Vector3Index(len(vertexes), point.x, point.y, z) vector3Loop.append(vector3Index) vertexes.append(vector3Index) return triangle_mesh.getMeldedPillarOutput(loops)
def getArcPath(elementNode):
"Get the arc path.rx ry x-axis-rotation large-arc-flag sweep-flag"
begin = elementNode.getPreviousVertex(Vector3())
end = evaluate.getVector3FromElementNode(elementNode)
largeArcFlag = evaluate.getEvaluatedBoolean(True, elementNode,
'largeArcFlag')
radius = lineation.getComplexByPrefix(elementNode, 'radius',
complex(1.0, 1.0))
sweepFlag = evaluate.getEvaluatedBoolean(True, elementNode, 'sweepFlag')
xAxisRotation = math.radians(
evaluate.getEvaluatedFloat(0.0, elementNode, 'xAxisRotation'))
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 getManipulatedGeometryOutput(elementNode, geometryOutput, prefix): 'Get inset geometryOutput.' derivation = InsetDerivation(elementNode, prefix) if derivation.radius == 0.0: return geometryOutput halfLayerHeight = 0.5 * derivation.radius importRadius = 0.5 * derivation.radius * setting.getImportCoarseness(elementNode) loopLayers = solid.getLoopLayersSetCopy(elementNode, geometryOutput, importRadius, derivation.radius) triangleAltitude = math.sqrt(0.75) * derivation.radius loops = [] vertexes = [] for loopLayerIndex in xrange(1, len(loopLayers), 2): loopLayer = loopLayers[loopLayerIndex] loopLayer.loops[0] = intercircle.getLargestInsetLoopFromLoop(loopLayer.loops[0], triangleAltitude) for loopLayerIndex in xrange(0, len(loopLayers), 2): loopLayer = loopLayers[loopLayerIndex] loopLists = [[solid.getLoopOrEmpty(loopLayerIndex - 2, loopLayers)]] loopLists.append([solid.getLoopOrEmpty(loopLayerIndex - 1, loopLayers)]) loopLists.append([intercircle.getLargestInsetLoopFromLoop(loopLayer.loops[0], derivation.radius)]) if evaluate.getEvaluatedBoolean(True, elementNode, prefix + 'insetTop'): loopLists.append([solid.getLoopOrEmpty(loopLayerIndex + 1, loopLayers)]) loopLists.append([solid.getLoopOrEmpty(loopLayerIndex + 2, loopLayers)]) largestLoop = euclidean.getLargestLoop(boolean_solid.getLoopsIntersection(importRadius, loopLists)) triangle_mesh.addVector3Loop(largestLoop, loops, vertexes, loopLayer.z) if evaluate.getEvaluatedBoolean(False, elementNode, prefix + 'addExtraTopLayer') and len(loops) > 0: topLoop = loops[-1] vector3Loop = [] loops.append(vector3Loop) z = topLoop[0].z + derivation.radius for point in topLoop: vector3Index = Vector3Index(len(vertexes), point.x, point.y, z) vector3Loop.append(vector3Index) vertexes.append(vector3Index) return triangle_mesh.getMeldedPillarOutput(loops)
def __init__(self, xmlElement):
'Set defaults.'
self.basename = evaluate.getEvaluatedBoolean(True, 'basename', xmlElement)
self.fileName = evaluate.getEvaluatedString('', 'file', xmlElement)
self.importName = evaluate.getEvaluatedString(None, '_importName', xmlElement)
self.overwriteRoot = evaluate.getEvaluatedBoolean(False, 'overwriteRoot', xmlElement)
self.xmlElement = xmlElement
def __init__(self, elementNode):
'Set defaults.'
self.appendDocumentElement = evaluate.getEvaluatedBoolean(False, elementNode, 'appendDocumentElement')
self.appendElement = evaluate.getEvaluatedBoolean(False, elementNode, 'appendElement')
self.basename = evaluate.getEvaluatedBoolean(True, elementNode, 'basename')
self.elementNode = elementNode
self.fileName = evaluate.getEvaluatedString('', elementNode, 'file')
self.importName = evaluate.getEvaluatedString(None, elementNode, '_importName')
def __init__(self, elementNode):
'Set defaults.'
self.appendDocumentElement = evaluate.getEvaluatedBoolean(False, elementNode, 'appendDocumentElement')
self.appendElement = evaluate.getEvaluatedBoolean(False, elementNode, 'appendElement')
self.basename = evaluate.getEvaluatedBoolean(True, elementNode, 'basename')
self.elementNode = elementNode
self.fileName = evaluate.getEvaluatedString('', elementNode, 'file')
self.importName = evaluate.getEvaluatedString(None, elementNode, '_importName')
def __init__(self, elementNode):
"Set defaults."
self.appendDocumentElement = evaluate.getEvaluatedBoolean(False, elementNode, "appendDocumentElement")
self.appendElement = evaluate.getEvaluatedBoolean(False, elementNode, "appendElement")
self.basename = evaluate.getEvaluatedBoolean(True, elementNode, "basename")
self.elementNode = elementNode
self.fileName = evaluate.getEvaluatedString("", elementNode, "file")
self.importName = evaluate.getEvaluatedString(None, elementNode, "_importName")
def __init__(self, elementNode):
'Set defaults.'
self.addLayerTemplate = evaluate.getEvaluatedBoolean(False, elementNode, 'addLayerTemplate')
self.elementNode = elementNode
self.fileName = evaluate.getEvaluatedString('', elementNode, 'file')
self.folderName = evaluate.getEvaluatedString('', elementNode, 'folder')
self.suffix = evaluate.getEvaluatedString('', elementNode, 'suffix')
self.targets = evaluate.getElementNodesByKey(elementNode, 'target')
self.writeMatrix = evaluate.getEvaluatedBoolean(True, elementNode, 'writeMatrix')
def __init__(self, xmlElement):
'Set defaults.'
self.addLayerTemplate = evaluate.getEvaluatedBoolean(False, 'addLayerTemplate', xmlElement)
self.fileName = evaluate.getEvaluatedString('', 'file', xmlElement)
self.folderName = evaluate.getEvaluatedString('', 'folder', xmlElement)
self.suffix = evaluate.getEvaluatedString('', 'suffix', xmlElement)
self.targets = evaluate.getXMLElementsByKey('target', xmlElement)
self.writeMatrix = evaluate.getEvaluatedBoolean(True, 'writeMatrix', xmlElement)
self.xmlElement = xmlElement
def __init__(self, elementNode):
'Set defaults.'
self.addLayerTemplate = evaluate.getEvaluatedBoolean(False, elementNode, 'addLayerTemplate')
self.elementNode = elementNode
self.fileName = evaluate.getEvaluatedString('', elementNode, 'file')
self.folderName = evaluate.getEvaluatedString('', elementNode, 'folder')
self.suffix = evaluate.getEvaluatedString('', elementNode, 'suffix')
self.targets = evaluate.getElementNodesByKey(elementNode, 'target')
self.writeMatrix = evaluate.getEvaluatedBoolean(True, elementNode, 'writeMatrix')
def getManipulatedGeometryOutput(elementNode, geometryOutput, prefix): 'Get inset geometryOutput.' derivation = InsetDerivation(elementNode, prefix) if derivation.radius == 0.0: return geometryOutput copyShallow = elementNode.getCopyShallow() solid.processElementNodeByGeometry(copyShallow, geometryOutput) targetMatrix = matrix.getBranchMatrixSetElementNode(elementNode) matrix.setElementNodeDictionaryMatrix(copyShallow, targetMatrix) transformedVertexes = copyShallow.xmlObject.getTransformedVertexes() minimumZ = boolean_geometry.getMinimumZ(copyShallow.xmlObject) maximumZ = euclidean.getTopPath(transformedVertexes) layerThickness = setting.getLayerThickness(elementNode) importRadius = setting.getImportRadius(elementNode) zoneArrangement = triangle_mesh.ZoneArrangement(layerThickness, transformedVertexes) copyShallow.attributes['visible'] = True copyShallowObjects = [copyShallow.xmlObject] bottomLoopLayer = euclidean.LoopLayer(minimumZ) z = minimumZ + 0.1 * layerThickness bottomLoopLayer.loops = boolean_geometry.getEmptyZLoops(copyShallowObjects, importRadius, False, z, zoneArrangement) loopLayers = [bottomLoopLayer] z = minimumZ + layerThickness loopLayers += boolean_geometry.getLoopLayers(copyShallowObjects, importRadius, layerThickness, maximumZ, False, z, zoneArrangement) copyShallow.parentNode.xmlObject.archivableObjects.remove(copyShallow.xmlObject) belowLoop = [] diagonalRadius = math.sqrt(0.5) * derivation.radius insetDiagonalLoops = [] loops = [] vertexes = [] for loopLayer in loopLayers: insetDiagonalLoops.append(intercircle.getLargestInsetLoopFromLoop(loopLayer.loops[0], diagonalRadius)) for loopLayerIndex, loopLayer in enumerate(loopLayers): vector3Loop = [] insetLoop = intercircle.getLargestInsetLoopFromLoop(loopLayer.loops[0], derivation.radius) loopLists = [[getLoopOrEmpty(loopLayerIndex - 1, insetDiagonalLoops)], [insetLoop]] largestLoop = euclidean.getLargestLoop(boolean_solid.getLoopsIntersection(importRadius, loopLists)) if evaluate.getEvaluatedBoolean(True, elementNode, prefix + 'insetTop'): loopLists = [[getLoopOrEmpty(loopLayerIndex + 1, insetDiagonalLoops)], [largestLoop]] largestLoop = euclidean.getLargestLoop(boolean_solid.getLoopsIntersection(importRadius, loopLists)) for point in largestLoop: vector3Index = Vector3Index(len(vertexes), point.real, point.imag, loopLayer.z) vector3Loop.append(vector3Index) vertexes.append(vector3Index) if len(vector3Loop) > 0: loops.append(vector3Loop) if evaluate.getEvaluatedBoolean(False, elementNode, prefix + 'addExtraTopLayer') and len(loops) > 0: topLoop = loops[-1] vector3Loop = [] loops.append(vector3Loop) z = topLoop[0].z + layerThickness for point in topLoop: vector3Index = Vector3Index(len(vertexes), point.x, point.y, z) vector3Loop.append(vector3Index) vertexes.append(vector3Index) geometryOutput = triangle_mesh.getMeldedPillarOutput(loops) return geometryOutput
def __init__(self, xmlElement):
'Set defaults.'
self.basename = evaluate.getEvaluatedBoolean(True, 'basename',
xmlElement)
self.fileName = evaluate.getEvaluatedString('', 'file', xmlElement)
self.importName = evaluate.getEvaluatedString(None, '_importName',
xmlElement)
self.overwriteRoot = evaluate.getEvaluatedBoolean(
False, 'overwriteRoot', xmlElement)
self.xmlElement = xmlElement
def __init__(self, xmlElement):
"""Set defaults."""
self.closed = evaluate.getEvaluatedBoolean(True, 'closed', xmlElement)
self.paths = evaluate.getTransformedPathsByKey([], 'paths', xmlElement)
vertexTargets = evaluate.getXMLElementsByKey('vertexes', xmlElement)
for vertexTarget in vertexTargets:
self.paths.append(vertexTarget.getVertexes())
self.target = evaluate.getXMLElementByKey('target', xmlElement)
self.track = evaluate.getEvaluatedBoolean(True, 'track', xmlElement)
self.visible = evaluate.getEvaluatedBoolean(True, 'visible', xmlElement)
self.xmlElement = xmlElement
def __init__(self, elementNode): 'Set defaults.' self.closed = evaluate.getEvaluatedBoolean(True, elementNode, 'closed') self.elementNode = elementNode self.paths = evaluate.getTransformedPathsByKey([], elementNode, 'paths') vertexTargets = evaluate.getElementNodesByKey(elementNode, 'vertexes') for vertexTarget in vertexTargets: self.paths.append(vertexTarget.getVertexes()) self.target = evaluate.getElementNodeByKey(elementNode, 'target') self.track = evaluate.getEvaluatedBoolean(True, elementNode, 'track') self.visible = evaluate.getEvaluatedBoolean(True, elementNode, 'visible')
def __init__(self, xmlElement):
'Set defaults.'
self.closed = evaluate.getEvaluatedBoolean(True, 'closed', xmlElement)
self.paths = evaluate.getTransformedPathsByKey([], 'paths', xmlElement)
vertexTargets = evaluate.getXMLElementsByKey('vertexes', xmlElement)
for vertexTarget in vertexTargets:
self.paths.append(vertexTarget.getVertexes())
self.target = evaluate.getXMLElementByKey('target', xmlElement)
self.track = evaluate.getEvaluatedBoolean(True, 'track', xmlElement)
self.visible = evaluate.getEvaluatedBoolean(True, 'visible', xmlElement)
self.xmlElement = xmlElement
def __init__(self, elementNode):
"Set defaults."
self.closed = evaluate.getEvaluatedBoolean(True, elementNode, "closed")
self.elementNode = elementNode
self.paths = evaluate.getTransformedPathsByKey([], elementNode, "paths")
vertexTargets = evaluate.getElementNodesByKey(elementNode, "vertexes")
for vertexTarget in vertexTargets:
self.paths.append(vertexTarget.getVertexes())
self.target = evaluate.getElementNodeByKey(elementNode, "target")
self.track = evaluate.getEvaluatedBoolean(True, elementNode, "track")
self.visible = evaluate.getEvaluatedBoolean(True, elementNode, "visible")
def __init__(self, elementNode): 'Set defaults.' self.closed = evaluate.getEvaluatedBoolean(True, elementNode, 'closed') self.elementNode = elementNode self.paths = evaluate.getTransformedPathsByKey([], elementNode, 'paths') vertexTargets = evaluate.getElementNodesByKey(elementNode, 'vertexes') for vertexTarget in vertexTargets: self.paths.append(vertexTarget.getVertexes()) self.target = evaluate.getElementNodeByKey(elementNode, 'target') self.track = evaluate.getEvaluatedBoolean(True, elementNode, 'track') self.visible = evaluate.getEvaluatedBoolean(True, elementNode, 'visible')
def __init__(self, xmlElement):
'Initialize.'
self.interpolationDictionary = {}
self.tiltFollow = evaluate.getEvaluatedBoolean(True, 'tiltFollow',
xmlElement)
self.tiltTop = evaluate.getVector3ByPrefix(None, 'tiltTop', xmlElement)
self.maximumUnbuckling = evaluate.getEvaluatedFloat(
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.getEvaluatedFloat(0.0, 'twist', xmlElement)
self.twistPathDefault = [Vector3(), Vector3(1.0, self.twist)]
self.xmlElement = xmlElement
insertTwistPortions(self, xmlElement)
def __init__(self, prefix, xmlElement):
'Set defaults.'
self.altitude = evaluate.getEvaluatedFloat(0.0, prefix + 'altitude',
xmlElement)
self.liftPath = evaluate.getEvaluatedBoolean(True, prefix + 'liftPath',
xmlElement)
self.xmlElement = xmlElement
def getCascadeBoolean(self, defaultBoolean, key): 'Get the cascade boolean.' if key in self.attributes: value = evaluate.getEvaluatedBoolean(None, self, key) if value != None: return value return self.parentNode.getCascadeBoolean(defaultBoolean, key)
def __init__(self, xmlElement):
'Initialize.'
self.interpolationDictionary = {}
self.radius = lineation.getRadiusComplex(complex(), xmlElement)
self.tiltFollow = evaluate.getEvaluatedBoolean(True, 'tiltFollow', xmlElement)
self.tiltTop = evaluate.getVector3ByPrefix(None, 'tiltTop', xmlElement)
self.maximumUnbuckling = evaluate.getEvaluatedFloat(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.getEvaluatedFloat(0.0, 'twist', xmlElement )
self.twistPathDefault = [Vector3(), Vector3(1.0, self.twist) ]
self.xmlElement = xmlElement
insertTwistPortions(self, xmlElement)
def __init__(self, elementNode):
'Initialize.'
elementNode.attributes['closed'] = 'true'
self.density = evaluate.getEvaluatedFloat(1.0, elementNode, 'density')
self.minimumRadiusOverThickness = evaluate.getEvaluatedFloat(1.0, elementNode, 'minimumRadiusOverThickness')
self.mobile = evaluate.getEvaluatedBoolean(False, elementNode, 'mobile')
self.inradius = lineation.getInradius(complex(10.0, 10.0), elementNode)
self.path = None
if 'path' in elementNode.attributes:
self.path = evaluate.getPathByKey([], elementNode, 'path')
self.searchAttempts = evaluate.getEvaluatedInt(0, elementNode, 'searchAttempts')
self.searchRadiusOverRadius = evaluate.getEvaluatedFloat(1.0, elementNode, 'searchRadiusOverRadius')
self.seed = evaluate.getEvaluatedInt(None, elementNode, 'seed')
self.wallThickness = evaluate.getEvaluatedFloat(2.0 * setting.getPerimeterWidth(elementNode), elementNode, 'wallThickness')
# Set derived variables.
self.halfWallThickness = 0.5 * self.wallThickness
self.inradiusMinusThickness = self.inradius - complex(self.wallThickness, self.wallThickness)
self.minimumRadius = evaluate.getEvaluatedFloat(self.minimumRadiusOverThickness * self.wallThickness, elementNode, 'minimumRadius')
self.inradiusMinusRadiusThickness = self.inradiusMinusThickness - complex(self.minimumRadius, self.minimumRadius)
self.potentialBubbleArea = 4.0 * self.inradiusMinusThickness.real * self.inradiusMinusThickness.imag
if self.path is None:
radiusPlusHalfThickness = self.minimumRadius + self.halfWallThickness
numberOfPoints = int(math.ceil(self.density * self.potentialBubbleArea / math.pi / radiusPlusHalfThickness / radiusPlusHalfThickness))
self.path = []
if self.seed is None:
self.seed = time.time()
print('Sponge slice seed used was: %s' % self.seed)
random.seed(self.seed)
for pointIndex in xrange(numberOfPoints):
point = euclidean.getRandomComplex(-self.inradiusMinusRadiusThickness, self.inradiusMinusRadiusThickness)
self.path.append(Vector3(point.real, point.imag))
def __init__(self, elementNode, prefix, sideLength):
'Set defaults.'
self.isClosed = evaluate.getEvaluatedBoolean(False, elementNode,
prefix + 'closed')
self.radius = evaluate.getEvaluatedFloat(
setting.getPerimeterWidth(elementNode), elementNode,
prefix + 'radius')
def getCascadeBoolean(self, defaultBoolean, key):
'Get the cascade boolean.'
if key in self.attributes:
value = evaluate.getEvaluatedBoolean(None, self, key)
if value is not None:
return value
return self.parentNode.getCascadeBoolean(defaultBoolean, key)
def __init__(self, elementNode, prefix):
'Set defaults.'
self.altitude = evaluate.getEvaluatedFloat(0.0, elementNode,
prefix + 'altitude')
self.elementNode = elementNode
self.liftPath = evaluate.getEvaluatedBoolean(True, elementNode,
prefix + 'liftPath')
def __init__(self, elementNode):
'Set defaults.'
self.closed = evaluate.getEvaluatedBoolean(False, elementNode, 'closed')
self.end = evaluate.getVector3ByPrefix(Vector3(), elementNode, 'end')
self.start = evaluate.getVector3ByPrefix(Vector3(), elementNode, 'start')
self.step = evaluate.getEvaluatedFloat(None, elementNode, 'step')
self.steps = evaluate.getEvaluatedFloat(None, elementNode, 'steps')
self.typeMenuRadioStrings = 'average maximum minimum'.split()
self.typeString = evaluate.getEvaluatedString('minimum', elementNode, 'type')
def __init__(self, elementNode):
self.inradius = lineation.getInradiusFirstByHeightWidth(complex(10.0, 10.0), elementNode)
self.density = evaluate.getEvaluatedFloat(0.2, elementNode, 'density')
self.radius = lineation.getComplexByPrefixBeginEnd(elementNode, 'radius', 'diameter', complex(1.0, 1.0))
self.seed = evaluate.getEvaluatedInt(None, elementNode, 'seed')
self.target = evaluate.getTransformedPathsByKey([], elementNode, 'target')
self.typeMenuRadioStrings = 'hexagonal random rectangular'.split()
self.typeString = evaluate.getEvaluatedString('rectangular', elementNode, 'type')
self.zigzag = evaluate.getEvaluatedBoolean(True, elementNode, 'zigzag')
def __init__(self, elementNode):
'Set defaults.'
self.closed = evaluate.getEvaluatedBoolean(False, elementNode, 'closed')
self.end = evaluate.getVector3ByPrefix(Vector3(), elementNode, 'end')
self.start = evaluate.getVector3ByPrefix(Vector3(), elementNode, 'start')
self.step = evaluate.getEvaluatedFloat(None, elementNode, 'step')
self.steps = evaluate.getEvaluatedFloat(None, elementNode, 'steps')
self.typeMenuRadioStrings = 'average maximum minimum'.split()
self.typeString = evaluate.getEvaluatedString('minimum', elementNode, 'type')
def __init__(self, xmlElement):
"""Set defaults."""
self.closed = evaluate.getEvaluatedBoolean(False, 'closed', xmlElement)
self.end = evaluate.getVector3ByPrefix(Vector3(), 'end', xmlElement)
self.start = evaluate.getVector3ByPrefix(Vector3(), 'start', xmlElement)
self.step = evaluate.getEvaluatedFloat(None, 'step', xmlElement)
self.steps = evaluate.getEvaluatedFloat(None, 'steps', xmlElement)
self.typeMenuRadioStrings = 'average maximum minimum'.split()
self.typeString = evaluate.getEvaluatedString('minimum', 'type', xmlElement)
def __init__(self, elementNode):
'Set defaults.'
self.inradius = lineation.getInradiusFirstByHeightWidth(complex(10.0, 10.0), elementNode)
self.density = evaluate.getEvaluatedFloat(0.2, elementNode, 'density')
self.radius = lineation.getComplexByPrefixBeginEnd(elementNode, 'radius', 'diameter', complex(1.0, 1.0))
self.seed = evaluate.getEvaluatedInt(None, elementNode, 'seed')
self.target = evaluate.getTransformedPathsByKey([], elementNode, 'target')
self.typeMenuRadioStrings = 'hexagonal random rectangular'.split()
self.typeString = evaluate.getEvaluatedString('rectangular', elementNode, 'type')
self.zigzag = evaluate.getEvaluatedBoolean(True, elementNode, 'zigzag')
def getManipulatedPaths(close, loop, prefix, sideLength, xmlElement): """Get path with outline.""" if len(loop) < 2: return [loop] isClosed = evaluate.getEvaluatedBoolean(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 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.getEvaluatedBoolean(True, 'largeArcFlag', xmlElement)
radius = lineation.getComplexByPrefix('radius', complex(1.0, 1.0), xmlElement )
sweepFlag = evaluate.getEvaluatedBoolean(True, 'sweepFlag', xmlElement)
xAxisRotation = math.radians(evaluate.getEvaluatedFloat(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 getManipulatedPaths(close, loop, prefix, sideLength, xmlElement):
"Get path with outline."
if len(loop) < 2:
return [loop]
isClosed = evaluate.getEvaluatedBoolean(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.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.getEvaluatedInt(None, 'seed', xmlElement)
self.target = evaluate.getTransformedPathsByKey([], 'target', xmlElement)
self.typeMenuRadioStrings = 'hexagonal random rectangular'.split()
self.typeString = evaluate.getEvaluatedString('rectangular', 'type', xmlElement)
self.zigzag = evaluate.getEvaluatedBoolean(True, 'zigzag', xmlElement)
def __init__(self, elementNode):
"Set defaults."
self.inradius = lineation.getInradius(complex(10.0, 10.0), elementNode)
self.demiwidth = lineation.getFloatByPrefixBeginEnd(elementNode, "demiwidth", "width", self.inradius.real)
self.demiheight = lineation.getFloatByPrefixBeginEnd(elementNode, "demiheight", "height", self.inradius.imag)
self.density = evaluate.getEvaluatedFloat(0.2, elementNode, "density")
self.radius = lineation.getComplexByPrefixBeginEnd(
elementNode, "elementRadius", "elementDiameter", complex(1.0, 1.0)
)
self.radius = lineation.getComplexByPrefixBeginEnd(elementNode, "radius", "diameter", self.radius)
self.seed = evaluate.getEvaluatedInt(None, elementNode, "seed")
self.target = evaluate.getTransformedPathsByKey([], elementNode, "target")
self.typeMenuRadioStrings = "hexagonal random rectangular".split()
self.typeString = evaluate.getEvaluatedString("rectangular", elementNode, "type")
self.zigzag = evaluate.getEvaluatedBoolean(True, elementNode, "zigzag")
def __init__(self, xmlElement): 'Set defaults.' self.radius = lineation.getRadiusComplex(complex(1.0, 1.0), xmlElement) self.sides = evaluate.getEvaluatedFloat(None, 'sides', xmlElement) if self.sides == None: radiusMaximum = max(self.radius.real, self.radius.imag) self.sides = evaluate.getSidesMinimumThreeBasedOnPrecisionSides(radiusMaximum, xmlElement) self.circularizedRadius = self.radius if evaluate.getEvaluatedBoolean(False, 'areaRadius', xmlElement): self.circularizedRadius *= euclidean.getAreaRadiusMultiplier(self.sides) self.start = evaluate.getEvaluatedFloat(0.0, 'start', xmlElement) end = evaluate.getEvaluatedFloat(360.0, 'end', xmlElement) self.revolutions = evaluate.getEvaluatedFloat(1.0, 'revolutions', xmlElement) self.extent = evaluate.getEvaluatedFloat(end - self.start, 'extent', xmlElement) self.extent += 360.0 * (self.revolutions - 1.0) self.spiral = evaluate.getVector3ByPrefix(None, 'spiral', xmlElement)
def __init__(self, xmlElement):
'Set defaults.'
self.radius = lineation.getRadiusComplex(complex(1.0, 1.0), xmlElement)
self.sides = evaluate.getEvaluatedFloat(None, 'sides', xmlElement)
if self.sides == None:
radiusMaximum = max(self.radius.real, self.radius.imag)
self.sides = evaluate.getSidesMinimumThreeBasedOnPrecisionSides(
radiusMaximum, xmlElement)
self.circularizedRadius = self.radius
if evaluate.getEvaluatedBoolean(False, 'areaRadius', xmlElement):
self.circularizedRadius *= euclidean.getAreaRadiusMultiplier(
self.sides)
self.start = evaluate.getEvaluatedFloat(0.0, 'start', xmlElement)
end = evaluate.getEvaluatedFloat(360.0, 'end', xmlElement)
self.revolutions = evaluate.getEvaluatedFloat(1.0, 'revolutions',
xmlElement)
self.extent = evaluate.getEvaluatedFloat(end - self.start, 'extent',
xmlElement)
self.extent += 360.0 * (self.revolutions - 1.0)
self.spiral = evaluate.getVector3ByPrefix(None, 'spiral', 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.getEvaluatedInt(None, 'seed', xmlElement)
self.target = evaluate.getTransformedPathsByKey([], 'target',
xmlElement)
self.typeMenuRadioStrings = 'hexagonal random rectangular'.split()
self.typeString = evaluate.getEvaluatedString('rectangular', 'type',
xmlElement)
self.zigzag = evaluate.getEvaluatedBoolean(True, 'zigzag', xmlElement)
def __init__(self, elementNode):
'Initialize.'
self.elementNode = elementNode
self.interpolationDictionary = {}
self.tiltFollow = evaluate.getEvaluatedBoolean(True, elementNode, 'tiltFollow')
self.tiltTop = evaluate.getVector3ByPrefix(None, elementNode, 'tiltTop')
self.maximumUnbuckling = evaluate.getEvaluatedFloat(5.0, elementNode, 'maximumUnbuckling')
scalePathDefault = [Vector3(1.0, 1.0, 0.0), Vector3(1.0, 1.0, 1.0)]
self.interpolationDictionary['scale'] = Interpolation().getByPrefixZ(elementNode, scalePathDefault, 'scale')
self.target = evaluate.getTransformedPathsByKey([], elementNode, 'target')
if self.tiltTop == None:
offsetPathDefault = [Vector3(), Vector3(0.0, 0.0, 1.0)]
self.interpolationDictionary['offset'] = Interpolation().getByPrefixZ(elementNode, offsetPathDefault, '')
tiltPathDefault = [Vector3(), Vector3(0.0, 0.0, 1.0)]
self.interpolationDictionary['tilt'] = Interpolation().getByPrefixZ(elementNode, tiltPathDefault, 'tilt')
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(elementNode, offsetAlongDefault, '')
self.twist = evaluate.getEvaluatedFloat(0.0, elementNode, 'twist')
self.twistPathDefault = [Vector3(), Vector3(1.0, self.twist) ]
insertTwistPortions(self, elementNode)
def setClosedAttribute(elementNode, revolutions):
'Set the closed attribute of the elementNode.'
closedBoolean = evaluate.getEvaluatedBoolean(revolutions <= 1, elementNode,
'closed')
elementNode.attributes['closed'] = str(closedBoolean).lower()
def getOriginalRoot(self): 'Get the original reparsed root element.' if evaluate.getEvaluatedBoolean(True, 'getOriginalRoot', self.root): return XMLSimpleReader(self.fileName, self.parentNode, self.xmlText).root return None
def getManipulatedGeometryOutput(elementNode, geometryOutput, prefix):
'Get inset geometryOutput.'
derivation = InsetDerivation(elementNode, prefix)
if derivation.radius == 0.0:
return geometryOutput
copyShallow = elementNode.getCopyShallow()
solid.processElementNodeByGeometry(copyShallow, geometryOutput)
targetMatrix = matrix.getBranchMatrixSetElementNode(elementNode)
matrix.setElementNodeDictionaryMatrix(copyShallow, targetMatrix)
transformedVertexes = copyShallow.xmlObject.getTransformedVertexes()
minimumZ = boolean_geometry.getMinimumZ(copyShallow.xmlObject)
maximumZ = euclidean.getTopPath(transformedVertexes)
layerThickness = setting.getLayerThickness(elementNode)
importRadius = setting.getImportRadius(elementNode)
zoneArrangement = triangle_mesh.ZoneArrangement(layerThickness,
transformedVertexes)
copyShallow.attributes['visible'] = True
copyShallowObjects = [copyShallow.xmlObject]
bottomLoopLayer = euclidean.LoopLayer(minimumZ)
z = minimumZ + 0.1 * layerThickness
bottomLoopLayer.loops = boolean_geometry.getEmptyZLoops(
copyShallowObjects, importRadius, False, z, zoneArrangement)
loopLayers = [bottomLoopLayer]
z = minimumZ + layerThickness
loopLayers += boolean_geometry.getLoopLayers(copyShallowObjects,
importRadius, layerThickness,
maximumZ, False, z,
zoneArrangement)
copyShallow.parentNode.xmlObject.archivableObjects.remove(
copyShallow.xmlObject)
belowLoop = []
diagonalRadius = math.sqrt(0.5) * derivation.radius
insetDiagonalLoops = []
loops = []
vertexes = []
for loopLayer in loopLayers:
insetDiagonalLoops.append(
intercircle.getLargestInsetLoopFromLoop(loopLayer.loops[0],
diagonalRadius))
for loopLayerIndex, loopLayer in enumerate(loopLayers):
vector3Loop = []
insetLoop = intercircle.getLargestInsetLoopFromLoop(
loopLayer.loops[0], derivation.radius)
loopLists = [[getLoopOrEmpty(loopLayerIndex - 1, insetDiagonalLoops)],
[insetLoop]]
largestLoop = euclidean.getLargestLoop(
boolean_solid.getLoopsIntersection(importRadius, loopLists))
if evaluate.getEvaluatedBoolean(True, elementNode,
prefix + 'insetTop'):
loopLists = [[
getLoopOrEmpty(loopLayerIndex + 1, insetDiagonalLoops)
], [largestLoop]]
largestLoop = euclidean.getLargestLoop(
boolean_solid.getLoopsIntersection(importRadius, loopLists))
for point in largestLoop:
vector3Index = Vector3Index(len(vertexes), point.real, point.imag,
loopLayer.z)
vector3Loop.append(vector3Index)
vertexes.append(vector3Index)
if len(vector3Loop) > 0:
loops.append(vector3Loop)
if evaluate.getEvaluatedBoolean(False, elementNode, prefix +
'addExtraTopLayer') and len(loops) > 0:
topLoop = loops[-1]
vector3Loop = []
loops.append(vector3Loop)
z = topLoop[0].z + layerThickness
for point in topLoop:
vector3Index = Vector3Index(len(vertexes), point.x, point.y, z)
vector3Loop.append(vector3Index)
vertexes.append(vector3Index)
geometryOutput = triangle_mesh.getMeldedPillarOutput(loops)
return geometryOutput
def getShouldReverse(elementNode, prefix): 'Determine if the loop should be reversed.' return evaluate.getEvaluatedBoolean(True, elementNode, prefix + 'reverse')
def setClosedAttribute(revolutions, xmlElement):
'Set the closed attribute of the xmlElement.'
closedBoolean = evaluate.getEvaluatedBoolean(revolutions <= 1, 'closed',
xmlElement)
xmlElement.attributeDictionary['closed'] = str(closedBoolean).lower()
def getOriginalRoot(self):
'Get the original reparsed document element.'
if evaluate.getEvaluatedBoolean(True, self.documentElement,
'getOriginalRoot'):
return DocumentNode(self.fileName, self.xmlText).documentElement
return None
def setClosedAttribute(revolutions, xmlElement): """Set the closed attribute of the xmlElement.""" closedBoolean = evaluate.getEvaluatedBoolean(revolutions <= 1, 'closed', xmlElement) xmlElement.attributeDictionary['closed'] = str(closedBoolean).lower()
def setClosedAttribute(elementNode, revolutions): 'Set the closed attribute of the elementNode.' closedBoolean = evaluate.getEvaluatedBoolean(revolutions <= 1, elementNode, 'closed') elementNode.attributes['closed'] = str(closedBoolean).lower()
def getOriginalRoot(self): 'Get the original reparsed document element.' if evaluate.getEvaluatedBoolean(True, self.documentElement, 'getOriginalRoot'): return DocumentNode(self.fileName, self.xmlText).documentElement return None
def __init__(self, elementNode, prefix, sideLength): 'Set defaults.' self.isClosed = evaluate.getEvaluatedBoolean(False, elementNode, prefix + 'closed') self.radius = evaluate.getEvaluatedFloat(setting.getPerimeterWidth(elementNode), elementNode, prefix + 'radius')
def getShouldReverse(prefix, xmlElement):
'Determine if the loop should be reversed.'
return evaluate.getEvaluatedBoolean(True, prefix + 'reverse', xmlElement)
def __init__(self, elementNode, prefix):
"Set defaults."
self.altitude = evaluate.getEvaluatedFloat(0.0, elementNode, prefix + "altitude")
self.elementNode = elementNode
self.liftPath = evaluate.getEvaluatedBoolean(True, elementNode, prefix + "liftPath")
def getShouldReverse(elementNode, prefix):
'Determine if the loop should be reversed.'
return evaluate.getEvaluatedBoolean(True, elementNode, prefix + 'reverse')
def getShouldReverse(prefix, xmlElement): 'Determine if the loop should be reversed.' return evaluate.getEvaluatedBoolean(True, prefix + 'reverse', xmlElement)
def getOriginalRoot(self):
'Get the original reparsed root element.'
if evaluate.getEvaluatedBoolean(True, 'getOriginalRoot', self.root):
return XMLSimpleReader(self.fileName, self.parentNode, self.xmlText).root
return None
