From 4eb0e063bcd34c21b737023aa6ed5baed80658d1 Mon Sep 17 00:00:00 2001 From: jaseg Date: Sun, 13 Jun 2021 15:00:17 +0200 Subject: Repo re-org, make gerberex tests run --- gerber/rs274x.py | 800 ------------------------------------------------------- 1 file changed, 800 deletions(-) delete mode 100644 gerber/rs274x.py (limited to 'gerber/rs274x.py') diff --git a/gerber/rs274x.py b/gerber/rs274x.py deleted file mode 100644 index afdf45f..0000000 --- a/gerber/rs274x.py +++ /dev/null @@ -1,800 +0,0 @@ -#! /usr/bin/env python -# -*- coding: utf-8 -*- - -# copyright 2014 Hamilton Kibbe -# Modified from parser.py by Paulo Henrique Silva -# -# 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 module provides an RS-274-X class and parser. -""" - -import copy -import json -import os -import re -import sys - -try: - from cStringIO import StringIO -except(ImportError): - from io import StringIO - -from .gerber_statements import * -from .primitives import * -from .cam import CamFile, FileSettings -from .utils import sq_distance - - -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 - - The GerberFile class represents a single gerber file. - - Parameters - ---------- - statements : list - list of gerber file statements - - settings : dict - Dictionary of gerber file settings - - filename : string - Filename of the source gerber file - - Attributes - ---------- - comments: list of strings - List of comments contained in the gerber file. - - size : tuple, (, ) - Size in [self.units] of the layer described by the gerber file. - - bounds: tuple, ((, ), (, )) - boundaries of the layer described by the gerber file. - `bounds` is stored as ((min x, max x), (min y, max y)) - - """ - - def __init__(self, statements, settings, primitives, apertures, filename=None): - super(GerberFile, self).__init__(statements, settings, primitives, filename) - - self.apertures = apertures - - @property - def comments(self): - return [comment.comment for comment in self.statements - if isinstance(comment, CommentStmt)] - - @property - def size(self): - xbounds, ybounds = self.bounds - return (xbounds[1] - xbounds[0], ybounds[1] - ybounds[0]) - - @property - def bounds(self): - min_x = min_y = 1000000 - max_x = max_y = -1000000 - - for stmt in [stmt for stmt in self.statements if isinstance(stmt, CoordStmt)]: - if stmt.x is not None: - min_x = min(stmt.x, min_x) - max_x = max(stmt.x, max_x) - - if stmt.y is not None: - min_y = min(stmt.y, min_y) - max_y = max(stmt.y, max_y) - - return ((min_x, max_x), (min_y, max_y)) - - @property - def bounding_box(self): - min_x = min_y = 1000000 - max_x = max_y = -1000000 - - for prim in self.primitives: - bounds = prim.bounding_box - min_x = min(bounds[0][0], min_x) - max_x = max(bounds[0][1], max_x) - - min_y = min(bounds[1][0], min_y) - max_y = max(bounds[1][1], max_y) - - return ((min_x, max_x), (min_y, max_y)) - - def write(self, filename, settings=None): - """ Write data out to a gerber file. - """ - with open(filename, 'w') as f: - for statement in self.statements: - f.write(statement.to_gerber(settings or self.settings)) - f.write("\n") - - def to_inch(self): - if self.units != 'inch': - self.units = 'inch' - for statement in self.statements: - statement.to_inch() - for primitive in self.primitives: - primitive.to_inch() - - def to_metric(self): - if self.units != 'metric': - self.units = 'metric' - for statement in self.statements: - statement.to_metric() - for primitive in self.primitives: - primitive.to_metric() - - def offset(self, x_offset=0, y_offset=0): - for statement in self.statements: - statement.offset(x_offset, y_offset) - for primitive in self.primitives: - primitive.offset(x_offset, y_offset) - - -class GerberParser(object): - """ 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"(?PFS)(?P(L|T|D))?(?P(A|I))[NG0-9]*X(?P[0-7][0-7])Y(?P[0-7][0-7])[DM0-9]*" - MO = r"(?PMO)(?P(MM|IN))" - LP = r"(?PLP)(?P(D|C))" - AD_CIRCLE = r"(?PAD)D(?P\d+)(?PC)[,]?(?P[^,%]*)" - AD_RECT = r"(?PAD)D(?P\d+)(?PR)[,](?P[^,%]*)" - AD_OBROUND = r"(?PAD)D(?P\d+)(?PO)[,](?P[^,%]*)" - AD_POLY = r"(?PAD)D(?P\d+)(?PP)[,](?P[^,%]*)" - AD_MACRO = r"(?PAD)D(?P\d+)(?P{name})[,]?(?P[^,%]*)".format(name=NAME) - AM = r"(?PAM)(?P{name})\*(?P[^%]*)".format(name=NAME) - # Include File - IF = r"(?PIF)(?P.*)" - - - # begin deprecated - AS = r"(?PAS)(?P(AXBY)|(AYBX))" - IN = r"(?PIN)(?P.*)" - IP = r"(?PIP)(?P(POS|NEG))" - IR = r"(?PIR)(?P{number})".format(number=NUMBER) - MI = r"(?PMI)(A(?P0|1))?(B(?P0|1))?" - OF = r"(?POF)(A(?P{decimal}))?(B(?P{decimal}))?".format(decimal=DECIMAL) - SF = r"(?PSF)(?P.*)" - LN = r"(?PLN)(?P.*)" - DEPRECATED_UNIT = re.compile(r'(?PG7[01])\*') - DEPRECATED_FORMAT = re.compile(r'(?PG9[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})?" - r"(X(?P{number}))?(Y(?P{number}))?" - r"(I(?P{number}))?(J(?P{number}))?" - r"(?P{op})?\*".format(number=NUMBER, function=COORD_FUNCTION, op=COORD_OP))) - - APERTURE_STMT = re.compile(r"(?P(G54)|(G55))?D(?P\d+)\*") - - COMMENT_STMT = re.compile(r"G0?4(?P[^*]*)(\*)?") - - EOF_STMT = re.compile(r"(?PM[0]?[012])\*") - - REGION_MODE_STMT = re.compile(r'(?PG3[67])\*') - QUAD_MODE_STMT = re.compile(r'(?PG7[45])\*') - - # Keep include loop from crashing us - INCLUDE_FILE_RECURSION_LIMIT = 10 - - def __init__(self): - self.filename = None - self.settings = FileSettings() - self.statements = [] - self.primitives = [] - self.apertures = {} - self.macros = {} - self.current_region = None - self.x = 0 - self.y = 0 - self.op = "D02" - self.aperture = 0 - self.interpolation = 'linear' - self.direction = 'clockwise' - self.image_polarity = 'positive' - self.level_polarity = 'dark' - self.region_mode = 'off' - self.quadrant_mode = 'multi-quadrant' - self.step_and_repeat = (1, 1, 0, 0) - self._recursion_depth = 0 - - def parse(self, filename): - self.filename = filename - with open(filename, "rU") 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)): - self.evaluate(stmt) - self.statements.append(stmt) - - # Initialize statement units - for stmt in self.statements: - stmt.units = self.settings.units - - return GerberFile(self.statements, self.settings, self.primitives, self.apertures.values(), filename) - - def _split_commands(self, 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 - - for cur in range(0, length): - - val = data[cur] - - 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 in_header and val == '%': - yield data[start:cur + 1] - start = cur + 1 - in_header = False - - def dump_json(self): - stmts = {"statements": [stmt.__dict__ for stmt in self.statements]} - return json.dumps(stmts) - - def dump_str(self): - string = "" - for stmt in self.statements: - string += str(stmt) + "\n" - return string - - 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 - - # 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": - stmt = AMParamStmt.from_dict(param) - stmt.units = self.settings.units - yield stmt - 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: - yield UnknownStmt(line) - - 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 - - # Quadrant Mode - (mode, r) = _match_one(self.QUAD_MODE_STMT, line) - if mode: - yield QuadrantModeStmt.from_gerber(line) - line = r - did_something = True - continue - - # comment - (comment, r) = _match_one(self.COMMENT_STMT, line) - if comment: - yield CommentStmt(comment["comment"]) - did_something = True - line = r - continue - - # deprecated codes - (deprecated_unit, r) = _match_one(self.DEPRECATED_UNIT, line) - if deprecated_unit: - 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 - - (deprecated_format, r) = _match_one(self.DEPRECATED_FORMAT, line) - if deprecated_format: - yield DeprecatedStmt.from_gerber(line) - line = r - did_something = True - continue - - # eof - (eof, r) = _match_one(self.EOF_STMT, line) - if eof: - yield EofStmt() - did_something = True - line = r - continue - - if line.find('*') > 0: - yield UnknownStmt(line) - did_something = True - line = "" - continue - - oldline = line - - def evaluate(self, stmt): - """ Evaluate Gerber statement and update image accordingly. - - This method is called once for each statement in the file as it - is parsed. - - Parameters - ---------- - statement : Statement - Gerber/Excellon statement to evaluate. - - """ - if isinstance(stmt, CoordStmt): - self._evaluate_coord(stmt) - - elif isinstance(stmt, ParamStmt): - self._evaluate_param(stmt) - - elif isinstance(stmt, ApertureStmt): - self._evaluate_aperture(stmt) - - elif isinstance(stmt, (RegionModeStmt, QuadrantModeStmt)): - self._evaluate_mode(stmt) - - elif isinstance(stmt, (CommentStmt, UnknownStmt, DeprecatedStmt, EofStmt)): - return - - else: - raise Exception("Invalid statement to evaluate") - - def _define_aperture(self, d, shape, modifiers): - aperture = None - if shape == 'C': - diameter = modifiers[0][0] - - hole_diameter = 0 - rectangular_hole = (0, 0) - if len(modifiers[0]) == 2: - hole_diameter = modifiers[0][1] - elif len(modifiers[0]) == 3: - rectangular_hole = modifiers[0][1:3] - - aperture = Circle(position=None, diameter=diameter, - hole_diameter=hole_diameter, - hole_width=rectangular_hole[0], - hole_height=rectangular_hole[1], - units=self.settings.units) - - elif shape == 'R': - width = modifiers[0][0] - height = modifiers[0][1] - - hole_diameter = 0 - rectangular_hole = (0, 0) - if len(modifiers[0]) == 3: - hole_diameter = modifiers[0][2] - elif len(modifiers[0]) == 4: - rectangular_hole = modifiers[0][2:4] - - aperture = Rectangle(position=None, width=width, height=height, - hole_diameter=hole_diameter, - hole_width=rectangular_hole[0], - hole_height=rectangular_hole[1], - units=self.settings.units) - elif shape == 'O': - width = modifiers[0][0] - height = modifiers[0][1] - - hole_diameter = 0 - rectangular_hole = (0, 0) - if len(modifiers[0]) == 3: - hole_diameter = modifiers[0][2] - elif len(modifiers[0]) == 4: - rectangular_hole = modifiers[0][2:4] - - aperture = Obround(position=None, width=width, height=height, - hole_diameter=hole_diameter, - hole_width=rectangular_hole[0], - hole_height=rectangular_hole[1], - units=self.settings.units) - elif shape == 'P': - outer_diameter = modifiers[0][0] - number_vertices = int(modifiers[0][1]) - if len(modifiers[0]) > 2: - rotation = modifiers[0][2] - else: - rotation = 0 - - hole_diameter = 0 - rectangular_hole = (0, 0) - if len(modifiers[0]) == 4: - hole_diameter = modifiers[0][3] - elif len(modifiers[0]) >= 5: - rectangular_hole = modifiers[0][3:5] - - aperture = Polygon(position=None, sides=number_vertices, - radius=outer_diameter/2.0, - hole_diameter=hole_diameter, - hole_width=rectangular_hole[0], - hole_height=rectangular_hole[1], - rotation=rotation) - else: - aperture = self.macros[shape].build(modifiers) - - aperture.units = self.settings.units - self.apertures[d] = aperture - - def _evaluate_mode(self, stmt): - if stmt.type == 'RegionMode': - if self.region_mode == 'on' and stmt.mode == 'off': - # Sometimes we have regions that have no points. Skip those - if self.current_region: - self.primitives.append(Region(self.current_region, - level_polarity=self.level_polarity, units=self.settings.units)) - - self.current_region = None - self.region_mode = stmt.mode - elif stmt.type == 'QuadrantMode': - self.quadrant_mode = stmt.mode - - def _evaluate_param(self, stmt): - if stmt.param == "FS": - self.settings.zero_suppression = stmt.zero_suppression - self.settings.format = stmt.format - self.settings.notation = stmt.notation - elif stmt.param == "MO": - self.settings.units = stmt.mode - elif stmt.param == "IP": - self.image_polarity = stmt.ip - elif stmt.param == "LP": - self.level_polarity = stmt.lp - elif stmt.param == "AM": - self.macros[stmt.name] = stmt - elif stmt.param == "AD": - self._define_aperture(stmt.d, stmt.shape, stmt.modifiers) - - def _evaluate_coord(self, stmt): - x = self.x if stmt.x is None else stmt.x - y = self.y if stmt.y is None else stmt.y - - if stmt.function in ("G01", "G1"): - self.interpolation = 'linear' - elif stmt.function in ('G02', 'G2', 'G03', 'G3'): - self.interpolation = 'arc' - self.direction = ('clockwise' if stmt.function in - ('G02', 'G2') else 'counterclockwise') - - if stmt.only_function: - # Sometimes we get a coordinate statement - # that only sets the function. If so, don't - # try futher otherwise that might draw/flash something - return - - if stmt.op: - self.op = stmt.op - else: - # no implicit op allowed, force here if coord block doesn't have it - stmt.op = self.op - - if self.op == "D01" or self.op == "D1": - start = (self.x, self.y) - end = (x, y) - - if self.interpolation == 'linear': - if self.region_mode == 'off': - self.primitives.append(Line(start, end, - self.apertures[self.aperture], - level_polarity=self.level_polarity, - units=self.settings.units)) - else: - # from gerber spec revision J3, Section 4.5, page 55: - # The segments are not graphics objects in themselves; segments are part of region which is the graphics object. The segments have no thickness. - # The current aperture is associated with the region. - # This has no graphical effect, but allows all its attributes to - # be applied to the region. - - if self.current_region is None: - self.current_region = [Line(start, end, - self.apertures.get(self.aperture, - Circle((0, 0), 0)), - level_polarity=self.level_polarity, - units=self.settings.units), ] - else: - self.current_region.append(Line(start, end, - self.apertures.get(self.aperture, - Circle((0, 0), 0)), - level_polarity=self.level_polarity, - units=self.settings.units)) - else: - i = 0 if stmt.i is None else stmt.i - j = 0 if stmt.j is None else stmt.j - center = self._find_center(start, end, (i, j)) - if self.region_mode == 'off': - self.primitives.append(Arc(start, end, center, self.direction, - self.apertures[self.aperture], - quadrant_mode=self.quadrant_mode, - level_polarity=self.level_polarity, - units=self.settings.units)) - else: - if self.current_region is None: - self.current_region = [Arc(start, end, center, self.direction, - self.apertures.get(self.aperture, Circle((0,0), 0)), - quadrant_mode=self.quadrant_mode, - level_polarity=self.level_polarity, - units=self.settings.units),] - else: - self.current_region.append(Arc(start, end, center, self.direction, - self.apertures.get(self.aperture, Circle((0,0), 0)), - quadrant_mode=self.quadrant_mode, - level_polarity=self.level_polarity, - units=self.settings.units)) - # Gerbv seems to reset interpolation mode in regions.. - # TODO: Make sure this is right. - self.interpolation = 'linear' - - elif self.op == "D02" or self.op == "D2": - - if self.region_mode == "on": - # D02 in the middle of a region finishes that region and starts a new one - if self.current_region and len(self.current_region) > 1: - self.primitives.append(Region(self.current_region, - level_polarity=self.level_polarity, - units=self.settings.units)) - self.current_region = None - - elif self.op == "D03" or self.op == "D3": - primitive = copy.deepcopy(self.apertures[self.aperture]) - - if primitive is not None: - - if not isinstance(primitive, AMParamStmt): - primitive.position = (x, y) - primitive.level_polarity = self.level_polarity - primitive.units = self.settings.units - self.primitives.append(primitive) - else: - # Aperture Macro - for am_prim in primitive.primitives: - renderable = am_prim.to_primitive((x, y), - self.level_polarity, - self.settings.units) - if renderable is not None: - self.primitives.append(renderable) - self.x, self.y = x, y - - def _find_center(self, start, end, offsets): - """ - In single quadrant mode, the offsets are always positive, which means - there are 4 possible centers. The correct center is the only one that - results in an arc with sweep angle of less than or equal to 90 degrees - in the specified direction - """ - two_pi = 2 * math.pi - if self.quadrant_mode == 'single-quadrant': - # The Gerber spec says single quadrant only has one possible center, - # and you can detect it based on the angle. But for real files, this - # seems to work better - there is usually only one option that makes - # sense for the center (since the distance should be the same - # from start and end). We select the center with the least error in - # radius from all the options with a valid sweep angle. - - sqdist_diff_min = sys.maxsize - center = None - for factors in [(1, 1), (1, -1), (-1, 1), (-1, -1)]: - - test_center = (start[0] + offsets[0] * factors[0], - start[1] + offsets[1] * factors[1]) - - # Find angle from center to start and end points - start_angle = math.atan2(*reversed([_start - _center for _start, _center in zip(start, test_center)])) - end_angle = math.atan2(*reversed([_end - _center for _end, _center in zip(end, test_center)])) - - # Clamp angles to 0, 2pi - theta0 = (start_angle + two_pi) % two_pi - theta1 = (end_angle + two_pi) % two_pi - - # Determine sweep angle in the current arc direction - if self.direction == 'counterclockwise': - sweep_angle = abs(theta1 - theta0) - else: - theta0 += two_pi - sweep_angle = abs(theta0 - theta1) % two_pi - - # Calculate the radius error - sqdist_start = sq_distance(start, test_center) - sqdist_end = sq_distance(end, test_center) - sqdist_diff = abs(sqdist_start - sqdist_end) - - # Take the option with the lowest radius error from the set of - # options with a valid sweep angle - # In some rare cases, the sweep angle is numerically (10**-14) above pi/2 - # So it is safer to compare the angles with some tolerance - is_lowest_radius_error = sqdist_diff < sqdist_diff_min - is_valid_sweep_angle = sweep_angle >= 0 and sweep_angle <= math.pi / 2.0 + 1e-6 - if is_lowest_radius_error and is_valid_sweep_angle: - center = test_center - sqdist_diff_min = sqdist_diff - return center - else: - return (start[0] + offsets[0], start[1] + offsets[1]) - - def _evaluate_aperture(self, stmt): - self.aperture = stmt.d - -def _match_one(expr, data): - match = expr.match(data) - if match is None: - return ({}, None) - else: - return (match.groupdict(), data[match.end(0):]) - - -def _match_one_from_many(exprs, data): - for expr in exprs: - match = expr.match(data) - if match: - return (match.groupdict(), data[match.end(0):]) - - return ({}, None) -- cgit