804 lines
29 KiB
Python
804 lines
29 KiB
Python
# -*- coding: utf-8 -*-
|
|
# ***************************************************************************
|
|
# * Copyright (c) 2017 LTS <SammelLothar@gmx.de> under LGPL *
|
|
# * Copyright (c) 2020-2021 Schildkroet *
|
|
# * *
|
|
# * This program is free software; you can redistribute it and/or modify *
|
|
# * it under the terms of the GNU Lesser General Public License (LGPL) *
|
|
# * as published by the Free Software Foundation; either version 2 of *
|
|
# * the License, or (at your option) any later version. *
|
|
# * for detail see the LICENCE text file. *
|
|
# * *
|
|
# * This program is distributed in the hope that it will be useful, *
|
|
# * but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
# * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
# * GNU Library General Public License for more details. *
|
|
# * *
|
|
# * You should have received a copy of the GNU Library General Public *
|
|
# * License along with this program; if not, write to the Free Software *
|
|
# * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
|
|
# * USA *
|
|
# * *
|
|
# ***************************************************************************
|
|
|
|
from __future__ import print_function
|
|
|
|
import FreeCAD
|
|
import FreeCADGui
|
|
import Path
|
|
import PathScripts.PathDressup as PathDressup
|
|
import PathScripts.PathGeom as PathGeom
|
|
import PathScripts.PathLog as PathLog
|
|
import PathScripts.PathUtils as PathUtils
|
|
import math
|
|
import copy
|
|
|
|
__doc__ = """LeadInOut Dressup MASHIN-CRC USE ROLL-ON ROLL-OFF to profile"""
|
|
|
|
from PySide.QtCore import QT_TRANSLATE_NOOP
|
|
|
|
from PathPythonGui.simple_edit_panel import SimpleEditPanel
|
|
|
|
translate = FreeCAD.Qt.translate
|
|
|
|
if False:
|
|
PathLog.setLevel(PathLog.Level.DEBUG, PathLog.thisModule())
|
|
PathLog.trackModule(PathLog.thisModule())
|
|
else:
|
|
PathLog.setLevel(PathLog.Level.INFO, PathLog.thisModule())
|
|
|
|
|
|
movecommands = ["G1", "G01", "G2", "G02", "G3", "G03"]
|
|
rapidcommands = ["G0", "G00"]
|
|
arccommands = ["G2", "G3", "G02", "G03"]
|
|
currLocation = {}
|
|
|
|
|
|
class ObjectDressup:
|
|
def __init__(self, obj):
|
|
lead_styles = [
|
|
QT_TRANSLATE_NOOP("Path_DressupLeadInOut", "Arc"),
|
|
QT_TRANSLATE_NOOP("Path_DressupLeadInOut", "Tangent"),
|
|
QT_TRANSLATE_NOOP("Path_DressupLeadInOut", "Perpendicular"),
|
|
]
|
|
self.obj = obj
|
|
obj.addProperty(
|
|
"App::PropertyLink",
|
|
"Base",
|
|
"Path",
|
|
QT_TRANSLATE_NOOP("App::Property", "The base path to modify"),
|
|
)
|
|
obj.addProperty(
|
|
"App::PropertyBool",
|
|
"LeadIn",
|
|
"Path",
|
|
QT_TRANSLATE_NOOP("App::Property", "Calculate roll-on to path"),
|
|
)
|
|
obj.addProperty(
|
|
"App::PropertyBool",
|
|
"LeadOut",
|
|
"Path",
|
|
QT_TRANSLATE_NOOP("App::Property", "Calculate roll-off from path"),
|
|
)
|
|
obj.addProperty(
|
|
"App::PropertyBool",
|
|
"KeepToolDown",
|
|
"Path",
|
|
QT_TRANSLATE_NOOP("App::Property", "Keep the Tool Down in Path"),
|
|
)
|
|
obj.addProperty(
|
|
"App::PropertyBool",
|
|
"UseMachineCRC",
|
|
"Path",
|
|
QT_TRANSLATE_NOOP(
|
|
"App::Property",
|
|
"Use Machine Cutter Radius Compensation /Tool Path Offset G41/G42",
|
|
),
|
|
)
|
|
obj.addProperty(
|
|
"App::PropertyDistance",
|
|
"Length",
|
|
"Path",
|
|
QT_TRANSLATE_NOOP("App::Property", "Length or Radius of the approach"),
|
|
)
|
|
obj.addProperty(
|
|
"App::PropertyEnumeration",
|
|
"StyleOn",
|
|
"Path",
|
|
QT_TRANSLATE_NOOP("App::Property", "The Style of motion into the Path"),
|
|
)
|
|
obj.StyleOn = lead_styles
|
|
obj.addProperty(
|
|
"App::PropertyEnumeration",
|
|
"StyleOff",
|
|
"Path",
|
|
QT_TRANSLATE_NOOP("App::Property", "The Style of motion out of the Path"),
|
|
)
|
|
obj.StyleOff = lead_styles
|
|
obj.addProperty(
|
|
"App::PropertyEnumeration",
|
|
"RadiusCenter",
|
|
"Path",
|
|
QT_TRANSLATE_NOOP(
|
|
"App::Property", "The Mode of Point Radiusoffset or Center"
|
|
),
|
|
)
|
|
obj.RadiusCenter = [
|
|
QT_TRANSLATE_NOOP("Path_DressupLeadInOut", "Radius"),
|
|
QT_TRANSLATE_NOOP("Path_DressupLeadInOut", "Center"),
|
|
]
|
|
obj.Proxy = self
|
|
obj.addProperty(
|
|
"App::PropertyDistance",
|
|
"ExtendLeadIn",
|
|
"Path",
|
|
QT_TRANSLATE_NOOP("App::Property", "Extends LeadIn distance"),
|
|
)
|
|
obj.addProperty(
|
|
"App::PropertyDistance",
|
|
"ExtendLeadOut",
|
|
"Path",
|
|
QT_TRANSLATE_NOOP("App::Property", "Extends LeadOut distance"),
|
|
)
|
|
obj.addProperty(
|
|
"App::PropertyBool",
|
|
"RapidPlunge",
|
|
"Path",
|
|
QT_TRANSLATE_NOOP("App::Property", "Perform plunges with G0"),
|
|
)
|
|
obj.addProperty(
|
|
"App::PropertyBool",
|
|
"IncludeLayers",
|
|
"Path",
|
|
QT_TRANSLATE_NOOP(
|
|
"App::Property", "Apply LeadInOut to layers within an operation"
|
|
),
|
|
)
|
|
|
|
self.wire = None
|
|
self.rapids = None
|
|
|
|
def __getstate__(self):
|
|
return None
|
|
|
|
def __setstate__(self, state):
|
|
# pylint: disable=unused-argument
|
|
return None
|
|
|
|
def setup(self, obj):
|
|
obj.Length = obj.Base.ToolController.Tool.Diameter * 0.75
|
|
obj.LeadIn = True
|
|
obj.LeadOut = True
|
|
obj.KeepToolDown = False
|
|
obj.UseMachineCRC = False
|
|
obj.StyleOn = "Arc"
|
|
obj.StyleOff = "Arc"
|
|
obj.RadiusCenter = "Radius"
|
|
obj.ExtendLeadIn = 0
|
|
obj.ExtendLeadOut = 0
|
|
obj.RapidPlunge = False
|
|
obj.IncludeLayers = True
|
|
|
|
def execute(self, obj):
|
|
if not obj.Base:
|
|
return
|
|
if not obj.Base.isDerivedFrom("Path::Feature"):
|
|
return
|
|
if not obj.Base.Path:
|
|
return
|
|
if obj.Length < 0:
|
|
PathLog.error(
|
|
translate("Path_DressupLeadInOut", "Length/Radius positive not Null")
|
|
+ "\n"
|
|
)
|
|
obj.Length = 0.1
|
|
self.wire, self.rapids = PathGeom.wireForPath(obj.Base.Path)
|
|
obj.Path = self.generateLeadInOutCurve(obj)
|
|
|
|
def getDirectionOfPath(self, obj):
|
|
op = PathDressup.baseOp(obj.Base)
|
|
|
|
if hasattr(op, "Side") and op.Side == "Outside":
|
|
if hasattr(op, "Direction") and op.Direction == "CW":
|
|
return "left"
|
|
else:
|
|
return "right"
|
|
else:
|
|
if hasattr(op, "Direction") and op.Direction == "CW":
|
|
return "right"
|
|
return "left"
|
|
|
|
def getSideOfPath(self, obj):
|
|
op = PathDressup.baseOp(obj.Base)
|
|
if hasattr(op, "Side"):
|
|
return op.Side
|
|
|
|
return ""
|
|
|
|
def normalize(self, Vector):
|
|
vx = 0
|
|
vy = 0
|
|
|
|
x = Vector.x
|
|
y = Vector.y
|
|
length = math.sqrt(x * x + y * y)
|
|
if (math.fabs(length)) > 0.0000000000001:
|
|
vx = round(x / length, 3)
|
|
vy = round(y / length, 3)
|
|
|
|
return FreeCAD.Vector(vx, vy, 0)
|
|
|
|
def invert(self, Vector):
|
|
x = Vector.x * -1
|
|
y = Vector.y * -1
|
|
z = Vector.z * -1
|
|
return FreeCAD.Vector(x, y, z)
|
|
|
|
def multiply(self, Vector, len):
|
|
x = Vector.x * len
|
|
y = Vector.y * len
|
|
z = Vector.z * len
|
|
return FreeCAD.Vector(x, y, z)
|
|
|
|
def rotate(self, Vector, angle):
|
|
s = math.sin(math.radians(angle))
|
|
c = math.cos(math.radians(angle))
|
|
xnew = Vector.x * c - Vector.y * s
|
|
ynew = Vector.x * s + Vector.y * c
|
|
return FreeCAD.Vector(xnew, ynew, Vector.z)
|
|
|
|
def getLeadStart(self, obj, queue, action):
|
|
"""returns Lead In G-code."""
|
|
# Modified March 2022 by lcorley to support leadin extension
|
|
results = []
|
|
op = PathDressup.baseOp(obj.Base)
|
|
tc = PathDressup.toolController(obj.Base)
|
|
horizFeed = tc.HorizFeed.Value
|
|
vertFeed = tc.VertFeed.Value
|
|
toolnummer = tc.ToolNumber
|
|
arcs_identical = False
|
|
|
|
# Set the correct twist command
|
|
if self.getDirectionOfPath(obj) == "left":
|
|
arcdir = "G3"
|
|
else:
|
|
arcdir = "G2"
|
|
|
|
R = obj.Length.Value # Radius of roll or length
|
|
if queue[1].Name == "G1": # line
|
|
p0 = queue[0].Placement.Base
|
|
p1 = queue[1].Placement.Base
|
|
v = self.normalize(p1.sub(p0))
|
|
PathLog.debug(" CURRENT_IN Line : P0 Z:{} p1 Z:{}".format(p0.z, p1.z))
|
|
else:
|
|
p0 = queue[0].Placement.Base
|
|
p1 = queue[1].Placement.Base
|
|
v = self.normalize(p1.sub(p0))
|
|
PathLog.debug(
|
|
" CURRENT_IN ARC : P0 X:{} Y:{} P1 X:{} Y:{} ".format(
|
|
p0.x, p0.y, p1.x, p1.y
|
|
)
|
|
)
|
|
|
|
# Calculate offset vector (will be overwritten for arcs)
|
|
if self.getDirectionOfPath(obj) == "right":
|
|
off_v = FreeCAD.Vector(v.y * R, -v.x * R, 0.0)
|
|
else:
|
|
off_v = FreeCAD.Vector(-v.y * R, v.x * R, 0.0)
|
|
|
|
# Check if we enter at line or arc command
|
|
if queue[1].Name in movecommands and queue[1].Name not in arccommands:
|
|
# We have a line move
|
|
vec = p1.sub(p0)
|
|
vec_n = self.normalize(vec)
|
|
vec_inv = self.invert(vec_n)
|
|
vec_off = self.multiply(vec_inv, obj.ExtendLeadIn)
|
|
PathLog.debug(
|
|
"LineCMD: {}, Vxinv: {}, Vyinv: {}, Vxoff: {}, Vyoff: {}".format(
|
|
queue[0].Name, vec_inv.x, vec_inv.y, vec_off.x, vec_off.y
|
|
)
|
|
)
|
|
else:
|
|
# We have an arc move
|
|
# Calculate coordinates for middle of circle
|
|
pij = copy.deepcopy(p0)
|
|
pij.x += queue[1].Parameters["I"]
|
|
pij.y += queue[1].Parameters["J"]
|
|
|
|
# Check if lead in and operation go in same direction (usually for inner circles)
|
|
if arcdir == queue[1].Name:
|
|
arcs_identical = True
|
|
|
|
# Calculate vector circle start -> circle middle
|
|
vec_circ = pij.sub(p0)
|
|
|
|
# Rotate vector to get direction for lead in
|
|
if arcdir == "G2":
|
|
vec_rot = self.rotate(vec_circ, 90)
|
|
else:
|
|
vec_rot = self.rotate(vec_circ, -90)
|
|
|
|
# Normalize and invert vector
|
|
vec_n = self.normalize(vec_rot)
|
|
|
|
v = self.invert(vec_n)
|
|
|
|
# Calculate offset of lead in
|
|
if arcdir == "G3":
|
|
off_v = FreeCAD.Vector(-v.y * R, v.x * R, 0.0)
|
|
else:
|
|
off_v = FreeCAD.Vector(v.y * R, -v.x * R, 0.0)
|
|
|
|
# Multiply offset by LeadIn length
|
|
# vec_off = self.multiply(vec_n, obj.ExtendLeadIn)
|
|
|
|
# offsetvector = FreeCAD.Vector(v.x*R-vec_off.x, v.y*R-vec_off.y, 0) # IJ
|
|
offsetvector = FreeCAD.Vector(v.x * R, v.y * R, 0) # IJ
|
|
|
|
if obj.RadiusCenter == "Radius":
|
|
leadstart = (p0.add(off_v)).sub(offsetvector) # Rmode
|
|
if arcs_identical:
|
|
t = p0.sub(leadstart)
|
|
t = p0.add(t)
|
|
leadstart = t
|
|
offsetvector = self.multiply(offsetvector, -1)
|
|
else:
|
|
leadstart = p0.add(off_v) # Dmode
|
|
# At this point leadstart is the beginning of the leadin arc
|
|
# and offsetvector points from leadstart to the center of the leadin arc
|
|
# so the offsetvector is a radius of the leadin arc at its start
|
|
# The extend line should be tangent to the leadin arc at this point, or perpendicular to the radius
|
|
if arcdir == "G2":
|
|
tangentvec = self.rotate(offsetvector, -90)
|
|
else:
|
|
tangentvec = self.rotate(offsetvector, 90)
|
|
# print ("tangentvec = ", tangentvec)
|
|
# Normalize the tangent vector
|
|
tangentvecNorm = self.normalize(tangentvec)
|
|
# print ("tangentvecNorm = ", tangentvecNorm)
|
|
# Multiply tangentvecNorm by LeadIn length
|
|
leadlinevec = self.multiply(tangentvecNorm, obj.ExtendLeadIn)
|
|
# print ("leadlinevec = ", leadlinevec)
|
|
# leadlinevec provides the offset from the beginning of the lead arc to the beginning of the extend line
|
|
extendstart = leadstart.add(leadlinevec)
|
|
# print ("extendstart = ", extendstart)
|
|
|
|
if action == "start":
|
|
if obj.ExtendLeadIn != 0:
|
|
# Rapid move to beginning of extend line
|
|
extendcommand = Path.Command(
|
|
"G0",
|
|
{
|
|
"X": extendstart.x,
|
|
"Y": extendstart.y,
|
|
"Z": op.ClearanceHeight.Value,
|
|
},
|
|
)
|
|
else:
|
|
# Rapid move to beginning of leadin arc
|
|
extendcommand = Path.Command(
|
|
"G0",
|
|
{"X": leadstart.x, "Y": leadstart.y, "Z": op.ClearanceHeight.Value},
|
|
)
|
|
results.append(extendcommand)
|
|
extendcommand = Path.Command("G0", {"Z": op.SafeHeight.Value})
|
|
results.append(extendcommand)
|
|
|
|
if action == "layer":
|
|
if not obj.KeepToolDown:
|
|
extendcommand = Path.Command("G0", {"Z": op.SafeHeight.Value})
|
|
results.append(extendcommand)
|
|
|
|
extendcommand = Path.Command("G0", {"X": leadstart.x, "Y": leadstart.y})
|
|
results.append(extendcommand)
|
|
|
|
if not obj.RapidPlunge:
|
|
extendcommand = Path.Command(
|
|
"G1", {"X": leadstart.x, "Y": leadstart.y, "Z": p1.z, "F": vertFeed}
|
|
)
|
|
else:
|
|
extendcommand = Path.Command(
|
|
"G0",
|
|
{
|
|
"X": leadstart.x,
|
|
"Y": leadstart.y,
|
|
"Z": p1.z,
|
|
},
|
|
)
|
|
results.append(extendcommand)
|
|
|
|
if obj.UseMachineCRC:
|
|
if self.getDirectionOfPath(obj) == "right":
|
|
results.append(Path.Command("G42", {"D": toolnummer}))
|
|
else:
|
|
results.append(Path.Command("G41", {"D": toolnummer}))
|
|
|
|
if obj.StyleOn == "Arc":
|
|
if obj.ExtendLeadIn != 0:
|
|
# Insert move to beginning of leadin arc
|
|
extendcommand = Path.Command(
|
|
"G1", {"X": leadstart.x, "Y": leadstart.y, "F": horizFeed}
|
|
)
|
|
results.append(extendcommand)
|
|
arcmove = Path.Command(
|
|
arcdir,
|
|
{
|
|
"X": p0.x,
|
|
"Y": p0.y,
|
|
"I": offsetvector.x,
|
|
"J": offsetvector.y,
|
|
"F": horizFeed,
|
|
},
|
|
) # add G2/G3 move
|
|
results.append(arcmove)
|
|
elif obj.StyleOn == "Tangent":
|
|
extendcommand = Path.Command("G1", {"X": p0.x, "Y": p0.y, "F": horizFeed})
|
|
results.append(extendcommand)
|
|
else:
|
|
PathLog.debug(" CURRENT_IN Perp")
|
|
|
|
currLocation.update(results[-1].Parameters)
|
|
currLocation["Z"] = p1.z
|
|
|
|
return results
|
|
|
|
def getLeadEnd(self, obj, queue, action):
|
|
"""returns the Gcode of LeadOut."""
|
|
# Modified March 2022 by lcorley to support leadout extension
|
|
# pylint: disable=unused-argument
|
|
results = []
|
|
# print ("action =", action)
|
|
# print ("queue[0] =" ,queue[0])
|
|
# print ("queue[1] =" ,queue[1])
|
|
# print ("queue[2] =" ,queue[2])
|
|
horizFeed = PathDressup.toolController(obj.Base).HorizFeed.Value
|
|
R = obj.Length.Value # Radius of roll or length
|
|
arcs_identical = False
|
|
|
|
# Set the correct twist command
|
|
if self.getDirectionOfPath(obj) == "right":
|
|
arcdir = "G2"
|
|
else:
|
|
arcdir = "G3"
|
|
|
|
if queue[1].Name == "G1": # line
|
|
p0 = queue[0].Placement.Base
|
|
p1 = queue[1].Placement.Base
|
|
v = self.normalize(p1.sub(p0))
|
|
else: # dealing with a circle
|
|
p0 = queue[0].Placement.Base
|
|
p1 = queue[1].Placement.Base
|
|
v = self.normalize(p1.sub(p0))
|
|
|
|
if self.getDirectionOfPath(obj) == "right":
|
|
off_v = FreeCAD.Vector(v.y * R, -v.x * R, 0.0)
|
|
else:
|
|
off_v = FreeCAD.Vector(-v.y * R, v.x * R, 0.0)
|
|
|
|
# Check if we leave at line or arc command
|
|
if queue[1].Name in movecommands and queue[1].Name not in arccommands:
|
|
# We have a line move
|
|
vec = p1.sub(p0)
|
|
vec_n = self.normalize(vec)
|
|
vec_inv = self.invert(vec_n)
|
|
vec_off = self.multiply(vec_inv, obj.ExtendLeadOut)
|
|
# PathLog.debug("LineCMD: {}, Vxinv: {}, Vyinv: {}, Vxoff: {}, Vyoff: {}".format(queue[0].Name, vec_inv.x, vec_inv.y, vec_off.x, vec_off.y))
|
|
else:
|
|
# We have an arc move
|
|
pij = copy.deepcopy(p0)
|
|
pij.x += queue[1].Parameters["I"]
|
|
pij.y += queue[1].Parameters["J"]
|
|
ve = pij.sub(p1)
|
|
|
|
if arcdir == queue[1].Name:
|
|
arcs_identical = True
|
|
|
|
if arcdir == "G2":
|
|
vec_rot = self.rotate(ve, -90)
|
|
else:
|
|
vec_rot = self.rotate(ve, 90)
|
|
|
|
vec_n = self.normalize(vec_rot)
|
|
v = vec_n
|
|
|
|
if arcdir == "G3":
|
|
off_v = FreeCAD.Vector(-v.y * R, v.x * R, 0.0)
|
|
else:
|
|
off_v = FreeCAD.Vector(v.y * R, -v.x * R, 0.0)
|
|
|
|
vec_inv = self.invert(vec_rot)
|
|
|
|
# vec_off = self.multiply(vec_inv, obj.ExtendLeadOut)
|
|
|
|
# offsetvector = FreeCAD.Vector(v.x*R-vec_off.x, v.y*R-vec_off.y, 0.0)
|
|
offsetvector = FreeCAD.Vector(v.x * R, v.y * R, 0.0)
|
|
if obj.RadiusCenter == "Radius":
|
|
leadend = (p1.add(off_v)).add(offsetvector) # Rmode
|
|
if arcs_identical:
|
|
t = p1.sub(leadend)
|
|
t = p1.add(t)
|
|
leadend = t
|
|
off_v = self.multiply(off_v, -1)
|
|
else:
|
|
leadend = p1.add(off_v) # Dmode
|
|
|
|
IJ = off_v # .negative()
|
|
# print ("leadend = ", leadend)
|
|
# print ("IJ = ", IJ)
|
|
# At this point leadend is the location of the end of the leadout arc
|
|
# IJ is an offset from the begining of the leadout arc to its center.
|
|
# It is parallel to a tangent line at the end of the leadout arc
|
|
# Create the normalized tangent vector
|
|
tangentvecNorm = self.normalize(IJ)
|
|
# print ("tangentvecNorm = ", tangentvecNorm)
|
|
# Multiply tangentvecNorm by LeadOut length
|
|
leadlinevec = self.multiply(tangentvecNorm, obj.ExtendLeadOut)
|
|
# print ("leadlinevec = ", leadlinevec)
|
|
# leadlinevec provides the offset from the end of the leadout arc to the end of the extend line
|
|
extendleadoutend = leadend.add(leadlinevec)
|
|
# print ("extendleadoutend = ", extendleadoutend)
|
|
|
|
# results.append(queue[1])
|
|
if obj.StyleOff == "Arc":
|
|
arcmove = Path.Command(
|
|
arcdir,
|
|
{"X": leadend.x, "Y": leadend.y, "I": IJ.x, "J": IJ.y, "F": horizFeed},
|
|
) # add G2/G3 move
|
|
results.append(arcmove)
|
|
if obj.ExtendLeadOut != 0:
|
|
extendcommand = Path.Command(
|
|
"G1",
|
|
{"X": extendleadoutend.x, "Y": extendleadoutend.y, "F": horizFeed},
|
|
)
|
|
results.append(extendcommand)
|
|
elif obj.StyleOff == "Tangent":
|
|
extendcommand = Path.Command(
|
|
"G1", {"X": leadend.x, "Y": leadend.y, "F": horizFeed}
|
|
)
|
|
results.append(extendcommand)
|
|
else:
|
|
PathLog.debug(" CURRENT_IN Perp")
|
|
|
|
if obj.UseMachineCRC: # crc off
|
|
results.append(Path.Command("G40", {}))
|
|
|
|
# print ("results =",results)
|
|
|
|
return results
|
|
|
|
def generateLeadInOutCurve(self, obj):
|
|
global currLocation # pylint: disable=global-statement
|
|
firstmove = Path.Command("G0", {"X": 0, "Y": 0, "Z": 0})
|
|
op = PathDressup.baseOp(obj.Base)
|
|
currLocation.update(firstmove.Parameters)
|
|
newpath = []
|
|
queue = []
|
|
action = "start"
|
|
prevCmd = ""
|
|
layers = []
|
|
|
|
# Read in all commands
|
|
for curCommand in obj.Base.Path.Commands:
|
|
# PathLog.debug("CurCMD: {}".format(curCommand))
|
|
if curCommand.Name not in movecommands + rapidcommands:
|
|
# Don't worry about non-move commands, just add to output
|
|
newpath.append(curCommand)
|
|
continue
|
|
|
|
if curCommand.Name in rapidcommands:
|
|
# We don't care about rapid moves
|
|
prevCmd = curCommand
|
|
currLocation.update(curCommand.Parameters)
|
|
continue
|
|
|
|
if curCommand.Name in movecommands:
|
|
if (
|
|
prevCmd.Name in rapidcommands
|
|
and curCommand.Name in movecommands
|
|
and len(queue) > 0
|
|
):
|
|
# Layer changed: Save current layer cmds and prepare next layer
|
|
layers.append(queue)
|
|
queue = []
|
|
if (
|
|
obj.IncludeLayers
|
|
and curCommand.z < currLocation["Z"]
|
|
and prevCmd.Name in movecommands
|
|
):
|
|
# Layer change within move cmds
|
|
# PathLog.debug("Layer change in move: {}->{}".format(currLocation['Z'], curCommand.z))
|
|
layers.append(queue)
|
|
queue = []
|
|
|
|
# Save all move commands
|
|
queue.append(curCommand)
|
|
|
|
currLocation.update(curCommand.Parameters)
|
|
prevCmd = curCommand
|
|
|
|
# Add last layer
|
|
if len(queue) > 0:
|
|
layers.append(queue)
|
|
|
|
# Go through each layer and add leadIn/Out
|
|
idx = 0
|
|
for layer in layers:
|
|
# PathLog.debug("Layer {}".format(idx))
|
|
|
|
if obj.LeadIn:
|
|
temp = self.getLeadStart(obj, layer, action)
|
|
newpath.extend(temp)
|
|
|
|
for cmd in layer:
|
|
# PathLog.debug("CurLoc: {}, NewCmd: {}".format(currLocation, cmd))
|
|
# if currLocation['X'] == cmd.x and currLocation['Y'] == cmd.y and currLocation['Z'] == cmd.z and cmd.Name in ['G1', 'G01']:
|
|
# continue
|
|
newpath.append(cmd)
|
|
|
|
if obj.LeadOut:
|
|
tmp = []
|
|
tmp.append(layer[-2])
|
|
tmp.append(layer[-1])
|
|
temp = self.getLeadEnd(obj, tmp, action)
|
|
newpath.extend(temp)
|
|
|
|
if not obj.KeepToolDown or idx == len(layers) - 1:
|
|
extendcommand = Path.Command("G0", {"Z": op.ClearanceHeight.Value})
|
|
newpath.append(extendcommand)
|
|
else:
|
|
action = "layer"
|
|
|
|
idx += 1
|
|
|
|
commands = newpath
|
|
return Path.Path(commands)
|
|
|
|
|
|
class TaskDressupLeadInOut(SimpleEditPanel):
|
|
_transaction_name = "Edit LeadInOut Dress-up"
|
|
_ui_file = ":/panels/DressUpLeadInOutEdit.ui"
|
|
|
|
def setupUi(self):
|
|
self.connectWidget("LeadIn", self.form.chkLeadIn)
|
|
self.connectWidget("LeadOut", self.form.chkLeadOut)
|
|
self.connectWidget("Length", self.form.dsbLen)
|
|
self.connectWidget("ExtendLeadIn", self.form.dsbExtendIn)
|
|
self.connectWidget("ExtendLeadOut", self.form.dsbExtendOut)
|
|
self.connectWidget("StyleOn", self.form.cboStyleIn)
|
|
self.connectWidget("StyleOff", self.form.cboStyleOut)
|
|
self.connectWidget("RadiusCenter", self.form.cboRadius)
|
|
self.connectWidget("RapidPlunge", self.form.chkRapidPlunge)
|
|
self.connectWidget("IncludeLayers", self.form.chkLayers)
|
|
self.connectWidget("KeepToolDown", self.form.chkKeepToolDown)
|
|
self.connectWidget("UseMachineCRC", self.form.chkUseCRC)
|
|
self.setFields()
|
|
|
|
|
|
class ViewProviderDressup:
|
|
def __init__(self, vobj):
|
|
self.obj = vobj.Object
|
|
self.setEdit(vobj)
|
|
|
|
def attach(self, vobj):
|
|
self.obj = vobj.Object
|
|
self.panel = None
|
|
|
|
def claimChildren(self):
|
|
if hasattr(self.obj.Base, "InList"):
|
|
for i in self.obj.Base.InList:
|
|
if hasattr(i, "Group"):
|
|
group = i.Group
|
|
for g in group:
|
|
if g.Name == self.obj.Base.Name:
|
|
group.remove(g)
|
|
i.Group = group
|
|
print(i.Group)
|
|
# FreeCADGui.ActiveDocument.getObject(obj.Base.Name).Visibility = False
|
|
return [self.obj.Base]
|
|
|
|
def setEdit(self, vobj, mode=0):
|
|
# pylint: disable=unused-argument
|
|
FreeCADGui.Control.closeDialog()
|
|
panel = TaskDressupLeadInOut(vobj.Object, self)
|
|
FreeCADGui.Control.showDialog(panel)
|
|
return True
|
|
|
|
def unsetEdit(self, vobj, mode=0):
|
|
if self.panel:
|
|
self.panel.abort()
|
|
|
|
def onDelete(self, arg1=None, arg2=None):
|
|
"""this makes sure that the base operation is added back to the project and visible"""
|
|
# pylint: disable=unused-argument
|
|
PathLog.debug("Deleting Dressup")
|
|
if arg1.Object and arg1.Object.Base:
|
|
FreeCADGui.ActiveDocument.getObject(arg1.Object.Base.Name).Visibility = True
|
|
job = PathUtils.findParentJob(self.obj)
|
|
if job:
|
|
job.Proxy.addOperation(arg1.Object.Base, arg1.Object)
|
|
arg1.Object.Base = None
|
|
return True
|
|
|
|
def __getstate__(self):
|
|
return None
|
|
|
|
def __setstate__(self, state):
|
|
# pylint: disable=unused-argument
|
|
return None
|
|
|
|
def clearTaskPanel(self):
|
|
self.panel = None
|
|
|
|
|
|
class CommandPathDressupLeadInOut:
|
|
# pylint: disable=no-init
|
|
|
|
def GetResources(self):
|
|
return {
|
|
"Pixmap": "Path_Dressup",
|
|
"MenuText": QT_TRANSLATE_NOOP("Path_DressupLeadInOut", "LeadInOut Dressup"),
|
|
"ToolTip": QT_TRANSLATE_NOOP(
|
|
"Path_DressupLeadInOut",
|
|
"Creates a Cutter Radius Compensation G41/G42 Entry Dressup object from a selected path",
|
|
),
|
|
}
|
|
|
|
def IsActive(self):
|
|
op = PathDressup.selection()
|
|
if op:
|
|
return not PathDressup.hasEntryMethod(op)
|
|
return False
|
|
|
|
def Activated(self):
|
|
# check that the selection contains exactly what we want
|
|
selection = FreeCADGui.Selection.getSelection()
|
|
if len(selection) != 1:
|
|
PathLog.error(
|
|
translate("Path_DressupLeadInOut", "Please select one path object")
|
|
+ "\n"
|
|
)
|
|
return
|
|
baseObject = selection[0]
|
|
if not baseObject.isDerivedFrom("Path::Feature"):
|
|
PathLog.error(
|
|
translate("Path_DressupLeadInOut", "The selected object is not a path")
|
|
+ "\n"
|
|
)
|
|
return
|
|
if baseObject.isDerivedFrom("Path::FeatureCompoundPython"):
|
|
PathLog.error(
|
|
translate("Path_DressupLeadInOut", "Please select a Profile object")
|
|
)
|
|
return
|
|
|
|
# everything ok!
|
|
FreeCAD.ActiveDocument.openTransaction("Create LeadInOut Dressup")
|
|
FreeCADGui.addModule("PathScripts.PathDressupLeadInOut")
|
|
FreeCADGui.addModule("PathScripts.PathUtils")
|
|
FreeCADGui.doCommand(
|
|
'obj = FreeCAD.ActiveDocument.addObject("Path::FeaturePython", "LeadInOutDressup")'
|
|
)
|
|
FreeCADGui.doCommand(
|
|
"dbo = PathScripts.PathDressupLeadInOut.ObjectDressup(obj)"
|
|
)
|
|
FreeCADGui.doCommand("base = FreeCAD.ActiveDocument." + selection[0].Name)
|
|
FreeCADGui.doCommand("job = PathScripts.PathUtils.findParentJob(base)")
|
|
FreeCADGui.doCommand("obj.Base = base")
|
|
FreeCADGui.doCommand("job.Proxy.addOperation(obj, base)")
|
|
FreeCADGui.doCommand("dbo.setup(obj)")
|
|
FreeCADGui.doCommand(
|
|
"obj.ViewObject.Proxy = PathScripts.PathDressupLeadInOut.ViewProviderDressup(obj.ViewObject)"
|
|
)
|
|
FreeCADGui.doCommand(
|
|
"Gui.ActiveDocument.getObject(base.Name).Visibility = False"
|
|
)
|
|
FreeCAD.ActiveDocument.commitTransaction()
|
|
FreeCAD.ActiveDocument.recompute()
|
|
|
|
|
|
if FreeCAD.GuiUp:
|
|
# register the FreeCAD command
|
|
FreeCADGui.addCommand("Path_DressupLeadInOut", CommandPathDressupLeadInOut())
|
|
|
|
PathLog.notice("Loading Path_DressupLeadInOut... done\n")
|