def getManipulatedGeometryOutput(elementNode, geometryOutput, prefix):
'Get outset geometryOutput.'
derivation = OutsetDerivation(elementNode, prefix)
if derivation.radius == 0.0:
return geometryOutput
halfLayerHeight = 0.5 * derivation.radius
importRadius = 0.5 * derivation.radius * setting.getImportCoarseness(
elementNode)
loopLayers = solid.getLoopLayersSetCopy(elementNode, geometryOutput,
importRadius, derivation.radius)
if len(loopLayers) == 0:
return triangle_mesh.getMeldedPillarOutput([])
triangleAltitude = math.sqrt(0.75) * derivation.radius
loops = []
vertexes = []
for loopLayerIndex in xrange(1, len(loopLayers), 2):
loopLayer = loopLayers[loopLayerIndex]
loopLayer.loops[0] = intercircle.getLargestInsetLoopFromLoop(
loopLayer.loops[0], triangleAltitude)
z = loopLayers[0].z - derivation.radius
for loopIndex in xrange(-2, len(loopLayers) + 2, 2):
loopLists = [[solid.getLoopOrEmpty(loopIndex - 2, loopLayers)]]
loopLists.append([solid.getLoopOrEmpty(loopIndex - 1, loopLayers)])
loopLists.append([
intercircle.getLargestInsetLoopFromLoop(
solid.getLoopOrEmpty(loopIndex, loopLayers),
-derivation.radius)
])
loopLists.append([solid.getLoopOrEmpty(loopIndex + 1, loopLayers)])
loopLists.append([solid.getLoopOrEmpty(loopIndex + 2, loopLayers)])
largestLoop = euclidean.getLargestLoop(
boolean_solid.getLoopsUnion(importRadius, loopLists))
triangle_mesh.addVector3Loop(largestLoop, loops, vertexes, z)
z += derivation.radius
return triangle_mesh.getMeldedPillarOutput(loops)
def getManipulatedGeometryOutput(elementNode, geometryOutput, prefix): 'Get outset geometryOutput.' derivation = OutsetDerivation(elementNode, prefix) if derivation.radius == 0.0: return geometryOutput halfLayerHeight = 0.5 * derivation.radius importRadius = 0.5 * derivation.radius * setting.getImportCoarseness(elementNode) loopLayers = solid.getLoopLayersSetCopy(elementNode, geometryOutput, importRadius, derivation.radius) if len(loopLayers) == 0: return triangle_mesh.getMeldedPillarOutput([]) triangleAltitude = math.sqrt(0.75) * derivation.radius loops = [] vertexes = [] for loopLayerIndex in xrange(1, len(loopLayers), 2): loopLayer = loopLayers[loopLayerIndex] loopLayer.loops[0] = intercircle.getLargestInsetLoopFromLoop(loopLayer.loops[0], triangleAltitude) z = loopLayers[0].z - derivation.radius for loopIndex in xrange(-2, len(loopLayers) + 2, 2): loopLists = [[solid.getLoopOrEmpty(loopIndex - 2, loopLayers)]] loopLists.append([solid.getLoopOrEmpty(loopIndex - 1, loopLayers)]) loopLists.append([intercircle.getLargestInsetLoopFromLoop(solid.getLoopOrEmpty(loopIndex, loopLayers), -derivation.radius)]) loopLists.append([solid.getLoopOrEmpty(loopIndex + 1, loopLayers)]) loopLists.append([solid.getLoopOrEmpty(loopIndex + 2, loopLayers)]) largestLoop = euclidean.getLargestLoop(boolean_solid.getLoopsUnion(importRadius, loopLists)) triangle_mesh.addVector3Loop(largestLoop, loops, vertexes, z) z += derivation.radius return triangle_mesh.getMeldedPillarOutput(loops)
def getManipulatedGeometryOutput(elementNode, geometryOutput, prefix): 'Get inset geometryOutput.' derivation = InsetDerivation(elementNode, prefix) if derivation.radius == 0.0: return geometryOutput halfLayerHeight = 0.5 * derivation.radius importRadius = 0.5 * derivation.radius * setting.getImportCoarseness(elementNode) loopLayers = solid.getLoopLayersSetCopy(elementNode, geometryOutput, importRadius, derivation.radius) triangleAltitude = math.sqrt(0.75) * derivation.radius loops = [] vertexes = [] for loopLayerIndex in xrange(1, len(loopLayers), 2): loopLayer = loopLayers[loopLayerIndex] loopLayer.loops[0] = intercircle.getLargestInsetLoopFromLoop(loopLayer.loops[0], triangleAltitude) for loopLayerIndex in xrange(0, len(loopLayers), 2): loopLayer = loopLayers[loopLayerIndex] loopLists = [[solid.getLoopOrEmpty(loopLayerIndex - 2, loopLayers)]] loopLists.append([solid.getLoopOrEmpty(loopLayerIndex - 1, loopLayers)]) loopLists.append([intercircle.getLargestInsetLoopFromLoop(loopLayer.loops[0], derivation.radius)]) if evaluate.getEvaluatedBoolean(True, elementNode, prefix + 'insetTop'): loopLists.append([solid.getLoopOrEmpty(loopLayerIndex + 1, loopLayers)]) loopLists.append([solid.getLoopOrEmpty(loopLayerIndex + 2, loopLayers)]) largestLoop = euclidean.getLargestLoop(boolean_solid.getLoopsIntersection(importRadius, loopLists)) triangle_mesh.addVector3Loop(largestLoop, loops, vertexes, loopLayer.z) if evaluate.getEvaluatedBoolean(False, elementNode, prefix + 'addExtraTopLayer') and len(loops) > 0: topLoop = loops[-1] vector3Loop = [] loops.append(vector3Loop) z = topLoop[0].z + derivation.radius for point in topLoop: vector3Index = Vector3Index(len(vertexes), point.x, point.y, z) vector3Loop.append(vector3Index) vertexes.append(vector3Index) return triangle_mesh.getMeldedPillarOutput(loops)
def getManipulatedGeometryOutput(elementNode, geometryOutput, prefix): 'Get inset geometryOutput.' derivation = InsetDerivation(elementNode, prefix) if derivation.radius == 0.0: return geometryOutput halfLayerHeight = 0.5 * derivation.radius importRadius = 0.5 * derivation.radius * setting.getImportCoarseness(elementNode) loopLayers = solid.getLoopLayersSetCopy(elementNode, geometryOutput, importRadius, derivation.radius) triangleAltitude = math.sqrt(0.75) * derivation.radius loops = [] vertexes = [] for loopLayerIndex in xrange(1, len(loopLayers), 2): loopLayer = loopLayers[loopLayerIndex] loopLayer.loops[0] = intercircle.getLargestInsetLoopFromLoop(loopLayer.loops[0], triangleAltitude) for loopLayerIndex in xrange(0, len(loopLayers), 2): loopLayer = loopLayers[loopLayerIndex] loopLists = [[solid.getLoopOrEmpty(loopLayerIndex - 2, loopLayers)]] loopLists.append([solid.getLoopOrEmpty(loopLayerIndex - 1, loopLayers)]) loopLists.append([intercircle.getLargestInsetLoopFromLoop(loopLayer.loops[0], derivation.radius)]) if evaluate.getEvaluatedBoolean(True, elementNode, prefix + 'insetTop'): loopLists.append([solid.getLoopOrEmpty(loopLayerIndex + 1, loopLayers)]) loopLists.append([solid.getLoopOrEmpty(loopLayerIndex + 2, loopLayers)]) largestLoop = euclidean.getLargestLoop(boolean_solid.getLoopsIntersection(importRadius, loopLists)) triangle_mesh.addVector3Loop(largestLoop, loops, vertexes, loopLayer.z) if evaluate.getEvaluatedBoolean(False, elementNode, prefix + 'addExtraTopLayer') and len(loops) > 0: topLoop = loops[-1] vector3Loop = [] loops.append(vector3Loop) z = topLoop[0].z + derivation.radius for point in topLoop: vector3Index = Vector3Index(len(vertexes), point.x, point.y, z) vector3Loop.append(vector3Index) vertexes.append(vector3Index) return triangle_mesh.getMeldedPillarOutput(loops)
def addSkinnedPerimeter(self):
'Add skinned perimeter.'
if self.perimeter == None:
return
perimeterThread = self.perimeter[:-1]
lowerZ = self.oldLocation.z - self.halfLayerThickness
innerPerimeter = intercircle.getLargestInsetLoopFromLoop(
perimeterThread, self.quarterPerimeterWidth)
outerPerimeter = intercircle.getLargestInsetLoopFromLoop(
perimeterThread, -self.quarterPerimeterWidth)
innerPerimeter = self.getClippedSimplifiedLoopPathByLoop(
innerPerimeter)
outerPerimeter = self.getClippedSimplifiedLoopPathByLoop(
outerPerimeter)
if len(innerPerimeter) < 4 or len(
outerPerimeter
) < 4 or not self.repository.halfWidthPerimeter.value:
self.addFlowRateLine(0.5 * self.oldFlowRate)
self.addPerimeterLoop(self.perimeter, lowerZ)
self.addPerimeterLoop(self.perimeter, self.oldLocation.z)
else:
self.addFlowRateLine(0.25 * self.oldFlowRate)
self.addPerimeterLoop(innerPerimeter, lowerZ)
self.addPerimeterLoop(outerPerimeter, lowerZ)
self.addPerimeterLoop(innerPerimeter, self.oldLocation.z)
self.addPerimeterLoop(outerPerimeter, self.oldLocation.z)
self.addFlowRateLine(self.oldFlowRate)
self.perimeter = None
def getManipulatedGeometryOutput(elementNode, geometryOutput, prefix): 'Get inset geometryOutput.' derivation = InsetDerivation(elementNode, prefix) if derivation.radius == 0.0: return geometryOutput copyShallow = elementNode.getCopyShallow() solid.processElementNodeByGeometry(copyShallow, geometryOutput) targetMatrix = matrix.getBranchMatrixSetElementNode(elementNode) matrix.setElementNodeDictionaryMatrix(copyShallow, targetMatrix) transformedVertexes = copyShallow.xmlObject.getTransformedVertexes() minimumZ = boolean_geometry.getMinimumZ(copyShallow.xmlObject) maximumZ = euclidean.getTopPath(transformedVertexes) layerThickness = setting.getLayerThickness(elementNode) importRadius = setting.getImportRadius(elementNode) zoneArrangement = triangle_mesh.ZoneArrangement(layerThickness, transformedVertexes) copyShallow.attributes['visible'] = True copyShallowObjects = [copyShallow.xmlObject] bottomLoopLayer = euclidean.LoopLayer(minimumZ) z = minimumZ + 0.1 * layerThickness bottomLoopLayer.loops = boolean_geometry.getEmptyZLoops(copyShallowObjects, importRadius, False, z, zoneArrangement) loopLayers = [bottomLoopLayer] z = minimumZ + layerThickness loopLayers += boolean_geometry.getLoopLayers(copyShallowObjects, importRadius, layerThickness, maximumZ, False, z, zoneArrangement) copyShallow.parentNode.xmlObject.archivableObjects.remove(copyShallow.xmlObject) belowLoop = [] diagonalRadius = math.sqrt(0.5) * derivation.radius insetDiagonalLoops = [] loops = [] vertexes = [] for loopLayer in loopLayers: insetDiagonalLoops.append(intercircle.getLargestInsetLoopFromLoop(loopLayer.loops[0], diagonalRadius)) for loopLayerIndex, loopLayer in enumerate(loopLayers): vector3Loop = [] insetLoop = intercircle.getLargestInsetLoopFromLoop(loopLayer.loops[0], derivation.radius) loopLists = [[getLoopOrEmpty(loopLayerIndex - 1, insetDiagonalLoops)], [insetLoop]] largestLoop = euclidean.getLargestLoop(boolean_solid.getLoopsIntersection(importRadius, loopLists)) if evaluate.getEvaluatedBoolean(True, elementNode, prefix + 'insetTop'): loopLists = [[getLoopOrEmpty(loopLayerIndex + 1, insetDiagonalLoops)], [largestLoop]] largestLoop = euclidean.getLargestLoop(boolean_solid.getLoopsIntersection(importRadius, loopLists)) for point in largestLoop: vector3Index = Vector3Index(len(vertexes), point.real, point.imag, loopLayer.z) vector3Loop.append(vector3Index) vertexes.append(vector3Index) if len(vector3Loop) > 0: loops.append(vector3Loop) if evaluate.getEvaluatedBoolean(False, elementNode, prefix + 'addExtraTopLayer') and len(loops) > 0: topLoop = loops[-1] vector3Loop = [] loops.append(vector3Loop) z = topLoop[0].z + layerThickness for point in topLoop: vector3Index = Vector3Index(len(vertexes), point.x, point.y, z) vector3Loop.append(vector3Index) vertexes.append(vector3Index) geometryOutput = triangle_mesh.getMeldedPillarOutput(loops) return geometryOutput
def addSkinnedPerimeter(self): 'Add skinned perimeter.' if self.perimeter is None: return bottomZ = self.oldLocation.z + self.layerThickness / self.verticalDivisionsFloat - self.layerThickness perimeterThread = self.perimeter[: -1] perimeters = [] radiusAddition = self.perimeterWidth / self.horizontalPerimeterDivisionsFloat radius = 0.5 * radiusAddition - self.halfPerimeterWidth for division in xrange(self.repository.horizontalPerimeterDivisions.value): perimeters.append(self.getClippedSimplifiedLoopPathByLoop(intercircle.getLargestInsetLoopFromLoop(perimeterThread, radius))) radius += radiusAddition skinnedPerimeterFlowRate = self.oldFlowRate / self.verticalDivisionsFloat if getIsMinimumSides(perimeters): self.addFlowRateLine(skinnedPerimeterFlowRate / self.horizontalPerimeterDivisionsFloat) for verticalDivisionIndex in xrange(self.verticalDivisions): z = bottomZ + self.layerThickness / self.verticalDivisionsFloat * float(verticalDivisionIndex) for perimeter in perimeters: self.addPerimeterLoop(perimeter, z) else: self.addFlowRateLine(skinnedPerimeterFlowRate) for verticalDivisionIndex in xrange(self.verticalDivisions): z = bottomZ + self.layerThickness / self.verticalDivisionsFloat * float(verticalDivisionIndex) self.addPerimeterLoop(self.perimeter, z) self.addFlowRateLine(self.oldFlowRate) self.perimeter = None
def addSkinnedPerimeter(self): 'Add skinned edge.' if self.edge == None: return bottomZ = self.oldLocation.z + self.layerHeight / self.verticalDivisionsFloat - self.layerHeight edgeThread = self.edge[: -1] edges = [] radiusAddition = self.edgeWidth / self.horizontalPerimeterDivisionsFloat radius = 0.5 * radiusAddition - self.halfEdgeWidth for division in xrange(self.repository.horizontalPerimeterDivisions.value): edges.append(self.getClippedSimplifiedLoopPathByLoop(intercircle.getLargestInsetLoopFromLoop(edgeThread, radius))) radius += radiusAddition skinnedPerimeterFlowRate = None if self.oldFlowRate != None: skinnedPerimeterFlowRate = self.oldFlowRate / self.verticalDivisionsFloat if getIsMinimumSides(edges): if self.oldFlowRate != None: self.addFlowRateLine(skinnedPerimeterFlowRate / self.horizontalPerimeterDivisionsFloat) for verticalDivisionIndex in xrange(self.verticalDivisions): z = bottomZ + self.layerHeight / self.verticalDivisionsFloat * float(verticalDivisionIndex) for edge in edges: self.addPerimeterLoop(edge, z) else: self.addFlowRateLine(skinnedPerimeterFlowRate) for verticalDivisionIndex in xrange(self.verticalDivisions): z = bottomZ + self.layerHeight / self.verticalDivisionsFloat * float(verticalDivisionIndex) self.addPerimeterLoop(self.edge, z) self.addFlowRateLine(self.oldFlowRate) self.edge = None
def addWiden(self, rotatedLoopLayer):
"Add widen to the layer."
trianglemesh.sortLoopsInOrderOfArea(False, rotatedLoopLayer.loops)
widdershinsLoops = []
clockwiseInsetLoops = []
for loopIndex in xrange(len(rotatedLoopLayer.loops)):
loop = rotatedLoopLayer.loops[loopIndex]
if euclidean.isWiddershins(loop):
otherLoops = rotatedLoopLayer.loops[:
loopIndex] + rotatedLoopLayer.loops[
loopIndex + 1:]
leftPoint = euclidean.getLeftPoint(loop)
if getIsPointInsideALoop(otherLoops, leftPoint):
self.distanceFeedRate.addGcodeFromLoop(
loop, rotatedLoopLayer.z)
else:
widdershinsLoops.append(loop)
else:
# clockwiseInsetLoop = intercircle.getLargestInsetLoopFromLoop(loop, self.doublePerimeterWidth)
# clockwiseInsetLoop.reverse()
# clockwiseInsetLoops.append(clockwiseInsetLoop)
clockwiseInsetLoops += intercircle.getInsetLoopsFromLoop(
loop, self.doublePerimeterWidth)
self.distanceFeedRate.addGcodeFromLoop(loop,
rotatedLoopLayer.z)
for widdershinsLoop in widdershinsLoops:
outsetLoop = intercircle.getLargestInsetLoopFromLoop(
widdershinsLoop, -self.doublePerimeterWidth)
widenedLoop = getWidenedLoop(widdershinsLoop, clockwiseInsetLoops,
outsetLoop, self.perimeterWidth)
self.distanceFeedRate.addGcodeFromLoop(widenedLoop,
rotatedLoopLayer.z)
def addWiden(self, rotatedBoundaryLayer):
"Add widen to the layer."
loops = triangle_mesh.getLoopsInOrderOfArea(
triangle_mesh.compareAreaAscending, rotatedBoundaryLayer.loops)
widdershinsLoops = []
clockwiseInsetLoops = []
for loopIndex in xrange(len(loops)):
loop = loops[loopIndex]
if euclidean.isWiddershins(loop):
otherLoops = loops[:loopIndex] + loops[loopIndex + 1:]
leftPoint = euclidean.getLeftPoint(loop)
if euclidean.isPointInsideLoops(otherLoops, leftPoint):
self.distanceFeedRate.addGcodeFromLoop(
loop, rotatedBoundaryLayer.z)
else:
widdershinsLoops.append(loop)
else:
clockwiseInsetLoops += intercircle.getInsetLoopsFromLoop(
self.doublePerimeterWidth, loop)
self.distanceFeedRate.addGcodeFromLoop(loop,
rotatedBoundaryLayer.z)
for widdershinsLoop in widdershinsLoops:
outsetLoop = intercircle.getLargestInsetLoopFromLoop(
widdershinsLoop, -self.doublePerimeterWidth)
widenedLoop = getWidenedLoop(widdershinsLoop, clockwiseInsetLoops,
outsetLoop, self.perimeterWidth,
self.tinyRadius)
self.distanceFeedRate.addGcodeFromLoop(widenedLoop,
rotatedBoundaryLayer.z)
def addSkinnedPerimeter(self):
"Add skinned edge."
if self.edge == None:
return
bottomZ = self.oldLocation.z + self.layerHeight / self.verticalDivisionsFloat - self.layerHeight
edgeThread = self.edge[:-1]
edges = []
radiusAddition = self.edgeWidth / self.horizontalPerimeterDivisionsFloat
radius = 0.5 * radiusAddition - self.halfEdgeWidth
for division in xrange(self.repository.horizontalPerimeterDivisions.value):
edges.append(
self.getClippedSimplifiedLoopPathByLoop(intercircle.getLargestInsetLoopFromLoop(edgeThread, radius))
)
radius += radiusAddition
skinnedPerimeterFlowRate = None
if self.oldFlowRate != None:
skinnedPerimeterFlowRate = self.oldFlowRate / self.verticalDivisionsFloat
if getIsMinimumSides(edges):
if self.oldFlowRate != None:
self.addFlowRateLine(skinnedPerimeterFlowRate / self.horizontalPerimeterDivisionsFloat)
for verticalDivisionIndex in xrange(self.verticalDivisions):
z = bottomZ + self.layerHeight / self.verticalDivisionsFloat * float(verticalDivisionIndex)
for edge in edges:
self.addPerimeterLoop(edge, z)
else:
self.addFlowRateLine(skinnedPerimeterFlowRate)
for verticalDivisionIndex in xrange(self.verticalDivisions):
z = bottomZ + self.layerHeight / self.verticalDivisionsFloat * float(verticalDivisionIndex)
self.addPerimeterLoop(self.edge, z)
self.addFlowRateLine(self.oldFlowRate)
self.edge = None
def addLeadinnedPerimeter(self): 'Add leadinned perimeter.' if self.perimeter == None: return self.perimeter = self.perimeter[: -1] innerPerimeter = intercircle.getLargestInsetLoopFromLoop(self.perimeter, self.quarterPerimeterWidth) innerPerimeter = self.getClippedSimplifiedLoopPathByLoop(innerPerimeter) outerPerimeter = intercircle.getLargestInsetLoopFromLoop(self.perimeter, -self.quarterPerimeterWidth*0.7853)# outerPerimeter = intercircle.getLargestInsetLoopFromLoop(self.perimeter, -self.quarterPerimeterWidth) outerPerimeter = self.getClippedSimplifiedLoopPathByLoop(outerPerimeter) lowerZ = self.oldLocation.z - self.halfLayerThickness self.addFlowRateLine(0.5 * self.oldFlowRate) #self.addPerimeterLoop(innerPerimeter, lowerZ) #self.addPerimeterLoop(outerPerimeter, lowerZ) self.addPerimeterLoop(innerPerimeter, self.oldLocation.z) self.addPerimeterLoop(outerPerimeter, self.oldLocation.z) self.addFlowRateLine(self.oldFlowRate)
def addSkinnedPerimeter(self): 'Add skinned perimeter.' if self.perimeter == None: return bottomZ = self.oldLocation.z + self.layerThickness / self.verticalDivisionsFloat - self.layerThickness perimeterThread = self.perimeter[: -1] perimeters = [] radiusAddition = self.perimeterWidth / self.horizontalPerimeterDivisionsFloat radius = 0.5 * radiusAddition - self.halfPerimeterWidth for division in xrange(self.repository.horizontalPerimeterDivisions.value): perimeters.append(self.getClippedSimplifiedLoopPathByLoop(intercircle.getLargestInsetLoopFromLoop(perimeterThread, radius))) radius += radiusAddition skinnedPerimeterFlowRate = self.oldFlowRate / self.verticalDivisionsFloat if getIsMinimumSides(perimeters): self.addFlowRateLine(skinnedPerimeterFlowRate / self.horizontalPerimeterDivisionsFloat) for verticalDivisionIndex in xrange(self.verticalDivisions): z = bottomZ + self.layerThickness / self.verticalDivisionsFloat * float(verticalDivisionIndex) for perimeter in perimeters: self.addPerimeterLoop(perimeter, z) else: self.addFlowRateLine(skinnedPerimeterFlowRate) for verticalDivisionIndex in xrange(self.verticalDivisions): z = bottomZ + self.layerThickness / self.verticalDivisionsFloat * float(verticalDivisionIndex) self.addPerimeterLoop(self.perimeter, z) self.addFlowRateLine(self.oldFlowRate) self.perimeter = None
def addWiden(self, loopLayer):
'Add widen to the layer.'
triangle_mesh.sortLoopsInOrderOfArea(False, loopLayer.loops)
widdershinsLoops = []
clockwiseInsetLoops = []
for loopIndex in xrange(len(loopLayer.loops)):
loop = loopLayer.loops[loopIndex]
if euclidean.isWiddershins(loop):
otherLoops = loopLayer.loops[:loopIndex] + loopLayer.loops[
loopIndex + 1:]
leftPoint = euclidean.getLeftPoint(loop)
if getIsPointInsideALoop(otherLoops, leftPoint):
self.distanceFeedRate.addGcodeFromLoop(loop, loopLayer.z)
else:
widdershinsLoops.append(loop)
else:
# clockwiseInsetLoop = intercircle.getLargestInsetLoopFromLoop(loop, self.widenEdgeWidth)
# clockwiseInsetLoop.reverse()
# clockwiseInsetLoops.append(clockwiseInsetLoop)
clockwiseInsetLoops += intercircle.getInsetLoopsFromLoop(
loop, self.widenEdgeWidth)
self.distanceFeedRate.addGcodeFromLoop(loop, loopLayer.z)
for widdershinsLoop in widdershinsLoops:
outsetLoop = intercircle.getLargestInsetLoopFromLoop(
widdershinsLoop, -self.widenEdgeWidth)
for widenedLoop in getWidenedLoops(widdershinsLoop,
clockwiseInsetLoops, outsetLoop,
self.lessThanHalfEdgeWidth):
self.distanceFeedRate.addGcodeFromLoop(widenedLoop,
loopLayer.z)
def addSkinnedPerimeter(self): """Add skinned perimeter.""" if self.perimeter is None: return self.perimeter = self.perimeter[: -1] innerPerimeter = intercircle.getLargestInsetLoopFromLoop(self.perimeter, self.quarterPerimeterWidth) innerPerimeter = self.getClippedSimplifiedLoopPathByLoop(innerPerimeter) outerPerimeter = intercircle.getLargestInsetLoopFromLoop(self.perimeter, -self.quarterPerimeterWidth) outerPerimeter = self.getClippedSimplifiedLoopPathByLoop(outerPerimeter) lowerZ = self.oldLocation.z - self.quarterLayerThickness higherZ = self.oldLocation.z + self.quarterLayerThickness self.addFlowRateLine(0.25 * self.oldFlowRate) self.addPerimeterLoop(innerPerimeter, lowerZ) self.addPerimeterLoop(outerPerimeter, lowerZ) self.addPerimeterLoop(innerPerimeter, higherZ) self.addPerimeterLoop(outerPerimeter, higherZ) self.addFlowRateLine(self.oldFlowRate)
def addSkinnedPerimeter(self): 'Add skinned perimeter.' if self.perimeter == None: return perimeterThread = self.perimeter[: -1] lowerZ = self.oldLocation.z - self.halfLayerThickness innerPerimeter = intercircle.getLargestInsetLoopFromLoop(perimeterThread, self.quarterPerimeterWidth) outerPerimeter = intercircle.getLargestInsetLoopFromLoop(perimeterThread, -self.quarterPerimeterWidth) innerPerimeter = self.getClippedSimplifiedLoopPathByLoop(innerPerimeter) outerPerimeter = self.getClippedSimplifiedLoopPathByLoop(outerPerimeter) if len(innerPerimeter) < 4 or len(outerPerimeter) < 4 or not self.repository.halfWidthPerimeter.value: self.addFlowRateLine(0.5 * self.oldFlowRate) self.addPerimeterLoop(self.perimeter, lowerZ) self.addPerimeterLoop(self.perimeter, self.oldLocation.z) else: self.addFlowRateLine(0.25 * self.oldFlowRate) self.addPerimeterLoop(innerPerimeter, lowerZ) self.addPerimeterLoop(outerPerimeter, lowerZ) self.addPerimeterLoop(innerPerimeter, self.oldLocation.z) self.addPerimeterLoop(outerPerimeter, self.oldLocation.z) self.addFlowRateLine(self.oldFlowRate) self.perimeter = None
def addCoilLayer(self, boundaryLayers, radius, z):
"Add a coil layer."
self.distanceFeedRate.addLine("(<layer> %s )" % z) # Indicate that a new layer is starting.
self.distanceFeedRate.addLine("(<nestedRing>)")
thread = []
for boundaryLayerIndex in xrange(1, len(boundaryLayers) - 1):
boundaryLayer = boundaryLayers[boundaryLayerIndex]
boundaryLayerBegin = boundaryLayers[boundaryLayerIndex - 1]
boundaryLayerEnd = boundaryLayers[boundaryLayerIndex + 1]
beginLocation = Vector3(0.0, 0.0, 0.5 * (boundaryLayerBegin.z + boundaryLayer.z))
outsetLoop = intercircle.getLargestInsetLoopFromLoop(boundaryLayer.loops[0], -radius)
self.addCoilToThread(beginLocation, 0.5 * (boundaryLayer.z + boundaryLayerEnd.z), outsetLoop, thread)
self.addGcodeFromThread(thread)
self.distanceFeedRate.addLine("(</nestedRing>)")
self.distanceFeedRate.addLine("(</layer>)")
def addCoilLayer( self, boundaryLayers, radius, z ):
"Add a coil layer."
self.distanceFeedRate.addLine('(<layer> %s )' % z ) # Indicate that a new layer is starting.
self.distanceFeedRate.addLine('(<nestedRing>)')
thread = []
for boundaryLayerIndex in xrange(1, len(boundaryLayers) - 1):
boundaryLayer = boundaryLayers[boundaryLayerIndex]
boundaryLayerBegin = boundaryLayers[boundaryLayerIndex - 1]
boundaryLayerEnd = boundaryLayers[boundaryLayerIndex + 1]
beginLocation = Vector3(0.0, 0.0, 0.5 * (boundaryLayerBegin.z + boundaryLayer.z))
outsetLoop = intercircle.getLargestInsetLoopFromLoop(boundaryLayer.loops[0], - radius)
self.addCoilToThread(beginLocation, 0.5 * (boundaryLayer.z + boundaryLayerEnd.z), outsetLoop, thread)
self.addGcodeFromThread(thread)
self.distanceFeedRate.addLine('(</nestedRing>)')
self.distanceFeedRate.addLine('(</layer>)')
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
def addWiden( self, rotatedBoundaryLayer ): "Add widen to the layer." loops = triangle_mesh.getLoopsInOrderOfArea( triangle_mesh.compareAreaAscending, rotatedBoundaryLayer.loops ) widdershinsLoops = [] clockwiseInsetLoops = [] for loopIndex in xrange( len( loops ) ): loop = loops[ loopIndex ] if euclidean.isWiddershins( loop ): otherLoops = loops[ : loopIndex ] + loops[ loopIndex + 1 : ] leftPoint = euclidean.getLeftPoint( loop ) if euclidean.isPointInsideLoops( otherLoops, leftPoint ): self.distanceFeedRate.addGcodeFromLoop( loop, rotatedBoundaryLayer.z ) else: widdershinsLoops.append( loop ) else: clockwiseInsetLoops += intercircle.getInsetLoopsFromLoop( self.doublePerimeterWidth, loop ) self.distanceFeedRate.addGcodeFromLoop( loop, rotatedBoundaryLayer.z ) for widdershinsLoop in widdershinsLoops: outsetLoop = intercircle.getLargestInsetLoopFromLoop( widdershinsLoop, - self.doublePerimeterWidth ) widenedLoop = getWidenedLoop( widdershinsLoop, clockwiseInsetLoops, outsetLoop, self.perimeterWidth, self.tinyRadius ) self.distanceFeedRate.addGcodeFromLoop( widenedLoop, rotatedBoundaryLayer.z )
def addWiden(self, rotatedLoopLayer): 'Add widen to the layer.' triangle_mesh.sortLoopsInOrderOfArea(False, rotatedLoopLayer.loops) widdershinsLoops = [] clockwiseInsetLoops = [] for loopIndex in xrange(len(rotatedLoopLayer.loops)): loop = rotatedLoopLayer.loops[loopIndex] if euclidean.isWiddershins(loop): otherLoops = rotatedLoopLayer.loops[: loopIndex] + rotatedLoopLayer.loops[loopIndex + 1 :] leftPoint = euclidean.getLeftPoint(loop) if getIsPointInsideALoop(otherLoops, leftPoint): self.distanceFeedRate.addGcodeFromLoop(loop, rotatedLoopLayer.z) else: widdershinsLoops.append(loop) else: # clockwiseInsetLoop = intercircle.getLargestInsetLoopFromLoop(loop, self.doublePerimeterWidth) # clockwiseInsetLoop.reverse() # clockwiseInsetLoops.append(clockwiseInsetLoop) clockwiseInsetLoops += intercircle.getInsetLoopsFromLoop(loop, self.doublePerimeterWidth) self.distanceFeedRate.addGcodeFromLoop(loop, rotatedLoopLayer.z) for widdershinsLoop in widdershinsLoops: outsetLoop = intercircle.getLargestInsetLoopFromLoop(widdershinsLoop, -self.doublePerimeterWidth) widenedLoop = getWidenedLoop(widdershinsLoop, clockwiseInsetLoops, outsetLoop, self.perimeterWidth) self.distanceFeedRate.addGcodeFromLoop(widenedLoop, rotatedLoopLayer.z)
def getManipulatedGeometryOutput(elementNode, geometryOutput, prefix):
'Get inset geometryOutput.'
derivation = InsetDerivation(elementNode, prefix)
if derivation.radius == 0.0:
return geometryOutput
copyShallow = elementNode.getCopyShallow()
solid.processElementNodeByGeometry(copyShallow, geometryOutput)
targetMatrix = matrix.getBranchMatrixSetElementNode(elementNode)
matrix.setElementNodeDictionaryMatrix(copyShallow, targetMatrix)
transformedVertexes = copyShallow.xmlObject.getTransformedVertexes()
minimumZ = boolean_geometry.getMinimumZ(copyShallow.xmlObject)
maximumZ = euclidean.getTopPath(transformedVertexes)
layerThickness = setting.getLayerThickness(elementNode)
importRadius = setting.getImportRadius(elementNode)
zoneArrangement = triangle_mesh.ZoneArrangement(layerThickness,
transformedVertexes)
copyShallow.attributes['visible'] = True
copyShallowObjects = [copyShallow.xmlObject]
bottomLoopLayer = euclidean.LoopLayer(minimumZ)
z = minimumZ + 0.1 * layerThickness
bottomLoopLayer.loops = boolean_geometry.getEmptyZLoops(
copyShallowObjects, importRadius, False, z, zoneArrangement)
loopLayers = [bottomLoopLayer]
z = minimumZ + layerThickness
loopLayers += boolean_geometry.getLoopLayers(copyShallowObjects,
importRadius, layerThickness,
maximumZ, False, z,
zoneArrangement)
copyShallow.parentNode.xmlObject.archivableObjects.remove(
copyShallow.xmlObject)
belowLoop = []
diagonalRadius = math.sqrt(0.5) * derivation.radius
insetDiagonalLoops = []
loops = []
vertexes = []
for loopLayer in loopLayers:
insetDiagonalLoops.append(
intercircle.getLargestInsetLoopFromLoop(loopLayer.loops[0],
diagonalRadius))
for loopLayerIndex, loopLayer in enumerate(loopLayers):
vector3Loop = []
insetLoop = intercircle.getLargestInsetLoopFromLoop(
loopLayer.loops[0], derivation.radius)
loopLists = [[getLoopOrEmpty(loopLayerIndex - 1, insetDiagonalLoops)],
[insetLoop]]
largestLoop = euclidean.getLargestLoop(
boolean_solid.getLoopsIntersection(importRadius, loopLists))
if evaluate.getEvaluatedBoolean(True, elementNode,
prefix + 'insetTop'):
loopLists = [[
getLoopOrEmpty(loopLayerIndex + 1, insetDiagonalLoops)
], [largestLoop]]
largestLoop = euclidean.getLargestLoop(
boolean_solid.getLoopsIntersection(importRadius, loopLists))
for point in largestLoop:
vector3Index = Vector3Index(len(vertexes), point.real, point.imag,
loopLayer.z)
vector3Loop.append(vector3Index)
vertexes.append(vector3Index)
if len(vector3Loop) > 0:
loops.append(vector3Loop)
if evaluate.getEvaluatedBoolean(False, elementNode, prefix +
'addExtraTopLayer') and len(loops) > 0:
topLoop = loops[-1]
vector3Loop = []
loops.append(vector3Loop)
z = topLoop[0].z + layerThickness
for point in topLoop:
vector3Index = Vector3Index(len(vertexes), point.x, point.y, z)
vector3Loop.append(vector3Index)
vertexes.append(vector3Index)
geometryOutput = triangle_mesh.getMeldedPillarOutput(loops)
return geometryOutput
