mirror
/
gerbonara
kopia lustrzana https://gitlab.com/gerbolyze/gerbonara
1
0
Forkuj 0
Kod Zgłoszenia Packages Projekty Wydania Wiki Aktywność

Allow negative render of soldermask per #50 

Update example code and rendering to show change
refactor
Hamilton Kibbe 2015-12-19 21:54:29 -05:00
rodzic 2e2b4e49c3
commit 1cb269131b
12 zmienionych plików z 276 dodań i 107 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

BIN
examples/cairo_example.png
Wyświetl plik

Plik binarny nie jest wyświetlany.
Side by Side Swipe Nakładka

Przed

Szerokość:  |  Wysokość:  |  Rozmiar: 108 KiB

Po

Szerokość:  |  Wysokość:  |  Rozmiar: 102 KiB

19
examples/cairo_example.py
Wyświetl plik

@ -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
Wyświetl plik

@ -243,7 +243,7 @@ class CamFile(object):
"""
pass
def render(self, ctx, filename=None):
def render(self, ctx, invert=False, filename=None):
""" Generate image of layer.
Parameters
@ -256,10 +256,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
Wyświetl plik

@ -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)

7
gerber/excellon.py
Wyświetl plik

@ -56,6 +56,7 @@ def read(filename):
settings = FileSettings(**detect_excellon_format(data))
return ExcellonParser(settings).parse(filename)
def loads(data):
""" Read data from string and return an ExcellonFile
Parameters
@ -332,13 +333,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
@ -477,7 +478,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:
# FIXME: for weird files with no tools defined, original calc from gerbv

31
gerber/exceptions.py 100644
Wyświetl plik

@ -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

121
gerber/render/cairo_backend.py
Wyświetl plik

@ -25,6 +25,7 @@ import tempfile
from ..primitives import *
class GerberCairoContext(GerberContext):
def __init__(self, scale=300):
GerberContext.__init__(self)
@ -32,42 +33,72 @@ 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])
self.ctx = cairo.Context(self.surface)
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_buffer = tempfile.NamedTemporaryFile()
self.mask = cairo.SVGSurface(self.mask_buffer, 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 isinstance(line.aperture, Circle):
width = line.aperture.diameter
if not self.invert:
self.ctx.set_source_rgba(*color, alpha=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()
elif isinstance(line.aperture, Rectangle):
points = [tuple(map(mul, x, self.scale)) for x in line.vertices]
self.ctx.set_source_rgba(*color, alpha=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])
for point in points[1:]:
self.ctx.line_to(*point)
self.ctx.fill()
if isinstance(line.aperture, Circle):
width = line.aperture.diameter
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()
elif isinstance(line.aperture, Rectangle):
points = [tuple(map(mul, x, self.scale)) 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()
else:
self.mask_ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)
self.mask_ctx.set_operator(cairo.OPERATOR_CLEAR)
if isinstance(line.aperture, Circle):
width = line.aperture.diameter
self.mask_ctx.set_line_width(0)
self.mask_ctx.set_line_width(width * self.scale[0])
self.mask_ctx.set_line_cap(cairo.LINE_CAP_ROUND)
self.mask_ctx.move_to(*start)
self.mask_ctx.line_to(*end)
self.mask_ctx.stroke()
elif isinstance(line.aperture, Rectangle):
points = [tuple(map(mul, x, self.scale)) for x in line.vertices]
self.mask_ctx.set_line_width(0)
self.mask_ctx.move_to(*points[0])
for point in points[1:]:
self.mask_ctx.line_to(*point)
self.mask_ctx.fill()
def _render_arc(self, arc, color):
center = map(mul, arc.center, self.scale)
@ -78,7 +109,7 @@ class GerberCairoContext(GerberContext):
angle2 = arc.end_angle
width = arc.aperture.diameter if arc.aperture.diameter != 0 else 0.001
self.ctx.set_source_rgba(*color, alpha=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_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...
@ -112,20 +143,34 @@ class GerberCairoContext(GerberContext):
def _render_circle(self, circle, color):
center = tuple(map(mul, circle.position, self.scale))
self.ctx.set_source_rgba(*color, alpha=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, radius=circle.radius * self.scale[0], angle1=0, angle2=2 * math.pi)
self.ctx.fill()
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" and not self.invert) else cairo.OPERATOR_CLEAR)
self.ctx.set_line_width(0)
self.ctx.arc(*center, radius=circle.radius * self.scale[0], angle1=0, angle2=2 * math.pi)
self.ctx.fill()
else:
self.mask_ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)
self.mask_ctx.set_operator(cairo.OPERATOR_CLEAR)
self.mask_ctx.set_line_width(0)
self.mask_ctx.arc(*center, radius=circle.radius * self.scale[0], angle1=0, angle2=2 * math.pi)
self.mask_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)))
self.ctx.set_source_rgba(*color, alpha=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,width=width, height=height)
self.ctx.fill()
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" and not self.invert) else cairo.OPERATOR_CLEAR)
self.ctx.set_line_width(0)
self.ctx.rectangle(*ll, width=width, height=height)
self.ctx.fill()
else:
self.mask_ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)
self.mask_ctx.set_operator(cairo.OPERATOR_CLEAR)
self.mask_ctx.set_line_width(0)
self.mask_ctx.rectangle(*ll, width=width, height=height)
self.mask_ctx.fill()
def _render_obround(self, obround, color):
self._render_circle(obround.subshapes['circle1'], color)
@ -140,17 +185,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" and not self.invert) 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)
self.mask_ctx.set_operator(cairo.OPERATOR_OVER)
self.mask_ctx.set_source_rgba(*self.color, 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:
@ -160,21 +211,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
Wyświetl plik

@ -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
@ -182,3 +183,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 100644
Wyświetl plik

@ -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)

66
gerber/rs274x.py
Wyświetl plik

@ -26,7 +26,7 @@ try:
from cStringIO import StringIO
except(ImportError):
from io import StringIO
from .gerber_statements import *
from .primitives import *
from .cam import CamFile, FileSettings
@ -49,8 +49,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
@ -215,7 +228,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):
lines = [line for line in StringIO(data)]
@ -254,27 +267,10 @@ 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
# 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
# coord
(coord, r) = _match_one(self.COORD_STMT, line)
if coord:
@ -292,14 +288,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)
@ -350,6 +338,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
Wyświetl plik

@ -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
Wyświetl plik

@ -98,60 +98,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')
@ -160,9 +160,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')
@ -170,29 +170,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')