def setToXMLElement(self, xmlElement): "Set to the xmlElement." self.radius = lineation.getRadiusComplex(self.radius, xmlElement) self.tiltFollow = evaluate.getEvaluatedBooleanDefault(self.tiltFollow, "tiltfollow", xmlElement) self.tiltTop = evaluate.getVector3ByPrefix("tilttop", self.tiltTop, xmlElement) self.maximumUnbuckling = evaluate.getEvaluatedFloatDefault( self.maximumUnbuckling, "maximumUnbuckling", xmlElement ) self.interpolationDictionary["scale"] = Interpolation().getByPrefixZ(self.scalePathDefault, "scale", xmlElement) if len(self.target) < 1: self.target = evaluate.getTransformedPathsByKey("target", xmlElement) if self.tiltTop == None: self.interpolationDictionary["offset"] = Interpolation().getByPrefixZ( self.offsetPathDefault, "", xmlElement ) self.interpolationDictionary["tilt"] = Interpolation().getByPrefixZ( self.tiltPathDefault, "tilt", xmlElement ) for point in self.interpolationDictionary["tilt"].path: point.x = math.radians(point.x) point.y = math.radians(point.y) else: self.interpolationDictionary["offset"] = Interpolation().getByPrefixAlong( self.offsetAlongDefault, "", xmlElement ) self.twist = evaluate.getEvaluatedFloatDefault(self.twist, "twist", xmlElement) if self.twist != 0.0: self.twistPathDefault = [Vector3(), Vector3(1.0, self.twist)] insertTwistPortions(self, xmlElement)
def __init__(self, xmlElement): 'Initialize.' self.interpolationDictionary = {} self.radius = lineation.getRadiusComplex(complex(), xmlElement) self.tiltFollow = evaluate.getEvaluatedBooleanDefault( True, 'tiltFollow', xmlElement) self.tiltTop = evaluate.getVector3ByPrefix(None, 'tiltTop', xmlElement) self.maximumUnbuckling = evaluate.getEvaluatedFloatDefault( 5.0, 'maximumUnbuckling', xmlElement) scalePathDefault = [Vector3(1.0, 1.0, 0.0), Vector3(1.0, 1.0, 1.0)] self.interpolationDictionary['scale'] = Interpolation().getByPrefixZ( scalePathDefault, 'scale', xmlElement) self.target = evaluate.getTransformedPathsByKey([], 'target', xmlElement) if self.tiltTop == None: offsetPathDefault = [Vector3(), Vector3(0.0, 0.0, 1.0)] self.interpolationDictionary['offset'] = Interpolation( ).getByPrefixZ(offsetPathDefault, '', xmlElement) tiltPathDefault = [Vector3(), Vector3(0.0, 0.0, 1.0)] self.interpolationDictionary['tilt'] = Interpolation( ).getByPrefixZ(tiltPathDefault, 'tilt', xmlElement) for point in self.interpolationDictionary['tilt'].path: point.x = math.radians(point.x) point.y = math.radians(point.y) else: offsetAlongDefault = [Vector3(), Vector3(1.0, 0.0, 0.0)] self.interpolationDictionary['offset'] = Interpolation( ).getByPrefixAlong(offsetAlongDefault, '', xmlElement) self.twist = evaluate.getEvaluatedFloatDefault(0.0, 'twist', xmlElement) self.twistPathDefault = [Vector3(), Vector3(1.0, self.twist)] insertTwistPortions(self, xmlElement)
def getFloatByPrefixBeginEnd(prefixBegin, prefixEnd, valueFloat, xmlElement): "Get float from prefixBegin, prefixEnd and xml element." valueFloat = evaluate.getEvaluatedFloatDefault(valueFloat, prefixBegin, xmlElement) if prefixEnd in xmlElement.attributeDictionary: return 0.5 * evaluate.getEvaluatedFloatDefault(valueFloat + valueFloat, prefixEnd, xmlElement) else: return valueFloat
def getGeometryOutput(xmlElement): "Get vector3 vertexes from attribute dictionary." radius = lineation.getRadiusComplex(complex(1.0, 1.0), xmlElement) sides = evaluate.getSidesMinimumThreeBasedOnPrecisionSides(max(radius.real, radius.imag), xmlElement) loop = [] start = evaluate.getEvaluatedFloatZero('start', xmlElement) start = getWrappedFloat(start, 360.0) extent = evaluate.getEvaluatedFloatDefault(360.0 - start, 'extent', xmlElement) end = evaluate.getEvaluatedFloatDefault(start + extent, 'end', xmlElement) end = getWrappedFloat(end, 360.0) revolutions = evaluate.getEvaluatedFloatOne('revolutions', xmlElement) if revolutions > 1: end += 360.0 * (revolutions - 1) angleTotal = math.radians(start) extent = end - start sidesCeiling = int(math.ceil(abs(sides) * extent / 360.0)) sideAngle = math.radians(extent) / sidesCeiling spiral = lineation.Spiral(0.5 * sideAngle / math.pi, xmlElement) for side in xrange(sidesCeiling + (extent != 360.0)): unitPolar = euclidean.getWiddershinsUnitPolar(angleTotal) vertex = spiral.getSpiralPoint(unitPolar, Vector3(unitPolar.real * radius.real, unitPolar.imag * radius.imag)) angleTotal += sideAngle loop.append(vertex) sideLength = sideAngle * lineation.getAverageRadius(radius) lineation.setClosedAttribute(revolutions, xmlElement) return lineation.getGeometryOutputByLoop(lineation.SideLoop(loop, sideAngle, sideLength), xmlElement)
def setToXMLElement(self, xmlElement): "Set to the xmlElement." self.radius = lineation.getRadiusComplex(self.radius, xmlElement) self.tiltFollow = evaluate.getEvaluatedBooleanDefault( self.tiltFollow, 'tiltfollow', xmlElement) self.tiltTop = evaluate.getVector3ByPrefix(self.tiltTop, 'tilttop', xmlElement) self.maximumUnbuckling = evaluate.getEvaluatedFloatDefault( self.maximumUnbuckling, 'maximumUnbuckling', xmlElement) self.interpolationDictionary['scale'] = Interpolation().getByPrefixZ( self.scalePathDefault, 'scale', xmlElement) if len(self.target) < 1: self.target = evaluate.getTransformedPathsByKey( 'target', xmlElement) if self.tiltTop == None: self.interpolationDictionary['offset'] = Interpolation( ).getByPrefixZ(self.offsetPathDefault, '', xmlElement) self.interpolationDictionary['tilt'] = Interpolation( ).getByPrefixZ(self.tiltPathDefault, 'tilt', xmlElement) for point in self.interpolationDictionary['tilt'].path: point.x = math.radians(point.x) point.y = math.radians(point.y) else: self.interpolationDictionary['offset'] = Interpolation( ).getByPrefixAlong(self.offsetAlongDefault, '', xmlElement) self.twist = evaluate.getEvaluatedFloatDefault(self.twist, 'twist', xmlElement) if self.twist != 0.0: self.twistPathDefault = [Vector3(), Vector3(1.0, self.twist)] insertTwistPortions(self, xmlElement)
def getGeometryOutput(xmlElement): "Get vector3 vertexes from attribute dictionary." fontFamily = evaluate.getEvaluatedStringDefault('Gentium Basic Regular', 'font-family', xmlElement) fontFamily = evaluate.getEvaluatedStringDefault(fontFamily, 'fontFamily', xmlElement) fontSize = evaluate.getEvaluatedFloatDefault(12.0, 'font-size', xmlElement) fontSize = evaluate.getEvaluatedFloatDefault(fontSize, 'fontSize', xmlElement) textString = evaluate.getEvaluatedStringDefault(xmlElement.text, 'text', xmlElement) if textString == '': print('Warning, textString is empty in getGeometryOutput in text for:') print(xmlElement) return [] geometryOutput = [] for textComplexLoop in svg_reader.getTextComplexLoops( fontFamily, fontSize, textString): textComplexLoop.reverse() vector3Path = euclidean.getVector3Path(textComplexLoop) sideLoop = lineation.SideLoop(vector3Path, None, None) sideLoop.rotate(xmlElement) geometryOutput += lineation.getGeometryOutputByManipulation( sideLoop, xmlElement) return geometryOutput
def getGeometryOutput(xmlElement): "Get vector3 vertices from attribute dictionary." radius = complex(1.0, 1.0) radius = lineation.getComplexByPrefixes(['demisize', 'radius'], radius, xmlElement) radius = lineation.getComplexByMultiplierPrefixes(2.0, ['diameter', 'size'], radius, xmlElement) sides = evaluate.getSidesMinimumThree(max(radius.real, radius.imag), xmlElement) sides = evaluate.getEvaluatedFloatDefault(sides, 'sides', xmlElement) loop = [] start = evaluate.getEvaluatedFloatZero('start', xmlElement) start = getWrappedFloat(start, 360.0) extent = evaluate.getEvaluatedFloatDefault(360.0 - start, 'extent', xmlElement) end = evaluate.getEvaluatedFloatDefault(start + extent, 'end', xmlElement) end = getWrappedFloat(end, 360.0) revolutions = evaluate.getEvaluatedFloatOne('revolutions', xmlElement) if revolutions > 1: end += 360.0 * (revolutions - 1) sidesCeiling = int(math.ceil(abs(sides) * extent / 360.0)) sideAngle = math.radians(extent) / sidesCeiling startAngle = math.radians(start) for side in xrange(sidesCeiling + (extent != 360.0)): angle = float(side) * sideAngle + startAngle point = euclidean.getWiddershinsUnitPolar(angle) vertex = Vector3(point.real * radius.real, point.imag * radius.imag) loop.append(vertex) sideLength = sideAngle * lineation.getAverageRadius(radius) return lineation.getGeometryOutputByLoop(lineation.SideLoop(loop, sideAngle, sideLength), xmlElement)
def setToXMLElement(self, xmlElement): "Set to the xmlElement." self.closed = evaluate.getEvaluatedBooleanDefault(False, 'closed', xmlElement) self.end = evaluate.getVector3ByPrefix('end', self.end, xmlElement) self.start = evaluate.getVector3ByPrefix('start', self.start, xmlElement) self.step = evaluate.getEvaluatedFloatDefault(self.step, 'step', xmlElement) self.steps = evaluate.getEvaluatedFloatDefault(self.steps, 'steps', xmlElement) self.typeString = evaluate.getEvaluatedStringDefault(self.typeString, 'type', xmlElement)
def __init__(self, xmlElement): 'Set defaults.' self.fontFamily = evaluate.getEvaluatedStringDefault('Gentium Basic Regular', 'font-family', xmlElement) self.fontFamily = evaluate.getEvaluatedStringDefault(self.fontFamily, 'fontFamily', xmlElement) self.fontSize = evaluate.getEvaluatedFloatDefault(12.0, 'font-size', xmlElement) self.fontSize = evaluate.getEvaluatedFloatDefault(self.fontSize, 'fontSize', xmlElement) self.textString = xmlElement.text self.textString = evaluate.getEvaluatedStringDefault(self.textString, 'text', xmlElement)
def __init__(self, xmlElement): 'Set defaults.' self.closed = evaluate.getEvaluatedBooleanDefault(False, 'closed', xmlElement) self.end = evaluate.getVector3ByPrefix(Vector3(), 'end', xmlElement) self.start = evaluate.getVector3ByPrefix(Vector3(), 'start', xmlElement) self.step = evaluate.getEvaluatedFloatDefault(None, 'step', xmlElement) self.steps = evaluate.getEvaluatedFloatDefault(None, 'steps', xmlElement) self.typeMenuRadioStrings = 'average maximum minimum'.split() self.typeString = evaluate.getEvaluatedStringDefault('minimum', 'type', xmlElement)
def setToXMLElementOnly(self, xmlElement): "Set to the xmlElement." self.axisEnd = evaluate.getVector3ByPrefix(self.axisEnd, 'axisEnd', xmlElement) self.axisStart = evaluate.getVector3ByPrefix(self.axisStart, 'axisStart', xmlElement) self.end = evaluate.getEvaluatedFloatDefault(self.end, 'end', xmlElement) self.loop = evaluate.getTransformedPathByKey('loop', xmlElement) self.sides = evaluate.getEvaluatedIntDefault(self.sides, 'sides', xmlElement) self.start = evaluate.getEvaluatedFloatDefault(self.start, 'start', xmlElement) self.target = evaluate.getTransformedPathsByKey('target', xmlElement)
def setToXMLElement(self, xmlElement): "Set to the xmlElement." self.fontFamily = evaluate.getEvaluatedStringDefault(self.fontFamily, "font-family", xmlElement) self.fontFamily = evaluate.getEvaluatedStringDefault(self.fontFamily, "fontFamily", xmlElement) self.fontSize = evaluate.getEvaluatedFloatDefault(self.fontSize, "font-size", xmlElement) self.fontSize = evaluate.getEvaluatedFloatDefault(self.fontSize, "fontSize", xmlElement) if self.textString == "": self.textString = xmlElement.text self.textString = evaluate.getEvaluatedStringDefault(self.textString, "text", xmlElement)
def getFloatByPrefixBeginEnd(prefixBegin, prefixEnd, valueFloat, xmlElement): "Get float from prefixBegin, prefixEnd and xml element." valueFloat = evaluate.getEvaluatedFloatDefault(valueFloat, prefixBegin, xmlElement) if prefixEnd in xmlElement.attributeDictionary: return 0.5 * evaluate.getEvaluatedFloatDefault(valueFloat + valueFloat, prefixEnd, xmlElement) else: return valueFloat
def setToXMLElement(self, xmlElement): "Set to the xmlElement." self.fontFamily = evaluate.getEvaluatedStringDefault(self.fontFamily, 'font-family', xmlElement) self.fontFamily = evaluate.getEvaluatedStringDefault(self.fontFamily, 'fontFamily', xmlElement) self.fontSize = evaluate.getEvaluatedFloatDefault(self.fontSize, 'font-size', xmlElement) self.fontSize = evaluate.getEvaluatedFloatDefault(self.fontSize, 'fontSize', xmlElement) if self.textString == '': self.textString = xmlElement.text self.textString = evaluate.getEvaluatedStringDefault(self.textString, 'text', xmlElement)
def setToObjectAttributeDictionary(self): "Set the shape of this carvable object info." self.inradius = evaluate.getVector3ByPrefixes(['demisize', 'inradius', 'radius'], Vector3(1.0, 1.0, 1.0), self.xmlElement) self.inradius = evaluate.getVector3ByMultiplierPrefixes(2.0, ['diameter', 'size'], self.inradius, self.xmlElement) self.inradius.z = 0.5 * evaluate.getEvaluatedFloatDefault(self.inradius.z + self.inradius.z, 'height', self.xmlElement) self.topOverBottom = evaluate.getEvaluatedFloatDefault(1.0, 'topoverbottom', self.xmlElement ) self.xmlElement.attributeDictionary['height'] = self.inradius.z + self.inradius.z self.xmlElement.attributeDictionary['radius.x'] = self.inradius.x self.xmlElement.attributeDictionary['radius.y'] = self.inradius.y self.xmlElement.attributeDictionary['topoverbottom'] = self.topOverBottom self.createShape()
def setToXMLElement(self, xmlElement): "Set to the xmlElement." end = evaluate.getVector3ByPrefix("end", None, xmlElement) start = evaluate.getVector3ByPrefix("start", Vector3(), xmlElement) inclinationDegree = math.degrees(getInclination(end, start)) self.inclination = math.radians(evaluate.getEvaluatedFloatDefault(inclinationDegree, "inclination", xmlElement)) self.radius = lineation.getFloatByPrefixBeginEnd("radius", "diameter", self.radius, xmlElement) size = evaluate.getEvaluatedFloatDefault(None, "size", xmlElement) if size != None: self.radius = 0.5 * size self.xmlElement = xmlElement
def setToObjectAttributeDictionary(self): 'Set the shape of this carvable object info.' self.inradius = evaluate.getVector3ByPrefixes(['demisize', 'inradius', 'radius'], Vector3(1.0, 1.0, 1.0), self.xmlElement) self.inradius = evaluate.getVector3ByMultiplierPrefixes(2.0, ['diameter', 'size'], self.inradius, self.xmlElement) self.inradius.z = 0.5 * evaluate.getEvaluatedFloatDefault(self.inradius.z + self.inradius.z, 'height', self.xmlElement) self.topOverBottom = evaluate.getEvaluatedFloatDefault(1.0, 'topOverBottom', self.xmlElement ) self.xmlElement.attributeDictionary['height'] = self.inradius.z + self.inradius.z self.xmlElement.attributeDictionary['radius.x'] = self.inradius.x self.xmlElement.attributeDictionary['radius.y'] = self.inradius.y self.xmlElement.attributeDictionary['topOverBottom'] = self.topOverBottom self.createShape()
def setToXMLElement(self, xmlElement): "Set to the xmlElement." end = evaluate.getVector3ByPrefix(None, 'end', xmlElement) start = evaluate.getVector3ByPrefix(Vector3(), 'start', xmlElement) inclinationDegree = math.degrees(getInclination(end, start)) self.inclination = math.radians(evaluate.getEvaluatedFloatDefault(inclinationDegree, 'inclination', xmlElement)) self.radius = lineation.getFloatByPrefixBeginEnd('radius', 'diameter', self.radius, xmlElement) size = evaluate.getEvaluatedFloatDefault(None, 'size', xmlElement) if size != None: self.radius = 0.5 * size self.xmlElement = xmlElement
def __init__(self, xmlElement): 'Set defaults.' self.closed = evaluate.getEvaluatedBooleanDefault( False, 'closed', xmlElement) self.end = evaluate.getVector3ByPrefix(Vector3(), 'end', xmlElement) self.start = evaluate.getVector3ByPrefix(Vector3(), 'start', xmlElement) self.step = evaluate.getEvaluatedFloatDefault(None, 'step', xmlElement) self.steps = evaluate.getEvaluatedFloatDefault(None, 'steps', xmlElement) self.typeMenuRadioStrings = 'average maximum minimum'.split() self.typeString = evaluate.getEvaluatedStringDefault( 'minimum', 'type', xmlElement)
def __init__(self, xmlElement): 'Set defaults.' self.radius = lineation.getRadiusComplex(complex(1.0, 1.0), xmlElement) self.sides = evaluate.getEvaluatedFloatDefault(None, 'sides', xmlElement) if self.sides == None: radiusMaximum = max(self.radius.real, self.radius.imag) self.sides = evaluate.getSidesMinimumThreeBasedOnPrecisionSides(radiusMaximum, xmlElement) self.start = evaluate.getEvaluatedFloatDefault(0.0, 'start', xmlElement) end = evaluate.getEvaluatedFloatDefault(360.0, 'end', xmlElement) self.revolutions = evaluate.getEvaluatedFloatDefault(1.0, 'revolutions', xmlElement) self.extent = evaluate.getEvaluatedFloatDefault(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 the xmlElement." self.closed = evaluate.getEvaluatedBooleanDefault( False, 'closed', xmlElement) self.end = evaluate.getVector3ByPrefix(self.end, 'end', xmlElement) self.start = evaluate.getVector3ByPrefix(self.start, 'start', xmlElement) self.step = evaluate.getEvaluatedFloatDefault(self.step, 'step', xmlElement) self.steps = evaluate.getEvaluatedFloatDefault(self.steps, 'steps', xmlElement) self.typeString = evaluate.getEvaluatedStringDefault( self.typeString, 'type', xmlElement)
def __init__(self, xmlElement): 'Set defaults.' self.axisEnd = evaluate.getVector3ByPrefix(None, 'axisEnd', xmlElement) self.axisStart = evaluate.getVector3ByPrefix(None, 'axisStart', xmlElement) self.end = evaluate.getEvaluatedFloatDefault(360.0, 'end', xmlElement) self.loop = evaluate.getTransformedPathByKey([], 'loop', xmlElement) self.sides = evaluate.getEvaluatedIntDefault(None, 'sides', xmlElement) self.start = evaluate.getEvaluatedFloatDefault(0.0, 'start', xmlElement) self.target = evaluate.getTransformedPathsByKey([], 'target', xmlElement) if len(self.target) < 1: print('Warning, no target in derive in lathe for:') print(xmlElement) return firstPath = self.target[0] if len(firstPath) < 3: print('Warning, firstPath length is less than three in derive in lathe for:') print(xmlElement) 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(xmlElement) 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(xmlElement) 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(distanceToLine, xmlElement) 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, xmlElement): 'Set defaults.' self.axisEnd = evaluate.getVector3ByPrefix(None, 'axisEnd', xmlElement) self.axisStart = evaluate.getVector3ByPrefix(None, 'axisStart', xmlElement) self.end = evaluate.getEvaluatedFloatDefault(360.0, 'end', xmlElement) self.loop = evaluate.getTransformedPathByKey([], 'loop', xmlElement) self.sides = evaluate.getEvaluatedIntDefault(None, 'sides', xmlElement) self.start = evaluate.getEvaluatedFloatDefault(0.0, 'start', xmlElement) self.target = evaluate.getTransformedPathsByKey([], 'target', xmlElement) if len(self.target) < 1: print('Warning, no target in derive in lathe for:') print(xmlElement) return firstPath = self.target[0] if len(firstPath) < 3: print('Warning, firstPath length is less than three in derive in lathe for:') print(xmlElement) 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(xmlElement) 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(xmlElement) 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(distanceToLine, xmlElement) 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, xmlElement): 'Set defaults.' self.length = evaluate.getEvaluatedFloatDefault(50.0, 'length', xmlElement) self.demilength = 0.5 * self.length self.radius = lineation.getFloatByPrefixBeginEnd('radius', 'diameter', 5.0, xmlElement) self.cageClearanceOverRadius = evaluate.getEvaluatedFloatDefault(0.05, 'cageClearanceOverRadius', xmlElement) self.cageClearance = self.cageClearanceOverRadius * self.radius self.cageClearance = evaluate.getEvaluatedFloatDefault(self.cageClearance, 'cageClearance', xmlElement) self.racewayClearanceOverRadius = evaluate.getEvaluatedFloatDefault(0.1, 'racewayClearanceOverRadius', xmlElement) self.racewayClearance = self.racewayClearanceOverRadius * self.radius self.racewayClearance = evaluate.getEvaluatedFloatDefault(self.racewayClearance, 'racewayClearance', xmlElement) self.typeMenuRadioStrings = 'assembly integral'.split() self.typeString = evaluate.getEvaluatedStringDefault('assembly', 'type', xmlElement) self.typeStringFirstCharacter = self.typeString[: 1 ].lower() self.wallThicknessOverRadius = evaluate.getEvaluatedFloatDefault(0.5, 'wallThicknessOverRadius', xmlElement) self.wallThickness = self.wallThicknessOverRadius * self.radius self.wallThickness = evaluate.getEvaluatedFloatDefault(self.wallThickness, 'wallThickness', xmlElement) self.zenithAngle = evaluate.getEvaluatedFloatDefault(45.0, 'zenithAngle', xmlElement) 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) self.xmlElement = xmlElement if self.typeStringFirstCharacter == 'a': self.setAssemblyCage() self.rectangleCenterX = self.demiwidth - self.demilength
def rotate(self, xmlElement): "Rotate." rotation = math.radians( evaluate.getEvaluatedFloatDefault(0.0, 'rotation', xmlElement ) ) rotation += evaluate.getEvaluatedFloatDefault(0.0, 'rotationOverSide', xmlElement ) * 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 xmlElement.attributeDictionary: isClockwise = euclidean.getBooleanFromValue( evaluate.getEvaluatedValueObliviously('clockwise', xmlElement ) ) if isClockwise == euclidean.getIsWiddershinsByVector3( self.loop ): self.loop.reverse()
def setToXMLElement(self, xmlElement): "Set to the xmlElement." self.fontFamily = evaluate.getEvaluatedStringDefault( self.fontFamily, 'font-family', xmlElement) self.fontFamily = evaluate.getEvaluatedStringDefault( self.fontFamily, 'fontFamily', xmlElement) self.fontSize = evaluate.getEvaluatedFloatDefault( self.fontSize, 'font-size', xmlElement) self.fontSize = evaluate.getEvaluatedFloatDefault( self.fontSize, 'fontSize', xmlElement) if self.textString == '': self.textString = xmlElement.text self.textString = evaluate.getEvaluatedStringDefault( self.textString, 'text', xmlElement)
def getGeometryOutput(xmlElement): "Get vector3 vertexes from attribute dictionary." start = evaluate.getVector3ByPrefix('start', Vector3(), xmlElement) end = evaluate.getVector3ByPrefix('end', Vector3(), xmlElement) endMinusStart = end - start endMinusStartLength = abs(endMinusStart) if endMinusStartLength <= 0.0: print('Warning, end is the same as start in getGeometryOutput in line for:') print(start) print(end) print(xmlElement) return None steps = evaluate.getEvaluatedFloatDefault(None, 'steps', xmlElement) step = evaluate.getEvaluatedFloatDefault(None, 'step', xmlElement) xmlElement.attributeDictionary['closed'] = str(evaluate.getEvaluatedBooleanDefault(False, 'closed', xmlElement)) if step == None and steps == None: return lineation.getGeometryOutputByLoop(lineation.SideLoop([start, end]), xmlElement) loop = [start] if step != None and steps != None: stepVector = step / endMinusStartLength * endMinusStart end = start + stepVector * steps return getGeometryOutputByStep(end, loop, steps, stepVector, xmlElement) if step == None: stepVector = endMinusStart / steps return getGeometryOutputByStep(end, loop, steps, stepVector, xmlElement) typeString = evaluate.getEvaluatedStringDefault('minimum', 'type', xmlElement) endMinusStartLengthOverStep = endMinusStartLength / step if typeString == 'average': steps = max(1.0, round(endMinusStartLengthOverStep)) stepVector = step / endMinusStartLength * endMinusStart end = start + stepVector * steps return getGeometryOutputByStep(end, loop, steps, stepVector, xmlElement) if typeString == 'maximum': steps = math.ceil(endMinusStartLengthOverStep) if steps < 1.0: return lineation.getGeometryOutputByLoop(lineation.SideLoop([start, end]), xmlElement) stepVector = endMinusStart / steps return getGeometryOutputByStep(end, loop, steps, stepVector, xmlElement) if typeString == 'minimum': steps = math.floor(endMinusStartLengthOverStep) if steps < 1.0: return lineation.getGeometryOutputByLoop(lineation.SideLoop(loop), xmlElement) stepVector = endMinusStart / steps return getGeometryOutputByStep(end, loop, steps, stepVector, xmlElement) print('Warning, the step type was not one of (average, maximum or minimum) in getGeometryOutput in line for:') print(typeString) print(xmlElement) loop.append(end) return lineation.getGeometryOutputByLoop(lineation.SideLoop(loop), xmlElement)
def setToXMLElement(self, xmlElement): "Set to the xmlElement." self.radius = lineation.getRadiusComplex(self.radius, xmlElement) if self.sides == None: self.sides = evaluate.getSidesMinimumThreeBasedOnPrecisionSides(max(self.radius.real, self.radius.imag), xmlElement) self.start = evaluate.getEvaluatedFloatDefault(self.start, 'start', xmlElement) self.start = getWrappedFloat(self.start, 360.0) self.extent = evaluate.getEvaluatedFloatDefault(360.0 - self.start, 'extent', xmlElement) self.end = evaluate.getEvaluatedFloatDefault(self.start + self.extent, 'end', xmlElement) self.end = getWrappedFloat(self.end, 360.0) self.revolutions = evaluate.getEvaluatedFloatDefault(self.revolutions, 'revolutions', xmlElement) if self.revolutions > 1: self.end += 360.0 * (self.revolutions - 1) self.extent = self.end - self.start self.spiral = evaluate.getVector3ByPrefix('spiral', self.spiral, xmlElement)
def getManipulatedPaths(close, loop, prefix, sideLength, xmlElement): "Get path with overhangs removed or filled in." if len(loop) < 3: print( 'Warning, loop has less than three sides in getManipulatedPaths in overhang for:' ) print(xmlElement) return [loop] overhangAngle = evaluate.getOverhangSupportAngle(xmlElement) overhangPlaneAngle = euclidean.getWiddershinsUnitPolar(0.5 * math.pi - overhangAngle) overhangVerticalAngle = math.radians( evaluate.getEvaluatedFloatDefault(0.0, prefix + 'inclination', xmlElement)) if overhangVerticalAngle != 0.0: overhangVerticalCosine = abs(math.cos(overhangVerticalAngle)) if overhangVerticalCosine == 0.0: return [loop] imaginaryTimesCosine = overhangPlaneAngle.imag * overhangVerticalCosine overhangPlaneAngle = euclidean.getNormalized( complex(overhangPlaneAngle.real, imaginaryTimesCosine)) alongAway = AlongAway(loop, overhangPlaneAngle) if euclidean.getIsWiddershinsByVector3(loop): alterWiddershinsSupportedPath(alongAway, close) else: alterClockwiseSupportedPath(alongAway, xmlElement) return [ euclidean.getLoopWithoutCloseSequentialPoints(close, alongAway.loop) ]
def setToXMLElement(self, xmlElement): "Set to the xmlElement." self.sides = evaluate.getEvaluatedFloatDefault(self.sides, 'sides', xmlElement) self.sideAngle = 2.0 * math.pi / self.sides self.radius = lineation.getComplexByMultiplierPrefixes( math.cos(0.5 * self.sideAngle), ['apothem', 'inradius'], self.radius, xmlElement) self.radius = lineation.getComplexByPrefixes(['demisize', 'radius'], self.radius, xmlElement) self.radius = lineation.getComplexByMultiplierPrefixes( 2.0, ['diameter', 'size'], self.radius, xmlElement) self.sidesCeiling = int(math.ceil(abs(self.sides))) self.start = evaluate.getEvaluatedIntDefault(self.start, 'start', xmlElement) self.start = lineation.getWrappedInteger(self.start, 360.0) self.extent = evaluate.getEvaluatedIntDefault( self.sidesCeiling - self.start, 'extent', xmlElement) self.end = evaluate.getEvaluatedIntDefault(self.start + self.extent, 'end', xmlElement) self.end = lineation.getWrappedInteger(self.end, self.sidesCeiling) self.revolutions = evaluate.getEvaluatedIntDefault( self.revolutions, 'revolutions', xmlElement) if self.revolutions > 1: self.end += self.sidesCeiling * (self.revolutions - 1) self.spiral = evaluate.getVector3ByPrefix(self.spiral, 'spiral', xmlElement)
def getGeometryOutput(xmlElement): "Get vector3 vertexes from attribute dictionary." inradius = lineation.getComplexByPrefixes(['demisize', 'inradius'], complex(1.0, 1.0), xmlElement) inradius = lineation.getComplexByMultiplierPrefix(2.0, 'size', inradius, xmlElement) demiwidth = lineation.getFloatByPrefixBeginEnd('demiwidth', 'width', inradius.real, xmlElement) demiheight = lineation.getFloatByPrefixBeginEnd('demiheight', 'height', inradius.imag, xmlElement) bottomDemiwidth = lineation.getFloatByPrefixBeginEnd('bottomdemiwidth', 'bottomwidth', demiwidth, xmlElement) topDemiwidth = lineation.getFloatByPrefixBeginEnd('topdemiwidth', 'topwidth', demiwidth, xmlElement) interiorAngle = evaluate.getEvaluatedFloatDefault(90.0, 'interiorangle', xmlElement) topRight = complex(topDemiwidth, demiheight) topLeft = complex(-topDemiwidth, demiheight) bottomLeft = complex(-bottomDemiwidth, -demiheight) bottomRight = complex(bottomDemiwidth, -demiheight) if interiorAngle != 90.0: interiorPlaneAngle = euclidean.getWiddershinsUnitPolar(math.radians(interiorAngle - 90.0)) topRight = (topRight - bottomRight) * interiorPlaneAngle + bottomRight topLeft = (topLeft - bottomLeft) * interiorPlaneAngle + bottomLeft revolutions = evaluate.getEvaluatedIntOne('revolutions', xmlElement) lineation.setClosedAttribute(revolutions, xmlElement) complexLoop = [topRight, topLeft, bottomLeft, bottomRight] originalLoop = complexLoop[:] for revolution in xrange(1, revolutions): complexLoop += originalLoop spiral = lineation.Spiral(0.25, xmlElement) loop = [] loopCentroid = euclidean.getLoopCentroid(originalLoop) for point in complexLoop: unitPolar = euclidean.getNormalized(point - loopCentroid) loop.append(spiral.getSpiralPoint(unitPolar, Vector3(point.real, point.imag))) return lineation.getGeometryOutputByLoop(lineation.SideLoop(loop, 0.5 * math.pi), xmlElement)
def getArcPath(xmlElement): "Get the arc path.rx ry x-axis-rotation large-arc-flag sweep-flag" begin = xmlElement.getPreviousVertex(Vector3()) end = evaluate.getVector3FromXMLElement(xmlElement) largeArcFlag = evaluate.getEvaluatedBooleanDefault(True, 'largeArcFlag', xmlElement) radius = lineation.getComplexByPrefix('radius', complex(1.0, 1.0), xmlElement) sweepFlag = evaluate.getEvaluatedBooleanDefault(True, 'sweepFlag', xmlElement) xAxisRotation = math.radians( evaluate.getEvaluatedFloatDefault(0.0, 'xAxisRotation', xmlElement)) arcComplexes = svg_reader.getArcComplexes(begin.dropAxis(), end.dropAxis(), largeArcFlag, radius, sweepFlag, xAxisRotation) path = [] if len(arcComplexes) < 1: return [] incrementZ = (end.z - begin.z) / float(len(arcComplexes)) z = begin.z for pointIndex in xrange(len(arcComplexes)): pointComplex = arcComplexes[pointIndex] z += incrementZ path.append(Vector3(pointComplex.real, pointComplex.imag, z)) if len(path) > 0: path[-1] = end return path
def getGeometryOutput(xmlElement): "Get vector3 vertices from attribute dictionary." if '_arguments' in xmlElement.attributeDictionary: arguments = xmlElement.attributeDictionary['_arguments'] if len(arguments) > 0: xmlElement.attributeDictionary['sides'] = arguments[0] sides = evaluate.getEvaluatedFloatDefault(4.0, 'sides', xmlElement) sideAngle = 2.0 * math.pi / float(sides) radiusXY = evaluate.RadiusXY().getByRadius( getRadiusFromXMLElement(sideAngle, xmlElement), xmlElement) loop = [] sidesCeiling = int(math.ceil(abs(sides))) start = evaluate.getEvaluatedIntZero('start', xmlElement) start = getWrappedInteger(start, sidesCeiling) extent = evaluate.getEvaluatedIntDefault(sidesCeiling - start, 'extent', xmlElement) end = evaluate.getEvaluatedIntDefault(start + extent, 'end', xmlElement) end = getWrappedInteger(end, sidesCeiling) for side in xrange(start, min(end, sidesCeiling)): angle = float(side) * sideAngle point = euclidean.getWiddershinsUnitPolar(angle) vertex = Vector3(point.real * radiusXY.radiusX, point.imag * radiusXY.radiusY) loop.append(vertex) sideLength = sideAngle * radiusXY.radius return lineation.getGeometryOutputByLoop( None, lineation.SideLoop(loop, sideAngle, sideLength), xmlElement)
def rotate(self, xmlElement): "Rotate." rotation = math.radians( evaluate.getEvaluatedFloatDefault(0.0, 'rotation', xmlElement)) rotation += evaluate.getEvaluatedFloatDefault( 0.0, 'rotationOverSide', xmlElement) * 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 xmlElement.attributeDictionary: isClockwise = euclidean.getBooleanFromValue( evaluate.getEvaluatedValueObliviously('clockwise', xmlElement)) if isClockwise == euclidean.getIsWiddershinsByVector3(self.loop): self.loop.reverse()
def __init__(self, xmlElement): 'Set defaults.' self.end = evaluate.getVector3ByPrefix(Vector3(0.0, 0.0, 1.0), 'end', xmlElement) self.start = evaluate.getVector3ByPrefix(Vector3(), 'start', xmlElement) self.radius = lineation.getFloatByPrefixBeginEnd('radius', 'diameter', 1.0, xmlElement) size = evaluate.getEvaluatedFloatDefault(None, 'size', xmlElement) if size != None: self.radius = 0.5 * size self.xmlElement = xmlElement
def setToXMLElement(self, xmlElement): "Set to the xmlElement." self.tiltFollow = evaluate.getEvaluatedBooleanDefault(self.tiltFollow, 'tiltfollow', xmlElement) self.tiltTop = evaluate.getVector3ByPrefix('tilttop', self.tiltTop, xmlElement) self.maximumUnbuckling = evaluate.getEvaluatedFloatDefault(self.maximumUnbuckling, 'maximumUnbuckling', xmlElement) self.interpolationDictionary['scale'] = Interpolation().getByPrefixZ(self.scalePathDefault, 'scale', xmlElement) if self.tiltTop == None: self.interpolationDictionary['offset'] = Interpolation().getByPrefixZ(self.offsetPathDefault, '', xmlElement) self.interpolationDictionary['tilt'] = Interpolation().getByPrefixZ(self.tiltPathDefault, 'tilt', xmlElement) for point in self.interpolationDictionary['tilt'].path: point.x = math.radians(point.x) point.y = math.radians(point.y) else: self.interpolationDictionary['offset'] = Interpolation().getByPrefixAlong(self.offsetAlongDefault, '', xmlElement) self.twist = evaluate.getEvaluatedFloatDefault(self.twist, 'twist', xmlElement ) if self.twist != 0.0: self.twistPathDefault = [Vector3(), Vector3(1.0, self.twist) ] insertTwistPortions(self, xmlElement)
def setToXMLElement(self, xmlElement): "Set to the xmlElement." self.end = evaluate.getVector3ByPrefix(self.end, 'end', xmlElement) self.start = evaluate.getVector3ByPrefix(self.start, 'start', xmlElement) self.radius = lineation.getFloatByPrefixBeginEnd('radius', 'diameter', self.radius, xmlElement) size = evaluate.getEvaluatedFloatDefault(None, 'size', xmlElement) if size != None: self.radius = 0.5 * size self.xmlElement = xmlElement
def getGeometryOutput(xmlElement): "Get vector3 vertexes from attribute dictionary." fontFamily = evaluate.getEvaluatedStringDefault('Gentium Basic Regular', 'font-family', xmlElement) fontFamily = evaluate.getEvaluatedStringDefault(fontFamily, 'fontFamily', xmlElement) fontSize = evaluate.getEvaluatedFloatDefault(12.0, 'font-size', xmlElement) fontSize = evaluate.getEvaluatedFloatDefault(fontSize, 'fontSize', xmlElement) textString = evaluate.getEvaluatedStringDefault(xmlElement.text, 'text', xmlElement) if textString == '': print('Warning, textString is empty in getGeometryOutput in text for:') print(xmlElement) return [] geometryOutput = [] for textComplexLoop in svg_reader.getTextComplexLoops(fontFamily, fontSize, textString): textComplexLoop.reverse() vector3Path = euclidean.getVector3Path(textComplexLoop) sideLoop = lineation.SideLoop(vector3Path, None, None) sideLoop.rotate(xmlElement) geometryOutput += lineation.getGeometryOutputByManipulation(sideLoop, xmlElement) return geometryOutput
def setToXMLElement(self, xmlElement): "Set to the xmlElement." self.end = evaluate.getVector3ByPrefix(self.end, 'end', xmlElement) self.start = evaluate.getVector3ByPrefix(self.start, 'start', xmlElement) self.radius = lineation.getFloatByPrefixBeginEnd( 'radius', 'diameter', self.radius, xmlElement) size = evaluate.getEvaluatedFloatDefault(None, 'size', xmlElement) if size != None: self.radius = 0.5 * size self.xmlElement = xmlElement
def setToXMLElement(self, xmlElement): "Set to the xmlElement." self.inradius = lineation.getComplexByPrefixes(['demisize', 'inradius'], self.inradius, xmlElement) self.inradius = lineation.getComplexByMultiplierPrefix(2.0, 'size', self.inradius, xmlElement) self.demiwidth = lineation.getFloatByPrefixBeginEnd('demiwidth', 'width', self.inradius.real, xmlElement) self.demiheight = lineation.getFloatByPrefixBeginEnd('demiheight', 'height', self.inradius.imag, xmlElement) self.bottomDemiwidth = lineation.getFloatByPrefixBeginEnd('bottomdemiwidth', 'bottomwidth', self.demiwidth, xmlElement) self.topDemiwidth = lineation.getFloatByPrefixBeginEnd('topdemiwidth', 'topwidth', self.demiwidth, xmlElement) self.interiorAngle = evaluate.getEvaluatedFloatDefault(self.interiorAngle, 'interiorangle', xmlElement) self.revolutions = evaluate.getEvaluatedIntDefault(self.revolutions, 'revolutions', xmlElement) self.spiral = evaluate.getVector3ByPrefix(self.spiral, 'spiral', xmlElement)
def __init__(self, xmlElement): 'Set defaults.' self.inradius = lineation.getComplexByPrefixes(['demisize', 'inradius'], complex(1.0, 1.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.bottomDemiwidth = lineation.getFloatByPrefixBeginEnd('bottomdemiwidth', 'bottomwidth', self.demiwidth, xmlElement) self.topDemiwidth = lineation.getFloatByPrefixBeginEnd('topdemiwidth', 'topwidth', self.demiwidth, xmlElement) self.interiorAngle = evaluate.getEvaluatedFloatDefault(90.0, 'interiorangle', xmlElement) self.revolutions = evaluate.getEvaluatedIntDefault(1, 'revolutions', xmlElement) self.spiral = evaluate.getVector3ByPrefix(None, 'spiral', xmlElement)
def setToXMLElement(self, xmlElement): "Set to the xmlElement." self.inradius = lineation.getComplexByPrefixes(['demisize', 'inradius'], self.inradius, xmlElement) self.inradius = lineation.getComplexByMultiplierPrefix(2.0, 'size', self.inradius, xmlElement) self.demiwidth = lineation.getFloatByPrefixBeginEnd('demiwidth', 'width', self.inradius.real, xmlElement) self.demiheight = lineation.getFloatByPrefixBeginEnd('demiheight', 'height', self.inradius.imag, xmlElement) self.bottomDemiwidth = lineation.getFloatByPrefixBeginEnd('bottomdemiwidth', 'bottomwidth', self.demiwidth, xmlElement) self.topDemiwidth = lineation.getFloatByPrefixBeginEnd('topdemiwidth', 'topwidth', self.demiwidth, xmlElement) self.interiorAngle = evaluate.getEvaluatedFloatDefault(self.interiorAngle, 'interiorangle', xmlElement) self.revolutions = evaluate.getEvaluatedIntDefault(self.revolutions, 'revolutions', xmlElement) self.spiral = evaluate.getVector3ByPrefix(self.spiral, 'spiral', xmlElement)
def setToXMLElement(self, xmlElement): "Set to the xmlElement." self.radius = lineation.getRadiusComplex(self.radius, xmlElement) if self.sides == None: self.sides = evaluate.getSidesMinimumThreeBasedOnPrecisionSides( max(self.radius.real, self.radius.imag), xmlElement) self.start = evaluate.getEvaluatedFloatDefault(self.start, 'start', xmlElement) self.start = getWrappedFloat(self.start, 360.0) self.extent = evaluate.getEvaluatedFloatDefault( 360.0 - self.start, 'extent', xmlElement) self.end = evaluate.getEvaluatedFloatDefault(self.start + self.extent, 'end', xmlElement) self.end = getWrappedFloat(self.end, 360.0) self.revolutions = evaluate.getEvaluatedFloatDefault( self.revolutions, 'revolutions', xmlElement) if self.revolutions > 1: self.end += 360.0 * (self.revolutions - 1) self.extent = self.end - self.start self.spiral = evaluate.getVector3ByPrefix('spiral', self.spiral, xmlElement)
def getGeometryOutput(xmlElement): "Get vector3 vertices from attribute dictionary." paths = evaluate.getPathsByKeys(['crosssection', 'section', 'target'], xmlElement) if len(euclidean.getConcatenatedList(paths)) == 0: print('Warning, in extrude there are no paths.') print(xmlElement.attributeDictionary) return None offsetPathDefault = [Vector3(), Vector3(0.0, 0.0, 1.0)] extrude = Extrude() extrude.tiltFollow = evaluate.getEvaluatedBooleanDefault( extrude.tiltFollow, 'tiltfollow', xmlElement) extrude.tiltTop = evaluate.getVector3ByPrefix('tilttop', extrude.tiltTop, xmlElement) extrude.maximumUnbuckling = evaluate.getEvaluatedFloatDefault( 5.0, 'maximumunbuckling', xmlElement) scalePathDefault = [Vector3(1.0, 1.0, 0.0), Vector3(1.0, 1.0, 1.0)] extrude.interpolationDictionary['scale'] = evaluate.Interpolation( ).getByPrefixZ(scalePathDefault, 'scale', xmlElement) if extrude.tiltTop == None: extrude.interpolationDictionary['offset'] = evaluate.Interpolation( ).getByPrefixZ(offsetPathDefault, '', xmlElement) tiltPathDefault = [Vector3(), Vector3(0.0, 0.0, 1.0)] interpolationTilt = evaluate.Interpolation().getByPrefixZ( tiltPathDefault, 'tilt', xmlElement) extrude.interpolationDictionary['tilt'] = interpolationTilt for point in interpolationTilt.path: point.x = math.radians(point.x) point.y = math.radians(point.y) else: offsetAlongDefault = [Vector3(), Vector3(1.0, 0.0, 0.0)] extrude.interpolationDictionary['offset'] = evaluate.Interpolation( ).getByPrefixAlong(offsetAlongDefault, '', xmlElement) insertTwistPortions(extrude.interpolationDictionary, xmlElement) segments = evaluate.getEvaluatedIntOne('segments', xmlElement) negatives = [] positives = [] portionDirections = evaluate.getSpacedPortionDirections( extrude.interpolationDictionary) for path in paths: endMultiplier = None if not euclidean.getIsWiddershinsByVector3(path): endMultiplier = 1.000001 geometryOutput = getGeometryOutputByPath(endMultiplier, extrude, path, portionDirections) if endMultiplier == None: positives.append(geometryOutput) else: negatives.append(geometryOutput) positiveOutput = trianglemesh.getUnifiedOutput(positives) if len(negatives) < 1: return positiveOutput return {'difference': [positiveOutput] + negatives}
def getGeometryOutput(xmlElement): "Get vector3 vertices from attribute dictionary." halfX = 1.0 halfX = evaluate.getEvaluatedFloatDefault(halfX, 'halfx', xmlElement) halfX = 0.5 * evaluate.getEvaluatedFloatDefault(halfX / 0.5, 'width', xmlElement) bottomHalfX = evaluate.getEvaluatedFloatDefault(halfX, 'bottomhalfx', xmlElement) bottomHalfX = 0.5 * evaluate.getEvaluatedFloatDefault( halfX / 0.5, 'bottomwidth', xmlElement) topHalfX = evaluate.getEvaluatedFloatDefault(halfX, 'tophalfx', xmlElement) topHalfX = 0.5 * evaluate.getEvaluatedFloatDefault(halfX / 0.5, 'topwidth', xmlElement) halfY = halfX if '_arguments' in xmlElement.attributeDictionary: arguments = xmlElement.attributeDictionary['_arguments'] halfX = 0.5 * euclidean.getFloatFromValue(arguments[0]) xmlElement.attributeDictionary['halfX'] = str(halfX) if len(arguments) > 1: halfY = 0.5 * euclidean.getFloatFromValue(arguments[1]) else: halfY = halfX halfY = evaluate.getEvaluatedFloatDefault(halfY, 'halfy', xmlElement) halfY = 0.5 * evaluate.getEvaluatedFloatDefault(halfY / 0.5, 'height', xmlElement) interiorAngle = evaluate.getEvaluatedFloatDefault(90.0, 'interiorangle', xmlElement) topRight = complex(topHalfX, halfY) topLeft = complex(-topHalfX, halfY) bottomLeft = complex(-bottomHalfX, -halfY) bottomRight = complex(bottomHalfX, -halfY) if interiorAngle != 90.0: interiorPlaneAngle = euclidean.getWiddershinsUnitPolar( math.radians(interiorAngle - 90.0)) topRight = (topRight - bottomRight) * interiorPlaneAngle + bottomRight topLeft = (topLeft - bottomLeft) * interiorPlaneAngle + bottomLeft loop = [ Vector3(topRight.real, topRight.imag), Vector3(topLeft.real, topLeft.imag), Vector3(bottomLeft.real, bottomLeft.imag), Vector3(bottomRight.real, bottomRight.imag) ] return lineation.getGeometryOutputByLoop( None, lineation.SideLoop(loop, 0.5 * math.pi), xmlElement)
def setToObjectAttributeDictionary(self): "Set the shape of this carvable object info." radius = evaluate.getVector3ByPrefix("radius", Vector3(1.0, 1.0, 1.0), self.xmlElement) radius = evaluate.getVector3ThroughSizeDiameter(radius, self.xmlElement) self.height = evaluate.getEvaluatedFloatDefault(radius.z + radius.z, "height", self.xmlElement) self.radiusX = radius.x self.radiusY = radius.y self.radiusZ = None self.topOverBottom = evaluate.getEvaluatedFloatOne("topoverbottom", self.xmlElement) self.xmlElement.attributeDictionary["height"] = self.height self.xmlElement.attributeDictionary["radiusx"] = self.radiusX self.xmlElement.attributeDictionary["radiusy"] = self.radiusY self.xmlElement.attributeDictionary["topoverbottom"] = self.topOverBottom self.createShape()
def setToObjectAttributeDictionary( self ): "Set the shape of this carvable object info." radius = evaluate.getVector3ByPrefix( 'radius', Vector3( 1.0, 1.0, 1.0 ), self.xmlElement ) radius = evaluate.getVector3ThroughSizeDiameter( radius, self.xmlElement ) self.height = evaluate.getEvaluatedFloatDefault( radius.z + radius.z, 'height', self.xmlElement ) self.radiusX = radius.x self.radiusY = radius.y self.radiusZ = None self.topOverBottom = evaluate.getEvaluatedFloatOne( 'topoverbottom', self.xmlElement ) self.xmlElement.attributeDictionary[ 'height' ] = self.height self.xmlElement.attributeDictionary[ 'radiusx' ] = self.radiusX self.xmlElement.attributeDictionary[ 'radiusy' ] = self.radiusY self.xmlElement.attributeDictionary[ 'topoverbottom' ] = self.topOverBottom self.createShape()
def __init__(self, xmlElement): 'Set defaults.' self.length = evaluate.getEvaluatedFloatDefault( 50.0, 'length', xmlElement) self.demilength = 0.5 * self.length self.radius = lineation.getFloatByPrefixBeginEnd( 'radius', 'diameter', 5.0, xmlElement) self.cageClearanceOverRadius = evaluate.getEvaluatedFloatDefault( 0.05, 'cageClearanceOverRadius', xmlElement) self.cageClearance = self.cageClearanceOverRadius * self.radius self.cageClearance = evaluate.getEvaluatedFloatDefault( self.cageClearance, 'cageClearance', xmlElement) self.racewayClearanceOverRadius = evaluate.getEvaluatedFloatDefault( 0.1, 'racewayClearanceOverRadius', xmlElement) self.racewayClearance = self.racewayClearanceOverRadius * self.radius self.racewayClearance = evaluate.getEvaluatedFloatDefault( self.racewayClearance, 'racewayClearance', xmlElement) self.typeMenuRadioStrings = 'assembly integral'.split() self.typeString = evaluate.getEvaluatedStringDefault( 'assembly', 'type', xmlElement) self.typeStringFirstCharacter = self.typeString[:1].lower() self.wallThicknessOverRadius = evaluate.getEvaluatedFloatDefault( 0.5, 'wallThicknessOverRadius', xmlElement) self.wallThickness = self.wallThicknessOverRadius * self.radius self.wallThickness = evaluate.getEvaluatedFloatDefault( self.wallThickness, 'wallThickness', xmlElement) self.zenithAngle = evaluate.getEvaluatedFloatDefault( 45.0, 'zenithAngle', xmlElement) 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) self.xmlElement = xmlElement if self.typeStringFirstCharacter == 'a': self.setAssemblyCage() self.rectangleCenterX = self.demiwidth - self.demilength
def __init__(self, xmlElement): 'Set defaults.' self.depthBottomOverRadius = evaluate.getEvaluatedFloatDefault(0.0, 'depthBottomOverRadius', xmlElement) self.depthTopOverRadius = evaluate.getEvaluatedFloatDefault(0.0, 'depthOverRadius', xmlElement) self.depthTopOverRadius = evaluate.getEvaluatedFloatDefault( self.depthTopOverRadius, 'depthTopOverRadius', xmlElement) self.radius = evaluate.getEvaluatedFloatDefault(1.0, 'radius', xmlElement) self.sides = evaluate.getEvaluatedIntDefault(4, 'sides', xmlElement) self.depthBottom = self.radius * self.depthBottomOverRadius self.depthBottom = evaluate.getEvaluatedFloatDefault(self.depthBottom, 'depthBottom', xmlElement) self.depthTop = self.radius * self.depthTopOverRadius self.depthTop = evaluate.getEvaluatedFloatDefault(self.depthTop, 'depth', xmlElement) self.depthTop = evaluate.getEvaluatedFloatDefault(self.depthTop, 'depthTop', xmlElement)
def __init__(self, xmlElement): 'Set defaults.' self.sides = evaluate.getEvaluatedFloatDefault(4.0, 'sides', xmlElement) self.sideAngle = 2.0 * math.pi / self.sides cosSide = math.cos(0.5 * self.sideAngle) self.radius = lineation.getComplexByMultiplierPrefixes(cosSide, ['apothem', 'inradius'], complex(1.0, 1.0), xmlElement) self.radius = lineation.getComplexByPrefixes(['demisize', 'radius'], self.radius, xmlElement) self.radius = lineation.getComplexByMultiplierPrefixes(2.0, ['diameter', 'size'], self.radius, xmlElement) self.sidesCeiling = int(math.ceil(abs(self.sides))) self.start = evaluate.getEvaluatedIntDefault(0, 'start', xmlElement) end = evaluate.getEvaluatedIntDefault(self.sidesCeiling, 'end', xmlElement) self.revolutions = evaluate.getEvaluatedIntDefault(1, 'revolutions', xmlElement) self.extent = evaluate.getEvaluatedIntDefault(end - self.start, 'extent', xmlElement) self.extent += self.sidesCeiling * (self.revolutions - 1) self.spiral = evaluate.getVector3ByPrefix(None, 'spiral', xmlElement)
def __init__(self, xmlElement): 'Initialize.' self.interpolationDictionary = {} self.radius = lineation.getRadiusComplex(complex(), xmlElement) self.tiltFollow = evaluate.getEvaluatedBooleanDefault(True, 'tiltFollow', xmlElement) self.tiltTop = evaluate.getVector3ByPrefix(None, 'tiltTop', xmlElement) self.maximumUnbuckling = evaluate.getEvaluatedFloatDefault(5.0, 'maximumUnbuckling', xmlElement) scalePathDefault = [Vector3(1.0, 1.0, 0.0), Vector3(1.0, 1.0, 1.0)] self.interpolationDictionary['scale'] = Interpolation().getByPrefixZ(scalePathDefault, 'scale', xmlElement) self.target = evaluate.getTransformedPathsByKey([], 'target', xmlElement) if self.tiltTop == None: offsetPathDefault = [Vector3(), Vector3(0.0, 0.0, 1.0)] self.interpolationDictionary['offset'] = Interpolation().getByPrefixZ(offsetPathDefault, '', xmlElement) tiltPathDefault = [Vector3(), Vector3(0.0, 0.0, 1.0)] self.interpolationDictionary['tilt'] = Interpolation().getByPrefixZ(tiltPathDefault, 'tilt', xmlElement) for point in self.interpolationDictionary['tilt'].path: point.x = math.radians(point.x) point.y = math.radians(point.y) else: offsetAlongDefault = [Vector3(), Vector3(1.0, 0.0, 0.0)] self.interpolationDictionary['offset'] = Interpolation().getByPrefixAlong(offsetAlongDefault, '', xmlElement) self.twist = evaluate.getEvaluatedFloatDefault(0.0, 'twist', xmlElement ) self.twistPathDefault = [Vector3(), Vector3(1.0, self.twist) ] insertTwistPortions(self, xmlElement)
def setToXMLElement(self, xmlElement): "Set to the xmlElement." self.sides = evaluate.getEvaluatedFloatDefault(self.sides, 'sides', xmlElement) self.sideAngle = 2.0 * math.pi / self.sides self.radius = lineation.getComplexByMultiplierPrefixes(math.cos(0.5 * self.sideAngle), ['apothem', 'inradius'], self.radius, xmlElement) self.radius = lineation.getComplexByPrefixes(['demisize', 'radius'], self.radius, xmlElement) self.radius = lineation.getComplexByMultiplierPrefixes(2.0, ['diameter', 'size'], self.radius, xmlElement) self.sidesCeiling = int(math.ceil(abs(self.sides))) self.start = evaluate.getEvaluatedIntDefault(self.start, 'start', xmlElement) self.start = lineation.getWrappedInteger(self.start, 360.0) self.extent = evaluate.getEvaluatedIntDefault(self.sidesCeiling - self.start, 'extent', xmlElement) self.end = evaluate.getEvaluatedIntDefault(self.start + self.extent, 'end', xmlElement) self.end = lineation.getWrappedInteger(self.end, self.sidesCeiling) self.revolutions = evaluate.getEvaluatedIntDefault(self.revolutions, 'revolutions', xmlElement) if self.revolutions > 1: self.end += self.sidesCeiling * (self.revolutions - 1) self.spiral = evaluate.getVector3ByPrefix('spiral', self.spiral, xmlElement)
def getGeometryOutput(xmlElement): "Get vector3 vertexes from attribute dictionary." sides = evaluate.getEvaluatedFloatDefault(4.0, 'sides', xmlElement) sideAngle = 2.0 * math.pi / sides radius = complex(1.0, 1.0) radius = lineation.getComplexByMultiplierPrefixes(math.cos(0.5 * sideAngle), ['apothem', 'inradius'], radius, xmlElement) radius = lineation.getComplexByPrefixes(['demisize', 'radius'], radius, xmlElement) radius = lineation.getComplexByMultiplierPrefixes(2.0, ['diameter', 'size'], radius, xmlElement) loop = [] sidesCeiling = int(math.ceil(abs(sides))) startEnd = lineation.StartEnd(sidesCeiling, '', xmlElement) spiral = lineation.Spiral(0.5 * sideAngle / math.pi, xmlElement) for side in xrange(startEnd.start, startEnd.end): angle = float(side) * sideAngle unitPolar = euclidean.getWiddershinsUnitPolar(angle) vertex = spiral.getSpiralPoint(unitPolar, Vector3(unitPolar.real * radius.real, unitPolar.imag * radius.imag)) loop.append(vertex) sideLength = sideAngle * lineation.getAverageRadius(radius) lineation.setClosedAttribute(startEnd.revolutions, xmlElement) return lineation.getGeometryOutputByLoop(lineation.SideLoop(loop, sideAngle, sideLength), xmlElement)
def getGeometryOutput(xmlElement): "Get vector3 vertexes from attribute dictionary." inradius = lineation.getComplexByPrefixes(['demisize', 'inradius'], complex(1.0, 1.0), xmlElement) inradius = lineation.getComplexByMultiplierPrefix(2.0, 'size', inradius, xmlElement) demiwidth = lineation.getFloatByPrefixBeginEnd('demiwidth', 'width', inradius.real, xmlElement) demiheight = lineation.getFloatByPrefixBeginEnd('demiheight', 'height', inradius.imag, xmlElement) bottomDemiwidth = lineation.getFloatByPrefixBeginEnd( 'bottomdemiwidth', 'bottomwidth', demiwidth, xmlElement) topDemiwidth = lineation.getFloatByPrefixBeginEnd('topdemiwidth', 'topwidth', demiwidth, xmlElement) interiorAngle = evaluate.getEvaluatedFloatDefault(90.0, 'interiorangle', xmlElement) topRight = complex(topDemiwidth, demiheight) topLeft = complex(-topDemiwidth, demiheight) bottomLeft = complex(-bottomDemiwidth, -demiheight) bottomRight = complex(bottomDemiwidth, -demiheight) if interiorAngle != 90.0: interiorPlaneAngle = euclidean.getWiddershinsUnitPolar( math.radians(interiorAngle - 90.0)) topRight = (topRight - bottomRight) * interiorPlaneAngle + bottomRight topLeft = (topLeft - bottomLeft) * interiorPlaneAngle + bottomLeft revolutions = evaluate.getEvaluatedIntOne('revolutions', xmlElement) lineation.setClosedAttribute(revolutions, xmlElement) complexLoop = [topRight, topLeft, bottomLeft, bottomRight] originalLoop = complexLoop[:] for revolution in xrange(1, revolutions): complexLoop += originalLoop spiral = lineation.Spiral(0.25, xmlElement) loop = [] loopCentroid = euclidean.getLoopCentroid(originalLoop) for point in complexLoop: unitPolar = euclidean.getNormalized(point - loopCentroid) loop.append( spiral.getSpiralPoint(unitPolar, Vector3(point.real, point.imag))) return lineation.getGeometryOutputByLoop( lineation.SideLoop(loop, 0.5 * math.pi), xmlElement)