Refactor rendering

2 files changed, 154 insertions, 569 deletions

diff --git a/gerber/render/render.py b/gerber/render/render.py
index f7e4485..f5c58d8 100644
--- a/gerber/render/render.py
+++ b/gerber/render/render.py
@@ -28,6 +28,7 @@ from ..gerber_statements import (CommentStmt, UnknownStmt, EofStmt, ParamStmt,
                                  QuadrantModeStmt,
 )
 
+from ..primitives import *
 
 class GerberContext(object):
     """ Gerber rendering context base class
@@ -39,40 +40,8 @@ class GerberContext(object):
 
     Attributes
     ----------
-    settings : FileSettings (dict-like)
-        Gerber file settings
-
-    x : float
-        X-coordinate of the "photoplotter" head.
-
-    y : float
-        Y-coordinate of the "photoplotter" head
-
-    aperture : int
-        The aperture that is currently in use
-
-    interpolation : str
-        Current interpolation mode. may be 'linear' or 'arc'
-
-    direction : string
-        Current arc direction. May be either 'clockwise' or 'counterclockwise'
-
-    image_polarity : string
-        Current image polarity setting. May be 'positive' or 'negative'
-
-    level_polarity : string
-        Level polarity. May be 'dark' or 'clear'. Dark polarity indicates the
-        existance of copper/silkscreen/etc. in the exposed area, whereas clear
-        polarity indicates material should be removed from the exposed area.
-
-    region_mode : string
-        Region mode. May be 'on' or 'off'. When region mode is set to 'on' the
-        following "contours" define the outline of a region. When region mode
-        is subsequently turned 'off', the defined area is filled.
-
-    quadrant_mode : string
-        Quadrant mode. May be 'single-quadrant' or 'multi-quadrant'. Defines
-        how arcs are specified.
+    units : string
+        Measurement units
 
     color : tuple (<float>, <float>, <float>)
         Color used for rendering as a tuple of normalized (red, green, blue) values.
@@ -87,73 +56,14 @@ class GerberContext(object):
     alpha : float
         Rendering opacity. Between 0.0 (transparent) and 1.0 (opaque.)
     """
-    def __init__(self):
-        self.settings = {}
-        self.x = 0
-        self.y = 0
-
-        self.aperture = 0
-        self.interpolation = 'linear'
-        self.direction = 'clockwise'
-        self.image_polarity = 'positive'
-        self.level_polarity = 'dark'
-        self.region_mode = 'off'
-        self.quadrant_mode = 'multi-quadrant'
-        self.step_and_repeat = (1, 1, 0, 0)
+    def __init__(self, units='inch'):
+        self.units = units
         self.color = (0.7215, 0.451, 0.200)
         self.drill_color = (0.25, 0.25, 0.25)
         self.background_color = (0.0, 0.0, 0.0)
         self.alpha = 1.0
-        
-    def set_format(self, settings):
-        """ Set source file format.
-
-        Parameters
-        ----------
-        settings : FileSettings instance or dict-like
-            Gerber file settings used in source file.
-        """
-        self.settings = settings
-
-    def set_coord_format(self, zero_suppression, decimal_format, notation):
-        """ Set coordinate format used in source gerber file
 
-        Parameters
-        ----------
-        zero_suppression : string
-            Zero suppression mode. may be 'leading' or 'trailling'
-
-        decimal_format : tuple (<int>, <int>)
-            Decimal precision format specified as (integer digits, decimal digits)
-
-        notation : string
-            Notation mode. 'absolute' or 'incremental'
-        """
-        if zero_suppression not in ('leading', 'trailling'):
-            raise ValueError('Zero suppression must be "leading" or "trailing"')
-        self.settings['zero_suppression'] = zero_suppression
-        self.settings['format'] = decimal_format
-        self.settings['notation'] = notation
-
-    def set_coord_notation(self, notation):
-        """ Set context notation mode
-
-        Parameters
-        ----------
-        notation : string
-            Notation mode. may be 'absolute' or 'incremental'
-
-        Raises
-        ------
-        ValueError
-            If `notation` is not either "absolute" or "incremental"
-
-        """
-        if notation not in ('absolute', 'incremental'):
-            raise ValueError('Notation may be "absolute" or "incremental"')
-        self.settings['notation'] = notation
-
-    def set_coord_unit(self, unit):
+    def set_units(self, units):
         """ Set context measurement units
 
         Parameters
@@ -166,70 +76,9 @@ class GerberContext(object):
         ValueError
             If `unit` is not 'inch' or 'metric'
         """
-        if unit not in ('inch', 'metric'):
-            raise ValueError('Unit may be "inch" or "metric"')
-        self.settings['units'] = unit
-
-    def set_image_polarity(self, polarity):
-        """ Set context image polarity
-
-        Parameters
-        ----------
-        polarity : string
-            Image polarity. May be "positive" or "negative"
-
-        Raises
-        ------
-        ValueError
-            If polarity is not 'positive' or 'negative'
-        """
-        if polarity not in ('positive', 'negative'):
-            raise ValueError('Polarity may be "positive" or "negative"')
-        self.image_polarity = polarity
-
-    def set_level_polarity(self, polarity):
-        """ Set context level polarity
-
-        Parameters
-        ----------
-        polarity : string
-            Level polarity. May be "dark" or "clear"
-
-        Raises
-        ------
-        ValueError
-            If polarity is not 'dark' or 'clear'
-        """
-        if polarity not in ('dark', 'clear'):
-            raise ValueError('Polarity may be "dark" or "clear"')
-        self.level_polarity = polarity
-
-    def set_interpolation(self, interpolation):
-        """ Set arc interpolation mode
-
-        Parameters
-        ----------
-        interpolation : string
-            Interpolation mode. May be 'linear' or 'arc'
-
-        Raises
-        ------
-        ValueError
-            If `interpolation` is not 'linear' or 'arc'
-        """
-        if interpolation not in ('linear', 'arc'):
-            raise ValueError('Interpolation may be "linear" or "arc"')
-        self.interpolation = interpolation
-
-    def set_aperture(self, d):
-        """ Set active aperture
-
-        Parameters
-        ----------
-        aperture : int
-            Aperture number to activate.
-        """
-        self.aperture = d
+        if units not in ('inch', 'metric'):
+            raise ValueError('Units may be "inch" or "metric"')
+        self.units = units
 
     def set_color(self, color):
         """ Set rendering color.
@@ -277,238 +126,49 @@ class GerberContext(object):
         """
         self.alpha = alpha
 
-    def resolve(self, x, y):
-        """ Resolve missing x or y coordinates in a coordinate command.
-
-        Replace missing x or y values with the current x or y position. This
-        is the default method for handling coordinate pairs pulled from gerber
-        file statments, as a move/line/arc involving a change in only one axis
-        will drop the redundant axis coordinate to reduce file size.
-
-        Parameters
-        ----------
-        x : float
-            X-coordinate. If `None`, will be replaced with current
-            "photoplotter" head x-coordinate
-
-        y : float
-            Y-coordinate. If `None`, will be replaced with current
-            "photoplotter" head y-coordinate
-
-        Returns
-        -------
-        coordinates : tuple (<float>, <float>)
-            Coordinates in absolute notation
-        """
-        x = x if x is not None else self.x
-        y = y if y is not None else self.y
-        return x, y
-
-    def define_aperture(self, d, shape, modifiers):
-        pass
-
-    def move(self, x, y, resolve=True):
-        """ Lights-off move.
-
-        Move the "photoplotter" head to (x, y) without drawing a line. If x or
-        y is `None`, remain at the same point in that axis.
-
-        Parameters
-        -----------
-        x : float
-            X-coordinate to move to. If x is `None`, do not move in the X
-            direction
-
-        y : float
-            Y-coordinate to move to. if y is `None`, do not move in the Y
-            direction
-
-        resolve : bool
-            If resolve is `True` the context will replace missing x or y
-            coordinates with the current plotter head position. This is the
-            default behavior.
-        """
-        if resolve:
-            self.x, self.y = self.resolve(x, y)
+    def render(self, primitive):
+        color = (self.color if primitive.level_polarity == 'dark'
+                 else self.background_color)
+        if isinstance(primitive, Line):
+            self._render_line(primitive, color)
+        elif isinstance(primitive, Arc):
+            self._render_arc(primitive, color)
+        elif isinstance(primitive, Region):
+            self._render_region(primitive, color)
+        elif isinstance(primitive, Circle):
+            self._render_circle(primitive, color)
+        elif isinstance(primitive, Rectangle):
+            self._render_rectangle(primitive, color)
+        elif isinstance(primitive, Obround):
+            self._render_obround(primitive, color)
+        elif isinstance(primitive, Polygon):
+            self._render_polygon(Polygon, color)
+        elif isinstance(primitive, Drill):
+            self._render_drill(primitive, self.drill_color)
         else:
-            self.x, self.y = x, y
-
-    def stroke(self, x, y, i, j):
-        """ Lights-on move. (draws a line or arc)
-
-        The stroke method is called when a Lights-on move statement is
-        encountered. This will call the `line` or `arc` method as necessary
-        based on the move statement's parameters. The `stroke` method should
-        be overridden in `GerberContext` subclasses.
-
-        Parameters
-        ----------
-        x : float
-            X coordinate of target position
-
-        y : float
-            Y coordinate of target position
-
-        i : float
-            Offset in X-direction from current position of arc center.
+            return
 
-        j : float
-            Offset in Y-direction from current position of arc center.
-        """
+    def _render_line(self, primitive, color):
         pass
 
-    def line(self, x, y):
-        """ Draw a line
-
-        Draws a line from the current position to  (x, y) using the currently
-        selected aperture. The `line` method should be overridden in
-        `GerberContext` subclasses.
-
-        Parameters
-        ----------
-        x : float
-            X coordinate of target position
-
-        y : float
-            Y coordinate of target position
-        """
+    def _render_arc(self, primitive, color):
         pass
 
-    def arc(self, x, y, i, j):
-        """ Draw an arc
-
-        Draw an arc from the current position to (x, y) using the currently
-        selected aperture. `i` and `j` specify the offset from the starting
-        position to the center of the arc.The `arc` method should be
-        overridden in `GerberContext` subclasses.
-
-        Parameters
-        ----------
-        x : float
-            X coordinate of target position
-
-        y : float
-            Y coordinate of target position
-
-        i : float
-            Offset in X-direction from current position of arc center.
-
-        j : float
-            Offset in Y-direction from current position of arc center.
-        """
+    def _render_region(self, primitive, color):
         pass
 
-    def flash(self, x, y):
-        """ Flash the current aperture
-
-        Draw a filled shape defined by the currently selected aperture.
-
-        Parameters
-        ----------
-        x : float
-            X coordinate of the position at which to flash
-
-        y : float
-            Y coordinate of the position at which to flash
-        """
+    def _render_circle(self, primitive, color):
         pass
 
-    def drill(self, x, y, diameter):
-        """ Draw a drill hit
-
-        Draw a filled circle representing a drill hit at the specified
-        position and with the specified diameter.
-
-        Parameters
-        ----------
-        x : float
-            X coordinate of the drill hit
-
-        y : float
-            Y coordinate of the drill hit
-
-        diameter : float
-            Finished hole diameter to draw.
-        """
+    def _render_rectangle(self, primitive, color):
         pass
 
-    def region_contour(self, x, y):
-        pass
-    
-    def fill_region(self):
+    def _render_obround(self, primitive, color):
         pass
-    
-    def evaluate(self, stmt):
-        """ Evaluate Gerber statement and update image accordingly.
-
-        This method is called once for each statement in a Gerber/Excellon
-        file when the file's `render` method is called. The evaluate method
-        should forward the statement on to the relevant handling method based
-        on the statement type.
-
-        Parameters
-        ----------
-        statement : Statement
-            Gerber/Excellon statement to evaluate.
 
-        """
-        if isinstance(stmt, (CommentStmt, UnknownStmt, EofStmt)):
-            return
-
-        elif isinstance(stmt, ParamStmt):
-            self._evaluate_param(stmt)
-
-        elif isinstance(stmt, CoordStmt):
-            self._evaluate_coord(stmt)
-
-        elif isinstance(stmt, ApertureStmt):
-            self._evaluate_aperture(stmt)
-
-        elif isinstance(stmt, (RegionModeStmt, QuadrantModeStmt)):
-            self._evaluate_mode(stmt)
+    def _render_polygon(self, primitive, color):
+        pass
 
-        else:
-            raise Exception("Invalid statement to evaluate")
-
-    def _evaluate_mode(self, stmt):
-        if stmt.type == 'RegionMode':
-            if self.region_mode == 'on' and stmt.mode == 'off':
-                self.fill_region()
-            self.region_mode = stmt.mode
-        elif stmt.type == 'QuadrantMode':
-            self.quadrant_mode = stmt.mode
-
-    def _evaluate_param(self, stmt):
-        if stmt.param == "FS":
-            self.set_coord_format(stmt.zero_suppression, stmt.format,
-                                  stmt.notation)
-            self.set_coord_notation(stmt.notation)
-        elif stmt.param == "MO":
-            self.set_coord_unit(stmt.mode)
-        elif stmt.param == "IP":
-            self.set_image_polarity(stmt.ip)
-        elif stmt.param == "LP":
-            self.set_level_polarity(stmt.lp)
-        elif stmt.param == "AD":
-            self.define_aperture(stmt.d, stmt.shape, stmt.modifiers)
-
-    def _evaluate_coord(self, stmt):
-        if stmt.function in ("G01", "G1"):
-            self.set_interpolation('linear')
-        elif stmt.function in ('G02', 'G2', 'G03', 'G3'):
-            self.set_interpolation('arc')
-            self.direction = ('clockwise' if stmt.function in ('G02', 'G2')
-                              else 'counterclockwise')
-        if stmt.op == "D01":
-            if self.region_mode == 'on':
-                self.region_contour(stmt.x, stmt.y)
-            else:
-                self.stroke(stmt.x, stmt.y, stmt.i, stmt.j)
-        elif stmt.op == "D02":
-            self.move(stmt.x, stmt.y)
-        elif stmt.op == "D03":
-            self.flash(stmt.x, stmt.y)
-
-    def _evaluate_aperture(self, stmt):
-        self.set_aperture(stmt.d)
+    def _render_drill(self, primitive, color):
+        pass
 
diff --git a/gerber/render/svgwrite_backend.py b/gerber/render/svgwrite_backend.py
index 15d7bd3..d9456a5 100644
--- a/gerber/render/svgwrite_backend.py
+++ b/gerber/render/svgwrite_backend.py
@@ -17,214 +17,139 @@
 # limitations under the License.
 
 from .render import GerberContext
-from .apertures import Circle, Rect, Obround, Polygon
+from operator import mul
 import svgwrite
 
 SCALE = 300
 
 
-def convert_color(color):
+def svg_color(color):
     color = tuple([int(ch * 255) for ch in color])
     return  'rgb(%d, %d, %d)' % color
 
-class SvgCircle(Circle):
-    def line(self, ctx, x, y, color='rgb(184, 115, 51)', alpha=1.0):
-        aline =  ctx.dwg.line(start=(ctx.x * SCALE, -ctx.y * SCALE),
-                              end=(x * SCALE, -y * SCALE),
-                              stroke=color,
-                              stroke_width=SCALE * self.diameter,
-                              stroke_linecap="round")
-        aline.stroke(opacity=alpha)
-        return aline
-        
-    def arc(self, ctx, x, y, i, j, direction, color='rgb(184, 115, 51)', alpha=1.0):
-        pass
-
-    def flash(self, ctx, x, y, color='rgb(184, 115, 51)', alpha=1.0):
-        circle = ctx.dwg.circle(center=(x * SCALE, -y * SCALE),
-                               r = SCALE * (self.diameter / 2.0),
-                               fill=color)
-        circle.fill(opacity=alpha)
-        return [circle, ]
-
-
-class SvgRect(Rect):
-    def line(self, ctx, x, y, color='rgb(184, 115, 51)', alpha=1.0):
-        aline = ctx.dwg.line(start=(ctx.x * SCALE, -ctx.y * SCALE),
-                            end=(x * SCALE, -y * SCALE),
-                            stroke=color, stroke_width=2,
-                            stroke_linecap="butt")
-        aline.stroke(opacity=alpha)
-        return aline
-
-    def flash(self, ctx, x, y, color='rgb(184, 115, 51)', alpha=1.0):
-        xsize, ysize = self.size
-        rectangle = ctx.dwg.rect(insert=(SCALE * (x - (xsize / 2)),
-                                     -SCALE * (y + (ysize / 2))),
-                             size=(SCALE * xsize, SCALE * ysize),
-                             fill=color)
-        rectangle.fill(opacity=alpha)
-        return [rectangle, ]
-
-
-class SvgObround(Obround):
-    def line(self, ctx, x, y, color='rgb(184, 115, 51)', alpha=1.0):
-        pass
-
-    def flash(self, ctx, x, y, color='rgb(184, 115, 51)', alpha=1.0):
-        xsize, ysize = self.size
-
-        # horizontal obround
-        if xsize == ysize:
-            circle = ctx.dwg.circle(center=(x * SCALE, -y * SCALE),
-                                   r = SCALE * (x / 2.0),
-                                   fill=color)
-            circle.fill(opacity=alpha)
-            return [circle, ]
-        if xsize > ysize:
-            rectx = xsize - ysize
-            recty = ysize
-            lcircle = ctx.dwg.circle(center=((x - (rectx / 2.0)) * SCALE,
-                                             -y * SCALE),
-                                     r = SCALE * (ysize / 2.0),
-                                     fill=color)
-
-            rcircle = ctx.dwg.circle(center=((x + (rectx / 2.0)) * SCALE,
-                                             -y * SCALE),
-                                     r = SCALE * (ysize / 2.0),
-                                     fill=color)
-
-            rect = ctx.dwg.rect(insert=(SCALE * (x - (xsize / 2.)),
-                                        -SCALE * (y + (ysize / 2.))),
-                                size=(SCALE * xsize, SCALE * ysize),
-                                fill=color)
-            lcircle.fill(opacity=alpha)
-            rcircle.fill(opacity=alpha)
-            rect.fill(opacity=alpha)
-            return [lcircle, rcircle, rect, ]
-
-        # Vertical obround
-        else:
-            rectx = xsize
-            recty = ysize - xsize
-            lcircle = ctx.dwg.circle(center=(x * SCALE,
-                                            (y - (recty / 2.)) * -SCALE),
-                                     r = SCALE * (xsize / 2.),
-                                     fill=color)
-
-            ucircle = ctx.dwg.circle(center=(x * SCALE,
-                                             (y + (recty / 2.)) * -SCALE),
-                                     r = SCALE * (xsize / 2.),
-                                     fill=color)
-
-            rect = ctx.dwg.rect(insert=(SCALE * (x - (xsize / 2.)),
-                                        -SCALE * (y + (ysize / 2.))),
-                                size=(SCALE * xsize, SCALE * ysize),
-                                fill=color)
-            lcircle.fill(opacity=alpha)
-            ucircle.fill(opacity=alpha)
-            rect.fill(opacity=alpha)
-            return [lcircle, ucircle, rect, ]
-
 
 class GerberSvgContext(GerberContext):
     def __init__(self):
         GerberContext.__init__(self)
-
-        self.apertures = {}
+        self.scale = (SCALE, -SCALE)
         self.dwg = svgwrite.Drawing()
-        self.dwg.transform = 'scale 1 -1'
         self.background = False
-        self.region_path = None
+
+    def dump(self, filename):
+        self.dwg.saveas(filename)
 
     def set_bounds(self, bounds):
         xbounds, ybounds = bounds
-        size = (SCALE * (xbounds[1] - xbounds[0]), SCALE * (ybounds[1] - ybounds[0]))
+        size = (SCALE * (xbounds[1] - xbounds[0]),
+                SCALE * (ybounds[1] - ybounds[0]))
         if not self.background:
-            self.dwg = svgwrite.Drawing(viewBox='%f, %f, %f, %f' % (SCALE*xbounds[0], -SCALE*ybounds[1],size[0], size[1]))
-            self.dwg.add(self.dwg.rect(insert=(SCALE * xbounds[0],
-                                               -SCALE * ybounds[1]),
-                                       size=size, fill=convert_color(self.background_color)))
+            vbox = '%f, %f, %f, %f' % (SCALE * xbounds[0], -SCALE * ybounds[1],
+                                       size[0], size[1])
+            self.dwg = svgwrite.Drawing(viewBox=vbox)
+            rect = self.dwg.rect(insert=(SCALE * xbounds[0],
+                                         -SCALE * ybounds[1]),
+                                 size=size,
+                                 fill=svg_color(self.background_color))
+            self.dwg.add(rect)
             self.background = True
 
-    def define_aperture(self, d, shape, modifiers):
-        aperture = None
-        if shape == 'C':
-            aperture = SvgCircle(diameter=float(modifiers[0][0]))
-        elif shape == 'R':
-            aperture = SvgRect(size=modifiers[0][0:2])
-        elif shape == 'O':
-            aperture = SvgObround(size=modifiers[0][0:2])
-        self.apertures[d] = aperture
-
-    def stroke(self, x, y, i, j):
-        super(GerberSvgContext, self).stroke(x, y, i, j)
-
-        if self.interpolation == 'linear':
-            self.line(x, y)
-        elif self.interpolation == 'arc':
-            self.arc(x, y, i, j)
-
-    def line(self, x, y):
-        super(GerberSvgContext, self).line(x, y)
-        x, y = self.resolve(x, y)
-        ap = self.apertures.get(self.aperture, None)
-        if ap is None:
-            return
-        color = (convert_color(self.color) if self.level_polarity == 'dark' 
-                 else convert_color(self.background_color))
-        alpha = self.alpha if self.level_polarity == 'dark' else 1.0
-        self.dwg.add(ap.line(self, x, y, color, alpha))
-        self.move(x, y, resolve=False)
-
-    def arc(self, x, y, i, j):
-        super(GerberSvgContext, self).arc(x, y, i, j)
-        x, y = self.resolve(x, y)
-        ap = self.apertures.get(self.aperture, None)
-        if ap is None:
-            return
-        #self.dwg.add(ap.arc(self, x, y, i, j, self.direction,
-        #                    convert_color(self.color), self.alpha))
-        self.move(x, y, resolve=False)
-
-    def flash(self, x, y):
-        super(GerberSvgContext, self).flash(x, y)
-        x, y = self.resolve(x, y)
-        ap = self.apertures.get(self.aperture, None)
-        if ap is None:
-            return
-        
-        color = (convert_color(self.color) if self.level_polarity == 'dark'
-                 else convert_color(self.background_color))
-        alpha = self.alpha if self.level_polarity == 'dark' else 1.0
-        for shape in ap.flash(self, x, y, color, alpha):
-            self.dwg.add(shape)
-        self.move(x, y, resolve=False)
-
-    def drill(self, x, y, diameter):
-        hit = self.dwg.circle(center=(x*SCALE, -y*SCALE),
-                              r=SCALE*(diameter/2.0),
-                              fill=convert_color(self.drill_color))
-        #hit.fill(opacity=self.alpha)
-        self.dwg.add(hit)
-
-    def region_contour(self, x, y):
-        super(GerberSvgContext, self).region_contour(x, y)
-        x, y = self.resolve(x, y)
-        color = (convert_color(self.color) if self.level_polarity == 'dark'
-                 else convert_color(self.background_color))
-        alpha = self.alpha if self.level_polarity == 'dark' else 1.0
-        if self.region_path is None:
-            self.region_path = self.dwg.path(d = 'M %f, %f' %
-                                             (self.x*SCALE, -self.y*SCALE),
-                                             fill = color, stroke = 'none')
-            self.region_path.fill(opacity=alpha)
-        self.region_path.push('L %f, %f' % (x*SCALE, -y*SCALE))
-        self.move(x, y, resolve=False)
-
-    def fill_region(self):
-        self.dwg.add(self.region_path)
-        self.region_path = None
+    def _render_line(self, line, color):
+        start = map(mul, line.start, self.scale)
+        end = map(mul, line.end, self.scale)
+        aline = self.dwg.line(start=start, end=end,
+                              stroke=svg_color(color),
+                              stroke_width=SCALE * line.width,
+                              stroke_linecap='round')
+        aline.stroke(opacity=self.alpha)
+        self.dwg.add(aline)
+
+    def _render_region(self, region, color):
+        points = [tuple(map(mul, point, self.scale)) for point in region.points]
+        region_path = self.dwg.path(d='M %f, %f' % points[0],
+                                    fill=svg_color(color),
+                                    stroke='none')
+        region_path.fill(opacity=self.alpha)
+        for point in points[1:]:
+            region_path.push('L %f, %f' % point)
+        self.dwg.add(region_path)
+
+    def _render_circle(self, circle, color):
+        center = map(mul, circle.position, self.scale)
+        acircle = self.dwg.circle(center=center,
+                                  r = SCALE * circle.radius,
+                                  fill=svg_color(color))
+        acircle.fill(opacity=self.alpha)
+        self.dwg.add(acircle)
+
+    def _render_rectangle(self, rectangle, color):
+        center = map(mul, rectangle.position, self.scale)
+        size = tuple(map(mul, (rectangle.width, rectangle.height), map(abs, self.scale)))
+        insert = center[0] - size[0] / 2., center[1] - size[1] / 2.
+        arect = self.dwg.rect(insert=insert, size=size,
+                              fill=svg_color(color))
+        arect.fill(opacity=self.alpha)
+        self.dwg.add(arect)
+
+    def _render_obround(self, obround, color):
+        x, y = tuple(map(mul, obround.position, self.scale))
+        xsize, ysize = tuple(map(mul, (obround.width, obround.height),
+                                 self.scale))
+        xscale, yscale = self.scale
+
+        # Corner case...
+        if xsize == ysize:
+            circle = self.dwg.circle(center=(x, y),
+                                   r = (xsize / 2.0),
+                                   fill=svg_color(color))
+            circle.fill(opacity=self.alpha)
+            self.dwg.add(circle)
+
+        # Horizontal obround
+        elif xsize > ysize:
+            rectx = xsize - ysize
+            recty = ysize
+            c1 = self.dwg.circle(center=(x - (rectx / 2.0), y),
+                                 r = (ysize / 2.0),
+                                 fill=svg_color(color))
+
+            c2 = self.dwg.circle(center=(x + (rectx / 2.0), y),
+                                 r = (ysize / 2.0),
+                                 fill=svg_color(color))
+
+            rect = self.dwg.rect(insert=(x, y),
+                                 size=(xsize, ysize),
+                                 fill=svg_color(color))
+            c1.fill(opacity=self.alpha)
+            c2.fill(opacity=self.alpha)
+            rect.fill(opacity=self.alpha)
+            self.dwg.add(c1)
+            self.dwg.add(c2)
+            self.dwg.add(rect)
 
-    def dump(self, filename):
-        self.dwg.saveas(filename)
+        # Vertical obround
+        else:
+            rectx = xsize
+            recty = ysize - xsize
+            c1 = self.dwg.circle(center=(x, y - (recty / 2.)),
+                                 r = (xsize / 2.),
+                                 fill=svg_color(color))
+
+            c2 = self.dwg.circle(center=(x, y + (recty / 2.)),
+                                 r = (xsize / 2.),
+                                 fill=svg_color(color))
+
+            rect = self.dwg.rect(insert=(x, y),
+                                size=(xsize, ysize),
+                                fill=svg_color(color))
+            c1.fill(opacity=self.alpha)
+            c2.fill(opacity=self.alpha)
+            rect.fill(opacity=self.alpha)
+            self.dwg.add(c1)
+            self.dwg.add(c2)
+            self.dwg.add(rect)
+
+    def _render_drill(self, primitive, color):
+        center = map(mul, primitive.position, self.scale)
+        hit = self.dwg.circle(center=center, r=SCALE * primitive.radius,
+                              fill=svg_color(color))
+        self.dwg.add(hit)