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)