mightyscape-1.2/extensions/fablabchemnitz/gcode_import/gcode_import.py
2022-11-05 10:41:20 +01:00

673 lines
29 KiB
Python

#!/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))
if not line.startswith(";"):
inkex.utils.debug(results)
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 = ('<svg xmlns="http://www.w3.org/2000/svg"'
' width="{}mm" height="{}mm" viewBox="{} {} {} {}"/>'
).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)