#!/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 = ('<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)