#!/usr/bin/env python3 """ ImportGCode, and Inkscape extension by Nathaniel Klumb This extension adds support for some GCode files to the File/Import... dialog in Inkscape. It loads the GCode file passed to it by Inkscape as a command-line parameter and writes the resulting SVG to stdout (which is how Inkscape input plugins work). This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. """ import re import inkex import sys import argparse from io import StringIO from math import sqrt ,pi, sin, cos, tan, acos, atan2, fabs from lxml import etree class ImportGCode: """ Import a GCode file and process it into an SVG. """ current_id = 0 geometry_error = False def __init__(self,gcode_filename,v_carve=False,laser_mode=False, ignore_z=True,label_z=True, tool_diameter=1.0,v_angle=90.0,v_top=0.0,v_step=1.0): """ Load a GCode file and process it into an SVG. """ self.unit = 1.0 self.ignore_z = ignore_z or v_carve self.label_z = label_z and not v_carve self.tool_diameter = tool_diameter self.v_carve = v_carve self.v_angle = v_angle * pi / 180.0 self.v_top = v_top self.v_step = v_step self.laser_mode = laser_mode self.spindle = False self.speed = 0 with open(gcode_filename) as file: self.loadGCode(file) self.createSVG() def getIJ(self,x1,y1,x2,y2,r): """ Calculate I and J from two arc endpoints and a radius. """ theta = atan2(y2 - y1, x2 - x1) alpha = acos(sqrt((x2 - x1)**2 + (y2 - y1)**2)/(2 * abs(r))) return (r * cos(theta + alpha), r * sin(theta + alpha)) def getTangentPoints(self,x1,y1,r1,x2,y2,r2): """ Compute the four outer tangent endpoints of two circles. """ theta = atan2(y2 - y1, x2 - x1) try: alpha = acos((r1 - r2)/sqrt((x2 - x1)**2 + (y2 - y1)**2)) except ValueError: # It's broken, but we'll just cap it off. # The SVG will be messed up, but that's better feedback # than just blankly saying, "Sorry, please try again." if not self.geometry_error: #Only show the error once. inkex.errormsg('Math error importing V-carve: ' 'V-bit angle too large?') inkex.errormsg(' Check your included angle ' 'setting and try again.') self.geometry_error = True if ((r1 - r2)/sqrt((x2 - x1)**2 + (y2 - y1)**2) < -1): alpha = pi else: alpha = 0 return ((x1 + r1 * cos(theta - alpha), y1 + r1 * sin(theta - alpha)), (x1 + r1 * cos(theta + alpha), y1 + r1 * sin(theta + alpha)), (x2 + r2 * cos(theta + alpha), y2 + r2 * sin(theta + alpha)), (x2 + r2 * cos(theta - alpha), y2 + r2 * sin(theta - alpha))) def intersectLines(self, p1, p2, p3, p4): """ Calculate the intersection of Line(p1,p2) and Line(p3,p4) returns a tuple: (x, y, valid, included) (x, y): the intersection valid: a unique solution exists included: the solution is within both the line segments Segment(p1,p2) and Segment(p3,p4) """ DET_TOLERANCE = 0.00000001 T = 0.00000001 # the first line is pt1 + r*(p2-p1) x1,y1 = p1 x2,y2 = p2 dx1 = x2 - x1 dy1 = y2 - y1 # the second line is p4 + s*(p4-p3) x3,y3 = p3 x4,y4 = p4; dx2 = x4 - x3 dy2 = y4 - y3 # In matrix form: # [ dx1 -dx2 ][ r ] = [ x3-x1 ] # [ dy1 -dy2 ][ s ] = [ y3-y1 ] # # Which can be solved: # [ r ] = _1_ [ -dy2 dx2 ] [ x3-x1 ] # [ s ] = DET [ -dy1 dx1 ] [ y3-y1 ] # # With the deteminant: DET = (-dx1 * dy2 + dy1 * dx2) DET = (-dx1 * dy2 + dy1 * dx2) # If DET is zero, they're parallel if fabs(DET) < DET_TOLERANCE: # If they overlap, either p3 or p4 must be # an included point, so check one, then check the # other. If either falls inside the segment from # p1 to p2, return it as *a* valid intersection. # Otherwise, return the bad news -- no intersection. # # Also, when checking the limits, allow a tolerance, T, # since we're working in floating point. if ((((x3 >= x1 - T) and (x3 <= x2 + T)) or ((x3 <= x1 + T) and (x3 >= x2 - T))) and (((y3 >= y1 - T) and (y3 <= y2 + T)) or ((y3 <= y1 + T) and (y3 >= y2 - T)))): return (x3,y3,False,True) elif ((((x4 >= x1 - T) and (x4 <= x2 + T)) or ((x4 <= x1 + T) and (x4 >= x2 - T))) and (((y4 >= y1 - T) and (y4 <= y2 + T)) or ((y4 <= y1 + T) and (y4 >= y2 - T)))): return (x4,y4,False,True) # NO CONNECTION... *dialtone* else: return (None,None,False,False) # Since the determinant is non-zero, now take the reciprocal. invDET = 1.0/DET # We want to calculate the intersection for each line so we can # average the results together. They should be identical, but # floating-point and rounding error, etc... # Calculate the scalar distances along Line(p1,p2) and Line(p3,p4) r = invDET * (-dy2 * (x3-x1) + dx2 * (y3-y1)) s = invDET * (-dy1 * (x3-x1) + dx1 * (y3-y1)) # Average the intersection's coordinates from the two lines. x = (x1 + r*dx1 + x3 + s*dx2)/2.0 y = (y1 + r*dy1 + y3 + s*dy2)/2.0 # Now one last check to see if the intersection's coordinates are # included within both line segments. included = ((((x >= x1 - T) and (x <= x2 + T)) or ((x <= x1 + T) and (x >= x2 - T))) and (((y >= y1 - T) and (y <= y2 + T)) or ((y <= y1 + T) and (y >= y2 - T))) and (((x >= x3 - T) and (x <= x4 + T)) or ((x <= x3 + T) and (x >= x4 - T))) and (((y >= y3 - T) and (y <= y4 + T)) or ((y <= y3 + T) and (y >= y4 - T)))) return (x,y,True,included) def getRadius(self,Z): """ Compute the radius of a V-bit given a Z coordinate. If the V-bit is above stock top, we just mirror it. Technically, the file's broken, but hey, may as well do something. """ if (self.v_top <= Z): return (Z - self.v_top) * tan(self.v_angle / 2) else: return (self.v_top - Z) * tan(self.v_angle / 2) def getAngle(self,center,point): """ Calculate the angle from a center to a point. """ a = atan2(point[1] - center[1], point[0] - center[0]) return a + ((2*pi) if (a<0.0) else 0) def isLargeAngle(self,center,p1,p2): """ Determine whether the SVG large angle flag should be set. """ a1 = self.getAngle(center,p1) a2 = self.getAngle(center,p2) angle = a1 - a2 if angle < 0: angle += 2 * pi return 1 if (abs(angle) > pi) else 0 def interpolatePoints(self,center,p1,p2): """ Interpolate a set of points along an arc. """ a1 = self.getAngle(center,p1) a2 = self.getAngle(center,p2) angle = a2 - a1 dz = 1.0 * (p2[2]-p1[2]) r = sqrt((center[0] - p1[0])**2 + (center[1] - p1[1])**2) length = r * abs(angle) / pi steps = int(round(length/self.v_step)) points = [] for i in range(1,steps): point = (center[0] + r * cos(a1 + angle*i/steps), center[1] + r * sin(a1 + angle*i/steps), p1[2] + dz*i/steps) points += [point] points += [p2] return points def makeVcarve(self,v_segments): """ Connect multiple V-carve segments into one path. Start on one V-carve segment and chain all the way to the opposite end, then add a switchback and chain all the way back to the beginning. """ vs = v_segments # Move to the starting point. path = 'M {} {} '.format(vs[0][1][0][0],vs[0][1][0][1]) # Initial arc, if it's not a point. if vs[0][0][0][2] > 0: path += ('A {} {} 0 {} {} {} {} ' ).format(vs[0][0][0][2],vs[0][0][0][2], 1 if (vs[0][0][0][2] > vs[0][0][1][2]) else 0, 0,vs[0][1][1][0],vs[0][1][1][1]) # Step through all the segments on the way to the other end. for v in range(len(vs)-1): # Check whether an intersection exists between the two # line segments. If so, use it, otherwise, connect with an arc. x,y,valid,included = self.intersectLines(vs[v][1][1], vs[v][1][2], vs[v+1][1][1], vs[v+1][1][2]) if included: #line segments path += 'L {} {} '.format(x,y) else: path += ('L {} {} A {} {} 0 {} {} {} {} ' ).format(vs[v][1][2][0],vs[v][1][2][1], vs[v][0][1][2],vs[v][0][1][2], self.isLargeAngle(vs[v][0][1], vs[v][1][2], vs[v+1][1][1]), 0,vs[v+1][1][1][0],vs[v+1][1][1][1]) # Connecting line. path += 'L {} {} '.format(vs[len(vs)-1][1][2][0], vs[len(vs)-1][1][2][1]) # Switchback arc, if it's not a point. if vs[len(vs)-1][0][1][2] > 0: path += ('A {} {} 0 {} {} {} {} ' ).format(vs[len(vs)-1][0][1][2],vs[len(vs)-1][0][1][2], 1 if (vs[len(vs)-1][0][1][2] > vs[len(vs)-2][0][0][2]) else 0, 0,vs[len(vs)-1][1][3][0],vs[len(vs)-1][1][3][1]) # Step through all the segments on the way back home. for v in range(len(vs)-1,0,-1): # Check whether an intersection exists between the two # line segments. If so, use it, otherwise, connect with an arc. x,y,valid,included = self.intersectLines(vs[v][1][3], vs[v][1][0], vs[v-1][1][3], vs[v-1][1][0]) if included: #line segments path += 'L {} {} '.format(x,y) else: path += ('L {} {} A {} {} 0 {} {} {} {} ' ).format(vs[v][1][0][0],vs[v][1][0][1], vs[v-1][0][1][2],vs[v-1][0][1][2], self.isLargeAngle(vs[v-1][0][1], vs[v][1][0], vs[v-1][1][3]), 0,vs[v-1][1][3][0],vs[v-1][1][3][1]) # And finally, close the curve. path += 'Z' return path def getVsegment(self,x1,y1,z1,x2,y2,z2): """ Compute the required data to define a V-carve segment. """ r1 = self.getRadius(z1) r2 = self.getRadius(z2) p = self.getTangentPoints(x1,y1,r1,x2,y2,r2) return (((x1,y1,r1),(x2,y2,r2)),p) def parseLine(self,command,X,Y,Z,line,no_path=False): """ Parse a line of G-code. This takes the current coordinates and modal command, then processes the new line of G-code to yield a new ending set of coordinates plus values necessary for curve computations. It also returns the resulting path data, unless otherwise indicated, e.g. for V-carves. """ comments = re.compile('\([^\)]*\)') commands = re.compile('([MSGXYZIJKR])([-.0-9]+)') lastX = X lastY = Y lastZ = Z I = 0.0 J = 0.0 K = 0.0 R = None results = commands.findall(comments.sub('',line)) for (code,val) in results: v = float(val) i = int(v) if code == 'M': if i == 3: self.spindle = True elif i == 5: self.spindle = False elif code == 'S': self.speed = v elif code == 'G': if i == 0: command = 'G0' elif i == 1: command = 'G1' elif i == 2: command = 'G2' elif i == 3: command = 'G3' elif i == 20: self.unit = 25.4 elif i == 21: self.unit = 1.0 elif val == "90": self.absolute = True elif val == "91": self.absolute = False elif val == "90.1": self.absoluteIJK = True elif val == "91.1": self.absoluteIJK = False elif code == 'X': if self.absolute: X = v * self.unit else: X += v * self.unit elif code == 'Y': if self.absolute: Y = v * self.unit else: Y += v * self.unit elif code == 'Z': if self.absolute: Z = v * self.unit else: Z += v * self.unit elif code == 'I': I = v * self.unit if self.absoluteIJK: I -= X elif code == 'J': J = v * self.unit if self.absoluteIJK: J -= Y elif code == 'K': # Sure, process it, but we don't *do* anything with K. K = v * self.unit if self.absoluteIJK: K -= Z elif code == 'R': R = v * self.unit if no_path: # V-carving doesn't need any path data. return ((command, X, Y, Z, I, J, K, R, '')) # The line's been parsed. Now let's generate path data from it. path = '' if command == 'G1': # If there's any XY motion, make a line segment. if ((X != lastX) or (Y != lastY)): path = 'L {} {} '.format(round(X,5),round(Y,5)) elif (command == 'G2') or (command == 'G3'): # Arcs! Oh, what glorious fun we'll have! First, sweep direction. sweep = 0 if (command == 'G2') else 1 # R overrules I and J if both are present, so we compute # new I and J values based on R. We need those to determine # whether the Large Angle Flag needs to be set. if R is not None: I,J = self.getIJ(lastX,lastY,X,Y,R) if (I != 0.0) or (J != 0.0): if sweep == 0: large_arc = self.isLargeAngle((lastX+I,lastY+J), (lastX,lastY),(X,Y)) else: large_arc = self.isLargeAngle((lastX+I,lastY+J), (X,Y),(lastX,lastY)) radius = sqrt(I**2 + J**2) path = 'A {} {} 0 {} {} {} {} '.format(round(radius,5), round(radius,5), large_arc,sweep, round(X,5),round(Y,5)) # No R, and no I or J either? Let's just call it a line segment. # (It may have had a K, but we don't believe in K for SVG imports.) else: path = 'L {} {} '.format(round(X,5),round(Y,5)) # In laser mode, if the spindle isn't active or the speed is zero, # there's no lasing to be had. Drop the path data. (The Inkscape # extension from J Tech Photonics uses G1/G2/G3 moves throughout, # with nary a G0, so if we don't do this, we'll show unlasered paths.) if (self.laser_mode and ((not self.spindle) or (self.speed == 0))): path = '' return ((command, X, Y, Z, I, J, K, R, path)) def savePath(self,path,Z): """ Save a set of path data, filing it by Z if appropriate. """ if (path.find('A') == -1) and (path.find('L') == -1): return #empty path if self.ignore_z: if path not in self.paths: self.paths.add(path) else: try: if path not in self.paths_by_z[Z]: self.paths_by_z[Z].add(path) except KeyError: self.paths_by_z[Z] = set([path]) def loadGCode(self,gcode_file): """ Load a G-code file, handling the contents. """ if self.ignore_z: self.paths = set([]) else: self.paths_by_z = {} self.absolute = True self.absoluteIJK = False self.unit=1.0 command = '' X = 0.0 Y = 0.0 Z = 0.0 lastX = X lastY = Y lastZ = Z self.minX = 0.0 self.minY = 0.0 self.minZ = 0.0 self.maxX = 0.0 self.maxY = 0.0 self.maxZ = 0.0 path = '' line = gcode_file.readline() v_segments = [] while line: command,X,Y,Z,I,J,K,R,path_data = self.parseLine(command, X, Y, Z, line, self.v_carve) self.minX = X if X < self.minX else self.minX self.maxX = X if X > self.maxX else self.maxX self.minY = Y if Y < self.minY else self.minY self.maxY = Y if Y > self.maxY else self.maxY self.minZ = Z if Z < self.minZ else self.minZ self.maxZ = Z if Z > self.maxZ else self.maxZ # V-carve mode. if self.v_carve: if (lastX != X) or (lastY != Y): if command == 'G1': v_segments += [self.getVsegment(lastX, lastY, lastZ, X, Y, Z)] elif (command == 'G2') or (command == 'G3'): # We don't attempt to handle the plethora of curves # that can result from V-carving arcs. Instead, we # just interpolate them and process the subparts. points = self.interpolatePoints((lastX+I,lastY+J), (lastX,lastY,lastZ), (X,Y,Z)) iX = lastX iY = lastY iZ = lastZ for p in points: v_segments += [self.getVsegment(iX, iY, iZ, p[0], p[1], p[2])] iX = p[0] iY = p[1] iZ = p[2] else: if len(v_segments): self.savePath(self.makeVcarve(v_segments),'VCarve') v_segments = [] # Standard mode (non-V-carve). else: if ((command == 'G0') or (not self.ignore_z and (Z != lastZ)) or (self.laser_mode and ((not self.spindle) or (self.speed == 0)))): if (path != ''): self.savePath(path,lastZ) path = '' if (((command == 'G1') or (command == 'G2') or (command == 'G3')) and (path == '')): path = 'M {} {} {}'.format(lastX,lastY,path_data) else: path += path_data lastX = X lastY = Y lastZ = Z line = gcode_file.readline() # Always remember to save the tail end of your work. if self.v_carve: if len(v_segments): self.savePath(self.makeVcarve(v_segments),'VCarve') else: if (path != ''): self.savePath(path,lastZ) def filterPaths(self): """ Filter out duplicate paths, leaving only the deepest instance. """ if self.ignore_z: return z_depths = sorted(self.paths_by_z,None,None,True) for i in range(0,len(z_depths)): for j in range(i+1, len(z_depths)): self.paths_by_z[z_depths[i]] -= self.paths_by_z[z_depths[j]] def next_id(self): """ Return an incrementing value. """ self.current_id += 1 return self.current_id def getStyle(self,color='#000000',width=None): """ Create a CSS-type style string. """ if width is None: width = self.tool_diameter return ('opacity:1;vector-effect:none;fill:none;fill-opacity:1;' 'stroke:{};stroke-width:{};stroke-opacity:1;' 'stroke-linecap:round;stroke-linejoin:round;' 'stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0' ).format(color,width) def createSVG(self): """ Create the output SVG. """ base = ('' ).format(self.maxX-self.minX, self.maxY-self.minY, self.minX, self.minY, self.maxX-self.minX, self.maxY-self.minY) self.doc = etree.parse(StringIO((base))) svg = self.doc.getroot() # Since G-code and SVG interpret Y in opposite directions, # we just group everything under a transform that mirrors Y. svg = etree.SubElement(svg,'g',{'id':'gcode', 'transform':'scale(1,-1)'}) # Add illustrative axes to the SVG to facilitate positioning. etree.SubElement(svg,'path', {'d':'M 0 {} V {}'.format(self.minY, self.maxY), 'style':self.getStyle('#00ff00',0.5), 'id':'vertical'}) etree.SubElement(svg,'path', {'d':'M {} 0 H {}'.format(self.minX, self.maxX), 'style':self.getStyle('#ff0000',0.5), 'id':'horizontal'}) # For V-carves, include the paths and use a narrow stroke width. if self.v_carve: for path in self.paths: etree.SubElement(svg,'path', {'d':path, 'style':self.getStyle(width=0.1), 'id':'path{}'.format(self.next_id())}) # For standard mode with Z ignored, include the paths. elif self.ignore_z: for path in self.paths: etree.SubElement(svg,'path', {'d':path, 'style':self.getStyle(), 'id':'path{}'.format(self.next_id())}) # For standard mode with Z grouping, filter the paths, # then add each group of paths (and optionally, labels). else: self.filterPaths() z_depths = sorted(self.paths_by_z) depth_num = 0 for i in range(0,len(z_depths)): if len(self.paths_by_z[z_depths[i]]): params = {'id':('group{}-{}' ).format(self.next_id(),z_depths[i]), 'style':self.getStyle()} group = etree.SubElement(svg,'g',params) # If labels are enabled, add the label to the group. if self.label_z: params = {'x':'{}'.format(self.maxX), 'y':'{}'.format(depth_num*-5), 'transform':'scale(1,-1)', 'id':'text{}'.format(i), 'style':('opacity:1;fill:#0000ff;' 'fill-opacity:1;stroke:none;' 'font-size:4.5')} if self.unit == 1.0: label = '{} mm'.format(z_depths[i]) else: label = '{} in'.format(z_depths[i]/self.unit) etree.SubElement(group,'text',params ).text = label depth_num += 1 # Now add the paths to the group. for path in self.paths_by_z[z_depths[i]]: id = 'path{}'.format(self.next_id()) etree.SubElement(group,'path', {'d':path, 'style':self.getStyle(), 'id':id}) # If labels are enabled, label the labels. if self.label_z: etree.SubElement(svg,'text', {'x':'{}'.format(self.maxX), 'y':'{}'.format(depth_num*-5), 'transform':'scale(1,-1)', 'id':'text{}'.format(i), 'style':('opacity:1;fill:#0000ff;' 'fill-opacity:1;stroke:none;' 'font-size:4.5')} ).text = 'Z Groups:' # And now for the code to allow Inkscape to run our lovely extension. if __name__ == '__main__': parser = argparse.ArgumentParser(description=('usage: %prog [options] GCodeFile')) parser.add_argument('-m', '--mode', help='Mode: vcarve, standard, laser', default='standard') parser.add_argument('-a', '--v_angle', help='Included (full) angle for V-bit, in degrees.', default=None) parser.add_argument('-t', '--v_top', help='Stock top (usually zero)', default=None) parser.add_argument('-s', '--v_step', help='Step size for curve interpolation.', default=None) parser.add_argument('-d', '--tool_diameter', help='Tool diameter / path width.', default=None) parser.add_argument('-u', '--units', help='Dialog units.', default='mm') parser.add_argument('-z', '--z_axis', help='Z-axis: ignore,group,label', default=False) parser.add_argument('--tab') parser.add_argument('--inputhelp') parser.add_argument('inputfile') # Now, process, my lovelies! args = parser.parse_args() # First steps first, what mode? v_carve = False ignore_z = False laser_mode = False if (args.mode == 'vcarve'): v_carve = True elif (args.mode == 'laser'): laser_mode = True # V-carve parameters. try: v_angle = round(float(args.v_angle),3) except ValueError: v_angle = 1.0 try: v_top = round(float(args.v_top) * (25.4 if (args.units == 'in') else 1.0),5) except ValueError: v_top = 0.0 try: v_step = round(float(args.v_step) * (25.4 if (args.units == 'in') else 1.0),5) except ValueError: v_step = 1.0 # Standard parameters. try: diameter = round(float(args.tool_diameter) * (25.4 if (args.units == 'in') else 1.0),3) except ValueError: diameter = 1.0 # General args. ignore_z = (args.z_axis == 'ignore') label_z = (args.z_axis == 'label') gc = ImportGCode(args.inputfile, v_carve, laser_mode, ignore_z, label_z, diameter, v_angle, v_top, v_step) gc.doc.write(sys.stdout.buffer)