def execute(self, obj):
PathLog.track()
if not obj.Base:
PathLog.error(translate("Path_DressupTag",
"No Base object found."))
return
if not obj.Base.isDerivedFrom("Path::Feature"):
PathLog.error(
translate("Path_DressupTag",
"Base is not a Path::Feature object."))
return
if not obj.Base.Path:
PathLog.error(
translate("Path_DressupTag",
"Base doesn't have a Path to dress-up."))
return
if not obj.Base.Path.Commands:
PathLog.error(translate("Path_DressupTag", "Base Path is empty."))
return
self.obj = obj
minZ = +MaxInt
minX = minZ
minY = minZ
maxZ = -MaxInt
maxX = maxZ
maxY = maxZ
# the assumption is that all helixes are in the xy-plane - in other words there is no
# intermittent point of a command that has a lower/higher Z-position than the start and
# and end positions of a command.
lastPt = FreeCAD.Vector(0, 0, 0)
for cmd in obj.Base.Path.Commands:
pt = PathGeom.commandEndPoint(cmd, lastPt)
if lastPt.x != pt.x:
maxX = max(pt.x, maxX)
minX = min(pt.x, minX)
if lastPt.y != pt.y:
maxY = max(pt.y, maxY)
minY = min(pt.y, minY)
if lastPt.z != pt.z:
maxZ = max(pt.z, maxZ)
minZ = min(pt.z, minZ)
lastPt = pt
PathLog.debug("bb = (%.2f, %.2f, %.2f) ... (%.2f, %.2f, %.2f)" %
(minX, minY, minZ, maxX, maxY, maxZ))
self.ptMin = FreeCAD.Vector(minX, minY, minZ)
self.ptMax = FreeCAD.Vector(maxX, maxY, maxZ)
self.masterSolid = TagSolid(self, minZ, self.toolRadius())
self.solids = [
self.masterSolid.cloneAt(pos) for pos in self.obj.Positions
]
self.tagSolid = Part.Compound(self.solids)
self.wire, rapid = PathGeom.wireForPath(obj.Base.Path) # pylint: disable=unused-variable
self.edges = self.wire.Edges
maxTagZ = minZ + obj.Height.Value
# lastX = 0
# lastY = 0
lastZ = 0
commands = []
for cmd in obj.Base.Path.Commands:
if cmd in PathGeom.CmdMove:
if lastZ <= maxTagZ or cmd.Parameters.get("Z",
lastZ) <= maxTagZ:
pass
else:
commands.append(cmd)
else:
commands.append(cmd)
obj.Path = obj.Base.Path
PathLog.track()
def execute(self, obj):
if not obj.Base or not obj.Base.isDerivedFrom('Path::Feature') or not obj.Base.Path:
return
tc = PathDressup.toolController(obj.Base)
if len(obj.Base.Path.Commands) > 0:
self.safeHeight = float(PathUtil.opProperty(obj.Base, 'SafeHeight'))
self.clearanceHeight = float(PathUtil.opProperty(obj.Base, 'ClearanceHeight'))
boundary = obj.Stock.Shape
cmd = obj.Base.Path.Commands[0]
pos = cmd.Placement.Base
commands = [cmd]
lastExit = None
for cmd in obj.Base.Path.Commands[1:]:
if cmd.Name in PathGeom.CmdMoveAll:
edge = PathGeom.edgeForCmd(cmd, pos)
inside = edge.common(boundary).Edges
outside = edge.cut(boundary).Edges
if not obj.Inside:
t = inside
inside = outside
outside = t
# it's really a shame that one cannot trust the sequence and/or
# orientation of edges
if 1 == len(inside) and 0 == len(outside):
PathLog.track(_vstr(pos), _vstr(lastExit), ' + ', cmd)
# cmd fully included by boundary
if lastExit:
commands.extend(self.boundaryCommands(obj, lastExit, pos, tc.VertFeed.Value))
lastExit = None
commands.append(cmd)
pos = PathGeom.commandEndPoint(cmd, pos)
elif 0 == len(inside) and 1 == len(outside):
PathLog.track(_vstr(pos), _vstr(lastExit), ' - ', cmd)
# cmd fully excluded by boundary
if not lastExit:
lastExit = pos
pos = PathGeom.commandEndPoint(cmd, pos)
else:
PathLog.track(_vstr(pos), _vstr(lastExit), len(inside), len(outside), cmd)
# cmd pierces boundary
while inside or outside:
ie = [e for e in inside if PathGeom.edgeConnectsTo(e, pos)]
PathLog.track(ie)
if ie:
e = ie[0]
ptL = e.valueAt(e.LastParameter)
flip = PathGeom.pointsCoincide(pos, ptL)
newPos = e.valueAt(e.FirstParameter) if flip else ptL
# inside edges are taken at this point (see swap of inside/outside
# above - so we can just connect the dots ...
if lastExit:
commands.extend(self.boundaryCommands(obj, lastExit, pos, tc.VertFeed.Value))
lastExit = None
PathLog.track(e, flip)
commands.extend(PathGeom.cmdsForEdge(e, flip, False))
inside.remove(e)
pos = newPos
lastExit = newPos
else:
oe = [e for e in outside if PathGeom.edgeConnectsTo(e, pos)]
PathLog.track(oe)
if oe:
e = oe[0]
ptL = e.valueAt(e.LastParameter)
flip = PathGeom.pointsCoincide(pos, ptL)
newPos = e.valueAt(e.FirstParameter) if flip else ptL
# outside edges are never taken at this point (see swap of
# inside/oustide above) - so just move along ...
outside.remove(e)
pos = newPos
else:
PathLog.error('huh?')
import Part
Part.show(Part.Vertex(pos), 'pos')
for e in inside:
Part.show(e, 'ei')
for e in outside:
Part.show(e, 'eo')
raise Exception('This is not supposed to happen')
#pos = PathGeom.commandEndPoint(cmd, pos)
else:
PathLog.track('no-move', cmd)
commands.append(cmd)
if lastExit:
commands.extend(self.boundaryCommands(obj, lastExit, None, tc.VertFeed.Value))
lastExit = None
else:
PathLog.warning("No Path Commands for %s" % obj.Base.Label)
commands = []
PathLog.track(commands)
obj.Path = Path.Path(commands)
def execute(self):
if (
not self.baseOp
or not self.baseOp.isDerivedFrom("Path::Feature")
or not self.baseOp.Path
):
return None
if len(self.baseOp.Path.Commands) == 0:
PathLog.warning("No Path Commands for %s" % self.baseOp.Label)
return []
tc = PathDressup.toolController(self.baseOp)
self.safeHeight = float(PathUtil.opProperty(self.baseOp, "SafeHeight"))
self.clearanceHeight = float(
PathUtil.opProperty(self.baseOp, "ClearanceHeight")
)
self.strG0ZsafeHeight = Path.Command( # was a Feed rate with G1
"G0", {"Z": self.safeHeight, "F": tc.VertRapid.Value}
)
self.strG0ZclearanceHeight = Path.Command("G0", {"Z": self.clearanceHeight})
cmd = self.baseOp.Path.Commands[0]
pos = cmd.Placement.Base # bogus m/c position to create first edge
bogusX = True
bogusY = True
commands = [cmd]
lastExit = None
for cmd in self.baseOp.Path.Commands[1:]:
if cmd.Name in PathGeom.CmdMoveAll:
if bogusX:
bogusX = "X" not in cmd.Parameters
if bogusY:
bogusY = "Y" not in cmd.Parameters
edge = PathGeom.edgeForCmd(cmd, pos)
if edge:
inside = edge.common(self.boundary).Edges
outside = edge.cut(self.boundary).Edges
if not self.inside: # UI "inside boundary" param
tmp = inside
inside = outside
outside = tmp
# it's really a shame that one cannot trust the sequence and/or
# orientation of edges
if 1 == len(inside) and 0 == len(outside):
PathLog.track(_vstr(pos), _vstr(lastExit), " + ", cmd)
# cmd fully included by boundary
if lastExit:
if not (
bogusX or bogusY
): # don't insert false paths based on bogus m/c position
commands.extend(
self.boundaryCommands(
lastExit, pos, tc.VertFeed.Value
)
)
lastExit = None
commands.append(cmd)
pos = PathGeom.commandEndPoint(cmd, pos)
elif 0 == len(inside) and 1 == len(outside):
PathLog.track(_vstr(pos), _vstr(lastExit), " - ", cmd)
# cmd fully excluded by boundary
if not lastExit:
lastExit = pos
pos = PathGeom.commandEndPoint(cmd, pos)
else:
PathLog.track(
_vstr(pos), _vstr(lastExit), len(inside), len(outside), cmd
)
# cmd pierces boundary
while inside or outside:
ie = [e for e in inside if PathGeom.edgeConnectsTo(e, pos)]
PathLog.track(ie)
if ie:
e = ie[0]
LastPt = e.valueAt(e.LastParameter)
flip = PathGeom.pointsCoincide(pos, LastPt)
newPos = e.valueAt(e.FirstParameter) if flip else LastPt
# inside edges are taken at this point (see swap of inside/outside
# above - so we can just connect the dots ...
if lastExit:
if not (bogusX or bogusY):
commands.extend(
self.boundaryCommands(
lastExit, pos, tc.VertFeed.Value
)
)
lastExit = None
PathLog.track(e, flip)
if not (
bogusX or bogusY
): # don't insert false paths based on bogus m/c position
commands.extend(
PathGeom.cmdsForEdge(
e,
flip,
False,
50,
tc.HorizFeed.Value,
tc.VertFeed.Value,
)
)
inside.remove(e)
pos = newPos
lastExit = newPos
else:
oe = [
e
for e in outside
if PathGeom.edgeConnectsTo(e, pos)
]
PathLog.track(oe)
if oe:
e = oe[0]
ptL = e.valueAt(e.LastParameter)
flip = PathGeom.pointsCoincide(pos, ptL)
newPos = (
e.valueAt(e.FirstParameter) if flip else ptL
)
# outside edges are never taken at this point (see swap of
# inside/outside above) - so just move along ...
outside.remove(e)
pos = newPos
else:
PathLog.error("huh?")
import Part
Part.show(Part.Vertex(pos), "pos")
for e in inside:
Part.show(e, "ei")
for e in outside:
Part.show(e, "eo")
raise Exception("This is not supposed to happen")
# Eif
# Eif
# Ewhile
# Eif
# pos = PathGeom.commandEndPoint(cmd, pos)
# Eif
else:
PathLog.track("no-move", cmd)
commands.append(cmd)
if lastExit:
commands.extend(self.boundaryCommands(lastExit, None, tc.VertFeed.Value))
lastExit = None
PathLog.track(commands)
return Path.Path(commands)
def execute(self, obj):
PathLog.track()
if not obj.Base:
PathLog.error(translate('Path_DressupTag', 'No Base object found.'))
return
if not obj.Base.isDerivedFrom('Path::Feature'):
PathLog.error(translate('Path_DressupTag', 'Base is not a Path::Feature object.'))
return
if not obj.Base.Path:
PathLog.error(translate('Path_DressupTag', 'Base doesn\'t have a Path to dress-up.'))
return
if not obj.Base.Path.Commands:
PathLog.error(translate('Path_DressupTag', 'Base Path is empty.'))
return
self.obj = obj
minZ = +sys.maxint
minX = minZ
minY = minZ
maxZ = -sys.maxint
maxX = maxZ
maxY = maxZ
# the assumption is that all helixes are in the xy-plane - in other words there is no
# intermittent point of a command that has a lower/higher Z-position than the start and
# and end positions of a command.
lastPt = FreeCAD.Vector(0, 0, 0)
for cmd in obj.Base.Path.Commands:
pt = PathGeom.commandEndPoint(cmd, lastPt)
if lastPt.x != pt.x:
maxX = max(pt.x, maxX)
minX = min(pt.x, minX)
if lastPt.y != pt.y:
maxY = max(pt.y, maxY)
minY = min(pt.y, minY)
if lastPt.z != pt.z:
maxZ = max(pt.z, maxZ)
minZ = min(pt.z, minZ)
lastPt = pt
PathLog.debug("bb = (%.2f, %.2f, %.2f) ... (%.2f, %.2f, %.2f)" % (minX, minY, minZ, maxX, maxY, maxZ))
self.ptMin = FreeCAD.Vector(minX, minY, minZ)
self.ptMax = FreeCAD.Vector(maxX, maxY, maxZ)
self.masterSolid = TagSolid(self, minZ, self.toolRadius())
self.solids = [self.masterSolid.cloneAt(pos) for pos in self.obj.Positions]
self.tagSolid = Part.Compound(self.solids)
self.wire, rapid = PathGeom.wireForPath(obj.Base.Path)
self.edges = self.wire.Edges
maxTagZ = minZ + obj.Height.Value
# lastX = 0
# lastY = 0
lastZ = 0
commands = []
for cmd in obj.Base.Path.Commands:
if cmd in PathGeom.CmdMove:
if lastZ <= maxTagZ or cmd.Parameters.get('Z', lastZ) <= maxTagZ:
pass
else:
commands.append(cmd)
else:
commands.append(cmd)
obj.Path = obj.Base.Path
PathLog.track()
