def generateHelix(self):
edges = self.wire.Edges
minZ = self.findMinZ(edges)
outedges = []
i = 0
while i < len(edges):
edge = edges[i]
israpid = False
for redge in self.rapids:
if PathGeom.edgesMatch(edge, redge):
israpid = True
if not israpid:
bb = edge.BoundBox
p0 = edge.Vertexes[0].Point
p1 = edge.Vertexes[1].Point
if bb.XLength < 1e-6 and bb.YLength < 1e-6 and bb.ZLength > 0 and p0.z > p1.z:
# plungelen = abs(p0.z-p1.z)
PathLog.debug(
"Found plunge move at X:{} Y:{} From Z:{} to Z{}, Searching for closed loop"
.format(p0.x, p0.y, p0.z, p1.z))
# next need to determine how many edges in the path after plunge are needed to cover the length:
loopFound = False
rampedges = []
j = i + 1
while not loopFound:
candidate = edges[j]
cp0 = candidate.Vertexes[0].Point
cp1 = candidate.Vertexes[1].Point
if PathGeom.pointsCoincide(p1, cp1):
# found closed loop
loopFound = True
rampedges.append(candidate)
break
if abs(cp0.z - cp1.z) > 1e-6:
# this edge is not parallel to XY plane, not qualified for ramping.
break
# PathLog.debug("Next edge length {}".format(candidate.Length))
rampedges.append(candidate)
j = j + 1
if j >= len(edges):
break
if len(rampedges) == 0 or not loopFound:
PathLog.debug("No suitable helix found")
outedges.append(edge)
else:
outedges.extend(self.createHelix(rampedges, p0, p1))
if not PathGeom.isRoughly(p1.z, minZ):
# the edges covered by the helix not handled again,
# unless reached the bottom height
i = j
else:
outedges.append(edge)
else:
outedges.append(edge)
i = i + 1
return outedges
def generateHelix(self):
edges = self.wire.Edges
minZ = self.findMinZ(edges)
outedges = []
i = 0
while i < len(edges):
edge = edges[i]
israpid = False
for redge in self.rapids:
if PathGeom.edgesMatch(edge, redge):
israpid = True
if not israpid:
bb = edge.BoundBox
p0 = edge.Vertexes[0].Point
p1 = edge.Vertexes[1].Point
if bb.XLength < 1e-6 and bb.YLength < 1e-6 and bb.ZLength > 0 and p0.z > p1.z:
# plungelen = abs(p0.z-p1.z)
PathLog.debug("Found plunge move at X:{} Y:{} From Z:{} to Z{}, Searching for closed loop".format(p0.x, p0.y, p0.z, p1.z))
# next need to determine how many edges in the path after plunge are needed to cover the length:
loopFound = False
rampedges = []
j = i + 1
while not loopFound:
candidate = edges[j]
cp0 = candidate.Vertexes[0].Point
cp1 = candidate.Vertexes[1].Point
if PathGeom.pointsCoincide(p1, cp1):
# found closed loop
loopFound = True
rampedges.append(candidate)
break
if abs(cp0.z - cp1.z) > 1e-6:
# this edge is not parallel to XY plane, not qualified for ramping.
break
# PathLog.debug("Next edge length {}".format(candidate.Length))
rampedges.append(candidate)
j = j + 1
if j >= len(edges):
break
if len(rampedges) == 0 or not loopFound:
PathLog.debug("No suitable helix found")
outedges.append(edge)
else:
outedges.extend(self.createHelix(rampedges, p0, p1))
if not PathGeom.isRoughly(p1.z, minZ):
# the edges covered by the helix not handled again,
# unless reached the bottom height
i = j
else:
outedges.append(edge)
else:
outedges.append(edge)
i = i + 1
return outedges
def createCommands(self, obj, edges):
commands = []
for edge in edges:
israpid = False
for redge in self.rapids:
if PathGeom.edgesMatch(edge, redge):
israpid = True
if israpid:
v = edge.valueAt(edge.LastParameter)
commands.append(
Path.Command('G0', {
'X': v.x,
'Y': v.y,
'Z': v.z
}))
else:
commands.extend(PathGeom.cmdsForEdge(edge))
lastCmd = Path.Command('G0', {'X': 0.0, 'Y': 0.0, 'Z': 0.0})
outCommands = []
horizFeed = obj.ToolController.HorizFeed.Value
vertFeed = obj.ToolController.VertFeed.Value
horizRapid = obj.ToolController.HorizRapid.Value
vertRapid = obj.ToolController.VertRapid.Value
for cmd in commands:
params = cmd.Parameters
zVal = params.get('Z', None)
zVal2 = lastCmd.Parameters.get('Z', None)
zVal = zVal and round(zVal, 8)
zVal2 = zVal2 and round(zVal2, 8)
if cmd.Name in ['G1', 'G2', 'G3', 'G01', 'G02', 'G03']:
if zVal is not None and zVal2 != zVal:
params['F'] = vertFeed
else:
params['F'] = horizFeed
lastCmd = cmd
elif cmd.Name in ['G0', 'G00']:
if zVal is not None and zVal2 != zVal:
params['F'] = vertRapid
else:
params['F'] = horizRapid
lastCmd = cmd
outCommands.append(Path.Command(cmd.Name, params))
return Path.Path(outCommands)
def horizontalFaceLoop(obj, face, faceList=None):
'''horizontalFaceLoop(obj, face, faceList=None) ... returns a list of face names which form the walls of a vertical hole face is a part of.
All face names listed in faceList must be part of the hole for the solution to be returned.'''
wires = [horizontalEdgeLoop(obj, e) for e in face.Edges]
# Not sure if sorting by Area is a premature optimization - but it seems
# the loop we're looking for is typically the biggest of the them all.
wires = sorted([w for w in wires if w], key=lambda w: Part.Face(w).Area)
for wire in wires:
hashes = [e.hashCode() for e in wire.Edges]
#find all faces that share a an edge with the wire and are vertical
faces = [
"Face%d" % (i + 1) for i, f in enumerate(obj.Shape.Faces)
if any(e.hashCode() in hashes
for e in f.Edges) and PathGeom.isVertical(f)
]
if faceList and not all(f in faces for f in faceList):
continue
# verify they form a valid hole by getting the outline and comparing
# the resulting XY footprint with that of the faces
comp = Part.makeCompound([obj.Shape.getElement(f) for f in faces])
outline = TechDraw.findShapeOutline(comp, 1, FreeCAD.Vector(0, 0, 1))
# findShapeOutline always returns closed wires, by removing the
# trace-backs single edge spikes don't contriubte to the bound box
uniqueEdges = []
for edge in outline.Edges:
if any(PathGeom.edgesMatch(edge, e) for e in uniqueEdges):
continue
uniqueEdges.append(edge)
w = Part.Wire(uniqueEdges)
# if the faces really form the walls of a hole then the resulting
# wire is still closed and it still has the same footprint
bb1 = comp.BoundBox
bb2 = w.BoundBox
if w.isClosed() and PathGeom.isRoughly(
bb1.XMin, bb2.XMin) and PathGeom.isRoughly(
bb1.XMax, bb2.XMax) and PathGeom.isRoughly(
bb1.YMin, bb2.YMin) and PathGeom.isRoughly(
bb1.YMax, bb2.YMax):
return faces
return None
def createCommands(self, obj, edges):
commands = []
for edge in edges:
israpid = False
for redge in self.rapids:
if PathGeom.edgesMatch(edge, redge):
israpid = True
if israpid:
v = edge.valueAt(edge.LastParameter)
commands.append(Path.Command('G0', {'X': v.x, 'Y': v.y, 'Z': v.z}))
else:
commands.extend(PathGeom.cmdsForEdge(edge))
lastCmd = Path.Command('G0', {'X': 0.0, 'Y': 0.0, 'Z': 0.0})
outCommands = []
horizFeed = obj.ToolController.HorizFeed.Value
vertFeed = obj.ToolController.VertFeed.Value
horizRapid = obj.ToolController.HorizRapid.Value
vertRapid = obj.ToolController.VertRapid.Value
for cmd in commands:
params = cmd.Parameters
zVal = params.get('Z', None)
zVal2 = lastCmd.Parameters.get('Z', None)
zVal = zVal and round(zVal, 8)
zVal2 = zVal2 and round(zVal2, 8)
if cmd.Name in ['G1', 'G2', 'G3', 'G01', 'G02', 'G03']:
if zVal is not None and zVal2 != zVal:
params['F'] = vertFeed
else:
params['F'] = horizFeed
lastCmd = cmd
elif cmd.Name in ['G0', 'G00']:
if zVal is not None and zVal2 != zVal:
params['F'] = vertRapid
else:
params['F'] = horizRapid
lastCmd = cmd
outCommands.append(Path.Command(cmd.Name, params))
return Path.Path(outCommands)
def horizontalFaceLoop(obj, face, faceList=None):
'''horizontalFaceLoop(obj, face, faceList=None) ... returns a list of face names which form the walls of a vertical hole face is a part of.
All face names listed in faceList must be part of the hole for the solution to be returned.'''
wires = [horizontalEdgeLoop(obj, e) for e in face.Edges]
# Not sure if sorting by Area is a premature optimization - but it seems
# the loop we're looking for is typically the biggest of the them all.
wires = sorted([w for w in wires if w], key=lambda w: Part.Face(w).Area)
for wire in wires:
hashes = [e.hashCode() for e in wire.Edges]
#find all faces that share a an edge with the wire and are vertical
faces = ["Face%d"%(i+1) for i,f in enumerate(obj.Shape.Faces) if any(e.hashCode() in hashes for e in f.Edges) and PathGeom.isVertical(f)]
if faceList and not all(f in faces for f in faceList):
continue
# verify they form a valid hole by getting the outline and comparing
# the resulting XY footprint with that of the faces
comp = Part.makeCompound([obj.Shape.getElement(f) for f in faces])
outline = TechDraw.findShapeOutline(comp, 1, FreeCAD.Vector(0,0,1))
# findShapeOutline always returns closed wires, by removing the
# trace-backs single edge spikes don't contriubte to the bound box
uniqueEdges = []
for edge in outline.Edges:
if any(PathGeom.edgesMatch(edge, e) for e in uniqueEdges):
continue
uniqueEdges.append(edge)
w = Part.Wire(uniqueEdges)
# if the faces really form the walls of a hole then the resulting
# wire is still closed and it still has the same footprint
bb1 = comp.BoundBox
bb2 = w.BoundBox
if w.isClosed() and PathGeom.isRoughly(bb1.XMin, bb2.XMin) and PathGeom.isRoughly(bb1.XMax, bb2.XMax) and PathGeom.isRoughly(bb1.YMin, bb2.YMin) and PathGeom.isRoughly(bb1.YMax, bb2.YMax):
return faces
return None
def test50(self):
"""Verify proper wire(s) aggregation from a Path."""
commands = []
commands.append(Path.Command('G1', {'X': 1}))
commands.append(Path.Command('G1', {'Y': 1}))
commands.append(Path.Command('G0', {'X': 0}))
commands.append(Path.Command('G1', {'Y': 0}))
wire,rapid = PathGeom.wireForPath(Path.Path(commands))
self.assertEqual(len(wire.Edges), 4)
self.assertLine(wire.Edges[0], Vector(0,0,0), Vector(1,0,0))
self.assertLine(wire.Edges[1], Vector(1,0,0), Vector(1,1,0))
self.assertLine(wire.Edges[2], Vector(1,1,0), Vector(0,1,0))
self.assertLine(wire.Edges[3], Vector(0,1,0), Vector(0,0,0))
self.assertEqual(len(rapid), 1)
self.assertTrue(PathGeom.edgesMatch(rapid[0], wire.Edges[2]))
wires = PathGeom.wiresForPath(Path.Path(commands))
self.assertEqual(len(wires), 2)
self.assertEqual(len(wires[0].Edges), 2)
self.assertLine(wires[0].Edges[0], Vector(0,0,0), Vector(1,0,0))
self.assertLine(wires[0].Edges[1], Vector(1,0,0), Vector(1,1,0))
self.assertEqual(len(wires[1].Edges), 1)
self.assertLine(wires[1].Edges[0], Vector(0,1,0), Vector(0,0,0))
def test50(self):
"""Verify proper wire(s) aggregation from a Path."""
commands = []
commands.append(Path.Command('G1', {'X': 1}))
commands.append(Path.Command('G1', {'Y': 1}))
commands.append(Path.Command('G0', {'X': 0}))
commands.append(Path.Command('G1', {'Y': 0}))
wire, rapid = PathGeom.wireForPath(Path.Path(commands))
self.assertEqual(len(wire.Edges), 4)
self.assertLine(wire.Edges[0], Vector(0, 0, 0), Vector(1, 0, 0))
self.assertLine(wire.Edges[1], Vector(1, 0, 0), Vector(1, 1, 0))
self.assertLine(wire.Edges[2], Vector(1, 1, 0), Vector(0, 1, 0))
self.assertLine(wire.Edges[3], Vector(0, 1, 0), Vector(0, 0, 0))
self.assertEqual(len(rapid), 1)
self.assertTrue(PathGeom.edgesMatch(rapid[0], wire.Edges[2]))
wires = PathGeom.wiresForPath(Path.Path(commands))
self.assertEqual(len(wires), 2)
self.assertEqual(len(wires[0].Edges), 2)
self.assertLine(wires[0].Edges[0], Vector(0, 0, 0), Vector(1, 0, 0))
self.assertLine(wires[0].Edges[1], Vector(1, 0, 0), Vector(1, 1, 0))
self.assertEqual(len(wires[1].Edges), 1)
self.assertLine(wires[1].Edges[0], Vector(0, 1, 0), Vector(0, 0, 0))
def generateRamps(self, allowBounce=True):
edges = self.wire.Edges
outedges = []
for edge in edges:
israpid = False
for redge in self.rapids:
if PathGeom.edgesMatch(edge, redge):
israpid = True
if not israpid:
bb = edge.BoundBox
p0 = edge.Vertexes[0].Point
p1 = edge.Vertexes[1].Point
rampangle = self.angle
if bb.XLength < 1e-6 and bb.YLength < 1e-6 and bb.ZLength > 0 and p0.z > p1.z:
plungelen = abs(p0.z - p1.z)
projectionlen = plungelen * math.tan(math.radians(rampangle)) # length of the forthcoming ramp projected to XY plane
if self.method == 'RampMethod3':
projectionlen = projectionlen / 2
PathLog.debug("Found plunge move at X:{} Y:{} From Z:{} to Z{}, length of ramp: {}".format(p0.x, p0.y, p0.z, p1.z, projectionlen))
# next need to determine how many edges in the path after
# plunge are needed to cover the length:
covered = False
coveredlen = 0
rampedges = []
i = edges.index(edge) + 1
while not covered:
candidate = edges[i]
cp0 = candidate.Vertexes[0].Point
cp1 = candidate.Vertexes[1].Point
if abs(cp0.z - cp1.z) > 1e-6:
# this edge is not parallel to XY plane, not qualified for ramping.
break
# PathLog.debug("Next edge length {}".format(candidate.Length))
rampedges.append(candidate)
coveredlen = coveredlen + candidate.Length
if coveredlen > projectionlen:
covered = True
i = i + 1
if i >= len(edges):
break
if len(rampedges) == 0:
PathLog.debug("No suitable edges for ramping, plunge will remain as such")
outedges.append(edge)
else:
if not covered:
if (not allowBounce) or self.method == 'RampMethod2':
l = 0
for redge in rampedges:
l = l + redge.Length
if self.method == 'RampMethod3':
rampangle = math.degrees(math.atan(l / (plungelen / 2)))
else:
rampangle = math.degrees(math.atan(l / plungelen))
PathLog.warning("Cannot cover with desired angle, tightening angle to: {}".format(rampangle))
# PathLog.debug("Doing ramp to edges: {}".format(rampedges))
if self.method == 'RampMethod1':
outedges.extend(self.createRampMethod1(rampedges, p0, projectionlen, rampangle))
elif self.method == 'RampMethod2':
outedges.extend(self.createRampMethod2(rampedges, p0, projectionlen, rampangle))
else:
# if the ramp cannot be covered with Method3, revert to Method1
# because Method1 support going back-and-forth and thus results in same path as Method3 when
# length of the ramp is smaller than needed for single ramp.
if (not covered) and allowBounce:
projectionlen = projectionlen * 2
outedges.extend(self.createRampMethod1(rampedges, p0, projectionlen, rampangle))
else:
outedges.extend(self.createRampMethod3(rampedges, p0, projectionlen, rampangle))
else:
outedges.append(edge)
else:
outedges.append(edge)
return outedges
def createCommands(self, obj, edges):
commands = []
for edge in edges:
israpid = False
for redge in self.rapids:
if PathGeom.edgesMatch(edge, redge):
israpid = True
if israpid:
v = edge.valueAt(edge.LastParameter)
commands.append(
Path.Command('G0', {
'X': v.x,
'Y': v.y,
'Z': v.z
}))
else:
commands.extend(PathGeom.cmdsForEdge(edge))
lastCmd = Path.Command('G0', {'X': 0.0, 'Y': 0.0, 'Z': 0.0})
outCommands = []
tc = PathDressup.toolController(obj.Base)
horizFeed = tc.HorizFeed.Value
vertFeed = tc.VertFeed.Value
if obj.RampFeedRate == "Horizontal Feed Rate":
rampFeed = tc.HorizFeed.Value
elif obj.RampFeedRate == "Vertical Feed Rate":
rampFeed = tc.VertFeed.Value
else:
rampFeed = obj.CustomFeedRate.Value
horizRapid = tc.HorizRapid.Value
vertRapid = tc.VertRapid.Value
for cmd in commands:
params = cmd.Parameters
zVal = params.get('Z', None)
zVal2 = lastCmd.Parameters.get('Z', None)
xVal = params.get('X', None)
xVal2 = lastCmd.Parameters.get('X', None)
yVal2 = lastCmd.Parameters.get('Y', None)
yVal = params.get('Y', None)
zVal = zVal and round(zVal, 8)
zVal2 = zVal2 and round(zVal2, 8)
if cmd.Name in ['G1', 'G2', 'G3', 'G01', 'G02', 'G03']:
if zVal is not None and zVal2 != zVal:
if PathGeom.isRoughly(xVal, xVal2) and PathGeom.isRoughly(
yVal, yVal2):
# this is a straight plunge
params['F'] = vertFeed
else:
# this is a ramp
params['F'] = rampFeed
else:
params['F'] = horizFeed
lastCmd = cmd
elif cmd.Name in ['G0', 'G00']:
if zVal is not None and zVal2 != zVal:
params['F'] = vertRapid
else:
params['F'] = horizRapid
lastCmd = cmd
outCommands.append(Path.Command(cmd.Name, params))
return Path.Path(outCommands)
def generateRamps(self, allowBounce=True):
edges = self.wire.Edges
outedges = []
for edge in edges:
israpid = False
for redge in self.rapids:
if PathGeom.edgesMatch(edge, redge):
israpid = True
if not israpid:
bb = edge.BoundBox
p0 = edge.Vertexes[0].Point
p1 = edge.Vertexes[1].Point
rampangle = self.angle
if bb.XLength < 1e-6 and bb.YLength < 1e-6 and bb.ZLength > 0 and p0.z > p1.z:
plungelen = abs(p0.z - p1.z)
projectionlen = plungelen * math.tan(math.radians(rampangle)) # length of the forthcoming ramp projected to XY plane
if self.method == 'RampMethod3':
projectionlen = projectionlen / 2
PathLog.debug("Found plunge move at X:{} Y:{} From Z:{} to Z{}, length of ramp: {}".format(p0.x, p0.y, p0.z, p1.z, projectionlen))
# next need to determine how many edges in the path after
# plunge are needed to cover the length:
covered = False
coveredlen = 0
rampedges = []
i = edges.index(edge) + 1
while not covered:
candidate = edges[i]
cp0 = candidate.Vertexes[0].Point
cp1 = candidate.Vertexes[1].Point
if abs(cp0.z - cp1.z) > 1e-6:
# this edge is not parallel to XY plane, not qualified for ramping.
break
# PathLog.debug("Next edge length {}".format(candidate.Length))
rampedges.append(candidate)
coveredlen = coveredlen + candidate.Length
if coveredlen > projectionlen:
covered = True
i = i + 1
if i >= len(edges):
break
if len(rampedges) == 0:
PathLog.debug("No suitable edges for ramping, plunge will remain as such")
outedges.append(edge)
else:
if not covered:
if (not allowBounce) or self.method == 'RampMethod2':
l = 0
for redge in rampedges:
l = l + redge.Length
if self.method == 'RampMethod3':
rampangle = math.degrees(math.atan(l / (plungelen / 2)))
else:
rampangle = math.degrees(math.atan(l / plungelen))
PathLog.warning("Cannot cover with desired angle, tightening angle to: {}".format(rampangle))
# PathLog.debug("Doing ramp to edges: {}".format(rampedges))
if self.method == 'RampMethod1':
outedges.extend(self.createRampMethod1(rampedges, p0, projectionlen, rampangle))
elif self.method == 'RampMethod2':
outedges.extend(self.createRampMethod2(rampedges, p0, projectionlen, rampangle))
else:
# if the ramp cannot be covered with Method3, revert to Method1
# because Method1 support going back-and-forth and thus results in same path as Method3 when
# length of the ramp is smaller than needed for single ramp.
if (not covered) and allowBounce:
projectionlen = projectionlen * 2
outedges.extend(self.createRampMethod1(rampedges, p0, projectionlen, rampangle))
else:
outedges.extend(self.createRampMethod3(rampedges, p0, projectionlen, rampangle))
else:
outedges.append(edge)
else:
outedges.append(edge)
return outedges
def createCommands(self, obj, edges):
commands = []
for edge in edges:
israpid = False
for redge in self.rapids:
if PathGeom.edgesMatch(edge, redge):
israpid = True
if israpid:
v = edge.valueAt(edge.LastParameter)
commands.append(Path.Command('G0', {'X': v.x, 'Y': v.y, 'Z': v.z}))
else:
commands.extend(PathGeom.cmdsForEdge(edge))
lastCmd = Path.Command('G0', {'X': 0.0, 'Y': 0.0, 'Z': 0.0})
outCommands = []
tc = PathDressup.toolController(obj.Base)
horizFeed = tc.HorizFeed.Value
vertFeed = tc.VertFeed.Value
if obj.RampFeedRate == "Horizontal Feed Rate":
rampFeed = tc.HorizFeed.Value
elif obj.RampFeedRate == "Vertical Feed Rate":
rampFeed = tc.VertFeed.Value
else:
rampFeed = obj.CustomFeedRate.Value
horizRapid = tc.HorizRapid.Value
vertRapid = tc.VertRapid.Value
for cmd in commands:
params = cmd.Parameters
zVal = params.get('Z', None)
zVal2 = lastCmd.Parameters.get('Z', None)
xVal = params.get('X', None)
xVal2 = lastCmd.Parameters.get('X', None)
yVal2 = lastCmd.Parameters.get('Y', None)
yVal = params.get('Y', None)
zVal = zVal and round(zVal, 8)
zVal2 = zVal2 and round(zVal2, 8)
if cmd.Name in ['G1', 'G2', 'G3', 'G01', 'G02', 'G03']:
if zVal is not None and zVal2 != zVal:
if PathGeom.isRoughly(xVal, xVal2) and PathGeom.isRoughly(yVal, yVal2):
# this is a straight plunge
params['F'] = vertFeed
else:
# this is a ramp
params['F'] = rampFeed
else:
params['F'] = horizFeed
lastCmd = cmd
elif cmd.Name in ['G0', 'G00']:
if zVal is not None and zVal2 != zVal:
params['F'] = vertRapid
else:
params['F'] = horizRapid
lastCmd = cmd
outCommands.append(Path.Command(cmd.Name, params))
return Path.Path(outCommands)