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)