diff options
Diffstat (limited to 'gerber/render')
| -rw-r--r-- | gerber/render/__init__.py | 3 | ||||
| -rw-r--r-- | gerber/render/apertures.py | 76 | ||||
| -rw-r--r-- | gerber/render/cairo_backend.py | 529 | ||||
| -rw-r--r-- | gerber/render/excellon_backend.py | 189 | ||||
| -rw-r--r-- | gerber/render/render.py | 204 | ||||
| -rw-r--r-- | gerber/render/rs274x_backend.py | 495 | ||||
| -rw-r--r-- | gerber/render/svgwrite_backend.py | 155 | ||||
| -rw-r--r-- | gerber/render/theme.py | 70 |
8 files changed, 1366 insertions, 355 deletions
diff --git a/gerber/render/__init__.py b/gerber/render/__init__.py index b4af4ad..f76d28f 100644 --- a/gerber/render/__init__.py +++ b/gerber/render/__init__.py @@ -24,5 +24,4 @@ SVG is the only supported format. """ -from svgwrite_backend import GerberSvgContext -from cairo_backend import GerberCairoContext +from .cairo_backend import GerberCairoContext diff --git a/gerber/render/apertures.py b/gerber/render/apertures.py deleted file mode 100644 index 52ae50c..0000000 --- a/gerber/render/apertures.py +++ /dev/null @@ -1,76 +0,0 @@ -#! /usr/bin/env python -# -*- coding: utf-8 -*- - -# Copyright 2014 Hamilton Kibbe <ham@hamiltonkib.be> - -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at - -# http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -""" -gerber.render.apertures -============ -**Gerber Aperture base classes** - -This module provides base classes for gerber apertures. These are used by -the rendering engine to draw the gerber file. -""" -import math - -class Aperture(object): - """ Gerber Aperture base class - """ - def draw(self, ctx, x, y): - raise NotImplementedError('The draw method must be implemented \ - in an Aperture subclass.') - - def flash(self, ctx, x, y): - raise NotImplementedError('The flash method must be implemented \ - in an Aperture subclass.') - - def _arc_params(self, startx, starty, x, y, i, j): - center = (startx + i, starty + j) - radius = math.sqrt(math.pow(center[0] - x, 2) + - math.pow(center[1] - y, 2)) - delta_x0 = startx - center[0] - delta_y0 = center[1] - starty - delta_x1 = x - center[0] - delta_y1 = center[1] - y - start_angle = math.atan2(delta_y0, delta_x0) - end_angle = math.atan2(delta_y1, delta_x1) - return {'center': center, 'radius': radius, - 'start_angle': start_angle, 'end_angle': end_angle} - - -class Circle(Aperture): - """ Circular Aperture base class - """ - def __init__(self, diameter=0.0): - self.diameter = diameter - - -class Rect(Aperture): - """ Rectangular Aperture base class - """ - def __init__(self, size=(0, 0)): - self.size = size - - -class Obround(Aperture): - """ Obround Aperture base class - """ - def __init__(self, size=(0, 0)): - self.size = size - - -class Polygon(Aperture): - """ Polygon Aperture base class - """ - pass diff --git a/gerber/render/cairo_backend.py b/gerber/render/cairo_backend.py index df513bb..8c7232f 100644 --- a/gerber/render/cairo_backend.py +++ b/gerber/render/cairo_backend.py @@ -12,80 +12,517 @@ # Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+ +# See the License for the specific language governing permissions and +# limitations under the License. + +try:
+ import cairo
+except ImportError:
+ import cairocffi as cairo
+ +import math
+from operator import mul, div
+import tempfile
-from .render import GerberContext
-from operator import mul
import cairocffi as cairo
-import math
-SCALE = 300.
+from ..primitives import *
+from .render import GerberContext, RenderSettings
+from .theme import THEMES
+
+try:
+ from cStringIO import StringIO
+except(ImportError):
+ from io import StringIO
class GerberCairoContext(GerberContext):
- def __init__(self, surface=None, size=(1000, 1000)):
- GerberContext.__init__(self)
- if surface is None:
- self.surface = cairo.ImageSurface(cairo.FORMAT_ARGB32,
- size[0], size[1])
+
+ def __init__(self, scale=300):
+ super(GerberCairoContext, self).__init__()
+ self.scale = (scale, scale)
+ self.surface = None
+ self.ctx = None
+ self.active_layer = None
+ self.output_ctx = None
+ self.bg = False
+ self.mask = None
+ self.mask_ctx = None
+ self.origin_in_inch = None
+ self.size_in_inch = None
+ self._xform_matrix = None
+
+ @property
+ def origin_in_pixels(self):
+ return (self.scale_point(self.origin_in_inch)
+ if self.origin_in_inch is not None else (0.0, 0.0))
+
+ @property
+ def size_in_pixels(self):
+ return (self.scale_point(self.size_in_inch)
+ if self.size_in_inch is not None else (0.0, 0.0))
+
+ def set_bounds(self, bounds, new_surface=False):
+ origin_in_inch = (bounds[0][0], bounds[1][0])
+ size_in_inch = (abs(bounds[0][1] - bounds[0][0]),
+ abs(bounds[1][1] - bounds[1][0]))
+ size_in_pixels = self.scale_point(size_in_inch)
+ self.origin_in_inch = origin_in_inch if self.origin_in_inch is None else self.origin_in_inch
+ self.size_in_inch = size_in_inch if self.size_in_inch is None else self.size_in_inch
+ if (self.surface is None) or new_surface:
+ self.surface_buffer = tempfile.NamedTemporaryFile()
+ self.surface = cairo.SVGSurface(
+ self.surface_buffer, size_in_pixels[0], size_in_pixels[1])
+ self.output_ctx = cairo.Context(self.surface)
+ self.output_ctx.set_fill_rule(cairo.FILL_RULE_EVEN_ODD)
+ self.output_ctx.scale(1, -1)
+ self.output_ctx.translate(-(origin_in_inch[0] * self.scale[0]),
+ (-origin_in_inch[1] * self.scale[0]) - size_in_pixels[1])
+ self._xform_matrix = cairo.Matrix(xx=1.0, yy=-1.0,
+ x0=-self.origin_in_pixels[0],
+ y0=self.size_in_pixels[1] + self.origin_in_pixels[1])
+
+ def render_layers(self, layers, filename, theme=THEMES['default']):
+ """ Render a set of layers
+ """
+ self.set_bounds(layers[0].bounds, True)
+ self._paint_background(True)
+
+ for layer in layers:
+ self._render_layer(layer, theme)
+ self.dump(filename)
+
+ def dump(self, filename):
+ """ Save image as `filename`
+ """
+ if filename and filename.lower().endswith(".svg"):
+ self.surface.finish()
+ self.surface_buffer.flush()
+ with open(filename, "w") as f:
+ self.surface_buffer.seek(0)
+ f.write(self.surface_buffer.read())
+ f.flush()
else:
- self.surface = surface
- self.ctx = cairo.Context(self.surface)
- self.size = size
- self.ctx.translate(0, self.size[1])
- self.scale = (SCALE,SCALE)
- self.ctx.scale(1, -1)
- self.apertures = {}
- self.background = False
+ return self.surface.write_to_png(filename)
- def set_bounds(self, bounds):
- xbounds, ybounds = bounds
- self.ctx.rectangle(SCALE * xbounds[0], SCALE * ybounds[0], SCALE * (xbounds[1]- xbounds[0]), SCALE * (ybounds[1] - ybounds[0]))
- self.ctx.set_source_rgb(0,0,0)
- self.ctx.fill()
+ def dump_str(self):
+ """ Return a string containing the rendered image.
+ """
+ fobj = StringIO()
+ self.surface.write_to_png(fobj)
+ return fobj.getvalue()
+
+ def dump_svg_str(self):
+ """ Return a string containg the rendered SVG.
+ """
+ self.surface.finish()
+ self.surface_buffer.flush()
+ return self.surface_buffer.read()
+
+ def _render_layer(self, layer, theme=THEMES['default']):
+ settings = theme.get(layer.layer_class, RenderSettings())
+ self.color = settings.color
+ self.alpha = settings.alpha
+ self.invert = settings.invert
+
+ # Get a new clean layer to render on
+ self._new_render_layer()
+ if settings.mirror:
+ raise Warning('mirrored layers aren\'t supported yet...')
+ for prim in layer.primitives:
+ self.render(prim)
+ # Add layer to image
+ self._flatten()
def _render_line(self, line, color):
- start = map(mul, line.start, self.scale)
- end = map(mul, line.end, self.scale)
- self.ctx.set_source_rgb (*color)
- self.ctx.set_line_width(line.width * SCALE)
+ start = [pos * scale for pos, scale in zip(line.start, self.scale)]
+ end = [pos * scale for pos, scale in zip(line.end, self.scale)]
+ if not self.invert:
+<<<<<<< HEAD + self.ctx.set_source_rgba(color[0], color[1], color[2], alpha=self.alpha)
+ self.ctx.set_operator(cairo.OPERATOR_OVER
+ if line.level_polarity == "dark"
+ else cairo.OPERATOR_CLEAR) +======= + self.ctx.set_source_rgba(*color, alpha=self.alpha)
+ self.ctx.set_operator(cairo.OPERATOR_OVER
+ if line.level_polarity == 'dark'
+ else cairo.OPERATOR_CLEAR)
+>>>>>>> 5476da8... Fix a bunch of rendering bugs. + else:
+ self.ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)
+ self.ctx.set_operator(cairo.OPERATOR_CLEAR)
+ if isinstance(line.aperture, Circle):
+<<<<<<< HEAD + width = line.aperture.diameter +======= + width = line.aperture.diameter
+>>>>>>> 5476da8... Fix a bunch of rendering bugs. + self.ctx.set_line_width(width * self.scale[0])
+ self.ctx.set_line_cap(cairo.LINE_CAP_ROUND)
+ self.ctx.move_to(*start)
+ self.ctx.line_to(*end)
+<<<<<<< HEAD + self.ctx.stroke() +======= + self.ctx.stroke()
+>>>>>>> 5476da8... Fix a bunch of rendering bugs. + elif isinstance(line.aperture, Rectangle):
+ points = [self.scale_point(x) for x in line.vertices]
+ self.ctx.set_line_width(0)
+ self.ctx.move_to(*points[0])
+ for point in points[1:]:
+ self.ctx.line_to(*point)
+ self.ctx.fill()
+
+ def _render_arc(self, arc, color):
+ center = self.scale_point(arc.center)
+ start = self.scale_point(arc.start)
+ end = self.scale_point(arc.end)
+ radius = self.scale[0] * arc.radius
+ angle1 = arc.start_angle
+ angle2 = arc.end_angle
+ if angle1 == angle2 and arc.quadrant_mode != 'single-quadrant':
+ # Make the angles slightly different otherwise Cario will draw nothing
+ angle2 -= 0.000000001
+ if isinstance(arc.aperture, Circle):
+ width = arc.aperture.diameter if arc.aperture.diameter != 0 else 0.001
+ else:
+ width = max(arc.aperture.width, arc.aperture.height, 0.001)
+
+ if not self.invert:
+<<<<<<< HEAD + self.ctx.set_source_rgba(color[0], color[1], color[2], alpha=self.alpha)
+ self.ctx.set_operator(cairo.OPERATOR_OVER
+ if arc.level_polarity == "dark"\
+ else cairo.OPERATOR_CLEAR)
+ else:
+ self.ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)
+ self.ctx.set_operator(cairo.OPERATOR_CLEAR)
+
+======= + self.ctx.set_source_rgba(*color, alpha=self.alpha)
+ self.ctx.set_operator(cairo.OPERATOR_OVER
+ if arc.level_polarity == 'dark'
+ else cairo.OPERATOR_CLEAR)
+ else:
+ self.ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)
+ self.ctx.set_operator(cairo.OPERATOR_CLEAR)
+>>>>>>> 5476da8... Fix a bunch of rendering bugs. + self.ctx.set_line_width(width * self.scale[0])
self.ctx.set_line_cap(cairo.LINE_CAP_ROUND)
- self.ctx.move_to(*start)
- self.ctx.line_to(*end)
- self.ctx.stroke()
+ self.ctx.move_to(*start) # You actually have to do this...
+ if arc.direction == 'counterclockwise':
+<<<<<<< HEAD + self.ctx.arc(center[0], center[1], radius, angle1, angle2)
+ else:
+ self.ctx.arc_negative(center[0], center[1], radius, angle1, angle2)
+======= + self.ctx.arc(*center, radius=radius, angle1=angle1, angle2=angle2)
+ else:
+ self.ctx.arc_negative(*center, radius=radius,
+ angle1=angle1, angle2=angle2)
+>>>>>>> 5476da8... Fix a bunch of rendering bugs. + self.ctx.move_to(*end) # ...lame
def _render_region(self, region, color):
- points = [tuple(map(mul, point, self.scale)) for point in region.points]
- self.ctx.set_source_rgb (*color)
+ if not self.invert:
+<<<<<<< HEAD + self.ctx.set_source_rgba(color[0], color[1], color[2], alpha=self.alpha)
+ self.ctx.set_operator(cairo.OPERATOR_OVER
+ if region.level_polarity == "dark"
+======= + self.ctx.set_source_rgba(*color, alpha=self.alpha)
+ self.ctx.set_operator(cairo.OPERATOR_OVER
+ if region.level_polarity == 'dark'
+>>>>>>> 5476da8... Fix a bunch of rendering bugs. + else cairo.OPERATOR_CLEAR)
+ else:
+ self.ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)
+ self.ctx.set_operator(cairo.OPERATOR_CLEAR)
+<<<<<<< HEAD +
+======= +>>>>>>> 5476da8... Fix a bunch of rendering bugs. + self.ctx.set_line_width(0)
+ self.ctx.set_line_cap(cairo.LINE_CAP_ROUND)
+ self.ctx.move_to(*self.scale_point(region.primitives[0].start))
+ for prim in region.primitives:
+ if isinstance(prim, Line):
+ self.ctx.line_to(*self.scale_point(prim.end))
+ else:
+ center = self.scale_point(prim.center)
+ radius = self.scale[0] * prim.radius
+ angle1 = prim.start_angle
+ angle2 = prim.end_angle
+ if prim.direction == 'counterclockwise':
+ self.ctx.arc(*center, radius=radius,
+ angle1=angle1, angle2=angle2)
+ else:
+ self.ctx.arc_negative(*center, radius=radius,
+ angle1=angle1, angle2=angle2)
+<<<<<<< HEAD + self.ctx.fill()
+ def _render_circle(self, circle, color):
+ center = self.scale_point(circle.position)
+ if not self.invert:
+ self.ctx.set_source_rgba(color[0], color[1], color[2], alpha=self.alpha)
+ self.ctx.set_operator(cairo.OPERATOR_OVER
+ if circle.level_polarity == "dark"
+ else cairo.OPERATOR_CLEAR)
+ else:
+ self.ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)
+ self.ctx.set_operator(cairo.OPERATOR_CLEAR)
+
+ if circle.hole_diameter > 0:
+ self.ctx.push_group()
+
self.ctx.set_line_width(0)
- self.ctx.move_to(*points[0])
- for point in points[1:]:
- self.ctx.move_to(*point)
+ self.ctx.arc(center[0], center[1], radius=circle.radius * self.scale[0], angle1=0, angle2=2 * math.pi)
+ self.ctx.fill()
+
+ if circle.hole_diameter > 0:
+ # Render the center clear
+
+ self.ctx.set_source_rgba(color[0], color[1], color[2], self.alpha)
+ self.ctx.set_operator(cairo.OPERATOR_CLEAR)
+ self.ctx.arc(center[0], center[1], radius=circle.hole_radius * self.scale[0], angle1=0, angle2=2 * math.pi)
+ self.ctx.fill()
+
+ self.ctx.pop_group_to_source()
+ self.ctx.paint_with_alpha(1) +======= self.ctx.fill()
def _render_circle(self, circle, color):
- center = map(mul, circle.position, self.scale)
- self.ctx.set_source_rgb (*color)
+ center = self.scale_point(circle.position)
+ if not self.invert:
+ self.ctx.set_source_rgba(*color, alpha=self.alpha)
+ self.ctx.set_operator(
+ cairo.OPERATOR_OVER if circle.level_polarity == 'dark' else cairo.OPERATOR_CLEAR)
+ else:
+ self.ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)
+ self.ctx.set_operator(cairo.OPERATOR_CLEAR)
self.ctx.set_line_width(0)
- self.ctx.arc(*center, radius=circle.radius * SCALE, angle1=0, angle2=2 * math.pi)
+ self.ctx.arc(*center, radius=circle.radius *
+ self.scale[0], angle1=0, angle2=2 * math.pi)
self.ctx.fill()
+>>>>>>> 5476da8... Fix a bunch of rendering bugs. def _render_rectangle(self, rectangle, color):
- ll = map(mul, rectangle.lower_left, self.scale)
- width, height = tuple(map(mul, (rectangle.width, rectangle.height), map(abs, self.scale)))
- self.ctx.set_source_rgb (*color)
+ lower_left = self.scale_point(rectangle.lower_left)
+ width, height = tuple([abs(coord) for coord in self.scale_point((rectangle.width, rectangle.height))])
+<<<<<<< HEAD +
+ if not self.invert:
+ self.ctx.set_source_rgba(color[0], color[1], color[2], alpha=self.alpha)
+ self.ctx.set_operator(cairo.OPERATOR_OVER
+ if rectangle.level_polarity == "dark"
+ else cairo.OPERATOR_CLEAR)
+ else:
+ self.ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)
+ self.ctx.set_operator(cairo.OPERATOR_CLEAR)
+
+ if rectangle.rotation != 0:
+ self.ctx.save()
+
+ center = map(mul, rectangle.position, self.scale)
+ matrix = cairo.Matrix()
+ matrix.translate(center[0], center[1])
+ # For drawing, we already handles the translation
+ lower_left[0] = lower_left[0] - center[0]
+ lower_left[1] = lower_left[1] - center[1]
+ matrix.rotate(rectangle.rotation)
+ self.ctx.transform(matrix)
+
+ if rectangle.hole_diameter > 0:
+ self.ctx.push_group()
+
+ self.ctx.set_line_width(0)
+ self.ctx.rectangle(lower_left[0], lower_left[1], width, height)
+ self.ctx.fill()
+
+ if rectangle.hole_diameter > 0:
+ # Render the center clear
+ self.ctx.set_source_rgba(color[0], color[1], color[2], self.alpha)
+ self.ctx.set_operator(cairo.OPERATOR_CLEAR)
+ center = map(mul, rectangle.position, self.scale)
+ self.ctx.arc(center[0], center[1], radius=rectangle.hole_radius * self.scale[0], angle1=0, angle2=2 * math.pi)
+ self.ctx.fill()
+
+ self.ctx.pop_group_to_source()
+ self.ctx.paint_with_alpha(1)
+
+ if rectangle.rotation != 0:
+ self.ctx.restore() +======= +
+ if not self.invert:
+ self.ctx.set_source_rgba(*color, alpha=self.alpha)
+ self.ctx.set_operator(
+ cairo.OPERATOR_OVER if rectangle.level_polarity == 'dark' else cairo.OPERATOR_CLEAR)
+ else:
+ self.ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)
+ self.ctx.set_operator(cairo.OPERATOR_CLEAR)
self.ctx.set_line_width(0)
- self.ctx.rectangle(*ll,width=width, height=height)
+ self.ctx.rectangle(*lower_left, width=width, height=height)
self.ctx.fill()
+>>>>>>> 5476da8... Fix a bunch of rendering bugs. def _render_obround(self, obround, color):
+
+ if not self.invert:
+ self.ctx.set_source_rgba(color[0], color[1], color[2], alpha=self.alpha)
+ self.ctx.set_operator(cairo.OPERATOR_OVER if obround.level_polarity == "dark" else cairo.OPERATOR_CLEAR)
+ else:
+ self.ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)
+ self.ctx.set_operator(cairo.OPERATOR_CLEAR)
+
+ if obround.hole_diameter > 0:
+ self.ctx.push_group()
+
self._render_circle(obround.subshapes['circle1'], color)
self._render_circle(obround.subshapes['circle2'], color)
self._render_rectangle(obround.subshapes['rectangle'], color)
+
+ if obround.hole_diameter > 0:
+ # Render the center clear
+ self.ctx.set_source_rgba(color[0], color[1], color[2], self.alpha)
+ self.ctx.set_operator(cairo.OPERATOR_CLEAR)
+ center = map(mul, obround.position, self.scale)
+ self.ctx.arc(center[0], center[1], radius=obround.hole_radius * self.scale[0], angle1=0, angle2=2 * math.pi)
+ self.ctx.fill()
+
+ self.ctx.pop_group_to_source()
+ self.ctx.paint_with_alpha(1)
+
+ def _render_polygon(self, polygon, color):
+
+ # TODO Ths does not handle rotation of a polygon
+ if not self.invert:
+ self.ctx.set_source_rgba(color[0], color[1], color[2], alpha=self.alpha)
+ self.ctx.set_operator(cairo.OPERATOR_OVER if polygon.level_polarity == "dark" else cairo.OPERATOR_CLEAR)
+ else:
+ self.ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)
+ self.ctx.set_operator(cairo.OPERATOR_CLEAR)
+
+ if polygon.hole_radius > 0:
+ self.ctx.push_group()
+
+ vertices = polygon.vertices
+
+ self.ctx.set_line_width(0)
+ self.ctx.set_line_cap(cairo.LINE_CAP_ROUND)
+
+ # Start from before the end so it is easy to iterate and make sure it is closed
+ self.ctx.move_to(*map(mul, vertices[-1], self.scale))
+ for v in vertices:
+ self.ctx.line_to(*map(mul, v, self.scale))
+
+ self.ctx.fill()
+
+ if polygon.hole_radius > 0:
+ # Render the center clear
+ center = tuple(map(mul, polygon.position, self.scale))
+ self.ctx.set_source_rgba(color[0], color[1], color[2], self.alpha)
+ self.ctx.set_operator(cairo.OPERATOR_CLEAR)
+ self.ctx.set_line_width(0)
+ self.ctx.arc(center[0], center[1], polygon.hole_radius * self.scale[0], 0, 2 * math.pi)
+ self.ctx.fill()
+
+ self.ctx.pop_group_to_source()
+ self.ctx.paint_with_alpha(1)
- def _render_drill(self, circle, color):
+ def _render_drill(self, circle, color=None):
+ color = color if color is not None else self.drill_color
self._render_circle(circle, color)
+
+ def _render_slot(self, slot, color):
+ start = map(mul, slot.start, self.scale)
+ end = map(mul, slot.end, self.scale)
+
+ width = slot.diameter
+
+ if not self.invert:
+ self.ctx.set_source_rgba(color[0], color[1], color[2], alpha=self.alpha)
+ self.ctx.set_operator(cairo.OPERATOR_OVER if slot.level_polarity == "dark" else cairo.OPERATOR_CLEAR)
+ else:
+ self.ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)
+ self.ctx.set_operator(cairo.OPERATOR_CLEAR)
- def dump(self, filename):
- self.surface.write_to_png(filename)
+ self.ctx.set_line_width(width * self.scale[0])
+ self.ctx.set_line_cap(cairo.LINE_CAP_ROUND)
+ self.ctx.move_to(*start)
+ self.ctx.line_to(*end)
+ self.ctx.stroke()
+
+ def _render_amgroup(self, amgroup, color):
+ self.ctx.push_group()
+ for primitive in amgroup.primitives:
+ self.render(primitive)
+ self.ctx.pop_group_to_source()
+ self.ctx.paint_with_alpha(1)
+
+ def _render_test_record(self, primitive, color):
+ position = [pos + origin for pos, origin in zip(primitive.position, self.origin_in_inch)]
+ self.ctx.set_operator(cairo.OPERATOR_OVER)
+ self.ctx.select_font_face(
+ 'monospace', cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_BOLD)
+ self.ctx.set_font_size(13)
+ self._render_circle(Circle(position, 0.015), color)
+ self.ctx.set_source_rgba(*color, alpha=self.alpha)
+ self.ctx.set_operator(
+ cairo.OPERATOR_OVER if primitive.level_polarity == 'dark' else cairo.OPERATOR_CLEAR)
+ self.ctx.move_to(*[self.scale[0] * (coord + 0.015)
+ for coord in position])
+ self.ctx.scale(1, -1)
+ self.ctx.show_text(primitive.net_name)
+ self.ctx.scale(1, -1) +
+ def _new_render_layer(self, color=None):
+ size_in_pixels = self.scale_point(self.size_in_inch)
+ layer = cairo.SVGSurface(None, size_in_pixels[0], size_in_pixels[1])
+ ctx = cairo.Context(layer)
+ ctx.set_fill_rule(cairo.FILL_RULE_EVEN_ODD)
+ ctx.scale(1, -1)
+ ctx.translate(-(self.origin_in_inch[0] * self.scale[0]),
+ (-self.origin_in_inch[1] * self.scale[0])
+ - size_in_pixels[1])
+ if self.invert:
+ ctx.set_operator(cairo.OPERATOR_OVER)
+ ctx.set_source_rgba(*self.color, alpha=self.alpha)
+ ctx.paint()
+ self.ctx = ctx
+ self.active_layer = layer
+
+ def _flatten(self):
+ self.output_ctx.set_operator(cairo.OPERATOR_OVER)
+<<<<<<< HEAD + ptn = cairo.SurfacePattern(self.active_layer) +======= + ptn = cairo.SurfacePattern(self.active_layer)
+>>>>>>> 5476da8... Fix a bunch of rendering bugs. + ptn.set_matrix(self._xform_matrix)
+ self.output_ctx.set_source(ptn)
+ self.output_ctx.paint()
+ self.ctx = None
+ self.active_layer = None
+
+ def _paint_background(self, force=False):
+ if (not self.bg) or force: + self.bg = True
+ self.output_ctx.set_operator(cairo.OPERATOR_OVER)
+<<<<<<< HEAD + self.output_ctx.set_source_rgba(self.background_color[0], self.background_color[1], self.background_color[2], alpha=1.0)
+ self.output_ctx.paint()
+
+ def scale_point(self, point):
+ return tuple([coord * scale for coord, scale in zip(point, self.scale)])
+======= + self.output_ctx.set_source_rgba(*self.background_color, alpha=1.0)
+ self.output_ctx.paint()
+
+ def scale_point(self, point):
+ return tuple([coord * scale for coord, scale in zip(point, self.scale)])
+>>>>>>> 5476da8... Fix a bunch of rendering bugs. diff --git a/gerber/render/excellon_backend.py b/gerber/render/excellon_backend.py new file mode 100644 index 0000000..da5b22b --- /dev/null +++ b/gerber/render/excellon_backend.py @@ -0,0 +1,189 @@ + +from .render import GerberContext +from ..excellon import DrillSlot +from ..excellon_statements import * + +class ExcellonContext(GerberContext): + + MODE_DRILL = 1 + MODE_SLOT =2 + + def __init__(self, settings): + GerberContext.__init__(self) + + # Statements that we write + self.comments = [] + self.header = [] + self.tool_def = [] + self.body_start = [RewindStopStmt()] + self.body = [] + self.start = [HeaderBeginStmt()] + + # Current tool and position + self.handled_tools = set() + self.cur_tool = None + self.drill_mode = ExcellonContext.MODE_DRILL + self.drill_down = False + self._pos = (None, None) + + self.settings = settings + + self._start_header() + self._start_comments() + + def _start_header(self): + """Create the header from the settings""" + + self.header.append(UnitStmt.from_settings(self.settings)) + + if self.settings.notation == 'incremental': + raise NotImplementedError('Incremental mode is not implemented') + else: + self.body.append(AbsoluteModeStmt()) + + def _start_comments(self): + + # Write the digits used - this isn't valid Excellon statement, so we write as a comment + self.comments.append(CommentStmt('FILE_FORMAT=%d:%d' % (self.settings.format[0], self.settings.format[1]))) + + def _get_end(self): + """How we end depends on our mode""" + + end = [] + + if self.drill_down: + end.append(RetractWithClampingStmt()) + end.append(RetractWithoutClampingStmt()) + + end.append(EndOfProgramStmt()) + + return end + + @property + def statements(self): + return self.start + self.comments + self.header + self.body_start + self.body + self._get_end() + + def set_bounds(self, bounds): + pass + + def _paint_background(self): + pass + + def _render_line(self, line, color): + raise ValueError('Invalid Excellon object') + def _render_arc(self, arc, color): + raise ValueError('Invalid Excellon object') + + def _render_region(self, region, color): + raise ValueError('Invalid Excellon object') + + def _render_level_polarity(self, region): + raise ValueError('Invalid Excellon object') + + def _render_circle(self, circle, color): + raise ValueError('Invalid Excellon object') + + def _render_rectangle(self, rectangle, color): + raise ValueError('Invalid Excellon object') + + def _render_obround(self, obround, color): + raise ValueError('Invalid Excellon object') + + def _render_polygon(self, polygon, color): + raise ValueError('Invalid Excellon object') + + def _simplify_point(self, point): + return (point[0] if point[0] != self._pos[0] else None, point[1] if point[1] != self._pos[1] else None) + + def _render_drill(self, drill, color): + + if self.drill_mode != ExcellonContext.MODE_DRILL: + self._start_drill_mode() + + tool = drill.hit.tool + if not tool in self.handled_tools: + self.handled_tools.add(tool) + self.header.append(ExcellonTool.from_tool(tool)) + + if tool != self.cur_tool: + self.body.append(ToolSelectionStmt(tool.number)) + self.cur_tool = tool + + point = self._simplify_point(drill.position) + self._pos = drill.position + self.body.append(CoordinateStmt.from_point(point)) + + def _start_drill_mode(self): + """ + If we are not in drill mode, then end the ROUT so we can do basic drilling + """ + + if self.drill_mode == ExcellonContext.MODE_SLOT: + + # Make sure we are retracted before changing modes + last_cmd = self.body[-1] + if self.drill_down: + self.body.append(RetractWithClampingStmt()) + self.body.append(RetractWithoutClampingStmt()) + self.drill_down = False + + # Switch to drill mode + self.body.append(DrillModeStmt()) + self.drill_mode = ExcellonContext.MODE_DRILL + + else: + raise ValueError('Should be in slot mode') + + def _render_slot(self, slot, color): + + # Set the tool first, before we might go into drill mode + tool = slot.hit.tool + if not tool in self.handled_tools: + self.handled_tools.add(tool) + self.header.append(ExcellonTool.from_tool(tool)) + + if tool != self.cur_tool: + self.body.append(ToolSelectionStmt(tool.number)) + self.cur_tool = tool + + # Two types of drilling - normal drill and slots + if slot.hit.slot_type == DrillSlot.TYPE_ROUT: + + # For ROUT, setting the mode is part of the actual command. + + # Are we in the right position? + if slot.start != self._pos: + if self.drill_down: + # We need to move into the right position, so retract + self.body.append(RetractWithClampingStmt()) + self.drill_down = False + + # Move to the right spot + point = self._simplify_point(slot.start) + self._pos = slot.start + self.body.append(CoordinateStmt.from_point(point, mode="ROUT")) + + # Now we are in the right spot, so drill down + if not self.drill_down: + self.body.append(ZAxisRoutPositionStmt()) + self.drill_down = True + + # Do a linear move from our current position to the end position + point = self._simplify_point(slot.end) + self._pos = slot.end + self.body.append(CoordinateStmt.from_point(point, mode="LINEAR")) + + self.drill_mode = ExcellonContext.MODE_SLOT + + else: + # This is a G85 slot, so do this in normally drilling mode + if self.drill_mode != ExcellonContext.MODE_DRILL: + self._start_drill_mode() + + # Slots don't use simplified points + self._pos = slot.end + self.body.append(SlotStmt.from_points(slot.start, slot.end)) + + def _render_inverted_layer(self): + pass +
\ No newline at end of file diff --git a/gerber/render/render.py b/gerber/render/render.py index f5c58d8..b319648 100644 --- a/gerber/render/render.py +++ b/gerber/render/render.py @@ -23,12 +23,13 @@ Rendering Render Gerber and Excellon files to a variety of formats. The render module currently supports SVG rendering using the `svgwrite` library. """ + + +from ..primitives import * from ..gerber_statements import (CommentStmt, UnknownStmt, EofStmt, ParamStmt, CoordStmt, ApertureStmt, RegionModeStmt, - QuadrantModeStmt, -) + QuadrantModeStmt,) -from ..primitives import * class GerberContext(object): """ Gerber rendering context base class @@ -41,7 +42,7 @@ class GerberContext(object): Attributes ---------- units : string - Measurement units + Measurement units. 'inch' or 'metric' color : tuple (<float>, <float>, <float>) Color used for rendering as a tuple of normalized (red, green, blue) values. @@ -56,79 +57,89 @@ class GerberContext(object): alpha : float Rendering opacity. Between 0.0 (transparent) and 1.0 (opaque.) """ + 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_units(self, units): - """ Set context measurement units - - Parameters - ---------- - unit : string - Measurement units. may be 'inch' or 'metric' - - Raises - ------ - ValueError - If `unit` is not 'inch' or 'metric' - """ + self._units = units + self._color = (0.7215, 0.451, 0.200) + self._background_color = (0.0, 0.0, 0.0) + self._alpha = 1.0 + self._invert = False + self.ctx = None + + @property + def units(self): + return self._units + + @units.setter + def units(self, units): 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. - - Parameters - ---------- - color : tuple (<float>, <float>, <float>) - Color as a tuple of (red, green, blue) values. Each channel is - represented as a float value in (0, 1) - """ - self.color = color - - def set_drill_color(self, color): - """ Set color used for rendering drill hits. - - Parameters - ---------- - color : tuple (<float>, <float>, <float>) - Color as a tuple of (red, green, blue) values. Each channel is - represented as a float value in (0, 1) - """ - self.drill_color = color - - def set_background_color(self, color): - """ Set rendering background color - - Parameters - ---------- - color : tuple (<float>, <float>, <float>) - Color as a tuple of (red, green, blue) values. Each channel is - represented as a float value in (0, 1) - """ - self.background_color = color - - def set_alpha(self, alpha): - """ Set layer rendering opacity - - .. note:: - Not all backends/rendering devices support this parameter. - - Parameters - ---------- - alpha : float - Rendering opacity. must be between 0.0 (transparent) and 1.0 (opaque) - """ - self.alpha = alpha + self._units = units + + @property + def color(self): + return self._color + + @color.setter + def color(self, color): + if len(color) != 3: + raise TypeError('Color must be a tuple of R, G, and B values') + for c in color: + if c < 0 or c > 1: + raise ValueError('Channel values must be between 0.0 and 1.0') + self._color = color + + @property + def drill_color(self): + return self._drill_color + + @drill_color.setter + def drill_color(self, color): + if len(color) != 3: + raise TypeError('Drill color must be a tuple of R, G, and B values') + for c in color: + if c < 0 or c > 1: + raise ValueError('Channel values must be between 0.0 and 1.0') + self._drill_color = color + + @property + def background_color(self): + return self._background_color + + @background_color.setter + def background_color(self, color): + if len(color) != 3: + raise TypeError('Background color must be a tuple of R, G, and B values') + for c in color: + if c < 0 or c > 1: + raise ValueError('Channel values must be between 0.0 and 1.0') + self._background_color = color + + @property + def alpha(self): + return self._alpha + + @alpha.setter + def alpha(self, alpha): + if alpha < 0 or alpha > 1: + raise ValueError('Alpha must be between 0.0 and 1.0') + self._alpha = alpha + + @property + def invert(self): + return self._invert + + @invert.setter + def invert(self, invert): + self._invert = invert def render(self, primitive): - color = (self.color if primitive.level_polarity == 'dark' - else self.background_color) + if not primitive: + return + + self._pre_render_primitive(primitive) + + color = self.color if isinstance(primitive, Line): self._render_line(primitive, color) elif isinstance(primitive, Arc): @@ -142,11 +153,35 @@ class GerberContext(object): elif isinstance(primitive, Obround): self._render_obround(primitive, color) elif isinstance(primitive, Polygon): - self._render_polygon(Polygon, color) + self._render_polygon(primitive, color) elif isinstance(primitive, Drill): - self._render_drill(primitive, self.drill_color) - else: - return + self._render_drill(primitive, self.color) + elif isinstance(primitive, Slot): + self._render_slot(primitive, self.color) + elif isinstance(primitive, AMGroup): + self._render_amgroup(primitive, color) + elif isinstance(primitive, Outline): + self._render_region(primitive, color) + elif isinstance(primitive, TestRecord): + self._render_test_record(primitive, color) + + self._post_render_primitive(primitive) + + def _pre_render_primitive(self, primitive): + """ + Called before rendering a primitive. Use the callback to perform some action before rendering + a primitive, for example adding a comment. + """ + return + + def _post_render_primitive(self, primitive): + """ + Called after rendering a primitive. Use the callback to perform some action after rendering + a primitive + """ + return + + def _render_line(self, primitive, color): pass @@ -171,4 +206,21 @@ class GerberContext(object): def _render_drill(self, primitive, color): pass + + def _render_slot(self, primitive, color): + pass + + def _render_amgroup(self, primitive, color): + pass + + def _render_test_record(self, primitive, color): + pass + +class RenderSettings(object): + + def __init__(self, color=(0.0, 0.0, 0.0), alpha=1.0, invert=False, mirror=False): + self.color = color + self.alpha = alpha + self.invert = invert + self.mirror = mirror diff --git a/gerber/render/rs274x_backend.py b/gerber/render/rs274x_backend.py new file mode 100644 index 0000000..b4b4612 --- /dev/null +++ b/gerber/render/rs274x_backend.py @@ -0,0 +1,495 @@ +"""Renders an in-memory Gerber file to statements which can be written to a string +""" +from copy import deepcopy + +try: + from cStringIO import StringIO +except(ImportError): + from io import StringIO + +from .render import GerberContext +from ..am_statements import * +from ..gerber_statements import * +from ..primitives import AMGroup, Arc, Circle, Line, Obround, Outline, Polygon, Rectangle + + +class AMGroupContext(object): + '''A special renderer to generate aperature macros from an AMGroup''' + + def __init__(self): + self.statements = [] + + def render(self, amgroup, name): + + if amgroup.stmt: + # We know the statement it was generated from, so use that to create the AMParamStmt + # It will give a much better result + + stmt = deepcopy(amgroup.stmt) + stmt.name = name + + return stmt + + else: + # Clone ourselves, then offset by the psotion so that + # our render doesn't have to consider offset. Just makes things simpler + nooffset_group = deepcopy(amgroup) + nooffset_group.position = (0, 0) + + # Now draw the shapes + for primitive in nooffset_group.primitives: + if isinstance(primitive, Outline): + self._render_outline(primitive) + elif isinstance(primitive, Circle): + self._render_circle(primitive) + elif isinstance(primitive, Rectangle): + self._render_rectangle(primitive) + elif isinstance(primitive, Line): + self._render_line(primitive) + elif isinstance(primitive, Polygon): + self._render_polygon(primitive) + else: + raise ValueError('amgroup') + + statement = AMParamStmt('AM', name, self._statements_to_string()) + return statement + + def _statements_to_string(self): + macro = '' + + for statement in self.statements: + macro += statement.to_gerber() + + return macro + + def _render_circle(self, circle): + self.statements.append(AMCirclePrimitive.from_primitive(circle)) + + def _render_rectangle(self, rectangle): + self.statements.append(AMCenterLinePrimitive.from_primitive(rectangle)) + + def _render_line(self, line): + self.statements.append(AMVectorLinePrimitive.from_primitive(line)) + + def _render_outline(self, outline): + self.statements.append(AMOutlinePrimitive.from_primitive(outline)) + + def _render_polygon(self, polygon): + self.statements.append(AMPolygonPrimitive.from_primitive(polygon)) + + def _render_thermal(self, thermal): + pass + + +class Rs274xContext(GerberContext): + + def __init__(self, settings): + GerberContext.__init__(self) + self.comments = [] + self.header = [] + self.body = [] + self.end = [EofStmt()] + + # Current values so we know if we have to execute + # moves, levey changes before anything else + self._level_polarity = None + self._pos = (None, None) + self._func = None + self._quadrant_mode = None + self._dcode = None + + # Primarily for testing and comarison to files, should we write + # flashes as a single statement or a move plus flash? Set to true + # to do in a single statement. Normally this can be false + self.condensed_flash = True + + # When closing a region, force a D02 staement to close a region. + # This is normally not necessary because regions are closed with a G37 + # staement, but this will add an extra statement for doubly close + # the region + self.explicit_region_move_end = False + + self._next_dcode = 10 + self._rects = {} + self._circles = {} + self._obrounds = {} + self._polygons = {} + self._macros = {} + + self._i_none = 0 + self._j_none = 0 + + self.settings = settings + + self._start_header(settings) + + def _start_header(self, settings): + self.header.append(FSParamStmt.from_settings(settings)) + self.header.append(MOParamStmt.from_units(settings.units)) + + def _simplify_point(self, point): + return (point[0] if point[0] != self._pos[0] else None, point[1] if point[1] != self._pos[1] else None) + + def _simplify_offset(self, point, offset): + + if point[0] != offset[0]: + xoffset = point[0] - offset[0] + else: + xoffset = self._i_none + + if point[1] != offset[1]: + yoffset = point[1] - offset[1] + else: + yoffset = self._j_none + + return (xoffset, yoffset) + + @property + def statements(self): + return self.comments + self.header + self.body + self.end + + def set_bounds(self, bounds): + pass + + def _paint_background(self): + pass + + def _select_aperture(self, aperture): + + # Select the right aperture if not already selected + if aperture: + if isinstance(aperture, Circle): + aper = self._get_circle(aperture.diameter, aperture.hole_diameter) + elif isinstance(aperture, Rectangle): + aper = self._get_rectangle(aperture.width, aperture.height) + elif isinstance(aperture, Obround): + aper = self._get_obround(aperture.width, aperture.height) + elif isinstance(aperture, AMGroup): + aper = self._get_amacro(aperture) + else: + raise NotImplementedError('Line with invalid aperture type') + + if aper.d != self._dcode: + self.body.append(ApertureStmt(aper.d)) + self._dcode = aper.d + + def _pre_render_primitive(self, primitive): + + if hasattr(primitive, 'comment'): + self.body.append(CommentStmt(primitive.comment)) + + def _render_line(self, line, color): + + self._select_aperture(line.aperture) + + self._render_level_polarity(line) + + # Get the right function + if self._func != CoordStmt.FUNC_LINEAR: + func = CoordStmt.FUNC_LINEAR + else: + func = None + self._func = CoordStmt.FUNC_LINEAR + + if self._pos != line.start: + self.body.append(CoordStmt.move(func, self._simplify_point(line.start))) + self._pos = line.start + # We already set the function, so the next command doesn't require that + func = None + + point = self._simplify_point(line.end) + + # In some files, we see a lot of duplicated ponts, so omit those + if point[0] != None or point[1] != None: + self.body.append(CoordStmt.line(func, self._simplify_point(line.end))) + self._pos = line.end + elif func: + self.body.append(CoordStmt.mode(func)) + + def _render_arc(self, arc, color): + + # Optionally set the quadrant mode if it has changed: + if arc.quadrant_mode != self._quadrant_mode: + + if arc.quadrant_mode != 'multi-quadrant': + self.body.append(QuadrantModeStmt.single()) + else: + self.body.append(QuadrantModeStmt.multi()) + + self._quadrant_mode = arc.quadrant_mode + + # Select the right aperture if not already selected + self._select_aperture(arc.aperture) + + self._render_level_polarity(arc) + + # Find the right movement mode. Always set to be sure it is really right + dir = arc.direction + if dir == 'clockwise': + func = CoordStmt.FUNC_ARC_CW + self._func = CoordStmt.FUNC_ARC_CW + elif dir == 'counterclockwise': + func = CoordStmt.FUNC_ARC_CCW + self._func = CoordStmt.FUNC_ARC_CCW + else: + raise ValueError('Invalid circular interpolation mode') + + if self._pos != arc.start: + # TODO I'm not sure if this is right + self.body.append(CoordStmt.move(CoordStmt.FUNC_LINEAR, self._simplify_point(arc.start))) + self._pos = arc.start + + center = self._simplify_offset(arc.center, arc.start) + end = self._simplify_point(arc.end) + self.body.append(CoordStmt.arc(func, end, center)) + self._pos = arc.end + + def _render_region(self, region, color): + + self._render_level_polarity(region) + + self.body.append(RegionModeStmt.on()) + + for p in region.primitives: + + if isinstance(p, Line): + self._render_line(p, color) + else: + self._render_arc(p, color) + + if self.explicit_region_move_end: + self.body.append(CoordStmt.move(None, None)) + + self.body.append(RegionModeStmt.off()) + + def _render_level_polarity(self, region): + if region.level_polarity != self._level_polarity: + self._level_polarity = region.level_polarity + self.body.append(LPParamStmt.from_region(region)) + + def _render_flash(self, primitive, aperture): + + self._render_level_polarity(primitive) + + if aperture.d != self._dcode: + self.body.append(ApertureStmt(aperture.d)) + self._dcode = aperture.d + + if self.condensed_flash: + self.body.append(CoordStmt.flash(self._simplify_point(primitive.position))) + else: + self.body.append(CoordStmt.move(None, self._simplify_point(primitive.position))) + self.body.append(CoordStmt.flash(None)) + + self._pos = primitive.position + + def _get_circle(self, diameter, hole_diameter, dcode = None): + '''Define a circlar aperture''' + + aper = self._circles.get((diameter, hole_diameter), None) + + if not aper: + if not dcode: + dcode = self._next_dcode + self._next_dcode += 1 + else: + self._next_dcode = max(dcode + 1, self._next_dcode) + + aper = ADParamStmt.circle(dcode, diameter, hole_diameter) + self._circles[(diameter, hole_diameter)] = aper + self.header.append(aper) + + return aper + + def _render_circle(self, circle, color): + + aper = self._get_circle(circle.diameter, circle.hole_diameter) + self._render_flash(circle, aper) + + def _get_rectangle(self, width, height, dcode = None): + '''Get a rectanglar aperture. If it isn't defined, create it''' + + key = (width, height) + aper = self._rects.get(key, None) + + if not aper: + if not dcode: + dcode = self._next_dcode + self._next_dcode += 1 + else: + self._next_dcode = max(dcode + 1, self._next_dcode) + + aper = ADParamStmt.rect(dcode, width, height) + self._rects[(width, height)] = aper + self.header.append(aper) + + return aper + + def _render_rectangle(self, rectangle, color): + + aper = self._get_rectangle(rectangle.width, rectangle.height) + self._render_flash(rectangle, aper) + + def _get_obround(self, width, height, dcode = None): + + key = (width, height) + aper = self._obrounds.get(key, None) + + if not aper: + if not dcode: + dcode = self._next_dcode + self._next_dcode += 1 + else: + self._next_dcode = max(dcode + 1, self._next_dcode) + + aper = ADParamStmt.obround(dcode, width, height) + self._obrounds[key] = aper + self.header.append(aper) + + return aper + + def _render_obround(self, obround, color): + + aper = self._get_obround(obround.width, obround.height) + self._render_flash(obround, aper) + + def _render_polygon(self, polygon, color): + + aper = self._get_polygon(polygon.radius, polygon.sides, polygon.rotation, polygon.hole_radius) + self._render_flash(polygon, aper) + + def _get_polygon(self, radius, num_vertices, rotation, hole_radius, dcode = None): + + key = (radius, num_vertices, rotation, hole_radius) + aper = self._polygons.get(key, None) + + if not aper: + if not dcode: + dcode = self._next_dcode + self._next_dcode += 1 + else: + self._next_dcode = max(dcode + 1, self._next_dcode) + + aper = ADParamStmt.polygon(dcode, radius * 2, num_vertices, rotation, hole_radius * 2) + self._polygons[key] = aper + self.header.append(aper) + + return aper + + def _render_drill(self, drill, color): + raise ValueError('Drills are not valid in RS274X files') + + def _hash_amacro(self, amgroup): + '''Calculate a very quick hash code for deciding if we should even check AM groups for comparision''' + + # We always start with an X because this forms part of the name + # Basically, in some cases, the name might start with a C, R, etc. That can appear + # to conflict with normal aperture definitions. Technically, it shouldn't because normal + # aperture definitions should have a comma, but in some cases the commit is omitted + hash = 'X' + for primitive in amgroup.primitives: + + hash += primitive.__class__.__name__[0] + + bbox = primitive.bounding_box + hash += str((bbox[0][1] - bbox[0][0]) * 100000)[0:2] + hash += str((bbox[1][1] - bbox[1][0]) * 100000)[0:2] + + if hasattr(primitive, 'primitives'): + hash += str(len(primitive.primitives)) + + if isinstance(primitive, Rectangle): + hash += str(primitive.width * 1000000)[0:2] + hash += str(primitive.height * 1000000)[0:2] + elif isinstance(primitive, Circle): + hash += str(primitive.diameter * 1000000)[0:2] + + if len(hash) > 20: + # The hash might actually get quite complex, so stop before + # it gets too long + break + + return hash + + def _get_amacro(self, amgroup, dcode = None): + # Macros are a little special since we don't have a good way to compare them quickly + # but in most cases, this should work + + hash = self._hash_amacro(amgroup) + macro = None + macroinfo = self._macros.get(hash, None) + + if macroinfo: + + # We have a definition, but check that the groups actually are the same + for macro in macroinfo: + + # Macros should have positions, right? But if the macro is selected for non-flashes + # then it won't have a position. This is of course a bad gerber, but they do exist + if amgroup.position: + position = amgroup.position + else: + position = (0, 0) + + offset = (position[0] - macro[1].position[0], position[1] - macro[1].position[1]) + if amgroup.equivalent(macro[1], offset): + break + macro = None + + # Did we find one in the group0 + if not macro: + # This is a new macro, so define it + if not dcode: + dcode = self._next_dcode + self._next_dcode += 1 + else: + self._next_dcode = max(dcode + 1, self._next_dcode) + + # Create the statements + # TODO + amrenderer = AMGroupContext() + statement = amrenderer.render(amgroup, hash) + + self.header.append(statement) + + aperdef = ADParamStmt.macro(dcode, hash) + self.header.append(aperdef) + + # Store the dcode and the original so we can check if it really is the same + # If it didn't have a postition, set it to 0, 0 + if amgroup.position == None: + amgroup.position = (0, 0) + macro = (aperdef, amgroup) + + if macroinfo: + macroinfo.append(macro) + else: + self._macros[hash] = [macro] + + return macro[0] + + def _render_amgroup(self, amgroup, color): + + aper = self._get_amacro(amgroup) + self._render_flash(amgroup, aper) + + def _render_inverted_layer(self): + pass + + def _new_render_layer(self): + # TODO Might need to implement this + pass + + def _flatten(self): + # TODO Might need to implement this + pass + + def dump(self): + """Write the rendered file to a StringIO steam""" + statements = map(lambda stmt: stmt.to_gerber(self.settings), self.statements) + stream = StringIO() + for statement in statements: + stream.write(statement + '\n') + + return stream +
\ No newline at end of file diff --git a/gerber/render/svgwrite_backend.py b/gerber/render/svgwrite_backend.py deleted file mode 100644 index 2df87b3..0000000 --- a/gerber/render/svgwrite_backend.py +++ /dev/null @@ -1,155 +0,0 @@ -#! /usr/bin/env python -# -*- coding: utf-8 -*- - -# Copyright 2014 Hamilton Kibbe <ham@hamiltonkib.be> -# Based on render_svg.py by Paulo Henrique Silva <ph.silva@gmail.com> - -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at - -# http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -from .render import GerberContext -from operator import mul -import svgwrite - -SCALE = 300 - - -def svg_color(color): - color = tuple([int(ch * 255) for ch in color]) - return 'rgb(%d, %d, %d)' % color - - -class GerberSvgContext(GerberContext): - def __init__(self): - GerberContext.__init__(self) - self.scale = (SCALE, -SCALE) - self.dwg = svgwrite.Drawing() - self.background = False - - 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])) - if not self.background: - 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 _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) - - # 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, circle, color): - center = map(mul, circle.position, self.scale) - hit = self.dwg.circle(center=center, r=SCALE * circle.radius, - fill=svg_color(color)) - self.dwg.add(hit) diff --git a/gerber/render/theme.py b/gerber/render/theme.py new file mode 100644 index 0000000..6135ccb --- /dev/null +++ b/gerber/render/theme.py @@ -0,0 +1,70 @@ +#! /usr/bin/env python +# -*- coding: utf-8 -*- + +# Copyright 2013-2014 Paulo Henrique Silva <ph.silva@gmail.com> + +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at + +# http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from .render import RenderSettings + +COLORS = { + 'black': (0.0, 0.0, 0.0), + 'white': (1.0, 1.0, 1.0), + 'red': (1.0, 0.0, 0.0), + 'green': (0.0, 1.0, 0.0), + 'blue': (0.0, 0.0, 1.0), + 'fr-4': (0.290, 0.345, 0.0), + 'green soldermask': (0.0, 0.612, 0.396), + 'blue soldermask': (0.059, 0.478, 0.651), + 'red soldermask': (0.968, 0.169, 0.165), + 'black soldermask': (0.298, 0.275, 0.282), + 'purple soldermask': (0.2, 0.0, 0.334), + 'enig copper': (0.686, 0.525, 0.510), + 'hasl copper': (0.871, 0.851, 0.839) +} + + +class Theme(object): + + def __init__(self, name=None, **kwargs): + self.name = 'Default' if name is None else name + self.background = kwargs.get('background', RenderSettings(COLORS['black'], alpha=0.0)) + self.topsilk = kwargs.get('topsilk', RenderSettings(COLORS['white'])) + self.bottomsilk = kwargs.get('bottomsilk', RenderSettings(COLORS['white'])) + self.topmask = kwargs.get('topmask', RenderSettings(COLORS['green soldermask'], alpha=0.8, invert=True)) + self.bottommask = kwargs.get('bottommask', RenderSettings(COLORS['green soldermask'], alpha=0.8, invert=True)) + self.top = kwargs.get('top', RenderSettings(COLORS['hasl copper'])) + self.bottom = kwargs.get('top', RenderSettings(COLORS['hasl copper'])) + self.drill = kwargs.get('drill', RenderSettings(COLORS['black'])) + self.ipc_netlist = kwargs.get('ipc_netlist', RenderSettings(COLORS['red'])) + + def __getitem__(self, key): + return getattr(self, key) + + def get(self, key, noneval=None): + val = getattr(self, key) + return val if val is not None else noneval + + +THEMES = { + 'default': Theme(), + 'OSH Park': Theme(name='OSH Park', + top=RenderSettings(COLORS['enig copper']), + bottom=RenderSettings(COLORS['enig copper']), + topmask=RenderSettings(COLORS['purple soldermask'], alpha=0.8, invert=True), + bottommask=RenderSettings(COLORS['purple soldermask'], alpha=0.8, invert=True)), + 'Blue': Theme(name='Blue', + topmask=RenderSettings(COLORS['blue soldermask'], alpha=0.8, invert=True), + bottommask=RenderSettings(COLORS['blue soldermask'], alpha=0.8, invert=True)), +} |