gcodeplot.py

#!/usr/bin/python
from __future__ import print_function
import re
import sys
import getopt
import math
import xml.etree.ElementTree as ET
import gcodeplotutils.anneal as anneal
import svgpath.parser as parser
import cmath
from random import sample
from svgpath.shader import Shader
from gcodeplotutils.processoffset import OffsetProcessor
from gcodeplotutils.evaluate import evaluate

SCALE_NONE = 0
SCALE_DOWN_ONLY = 1
SCALE_FIT = 2
ALIGN_NONE = 0
ALIGN_BOTTOM = 1
ALIGN_TOP = 2
ALIGN_LEFT = ALIGN_BOTTOM
ALIGN_RIGHT = ALIGN_TOP
ALIGN_CENTER = 3

class Plotter(object):
    def __init__(self, xyMin=(7,8), xyMax=(204,178),
            drawSpeed=35, moveSpeed=40, zSpeed=5, workZ = 14.5, liftDeltaZ = 2.5, safeDeltaZ = 20,
            liftCommand=None, safeLiftCommand=None, downCommand=None, comment=";",
            initCode = "G00 S1; endstops|"
                       "G00 E0; no extrusion|"
                       "G01 S1; endstops|"
                       "G01 E0; no extrusion|"
                       "G21; millimeters|"
                       "G91 G0 F%.1f{{zspeed*60}} Z%.3f{{safe}}; pen park !!Zsafe|"
                       "G90; absolute|"
                       "G28 X; home|"
                       "G28 Y; home|"
                       "G28 Z; home",
            endCode=None):
        self.xyMin = xyMin
        self.xyMax = xyMax
        self.drawSpeed = drawSpeed
        self.moveSpeed = moveSpeed
        self.workZ = workZ
        self.liftDeltaZ = liftDeltaZ
        self.safeDeltaZ = safeDeltaZ
        self.zSpeed = zSpeed
        self.liftCommand = liftCommand
        self.safeLiftCommand = safeLiftCommand
        self.downCommand = downCommand
        self.initCode = initCode
        self.endCode = endCode
        self.comment = comment

    def inRange(self, point):
        for i in range(2):
            if point[i] < self.xyMin[i]-.001 or point[i] > self.xyMax[i]+.001:
                return False
        return True

    @property
    def safeUpZ(self):
        return self.workZ + self.safeDeltaZ

    @property
    def penUpZ(self):
        return self.workZ + self.liftDeltaZ
        
    def updateVariables(self):
        self.variables = {'lift':self.liftDeltaZ, 'work':self.workZ, 'safe':self.safeDeltaZ, 'left':self.xyMin[0],
            'bottom':self.xyMin[1], 'zspeed':self.zSpeed, 'movespeed':self.moveSpeed}
        self.formulas = {'right':str(self.xyMax[0]), 'top':str(self.xyMax[1]), 'up':'work+lift', 'park':'work+safe', 'centerx':'(left+right)/2.', 'centery':'(top+bottom)/2.'}

def processCode(code):
    if not code:
        return []

    data = []
    pattern = r'\{\{([^}]+)\}\}'
    
    data = tuple( evaluate(expr, plotter.variables, plotter.formulas) for expr in re.findall(pattern, code))

        
    formatString = re.sub(pattern, '', code.replace('|', '\n'))
    
    return [formatString % data]
        
def gcodeHeader(plotter):
    return processCode(plotter.initCode)

def isSameColor(rgb1, rgb2):
    if rgb1 is None or rgb2 is None:
        return rgb1 is rgb2
    return max(abs(rgb1[i]-rgb2[i]) for i in range(3)) < 0.001

class Pen(object):
    def __init__(self, text):
        text = re.sub(r'\s+', r' ', text.strip())
        self.description = text
        data = text.split(' ', 4)
        if len(data) < 3:
            raise ValueError('Pen parsing error')
        if len(data) < 4:
            data.append('')
        self.pen = int(data[0])
        self.offset = tuple(map(float, re.sub(r'[()]',r'',data[1]).split(',')))
        self.color = parser.rgbFromColor(data[2])
        self.name = data[3]

class Scale(object):
    def __init__(self, scale=(1.,1.), offset=(0.,0.)):
        self.offset = offset
        self.scale = scale

    def clone(self):
        return Scale(scale=[self.scale[0],self.scale[1]], offset=[self.offset[0],self.offset[1]])

    def __repr__(self):
        return str(self.scale)+','+str(self.offset)

    def fit(self, plotter, xyMin, xyMax):
        s = [0,0]
        o = [0,0]
        for i in range(2):
            delta = xyMax[i]-xyMin[i]
            if delta == 0:
                s[i] = 1.
            else:
                s[i] = (plotter.xyMax[i]-plotter.xyMin[i]) / delta
        self.scale = [min(s),min(s)]
        self.offset = list(plotter.xyMin[i] - xyMin[i]*self.scale[i] for i in range(2))

    def align(self, plotter, xyMin, xyMax, align):
        o = [0,0]
        for i in range(2):
            if align[i] == ALIGN_LEFT:
                o[i] = plotter.xyMin[i] - self.scale[i]*xyMin[i]
            elif align[i] == ALIGN_RIGHT:
                o[i] = plotter.xyMax[i] - self.scale[i]*xyMax[i]
            elif align[i] == ALIGN_NONE:
                o[i] = self.offset[i] # self.xyMin[i]
            elif align[i] == ALIGN_CENTER:
                o[i] = 0.5 * (plotter.xyMin[i] - self.scale[i]*xyMin[i] + plotter.xyMax[i] - self.scale[i]*xyMax[i])
            else:
                raise ValueError()
        self.offset = o

    def scalePoint(self, point):
        return (point[0]*self.scale[0]+self.offset[0], point[1]*self.scale[1]+self.offset[1])

def comparison(a,b):
    return 1 if a>b else (-1 if a<b else 0)

def safeSorted(data,comparison=comparison):
    """
    A simpleminded recursive merge sort that will work even if the comparison function fails to be a partial order.
    Makes (shallow) copies of the data, which uses more memory than is absolutely necessary. In the intended application,
    the comparison function is very expensive but the number of data points is small.
    """
    n = len(data)
    if n <= 1:
        return list(data)
    d1 = safeSorted(data[:n//2],comparison=comparison)
    d2 = safeSorted(data[n//2:],comparison=comparison)
    i1 = 0
    i2 = 0
    out = []
    while i1 < len(d1) and i2 < len(d2):
        if comparison(d1[i1], d2[i2]) < 0:
            out.append(d1[i1])
            i1 += 1
        else:
            out.append(d2[i2])
            i2 += 1
    if i1 < len(d1):
        out += d1[i1:]
    elif i2 < len(d2):
        out += d2[i2:]
    return out

def comparePaths(path1,path2,tolerance=0.05,pointsToCheck=3):
    """
    inner paths come before outer ones
    closed paths come before open ones
    otherwise, average left to right movement
    """

    def fixPath(path):
        out = [complex(point[0],point[1]) for point in path]
        if out[0] != out[-1] and abs(out[0]-out[-1]) <= tolerance:
            out.append(out[0])
        return out

    def closed(path):
        return path[-1] == path[0]

    def inside(z, path):
        for p in path:
            if p == z:
                return False
        try:
            phases = sorted((cmath.phase(p-z) for p in path))
            # make a ray that is relatively far away from any points
            if len(phases) == 1:
                # should not happen
                bestPhase = phases[0] + math.pi
            else:
                bestIndex = max( (phases[i+1]-phases[i],i) for i in range(len(phases)-1))[1]
                bestPhase = (phases[bestIndex+1]+phases[bestIndex])/2.
            ray = cmath.rect(1., bestPhase)
            rotatedPath = tuple((p-z) / ray for p in path)
            # now we just need to check shiftedPath's intersection with the positive real line
            s = 0
            for i,p2 in enumerate(rotatedPath):
                p1 = rotatedPath[i-1]
                if p1.imag == p2.imag:
                    # horizontal lines can't intersect positive real line once phase selection was done
                    continue
                    # (1/m)y + xIntercept = x
                reciprocalSlope = (p2.real-p1.real)/(p2.imag-p1.imag)
                xIntercept = p2.real - reciprocalSlope * p2.imag
                if xIntercept == 0:
                    return False # on boundary
                if p1.imag * p2.imag < 0 and xIntercept > 0:
                    if p1.imag < 0:
                        s += 1
                    else:
                        s -= 1
            return s != 0

        except OverflowError:
            return False

    def nestedPaths(path1, path2):
        if not closed(path2):
            return False
        k = min(pointsToCheck, len(path1))
        for point in sample(path1, k):
            if inside(point, path2):
                return True
        return False

    path1 = fixPath(path1)
    path2 = fixPath(path2)

    if nestedPaths(path1, path2):
        return -1
    elif nestedPaths(path2, path1):
        return 1
    elif closed(path1) and not closed(path2):
        return -1
    elif closed(path2) and not closed(path1):
        return 1
    x1 = sum(p.real for p in path1) / len(path1)
    x2 = sum(p.real for p in path2) / len(path2)
    return comparison(x1,x2)

def removePenBob(data):
    """
    Merge segments with same beginning and end
    """

    outData = {}

    for pen in data:
        outSegments = []
        outSegment = []

        for segment in data[pen]:
            if not outSegment:
                outSegment = list(segment)
            elif outSegment[-1] == segment[0]:
                outSegment += segment[1:]
            else:
                outSegments.append(outSegment)
                outSegment = list(segment)

        if outSegment:
            outSegments.append(outSegment)

        if outSegments:
            outData[pen] = outSegments

    return outData

def dedup(data):
    curPoint = None

    def d2(a,b):
        return (a[0]-b[0])**2+(a[1]-b[1])**2

    newData = {}

    for pen in data:
        newSegments = []
        newSegment = []
        draws = set()

        for segment in data[pen]:
            newSegment = [segment[0]]
            for i in range(1,len(segment)):
                draw = (segment[i-1], segment[i])
                if draw in draws or (segment[i], segment[i-1]) in draws:
                    if len(newSegment)>1:
                        newSegments.append(newSegment)
                    newSegment = [segment[i]]
                else:
                    draws.add(draw)
                    newSegment.append(segment[i])
            if newSegment:
                newSegments.append(newSegment)

        if newSegments:
            newData[pen] = newSegments

    return removePenBob(newData)

def describePen(pens, pen):
    if pens is not None and pen in pens:
        return pens[pen].description
    else:
        return str(pen)

def penColor(pens, pen):
    if pens is not None and pen in pens:
        return pens[pen].color
    else:
        return (0.,0.,0.)

def emitGcode(data, pens = {}, plotter=Plotter(), scalingMode=SCALE_NONE, align = None, tolerance=0, gcodePause="@pause", pauseAtStart = False, simulation = False, relCode = False, incHoming = True):
    if len(data) == 0:
        return None

    xyMin = [float("inf"),float("inf")]
    xyMax = [float("-inf"),float("-inf")]

    allFit = True

    scale = Scale()
    scale.offset = (plotter.xyMin[0],plotter.xyMin[1])

    for pen in data:
        for segment in data[pen]:
            for point in segment:
                if not plotter.inRange(scale.scalePoint(point)):
                    allFit = False
                for i in range(2):
                    xyMin[i] = min(xyMin[i], point[i])
                    xyMax[i] = max(xyMax[i], point[i])

    if scalingMode == SCALE_NONE:
        if not allFit:
            sys.stderr.write("Drawing out of range: "+str(xyMin)+" "+str(xyMax)+"\n")
            return None
    elif scalingMode != SCALE_DOWN_ONLY or not allFit:
        if xyMin[0] > xyMax[0]:
            return None
        scale = Scale()
        scale.fit(plotter, xyMin, xyMax)

    if align is not None:
        scale.align(plotter, xyMin, xyMax, align)

    if not simulation:
        gcode = gcodeHeader(plotter)
    else:
        gcode = []
        gcode.append('<?xml version="1.0" standalone="yes"?>')
        gcode.append('<svg width="%.4fmm" height="%.4fmm" viewBox="%.4f %.4f %.4f %.4f" xmlns="http://www.w3.org/2000/svg" version="1.1">' % (
            plotter.xyMax[0]-plotter.xyMin[0], plotter.xyMax[1]-plotter.xyMin[0], plotter.xyMin[0], plotter.xyMin[1], plotter.xyMax[0], plotter.xyMax[1]))
            
            
    def park():
        if not simulation:
            lift = plotter.safeLiftCommand or plotter.liftCommand
            if lift:
                gcode.extend(processCode(lift))
            else:
                if relCode:
                    gcode.append('G90 ;Absolute mode for Z movement')
                gcode.append('G00 F%.1f Z%.3f; pen park !!Zpark' % (plotter.zSpeed*60., plotter.safeUpZ))
                if relCode:
                    gcode.append('G91 ;Relative mode for XY movement')

    park()
    if relCode:
        gcode.append('G91 ;Relative mode for XY movement')
    if not simulation:
        gcode.append('G00 F%.1f Y%.3f; !!Ybottom' % (plotter.moveSpeed*60.,   plotter.xyMin[1]))
        gcode.append('G00 F%.1f X%.3f; !!Xleft' % (plotter.moveSpeed*60.,   plotter.xyMin[0]))

    class State(object):
        pass

    state = State()
    state.time = (plotter.xyMin[1]+plotter.xyMin[0]) / plotter.moveSpeed
    state.curXY = plotter.xyMin
    state.curZ = plotter.safeUpZ
    state.penColor = (0.,0.,0.)

    def distance(a,b):
        return math.hypot(a[0]-b[0],a[1]-b[1])

    def penUp(force=False):
        if state.curZ is None or state.curZ not in (plotter.safeUpZ, plotter.penUpZ) or force:
            if not simulation:
                if plotter.liftCommand:
                    gcode.extend(processCode(plotter.liftCommand))
                else:
                    gcode.append('G00 F%.1f Z%.3f; pen up !!Zup' % (plotter.zSpeed*60., plotter.penUpZ))
            if state.curZ is not None:
                state.time += abs(plotter.penUpZ-state.curZ) / plotter.zSpeed
            state.curZ = plotter.penUpZ

    def penDown(force=False):
        if state.curZ is None or state.curZ != plotter.workZ or force:
            if not simulation:
                if plotter.downCommand:
                    gcode.extend(processCode(plotter.downCommand))
                else:
                    if relCode:
                        gcode.append('G90 ;Absolute mode for Z movement')
                    gcode.append('G00 F%.1f Z%.3f; pen down !!Zwork' % (plotter.zSpeed*60., plotter.workZ))
                    if relCode:
                        gcode.append('G91 ;Relavite mode for XY-movement')
            state.time += abs(state.curZ-plotter.workZ) / plotter.zSpeed
            state.curZ = plotter.workZ

    def penMove(down, speed, p, force=False):
        def flip(y):
            return plotter.xyMax[1] - (y-plotter.xyMin[1])
        if state.curXY is None:
            d = float("inf")
        else:
            d = distance(state.curXY, p)
        if d > tolerance or force:
            if down:
                penDown(force=force)
            else:
                penUp(force=force)
            if not simulation:
                x = p[0]
                y = p[1]
                if relCode:
                    x -= state.curXY[0]
                    y -= state.curXY[1]
                gcode.append('G0%d F%.1f X%.3f Y%.3f; %s !!Xleft+%.3f Ybottom+%.3f' % (
                    1 if down else 0, speed*60., x, y, "draw" if down else "move",
                    p[0]-plotter.xyMin[0], p[1]-plotter.xyMin[1]))
            else:
                start = state.curXY if state.curXY is not None else plotter.xyMin
                color = [int(math.floor(255*x+0.5)) for x in (state.penColor if down else (0,0.5,0))]
                thickness = 0.15 if down else 0.1
                end = complex(p[0], flip(p[1]))
                gcode.append('<line x1="%.3f" y1="%.3f" x2="%.3f" y2="%.3f" stroke="rgb(%d,%d,%d)" stroke-width="%.2f"/>'
                    % (start[0], flip(start[1]), end.real, end.imag, color[0], color[1], color[2], thickness))
                ray = end - complex(start[0],flip(start[1]))
                if abs(ray)>0:
                    ray = ray/abs(ray)
                    for theta in [math.pi * 0.8,-math.pi * 0.8]:
                        head = end + ray * cmath.rect(max(0.3,min(2,d*0.25)), theta)
                        gcode.append('<line x1="%.3f" y1="%.3f" x2="%.3f" y2="%.3f" stroke="rgb(0,128,0)" stroke-linejoin="round" stroke-width="0.1"/>'
                            % (end.real, end.imag, head.real, head.imag))

            if state.curXY is not None:
                state.time += d / speed
            state.curXY = p

    for pen in sorted(data):
        if pen != 1:
            state.curZ = None
            state.curXY = None

        state.penColor = penColor(pens, pen)

        s = scale.clone()

        if pens is not None and pen in pens:
            s.offset = (s.offset[0]-pens[pen].offset[0],s.offset[1]-pens[pen].offset[1])

        newPen = True

        for segment in data[pen]:
            penMove(False, plotter.moveSpeed, s.scalePoint(segment[0]))

            if newPen and (pen != 1 or pauseAtStart) and not simulation:
                gcode.append( gcodePause+' load pen: ' + describePen(pens,pen) )
                penMove(False, plotter.moveSpeed, s.scalePoint(segment[0]), force=True)
            newPen = False

            for i in range(1,len(segment)):
                penMove(True, plotter.drawSpeed, s.scalePoint(segment[i]))

    park()

    if simulation:
        gcode.append('</svg>')
    else:
        gcode.extend(processCode(plotter.endCode))

    if not quiet:
        sys.stderr.write('Estimated printing time: %dm %.1fs\n' % (state.time // 60, state.time % 60))
        sys.stderr.flush()

    return gcode

def parseHPGL(hpgl,dpi=(1016.,1016.)):
    try:
        scale = (25.4/dpi[0], 25.4/dpi[1])
    except:
        scale = (25.4/dpi, 25.4/dpi)

    segment = []
    pen = 1
    data = {pen:[]}

    for cmd in re.sub(r'\s', r'', hpgl).split(';'):
        if cmd.startswith('PD'):
            try:
                coords = list(map(float, cmd[2:].split(',')))
                for i in range(0,len(coords),2):
                    segment.append((coords[i]*scale[0], coords[i+1]*scale[1]))
            except:
                pass
                # ignore no-movement PD/PU
        elif cmd.startswith('PU'):
            try:
                if segment:
                    data[pen].append(segment)
                coords = list(map(float, cmd[2:].split(',')))
                segment = [(coords[-2]*scale[0], coords[-1]*scale[1])]
            except:
                pass
                # ignore no-movement PD/PU
        elif cmd.startswith('SP'):
            if segment:
                data[pen].append(segment)
                segment = []
                pen = int(cmd[2:])
                if pen not in data:
                    data[pen] = []
        elif cmd.startswith('IN'):
            pass
        elif len(cmd) > 0:
            sys.stderr.write('Unknown command '+cmd[:2]+'\n')

    if segment:
        data[pen].append(segment)

    return data

def emitHPGL(data, pens=None):
    def hpglCoordinates(offset,point):
        x = (point[0]-offset[0]) * 1016. / 25.4
        y = (point[1]-offset[1]) * 1016. / 25.4
        return str(int(round(x)))+','+str(int(round(y)))

    hpgl = []
    hpgl.append('IN')
    for pen in sorted(data):
        if pens is not None and pen in pens:
            offset = pens[pen].offset
        else:
            offset = (0.,0.)
        hpgl.append('SP'+str(pen))
        for segment in data[pen]:
            hpgl.append('PU'+hpglCoordinates(offset,segment[0]))
            for i in range(1,len(segment)):
                hpgl.append('PD'+hpglCoordinates(offset,segment[i]))
    hpgl.append('PU')
    hpgl.append('')
    return ';'.join(hpgl)

def getPen(pens, color):
    if pens is None:
        return 1

    if color is None:
        color = (0.,0.,0.)

    bestD2 = 10
    bestPen = 1

    for p in pens:
        c = pens[p].color
        d2 = (c[0]-color[0])**2+(c[1]-color[1])**2+(c[2]-color[2])**2
        if d2 < bestD2:
            bestPen = p
            bestD2 = d2

    return bestPen

def parseSVG(svgTree, tolerance=0.05, shader=None, strokeAll=False, pens=None, extractColor = None):
    data = {}
    for path in parser.getPathsFromSVG(svgTree)[0]:
        lines = []

        stroke = strokeAll or (path.svgState.stroke is not None and (extractColor is None or isSameColor(path.svgState.stroke, extractColor)))

        strokePen = getPen(pens, path.svgState.stroke)

        if strokePen not in data:
            data[strokePen] = []

        for line in path.linearApproximation(error=tolerance):
            if stroke:
                data[strokePen].append([(line.start.real,line.start.imag),(line.end.real,line.end.imag)])
            lines.append((line.start, line.end))
        if not data[strokePen]:
            del data[strokePen]

        if shader is not None and shader.isActive() and path.svgState.fill is not None and (extractColor is None or
                isSameColor(path.svgState.fill, extractColor)):
            pen = getPen(pens, path.svgState.fill)

            if pen not in data:
                data[pen] = []

            grayscale = sum(path.svgState.fill) / 3.
            mode = Shader.MODE_NONZERO if path.svgState.fillRule == 'nonzero' else Shader.MODE_EVEN_ODD
            if path.svgState.fillOpacity is not None:
                grayscale = grayscale * path.svgState.fillOpacity + 1. - path.svgState.fillOpacity # TODO: real alpha!
            fillLines = shader.shade(lines, grayscale, avoidOutline=(path.svgState.stroke is None or strokePen != pen), mode=mode)
            for line in fillLines:
                data[pen].append([(line[0].real,line[0].imag),(line[1].real,line[1].imag)])

            if not data[pen]:
                del data[pen]

    return data

def getConfigOpts(filename):
    opts = []
    with open(filename) as f:
        for line in f:
            l = line.strip()
            if len(l) and l[0] != '#':
                entry = l.split('=', 2)
                opt = entry[0]
                if len(opt) == 1:
                    opt = '-' + opt
                elif opt[0] != '-':
                    opt = '--' + opt
                if len(entry) > 1:
                    arg = entry[1]
                    if arg[0] in ('"', "'"):
                        arg = arg[1:-1]
                else:
                    arg = None
                opts.append( (opt,arg) )
    return opts

def directionalize(paths, angle, tolerance=1e-10):
    vector = (math.cos(angle * math.pi / 180.), math.sin(angle * math.pi / 180.))

    outPaths = []
    for path in paths:
        startIndex = 0
        prevPoint = path[0]
        canBeForward = True
        canBeReversed = True
        i = 1
        while i < len(path):
            curVector = (path[i][0]-prevPoint[0],path[i][1]-prevPoint[1])
            if curVector[0] or curVector[1]:
                dotProduct = curVector[0]*vector[0] + curVector[1]*vector[1]
                if dotProduct > tolerance:
                    if not canBeForward:
                        outPaths.append(list(reversed(path[startIndex:i])))
                        startIndex = i-1
                        canBeForward = True
                    canBeReversed = False
                elif dotProduct < -tolerance:
                    if not canBeReversed:
                        outPaths.append(path[startIndex:i])
                        startIndex = i-1
                        canBeReversed = True
                    canBeForward = False
                prevPoint = path[i]
            i += 1
        if canBeForward:
            outPaths.append(path[startIndex:i])
        else:
            outPaths.append(list(reversed(path[startIndex:i])))

    return outPaths

def fixComments(plotter, data, comment = ";"):
    if comment == ";":
        return data
    out = []
    for command in data:
        for line in command.split('\n'):
            try:
                ind = line.index(";")
                if ind >= 0:
                    if not comment:
                        out.append( line[:ind].strip() )
                    else:
                        out.append( line[:ind] + comment[0] + line[ind+1:] + comment[1:] )
                else:
                    out.append(line)
            except ValueError:
                out.append(line)
    return out

if __name__ == '__main__':

    def help(error=False):
        if error:
            output = sys.stderr
        else:
            output = sys.stdout
        output.write("gcodeplot.py [options] [inputfile [> output.gcode]\n")
        output.write("""
    --dump-options: show current settings instead of doing anything
 -h|--help: this
 -r|--allow-repeats*: do not deduplicate paths
 -f|--scale=mode: scaling option: none(n), fit(f), down-only(d) [default none; other options don't work with tool-offset]
 -D|--input-dpi=xdpi[,ydpi]: hpgl dpi
 -t|--tolerance=x: ignore (some) deviations of x millimeters or less [default 0.05]
 -s|--send=port*: send gcode to serial port instead of stdout
 -S|--send-speed=baud: set baud rate for sending
 -x|--align-x=mode: horizontal alignment: none(n), left(l), right(r) or center(c)
 -y|--align-y=mode: vertical alignment: none(n), bottom(b), top(t) or center(c)
 -a|--area=x1,y1,x2,y2: gcode print area in millimeters
 -Z|--lift-delta-z=z: amount to lift for pen-up (millimeters)
 -z|--work-z=z: z-position for drawing (millimeters)
 -F|--pen-up-speed=z: speed for moving with pen up (millimeters/second)
 -f|--pen-down-speed=z: speed for moving with pen down (millimeters/second)
 -u|--z-speed=s: speed for up/down movement (millimeters/second)
 -H|--hpgl-out*: output is HPGL, not gcode; most options ignored [default: off]
 -T|--shading-threshold=n: darkest grayscale to leave unshaded (decimal, 0. to 1.; set to 0 to turn off SVG shading) [default 1.0]
 -m|--shading-lightest=x: shading spacing for lightest colors (millimeters) [default 3.0]
 -M|--shading-darkest=x: shading spacing for darkest color (millimeters) [default 0.5]
 -A|--shading-angle=x: shading angle (degrees) [default 45]
 -X|--shading-crosshatch*: cross hatch shading
 -L|--stroke-all*: stroke even regions specified by SVG to have no stroke
 -O|--shading-avoid-outline*: avoid going over outline twice when shading
 -o|--optimization-time=t: max time to spend optimizing (seconds; set to 0 to turn off optimization) [default 60]
 -e|--direction=angle: for slanted pens: prefer to draw in given direction (degrees; 0=positive x, 90=positive y, none=no preferred direction) [default none]
 -d|--sort*: sort paths from inside to outside for cutting [default off]
 -c|--config-file=filename: read arguments, one per line, from filename
 -w|--gcode-pause=cmd: gcode pause command [default: @pause]
 -P|--pens=penfile: read output pens from penfile
 -U|--pause-at-start*: pause at start (can be included without any input file to manually move stuff)
 -R|--extract-color=c: extract color (specified in SVG format , e.g., rgb(1,0,0) or #ff0000 or red)
    --comment-delimiters=xy: one or two characters specifying comment delimiters, e.g., ";" or "()"
    --tool-offset=x: cutting tool offset (millimeters) [default 0.0]
    --overcut=x: overcut (millimeters) [default 0.0]
    --lift-command=gcode: gcode lift command (separate lines with |)
    --down-command=gcode: gcode down command (separate lines with |)
    --init-code=gcode: gcode init commands (separate lines with |)

 The options with an asterisk are default off and can be turned off again by adding "no-" at the beginning to the long-form option, e.g., --no-stroke-all or --no-send.
""")


    tolerance = 0.05
    doDedup = True
    sendPort = None
    sendSpeed = 115200
    hpglLength = 279.4
    scalingMode = SCALE_NONE
    shader = Shader()
    align = [ALIGN_NONE, ALIGN_NONE]
    plotter = Plotter()
    hpglOut = False
    strokeAll = False
    extractColor = None
    gcodePause = "@pause"
    optimizationTime = 30
    dpi = (1016., 1016.)
    pens = {1:Pen('1 (0.,0.) black default')}
    doDump = False
    penFilename = None
    pauseAtStart = False
    sortPaths = False
    svgSimulation = False
    toolOffset = 0.
    overcut = 0.
    toolMode = "custom"
    booleanExtractColor = False
    quiet = False
    comment = ";"
    sendAndSave = False
    directionAngle = None
    relCode = False
    incHoming = True

    def maybeNone(a):
        return None if a=='none' else a

    try:
        opts, args = getopt.getopt(sys.argv[1:], "e:UR:Uhdulw:P:o:Oc:LT:M:m:A:XHrf:na:D:t:s:S:x:y:z:Z:p:f:F:",
                        ["help", "down", "up", "lower-left", "allow-repeats", "no-allow-repeats", "scale=", "config-file=",
                        "area=", 'align-x=', 'align-y=', 'optimization-time=', "pens=",
                        'input-dpi=', 'tolerance=', 'send=', 'send-speed=', 'work-z=', 'lift-delta-z=', 'safe-delta-z=',
                        'pen-down-speed=', 'pen-up-speed=', 'z-speed=', 'hpgl-out', 'no-hpgl-out', 'shading-threshold=',
                        'shading-angle=', 'shading-crosshatch', 'no-shading-crosshatch', 'shading-avoid-outline',
                        'pause-at-start', 'no-pause-at-start', 'min-x=', 'max-x=', 'min-y=', 'max-y=',
                        'no-shading-avoid-outline', 'shading-darkest=', 'shading-lightest=', 'stroke-all', 'no-stroke-all', 'gcode-pause', 'dump-options', 'tab=', 'extract-color=', 'sort', 'no-sort', 'simulation', 'no-simulation', 'tool-offset=', 'overcut=',
                        'boolean-shading-crosshatch=', 'boolean-sort=', 'tool-mode=', 'send-and-save=', 'direction=', 'lift-command=', 'down-command=',
                        'init-code=', 'comment-delimiters=', 'end-code=', 'rel-code=' ], )

        if len(args) + len(opts) == 0:
            raise getopt.GetoptError("invalid commandline")

        i = 0
        while i < len(opts):
            opt,arg = opts[i]
            if opt in ('-r', '--allow-repeats'):
                doDedup = False
            elif opt == '--no-allow-repeats':
                doDedup = True
            elif opt in ('-w', '--gcode-pause'):
                gcodePause = arg
            elif opt in ('-p', '--pens'):
                pens = {}
                penFilename = arg
                with open(arg) as f:
                    for line in f:
                        if line.strip():
                            p = Pen(line)
                            pens[p.pen] = p
            elif opt in ('-f', '--scale'):
                arg = arg.lower()
                if arg.startswith('n'):
                    scalingMode = SCALE_NONE
                elif arg.startswith('d'):
                    scalingMode = SCALE_DOWN_ONLY
                elif arg.startswith('f'):
                    scalingMode = SCALE_FIT
            elif opt in ('-x', '--align-x'):
                arg = arg.lower()
                if arg.startswith('l'):
                    align[0] = ALIGN_LEFT
                elif arg.startswith('r'):
                    align[0] = ALIGN_RIGHT
                elif arg.startswith('c'):
                    align[0] = ALIGN_CENTER
                elif arg.startswith('n'):
                    align[0] = ALIGN_NONE
                else:
                    raise ValueError()
            elif opt in ('-y', '--align-y'):
                arg = arg.lower()
                if arg.startswith('b'):
                    align[1] = ALIGN_LEFT
                elif arg.startswith('t'):
                    align[1] = ALIGN_RIGHT
                elif arg.startswith('c'):
                    align[1] = ALIGN_CENTER
                elif arg.startswith('n'):
                    align[1] = ALIGN_NONE
                else:
                    raise ValueError()
            elif opt in ('-t', '--tolerance'):
                tolerance = float(arg)
            elif opt in ('-s', '--send'):
                sendPort = None if len(arg.strip()) == 0 else arg
            elif opt == '--send-and-save':
                sendPort = None if len(arg.strip()) == 0 else arg
                if sendPort is not None:
                    sendAndSave = True
            elif opt == '--no-send':
                sendPort = None
            elif opt in ('-S', '--send-speed'):
                sendSpeed = int(arg)
            elif opt in ('-a', '--area'):
                v = list(map(float, arg.split(',')))
                plotter.xyMin = (v[0],v[1])
                plotter.xyMax = (v[2],v[3])
            elif opt == '--min-x':
                plotter.xyMin = (float(arg),plotter.xyMin[1])
            elif opt == '--min-y':
                plotter.xyMin = (plotter.xyMin[0],float(arg))
            elif opt == '--max-x':
                plotter.xyMax = (float(arg),plotter.xyMax[1])
            elif opt == '--max-y':
                plotter.xyMax = (plotter.xyMax[0],float(arg))
            elif opt in ('-D', '--input-dpi'):
                v = list(map(float, arg.split(',')))
                if len(v) > 1:
                    dpi = v[0:2]
                else:
                    dpi = (v[0],v[0])
            elif opt in ('-Z', '--lift-delta-z'):
                plotter.liftDeltaZ = float(arg)
            elif opt in ('-z', '--work-z'):
                plotter.workZ = float(arg)
            elif opt == '--tool-offset':
                toolOffset = float(arg)
            elif opt == '--overcut':
                overcut = float(arg)
            elif opt in ('-p', '--safe-delta-z'):
                plotter.safeDeltaZ = float(arg)
            elif opt in ('-F', '--pen-up-speed'):
                plotter.moveSpeed = float(arg)
            elif opt in ('-f', '--pen-down-speed'):
                plotter.drawSpeed = float(arg)
            elif opt in ('-u', '--z-speed'):
                plotter.zSpeed = float(arg)
            elif opt in ('-H', '--hpgl-out'):
                hpglOut = True
            elif opt == '--no-hpgl-out':
                hpglOut = False
            elif opt in ('-T', '--shading-threshold'):
                shader.unshadedThreshold = float(arg)
            elif opt in ('-m', '--shading-lightest'):
                shader.lightestSpacing = float(arg)
            elif opt in ('-M', '--shading-darkest'):
                shader.darkestSpacing = float(arg)
            elif opt in ('-A', '--shading-angle'):
                shader.angle = float(arg)
            elif opt == '--boolean-shading-crosshatch':
                shader.crossHatch = arg.strip() != 'false'
            elif opt == '--boolean-sort':
                sort = arg.strip() != 'false'
            elif opt in ('-X', '--shading-crosshatch'):
                shader.crossHatch = True
            elif opt == '--no-shading-crosshatch':
                shader.crossHatch = False
            elif opt in ('-O', '--shading-avoid-outline'):
                avoidOutline = True
            elif opt == '--no-shading-avoid-outline':
                avoidOutline = False
            elif opt == '--no-shading-crosshatch':
                shader.crossHatch = False
            elif opt == '--pause-at-start':
                pauseAtStart = True
            elif opt == '--no-pause-at-start':
                pauseAtStart = False
            elif opt in ('-L', '--stroke-all'):
                strokeAll = True
            elif opt == '--no-stroke-all':
                strokeAll = False
            elif opt in ('-c', '--config-file'):
                configOpts = getConfigOpts(arg)
                opts = opts[:i+1] + configOpts + opts[i+1:]
            elif opt in ('-o', '--optimization-time'):
                optimizationTime = float(arg)
                if optimizationTime > 0:
                    sort = False
            elif opt in ('-h', '--help'):
                help()
                sys.exit(0)
            elif opt == '--dump-options':
                doDump = True
            elif opt in ('-R', '--extract-color'):
                arg = arg.lower()
                if arg == 'all' or len(arg.strip())==0:
                    extractColor = None
                else:
                    extractColor = parser.rgbFromColor(arg)
            elif opt in ('-d', '--sort'):
                sortPaths = True
                optimizationTime = 0
            elif opt == '--no-sort':
                sortPaths = False
            elif opt in ('U', '--simulation'):
                svgSimulation = True
            elif opt == '--no-simulation':
                svgSimulation = False
            elif opt == '--tab':
                quiet = True # Inkscape
            elif opt == "--tool-mode":
                toolMode = arg
            elif opt in ('e', '--direction'):
                if len(arg.strip()) == 0 or arg == 'none':
                    directionAngle = None
                else:
                    directionAngle = float(arg)
            elif opt == '--lift-command':
                plotter.liftCommand = maybeNone(arg)
            elif opt == '--down-command':
                plotter.downCommand = maybeNone(arg)
            elif opt == '--init-code':
                plotter.initCode = maybeNone(arg)
            elif opt == '--end-code':
                plotter.endCode = maybeNone(arg)
            elif opt == '--comment-delimiters':
                plotter.comment = maybeNone(arg)
            elif opt == "--rel-code":
                relCode = arg == "true"
            elif opt == "--inc-homing":
                incHoming = arg == "true"
            else:
                raise ValueError("Unrecognized argument "+opt + " " + arg)
            i += 1

    except getopt.GetoptError as e:
        sys.stderr.write(str(e)+"\n")
        help(error=True)
        sys.exit(2)

    if doDump:
        print('no-allow-repeats' if doDedup else 'allow-repeats')

        print('gcode-pause=' + gcodePause)

        if penFilename is not None:
            print('pens=' + penFilename)

        if scalingMode == SCALE_NONE:
            print('scale=none')
        elif scalingMode == SCALE_DOWN_ONLY:
            print('scale=down')
        else:
            print('scale=fit')

        if align[0] == ALIGN_LEFT:
            print('align-x=left')
        elif align[0] == ALIGN_CENTER:
            print('align-x=center')
        elif align[0] == ALIGN_RIGHT:
            print('align-x=right')
        else:
            print('align-x=none')

        if align[1] == ALIGN_BOTTOM:
            print('align-y=bottom')
        elif align[1] == ALIGN_CENTER:
            print('align-y=center')
        elif align[1] == ALIGN_TOP:
            print('align-y=top')
        else:
            print('align-y=none')

        print('tolerance=' + str(tolerance))

        if sendPort is not None:
            print('send=' + str(sendPort))
        else:
            print('no-send')

        print('send-speed=' + str(sendSpeed))
        print('area=%g,%g,%g,%g' % tuple(list(plotter.xyMin)+list(plotter.xyMax)))
        print('input-dpi=%g,%g' % tuple(dpi))
        print('safe-delta-z=%g' % (plotter.safeDeltaZ))
        print('lift-delta-z=%g' % (plotter.liftDeltaZ))
        print('work-z=%g' % (plotter.workZ))
        print('pen-down-speed=%g' % (plotter.drawSpeed))
        print('pen-up-speed=%g' % (plotter.moveSpeed))
        print('z-speed=%g' % (plotter.zSpeed))
        print('hpgl-out' if hpglOut else 'no-hpgl-out')
        print('shading-threshold=%g' % (shader.unshadedThreshold))
        print('shading-lightest=%g' % (shader.lightestSpacing))
        print('shading-darkest=%g' % (shader.darkestSpacing))
        print('shading-angle=%g' % (shader.angle))
        print('shading-crosshatch' if shader.crossHatch else 'no-shading-crosshatch')
        print('stroke-all' if strokeAll else 'no-stroke-all')
        print('optimization-time=%g' % (optimizationTime))
        print('sort' if sortPaths else 'no-sort')
        print('pause-at-start' if pauseAtStart else 'no-pause-at-start')
        print('extract-color=all' if extractColor is None else 'extract-color=rgb(%.3f,%.3f,%.3f)' % tuple(extractColor))
        print('tool-offset=%.3f' % toolOffset)
        print('overcut=%.3f' % overcut)
        print('simulation' if svgSimulation else 'no-simulation')
        print('direction=' + ('none' if directionAngle is None else '%.3f'%directionAngle))
        print('lift-command=' + ('none' if plotter.liftCommand is None else plotter.liftCommand))
        print('down-command=' + ('none' if plotter.downCommand is None else plotter.downCommand))
        print('init-code=' + ('none' if plotter.initCode is None else plotter.initCode))
        print('end-code=' + ('none' if plotter.endCode is None else plotter.endCode))
        print('comment-delimiters=' + ('none' if plotter.comment is None else plotter.comment))

        sys.exit(0)

    if toolMode == 'cut':
        shader.unshadedThreshold = 0
        optimizationTime = 0
        sortPaths = True
        directionAngle = None
    elif toolMode == 'draw':
        toolOffset = 0.
        sortPaths = False
        
    plotter.updateVariables()

    if len(args) == 0:
        if not pauseAtStart:
            help()

        if sendPort is None:
            sys.stderr.write("Need to specify --send=port to be able to pause without any file.")
            sys.exit(1)
        import gcodeplotutils.sendgcode as sendgcode

        sendgcode.sendGcode(port=sendPort, speed=sendSpeed, commands=gcodeHeader(plotter) + [gcodePause], gcodePause=gcodePause, variables=plotter.variables, formulas=plotter.formulas)
        sys.exit(0)

    with open(args[0]) as f:
        data = f.read()

    svgTree = None

    try:
        svgTree = ET.fromstring(data)
        if not 'svg' in svgTree.tag:
            svgTree = None
    except:
        svgTree = None

    if svgTree is None and 'PD' not in data and 'PU' not in data:
        sys.stderr.write("Unrecognized file.\n")
        exit(1)

    shader.setDrawingDirectionAngle(directionAngle)
    if svgTree is not None:
        penData = parseSVG(svgTree, tolerance=tolerance, shader=shader, strokeAll=strokeAll, pens=pens, extractColor=extractColor)
    else:
        penData = parseHPGL(data, dpi=dpi)
    penData = removePenBob(penData)

    if doDedup:
        penData = dedup(penData)

    if sortPaths:
        for pen in penData:
            penData[pen] = safeSorted(penData[pen], comparison=comparePaths)
        penData = removePenBob(penData)

    if optimizationTime > 0. and directionAngle is None:
        for pen in penData:
            penData[pen] = anneal.optimize(penData[pen], timeout=optimizationTime/2., quiet=quiet)
        penData = removePenBob(penData)

    if toolOffset > 0. or overcut > 0.:
        if scalingMode != SCALE_NONE:
            sys.stderr.write("Scaling with tool-offset > 0 will produce unpredictable results.\n")
        op = OffsetProcessor(toolOffset=toolOffset, overcut=overcut, tolerance=tolerance)
        for pen in penData:
            penData[pen] = op.processPath(penData[pen])

    if directionAngle is not None:
        for pen in penData:
            penData[pen] = directionalize(penData[pen], directionAngle)
        penData = removePenBob(penData)

    if len(penData) > 1:
        sys.stderr.write("Uses the following pens:\n")
        for pen in sorted(penData):
            sys.stderr.write(describePen(pens, pen)+"\n")

    if hpglOut and not svgSimulation:
        g = emitHPGL(penData, pens=pens)
    else:
        g = emitGcode(penData, align=align, scalingMode=scalingMode, tolerance=tolerance,
                plotter=plotter, gcodePause=gcodePause, pens=pens, pauseAtStart=pauseAtStart, simulation=svgSimulation, relCode = relCode, incHoming = incHoming)

    if g:
        dump = True

        if sendPort is not None and not svgSimulation:
            import gcodeplotutils.sendgcode as sendgcode

            dump = sendAndSave

            if hpglOut:
                sendgcode.sendHPGL(port=sendPort, speed=sendSpeed, commands=g)
            else:
                sendgcode.sendGcode(port=sendPort, speed=sendSpeed, commands=g, gcodePause=gcodePause, plotter=plotter, variables=plotter.variables, formulas=plotter.formulas)

        if dump:
            if hpglOut:
                sys.stdout.write(g)
            else:
                print('\n'.join(fixComments(plotter, g, comment=plotter.comment)))

    else:
        sys.stderr.write("No points.")
        sys.exit(1)