svg2gcode/svg2gcode.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import svg, sys
from gcode import Gcode
from optparse import OptionParser
from tinycss import CSS21Parser

from shapely.geometry import box, MultiLineString, Point, Polygon
from shapely.affinity import rotate
from shapely import speedups
from math import sqrt

# enable Shapely speedups, if possible
if speedups.available:
    speedups.enable()

def hatchbox(rect, angle, spacing):
    """
    returns a Shapely geometry (MULTILINESTRING, or more rarely,
    GEOMETRYCOLLECTION) for a simple hatched rectangle.

    args:
    rect - a Shapely geometry for the outer boundary of the hatch
           Likely most useful if it really is a rectangle

    angle - angle of hatch lines, conventional anticlockwise -ve

    spacing - spacing between hatch lines

    GEOMETRYCOLLECTION case occurs when a hatch line intersects with
    the corner of the clipping rectangle, which produces a point
    along with the usual lines.
    """

    (llx, lly, urx, ury) = rect.bounds
    centre_x = (urx + llx) / 2
    centre_y = (ury + lly) / 2
    diagonal_length = sqrt((urx - llx) ** 2 + (ury - lly) ** 2)
    number_of_lines = 2 + int(diagonal_length / spacing)
    hatch_length = spacing * (number_of_lines - 1)

    # build a square (of side hatch_length) horizontal lines
    # centred on centroid of the bounding box, 'spacing' units apart
    coords = []
    for i in range(number_of_lines):
        # alternate lines l2r and r2l to keep HP-7470A plotter happy ☺
        if i % 2:
            coords.extend([((centre_x - hatch_length / 2, centre_y
                          - hatch_length / 2 + i * spacing), (centre_x
                          + hatch_length / 2, centre_y - hatch_length
                          / 2 + i * spacing))])
        else:
            coords.extend([((centre_x + hatch_length / 2, centre_y
                          - hatch_length / 2 + i * spacing), (centre_x
                          - hatch_length / 2, centre_y - hatch_length
                          / 2 + i * spacing))])
    # turn array into Shapely object
    lines = MultiLineString(coords)
    # Rotate by angle around box centre
    lines = rotate(lines, angle, origin='centroid', use_radians=False)
    # return clipped array
    return rect.intersection(lines)

def get_infill(polygon):
    # create shape from polygon:
    segments = []
    for pnt in polygon:
        x, y = pnt.coord()
        segments.append((x, y))

    shape = Polygon(segments)
    if shape.is_valid:
        return shape.intersection(INFILL)
    else:
        return []

parser = OptionParser()
parser.add_option("-f", "--file", dest="filename", default=None,
                  help="Load SVG file", metavar="FILE")
parser.add_option("-s", "--scale",
                  dest="scale", type="float", default=1.0,
                  help="set scale factor (default 1.0)")
parser.add_option("-e", "",
                  dest="engrave_speed", type="float", default=20,
                  help="engrave speed mm/sec (default 20)")
parser.add_option("-t", "",
                  dest="travel_speed", type="float", default=130,
                  help="travel speed mm/sec (default 130)")
parser.add_option("-o", "--outline", action="store_true",
                  dest="outline", default=False,
                  help="no infill, only outlines")


(options, args) = parser.parse_args()


if not options.filename:
    print "no filename given!"
    sys.exit(1)

gcode = Gcode(scale=options.scale, travel_speed=options.travel_speed, engrave_speed=options.engrave_speed)

im = svg.parse(options.filename)
b1, b2 = im.bbox()
width, height = b2.coord()
print "Original dimension: %.2f x %.2f" % (width, height)
width *= gcode.mm_pixel * options.scale
height *= gcode.mm_pixel * options.scale
print "Print dimension: %.2fmm x %.2fmm" % (width, height)

x1, y1 = b1.coord()
x2, y2 = b2.coord()
page = box(x1, y1, x2, y2)
INFILL = hatchbox(page, 0, 2)

def parse_style(stylestr):
    if stylestr.strip() == '':
        return None
    parser = CSS21Parser()
    style = parser.parse_style_attr(stylestr)
    kv = {}
    for obj in style[0]:
        kv[obj.name] = obj.value[0].value
    return kv

def normalize(coord):
    x = coord[0]
    y = coord[1]
    # flip y
    y = (b2.coord()[1] - y)
    return (x, y)

data = im.flatten()
for d in data:
    if hasattr(d, "segments"):
        for l in d.segments(1):
            # THE OUTLINE
            x, y = normalize(l[0].coord())
            gcode.move(x, y)
            for pt in l[1:]:
                x, y = normalize(pt.coord())
                gcode.engrave(x, y)

            if options.outline:
                continue

            if (isinstance(d, svg.Polygon) or isinstance(d, svg.Path)):
                #check if we shoild infill?
                style = parse_style(d.style)
                if not style:
                    continue
                if not 'fill' in style.keys():
                    continue
                if style['fill'] == 'none':
                    continue

                # THE INFILL
                for line in get_infill(l):
                    start = normalize((line.coords[0][0], line.coords[0][1]))
                    end = normalize((line.coords[1][0], line.coords[1][1]))
                    gcode.move(start[0], start[1])
                    gcode.engrave(end[0], end[1])

# write gcode file
gcode.write(options.filename + ".g")