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)
