jaseg/gerbonara
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge in negative soldermask. Still required further changes to support negatives for shapes that dont exist in the merge source

Browse source
This commit is contained in:
Garret Fick 2016-07-17 10:42:03 +08:00
commit 0dded38353
13 changed files with 319 additions and 143 deletions
Download patch file Download diff file Expand all files Collapse all files

1
README.md
View file

@ -27,6 +27,7 @@ Rendering Examples:
-------------------
###Top Composite rendering
![Composite Top Image](examples/cairo_example.png)
Source code for this example can be found [here](examples/cairo_example.py).

BIN
examples/cairo_example.png
View file

Binary file not shown.
Side by side Swipe Overlay

Before

Width:  |  Height:  |  Size: 108 KiB

After

Width:  |  Height:  |  Size: 102 KiB

Before After
Before After

19
examples/cairo_example.py
View file

@ -25,7 +25,7 @@ a .png file.
import os
from gerber import read
from gerber.render import GerberCairoContext
from gerber.render import GerberCairoContext, theme
GERBER_FOLDER = os.path.abspath(os.path.join(os.path.dirname(__file__), 'gerbers'))
@ -40,25 +40,30 @@ drill = read(os.path.join(GERBER_FOLDER, 'ncdrill.DRD'))
# Create a new drawing context
ctx = GerberCairoContext()
# Set opacity and color for copper layer
ctx.alpha = 1.0
ctx.color = theme.COLORS['hasl copper']
# Draw the copper layer
copper.render(ctx)
# Set opacity and color for soldermask layer
ctx.alpha = 0.6
ctx.color = (0.2, 0.2, 0.75)
ctx.alpha = 0.75
ctx.color = theme.COLORS['green soldermask']
# Draw the soldermask layer
mask.render(ctx)
mask.render(ctx, invert=True)
# Set opacity and color for silkscreen layer
ctx.alpha = 0.85
ctx.color = (1, 1, 1)
ctx.alpha = 1.0
ctx.color = theme.COLORS['white']
# Draw the silkscreen layer
silk.render(ctx)
# Set opacity for drill layer
ctx.alpha = 1.
ctx.alpha = 1.0
ctx.color = theme.COLORS['black']
drill.render(ctx)
# Write output to png file

10
gerber/cam.py
View file

@ -248,7 +248,7 @@ class CamFile(object):
"""
pass
def render(self, ctx, filename=None):
def render(self, ctx, invert=False, filename=None):
""" Generate image of layer.
Parameters
@ -262,10 +262,14 @@ class CamFile(object):
ctx.set_bounds(self.bounds)
ctx._paint_background()
if ctx.invert:
if invert:
ctx.invert = True
ctx._paint_inverted_layer()
for p in self.primitives:
ctx.render(p)
if invert:
ctx.invert = False
ctx._render_mask()
if filename is not None:
ctx.dump(filename)

9
gerber/common.py
View file

@ -17,9 +17,11 @@
from . import rs274x
from . import excellon
from .exceptions import ParseError
from .utils import detect_file_format
def read(filename):
""" Read a gerber or excellon file and return a representative object.
@ -35,14 +37,15 @@ def read(filename):
ExcellonFile. Returns None if file is not an Excellon or Gerber file.
"""
with open(filename, 'rU') as f:
data = f.read()
data = f.read()
fmt = detect_file_format(data)
if fmt == 'rs274x':
return rs274x.read(filename)
elif fmt == 'excellon':
return excellon.read(filename)
else:
raise TypeError('Unable to detect file format')
raise ParseError('Unable to detect file format')
def loads(data):
""" Read gerber or excellon file contents from a string and return a
@ -59,7 +62,7 @@ def loads(data):
CncFile object representing the file, either GerberFile or
ExcellonFile. Returns None if file is not an Excellon or Gerber file.
"""
fmt = detect_file_format(data)
if fmt == 'rs274x':
return rs274x.loads(data)

22
gerber/excellon.py
View file

@ -26,16 +26,18 @@ This module provides Excellon file classes and parsing utilities
import math
import operator
from .cam import CamFile, FileSettings
from .excellon_statements import *
from .excellon_tool import ExcellonToolDefinitionParser
from .primitives import Drill, Slot
from .utils import inch, metric
try:
from cStringIO import StringIO
except(ImportError):
from io import StringIO
from .excellon_statements import *
from .excellon_tool import ExcellonToolDefinitionParser
from .cam import CamFile, FileSettings
from .primitives import Drill, Slot
from .utils import inch, metric
def read(filename):
@ -56,8 +58,8 @@ def read(filename):
data = f.read()
settings = FileSettings(**detect_excellon_format(data))
return ExcellonParser(settings).parse(filename)
def loads(data, settings = None, tools = None):
def loads(data, settings = None, tools = None):
""" Read data from string and return an ExcellonFile
Parameters
----------
@ -402,13 +404,13 @@ class ExcellonParser(object):
def parse_raw(self, data, filename=None):
for line in StringIO(data):
self._parse(line.strip())
self._parse_line(line.strip())
for stmt in self.statements:
stmt.units = self.units
return ExcellonFile(self.statements, self.tools, self.hits,
self._settings(), filename)
def _parse(self, line):
def _parse_line(self, line):
# skip empty lines
if not line.strip():
return
@ -599,7 +601,7 @@ class ExcellonParser(object):
elif line[0] == 'T' and self.state != 'HEADER':
stmt = ToolSelectionStmt.from_excellon(line)
self.statements.append(stmt)
# T0 is used as END marker, just ignore
if stmt.tool != 0:
tool = self._get_tool(stmt.tool)

31
gerber/exceptions.py Normal file
View file

@ -0,0 +1,31 @@
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright 2015 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.
class ParseError(Exception):
pass
class GerberParseError(ParseError):
pass
class ExcellonParseError(ParseError):
pass
class ExcellonFileError(IOError):
pass
class GerberFileError(IOError):
pass

182
gerber/render/cairo_backend.py
View file

@ -28,6 +28,7 @@ import tempfile
from ..primitives import *
class GerberCairoContext(GerberContext):
def __init__(self, scale=300):
GerberContext.__init__(self)
@ -35,12 +36,17 @@ class GerberCairoContext(GerberContext):
self.surface = None
self.ctx = None
self.bg = False
self.mask = None
self.mask_ctx = None
self.origin_in_pixels = None
self.size_in_pixels = None
def set_bounds(self, bounds):
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 = map(mul, size_in_inch, self.scale)
self.origin_in_pixels = tuple(map(mul, origin_in_inch, self.scale)) if self.origin_in_pixels is None else self.origin_in_pixels
self.size_in_pixels = size_in_pixels if self.size_in_pixels is None else self.size_in_pixels
if self.surface is None:
self.surface_buffer = tempfile.NamedTemporaryFile()
self.surface = cairo.SVGSurface(self.surface_buffer, size_in_pixels[0], size_in_pixels[1])
@ -48,29 +54,38 @@ class GerberCairoContext(GerberContext):
self.ctx.set_fill_rule(cairo.FILL_RULE_EVEN_ODD)
self.ctx.scale(1, -1)
self.ctx.translate(-(origin_in_inch[0] * self.scale[0]), (-origin_in_inch[1]*self.scale[0]) - size_in_pixels[1])
# self.ctx.translate(-(origin_in_inch[0] * self.scale[0]), -origin_in_inch[1]*self.scale[1])
self.mask = cairo.SVGSurface(None, size_in_pixels[0], size_in_pixels[1])
self.mask_ctx = cairo.Context(self.mask)
self.mask_ctx.set_fill_rule(cairo.FILL_RULE_EVEN_ODD)
self.mask_ctx.scale(1, -1)
self.mask_ctx.translate(-(origin_in_inch[0] * self.scale[0]), (-origin_in_inch[1]*self.scale[0]) - size_in_pixels[1])
def _render_line(self, line, color):
start = map(mul, line.start, self.scale)
end = map(mul, line.end, self.scale)
if not self.invert:
ctx = self.ctx
ctx.set_source_rgba(color[0], color[1], color[2], alpha=self.alpha)
ctx.set_operator(cairo.OPERATOR_OVER if line.level_polarity == "dark" else cairo.OPERATOR_CLEAR)
else:
ctx = self.mask_ctx
ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)
ctx.set_operator(cairo.OPERATOR_CLEAR)
if isinstance(line.aperture, Circle):
width = line.aperture.diameter
self.ctx.set_source_rgba(color[0], color[1], color[2], self.alpha)
self.ctx.set_operator(cairo.OPERATOR_OVER if (line.level_polarity == "dark" and not self.invert) else cairo.OPERATOR_CLEAR)
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()
ctx.set_line_width(width * self.scale[0])
ctx.set_line_cap(cairo.LINE_CAP_ROUND)
ctx.move_to(*start)
ctx.line_to(*end)
ctx.stroke()
elif isinstance(line.aperture, Rectangle):
points = [tuple(map(mul, x, self.scale)) for x in line.vertices]
self.ctx.set_source_rgba(color[0], color[1], color[2], self.alpha)
self.ctx.set_operator(cairo.OPERATOR_OVER if (line.level_polarity == "dark" and not self.invert) else cairo.OPERATOR_CLEAR)
self.ctx.set_line_width(0)
self.ctx.move_to(*points[0])
ctx.set_line_width(0)
ctx.move_to(*points[0])
for point in points[1:]:
self.ctx.line_to(*point)
self.ctx.fill()
ctx.line_to(*point)
ctx.fill()
def _render_arc(self, arc, color):
center = map(mul, arc.center, self.scale)
@ -86,27 +101,42 @@ class GerberCairoContext(GerberContext):
width = arc.aperture.diameter if arc.aperture.diameter != 0 else 0.001
else:
width = max(arc.aperture.width, arc.aperture.height, 0.001)
self.ctx.set_source_rgba(color[0], color[1], color[2], self.alpha)
self.ctx.set_operator(cairo.OPERATOR_OVER if (arc.level_polarity == "dark" and not self.invert)else cairo.OPERATOR_CLEAR)
self.ctx.set_line_width(width * self.scale[0])
self.ctx.set_line_cap(cairo.LINE_CAP_ROUND)
self.ctx.move_to(*start) # You actually have to do this...
if arc.direction == 'counterclockwise':
self.ctx.arc(center[0], center[1], radius, angle1, angle2)
if not self.invert:
ctx = self.ctx
ctx.set_source_rgba(color[0], color[1], color[2], alpha=self.alpha)
ctx.set_operator(cairo.OPERATOR_OVER if arc.level_polarity == "dark" else cairo.OPERATOR_CLEAR)
else:
self.ctx.arc_negative(center[0], center[1], radius, angle1, angle2)
self.ctx.move_to(*end) # ...lame
self.ctx.stroke()
ctx = self.mask_ctx
ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)
ctx.set_operator(cairo.OPERATOR_CLEAR)
ctx.set_line_width(width * self.scale[0])
ctx.set_line_cap(cairo.LINE_CAP_ROUND)
ctx.move_to(*start) # You actually have to do this...
if arc.direction == 'counterclockwise':
ctx.arc(center[0], center[1], radius, angle1, angle2)
else:
ctx.arc_negative(center[0], center[1], radius, angle1, angle2)
ctx.move_to(*end) # ...lame
ctx.stroke()
def _render_region(self, region, color):
self.ctx.set_source_rgba(color[0], color[1], color[2], self.alpha)
self.ctx.set_operator(cairo.OPERATOR_OVER if (region.level_polarity == "dark" and not self.invert) else cairo.OPERATOR_CLEAR)
self.ctx.set_line_width(0)
self.ctx.set_line_cap(cairo.LINE_CAP_ROUND)
self.ctx.move_to(*tuple(map(mul, region.primitives[0].start, self.scale)))
if not self.invert:
ctx = self.ctx
ctx.set_source_rgba(color[0], color[1], color[2], alpha=self.alpha)
ctx.set_operator(cairo.OPERATOR_OVER if region.level_polarity == "dark" else cairo.OPERATOR_CLEAR)
else:
ctx = self.mask_ctx
ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)
ctx.set_operator(cairo.OPERATOR_CLEAR)
ctx.set_line_width(0)
ctx.set_line_cap(cairo.LINE_CAP_ROUND)
ctx.move_to(*tuple(map(mul, region.primitives[0].start, self.scale)))
for p in region.primitives:
if isinstance(p, Line):
self.ctx.line_to(*tuple(map(mul, p.end, self.scale)))
ctx.line_to(*tuple(map(mul, p.end, self.scale)))
else:
center = map(mul, p.center, self.scale)
start = map(mul, p.start, self.scale)
@ -115,25 +145,40 @@ class GerberCairoContext(GerberContext):
angle1 = p.start_angle
angle2 = p.end_angle
if p.direction == 'counterclockwise':
self.ctx.arc(center[0], center[1], radius, angle1, angle2)
ctx.arc(center[0], center[1], radius, angle1, angle2)
else:
self.ctx.arc_negative(center[0], center[1], radius, angle1, angle2)
self.ctx.fill()
ctx.arc_negative(center[0], center[1], radius, angle1, angle2)
ctx.fill()
def _render_circle(self, circle, color):
center = tuple(map(mul, circle.position, self.scale))
self.ctx.set_source_rgba(color[0], color[1], color[2], self.alpha)
self.ctx.set_operator(cairo.OPERATOR_OVER if (circle.level_polarity == "dark" and not self.invert) else cairo.OPERATOR_CLEAR)
self.ctx.set_line_width(0)
self.ctx.arc(center[0], center[1], circle.radius * self.scale[0], 0, 2 * math.pi)
self.ctx.fill()
if not self.invert:
ctx = self.ctx
ctx.set_source_rgba(*color, alpha=self.alpha)
ctx.set_operator(cairo.OPERATOR_OVER if circle.level_polarity == "dark" else cairo.OPERATOR_CLEAR)
else:
ctx = self.mask_ctx
ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)
ctx.set_operator(cairo.OPERATOR_CLEAR)
ctx.set_line_width(0)
ctx.arc(center[0], center[1], radius=circle.radius * self.scale[0], angle1=0, angle2=2 * math.pi)
ctx.fill()
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)))
if not self.invert:
ctx = self.ctx
ctx.set_source_rgba(color[0], color[1], color[2], alpha=self.alpha)
ctx.set_operator(cairo.OPERATOR_OVER if rectangle.level_polarity == "dark" else cairo.OPERATOR_CLEAR)
else:
ctx = self.mask_ctx
ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)
ctx.set_operator(cairo.OPERATOR_CLEAR)
if rectangle.rotation != 0:
self.ctx.save()
ctx.save()
center = map(mul, rectangle.position, self.scale)
matrix = cairo.Matrix()
@ -142,16 +187,14 @@ class GerberCairoContext(GerberContext):
ll[0] = ll[0] - center[0]
ll[1] = ll[1] - center[1]
matrix.rotate(rectangle.rotation)
self.ctx.transform(matrix)
self.ctx.set_source_rgba(color[0], color[1], color[2], self.alpha)
self.ctx.set_operator(cairo.OPERATOR_OVER if (rectangle.level_polarity == "dark" and not self.invert) else cairo.OPERATOR_CLEAR)
self.ctx.set_line_width(0)
self.ctx.rectangle(ll[0], ll[1], width, height)
self.ctx.fill()
ctx.transform(matrix)
ctx.set_line_width(0)
ctx.rectangle(ll[0], ll[1], width, height)
ctx.fill()
if rectangle.rotation != 0:
self.ctx.restore()
ctx.restore()
def _render_obround(self, obround, color):
self._render_circle(obround.subshapes['circle1'], color)
@ -196,14 +239,21 @@ class GerberCairoContext(GerberContext):
end = map(mul, slot.end, self.scale)
width = slot.diameter
if not self.invert:
ctx = self.ctx
ctx.set_source_rgba(color[0], color[1], color[2], alpha=self.alpha)
ctx.set_operator(cairo.OPERATOR_OVER if slot.level_polarity == "dark" else cairo.OPERATOR_CLEAR)
else:
ctx = self.mask_ctx
ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)
ctx.set_operator(cairo.OPERATOR_CLEAR)
self.ctx.set_source_rgba(color[0], color[1], color[2], self.alpha)
self.ctx.set_operator(cairo.OPERATOR_OVER if (slot.level_polarity == "dark" and not self.invert) else cairo.OPERATOR_CLEAR)
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()
ctx.set_line_width(width * self.scale[0])
ctx.set_line_cap(cairo.LINE_CAP_ROUND)
ctx.move_to(*start)
ctx.line_to(*end)
ctx.stroke()
def _render_amgroup(self, amgroup, color):
self.ctx.push_group()
@ -217,17 +267,23 @@ class GerberCairoContext(GerberContext):
self.ctx.set_font_size(200)
self._render_circle(Circle(primitive.position, 0.01), color)
self.ctx.set_source_rgb(*color)
self.ctx.set_operator(cairo.OPERATOR_OVER if (primitive.level_polarity == "dark" and not self.invert) else cairo.OPERATOR_CLEAR)
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.01) for coord in primitive.position])
self.ctx.scale(1, -1)
self.ctx.show_text(primitive.net_name)
self.ctx.scale(1, -1)
def _paint_inverted_layer(self):
self.ctx.set_source_rgba(self.background_color[0], self.background_color[1], self.background_color[2])
def _paint_inverted_layer(self):
self.mask_ctx.set_operator(cairo.OPERATOR_OVER)
self.mask_ctx.set_source_rgba(self.background_color[0], self.background_color[1], self.background_color[2], alpha=self.alpha)
self.mask_ctx.paint()
def _render_mask(self):
self.ctx.set_operator(cairo.OPERATOR_OVER)
ptn = cairo.SurfacePattern(self.mask)
ptn.set_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]))
self.ctx.set_source(ptn)
self.ctx.paint()
self.ctx.set_operator(cairo.OPERATOR_CLEAR)
def _paint_background(self):
if not self.bg:
@ -237,21 +293,17 @@ class GerberCairoContext(GerberContext):
def dump(self, filename):
is_svg = filename.lower().endswith(".svg")
if is_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.write_to_png(filename)
def dump_svg_str(self):
self.surface.finish()
self.surface_buffer.flush()
return self.surface_buffer.read()

23
gerber/render/render.py
View file

@ -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 ..gerber_statements import (CommentStmt, UnknownStmt, EofStmt, ParamStmt,
CoordStmt, ApertureStmt, RegionModeStmt,
QuadrantModeStmt,
)
from ..primitives import *
from ..gerber_statements import (CommentStmt, UnknownStmt, EofStmt, ParamStmt,
CoordStmt, ApertureStmt, RegionModeStmt,
QuadrantModeStmt,)
class GerberContext(object):
""" Gerber rendering context base class
@ -213,3 +214,17 @@ class GerberContext(object):
def _render_test_record(self, primitive, color):
pass
class Renderable(object):
def __init__(self, color=None, alpha=None, invert=False):
self.color = color
self.alpha = alpha
self.invert = invert
def to_render(self):
""" Override this in subclass. Should return a list of Primitives or Renderables
"""
raise NotImplementedError('to_render() must be implemented in subclass')
def apply_theme(self, theme):
raise NotImplementedError('apply_theme() must be implemented in subclass')

50
gerber/render/theme.py Normal file
View file

@ -0,0 +1,50 @@
#! /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.
COLORS = {
'black': (0.0, 0.0, 0.0),
'white': (1.0, 1.0, 1.0),
'fr-4': (0.702, 0.655, 0.192),
'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),
'enig copper': (0.780, 0.588, 0.286),
'hasl copper': (0.871, 0.851, 0.839)
}
class RenderSettings(object):
def __init__(self, color, alpha=1.0, invert=False):
self.color = color
self.alpha = alpha
self.invert = False
class Theme(object):
def __init__(self, **kwargs):
self.background = kwargs.get('background', RenderSettings(COLORS['black'], 0.0))
self.topsilk = kwargs.get('topsilk', RenderSettings(COLORS['white']))
self.topsilk = kwargs.get('bottomsilk', RenderSettings(COLORS['white']))
self.topmask = kwargs.get('topmask', RenderSettings(COLORS['green soldermask'], 0.8, True))
self.topmask = kwargs.get('topmask', RenderSettings(COLORS['green soldermask'], 0.8, True))
self.top = kwargs.get('top', RenderSettings(COLORS['hasl copper']))
self.bottom = kwargs.get('top', RenderSettings(COLORS['hasl copper']))
self.drill = kwargs.get('drill', self.background)

68
gerber/rs274x.py
View file

@ -27,7 +27,7 @@ try:
from cStringIO import StringIO
except(ImportError):
from io import StringIO
from .gerber_statements import *
from .primitives import *
from .cam import CamFile, FileSettings
@ -51,8 +51,21 @@ def read(filename):
def loads(data):
""" Generate a GerberFile object from rs274x data in memory
Parameters
----------
data : string
string containing gerber file contents
Returns
-------
file : :class:`gerber.rs274x.GerberFile`
A GerberFile created from the specified file.
"""
return GerberParser().parse_raw(data)
class GerberFile(CamFile):
""" A class representing a single gerber file
@ -234,7 +247,7 @@ class GerberParser(object):
def parse(self, filename):
with open(filename, "rU") as fp:
data = fp.read()
return self.parse_raw(data, filename=None)
return self.parse_raw(data, filename)
def parse_raw(self, data, filename=None):
for stmt in self._parse(self._split_commands(data)):
@ -303,7 +316,6 @@ class GerberParser(object):
oldline = line
continue
did_something = True # make sure we do at least one loop
while did_something and len(line) > 0:
did_something = False
@ -321,23 +333,7 @@ class GerberParser(object):
line = r
did_something = True
continue
# Region Mode
(mode, r) = _match_one(self.REGION_MODE_STMT, line)
if mode:
yield RegionModeStmt.from_gerber(line)
line = r
did_something = True
continue
# Quadrant Mode
(mode, r) = _match_one(self.QUAD_MODE_STMT, line)
if mode:
yield QuadrantModeStmt.from_gerber(line)
line = r
did_something = True
continue
# aperture selection
(aperture, r) = _match_one(self.APERTURE_STMT, line)
if aperture:
@ -346,14 +342,6 @@ class GerberParser(object):
line = r
continue
# comment
(comment, r) = _match_one(self.COMMENT_STMT, line)
if comment:
yield CommentStmt(comment["comment"])
did_something = True
line = r
continue
# parameter
(param, r) = _match_one_from_many(self.PARAM_STMT, line)
@ -406,6 +394,30 @@ class GerberParser(object):
line = r
continue
# Region Mode
(mode, r) = _match_one(self.REGION_MODE_STMT, line)
if mode:
yield RegionModeStmt.from_gerber(line)
line = r
did_something = True
continue
# Quadrant Mode
(mode, r) = _match_one(self.QUAD_MODE_STMT, line)
if mode:
yield QuadrantModeStmt.from_gerber(line)
line = r
did_something = True
continue
# comment
(comment, r) = _match_one(self.COMMENT_STMT, line)
if comment:
yield CommentStmt(comment["comment"])
did_something = True
line = r
continue
# deprecated codes
(deprecated_unit, r) = _match_one(self.DEPRECATED_UNIT, line)
if deprecated_unit:

5
gerber/tests/test_common.py
View file

@ -2,6 +2,7 @@
# -*- coding: utf-8 -*-
# Author: Hamilton Kibbe <ham@hamiltonkib.be>
from ..exceptions import ParseError
from ..common import read, loads
from ..excellon import ExcellonFile
from ..rs274x import GerberFile
@ -31,12 +32,12 @@ def test_load_from_string():
top_copper = loads(f.read())
assert_true(isinstance(ncdrill, ExcellonFile))
assert_true(isinstance(top_copper, GerberFile))
def test_file_type_validation():
""" Test file format validation
"""
assert_raises(TypeError, read, 'LICENSE')
assert_raises(ParseError, read, 'LICENSE')

42
gerber/tests/test_excellon.py
View file

@ -99,60 +99,60 @@ def test_parser_hole_sizes():
def test_parse_whitespace():
p = ExcellonParser(FileSettings())
assert_equal(p._parse(' '), None)
assert_equal(p._parse_line(' '), None)
def test_parse_comment():
p = ExcellonParser(FileSettings())
p._parse(';A comment')
p._parse_line(';A comment')
assert_equal(p.statements[0].comment, 'A comment')
def test_parse_format_comment():
p = ExcellonParser(FileSettings())
p._parse('; FILE_FORMAT=9:9 ')
p._parse_line('; FILE_FORMAT=9:9 ')
assert_equal(p.format, (9, 9))
def test_parse_header():
p = ExcellonParser(FileSettings())
p._parse('M48 ')
p._parse_line('M48 ')
assert_equal(p.state, 'HEADER')
p._parse('M95 ')
p._parse_line('M95 ')
assert_equal(p.state, 'DRILL')
def test_parse_rout():
p = ExcellonParser(FileSettings())
p._parse('G00 ')
p._parse_line('G00 ')
assert_equal(p.state, 'ROUT')
p._parse('G05 ')
p._parse_line('G05 ')
assert_equal(p.state, 'DRILL')
def test_parse_version():
p = ExcellonParser(FileSettings())
p._parse('VER,1 ')
p._parse_line('VER,1 ')
assert_equal(p.statements[0].version, 1)
p._parse('VER,2 ')
p._parse_line('VER,2 ')
assert_equal(p.statements[1].version, 2)
def test_parse_format():
p = ExcellonParser(FileSettings())
p._parse('FMAT,1 ')
p._parse_line('FMAT,1 ')
assert_equal(p.statements[0].format, 1)
p._parse('FMAT,2 ')
p._parse_line('FMAT,2 ')
assert_equal(p.statements[1].format, 2)
def test_parse_units():
settings = FileSettings(units='inch', zeros='trailing')
p = ExcellonParser(settings)
p._parse(';METRIC,LZ')
p._parse_line(';METRIC,LZ')
assert_equal(p.units, 'inch')
assert_equal(p.zeros, 'trailing')
p._parse('METRIC,LZ')
p._parse_line('METRIC,LZ')
assert_equal(p.units, 'metric')
assert_equal(p.zeros, 'leading')
@ -161,9 +161,9 @@ def test_parse_incremental_mode():
settings = FileSettings(units='inch', zeros='trailing')
p = ExcellonParser(settings)
assert_equal(p.notation, 'absolute')
p._parse('ICI,ON ')
p._parse_line('ICI,ON ')
assert_equal(p.notation, 'incremental')
p._parse('ICI,OFF ')
p._parse_line('ICI,OFF ')
assert_equal(p.notation, 'absolute')
@ -171,29 +171,29 @@ def test_parse_absolute_mode():
settings = FileSettings(units='inch', zeros='trailing')
p = ExcellonParser(settings)
assert_equal(p.notation, 'absolute')
p._parse('ICI,ON ')
p._parse_line('ICI,ON ')
assert_equal(p.notation, 'incremental')
p._parse('G90 ')
p._parse_line('G90 ')
assert_equal(p.notation, 'absolute')
def test_parse_repeat_hole():
p = ExcellonParser(FileSettings())
p.active_tool = ExcellonTool(FileSettings(), number=8)
p._parse('R03X1.5Y1.5')
p._parse_line('R03X1.5Y1.5')
assert_equal(p.statements[0].count, 3)
def test_parse_incremental_position():
p = ExcellonParser(FileSettings(notation='incremental'))
p._parse('X01Y01')
p._parse('X01Y01')
p._parse_line('X01Y01')
p._parse_line('X01Y01')
assert_equal(p.pos, [2.,2.])
def test_parse_unknown():
p = ExcellonParser(FileSettings())
p._parse('Not A Valid Statement')
p._parse_line('Not A Valid Statement')
assert_equal(p.statements[0].stmt, 'Not A Valid Statement')