From 125eb821b9f5d4c58b17d43e318e9a6829120d03 Mon Sep 17 00:00:00 2001
From: jaseg <git@jaseg.de>
Date: Mon, 8 Nov 2021 13:06:23 +0100
Subject: Parser half-refactored
---
examples/cairo_bottom.png | Bin 42180 -> 0 bytes
examples/cairo_example.png | Bin 100252 -> 0 bytes
examples/cairo_example.py | 78 --
gerbonara/gerber/am_read.py | 4 +-
gerbonara/gerber/cam.py | 199 +----
gerbonara/gerber/gerber_statements.py | 890 +++------------------
gerbonara/gerber/panelize/__init__.py | 7 -
gerbonara/gerber/panelize/utility.py | 8 -
gerbonara/gerber/render/__init__.py | 31 -
gerbonara/gerber/render/cairo_backend.py | 640 ---------------
gerbonara/gerber/rs274x.py | 546 ++++++-------
.../gerber/tests/panelize/data/ref_gerber_inch.gtl | 1 -
.../tests/panelize/data/ref_gerber_metric.gtl | 1 -
.../panelize/data/ref_gerber_single_quadrant.gtl | 40 -
.../tests/panelize/expects/RS2724x_offset.gtl | 1 -
.../tests/panelize/expects/RS2724x_rotate.gtl | 1 -
.../gerber/tests/panelize/expects/RS2724x_save.gtl | 1 -
.../panelize/expects/RS2724x_single_quadrant.gtl | 35 -
.../tests/panelize/expects/RS2724x_to_inch.gtl | 1 -
.../tests/panelize/expects/RS2724x_to_metric.gtl | 1 -
.../gerber/tests/panelize/test_am_expression.py | 13 -
gerbonara/gerber/tests/panelize/test_rs274x.py | 5 -
gerbonara/gerber/tests/test_am_statements.py | 395 ---------
gerbonara/gerber/tests/test_cairo_backend.py | 382 ---------
gerbonara/gerber/tests/test_gerber_statements.py | 64 +-
gerbonara/gerber/utils.py | 20 +-
26 files changed, 448 insertions(+), 2916 deletions(-)
delete mode 100644 examples/cairo_bottom.png
delete mode 100644 examples/cairo_example.png
delete mode 100644 examples/cairo_example.py
delete mode 100644 gerbonara/gerber/panelize/__init__.py
delete mode 100644 gerbonara/gerber/render/__init__.py
delete mode 100644 gerbonara/gerber/render/cairo_backend.py
delete mode 100644 gerbonara/gerber/tests/panelize/data/ref_gerber_single_quadrant.gtl
delete mode 100644 gerbonara/gerber/tests/panelize/expects/RS2724x_single_quadrant.gtl
delete mode 100644 gerbonara/gerber/tests/test_am_statements.py
delete mode 100644 gerbonara/gerber/tests/test_cairo_backend.py
diff --git a/examples/cairo_bottom.png b/examples/cairo_bottom.png
deleted file mode 100644
index 70f7551..0000000
Binary files a/examples/cairo_bottom.png and /dev/null differ
diff --git a/examples/cairo_example.png b/examples/cairo_example.png
deleted file mode 100644
index 4b4ee0a..0000000
Binary files a/examples/cairo_example.png and /dev/null differ
diff --git a/examples/cairo_example.py b/examples/cairo_example.py
deleted file mode 100644
index ecfed4d..0000000
--- a/examples/cairo_example.py
+++ /dev/null
@@ -1,78 +0,0 @@
-#! /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.
-
-"""
-This example demonstrates the use of pcb-tools with cairo to render a composite
-image from a set of gerber files. Each layer is loaded and drawn using a
-GerberCairoContext. The color and opacity of each layer can be set individually.
-Once all thedesired layers are drawn on the context, the context is written to
-a .png file.
-"""
-
-import os
-from gerber import load_layer
-from gerber.render import RenderSettings, theme
-from gerber.render.cairo_backend import GerberCairoContext
-
-GERBER_FOLDER = os.path.abspath(os.path.join(os.path.dirname(__file__), 'gerbers'))
-
-
-# Open the gerber files
-copper = load_layer(os.path.join(GERBER_FOLDER, 'copper.GTL'))
-mask = load_layer(os.path.join(GERBER_FOLDER, 'soldermask.GTS'))
-silk = load_layer(os.path.join(GERBER_FOLDER, 'silkscreen.GTO'))
-drill = load_layer(os.path.join(GERBER_FOLDER, 'ncdrill.DRD'))
-
-# Create a new drawing context
-ctx = GerberCairoContext()
-
-# Draw the copper layer. render_layer() uses the default color scheme for the
-# layer, based on the layer type. Copper layers are rendered as
-ctx.render_layer(copper)
-
-# Draw the soldermask layer
-ctx.render_layer(mask)
-
-
-# The default style can be overridden by passing a RenderSettings instance to
-# render_layer().
-# First, create a settings object:
-our_settings = RenderSettings(color=theme.COLORS['white'], alpha=0.85)
-
-# Draw the silkscreen layer, and specify the rendering settings to use
-ctx.render_layer(silk, settings=our_settings)
-
-# Draw the drill layer
-ctx.render_layer(drill)
-
-# Write output to png file
-ctx.dump(os.path.join(os.path.dirname(__file__), 'cairo_example.png'))
-
-# Load the bottom layers
-copper = load_layer(os.path.join(GERBER_FOLDER, 'bottom_copper.GBL'))
-mask = load_layer(os.path.join(GERBER_FOLDER, 'bottom_mask.GBS'))
-
-# Clear the drawing
-ctx.clear()
-
-# Render bottom layers
-ctx.render_layer(copper)
-ctx.render_layer(mask)
-ctx.render_layer(drill)
-
-# Write png file
-ctx.dump(os.path.join(os.path.dirname(__file__), 'cairo_bottom.png'))
diff --git a/gerbonara/gerber/am_read.py b/gerbonara/gerber/am_read.py
index 906aaa9..c50bd01 100644
--- a/gerbonara/gerber/am_read.py
+++ b/gerbonara/gerber/am_read.py
@@ -19,7 +19,6 @@
"""
from .am_opcode import OpCode
-from .am_primitive import eval_macro
import string
@@ -251,5 +250,6 @@ if __name__ == '__main__':
print_instructions(instructions)
print("eval:")
- for primitive in eval_macro(instructions):
+ from .am_primitive import eval_macro
+ for primitive in eval_macro(instructions, 'mm'):
print(primitive)
diff --git a/gerbonara/gerber/cam.py b/gerbonara/gerber/cam.py
index 4f20283..5da8600 100644
--- a/gerbonara/gerber/cam.py
+++ b/gerbonara/gerber/cam.py
@@ -14,164 +14,50 @@
# 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.
-"""
-CAM File
-============
-**AM file classes**
-This module provides common base classes for Excellon/Gerber CNC files
-"""
-
-
-class FileSettings(object):
- """ CAM File Settings
-
- Provides a common representation of gerber/excellon file settings
-
- Parameters
- ----------
- notation: string
- notation format. either 'absolute' or 'incremental'
-
- units : string
- Measurement units. 'inch' or 'metric'
-
- zero_suppression: string
- 'leading' to suppress leading zeros, 'trailing' to suppress trailing zeros.
- This is the convention used in Gerber files.
-
- format : tuple (int, int)
- Decimal format
-
- zeros : string
- 'leading' to include leading zeros, 'trailing to include trailing zeros.
- This is the convention used in Excellon files
-
- Notes
- -----
- Either `zeros` or `zero_suppression` should be specified, there is no need to
- specify both. `zero_suppression` will take on the opposite value of `zeros`
- and vice versa
- """
-
- def __init__(self, notation='absolute', units='inch',
- zero_suppression=None, format=(2, 5), zeros=None,
- angle_units='degrees'):
- if notation not in ['absolute', 'incremental']:
- raise ValueError('Notation must be either absolute or incremental')
- self.notation = notation
-
- if units not in ['inch', 'metric']:
- raise ValueError('Units must be either inch or metric')
- self.units = units
-
- if zero_suppression is None and zeros is None:
- self.zero_suppression = 'trailing'
-
- elif zero_suppression == zeros:
- raise ValueError('Zeros and Zero Suppression must be different. \
- Best practice is to specify only one.')
-
- elif zero_suppression is not None:
- if zero_suppression not in ['leading', 'trailing']:
- # This is a common problem in Eagle files, so just suppress it
- self.zero_suppression = 'leading'
- else:
- self.zero_suppression = zero_suppression
-
- elif zeros is not None:
- if zeros not in ['leading', 'trailing']:
- raise ValueError('Zeros must be either leading or trailling')
- self.zeros = zeros
-
- if len(format) != 2:
- raise ValueError('Format must be a tuple(n=2) of integers')
- self.format = format
-
- if angle_units not in ('degrees', 'radians'):
- raise ValueError('Angle units may be degrees or radians')
- self.angle_units = angle_units
-
- @property
- def zero_suppression(self):
- return self._zero_suppression
-
- @zero_suppression.setter
- def zero_suppression(self, value):
- self._zero_suppression = value
- self._zeros = 'leading' if value == 'trailing' else 'trailing'
-
- @property
- def zeros(self):
- return self._zeros
-
- @zeros.setter
- def zeros(self, value):
-
- self._zeros = value
- self._zero_suppression = 'leading' if value == 'trailing' else 'trailing'
-
- def __getitem__(self, key):
- if key == 'notation':
- return self.notation
- elif key == 'units':
- return self.units
- elif key == 'zero_suppression':
- return self.zero_suppression
- elif key == 'zeros':
- return self.zeros
- elif key == 'format':
- return self.format
- elif key == 'angle_units':
- return self.angle_units
- else:
- raise KeyError()
-
- def __setitem__(self, key, value):
- if key == 'notation':
- if value not in ['absolute', 'incremental']:
- raise ValueError('Notation must be either \
- absolute or incremental')
- self.notation = value
- elif key == 'units':
- if value not in ['inch', 'metric']:
- raise ValueError('Units must be either inch or metric')
- self.units = value
-
- elif key == 'zero_suppression':
- if value not in ['leading', 'trailing']:
- raise ValueError('Zero suppression must be either leading or \
- trailling')
- self.zero_suppression = value
-
- elif key == 'zeros':
- if value not in ['leading', 'trailing']:
- raise ValueError('Zeros must be either leading or trailling')
- self.zeros = value
-
- elif key == 'format':
- if len(value) != 2:
- raise ValueError('Format must be a tuple(n=2) of integers')
- self.format = value
-
- elif key == 'angle_units':
- if value not in ('degrees', 'radians'):
- raise ValueError('Angle units may be degrees or radians')
- self.angle_units = value
-
- else:
- raise KeyError('%s is not a valid key' % key)
-
- def __eq__(self, other):
- return (self.notation == other.notation and
- self.units == other.units and
- self.zero_suppression == other.zero_suppression and
- self.format == other.format and
- self.angle_units == other.angle_units)
+from dataclasses import dataclass
+
+
+@dataclass
+class FileSettings:
+ output_axes : str = 'AXBY' # For deprecated AS statement
+ image_polarity : str = 'positive'
+ image_rotation: int = 0
+ mirror_image : tuple = (False, False)
+ scale_factor : tuple = (1.0, 1.0) # For deprecated SF statement
+ notation : str = 'absolute'
+ units : str = 'inch'
+ angle_units : str = 'degrees'
+ zeros : bool = None
+ number_format : tuple = (2, 5)
+
+ # input validation
+ def __setattr__(self, name, value):
+ if name == 'output_axes' and value not in [None, 'AXBY', 'AYBX']:
+ raise ValueError('output_axes must be either "AXBY", "AYBX" or None')
+ if name == 'image_rotation' and value not in [0, 90, 180, 270]:
+ raise ValueError('image_rotation must be 0, 90, 180 or 270')
+ elif name == 'image_polarity' and value not in ['positive', 'negative']:
+ raise ValueError('image_polarity must be either "positive" or "negative"')
+ elif name == 'mirror_image' and len(value) != 2:
+ raise ValueError('mirror_image must be 2-tuple of bools: (mirror_a, mirror_b)')
+ elif name == 'scale_factor' and len(value) != 2:
+ raise ValueError('scale_factor must be 2-tuple of floats: (scale_a, scale_b)')
+ elif name == 'notation' and value not in ['inch', 'mm']:
+ raise ValueError('Units must be either "inch" or "mm"')
+ elif name == 'units' and value not in ['absolute', 'incremental']:
+ raise ValueError('Notation must be either "absolute" or "incremental"')
+ elif name == 'angle_units' and value not in ('degrees', 'radians'):
+ raise ValueError('Angle units may be "degrees" or "radians"')
+ elif name == 'zeros' and value not in [None, 'leading', 'trailing']:
+ raise ValueError('zero_suppression must be either "leading" or "trailing" or None')
+ elif name == 'number_format' and len(value) != 2:
+ raise ValueError('Number format must be a (integer, fractional) tuple of integers')
+
+ super().__setattr__(name, value)
def __str__(self):
- return ('<Settings: %s %s %s %s %s>' %
- (self.units, self.notation, self.zero_suppression, self.format, self.angle_units))
+ return f'<File settings: units={self.units}/{self.angle_units} notation={self.notation} zeros={self.zeros} number_format={self.number_format}>'
class CamFile(object):
@@ -202,7 +88,7 @@ class CamFile(object):
File notation setting. May be either 'absolute' or 'incremental'
units : string
- File units setting. May be 'inch' or 'metric'
+ File units setting. May be 'inch' or 'mm'
zero_suppression : string
File zero-suppression setting. May be either 'leading' or 'trailling'
@@ -226,6 +112,7 @@ class CamFile(object):
self.zero_suppression = 'trailing'
self.zeros = 'leading'
self.format = (2, 5)
+
self.statements = statements if statements is not None else []
if primitives is not None:
self.primitives = primitives
diff --git a/gerbonara/gerber/gerber_statements.py b/gerbonara/gerber/gerber_statements.py
index 9296d1b..d2f67c1 100644
--- a/gerbonara/gerber/gerber_statements.py
+++ b/gerbonara/gerber/gerber_statements.py
@@ -29,7 +29,7 @@ from .am_primitive import eval_macro
from .primitives import AMGroup
-class Statement(object):
+class Statement:
""" Gerber statement Base class
The statement class provides a type attribute.
@@ -45,10 +45,6 @@ class Statement(object):
String identifying the statement type.
"""
- def __init__(self, stype, units='inch'):
- self.type = stype
- self.units = units
-
def __str__(self):
s = "<{0} ".format(self.__class__.__name__)
@@ -58,12 +54,6 @@ class Statement(object):
s = s.rstrip() + ">"
return s
- def to_inch(self):
- self.units = 'inch'
-
- def to_metric(self):
- self.units = 'metric'
-
def offset(self, x_offset=0, y_offset=0):
pass
@@ -72,201 +62,51 @@ class Statement(object):
class ParamStmt(Statement):
- """ Gerber parameter statement Base class
-
- The parameter statement class provides a parameter type attribute.
-
- Parameters
- ----------
- param : string
- two-character code identifying the parameter statement type.
-
- Attributes
- ----------
- param : string
- Parameter type code
- """
-
- def __init__(self, param):
- Statement.__init__(self, "PARAM")
- self.param = param
-
-
-class FSParamStmt(ParamStmt):
- """ FS - Gerber Format Specification Statement
- """
+ pass
- @classmethod
- def from_settings(cls, settings):
+class FormatSpecStmt(ParamStmt):
+ """ FS - Gerber Format Specification Statement """
+ code = 'FS'
- return cls('FS', settings.zero_suppression, settings.notation, settings.format)
+ def to_gerber(self, settings):
+ zeros = 'L' if settings.zero_suppression == 'leading' else 'T'
+ notation = 'A' if settings.notation == 'absolute' else 'I'
+ fmt = settings.number_format
+ number_format = str(settings.number_format[0]) + str(settings.number_format[1])
- @classmethod
- def from_dict(cls, stmt_dict):
- """
- """
- param = stmt_dict.get('param')
-
- if stmt_dict.get('zero') == 'L':
- zeros = 'leading'
- elif stmt_dict.get('zero') == 'T':
- zeros = 'trailing'
- else:
- zeros = 'none'
-
- notation = 'absolute' if stmt_dict.get('notation') == 'A' else 'incremental'
- fmt = tuple(map(int, stmt_dict.get('x')))
- return cls(param, zeros, notation, fmt)
-
- def __init__(self, param, zero_suppression='leading',
- notation='absolute', format=(2, 4)):
- """ Initialize FSParamStmt class
-
- .. note::
- The FS command specifies the format of the coordinate data. It
- must only be used once at the beginning of a file. It must be
- specified before the first use of coordinate data.
-
- Parameters
- ----------
- param : string
- Parameter.
-
- zero_suppression : string
- Zero-suppression mode. May be either 'leading', 'trailing' or 'none' (all zeros are present)
-
- notation : string
- Notation mode. May be either 'absolute' or 'incremental'
-
- format : tuple (int, int)
- Gerber precision format expressed as a tuple containing:
- (number of integer-part digits, number of decimal-part digits)
-
- Returns
- -------
- ParamStmt : FSParamStmt
- Initialized FSParamStmt class.
-
- """
- ParamStmt.__init__(self, param)
- self.zero_suppression = zero_suppression
- self.notation = notation
- self.format = format
-
- def to_gerber(self, settings=None):
- if settings:
- zero_suppression = 'L' if settings.zero_suppression == 'leading' else 'T'
- notation = 'A' if settings.notation == 'absolute' else 'I'
- fmt = ''.join(map(str, settings.format))
- else:
- zero_suppression = 'L' if self.zero_suppression == 'leading' else 'T'
- notation = 'A' if self.notation == 'absolute' else 'I'
- fmt = ''.join(map(str, self.format))
-
- return '%FS{0}{1}X{2}Y{3}*%'.format(zero_suppression, notation, fmt, fmt)
+ return f'%FS{zeros}{notation}X{number_format}Y{number_format}*%'
def __str__(self):
- return ('<Format Spec: %d:%d %s zero suppression %s notation>' %
- (self.format[0], self.format[1], self.zero_suppression, self.notation))
+ return '<FS Format Specification>'
-class MOParamStmt(ParamStmt):
- """ MO - Gerber Mode (measurement units) Statement.
- """
+class UnitStmt(ParamStmt):
+ """ MO - Coordinate unit mode statement """
- @classmethod
- def from_units(cls, units):
- return cls(None, units)
-
- @classmethod
- def from_dict(cls, stmt_dict):
- param = stmt_dict.get('param')
- if stmt_dict.get('mo') is None:
- mo = None
- elif stmt_dict.get('mo').lower() not in ('in', 'mm'):
- raise ValueError('Mode may be mm or in')
- elif stmt_dict.get('mo').lower() == 'in':
- mo = 'inch'
- else:
- mo = 'metric'
- return cls(param, mo)
-
- def __init__(self, param, mo):
- """ Initialize MOParamStmt class
-
- Parameters
- ----------
- param : string
- Parameter.
-
- mo : string
- Measurement units. May be either 'inch' or 'metric'
-
- Returns
- -------
- ParamStmt : MOParamStmt
- Initialized MOParamStmt class.
-
- """
- ParamStmt.__init__(self, param)
- self.mode = mo
-
- def to_gerber(self, settings=None):
- mode = 'MM' if self.mode == 'metric' else 'IN'
- return '%MO{0}*%'.format(mode)
-
- def to_inch(self):
- self.mode = 'inch'
-
- def to_metric(self):
- self.mode = 'metric'
+ def to_gerber(self, settings):
+ return '%MOMM*%' if settings.units == 'mm' else '%MOIN*%'
def __str__(self):
- mode_str = 'millimeters' if self.mode == 'metric' else 'inches'
- return ('<Mode: %s>' % mode_str)
-
-
-class LPParamStmt(ParamStmt):
- """ LP - Gerber Level Polarity statement
- """
-
- @classmethod
- def from_dict(cls, stmt_dict):
- param = stmt_dict['param']
- lp = 'clear' if stmt_dict.get('lp') == 'C' else 'dark'
- return cls(param, lp)
+ return ('<MO Coordinate unit mode statement>' % mode_str)
- def __init__(self, param, lp):
- """ Initialize LPParamStmt class
- Parameters
- ----------
- param : string
- Parameter
+class LoadPolarityStmt(ParamStmt):
+ """ LP - Gerber Load Polarity statement """
- lp : string
- Level polarity. May be either 'clear' or 'dark'
-
- Returns
- -------
- ParamStmt : LPParamStmt
- Initialized LPParamStmt class.
-
- """
- ParamStmt.__init__(self, param)
- self.lp = lp
+ def __init__(self, dark):
+ self.dark = dark
def to_gerber(self, settings=None):
- lp = 'C' if self.lp == 'clear' else 'D'
- return '%LP{0}*%'.format(lp)
+ lp = 'D' if self.dark else 'C'
+ return f'%LP{lp}*%'
def __str__(self):
- return '<Level Polarity: %s>' % self.lp
+ lp = 'dark' if self.dark else 'clear'
+ return f'<LP Level Polarity: {lp}>'
class ADParamStmt(ParamStmt):
- """ AD - Gerber Aperture Definition Statement
- """
+ """ AD - Aperture Definition Statement """
@classmethod
def rect(cls, dcode, width, height, hole_diameter=None, hole_width=None, hole_height=None):
@@ -418,10 +258,7 @@ class AMParamStmt(ParamStmt):
self.name = name
self.macro = macro
self.units = units
- self.primitives = list(eval_macro(self.instructions))
-
- def read(self, macro):
- return read_macro(macro)
+ self.primitives = list(eval_macro(read_macro(macro), units))
@classmethod
def circle(cls, name, units):
@@ -457,20 +294,8 @@ class AMParamStmt(ParamStmt):
def polygon(cls, name, units):
return cls('AM', name, '5,1,$2,0,0,$1,$3*1,0,$4,0,0,0', units)
- def to_inch(self):
- if self.units == 'metric':
- self.units = 'inch'
- for primitive in self.primitives:
- primitive.to_inch()
-
- def to_metric(self):
- if self.units == 'inch':
- self.units = 'metric'
- for primitive in self.primitives:
- primitive.to_metric()
-
- def to_gerber(self, settings=None):
- primitive_defs = '\n'.join(primitive.to_gerber() for primitive in self.primitives)
+ def to_gerber(self, unit=None):
+ primitive_defs = '\n'.join(primitive.to_gerber(unit=unit) for primitive in self.primitives)
return f'%AM{self.name}*\n{primitive_defs}%'
def rotate(self, angle, center=None):
@@ -478,444 +303,81 @@ class AMParamStmt(ParamStmt):
primitive_def.rotate(angle, center)
def __str__(self):
- return '<Aperture Macro %s: %s>' % (self.name, self.macro)
-
-
-class ASParamStmt(ParamStmt):
- """ AS - Axis Select. (Deprecated) """
- @classmethod
- def from_dict(cls, stmt_dict):
- param = stmt_dict.get('param')
- mode = stmt_dict.get('mode')
- return cls(param, mode)
+ return '<AM Aperture Macro %s: %s>' % (self.name, self.macro)
- def __init__(self, param, mode):
- """ Initialize ASParamStmt class
- Parameters
- ----------
- param : string
- Parameter string.
+class AxisSelectionStmt(ParamStmt):
+ """ AS - Axis Selection Statement. (Deprecated) """
- mode : string
- Axis select. May be either 'AXBY' or 'AYBX'
-
- Returns
- -------
- ParamStmt : ASParamStmt
- Initialized ASParamStmt class.
-
- """
- ParamStmt.__init__(self, param)
- self.mode = mode
-
- def to_gerber(self, settings=None):
- return '%AS{0}*%'.format(self.mode)
+ def to_gerber(self, settings):
+ return f'%AS{settings.output_axes}*%'
def __str__(self):
- return ('<Axis Select: %s>' % self.mode)
-
-
-class INParamStmt(ParamStmt):
- """ IN - Image Name Statement (Deprecated)
- """
- @classmethod
- def from_dict(cls, stmt_dict):
- return cls(**stmt_dict)
-
- def __init__(self, param, name):
- """ Initialize INParamStmt class
-
- Parameters
- ----------
- param : string
- Parameter code
+ return '<AS Axis Select>'
- name : string
- Image name
+class ImagePolarityStmt(ParamStmt):
+ """ IP - Image Polarity Statement. (Deprecated) """
- Returns
- -------
- ParamStmt : INParamStmt
- Initialized INParamStmt class.
-
- """
- ParamStmt.__init__(self, param)
- self.name = name
-
- def to_gerber(self, settings=None):
- return '%IN{0}*%'.format(self.name)
+ def to_gerber(self, settings):
+ ip = 'POS' if settings.image_polarity == 'positive' else 'NEG'
+ return f'%IP{ip}*%'
def __str__(self):
- return '<Image Name: %s>' % self.name
-
-
-class IPParamStmt(ParamStmt):
- """ IP - Gerber Image Polarity Statement. (Deprecated)
- """
- @classmethod
- def from_dict(cls, stmt_dict):
- param = stmt_dict.get('param')
- ip = 'positive' if stmt_dict.get('ip') == 'POS' else 'negative'
- return cls(param, ip)
+ return '<IP Image Polarity>'
- def __init__(self, param, ip):
- """ Initialize IPParamStmt class
- Parameters
- ----------
- param : string
- Parameter string.
-
- ip : string
- Image polarity. May be either'positive' or 'negative'
-
- Returns
- -------
- ParamStmt : IPParamStmt
- Initialized IPParamStmt class.
-
- """
- ParamStmt.__init__(self, param)
- self.ip = ip
+class ImageRotationStmt(ParamStmt):
+ """ IR - Image Rotation Statement. (Deprecated) """
- def to_gerber(self, settings=None):
- ip = 'POS' if self.ip == 'positive' else 'NEG'
- return '%IP{0}*%'.format(ip)
+ def to_gerber(self, settings):
+ return f'%IR{settings.image_rotation}*%'
def __str__(self):
- return ('<Image Polarity: %s>' % self.ip)
-
-
-class IRParamStmt(ParamStmt):
- """ IR - Image Rotation Param (Deprecated)
- """
- @classmethod
- def from_dict(cls, stmt_dict):
- angle = int(stmt_dict['angle'])
- return cls(stmt_dict['param'], angle)
-
- def __init__(self, param, angle):
- """ Initialize IRParamStmt class
-
- Parameters
- ----------
- param : string
- Parameter code
-
- angle : int
- Image angle
+ return '<IR Image Rotation>'
- Returns
- -------
- ParamStmt : IRParamStmt
- Initialized IRParamStmt class.
-
- """
- ParamStmt.__init__(self, param)
- self.angle = angle
+class MirrorImageStmt(ParamStmt):
+ """ MI - Mirror Image Statement. (Deprecated) """
- def to_gerber(self, settings=None):
- return '%IR{0}*%'.format(self.angle)
+ def to_gerber(self, settings):
+ return f'%SFA{int(bool(settings.mirror_image[0]))}B{int(bool(settings.mirror_image[1]))}*%'
def __str__(self):
- return '<Image Angle: %s>' % self.angle
+ return '<MI Mirror Image>'
+class OffsetStmt(ParamStmt):
+ """ OF - File Offset Statement. (Deprecated) """
-class MIParamStmt(ParamStmt):
- """ MI - Image Mirror Param (Deprecated)
- """
- @classmethod
- def from_dict(cls, stmt_dict):
- param = stmt_dict.get('param')
- a = int(stmt_dict.get('a', 0))
- b = int(stmt_dict.get('b', 0))
- return cls(param, a, b)
-
- def __init__(self, param, a, b):
- """ Initialize MIParamStmt class
-
- Parameters
- ----------
- param : string
- Parameter code
-
- a : int
- Mirror for A output devices axis (0=disabled, 1=mirrored)
-
- b : int
- Mirror for B output devices axis (0=disabled, 1=mirrored)
-
- Returns
- -------
- ParamStmt : MIParamStmt
- Initialized MIParamStmt class.
-
- """
- ParamStmt.__init__(self, param)
- self.a = a
- self.b = b
-
- def to_gerber(self, settings=None):
- ret = "%MI"
- if self.a is not None:
- ret += "A{0}".format(self.a)
- if self.b is not None:
- ret += "B{0}".format(self.b)
- ret += "*%"
- return ret
-
- def __str__(self):
- return '<Image Mirror: A=%d B=%d>' % (self.a, self.b)
-
-
-class OFParamStmt(ParamStmt):
- """ OF - Gerber Offset statement (Deprecated)
- """
-
- @classmethod
- def from_dict(cls, stmt_dict):
- param = stmt_dict.get('param')
- a = float(stmt_dict.get('a', 0))
- b = float(stmt_dict.get('b', 0))
- return cls(param, a, b)
-
- def __init__(self, param, a, b):
- """ Initialize OFParamStmt class
-
- Parameters
- ----------
- param : string
- Parameter
-
- a : float
- Offset along the output device A axis
-
- b : float
- Offset along the output device B axis
-
- Returns
- -------
- ParamStmt : OFParamStmt
- Initialized OFParamStmt class.
-
- """
- ParamStmt.__init__(self, param)
- self.a = a
- self.b = b
+ def __init__(self, a, b):
+ self.a, self.b = a, b
def to_gerber(self, settings=None):
- ret = '%OF'
- if self.a is not None:
- ret += 'A' + decimal_string(self.a, precision=5)
- if self.b is not None:
- ret += 'B' + decimal_string(self.b, precision=5)
- return ret + '*%'
-
- def to_inch(self):
- if self.units == 'metric':
- self.units = 'inch'
- if self.a is not None:
- self.a = inch(self.a)
- if self.b is not None:
- self.b = inch(self.b)
-
- def to_metric(self):
- if self.units == 'inch':
- self.units = 'metric'
- if self.a is not None:
- self.a = metric(self.a)
- if self.b is not None:
- self.b = metric(self.b)
-
- def offset(self, x_offset=0, y_offset=0):
- if self.a is not None:
- self.a += x_offset
- if self.b is not None:
- self.b += y_offset
+ # FIXME unit conversion
+ return f'%OFA{decimal_string(self.a, precision=5)}B{decimal_string(self.b, precision=5)}*%'
def __str__(self):
- offset_str = ''
- if self.a is not None:
- offset_str += ('X: %f ' % self.a)
- if self.b is not None:
- offset_str += ('Y: %f ' % self.b)
- return ('<Offset: %s>' % offset_str)
+ return f'<OF Offset a={self.a} b={self.b}>'
class SFParamStmt(ParamStmt):
- """ SF - Scale Factor Param (Deprecated)
- """
-
- @classmethod
- def from_dict(cls, stmt_dict):
- param = stmt_dict.get('param')
- a = float(stmt_dict.get('a', 1))
- b = float(stmt_dict.get('b', 1))
- return cls(param, a, b)
-
- def __init__(self, param, a, b):
- """ Initialize OFParamStmt class
-
- Parameters
- ----------
- param : string
- Parameter
-
- a : float
- Scale factor for the output device A axis
-
- b : float
- Scale factor for the output device B axis
-
- Returns
- -------
- ParamStmt : SFParamStmt
- Initialized SFParamStmt class.
-
- """
- ParamStmt.__init__(self, param)
- self.a = a
- self.b = b
-
- def to_gerber(self, settings=None):
- ret = '%SF'
- if self.a is not None:
- ret += 'A' + decimal_string(self.a, precision=5)
- if self.b is not None:
- ret += 'B' + decimal_string(self.b, precision=5)
- return ret + '*%'
-
- def to_inch(self):
- if self.units == 'metric':
- self.units = 'inch'
- if self.a is not None:
- self.a = inch(self.a)
- if self.b is not None:
- self.b = inch(self.b)
-
- def to_metric(self):
- if self.units == 'inch':
- self.units = 'metric'
- if self.a is not None:
- self.a = metric(self.a)
- if self.b is not None:
- self.b = metric(self.b)
-
- def offset(self, x_offset=0, y_offset=0):
- if self.a is not None:
- self.a += x_offset
- if self.b is not None:
- self.b += y_offset
-
- def __str__(self):
- scale_factor = ''
- if self.a is not None:
- scale_factor += ('X: %g ' % self.a)
- if self.b is not None:
- scale_factor += ('Y: %g' % self.b)
- return ('<Scale Factor: %s>' % scale_factor)
-
-
-class LNParamStmt(ParamStmt):
- """ LN - Level Name Statement (Deprecated)
- """
- @classmethod
- def from_dict(cls, stmt_dict):
- return cls(**stmt_dict)
-
- def __init__(self, param, name):
- """ Initialize LNParamStmt class
-
- Parameters
- ----------
- param : string
- Parameter code
-
- name : string
- Level name
-
- Returns
- -------
- ParamStmt : LNParamStmt
- Initialized LNParamStmt class.
-
- """
- ParamStmt.__init__(self, param)
- self.name = name
-
- def to_gerber(self, settings=None):
- return '%LN{0}*%'.format(self.name)
-
- def __str__(self):
- return '<Level Name: %s>' % self.name
-
+ """ SF - Scale Factor Statement. (Deprecated) """
-class DeprecatedStmt(Statement):
- """ Unimportant deprecated statement, will be parsed but not emitted.
- """
- @classmethod
- def from_gerber(cls, line):
- return cls(line)
-
- def __init__(self, line):
- """ Initialize DeprecatedStmt class
-
- Parameters
- ----------
- line : string
- Deprecated statement text
-
- Returns
- -------
- DeprecatedStmt
- Initialized DeprecatedStmt class.
-
- """
- Statement.__init__(self, "DEPRECATED")
- self.line = line
+ def __init__(self, a, b):
+ self.a, self.b = a, b
def to_gerber(self, settings=None):
- return self.line
+ return '%SFA{decimal_string(self.a, precision=5)}B{decimal_string(self.b, precision=5)}*%'
def __str__(self):
- return '<Deprecated Statement: \'%s\'>' % self.line
-
+ return '<SF Scale Factor>'
class CoordStmt(Statement):
- """ Coordinate Data Block
- """
-
- OP_DRAW = 'D01'
- OP_MOVE = 'D02'
- OP_FLASH = 'D03'
-
- FUNC_LINEAR = 'G01'
- FUNC_ARC_CW = 'G02'
- FUNC_ARC_CCW = 'G03'
+ """ D01 - D03 operation statements """
- @classmethod
- def from_dict(cls, stmt_dict, settings):
- function = stmt_dict['function']
- x = stmt_dict.get('x')
- y = stmt_dict.get('y')
- i = stmt_dict.get('i')
- j = stmt_dict.get('j')
- op = stmt_dict.get('op')
-
- if x is not None:
- x = parse_gerber_value(stmt_dict.get('x'), settings.format,
- settings.zero_suppression)
- if y is not None:
- y = parse_gerber_value(stmt_dict.get('y'), settings.format,
- settings.zero_suppression)
- if i is not None:
- i = parse_gerber_value(stmt_dict.get('i'), settings.format,
- settings.zero_suppression)
- if j is not None:
- j = parse_gerber_value(stmt_dict.get('j'), settings.format,
- settings.zero_suppression)
- return cls(function, x, y, i, j, op, settings)
+ def __init__(self, x, y, i, j):
+ self.x = x
+ self.y = y
+ self.i = i
+ self.j = j
@classmethod
def move(cls, func, point):
@@ -943,94 +405,20 @@ class CoordStmt(Statement):
else:
return cls(None, None, None, None, None, CoordStmt.OP_FLASH, None)
- def __init__(self, function, x, y, i, j, op, settings):
- """ Initialize CoordStmt class
-
- Parameters
- ----------
- function : string
- function
-
- x : float
- X coordinate
-
- y : float
- Y coordinate
-
- i : float
- Coordinate offset in the X direction
-
- j : float
- Coordinate offset in the Y direction
-
- op : string
- Operation code
-
- settings : dict {'zero_suppression', 'format'}
- Gerber file coordinate format
-
- Returns
- -------
- Statement : CoordStmt
- Initialized CoordStmt class.
-
- """
- Statement.__init__(self, "COORD")
- self.function = function
- self.x = x
- self.y = y
- self.i = i
- self.j = j
- self.op = op
-
def to_gerber(self, settings=None):
ret = ''
- if self.function:
- ret += self.function
if self.x is not None:
- ret += 'X{0}'.format(write_gerber_value(self.x, settings.format,
- settings.zero_suppression))
+ ret += 'X{0}'.format(write_gerber_value(self.x, settings.format, settings.zero_suppression))
if self.y is not None:
- ret += 'Y{0}'.format(write_gerber_value(self.y, settings.format,
- settings.zero_suppression))
+ ret += 'Y{0}'.format(write_gerber_value(self.y, settings.format, settings.zero_suppression))
if self.i is not None:
- ret += 'I{0}'.format(write_gerber_value(self.i, settings.format,
- settings.zero_suppression))
+ ret += 'I{0}'.format(write_gerber_value(self.i, settings.format, settings.zero_suppression))
if self.j is not None:
- ret += 'J{0}'.format(write_gerber_value(self.j, settings.format,
- settings.zero_suppression))
+ ret += 'J{0}'.format(write_gerber_value(self.j, settings.format, settings.zero_suppression))
if self.op:
ret += self.op
return ret + '*'
- def to_inch(self):
- if self.units == 'metric':
- self.units = 'inch'
- if self.x is not None:
- self.x = inch(self.x)
- if self.y is not None:
- self.y = inch(self.y)
- if self.i is not None:
- self.i = inch(self.i)
- if self.j is not None:
- self.j = inch(self.j)
- if self.function == "G71":
- self.function = "G70"
-
- def to_metric(self):
- if self.units == 'inch':
- self.units = 'metric'
- if self.x is not None:
- self.x = metric(self.x)
- if self.y is not None:
- self.y = metric(self.y)
- if self.i is not None:
- self.i = metric(self.i)
- if self.j is not None:
- self.j = metric(self.j)
- if self.function == "G70":
- self.function = "G71"
-
def offset(self, x_offset=0, y_offset=0):
if self.x is not None:
self.x += x_offset
@@ -1076,13 +464,56 @@ class CoordStmt(Statement):
# TODO this isn't required
return self.function != None and self.op == None and self.x == None and self.y == None and self.i == None and self.j == None
+class InterpolateStmt(CoordStmt):
+ """ D01 interpolation operation """
+ code = 'D01'
-class ApertureStmt(Statement):
- """ Aperture Statement
- """
+class MoveStmt(CoordStmt):
+ """ D02 move operation """
+ code = 'D02'
+
+class FlashStmt(CoordStmt):
+ """ D03 flash operation """
+ code = 'D03'
+
+class InterpolationStmt(Statement):
+ """ G01 / G02 / G03 interpolation mode statement """
+ def to_gerber(self, **_kwargs):
+ return self.code + '*'
+
+ def __str__(self):
+ return f'<{self.__doc__.strip()}>'
+
+class LinearModeStmt(InterpolationStmt):
+ """ G01 linear interpolation mode statement """
+ code = 'G01'
- def __init__(self, d, deprecated=None):
- Statement.__init__(self, "APERTURE")
+class CircularCWModeStmt(InterpolationStmt):
+ """ G02 circular interpolation mode statement """
+ code = 'G02'
+
+class CircularCCWModeStmt(InterpolationStmt):
+ """ G03 circular interpolation mode statement """
+ code = 'G03'
+
+class SingleQuadrantModeStmt(InterpolationStmt):
+ """ G75 single-quadrant arc interpolation mode statement """
+ code = 'G75'
+
+class MultiQuadrantModeStmt(InterpolationStmt):
+ """ G74 multi-quadrant arc interpolation mode statement """
+ code = 'G74'
+
+class RegionStartStatement(InterpolationStmt):
+ """ G36 Region Mode Start Statement. """
+ code = 'G36'
+
+class RegionEndStatement(InterpolationStmt):
+ """ G37 Region Mode End Statement. """
+ code = 'G37'
+
+class ApertureStmt(Statement):
+ def __init__(self, d):
self.d = int(d)
self.deprecated = True if deprecated is not None and deprecated is not False else False
@@ -1097,23 +528,20 @@ class ApertureStmt(Statement):
class CommentStmt(Statement):
- """ Comment Statment
- """
+ """ G04 Comment Statment """
def __init__(self, comment):
- Statement.__init__(self, "COMMENT")
self.comment = comment if comment is not None else ""
def to_gerber(self, settings=None):
- return 'G04{0}*'.format(self.comment)
+ return f'G04{self.comment}*'
def __str__(self):
- return '<Comment: %s>' % self.comment
+ return f'<G04 Comment: {self.comment}>'
class EofStmt(Statement):
- """ EOF Statement
- """
+ """ M02 EOF Statement """
def __init__(self):
Statement.__init__(self, "EOF")
@@ -1122,76 +550,14 @@ class EofStmt(Statement):
return 'M02*'
def __str__(self):
- return '<EOF Statement>'
-
-
-class QuadrantModeStmt(Statement):
-
- @classmethod
- def single(cls):
- return cls('single-quadrant')
-
- @classmethod
- def multi(cls):
- return cls('multi-quadrant')
-
- @classmethod
- def from_gerber(cls, line):
- if 'G74' not in line and 'G75' not in line:
- raise ValueError('%s is not a valid quadrant mode statement'
- % line)
- return (cls('single-quadrant') if line[:3] == 'G74'
- else cls('multi-quadrant'))
-
- def __init__(self, mode):
- super(QuadrantModeStmt, self).__init__('QuadrantMode')
- mode = mode.lower()
- if mode not in ['single-quadrant', 'multi-quadrant']:
- raise ValueError('Quadrant mode must be "single-quadrant" \
- or "multi-quadrant"')
- self.mode = mode
-
- def to_gerber(self, settings=None):
- return 'G74*' if self.mode == 'single-quadrant' else 'G75*'
-
-
-class RegionModeStmt(Statement):
-
- @classmethod
- def from_gerber(cls, line):
- if 'G36' not in line and 'G37' not in line:
- raise ValueError('%s is not a valid region mode statement' % line)
- return (cls('on') if line[:3] == 'G36' else cls('off'))
-
- @classmethod
- def on(cls):
- return cls('on')
-
- @classmethod
- def off(cls):
- return cls('off')
-
- def __init__(self, mode):
- super(RegionModeStmt, self).__init__('RegionMode')
- mode = mode.lower()
- if mode not in ['on', 'off']:
- raise ValueError('Valid modes are "on" or "off"')
- self.mode = mode
-
- def to_gerber(self, settings=None):
- return 'G36*' if self.mode == 'on' else 'G37*'
-
+ return '<M02 EOF Statement>'
class UnknownStmt(Statement):
- """ Unknown Statement
- """
-
def __init__(self, line):
- Statement.__init__(self, "UNKNOWN")
self.line = line
- def to_gerber(self, settings=None):
+ def to_gerber(self, settings):
return self.line
def __str__(self):
- return '<Unknown Statement: \'%s\'>' % self.line
+ return f'<Unknown Statement: "{self.line}">'
diff --git a/gerbonara/gerber/panelize/__init__.py b/gerbonara/gerber/panelize/__init__.py
deleted file mode 100644
index 7185aea..0000000
--- a/gerbonara/gerber/panelize/__init__.py
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-# Copyright 2019 Hiroshi Murayama <opiopan@gmail.com>
-
-from .composition import GerberComposition, DrillComposition
-# from .dxf import DxfFile
diff --git a/gerbonara/gerber/panelize/utility.py b/gerbonara/gerber/panelize/utility.py
index fc44e79..0d57979 100644
--- a/gerbonara/gerber/panelize/utility.py
+++ b/gerbonara/gerber/panelize/utility.py
@@ -5,14 +5,6 @@
from math import cos, sin, pi, sqrt
-# TODO: replace with ..utils.rotate
-#def rotate(x, y, angle, center):
-# x0 = x - center[0]
-# y0 = y - center[1]
-# angle = angle * pi / 180.0
-# return (cos(angle) * x0 - sin(angle) * y0 + center[0],
-# sin(angle) * x0 + cos(angle) * y0 + center[1])
-
def is_equal_value(a, b, error_range=0):
return (a - b) * (a - b) <= error_range * error_range
diff --git a/gerbonara/gerber/render/__init__.py b/gerbonara/gerber/render/__init__.py
deleted file mode 100644
index c7dbdd5..0000000
--- a/gerbonara/gerber/render/__init__.py
+++ /dev/null
@@ -1,31 +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
-============
-**Gerber Renderers**
-
-This module provides contexts for rendering images of gerber layers. Currently
-SVG is the only supported format.
-"""
-
-from .render import RenderSettings
-from .cairo_backend import GerberCairoContext
-
-available_renderers = {
- 'cairo': GerberCairoContext,
-}
diff --git a/gerbonara/gerber/render/cairo_backend.py b/gerbonara/gerber/render/cairo_backend.py
deleted file mode 100644
index 431ab94..0000000
--- a/gerbonara/gerber/render/cairo_backend.py
+++ /dev/null
@@ -1,640 +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.
-
-try:
- import cairo
-except ImportError:
- import cairocffi as cairo
-
-from operator import mul
-import tempfile
-import warnings
-import os
-
-from .render import GerberContext, RenderSettings
-from .theme import THEMES
-from ..primitives import *
-from ..utils import rotate_point
-
-from io import BytesIO
-
-
-class GerberCairoContext(GerberContext):
-
- def __init__(self, scale=300):
- super(GerberCairoContext, self).__init__()
- self.scale = (scale, scale)
- self.surface = None
- self.surface_buffer = None
- self.ctx = None
- self.active_layer = None
- self.active_matrix = None
- self.output_ctx = None
- self.has_bg = False
- self.origin_in_inch = None
- self.size_in_inch = None
- self._xform_matrix = None
- self._render_count = 0
-
- @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
- self._xform_matrix = cairo.Matrix(xx=1.0, yy=-1.0,
- x0=-self.origin_in_pixels[0],
- y0=self.size_in_pixels[1])
- 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)
-
- def render_layer(self, layer, filename=None, settings=None, bgsettings=None,
- verbose=False, bounds=None):
- if settings is None:
- settings = THEMES['default'].get(layer.layer_class, RenderSettings())
- if bgsettings is None:
- bgsettings = THEMES['default'].get('background', RenderSettings())
-
- if self._render_count == 0:
- if verbose:
- print('[Render]: Rendering Background.')
- self.clear()
- if bounds is not None:
- self.set_bounds(bounds)
- else:
- self.set_bounds(layer.bounds)
- self.paint_background(bgsettings)
- if verbose:
- print('[Render]: Rendering {} Layer.'.format(layer.layer_class))
- self._render_count += 1
- self._render_layer(layer, settings)
- if filename is not None:
- self.dump(filename, verbose)
-
- def render_layers(self, layers, filename, theme=THEMES['default'],
- verbose=False, max_width=800, max_height=600):
- """ Render a set of layers
- """
- # Calculate scale parameter
- x_range = [10000, -10000]
- y_range = [10000, -10000]
- for layer in layers:
- bounds = layer.bounds
- if bounds is not None:
- layer_x, layer_y = bounds
- x_range[0] = min(x_range[0], layer_x[0])
- x_range[1] = max(x_range[1], layer_x[1])
- y_range[0] = min(y_range[0], layer_y[0])
- y_range[1] = max(y_range[1], layer_y[1])
- width = x_range[1] - x_range[0]
- height = y_range[1] - y_range[0]
-
- scale = math.floor(min(float(max_width)/width, float(max_height)/height))
- self.scale = (scale, scale)
-
- self.clear()
-
- # Render layers
- bgsettings = theme['background']
- for layer in layers:
- settings = theme.get(layer.layer_class, RenderSettings())
- self.render_layer(layer, settings=settings, bgsettings=bgsettings,
- verbose=verbose)
- self.dump(filename, verbose)
-
- def dump(self, filename=None, verbose=False):
- """ Save image as `filename`
- """
- try:
- is_svg = os.path.splitext(filename.lower())[1] == '.svg'
- except:
- is_svg = False
-
- if verbose:
- print('[Render]: Writing image to {}'.format(filename))
-
- if is_svg:
- self.surface.finish()
- self.surface_buffer.flush()
- with open(filename, "wb") as f:
- self.surface_buffer.seek(0)
- f.write(self.surface_buffer.read())
- f.flush()
- else:
- return self.surface.write_to_png(filename)
-
- def dump_str(self):
- """ Return a byte-string containing the rendered image.
- """
- fobj = BytesIO()
- 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 clear(self):
- self.surface = None
- self.output_ctx = None
- self.has_bg = False
- self.origin_in_inch = None
- self.size_in_inch = None
- self._xform_matrix = None
- self._render_count = 0
- self.surface_buffer = None
-
- def _new_mask(self):
- class Mask:
- def __enter__(msk):
- size_in_pixels = self.size_in_pixels
- msk.surface = cairo.SVGSurface(None, size_in_pixels[0],
- size_in_pixels[1])
- msk.ctx = cairo.Context(msk.surface)
- msk.ctx.translate(-self.origin_in_pixels[0], -self.origin_in_pixels[1])
- return msk
-
-
- def __exit__(msk, exc_type, exc_val, traceback):
- if hasattr(msk.surface, 'finish'):
- msk.surface.finish()
-
- return Mask()
-
- def _render_layer(self, layer, settings):
- self.invert = settings.invert
- # Get a new clean layer to render on
- self.new_render_layer(mirror=settings.mirror)
- for prim in layer.primitives:
- self.render(prim)
- # Add layer to image
- self.flatten(settings.color, settings.alpha)
-
- def _render_line(self, line, color):
- start = self.scale_point(line.start)
- end = self.scale_point(line.end)
- self.ctx.set_operator(cairo.OPERATOR_OVER
- if (not self.invert)
- and line.level_polarity == 'dark'
- else cairo.OPERATOR_CLEAR)
-
- with self._clip_primitive(line):
- with self._new_mask() as mask:
- if isinstance(line.aperture, Circle):
- width = line.aperture.diameter
- mask.ctx.set_line_width(width * self.scale[0])
- mask.ctx.set_line_cap(cairo.LINE_CAP_ROUND)
- mask.ctx.move_to(*start)
- mask.ctx.line_to(*end)
- mask.ctx.stroke()
-
- elif hasattr(line, 'vertices') and line.vertices is not None:
- points = [self.scale_point(x) for x in line.vertices]
- mask.ctx.set_line_width(0)
- mask.ctx.move_to(*points[-1])
- for point in points:
- mask.ctx.line_to(*point)
- mask.ctx.fill()
- self.ctx.mask_surface(mask.surface, self.origin_in_pixels[0])
-
- 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
- two_pi = 2 * math.pi
- angle1 = (arc.start_angle + two_pi) % two_pi
- angle2 = (arc.end_angle + two_pi) % two_pi
-
- if arc.quadrant_mode == 'single-quadrant':
- warnings.warn('Cairo backend does not support single-quadrant arcs.')
-
- if angle1 == angle2:
- # 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)
-
- self.ctx.set_operator(cairo.OPERATOR_OVER
- if (not self.invert)
- and arc.level_polarity == 'dark'
- else cairo.OPERATOR_CLEAR)
- with self._clip_primitive(arc):
- with self._new_mask() as mask:
- mask.ctx.set_line_width(width * self.scale[0])
- mask.ctx.set_line_cap(cairo.LINE_CAP_ROUND if isinstance(arc.aperture, Circle) else cairo.LINE_CAP_SQUARE)
- mask.ctx.move_to(*start) # You actually have to do this...
- if arc.direction == 'counterclockwise':
- mask.ctx.arc(center[0], center[1], radius, angle1, angle2)
- else:
- mask.ctx.arc_negative(center[0], center[1], radius, angle1, angle2)
- mask.ctx.move_to(*end) # ...lame
- mask.ctx.stroke()
-
- #if isinstance(arc.aperture, Rectangle):
- # print("Flash Rectangle Ends")
- # print(arc.aperture.rotation * 180/math.pi)
- # rect = arc.aperture
- # width = self.scale[0] * rect.width
- # height = self.scale[1] * rect.height
- # for point, angle in zip((start, end), (angle1, angle2)):
- # print("{} w {} h{}".format(point, rect.width, rect.height))
- # mask.ctx.rectangle(point[0] - width/2.0,
- # point[1] - height/2.0, width, height)
- # mask.ctx.fill()
-
- self.ctx.mask_surface(mask.surface, self.origin_in_pixels[0])
-
- def _render_region(self, region, color):
- self.ctx.set_operator(cairo.OPERATOR_OVER
- if (not self.invert) and region.level_polarity == 'dark'
- else cairo.OPERATOR_CLEAR)
- with self._clip_primitive(region):
- with self._new_mask() as mask:
- mask.ctx.set_line_width(0)
- mask.ctx.set_line_cap(cairo.LINE_CAP_ROUND)
- mask.ctx.move_to(*self.scale_point(region.primitives[0].start))
- for prim in region.primitives:
- if isinstance(prim, Line):
- mask.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 angle1 == angle2:
- # Make the angles slightly different otherwise Cario will draw nothing
- angle2 -= 0.000000001
- if prim.direction == 'counterclockwise':
- mask.ctx.arc(center[0], center[1], radius,
- angle1, angle2)
- else:
- mask.ctx.arc_negative(center[0], center[1], radius,
- angle1, angle2)
- mask.ctx.fill()
- self.ctx.mask_surface(mask.surface, self.origin_in_pixels[0])
-
- def _render_circle(self, circle, color):
- center = self.scale_point(circle.position)
- self.ctx.set_operator(cairo.OPERATOR_OVER
- if (not self.invert)
- and circle.level_polarity == 'dark'
- else cairo.OPERATOR_CLEAR)
- with self._clip_primitive(circle):
- with self._new_mask() as mask:
- mask.ctx.set_line_width(0)
- mask.ctx.arc(center[0], center[1], (circle.radius * self.scale[0]), 0, (2 * math.pi))
- mask.ctx.fill()
-
- if hasattr(circle, 'hole_diameter') and circle.hole_diameter is not None and circle.hole_diameter > 0:
- mask.ctx.set_operator(cairo.OPERATOR_CLEAR)
- mask.ctx.arc(center[0], center[1], circle.hole_radius * self.scale[0], 0, 2 * math.pi)
- mask.ctx.fill()
-
- if (hasattr(circle, 'hole_width') and hasattr(circle, 'hole_height')
- and circle.hole_width is not None and circle.hole_height is not None
- and circle.hole_width > 0 and circle.hole_height > 0):
- mask.ctx.set_operator(cairo.OPERATOR_CLEAR
- if circle.level_polarity == 'dark'
- and (not self.invert)
- else cairo.OPERATOR_OVER)
- width, height = self.scale_point((circle.hole_width, circle.hole_height))
- lower_left = rotate_point(
- (center[0] - width / 2.0, center[1] - height / 2.0),
- circle.rotation, center)
- lower_right = rotate_point((center[0] + width / 2.0, center[1] - height / 2.0),
- circle.rotation, center)
- upper_left = rotate_point((center[0] - width / 2.0, center[1] + height / 2.0),
- circle.rotation, center)
- upper_right = rotate_point((center[0] + width / 2.0, center[1] + height / 2.0),
- circle.rotation, center)
- points = (lower_left, lower_right, upper_right, upper_left)
- mask.ctx.move_to(*points[-1])
- for point in points:
- mask.ctx.line_to(*point)
- mask.ctx.fill()
- self.ctx.mask_surface(mask.surface, self.origin_in_pixels[0])
-
- def _render_rectangle(self, rectangle, color):
- lower_left = self.scale_point(rectangle.lower_left)
- width, height = tuple([abs(coord) for coord in
- self.scale_point((rectangle.width,
- rectangle.height))])
- self.ctx.set_operator(cairo.OPERATOR_OVER
- if (not self.invert)
- and rectangle.level_polarity == 'dark'
- else cairo.OPERATOR_CLEAR)
- with self._clip_primitive(rectangle):
- with self._new_mask() as mask:
- mask.ctx.set_line_width(0)
- mask.ctx.rectangle(lower_left[0], lower_left[1], width, height)
- mask.ctx.fill()
-
- center = self.scale_point(rectangle.position)
- if rectangle.hole_diameter > 0:
- # Render the center clear
- mask.ctx.set_operator(cairo.OPERATOR_CLEAR
- if rectangle.level_polarity == 'dark'
- and (not self.invert)
- else cairo.OPERATOR_OVER)
-
- mask.ctx.arc(center[0], center[1], rectangle.hole_radius * self.scale[0], 0, 2 * math.pi)
- mask.ctx.fill()
-
- if rectangle.hole_width > 0 and rectangle.hole_height > 0:
- mask.ctx.set_operator(cairo.OPERATOR_CLEAR
- if rectangle.level_polarity == 'dark'
- and (not self.invert)
- else cairo.OPERATOR_OVER)
- width, height = self.scale_point((rectangle.hole_width, rectangle.hole_height))
- lower_left = rotate_point((center[0] - width/2.0, center[1] - height/2.0), rectangle.rotation, center)
- lower_right = rotate_point((center[0] + width/2.0, center[1] - height/2.0), rectangle.rotation, center)
- upper_left = rotate_point((center[0] - width / 2.0, center[1] + height / 2.0), rectangle.rotation, center)
- upper_right = rotate_point((center[0] + width / 2.0, center[1] + height / 2.0), rectangle.rotation, center)
- points = (lower_left, lower_right, upper_right, upper_left)
- mask.ctx.move_to(*points[-1])
- for point in points:
- mask.ctx.line_to(*point)
- mask.ctx.fill()
- self.ctx.mask_surface(mask.surface, self.origin_in_pixels[0])
-
- def _render_obround(self, obround, color):
- self.ctx.set_operator(cairo.OPERATOR_OVER
- if (not self.invert)
- and obround.level_polarity == 'dark'
- else cairo.OPERATOR_CLEAR)
- with self._clip_primitive(obround):
- with self._new_mask() as mask:
- mask.ctx.set_line_width(0)
-
- # Render circles
- for circle in (obround.subshapes['circle1'], obround.subshapes['circle2']):
- center = self.scale_point(circle.position)
- mask.ctx.arc(center[0], center[1], (circle.radius * self.scale[0]), 0, (2 * math.pi))
- mask.ctx.fill()
-
- # Render Rectangle
- rectangle = obround.subshapes['rectangle']
- lower_left = self.scale_point(rectangle.lower_left)
- width, height = tuple([abs(coord) for coord in
- self.scale_point((rectangle.width,
- rectangle.height))])
- mask.ctx.rectangle(lower_left[0], lower_left[1], width, height)
- mask.ctx.fill()
-
- center = self.scale_point(obround.position)
- if obround.hole_diameter > 0:
- # Render the center clear
- mask.ctx.set_operator(cairo.OPERATOR_CLEAR)
- mask.ctx.arc(center[0], center[1], obround.hole_radius * self.scale[0], 0, 2 * math.pi)
- mask.ctx.fill()
-
- if obround.hole_width > 0 and obround.hole_height > 0:
- mask.ctx.set_operator(cairo.OPERATOR_CLEAR
- if rectangle.level_polarity == 'dark'
- and (not self.invert)
- else cairo.OPERATOR_OVER)
- width, height =self.scale_point((obround.hole_width, obround.hole_height))
- lower_left = rotate_point((center[0] - width / 2.0, center[1] - height / 2.0),
- obround.rotation, center)
- lower_right = rotate_point((center[0] + width / 2.0, center[1] - height / 2.0),
- obround.rotation, center)
- upper_left = rotate_point((center[0] - width / 2.0, center[1] + height / 2.0),
- obround.rotation, center)
- upper_right = rotate_point((center[0] + width / 2.0, center[1] + height / 2.0),
- obround.rotation, center)
- points = (lower_left, lower_right, upper_right, upper_left)
- mask.ctx.move_to(*points[-1])
- for point in points:
- mask.ctx.line_to(*point)
- mask.ctx.fill()
-
- self.ctx.mask_surface(mask.surface, self.origin_in_pixels[0])
-
- def _render_polygon(self, polygon, color):
- self.ctx.set_operator(cairo.OPERATOR_OVER
- if (not self.invert)
- and polygon.level_polarity == 'dark'
- else cairo.OPERATOR_CLEAR)
- with self._clip_primitive(polygon):
- with self._new_mask() as mask:
-
- vertices = polygon.vertices
- mask.ctx.set_line_width(0)
- mask.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
- mask.ctx.move_to(*self.scale_point(vertices[-1]))
- for v in vertices:
- mask.ctx.line_to(*self.scale_point(v))
- mask.ctx.fill()
-
- center = self.scale_point(polygon.position)
- if polygon.hole_radius > 0:
- # Render the center clear
- mask.ctx.set_operator(cairo.OPERATOR_CLEAR
- if polygon.level_polarity == 'dark'
- and (not self.invert)
- else cairo.OPERATOR_OVER)
- mask.ctx.set_line_width(0)
- mask.ctx.arc(center[0],
- center[1],
- polygon.hole_radius * self.scale[0], 0, 2 * math.pi)
- mask.ctx.fill()
-
- if polygon.hole_width > 0 and polygon.hole_height > 0:
- mask.ctx.set_operator(cairo.OPERATOR_CLEAR
- if polygon.level_polarity == 'dark'
- and (not self.invert)
- else cairo.OPERATOR_OVER)
- width, height = self.scale_point((polygon.hole_width, polygon.hole_height))
- lower_left = rotate_point((center[0] - width / 2.0, center[1] - height / 2.0),
- polygon.rotation, center)
- lower_right = rotate_point((center[0] + width / 2.0, center[1] - height / 2.0),
- polygon.rotation, center)
- upper_left = rotate_point((center[0] - width / 2.0, center[1] + height / 2.0),
- polygon.rotation, center)
- upper_right = rotate_point((center[0] + width / 2.0, center[1] + height / 2.0),
- polygon.rotation, center)
- points = (lower_left, lower_right, upper_right, upper_left)
- mask.ctx.move_to(*points[-1])
- for point in points:
- mask.ctx.line_to(*point)
- mask.ctx.fill()
-
- self.ctx.mask_surface(mask.surface, self.origin_in_pixels[0])
-
- 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
-
- self.ctx.set_operator(cairo.OPERATOR_OVER
- if slot.level_polarity == 'dark' and
- (not self.invert) else cairo.OPERATOR_CLEAR)
- with self._clip_primitive(slot):
- with self._new_mask() as mask:
- mask.ctx.set_line_width(width * self.scale[0])
- mask.ctx.set_line_cap(cairo.LINE_CAP_ROUND)
- mask.ctx.move_to(*start)
- mask.ctx.line_to(*end)
- mask.ctx.stroke()
- self.ctx.mask_surface(mask.surface, self.origin_in_pixels[0])
-
- def _render_amgroup(self, amgroup, color):
- # Since holes/clear areas in the mask group must be drawn as clear, we need to render the primitives of this
- # group into a mask context first, then composite this mask context on top of our output surface. This means
- # that a clear primitive inside the group will cover/draw over dark primitives inside the group, but it will
- # *not* cover/draw over dark primitives outside the group.
-
- mask_surface = cairo.SVGSurface(None, self.size_in_pixels[0], self.size_in_pixels[1])
- mask_ctx = cairo.Context(mask_surface)
- mask_ctx.set_matrix(self.ctx.get_matrix())
-
- old_surface, self.surface = self.surface, mask_surface
- old_ctx, self.ctx = self.ctx, mask_ctx
-
- for primitive in amgroup.primitives:
- self.render(primitive)
-
- old_ctx.mask_surface(mask_surface, self.origin_in_pixels[0])
- mask_surface.finish()
- self.surface, self.ctx = old_surface, old_ctx
-
- def _render_test_record(self, primitive, color):
- position = [pos + origin for pos, origin in
- zip(primitive.position, self.origin_in_inch)]
- 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_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.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, mirror=False):
- size_in_pixels = self.scale_point(self.size_in_inch)
- m = self._xform_matrix
- matrix = cairo.Matrix(m.xx, m.yx, m.xy, m.yy, m.x0, m.y0)
- layer = cairo.SVGSurface(None, size_in_pixels[0], size_in_pixels[1])
- ctx = cairo.Context(layer)
-
- if self.invert:
- ctx.set_source_rgba(0.0, 0.0, 0.0, 1.0)
- ctx.set_operator(cairo.OPERATOR_OVER)
- ctx.paint()
- if mirror:
- matrix.xx = -1.0
- matrix.x0 = self.origin_in_pixels[0] + self.size_in_pixels[0]
- self.ctx = ctx
- self.ctx.set_matrix(matrix)
- self.active_layer = layer
- self.active_matrix = matrix
-
- def flatten(self, color=None, alpha=None):
- color = color if color is not None else self.color
- alpha = alpha if alpha is not None else self.alpha
- self.output_ctx.set_source_rgba(color[0], color[1], color[2], alpha)
- self.output_ctx.mask_surface(self.active_layer)
- self.ctx = None
- self.active_layer = None
- self.active_matrix = None
-
- def paint_background(self, settings=None):
- color = settings.color if settings is not None else self.background_color
- alpha = settings.alpha if settings is not None else 1.0
- if not self.has_bg:
- self.has_bg = True
- self.output_ctx.set_source_rgba(color[0], color[1], color[2], alpha)
- self.output_ctx.paint()
-
- def _clip_primitive(self, primitive):
- """ Clip rendering context to pixel-aligned bounding box
-
- Calculates pixel- and axis- aligned bounding box, and clips current
- context to that region. Improves rendering speed significantly. This
- returns a context manager, use as follows:
-
- with self._clip_primitive(some_primitive):
- do_rendering_stuff()
- do_more_rendering stuff(with, arguments)
-
- The context manager will reset the context's clipping region when it
- goes out of scope.
-
- """
- class Clip:
- def __init__(clp, primitive):
- (xmin, ymin), (xmax, ymax) = primitive.bounding_box
-
- # Round bounds to the nearest pixel outside of the primitive
- clp.xmin = math.floor(self.scale[0] * xmin)
- clp.xmax = math.ceil(self.scale[0] * xmax)
-
- # We need to offset Y to take care of the difference in y-pos
- # caused by flipping the axis.
- clp.ymin = math.floor(
- (self.scale[1] * ymin) - math.ceil(self.origin_in_pixels[1]))
- clp.ymax = math.ceil(
- (self.scale[1] * ymax) - math.floor(self.origin_in_pixels[1]))
-
- # Calculate width and height, rounded to the nearest pixel
- clp.width = abs(clp.xmax - clp.xmin)
- clp.height = abs(clp.ymax - clp.ymin)
-
- def __enter__(clp):
- # Clip current context to primitive's bounding box
- self.ctx.rectangle(clp.xmin, clp.ymin, clp.width, clp.height)
- self.ctx.clip()
-
- def __exit__(clp, exc_type, exc_val, traceback):
- # Reset context clip region
- self.ctx.reset_clip()
-
- return Clip(primitive)
-
- def scale_point(self, point):
- return tuple([coord * scale for coord, scale in zip(point, self.scale)])
diff --git a/gerbonara/gerber/rs274x.py b/gerbonara/gerber/rs274x.py
index 1d946e9..1ab030c 100644
--- a/gerbonara/gerber/rs274x.py
+++ b/gerbonara/gerber/rs274x.py
@@ -25,12 +25,10 @@ import json
import os
import re
import sys
+import warnings
+from pathlib import Path
from itertools import count, chain
-
-try:
- from cStringIO import StringIO
-except(ImportError):
- from io import StringIO
+from io import StringIO
from .gerber_statements import *
from .primitives import *
@@ -38,40 +36,6 @@ from .cam import CamFile, FileSettings
from .utils import sq_distance, rotate_point
-def read(filename):
- """ Read data from filename and return a GerberFile
-
- Parameters
- ----------
- filename : string
- Filename of file to parse
-
- Returns
- -------
- file : :class:`gerber.rs274x.GerberFile`
- A GerberFile created from the specified file.
- """
- return GerberParser().parse(filename)
-
-
-def loads(data, filename=None):
- """ Generate a GerberFile object from rs274x data in memory
-
- Parameters
- ----------
- data : string
- string containing gerber file contents
-
- filename : string, optional
- string containing the filename of the data source
-
- Returns
- -------
- file : :class:`gerber.rs274x.GerberFile`
- A GerberFile created from the specified file.
- """
- return GerberParser().parse_raw(data, filename)
-
class GerberFile(CamFile):
""" A class representing a single gerber file
@@ -148,18 +112,31 @@ class GerberFile(CamFile):
self.context.notation = 'absolute'
self.context.zeros = 'trailing'
+
+ @classmethod
+ def open(kls, filename, enable_includes=False, enable_include_dir=None):
+ with open(filename, "r") as f:
+ if enable_includes and enable_include_dir is None:
+ enable_include_dir = Path(filename).parent
+ return kls.from_string(f.read(), enable_include_dir)
+
+
+ @classmethod
+ def from_string(kls, data, enable_include_dir=None):
+ return GerberParser().parse(data, enable_include_dir)
+
@property
def comments(self):
- return [comment.comment for comment in self.statements if isinstance(comment, CommentStmt)]
+ return [stmt.comment for stmt in self.statements if isinstance(stmt, CommentStmt)]
@property
def size(self):
- (x0, y0), (x1, y1)= self.bounding_box
+ (x0, y0), (x1, y1) = self.bounding_box
return (x1 - x0, y1 - y0)
@property
def bounding_box(self):
- bounds = [ p.bounding_box for p in self.primitives ]
+ bounds = [ p.bounding_box for p in self.pDeprecatedrimitives ]
min_x = min(x0 for (x0, y0), (x1, y1) in bounds)
min_y = min(y0 for (x0, y0), (x1, y1) in bounds)
@@ -169,19 +146,19 @@ class GerberFile(CamFile):
return ((min_x, max_x), (min_y, max_y))
# TODO: re-add settings arg
- def write(self, filename=None):
- self.context.notation = 'absolute'
- self.context.zeros = 'trailing'
- self.context.format = self.format
+ def write(self, filename):
+ self.settings.notation = 'absolute'
+ self.settings.zeros = 'trailing'
+ self.settings.format = self.format
self.units = self.units
- with open(filename or self.filename, 'w') as f:
- print(MOParamStmt('MO', self.context.units).to_gerber(self.context), file=f)
- print(FSParamStmt('FS', self.context.zero_suppression, self.context.notation, self.context.format).to_gerber(self.context), file=f)
- print('%IPPOS*%', file=f)
+ with open(filename, 'w') as f:
+ print(UnitStmt().to_gerber(self.settings), file=f)
+ print(FormatSpecStmt().to_gerber(self.settings), file=f)
+ print(ImagePolarityStmt().to_gerber(self.settings), file=f)
for thing in chain(self.aperture_macros.values(), self.aperture_defs, self.main_statements):
- print(thing.to_gerber(self.context), file=f)
+ print(thing.to_gerber(self.settings), file=f)
print('M02*', file=f)
@@ -236,7 +213,6 @@ class GerberFile(CamFile):
def _generalize_apertures(self):
# For rotation, replace standard apertures with macro apertures.
-
if not any(isinstance(stm, ADParamStmt) and stm.shape in 'ROP' for stm in self.aperture_defs):
return
@@ -269,68 +245,47 @@ class GerberFile(CamFile):
statement.shape = polygon
-class GerberParser(object):
- """ GerberParser
- """
+class GerberParser:
NUMBER = r"[\+-]?\d+"
DECIMAL = r"[\+-]?\d+([.]?\d+)?"
- STRING = r"[a-zA-Z0-9_+\-/!?<>”’(){}.\|&@# :]+"
NAME = r"[a-zA-Z_$\.][a-zA-Z_$\.0-9+\-]+"
- FS = r"(?P<param>FS)(?P<zero>(L|T|D))?(?P<notation>(A|I))[NG0-9]*X(?P<x>[0-7][0-7])Y(?P<y>[0-7][0-7])[DM0-9]*"
- MO = r"(?P<param>MO)(?P<mo>(MM|IN))"
- LP = r"(?P<param>LP)(?P<lp>(D|C))"
- AD_CIRCLE = r"(?P<param>AD)D(?P<d>\d+)(?P<shape>C)[,]?(?P<modifiers>[^,%]*)"
- AD_RECT = r"(?P<param>AD)D(?P<d>\d+)(?P<shape>R)[,](?P<modifiers>[^,%]*)"
- AD_OBROUND = r"(?P<param>AD)D(?P<d>\d+)(?P<shape>O)[,](?P<modifiers>[^,%]*)"
- AD_POLY = r"(?P<param>AD)D(?P<d>\d+)(?P<shape>P)[,](?P<modifiers>[^,%]*)"
- AD_MACRO = r"(?P<param>AD)D(?P<d>\d+)(?P<shape>{name})[,]?(?P<modifiers>[^,%]*)".format(name=NAME)
- AM = r"(?P<param>AM)(?P<name>{name})\*(?P<macro>[^%]*)".format(name=NAME)
- # Include File
- IF = r"(?P<param>IF)(?P<filename>.*)"
-
-
- # begin deprecated
- AS = r"(?P<param>AS)(?P<mode>(AXBY)|(AYBX))"
- IN = r"(?P<param>IN)(?P<name>.*)"
- IP = r"(?P<param>IP)(?P<ip>(POS|NEG))"
- IR = r"(?P<param>IR)(?P<angle>{number})".format(number=NUMBER)
- MI = r"(?P<param>MI)(A(?P<a>0|1))?(B(?P<b>0|1))?"
- OF = r"(?P<param>OF)(A(?P<a>{decimal}))?(B(?P<b>{decimal}))?".format(decimal=DECIMAL)
- SF = r"(?P<param>SF)(A(?P<a>{decimal}))?(B(?P<b>{decimal}))?".format(decimal=DECIMAL)
- LN = r"(?P<param>LN)(?P<name>.*)"
- DEPRECATED_UNIT = re.compile(r'(?P<mode>G7[01])\*')
- DEPRECATED_FORMAT = re.compile(r'(?P<format>G9[01])\*')
- # end deprecated
-
- PARAMS = (FS, MO, LP, AD_CIRCLE, AD_RECT, AD_OBROUND, AD_POLY,
- AD_MACRO, AM, AS, IF, IN, IP, IR, MI, OF, SF, LN)
-
- PARAM_STMT = [re.compile(r"%?{0}\*%?".format(p)) for p in PARAMS]
-
- COORD_FUNCTION = r"G0?[123]"
- COORD_OP = r"D0?[123]"
-
- COORD_STMT = re.compile((
- r"(?P<function>{function})?"
- r"(X(?P<x>{number}))?(Y(?P<y>{number}))?"
- r"(I(?P<i>{number}))?(J(?P<j>{number}))?"
- r"(?P<op>{op})?\*".format(number=NUMBER, function=COORD_FUNCTION, op=COORD_OP)))
-
- APERTURE_STMT = re.compile(r"(?P<deprecated>(G54)|(G55))?D(?P<d>\d+)\*")
-
- COMMENT_STMT = re.compile(r"G0?4(?P<comment>[^*]*)(\*)?")
-
- EOF_STMT = re.compile(r"(?P<eof>M[0]?[012])\*")
-
- REGION_MODE_STMT = re.compile(r'(?P<mode>G3[67])\*')
- QUAD_MODE_STMT = re.compile(r'(?P<mode>G7[45])\*')
-
- # Keep include loop from crashing us
- INCLUDE_FILE_RECURSION_LIMIT = 10
-
- def __init__(self):
- self.filename = None
+ STATEMENT_REGEXES = {
+ 'unit_mode': r"MO(?P<unit>(MM|IN))",
+ 'interpolation_mode': r"(?P<code>G0?[123]|G74|G75)?",
+ 'coord': = fr"(X(?P<x>{NUMBER}))?(Y(?P<y>{NUMBER}))?" \
+ fr"(I(?P<i>{NUMBER}))?(J(?P<j>{NUMBER}))?" \
+ fr"(?P<operation>D0?[123])?\*",
+ 'aperture': r"(G54|G55)?D(?P<number>\d+)\*",
+ 'comment': r"G0?4(?P<comment>[^*]*)(\*)?",
+ 'format_spec': r"FS(?P<zero>(L|T|D))?(?P<notation>(A|I))[NG0-9]*X(?P<x>[0-7][0-7])Y(?P<y>[0-7][0-7])[DM0-9]*",
+ 'load_polarity': r"LP(?P<polarity>(D|C))",
+ 'load_name': r"LN(?P<name>.*)",
+ 'offset': fr"OF(A(?P<a>{DECIMAL}))?(B(?P<b>{DECIMAL}))?",
+ 'include_file': r"IF(?P<filename>.*)",
+ 'image_name': r"IN(?P<name>.*)",
+ 'axis_selection': r"AS(?P<axes>AXBY|AYBX)",
+ 'image_polarity': r"IP(?P<polarity>(POS|NEG))",
+ 'image_rotation': fr"IR(?P<rotation>{NUMBER})",
+ 'mirror_image': r"MI(A(?P<a>0|1))?(B(?P<b>0|1))?",
+ 'scale_factor': fr"SF(A(?P<a>{DECIMAL}))?(B(?P<b>{DECIMAL}))?",
+ 'aperture_definition': fr"ADD(?P<number>\d+)(?P<shape>C|R|O|P|{NAME})[,]?(?P<modifiers>[^,%]*)",
+ 'aperture_macro': fr"AM(?P<name>{NAME})\*(?P<macro>[^%]*)",
+ 'region_mode': r'(?P<mode>G3[67])\*',
+ 'quadrant_mode': r'(?P<mode>G7[45])\*',
+ 'old_unit':r'(?P<mode>G7[01])\*',
+ 'old_notation': r'(?P<mode>G9[01])\*',
+ 'eof': r"M0?[02]\*",
+ 'ignored': r"(?P<stmt>M01)\*",
+ }
+
+ STATEMENT_REGEXES = { key: re.compile(value) for key, value in STATEMENT_REGEXES.items() }
+
+
+ def __init__(self, include_dir=None):
+ """ Pass an include dir to enable IF include statements (potentially DANGEROUS!). """
+ self.include_dir = include_dir
+ self.include_stack = []
self.settings = FileSettings()
self.statements = []
self.primitives = []
@@ -339,6 +294,7 @@ class GerberParser(object):
self.current_region = None
self.x = 0
self.y = 0
+ self.last_operation = None
self.op = "D02"
self.aperture = 0
self.interpolation = 'linear'
@@ -348,17 +304,9 @@ class GerberParser(object):
self.region_mode = 'off'
self.quadrant_mode = 'multi-quadrant'
self.step_and_repeat = (1, 1, 0, 0)
- self._recursion_depth = 0
- def parse(self, filename):
- self.filename = filename
- with open(filename, "r") as fp:
- data = fp.read()
- return self.parse_raw(data, filename)
-
- def parse_raw(self, data, filename=None):
- self.filename = filename
- for stmt in self._parse(self._split_commands(data)):
+ def parse(self, data):
+ for stmt in self._parse(data):
self.evaluate(stmt)
self.statements.append(stmt)
@@ -366,38 +314,37 @@ class GerberParser(object):
for stmt in self.statements:
stmt.units = self.settings.units
- return GerberFile(self.statements, self.settings, self.primitives, self.apertures.values(), filename)
+ return GerberFile(self.statements, self.settings, self.primitives, self.apertures.values())
- def _split_commands(self, data):
+ @classmethod
+ def _split_commands(kls, data):
"""
Split the data into commands. Commands end with * (and also newline to help with some badly formatted files)
"""
- length = len(data)
start = 0
- in_header = True
+ extended_command = False
- for cur in range(0, length):
+ for pos, c in enumerate(data):
+ if c == '%':
+ if extended_command:
+ yield data[start:pos+1]
+ extended_command = False
+ start = pos + 1
- val = data[cur]
+ else:
+ extended_command = True
- if val == '%' and start == cur:
- in_header = True
continue
- if val == '\r' or val == '\n':
- if start != cur:
- yield data[start:cur]
- start = cur + 1
-
- elif not in_header and val == '*':
- yield data[start:cur + 1]
- start = cur + 1
+ elif extended_command:
+ continue
- elif in_header and val == '%':
- yield data[start:cur + 1]
+ if c == '\r' or c == '\n' or c == '*':
+ word_command = data[start:pos+1].strip()
+ if word_command and word_command != '*':
+ yield word_command
start = cur + 1
- in_header = False
def dump_json(self):
return json.dumps({"statements": [stmt.__dict__ for stmt in self.statements]})
@@ -406,164 +353,189 @@ class GerberParser(object):
return '\n'.join(str(stmt) for stmt in self.statements) + '\n'
def _parse(self, data):
- oldline = ''
-
- for line in data:
- line = oldline + line.strip()
-
- # skip empty lines
- if not len(line):
- continue
-
- # deal with multi-line parameters
- if line.startswith("%") and not line.endswith("%") and not "%" in line[1:]:
- oldline = line
- continue
-
- did_something = True # make sure we do at least one loop
- while did_something and len(line) > 0:
- did_something = False
-
- # consume empty data blocks
- if line[0] == '*':
- line = line[1:]
- did_something = True
- continue
-
- # coord
- (coord, r) = _match_one(self.COORD_STMT, line)
- if coord:
- yield CoordStmt.from_dict(coord, self.settings)
- line = r
- did_something = True
- continue
-
- # aperture selection
- (aperture, r) = _match_one(self.APERTURE_STMT, line)
- if aperture:
- yield ApertureStmt(**aperture)
- did_something = True
- line = r
- continue
+ for line in self._split_commands(data):
+ # We cannot assume input gerber to use well-formed statement delimiters. Thus, we may need to parse
+ # multiple statements from one line.
+ while line:
+ for name, le_regex in self.STATEMENT_REGEXES.items():
+ if (match := le_regex.match(line))
+ yield from getattr(self, f'_parse_{name}')(self, match.groupdict())
+ line = line[match.end(0):]
+ break
- # parameter
- (param, r) = _match_one_from_many(self.PARAM_STMT, line)
-
- if param:
- if param["param"] == "FS":
- stmt = FSParamStmt.from_dict(param)
- self.settings.zero_suppression = stmt.zero_suppression
- self.settings.format = stmt.format
- self.settings.notation = stmt.notation
- yield stmt
- elif param["param"] == "MO":
- stmt = MOParamStmt.from_dict(param)
- self.settings.units = stmt.mode
- yield stmt
- elif param["param"] == "LP":
- yield LPParamStmt.from_dict(param)
- elif param["param"] == "AD":
- yield ADParamStmt.from_dict(param)
- elif param["param"] == "AM":
- yield AMParamStmt.from_dict(param, units=self.settings.units)
- elif param["param"] == "OF":
- yield OFParamStmt.from_dict(param)
- elif param["param"] == "IF":
- # Don't crash on include loop
- if self._recursion_depth < self.INCLUDE_FILE_RECURSION_LIMIT:
- self._recursion_depth += 1
- with open(os.path.join(os.path.dirname(self.filename), param["filename"]), 'r') as f:
- inc_data = f.read()
- for stmt in self._parse(self._split_commands(inc_data)):
- yield stmt
- self._recursion_depth -= 1
- else:
- raise IOError("Include file nesting depth limit exceeded.")
- elif param["param"] == "IN":
- yield INParamStmt.from_dict(param)
- elif param["param"] == "LN":
- yield LNParamStmt.from_dict(param)
- # deprecated commands AS, IN, IP, IR, MI, OF, SF, LN
- elif param["param"] == "AS":
- yield ASParamStmt.from_dict(param)
- elif param["param"] == "IN":
- yield INParamStmt.from_dict(param)
- elif param["param"] == "IP":
- yield IPParamStmt.from_dict(param)
- elif param["param"] == "IR":
- yield IRParamStmt.from_dict(param)
- elif param["param"] == "MI":
- yield MIParamStmt.from_dict(param)
- elif param["param"] == "OF":
- yield OFParamStmt.from_dict(param)
- elif param["param"] == "SF":
- yield SFParamStmt.from_dict(param)
- elif param["param"] == "LN":
- yield LNParamStmt.from_dict(param)
- else:
+ else:
+ if line[-1] == '*':
yield UnknownStmt(line)
+ line = ''
+
+ def _parse_interpolation_mode(self, match):
+ if match['code'] == 'G01':
+ yield LinearModeStmt()
+ elif match['code'] == 'G02':
+ yield CircularCWModeStmt()
+ elif match['code'] == 'G03':
+ yield CircularCCWModeStmt()
+ elif match['code'] == 'G74':
+ yield MultiQuadrantModeStmt()
+ elif match['code'] == 'G75':
+ yield SingleQuadrantModeStmt()
+
+ def _parse_coord(self, match):
+ x = parse_gerber_value(match.get('x'), self.settings)
+ y = parse_gerber_value(match.get('y'), self.settings)
+ i = parse_gerber_value(match.get('i'), self.settings)
+ j = parse_gerber_value(match.get('j'), self.settings)
+ if not (op := match['operation']):
+ if self.last_operation == 'D01':
+ warnings.warn('Coordinate statement without explicit operation code. This is forbidden by spec.',
+ SyntaxWarning)
+ op = 'D01'
+ else:
+ raise SyntaxError('Ambiguous coordinate statement. Coordinate statement does not have an operation '\
+ 'mode and the last operation statement was not D01.')
+
+ if op in ('D1', 'D01'):
+ yield InterpolateStmt(x, y, i, j)
+
+ if i is not None or j is not None:
+ raise SyntaxError("i/j coordinates given for D02/D03 operation (which doesn't take i/j)")
+
+ if op in ('D2', 'D02'):
+ yield MoveStmt(x, y, i, j)
+ else: # D03
+ yield FlashStmt(x, y, i, j)
+
+
+ def _parse_aperture(self, match):
+ number = int(match['number'])
+ if number < 10:
+ raise SyntaxError(f'Invalid aperture number {number}: Aperture number must be >= 10.')
+ yield ApertureStmt(number)
+
+ def _parse_format_spec(self, match):
+ # This is a common problem in Eagle files, so just suppress it
+ self.settings.zero_suppression = {'L': 'leading', 'T': 'trailing'}.get(match['zero'], 'leading')
+ self.settings.notation = 'absolute' if match.['notation'] == 'A' else 'incremental'
- did_something = True
- 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
+ if match['x'] != match['y']:
+ raise SyntaxError(f'FS specifies different coordinate formats for X and Y ({match["x"]} != {match["y"]})')
+ self.settings.number_format = int(match['x'][0]), int(match['x'][1])
- # Quadrant Mode
- (mode, r) = _match_one(self.QUAD_MODE_STMT, line)
- if mode:
- yield QuadrantModeStmt.from_gerber(line)
- line = r
- did_something = True
- continue
+ yield FormatSpecStmt()
- # comment
- (comment, r) = _match_one(self.COMMENT_STMT, line)
- if comment:
- yield CommentStmt(comment["comment"])
- did_something = True
- line = r
- continue
+ def _parse_unit_mode(self, match):
+ if match['unit'] == 'MM':
+ self.settings.units = 'mm'
+ else:
+ self.settings.units = 'inch'
- # deprecated codes
- (deprecated_unit, r) = _match_one(self.DEPRECATED_UNIT, line)
- if deprecated_unit:
- stmt = MOParamStmt(param="MO", mo="inch" if "G70" in
- deprecated_unit["mode"] else "metric")
- self.settings.units = stmt.mode
- yield stmt
- line = r
- did_something = True
- continue
+ yield MOParamStmt()
- (deprecated_format, r) = _match_one(self.DEPRECATED_FORMAT, line)
- if deprecated_format:
- yield DeprecatedStmt.from_gerber(line)
- line = r
- did_something = True
- continue
+ def _parse_load_polarity(self, match):
+ yield LoadPolarityStmt(dark=(match['polarity'] == 'D'))
- # eof
- (eof, r) = _match_one(self.EOF_STMT, line)
- if eof:
- yield EofStmt()
- did_something = True
- line = r
- continue
+ def _parse_offset(self, match):
+ a, b = match['a'], match['b']
+ a = float(a) if a else 0
+ b = float(b) if b else 0
+ yield OffsetStmt(a, b)
- if line.find('*') > 0:
- yield UnknownStmt(line)
- did_something = True
- line = ""
- continue
+ def _parse_include_file(self, match):
+ if self.include_dir is None:
+ warnings.warn('IF Include File statement found, but includes are deactivated.', ResourceWarning)
+ else:
+ warnings.warn('IF Include File statement found. Includes are activated, but is this really a good idea?', ResourceWarning)
+
+ include_file = self.include_dir / param["filename"]
+ if include_file in self.include_stack
+ raise ValueError("Recusive file inclusion via IF include statement.")
+ self.include_stack.append(include_file)
+
+ # Spec 2020-09 section 3.1: Gerber files must use UTF-8
+ yield from self._parse(f.read_text(encoding='UTF-8'))
+ self.include_stack.pop()
+
+
+ def _parse_image_name(self, match):
+ warnings.warn('Deprecated IN (image name) statement found. This deprecated since rev. I4 (Oct 2013).',
+ DeprecationWarning)
+ yield CommentStmt(f'Image name: {match["name"]}')
+
+ def _parse_load_name(self, match):
+ warnings.warn('Deprecated LN (load name) statement found. This deprecated since rev. I4 (Oct 2013).',
+ DeprecationWarning)
+ yield CommentStmt(f'Name of subsequent part: {match["name"]}')
+
+ def _parse_axis_selection(self, match):
+ warnings.warn('Deprecated AS (axis selection) statement found. This deprecated since rev. I1 (Dec 2012).',
+ DeprecationWarning)
+ self.settings.output_axes = match['axes']
+ yield AxisSelectionStmt()
+
+ def _parse_image_polarity(self, match):
+ warnings.warn('Deprecated IP (image polarity) statement found. This deprecated since rev. I4 (Oct 2013).',
+ DeprecationWarning)
+ self.settings.image_polarity = match['polarity']
+ yield ImagePolarityStmt()
+
+ def _parse_image_rotation(self, match):
+ warnings.warn('Deprecated IR (image rotation) statement found. This deprecated since rev. I1 (Dec 2012).',
+ DeprecationWarning)
+ self.settings.image_rotation = int(match['rotation'])
+ yield ImageRotationStmt()
+
+ def _parse_mirror_image(self, match):
+ warnings.warn('Deprecated MI (mirror image) statement found. This deprecated since rev. I1 (Dec 2012).',
+ DeprecationWarning)
+ self.settings.mirror = bool(int(match['a'] or '0')), bool(int(match['b'] or '1'))
+ yield MirrorImageStmt()
+
+ def _parse_scale_factor(self, match):
+ warnings.warn('Deprecated SF (scale factor) statement found. This deprecated since rev. I1 (Dec 2012).',
+ DeprecationWarning)
+ a = float(match['a']) if match['a'] else 1.0
+ b = float(match['b']) if match['b'] else 1.0
+ self.settings.scale_factor = a, b
+ yield ScaleFactorStmt()
+
+ def _parse_comment(self, match):
+ yield CommentStmt(match["comment"])
+
+ def _parse_region_mode(self, match):
+ yield RegionStartStatement() if match['mode'] == 'G36' else RegionEndStatement()
+
+ elif param["param"] == "AM":
+ yield AMParamStmt.from_dict(param, units=self.settings.units)
+ elif param["param"] == "AD":
+ yield ADParamStmt.from_dict(param)
+
+ def _parse_quadrant_mode(self, match):
+ if match['mode'] == 'G74':
+ warnings.warn('Deprecated G74 single quadrant mode statement found. This deprecated since 2021.',
+ DeprecationWarning)
+ yield SingleQuadrantModeStmt()
+ else:
+ yield MultiQuadrantModeStmt()
+
+ def _parse_old_unit(self, match):
+ self.settings.units = 'inch' if match['mode'] == 'G70' else 'mm'
+ warnings.warn(f'Deprecated {match["mode"]} unit mode statement found. This deprecated since 2012.',
+ DeprecationWarning)
+ yield CommentStmt(f'Replaced deprecated {match["mode"]} unit mode statement with MO statement')
+ yield UnitStmt()
+
+ def _parse_old_unit(self, match):
+ # FIXME make sure we always have FS at end of processing.
+ self.settings.notation = 'absolute' if match['mode'] == 'G90' else 'incremental'
+ warnings.warn(f'Deprecated {match["mode"]} notation mode statement found. This deprecated since 2012.',
+ DeprecationWarning)
+ yield CommentStmt(f'Replaced deprecated {match["mode"]} notation mode statement with FS statement')
+
+ def _parse_eof(self, match):
+ yield EofStmt()
- oldline = line
+ def _parse_ignored(self, match):
+ yield CommentStmt(f'Ignoring {match{"stmt"]} statement.')
def evaluate(self, stmt):
""" Evaluate Gerber statement and update image accordingly.
diff --git a/gerbonara/gerber/tests/panelize/data/ref_gerber_inch.gtl b/gerbonara/gerber/tests/panelize/data/ref_gerber_inch.gtl
index 3ec60d8..f71c948 100644
--- a/gerbonara/gerber/tests/panelize/data/ref_gerber_inch.gtl
+++ b/gerbonara/gerber/tests/panelize/data/ref_gerber_inch.gtl
@@ -8,7 +8,6 @@
1,1,0.015748,-0.0472441,0,$1*
4,1,4,0.0472441,0,0.0551181,-0.00787402,0.0472441,-0.015748,0.0393701,-0.00787402,0.0472441,0,$1*
5,1,6,0.0472441,0.00787402,0.015748,$1*
-6,-0.0275591,0,0.019685,0.0019685,0.00590551,2,0.0019685,0.023622,$1*
7,0.0275591,0,0.023622,0.019685,0.00590551,$1*%
%ADD10C,0.0003937*%
%ADD11C,0.03937X0.01575*%
diff --git a/gerbonara/gerber/tests/panelize/data/ref_gerber_metric.gtl b/gerbonara/gerber/tests/panelize/data/ref_gerber_metric.gtl
index 8dfbdd4..98833de 100644
--- a/gerbonara/gerber/tests/panelize/data/ref_gerber_metric.gtl
+++ b/gerbonara/gerber/tests/panelize/data/ref_gerber_metric.gtl
@@ -8,7 +8,6 @@
1,1,0.4,-1.2,0,$1*
4,1,4,1.2,0,1.4,-0.2,1.2,-0.4,1,-0.2,1.2,0,$1*
5,1,6,1.2,0.2,0.4,$1*
-6,-0.7,0,0.5,0.05,0.15,2,0.05,0.6,$1*
7,0.7,0,0.6,0.5,0.15,$1*%
%ADD10C,0.01*%
%ADD11C,1X0.4*%
diff --git a/gerbonara/gerber/tests/panelize/data/ref_gerber_single_quadrant.gtl b/gerbonara/gerber/tests/panelize/data/ref_gerber_single_quadrant.gtl
deleted file mode 100644
index f31f1e7..0000000
--- a/gerbonara/gerber/tests/panelize/data/ref_gerber_single_quadrant.gtl
+++ /dev/null
@@ -1,40 +0,0 @@
-%MOMM*%
-%FSLAX34Y34*%
-%IPPOS*%
-%ADD10C,0.1*%
-G74*
-%LPD*%
-
-D10*
-
-G36*
-G01*
-X0Y10000D02*
-Y90000D01*
-G02*
-X10000Y100000I10000*
-X20000Y90000J10000*
-G01*
-Y20000*
-X40000*
-G02*
-X50000Y10000J10000*
-X40000Y0I10000*
-G01*
-X10000*
-G02*
-X0Y10000J10000*
-G37*
-
-G03*
-X70000Y50000D02*
-X60000Y60000I10000D01*
-X50000Y50000J10000*
-X60000Y40000I10000*
-X70000Y50000J10000*
-
-G02*
-X60000Y90000D02*
-X60000Y90000I10000D01*
-
-M02*
diff --git a/gerbonara/gerber/tests/panelize/expects/RS2724x_offset.gtl b/gerbonara/gerber/tests/panelize/expects/RS2724x_offset.gtl
index 3dc3e6a..0bebd07 100644
--- a/gerbonara/gerber/tests/panelize/expects/RS2724x_offset.gtl
+++ b/gerbonara/gerber/tests/panelize/expects/RS2724x_offset.gtl
@@ -7,7 +7,6 @@
1,1,0.4,-1.2,0,$1*
4,1,4,1.2,0,1.4,-0.2,1.2,-0.4,1,-0.2,1.2,0,$1*
5,1,6,1.2,0.2,0.4,$1*
-6,-0.7,0,0.5,0.05,0.15,2,0.05,0.6,$1*
7,0.7,0,0.6,0.5,0.15,$1*%
%ADD10C,0.01*%
%ADD11C,1X0.4*%
diff --git a/gerbonara/gerber/tests/panelize/expects/RS2724x_rotate.gtl b/gerbonara/gerber/tests/panelize/expects/RS2724x_rotate.gtl
index f7c82cd..00335b8 100644
--- a/gerbonara/gerber/tests/panelize/expects/RS2724x_rotate.gtl
+++ b/gerbonara/gerber/tests/panelize/expects/RS2724x_rotate.gtl
@@ -7,7 +7,6 @@
1,1,0.4,-1.2,0,($1)+(20)*
4,1,4,1.2,0,1.4,-0.2,1.2,-0.4,1,-0.2,1.2,0,($1)+(20)*
5,1,6,1.2,0.2,0.4,($1)+(20)*
-6,-0.7,0,0.5,0.05,0.15,2,0.05,0.6,($1)+(20)*
7,0.7,0,0.6,0.5,0.15,($1)+(20)*%
%AMMACR*
21,1,$1,$2,0,0,20*
diff --git a/gerbonara/gerber/tests/panelize/expects/RS2724x_save.gtl b/gerbonara/gerber/tests/panelize/expects/RS2724x_save.gtl
index 5053d99..b4fe9e1 100644
--- a/gerbonara/gerber/tests/panelize/expects/RS2724x_save.gtl
+++ b/gerbonara/gerber/tests/panelize/expects/RS2724x_save.gtl
@@ -7,7 +7,6 @@
1,1,0.4,-1.2,0,$1*
4,1,4,1.2,0,1.4,-0.2,1.2,-0.4,1,-0.2,1.2,0,$1*
5,1,6,1.2,0.2,0.4,$1*
-6,-0.7,0,0.5,0.05,0.15,2,0.05,0.6,$1*
7,0.7,0,0.6,0.5,0.15,$1*%
%ADD10C,0.01*%
%ADD11C,1X0.4*%
diff --git a/gerbonara/gerber/tests/panelize/expects/RS2724x_single_quadrant.gtl b/gerbonara/gerber/tests/panelize/expects/RS2724x_single_quadrant.gtl
deleted file mode 100644
index dbec705..0000000
--- a/gerbonara/gerber/tests/panelize/expects/RS2724x_single_quadrant.gtl
+++ /dev/null
@@ -1,35 +0,0 @@
-%MOMM*%
-%FSLAX34Y34*%
-%IPPOS*%
-%ADD10C,0.1*%
-G75*
-%LPD*%
-D10*
-G36*
-G01*
-X0Y10000D02*
-X0Y90000D01*
-G02*
-X10000Y100000I10000J0D01*
-X20000Y90000I0J-10000D01*
-G01*
-X20000Y20000D01*
-X40000Y20000D01*
-G02*
-X50000Y10000I0J-10000D01*
-X40000Y0I-10000J0D01*
-G01*
-X10000Y0D01*
-G02*
-X0Y10000I0J10000D01*
-G37*
-G03*
-X70000Y50000D02*
-X60000Y60000I-10000J0D01*
-X50000Y50000I0J-10000D01*
-X60000Y40000I10000J0D01*
-X70000Y50000I0J10000D01*
-G02*
-X60000Y90000D02*
-X60000Y90000I0J0D01*
-M02*
diff --git a/gerbonara/gerber/tests/panelize/expects/RS2724x_to_inch.gtl b/gerbonara/gerber/tests/panelize/expects/RS2724x_to_inch.gtl
index cb9234e..ed23a58 100644
--- a/gerbonara/gerber/tests/panelize/expects/RS2724x_to_inch.gtl
+++ b/gerbonara/gerber/tests/panelize/expects/RS2724x_to_inch.gtl
@@ -7,7 +7,6 @@
1,1,0.015748,-0.0472441,0,$1*
4,1,4,0.0472441,0,0.0551181,-0.00787402,0.0472441,-0.015748,0.0393701,-0.00787402,0.0472441,0,$1*
5,1,6,0.0472441,0.00787402,0.015748,$1*
-6,-0.0275591,0,0.019685,0.0019685,0.00590551,2,0.0019685,0.023622,$1*
7,0.0275591,0,0.023622,0.019685,0.00590551,$1*%
%ADD10C,0.0003937*%
%ADD11C,0.03937X0.01575*%
diff --git a/gerbonara/gerber/tests/panelize/expects/RS2724x_to_metric.gtl b/gerbonara/gerber/tests/panelize/expects/RS2724x_to_metric.gtl
index a8efda8..2a4df41 100644
--- a/gerbonara/gerber/tests/panelize/expects/RS2724x_to_metric.gtl
+++ b/gerbonara/gerber/tests/panelize/expects/RS2724x_to_metric.gtl
@@ -7,7 +7,6 @@
1,1,0.399999,-1.2,0,$1*
4,1,4,1.2,0,1.4,-0.2,1.2,-0.399999,1,-0.2,1.2,0,$1*
5,1,6,1.2,0.2,0.399999,$1*
-6,-0.700001,0,0.499999,0.0499999,0.15,2,0.0499999,0.599999,$1*
7,0.700001,0,0.599999,0.499999,0.15,$1*%
%ADD10C,0.01*%
%ADD11C,1X0.4*%
diff --git a/gerbonara/gerber/tests/panelize/test_am_expression.py b/gerbonara/gerber/tests/panelize/test_am_expression.py
index 45758b7..576be88 100644
--- a/gerbonara/gerber/tests/panelize/test_am_expression.py
+++ b/gerbonara/gerber/tests/panelize/test_am_expression.py
@@ -30,10 +30,6 @@ class TestAMConstantExpression(unittest.TestCase):
self.assertEqual(self.const_int.to_gerber(), '7')
self.assertEqual(self.const_float.to_gerber(), '1.2345')
- def test_to_instructions(self):
- self.const_int.to_instructions()
- self.const_float.to_instructions()
-
class TestAMVariableExpression(unittest.TestCase):
def setUp(self):
self.var1_num = 1
@@ -57,10 +53,6 @@ class TestAMVariableExpression(unittest.TestCase):
self.assertEqual(self.var1.to_gerber(), '$1')
self.assertEqual(self.var2.to_gerber(), '$512')
- def test_to_instructions(self):
- self.var1.to_instructions()
- self.var2.to_instructions()
-
class TestAMOperatorExpression(unittest.TestCase):
def setUp(self):
self.c1 = 10
@@ -132,11 +124,6 @@ class TestAMOperatorExpression(unittest.TestCase):
self.c1, self.c2, self.c1, self.c2
))
- def test_to_instructions(self):
- for of, expression in self.vc_exps + self.cv_exps + self.cc_exps:
- expression.to_instructions()
- self.composition.to_instructions()
-
class TestAMExpression(unittest.TestCase):
def setUp(self):
self.c1 = 10
diff --git a/gerbonara/gerber/tests/panelize/test_rs274x.py b/gerbonara/gerber/tests/panelize/test_rs274x.py
index 067717d..73f3172 100644
--- a/gerbonara/gerber/tests/panelize/test_rs274x.py
+++ b/gerbonara/gerber/tests/panelize/test_rs274x.py
@@ -68,8 +68,3 @@ class TestRs274x(unittest.TestCase):
gerber.rotate(20, (10,10))
gerber.write(outfile)
- def test_single_quadrant(self):
- with self._check_result('RS2724x_single_quadrant.gtl') as outfile:
- gerber = read(self.SQ_FILE)
- gerber.write(outfile)
-
diff --git a/gerbonara/gerber/tests/test_am_statements.py b/gerbonara/gerber/tests/test_am_statements.py
deleted file mode 100644
index 0d100b5..0000000
--- a/gerbonara/gerber/tests/test_am_statements.py
+++ /dev/null
@@ -1,395 +0,0 @@
-#! /usr/bin/env python
-# -*- coding: utf-8 -*-
-
-# Author: Hamilton Kibbe <ham@hamiltonkib.be>
-
-import pytest
-
-from ..am_statements import *
-from ..am_statements import inch, metric
-
-
-def test_AMPrimitive_ctor():
- for exposure in ("on", "off", "ON", "OFF"):
- for code in (0, 1, 2, 4, 5, 6, 7, 20, 21, 22):
- p = AMPrimitive(code, exposure)
- assert p.code == code
- assert p.exposure == exposure.lower()
-
-
-def test_AMPrimitive_validation():
- pytest.raises(TypeError, AMPrimitive, "1", "off")
- pytest.raises(ValueError, AMPrimitive, 0, "exposed")
- pytest.raises(ValueError, AMPrimitive, 3, "off")
-
-
-def test_AMPrimitive_conversion():
- p = AMPrimitive(4, "on")
- pytest.raises(NotImplementedError, p.to_inch)
- pytest.raises(NotImplementedError, p.to_metric)
-
-
-def test_AMCommentPrimitive_ctor():
- c = AMCommentPrimitive(0, " This is a comment *")
- assert c.code == 0
- assert c.comment == "This is a comment"
-
-
-def test_AMCommentPrimitive_validation():
- pytest.raises(ValueError, AMCommentPrimitive, 1, "This is a comment")
-
-
-def test_AMCommentPrimitive_factory():
- c = AMCommentPrimitive.from_gerber("0 Rectangle with rounded corners. *")
- assert c.code == 0
- assert c.comment == "Rectangle with rounded corners."
-
-
-def test_AMCommentPrimitive_dump():
- c = AMCommentPrimitive(0, "Rectangle with rounded corners.")
- assert c.to_gerber() == "0 Rectangle with rounded corners. *"
-
-
-def test_AMCommentPrimitive_conversion():
- c = AMCommentPrimitive(0, "Rectangle with rounded corners.")
- ci = c
- cm = c
- ci.to_inch()
- cm.to_metric()
- assert c == ci
- assert c == cm
-
-
-def test_AMCommentPrimitive_string():
- c = AMCommentPrimitive(0, "Test Comment")
- assert str(c) == "<Aperture Macro Comment: Test Comment>"
-
-
-def test_AMCirclePrimitive_ctor():
- test_cases = (
- (1, "on", 0, (0, 0)),
- (1, "off", 1, (0, 1)),
- (1, "on", 2.5, (0, 2)),
- (1, "off", 5.0, (3, 3)),
- )
- for code, exposure, diameter, position in test_cases:
- c = AMCirclePrimitive(code, exposure, diameter, position)
- assert c.code == code
- assert c.exposure == exposure
- assert c.diameter == diameter
- assert c.position == position
-
-
-def test_AMCirclePrimitive_validation():
- pytest.raises(ValueError, AMCirclePrimitive, 2, "on", 0, (0, 0))
-
-
-def test_AMCirclePrimitive_factory():
- c = AMCirclePrimitive.from_gerber("1,0,5,0,0*")
- assert c.code == 1
- assert c.exposure == "off"
- assert c.diameter == 5
- assert c.position == (0, 0)
-
-
-def test_AMCirclePrimitive_dump():
- c = AMCirclePrimitive(1, "off", 5, (0, 0))
- assert c.to_gerber() == "1,0,5,0,0*"
- c = AMCirclePrimitive(1, "on", 5, (0, 0))
- assert c.to_gerber() == "1,1,5,0,0*"
-
-
-def test_AMCirclePrimitive_conversion():
- c = AMCirclePrimitive(1, "off", 25.4, (25.4, 0))
- c.to_inch()
- assert c.diameter == 1
- assert c.position == (1, 0)
-
- c = AMCirclePrimitive(1, "off", 1, (1, 0))
- c.to_metric()
- assert c.diameter == 25.4
- assert c.position == (25.4, 0)
-
-
-def test_AMVectorLinePrimitive_validation():
- pytest.raises(
- ValueError, AMVectorLinePrimitive, 3, "on", 0.1, (0, 0), (3.3, 5.4), 0
- )
-
-
-def test_AMVectorLinePrimitive_factory():
- l = AMVectorLinePrimitive.from_gerber("20,1,0.9,0,0.45,12,0.45,0*")
- assert l.code == 20
- assert l.exposure == "on"
- assert l.width == 0.9
- assert l.start == (0, 0.45)
- assert l.end == (12, 0.45)
- assert l.rotation == 0
-
-
-def test_AMVectorLinePrimitive_dump():
- l = AMVectorLinePrimitive.from_gerber("20,1,0.9,0,0.45,12,0.45,0*")
- assert l.to_gerber() == "20,1,0.9,0.0,0.45,12.0,0.45,0.0*"
-
-
-def test_AMVectorLinePrimtive_conversion():
- l = AMVectorLinePrimitive(20, "on", 25.4, (0, 0), (25.4, 25.4), 0)
- l.to_inch()
- assert l.width == 1
- assert l.start == (0, 0)
- assert l.end == (1, 1)
-
- l = AMVectorLinePrimitive(20, "on", 1, (0, 0), (1, 1), 0)
- l.to_metric()
- assert l.width == 25.4
- assert l.start == (0, 0)
- assert l.end == (25.4, 25.4)
-
-
-def test_AMOutlinePrimitive_validation():
- pytest.raises(
- ValueError,
- AMOutlinePrimitive,
- 7,
- "on",
- (0, 0),
- [(3.3, 5.4), (4.0, 5.4), (0, 0)],
- 0,
- )
- pytest.raises(
- ValueError,
- AMOutlinePrimitive,
- 4,
- "on",
- (0, 0),
- [(3.3, 5.4), (4.0, 5.4), (0, 1)],
- 0,
- )
-
-
-def test_AMOutlinePrimitive_factory():
- o = AMOutlinePrimitive.from_gerber("4,1,3,0,0,3,3,3,0,0,0,0*")
- assert o.code == 4
- assert o.exposure == "on"
- assert o.start_point == (0, 0)
- assert o.points == [(3, 3), (3, 0), (0, 0)]
- assert o.rotation == 0
-
-
-def test_AMOUtlinePrimitive_dump():
- o = AMOutlinePrimitive(4, "on", (0, 0), [(3, 3), (3, 0), (0, 0)], 0)
- # New lines don't matter for Gerber, but we insert them to make it easier to remove
- # For test purposes we can ignore them
- assert o.to_gerber().replace("\n", "") == "4,1,3,0,0,3,3,3,0,0,0,0*"
-
-
-def test_AMOutlinePrimitive_conversion():
- o = AMOutlinePrimitive(4, "on", (0, 0), [(25.4, 25.4), (25.4, 0), (0, 0)], 0)
- o.to_inch()
- assert o.start_point == (0, 0)
- assert o.points == ((1.0, 1.0), (1.0, 0.0), (0.0, 0.0))
-
- o = AMOutlinePrimitive(4, "on", (0, 0), [(1, 1), (1, 0), (0, 0)], 0)
- o.to_metric()
- assert o.start_point == (0, 0)
- assert o.points == ((25.4, 25.4), (25.4, 0), (0, 0))
-
-
-def test_AMPolygonPrimitive_validation():
- pytest.raises(ValueError, AMPolygonPrimitive, 6, "on", 3, (3.3, 5.4), 3, 0)
- pytest.raises(ValueError, AMPolygonPrimitive, 5, "on", 2, (3.3, 5.4), 3, 0)
- pytest.raises(ValueError, AMPolygonPrimitive, 5, "on", 13, (3.3, 5.4), 3, 0)
-
-
-def test_AMPolygonPrimitive_factory():
- p = AMPolygonPrimitive.from_gerber("5,1,3,3.3,5.4,3,0")
- assert p.code == 5
- assert p.exposure == "on"
- assert p.vertices == 3
- assert p.position == (3.3, 5.4)
- assert p.diameter == 3
- assert p.rotation == 0
-
-
-def test_AMPolygonPrimitive_dump():
- p = AMPolygonPrimitive(5, "on", 3, (3.3, 5.4), 3, 0)
- assert p.to_gerber() == "5,1,3,3.3,5.4,3,0*"
-
-
-def test_AMPolygonPrimitive_conversion():
- p = AMPolygonPrimitive(5, "off", 3, (25.4, 0), 25.4, 0)
- p.to_inch()
- assert p.diameter == 1
- assert p.position == (1, 0)
-
- p = AMPolygonPrimitive(5, "off", 3, (1, 0), 1, 0)
- p.to_metric()
- assert p.diameter == 25.4
- assert p.position == (25.4, 0)
-
-
-def test_AMMoirePrimitive_validation():
- pytest.raises(
- ValueError, AMMoirePrimitive, 7, (0, 0), 5.1, 0.2, 0.4, 6, 0.1, 6.1, 0
- )
-
-
-def test_AMMoirePrimitive_factory():
- m = AMMoirePrimitive.from_gerber("6,0,0,5,0.5,0.5,2,0.1,6,0*")
- assert m.code == 6
- assert m.position == (0, 0)
- assert m.diameter == 5
- assert m.ring_thickness == 0.5
- assert m.gap == 0.5
- assert m.max_rings == 2
- assert m.crosshair_thickness == 0.1
- assert m.crosshair_length == 6
- assert m.rotation == 0
-
-
-def test_AMMoirePrimitive_dump():
- m = AMMoirePrimitive.from_gerber("6,0,0,5,0.5,0.5,2,0.1,6,0*")
- assert m.to_gerber() == "6,0,0,5.0,0.5,0.5,2,0.1,6.0,0.0*"
-
-
-def test_AMMoirePrimitive_conversion():
- m = AMMoirePrimitive(6, (25.4, 25.4), 25.4, 25.4, 25.4, 6, 25.4, 25.4, 0)
- m.to_inch()
- assert m.position == (1.0, 1.0)
- assert m.diameter == 1.0
- assert m.ring_thickness == 1.0
- assert m.gap == 1.0
- assert m.crosshair_thickness == 1.0
- assert m.crosshair_length == 1.0
-
- m = AMMoirePrimitive(6, (1, 1), 1, 1, 1, 6, 1, 1, 0)
- m.to_metric()
- assert m.position == (25.4, 25.4)
- assert m.diameter == 25.4
- assert m.ring_thickness == 25.4
- assert m.gap == 25.4
- assert m.crosshair_thickness == 25.4
- assert m.crosshair_length == 25.4
-
-
-def test_AMThermalPrimitive_validation():
- pytest.raises(ValueError, AMThermalPrimitive, 8, (0.0, 0.0), 7, 5, 0.2, 0.0)
- pytest.raises(TypeError, AMThermalPrimitive, 7, (0.0, "0"), 7, 5, 0.2, 0.0)
-
-
-def test_AMThermalPrimitive_factory():
- t = AMThermalPrimitive.from_gerber("7,0,0,7,6,0.2,45*")
- assert t.code == 7
- assert t.position == (0, 0)
- assert t.outer_diameter == 7
- assert t.inner_diameter == 6
- assert t.gap == 0.2
- assert t.rotation == 45
-
-
-def test_AMThermalPrimitive_dump():
- t = AMThermalPrimitive.from_gerber("7,0,0,7,6,0.2,30*")
- assert t.to_gerber() == "7,0,0,7.0,6.0,0.2,30.0*"
-
-
-def test_AMThermalPrimitive_conversion():
- t = AMThermalPrimitive(7, (25.4, 25.4), 25.4, 25.4, 25.4, 0.0)
- t.to_inch()
- assert t.position == (1.0, 1.0)
- assert t.outer_diameter == 1.0
- assert t.inner_diameter == 1.0
- assert t.gap == 1.0
-
- t = AMThermalPrimitive(7, (1, 1), 1, 1, 1, 0)
- t.to_metric()
- assert t.position == (25.4, 25.4)
- assert t.outer_diameter == 25.4
- assert t.inner_diameter == 25.4
- assert t.gap == 25.4
-
-
-def test_AMCenterLinePrimitive_validation():
- pytest.raises(ValueError, AMCenterLinePrimitive, 22, 1, 0.2, 0.5, (0, 0), 0)
-
-
-def test_AMCenterLinePrimtive_factory():
- l = AMCenterLinePrimitive.from_gerber("21,1,6.8,1.2,3.4,0.6,0*")
- assert l.code == 21
- assert l.exposure == "on"
- assert l.width == 6.8
- assert l.height == 1.2
- assert l.center == (3.4, 0.6)
- assert l.rotation == 0
-
-
-def test_AMCenterLinePrimitive_dump():
- l = AMCenterLinePrimitive.from_gerber("21,1,6.8,1.2,3.4,0.6,0*")
- assert l.to_gerber() == "21,1,6.8,1.2,3.4,0.6,0.0*"
-
-
-def test_AMCenterLinePrimitive_conversion():
- l = AMCenterLinePrimitive(21, "on", 25.4, 25.4, (25.4, 25.4), 0)
- l.to_inch()
- assert l.width == 1.0
- assert l.height == 1.0
- assert l.center == (1.0, 1.0)
-
- l = AMCenterLinePrimitive(21, "on", 1, 1, (1, 1), 0)
- l.to_metric()
- assert l.width == 25.4
- assert l.height == 25.4
- assert l.center == (25.4, 25.4)
-
-
-def test_AMLowerLeftLinePrimitive_validation():
- pytest.raises(ValueError, AMLowerLeftLinePrimitive, 23, 1, 0.2, 0.5, (0, 0), 0)
-
-
-def test_AMLowerLeftLinePrimtive_factory():
- l = AMLowerLeftLinePrimitive.from_gerber("22,1,6.8,1.2,3.4,0.6,0*")
- assert l.code == 22
- assert l.exposure == "on"
- assert l.width == 6.8
- assert l.height == 1.2
- assert l.lower_left == (3.4, 0.6)
- assert l.rotation == 0
-
-
-def test_AMLowerLeftLinePrimitive_dump():
- l = AMLowerLeftLinePrimitive.from_gerber("22,1,6.8,1.2,3.4,0.6,0*")
- assert l.to_gerber() == "22,1,6.8,1.2,3.4,0.6,0.0*"
-
-
-def test_AMLowerLeftLinePrimitive_conversion():
- l = AMLowerLeftLinePrimitive(22, "on", 25.4, 25.4, (25.4, 25.4), 0)
- l.to_inch()
- assert l.width == 1.0
- assert l.height == 1.0
- assert l.lower_left == (1.0, 1.0)
-
- l = AMLowerLeftLinePrimitive(22, "on", 1, 1, (1, 1), 0)
- l.to_metric()
- assert l.width == 25.4
- assert l.height == 25.4
- assert l.lower_left == (25.4, 25.4)
-
-
-def test_AMUnsupportPrimitive():
- u = AMUnsupportPrimitive.from_gerber("Test")
- assert u.primitive == "Test"
- u = AMUnsupportPrimitive("Test")
- assert u.to_gerber() == "Test"
-
-
-def test_AMUnsupportPrimitive_smoketest():
- u = AMUnsupportPrimitive.from_gerber("Test")
- u.to_inch()
- u.to_metric()
-
-
-def test_inch():
- assert inch(25.4) == 1
-
-
-def test_metric():
- assert metric(1) == 25.4
diff --git a/gerbonara/gerber/tests/test_cairo_backend.py b/gerbonara/gerber/tests/test_cairo_backend.py
deleted file mode 100644
index b8c9676..0000000
--- a/gerbonara/gerber/tests/test_cairo_backend.py
+++ /dev/null
@@ -1,382 +0,0 @@
-#! /usr/bin/env python
-# -*- coding: utf-8 -*-
-
-# Author: Garret Fick <garret@ficksworkshop.com>
-import os
-import shutil
-import io
-import tempfile
-import uuid
-import cv2
-from pathlib import Path
-
-import pytest
-from PIL import Image
-import numpy as np
-
-from ..render.cairo_backend import GerberCairoContext
-from ..rs274x import read
-
-class Tempdir:
- def __init__(self):
- self.path = tempfile.mkdtemp(prefix='gerbonara-test-')
- self.delete = True
-
- def cleanup(self):
- if self.delete:
- shutil.rmtree(self.path)
-
- def create(self, prefix='fail-', suffix=''):
- return Path(self.path) / f'{prefix}{uuid.uuid4()}{suffix}'
-
- def keep(self):
- self.delete = False
-
-output_dir = Tempdir()
-@pytest.fixture(scope='session', autouse=True)
-def cleanup(request):
- global output_dir
- request.addfinalizer(output_dir.cleanup)
-
-def test_render_two_boxes():
- """Umaco exapmle of two boxes"""
- _test_render("resources/example_two_square_boxes.gbr", "golden/example_two_square_boxes.png")
-
-
-def test_render_simple_contour():
- """Umaco exapmle of a simple arrow-shaped contour"""
- gerber = _test_render("resources/example_simple_contour.gbr", "golden/example_simple_contour.png")
-
- # Check the resulting dimensions
- assert ((2.0, 11.0), (1.0, 9.0)) == gerber.bounding_box
-
-
-def test_render_single_contour_1():
- """Umaco example of a single contour
-
- The resulting image for this test is used by other tests because they must generate the same output."""
- _test_render(
- "resources/example_single_contour_1.gbr", "golden/example_single_contour.png",
- 0.001 # TODO: It looks like we have some aliasing artifacts here. Make sure this is not caused by an actual error.
- )
-
-
-def test_render_single_contour_2():
- """Umaco exapmle of a single contour, alternate contour end order
-
- The resulting image for this test is used by other tests because they must generate the same output."""
- _test_render(
- "resources/example_single_contour_2.gbr", "golden/example_single_contour.png",
- 0.001 # TODO: It looks like we have some aliasing artifacts here. Make sure this is not caused by an actual error.
- )
-
-
-def test_render_single_contour_3():
- """Umaco exapmle of a single contour with extra line"""
- _test_render(
- "resources/example_single_contour_3.gbr", "golden/example_single_contour_3.png",
- 0.001 # TODO: It looks like we have some aliasing artifacts here. Make sure this is not caused by an actual error.
- )
-
-
-def test_render_not_overlapping_contour():
- """Umaco example of D02 staring a second contour"""
- _test_render(
- "resources/example_not_overlapping_contour.gbr",
- "golden/example_not_overlapping_contour.png",
- )
-
-
-def test_render_not_overlapping_touching():
- """Umaco example of D02 staring a second contour"""
- _test_render(
- "resources/example_not_overlapping_touching.gbr",
- "golden/example_not_overlapping_touching.png",
- )
-
-
-def test_render_overlapping_touching():
- """Umaco example of D02 staring a second contour"""
- _test_render(
- "resources/example_overlapping_touching.gbr",
- "golden/example_overlapping_touching.png",
- )
-
-
-def test_render_overlapping_contour():
- """Umaco example of D02 staring a second contour"""
- _test_render("resources/example_overlapping_contour.gbr", "golden/example_overlapping_contour.png")
-
-
-def test_render_level_holes():
- """Umaco example of using multiple levels to create multiple holes"""
- _test_render("resources/example_level_holes.gbr", "golden/example_level_holes.png",
- autocrop_golden=True, auto_contrast=True, scale=50, max_delta=0.005)
-
-
-def test_render_cutin():
- """Umaco example of using a cutin"""
- _test_render("resources/example_cutin.gbr", "golden/example_cutin.png",
- autocrop_golden=True, auto_contrast=True, max_delta=0.005)
-
-
-def test_render_fully_coincident():
- """Umaco example of coincident lines rendering two contours"""
-
- _test_render(
- "resources/example_fully_coincident.gbr", "golden/example_fully_coincident.png"
- )
-
-
-def test_render_coincident_hole():
- """Umaco example of coincident lines rendering a hole in the contour"""
-
- _test_render(
- "resources/example_coincident_hole.gbr", "golden/example_coincident_hole.png"
- )
-
-
-def test_render_cutin_multiple():
- """Umaco example of a region with multiple cutins"""
-
- _test_render(
- "resources/example_cutin_multiple.gbr", "golden/example_cutin_multiple.png"
- )
-
-
-def test_flash_circle():
- """Umaco example a simple circular flash with and without a hole"""
-
- _test_render(
- "resources/example_flash_circle.gbr",
- "golden/example_flash_circle.png",
- )
-
-
-def test_flash_rectangle():
- """Umaco example a simple rectangular flash with and without a hole"""
-
- _test_render(
- "resources/example_flash_rectangle.gbr", "golden/example_flash_rectangle.png"
- )
-
-
-def test_flash_obround():
- """Umaco example a simple obround flash with and without a hole"""
-
- _test_render(
- "resources/example_flash_obround.gbr", "golden/example_flash_obround.png"
- )
-
-
-def test_flash_polygon():
- """Umaco example a simple polygon flash with and without a hole"""
-
- _test_render(
- "resources/example_flash_polygon.gbr", "golden/example_flash_polygon.png"
- )
-
-
-def test_holes_dont_clear():
- """Umaco example that an aperture with a hole does not clear the area"""
-
- _test_render(
- "resources/example_holes_dont_clear.gbr", "golden/example_holes_dont_clear.png"
- )
-
-
-def test_render_am_exposure_modifier():
- """Umaco example that an aperture macro with a hole does not clear the area"""
-
- _test_render(
- "resources/example_am_exposure_modifier.gbr",
- "golden/example_am_exposure_modifier.png",
- scale = 50,
- autocrop_golden = True,
- auto_contrast = True,
- max_delta = 0.005 # Take artifacts due to differences in anti-aliasing and thresholding into account
- )
-
-
-def test_render_svg_simple_contour():
- """Example of rendering to an SVG file"""
- _test_simple_render_svg("resources/example_simple_contour.gbr")
-
-
-def test_fine_lines_x():
- """ Regression test for pcb-tools upstream PR #199 """
- for fn, axis in [
- ('resources/test_fine_lines_x.gbr', 1),
- ('resources/test_fine_lines_y.gbr', 0) ]:
- gerber_path = _resolve_path(fn)
-
- gerber = read(gerber_path)
-
- # Create PNG image to the memory stream
- ctx = GerberCairoContext(scale=51)
- gerber.render(ctx)
-
- global output_dir
- with output_dir.create(suffix='.png') as outfile:
- actual_bytes = ctx.dump(outfile)
-
- out = Image.open(outfile)
- out = np.array(out)
- out = out.astype(float).mean(axis=2) / 255
-
- means = out[10:-10,10:-10].mean(axis=axis)
-
- print(means.mean(), means.max(), means.min(), means.std())
- #print(means_y.mean(), means_y.max(), means_y.min(), means_y.std())
- # means_x broken: 0.3240598567858516 0.3443678513071895 0.2778033088235294 0.017457710324088545
- # means_x fixed: 0.33338519639882097 0.3443678513071895 0.3183159722222221 0.006792500045785638
- # means_y broken: 0.3240598567858518 0.3247468922209409 0.1660387030629246 0.009953477851147686
- # means_y fixed: 0.33338519639882114 0.3340766371908242 0.17388184031782652 0.010043400730860096
-
- assert means.std() < 0.01
-
-# TODO add scale tests: Export with different scale=... params and compare against bitmap-scaled reference image
-
-def _resolve_path(path):
- return os.path.join(os.path.dirname(__file__), path)
-
-def images_match(reference, output, max_delta, autocrop_golden=False, auto_contrast=False):
- global output_dir
-
- ref, out = Image.open(reference), Image.open(output)
- if ref.mode == 'P': # palette mode
- ref = ref.convert('RGB')
-
- ref, out = np.array(ref), np.array(out)
- # convert to grayscale
- ref, out = ref.astype(float).mean(axis=2), out.astype(float).mean(axis=2)
-
- if autocrop_golden:
- rows = ref.sum(axis=1)
- cols = ref.sum(axis=0)
-
- x0 = np.argmax(cols > 0)
- y0 = np.argmax(rows > 0)
- x1 = len(cols) - np.argmax(cols[::-1] > 0)
- y1 = len(rows) - np.argmax(rows[::-1] > 0)
- print(f'{x0=} {y0=} {x1=} {y1=}')
-
- ref = ref[y0:y1, x0:x1]
- ref = cv2.resize(ref, dsize=out.shape[::-1], interpolation=cv2.INTER_LINEAR)
-
- def print_stats(name, ref):
- print(name, 'stats:', ref.min(), ref.mean(), ref.max(), 'std:', ref.std())
-
- if auto_contrast:
- print_stats('ref pre proc', ref)
- print_stats('out pre proc', out)
-
- ref -= ref.min()
- ref /= ref.max() + 1e-9
- ref *= 255
-
- out -= out.min()
- out /= out.max() + 1e-9
- out *= 255
-
- def write_refout():
- nonlocal autocrop_golden, ref
- if autocrop_golden:
- global output_dir
- with output_dir.create(suffix='.png') as ref_out:
- cv2.imwrite(str(ref_out), ref)
- print('Processed reference image:', ref_out)
-
- if ref.shape != out.shape:
- print(f'Rendering image size mismatch: {ref.shape} != {out.shape}')
- print(f'Reference image: {Path(reference).absolute()}')
- print(f'Actual output: {output}')
-
- write_refout()
- output_dir.keep()
-
- return False
-
- delta = np.abs(out - ref).astype(float) / 255
-
- if delta.mean() > max_delta:
- print(f'Renderings mismatch: {delta.mean()=}, {max_delta=}')
- print(f'Reference image: {Path(reference).absolute()}')
- print(f'Actual output: {output}')
- with output_dir.create(suffix='.png') as proc_out:
- cv2.imwrite(str(proc_out), out)
- print('Processed output image:', proc_out)
- print_stats('reference', ref)
- print_stats('actual', out)
-
- write_refout()
- output_dir.keep()
-
- return False
-
- return True
-
-
-def _test_render(gerber_path, png_expected_path, max_delta=1e-6, scale=300, autocrop_golden=False, auto_contrast=False):
- """Render the gerber file and compare to the expected PNG output.
-
- Parameters
- ----------
- gerber_path : string
- Path to Gerber file to open
- png_expected_path : string
- Path to the PNG file to compare to
- create_output : string|None
- If not None, write the generated PNG to the specified path.
- This is primarily to help with
- """
-
- gerber_path = _resolve_path(gerber_path)
- png_expected_path = _resolve_path(png_expected_path)
-
- gerber = read(gerber_path)
-
- # Create PNG image to the memory stream
- ctx = GerberCairoContext(scale=scale)
- gerber.render(ctx)
-
- global output_dir
- with output_dir.create(suffix='.png') as outfile:
- actual_bytes = ctx.dump(outfile)
-
- assert images_match(png_expected_path, outfile, max_delta, autocrop_golden, auto_contrast)
-
- return gerber
-
-
-def _test_simple_render_svg(gerber_path):
- """Render the gerber file as SVG
-
- Note: verifies only the header, not the full content.
-
- Parameters
- ----------
- gerber_path : string
- Path to Gerber file to open
- """
-
- gerber_path = _resolve_path(gerber_path)
- gerber = read(gerber_path)
-
- # Create SVG image to the memory stream
- ctx = GerberCairoContext()
- gerber.render(ctx)
-
- temp_dir = tempfile.mkdtemp()
- svg_temp_path = os.path.join(temp_dir, "output.svg")
-
- assert not os.path.exists(svg_temp_path)
- ctx.dump(svg_temp_path)
- assert os.path.exists(svg_temp_path)
-
- with open(svg_temp_path, "r") as expected_file:
- expected_bytes = expected_file.read()
- assert expected_bytes[:38] == '<?xml version="1.0" encoding="UTF-8"?>'
-
- shutil.rmtree(temp_dir)
-
diff --git a/gerbonara/gerber/tests/test_gerber_statements.py b/gerbonara/gerber/tests/test_gerber_statements.py
index 140cbd1..17e2591 100644
--- a/gerbonara/gerber/tests/test_gerber_statements.py
+++ b/gerbonara/gerber/tests/test_gerber_statements.py
@@ -413,84 +413,29 @@ def test_AMParamStmt_factory():
1,1,1.5,0,0*
20,1,0.9,0,0.45,12,0.45,0*
21,1,6.8,1.2,3.4,0.6,0*
-22,1,6.8,1.2,0,0,0*
4,1,4,0.1,0.1,0.5,0.1,0.5,0.5,0.1,0.5,0.1,0.1,0*
5,1,8,0,0,8,0*
-6,0,0,5,0.5,0.5,2,0.1,6,0*
7,0,0,7,6,0.2,0*
-8,THIS IS AN UNSUPPORTED PRIMITIVE*
"""
- s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro})
- s.build()
+ s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro}, units='mm')
assert len(s.primitives) == 10
assert isinstance(s.primitives[0], AMCommentPrimitive)
assert isinstance(s.primitives[1], AMCirclePrimitive)
assert isinstance(s.primitives[2], AMVectorLinePrimitive)
assert isinstance(s.primitives[3], AMCenterLinePrimitive)
- assert isinstance(s.primitives[4], AMLowerLeftLinePrimitive)
assert isinstance(s.primitives[5], AMOutlinePrimitive)
assert isinstance(s.primitives[6], AMPolygonPrimitive)
- assert isinstance(s.primitives[7], AMMoirePrimitive)
assert isinstance(s.primitives[8], AMThermalPrimitive)
- assert isinstance(s.primitives[9], AMUnsupportPrimitive)
-
-
-def testAMParamStmt_conversion():
- name = "POLYGON"
- macro = "5,1,8,25.4,25.4,25.4,0*"
- s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro})
-
- s.build()
- s.units = "metric"
-
- # No effect
- s.to_metric()
- assert s.primitives[0].position == (25.4, 25.4)
- assert s.primitives[0].diameter == 25.4
-
- s.to_inch()
- assert s.units == "inch"
- assert s.primitives[0].position == (1.0, 1.0)
- assert s.primitives[0].diameter == 1.0
-
- # No effect
- s.to_inch()
- assert s.primitives[0].position == (1.0, 1.0)
- assert s.primitives[0].diameter == 1.0
-
- macro = "5,1,8,1,1,1,0*"
- s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro})
- s.build()
- s.units = "inch"
-
- # No effect
- s.to_inch()
- assert s.primitives[0].position == (1.0, 1.0)
- assert s.primitives[0].diameter == 1.0
-
- s.to_metric()
- assert s.units == "metric"
- assert s.primitives[0].position == (25.4, 25.4)
- assert s.primitives[0].diameter == 25.4
-
- # No effect
- s.to_metric()
- assert s.primitives[0].position == (25.4, 25.4)
- assert s.primitives[0].diameter == 25.4
def test_AMParamStmt_dump():
name = "POLYGON"
macro = "5,1,8,25.4,25.4,25.4,0.0"
- s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro})
- s.build()
+ s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro}, units='mm')
assert s.to_gerber() == "%AMPOLYGON*5,1,8,25.4,25.4,25.4,0.0*%"
# TODO - Store Equations and update on unit change...
- s = AMParamStmt.from_dict(
- {"param": "AM", "name": "OC8", "macro": "5,1,8,0,0,1.08239X$1,22.5"}
- )
- s.build()
+ s = AMParamStmt.from_dict({"param": "AM", "name": "OC8", "macro": "5,1,8,0,0,1.08239X$1,22.5"}, units='mm')
# assert_equal(s.to_gerber(), '%AMOC8*5,1,8,0,0,1.08239X$1,22.5*%')
assert s.to_gerber() == "%AMOC8*5,1,8,0,0,0,22.5*%"
@@ -498,8 +443,7 @@ def test_AMParamStmt_dump():
def test_AMParamStmt_string():
name = "POLYGON"
macro = "5,1,8,25.4,25.4,25.4,0*"
- s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro})
- s.build()
+ s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro}, units='mm')
assert str(s) == "<Aperture Macro POLYGON: 5,1,8,25.4,25.4,25.4,0*>"
diff --git a/gerbonara/gerber/utils.py b/gerbonara/gerber/utils.py
index 3d39df9..c2e81cd 100644
--- a/gerbonara/gerber/utils.py
+++ b/gerbonara/gerber/utils.py
@@ -29,7 +29,7 @@ from math import radians, sin, cos, sqrt, atan2, pi
MILLIMETERS_PER_INCH = 25.4
-def parse_gerber_value(value, format=(2, 5), zero_suppression='trailing'):
+def parse_gerber_value(value, settings):
""" Convert gerber/excellon formatted string to floating-point number
.. note::
@@ -60,12 +60,16 @@ def parse_gerber_value(value, format=(2, 5), zero_suppression='trailing'):
The specified value as a floating-point number.
"""
+
+ if value is None:
+ return None
+
# Handle excellon edge case with explicit decimal. "That was easy!"
if '.' in value:
return float(value)
# Format precision
- integer_digits, decimal_digits = format
+ integer_digits, decimal_digits = settings.format
MAX_DIGITS = integer_digits + decimal_digits
# Absolute maximum number of digits supported. This will handle up to
@@ -82,9 +86,9 @@ def parse_gerber_value(value, format=(2, 5), zero_suppression='trailing'):
missing_digits = MAX_DIGITS - len(value)
- if zero_suppression == 'trailing':
+ if settings.zero_suppression == 'trailing':
digits = list(value + ('0' * missing_digits))
- elif zero_suppression == 'leading':
+ elif settings.zero_suppression == 'leading':
digits = list(('0' * missing_digits) + value)
else:
digits = list(value)
@@ -94,7 +98,7 @@ def parse_gerber_value(value, format=(2, 5), zero_suppression='trailing'):
return -result if negative else result
-def write_gerber_value(value, format=(2, 5), zero_suppression='trailing'):
+def write_gerber_value(value, settings):
""" Convert a floating point number to a Gerber/Excellon-formatted string.
.. note::
@@ -128,7 +132,7 @@ def write_gerber_value(value, format=(2, 5), zero_suppression='trailing'):
return "%f" %value
# Format precision
- integer_digits, decimal_digits = format
+ integer_digits, decimal_digits = settings.format
MAX_DIGITS = integer_digits + decimal_digits
if MAX_DIGITS > 13 or integer_digits > 6 or decimal_digits > 7:
@@ -154,10 +158,10 @@ def write_gerber_value(value, format=(2, 5), zero_suppression='trailing'):
return '0'
# Suppression...
- if zero_suppression == 'trailing':
+ if settings.zero_suppression == 'trailing':
while digits and digits[-1] == '0':
digits.pop()
- elif zero_suppression == 'leading':
+ elif settings.zero_suppression == 'leading':
while digits and digits[0] == '0':
digits.pop(0)
--
cgit