def bGeneratePressed(self, _):
self.bSave.Enable(False)
self.bVisualize.Enable(False)
self.gcl.clear()
self.gcode = []
errs = []
try:
dec = int(self.teDecimals.GetValue())
self.fmt = "%0." + str(dec) + "f"
except:
errs.append("Decimal Places")
try:
sx = float(self.teStartX.GetValue())
except:
errs.append("Center X")
try:
sy = float(self.teStartY.GetValue())
except:
errs.append("Center Y")
try:
sz = float(self.teStartZ.GetValue())
except:
errs.append("Center Z")
try:
safez = float(self.teSafeZ.GetValue())
except:
errs.append("Safe Z")
addspeed = self.cbAddSpeed.IsChecked()
try:
feedzG0 = float(self.teFeedZG0.GetValue())
except:
errs.append("Z G0 Speed")
try:
feedzG1 = float(self.teFeedZG1.GetValue())
except:
errs.append("Z G1 Speed")
try:
feedxyG0 = float(self.teFeedXYG0.GetValue())
except:
errs.append("XY G0 Speed")
try:
feedxyG23 = float(self.teFeedXYG1.GetValue())
except:
errs.append("XY G1 Speed")
try:
cdiam = float(self.teDiameter.GetValue())
except:
errs.append("Overall Diameter")
try:
depth = float(self.teDepth.GetValue())
except:
errs.append("Depth")
try:
passdepth = float(self.tePassDepth.GetValue())
except:
errs.append("Depth per Pass")
try:
tdiam = float(self.teToolDiam.GetValue())
except:
errs.append("Tool Diameter")
try:
hdiam = float(self.teHoleDiam.GetValue())
except:
errs.append("Hole Diameter")
try:
spacing = float(self.teSpacing.GetValue())
except:
errs.append("Spacing")
try:
stepover = float(self.teStepover.GetValue())
except:
errs.append("Stepover")
if not ValidateNoEntryErrors(self, errs):
return
inside = self.cbInside.IsChecked()
stagger = self.cbStagger.IsChecked()
retract = self.cbRetract.IsChecked()
if not ValidateToolSize(self, tdiam, hdiam, "Hole Diameter"):
return
if not ValidateMinLength(self, cdiam, hdiam + spacing, "Overall diameter", "Hole diameter + spacing"):
return
self.gcode = self.preamble(self.getChosen(self.rbMeas), tdiam, self.toolInfo, safez)
if inside:
radlimit = cdiam/2 - hdiam/2
else:
radlimit = cdiam/2
minx = sx - cdiam/2
maxx = sx + cdiam/2
miny = sy - cdiam/2
maxy = sy + cdiam/2
cd = self.getChosen(self.rbCutDir)
if cd == "Clockwise":
cmd = "G2"
else:
cmd = "G3"
nrows = int((maxy - miny)/(hdiam+spacing))
ncols = int((maxx - minx)/(hdiam+spacing))
if not ValidateNonZero(self, ncols, "Number of calculated columns"):
return
if not ValidateNonZero(self, nrows, "Number of calculated rows"):
return
xstep = (maxx - minx) / float(ncols)
ystep = (maxy - miny) / float(nrows)
if stagger:
ystep *= 0.866
nrows = int((nrows/0.866)+0.5)
if self.settings.annotate:
self.gcode.append("(Circular drill pattern center (%6.2f,%6.2f) diameter %6.2f depth from %6.2f to %6.2f)" % (sx, sy, cdiam, sz, depth))
self.gcode.append("(Cut Direction: %s)" % cd)
self.gcode.append("(Inside Circle: %s)" % str(inside))
self.gcode.append("(Retract each pass: %s)" % str(retract))
self.gcode.append("(Hole diameter: %6.2f)" % hdiam)
self.gcode.append("(Stagger rows: %s)" % str(stagger))
self.gcode.append("(Calculated step x/y: %6.2f/%6.2f)" % (xstep, ystep))
self.gcode.append(("G0 Z"+self.fmt+self.speedTerm(addspeed, feedzG0)) % (safez))
points = [(sx, sy)]
ix = 1
while sx + ix*xstep <= maxx:
if ix*xstep <= radlimit:
points = [(sx - ix*xstep, sy)] + points + [(sx + ix*xstep, sy)]
ix += 1
iy = 1
while sy + iy*ystep <= maxy:
rowu = []
rowd = []
ix = 0
if stagger and iy%2 != 0:
bx = xstep/2
else:
bx = 0
while sx + ix*xstep + bx <= maxx:
r = triangulate((0,0), (ix*xstep+bx, iy*ystep))
if r <= radlimit:
if bx == 0 and ix == 0:
rowu.append((sx + ix*xstep + bx, sy + iy*ystep))
rowd.append((sx + ix*xstep + bx, sy - iy*ystep))
else:
rowu = [(sx - ix*xstep - bx, sy + iy*ystep)] + rowu + [(sx + ix*xstep + bx, sy + iy*ystep)]
rowd = [(sx - ix*xstep - bx, sy - iy*ystep)] + rowd + [(sx + ix*xstep + bx, sy - iy*ystep)]
ix += 1
points = rowu + points + rowd
iy += 1
passes = int(math.ceil(depth/passdepth))
for p in points:
self.gcode.append(("G0 X"+self.fmt+" Y"+self.fmt+self.speedTerm(addspeed, feedxyG0)) % (p[0], p[1]))
cz = sz
for i in range(passes):
cz -= passdepth
if cz < -depth:
cz = -depth
self.gcode.append(("G1 Z"+self.fmt+self.speedTerm(addspeed, feedzG1)) % (cz))
if self.settings.annotate:
self.gcode.append("(Pass number %d at depth %f)" % (i, cz))
if hdiam > tdiam:
maxyoff = (hdiam-tdiam)/2.0
yoff = stepover
while True:
if yoff > maxyoff:
yoff = maxyoff
self.gcode.append(("G1 Y"+self.fmt+self.speedTerm(addspeed, feedxyG0)) % (p[1]-yoff))
self.gcode.append((cmd+" J"+self.fmt+" X"+self.fmt+" Y"+self.fmt+self.speedTerm(addspeed, feedxyG23)) % (yoff, p[0], p[1]-yoff))
if yoff >= maxyoff:
break
yoff += stepover
self.gcode.append(("G1 X"+self.fmt+" Y"+self.fmt+self.speedTerm(addspeed, feedxyG23)) % (p[0], p[1]))
if retract:
self.gcode.append(("G0 Z"+self.fmt+self.speedTerm(addspeed, feedzG0)) % (safez))
if not retract:
self.gcode.append(("G0 Z"+self.fmt+self.speedTerm(addspeed, feedzG0)) % (safez))
if self.settings.annotate:
self.gcode.append("(End object %s)" % self.viewTitle)
self.gcl.updateList(self.gcode)
self.bSave.Enable()
self.bVisualize.Enable()
self.setState(False, True)
def bGeneratePressed(self, _):
self.bSave.Enable(False)
self.bVisualize.Enable(False)
self.gcl.clear()
self.gcode = []
errs = []
try:
dec = int(self.teDecimals.GetValue())
self.fmt = "%0." + str(dec) + "f"
except:
errs.append("Decimal Places")
try:
sx = float(self.teStartX.GetValue())
except:
errs.append("Start X")
try:
sy = float(self.teStartY.GetValue())
except:
errs.append("Start Y")
try:
sz = float(self.teStartZ.GetValue())
except:
errs.append("Start Z")
try:
safez = float(self.teSafeZ.GetValue())
except:
errs.append("Safe Z")
try:
feedzG0 = float(self.teFeedZG0.GetValue())
except:
errs.append("Z G0 Speed")
try:
feedzG1 = float(self.teFeedZG1.GetValue())
except:
errs.append("Z G1 Speed")
try:
feedxyG0 = float(self.teFeedXYG0.GetValue())
except:
errs.append("XY G0 Speed")
try:
feedxyG1 = float(self.teFeedXYG1.GetValue())
except:
errs.append("XY G1 Speed")
try:
totalx = float(self.teSizeX.GetValue())
except:
errs.append("Size X")
try:
totaly = float(self.teSizeY.GetValue())
except:
errs.append("Size Y")
try:
totaldepth = float(self.teTotalDepth.GetValue())
except:
errs.append("Depth")
try:
passdepth = float(self.tePassDepth.GetValue())
except:
errs.append("Depth per Pass")
try:
angle = float(self.teAngle.GetValue())
except:
errs.append("Angle")
try:
gap = float(self.teGap.GetValue())
except:
errs.append("Perpendicular Gap")
try:
yoffset = float(self.teYOffset.GetValue())
except:
errs.append("Y Offset")
try:
self.tDiam = float(self.teToolDiam.GetValue())
except:
errs.append("Tool Diameter")
if not ValidateNoEntryErrors(self, errs):
return
self.gcode = self.preamble(self.getChosen(self.rbMeas), self.tDiam,
self.toolInfo, safez)
border = self.cbBorder.IsChecked()
addspeed = self.cbAddSpeed.IsChecked()
plist = hatch(angle, sx, sy, sx + totalx, sy + totaly, gap, yoffset)
sp = self.getChosen(self.rbStartPoints)
adjx = 0
adjy = 0
if sp == "Upper Left":
adjy = -totaly
elif sp == "Upper Right":
adjy = -totaly
adjx = -totalx
elif sp == "Lower Right":
adjx = -totalx
elif sp == "Center":
adjx = -totalx / 2
adjy = -totaly / 2
points = [[[p[0][0] + adjx, p[0][1] + adjy],
[p[1][0] + adjx, p[1][1] + adjy]] for p in plist]
corners = [[sx + adjx, sy + adjy], [sx + adjx, sy + totaly + adjy],
[sx + totalx + adjx, sy + totaly + adjy],
[sx + totalx + adjx, sy + adjy]]
passes = int(math.ceil(float(totaldepth) / float(passdepth)))
if self.settings.annotate:
self.gcode.append(
"(Cross Hatch pattern start (%6.2f,%6.2f) width %6.2f height %6.2f depth from %6.2f to %6.2f)"
% (sx, sy, totalx, totaly, sz, totaldepth))
self.gcode.append("(Start point: %s)" % sp)
self.gcode.append("(Y offset: %6.2f)" % yoffset)
self.gcode.append("(Cut border: %s)" % str(border))
self.gcode.append("(Gap: %6.2f)" % gap)
self.gcode.append("(Angle: %6.2f)" % angle)
depth = 0
flag = True
for i in range(passes):
depth += passdepth
if depth > totaldepth: depth = totaldepth
if self.settings.annotate:
self.gcode.append("(Pass number %d at depth %f)" % (i, depth))
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) %
safez)
for p in points:
if flag:
xa = p[0][0]
ya = p[0][1]
xb = p[1][0]
yb = p[1][1]
else:
xa = p[1][0]
ya = p[1][1]
xb = p[0][0]
yb = p[0][1]
flag = not flag
self.gcode.append(
("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) % (xa, ya))
self.gcode.append(
("G1 Z" + self.fmt + self.speedTerm(addspeed, feedzG1)) %
(sz - depth))
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) % (xb, yb))
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) %
(safez))
if border:
self.gcode.append(("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) %
(corners[0][0], corners[0][1]))
self.gcode.append(
("G1 Z" + self.fmt + self.speedTerm(addspeed, feedzG1)) %
(sz - depth))
self.gcode.append(("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
(corners[1][0], corners[1][1]))
self.gcode.append(("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
(corners[2][0], corners[2][1]))
self.gcode.append(("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
(corners[3][0], corners[3][1]))
self.gcode.append(("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
(corners[0][0], corners[0][1]))
self.gcode.append(
("G0 Z" + self.fmt + "" +
self.speedTerm(addspeed, feedzG0) + "\n") % (safez))
self.gcode.append(("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) % (sx, sy))
if self.settings.annotate:
self.gcode.append("(End object %s)" % self.viewTitle)
self.gcl.updateList(self.gcode)
self.bSave.Enable()
self.bVisualize.Enable()
self.setState(False, True)
def bGeneratePressed(self, _):
self.bSave.Enable(False)
self.bVisualize.Enable(False)
self.gcl.clear()
self.gcode = []
errs = []
try:
dec = int(self.teDecimals.GetValue())
self.fmt = "%0." + str(dec) + "f"
except:
errs.append("Decimal Places")
try:
sx = float(self.teStartX.GetValue())
except:
errs.append("Center X")
try:
sy = float(self.teStartY.GetValue())
except:
errs.append("Center Y")
try:
sz = float(self.teStartZ.GetValue())
except:
errs.append("Center Z")
try:
safez = float(self.teSafeZ.GetValue())
except:
errs.append("Safe Z")
addspeed = self.cbAddSpeed.IsChecked()
try:
feedzG0 = float(self.teFeedZG0.GetValue())
except:
errs.append("Z G0 Speed")
try:
feedzG1 = float(self.teFeedZG1.GetValue())
except:
errs.append("Z G1 Speed")
try:
feedxyG0 = float(self.teFeedXYG0.GetValue())
except:
errs.append("XY G0 Speed")
try:
feedxyG23 = float(self.teFeedXYG1.GetValue())
except:
errs.append("XY G1 Speed")
try:
diam = float(self.teDiam.GetValue())
except:
errs.append("Diameter")
try:
depth = float(self.teTotalDepth.GetValue())
except:
errs.append("Depth")
try:
passdepth = float(self.tePassDepth.GetValue())
except:
errs.append("Depth per Pass")
try:
tdiam = float(self.teToolDiam.GetValue())
except:
errs.append("Tool Diameter")
try:
stepover = float(self.teStepOver.GetValue())
except:
errs.append("Stepover")
if not ValidateNoEntryErrors(self, errs):
return
if not ValidateToolSize(self, tdiam, diam, "Circle Diameter"):
return
if not ValidateRange(self, stepover, 0.001, 1.0, "Stepover",
"0 < x <= 1.0"):
return
self.gcode = self.preamble(self.getChosen(self.rbMeas), tdiam,
self.toolInfo, safez)
self.tDiam = tdiam
if self.settings.annotate:
self.gcode.append(
"(Circle center (%6.2f,%6.2f) radius %6.2f depth from %6.2f to %6.2f"
% (sx, sy, diam / 2, sz, depth))
tm = self.getChosen(self.rbToolMove)
if tm == "Inside Circle":
diam -= tdiam
elif tm == "Outside Circle":
diam += tdiam
cd = self.getChosen(self.rbCutDir)
if cd == "Clockwise":
cmd = "G2"
else:
cmd = "G3"
passes = int(math.ceil(depth / passdepth))
pkt = self.cbPocket.IsChecked()
if self.settings.annotate:
self.gcode.append("(Cutting direction: %s)" % cd)
self.gcode.append("(Tool movement: %s)" % tm)
self.gcode.append("(Pocket: %s)" % pkt)
if not pkt:
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) %
(safez))
self.gcode.append(
("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) % (sx, sy - diam / 2))
cz = sz
for i in range(passes):
cz -= passdepth
if cz < -depth:
cz = -depth
if self.settings.annotate:
self.gcode.append("(Pass number %d at depth %f)" % (i, cz))
if pkt:
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) %
(safez))
self.gcode.append(
("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) % (sx, sy))
self.gcode.append(
("G1 Z" + self.fmt + self.speedTerm(addspeed, feedzG1)) %
(cz))
r = tdiam * stepover
while r < diam / 2:
self.gcode.append(
("G1 Y" + self.fmt +
self.speedTerm(addspeed, feedxyG23)) % (sy - r))
self.gcode.append(
(cmd + " J" + self.fmt + " X" + self.fmt + " Y" +
self.fmt + self.speedTerm(addspeed, feedxyG23)) %
(r, sx, sy - r))
r += tdiam * stepover
self.gcode.append(
("G1 Y" + self.fmt + self.speedTerm(addspeed, feedxyG23)) %
(sy - diam / 2))
else:
self.gcode.append(
("G1 Z" + self.fmt + self.speedTerm(addspeed, feedzG1)) %
(cz))
self.gcode.append(
(cmd + " J" + self.fmt + " X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG23)) %
(diam / 2, sx, sy - diam / 2))
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) % (safez))
if self.settings.annotate:
self.gcode.append("(End object %s)" % self.viewTitle)
self.gcl.updateList(self.gcode)
self.bSave.Enable(True)
self.bVisualize.Enable()
self.setState(False, True)
def bGeneratePressed(self, _):
self.bSave.Enable(False)
self.bVisualize.Enable(False)
self.gcl.clear()
self.gcode = []
errs = []
try:
dec = int(self.teDecimals.GetValue())
self.fmt = "%0." + str(dec) + "f"
except:
errs.append("Decimal Places")
try:
sx = float(self.teStartX.GetValue())
except:
errs.append("Start X")
try:
sy = float(self.teStartY.GetValue())
except:
errs.append("Start Y")
try:
sz = float(self.teStartZ.GetValue())
except:
errs.append("Start Z")
try:
safez = float(self.teSafeZ.GetValue())
except:
errs.append("Safe Z")
addspeed = self.cbAddSpeed.IsChecked()
try:
feedzG0 = float(self.teFeedZG0.GetValue())
except:
errs.append("Z G0 Speed")
try:
feedzG1 = float(self.teFeedZG1.GetValue())
except:
errs.append("Z G1 Speed")
try:
feedxyG0 = float(self.teFeedXYG0.GetValue())
except:
errs.append("XY G0 Speed")
try:
feedxyG1 = float(self.teFeedXYG1.GetValue())
except:
errs.append("XY G1 Speed")
try:
height = float(self.teHeight.GetValue())
except:
errs.append("Height")
try:
width = float(self.teWidth.GetValue())
except:
errs.append("Width")
try:
depth = float(self.teTotalDepth.GetValue())
except:
errs.append("Depth")
try:
passdepth = float(self.tePassDepth.GetValue())
except:
errs.append("Depth per Pass")
try:
tdiam = float(self.teToolDiam.GetValue())
except:
errs.append("Tool Diameter")
try:
stepover = float(self.teStepOver.GetValue())
except:
errs.append("Stepover")
try:
angle = float(self.teAngle.GetValue())
except:
errs.append("Angle")
if not ValidateNoEntryErrors(self, errs):
return
rot = Rotator(angle)
if not ValidateToolSize(self, tdiam, height, "Height"):
return
if not ValidateToolSize(self, tdiam, width, "Width"):
return
if not ValidateRange(self, stepover, 0.001, 1.0, "Stepover",
"0 < x <= 1.0"):
return
self.gcode = self.preamble(self.getChosen(self.rbMeas), tdiam,
self.toolInfo, safez)
self.tDiam = tdiam
if self.settings.annotate:
if angle == 0:
self.gcode.append(
"(Rectangle (%6.2f,%6.2f) to (%6.2f,%6.2f) depth from %6.2f to %6.2f)"
% (sx, sy, width, height, sz, depth))
else:
rx1, ry1 = rot.rotate(sx, sy)
rx2, ry2 = rot.rotate(width + sx, height + sy)
self.gcode.append(
"(Rectangle (%6.2f,%6.2f) to (%6.2f,%6.2f) depth from %6.2f to %6.2f rotated %6.2f)"
% (rx1, ry1, rx2, ry2, sz, depth, angle))
points = [[sx, sy], [sx, sy + height], [sx + width, sy + height],
[sx + width, sy], [sx, sy]]
sp = self.getChosen(self.rbStartPoints)
adjx = 0
adjy = 0
if sp == "Upper Left":
adjy = -height
elif sp == "Upper Right":
adjy = -height
adjx = -width
elif sp == "Lower Right":
adjx = -width
elif sp == "Center":
adjx = -width / 2
adjy = -height / 2
for p in points:
p[0] += adjx
p[1] += adjy
tm = self.getChosen(self.rbToolMove)
rad = float(tdiam) / 2.0
if tm == "Inside Rectangle":
points[0][0] += rad
points[0][1] += rad
points[1][0] += rad
points[1][1] -= rad
points[2][0] -= rad
points[2][1] -= rad
points[3][0] -= rad
points[3][1] += rad
points[4][0] += rad
points[4][1] += rad
elif tm == "Outside Rectangle":
points[0][0] -= rad
points[0][1] -= rad
points[1][0] -= rad
points[1][1] += rad
points[2][0] += rad
points[2][1] += rad
points[3][0] += rad
points[3][1] -= rad
points[4][0] -= rad
points[4][1] -= rad
cd = self.getChosen(self.rbCutDir)
if cd != "Clockwise":
np = points[::-1]
points = np
pkt = self.getChosen(self.rbPkts)
if self.settings.annotate:
self.gcode.append("(Start point: %s)" % sp)
self.gcode.append("(Cutting direction: %s)" % cd)
self.gcode.append("(Tool movement: %s)" % tm)
self.gcode.append("(Pocket: %s)" % pkt)
if pkt == "None":
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) %
(safez))
self.gcode.append(("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) %
rot.rotate(points[0][0], points[0][1]))
xmin = min(points[0][0], points[2][0]) + tdiam / 2
xmax = max(points[0][0], points[2][0]) - tdiam / 2
ymin = min(points[0][1], points[2][1]) + tdiam / 2
ymax = max(points[0][1], points[2][1]) - tdiam / 2
passes = int(math.ceil(depth / passdepth))
cz = sz
xlast = 0
ylast = 0
for i in range(passes):
cz -= passdepth
if cz < -depth:
cz = -depth
if self.settings.annotate:
self.gcode.append("(Pass number %d at depth %f)" % (i, cz))
if pkt == "Horizontal":
first = True
alt = True
y = ymin
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) %
(safez))
self.gcode.append(("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) %
rot.rotate(xmin, ymin))
self.gcode.append(
("G1 Z" + self.fmt + self.speedTerm(addspeed, feedzG1)) %
(cz))
while y <= ymax:
if not first:
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
rot.rotate(xlast, y))
if alt:
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
rot.rotate(xmax, y))
xlast = xmax
else:
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
rot.rotate(xmin, y))
xlast = xmin
y += tdiam * stepover
first = False
alt = not alt
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) %
(safez))
self.gcode.append(("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) %
rot.rotate(points[0][0], points[0][1]))
elif pkt == "Vertical":
first = True
alt = True
x = xmin
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) %
(safez))
self.gcode.append(("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) %
rot.rotate(xmin, ymin))
self.gcode.append(
("G1 Z" + self.fmt + self.speedTerm(addspeed, feedzG1)) %
(cz))
while x <= xmax:
if not first:
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
rot.rotate(x, ylast))
if alt:
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
rot.rotate(x, ymax))
ylast = ymax
else:
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
rot.rotate(x, ymin))
ylast = ymin
x += tdiam * stepover
first = False
alt = not alt
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) %
(safez))
self.gcode.append(("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) %
rot.rotate(points[0][0], points[0][1]))
elif pkt == "Centered":
vertical = False
if (xmax - xmin) > (ymax - ymin):
ya = (ymax + ymin) / 2.0
yb = ya
d = ymax - ya
xa = xmin + d
xb = xmax - d
elif (xmax - xmin) < (ymax - ymin):
vertical = True
xa = (xmax + xmin) / 2.0
xb = xa
d = xmax - xa
ya = ymin + d
yb = ymax - d
else:
xa = (xmax + xmin) / 2.0
xb = xa
ya = (ymax + ymin) / 2.0
yb = ya
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) %
(safez))
self.gcode.append(
("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) % rot.rotate(xb, yb))
self.gcode.append(
("G1 Z" + self.fmt + self.speedTerm(addspeed, feedzG1)) %
(cz))
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) % rot.rotate(xa, ya))
d = stepover * tdiam
while (xa - d) >= xmin:
if cd == "Clockwise":
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
rot.rotate(xa - d, ya - d))
if vertical:
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
rot.rotate(xa - d, yb + d))
else:
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
rot.rotate(xa - d, ya + d))
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
rot.rotate(xb + d, yb + d))
if vertical:
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
rot.rotate(xb + d, ya - d))
else:
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
rot.rotate(xb + d, yb - d))
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
rot.rotate(xa - d, ya - d))
else:
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
rot.rotate(xa - d, ya - d))
if vertical:
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
rot.rotate(xb + d, ya - d))
else:
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
rot.rotate(xb + d, yb - d))
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
rot.rotate(xb + d, yb + d))
if vertical:
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
rot.rotate(xa - d, yb + d))
else:
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
rot.rotate(xa - d, ya + d))
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
rot.rotate(xa - d, ya - d))
d += stepover * tdiam
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) %
(safez))
self.gcode.append(("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) %
rot.rotate(points[0][0], points[0][1]))
self.gcode.append(
("G1 Z" + self.fmt + self.speedTerm(addspeed, feedzG1)) % (cz))
for p in points[1:]:
self.gcode.append(("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
rot.rotate(p[0], p[1]))
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) % (safez))
if self.settings.annotate:
self.gcode.append("(End object %s)" % self.viewTitle)
self.gcl.updateList(self.gcode)
self.bSave.Enable()
self.bVisualize.Enable()
self.setState(False, True)
def bGeneratePressed(self, _):
self.bVisualize.Enable(False)
self.bSave.Enable(False)
self.gcl.clear()
self.gcode = []
errs = []
try:
dec = int(self.teDecimals.GetValue())
self.fmt = "%0." + str(dec) + "f"
except:
errs.append("Decimal Places")
try:
sx = float(self.teStartX.GetValue())
except:
errs.append("Start X")
try:
sy = float(self.teStartY.GetValue())
except:
errs.append("Start Y")
try:
sz = float(self.teStartZ.GetValue())
except:
errs.append("Start Z")
try:
angle = float(self.teAngle.GetValue())
except:
errs.append("Angle")
try:
safez = float(self.teSafeZ.GetValue())
except:
errs.append("Safe Z")
addspeed = self.cbAddSpeed.IsChecked()
try:
feedzG0 = float(self.teFeedZG0.GetValue())
except:
errs.append("Z G0 Speed")
try:
feedzG1 = float(self.teFeedZG1.GetValue())
except:
errs.append("Z G1 Speed")
try:
feedxyG0 = float(self.teFeedXYG0.GetValue())
except:
errs.append("XY G0 Speed")
try:
feedxyG23 = float(self.teFeedXYG1.GetValue())
except:
errs.append("XY G1 Speed")
try:
height = float(self.teHeight.GetValue())
except:
errs.append("Height")
try:
width = float(self.teWidth.GetValue())
except:
errs.append("Width")
try:
depth = float(self.teDepth.GetValue())
except:
errs.append("Depth")
try:
passdepth = float(self.tePassDepth.GetValue())
except:
errs.append("Depth per Pass")
try:
stepover = float(self.teStepover.GetValue())
except:
errs.append("Stepover")
try:
tdiam = float(self.teToolDiam.GetValue())
except:
errs.append("Tool Diameter")
try:
hdiam = float(self.teHoleDiam.GetValue())
except:
errs.append("Hole Diameter")
try:
spacing = float(self.teSpacing.GetValue())
except:
errs.append("Spacing")
if not ValidateNoEntryErrors(self, errs):
return
if not ValidateToolSize(self, tdiam, hdiam, "Hole Diameter"):
return
if not ValidateMinLength(self, height, hdiam + spacing, "Height",
"Hole Diameter + Spacing"):
return
if not ValidateMinLength(self, width, hdiam + spacing, "Width",
"Hole Diameter + Spacing"):
return
self.gcode = self.preamble(self.getChosen(self.rbMeas), tdiam,
self.toolInfo, safez)
sp = self.getChosen(self.rbStartPoints)
if sp == "Upper Left":
sy -= height
elif sp == "Upper Right":
sy -= height
sx -= width
elif sp == "Lower Right":
sx -= width
elif sp == "Center":
sx -= width / 2
sy -= height / 2
perimeteronly = self.cbPerimeter.IsChecked()
inside = self.cbInside.IsChecked()
if perimeteronly:
stagger = False
else:
stagger = self.cbStagger.IsChecked()
retract = self.cbRetract.IsChecked()
if inside:
minx = sx + hdiam / 2
maxx = sx + width - hdiam / 2
miny = sy + hdiam / 2
maxy = sy + height - hdiam / 2
else:
minx = sx
maxx = sx + width
miny = sy
maxy = sy + height
cd = self.getChosen(self.rbCutDir)
if cd == "Clockwise":
cmd = "G2"
else:
cmd = "G3"
nrows = int((maxy - miny) / (hdiam + spacing))
ncols = int((maxx - minx) / (hdiam + spacing))
xstep = (maxx - minx) / float(ncols)
ystep = (maxy - miny) / float(nrows)
if stagger:
ystep *= 0.866
nrows = int((nrows / 0.866) + 0.5)
cx = minx
cy = miny
rot = None
if angle != 0:
rot = Rotator(angle)
if self.settings.annotate:
self.gcode.append(
"(Rectangular drill pattern start (%6.2f,%6.2f) height %6.2f width %6.2f depth from %6.2f to %6.2f)"
% (sx, sy, height, width, sz, depth))
self.gcode.append("(Starting point: %s)" % sp)
self.gcode.append("(Cut Direction: %s)" % cd)
self.gcode.append("(Inside Circle: %s)" % str(inside))
self.gcode.append("(Perimeter Only: %s)" % str(perimeteronly))
self.gcode.append("(Retract each pass: %s)" % str(retract))
self.gcode.append("(Hole diameter: %6.2f)" % hdiam)
self.gcode.append("(Stagger rows: %s)" % str(stagger))
self.gcode.append("(Calculated step x/y: %6.2f/%6.2f)" %
(xstep, ystep))
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) % (safez))
passes = int(math.ceil(depth / passdepth))
maxyoff = hdiam / 2 - tdiam / 2
for iy in range(nrows + 1):
for ix in range(ncols + 1):
includeHole = False
if not perimeteronly:
if cx <= maxx and cy <= maxy:
includeHole = True
else:
if ix == 0 or ix == ncols or iy == 0 or iy == nrows:
includeHole = True
if includeHole:
if rot is None:
nx = cx
ny = cy
else:
nx, ny = rot.rotate(cx, cy)
self.gcode.append(
("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) % (nx, ny))
cz = sz
for i in range(passes):
cz -= passdepth
if cz < -depth:
cz = -depth
if self.settings.annotate:
self.gcode.append("(Pass number %d at depth %f)" %
(i, cz))
self.gcode.append(
("G1 Z" + self.fmt +
self.speedTerm(addspeed, feedzG1)) % (cz))
if hdiam > tdiam:
maxyoff = (hdiam - tdiam) / 2.0
yoff = stepover
while True:
if yoff > maxyoff:
yoff = maxyoff
self.gcode.append(
("G1 Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) %
(ny - yoff))
self.gcode.append(
(cmd + " J" + self.fmt + " X" + self.fmt +
" Y" + self.fmt +
self.speedTerm(addspeed, feedxyG23)) %
(yoff, nx, ny - yoff))
if yoff >= maxyoff:
break
yoff += stepover
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG23)) %
(nx, ny))
if retract:
self.gcode.append(
("G0 Z" + self.fmt +
self.speedTerm(addspeed, feedzG0)) % (safez))
if not retract:
self.gcode.append(
("G0 Z" + self.fmt +
self.speedTerm(addspeed, feedzG0)) % (safez))
cx += xstep
cy += ystep
if stagger and iy % 2 == 0:
cx = minx + xstep / 2
else:
cx = minx
if self.settings.annotate:
self.gcode.append("(End object %s)" % self.viewTitle)
self.gcl.updateList(self.gcode)
self.setState(False, True)
self.bVisualize.Enable()
self.bSave.Enable()
def bGeneratePressed(self, _):
self.bSave.Enable(False)
self.bVisualize.Enable(False)
self.gcl.clear()
self.gcode = []
errs = []
try:
dec = int(self.teDecimals.GetValue())
self.fmt = "%0." + str(dec) + "f"
except:
errs.append("Decimal Places")
try:
sx = float(self.teStartX.GetValue())
except:
errs.append("Start X")
try:
sy = float(self.teStartY.GetValue())
except:
errs.append("Start Y")
try:
sz = float(self.teStartZ.GetValue())
except:
errs.append("Start Z")
try:
safez = float(self.teSafeZ.GetValue())
except:
errs.append("Safe Z")
addspeed = self.cbAddSpeed.IsChecked()
try:
feedzG0 = float(self.teFeedZG0.GetValue())
except:
errs.append("Z G0 Speed")
try:
feedzG1 = float(self.teFeedZG1.GetValue())
except:
errs.append("Z G1 Speed")
try:
feedxyG0 = float(self.teFeedXYG0.GetValue())
except:
errs.append("XY G0 Speed")
try:
feedxyG23 = float(self.teFeedXYG1.GetValue())
except:
errs.append("XY G1 Speed")
try:
totaldepth = float(self.teTotalDepth.GetValue())
except:
errs.append("Depth")
try:
passdepth = float(self.tePassDepth.GetValue())
except:
errs.append("Depth per Pass")
try:
tdiam = float(self.teToolDiam.GetValue())
except:
errs.append("Tool Diameter")
try:
hdiam = float(self.teHoleDiam.GetValue())
except:
errs.append("Hole Diameter")
try:
spacing = float(self.teSpacing.GetValue())
except:
errs.append("Spacing")
try:
nholes = int(self.teNHoles.GetValue())
except:
errs.append("Number of Holes")
try:
angle = float(self.teAngle.GetValue())
except:
errs.append("Angle")
try:
stepover = float(self.teStepover.GetValue())
except:
errs.append("Stepover")
if not ValidateNoEntryErrors(self, errs):
return
if not ValidateToolSize(self, tdiam, hdiam, "Hole Diameter"):
return
if not ValidateMinLength(self, spacing, hdiam, "Hole Spacing",
"Hole Diameter"):
return
self.gcode = self.preamble(self.getChosen(self.rbMeas), tdiam,
self.toolInfo, safez)
retract = self.cbRetract.IsChecked()
cd = self.getChosen(self.rbCutDir)
if cd == "Clockwise":
cmd = "G2"
else:
cmd = "G3"
dy = spacing * math.sin(math.radians(angle))
dx = spacing * math.cos(math.radians(angle))
if self.settings.annotate:
self.gcode.append(
"(Linear drill pattern start (%6.2f,%6.2f) Number of holes %d depth from %6.2f to %6.2f)"
% (sx, sy, nholes, sz, totaldepth))
self.gcode.append("(Cut Direction: %s)" % cd)
self.gcode.append("(Spacing: %6.2f)" % spacing)
self.gcode.append("(Angle: %6.2f)" % angle)
self.gcode.append("(Retract each pass: %s)" % str(retract))
self.gcode.append("(Hole diameter: %6.2f)" % hdiam)
self.gcode.append("(Calculated step x/y: %6.2f/%6.2f)" % (dx, dy))
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) % (safez))
passes = int(math.ceil(totaldepth / passdepth))
for ix in range(nholes):
cx = sx + ix * dx
cy = sy + ix * dy
self.gcode.append(("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) % (cx, cy))
cz = sz
for i in range(passes):
cz -= passdepth
if cz < -totaldepth:
cz = -totaldepth
if self.settings.annotate:
self.gcode.append("(Pass number %d at depth %f)" % (i, cz))
self.gcode.append(
("G1 Z" + self.fmt + self.speedTerm(addspeed, feedzG1)) %
(cz))
if hdiam > tdiam:
maxyoff = (hdiam - tdiam) / 2.0
yoff = stepover
while True:
if yoff > maxyoff:
yoff = maxyoff
self.gcode.append(
("G1 Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) % (cy - yoff))
self.gcode.append(
(cmd + " J" + self.fmt + " X" + self.fmt + " Y" +
self.fmt + self.speedTerm(addspeed, feedxyG23)) %
(yoff, cx, cy - yoff))
if yoff >= maxyoff:
break
yoff += stepover
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG23)) % (cx, cy))
if retract:
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0))
% (safez))
if not retract:
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) %
(safez))
if self.settings.annotate:
self.gcode.append("(End object %s)" % self.viewTitle)
self.gcl.updateList(self.gcode)
self.bSave.Enable()
self.bVisualize.Enable()
self.setState(False, True)
def bGeneratePressed(self, _):
self.bSave.Enable(False)
self.bVisualize.Enable(False)
self.gcl.clear()
self.gcode = []
errs = []
try:
dec = int(self.teDecimals.GetValue())
self.fmt = "%0." + str(dec) + "f"
except:
errs.append("Decimal places")
try:
sx = float(self.teStartX.GetValue())
except:
errs.append("Start X")
try:
sy = float(self.teStartY.GetValue())
except:
errs.append("Start Y")
try:
sz = float(self.teStartZ.GetValue())
except:
errs.append("Start Z")
try:
safez = float(self.teSafeZ.GetValue())
except:
errs.append("Safe Z")
try:
feedzG0 = float(self.teFeedZG0.GetValue())
except:
errs.append("Z G0 Speed")
try:
feedzG1 = float(self.teFeedZG1.GetValue())
except:
errs.append("Z G1 Speed")
try:
feedxyG0 = float(self.teFeedXYG0.GetValue())
except:
errs.append("XY G0 Speed")
try:
feedxyG1 = float(self.teFeedXYG1.GetValue())
except:
errs.append("XY G1 Speed")
try:
totalx = float(self.teSizeX.GetValue())
except:
errs.append("Size X")
try:
totaly = float(self.teSizeY.GetValue())
except:
errs.append("Size Y")
try:
totaldepth = float(self.teTotalDepth.GetValue())
except:
errs.append("Depth")
try:
passdepth = float(self.tePassDepth.GetValue())
except:
errs.append("Depth per Pass")
try:
segments = int(self.teSegments.GetValue())
except:
errs.append("Segments")
try:
self.tDiam = float(self.teToolDiam.GetValue())
except:
errs.append("Tool Diameter")
if not ValidateNoEntryErrors(self, errs):
return
self.gcode = self.preamble(self.getChosen(self.rbMeas), self.tDiam, self.toolInfo, safez)
border = self.cbBorder.IsChecked()
addspeed = self.cbAddSpeed.IsChecked()
sizex = totalx / segments
sizey = totaly / segments
sp = self.getChosen(self.rbStartPoints)
adjx = 0
adjy = 0
if sp == "Upper Left":
adjy = -totaly
elif sp == "Upper Right":
adjy = -totaly
adjx = -totalx
elif sp == "Lower Right":
adjx = -totalx
elif sp == "Center":
adjx = -totalx/2
adjy = -totaly/2
xvals = [sx + i*sizex + adjx for i in range(segments+1)]
yvals = [sy + i*sizey + adjy for i in range(segments+1)]
points = []
for i in range(1, segments):
points.append([xvals[0], yvals[segments-i], xvals[i], yvals[segments]])
points.append([xvals[0], yvals[0], xvals[segments], yvals[segments]])
for i in range(1, segments):
points.append([xvals[i], yvals[0], xvals[segments], yvals[segments-i]])
for i in range(1, segments):
points.append([xvals[segments-i], yvals[segments], xvals[segments], yvals[segments-i]])
points.append([xvals[0], yvals[segments], xvals[segments], yvals[0]])
for i in range(1, segments):
points.append([xvals[0], yvals[segments-i], xvals[segments-i], yvals[0]])
passes = int(math.ceil(float(totaldepth)/float(passdepth)))
if self.settings.annotate:
self.gcode.append("(Diamond pattern start (%6.2f,%6.2f) width %6.2f height %6.2f segments %d depth from %6.2f to %6.2f)" % (sx, sy, totalx, totaly, segments, sz, totaldepth))
self.gcode.append("(Start point: %s)" % sp)
self.gcode.append("(Cut border: %s)" % str(border))
depth = 0
flag = True
for i in range(passes):
depth += passdepth
if depth > totaldepth: depth=totaldepth
if self.settings.annotate:
self.gcode.append("(Pass number %d at depth %f)" % (i, depth))
self.gcode.append(("G0 Z"+self.fmt+self.speedTerm(addspeed, feedzG0)) % safez)
for p in points:
if flag:
xa = p[0]
ya = p[1]
xb = p[2]
yb = p[3]
else:
xa = p[2]
ya = p[3]
xb = p[0]
yb = p[1]
flag = not flag
self.gcode.append(("G0 X"+self.fmt+" Y"+self.fmt+self.speedTerm(addspeed, feedxyG0)) % (xa, ya))
self.gcode.append(("G1 Z"+self.fmt+self.speedTerm(addspeed, feedzG1)) % (sz-depth))
self.gcode.append(("G1 X"+self.fmt+" Y"+self.fmt+self.speedTerm(addspeed, feedxyG1)) % (xb, yb))
self.gcode.append(("G0 Z"+self.fmt+self.speedTerm(addspeed, feedzG0)) % (safez))
if border:
self.gcode.append(("G0 X"+self.fmt+" Y"+self.fmt+self.speedTerm(addspeed, feedxyG0)) % (xvals[0], yvals[0]))
self.gcode.append(("G1 Z"+self.fmt+self.speedTerm(addspeed, feedzG1)) % (sz-depth))
self.gcode.append(("G1 X"+self.fmt+" Y"+self.fmt+self.speedTerm(addspeed, feedxyG1)) % (xvals[segments], yvals[0]))
self.gcode.append(("G1 X"+self.fmt+" Y"+self.fmt+self.speedTerm(addspeed, feedxyG1)) % (xvals[segments], yvals[segments]))
self.gcode.append(("G1 X"+self.fmt+" Y"+self.fmt+self.speedTerm(addspeed, feedxyG1)) % (xvals[0], yvals[segments]))
self.gcode.append(("G1 X"+self.fmt+" Y"+self.fmt+self.speedTerm(addspeed, feedxyG1)) % (xvals[0], yvals[0]))
self.gcode.append(("G0 Z"+self.fmt+""+self.speedTerm(addspeed, feedzG0)+"\n") % (safez))
self.gcode.append(("G0 X"+self.fmt+" Y"+self.fmt+self.speedTerm(addspeed, feedxyG0)) % (sx, sy))
if self.settings.annotate:
self.gcode.append("(End object %s)" % self.viewTitle)
self.gcl.updateList(self.gcode)
self.bSave.Enable()
self.bVisualize.Enable()
self.setState(False, True)
def bGeneratePressed(self, _):
self.bSave.Enable(False)
self.bVisualize.Enable(False)
self.gcl.clear()
self.gcode = []
errs = []
try:
dec = int(self.teDecimals.GetValue())
self.fmt = "%0." + str(dec) + "f"
except:
errs.append("Decimal Places")
try:
sx = float(self.teStartX.GetValue())
except:
errs.append("Center X")
try:
sy = float(self.teStartY.GetValue())
except:
errs.append("Center Y")
try:
sz = float(self.teStartZ.GetValue())
except:
errs.append("Center Z")
try:
safez = float(self.teSafeZ.GetValue())
except:
errs.append("Safe Z")
addspeed = self.cbAddSpeed.IsChecked()
try:
feedzG0 = float(self.teFeedZG0.GetValue())
except:
errs.append("Z G0 Speed")
try:
feedzG1 = float(self.teFeedZG1.GetValue())
except:
errs.append("Z G1 Speed")
try:
feedxyG0 = float(self.teFeedXYG0.GetValue())
except:
errs.append("XY G0 Speed")
try:
feedxyG1 = float(self.teFeedXYG1.GetValue())
except:
errs.append("XY G1 Speed")
try:
length = float(self.teSLength.GetValue())
except:
errs.append("Side Length")
try:
angle = float(self.teAngle.GetValue())
except:
errs.append("Angle")
try:
depth = float(self.teTotalDepth.GetValue())
except:
errs.append("Depth")
try:
passdepth = float(self.tePassDepth.GetValue())
except:
errs.append("Depth per Pass")
try:
tdiam = float(self.teToolDiam.GetValue())
except:
errs.append("Tool Diameter")
try:
stepover = float(self.teStepOver.GetValue())
except:
errs.append("Stepover")
try:
sides = int(self.teSides.GetValue())
except:
errs.append("Number of Sides")
if not ValidateNoEntryErrors(self, errs):
return
if not ValidateRange(self, stepover, 0.001, 1.0, "Stepover",
"0 < x <= 1.0"):
return
if not ValidateMinLength(self, sides, 3, "Mumber of Sides", "3"):
return
self.gcode = self.preamble(self.getChosen(self.rbMeas), tdiam,
self.toolInfo, safez)
self.tDiam = tdiam
if self.settings.annotate:
self.gcode.append(
"(Regular Polygon center at (%6.2f,%6.2f) depth from %6.2f to %6.2f"
% (sx, sy, sz, depth))
step = 360.0 / sides
a = 0
angles = []
while a < 360:
angles.append(a + angle)
a += step
angles = angles[:
sides] #make sure we didn't get an extra one because of rounding
angles.append(angles[0])
cd = self.getChosen(self.rbCutDir)
if cd == "Clockwise":
na = angles[::-1]
angles = na
pkt = self.cbPocket.IsChecked()
tm = self.getChosen(self.rbToolMove)
if tm == "Inside Polygon":
length -= tdiam / 2.0
elif tm == "Outside Polygon":
length += tdiam / 2.0
passes = int(math.ceil(depth / passdepth))
if self.settings.annotate:
self.gcode.append("(Cutting direction: %s)" % cd)
self.gcode.append("(Tool movement: %s)" % tm)
self.gcode.append("(Pocket: %s)" % pkt)
cz = sz
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) % (safez))
if not pkt:
x = length * math.cos(math.radians(angles[0]))
y = length * math.sin(math.radians(angles[0]))
self.gcode.append(
("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) % (x + sx, y + sy))
for i in range(passes):
cz -= passdepth
if cz < -depth:
cz = -depth
if self.settings.annotate:
self.gcode.append("(Pass number %d at depth %f)" % (i, cz))
if pkt:
self.gcode.append(
("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) % (sx, sy))
self.gcode.append(
("G1 Z" + self.fmt + self.speedTerm(addspeed, feedzG1)) %
(cz))
l = tdiam * stepover
while l < length:
self.gcode.append("(pocket pass at radius %f)" % l)
for a in angles:
x = l * math.cos(math.radians(a))
y = l * math.sin(math.radians(a))
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
(x + sx, y + sy))
l += tdiam * stepover
self.gcode.append("(final pass)")
for a in angles:
x = length * math.cos(math.radians(a))
y = length * math.sin(math.radians(a))
self.gcode.append(("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
(x + sx, y + sy))
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) %
(safez))
else:
self.gcode.append(
("G1 Z" + self.fmt + self.speedTerm(addspeed, feedzG1)) %
(cz))
self.gcode.append("(contour only)")
for a in angles[1:]:
x = length * math.cos(math.radians(a))
y = length * math.sin(math.radians(a))
self.gcode.append(("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) %
(x + sx, y + sy))
if not pkt:
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) %
(safez))
if self.settings.annotate:
self.gcode.append("(End object %s)" % self.viewTitle)
self.gcl.updateList(self.gcode)
self.bSave.Enable()
self.bVisualize.Enable()
self.setState(False, True)
def bGeneratePressed(self, _):
self.bSave.Enable(False)
self.bVisualize.Enable(False)
self.gcl.clear()
self.gcode = []
errs = []
try:
dec = int(self.teDecimals.GetValue())
self.fmt = "%0." + str(dec) + "f"
except:
errs.append("Decimal Places")
try:
data = eval(self.tePoints.GetValue())
except:
errs.append("Point List")
try:
sz = float(self.teStartZ.GetValue())
except:
errs.append("Start Z")
try:
safez = float(self.teSafeZ.GetValue())
except:
errs.append("Safe Z")
closePath = self.cbClosePath.IsChecked()
addspeed = self.cbAddSpeed.IsChecked()
try:
feedzG0 = float(self.teFeedZG0.GetValue())
except:
errs.append("Z G0 Speed")
try:
feedzG1 = float(self.teFeedZG1.GetValue())
except:
errs.append("Z G1 Speed")
try:
feedxyG0 = float(self.teFeedXYG0.GetValue())
except:
errs.append("XY G0 Speed")
try:
feedxyG1 = float(self.teFeedXYG1.GetValue())
except:
errs.append("XY G1 Speed")
try:
depth = float(self.teTotalDepth.GetValue())
except:
errs.append("Depth")
try:
passdepth = float(self.tePassDepth.GetValue())
except:
errs.append("Depth per Pass")
try:
tdiam = float(self.teToolDiam.GetValue())
except:
errs.append("Tool Diameter")
try:
stepover = float(self.teStepOver.GetValue())
except:
errs.append("Stepover")
if not ValidateNoEntryErrors(self, errs):
return
if closePath and len(data) < 3:
ValidateTrue(self, False, "Need >2 points for a closed path")
return
if not ValidateRange(self, stepover, 0.001, 1.0, "Stepover", "0 < x <= 1.0"):
return
self.gcode = self.preamble(self.getChosen(self.rbMeas), tdiam, self.toolInfo, safez)
self.tDiam = tdiam
if self.settings.annotate:
self.gcode.append("(Polyline depth from %6.2f to %6.2f" % (sz, depth))
tracks = self.scTracks.GetValue()
tm = self.getChosen(self.rbToolMove)
passes = int(math.ceil(depth/passdepth))
if tm == "Left of Forward":
offset = tdiam/2.0
offset2 = stepover
elif tm == "Right of Forward":
offset = -tdiam/2.0
offset2 = -stepover
else:
offset = 0
offset2 = 0
if tracks != 1:
dlg = wx.MessageDialog(self, "Cannot have more than 1 track when tool movement is \"On Polyline\".\nAssuming a value of 1.",
'Only 1 Track permitted', wx.OK | wx.ICON_WARNING)
dlg.ShowModal()
dlg.Destroy()
tracks = 1
if offset != 0:
data = offsetPath(data, offset, closePath)
if data is None:
ValidateTrue(self, False, "Unable to calculate offset path for track 0")
return
if self.settings.annotate:
self.gcode.append("(Tool movement: %s)" % tm)
self.gcode.append("(Tracks: %d)" % tracks)
cz = sz - passdepth
if cz < -depth:
cz = -depth
self.gcode.append(("G0 X"+self.fmt+" Y"+self.fmt+self.speedTerm(addspeed, feedxyG0)) % (data[0][0], data[0][1]))
saveData = [x for x in data]
for p in range(passes):
if self.settings.annotate:
self.gcode.append("(pass %d at depth %6.2f)" % (p, cz))
self.gcode.append(("G1 Z"+self.fmt+self.speedTerm(addspeed, feedzG1)) % (cz))
for trk in range(tracks):
for pt in data[1:]:
self.gcode.append(("G1 X"+self.fmt+" Y"+self.fmt+self.speedTerm(addspeed, feedxyG1)) % (pt[0], pt[1]))
if closePath:
self.gcode.append(("G1 X"+self.fmt+" Y"+self.fmt+self.speedTerm(addspeed, feedxyG1)) % (data[0][0], data[0][1]))
else:
self.gcode.append(("G0 Z"+self.fmt+self.speedTerm(addspeed, feedzG0)) % (safez))
self.gcode.append(("G0 X"+self.fmt+" Y"+self.fmt+self.speedTerm(addspeed, feedxyG1)) % (data[0][0], data[0][1]))
self.gcode.append(("G1 Z"+self.fmt+self.speedTerm(addspeed, feedzG1)) % (cz))
if trk+1 < tracks: # if not last track
data = offsetPath(data, offset2, closePath)
if data is None:
ValidateTrue(self, False, "Unable to calculate offset path for track %d" % (trk+1))
return
self.gcode.append(("G1 X"+self.fmt+" Y"+self.fmt+self.speedTerm(addspeed, feedxyG1)) % (data[0][0], data[0][1]))
data = [x for x in saveData]
self.gcode.append(("G1 X"+self.fmt+" Y"+self.fmt+self.speedTerm(addspeed, feedxyG1)) % (data[0][0], data[0][1]))
cz -= passdepth
if cz < -depth:
cz = -depth
self.gcode.append(("G0 Z"+self.fmt+self.speedTerm(addspeed, feedzG0)) % (safez))
if self.settings.annotate:
self.gcode.append("(End object %s)" % self.viewTitle)
self.gcl.updateList(self.gcode)
self.bSave.Enable()
self.bVisualize.Enable()
self.setState(False, True)
def bGeneratePressed(self, _):
self.bSave.Enable(False)
self.bVisualize.Enable(False)
self.gcl.clear()
self.gcode = []
errs = []
try:
dec = int(self.teDecimals.GetValue())
self.fmt = "%0." + str(dec) + "f"
except:
errs.append("Decimal Places")
try:
sx = float(self.teStartX.GetValue())
except:
errs.append("Start X")
try:
sy = float(self.teStartY.GetValue())
except:
errs.append("Start Y")
try:
sz = float(self.teStartZ.GetValue())
except:
errs.append("Start Z")
try:
safez = float(self.teSafeZ.GetValue())
except:
errs.append("Safe Z")
try:
feedzG0 = float(self.teFeedZG0.GetValue())
except:
errs.append("Z G0 Speed")
try:
feedzG1 = float(self.teFeedZG1.GetValue())
except:
errs.append("Z G1 Speed")
try:
feedxyG0 = float(self.teFeedXYG0.GetValue())
except:
errs.append("XY G0 Speed")
try:
feedxyG1 = float(self.teFeedXYG1.GetValue())
except:
errs.append("XY G1 Speed")
try:
sizex = float(self.teSizeX.GetValue())
except:
errs.append("Size X")
try:
sizey = float(self.teSizeY.GetValue())
except:
errs.append("Size Y")
try:
totaldepth = float(self.teTotalDepth.GetValue())
except:
errs.append("Depth")
try:
passdepth = float(self.tePassDepth.GetValue())
except:
errs.append("Depth per Pass")
try:
segmentx = int(self.teXSegments.GetValue())
except:
errs.append("X Segments")
try:
segmenty = int(self.teYSegments.GetValue())
except:
errs.append("Y Segments")
try:
self.tDiam = float(self.teToolDiam.GetValue())
except:
errs.append("Tool Diameter")
if not ValidateNoEntryErrors(self, errs):
return
self.gcode = self.preamble(self.getChosen(self.rbMeas), self.tDiam,
self.toolInfo, safez)
addspeed = self.cbAddSpeed.IsChecked()
segszx = sizex / segmentx
segszy = sizey / segmenty
sp = self.getChosen(self.rbStartPoints)
adjx = 0
adjy = 0
if sp == "Upper Left":
adjy = -sizey
elif sp == "Upper Right":
adjy = -sizey
adjx = -sizex
elif sp == "Lower Right":
adjx = -sizex
elif sp == "Center":
adjx = -sizex / 2
adjy = -sizey / 2
xvals = [sx + i * segszx + adjx for i in range(segmentx + 1)]
yvals = [sy + i * segszy + adjy for i in range(segmenty + 1)]
points = []
flag = False
for i in range(0, segmentx + 1):
if not flag:
points.append([xvals[i], yvals[0], xvals[i], yvals[-1]])
else:
points.append([xvals[i], yvals[-1], xvals[i], yvals[0]])
flag = not flag
flag = False
for i in range(0, segmenty + 1):
if not flag:
points.append([xvals[0], yvals[i], xvals[-1], yvals[i]])
else:
points.append([xvals[-1], yvals[i], xvals[0], yvals[i]])
flag = not flag
passes = int(math.ceil(float(totaldepth) / float(passdepth)))
if self.settings.annotate:
self.gcode.append(
"(Grid pattern start (%6.2f,%6.2f) width %6.2f height %6.2f segments %d,%d depth from %6.2f to %6.2f)"
% (sx, sy, sizex, sizey, segmentx, segmenty, sz, totaldepth))
self.gcode.append("(Start point: %s)" % sp)
depth = 0
for i in range(passes):
depth += passdepth
if depth > totaldepth: depth = totaldepth
if self.settings.annotate:
self.gcode.append("(Pass number %d at depth %f)" % (i, depth))
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) %
safez)
for p in points:
self.gcode.append(
("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) % (p[0], p[1]))
self.gcode.append(
("G1 Z" + self.fmt + self.speedTerm(addspeed, feedzG1)) %
(sz - depth))
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) % (p[2], p[3]))
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) %
(safez))
self.gcode.append(("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) % (sx, sy))
if self.settings.annotate:
self.gcode.append("(End object %s)" % self.viewTitle)
self.gcl.updateList(self.gcode)
self.bSave.Enable()
self.bVisualize.Enable()
self.setState(False, True)
def bGeneratePressed(self, _):
self.bSave.Enable(False)
self.bVisualize.Enable(False)
self.gcl.clear()
self.gcode = []
errs = []
try:
dec = int(self.teDecimals.GetValue())
self.fmt = "%0." + str(dec) + "f"
except:
errs.append("Decimal Places")
try:
sx = float(self.teStartX.GetValue())
except:
errs.append("Center X")
try:
sy = float(self.teStartY.GetValue())
except:
errs.append("Center Y")
try:
sz = float(self.teStartZ.GetValue())
except:
errs.append("Center Z")
try:
startang = float(self.teStartAng.GetValue())
except:
errs.append("Start Angle")
try:
endang = float(self.teEndAng.GetValue())
except:
errs.append("End Angle")
try:
safez = float(self.teSafeZ.GetValue())
except:
errs.append("Safe Z")
cutrad = self.cbCutRad.IsChecked()
addspeed = self.cbAddSpeed.IsChecked()
try:
feedzG0 = float(self.teFeedZG0.GetValue())
except:
errs.append("Z G0 Speed")
try:
feedzG1 = float(self.teFeedZG1.GetValue())
except:
errs.append("Z G1 Speed")
try:
feedxyG0 = float(self.teFeedXYG0.GetValue())
except:
errs.append("XY G0 Speed")
try:
feedxyG123 = float(self.teFeedXYG1.GetValue())
except:
errs.append("XY G1 Speed")
try:
diam = float(self.teDiam.GetValue())
except:
errs.append("Diameter")
try:
depth = float(self.teTotalDepth.GetValue())
except:
errs.append("Depth")
try:
passdepth = float(self.tePassDepth.GetValue())
except:
errs.append("Depth per Pass")
try:
tdiam = float(self.teToolDiam.GetValue())
except:
errs.append("Tool Diameter")
try:
stepover = float(self.teStepOver.GetValue())
except:
errs.append("Stepover")
if not ValidateNoEntryErrors(self, errs):
return
if not ValidateToolSize(self, tdiam, diam, "Arc Diameter"):
return
if not ValidateRange(self, stepover, 0.001, 1.0, "Stepover",
"0 < x <= 1.0"):
return
self.gcode = self.preamble(self.getChosen(self.rbMeas), tdiam,
self.toolInfo, safez)
self.tDiam = tdiam
tm = self.getChosen(self.rbToolMove)
if tm == "Inside Arc":
diam -= tdiam
elif tm == "Outside Arc":
diam += tdiam
cd = self.getChosen(self.rbCutDir)
if cd == "Clockwise":
cmd = "G2"
else:
cmd = "G3"
passes = int(math.ceil(depth / passdepth))
rad = diam / 2
cosstart = math.cos(math.radians(startang))
sinstart = math.sin(math.radians(startang))
cosend = math.cos(math.radians(endang))
sinend = math.sin(math.radians(endang))
startxoff = rad * cosstart
startyoff = rad * sinstart
endxoff = rad * cosend
endyoff = rad * sinend
pkt = self.cbPocket.IsChecked()
if self.settings.annotate:
self.gcode.append(
"(Arc center (%6.2f,%6.2f) %6.2f deg %s to %6.2f deg depth from %6.2f to %6.2f)"
% (sx, sy, startang, cd, endang, sz, depth))
if self.settings.annotate:
self.gcode.append("(Cutting direction: %s)" % cd)
self.gcode.append("(Cut Radii: %s" % str(cutrad))
self.gcode.append("(Tool movement: %s)" % tm)
self.gcode.append("(Pocket: %s)" % pkt)
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) % (safez))
if not pkt:
self.gcode.append(("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) % (sx, sy))
cz = sz
for i in range(passes):
cz -= passdepth
if cz < -depth:
cz = -depth
if self.settings.annotate:
self.gcode.append("(Pass number %d at depth %f)" % (i, cz))
if pkt:
self.gcode.append(
("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) % (sx, sy))
self.gcode.append(
("G1 Z" + self.fmt + self.speedTerm(addspeed, feedzG1)) %
(cz))
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) %
(safez))
rad = tdiam * stepover
while rad < diam / 2:
pktstxoff = rad * cosstart
pktstyoff = rad * sinstart
pktendxoff = rad * cosend
pktendyoff = rad * sinend
self.gcode.append(("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) %
(sx + pktstxoff, sy + pktstyoff))
self.gcode.append(
("G1 Z" + self.fmt + self.speedTerm(addspeed, feedzG1))
% (cz))
self.gcode.append(
(cmd + self.IJTerm("I", -pktstxoff) + self.IJTerm(
"J", -pktstyoff) + " X" + self.fmt + " Y" +
self.fmt + self.speedTerm(addspeed, feedxyG123)) %
(sx + pktendxoff, sy + pktendyoff))
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0))
% (safez))
rad += tdiam * stepover
self.gcode.append(
("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) % (sx, sy))
if cutrad:
self.gcode.append(
("G1 Z" + self.fmt + self.speedTerm(addspeed, feedzG1)) %
(cz))
self.gcode.append(("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG123)) %
(sx + startxoff, sy + startyoff))
else:
self.gcode.append(("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) %
(sx + startxoff, sy + startyoff))
self.gcode.append(
("G1 Z" + self.fmt + self.speedTerm(addspeed, feedzG1)) %
(cz))
self.gcode.append(
(cmd + self.IJTerm("I", -startxoff) +
self.IJTerm("J", -startyoff) + " X" + self.fmt + " Y" +
self.fmt + self.speedTerm(addspeed, feedxyG123)) %
(sx + endxoff, sy + endyoff))
if cutrad:
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG123)) % (sx, sy))
else:
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) %
(safez))
if cutrad:
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) %
(safez))
if self.settings.annotate:
self.gcode.append("(End object %s)" % self.viewTitle)
self.gcl.updateList(self.gcode)
self.bSave.Enable()
self.bVisualize.Enable()
self.setState(False, True)
def bGeneratePressed(self, _):
self.bSave.Enable(False)
self.bVisualize.Enable(False)
self.gcl.clear()
self.gcode = []
errs = []
try:
dec = int(self.teDecimals.GetValue())
self.fmt = "%0." + str(dec) + "f"
except:
errs.append("Decimal Places")
try:
sx = float(self.teStartX.GetValue())
except:
errs.append("Start X")
try:
sy = float(self.teStartY.GetValue())
except:
errs.append("Start Y")
try:
sz = float(self.teStartZ.GetValue())
except:
errs.append("Start Z")
try:
self.safez = float(self.teSafeZ.GetValue())
except:
errs.append("Safe Z")
self.addspeed = self.cbAddSpeed.IsChecked()
try:
self.feedzG0 = float(self.teFeedZG0.GetValue())
except:
errs.append("Z G0 Speed")
try:
self.feedzG1 = float(self.teFeedZG1.GetValue())
except:
errs.append("Z G1 Speed")
try:
self.feedxyG0 = float(self.teFeedXYG0.GetValue())
except:
errs.append("XY G0 Speed")
try:
self.feedxyG1 = float(self.teFeedXYG1.GetValue())
except:
errs.append("XY G1 Speed")
try:
length = float(self.teLength.GetValue())
except:
errs.append("Length")
try:
width = float(self.teWidth.GetValue())
except:
errs.append("Width")
try:
self.depth = float(self.teTotalDepth.GetValue())
except:
errs.append("Depth")
try:
self.passdepth = float(self.tePassDepth.GetValue())
except:
errs.append("Depth per Pass")
try:
tdiam = float(self.teToolDiam.GetValue())
except:
errs.append("Tool Diameter")
try:
stepover = float(self.teStepOver.GetValue())
except:
errs.append("Stepover")
try:
angle = float(self.teAngle.GetValue())
except:
errs.append("Angle")
if not ValidateNoEntryErrors(self, errs):
return
if not ValidateToolSize(self, tdiam, length, "Length"):
return
if not ValidateToolSize(self, tdiam, width, "Width"):
return
if not ValidateRange(self, stepover, 0.001, 1.0, "Stepover",
"0 < x <= 1.0"):
return
if not ValidateMinLength(self, length, width, "Length", "Width"):
return
self.gcode = self.preamble(self.getChosen(self.rbMeas), tdiam,
self.toolInfo, self.safez)
self.tDiam = tdiam
if self.settings.annotate:
self.gcode.append(
"(Rounded slot start (%6.2f,%6.2f) length %6.2f width %6.2f depth from %6.2f to %6.2f)"
% (sx, sy, width, length, sz, self.depth))
length -= width
points = [[sx, sy], [sx, sy + width], [sx + length, sy + width],
[sx + length, sy]]
centers = [[sx, sy + width / 2], [sx + length, sy + width / 2]]
sp = self.getChosen(self.rbStartPoints)
adjx = 0
adjy = 0
if sp == "Upper Left":
adjy = -width
elif sp == "Upper Right":
adjy = -width
adjx = -length
elif sp == "Lower Right":
adjx = -length
elif sp == "Center":
adjx = -length / 2
adjy = -width / 2
for p in points:
p[0] += adjx
p[1] += adjy
for c in centers:
c[0] += adjx
c[1] += adjy
tm = self.getChosen(self.rbToolMove)
rad = float(tdiam) / 2.0
if tm == "Inside":
points[0][1] += rad
points[1][1] -= rad
points[2][1] -= rad
points[3][1] += rad
elif tm == "Outside":
points[0][1] -= rad
points[1][1] += rad
points[2][1] += rad
points[3][1] -= rad
np = []
nc = []
cosv = math.cos(math.radians(angle))
sinv = math.sin(math.radians(angle))
for p in points:
np.append([p[0] * cosv - p[1] * sinv, p[0] * sinv + p[1] * cosv])
for c in centers:
nc.append([c[0] * cosv - c[1] * sinv, c[0] * sinv + c[1] * cosv])
cd = self.getChosen(self.rbCutDir)
clockwise = True
if cd != "Clockwise":
clockwise = False
pkt = self.cbPocket.IsChecked()
if self.settings.annotate:
self.gcode.append("(Start point: %s)" % sp)
self.gcode.append("(Cutting direction: %s)" % cd)
self.gcode.append("(Tool movement: %s)" % tm)
self.gcode.append("(Pocket: %s)" % pkt)
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(self.addspeed, self.feedzG0)) %
(self.safez))
passes = int(math.ceil(self.depth / self.passdepth))
cz = sz
for i in range(passes):
cz -= self.passdepth
if cz < -self.depth:
cz = -self.depth
if self.settings.annotate:
self.gcode.append("(Pass number %d at depth %f)" % (i, cz))
if pkt:
self.gcode.append(
("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(self.addspeed, self.feedxyG0)) %
(nc[1][0], nc[1][1]))
self.gcode.append(
("G1 Z" + self.fmt +
self.speedTerm(self.addspeed, self.feedzG1)) % (cz))
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(self.addspeed, self.feedxyG1)) %
(nc[0][0], nc[0][1]))
d = centers[0][1] - points[0][1]
cd = stepover * tdiam
while cd < d:
pc = [p for p in centers]
pp = [[pc[0][0], pc[0][1] - cd], [pc[0][0], pc[0][1] + cd],
[pc[1][0], pc[1][1] + cd], [pc[1][0], pc[1][1] - cd]]
npp = []
npc = []
for p in pp:
npp.append([
p[0] * cosv - p[1] * sinv,
p[0] * sinv + p[1] * cosv
])
for c in pc:
npc.append([
c[0] * cosv - c[1] * sinv,
c[0] * sinv + c[1] * cosv
])
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(self.addspeed, self.feedxyG1)) %
(npp[0][0], npp[0][1]))
self.loop(npp, npc, clockwise)
cd += stepover * tdiam
self.gcode.append(
("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(self.addspeed, self.feedxyG1)) %
(np[0][0], np[0][1]))
else:
self.gcode.append(
("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(self.addspeed, self.feedxyG0)) %
(np[0][0], np[0][1]))
self.gcode.append(
("G1 Z" + self.fmt +
self.speedTerm(self.addspeed, self.feedzG1)) % (cz))
self.loop(np, nc, clockwise)
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(self.addspeed, self.feedzG0)) %
(self.safez))
if self.settings.annotate:
self.gcode.append("(End object %s)" % self.viewTitle)
self.gcl.updateList(self.gcode)
self.bSave.Enable()
self.bVisualize.Enable()
self.setState(False, True)
def bGeneratePressed(self, _):
self.bSave.Enable(False)
self.bVisualize.Enable(False)
self.gcl.clear()
self.gcode = []
errs = []
try:
dec = int(self.teDecimals.GetValue())
self.fmt = "%0." + str(dec) + "f"
except:
errs.append("Decimal Places")
try:
sx = float(self.teStartX.GetValue())
except:
errs.append("Start X")
try:
sy = float(self.teStartY.GetValue())
except:
errs.append("Start Y")
try:
ex = float(self.teEndX.GetValue())
except:
errs.append("End X")
try:
ey = float(self.teEndY.GetValue())
except:
errs.append("End Y")
try:
sz = float(self.teStartZ.GetValue())
except:
errs.append("Start Z")
try:
safez = float(self.teSafeZ.GetValue())
except:
errs.append("Safe Z")
addspeed = self.cbAddSpeed.IsChecked()
try:
feedzG0 = float(self.teFeedZG0.GetValue())
except:
errs.append("Z G0 Speed")
try:
feedzG1 = float(self.teFeedZG1.GetValue())
except:
errs.append("Z G1 Speed")
try:
feedxyG0 = float(self.teFeedXYG0.GetValue())
except:
errs.append("XY G0 Speed")
try:
feedxyG1 = float(self.teFeedXYG1.GetValue())
except:
errs.append("XY G1 Speed")
try:
depth = float(self.teTotalDepth.GetValue())
except:
errs.append("Depth")
try:
passdepth = float(self.tePassDepth.GetValue())
except:
errs.append("Depth per Pass")
try:
tdiam = float(self.teToolDiam.GetValue())
except:
errs.append("Tool Diameter")
if not ValidateNoEntryErrors(self, errs):
return
self.gcode = self.preamble(self.getChosen(self.rbMeas), tdiam,
self.toolInfo, safez)
self.tDiam = tdiam
rise = float(ey) - float(sy)
run = float(ex) - float(sx)
sign = 1
if run < 0:
sign = -1
if run == 0:
trise = 0
if rise > 0:
trun = -tdiam / 2
else:
trun = tdiam / 2
else:
angler = math.atan(rise / run)
trise = sign * math.cos(angler) * tdiam / 2
trun = sign * (-(math.sin(angler) * tdiam / 2))
tm = self.getChosen(self.rbToolMove)
if tm == "Left of forward motion":
sx += trun
ex += trun
sy += trise
ey += trise
elif tm == "Right of forward motion":
sx -= trun
ex -= trun
sy -= trise
ey -= trise
if self.settings.annotate:
self.gcode.append("(Tool movement: %s)" % tm)
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) % (safez))
passes = int(math.ceil(depth / passdepth))
if self.settings.annotate:
self.gcode.append(
"(Line (%6.2f,%6.2f) to (%6.2f,%6.2f) depth from %6.2f to %6.2f)"
% (sx, sy, ex, ey, sz, depth))
cz = sz
for i in range(passes):
cz -= passdepth
if cz < -depth:
cz = -depth
if self.settings.annotate:
self.gcode.append("(Pass number %d at depth %f)" % (i, cz))
self.gcode.append(("G0 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG0)) % (sx, sy))
self.gcode.append(
("G1 Z" + self.fmt + self.speedTerm(addspeed, feedzG1)) % (cz))
self.gcode.append(("G1 X" + self.fmt + " Y" + self.fmt +
self.speedTerm(addspeed, feedxyG1)) % (ex, ey))
self.gcode.append(
("G0 Z" + self.fmt + self.speedTerm(addspeed, feedzG0)) %
(safez))
if self.settings.annotate:
self.gcode.append("(End object %s)" % self.viewTitle)
self.gcl.updateList(self.gcode)
self.bSave.Enable()
self.bVisualize.Enable()
self.setState(False, True)