def getPathOutput(creationFirst, gearDerivation, translation, vector3GearProfileFirst, vector3GearProfileSecond, xmlElement): "Get gear path output." vector3GearProfileFirst = lineation.getGeometryOutputByLoop(lineation.SideLoop(vector3GearProfileFirst), xmlElement) if creationFirst == 'f': return vector3GearProfileFirst vector3GearProfileSecond = lineation.getGeometryOutputByLoop(lineation.SideLoop(vector3GearProfileSecond), xmlElement) if creationFirst == 's': return vector3GearProfileSecond euclidean.translateVector3Path(vector3GearProfileSecond, translation) return [vector3GearProfileFirst, vector3GearProfileSecond]
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 getGeometryOutput(derivation, xmlElement):
"Get vector3 vertexes from attribute dictionary."
if derivation == None:
derivation = LineDerivation()
derivation.setToXMLElement(xmlElement)
endMinusStart = derivation.end - derivation.start
endMinusStartLength = abs(endMinusStart)
if endMinusStartLength <= 0.0:
print('Warning, end is the same as start in getGeometryOutput in line for:')
print(derivation.start)
print(derivation.end)
print(xmlElement)
return None
typeStringTwoCharacters = derivation.typeString.lower()[: 2]
xmlElement.attributeDictionary['closed'] = str(derivation.closed)
if derivation.step == None and derivation.steps == None:
return lineation.getGeometryOutputByLoop(lineation.SideLoop([derivation.start, derivation.end]), xmlElement)
loop = [derivation.start]
if derivation.step != None and derivation.steps != None:
stepVector = derivation.step / endMinusStartLength * endMinusStart
derivation.end = derivation.start + stepVector * derivation.steps
return getGeometryOutputByStep(derivation.end, loop, derivation.steps, stepVector, xmlElement)
if derivation.step == None:
stepVector = endMinusStart / derivation.steps
return getGeometryOutputByStep(derivation.end, loop, derivation.steps, stepVector, xmlElement)
endMinusStartLengthOverStep = endMinusStartLength / derivation.step
if typeStringTwoCharacters == 'av':
derivation.steps = max(1.0, round(endMinusStartLengthOverStep))
stepVector = derivation.step / endMinusStartLength * endMinusStart
derivation.end = derivation.start + stepVector * derivation.steps
return getGeometryOutputByStep(derivation.end, loop, derivation.steps, stepVector, xmlElement)
if typeStringTwoCharacters == 'ma':
derivation.steps = math.ceil(endMinusStartLengthOverStep)
if derivation.steps < 1.0:
return lineation.getGeometryOutputByLoop(lineation.SideLoop([derivation.start, derivation.end]), xmlElement)
stepVector = endMinusStart / derivation.steps
return getGeometryOutputByStep(derivation.end, loop, derivation.steps, stepVector, xmlElement)
if typeStringTwoCharacters == 'mi':
derivation.steps = math.floor(endMinusStartLengthOverStep)
if derivation.steps < 1.0:
return lineation.getGeometryOutputByLoop(lineation.SideLoop(loop), xmlElement)
stepVector = endMinusStart / derivation.steps
return getGeometryOutputByStep(derivation.end, loop, derivation.steps, stepVector, xmlElement)
print('Warning, the step type was not one of (average, maximum or minimum) in getGeometryOutput in line for:')
print(derivation.typeString)
print(xmlElement)
loop.append(derivation.end)
return lineation.getGeometryOutputByLoop(lineation.SideLoop(loop), xmlElement)
def getGeometryOutput(derivation, xmlElement): "Get vector3 vertexes from attribute dictionary." if derivation == None: derivation = ShaftDerivation() derivation.setToXMLElement(xmlElement) shaftPath = getShaftPath(derivation.depthBottom, derivation.depthTop, derivation.radius, derivation.sides) return lineation.getGeometryOutputByLoop(lineation.SideLoop(shaftPath), xmlElement)
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 getGeometryOutputByStep(elementNode, end, loop, steps, stepVector): "Get line geometry output by the end, loop, steps and stepVector." stepsFloor = int(math.floor(abs(steps))) for stepIndex in xrange(1, stepsFloor): loop.append(loop[stepIndex - 1] + stepVector) loop.append(end) return lineation.getGeometryOutputByLoop(elementNode, lineation.SideLoop(loop))
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 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 getGeometryOutput(derivation, elementNode): "Get vector3 vertexes from attribute dictionary." if derivation == None: derivation = TeardropDerivation(elementNode) teardropPath = getTeardropPath( derivation.inclination, derivation.overhangRadians, derivation.overhangSpan, derivation.radiusArealized, derivation.sides) return lineation.getGeometryOutputByLoop(elementNode, lineation.SideLoop(teardropPath))
def getGeometryOutput(derivation, xmlElement): "Get vector3 vertexes from attribute dictionary." if derivation == None: derivation = TeardropDerivation() derivation.setToXMLElement(xmlElement) teardropPath = getTeardropPath(derivation.inclination, derivation.radius, xmlElement) return lineation.getGeometryOutputByLoop(lineation.SideLoop(teardropPath), xmlElement)
def getGeometryOutput(elementNode):
'Get vector3 vertexes from attribute dictionary.'
derivation = GridDerivation(elementNode)
diameter = derivation.radius + derivation.radius
typeStringTwoCharacters = derivation.typeString.lower()[: 2]
typeStringFirstCharacter = typeStringTwoCharacters[: 1]
topRight = complex(derivation.demiwidth, derivation.demiheight)
loopsComplex = [euclidean.getSquareLoopWiddershins(-topRight, topRight)]
if len(derivation.target) > 0:
loopsComplex = euclidean.getComplexPaths(derivation.target)
maximumComplex = euclidean.getMaximumByComplexPaths(loopsComplex)
minimumComplex = euclidean.getMinimumByComplexPaths(loopsComplex)
gridPath = None
if typeStringTwoCharacters == 'he':
gridPath = getHexagonalGrid(diameter, loopsComplex, maximumComplex, minimumComplex, derivation.zigzag)
elif typeStringTwoCharacters == 'ra' or typeStringFirstCharacter == 'a':
gridPath = getRandomGrid(derivation, diameter, elementNode, loopsComplex, maximumComplex, minimumComplex)
elif typeStringTwoCharacters == 're' or typeStringFirstCharacter == 'e':
gridPath = getRectangularGrid(diameter, loopsComplex, maximumComplex, minimumComplex, derivation.zigzag)
if gridPath == None:
print('Warning, the step type was not one of (hexagonal, random or rectangular) in getGeometryOutput in grid for:')
print(derivation.typeString)
print(elementNode)
return []
loop = euclidean.getVector3Path(gridPath)
elementNode.attributes['closed'] = 'false'
return lineation.getGeometryOutputByLoop(elementNode, lineation.SideLoop(loop, 0.5 * math.pi))
def getGeometryOutput(derivation, xmlElement): "Get vector3 vertexes from attribute dictionary." if derivation == None: derivation = SquareDerivation() derivation.setToXMLElement(xmlElement) topRight = complex(derivation.topDemiwidth, derivation.demiheight) topLeft = complex(-derivation.topDemiwidth, derivation.demiheight) bottomLeft = complex(-derivation.bottomDemiwidth, -derivation.demiheight) bottomRight = complex(derivation.bottomDemiwidth, -derivation.demiheight) if derivation.interiorAngle != 90.0: interiorPlaneAngle = euclidean.getWiddershinsUnitPolar(math.radians(derivation.interiorAngle - 90.0)) topRight = (topRight - bottomRight) * interiorPlaneAngle + bottomRight topLeft = (topLeft - bottomLeft) * interiorPlaneAngle + bottomLeft lineation.setClosedAttribute(derivation.revolutions, xmlElement) complexLoop = [topRight, topLeft, bottomLeft, bottomRight] originalLoop = complexLoop[:] for revolution in xrange(1, derivation.revolutions): complexLoop += originalLoop spiral = lineation.Spiral(derivation.spiral, 0.25) 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 getGeometryOutput(derivation, xmlElement):
"Get triangle mesh from attribute dictionary."
if derivation == None:
derivation = ConcatenateDerivation(xmlElement)
concatenatedList = euclidean.getConcatenatedList(derivation.target)[:]
if len(concatenatedList) == 0:
print("Warning, in concatenate there are no paths.")
print(xmlElement.attributeDictionary)
return None
if "closed" not in xmlElement.attributeDictionary:
xmlElement.attributeDictionary["closed"] = "true"
return lineation.getGeometryOutputByLoop(lineation.SideLoop(concatenatedList, None, None), xmlElement)
def getGeometryOutput(derivation, elementNode):
'Get triangle mesh from attribute dictionary.'
if derivation == None:
derivation = ConcatenateDerivation(elementNode)
concatenatedList = euclidean.getConcatenatedList(derivation.target)[:]
if len(concatenatedList) == 0:
print('Warning, in concatenate there are no paths.')
print(elementNode.attributes)
return None
if 'closed' not in elementNode.attributes:
elementNode.attributes['closed'] = 'true'
return lineation.getGeometryOutputByLoop(elementNode, lineation.SideLoop(concatenatedList, None, None))
def getGeometryOutput(derivation, elementNode): "Get vector3 vertexes from attribute dictionary." if derivation == None: derivation = PolygonDerivation(elementNode) loop = [] spiral = lineation.Spiral(derivation.spiral, 0.5 * derivation.sideAngle / math.pi) for side in xrange(derivation.start, derivation.start + derivation.extent + 1): angle = float(side) * derivation.sideAngle unitPolar = euclidean.getWiddershinsUnitPolar(angle) vertex = spiral.getSpiralPoint(unitPolar, Vector3(unitPolar.real * derivation.radius.real, unitPolar.imag * derivation.radius.imag)) loop.append(vertex) loop = euclidean.getLoopWithoutCloseEnds(0.000001 * max(derivation.radius.real, derivation.radius.imag), loop) lineation.setClosedAttribute(elementNode, derivation.revolutions) return lineation.getGeometryOutputByLoop(elementNode, lineation.SideLoop(loop, derivation.sideAngle))
def getGeometryOutput(derivation, xmlElement): "Get vector3 vertexes from attribute dictionary." if derivation == None: derivation = PolygonDerivation() derivation.setToXMLElement(xmlElement) loop = [] spiral = lineation.Spiral(derivation.spiral, 0.5 * derivation.sideAngle / math.pi) for side in xrange(derivation.start, derivation.end): angle = float(side) * derivation.sideAngle unitPolar = euclidean.getWiddershinsUnitPolar(angle) vertex = spiral.getSpiralPoint(unitPolar, Vector3(unitPolar.real * derivation.radius.real, unitPolar.imag * derivation.radius.imag)) loop.append(vertex) sideLength = derivation.sideAngle * lineation.getRadiusAverage(derivation.radius) lineation.setClosedAttribute(derivation.revolutions, xmlElement) return lineation.getGeometryOutputByLoop(lineation.SideLoop(loop, derivation.sideAngle, sideLength), xmlElement)
def getGeometryOutput(derivation, xmlElement): "Get vector3 vertexes from attribute dictionary." if derivation == None: derivation = CircleDerivation(xmlElement) loop = [] angleTotal = math.radians(derivation.start) sidesCeiling = int(math.ceil(abs(derivation.sides) * derivation.extent / 360.0)) sideAngle = math.radians(derivation.extent) / sidesCeiling spiral = lineation.Spiral(derivation.spiral, 0.5 * sideAngle / math.pi) for side in xrange(sidesCeiling + 1): unitPolar = euclidean.getWiddershinsUnitPolar(angleTotal) vertex = spiral.getSpiralPoint(unitPolar, Vector3(unitPolar.real * derivation.radius.real, unitPolar.imag * derivation.radius.imag)) angleTotal += sideAngle loop.append(vertex) loop = euclidean.getLoopWithoutCloseEnds(0.000001 * max(derivation.radius.real, derivation.radius.imag), loop) sideLength = sideAngle * lineation.getRadiusAverage(derivation.radius) lineation.setClosedAttribute(derivation.revolutions, xmlElement) return lineation.getGeometryOutputByLoop(lineation.SideLoop(loop, sideAngle, sideLength), xmlElement)
def getGeometryOutput(xmlElement): "Get vector3 vertices 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) for side in xrange(startEnd.start, startEnd.end): angle = float(side) * sideAngle 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 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(derivation, elementNode): "Get vector3 vertexes from attribute dictionary." if derivation == None: derivation = CircleDerivation(elementNode) angleTotal = math.radians(derivation.start) loop = [] sidesCeiling = int(math.ceil(abs(derivation.sides) * derivation.extent / 360.0)) sideAngle = math.radians(derivation.extent) / sidesCeiling if derivation.sides < 0.0: sideAngle = -sideAngle spiral = lineation.Spiral(derivation.spiral, 0.5 * sideAngle / math.pi) for side in xrange(sidesCeiling + 1): unitPolar = euclidean.getWiddershinsUnitPolar(angleTotal) x = unitPolar.real * derivation.radiusArealized.real y = unitPolar.imag * derivation.radiusArealized.imag vertex = spiral.getSpiralPoint(unitPolar, Vector3(x, y)) angleTotal += sideAngle loop.append(vertex) radiusMaximum = 0.000001 * max(derivation.radiusArealized.real, derivation.radiusArealized.imag) loop = euclidean.getLoopWithoutCloseEnds(radiusMaximum, loop) lineation.setClosedAttribute(elementNode, derivation.revolutions) return lineation.getGeometryOutputByLoop(elementNode, lineation.SideLoop(loop, sideAngle))
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 getGeometryOutput(xmlElement):
"Get vector3 vertices from attribute dictionary."
inradius = complex( 1.0, 1.0 )
inradius = lineation.getComplexByPrefixes( ['demisize', 'inradius'], inradius, 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
loop = [
Vector3( topRight.real, topRight.imag ),
Vector3( topLeft.real, topLeft.imag ),
Vector3( bottomLeft.real, bottomLeft.imag ),
Vector3( bottomRight.real, bottomRight.imag ) ]
return lineation.getGeometryOutputByLoop( lineation.SideLoop( loop, 0.5 * math.pi ), xmlElement )
def getGeometryOutput(xmlElement):
"Get vector3 vertexes from attribute dictionary."
inradius = lineation.getComplexByPrefixes(['demisize', 'inradius'], complex(5.0, 5.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)
radius = lineation.getComplexByPrefixBeginEnd('elementRadius', 'elementDiameter', complex(1.0, 1.0), xmlElement)
radius = lineation.getComplexByPrefixBeginEnd('radius', 'diameter', radius, xmlElement)
diameter = radius + radius
typeString = evaluate.getEvaluatedStringDefault('rectangular', 'type', xmlElement)
typeStringTwoCharacters = typeString.lower()[: 2]
typeStringFirstCharacter = typeStringTwoCharacters[: 1]
zigzag = evaluate.getEvaluatedBooleanDefault(True, 'zigzag', xmlElement)
topRight = complex(demiwidth, demiheight)
bottomLeft = -topRight
loopsComplex = [euclidean.getSquareLoopWiddershins(bottomLeft, topRight)]
paths = evaluate.getTransformedPathsByKey('target', xmlElement)
if len(paths) > 0:
loopsComplex = euclidean.getComplexPaths(paths)
maximumComplex = euclidean.getMaximumByPathsComplex(loopsComplex)
minimumComplex = euclidean.getMinimumByPathsComplex(loopsComplex)
gridPath = None
if typeStringTwoCharacters == 'he':
gridPath = getHexagonalGrid(diameter, loopsComplex, maximumComplex, minimumComplex, zigzag)
elif typeStringTwoCharacters == 'ra' or typeStringFirstCharacter == 'a':
gridPath = getRandomGrid(diameter, loopsComplex, maximumComplex, minimumComplex, xmlElement)
elif typeStringTwoCharacters == 're' or typeStringFirstCharacter == 'e':
gridPath = getRectangularGrid(diameter, loopsComplex, maximumComplex, minimumComplex, zigzag)
if gridPath == None:
print('Warning, the step type was not one of (hexagonal, random or rectangular) in getGeometryOutput in grid for:')
print(typeString)
print(xmlElement)
return []
loop = euclidean.getVector3Path(gridPath)
xmlElement.attributeDictionary['closed'] = 'false'
return lineation.getGeometryOutputByLoop(lineation.SideLoop(loop, 0.5 * math.pi), xmlElement)
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 getGeometryOutput(derivation, xmlElement): "Get vector3 vertexes from attribute dictionary." if derivation == None: derivation = TeardropDerivation(xmlElement) teardropPath = getTeardropPath(derivation.inclination, derivation.radius, xmlElement) return lineation.getGeometryOutputByLoop(lineation.SideLoop(teardropPath), xmlElement)
def getGeometryOutput(derivation, elementNode): "Get vector3 vertexes from attribute dictionary." if derivation is None: derivation = ShaftDerivation(elementNode) shaftPath = getShaftPath(derivation.depthBottom, derivation.depthTop, derivation.radius, derivation.sides) return lineation.getGeometryOutputByLoop(elementNode, lineation.SideLoop(shaftPath))
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 getGeometryOutput(derivation, elementNode): "Get vector3 vertexes from attribute dictionary." if derivation == None: derivation = ShaftDerivation(elementNode) shaftPath = getShaftPath(derivation.depthBottom, derivation.depthTop, derivation.radius, derivation.sides) return lineation.getGeometryOutputByLoop(elementNode, lineation.SideLoop(shaftPath))
def getGeometryOutput(derivation, elementNode):
"Get vector3 vertexes from attribute dictionary."
if derivation == None:
derivation = LineDerivation(elementNode)
endMinusStart = derivation.end - derivation.start
endMinusStartLength = abs(endMinusStart)
if endMinusStartLength <= 0.0:
print(
'Warning, end is the same as start in getGeometryOutput in line for:'
)
print(derivation.start)
print(derivation.end)
print(elementNode)
return None
typeStringTwoCharacters = derivation.typeString.lower()[:2]
elementNode.attributes['closed'] = str(derivation.closed)
if derivation.step == None and derivation.steps == None:
return lineation.getGeometryOutputByLoop(
elementNode, lineation.SideLoop([derivation.start,
derivation.end]))
loop = [derivation.start]
if derivation.step != None and derivation.steps != None:
stepVector = derivation.step / endMinusStartLength * endMinusStart
derivation.end = derivation.start + stepVector * derivation.steps
return getGeometryOutputByStep(elementNode, derivation.end, loop,
derivation.steps, stepVector)
if derivation.step == None:
stepVector = endMinusStart / derivation.steps
return getGeometryOutputByStep(elementNode, derivation.end, loop,
derivation.steps, stepVector)
endMinusStartLengthOverStep = endMinusStartLength / derivation.step
if typeStringTwoCharacters == 'av':
derivation.steps = max(1.0, round(endMinusStartLengthOverStep))
stepVector = derivation.step / endMinusStartLength * endMinusStart
derivation.end = derivation.start + stepVector * derivation.steps
return getGeometryOutputByStep(elementNode, derivation.end, loop,
derivation.steps, stepVector)
if typeStringTwoCharacters == 'ma':
derivation.steps = math.ceil(endMinusStartLengthOverStep)
if derivation.steps < 1.0:
return lineation.getGeometryOutputByLoop(
elementNode,
lineation.SideLoop([derivation.start, derivation.end]))
stepVector = endMinusStart / derivation.steps
return getGeometryOutputByStep(elementNode, derivation.end, loop,
derivation.steps, stepVector)
if typeStringTwoCharacters == 'mi':
derivation.steps = math.floor(endMinusStartLengthOverStep)
if derivation.steps < 1.0:
return lineation.getGeometryOutputByLoop(elementNode,
lineation.SideLoop(loop))
stepVector = endMinusStart / derivation.steps
return getGeometryOutputByStep(elementNode, derivation.end, loop,
derivation.steps, stepVector)
print(
'Warning, the step type was not one of (average, maximum or minimum) in getGeometryOutput in line for:'
)
print(derivation.typeString)
print(elementNode)
loop.append(derivation.end)
return lineation.getGeometryOutputByLoop(elementNode,
lineation.SideLoop(loop))