def make_zig_curve(curve, y0, y): global test_count if rightward_for_zigs: curve.Reverse() zig = area.Curve() zig_started = False zag_found = False prev_p = None for vertex in curve.getVertices(): if prev_p != None: if math.fabs(vertex.p.y - y0) < 0.002: if zig_started: zig.append(unrotated_vertex(vertex)) elif math.fabs(prev_p.y - y0) < 0.002 and vertex.type == 0: zig.append( area.Vertex(0, unrotated_point(prev_p), area.Point(0, 0))) zig.append(unrotated_vertex(vertex)) zig_started = True elif zig_started: zig.append(unrotated_vertex(vertex)) if math.fabs(vertex.p.y - y) < 0.002: zag_found = True break prev_p = vertex.p if zig_started: curve_list_for_zigs.append(zig)
def make_area_for_roughing(k): num_spans = kurve.num_spans(k) if num_spans == 0: raise "sketch has no spans!" d, startx, starty, ex, ey, cx, cy = kurve.get_span(k, 0) d, sx, sy, endx, endy, cx, cy = kurve.get_span(k, num_spans - 1) a = area.Area() c = area.Curve() largey = 7 for span in range(0, num_spans): d, sx, sy, ex, ey, cx, cy = kurve.get_span(k, span) if span == 0: # first span c.append( area.Vertex(0, area.Point(startx, largey), area.Point(0, 0))) c.append(area.Vertex(d, area.Point(ex, ey), area.Point(cx, cy))) # close the area c.append(area.Vertex(0, area.Point(endx, largey), area.Point(0, 0))) c.append(area.Vertex(0, area.Point(startx, largey), area.Point(0, 0))) a.append(c) return a
def rotated_area(a): an = area.Area() for curve in a.getCurves(): curve_new = area.Curve() for v in curve.getVertices(): curve_new.append(rotated_vertex(v)) an.append(curve_new) return an
def make_circle(p, radius): circle = area.Area() c = area.Curve() c.append(p + area.Point(radius, 0)) c.append(area.Vertex(1, p + area.Point(-radius, 0), p)) c.append(area.Vertex(1, p + area.Point(radius, 0), p)) circle.append(c) return circle
def feed(self, x=None, y=None, z=None, a=None, b=None, c=None): px = self.x py = self.y pz = self.z recreator.Redirector.feed(self, x, y, z, a, b, c) if self.x == None or self.y == None or self.z == None: return if px == self.x and py == self.y: return # add a line to the path if self.path == None: self.path = area.Curve() self.path.append(area.Point(self.x, self.y))
def make_smaller( curve, start = None, finish = None, end_beyond = False ): if start != None: curve.ChangeStart(curve.NearestPoint(start)) if finish != None: if end_beyond: curve2 = area.Curve(curve) curve2.ChangeEnd(curve2.NearestPoint(finish)) first = True for vertex in curve2.getVertices(): if first == False: curve.append(vertex) first = False else: curve.ChangeEnd(curve.NearestPoint(finish))
def zigzag(a, stepover, zig_unidirectional): if a.num_curves() == 0: return global rightward_for_zigs global curve_list_for_zigs global sin_angle_for_zigs global cos_angle_for_zigs global sin_minus_angle_for_zigs global cos_minus_angle_for_zigs global one_over_units one_over_units = 1 / area.get_units() a = rotated_area(a) b = area.Box() a.GetBox(b) x0 = b.MinX() - 1.0 x1 = b.MaxX() + 1.0 height = b.MaxY() - b.MinY() num_steps = int(height / stepover + 1) y = b.MinY() + 0.1 * one_over_units null_point = area.Point(0, 0) rightward_for_zigs = True curve_list_for_zigs = [] for i in range(0, num_steps): y0 = y y = y + stepover p0 = area.Point(x0, y0) p1 = area.Point(x0, y) p2 = area.Point(x1, y) p3 = area.Point(x1, y0) c = area.Curve() c.append(area.Vertex(0, p0, null_point, 0)) c.append(area.Vertex(0, p1, null_point, 0)) c.append(area.Vertex(0, p2, null_point, 1)) c.append(area.Vertex(0, p3, null_point, 0)) c.append(area.Vertex(0, p0, null_point, 1)) a2 = area.Area() a2.append(c) a2.Intersect(a) make_zig(a2, y0, y, zig_unidirectional) if zig_unidirectional == False: rightward_for_zigs = (rightward_for_zigs == False) reorder_zigs()
def cut_path(self): if self.path == None: return print self.drag_distance self.path.OffsetForward(self.drag_distance, False) nc.creator = nc.creator.original if self.path.getNumVertices() > 0: v = self.path.FirstVertex() nc.creator.feed(v.p.x, v.p.y) cut_curve(self.path) nc.creator = self self.path = area.Curve()
def arc(self, x=None, y=None, z=None, i=None, j=None, k=None, r=None, ccw=True): recreator.Redirector.arc(self, x, y, z, i, j, k, r, ccw) # add an arc to the path if self.path == None: self.path = area.Curve() self.path.append( area.Vertex(1 if ccw else -1, area.Point(self.x, self.y), area.Point(i, j)))
def arc(self, dir, x, y, z, i, j, k, r): self.rapid_flag = False if x == None: x = self.x if y == None: y = self.y if z == None: z = self.z area.set_units(0.05) curve = area.Curve() curve.append(area.Point(self.x, self.y)) curve.append(area.Vertex(dir, area.Point(x, y), area.Point(i, j))) curve.UnFitArcs() for span in curve.GetSpans(): self.add_line(Point(span.p.x, span.p.y, z), Point(span.v.p.x, span.v.p.y, z)) self.x = x self.y = y self.z = z
def make_obround(p0, p1, radius): dir = p1 - p0 d = dir.length() dir.normalize() right = area.Point(dir.y, -dir.x) obround = area.Area() c = area.Curve() vt0 = p0 + right * radius vt1 = p1 + right * radius vt2 = p1 - right * radius vt3 = p0 - right * radius c.append(area.Vertex(0, vt0, area.Point(0, 0))) c.append(area.Vertex(0, vt1, area.Point(0, 0))) c.append(area.Vertex(1, vt2, p1)) c.append(area.Vertex(0, vt3, area.Point(0, 0))) c.append(area.Vertex(1, vt0, p0)) obround.append(c) return obround
def profile2(curve, direction="on", radius=1.0, vertfeed=0.0, horizfeed=0.0, vertrapid=0.0, horizrapid=0.0, offset_extra=0.0, roll_radius=2.0, roll_on=None, roll_off=None, depthparams=None, extend_at_start=0.0, extend_at_end=0.0, lead_in_line_len=0.0, lead_out_line_len=0.0): # print "direction: " + str(direction) # print "radius: " + str(radius) # print "vertfeed: " + str(vertfeed) # print "horizfeed: " + str(horizfeed) # print "offset_extra: " + str(offset_extra) # print "roll_radius: " + str(roll_radius) # print "roll_on: " + str(roll_on) # print "roll_off: " + str(roll_off) # print "depthparams: " + str(depthparams) # print "extend_at_start: " + str(extend_at_start) # print "extend_at_end: " + str(extend_at_end) # print "lead_in_line_len: " + str(lead_in_line_len) # print "lead_out_line_len: " + str(lead_out_line_len) # print "in profile2: 318" global tags direction = direction.lower() offset_curve = area.Curve(curve) # print "curve: " , str(curve) # print "result curve: ", offset_curve.__dict__ if direction == "on": use_CRC() == False if direction != "on": if direction != "left" and direction != "right": raise ("direction must be left or right", direction) # get tool diameter offset = radius + offset_extra if use_CRC() is False or (use_CRC() is True and CRC_nominal_path() is True): if math.fabs(offset) > 0.00005: if direction == "right": offset = -offset offset_success = offset_curve.Offset(offset) if offset_success is False: global using_area_for_offset if curve.IsClosed() and (using_area_for_offset is False): cw = curve.IsClockwise() using_area_for_offset = True a = area.Area() a.append(curve) print("curve, offset: ", str(curve), str(offset)) a.Offset(-offset) for curve in a.getCurves(): print("result curve: ", curve) curve_cw = curve.IsClockwise() if cw != curve_cw: curve.Reverse() # once we know how what a good start point is # we might want to set it here #set_good_start_point(curve, False) profile(curve, direction, 0.0, 0.0, roll_radius, roll_on, roll_off, depthparams, extend_at_start, extend_at_end, lead_in_line_len, lead_out_line_len) using_area_for_offset = False return else: raise Exception("couldn't offset kurve " + str(offset_curve)) # extend curve if extend_at_start > 0.0: span = offset_curve.GetFirstSpan() new_start = span.p + span.GetVector(0.0) * (-extend_at_start) new_curve = area.Curve() new_curve.append(new_start) for vertex in offset_curve.getVertices(): new_curve.append(vertex) offset_curve = new_curve if extend_at_end > 0.0: span = offset_curve.GetLastSpan() new_end = span.v.p + span.GetVector(1.0) * extend_at_end offset_curve.append(new_end) # remove tags further than radius from the offset kurve new_tags = [] for tag in tags: if tag.dist(offset_curve) <= radius + 0.001: new_tags.append(tag) tags = new_tags if offset_curve.getNumVertices() <= 1: raise ("sketch has no spans!") # do multiple depths depths = depthparams.get_depths() # current_start_depth = depthparams.start_depth # tags if len(tags) > 0: # make a copy to restore to after each level copy_of_offset_curve = area.Curve(offset_curve) prev_depth = depthparams.start_depth endpoint = None for depth in depths: mat_depth = prev_depth if len(tags) > 0: split_for_tags(offset_curve, radius, depthparams.start_depth, depth, depthparams.final_depth) # make the roll on and roll off kurves roll_on_curve = area.Curve() add_roll_on(offset_curve, roll_on_curve, direction, roll_radius, offset_extra, roll_on) roll_off_curve = area.Curve() add_roll_off(offset_curve, roll_off_curve, direction, roll_radius, offset_extra, roll_off) if use_CRC(): crc_start_point = area.Point() add_CRC_start_line(offset_curve, roll_on_curve, roll_off_curve, radius, direction, crc_start_point, lead_in_line_len) # get the tag depth at the start start_z = get_tag_z_for_span(0, offset_curve, radius, depthparams.start_depth, depth, depthparams.final_depth) if start_z > mat_depth: mat_depth = start_z # rapid across to the start s = roll_on_curve.FirstVertex().p # start point if (endpoint is None) or (endpoint != s): if use_CRC(): rapid(crc_start_point.x, crc_start_point.y) + "F " + horizrapid + "\n" else: rapid(s.x, s.y) #+ "F " + str(horizrapid) + "\n" # rapid down to just above the material if endpoint is None: rapid( z=mat_depth + depthparams.rapid_safety_space) #+ "F " + vertrapid + "\n" else: rapid(z=mat_depth) #+ "F " + str(vertrapid) + "\n" # feed down to depth mat_depth = depth if start_z > mat_depth: mat_depth = start_z feed(s.x, s.y, z=mat_depth) if use_CRC(): start_CRC(direction == "left", radius) # move to the startpoint feed(s.x, s.y) # cut the roll on arc cut_curve(roll_on_curve) # cut the main kurve current_perim = 0.0 for span in offset_curve.GetSpans(): # height for tags current_perim += span.Length() ez = get_tag_z_for_span(current_perim, offset_curve, radius, depthparams.start_depth, depth, depthparams.final_depth) if ez is None: ez = depth if span.v.type == 0: # line feed(span.v.p.x, span.v.p.y, ez) else: if span.v.type == 1: # anti-clockwise arc arc_ccw(span.v.p.x, span.v.p.y, ez, i=span.v.c.x, j=span.v.c.y) else: arc_cw(span.v.p.x, span.v.p.y, ez, i=span.v.c.x, j=span.v.c.y) # cut the roll off arc cut_curve(roll_off_curve) endpoint = offset_curve.LastVertex().p if roll_off_curve.getNumVertices() > 0: endpoint = roll_off_curve.LastVertex().p # add CRC end_line if use_CRC(): crc_end_point = area.Point() add_CRC_end_line(offset_curve, roll_on_curve, roll_off_curve, radius, direction, crc_end_point, lead_out_line_len) if direction == "on": rapid( z=depthparams.clearance_height) #+ "F " + vertrapid + "\n" else: feed(crc_end_point.x, crc_end_point.y) # restore the unsplit kurve if len(tags) > 0: offset_curve = area.Curve(copy_of_offset_curve) if use_CRC(): end_CRC() if endpoint != s: # rapid up to the clearance height rapid(z=depthparams.clearance_height) # + "F " + vertrapid + "\n" prev_depth = depth rapid(z=depthparams.clearance_height) # + "F " + vertrapid + "\n" del offset_curve if len(tags) > 0: del copy_of_offset_curve
def makeAreaCurve(edges, direction, startpt=None, endpt=None): curveobj = area.Curve() cleanededges = Part.__sortEdges__(cleanedges(edges, 0.01)) # for e in cleanededges: # print str(e.valueAt(e.FirstParameter)) + "," + # str(e.valueAt(e.LastParameter)) edgelist = [] if len(cleanededges) == 1: # user selected a single edge. edgelist = cleanededges else: # edgelist = [] #Multiple edges. Need to sequence the vetexes. # First get the first segment oriented correctly. # We first compare the last parameter of the first segment to see if it # matches either end of the second segment. If not, it must need # flipping. p0L = cleanededges[0].valueAt(cleanededges[0].LastParameter) if PathGeom.pointsCoincide( p0L, cleanededges[1].valueAt(cleanededges[1].FirstParameter) ) or PathGeom.pointsCoincide( p0L, cleanededges[1].valueAt(cleanededges[1].LastParameter)): edge0 = cleanededges[0] else: edge0 = PathUtils.reverseEdge(cleanededges[0]) edgelist.append(edge0) # Now iterate the rest of the edges matching the last parameter of the # previous segment. for edge in cleanededges[1:]: if PathGeom.pointsCoincide( edge.valueAt(edge.FirstParameter), edgelist[-1].valueAt(edgelist[-1].LastParameter)): nextedge = edge else: nextedge = PathUtils.reverseEdge(edge) edgelist.append(nextedge) # print "makeareacurve 87: " + "area.Point(" + # str(edgelist[0].Vertexes[0].X) + ", " + # str(edgelist[0].Vertexes[0].Y)+")" curveobj.append( area.Point(edgelist[0].Vertexes[0].X, edgelist[0].Vertexes[0].Y)) # seglist =[] # if direction=='CW': # edgelist.reverse() # for e in edgelist: # seglist.append(PathUtils.reverseEdge(e)) #swap end points on every segment # else: # for e in edgelist: # seglist.append(e) for s in edgelist: curveobj.append(makeAreaVertex(s)) if startpt: # future nearest point code yet to be worked out -fixme # v1 = Vector(startpt.X,startpt.Y,startpt.Z) # perppoint1 = DraftGeomUtils.findPerpendicular(v1,firstedge) # perppoint1 = DraftGeomUtils.findDistance(v1,firstedge) # if perppoint1: # curveobj.ChangeStart(area.Point(perppoint1[0].x,perppoint1[0].y)) # else: # curveobj.ChangeStart(area.Point(startpt.X,startpt.Y)) curveobj.ChangeStart(area.Point(startpt.x, startpt.y)) if endpt: # future nearest point code yet to be worked out -fixme # v2 = Vector(endpt.X,endpt.Y,endpt.Z) # perppoint2 = DraftGeomUtils.findPerpendicular(v2,lastedge) # if perppoint2: # curveobj.ChangeEnd(area.Point(perppoint2[0].x,perppoint2[0].y)) # else: # curveobj.ChangeEnd(area.Point(endpt.X,endpt.Y)) curveobj.ChangeEnd(area.Point(endpt.x, endpt.y)) if curveobj.IsClockwise() and direction == 'CCW': curveobj.Reverse() elif not curveobj.IsClockwise() and direction == 'CW': curveobj.Reverse() return curveobj
tool_change(id=4) spindle(7000) feedrate_hv(840, 100) flush_nc() clearance = float(5) rapid_safety_space = float(2) start_depth = float(0) step_down = float(1) final_depth = float(-1) tool_diameter = float(4.7752) cutting_edge_angle = float(0) #absolute() mode roll_radius = float(2) offset_extra = 0 comment('Sketch') curve = area.Curve() #open path curve.append(area.Point(66.163292, 40.55579)) curve.append(area.Point(66.163292, -37.200397)) curve.append( area.Vertex(-1, area.Point(56.163292, -47.200397), area.Point(56.163292, -37.200397))) curve.append(area.Point(-58.730675, -47.200397)) curve.append( area.Vertex(-1, area.Point(-68.730675, -37.200397), area.Point(-58.730675, -37.200397))) curve.append(area.Point(-68.730675, 40.55579)) roll_on = 'auto' roll_off = 'auto' extend_at_start = 0
def zigzag(a, a_firstoffset, stepover): if a.num_curves() == 0: return global rightward_for_zigs global curve_list_for_zigs global test_count global sin_angle_for_zigs global cos_angle_for_zigs global sin_minus_angle_for_zigs global cos_minus_angle_for_zigs a = rotated_area(a) b = area.Box() a.GetBox(b) #x0 = b.MinX() - 1.0 #x1 = b.MaxX() + 1.0 x1 = b.MinX() - 1.0 x0 = b.MaxX() + 1.0 height = b.MaxY() - b.MinY() num_steps = int(height / stepover + 1) #y = b.MinY() + 0.1 y = b.MaxY() - 0.1 null_point = area.Point(0, 0) rightward_for_zigs = True curve_list_for_zigs = [] test_count = 0 for i in range(0, num_steps): #collect vertices for a box shape from X+,Y+ toward the curve #then move the tool Y+ and then back toward the X start position # -------> # | # -------< test_count = test_count + 1 y0 = y #y = y + stepover y = y - stepover p0 = area.Point(x0, y0) p1 = area.Point(x0, y) p2 = area.Point(x1, y) p3 = area.Point(x1, y0) c = area.Curve() c.append(area.Vertex(0, p0, null_point, 0)) c.append(area.Vertex(0, p1, null_point, 0)) c.append(area.Vertex(0, p2, null_point, 1)) c.append(area.Vertex(0, p3, null_point, 0)) c.append(area.Vertex(0, p0, null_point, 1)) a2 = area.Area() a2.append(c) a2.Intersect(a) rightward_for_zigs = (rightward_for_zigs == False) y10 = y + stepover #y = y + stepover y2 = y + stepover * 2 p10 = area.Point(x0, y10) p11 = area.Point(x0, y2) p12 = area.Point(x1, y2) p13 = area.Point(x1, y10) c2 = area.Curve() c2.append(area.Vertex(0, p10, null_point, 0)) c2.append(area.Vertex(0, p11, null_point, 0)) c2.append(area.Vertex(0, p12, null_point, 1)) c2.append(area.Vertex(0, p13, null_point, 0)) c2.append(area.Vertex(0, p10, null_point, 1)) a3 = area.Area() a3.append(c2) a3.Intersect(a) make_zig(a3, y0, y) rightward_for_zigs = (rightward_for_zigs == False) reorder_zigs()
def profile(curve, direction = "on", radius = 1.0, offset_extra = 0.0, roll_radius = 2.0, roll_on = None, roll_off = None, rapid_safety_space = None, clearance = None, start_depth = None, step_down = None, final_depth = None, extend_at_start = 0.0, extend_at_end = 0.0, lead_in_line_len=0.0,lead_out_line_len= 0.0): global tags offset_curve = area.Curve(curve) if direction == "on": use_CRC == False if direction != "on": if direction != "left" and direction != "right": raise "direction must be left or right", direction # get tool diameter offset = radius + offset_extra if use_CRC == False or (use_CRC==True and CRC_nominal_path==True): if direction == "right": offset = -offset offset_success = offset_curve.Offset(offset) if offset_success == False: raise Exception, "couldn't offset kurve " + str(offset_curve) # extend curve if extend_at_start > 0.0: span = offset_curve.GetFirstSpan() new_start = span.p + span.GetVector(0.0) * ( -extend_at_start) new_curve = area.Curve() new_curve.append(new_start) for vertex in offset_curve.getVertices(): new_curve.append(vertex) offset_curve = new_curve if extend_at_end > 0.0: span = offset_curve.GetLastSpan() new_end = span.v.p + span.GetVector(1.0) * extend_at_end offset_curve.append(new_end) # remove tags further than radius from the offset kurve new_tags = [] for tag in tags: if tag.dist(offset_curve) <= radius + 0.001: new_tags.append(tag) tags = new_tags if offset_curve.getNumVertices() <= 1: raise "sketch has no spans!" # do multiple depths total_to_cut = start_depth - final_depth; num_step_downs = int(float(total_to_cut) / math.fabs(step_down) + 0.999999) # tags if len(tags) > 0: # make a copy to restore to after each level copy_of_offset_curve = area.Curve(offset_curve) prev_depth = start_depth for step in range(0, num_step_downs): depth_of_cut = ( start_depth - final_depth ) * ( step + 1 ) / num_step_downs depth = start_depth - depth_of_cut mat_depth = prev_depth if len(tags) > 0: split_for_tags(offset_curve, radius, start_depth, depth, final_depth) # make the roll on and roll off kurves roll_on_curve = area.Curve() add_roll_on(offset_curve, roll_on_curve, direction, roll_radius, offset_extra, roll_on) roll_off_curve = area.Curve() add_roll_off(offset_curve, roll_off_curve, direction, roll_radius, offset_extra, roll_off) if use_CRC: crc_start_point = area.Point() add_CRC_start_line(offset_curve,roll_on_curve,roll_off_curve,radius,direction,crc_start_point,lead_in_line_len) # get the tag depth at the start start_z = get_tag_z_for_span(0, offset_curve, radius, start_depth, depth, final_depth) if start_z > mat_depth: mat_depth = start_z # rapid across to the start s = roll_on_curve.FirstVertex().p # start point if use_CRC: rapid(crc_start_point.x,crc_start_point.y) else: rapid(s.x, s.y) # rapid down to just above the material rapid(z = mat_depth + rapid_safety_space) # feed down to depth mat_depth = depth if start_z > mat_depth: mat_depth = start_z feed(z = mat_depth) if use_CRC: start_CRC(direction == "left", radius) # move to the startpoint feed(s.x, s.y) # cut the roll on arc cut_curve(roll_on_curve) # cut the main kurve current_perim = 0.0 for span in offset_curve.GetSpans(): # height for tags current_perim += span.Length() ez = get_tag_z_for_span(current_perim, offset_curve, radius, start_depth, depth, final_depth) if span.v.type == 0:#line feed(span.v.p.x, span.v.p.y, ez) else: if span.v.type == 1:# anti-clockwise arc arc_ccw(span.v.p.x, span.v.p.y, ez, i = span.v.c.x, j = span.v.c.y) else: arc_cw(span.v.p.x, span.v.p.y, ez, i = span.v.c.x, j = span.v.c.y) # cut the roll off arc cut_curve(roll_off_curve) #add CRC end_line if use_CRC: crc_end_point = area.Point() add_CRC_end_line(offset_curve,roll_on_curve,roll_off_curve,radius,direction,crc_end_point,lead_out_line_len) if direction == "on": rapid(z = clearance) else: feed(crc_end_point.x, crc_end_point.y) # restore the unsplit kurve if len(tags) > 0: offset_curve = area.Curve(copy_of_offset_curve) if use_CRC: end_CRC() # rapid up to the clearance height rapid(z = clearance) del offset_curve if len(tags) > 0: del copy_of_offset_curve
def profile(curve, side_of_line, radius=1.0, vertfeed=0.0, horizfeed=0.0, offset_extra=0.0, rapid_safety_space=None, clearance=None, start_depth=None, stepdown=None, final_depth=None, use_CRC=False, roll_on=None, roll_off=None, roll_start=False, roll_end=True, roll_radius=None, roll_start_pt=None, roll_end_pt=None): output = "" output += "G0 Z" + str(clearance) + "\n" print "in profile: 151" offset_curve = area.Curve(curve) if offset_curve.getNumVertices() <= 1: raise Exception, "Sketch has no elements!" if side_of_line == "On": use_CRC = False elif (side_of_line == "Left") or (side_of_line == "Right"): # get tool radius plus little bit of extra offset, if needed to clean # up profile a little more offset = radius + offset_extra if side_of_line == 'Left': offset_curve.Offset(offset) else: offset_curve.Offset(-offset) if offset_curve is False: raise Exception, "couldn't offset kurve " + str(offset_curve) else: raise Exception, "Side must be 'Left','Right', or 'On'" # ========================================================================= # #roll_on roll_off section # roll_on_curve = area.Curve() # if offset_curve.getNumVertices() <= 1: return # first_span = offset_curve.GetFirstSpan() # if roll_on == None: # rollstart = first_span.p # elif roll_on == 'auto': # if roll_radius < 0.0000000001: # rollstart = first_span.p # v = first_span.GetVector(0.0) # if direction == 'right': # off_v = area.Point(v.y, -v.x) # else: # off_v = area.Point(-v.y, v.x) # rollstart = first_span.p + off_v * roll_radius # else: # rollstart = roll_on # # rvertex = area.Vertex(first_span.p) # # if first_span.p == rollstart: # rvertex.type = 0 # else: # v = first_span.GetVector(0.0) # get start direction # rvertex.c, rvertex.type = area.TangentialArc(first_span.p, rollstart, -v) # rvertex.type = -rvertex.type # because TangentialArc was used in reverse # # add a start roll on point # roll_on_curve.append(rollstart) # # # add the roll on arc # roll_on_curve.append(rvertex) # #end of roll_on roll_off section # ========================================================================= # do multiple depths layer_count = int((start_depth - final_depth) / stepdown) if layer_count * stepdown + 0.00001 < start_depth - final_depth: layer_count += 1 # current_start_depth = start_depth prev_depth = start_depth for i in range(1, layer_count + 1): if i == layer_count: depth = final_depth else: depth = start_depth - i * stepdown mat_depth = prev_depth start_z = mat_depth # first move output += "G0 X" + str(PathUtils.fmt(offset_curve.GetFirstSpan().p.x)) +\ " Y" + str(PathUtils.fmt(offset_curve.GetFirstSpan().p.y)) +\ " Z" + str(PathUtils.fmt(mat_depth + rapid_safety_space)) + "\n" # feed down to depth mat_depth = depth if start_z > mat_depth: mat_depth = start_z # feed down in Z output += "G1 X" + str(PathUtils.fmt(offset_curve.GetFirstSpan().p.x)) +\ " Y" + str(PathUtils.fmt(offset_curve.GetFirstSpan().p.y)) + " Z" + str(PathUtils.fmt(depth)) +\ " F" + str(PathUtils.fmt(vertfeed)) + "\n" if use_CRC: if side_of_line == 'left': output += "G41" + "\n" else: output += "G42" + "\n" # cut the main kurve current_perim = 0.0 lastx = offset_curve.GetFirstSpan().p.x lasty = offset_curve.GetFirstSpan().p.y for span in offset_curve.GetSpans(): current_perim += span.Length() if span.v.type == 0: # line # feed(span.v.p.x, span.v.p.y, ez) output += "G1 X" + str(PathUtils.fmt(span.v.p.x)) + " Y" + str(PathUtils.fmt(span.v.p.y)) +\ " Z" + str(PathUtils.fmt(depth)) + " F" + \ str(PathUtils.fmt(horizfeed)) + "\n" lastx = span.v.p.x lasty = span.v.p.y elif (span.v.type == 1) or (span.v.type == -1): if span.v.type == 1: # anti-clockwise arc command = 'G3' elif span.v.type == -1: # clockwise arc command = 'G2' arc_I = span.v.c.x - lastx arc_J = span.v.c.y - lasty output += command + "X" + str(PathUtils.fmt(span.v.p.x)) + " Y" + str( PathUtils.fmt(span.v.p.y)) # +" Z"+ str(PathUtils.fmt(depth)) output += " I" + str(PathUtils.fmt(arc_I)) + " J" + str(PathUtils.fmt(arc_J)) + " F" + str( PathUtils.fmt(horizfeed)) + '\n' # " K"+str(PathUtils.fmt(depth)) +"\n" lastx = span.v.p.x lasty = span.v.p.y else: raise Exception, "valid geometry identifier needed" if use_CRC: # end_CRC() output += "G40" + "\n" # rapid up to the clearance height output += "G0 Z" + str(PathUtils.fmt(clearance)) + "\n" del offset_curve return output
def load(self, nc_filepath): # this converts the G1s in an NC file into arcs with G2 or G3 pattern_main = re.compile( '([(!;].*|\s+|[a-zA-Z0-9_:](?:[+-])?\d*(?:\.\d*)?|\w\#\d+|\(.*?\)|\#\d+\=(?:[+-])?\d*(?:\.\d*)?)' ) self.lines = [] self.length = 0.0 file = open(nc_filepath, 'r') arc = 0 self.rapid = False curx = None cury = None curz = None while (True): line = file.readline().rstrip() if len(line) == 0: break move = False x = None y = None z = None i = None j = None words = pattern_main.findall(line) for word in words: word = word.upper() if word == 'G1' or word == 'G01': self.rapid = False arc = 0 elif word == 'G2' or word == 'G02': self.rapid = False arc = -1 elif word == 'G3' or word == 'G03': self.rapid = False arc = 1 elif word == 'G0' or word == 'G00': self.rapid = True arc = 0 elif word[0] == 'X': x = eval(word[1:]) move = True elif word[0] == 'Y': y = eval(word[1:]) move = True elif word[0] == 'Z': z = eval(word[1:]) move = True elif word[0] == 'I': i = float(eval(word[1:])) elif word[0] == 'J': j = float(eval(word[1:])) elif word[0] == 'T': self.current_tool = eval(word[1:]) if (curx != None) and (cury != None) and (curz != None): self.add_line(Point(curx, cury, curz), Point(curx, cury, 30.0)) curz = 30.0 elif word[0] == ';': break if move: if (curx != None) and (cury != None) and (curz != None): newx = curx newy = cury newz = curz if x != None: newx = float(x) if y != None: newy = float(y) if z != None: newz = float(z) if arc != 0: area.set_units(0.05) curve = area.Curve() curve.append(area.Point(curx, cury)) # next 4 lines were for Bridgeport. # this only works for LinuxCNC now #if (newx > curx) != (arc > 0): # j = -j #if (newy > cury) != (arc < 0): # i = -i curve.append( area.Vertex(arc, area.Point(newx, newy), area.Point(curx + i, cury + j))) curve.UnFitArcs() for span in curve.GetSpans(): self.add_line(Point(span.p.x, span.p.y, newz), Point(span.v.p.x, span.v.p.y, newz)) else: self.add_line(Point(curx, cury, curz), Point(newx, newy, newz)) if x != None: curx = float(x) if y != None: cury = float(y) if z != None: curz = float(z) for line in self.lines: self.length += line.Length() file.close() self.rewind()
def make_zig_curve(curve, y0, y, zig_unidirectional): if rightward_for_zigs: curve.Reverse() # find a high point to start looking from high_point = None for vertex in curve.getVertices(): if high_point == None: high_point = vertex.p elif vertex.p.y > high_point.y: # use this as the new high point high_point = vertex.p elif math.fabs(vertex.p.y - high_point.y) < 0.002 * one_over_units: # equal high point if rightward_for_zigs: # use the furthest left point if vertex.p.x < high_point.x: high_point = vertex.p else: # use the furthest right point if vertex.p.x > high_point.x: high_point = vertex.p zig = area.Curve() high_point_found = False zig_started = False zag_found = False for i in range( 0, 2 ): # process the curve twice because we don't know where it will start prev_p = None for vertex in curve.getVertices(): if zag_found: break if prev_p != None: if zig_started: zig.append(unrotated_vertex(vertex)) if math.fabs(vertex.p.y - y) < 0.002 * one_over_units: zag_found = True break elif high_point_found: if math.fabs(vertex.p.y - y0) < 0.002 * one_over_units: if zig_started: zig.append(unrotated_vertex(vertex)) elif math.fabs( prev_p.y - y0 ) < 0.002 * one_over_units and vertex.type == 0: zig.append( area.Vertex(0, unrotated_point(prev_p), area.Point(0, 0))) zig.append(unrotated_vertex(vertex)) zig_started = True elif vertex.p.x == high_point.x and vertex.p.y == high_point.y: high_point_found = True prev_p = vertex.p if zig_started: if zig_unidirectional == True: # remove the last bit of zig if math.fabs(zig.LastVertex().p.y - y) < 0.002 * one_over_units: vertices = zig.getVertices() while len(vertices) > 0: v = vertices[len(vertices) - 1] if math.fabs(v.p.y - y0) < 0.002 * one_over_units: break else: vertices.pop() zig = area.Curve() for v in vertices: zig.append(v) curve_list_for_zigs.append(zig)
def makeAreaCurve(edges, direction, startpt=None, endpt=None): curveobj = area.Curve() cleanededges = PathUtils.cleanedges(edges, 0.01) #sort the edges vlist, edgestart, common = PathSelection.Sort2Edges( [cleanededges[0], cleanededges[1]]) if cleanededges[0].valueAt(cleanededges[0].FirstParameter) <> edgestart: firstedge = PathUtils.reverseEdge(cleanededges[0]) else: firstedge = cleanededges[0] edgelist = [] edgelist.append(firstedge) #get start and end points of each edge aligned for e in cleanededges[1:]: if DraftVecUtils.equals(common, e.valueAt(e.FirstParameter)): edgelist.append(e) common = e.valueAt(e.LastParameter) else: newedge = PathUtils.reverseEdge(e) common = newedge.valueAt(newedge.LastParameter) edgelist.append(newedge) curveobj.append(area.Point(edgestart.x, edgestart.y)) # seglist =[] # if direction=='CW': # edgelist.reverse() # for e in edgelist: # seglist.append(PathUtils.reverseEdge(e)) #swap end points on every segment # else: # for e in edgelist: # seglist.append(e) for s in edgelist: curveobj.append(makeAreaVertex(s)) if startpt: # future nearest point code yet to be worked out -fixme # v1 = Vector(startpt.X,startpt.Y,startpt.Z) # perppoint1 = DraftGeomUtils.findPerpendicular(v1,firstedge) # perppoint1 = DraftGeomUtils.findDistance(v1,firstedge) # if perppoint1: # curveobj.ChangeStart(area.Point(perppoint1[0].x,perppoint1[0].y)) # else: # curveobj.ChangeStart(area.Point(startpt.X,startpt.Y)) curveobj.ChangeStart(area.Point(startpt.X, startpt.Y)) if endpt: # future nearest point code yet to be worked out -fixme # v2 = Vector(endpt.X,endpt.Y,endpt.Z) # perppoint2 = DraftGeomUtils.findPerpendicular(v2,lastedge) # if perppoint2: # curveobj.ChangeEnd(area.Point(perppoint2[0].x,perppoint2[0].y)) # else: # curveobj.ChangeEnd(area.Point(endpt.X,endpt.Y)) curveobj.ChangeEnd(area.Point(endpt.X, endpt.Y)) if direction == 'CW': curveobj.Reverse() return curveobj