Example #1
0
File: cool.py Project: Ademan/Cura
	def addCoolOrbits(self, remainingOrbitTime):
		'Add the minimum radius cool orbits.'
		if len(self.boundaryLayer.loops) < 1:
			return
		insetBoundaryLoops = self.boundaryLayer.loops
		if abs(self.repository.orbitalOutset.value) > 0.1 * abs(self.edgeWidth):
			insetBoundaryLoops = intercircle.getInsetLoopsFromLoops(self.boundaryLayer.loops, -self.repository.orbitalOutset.value)
		if len(insetBoundaryLoops) < 1:
			insetBoundaryLoops = self.boundaryLayer.loops
		largestLoop = euclidean.getLargestLoop(insetBoundaryLoops)
		loopArea = euclidean.getAreaLoopAbsolute(largestLoop)
		if loopArea < self.minimumArea:
			center = 0.5 * (euclidean.getMaximumByComplexPath(largestLoop) + euclidean.getMinimumByComplexPath(largestLoop))
			centerXBounded = max(center.real, self.boundingRectangle.cornerMinimum.real)
			centerXBounded = min(centerXBounded, self.boundingRectangle.cornerMaximum.real)
			centerYBounded = max(center.imag, self.boundingRectangle.cornerMinimum.imag)
			centerYBounded = min(centerYBounded, self.boundingRectangle.cornerMaximum.imag)
			center = complex(centerXBounded, centerYBounded)
			maximumCorner = center + self.halfCorner
			minimumCorner = center - self.halfCorner
			largestLoop = euclidean.getSquareLoopWiddershins(minimumCorner, maximumCorner)
		pointComplex = euclidean.getXYComplexFromVector3(self.oldLocation)
		if pointComplex != None:
			largestLoop = euclidean.getLoopStartingClosest(self.edgeWidth, pointComplex, largestLoop)
		intercircle.addOrbitsIfLarge(
			self.distanceFeedRate, largestLoop, self.orbitalFeedRatePerSecond, remainingOrbitTime, self.highestZ)
Example #2
0
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))
Example #3
0
 def addCoolOrbits(self, remainingOrbitTime):
     'Add the minimum radius cool orbits.'
     if len(self.boundaryLayer.loops) < 1:
         return
     insetBoundaryLoops = intercircle.getInsetLoopsFromLoops(
         self.perimeterWidth, self.boundaryLayer.loops)
     if len(insetBoundaryLoops) < 1:
         insetBoundaryLoops = self.boundaryLayer.loops
     largestLoop = euclidean.getLargestLoop(insetBoundaryLoops)
     loopArea = euclidean.getAreaLoopAbsolute(largestLoop)
     if loopArea < self.minimumArea:
         center = 0.5 * (euclidean.getMaximumByComplexPath(largestLoop) +
                         euclidean.getMinimumByComplexPath(largestLoop))
         centerXBounded = max(center.real,
                              self.boundingRectangle.cornerMinimum.real)
         centerXBounded = min(centerXBounded,
                              self.boundingRectangle.cornerMaximum.real)
         centerYBounded = max(center.imag,
                              self.boundingRectangle.cornerMinimum.imag)
         centerYBounded = min(centerYBounded,
                              self.boundingRectangle.cornerMaximum.imag)
         center = complex(centerXBounded, centerYBounded)
         maximumCorner = center + self.halfCorner
         minimumCorner = center - self.halfCorner
         largestLoop = euclidean.getSquareLoopWiddershins(
             minimumCorner, maximumCorner)
     pointComplex = euclidean.getXYComplexFromVector3(self.oldLocation)
     if pointComplex != None:
         largestLoop = euclidean.getLoopStartingNearest(
             self.perimeterWidth, pointComplex, largestLoop)
     intercircle.addOrbitsIfLarge(self.distanceFeedRate, largestLoop,
                                  self.orbitalFeedRatePerSecond,
                                  remainingOrbitTime, self.highestZ)
def getGeometryOutput(derivation, elementNode):
	"Get vector3 vertexes from attribute dictionary."
	if derivation is None:
		derivation = SpongeSliceDerivation(elementNode)
	awayPoints = []
	vector3Path = euclidean.getVector3Path(euclidean.getSquareLoopWiddershins(-derivation.inradius, derivation.inradius))
	geometryOutput = lineation.SideLoop(vector3Path).getManipulationPluginLoops(elementNode)
	minimumDistanceFromOther = derivation.wallThickness + derivation.minimumRadius + derivation.minimumRadius
	if derivation.inradiusMinusRadiusThickness.real <= 0.0 or derivation.inradiusMinusRadiusThickness.imag <= 0.0:
		return geometryOutput
	for point in derivation.path:
		if abs(point.x) <= derivation.inradiusMinusRadiusThickness.real and abs(point.y) <= derivation.inradiusMinusRadiusThickness.imag:
			awayPoints.append(point)
	awayCircles = []
	for point in awayPoints:
		if getIsPointAway(minimumDistanceFromOther, point, awayCircles):
			awayCircles.append(SpongeCircle(point, derivation.minimumRadius))
	averagePotentialBubbleArea = derivation.potentialBubbleArea / float(len(awayCircles))
	averageBubbleRadius = math.sqrt(averagePotentialBubbleArea / math.pi) - 0.5 * derivation.wallThickness
	sides = -4 * (max(evaluate.getSidesBasedOnPrecision(elementNode, averageBubbleRadius), 4) / 4)
	sideAngle = math.pi / sides
	cosSide = math.cos(sideAngle)
	overlapArealRatio = (1 - cosSide) / cosSide
	for circleIndex, circle in enumerate(awayCircles):
		otherCircles = awayCircles[: circleIndex] + awayCircles[circleIndex + 1 :]
		circle.radius = circle.getRadius(circle.center, derivation, otherCircles, overlapArealRatio)
	if derivation.searchAttempts > 0:
		for circleIndex, circle in enumerate(awayCircles):
			otherCircles = awayCircles[: circleIndex] + awayCircles[circleIndex + 1 :]
			circle.moveCircle(derivation, otherCircles, overlapArealRatio)
	for circle in awayCircles:
		vector3Path = euclidean.getVector3Path(euclidean.getComplexPolygon(circle.center.dropAxis(), circle.radius, sides, sideAngle))
		geometryOutput += lineation.SideLoop(vector3Path).getManipulationPluginLoops(elementNode)
	return geometryOutput
    def cool(self, layer):
        '''Apply the cooling by moving the nozzle around the print.'''

        if layer.index == 0:
            # We don't have to slow down on the first layer
            return

        (layerDistance, layerDuration) = layer.getDistanceAndDuration()
        remainingOrbitTime = max(self.minimumLayerTime - layerDuration, 0.0)

        boundaryLayerLoops = []
        for nestedRing in layer.nestedRings:
            boundaryLayerLoops.append(nestedRing.getXYBoundaries())

        if remainingOrbitTime > 0.0 and boundaryLayerLoops != None:
            if len(boundaryLayerLoops) < 1:
                return

            largestLoop = euclidean.getLargestLoop(boundaryLayerLoops)
            cornerMinimum = euclidean.getMinimumByComplexPath(largestLoop) - self.oribitalMargin
            cornerMaximum = euclidean.getMaximumByComplexPath(largestLoop) + self.oribitalMargin

            largestLoop = euclidean.getSquareLoopWiddershins(cornerMaximum, cornerMinimum)

            if len(largestLoop) > 1 and remainingOrbitTime > 1.5 :
                timeInOrbit = 0.0

                while timeInOrbit < remainingOrbitTime:
                    for point in largestLoop:
                        gcodeArgs = [('X', round(point.real, self.decimalPlaces)),
                                     ('Y', round(point.imag, self.decimalPlaces)),
                                     ('Z', round(layer.z, self.decimalPlaces)),
                                     ('F', round(self.orbitalFeedRateMinute, self.decimalPlaces))]
                        layer.preLayerGcodeCommands.append(GcodeCommand(gcodes.LINEAR_GCODE_MOVEMENT, gcodeArgs))
                    timeInOrbit += euclidean.getLoopLength(largestLoop) / self.orbitalFeedRateSecond
Example #6
0
def getGeometryOutput(derivation, xmlElement):
	"Get vector3 vertexes from attribute dictionary."
	if derivation == None:
		derivation = GridDerivation()
		derivation.setToXMLElement(xmlElement)
	diameter = derivation.radius + derivation.radius
	typeStringTwoCharacters = derivation.typeString.lower()[: 2]
	typeStringFirstCharacter = typeStringTwoCharacters[: 1]
	topRight = complex(derivation.demiwidth, derivation.demiheight)
	bottomLeft = -topRight
	loopsComplex = [euclidean.getSquareLoopWiddershins(bottomLeft, topRight)]
	if len(derivation.target) > 0:
		loopsComplex = euclidean.getComplexPaths(derivation.target)
	maximumComplex = euclidean.getMaximumByPathsComplex(loopsComplex)
	minimumComplex = euclidean.getMinimumByPathsComplex(loopsComplex)
	gridPath = None
	if typeStringTwoCharacters == 'he':
		gridPath = getHexagonalGrid(diameter, loopsComplex, maximumComplex, minimumComplex, derivation.zigzag)
	elif typeStringTwoCharacters == 'ra' or typeStringFirstCharacter == 'a':
		gridPath = getRandomGrid(derivation, diameter, loopsComplex, maximumComplex, minimumComplex, xmlElement)
	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(xmlElement)
		return []
	loop = euclidean.getVector3Path(gridPath)
	xmlElement.attributeDictionary['closed'] = 'false'
	return lineation.getGeometryOutputByLoop(lineation.SideLoop(loop, 0.5 * math.pi), xmlElement)
Example #7
0
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 = derivation.inradius
    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))
Example #8
0
def getGeometryOutput(elementNode):
	'Get vector3 vertexes from attribute dictionary.'
	derivation = VoronoiDerivation(elementNode)
	complexPath = euclidean.getConcatenatedList(euclidean.getComplexPaths(derivation.target))
	geometryOutput = []
	topRight = derivation.inradius
	squareLoop = euclidean.getSquareLoopWiddershins(-topRight, topRight)
	loopComplexes = []
	for pointIndex, point in enumerate(complexPath):
		outsides = complexPath[: pointIndex] + complexPath[pointIndex + 1 :]
		loopComplex = getVoronoiLoopByPoints(point, squareLoop, outsides)
		loopComplex = intercircle.getLargestInsetLoopFromLoop(loopComplex, derivation.radius)
		loopComplexes.append(loopComplex)
	elementNode.attributes['closed'] = 'true'
	for loopComplex in loopComplexes:
		vector3Path = euclidean.getVector3Path(loopComplex)
		geometryOutput += lineation.SideLoop(vector3Path).getManipulationPluginLoops(elementNode)
	return geometryOutput
Example #9
0
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)