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, 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 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, 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 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 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)