def getCubicPath(elementNode):
"Get the cubic path."
end = evaluate.getVector3FromElementNode(elementNode)
previousElementNode = elementNode.getPreviousElementNode()
if previousElementNode is None:
print('Warning, can not get previousElementNode in getCubicPath in cubic for:')
print(elementNode)
return [end]
begin = elementNode.getPreviousVertex(Vector3())
evaluatedControlPoints = evaluate.getTransformedPathByKey([], elementNode, 'controlPoints')
if len(evaluatedControlPoints) > 1:
return getCubicPathByBeginEnd(begin, evaluatedControlPoints, elementNode, end)
controlPoint0 = evaluate.getVector3ByPrefix(None, elementNode, 'controlPoint0')
controlPoint1 = evaluate.getVector3ByPrefix(None, elementNode, 'controlPoint1')
if len(evaluatedControlPoints) == 1:
controlPoint1 = evaluatedControlPoints[0]
if controlPoint0 is None:
oldControlPoint = evaluate.getVector3ByPrefixes(previousElementNode, ['controlPoint','controlPoint1'], None)
if oldControlPoint is None:
oldControlPoints = evaluate.getTransformedPathByKey([], previousElementNode, 'controlPoints')
if len(oldControlPoints) > 0:
oldControlPoint = oldControlPoints[-1]
if oldControlPoint is None:
oldControlPoint = end
controlPoint0 = begin + begin - oldControlPoint
return getCubicPathByBeginEnd(begin, [controlPoint0, controlPoint1], elementNode, end)
def getCubicPath(xmlElement):
"Get the cubic path."
end = evaluate.getVector3FromXMLElement(xmlElement)
previousXMLElement = xmlElement.getPreviousXMLElement()
if previousXMLElement == None:
print(
'Warning, can not get previousXMLElement in getCubicPath in cubic for:'
)
print(xmlElement)
return [end]
begin = xmlElement.getPreviousVertex(Vector3())
controlPoint0 = evaluate.getVector3ByPrefix('controlPoint0', None,
xmlElement)
if controlPoint0 == None:
oldControlPoint = evaluate.getVector3ByPrefixes(
['controlPoint', 'controlPoint1'], None, previousXMLElement)
if oldControlPoint == None:
print(
'Warning, can not get oldControlPoint in getCubicPath in cubic for:'
)
print(xmlElement)
return [end]
controlPoint0 = begin + begin - oldControlPoint
controlPoints = [
controlPoint0,
evaluate.getVector3ByPrefix('controlPoint1', None, xmlElement)
]
return svg_reader.getCubicPoints(
begin, controlPoints, end,
lineation.getNumberOfBezierPoints(begin, end, xmlElement))
def getCubicPath(xmlElement):
"Get the cubic path."
end = evaluate.getVector3FromXMLElement(xmlElement)
previousXMLElement = xmlElement.getPreviousXMLElement()
if previousXMLElement == None:
print('Warning, can not get previousXMLElement in getCubicPath in cubic for:')
print(xmlElement)
return [end]
begin = xmlElement.getPreviousVertex(Vector3())
evaluatedControlPoints = evaluate.getTransformedPathByKey('controlPoints', xmlElement)
if len(evaluatedControlPoints) > 1:
return getCubicPathByBeginEnd(begin, evaluatedControlPoints, end, xmlElement)
controlPoint0 = evaluate.getVector3ByPrefix('controlPoint0', None, xmlElement)
controlPoint1 = evaluate.getVector3ByPrefix('controlPoint1', None, xmlElement)
if len(evaluatedControlPoints) == 1:
controlPoint1 = evaluatedControlPoints[0]
if controlPoint0 == None:
oldControlPoint = evaluate.getVector3ByPrefixes(['controlPoint','controlPoint1'], None, previousXMLElement)
if oldControlPoint == None:
oldControlPoints = evaluate.getTransformedPathByKey('controlPoints', previousXMLElement)
if len(oldControlPoints) > 0:
oldControlPoint = oldControlPoints[-1]
if oldControlPoint == None:
oldControlPoint = end
controlPoint0 = begin + begin - oldControlPoint
return getCubicPathByBeginEnd(begin, [controlPoint0, controlPoint1], end, xmlElement)
def getCubicPath(xmlElement):
"Get the cubic path."
end = evaluate.getVector3FromXMLElement(xmlElement)
previousXMLElement = xmlElement.getPreviousXMLElement()
if previousXMLElement == None:
print('Warning, can not get previousXMLElement in getCubicPath in cubic for:')
print(xmlElement)
return [end]
begin = xmlElement.getPreviousVertex(Vector3())
evaluatedControlPoints = evaluate.getTransformedPathByKey([], 'controlPoints', xmlElement)
if len(evaluatedControlPoints) > 1:
return getCubicPathByBeginEnd(begin, evaluatedControlPoints, end, xmlElement)
controlPoint0 = evaluate.getVector3ByPrefix(None, 'controlPoint0', xmlElement)
controlPoint1 = evaluate.getVector3ByPrefix(None, 'controlPoint1', xmlElement)
if len(evaluatedControlPoints) == 1:
controlPoint1 = evaluatedControlPoints[0]
if controlPoint0 == None:
oldControlPoint = evaluate.getVector3ByPrefixes(['controlPoint','controlPoint1'], None, previousXMLElement)
if oldControlPoint == None:
oldControlPoints = evaluate.getTransformedPathByKey([], 'controlPoints', previousXMLElement)
if len(oldControlPoints) > 0:
oldControlPoint = oldControlPoints[-1]
if oldControlPoint == None:
oldControlPoint = end
controlPoint0 = begin + begin - oldControlPoint
return getCubicPathByBeginEnd(begin, [controlPoint0, controlPoint1], end, 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 flipPoints(points, prefix, xmlElement):
"Flip the points."
origin = evaluate.getVector3ByPrefix(Vector3(), prefix + 'origin',
xmlElement)
axis = evaluate.getVector3ByPrefix(Vector3(1.0, 0.0, 0.0), prefix + 'axis',
xmlElement).getNormalized()
for point in points:
point.setToVector3(point - 2.0 * axis.dot(point - origin) * axis)
def flipPoints(elementNode, points, prefix):
'Flip the points.'
origin = evaluate.getVector3ByPrefix(Vector3(), elementNode,
prefix + 'origin')
axis = evaluate.getVector3ByPrefix(Vector3(1.0, 0.0, 0.0), elementNode,
prefix + 'axis').getNormalized()
for point in points:
point.setToVector3(point - 2.0 * axis.dot(point - origin) * axis)
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 __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 __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.getEvaluatedFloat(None, "size", xmlElement)
if size != None:
self.radius = 0.5 * size
self.xmlElement = xmlElement
def __init__(self, elementNode): 'Set defaults.' self.elementNode = elementNode self.end = evaluate.getVector3ByPrefix(Vector3(0.0, 0.0, 1.0), elementNode, 'end') self.start = evaluate.getVector3ByPrefix(Vector3(), elementNode, 'start') self.radius = lineation.getFloatByPrefixBeginEnd(elementNode, 'radius', 'diameter', 1.0) size = evaluate.getEvaluatedFloat(None, elementNode, 'size') if size is not None: self.radius = 0.5 * size
def __init__(self, elementNode):
'Set defaults.'
self.closed = evaluate.getEvaluatedBoolean(False, elementNode, 'closed')
self.end = evaluate.getVector3ByPrefix(Vector3(), elementNode, 'end')
self.start = evaluate.getVector3ByPrefix(Vector3(), elementNode, 'start')
self.step = evaluate.getEvaluatedFloat(None, elementNode, 'step')
self.steps = evaluate.getEvaluatedFloat(None, elementNode, 'steps')
self.typeMenuRadioStrings = 'average maximum minimum'.split()
self.typeString = evaluate.getEvaluatedString('minimum', elementNode, 'type')
def __init__(self, xmlElement):
'Set defaults.'
self.closed = evaluate.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 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 __init__(self, elementNode):
'Set defaults.'
self.closed = evaluate.getEvaluatedBoolean(False, elementNode, 'closed')
self.end = evaluate.getVector3ByPrefix(Vector3(), elementNode, 'end')
self.start = evaluate.getVector3ByPrefix(Vector3(), elementNode, 'start')
self.step = evaluate.getEvaluatedFloat(None, elementNode, 'step')
self.steps = evaluate.getEvaluatedFloat(None, elementNode, 'steps')
self.typeMenuRadioStrings = 'average maximum minimum'.split()
self.typeString = evaluate.getEvaluatedString('minimum', elementNode, 'type')
def __init__(self, xmlElement):
'Set defaults.'
end = evaluate.getVector3ByPrefix(None, 'end', xmlElement)
start = evaluate.getVector3ByPrefix(Vector3(), 'start', xmlElement)
inclinationDegree = math.degrees(getInclination(end, start))
self.inclination = math.radians(evaluate.getEvaluatedFloat(inclinationDegree, 'inclination', xmlElement))
self.radius = lineation.getFloatByPrefixBeginEnd('radius', 'diameter', 1.0, xmlElement)
size = evaluate.getEvaluatedFloat(None, 'size', xmlElement)
if size != None:
self.radius = 0.5 * size
self.xmlElement = xmlElement
def 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 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 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 __init__(self, elementNode):
'Set defaults.'
self.elementNode = elementNode
self.end = evaluate.getVector3ByPrefix(Vector3(0.0, 0.0, 1.0),
elementNode, 'end')
self.start = evaluate.getVector3ByPrefix(Vector3(), elementNode,
'start')
self.radius = lineation.getFloatByPrefixBeginEnd(
elementNode, 'radius', 'diameter', 1.0)
size = evaluate.getEvaluatedFloat(None, elementNode, 'size')
if size != None:
self.radius = 0.5 * size
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.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, elementNode):
'Set defaults.'
self.axisEnd = evaluate.getVector3ByPrefix(None, elementNode, 'axisEnd')
self.axisStart = evaluate.getVector3ByPrefix(None, elementNode, 'axisStart')
self.end = evaluate.getEvaluatedFloat(360.0, elementNode, 'end')
self.loop = evaluate.getTransformedPathByKey([], elementNode, 'loop')
self.sides = evaluate.getEvaluatedInt(None, elementNode, 'sides')
self.start = evaluate.getEvaluatedFloat(0.0, elementNode, 'start')
self.target = evaluate.getTransformedPathsByKey([], elementNode, 'target')
if len(self.target) < 1:
print('Warning, no target in derive in lathe for:')
print(elementNode)
return
firstPath = self.target[0]
if len(firstPath) < 3:
print('Warning, firstPath length is less than three in derive in lathe for:')
print(elementNode)
self.target = []
return
if self.axisStart == None:
if self.axisEnd == None:
self.axisStart = firstPath[0]
self.axisEnd = firstPath[-1]
else:
self.axisStart = Vector3()
self.axis = self.axisEnd - self.axisStart
axisLength = abs(self.axis)
if axisLength <= 0.0:
print('Warning, axisLength is zero in derive in lathe for:')
print(elementNode)
self.target = []
return
self.axis /= axisLength
firstVector3 = firstPath[1] - self.axisStart
firstVector3Length = abs(firstVector3)
if firstVector3Length <= 0.0:
print('Warning, firstVector3Length is zero in derive in lathe for:')
print(elementNode)
self.target = []
return
firstVector3 /= firstVector3Length
self.axisProjectiveSpace = euclidean.ProjectiveSpace().getByBasisZFirst(self.axis, firstVector3)
if self.sides == None:
distanceToLine = euclidean.getDistanceToLineByPaths(self.axisStart, self.axisEnd, self.target)
self.sides = evaluate.getSidesMinimumThreeBasedOnPrecisionSides(elementNode, distanceToLine)
endRadian = math.radians(self.end)
startRadian = math.radians(self.start)
self.isEndCloseToStart = euclidean.getIsRadianClose(endRadian, startRadian)
if len(self.loop) < 1:
self.loop = euclidean.getComplexPolygonByStartEnd(endRadian, 1.0, self.sides, startRadian)
self.normal = euclidean.getNormalByPath(firstPath)
def __init__(self, elementNode):
'Set defaults.'
self.axisEnd = evaluate.getVector3ByPrefix(None, elementNode, 'axisEnd')
self.axisStart = evaluate.getVector3ByPrefix(None, elementNode, 'axisStart')
self.end = evaluate.getEvaluatedFloat(360.0, elementNode, 'end')
self.loop = evaluate.getTransformedPathByKey([], elementNode, 'loop')
self.sides = evaluate.getEvaluatedInt(None, elementNode, 'sides')
self.start = evaluate.getEvaluatedFloat(0.0, elementNode, 'start')
self.target = evaluate.getTransformedPathsByKey([], elementNode, 'target')
if len(self.target) < 1:
print('Warning, no target in derive in lathe for:')
print(elementNode)
return
firstPath = self.target[0]
if len(firstPath) < 3:
print('Warning, firstPath length is less than three in derive in lathe for:')
print(elementNode)
self.target = []
return
if self.axisStart == None:
if self.axisEnd == None:
self.axisStart = firstPath[0]
self.axisEnd = firstPath[-1]
else:
self.axisStart = Vector3()
self.axis = self.axisEnd - self.axisStart
axisLength = abs(self.axis)
if axisLength <= 0.0:
print('Warning, axisLength is zero in derive in lathe for:')
print(elementNode)
self.target = []
return
self.axis /= axisLength
firstVector3 = firstPath[1] - self.axisStart
firstVector3Length = abs(firstVector3)
if firstVector3Length <= 0.0:
print('Warning, firstVector3Length is zero in derive in lathe for:')
print(elementNode)
self.target = []
return
firstVector3 /= firstVector3Length
self.axisProjectiveSpace = euclidean.ProjectiveSpace().getByBasisZFirst(self.axis, firstVector3)
if self.sides == None:
distanceToLine = euclidean.getDistanceToLineByPaths(self.axisStart, self.axisEnd, self.target)
self.sides = evaluate.getSidesMinimumThreeBasedOnPrecisionSides(elementNode, distanceToLine)
endRadian = math.radians(self.end)
startRadian = math.radians(self.start)
self.isEndCloseToStart = euclidean.getIsRadianClose(endRadian, startRadian)
if len(self.loop) < 1:
self.loop = euclidean.getComplexPolygonByStartEnd(endRadian, 1.0, self.sides, startRadian)
self.normal = euclidean.getNormalByPath(firstPath)
def 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 __init__(self, stepRatio, xmlElement):
"Initialize."
self.spiral = evaluate.getVector3ByPrefix('spiral', None, xmlElement)
if self.spiral == None:
return
self.spiralIncrement = self.spiral * stepRatio
self.spiralTotal = Vector3()
def __init__(self, xmlElement):
'Initialize.'
self.interpolationDictionary = {}
self.tiltFollow = evaluate.getEvaluatedBoolean(True, 'tiltFollow',
xmlElement)
self.tiltTop = evaluate.getVector3ByPrefix(None, 'tiltTop', xmlElement)
self.maximumUnbuckling = evaluate.getEvaluatedFloat(
5.0, 'maximumUnbuckling', xmlElement)
scalePathDefault = [Vector3(1.0, 1.0, 0.0), Vector3(1.0, 1.0, 1.0)]
self.interpolationDictionary['scale'] = Interpolation().getByPrefixZ(
scalePathDefault, 'scale', xmlElement)
self.target = evaluate.getTransformedPathsByKey([], 'target',
xmlElement)
if self.tiltTop == None:
offsetPathDefault = [Vector3(), Vector3(0.0, 0.0, 1.0)]
self.interpolationDictionary['offset'] = Interpolation(
).getByPrefixZ(offsetPathDefault, '', xmlElement)
tiltPathDefault = [Vector3(), Vector3(0.0, 0.0, 1.0)]
self.interpolationDictionary['tilt'] = Interpolation(
).getByPrefixZ(tiltPathDefault, 'tilt', xmlElement)
for point in self.interpolationDictionary['tilt'].path:
point.x = math.radians(point.x)
point.y = math.radians(point.y)
else:
offsetAlongDefault = [Vector3(), Vector3(1.0, 0.0, 0.0)]
self.interpolationDictionary['offset'] = Interpolation(
).getByPrefixAlong(offsetAlongDefault, '', xmlElement)
self.twist = evaluate.getEvaluatedFloat(0.0, 'twist', xmlElement)
self.twistPathDefault = [Vector3(), Vector3(1.0, self.twist)]
self.xmlElement = xmlElement
insertTwistPortions(self, xmlElement)
def __init__(self, elementNode):
'Set defaults.'
self.bevelOverRadius = evaluate.getEvaluatedFloat(
0.25, elementNode, 'bevelOverRadius')
self.clearanceOverRadius = evaluate.getEvaluatedFloat(
0.0, elementNode, 'clearanceOverRadius')
self.elementNode = elementNode
self.endZ = evaluate.getEvaluatedFloat(10.0, elementNode, 'endZ')
self.start = evaluate.getVector3ByPrefix(Vector3(), elementNode,
'start')
self.radius = lineation.getFloatByPrefixBeginEnd(
elementNode, 'radius', 'diameter', 2.0)
self.sides = evaluate.getSidesMinimumThreeBasedOnPrecision(
elementNode, max(self.radius.real, self.radius.imag))
self.radiusArealized = evaluate.getRadiusArealizedBasedOnAreaRadius(
elementNode, self.radius, self.sides)
self.topOverBottom = evaluate.getEvaluatedFloat(
0.8, elementNode, 'topOverBottom')
setTopOverBottomByRadius(self, self.endZ, self.radiusArealized,
self.start.z)
# Set derived variables.
self.bevel = evaluate.getEvaluatedFloat(
self.bevelOverRadius * self.radiusArealized, elementNode, 'bevel')
self.clearance = evaluate.getEvaluatedFloat(
self.clearanceOverRadius * self.radiusArealized, elementNode,
'clearance')
def getManipulatedPaths(close, loop, prefix, sideLength, xmlElement):
"Get segment loop."
if len(loop) < 3:
return [loop]
path = evaluate.getPathByPrefix(getSegmentPathDefault(), prefix,
xmlElement)
if path == getSegmentPathDefault():
return [loop]
path = getXNormalizedVector3Path(path)
segmentCenter = evaluate.getVector3ByPrefix(None, prefix + 'center',
xmlElement)
if euclidean.getIsWiddershinsByVector3(loop):
path = path[::-1]
for point in path:
point.x = 1.0 - point.x
if segmentCenter == None:
point.y = -point.y
segmentLoop = []
startEnd = StartEnd(len(loop), prefix, xmlElement)
for pointIndex in xrange(len(loop)):
if pointIndex >= startEnd.start and pointIndex < startEnd.end:
segmentLoop += getSegmentPath(loop, path, pointIndex,
segmentCenter)
else:
segmentLoop.append(loop[pointIndex])
return [euclidean.getLoopWithoutCloseSequentialPoints(close, segmentLoop)]
def __init__(self, stepRatio, xmlElement):
"Initialize."
self.spiral = evaluate.getVector3ByPrefix('spiral', None, xmlElement)
if self.spiral == None:
return
self.spiralIncrement = self.spiral * stepRatio
self.spiralTotal = Vector3()
def __init__(self, xmlElement):
'Initialize.'
self.interpolationDictionary = {}
self.radius = lineation.getRadiusComplex(complex(), xmlElement)
self.tiltFollow = evaluate.getEvaluatedBoolean(True, 'tiltFollow', xmlElement)
self.tiltTop = evaluate.getVector3ByPrefix(None, 'tiltTop', xmlElement)
self.maximumUnbuckling = evaluate.getEvaluatedFloat(5.0, 'maximumUnbuckling', xmlElement)
scalePathDefault = [Vector3(1.0, 1.0, 0.0), Vector3(1.0, 1.0, 1.0)]
self.interpolationDictionary['scale'] = Interpolation().getByPrefixZ(scalePathDefault, 'scale', xmlElement)
self.target = evaluate.getTransformedPathsByKey([], 'target', xmlElement)
if self.tiltTop == None:
offsetPathDefault = [Vector3(), Vector3(0.0, 0.0, 1.0)]
self.interpolationDictionary['offset'] = Interpolation().getByPrefixZ(offsetPathDefault, '', xmlElement)
tiltPathDefault = [Vector3(), Vector3(0.0, 0.0, 1.0)]
self.interpolationDictionary['tilt'] = Interpolation().getByPrefixZ(tiltPathDefault, 'tilt', xmlElement)
for point in self.interpolationDictionary['tilt'].path:
point.x = math.radians(point.x)
point.y = math.radians(point.y)
else:
offsetAlongDefault = [Vector3(), Vector3(1.0, 0.0, 0.0)]
self.interpolationDictionary['offset'] = Interpolation().getByPrefixAlong(offsetAlongDefault, '', xmlElement)
self.twist = evaluate.getEvaluatedFloat(0.0, 'twist', xmlElement )
self.twistPathDefault = [Vector3(), Vector3(1.0, self.twist) ]
self.xmlElement = xmlElement
insertTwistPortions(self, xmlElement)
def 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 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 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, elementNode): 'Set defaults.' end = evaluate.getVector3ByPrefix(None, elementNode, 'end') start = evaluate.getVector3ByPrefix(Vector3(), elementNode, 'start') inclinationDegree = math.degrees(getInclination(end, start)) self.elementNode = elementNode self.inclination = math.radians(evaluate.getEvaluatedFloat(inclinationDegree, elementNode, 'inclination')) self.overhangRadians = setting.getOverhangRadians(elementNode) self.overhangSpan = setting.getOverhangSpan(elementNode) self.radius = lineation.getFloatByPrefixBeginEnd(elementNode, 'radius', 'diameter', 1.0) size = evaluate.getEvaluatedFloat(None, elementNode, 'size') if size != None: self.radius = 0.5 * size self.sides = evaluate.getEvaluatedFloat(None, elementNode, 'sides') if self.sides == None: self.sides = evaluate.getSidesMinimumThreeBasedOnPrecisionSides(elementNode, self.radius) self.radiusArealized = evaluate.getRadiusArealizedBasedOnAreaRadius(elementNode, self.radius, self.sides)
def setToObjectAttributeDictionary( self ): "Set the shape of this carvable object info." self.radius = evaluate.getVector3ByPrefix( 'radius', Vector3( 1.0, 1.0, 1.0 ), self.xmlElement ) self.radius = evaluate.getVector3ThroughSizeDiameter( self.radius, self.xmlElement ) self.xmlElement.attributeDictionary[ 'radiusx' ] = self.radius.x self.xmlElement.attributeDictionary[ 'radiusy' ] = self.radius.y self.xmlElement.attributeDictionary[ 'radiusz' ] = self.radius.z self.createShape()
def getManipulatedPaths( close, loop, prefix, xmlElement ): "Get translated path." delta = evaluate.getVector3ByPrefix( prefix + 'delta', Vector3(), xmlElement ) if abs( delta ) <= 0.0: return [ loop ] for point in loop: point.setToVector3( point + delta ) return [ loop ]
def setToObjectAttributeDictionary( self ): "Set the shape of this carvable object info." self.half = evaluate.getVector3ByPrefix( 'half', Vector3( 1.0, 1.0, 1.0 ), self.xmlElement ) self.half = evaluate.getVector3ThroughSizeDiameter( self.half, self.xmlElement ) self.xmlElement.attributeDictionary[ 'halfx' ] = self.half.x self.xmlElement.attributeDictionary[ 'halfy' ] = self.half.y self.xmlElement.attributeDictionary[ 'halfz' ] = self.half.z self.createShape()
def getManipulatedPaths(close, loop, prefix, xmlElement):
"Get translated path."
delta = evaluate.getVector3ByPrefix(prefix + 'delta', Vector3(),
xmlElement)
if abs(delta) <= 0.0:
return [loop]
for point in loop:
point.setToVector3(point + delta)
return [loop]
def getCubicPath(xmlElement):
"Get the cubic path."
end = evaluate.getVector3FromXMLElement(xmlElement)
previousXMLElement = xmlElement.getPreviousXMLElement()
if previousXMLElement == None:
print('Warning, can not get previousXMLElement in getCubicPath in cubic for:')
print(xmlElement)
return [end]
begin = xmlElement.getPreviousVertex(Vector3())
controlPoint0 = evaluate.getVector3ByPrefix('controlPoint0', None, xmlElement)
if controlPoint0 == None:
oldControlPoint = evaluate.getVector3ByPrefixes(['controlPoint','controlPoint1'], None, previousXMLElement)
if oldControlPoint == None:
print('Warning, can not get oldControlPoint in getCubicPath in cubic for:')
print(xmlElement)
return [end]
controlPoint0 = begin + begin - oldControlPoint
controlPoints = [controlPoint0, evaluate.getVector3ByPrefix('controlPoint1', None, xmlElement)]
return svg_reader.getCubicPoints(begin, controlPoints, end, lineation.getNumberOfBezierPoints(begin, end, xmlElement))
def __init__(self, elementNode): 'Set defaults.' self.inradius = lineation.getInradius(complex(1.0, 1.0), elementNode) self.demiwidth = lineation.getFloatByPrefixBeginEnd(elementNode, 'demiwidth', 'width', self.inradius.real) self.demiheight = lineation.getFloatByPrefixBeginEnd(elementNode, 'demiheight', 'height', self.inradius.imag) self.bottomDemiwidth = lineation.getFloatByPrefixBeginEnd(elementNode, 'bottomdemiwidth', 'bottomwidth', self.demiwidth) self.topDemiwidth = lineation.getFloatByPrefixBeginEnd(elementNode, 'topdemiwidth', 'topwidth', self.demiwidth) self.interiorAngle = evaluate.getEvaluatedFloat(90.0, elementNode, 'interiorangle') self.revolutions = evaluate.getEvaluatedInt(1, elementNode, 'revolutions') self.spiral = evaluate.getVector3ByPrefix(None, elementNode, 'spiral')
def __init__(self, elementNode): 'Set defaults.' self.inradius = lineation.getInradius(complex(1.0, 1.0), elementNode) self.demiwidth = lineation.getFloatByPrefixBeginEnd(elementNode, 'demiwidth', 'width', self.inradius.real) self.demiheight = lineation.getFloatByPrefixBeginEnd(elementNode, 'demiheight', 'height', self.inradius.imag) self.bottomDemiwidth = lineation.getFloatByPrefixBeginEnd(elementNode, 'bottomdemiwidth', 'bottomwidth', self.demiwidth) self.topDemiwidth = lineation.getFloatByPrefixBeginEnd(elementNode, 'topdemiwidth', 'topwidth', self.demiwidth) self.interiorAngle = evaluate.getEvaluatedFloat(90.0, elementNode, 'interiorangle') self.revolutions = evaluate.getEvaluatedInt(1, elementNode, 'revolutions') self.spiral = evaluate.getVector3ByPrefix(None, elementNode, 'spiral')
def setToObjectAttributeDictionary(self):
"Set the shape of this carvable object info."
self.half = evaluate.getVector3ByPrefix('half', Vector3(1.0, 1.0, 1.0),
self.xmlElement)
self.half = evaluate.getVector3ThroughSizeDiameter(
self.half, self.xmlElement)
self.xmlElement.attributeDictionary['halfx'] = self.half.x
self.xmlElement.attributeDictionary['halfy'] = self.half.y
self.xmlElement.attributeDictionary['halfz'] = self.half.z
self.createShape()
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 getCumulativeVector3Remove(defaultVector3, prefix, xmlElement): """Get cumulative vector3 and delete the prefixed attributes.""" if prefix == '': defaultVector3.x = evaluate.getEvaluatedFloat(defaultVector3.x, 'x', xmlElement) defaultVector3.y = evaluate.getEvaluatedFloat(defaultVector3.y, 'y', xmlElement) defaultVector3.z = evaluate.getEvaluatedFloat(defaultVector3.z, 'z', xmlElement) euclidean.removeElementsFromDictionary(xmlElement.attributeDictionary, ['x', 'y', 'z']) prefix = 'cartesian' defaultVector3 = evaluate.getVector3ByPrefix(defaultVector3, prefix, xmlElement) euclidean.removePrefixFromDictionary(xmlElement.attributeDictionary, prefix) return defaultVector3
def 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 getCumulativeVector3Remove(defaultVector3, elementNode, prefix):
"Get cumulative vector3 and delete the prefixed attributes."
if prefix == "":
defaultVector3.x = evaluate.getEvaluatedFloat(defaultVector3.x, elementNode, "x")
defaultVector3.y = evaluate.getEvaluatedFloat(defaultVector3.y, elementNode, "y")
defaultVector3.z = evaluate.getEvaluatedFloat(defaultVector3.z, elementNode, "z")
euclidean.removeElementsFromDictionary(elementNode.attributes, ["x", "y", "z"])
prefix = "cartesian"
defaultVector3 = evaluate.getVector3ByPrefix(defaultVector3, elementNode, prefix)
euclidean.removePrefixFromDictionary(elementNode.attributes, prefix)
return defaultVector3
def setToObjectAttributeDictionary(self):
"Set the shape of this carvable object info."
self.radius = evaluate.getVector3ByPrefix('radius',
Vector3(1.0, 1.0, 1.0),
self.xmlElement)
self.radius = evaluate.getVector3ThroughSizeDiameter(
self.radius, self.xmlElement)
self.xmlElement.attributeDictionary['radiusx'] = self.radius.x
self.xmlElement.attributeDictionary['radiusy'] = self.radius.y
self.xmlElement.attributeDictionary['radiusz'] = self.radius.z
self.createShape()
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 getCumulativeVector3Remove(defaultVector3, elementNode, prefix): 'Get cumulative vector3 and delete the prefixed attributes.' if prefix == '': defaultVector3.x = evaluate.getEvaluatedFloat(defaultVector3.x, elementNode, 'x') defaultVector3.y = evaluate.getEvaluatedFloat(defaultVector3.y, elementNode, 'y') defaultVector3.z = evaluate.getEvaluatedFloat(defaultVector3.z, elementNode, 'z') euclidean.removeElementsFromDictionary(elementNode.attributes, ['x', 'y', 'z']) prefix = 'cartesian' defaultVector3 = evaluate.getVector3ByPrefix(defaultVector3, elementNode, prefix) euclidean.removePrefixFromDictionary(elementNode.attributes, prefix) return defaultVector3
def __init__(self, elementNode):
"Set defaults."
self.inradius = lineation.getInradius(complex(1.0, 1.0), elementNode)
self.demiwidth = lineation.getFloatByPrefixBeginEnd(elementNode, "demiwidth", "width", self.inradius.real)
self.demiheight = lineation.getFloatByPrefixBeginEnd(elementNode, "demiheight", "height", self.inradius.imag)
self.bottomDemiwidth = lineation.getFloatByPrefixBeginEnd(
elementNode, "bottomdemiwidth", "bottomwidth", self.demiwidth
)
self.topDemiwidth = lineation.getFloatByPrefixBeginEnd(elementNode, "topdemiwidth", "topwidth", self.demiwidth)
self.interiorAngle = evaluate.getEvaluatedFloat(90.0, elementNode, "interiorangle")
self.revolutions = evaluate.getEvaluatedInt(1, elementNode, "revolutions")
self.spiral = evaluate.getVector3ByPrefix(None, elementNode, "spiral")
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 __init__(self, elementNode):
'Set defaults.'
end = evaluate.getVector3ByPrefix(None, elementNode, 'end')
start = evaluate.getVector3ByPrefix(Vector3(), elementNode, 'start')
inclinationDegree = math.degrees(getInclination(end, start))
self.elementNode = elementNode
self.inclination = math.radians(
evaluate.getEvaluatedFloat(inclinationDegree, elementNode,
'inclination'))
self.overhangRadians = setting.getOverhangRadians(elementNode)
self.overhangSpan = setting.getOverhangSpan(elementNode)
self.radius = lineation.getFloatByPrefixBeginEnd(
elementNode, 'radius', 'diameter', 1.0)
size = evaluate.getEvaluatedFloat(None, elementNode, 'size')
if size != None:
self.radius = 0.5 * size
self.sides = evaluate.getEvaluatedFloat(None, elementNode, 'sides')
if self.sides == None:
self.sides = evaluate.getSidesMinimumThreeBasedOnPrecisionSides(
elementNode, self.radius)
self.radiusArealized = evaluate.getRadiusArealizedBasedOnAreaRadius(
elementNode, self.radius, self.sides)
