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, xmlElement):
"Set defaults."
self.fontFamily = evaluate.getEvaluatedString("Gentium Basic Regular", "font-family", xmlElement)
self.fontFamily = evaluate.getEvaluatedString(self.fontFamily, "fontFamily", xmlElement)
self.fontSize = evaluate.getEvaluatedFloat(12.0, "font-size", xmlElement)
self.fontSize = evaluate.getEvaluatedFloat(self.fontSize, "fontSize", xmlElement)
self.textString = xmlElement.text
self.textString = evaluate.getEvaluatedString(self.textString, "text", xmlElement)
def __init__(self, xmlElement):
"""Set defaults."""
self.fontFamily = evaluate.getEvaluatedString('Gentium Basic Regular', 'font-family', xmlElement)
self.fontFamily = evaluate.getEvaluatedString(self.fontFamily, 'fontFamily', xmlElement)
self.fontSize = evaluate.getEvaluatedFloat(12.0, 'font-size', xmlElement)
self.fontSize = evaluate.getEvaluatedFloat(self.fontSize, 'fontSize', xmlElement)
self.textString = xmlElement.text
self.textString = evaluate.getEvaluatedString(self.textString, 'text', xmlElement)
def __init__(self, elementNode):
"Set defaults."
self.fontFamily = evaluate.getEvaluatedString("Gentium Basic Regular", elementNode, "font-family")
self.fontFamily = evaluate.getEvaluatedString(self.fontFamily, elementNode, "fontFamily")
self.fontSize = evaluate.getEvaluatedFloat(12.0, elementNode, "font-size")
self.fontSize = evaluate.getEvaluatedFloat(self.fontSize, elementNode, "fontSize")
self.textString = elementNode.getTextContent()
self.textString = evaluate.getEvaluatedString(self.textString, elementNode, "text")
def __init__(self, elementNode):
'Set defaults.'
self.fontFamily = evaluate.getEvaluatedString('Gentium Basic Regular', elementNode, 'font-family')
self.fontFamily = evaluate.getEvaluatedString(self.fontFamily, elementNode, 'fontFamily')
self.fontSize = evaluate.getEvaluatedFloat(12.0, elementNode, 'font-size')
self.fontSize = evaluate.getEvaluatedFloat(self.fontSize, elementNode, 'fontSize')
self.textString = elementNode.getTextContent()
self.textString = evaluate.getEvaluatedString(self.textString, elementNode, 'text')
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 getCumulativeVector3Remove(defaultVector3, elementNode, prefix):
"Get cumulative vector3 and delete the prefixed attributes."
if prefix == "":
defaultVector3.x = evaluate.getEvaluatedFloat(defaultVector3.x, elementNode, "x")
defaultVector3.y = evaluate.getEvaluatedFloat(defaultVector3.y, elementNode, "y")
defaultVector3.z = evaluate.getEvaluatedFloat(defaultVector3.z, elementNode, "z")
euclidean.removeElementsFromDictionary(elementNode.attributes, ["x", "y", "z"])
prefix = "cartesian"
defaultVector3 = evaluate.getVector3ByPrefix(defaultVector3, elementNode, prefix)
euclidean.removePrefixFromDictionary(elementNode.attributes, prefix)
return defaultVector3
def __init__(self, xmlElement):
'Set defaults.'
end = evaluate.getVector3ByPrefix(None, 'end', xmlElement)
start = evaluate.getVector3ByPrefix(Vector3(), 'start', xmlElement)
inclinationDegree = math.degrees(getInclination(end, start))
self.inclination = math.radians(evaluate.getEvaluatedFloat(inclinationDegree, 'inclination', xmlElement))
self.radius = lineation.getFloatByPrefixBeginEnd('radius', 'diameter', 1.0, xmlElement)
size = evaluate.getEvaluatedFloat(None, 'size', xmlElement)
if size != None:
self.radius = 0.5 * size
self.xmlElement = xmlElement
def getCumulativeVector3Remove(defaultVector3, elementNode, prefix): 'Get cumulative vector3 and delete the prefixed attributes.' if prefix == '': defaultVector3.x = evaluate.getEvaluatedFloat(defaultVector3.x, elementNode, 'x') defaultVector3.y = evaluate.getEvaluatedFloat(defaultVector3.y, elementNode, 'y') defaultVector3.z = evaluate.getEvaluatedFloat(defaultVector3.z, elementNode, 'z') euclidean.removeElementsFromDictionary(elementNode.attributes, ['x', 'y', 'z']) prefix = 'cartesian' defaultVector3 = evaluate.getVector3ByPrefix(defaultVector3, elementNode, prefix) euclidean.removePrefixFromDictionary(elementNode.attributes, prefix) return defaultVector3
def getCumulativeVector3Remove(defaultVector3, prefix, xmlElement): """Get cumulative vector3 and delete the prefixed attributes.""" if prefix == '': defaultVector3.x = evaluate.getEvaluatedFloat(defaultVector3.x, 'x', xmlElement) defaultVector3.y = evaluate.getEvaluatedFloat(defaultVector3.y, 'y', xmlElement) defaultVector3.z = evaluate.getEvaluatedFloat(defaultVector3.z, 'z', xmlElement) euclidean.removeElementsFromDictionary(xmlElement.attributeDictionary, ['x', 'y', 'z']) prefix = 'cartesian' defaultVector3 = evaluate.getVector3ByPrefix(defaultVector3, prefix, xmlElement) euclidean.removePrefixFromDictionary(xmlElement.attributeDictionary, prefix) return defaultVector3
def getComplexByPrefix( prefix, valueComplex, xmlElement ): "Get complex from prefix and xml element." value = evaluate.getEvaluatedValue(prefix, xmlElement) if value != None: valueComplex = getComplexByDictionaryListValue(value, valueComplex) x = evaluate.getEvaluatedFloat(prefix + '.x', xmlElement) if x != None: valueComplex = complex( x, getComplexIfNone( valueComplex ).imag ) y = evaluate.getEvaluatedFloat(prefix + '.y', xmlElement) if y != None: valueComplex = complex( getComplexIfNone( valueComplex ).real, y ) return valueComplex
def getComplexByPrefix(elementNode, prefix, valueComplex): 'Get complex from prefix and xml element.' value = evaluate.getEvaluatedValue(None, elementNode, prefix) if value != None: valueComplex = getComplexByDictionaryListValue(value, valueComplex) x = evaluate.getEvaluatedFloat(None, elementNode, prefix + '.x') if x != None: valueComplex = complex( x, getComplexIfNone( valueComplex ).imag ) y = evaluate.getEvaluatedFloat(None, elementNode, prefix + '.y') if y != None: valueComplex = complex( getComplexIfNone( valueComplex ).real, y ) return valueComplex
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.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, elementNode):
'Set defaults.'
self.axisEnd = evaluate.getVector3ByPrefix(None, elementNode, 'axisEnd')
self.axisStart = evaluate.getVector3ByPrefix(None, elementNode, 'axisStart')
self.end = evaluate.getEvaluatedFloat(360.0, elementNode, 'end')
self.loop = evaluate.getTransformedPathByKey([], elementNode, 'loop')
self.sides = evaluate.getEvaluatedInt(None, elementNode, 'sides')
self.start = evaluate.getEvaluatedFloat(0.0, elementNode, 'start')
self.target = evaluate.getTransformedPathsByKey([], elementNode, 'target')
if len(self.target) < 1:
print('Warning, no target in derive in lathe for:')
print(elementNode)
return
firstPath = self.target[0]
if len(firstPath) < 3:
print('Warning, firstPath length is less than three in derive in lathe for:')
print(elementNode)
self.target = []
return
if self.axisStart == None:
if self.axisEnd == None:
self.axisStart = firstPath[0]
self.axisEnd = firstPath[-1]
else:
self.axisStart = Vector3()
self.axis = self.axisEnd - self.axisStart
axisLength = abs(self.axis)
if axisLength <= 0.0:
print('Warning, axisLength is zero in derive in lathe for:')
print(elementNode)
self.target = []
return
self.axis /= axisLength
firstVector3 = firstPath[1] - self.axisStart
firstVector3Length = abs(firstVector3)
if firstVector3Length <= 0.0:
print('Warning, firstVector3Length is zero in derive in lathe for:')
print(elementNode)
self.target = []
return
firstVector3 /= firstVector3Length
self.axisProjectiveSpace = euclidean.ProjectiveSpace().getByBasisZFirst(self.axis, firstVector3)
if self.sides == None:
distanceToLine = euclidean.getDistanceToLineByPaths(self.axisStart, self.axisEnd, self.target)
self.sides = evaluate.getSidesMinimumThreeBasedOnPrecisionSides(elementNode, distanceToLine)
endRadian = math.radians(self.end)
startRadian = math.radians(self.start)
self.isEndCloseToStart = euclidean.getIsRadianClose(endRadian, startRadian)
if len(self.loop) < 1:
self.loop = euclidean.getComplexPolygonByStartEnd(endRadian, 1.0, self.sides, startRadian)
self.normal = euclidean.getNormalByPath(firstPath)
def __init__(self, elementNode): 'Set defaults.' self.radius = lineation.getRadiusComplex(elementNode, complex(1.0, 1.0)) self.sides = evaluate.getEvaluatedFloat(None, elementNode, 'sides') if self.sides == None: radiusMaximum = max(self.radius.real, self.radius.imag) self.sides = evaluate.getSidesMinimumThreeBasedOnPrecisionSides(elementNode, radiusMaximum) self.radiusArealized = evaluate.getRadiusArealizedBasedOnAreaRadius(elementNode, self.radius, self.sides) self.start = evaluate.getEvaluatedFloat(0.0, elementNode, 'start') end = evaluate.getEvaluatedFloat(360.0, elementNode, 'end') self.revolutions = evaluate.getEvaluatedFloat(1.0, elementNode, 'revolutions') self.extent = evaluate.getEvaluatedFloat(end - self.start, elementNode, 'extent') self.extent += 360.0 * (self.revolutions - 1.0) self.spiral = evaluate.getVector3ByPrefix(None, elementNode, 'spiral')
def __init__(self, elementNode):
'Set defaults.'
self.length = evaluate.getEvaluatedFloat(50.0, elementNode, 'length')
self.demilength = 0.5 * self.length
self.elementNode = elementNode
self.radius = lineation.getFloatByPrefixBeginEnd(elementNode, 'radius', 'diameter', 5.0)
self.cageClearanceOverRadius = evaluate.getEvaluatedFloat(0.05, elementNode, 'cageClearanceOverRadius')
self.cageClearance = self.cageClearanceOverRadius * self.radius
self.cageClearance = evaluate.getEvaluatedFloat(self.cageClearance, elementNode, 'cageClearance')
self.racewayClearanceOverRadius = evaluate.getEvaluatedFloat(0.1, elementNode, 'racewayClearanceOverRadius')
self.racewayClearance = self.racewayClearanceOverRadius * self.radius
self.racewayClearance = evaluate.getEvaluatedFloat(self.racewayClearance, elementNode, 'racewayClearance')
self.typeMenuRadioStrings = 'assembly integral'.split()
self.typeString = evaluate.getEvaluatedString('assembly', elementNode, 'type')
self.typeStringFirstCharacter = self.typeString[: 1 ].lower()
self.wallThicknessOverRadius = evaluate.getEvaluatedFloat(0.5, elementNode, 'wallThicknessOverRadius')
self.wallThickness = self.wallThicknessOverRadius * self.radius
self.wallThickness = evaluate.getEvaluatedFloat(self.wallThickness, elementNode, 'wallThickness')
self.zenithAngle = evaluate.getEvaluatedFloat(45.0, elementNode, 'zenithAngle')
self.zenithRadian = math.radians(self.zenithAngle)
self.demiheight = self.radius * math.cos(self.zenithRadian) - self.racewayClearance
self.height = self.demiheight + self.demiheight
self.radiusPlusClearance = self.radius + self.cageClearance
self.cageRadius = self.radiusPlusClearance + self.wallThickness
self.demiwidth = self.cageRadius
self.bearingCenterX = self.cageRadius - self.demilength
separation = self.cageRadius + self.radiusPlusClearance
bearingLength = -self.bearingCenterX - self.bearingCenterX
self.numberOfSteps = int(math.floor(bearingLength / separation))
self.stepX = bearingLength / float(self.numberOfSteps)
self.bearingCenterXs = getBearingCenterXs(self.bearingCenterX, self.numberOfSteps, self.stepX)
if self.typeStringFirstCharacter == 'a':
self.setAssemblyCage()
self.rectangleCenterX = self.demiwidth - self.demilength
def rotate(self, elementNode): 'Rotate.' rotation = math.radians(evaluate.getEvaluatedFloat(0.0, elementNode, 'rotation')) rotation += evaluate.getEvaluatedFloat(0.0, elementNode, 'rotationOverSide') * self.sideAngle if rotation != 0.0: planeRotation = euclidean.getWiddershinsUnitPolar( rotation ) for vertex in self.loop: rotatedComplex = vertex.dropAxis() * planeRotation vertex.x = rotatedComplex.real vertex.y = rotatedComplex.imag if 'clockwise' in elementNode.attributes: isClockwise = euclidean.getBooleanFromValue(evaluate.getEvaluatedValueObliviously(elementNode, 'clockwise')) if isClockwise == euclidean.getIsWiddershinsByVector3( self.loop ): self.loop.reverse()
def __init__(self, elementNode):
'Set defaults.'
self.fileName = evaluate.getEvaluatedString('', elementNode, 'file')
self.heightGrid = evaluate.getEvaluatedValue([], elementNode, 'heightGrid')
self.inradius = evaluate.getVector3ByPrefixes(elementNode, ['demisize', 'inradius'], Vector3(10.0, 10.0, 5.0))
self.inradius = evaluate.getVector3ByMultiplierPrefix(elementNode, 2.0, 'size', self.inradius)
self.start = evaluate.getEvaluatedFloat(0.0, elementNode, 'start')
def setTopOverBottomByRadius(derivation, endZ, radius, startZ):
"Set the derivation topOverBottom by the angle of the elementNode, the endZ, float radius and startZ."
angleDegrees = evaluate.getEvaluatedFloat(None, derivation.elementNode, "angle")
if angleDegrees != None:
derivation.topOverBottom = cylinder.getTopOverBottom(
math.radians(angleDegrees), endZ, complex(radius, radius), startZ
)
def __init__(self, xmlElement):
'Set defaults.'
self.fileName = evaluate.getEvaluatedString('', 'file', xmlElement)
self.heightGrid = evaluate.getEvaluatedValue([], 'heightGrid', xmlElement)
self.inradius = evaluate.getVector3ByPrefixes(['demisize', 'inradius'], Vector3(10.0, 10.0, 5.0), xmlElement)
self.inradius = evaluate.getVector3ByMultiplierPrefix(2.0, 'size', self.inradius, xmlElement)
self.start = evaluate.getEvaluatedFloat(0.0, 'start', xmlElement)
def getCascadeFloat(self, defaultFloat, key): 'Get the cascade float.' if key in self.attributes: value = evaluate.getEvaluatedFloat(None, self, key) if value != None: return value return self.parentNode.getCascadeFloat(defaultFloat, key)
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 is 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 setToXMLElement(self, xmlElement): """Set to xmlElement.""" attributeDictionary = xmlElement.attributeDictionary self.inradius = evaluate.getVector3ByPrefixes(['demisize', 'inradius', 'radius'], Vector3(1.0, 1.0, 1.0), xmlElement) self.inradius = evaluate.getVector3ByMultiplierPrefixes(2.0, ['diameter', 'size'], self.inradius, xmlElement) self.inradius.z = 0.5 * evaluate.getEvaluatedFloat(self.inradius.z + self.inradius.z, 'height', xmlElement) self.topOverBottom = evaluate.getEvaluatedFloat(1.0, 'topOverBottom', xmlElement ) self.xmlElement = xmlElement if 'inradius' in attributeDictionary: del attributeDictionary['inradius'] attributeDictionary['height'] = self.inradius.z + self.inradius.z attributeDictionary['radius.x'] = self.inradius.x attributeDictionary['radius.y'] = self.inradius.y attributeDictionary['topOverBottom'] = self.topOverBottom self.createShape() self.liftByMinimumZ(-self.inradius.z) solid.processArchiveRemoveSolid(self.getGeometryOutput(), xmlElement)
def setToElementNode(self, elementNode): 'Set to elementNode.' attributes = elementNode.attributes self.elementNode = elementNode self.inradius = evaluate.getVector3ByPrefixes(elementNode, ['demisize', 'inradius', 'radius'], Vector3(1.0, 1.0, 1.0)) self.inradius = evaluate.getVector3ByMultiplierPrefixes(elementNode, 2.0, ['diameter', 'size'], self.inradius) self.inradius.z = 0.5 * evaluate.getEvaluatedFloat(self.inradius.z + self.inradius.z, elementNode, 'height') self.topOverBottom = evaluate.getEvaluatedFloat(1.0, elementNode, 'topOverBottom') if 'inradius' in attributes: del attributes['inradius'] attributes['height'] = self.inradius.z + self.inradius.z attributes['radius.x'] = self.inradius.x attributes['radius.y'] = self.inradius.y attributes['topOverBottom'] = self.topOverBottom self.createShape() self.liftByMinimumZ(-self.inradius.z) solid.processArchiveRemoveSolid(elementNode, self.getGeometryOutput())
def liftByMinimumZ(self, minimumZ):
"Lift the triangle mesh to the altitude."
altitude = evaluate.getEvaluatedFloat(None, "altitude", self.xmlElement)
if altitude == None:
return
lift = altitude - minimumZ
for vertex in self.vertexes:
vertex.z += lift
def __init__(self, elementNode): 'Set defaults.' end = evaluate.getVector3ByPrefix(None, elementNode, 'end') start = evaluate.getVector3ByPrefix(Vector3(), elementNode, 'start') inclinationDegree = math.degrees(getInclination(end, start)) self.elementNode = elementNode self.inclination = math.radians(evaluate.getEvaluatedFloat(inclinationDegree, elementNode, 'inclination')) self.overhangRadians = setting.getOverhangRadians(elementNode) self.overhangSpan = setting.getOverhangSpan(elementNode) self.radius = lineation.getFloatByPrefixBeginEnd(elementNode, 'radius', 'diameter', 1.0) size = evaluate.getEvaluatedFloat(None, elementNode, 'size') if size != None: self.radius = 0.5 * size self.sides = evaluate.getEvaluatedFloat(None, elementNode, 'sides') if self.sides == None: self.sides = evaluate.getSidesMinimumThreeBasedOnPrecisionSides(elementNode, self.radius) self.radiusArealized = evaluate.getRadiusArealizedBasedOnAreaRadius(elementNode, self.radius, self.sides)
def getFloatByPrefixSide(defaultValue, elementNode, prefix, side): 'Get float by prefix and side.' if elementNode == None: return defaultValue if side != None: key = prefix + 'OverSide' if key in elementNode.attributes: defaultValue = euclidean.getFloatFromValue(evaluate.getEvaluatedValueObliviously(elementNode, key)) * side return evaluate.getEvaluatedFloat(defaultValue, elementNode, prefix)
def __init__(self, elementNode): 'Set defaults.' self.elementNode = elementNode self.end = evaluate.getVector3ByPrefix(Vector3(0.0, 0.0, 1.0), elementNode, 'end') self.start = evaluate.getVector3ByPrefix(Vector3(), elementNode, 'start') self.radius = lineation.getFloatByPrefixBeginEnd(elementNode, 'radius', 'diameter', 1.0) size = evaluate.getEvaluatedFloat(None, elementNode, 'size') if size is not None: self.radius = 0.5 * size
def __init__(self, elementNode, prefix): 'Set defaults.' self.radius = evaluate.getEvaluatedFloat(2.0 * setting.getPerimeterWidth(elementNode), elementNode, prefix + 'radius')
def getFloatByPrefixSide(prefix, side, xmlElement):
'Get float by prefix and side.'
floatByDenominatorPrefix = evaluate.getEvaluatedFloat(
0.0, prefix, xmlElement)
return floatByDenominatorPrefix + evaluate.getEvaluatedFloat(
0.0, prefix + 'OverSide', xmlElement) * side
def __init__(self, elementNode, prefix): 'Set defaults.' self.overhangRadians = setting.getOverhangRadians(elementNode) self.overhangInclinationRadians = math.radians(evaluate.getEvaluatedFloat(0.0, elementNode, prefix + 'inclination'))
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 getFloatByPrefixBeginEnd(elementNode, prefixBegin, prefixEnd, valueFloat): 'Get float from prefixBegin, prefixEnd and xml element.' valueFloat = evaluate.getEvaluatedFloat(valueFloat, elementNode, prefixBegin) if prefixEnd in elementNode.attributes: return 0.5 * evaluate.getEvaluatedFloat(valueFloat + valueFloat, elementNode, prefixEnd) return valueFloat
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 __init__(self, xmlElement):
'Set defaults.'
self.bevelOverRadius = evaluate.getEvaluatedFloat(0.2, 'bevelOverRadius', xmlElement)
self.boltRadiusOverRadius = evaluate.getEvaluatedFloat(0.0, 'boltRadiusOverRadius', xmlElement)
self.columns = evaluate.getEvaluatedInt(2, 'columns', xmlElement)
self.heightOverRadius = evaluate.getEvaluatedFloat(2.0, 'heightOverRadius', xmlElement)
self.interiorOverhangRadians = setting.getInteriorOverhangRadians(xmlElement)
self.overhangSpan = setting.getOverhangSpan(xmlElement)
self.pegClearanceOverRadius = evaluate.getEvaluatedFloat(0.0, 'pegClearanceOverRadius', xmlElement)
self.pegRadians = math.radians(evaluate.getEvaluatedFloat(2.0, 'pegAngle', xmlElement))
self.pegHeightOverHeight = evaluate.getEvaluatedFloat(0.4, 'pegHeightOverHeight', xmlElement)
self.pegRadiusOverRadius = evaluate.getEvaluatedFloat(0.7, 'pegRadiusOverRadius', xmlElement)
self.radius = lineation.getFloatByPrefixBeginEnd('radius', 'width', 5.0, xmlElement)
self.rows = evaluate.getEvaluatedInt(1, 'rows', xmlElement)
self.topBevelOverRadius = evaluate.getEvaluatedFloat(0.2, 'topBevelOverRadius', xmlElement)
self.xmlElement = xmlElement
# Set derived values.
self.bevel = evaluate.getEvaluatedFloat(self.bevelOverRadius * self.radius, 'bevel', xmlElement)
self.boltRadius = evaluate.getEvaluatedFloat(self.boltRadiusOverRadius * self.radius, 'boltRadius', xmlElement)
self.boltSides = evaluate.getSidesMinimumThreeBasedOnPrecision(self.boltRadius, xmlElement)
self.bottomLeftCenter = complex(-float(self.columns - 1), -float(self.rows - 1)) * self.radius
self.height = evaluate.getEvaluatedFloat(self.heightOverRadius * self.radius, 'height', xmlElement)
self.hollowPegSockets = []
centerY = self.bottomLeftCenter.imag
diameter = self.radius + self.radius
self.pegExistence = CellExistence(self.columns, self.rows, evaluate.getEvaluatedValue(None, 'pegs', xmlElement))
self.socketExistence = CellExistence(self.columns, self.rows, evaluate.getEvaluatedValue(None, 'sockets', xmlElement))
for rowIndex in xrange(self.rows):
centerX = self.bottomLeftCenter.real
for columnIndex in xrange(self.columns):
hollowPegSocket = HollowPegSocket(complex(centerX, centerY))
hollowPegSocket.shouldAddPeg = self.pegExistence.getIsInExistence(columnIndex, rowIndex)
hollowPegSocket.shouldAddSocket = self.socketExistence.getIsInExistence(columnIndex, rowIndex)
self.hollowPegSockets.append(hollowPegSocket)
centerX += diameter
centerY += diameter
self.pegClearance = evaluate.getEvaluatedFloat(self.pegClearanceOverRadius * self.radius, 'pegClearance', xmlElement)
halfPegClearance = 0.5 * self.pegClearance
self.pegHeight = evaluate.getEvaluatedFloat(self.pegHeightOverHeight * self.height, 'pegHeight', xmlElement)
self.pegRadius = evaluate.getEvaluatedFloat(self.pegRadiusOverRadius * self.radius, 'pegRadius', xmlElement)
sides = 24 * max(1, math.floor(evaluate.getSidesBasedOnPrecision(self.pegRadius, xmlElement) / 24))
self.socketRadius = self.pegRadius + halfPegClearance
self.pegSides = evaluate.getEvaluatedInt(sides, 'pegSides', xmlElement)
self.socketSides = evaluate.getEvaluatedInt(sides, 'socketSides', xmlElement)
self.pegRadius -= halfPegClearance
self.topBevel = evaluate.getEvaluatedFloat(self.topBevelOverRadius * self.radius, 'topBevel', xmlElement)
self.topBevelPositions = evaluate.getEvaluatedString('nwse', 'topBevelPositions', xmlElement).lower()
self.topRight = complex(float(self.columns), float(self.rows)) * self.radius
def setTopOverBottomByRadius(derivation, endZ, radius, startZ): 'Set the derivation topOverBottom by the angle of the elementNode, the endZ, float radius and startZ.' angleDegrees = evaluate.getEvaluatedFloat(None, derivation.elementNode, 'angle') if angleDegrees != None: derivation.topOverBottom = cylinder.getTopOverBottom(math.radians(angleDegrees), endZ, complex(radius, radius), startZ)
def __init__(self, elementNode):
'Set defaults.'
self.axisEnd = evaluate.getVector3ByPrefix(None, elementNode,
'axisEnd')
self.axisStart = evaluate.getVector3ByPrefix(None, elementNode,
'axisStart')
self.end = evaluate.getEvaluatedFloat(360.0, elementNode, 'end')
self.loop = evaluate.getTransformedPathByKey([], elementNode, 'loop')
self.sides = evaluate.getEvaluatedInt(None, elementNode, 'sides')
self.start = evaluate.getEvaluatedFloat(0.0, elementNode, 'start')
self.target = evaluate.getTransformedPathsByKey([], elementNode,
'target')
if len(self.target) < 1:
print('Warning, no target in derive in lathe for:')
print(elementNode)
return
firstPath = self.target[0]
if len(firstPath) < 3:
print(
'Warning, firstPath length is less than three in derive in lathe for:'
)
print(elementNode)
self.target = []
return
if self.axisStart == None:
if self.axisEnd == None:
self.axisStart = firstPath[0]
self.axisEnd = firstPath[-1]
else:
self.axisStart = Vector3()
self.axis = self.axisEnd - self.axisStart
axisLength = abs(self.axis)
if axisLength <= 0.0:
print('Warning, axisLength is zero in derive in lathe for:')
print(elementNode)
self.target = []
return
self.axis /= axisLength
firstVector3 = firstPath[1] - self.axisStart
firstVector3Length = abs(firstVector3)
if firstVector3Length <= 0.0:
print(
'Warning, firstVector3Length is zero in derive in lathe for:')
print(elementNode)
self.target = []
return
firstVector3 /= firstVector3Length
self.axisProjectiveSpace = euclidean.ProjectiveSpace(
).getByBasisZFirst(self.axis, firstVector3)
if self.sides == None:
distanceToLine = euclidean.getDistanceToLineByPaths(
self.axisStart, self.axisEnd, self.target)
self.sides = evaluate.getSidesMinimumThreeBasedOnPrecisionSides(
elementNode, distanceToLine)
endRadian = math.radians(self.end)
startRadian = math.radians(self.start)
self.isEndCloseToStart = euclidean.getIsRadianClose(
endRadian, startRadian)
if len(self.loop) < 1:
self.loop = euclidean.getComplexPolygonByStartEnd(
endRadian, 1.0, self.sides, startRadian)
self.normal = euclidean.getNormalByPath(firstPath)
def setAssemblyCage(self): 'Set two piece assembly parameters.' self.grooveDepthOverRadius = evaluate.getEvaluatedFloat(0.15, self.elementNode, 'grooveDepthOverRadius') self.grooveDepth = self.grooveDepthOverRadius * self.radius self.grooveDepth = evaluate.getEvaluatedFloat(self.grooveDepth, self.elementNode, 'grooveDepth') self.grooveWidthOverRadius = evaluate.getEvaluatedFloat(0.6, self.elementNode, 'grooveWidthOverRadius') self.grooveWidth = self.grooveWidthOverRadius * self.radius self.grooveWidth = evaluate.getEvaluatedFloat(self.grooveWidth, self.elementNode, 'grooveWidth') self.pegClearanceOverRadius = evaluate.getEvaluatedFloat(0.0, self.elementNode, 'pegClearanceOverRadius') self.pegClearance = self.pegClearanceOverRadius * self.radius self.pegClearance = evaluate.getEvaluatedFloat(self.pegClearance, self.elementNode, 'pegClearance') self.halfPegClearance = 0.5 * self.pegClearance self.pegRadiusOverRadius = evaluate.getEvaluatedFloat(0.5, self.elementNode, 'pegRadiusOverRadius') self.pegRadius = self.pegRadiusOverRadius * self.radius self.pegRadius = evaluate.getEvaluatedFloat(self.pegRadius, self.elementNode, 'pegRadius') self.sides = evaluate.getSidesMinimumThreeBasedOnPrecision(self.elementNode, self.pegRadius) self.pegRadiusArealized = evaluate.getRadiusArealizedBasedOnAreaRadius(self.elementNode, self.pegRadius, self.sides) self.pegBevelOverPegRadius = evaluate.getEvaluatedFloat(0.25, self.elementNode, 'pegBevelOverPegRadius') self.pegBevel = self.pegBevelOverPegRadius * self.pegRadiusArealized self.pegBevel = evaluate.getEvaluatedFloat(self.pegBevel, self.elementNode, 'pegBevel') self.pegMaximumRadius = self.pegRadiusArealized + abs(self.halfPegClearance) self.separationOverRadius = evaluate.getEvaluatedFloat(0.5, self.elementNode, 'separationOverRadius') self.separation = self.separationOverRadius * self.radius self.separation = evaluate.getEvaluatedFloat(self.separation, self.elementNode, 'separation') self.topOverBottom = evaluate.getEvaluatedFloat(0.8, self.elementNode, 'topOverBottom') peg.setTopOverBottomByRadius(self, 0.0, self.pegRadiusArealized, self.height) self.quarterHeight = 0.5 * self.demiheight self.pegY = 0.5 * self.wallThickness + self.pegMaximumRadius cagePegRadius = self.cageRadius + self.pegMaximumRadius halfStepX = 0.5 * self.stepX pegHypotenuse = math.sqrt(self.pegY * self.pegY + halfStepX * halfStepX) if cagePegRadius > pegHypotenuse: self.pegY = math.sqrt(cagePegRadius * cagePegRadius - halfStepX * halfStepX) self.demiwidth = max(self.pegY + self.pegMaximumRadius + self.wallThickness, self.demiwidth) self.innerDemiwidth = self.demiwidth self.demiwidth += self.grooveDepth self.halfSeparationWidth = self.demiwidth + 0.5 * self.separation if self.pegRadiusArealized <= 0.0: self.pegCenterXs = [] else: self.pegCenterXs = getPegCenterXs(self.numberOfSteps, self.bearingCenterX + halfStepX, self.stepX)
