2020-04-05 18:11:48 +00:00
|
|
|
from PyQt5 import QtWidgets
|
2020-06-02 15:29:45 +00:00
|
|
|
from camlib import Geometry, arc, arc_angle, ApertureMacro, grace
|
2019-10-15 23:28:18 +00:00
|
|
|
|
|
|
|
import numpy as np
|
2020-07-02 14:15:13 +00:00
|
|
|
# import re
|
|
|
|
# import logging
|
2019-10-15 23:28:18 +00:00
|
|
|
import traceback
|
|
|
|
from copy import deepcopy
|
2020-07-02 14:15:13 +00:00
|
|
|
# import sys
|
2019-10-15 23:28:18 +00:00
|
|
|
|
2020-07-02 14:15:13 +00:00
|
|
|
from shapely.ops import unary_union, linemerge
|
|
|
|
# from shapely.affinity import scale, translate
|
2019-10-15 23:28:18 +00:00
|
|
|
import shapely.affinity as affinity
|
2020-07-02 14:15:13 +00:00
|
|
|
from shapely.geometry import box as shply_box
|
2019-10-15 23:28:18 +00:00
|
|
|
|
2019-12-02 18:03:27 +00:00
|
|
|
from lxml import etree as ET
|
2020-07-02 14:15:13 +00:00
|
|
|
import ezdxf
|
|
|
|
|
|
|
|
from appParsers.ParseDXF import *
|
2020-09-23 08:50:00 +00:00
|
|
|
from appParsers.ParseSVG import svgparselength, getsvggeo, svgparse_viewbox
|
2020-04-27 07:03:22 +00:00
|
|
|
|
2019-10-06 12:56:41 +00:00
|
|
|
import gettext
|
|
|
|
import builtins
|
|
|
|
|
2019-10-06 04:14:10 +00:00
|
|
|
if '_' not in builtins.__dict__:
|
|
|
|
_ = gettext.gettext
|
|
|
|
|
2019-10-15 23:28:18 +00:00
|
|
|
log = logging.getLogger('base')
|
|
|
|
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
class Gerber(Geometry):
|
|
|
|
"""
|
|
|
|
Here it is done all the Gerber parsing.
|
|
|
|
|
|
|
|
**ATTRIBUTES**
|
|
|
|
|
|
|
|
* ``apertures`` (dict): The keys are names/identifiers of each aperture.
|
|
|
|
The values are dictionaries key/value pairs which describe the aperture. The
|
|
|
|
type key is always present and the rest depend on the key:
|
|
|
|
|
|
|
|
+-----------+-----------------------------------+
|
|
|
|
| Key | Value |
|
|
|
|
+===========+===================================+
|
|
|
|
| type | (str) "C", "R", "O", "P", or "AP" |
|
|
|
|
+-----------+-----------------------------------+
|
|
|
|
| others | Depend on ``type`` |
|
|
|
|
+-----------+-----------------------------------+
|
|
|
|
| solid_geometry | (list) |
|
|
|
|
+-----------+-----------------------------------+
|
|
|
|
* ``aperture_macros`` (dictionary): Are predefined geometrical structures
|
|
|
|
that can be instantiated with different parameters in an aperture
|
|
|
|
definition. See ``apertures`` above. The key is the name of the macro,
|
|
|
|
and the macro itself, the value, is a ``Aperture_Macro`` object.
|
|
|
|
|
|
|
|
* ``flash_geometry`` (list): List of (Shapely) geometric object resulting
|
|
|
|
from ``flashes``. These are generated from ``flashes`` in ``do_flashes()``.
|
|
|
|
|
|
|
|
* ``buffered_paths`` (list): List of (Shapely) polygons resulting from
|
|
|
|
*buffering* (or thickening) the ``paths`` with the aperture. These are
|
|
|
|
generated from ``paths`` in ``buffer_paths()``.
|
|
|
|
|
|
|
|
**USAGE**::
|
|
|
|
|
|
|
|
g = Gerber()
|
|
|
|
g.parse_file(filename)
|
|
|
|
g.create_geometry()
|
|
|
|
do_something(s.solid_geometry)
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
# defaults = {
|
|
|
|
# "steps_per_circle": 128,
|
|
|
|
# "use_buffer_for_union": True
|
|
|
|
# }
|
|
|
|
|
2019-12-18 01:14:17 +00:00
|
|
|
app = None
|
|
|
|
|
2019-10-06 04:14:10 +00:00
|
|
|
def __init__(self, steps_per_circle=None):
|
|
|
|
"""
|
|
|
|
The constructor takes no parameters. Use ``gerber.parse_files()``
|
|
|
|
or ``gerber.parse_lines()`` to populate the object from Gerber source.
|
|
|
|
|
|
|
|
:return: Gerber object
|
|
|
|
:rtype: Gerber
|
|
|
|
"""
|
|
|
|
|
|
|
|
# How to approximate a circle with lines.
|
|
|
|
self.steps_per_circle = int(self.app.defaults["gerber_circle_steps"])
|
2019-12-05 13:18:54 +00:00
|
|
|
self.decimals = self.app.decimals
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
# Initialize parent
|
2019-10-10 10:00:44 +00:00
|
|
|
Geometry.__init__(self, geo_steps_per_circle=self.steps_per_circle)
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
# Number format
|
|
|
|
self.int_digits = 3
|
|
|
|
"""Number of integer digits in Gerber numbers. Used during parsing."""
|
|
|
|
|
|
|
|
self.frac_digits = 4
|
|
|
|
"""Number of fraction digits in Gerber numbers. Used during parsing."""
|
|
|
|
|
|
|
|
self.gerber_zeros = self.app.defaults['gerber_def_zeros']
|
|
|
|
"""Zeros in Gerber numbers. If 'L' then remove leading zeros, if 'T' remove trailing zeros. Used during parsing.
|
|
|
|
"""
|
|
|
|
|
|
|
|
# ## Gerber elements # ##
|
|
|
|
'''
|
|
|
|
apertures = {
|
|
|
|
'id':{
|
|
|
|
'type':string,
|
|
|
|
'size':float,
|
|
|
|
'width':float,
|
|
|
|
'height':float,
|
|
|
|
'geometry': [],
|
|
|
|
}
|
|
|
|
}
|
|
|
|
apertures['geometry'] list elements are dicts
|
|
|
|
dict = {
|
|
|
|
'solid': [],
|
|
|
|
'follow': [],
|
|
|
|
'clear': []
|
|
|
|
}
|
|
|
|
'''
|
|
|
|
|
|
|
|
# store the file units here:
|
2019-10-12 01:49:50 +00:00
|
|
|
self.units = self.app.defaults['gerber_def_units']
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
# aperture storage
|
|
|
|
self.apertures = {}
|
|
|
|
|
|
|
|
# Aperture Macros
|
|
|
|
self.aperture_macros = {}
|
|
|
|
|
|
|
|
# will store the Gerber geometry's as solids
|
|
|
|
self.solid_geometry = Polygon()
|
|
|
|
|
|
|
|
# will store the Gerber geometry's as paths
|
|
|
|
self.follow_geometry = []
|
|
|
|
|
|
|
|
# made True when the LPC command is encountered in Gerber parsing
|
|
|
|
# it allows adding data into the clear_geometry key of the self.apertures[aperture] dict
|
|
|
|
self.is_lpc = False
|
|
|
|
|
|
|
|
self.source_file = ''
|
|
|
|
|
|
|
|
# ### Parser patterns ## ##
|
|
|
|
# FS - Format Specification
|
|
|
|
# The format of X and Y must be the same!
|
|
|
|
# L-omit leading zeros, T-omit trailing zeros, D-no zero supression
|
|
|
|
# A-absolute notation, I-incremental notation
|
|
|
|
self.fmt_re = re.compile(r'%?FS([LTD])?([AI])X(\d)(\d)Y\d\d\*%?$')
|
|
|
|
self.fmt_re_alt = re.compile(r'%FS([LTD])?([AI])X(\d)(\d)Y\d\d\*MO(IN|MM)\*%$')
|
|
|
|
self.fmt_re_orcad = re.compile(r'(G\d+)*\**%FS([LTD])?([AI]).*X(\d)(\d)Y\d\d\*%$')
|
|
|
|
|
|
|
|
# Mode (IN/MM)
|
|
|
|
self.mode_re = re.compile(r'^%?MO(IN|MM)\*%?$')
|
|
|
|
|
|
|
|
# Comment G04|G4
|
|
|
|
self.comm_re = re.compile(r'^G0?4(.*)$')
|
|
|
|
|
|
|
|
# AD - Aperture definition
|
|
|
|
# Aperture Macro names: Name = [a-zA-Z_.$]{[a-zA-Z_.0-9]+}
|
|
|
|
# NOTE: Adding "-" to support output from Upverter.
|
|
|
|
self.ad_re = re.compile(r'^%ADD(\d\d+)([a-zA-Z_$\.][a-zA-Z0-9_$\.\-]*)(?:,(.*))?\*%$')
|
|
|
|
|
|
|
|
# AM - Aperture Macro
|
|
|
|
# Beginning of macro (Ends with *%):
|
|
|
|
# self.am_re = re.compile(r'^%AM([a-zA-Z0-9]*)\*')
|
|
|
|
|
|
|
|
# Tool change
|
|
|
|
# May begin with G54 but that is deprecated
|
|
|
|
self.tool_re = re.compile(r'^(?:G54)?D(\d\d+)\*$')
|
|
|
|
|
|
|
|
# G01... - Linear interpolation plus flashes with coordinates
|
|
|
|
# Operation code (D0x) missing is deprecated... oh well I will support it.
|
|
|
|
self.lin_re = re.compile(r'^(?:G0?(1))?(?=.*X([\+-]?\d+))?(?=.*Y([\+-]?\d+))?[XY][^DIJ]*(?:D0?([123]))?\*$')
|
|
|
|
|
|
|
|
# Operation code alone, usually just D03 (Flash)
|
|
|
|
self.opcode_re = re.compile(r'^D0?([123])\*$')
|
|
|
|
|
|
|
|
# G02/3... - Circular interpolation with coordinates
|
|
|
|
# 2-clockwise, 3-counterclockwise
|
|
|
|
# Operation code (D0x) missing is deprecated... oh well I will support it.
|
|
|
|
# Optional start with G02 or G03, optional end with D01 or D02 with
|
|
|
|
# optional coordinates but at least one in any order.
|
|
|
|
self.circ_re = re.compile(r'^(?:G0?([23]))?(?=.*X([\+-]?\d+))?(?=.*Y([\+-]?\d+))' +
|
|
|
|
'?(?=.*I([\+-]?\d+))?(?=.*J([\+-]?\d+))?[XYIJ][^D]*(?:D0([12]))?\*$')
|
|
|
|
|
|
|
|
# G01/2/3 Occurring without coordinates
|
|
|
|
self.interp_re = re.compile(r'^(?:G0?([123]))\*')
|
|
|
|
|
|
|
|
# Single G74 or multi G75 quadrant for circular interpolation
|
|
|
|
self.quad_re = re.compile(r'^G7([45]).*\*$')
|
|
|
|
|
|
|
|
# Region mode on
|
|
|
|
# In region mode, D01 starts a region
|
|
|
|
# and D02 ends it. A new region can be started again
|
|
|
|
# with D01. All contours must be closed before
|
|
|
|
# D02 or G37.
|
|
|
|
self.regionon_re = re.compile(r'^G36\*$')
|
|
|
|
|
|
|
|
# Region mode off
|
|
|
|
# Will end a region and come off region mode.
|
|
|
|
# All contours must be closed before D02 or G37.
|
|
|
|
self.regionoff_re = re.compile(r'^G37\*$')
|
|
|
|
|
|
|
|
# End of file
|
|
|
|
self.eof_re = re.compile(r'^M02\*')
|
|
|
|
|
|
|
|
# IP - Image polarity
|
|
|
|
self.pol_re = re.compile(r'^%?IP(POS|NEG)\*%?$')
|
|
|
|
|
|
|
|
# LP - Level polarity
|
|
|
|
self.lpol_re = re.compile(r'^%LP([DC])\*%$')
|
|
|
|
|
|
|
|
# Units (OBSOLETE)
|
|
|
|
self.units_re = re.compile(r'^G7([01])\*$')
|
|
|
|
|
|
|
|
# Absolute/Relative G90/1 (OBSOLETE)
|
|
|
|
self.absrel_re = re.compile(r'^G9([01])\*$')
|
|
|
|
|
|
|
|
# Aperture macros
|
|
|
|
self.am1_re = re.compile(r'^%AM([^\*]+)\*([^%]+)?(%)?$')
|
|
|
|
self.am2_re = re.compile(r'(.*)%$')
|
|
|
|
|
2019-10-12 01:49:50 +00:00
|
|
|
# flag to store if a conversion was done. It is needed because multiple units declarations can be found
|
|
|
|
# in a Gerber file (normal or obsolete ones)
|
|
|
|
self.conversion_done = False
|
|
|
|
|
2019-10-06 04:14:10 +00:00
|
|
|
self.use_buffer_for_union = self.app.defaults["gerber_use_buffer_for_union"]
|
|
|
|
|
2020-07-14 13:46:01 +00:00
|
|
|
# Attributes to be included in serialization
|
|
|
|
# Always append to it because it carries contents
|
|
|
|
# from Geometry.
|
|
|
|
self.ser_attrs += ['apertures', 'int_digits', 'frac_digits', 'aperture_macros', 'solid_geometry', 'source_file']
|
|
|
|
|
2019-10-06 04:14:10 +00:00
|
|
|
def aperture_parse(self, apertureId, apertureType, apParameters):
|
|
|
|
"""
|
|
|
|
Parse gerber aperture definition into dictionary of apertures.
|
|
|
|
The following kinds and their attributes are supported:
|
|
|
|
|
|
|
|
* *Circular (C)*: size (float)
|
|
|
|
* *Rectangle (R)*: width (float), height (float)
|
|
|
|
* *Obround (O)*: width (float), height (float).
|
|
|
|
* *Polygon (P)*: diameter(float), vertices(int), [rotation(float)]
|
|
|
|
* *Aperture Macro (AM)*: macro (ApertureMacro), modifiers (list)
|
|
|
|
|
|
|
|
:param apertureId: Id of the aperture being defined.
|
|
|
|
:param apertureType: Type of the aperture.
|
|
|
|
:param apParameters: Parameters of the aperture.
|
|
|
|
:type apertureId: str
|
|
|
|
:type apertureType: str
|
|
|
|
:type apParameters: str
|
|
|
|
:return: Identifier of the aperture.
|
|
|
|
:rtype: str
|
|
|
|
"""
|
|
|
|
if self.app.abort_flag:
|
|
|
|
# graceful abort requested by the user
|
2020-04-27 07:03:22 +00:00
|
|
|
raise grace
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
# Found some Gerber with a leading zero in the aperture id and the
|
|
|
|
# referenced it without the zero, so this is a hack to handle that.
|
|
|
|
apid = str(int(apertureId))
|
|
|
|
|
|
|
|
try: # Could be empty for aperture macros
|
|
|
|
paramList = apParameters.split('X')
|
2019-11-11 00:35:42 +00:00
|
|
|
except Exception:
|
2019-10-06 04:14:10 +00:00
|
|
|
paramList = None
|
|
|
|
|
|
|
|
if apertureType == "C": # Circle, example: %ADD11C,0.1*%
|
|
|
|
self.apertures[apid] = {"type": "C",
|
|
|
|
"size": float(paramList[0])}
|
|
|
|
return apid
|
|
|
|
|
|
|
|
if apertureType == "R": # Rectangle, example: %ADD15R,0.05X0.12*%
|
|
|
|
self.apertures[apid] = {"type": "R",
|
|
|
|
"width": float(paramList[0]),
|
|
|
|
"height": float(paramList[1]),
|
2019-10-15 23:28:18 +00:00
|
|
|
"size": np.sqrt(float(paramList[0]) ** 2 + float(paramList[1]) ** 2)} # Hack
|
2019-10-06 04:14:10 +00:00
|
|
|
return apid
|
|
|
|
|
|
|
|
if apertureType == "O": # Obround
|
|
|
|
self.apertures[apid] = {"type": "O",
|
|
|
|
"width": float(paramList[0]),
|
|
|
|
"height": float(paramList[1]),
|
2019-10-15 23:28:18 +00:00
|
|
|
"size": np.sqrt(float(paramList[0]) ** 2 + float(paramList[1]) ** 2)} # Hack
|
2019-10-06 04:14:10 +00:00
|
|
|
return apid
|
|
|
|
|
|
|
|
if apertureType == "P": # Polygon (regular)
|
|
|
|
self.apertures[apid] = {"type": "P",
|
|
|
|
"diam": float(paramList[0]),
|
|
|
|
"nVertices": int(paramList[1]),
|
|
|
|
"size": float(paramList[0])} # Hack
|
|
|
|
if len(paramList) >= 3:
|
|
|
|
self.apertures[apid]["rotation"] = float(paramList[2])
|
|
|
|
return apid
|
|
|
|
|
|
|
|
if apertureType in self.aperture_macros:
|
|
|
|
self.apertures[apid] = {"type": "AM",
|
|
|
|
"macro": self.aperture_macros[apertureType],
|
|
|
|
"modifiers": paramList}
|
|
|
|
return apid
|
|
|
|
|
|
|
|
log.warning("Aperture not implemented: %s" % str(apertureType))
|
|
|
|
return None
|
|
|
|
|
|
|
|
def parse_file(self, filename, follow=False):
|
|
|
|
"""
|
|
|
|
Calls Gerber.parse_lines() with generator of lines
|
|
|
|
read from the given file. Will split the lines if multiple
|
|
|
|
statements are found in a single original line.
|
|
|
|
|
|
|
|
The following line is split into two::
|
|
|
|
|
|
|
|
G54D11*G36*
|
|
|
|
|
|
|
|
First is ``G54D11*`` and seconds is ``G36*``.
|
|
|
|
|
|
|
|
:param filename: Gerber file to parse.
|
|
|
|
:type filename: str
|
|
|
|
:param follow: If true, will not create polygons, just lines
|
|
|
|
following the gerber path.
|
|
|
|
:type follow: bool
|
|
|
|
:return: None
|
|
|
|
"""
|
|
|
|
|
|
|
|
with open(filename, 'r') as gfile:
|
|
|
|
|
|
|
|
def line_generator():
|
|
|
|
for line in gfile:
|
|
|
|
line = line.strip(' \r\n')
|
|
|
|
while len(line) > 0:
|
|
|
|
|
|
|
|
# If ends with '%' leave as is.
|
|
|
|
if line[-1] == '%':
|
|
|
|
yield line
|
|
|
|
break
|
|
|
|
|
|
|
|
# Split after '*' if any.
|
|
|
|
starpos = line.find('*')
|
|
|
|
if starpos > -1:
|
|
|
|
cleanline = line[:starpos + 1]
|
|
|
|
yield cleanline
|
|
|
|
line = line[starpos + 1:]
|
|
|
|
|
|
|
|
# Otherwise leave as is.
|
|
|
|
else:
|
|
|
|
# yield clean line
|
|
|
|
yield line
|
|
|
|
break
|
|
|
|
|
|
|
|
processed_lines = list(line_generator())
|
|
|
|
self.parse_lines(processed_lines)
|
|
|
|
|
|
|
|
# @profile
|
|
|
|
def parse_lines(self, glines):
|
|
|
|
"""
|
|
|
|
Main Gerber parser. Reads Gerber and populates ``self.paths``, ``self.apertures``,
|
|
|
|
``self.flashes``, ``self.regions`` and ``self.units``.
|
|
|
|
|
|
|
|
:param glines: Gerber code as list of strings, each element being
|
|
|
|
one line of the source file.
|
|
|
|
:type glines: list
|
|
|
|
:return: None
|
|
|
|
:rtype: None
|
|
|
|
"""
|
|
|
|
|
|
|
|
# Coordinates of the current path, each is [x, y]
|
|
|
|
path = []
|
|
|
|
|
|
|
|
# this is for temporary storage of solid geometry until it is added to poly_buffer
|
|
|
|
geo_s = None
|
|
|
|
|
|
|
|
# this is for temporary storage of follow geometry until it is added to follow_buffer
|
|
|
|
geo_f = None
|
|
|
|
|
|
|
|
# Polygons are stored here until there is a change in polarity.
|
2020-10-21 10:55:41 +00:00
|
|
|
# Only then they are combined via unary_union and added or
|
2019-10-06 04:14:10 +00:00
|
|
|
# subtracted from solid_geometry. This is ~100 times faster than
|
|
|
|
# applying a union for every new polygon.
|
|
|
|
poly_buffer = []
|
|
|
|
|
|
|
|
# store here the follow geometry
|
|
|
|
follow_buffer = []
|
|
|
|
|
|
|
|
last_path_aperture = None
|
|
|
|
current_aperture = None
|
|
|
|
|
|
|
|
# 1,2 or 3 from "G01", "G02" or "G03"
|
|
|
|
current_interpolation_mode = None
|
|
|
|
|
|
|
|
# 1 or 2 from "D01" or "D02"
|
|
|
|
# Note this is to support deprecated Gerber not putting
|
|
|
|
# an operation code at the end of every coordinate line.
|
|
|
|
current_operation_code = None
|
|
|
|
|
|
|
|
# Current coordinates
|
2020-02-02 13:54:09 +00:00
|
|
|
current_x = 0
|
|
|
|
current_y = 0
|
|
|
|
previous_x = 0
|
|
|
|
previous_y = 0
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
current_d = None
|
|
|
|
|
|
|
|
# Absolute or Relative/Incremental coordinates
|
|
|
|
# Not implemented
|
2020-04-27 07:03:22 +00:00
|
|
|
# absolute = True
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
# How to interpret circular interpolation: SINGLE or MULTI
|
|
|
|
quadrant_mode = None
|
|
|
|
|
|
|
|
# Indicates we are parsing an aperture macro
|
|
|
|
current_macro = None
|
|
|
|
|
|
|
|
# Indicates the current polarity: D-Dark, C-Clear
|
|
|
|
current_polarity = 'D'
|
|
|
|
|
|
|
|
# If a region is being defined
|
|
|
|
making_region = False
|
|
|
|
|
|
|
|
# ### Parsing starts here ## ##
|
|
|
|
line_num = 0
|
|
|
|
gline = ""
|
|
|
|
|
|
|
|
s_tol = float(self.app.defaults["gerber_simp_tolerance"])
|
|
|
|
|
|
|
|
self.app.inform.emit('%s %d %s.' % (_("Gerber processing. Parsing"), len(glines), _("lines")))
|
|
|
|
try:
|
|
|
|
for gline in glines:
|
|
|
|
if self.app.abort_flag:
|
|
|
|
# graceful abort requested by the user
|
2020-04-27 07:03:22 +00:00
|
|
|
raise grace
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
line_num += 1
|
|
|
|
self.source_file += gline + '\n'
|
|
|
|
|
|
|
|
# Cleanup #
|
|
|
|
gline = gline.strip(' \r\n')
|
|
|
|
# log.debug("Line=%3s %s" % (line_num, gline))
|
|
|
|
|
2019-12-26 01:15:17 +00:00
|
|
|
# ###############################################################
|
|
|
|
# ################ Ignored lines ############################
|
|
|
|
# ################ Comments ############################
|
|
|
|
# ###############################################################
|
2019-10-06 04:14:10 +00:00
|
|
|
match = self.comm_re.search(gline)
|
|
|
|
if match:
|
|
|
|
continue
|
|
|
|
|
2019-12-26 02:42:48 +00:00
|
|
|
# ###############################################################
|
|
|
|
# ################ Polarity change #############################
|
|
|
|
# ######## Example: %LPD*% or %LPC*% ###################
|
|
|
|
# ######## If polarity changes, creates geometry from current #
|
|
|
|
# ######## buffer, then adds or subtracts accordingly. #
|
|
|
|
# ###############################################################
|
2019-10-06 04:14:10 +00:00
|
|
|
match = self.lpol_re.search(gline)
|
|
|
|
if match:
|
|
|
|
new_polarity = match.group(1)
|
|
|
|
# log.info("Polarity CHANGE, LPC = %s, poly_buff = %s" % (self.is_lpc, poly_buffer))
|
|
|
|
self.is_lpc = True if new_polarity == 'C' else False
|
2020-02-25 19:22:51 +00:00
|
|
|
try:
|
|
|
|
path_length = len(path)
|
|
|
|
except TypeError:
|
|
|
|
path_length = 1
|
|
|
|
|
|
|
|
if path_length > 1 and current_polarity != new_polarity:
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
# finish the current path and add it to the storage
|
|
|
|
# --- Buffered ----
|
|
|
|
width = self.apertures[last_path_aperture]["size"]
|
|
|
|
|
2020-02-29 22:52:24 +00:00
|
|
|
geo_dict = {}
|
2019-10-06 04:14:10 +00:00
|
|
|
geo_f = LineString(path)
|
|
|
|
if not geo_f.is_empty:
|
|
|
|
follow_buffer.append(geo_f)
|
|
|
|
geo_dict['follow'] = geo_f
|
|
|
|
|
|
|
|
geo_s = LineString(path).buffer(width / 1.999, int(self.steps_per_circle / 4))
|
2019-12-17 15:37:18 +00:00
|
|
|
if not geo_s.is_empty and geo_s.is_valid:
|
2019-10-06 04:14:10 +00:00
|
|
|
if self.app.defaults['gerber_simplification']:
|
|
|
|
poly_buffer.append(geo_s.simplify(s_tol))
|
|
|
|
else:
|
|
|
|
poly_buffer.append(geo_s)
|
2019-12-17 15:37:18 +00:00
|
|
|
|
2019-10-06 04:14:10 +00:00
|
|
|
if self.is_lpc is True:
|
|
|
|
geo_dict['clear'] = geo_s
|
|
|
|
else:
|
|
|
|
geo_dict['solid'] = geo_s
|
|
|
|
|
|
|
|
if last_path_aperture not in self.apertures:
|
2020-02-29 22:52:24 +00:00
|
|
|
self.apertures[last_path_aperture] = {}
|
2019-10-06 04:14:10 +00:00
|
|
|
if 'geometry' not in self.apertures[last_path_aperture]:
|
|
|
|
self.apertures[last_path_aperture]['geometry'] = []
|
|
|
|
self.apertures[last_path_aperture]['geometry'].append(deepcopy(geo_dict))
|
|
|
|
|
|
|
|
path = [path[-1]]
|
|
|
|
|
|
|
|
# --- Apply buffer ---
|
|
|
|
# If added for testing of bug #83
|
|
|
|
# TODO: Remove when bug fixed
|
2020-02-25 19:22:51 +00:00
|
|
|
try:
|
|
|
|
buff_length = len(poly_buffer)
|
|
|
|
except TypeError:
|
|
|
|
buff_length = 1
|
|
|
|
|
|
|
|
if buff_length > 0:
|
2019-10-06 04:14:10 +00:00
|
|
|
if current_polarity == 'D':
|
2020-07-02 14:15:13 +00:00
|
|
|
self.solid_geometry = self.solid_geometry.union(unary_union(poly_buffer))
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
else:
|
2020-07-02 14:15:13 +00:00
|
|
|
self.solid_geometry = self.solid_geometry.difference(unary_union(poly_buffer))
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
# follow_buffer = []
|
|
|
|
poly_buffer = []
|
|
|
|
|
|
|
|
current_polarity = new_polarity
|
|
|
|
continue
|
|
|
|
|
2019-12-26 01:15:17 +00:00
|
|
|
# ################################################################
|
|
|
|
# ##################### Number format ###########################
|
|
|
|
# ##################### Example: %FSLAX24Y24*% #################
|
|
|
|
# ################################################################
|
|
|
|
|
2019-10-06 04:14:10 +00:00
|
|
|
match = self.fmt_re.search(gline)
|
|
|
|
if match:
|
|
|
|
absolute = {'A': 'Absolute', 'I': 'Relative'}[match.group(2)]
|
|
|
|
if match.group(1) is not None:
|
|
|
|
self.gerber_zeros = match.group(1)
|
|
|
|
self.int_digits = int(match.group(3))
|
|
|
|
self.frac_digits = int(match.group(4))
|
|
|
|
log.debug("Gerber format found. (%s) " % str(gline))
|
|
|
|
|
|
|
|
log.debug(
|
|
|
|
"Gerber format found. Gerber zeros = %s (L-omit leading zeros, T-omit trailing zeros, "
|
|
|
|
"D-no zero supression)" % self.gerber_zeros)
|
|
|
|
log.debug("Gerber format found. Coordinates type = %s (Absolute or Relative)" % absolute)
|
|
|
|
continue
|
|
|
|
|
2019-12-26 01:15:17 +00:00
|
|
|
# ################################################################
|
|
|
|
# ######################## Mode (IN/MM) #######################
|
|
|
|
# ##################### Example: %MOIN*% #####################
|
|
|
|
# ################################################################
|
2019-10-06 04:14:10 +00:00
|
|
|
match = self.mode_re.search(gline)
|
|
|
|
if match:
|
2019-10-12 01:49:50 +00:00
|
|
|
self.units = match.group(1)
|
|
|
|
log.debug("Gerber units found = %s" % self.units)
|
2019-10-06 04:14:10 +00:00
|
|
|
# Changed for issue #80
|
2019-10-12 01:49:50 +00:00
|
|
|
# self.convert_units(match.group(1))
|
|
|
|
self.conversion_done = True
|
2019-10-06 04:14:10 +00:00
|
|
|
continue
|
|
|
|
|
2019-12-26 01:15:17 +00:00
|
|
|
# ################################################################
|
|
|
|
# Combined Number format and Mode --- Allegro does this ##########
|
|
|
|
# ################################################################
|
2019-10-06 04:14:10 +00:00
|
|
|
match = self.fmt_re_alt.search(gline)
|
|
|
|
if match:
|
|
|
|
absolute = {'A': 'Absolute', 'I': 'Relative'}[match.group(2)]
|
|
|
|
if match.group(1) is not None:
|
|
|
|
self.gerber_zeros = match.group(1)
|
|
|
|
self.int_digits = int(match.group(3))
|
|
|
|
self.frac_digits = int(match.group(4))
|
|
|
|
log.debug("Gerber format found. (%s) " % str(gline))
|
|
|
|
log.debug(
|
|
|
|
"Gerber format found. Gerber zeros = %s (L-omit leading zeros, T-omit trailing zeros, "
|
|
|
|
"D-no zero suppression)" % self.gerber_zeros)
|
|
|
|
log.debug("Gerber format found. Coordinates type = %s (Absolute or Relative)" % absolute)
|
|
|
|
|
2019-10-12 01:49:50 +00:00
|
|
|
self.units = match.group(5)
|
|
|
|
log.debug("Gerber units found = %s" % self.units)
|
2019-10-06 04:14:10 +00:00
|
|
|
# Changed for issue #80
|
2019-10-12 01:49:50 +00:00
|
|
|
# self.convert_units(match.group(5))
|
|
|
|
self.conversion_done = True
|
2019-10-06 04:14:10 +00:00
|
|
|
continue
|
|
|
|
|
2019-12-26 01:15:17 +00:00
|
|
|
# ################################################################
|
|
|
|
# #### Search for OrCAD way for having Number format ########
|
|
|
|
# ################################################################
|
2019-10-06 04:14:10 +00:00
|
|
|
match = self.fmt_re_orcad.search(gline)
|
|
|
|
if match:
|
|
|
|
if match.group(1) is not None:
|
|
|
|
if match.group(1) == 'G74':
|
|
|
|
quadrant_mode = 'SINGLE'
|
|
|
|
elif match.group(1) == 'G75':
|
|
|
|
quadrant_mode = 'MULTI'
|
|
|
|
absolute = {'A': 'Absolute', 'I': 'Relative'}[match.group(3)]
|
|
|
|
if match.group(2) is not None:
|
|
|
|
self.gerber_zeros = match.group(2)
|
|
|
|
|
|
|
|
self.int_digits = int(match.group(4))
|
|
|
|
self.frac_digits = int(match.group(5))
|
|
|
|
log.debug("Gerber format found. (%s) " % str(gline))
|
|
|
|
log.debug(
|
|
|
|
"Gerber format found. Gerber zeros = %s (L-omit leading zeros, T-omit trailing zeros, "
|
|
|
|
"D-no zerosuppressionn)" % self.gerber_zeros)
|
|
|
|
log.debug("Gerber format found. Coordinates type = %s (Absolute or Relative)" % absolute)
|
|
|
|
|
2019-10-12 01:49:50 +00:00
|
|
|
self.units = match.group(1)
|
|
|
|
log.debug("Gerber units found = %s" % self.units)
|
2019-10-06 04:14:10 +00:00
|
|
|
# Changed for issue #80
|
2019-10-12 01:49:50 +00:00
|
|
|
# self.convert_units(match.group(5))
|
|
|
|
self.conversion_done = True
|
2019-10-06 04:14:10 +00:00
|
|
|
continue
|
|
|
|
|
2019-12-26 01:15:17 +00:00
|
|
|
# ################################################################
|
|
|
|
# ############ Units (G70/1) OBSOLETE ######################
|
|
|
|
# ################################################################
|
2019-10-06 04:14:10 +00:00
|
|
|
match = self.units_re.search(gline)
|
|
|
|
if match:
|
|
|
|
obs_gerber_units = {'0': 'IN', '1': 'MM'}[match.group(1)]
|
2020-01-12 02:05:13 +00:00
|
|
|
self.units = obs_gerber_units
|
2019-10-06 04:14:10 +00:00
|
|
|
log.warning("Gerber obsolete units found = %s" % obs_gerber_units)
|
|
|
|
# Changed for issue #80
|
2019-10-12 01:49:50 +00:00
|
|
|
# self.convert_units({'0': 'IN', '1': 'MM'}[match.group(1)])
|
|
|
|
self.conversion_done = True
|
2019-10-06 04:14:10 +00:00
|
|
|
continue
|
|
|
|
|
2019-12-26 01:15:17 +00:00
|
|
|
# ################################################################
|
|
|
|
# ##### Absolute/relative coordinates G90/1 OBSOLETE ###########
|
|
|
|
# ################################################################
|
2019-10-06 04:14:10 +00:00
|
|
|
match = self.absrel_re.search(gline)
|
|
|
|
if match:
|
|
|
|
absolute = {'0': "Absolute", '1': "Relative"}[match.group(1)]
|
|
|
|
log.warning("Gerber obsolete coordinates type found = %s (Absolute or Relative) " % absolute)
|
|
|
|
continue
|
|
|
|
|
2019-12-26 01:15:17 +00:00
|
|
|
# ################################################################
|
|
|
|
# Aperture Macros ################################################
|
2019-10-06 04:14:10 +00:00
|
|
|
# Having this at the beginning will slow things down
|
|
|
|
# but macros can have complicated statements than could
|
|
|
|
# be caught by other patterns.
|
2019-12-26 01:15:17 +00:00
|
|
|
# ################################################################
|
2019-10-06 04:14:10 +00:00
|
|
|
if current_macro is None: # No macro started yet
|
|
|
|
match = self.am1_re.search(gline)
|
|
|
|
# Start macro if match, else not an AM, carry on.
|
|
|
|
if match:
|
|
|
|
log.debug("Starting macro. Line %d: %s" % (line_num, gline))
|
|
|
|
current_macro = match.group(1)
|
|
|
|
self.aperture_macros[current_macro] = ApertureMacro(name=current_macro)
|
|
|
|
if match.group(2): # Append
|
|
|
|
self.aperture_macros[current_macro].append(match.group(2))
|
|
|
|
if match.group(3): # Finish macro
|
|
|
|
# self.aperture_macros[current_macro].parse_content()
|
|
|
|
current_macro = None
|
|
|
|
log.debug("Macro complete in 1 line.")
|
|
|
|
continue
|
|
|
|
else: # Continue macro
|
|
|
|
log.debug("Continuing macro. Line %d." % line_num)
|
|
|
|
match = self.am2_re.search(gline)
|
|
|
|
if match: # Finish macro
|
|
|
|
log.debug("End of macro. Line %d." % line_num)
|
|
|
|
self.aperture_macros[current_macro].append(match.group(1))
|
|
|
|
# self.aperture_macros[current_macro].parse_content()
|
|
|
|
current_macro = None
|
|
|
|
else: # Append
|
|
|
|
self.aperture_macros[current_macro].append(gline)
|
|
|
|
continue
|
|
|
|
|
2019-12-26 01:15:17 +00:00
|
|
|
# ################################################################
|
|
|
|
# ############## Aperture definitions %ADD... #################
|
|
|
|
# ################################################################
|
2019-10-06 04:14:10 +00:00
|
|
|
match = self.ad_re.search(gline)
|
|
|
|
if match:
|
|
|
|
# log.info("Found aperture definition. Line %d: %s" % (line_num, gline))
|
|
|
|
self.aperture_parse(match.group(1), match.group(2), match.group(3))
|
|
|
|
continue
|
|
|
|
|
2019-12-26 01:15:17 +00:00
|
|
|
# ################################################################
|
|
|
|
# ################ Operation code alone #########################
|
|
|
|
# ########### Operation code alone, usually just D03 (Flash) ###
|
2019-10-06 04:14:10 +00:00
|
|
|
# self.opcode_re = re.compile(r'^D0?([123])\*$')
|
2019-12-26 01:15:17 +00:00
|
|
|
# ################################################################
|
2019-10-06 04:14:10 +00:00
|
|
|
match = self.opcode_re.search(gline)
|
|
|
|
if match:
|
|
|
|
current_operation_code = int(match.group(1))
|
|
|
|
current_d = current_operation_code
|
|
|
|
|
|
|
|
if current_operation_code == 3:
|
|
|
|
|
|
|
|
# --- Buffered ---
|
|
|
|
try:
|
2019-10-08 01:17:08 +00:00
|
|
|
# log.debug("Bare op-code %d." % current_operation_code)
|
2020-02-29 22:52:24 +00:00
|
|
|
geo_dict = {}
|
2019-10-06 04:14:10 +00:00
|
|
|
flash = self.create_flash_geometry(
|
|
|
|
Point(current_x, current_y), self.apertures[current_aperture],
|
|
|
|
self.steps_per_circle)
|
|
|
|
|
|
|
|
geo_dict['follow'] = Point([current_x, current_y])
|
|
|
|
|
|
|
|
if not flash.is_empty:
|
|
|
|
if self.app.defaults['gerber_simplification']:
|
|
|
|
poly_buffer.append(flash.simplify(s_tol))
|
|
|
|
else:
|
|
|
|
poly_buffer.append(flash)
|
|
|
|
if self.is_lpc is True:
|
|
|
|
geo_dict['clear'] = flash
|
|
|
|
else:
|
|
|
|
geo_dict['solid'] = flash
|
|
|
|
|
|
|
|
if current_aperture not in self.apertures:
|
2020-02-29 22:52:24 +00:00
|
|
|
self.apertures[current_aperture] = {}
|
2019-10-06 04:14:10 +00:00
|
|
|
if 'geometry' not in self.apertures[current_aperture]:
|
|
|
|
self.apertures[current_aperture]['geometry'] = []
|
|
|
|
self.apertures[current_aperture]['geometry'].append(deepcopy(geo_dict))
|
|
|
|
|
|
|
|
except IndexError:
|
|
|
|
log.warning("Line %d: %s -> Nothing there to flash!" % (line_num, gline))
|
|
|
|
|
|
|
|
continue
|
|
|
|
|
2019-12-26 01:15:17 +00:00
|
|
|
# ################################################################
|
|
|
|
# ################ Tool/aperture change ########################
|
|
|
|
# ################ Example: D12* ########################
|
|
|
|
# ################################################################
|
2019-10-06 04:14:10 +00:00
|
|
|
match = self.tool_re.search(gline)
|
|
|
|
if match:
|
|
|
|
current_aperture = match.group(1)
|
|
|
|
# log.debug("Line %d: Aperture change to (%s)" % (line_num, current_aperture))
|
|
|
|
|
|
|
|
# If the aperture value is zero then make it something quite small but with a non-zero value
|
|
|
|
# so it can be processed by FlatCAM.
|
|
|
|
# But first test to see if the aperture type is "aperture macro". In that case
|
|
|
|
# we should not test for "size" key as it does not exist in this case.
|
2020-04-01 15:45:20 +00:00
|
|
|
if self.apertures[current_aperture]["type"] != "AM":
|
2019-10-06 04:14:10 +00:00
|
|
|
if self.apertures[current_aperture]["size"] == 0:
|
|
|
|
self.apertures[current_aperture]["size"] = 1e-12
|
|
|
|
# log.debug(self.apertures[current_aperture])
|
|
|
|
|
|
|
|
# Take care of the current path with the previous tool
|
2020-02-25 19:22:51 +00:00
|
|
|
try:
|
|
|
|
path_length = len(path)
|
|
|
|
except TypeError:
|
|
|
|
path_length = 1
|
|
|
|
|
|
|
|
if path_length > 1:
|
2019-10-06 04:14:10 +00:00
|
|
|
if self.apertures[last_path_aperture]["type"] == 'R':
|
|
|
|
# do nothing because 'R' type moving aperture is none at once
|
|
|
|
pass
|
|
|
|
else:
|
2020-02-29 22:52:24 +00:00
|
|
|
geo_dict = {}
|
2019-10-06 04:14:10 +00:00
|
|
|
geo_f = LineString(path)
|
|
|
|
if not geo_f.is_empty:
|
|
|
|
follow_buffer.append(geo_f)
|
|
|
|
geo_dict['follow'] = geo_f
|
|
|
|
|
|
|
|
# --- Buffered ----
|
|
|
|
width = self.apertures[last_path_aperture]["size"]
|
|
|
|
geo_s = LineString(path).buffer(width / 1.999, int(self.steps_per_circle / 4))
|
|
|
|
if not geo_s.is_empty:
|
|
|
|
if self.app.defaults['gerber_simplification']:
|
|
|
|
poly_buffer.append(geo_s.simplify(s_tol))
|
|
|
|
else:
|
|
|
|
poly_buffer.append(geo_s)
|
|
|
|
if self.is_lpc is True:
|
|
|
|
geo_dict['clear'] = geo_s
|
|
|
|
else:
|
|
|
|
geo_dict['solid'] = geo_s
|
|
|
|
|
|
|
|
if last_path_aperture not in self.apertures:
|
2020-02-29 22:52:24 +00:00
|
|
|
self.apertures[last_path_aperture] = {}
|
2019-10-06 04:14:10 +00:00
|
|
|
if 'geometry' not in self.apertures[last_path_aperture]:
|
|
|
|
self.apertures[last_path_aperture]['geometry'] = []
|
|
|
|
self.apertures[last_path_aperture]['geometry'].append(deepcopy(geo_dict))
|
|
|
|
|
|
|
|
path = [path[-1]]
|
|
|
|
continue
|
|
|
|
|
2019-12-26 01:15:17 +00:00
|
|
|
# ################################################################
|
|
|
|
# ################ G36* - Begin region ########################
|
|
|
|
# ################################################################
|
2019-10-06 04:14:10 +00:00
|
|
|
if self.regionon_re.search(gline):
|
2020-02-25 19:22:51 +00:00
|
|
|
try:
|
|
|
|
path_length = len(path)
|
|
|
|
except TypeError:
|
|
|
|
path_length = 1
|
|
|
|
|
|
|
|
if path_length > 1:
|
2019-10-06 04:14:10 +00:00
|
|
|
# Take care of what is left in the path
|
|
|
|
|
2020-02-29 22:52:24 +00:00
|
|
|
geo_dict = {}
|
2019-10-06 04:14:10 +00:00
|
|
|
geo_f = LineString(path)
|
|
|
|
if not geo_f.is_empty:
|
|
|
|
follow_buffer.append(geo_f)
|
|
|
|
geo_dict['follow'] = geo_f
|
|
|
|
|
|
|
|
# --- Buffered ----
|
|
|
|
width = self.apertures[last_path_aperture]["size"]
|
|
|
|
geo_s = LineString(path).buffer(width / 1.999, int(self.steps_per_circle / 4))
|
|
|
|
if not geo_s.is_empty:
|
|
|
|
if self.app.defaults['gerber_simplification']:
|
|
|
|
poly_buffer.append(geo_s.simplify(s_tol))
|
|
|
|
else:
|
|
|
|
poly_buffer.append(geo_s)
|
|
|
|
if self.is_lpc is True:
|
|
|
|
geo_dict['clear'] = geo_s
|
|
|
|
else:
|
|
|
|
geo_dict['solid'] = geo_s
|
|
|
|
|
|
|
|
if last_path_aperture not in self.apertures:
|
2020-02-29 22:52:24 +00:00
|
|
|
self.apertures[last_path_aperture] = {}
|
2019-10-06 04:14:10 +00:00
|
|
|
if 'geometry' not in self.apertures[last_path_aperture]:
|
|
|
|
self.apertures[last_path_aperture]['geometry'] = []
|
|
|
|
self.apertures[last_path_aperture]['geometry'].append(deepcopy(geo_dict))
|
|
|
|
|
|
|
|
path = [path[-1]]
|
|
|
|
|
|
|
|
making_region = True
|
|
|
|
continue
|
|
|
|
|
2019-12-26 01:15:17 +00:00
|
|
|
# ################################################################
|
|
|
|
# ################ G37* - End region ########################
|
|
|
|
# ################################################################
|
2019-10-06 04:14:10 +00:00
|
|
|
if self.regionoff_re.search(gline):
|
|
|
|
making_region = False
|
|
|
|
|
|
|
|
if '0' not in self.apertures:
|
|
|
|
self.apertures['0'] = {}
|
|
|
|
self.apertures['0']['type'] = 'REG'
|
|
|
|
self.apertures['0']['size'] = 0.0
|
2020-02-29 22:52:24 +00:00
|
|
|
self.apertures['0']['geometry'] = []
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
# if D02 happened before G37 we now have a path with 1 element only; we have to add the current
|
|
|
|
# geo to the poly_buffer otherwise we loose it
|
|
|
|
if current_operation_code == 2:
|
2020-02-25 19:22:51 +00:00
|
|
|
try:
|
|
|
|
path_length = len(path)
|
|
|
|
except TypeError:
|
|
|
|
path_length = 1
|
|
|
|
|
|
|
|
if path_length == 1:
|
2019-10-06 04:14:10 +00:00
|
|
|
# this means that the geometry was prepared previously and we just need to add it
|
2020-02-29 22:52:24 +00:00
|
|
|
geo_dict = {}
|
2019-10-06 04:14:10 +00:00
|
|
|
if geo_f:
|
|
|
|
if not geo_f.is_empty:
|
|
|
|
follow_buffer.append(geo_f)
|
|
|
|
geo_dict['follow'] = geo_f
|
|
|
|
if geo_s:
|
|
|
|
if not geo_s.is_empty:
|
|
|
|
if self.app.defaults['gerber_simplification']:
|
|
|
|
poly_buffer.append(geo_s.simplify(s_tol))
|
|
|
|
else:
|
|
|
|
poly_buffer.append(geo_s)
|
|
|
|
if self.is_lpc is True:
|
|
|
|
geo_dict['clear'] = geo_s
|
|
|
|
else:
|
|
|
|
geo_dict['solid'] = geo_s
|
|
|
|
|
|
|
|
if geo_s or geo_f:
|
|
|
|
self.apertures['0']['geometry'].append(deepcopy(geo_dict))
|
|
|
|
|
|
|
|
path = [[current_x, current_y]] # Start new path
|
|
|
|
|
|
|
|
# Only one path defines region?
|
|
|
|
# This can happen if D02 happened before G37 and
|
|
|
|
# is not and error.
|
2020-02-25 19:22:51 +00:00
|
|
|
try:
|
|
|
|
path_length = len(path)
|
|
|
|
except TypeError:
|
|
|
|
path_length = 1
|
|
|
|
|
|
|
|
if path_length < 3:
|
2019-10-06 04:14:10 +00:00
|
|
|
# print "ERROR: Path contains less than 3 points:"
|
|
|
|
# path = [[current_x, current_y]]
|
|
|
|
continue
|
|
|
|
|
|
|
|
# For regions we may ignore an aperture that is None
|
|
|
|
|
|
|
|
# --- Buffered ---
|
2020-02-29 22:52:24 +00:00
|
|
|
geo_dict = {}
|
2019-12-26 01:15:17 +00:00
|
|
|
if current_aperture in self.apertures:
|
2020-01-13 23:36:37 +00:00
|
|
|
# the following line breaks loading of Circuit Studio Gerber files
|
|
|
|
# buff_value = float(self.apertures[current_aperture]['size']) / 2.0
|
2019-12-26 02:42:48 +00:00
|
|
|
# region_geo = Polygon(path).buffer(buff_value, int(self.steps_per_circle))
|
|
|
|
region_geo = Polygon(path) # Sprint Layout Gerbers with ground fill are crashed with above
|
2019-12-26 01:15:17 +00:00
|
|
|
else:
|
|
|
|
region_geo = Polygon(path)
|
|
|
|
|
|
|
|
region_f = region_geo.exterior
|
2019-10-06 04:14:10 +00:00
|
|
|
if not region_f.is_empty:
|
|
|
|
follow_buffer.append(region_f)
|
|
|
|
geo_dict['follow'] = region_f
|
|
|
|
|
2019-12-26 01:15:17 +00:00
|
|
|
region_s = region_geo
|
2019-10-06 04:14:10 +00:00
|
|
|
if not region_s.is_valid:
|
2019-12-26 01:15:17 +00:00
|
|
|
region_s = region_s.buffer(0, int(self.steps_per_circle))
|
2019-10-06 04:14:10 +00:00
|
|
|
if not region_s.is_empty:
|
|
|
|
if self.app.defaults['gerber_simplification']:
|
|
|
|
poly_buffer.append(region_s.simplify(s_tol))
|
|
|
|
else:
|
|
|
|
poly_buffer.append(region_s)
|
2019-12-26 01:15:17 +00:00
|
|
|
|
2019-10-06 04:14:10 +00:00
|
|
|
if self.is_lpc is True:
|
|
|
|
geo_dict['clear'] = region_s
|
|
|
|
else:
|
|
|
|
geo_dict['solid'] = region_s
|
|
|
|
|
|
|
|
if not region_s.is_empty or not region_f.is_empty:
|
|
|
|
self.apertures['0']['geometry'].append(deepcopy(geo_dict))
|
|
|
|
|
|
|
|
path = [[current_x, current_y]] # Start new path
|
|
|
|
continue
|
|
|
|
|
2019-12-26 01:15:17 +00:00
|
|
|
# ################################################################
|
|
|
|
# ################ G01/2/3* - Interpolation mode change #########
|
|
|
|
# #### Can occur along with coordinates and operation code but ##
|
|
|
|
# #### sometimes by itself (handled here). #####################
|
|
|
|
# #### Example: G01* #####################
|
|
|
|
# ################################################################
|
2019-10-06 04:14:10 +00:00
|
|
|
match = self.interp_re.search(gline)
|
|
|
|
if match:
|
|
|
|
current_interpolation_mode = int(match.group(1))
|
|
|
|
continue
|
|
|
|
|
2019-12-26 01:15:17 +00:00
|
|
|
# ################################################################
|
|
|
|
# ######### G01 - Linear interpolation plus flashes #############
|
|
|
|
# ######### Operation code (D0x) missing is deprecated #########
|
2019-10-06 04:14:10 +00:00
|
|
|
# REGEX: r'^(?:G0?(1))?(?:X(-?\d+))?(?:Y(-?\d+))?(?:D0([123]))?\*$'
|
2019-12-26 01:15:17 +00:00
|
|
|
# ################################################################
|
2019-10-06 04:14:10 +00:00
|
|
|
match = self.lin_re.search(gline)
|
|
|
|
if match:
|
|
|
|
# Dxx alone?
|
|
|
|
# if match.group(1) is None and match.group(2) is None and match.group(3) is None:
|
|
|
|
# try:
|
|
|
|
# current_operation_code = int(match.group(4))
|
2019-11-11 00:35:42 +00:00
|
|
|
# except Exception:
|
2019-10-06 04:14:10 +00:00
|
|
|
# pass # A line with just * will match too.
|
|
|
|
# continue
|
|
|
|
# NOTE: Letting it continue allows it to react to the
|
|
|
|
# operation code.
|
|
|
|
|
|
|
|
# Parse coordinates
|
|
|
|
if match.group(2) is not None:
|
|
|
|
linear_x = parse_gerber_number(match.group(2),
|
|
|
|
self.int_digits, self.frac_digits, self.gerber_zeros)
|
|
|
|
current_x = linear_x
|
|
|
|
else:
|
|
|
|
linear_x = current_x
|
|
|
|
if match.group(3) is not None:
|
|
|
|
linear_y = parse_gerber_number(match.group(3),
|
|
|
|
self.int_digits, self.frac_digits, self.gerber_zeros)
|
|
|
|
current_y = linear_y
|
|
|
|
else:
|
|
|
|
linear_y = current_y
|
|
|
|
|
|
|
|
# Parse operation code
|
|
|
|
if match.group(4) is not None:
|
|
|
|
current_operation_code = int(match.group(4))
|
|
|
|
|
|
|
|
# Pen down: add segment
|
|
|
|
if current_operation_code == 1:
|
|
|
|
# if linear_x or linear_y are None, ignore those
|
|
|
|
if current_x is not None and current_y is not None:
|
|
|
|
# only add the point if it's a new one otherwise skip it (harder to process)
|
|
|
|
if path[-1] != [current_x, current_y]:
|
|
|
|
path.append([current_x, current_y])
|
2020-07-27 00:25:38 +00:00
|
|
|
elif len(path) == 1:
|
|
|
|
# it's a flash that is done by moving with pen up D2 and then just a pen down D1
|
|
|
|
# Reset path starting point
|
|
|
|
path = [[current_x, current_y]]
|
|
|
|
|
|
|
|
# --- BUFFERED ---
|
|
|
|
# Draw the flash
|
|
|
|
# this treats the case when we are storing geometry as paths
|
|
|
|
geo_dict = {}
|
|
|
|
geo_flash = Point([current_x, current_y])
|
|
|
|
follow_buffer.append(geo_flash)
|
|
|
|
geo_dict['follow'] = geo_flash
|
|
|
|
|
|
|
|
# this treats the case when we are storing geometry as solids
|
|
|
|
flash = self.create_flash_geometry(
|
|
|
|
Point([current_x, current_y]),
|
|
|
|
self.apertures[current_aperture],
|
|
|
|
self.steps_per_circle
|
|
|
|
)
|
|
|
|
if not flash.is_empty:
|
|
|
|
if self.app.defaults['gerber_simplification']:
|
|
|
|
poly_buffer.append(flash.simplify(s_tol))
|
|
|
|
else:
|
|
|
|
poly_buffer.append(flash)
|
|
|
|
|
|
|
|
if self.is_lpc is True:
|
|
|
|
geo_dict['clear'] = flash
|
|
|
|
else:
|
|
|
|
geo_dict['solid'] = flash
|
|
|
|
|
|
|
|
if current_aperture not in self.apertures:
|
|
|
|
self.apertures[current_aperture] = {}
|
|
|
|
if 'geometry' not in self.apertures[current_aperture]:
|
|
|
|
self.apertures[current_aperture]['geometry'] = []
|
|
|
|
self.apertures[current_aperture]['geometry'].append(deepcopy(geo_dict))
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
if making_region is False:
|
|
|
|
# if the aperture is rectangle then add a rectangular shape having as parameters the
|
|
|
|
# coordinates of the start and end point and also the width and height
|
|
|
|
# of the 'R' aperture
|
|
|
|
try:
|
|
|
|
if self.apertures[current_aperture]["type"] == 'R':
|
|
|
|
width = self.apertures[current_aperture]['width']
|
|
|
|
height = self.apertures[current_aperture]['height']
|
|
|
|
minx = min(path[0][0], path[1][0]) - width / 2
|
|
|
|
maxx = max(path[0][0], path[1][0]) + width / 2
|
|
|
|
miny = min(path[0][1], path[1][1]) - height / 2
|
|
|
|
maxy = max(path[0][1], path[1][1]) + height / 2
|
|
|
|
log.debug("Coords: %s - %s - %s - %s" % (minx, miny, maxx, maxy))
|
|
|
|
|
2020-02-29 22:52:24 +00:00
|
|
|
geo_dict = {}
|
2019-10-06 04:14:10 +00:00
|
|
|
geo_f = Point([current_x, current_y])
|
|
|
|
follow_buffer.append(geo_f)
|
|
|
|
geo_dict['follow'] = geo_f
|
|
|
|
|
|
|
|
geo_s = shply_box(minx, miny, maxx, maxy)
|
|
|
|
if self.app.defaults['gerber_simplification']:
|
|
|
|
poly_buffer.append(geo_s.simplify(s_tol))
|
|
|
|
else:
|
|
|
|
poly_buffer.append(geo_s)
|
|
|
|
|
|
|
|
if self.is_lpc is True:
|
|
|
|
geo_dict['clear'] = geo_s
|
|
|
|
else:
|
|
|
|
geo_dict['solid'] = geo_s
|
|
|
|
|
|
|
|
if current_aperture not in self.apertures:
|
2020-02-29 22:52:24 +00:00
|
|
|
self.apertures[current_aperture] = {}
|
2019-10-06 04:14:10 +00:00
|
|
|
if 'geometry' not in self.apertures[current_aperture]:
|
|
|
|
self.apertures[current_aperture]['geometry'] = []
|
|
|
|
self.apertures[current_aperture]['geometry'].append(deepcopy(geo_dict))
|
2020-04-27 07:03:22 +00:00
|
|
|
except Exception:
|
2019-10-06 04:14:10 +00:00
|
|
|
pass
|
|
|
|
last_path_aperture = current_aperture
|
|
|
|
# we do this for the case that a region is done without having defined any aperture
|
|
|
|
if last_path_aperture is None:
|
|
|
|
if '0' not in self.apertures:
|
|
|
|
self.apertures['0'] = {}
|
|
|
|
self.apertures['0']['type'] = 'REG'
|
|
|
|
self.apertures['0']['size'] = 0.0
|
|
|
|
self.apertures['0']['geometry'] = []
|
|
|
|
last_path_aperture = '0'
|
|
|
|
else:
|
|
|
|
self.app.inform.emit('[WARNING] %s: %s' %
|
|
|
|
(_("Coordinates missing, line ignored"), str(gline)))
|
|
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' %
|
|
|
|
_("GERBER file might be CORRUPT. Check the file !!!"))
|
|
|
|
|
|
|
|
elif current_operation_code == 2:
|
2020-02-25 19:22:51 +00:00
|
|
|
try:
|
|
|
|
path_length = len(path)
|
|
|
|
except TypeError:
|
|
|
|
path_length = 1
|
|
|
|
|
|
|
|
if path_length > 1:
|
2019-10-06 04:14:10 +00:00
|
|
|
geo_s = None
|
|
|
|
|
2020-02-29 22:52:24 +00:00
|
|
|
geo_dict = {}
|
2019-10-06 04:14:10 +00:00
|
|
|
# --- BUFFERED ---
|
|
|
|
# this treats the case when we are storing geometry as paths only
|
|
|
|
if making_region:
|
|
|
|
# we do this for the case that a region is done without having defined any aperture
|
|
|
|
if last_path_aperture is None:
|
|
|
|
if '0' not in self.apertures:
|
|
|
|
self.apertures['0'] = {}
|
|
|
|
self.apertures['0']['type'] = 'REG'
|
|
|
|
self.apertures['0']['size'] = 0.0
|
|
|
|
self.apertures['0']['geometry'] = []
|
|
|
|
last_path_aperture = '0'
|
|
|
|
geo_f = Polygon()
|
|
|
|
else:
|
|
|
|
geo_f = LineString(path)
|
|
|
|
|
|
|
|
try:
|
|
|
|
if self.apertures[last_path_aperture]["type"] != 'R':
|
|
|
|
if not geo_f.is_empty:
|
|
|
|
follow_buffer.append(geo_f)
|
|
|
|
geo_dict['follow'] = geo_f
|
|
|
|
except Exception as e:
|
|
|
|
log.debug("camlib.Gerber.parse_lines() --> %s" % str(e))
|
|
|
|
if not geo_f.is_empty:
|
|
|
|
follow_buffer.append(geo_f)
|
|
|
|
geo_dict['follow'] = geo_f
|
|
|
|
|
|
|
|
# this treats the case when we are storing geometry as solids
|
|
|
|
if making_region:
|
|
|
|
# we do this for the case that a region is done without having defined any aperture
|
|
|
|
if last_path_aperture is None:
|
|
|
|
if '0' not in self.apertures:
|
|
|
|
self.apertures['0'] = {}
|
|
|
|
self.apertures['0']['type'] = 'REG'
|
|
|
|
self.apertures['0']['size'] = 0.0
|
|
|
|
self.apertures['0']['geometry'] = []
|
|
|
|
last_path_aperture = '0'
|
|
|
|
|
|
|
|
try:
|
|
|
|
geo_s = Polygon(path)
|
|
|
|
except ValueError:
|
|
|
|
log.warning("Problem %s %s" % (gline, line_num))
|
|
|
|
self.app.inform.emit('[ERROR] %s: %s' %
|
|
|
|
(_("Region does not have enough points. "
|
|
|
|
"File will be processed but there are parser errors. "
|
|
|
|
"Line number"), str(line_num)))
|
|
|
|
else:
|
|
|
|
if last_path_aperture is None:
|
|
|
|
log.warning("No aperture defined for curent path. (%d)" % line_num)
|
|
|
|
width = self.apertures[last_path_aperture]["size"] # TODO: WARNING this should fail!
|
|
|
|
geo_s = LineString(path).buffer(width / 1.999, int(self.steps_per_circle / 4))
|
|
|
|
|
|
|
|
try:
|
|
|
|
if self.apertures[last_path_aperture]["type"] != 'R':
|
|
|
|
if not geo_s.is_empty:
|
|
|
|
if self.app.defaults['gerber_simplification']:
|
|
|
|
poly_buffer.append(geo_s.simplify(s_tol))
|
|
|
|
else:
|
|
|
|
poly_buffer.append(geo_s)
|
|
|
|
|
|
|
|
if self.is_lpc is True:
|
|
|
|
geo_dict['clear'] = geo_s
|
|
|
|
else:
|
|
|
|
geo_dict['solid'] = geo_s
|
|
|
|
except Exception as e:
|
|
|
|
log.debug("camlib.Gerber.parse_lines() --> %s" % str(e))
|
|
|
|
if self.app.defaults['gerber_simplification']:
|
|
|
|
poly_buffer.append(geo_s.simplify(s_tol))
|
|
|
|
else:
|
|
|
|
poly_buffer.append(geo_s)
|
|
|
|
|
|
|
|
if self.is_lpc is True:
|
|
|
|
geo_dict['clear'] = geo_s
|
|
|
|
else:
|
|
|
|
geo_dict['solid'] = geo_s
|
|
|
|
|
|
|
|
if last_path_aperture not in self.apertures:
|
2020-02-29 22:52:24 +00:00
|
|
|
self.apertures[last_path_aperture] = {}
|
2019-10-06 04:14:10 +00:00
|
|
|
if 'geometry' not in self.apertures[last_path_aperture]:
|
|
|
|
self.apertures[last_path_aperture]['geometry'] = []
|
|
|
|
self.apertures[last_path_aperture]['geometry'].append(deepcopy(geo_dict))
|
|
|
|
|
|
|
|
# if linear_x or linear_y are None, ignore those
|
|
|
|
if linear_x is not None and linear_y is not None:
|
|
|
|
path = [[linear_x, linear_y]] # Start new path
|
|
|
|
else:
|
|
|
|
self.app.inform.emit('[WARNING] %s: %s' %
|
|
|
|
(_("Coordinates missing, line ignored"), str(gline)))
|
|
|
|
self.app.inform.emit('[WARNING_NOTCL] %s' %
|
|
|
|
_("GERBER file might be CORRUPT. Check the file !!!"))
|
|
|
|
|
|
|
|
# Flash
|
|
|
|
# Not allowed in region mode.
|
|
|
|
elif current_operation_code == 3:
|
|
|
|
|
|
|
|
# Create path draw so far.
|
2020-02-25 19:22:51 +00:00
|
|
|
try:
|
|
|
|
path_length = len(path)
|
|
|
|
except TypeError:
|
|
|
|
path_length = 1
|
|
|
|
|
|
|
|
if path_length > 1:
|
2019-10-06 04:14:10 +00:00
|
|
|
# --- Buffered ----
|
2020-02-29 22:52:24 +00:00
|
|
|
geo_dict = {}
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
# this treats the case when we are storing geometry as paths
|
|
|
|
geo_f = LineString(path)
|
|
|
|
if not geo_f.is_empty:
|
|
|
|
try:
|
|
|
|
if self.apertures[last_path_aperture]["type"] != 'R':
|
|
|
|
follow_buffer.append(geo_f)
|
|
|
|
geo_dict['follow'] = geo_f
|
|
|
|
except Exception as e:
|
|
|
|
log.debug("camlib.Gerber.parse_lines() --> G01 match D03 --> %s" % str(e))
|
|
|
|
follow_buffer.append(geo_f)
|
|
|
|
geo_dict['follow'] = geo_f
|
|
|
|
|
|
|
|
# this treats the case when we are storing geometry as solids
|
|
|
|
width = self.apertures[last_path_aperture]["size"]
|
|
|
|
geo_s = LineString(path).buffer(width / 1.999, int(self.steps_per_circle / 4))
|
|
|
|
if not geo_s.is_empty:
|
|
|
|
try:
|
|
|
|
if self.apertures[last_path_aperture]["type"] != 'R':
|
|
|
|
if self.app.defaults['gerber_simplification']:
|
|
|
|
poly_buffer.append(geo_s.simplify(s_tol))
|
|
|
|
else:
|
|
|
|
poly_buffer.append(geo_s)
|
|
|
|
|
|
|
|
if self.is_lpc is True:
|
|
|
|
geo_dict['clear'] = geo_s
|
|
|
|
else:
|
|
|
|
geo_dict['solid'] = geo_s
|
2019-11-11 00:35:42 +00:00
|
|
|
except Exception:
|
2019-10-06 04:14:10 +00:00
|
|
|
if self.app.defaults['gerber_simplification']:
|
|
|
|
poly_buffer.append(geo_s.simplify(s_tol))
|
|
|
|
else:
|
|
|
|
poly_buffer.append(geo_s)
|
|
|
|
|
|
|
|
if self.is_lpc is True:
|
|
|
|
geo_dict['clear'] = geo_s
|
|
|
|
else:
|
|
|
|
geo_dict['solid'] = geo_s
|
|
|
|
|
|
|
|
if last_path_aperture not in self.apertures:
|
2020-02-29 22:52:24 +00:00
|
|
|
self.apertures[last_path_aperture] = {}
|
2019-10-06 04:14:10 +00:00
|
|
|
if 'geometry' not in self.apertures[last_path_aperture]:
|
|
|
|
self.apertures[last_path_aperture]['geometry'] = []
|
|
|
|
self.apertures[last_path_aperture]['geometry'].append(deepcopy(geo_dict))
|
|
|
|
|
|
|
|
# Reset path starting point
|
|
|
|
path = [[linear_x, linear_y]]
|
|
|
|
|
|
|
|
# --- BUFFERED ---
|
|
|
|
# Draw the flash
|
|
|
|
# this treats the case when we are storing geometry as paths
|
2020-02-29 22:52:24 +00:00
|
|
|
geo_dict = {}
|
2019-10-06 04:14:10 +00:00
|
|
|
geo_flash = Point([linear_x, linear_y])
|
|
|
|
follow_buffer.append(geo_flash)
|
|
|
|
geo_dict['follow'] = geo_flash
|
|
|
|
|
|
|
|
# this treats the case when we are storing geometry as solids
|
|
|
|
flash = self.create_flash_geometry(
|
|
|
|
Point([linear_x, linear_y]),
|
|
|
|
self.apertures[current_aperture],
|
|
|
|
self.steps_per_circle
|
|
|
|
)
|
|
|
|
if not flash.is_empty:
|
|
|
|
if self.app.defaults['gerber_simplification']:
|
|
|
|
poly_buffer.append(flash.simplify(s_tol))
|
|
|
|
else:
|
|
|
|
poly_buffer.append(flash)
|
|
|
|
|
|
|
|
if self.is_lpc is True:
|
|
|
|
geo_dict['clear'] = flash
|
|
|
|
else:
|
|
|
|
geo_dict['solid'] = flash
|
|
|
|
|
|
|
|
if current_aperture not in self.apertures:
|
2020-02-29 22:52:24 +00:00
|
|
|
self.apertures[current_aperture] = {}
|
2019-10-06 04:14:10 +00:00
|
|
|
if 'geometry' not in self.apertures[current_aperture]:
|
|
|
|
self.apertures[current_aperture]['geometry'] = []
|
|
|
|
self.apertures[current_aperture]['geometry'].append(deepcopy(geo_dict))
|
|
|
|
|
|
|
|
# maybe those lines are not exactly needed but it is easier to read the program as those coordinates
|
|
|
|
# are used in case that circular interpolation is encountered within the Gerber file
|
|
|
|
current_x = linear_x
|
|
|
|
current_y = linear_y
|
|
|
|
|
|
|
|
# log.debug("Line_number=%3s X=%s Y=%s (%s)" % (line_num, linear_x, linear_y, gline))
|
|
|
|
continue
|
|
|
|
|
2019-12-26 01:15:17 +00:00
|
|
|
# ################################################################
|
|
|
|
# ######### G74/75* - Single or multiple quadrant arcs ##########
|
|
|
|
# ################################################################
|
2019-10-06 04:14:10 +00:00
|
|
|
match = self.quad_re.search(gline)
|
|
|
|
if match:
|
|
|
|
if match.group(1) == '4':
|
|
|
|
quadrant_mode = 'SINGLE'
|
|
|
|
else:
|
|
|
|
quadrant_mode = 'MULTI'
|
|
|
|
continue
|
|
|
|
|
2019-12-26 01:15:17 +00:00
|
|
|
# ################################################################
|
|
|
|
# ######### G02/3 - Circular interpolation #####################
|
|
|
|
# ######### 2-clockwise, 3-counterclockwise #####################
|
|
|
|
# ######### Ex. format: G03 X0 Y50 I-50 J0 where the #########
|
|
|
|
# ######### X, Y coords are the coords of the End Point #########
|
|
|
|
# ################################################################
|
2019-10-06 04:14:10 +00:00
|
|
|
match = self.circ_re.search(gline)
|
|
|
|
if match:
|
|
|
|
arcdir = [None, None, "cw", "ccw"]
|
|
|
|
|
|
|
|
mode, circular_x, circular_y, i, j, d = match.groups()
|
|
|
|
|
|
|
|
try:
|
|
|
|
circular_x = parse_gerber_number(circular_x,
|
|
|
|
self.int_digits, self.frac_digits, self.gerber_zeros)
|
2020-04-27 07:03:22 +00:00
|
|
|
except Exception:
|
2019-10-06 04:14:10 +00:00
|
|
|
circular_x = current_x
|
|
|
|
|
|
|
|
try:
|
|
|
|
circular_y = parse_gerber_number(circular_y,
|
|
|
|
self.int_digits, self.frac_digits, self.gerber_zeros)
|
2020-04-27 07:03:22 +00:00
|
|
|
except Exception:
|
2019-10-06 04:14:10 +00:00
|
|
|
circular_y = current_y
|
|
|
|
|
|
|
|
# According to Gerber specification i and j are not modal, which means that when i or j are missing,
|
|
|
|
# they are to be interpreted as being zero
|
|
|
|
try:
|
|
|
|
i = parse_gerber_number(i, self.int_digits, self.frac_digits, self.gerber_zeros)
|
2020-04-27 07:03:22 +00:00
|
|
|
except Exception:
|
2019-10-06 04:14:10 +00:00
|
|
|
i = 0
|
|
|
|
|
|
|
|
try:
|
|
|
|
j = parse_gerber_number(j, self.int_digits, self.frac_digits, self.gerber_zeros)
|
2020-04-27 07:03:22 +00:00
|
|
|
except Exception:
|
2019-10-06 04:14:10 +00:00
|
|
|
j = 0
|
|
|
|
|
|
|
|
if quadrant_mode is None:
|
|
|
|
log.error("Found arc without preceding quadrant specification G74 or G75. (%d)" % line_num)
|
|
|
|
log.error(gline)
|
|
|
|
continue
|
|
|
|
|
|
|
|
if mode is None and current_interpolation_mode not in [2, 3]:
|
|
|
|
log.error("Found arc without circular interpolation mode defined. (%d)" % line_num)
|
|
|
|
log.error(gline)
|
|
|
|
continue
|
|
|
|
elif mode is not None:
|
|
|
|
current_interpolation_mode = int(mode)
|
|
|
|
|
|
|
|
# Set operation code if provided
|
|
|
|
if d is not None:
|
|
|
|
current_operation_code = int(d)
|
|
|
|
|
|
|
|
# Nothing created! Pen Up.
|
|
|
|
if current_operation_code == 2:
|
|
|
|
log.warning("Arc with D2. (%d)" % line_num)
|
2020-02-25 19:22:51 +00:00
|
|
|
try:
|
|
|
|
path_length = len(path)
|
|
|
|
except TypeError:
|
|
|
|
path_length = 1
|
|
|
|
|
|
|
|
if path_length > 1:
|
2020-02-29 22:52:24 +00:00
|
|
|
geo_dict = {}
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
if last_path_aperture is None:
|
|
|
|
log.warning("No aperture defined for curent path. (%d)" % line_num)
|
|
|
|
|
|
|
|
# --- BUFFERED ---
|
|
|
|
width = self.apertures[last_path_aperture]["size"]
|
|
|
|
|
|
|
|
# this treats the case when we are storing geometry as paths
|
|
|
|
geo_f = LineString(path)
|
|
|
|
if not geo_f.is_empty:
|
|
|
|
follow_buffer.append(geo_f)
|
|
|
|
geo_dict['follow'] = geo_f
|
|
|
|
|
|
|
|
# this treats the case when we are storing geometry as solids
|
|
|
|
buffered = LineString(path).buffer(width / 1.999, int(self.steps_per_circle))
|
|
|
|
if not buffered.is_empty:
|
|
|
|
if self.app.defaults['gerber_simplification']:
|
|
|
|
poly_buffer.append(buffered.simplify(s_tol))
|
|
|
|
else:
|
|
|
|
poly_buffer.append(buffered)
|
|
|
|
|
|
|
|
if self.is_lpc is True:
|
|
|
|
geo_dict['clear'] = buffered
|
|
|
|
else:
|
|
|
|
geo_dict['solid'] = buffered
|
|
|
|
|
|
|
|
if last_path_aperture not in self.apertures:
|
2020-02-29 22:52:24 +00:00
|
|
|
self.apertures[last_path_aperture] = {}
|
2019-10-06 04:14:10 +00:00
|
|
|
if 'geometry' not in self.apertures[last_path_aperture]:
|
|
|
|
self.apertures[last_path_aperture]['geometry'] = []
|
|
|
|
self.apertures[last_path_aperture]['geometry'].append(deepcopy(geo_dict))
|
|
|
|
|
|
|
|
current_x = circular_x
|
|
|
|
current_y = circular_y
|
|
|
|
path = [[current_x, current_y]] # Start new path
|
|
|
|
continue
|
|
|
|
|
|
|
|
# Flash should not happen here
|
|
|
|
if current_operation_code == 3:
|
|
|
|
log.error("Trying to flash within arc. (%d)" % line_num)
|
|
|
|
continue
|
|
|
|
|
|
|
|
if quadrant_mode == 'MULTI':
|
|
|
|
center = [i + current_x, j + current_y]
|
2019-10-15 23:28:18 +00:00
|
|
|
radius = np.sqrt(i ** 2 + j ** 2)
|
|
|
|
start = np.arctan2(-j, -i) # Start angle
|
2019-10-06 04:14:10 +00:00
|
|
|
# Numerical errors might prevent start == stop therefore
|
|
|
|
# we check ahead of time. This should result in a
|
|
|
|
# 360 degree arc.
|
|
|
|
if current_x == circular_x and current_y == circular_y:
|
|
|
|
stop = start
|
|
|
|
else:
|
2019-10-15 23:28:18 +00:00
|
|
|
stop = np.arctan2(-center[1] + circular_y, -center[0] + circular_x) # Stop angle
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
this_arc = arc(center, radius, start, stop,
|
|
|
|
arcdir[current_interpolation_mode],
|
|
|
|
self.steps_per_circle)
|
|
|
|
|
|
|
|
# The last point in the computed arc can have
|
|
|
|
# numerical errors. The exact final point is the
|
|
|
|
# specified (x, y). Replace.
|
|
|
|
this_arc[-1] = (circular_x, circular_y)
|
|
|
|
|
|
|
|
# Last point in path is current point
|
|
|
|
# current_x = this_arc[-1][0]
|
|
|
|
# current_y = this_arc[-1][1]
|
|
|
|
current_x, current_y = circular_x, circular_y
|
|
|
|
|
|
|
|
# Append
|
|
|
|
path += this_arc
|
|
|
|
last_path_aperture = current_aperture
|
|
|
|
|
|
|
|
continue
|
|
|
|
|
|
|
|
if quadrant_mode == 'SINGLE':
|
|
|
|
|
|
|
|
center_candidates = [
|
|
|
|
[i + current_x, j + current_y],
|
|
|
|
[-i + current_x, j + current_y],
|
|
|
|
[i + current_x, -j + current_y],
|
|
|
|
[-i + current_x, -j + current_y]
|
|
|
|
]
|
|
|
|
|
|
|
|
valid = False
|
|
|
|
log.debug("I: %f J: %f" % (i, j))
|
|
|
|
for center in center_candidates:
|
2019-10-15 23:28:18 +00:00
|
|
|
radius = np.sqrt(i ** 2 + j ** 2)
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
# Make sure radius to start is the same as radius to end.
|
2019-10-15 23:28:18 +00:00
|
|
|
radius2 = np.sqrt((center[0] - circular_x) ** 2 + (center[1] - circular_y) ** 2)
|
2019-10-06 04:14:10 +00:00
|
|
|
if radius2 < radius * 0.95 or radius2 > radius * 1.05:
|
|
|
|
continue # Not a valid center.
|
|
|
|
|
|
|
|
# Correct i and j and continue as with multi-quadrant.
|
|
|
|
i = center[0] - current_x
|
|
|
|
j = center[1] - current_y
|
|
|
|
|
2019-10-15 23:28:18 +00:00
|
|
|
start = np.arctan2(-j, -i) # Start angle
|
|
|
|
stop = np.arctan2(-center[1] + circular_y, -center[0] + circular_x) # Stop angle
|
2019-10-06 04:14:10 +00:00
|
|
|
angle = abs(arc_angle(start, stop, arcdir[current_interpolation_mode]))
|
|
|
|
log.debug("ARC START: %f, %f CENTER: %f, %f STOP: %f, %f" %
|
|
|
|
(current_x, current_y, center[0], center[1], circular_x, circular_y))
|
|
|
|
log.debug("START Ang: %f, STOP Ang: %f, DIR: %s, ABS: %.12f <= %.12f: %s" %
|
2019-10-15 23:28:18 +00:00
|
|
|
(start * 180 / np.pi, stop * 180 / np.pi, arcdir[current_interpolation_mode],
|
|
|
|
angle * 180 / np.pi, np.pi / 2 * 180 / np.pi, angle <= (np.pi + 1e-6) / 2))
|
2019-10-06 04:14:10 +00:00
|
|
|
|
2019-10-15 23:28:18 +00:00
|
|
|
if angle <= (np.pi + 1e-6) / 2:
|
2019-10-06 04:14:10 +00:00
|
|
|
log.debug("########## ACCEPTING ARC ############")
|
|
|
|
this_arc = arc(center, radius, start, stop,
|
|
|
|
arcdir[current_interpolation_mode],
|
|
|
|
self.steps_per_circle)
|
|
|
|
|
|
|
|
# Replace with exact values
|
|
|
|
this_arc[-1] = (circular_x, circular_y)
|
|
|
|
|
|
|
|
# current_x = this_arc[-1][0]
|
|
|
|
# current_y = this_arc[-1][1]
|
|
|
|
current_x, current_y = circular_x, circular_y
|
|
|
|
|
|
|
|
path += this_arc
|
|
|
|
last_path_aperture = current_aperture
|
|
|
|
valid = True
|
|
|
|
break
|
|
|
|
|
|
|
|
if valid:
|
|
|
|
continue
|
|
|
|
else:
|
|
|
|
log.warning("Invalid arc in line %d." % line_num)
|
|
|
|
|
2019-12-26 01:15:17 +00:00
|
|
|
# ################################################################
|
|
|
|
# ######### EOF - END OF FILE ####################################
|
|
|
|
# ################################################################
|
2019-10-06 04:14:10 +00:00
|
|
|
match = self.eof_re.search(gline)
|
|
|
|
if match:
|
|
|
|
continue
|
|
|
|
|
2019-12-26 01:15:17 +00:00
|
|
|
# ################################################################
|
|
|
|
# ######### Line did not match any pattern. Warn user. ##########
|
|
|
|
# ################################################################
|
2019-10-06 04:14:10 +00:00
|
|
|
log.warning("Line ignored (%d): %s" % (line_num, gline))
|
2020-05-18 13:39:26 +00:00
|
|
|
# provide the app with a way to process the GUI events when in a blocking loop
|
2020-04-05 18:11:48 +00:00
|
|
|
QtWidgets.QApplication.processEvents()
|
2019-10-06 04:14:10 +00:00
|
|
|
|
2020-02-25 19:22:51 +00:00
|
|
|
try:
|
|
|
|
path_length = len(path)
|
|
|
|
except TypeError:
|
|
|
|
path_length = 1
|
|
|
|
|
|
|
|
if path_length > 1:
|
2019-10-06 04:14:10 +00:00
|
|
|
# In case that G01 (moving) aperture is rectangular, there is no need to still create
|
|
|
|
# another geo since we already created a shapely box using the start and end coordinates found in
|
|
|
|
# path variable. We do it only for other apertures than 'R' type
|
|
|
|
if self.apertures[last_path_aperture]["type"] == 'R':
|
|
|
|
pass
|
|
|
|
else:
|
|
|
|
# EOF, create shapely LineString if something still in path
|
|
|
|
# ## --- Buffered ---
|
|
|
|
|
2020-02-29 22:52:24 +00:00
|
|
|
geo_dict = {}
|
2019-10-06 04:14:10 +00:00
|
|
|
# this treats the case when we are storing geometry as paths
|
|
|
|
geo_f = LineString(path)
|
|
|
|
if not geo_f.is_empty:
|
|
|
|
follow_buffer.append(geo_f)
|
|
|
|
geo_dict['follow'] = geo_f
|
|
|
|
|
|
|
|
# this treats the case when we are storing geometry as solids
|
|
|
|
width = self.apertures[last_path_aperture]["size"]
|
|
|
|
geo_s = LineString(path).buffer(width / 1.999, int(self.steps_per_circle / 4))
|
|
|
|
if not geo_s.is_empty:
|
|
|
|
if self.app.defaults['gerber_simplification']:
|
|
|
|
poly_buffer.append(geo_s.simplify(s_tol))
|
|
|
|
else:
|
|
|
|
poly_buffer.append(geo_s)
|
|
|
|
|
|
|
|
if self.is_lpc is True:
|
|
|
|
geo_dict['clear'] = geo_s
|
|
|
|
else:
|
|
|
|
geo_dict['solid'] = geo_s
|
|
|
|
|
|
|
|
if last_path_aperture not in self.apertures:
|
2020-02-29 22:52:24 +00:00
|
|
|
self.apertures[last_path_aperture] = {}
|
2019-10-06 04:14:10 +00:00
|
|
|
if 'geometry' not in self.apertures[last_path_aperture]:
|
|
|
|
self.apertures[last_path_aperture]['geometry'] = []
|
|
|
|
self.apertures[last_path_aperture]['geometry'].append(deepcopy(geo_dict))
|
|
|
|
|
|
|
|
# --- Apply buffer ---
|
|
|
|
# this treats the case when we are storing geometry as paths
|
|
|
|
self.follow_geometry = follow_buffer
|
|
|
|
|
|
|
|
# this treats the case when we are storing geometry as solids
|
2020-02-14 15:08:06 +00:00
|
|
|
try:
|
2020-02-25 19:22:51 +00:00
|
|
|
buff_length = len(poly_buffer)
|
|
|
|
except TypeError:
|
|
|
|
buff_length = 1
|
|
|
|
|
|
|
|
try:
|
|
|
|
sol_geo_length = len(self.solid_geometry)
|
|
|
|
except TypeError:
|
|
|
|
sol_geo_length = 1
|
|
|
|
|
|
|
|
try:
|
2020-06-02 15:29:45 +00:00
|
|
|
if buff_length == 0 and sol_geo_length in [0, 1] and self.solid_geometry.area == 0:
|
2020-02-14 15:08:06 +00:00
|
|
|
log.error("Object is not Gerber file or empty. Aborting Object creation.")
|
|
|
|
return 'fail'
|
|
|
|
except TypeError as e:
|
|
|
|
log.error("Object is not Gerber file or empty. Aborting Object creation. %s" % str(e))
|
2019-10-06 04:14:10 +00:00
|
|
|
return 'fail'
|
|
|
|
|
2020-02-25 19:22:51 +00:00
|
|
|
log.warning("Joining %d polygons." % buff_length)
|
|
|
|
self.app.inform.emit('%s: %d.' % (_("Gerber processing. Joining polygons"), buff_length))
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
if self.use_buffer_for_union:
|
|
|
|
log.debug("Union by buffer...")
|
|
|
|
|
|
|
|
new_poly = MultiPolygon(poly_buffer)
|
|
|
|
if self.app.defaults["gerber_buffering"] == 'full':
|
|
|
|
new_poly = new_poly.buffer(0.00000001)
|
|
|
|
new_poly = new_poly.buffer(-0.00000001)
|
2020-06-03 01:02:04 +00:00
|
|
|
log.warning("Union(buffer) done.")
|
|
|
|
|
2019-10-06 04:14:10 +00:00
|
|
|
else:
|
|
|
|
log.debug("Union by union()...")
|
2020-07-02 14:15:13 +00:00
|
|
|
new_poly = unary_union(poly_buffer)
|
2019-10-06 04:14:10 +00:00
|
|
|
new_poly = new_poly.buffer(0, int(self.steps_per_circle / 4))
|
|
|
|
log.warning("Union done.")
|
|
|
|
|
|
|
|
if current_polarity == 'D':
|
|
|
|
self.app.inform.emit('%s' % _("Gerber processing. Applying Gerber polarity."))
|
|
|
|
if new_poly.is_valid:
|
2019-12-18 01:14:17 +00:00
|
|
|
self.solid_geometry = self.solid_geometry.union(new_poly)
|
2019-10-06 04:14:10 +00:00
|
|
|
else:
|
|
|
|
# I do this so whenever the parsed geometry of the file is not valid (intersections) it is still
|
|
|
|
# loaded. Instead of applying a union I add to a list of polygons.
|
|
|
|
final_poly = []
|
|
|
|
try:
|
|
|
|
for poly in new_poly:
|
|
|
|
final_poly.append(poly)
|
|
|
|
except TypeError:
|
|
|
|
final_poly.append(new_poly)
|
|
|
|
|
|
|
|
try:
|
|
|
|
for poly in self.solid_geometry:
|
|
|
|
final_poly.append(poly)
|
|
|
|
except TypeError:
|
|
|
|
final_poly.append(self.solid_geometry)
|
|
|
|
|
|
|
|
self.solid_geometry = final_poly
|
|
|
|
|
2019-12-26 02:42:48 +00:00
|
|
|
# FIX for issue #347 - Sprint Layout generate Gerber files when the copper pour is enabled
|
2019-12-18 01:14:17 +00:00
|
|
|
# it use a filled bounding box polygon to which add clear polygons (negative) to isolate the copper
|
|
|
|
# features
|
|
|
|
if self.app.defaults['gerber_extra_buffering']:
|
2020-02-29 22:52:24 +00:00
|
|
|
candidate_geo = []
|
2019-12-18 15:53:41 +00:00
|
|
|
try:
|
|
|
|
for p in self.solid_geometry:
|
2019-12-26 02:42:48 +00:00
|
|
|
candidate_geo.append(p.buffer(-0.0000001))
|
2019-12-18 15:53:41 +00:00
|
|
|
except TypeError:
|
2019-12-26 02:42:48 +00:00
|
|
|
candidate_geo.append(self.solid_geometry.buffer(-0.0000001))
|
2019-12-18 01:14:17 +00:00
|
|
|
self.solid_geometry = candidate_geo
|
|
|
|
|
2019-10-06 04:14:10 +00:00
|
|
|
# try:
|
|
|
|
# self.solid_geometry = self.solid_geometry.union(new_poly)
|
|
|
|
# except Exception as e:
|
|
|
|
# # in case in the new_poly are some self intersections try to avoid making union with them
|
|
|
|
# for poly in new_poly:
|
|
|
|
# try:
|
|
|
|
# self.solid_geometry = self.solid_geometry.union(poly)
|
2019-11-11 00:35:42 +00:00
|
|
|
# except Exception:
|
2019-10-06 04:14:10 +00:00
|
|
|
# pass
|
|
|
|
else:
|
|
|
|
self.solid_geometry = self.solid_geometry.difference(new_poly)
|
2019-10-12 01:49:50 +00:00
|
|
|
|
2019-12-18 01:14:17 +00:00
|
|
|
if self.app.defaults['gerber_clean_apertures']:
|
|
|
|
# clean the Gerber file of apertures with no geometry
|
|
|
|
for apid, apvalue in list(self.apertures.items()):
|
|
|
|
if 'geometry' not in apvalue:
|
|
|
|
self.apertures.pop(apid)
|
|
|
|
|
2019-10-12 01:49:50 +00:00
|
|
|
# init this for the following operations
|
|
|
|
self.conversion_done = False
|
2019-10-06 04:14:10 +00:00
|
|
|
except Exception as err:
|
|
|
|
ex_type, ex, tb = sys.exc_info()
|
|
|
|
traceback.print_tb(tb)
|
|
|
|
# print traceback.format_exc()
|
|
|
|
|
|
|
|
log.error("Gerber PARSING FAILED. Line %d: %s" % (line_num, gline))
|
|
|
|
|
|
|
|
loc = '%s #%d %s: %s\n' % (_("Gerber Line"), line_num, _("Gerber Line Content"), gline) + repr(err)
|
|
|
|
self.app.inform.emit('[ERROR] %s\n%s:' %
|
|
|
|
(_("Gerber Parser ERROR"), loc))
|
|
|
|
|
|
|
|
@staticmethod
|
|
|
|
def create_flash_geometry(location, aperture, steps_per_circle=None):
|
|
|
|
|
|
|
|
# log.debug('Flashing @%s, Aperture: %s' % (location, aperture))
|
|
|
|
|
|
|
|
if type(location) == list:
|
|
|
|
location = Point(location)
|
|
|
|
|
|
|
|
if aperture['type'] == 'C': # Circles
|
|
|
|
return location.buffer(aperture['size'] / 2, int(steps_per_circle / 4))
|
|
|
|
|
|
|
|
if aperture['type'] == 'R': # Rectangles
|
|
|
|
loc = location.coords[0]
|
|
|
|
width = aperture['width']
|
|
|
|
height = aperture['height']
|
|
|
|
minx = loc[0] - width / 2
|
|
|
|
maxx = loc[0] + width / 2
|
|
|
|
miny = loc[1] - height / 2
|
|
|
|
maxy = loc[1] + height / 2
|
|
|
|
return shply_box(minx, miny, maxx, maxy)
|
|
|
|
|
|
|
|
if aperture['type'] == 'O': # Obround
|
|
|
|
loc = location.coords[0]
|
|
|
|
width = aperture['width']
|
|
|
|
height = aperture['height']
|
|
|
|
if width > height:
|
|
|
|
p1 = Point(loc[0] + 0.5 * (width - height), loc[1])
|
|
|
|
p2 = Point(loc[0] - 0.5 * (width - height), loc[1])
|
|
|
|
c1 = p1.buffer(height * 0.5, int(steps_per_circle / 4))
|
|
|
|
c2 = p2.buffer(height * 0.5, int(steps_per_circle / 4))
|
|
|
|
else:
|
|
|
|
p1 = Point(loc[0], loc[1] + 0.5 * (height - width))
|
|
|
|
p2 = Point(loc[0], loc[1] - 0.5 * (height - width))
|
|
|
|
c1 = p1.buffer(width * 0.5, int(steps_per_circle / 4))
|
|
|
|
c2 = p2.buffer(width * 0.5, int(steps_per_circle / 4))
|
2020-07-02 14:15:13 +00:00
|
|
|
return unary_union([c1, c2]).convex_hull
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
if aperture['type'] == 'P': # Regular polygon
|
|
|
|
loc = location.coords[0]
|
|
|
|
diam = aperture['diam']
|
|
|
|
n_vertices = aperture['nVertices']
|
|
|
|
points = []
|
|
|
|
for i in range(0, n_vertices):
|
2019-10-15 23:28:18 +00:00
|
|
|
x = loc[0] + 0.5 * diam * (np.cos(2 * np.pi * i / n_vertices))
|
|
|
|
y = loc[1] + 0.5 * diam * (np.sin(2 * np.pi * i / n_vertices))
|
2019-10-06 04:14:10 +00:00
|
|
|
points.append((x, y))
|
|
|
|
ply = Polygon(points)
|
|
|
|
if 'rotation' in aperture:
|
|
|
|
ply = affinity.rotate(ply, aperture['rotation'])
|
|
|
|
return ply
|
|
|
|
|
|
|
|
if aperture['type'] == 'AM': # Aperture Macro
|
|
|
|
loc = location.coords[0]
|
|
|
|
flash_geo = aperture['macro'].make_geometry(aperture['modifiers'])
|
|
|
|
if flash_geo.is_empty:
|
|
|
|
log.warning("Empty geometry for Aperture Macro: %s" % str(aperture['macro'].name))
|
|
|
|
return affinity.translate(flash_geo, xoff=loc[0], yoff=loc[1])
|
|
|
|
|
|
|
|
log.warning("Unknown aperture type: %s" % aperture['type'])
|
|
|
|
return None
|
|
|
|
|
|
|
|
def create_geometry(self):
|
|
|
|
"""
|
|
|
|
Geometry from a Gerber file is made up entirely of polygons.
|
|
|
|
Every stroke (linear or circular) has an aperture which gives
|
|
|
|
it thickness. Additionally, aperture strokes have non-zero area,
|
|
|
|
and regions naturally do as well.
|
|
|
|
|
|
|
|
:rtype : None
|
|
|
|
:return: None
|
|
|
|
"""
|
|
|
|
pass
|
|
|
|
# self.buffer_paths()
|
|
|
|
#
|
|
|
|
# self.fix_regions()
|
|
|
|
#
|
|
|
|
# self.do_flashes()
|
|
|
|
#
|
2020-10-21 10:55:41 +00:00
|
|
|
# self.solid_geometry = unary_union(self.buffered_paths +
|
2019-10-06 04:14:10 +00:00
|
|
|
# [poly['polygon'] for poly in self.regions] +
|
|
|
|
# self.flash_geometry)
|
|
|
|
|
|
|
|
def get_bounding_box(self, margin=0.0, rounded=False):
|
|
|
|
"""
|
|
|
|
Creates and returns a rectangular polygon bounding at a distance of
|
|
|
|
margin from the object's ``solid_geometry``. If margin > 0, the polygon
|
|
|
|
can optionally have rounded corners of radius equal to margin.
|
|
|
|
|
|
|
|
:param margin: Distance to enlarge the rectangular bounding
|
|
|
|
box in both positive and negative, x and y axes.
|
|
|
|
:type margin: float
|
|
|
|
:param rounded: Wether or not to have rounded corners.
|
|
|
|
:type rounded: bool
|
|
|
|
:return: The bounding box.
|
|
|
|
:rtype: Shapely.Polygon
|
|
|
|
"""
|
|
|
|
|
|
|
|
bbox = self.solid_geometry.envelope.buffer(margin)
|
|
|
|
if not rounded:
|
|
|
|
bbox = bbox.envelope
|
|
|
|
return bbox
|
|
|
|
|
2020-04-27 07:03:22 +00:00
|
|
|
def bounds(self, flatten=None):
|
2019-10-06 04:14:10 +00:00
|
|
|
"""
|
|
|
|
Returns coordinates of rectangular bounds
|
|
|
|
of Gerber geometry: (xmin, ymin, xmax, ymax).
|
2020-04-27 07:03:22 +00:00
|
|
|
|
|
|
|
:param flatten: Not used, it is here for compatibility with base class method
|
|
|
|
:return: None
|
2019-10-06 04:14:10 +00:00
|
|
|
"""
|
|
|
|
|
2019-10-12 01:49:50 +00:00
|
|
|
log.debug("parseGerber.Gerber.bounds()")
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
if self.solid_geometry is None:
|
|
|
|
log.debug("solid_geometry is None")
|
|
|
|
return 0, 0, 0, 0
|
|
|
|
|
|
|
|
def bounds_rec(obj):
|
|
|
|
if type(obj) is list and type(obj) is not MultiPolygon:
|
2019-10-15 23:28:18 +00:00
|
|
|
minx = np.Inf
|
|
|
|
miny = np.Inf
|
|
|
|
maxx = -np.Inf
|
|
|
|
maxy = -np.Inf
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
for k in obj:
|
|
|
|
if type(k) is dict:
|
|
|
|
for key in k:
|
|
|
|
minx_, miny_, maxx_, maxy_ = bounds_rec(k[key])
|
|
|
|
minx = min(minx, minx_)
|
|
|
|
miny = min(miny, miny_)
|
|
|
|
maxx = max(maxx, maxx_)
|
|
|
|
maxy = max(maxy, maxy_)
|
|
|
|
else:
|
|
|
|
if not k.is_empty:
|
|
|
|
try:
|
|
|
|
minx_, miny_, maxx_, maxy_ = bounds_rec(k)
|
|
|
|
except Exception as e:
|
|
|
|
log.debug("camlib.Gerber.bounds() --> %s" % str(e))
|
|
|
|
return
|
|
|
|
|
|
|
|
minx = min(minx, minx_)
|
|
|
|
miny = min(miny, miny_)
|
|
|
|
maxx = max(maxx, maxx_)
|
|
|
|
maxy = max(maxy, maxy_)
|
|
|
|
return minx, miny, maxx, maxy
|
|
|
|
else:
|
|
|
|
# it's a Shapely object, return it's bounds
|
|
|
|
return obj.bounds
|
|
|
|
|
|
|
|
bounds_coords = bounds_rec(self.solid_geometry)
|
|
|
|
return bounds_coords
|
|
|
|
|
2019-10-12 01:49:50 +00:00
|
|
|
def convert_units(self, obj_units):
|
|
|
|
"""
|
|
|
|
Converts the units of the object to ``units`` by scaling all
|
|
|
|
the geometry appropriately. This call ``scale()``. Don't call
|
2019-11-13 00:59:47 +00:00
|
|
|
it again in descendants.
|
2019-10-12 01:49:50 +00:00
|
|
|
|
2019-12-05 23:20:33 +00:00
|
|
|
:param obj_units: "IN" or "MM"
|
|
|
|
:type obj_units: str
|
2019-10-12 01:49:50 +00:00
|
|
|
:return: Scaling factor resulting from unit change.
|
|
|
|
:rtype: float
|
|
|
|
"""
|
|
|
|
|
|
|
|
if obj_units.upper() == self.units.upper():
|
|
|
|
log.debug("parseGerber.Gerber.convert_units() --> Factor: 1")
|
|
|
|
return 1.0
|
|
|
|
|
|
|
|
if obj_units.upper() == "MM":
|
|
|
|
factor = 25.4
|
|
|
|
log.debug("parseGerber.Gerber.convert_units() --> Factor: 25.4")
|
|
|
|
elif obj_units.upper() == "IN":
|
|
|
|
factor = 1 / 25.4
|
|
|
|
log.debug("parseGerber.Gerber.convert_units() --> Factor: %s" % str(1 / 25.4))
|
|
|
|
else:
|
|
|
|
log.error("Unsupported units: %s" % str(obj_units))
|
|
|
|
log.debug("parseGerber.Gerber.convert_units() --> Factor: 1")
|
|
|
|
return 1.0
|
|
|
|
|
|
|
|
self.units = obj_units
|
|
|
|
self.file_units_factor = factor
|
|
|
|
self.scale(factor, factor)
|
|
|
|
return factor
|
|
|
|
|
2020-09-21 00:27:52 +00:00
|
|
|
def import_svg(self, filename, object_type='gerber', flip=True, units=None):
|
2019-12-02 18:03:27 +00:00
|
|
|
"""
|
|
|
|
Imports shapes from an SVG file into the object's geometry.
|
|
|
|
|
2020-09-21 00:27:52 +00:00
|
|
|
:param filename: Path to the SVG file.
|
|
|
|
:type filename: str
|
|
|
|
:param object_type: parameter passed further along
|
|
|
|
:param flip: Flip the vertically.
|
|
|
|
:type flip: bool
|
|
|
|
:param units: FlatCAM units
|
2019-12-02 18:03:27 +00:00
|
|
|
:return: None
|
|
|
|
"""
|
|
|
|
|
2020-06-03 17:35:59 +00:00
|
|
|
log.debug("appParsers.ParseGerber.Gerber.import_svg()")
|
2019-12-02 18:03:27 +00:00
|
|
|
|
|
|
|
# Parse into list of shapely objects
|
|
|
|
svg_tree = ET.parse(filename)
|
|
|
|
svg_root = svg_tree.getroot()
|
|
|
|
|
|
|
|
# Change origin to bottom left
|
|
|
|
# h = float(svg_root.get('height'))
|
|
|
|
# w = float(svg_root.get('width'))
|
|
|
|
h = svgparselength(svg_root.get('height'))[0] # TODO: No units support yet
|
|
|
|
|
2020-09-21 00:27:52 +00:00
|
|
|
units = self.app.defaults['units'] if units is None else units
|
|
|
|
res = self.app.defaults['gerber_circle_steps']
|
2020-09-23 08:50:00 +00:00
|
|
|
factor = svgparse_viewbox(svg_root)
|
|
|
|
geos = getsvggeo(svg_root, 'gerber', units=units, res=res, factor=factor)
|
2019-12-02 18:03:27 +00:00
|
|
|
if flip:
|
|
|
|
geos = [translate(scale(g, 1.0, -1.0, origin=(0, 0)), yoff=h) for g in geos]
|
|
|
|
|
|
|
|
# Add to object
|
|
|
|
if self.solid_geometry is None:
|
2020-02-29 22:52:24 +00:00
|
|
|
self.solid_geometry = []
|
2019-12-02 18:03:27 +00:00
|
|
|
|
|
|
|
# if type(self.solid_geometry) == list:
|
|
|
|
# if type(geos) == list:
|
|
|
|
# self.solid_geometry += geos
|
|
|
|
# else:
|
|
|
|
# self.solid_geometry.append(geos)
|
|
|
|
# else: # It's shapely geometry
|
|
|
|
# self.solid_geometry = [self.solid_geometry, geos]
|
|
|
|
|
|
|
|
if type(geos) == list:
|
|
|
|
# HACK for importing QRCODE exported by FlatCAM
|
2020-02-25 19:22:51 +00:00
|
|
|
try:
|
|
|
|
geos_length = len(geos)
|
|
|
|
except TypeError:
|
|
|
|
geos_length = 1
|
|
|
|
|
|
|
|
if geos_length == 1:
|
2020-02-29 22:52:24 +00:00
|
|
|
geo_qrcode = []
|
2019-12-02 18:03:27 +00:00
|
|
|
geo_qrcode.append(Polygon(geos[0].exterior))
|
|
|
|
for i_el in geos[0].interiors:
|
2020-09-21 00:27:52 +00:00
|
|
|
geo_qrcode.append(Polygon(i_el).buffer(0, resolution=res))
|
2019-12-02 18:03:27 +00:00
|
|
|
for poly in geo_qrcode:
|
|
|
|
geos.append(poly)
|
|
|
|
|
|
|
|
if type(self.solid_geometry) == list:
|
|
|
|
self.solid_geometry += geos
|
|
|
|
else:
|
|
|
|
geos.append(self.solid_geometry)
|
|
|
|
self.solid_geometry = geos
|
|
|
|
else:
|
|
|
|
if type(self.solid_geometry) == list:
|
|
|
|
self.solid_geometry.append(geos)
|
|
|
|
else:
|
|
|
|
self.solid_geometry = [self.solid_geometry, geos]
|
|
|
|
|
|
|
|
# flatten the self.solid_geometry list for import_svg() to import SVG as Gerber
|
|
|
|
self.solid_geometry = list(self.flatten_list(self.solid_geometry))
|
|
|
|
|
|
|
|
try:
|
|
|
|
__ = iter(self.solid_geometry)
|
|
|
|
except TypeError:
|
|
|
|
self.solid_geometry = [self.solid_geometry]
|
|
|
|
|
|
|
|
if '0' not in self.apertures:
|
2020-02-29 22:52:24 +00:00
|
|
|
self.apertures['0'] = {}
|
2019-12-02 18:03:27 +00:00
|
|
|
self.apertures['0']['type'] = 'REG'
|
|
|
|
self.apertures['0']['size'] = 0.0
|
2020-02-29 22:52:24 +00:00
|
|
|
self.apertures['0']['geometry'] = []
|
2019-12-02 18:03:27 +00:00
|
|
|
|
|
|
|
for pol in self.solid_geometry:
|
2020-02-29 22:52:24 +00:00
|
|
|
new_el = {}
|
2019-12-02 18:03:27 +00:00
|
|
|
new_el['solid'] = pol
|
|
|
|
new_el['follow'] = pol.exterior
|
2020-04-28 11:37:34 +00:00
|
|
|
self.apertures['0']['geometry'].append(new_el)
|
2019-12-02 18:03:27 +00:00
|
|
|
|
2020-07-02 14:15:13 +00:00
|
|
|
def import_dxf_as_gerber(self, filename, units='MM'):
|
|
|
|
"""
|
|
|
|
Imports shapes from an DXF file into the Gerberobject geometry.
|
|
|
|
|
|
|
|
:param filename: Path to the DXF file.
|
|
|
|
:type filename: str
|
|
|
|
:param units: Application units
|
|
|
|
:return: None
|
|
|
|
"""
|
|
|
|
|
|
|
|
log.debug("Parsing DXF file geometry into a Gerber object geometry.")
|
|
|
|
# Parse into list of shapely objects
|
|
|
|
dxf = ezdxf.readfile(filename)
|
|
|
|
geos = getdxfgeo(dxf)
|
|
|
|
# trying to optimize the resulting geometry by merging contiguous lines
|
|
|
|
geos = linemerge(geos)
|
|
|
|
|
|
|
|
# Add to object
|
|
|
|
if self.solid_geometry is None:
|
|
|
|
self.solid_geometry = []
|
|
|
|
|
|
|
|
if type(self.solid_geometry) is list:
|
|
|
|
if type(geos) is list:
|
|
|
|
self.solid_geometry += geos
|
|
|
|
else:
|
|
|
|
self.solid_geometry.append(geos)
|
|
|
|
else: # It's shapely geometry
|
|
|
|
self.solid_geometry = [self.solid_geometry, geos]
|
|
|
|
|
|
|
|
# flatten the self.solid_geometry list for import_dxf() to import DXF as Gerber
|
|
|
|
flat_geo = list(self.flatten_list(self.solid_geometry))
|
|
|
|
if flat_geo:
|
|
|
|
self.solid_geometry = unary_union(flat_geo)
|
|
|
|
self.follow_geometry = self.solid_geometry
|
|
|
|
else:
|
|
|
|
return "fail"
|
|
|
|
|
|
|
|
# create the self.apertures data structure
|
|
|
|
if '0' not in self.apertures:
|
|
|
|
self.apertures['0'] = {}
|
|
|
|
self.apertures['0']['type'] = 'REG'
|
|
|
|
self.apertures['0']['size'] = 0.0
|
|
|
|
self.apertures['0']['geometry'] = []
|
|
|
|
|
|
|
|
for pol in flat_geo:
|
|
|
|
new_el = {}
|
|
|
|
new_el['solid'] = pol
|
|
|
|
new_el['follow'] = pol
|
|
|
|
self.apertures['0']['geometry'].append(deepcopy(new_el))
|
|
|
|
|
2019-10-06 04:14:10 +00:00
|
|
|
def scale(self, xfactor, yfactor=None, point=None):
|
|
|
|
"""
|
|
|
|
Scales the objects' geometry on the XY plane by a given factor.
|
|
|
|
These are:
|
|
|
|
|
|
|
|
* ``buffered_paths``
|
|
|
|
* ``flash_geometry``
|
|
|
|
* ``solid_geometry``
|
|
|
|
* ``regions``
|
|
|
|
|
|
|
|
NOTE:
|
|
|
|
Does not modify the data used to create these elements. If these
|
|
|
|
are recreated, the scaling will be lost. This behavior was modified
|
|
|
|
because of the complexity reached in this class.
|
|
|
|
|
|
|
|
:param xfactor: Number by which to scale on X axis.
|
|
|
|
:type xfactor: float
|
|
|
|
:param yfactor: Number by which to scale on Y axis.
|
|
|
|
:type yfactor: float
|
2019-10-06 12:56:41 +00:00
|
|
|
:param point: reference point for scaling operation
|
2019-10-06 04:14:10 +00:00
|
|
|
:rtype : None
|
|
|
|
"""
|
2019-10-12 01:49:50 +00:00
|
|
|
log.debug("parseGerber.Gerber.scale()")
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
try:
|
|
|
|
xfactor = float(xfactor)
|
2019-11-11 00:35:42 +00:00
|
|
|
except Exception:
|
2019-10-06 04:14:10 +00:00
|
|
|
self.app.inform.emit('[ERROR_NOTCL] %s' %
|
|
|
|
_("Scale factor has to be a number: integer or float."))
|
|
|
|
return
|
|
|
|
|
|
|
|
if yfactor is None:
|
|
|
|
yfactor = xfactor
|
|
|
|
else:
|
|
|
|
try:
|
|
|
|
yfactor = float(yfactor)
|
2019-11-11 00:35:42 +00:00
|
|
|
except Exception:
|
2019-10-06 04:14:10 +00:00
|
|
|
self.app.inform.emit('[ERROR_NOTCL] %s' %
|
|
|
|
_("Scale factor has to be a number: integer or float."))
|
|
|
|
return
|
|
|
|
|
2019-12-09 14:20:22 +00:00
|
|
|
if xfactor == 0 and yfactor == 0:
|
|
|
|
return
|
|
|
|
|
2019-10-06 04:14:10 +00:00
|
|
|
if point is None:
|
|
|
|
px = 0
|
|
|
|
py = 0
|
|
|
|
else:
|
|
|
|
px, py = point
|
|
|
|
|
|
|
|
# variables to display the percentage of work done
|
|
|
|
self.geo_len = 0
|
|
|
|
try:
|
2019-12-09 14:20:22 +00:00
|
|
|
self.geo_len = len(self.solid_geometry)
|
2019-10-06 04:14:10 +00:00
|
|
|
except TypeError:
|
|
|
|
self.geo_len = 1
|
|
|
|
|
|
|
|
self.old_disp_number = 0
|
|
|
|
self.el_count = 0
|
|
|
|
|
|
|
|
def scale_geom(obj):
|
|
|
|
if type(obj) is list:
|
|
|
|
new_obj = []
|
|
|
|
for g in obj:
|
|
|
|
new_obj.append(scale_geom(g))
|
|
|
|
return new_obj
|
|
|
|
else:
|
|
|
|
try:
|
|
|
|
self.el_count += 1
|
|
|
|
disp_number = int(np.interp(self.el_count, [0, self.geo_len], [0, 99]))
|
|
|
|
if self.old_disp_number < disp_number <= 100:
|
|
|
|
self.app.proc_container.update_view_text(' %d%%' % disp_number)
|
|
|
|
self.old_disp_number = disp_number
|
|
|
|
|
|
|
|
return affinity.scale(obj, xfactor, yfactor, origin=(px, py))
|
|
|
|
except AttributeError:
|
|
|
|
return obj
|
|
|
|
|
|
|
|
self.solid_geometry = scale_geom(self.solid_geometry)
|
|
|
|
self.follow_geometry = scale_geom(self.follow_geometry)
|
|
|
|
|
|
|
|
# we need to scale the geometry stored in the Gerber apertures, too
|
|
|
|
try:
|
|
|
|
for apid in self.apertures:
|
2020-02-29 22:52:24 +00:00
|
|
|
new_geometry = []
|
2019-10-06 04:14:10 +00:00
|
|
|
if 'geometry' in self.apertures[apid]:
|
|
|
|
for geo_el in self.apertures[apid]['geometry']:
|
2020-02-29 22:52:24 +00:00
|
|
|
new_geo_el = {}
|
2019-10-06 04:14:10 +00:00
|
|
|
if 'solid' in geo_el:
|
2019-10-12 01:49:50 +00:00
|
|
|
new_geo_el['solid'] = scale_geom(geo_el['solid'])
|
2019-10-06 04:14:10 +00:00
|
|
|
if 'follow' in geo_el:
|
2019-10-12 01:49:50 +00:00
|
|
|
new_geo_el['follow'] = scale_geom(geo_el['follow'])
|
2019-10-06 04:14:10 +00:00
|
|
|
if 'clear' in geo_el:
|
2019-10-12 01:49:50 +00:00
|
|
|
new_geo_el['clear'] = scale_geom(geo_el['clear'])
|
|
|
|
new_geometry.append(new_geo_el)
|
|
|
|
|
|
|
|
self.apertures[apid]['geometry'] = deepcopy(new_geometry)
|
|
|
|
|
|
|
|
try:
|
|
|
|
if str(self.apertures[apid]['type']) == 'R' or str(self.apertures[apid]['type']) == 'O':
|
|
|
|
self.apertures[apid]['width'] *= xfactor
|
|
|
|
self.apertures[apid]['height'] *= xfactor
|
|
|
|
elif str(self.apertures[apid]['type']) == 'P':
|
|
|
|
self.apertures[apid]['diam'] *= xfactor
|
|
|
|
self.apertures[apid]['nVertices'] *= xfactor
|
|
|
|
except KeyError:
|
|
|
|
pass
|
|
|
|
|
|
|
|
try:
|
|
|
|
if self.apertures[apid]['size'] is not None:
|
|
|
|
self.apertures[apid]['size'] = float(self.apertures[apid]['size'] * xfactor)
|
|
|
|
except KeyError:
|
|
|
|
pass
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
except Exception as e:
|
|
|
|
log.debug('camlib.Gerber.scale() Exception --> %s' % str(e))
|
|
|
|
return 'fail'
|
|
|
|
|
2019-12-09 14:20:22 +00:00
|
|
|
self.app.inform.emit('[success] %s' % _("Gerber Scale done."))
|
2019-10-06 04:14:10 +00:00
|
|
|
self.app.proc_container.new_text = ''
|
|
|
|
|
|
|
|
# ## solid_geometry ???
|
|
|
|
# It's a cascaded union of objects.
|
|
|
|
# self.solid_geometry = affinity.scale(self.solid_geometry, factor,
|
|
|
|
# factor, origin=(0, 0))
|
|
|
|
|
|
|
|
# # Now buffered_paths, flash_geometry and solid_geometry
|
|
|
|
# self.create_geometry()
|
|
|
|
|
|
|
|
def offset(self, vect):
|
|
|
|
"""
|
|
|
|
Offsets the objects' geometry on the XY plane by a given vector.
|
|
|
|
These are:
|
|
|
|
|
|
|
|
* ``buffered_paths``
|
|
|
|
* ``flash_geometry``
|
|
|
|
* ``solid_geometry``
|
|
|
|
* ``regions``
|
|
|
|
|
|
|
|
NOTE:
|
|
|
|
Does not modify the data used to create these elements. If these
|
|
|
|
are recreated, the scaling will be lost. This behavior was modified
|
|
|
|
because of the complexity reached in this class.
|
|
|
|
|
|
|
|
:param vect: (x, y) offset vector.
|
|
|
|
:type vect: tuple
|
|
|
|
:return: None
|
|
|
|
"""
|
2019-10-12 01:49:50 +00:00
|
|
|
log.debug("parseGerber.Gerber.offset()")
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
try:
|
|
|
|
dx, dy = vect
|
|
|
|
except TypeError:
|
|
|
|
self.app.inform.emit('[ERROR_NOTCL] %s' %
|
|
|
|
_("An (x,y) pair of values are needed. "
|
|
|
|
"Probable you entered only one value in the Offset field."))
|
|
|
|
return
|
|
|
|
|
2019-12-09 14:20:22 +00:00
|
|
|
if dx == 0 and dy == 0:
|
|
|
|
return
|
|
|
|
|
2019-10-06 04:14:10 +00:00
|
|
|
# variables to display the percentage of work done
|
|
|
|
self.geo_len = 0
|
|
|
|
try:
|
2020-04-27 07:03:22 +00:00
|
|
|
self.geo_len = len(self.solid_geometry)
|
2019-10-06 04:14:10 +00:00
|
|
|
except TypeError:
|
|
|
|
self.geo_len = 1
|
|
|
|
|
|
|
|
self.old_disp_number = 0
|
|
|
|
self.el_count = 0
|
|
|
|
|
|
|
|
def offset_geom(obj):
|
|
|
|
if type(obj) is list:
|
|
|
|
new_obj = []
|
|
|
|
for g in obj:
|
|
|
|
new_obj.append(offset_geom(g))
|
|
|
|
return new_obj
|
|
|
|
else:
|
|
|
|
try:
|
|
|
|
self.el_count += 1
|
|
|
|
disp_number = int(np.interp(self.el_count, [0, self.geo_len], [0, 99]))
|
|
|
|
if self.old_disp_number < disp_number <= 100:
|
|
|
|
self.app.proc_container.update_view_text(' %d%%' % disp_number)
|
|
|
|
self.old_disp_number = disp_number
|
|
|
|
|
|
|
|
return affinity.translate(obj, xoff=dx, yoff=dy)
|
|
|
|
except AttributeError:
|
|
|
|
return obj
|
|
|
|
|
|
|
|
# ## Solid geometry
|
|
|
|
self.solid_geometry = offset_geom(self.solid_geometry)
|
|
|
|
self.follow_geometry = offset_geom(self.follow_geometry)
|
|
|
|
|
|
|
|
# we need to offset the geometry stored in the Gerber apertures, too
|
|
|
|
try:
|
|
|
|
for apid in self.apertures:
|
|
|
|
if 'geometry' in self.apertures[apid]:
|
|
|
|
for geo_el in self.apertures[apid]['geometry']:
|
|
|
|
if 'solid' in geo_el:
|
|
|
|
geo_el['solid'] = offset_geom(geo_el['solid'])
|
|
|
|
if 'follow' in geo_el:
|
|
|
|
geo_el['follow'] = offset_geom(geo_el['follow'])
|
|
|
|
if 'clear' in geo_el:
|
|
|
|
geo_el['clear'] = offset_geom(geo_el['clear'])
|
|
|
|
|
|
|
|
except Exception as e:
|
|
|
|
log.debug('camlib.Gerber.offset() Exception --> %s' % str(e))
|
|
|
|
return 'fail'
|
|
|
|
|
|
|
|
self.app.inform.emit('[success] %s' %
|
|
|
|
_("Gerber Offset done."))
|
|
|
|
self.app.proc_container.new_text = ''
|
|
|
|
|
|
|
|
def mirror(self, axis, point):
|
|
|
|
"""
|
|
|
|
Mirrors the object around a specified axis passing through
|
|
|
|
the given point. What is affected:
|
|
|
|
|
|
|
|
* ``buffered_paths``
|
|
|
|
* ``flash_geometry``
|
|
|
|
* ``solid_geometry``
|
|
|
|
* ``regions``
|
|
|
|
|
|
|
|
NOTE:
|
|
|
|
Does not modify the data used to create these elements. If these
|
|
|
|
are recreated, the scaling will be lost. This behavior was modified
|
|
|
|
because of the complexity reached in this class.
|
|
|
|
|
|
|
|
:param axis: "X" or "Y" indicates around which axis to mirror.
|
|
|
|
:type axis: str
|
|
|
|
:param point: [x, y] point belonging to the mirror axis.
|
|
|
|
:type point: list
|
|
|
|
:return: None
|
|
|
|
"""
|
2019-10-12 01:49:50 +00:00
|
|
|
log.debug("parseGerber.Gerber.mirror()")
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
px, py = point
|
|
|
|
xscale, yscale = {"X": (1.0, -1.0), "Y": (-1.0, 1.0)}[axis]
|
|
|
|
|
|
|
|
# variables to display the percentage of work done
|
|
|
|
self.geo_len = 0
|
|
|
|
try:
|
2020-04-27 07:03:22 +00:00
|
|
|
self.geo_len = len(self.solid_geometry)
|
2019-10-06 04:14:10 +00:00
|
|
|
except TypeError:
|
|
|
|
self.geo_len = 1
|
|
|
|
|
|
|
|
self.old_disp_number = 0
|
|
|
|
self.el_count = 0
|
|
|
|
|
|
|
|
def mirror_geom(obj):
|
|
|
|
if type(obj) is list:
|
|
|
|
new_obj = []
|
|
|
|
for g in obj:
|
|
|
|
new_obj.append(mirror_geom(g))
|
|
|
|
return new_obj
|
|
|
|
else:
|
|
|
|
try:
|
|
|
|
self.el_count += 1
|
|
|
|
disp_number = int(np.interp(self.el_count, [0, self.geo_len], [0, 99]))
|
|
|
|
if self.old_disp_number < disp_number <= 100:
|
|
|
|
self.app.proc_container.update_view_text(' %d%%' % disp_number)
|
|
|
|
self.old_disp_number = disp_number
|
|
|
|
|
|
|
|
return affinity.scale(obj, xscale, yscale, origin=(px, py))
|
|
|
|
except AttributeError:
|
|
|
|
return obj
|
|
|
|
|
|
|
|
self.solid_geometry = mirror_geom(self.solid_geometry)
|
|
|
|
self.follow_geometry = mirror_geom(self.follow_geometry)
|
|
|
|
|
|
|
|
# we need to mirror the geometry stored in the Gerber apertures, too
|
|
|
|
try:
|
|
|
|
for apid in self.apertures:
|
|
|
|
if 'geometry' in self.apertures[apid]:
|
|
|
|
for geo_el in self.apertures[apid]['geometry']:
|
|
|
|
if 'solid' in geo_el:
|
|
|
|
geo_el['solid'] = mirror_geom(geo_el['solid'])
|
|
|
|
if 'follow' in geo_el:
|
|
|
|
geo_el['follow'] = mirror_geom(geo_el['follow'])
|
|
|
|
if 'clear' in geo_el:
|
|
|
|
geo_el['clear'] = mirror_geom(geo_el['clear'])
|
|
|
|
except Exception as e:
|
|
|
|
log.debug('camlib.Gerber.mirror() Exception --> %s' % str(e))
|
|
|
|
return 'fail'
|
|
|
|
|
|
|
|
self.app.inform.emit('[success] %s' %
|
|
|
|
_("Gerber Mirror done."))
|
|
|
|
self.app.proc_container.new_text = ''
|
|
|
|
|
|
|
|
def skew(self, angle_x, angle_y, point):
|
|
|
|
"""
|
|
|
|
Shear/Skew the geometries of an object by angles along x and y dimensions.
|
|
|
|
|
|
|
|
Parameters
|
|
|
|
----------
|
|
|
|
angle_x, angle_y : float, float
|
|
|
|
The shear angle(s) for the x and y axes respectively. These can be
|
|
|
|
specified in either degrees (default) or radians by setting
|
|
|
|
use_radians=True.
|
|
|
|
|
|
|
|
See shapely manual for more information:
|
|
|
|
http://toblerity.org/shapely/manual.html#affine-transformations
|
2019-10-06 12:56:41 +00:00
|
|
|
:param angle_x: the angle on X axis for skewing
|
|
|
|
:param angle_y: the angle on Y axis for skewing
|
|
|
|
:param point: reference point for skewing operation
|
|
|
|
:return None
|
2019-10-06 04:14:10 +00:00
|
|
|
"""
|
2019-10-12 01:49:50 +00:00
|
|
|
log.debug("parseGerber.Gerber.skew()")
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
px, py = point
|
|
|
|
|
2019-12-09 14:20:22 +00:00
|
|
|
if angle_x == 0 and angle_y == 0:
|
|
|
|
return
|
|
|
|
|
2019-10-06 04:14:10 +00:00
|
|
|
# variables to display the percentage of work done
|
|
|
|
self.geo_len = 0
|
|
|
|
try:
|
2019-12-09 14:20:22 +00:00
|
|
|
self.geo_len = len(self.solid_geometry)
|
2019-10-06 04:14:10 +00:00
|
|
|
except TypeError:
|
|
|
|
self.geo_len = 1
|
|
|
|
|
|
|
|
self.old_disp_number = 0
|
|
|
|
self.el_count = 0
|
|
|
|
|
|
|
|
def skew_geom(obj):
|
|
|
|
if type(obj) is list:
|
|
|
|
new_obj = []
|
|
|
|
for g in obj:
|
|
|
|
new_obj.append(skew_geom(g))
|
|
|
|
return new_obj
|
|
|
|
else:
|
|
|
|
try:
|
|
|
|
self.el_count += 1
|
|
|
|
disp_number = int(np.interp(self.el_count, [0, self.geo_len], [0, 100]))
|
|
|
|
if self.old_disp_number < disp_number <= 100:
|
|
|
|
self.app.proc_container.update_view_text(' %d%%' % disp_number)
|
|
|
|
self.old_disp_number = disp_number
|
|
|
|
|
|
|
|
return affinity.skew(obj, angle_x, angle_y, origin=(px, py))
|
|
|
|
except AttributeError:
|
|
|
|
return obj
|
|
|
|
|
|
|
|
self.solid_geometry = skew_geom(self.solid_geometry)
|
|
|
|
self.follow_geometry = skew_geom(self.follow_geometry)
|
|
|
|
|
|
|
|
# we need to skew the geometry stored in the Gerber apertures, too
|
|
|
|
try:
|
|
|
|
for apid in self.apertures:
|
|
|
|
if 'geometry' in self.apertures[apid]:
|
|
|
|
for geo_el in self.apertures[apid]['geometry']:
|
|
|
|
if 'solid' in geo_el:
|
|
|
|
geo_el['solid'] = skew_geom(geo_el['solid'])
|
|
|
|
if 'follow' in geo_el:
|
|
|
|
geo_el['follow'] = skew_geom(geo_el['follow'])
|
|
|
|
if 'clear' in geo_el:
|
|
|
|
geo_el['clear'] = skew_geom(geo_el['clear'])
|
|
|
|
except Exception as e:
|
|
|
|
log.debug('camlib.Gerber.skew() Exception --> %s' % str(e))
|
|
|
|
return 'fail'
|
|
|
|
|
2019-10-06 04:28:13 +00:00
|
|
|
self.app.inform.emit('[success] %s' % _("Gerber Skew done."))
|
2019-10-06 04:14:10 +00:00
|
|
|
self.app.proc_container.new_text = ''
|
|
|
|
|
|
|
|
def rotate(self, angle, point):
|
|
|
|
"""
|
|
|
|
Rotate an object by a given angle around given coords (point)
|
|
|
|
:param angle:
|
|
|
|
:param point:
|
|
|
|
:return:
|
|
|
|
"""
|
2019-10-12 01:49:50 +00:00
|
|
|
log.debug("parseGerber.Gerber.rotate()")
|
2019-10-06 04:14:10 +00:00
|
|
|
|
|
|
|
px, py = point
|
|
|
|
|
2019-12-09 14:20:22 +00:00
|
|
|
if angle == 0:
|
|
|
|
return
|
|
|
|
|
2019-10-06 04:14:10 +00:00
|
|
|
# variables to display the percentage of work done
|
|
|
|
self.geo_len = 0
|
|
|
|
try:
|
2020-04-27 07:03:22 +00:00
|
|
|
self.geo_len = len(self.solid_geometry)
|
2019-10-06 04:14:10 +00:00
|
|
|
except TypeError:
|
|
|
|
self.geo_len = 1
|
|
|
|
|
|
|
|
self.old_disp_number = 0
|
|
|
|
self.el_count = 0
|
|
|
|
|
|
|
|
def rotate_geom(obj):
|
|
|
|
if type(obj) is list:
|
|
|
|
new_obj = []
|
|
|
|
for g in obj:
|
|
|
|
new_obj.append(rotate_geom(g))
|
|
|
|
return new_obj
|
|
|
|
else:
|
|
|
|
try:
|
|
|
|
self.el_count += 1
|
|
|
|
disp_number = int(np.interp(self.el_count, [0, self.geo_len], [0, 100]))
|
|
|
|
if self.old_disp_number < disp_number <= 100:
|
|
|
|
self.app.proc_container.update_view_text(' %d%%' % disp_number)
|
|
|
|
self.old_disp_number = disp_number
|
|
|
|
|
|
|
|
return affinity.rotate(obj, angle, origin=(px, py))
|
|
|
|
except AttributeError:
|
|
|
|
return obj
|
|
|
|
|
|
|
|
self.solid_geometry = rotate_geom(self.solid_geometry)
|
|
|
|
self.follow_geometry = rotate_geom(self.follow_geometry)
|
|
|
|
|
|
|
|
# we need to rotate the geometry stored in the Gerber apertures, too
|
|
|
|
try:
|
|
|
|
for apid in self.apertures:
|
|
|
|
if 'geometry' in self.apertures[apid]:
|
|
|
|
for geo_el in self.apertures[apid]['geometry']:
|
|
|
|
if 'solid' in geo_el:
|
|
|
|
geo_el['solid'] = rotate_geom(geo_el['solid'])
|
|
|
|
if 'follow' in geo_el:
|
|
|
|
geo_el['follow'] = rotate_geom(geo_el['follow'])
|
|
|
|
if 'clear' in geo_el:
|
|
|
|
geo_el['clear'] = rotate_geom(geo_el['clear'])
|
|
|
|
except Exception as e:
|
|
|
|
log.debug('camlib.Gerber.rotate() Exception --> %s' % str(e))
|
|
|
|
return 'fail'
|
2019-12-29 23:18:56 +00:00
|
|
|
self.app.inform.emit('[success] %s' % _("Gerber Rotate done."))
|
2019-10-06 04:14:10 +00:00
|
|
|
self.app.proc_container.new_text = ''
|
2019-10-12 01:49:50 +00:00
|
|
|
|
2020-06-03 01:02:04 +00:00
|
|
|
def buffer(self, distance, join=2, factor=None):
|
2019-12-23 20:59:01 +00:00
|
|
|
"""
|
|
|
|
|
2020-04-27 07:03:22 +00:00
|
|
|
:param distance: If 'factor' is True then distance is the factor
|
|
|
|
:param join: The type of joining used by the Shapely buffer method. Can be: round, square and bevel
|
|
|
|
:param factor: True or False (None)
|
2019-12-23 20:59:01 +00:00
|
|
|
:return:
|
|
|
|
"""
|
|
|
|
log.debug("parseGerber.Gerber.buffer()")
|
|
|
|
|
|
|
|
if distance == 0:
|
|
|
|
return
|
|
|
|
|
|
|
|
# variables to display the percentage of work done
|
|
|
|
self.geo_len = 0
|
|
|
|
try:
|
2019-12-29 23:18:56 +00:00
|
|
|
self.geo_len = len(self.solid_geometry)
|
|
|
|
except (TypeError, ValueError):
|
2019-12-23 20:59:01 +00:00
|
|
|
self.geo_len = 1
|
|
|
|
|
|
|
|
self.old_disp_number = 0
|
|
|
|
self.el_count = 0
|
|
|
|
|
2019-12-29 23:18:56 +00:00
|
|
|
if factor is None:
|
|
|
|
def buffer_geom(obj):
|
|
|
|
if type(obj) is list:
|
|
|
|
new_obj = []
|
|
|
|
for g in obj:
|
|
|
|
new_obj.append(buffer_geom(g))
|
|
|
|
return new_obj
|
|
|
|
else:
|
|
|
|
try:
|
|
|
|
self.el_count += 1
|
|
|
|
disp_number = int(np.interp(self.el_count, [0, self.geo_len], [0, 100]))
|
|
|
|
if self.old_disp_number < disp_number <= 100:
|
|
|
|
self.app.proc_container.update_view_text(' %d%%' % disp_number)
|
|
|
|
self.old_disp_number = disp_number
|
2019-12-23 20:59:01 +00:00
|
|
|
|
2019-12-29 23:18:56 +00:00
|
|
|
return obj.buffer(distance, resolution=int(self.steps_per_circle), join_style=join)
|
2019-12-23 20:59:01 +00:00
|
|
|
|
2019-12-29 23:18:56 +00:00
|
|
|
except AttributeError:
|
|
|
|
return obj
|
2019-12-23 20:59:01 +00:00
|
|
|
|
2019-12-29 23:18:56 +00:00
|
|
|
res = buffer_geom(self.solid_geometry)
|
|
|
|
try:
|
|
|
|
__ = iter(res)
|
|
|
|
self.solid_geometry = res
|
|
|
|
except TypeError:
|
|
|
|
self.solid_geometry = [res]
|
2019-12-23 20:59:01 +00:00
|
|
|
|
2019-12-29 23:18:56 +00:00
|
|
|
# we need to buffer the geometry stored in the Gerber apertures, too
|
|
|
|
try:
|
|
|
|
for apid in self.apertures:
|
2020-02-29 22:52:24 +00:00
|
|
|
new_geometry = []
|
2019-12-29 23:18:56 +00:00
|
|
|
if 'geometry' in self.apertures[apid]:
|
|
|
|
for geo_el in self.apertures[apid]['geometry']:
|
2020-02-29 22:52:24 +00:00
|
|
|
new_geo_el = {}
|
2019-12-29 23:18:56 +00:00
|
|
|
if 'solid' in geo_el:
|
|
|
|
new_geo_el['solid'] = buffer_geom(geo_el['solid'])
|
|
|
|
if 'follow' in geo_el:
|
|
|
|
new_geo_el['follow'] = geo_el['follow']
|
|
|
|
if 'clear' in geo_el:
|
|
|
|
new_geo_el['clear'] = buffer_geom(geo_el['clear'])
|
|
|
|
new_geometry.append(new_geo_el)
|
|
|
|
|
|
|
|
self.apertures[apid]['geometry'] = deepcopy(new_geometry)
|
2019-12-23 20:59:01 +00:00
|
|
|
|
2019-12-29 23:18:56 +00:00
|
|
|
try:
|
|
|
|
if str(self.apertures[apid]['type']) == 'R' or str(self.apertures[apid]['type']) == 'O':
|
|
|
|
self.apertures[apid]['width'] += (distance * 2)
|
|
|
|
self.apertures[apid]['height'] += (distance * 2)
|
|
|
|
elif str(self.apertures[apid]['type']) == 'P':
|
|
|
|
self.apertures[apid]['diam'] += (distance * 2)
|
|
|
|
self.apertures[apid]['nVertices'] += (distance * 2)
|
|
|
|
except KeyError:
|
|
|
|
pass
|
2019-12-23 20:59:01 +00:00
|
|
|
|
2019-12-29 23:18:56 +00:00
|
|
|
try:
|
|
|
|
if self.apertures[apid]['size'] is not None:
|
|
|
|
self.apertures[apid]['size'] = float(self.apertures[apid]['size'] + (distance * 2))
|
|
|
|
except KeyError:
|
|
|
|
pass
|
|
|
|
except Exception as e:
|
|
|
|
log.debug('camlib.Gerber.buffer() Exception --> %s' % str(e))
|
|
|
|
return 'fail'
|
|
|
|
else:
|
|
|
|
try:
|
|
|
|
for apid in self.apertures:
|
|
|
|
try:
|
|
|
|
if str(self.apertures[apid]['type']) == 'R' or str(self.apertures[apid]['type']) == 'O':
|
|
|
|
self.apertures[apid]['width'] *= distance
|
|
|
|
self.apertures[apid]['height'] *= distance
|
|
|
|
elif str(self.apertures[apid]['type']) == 'P':
|
|
|
|
self.apertures[apid]['diam'] *= distance
|
|
|
|
self.apertures[apid]['nVertices'] *= distance
|
|
|
|
except KeyError:
|
|
|
|
pass
|
|
|
|
|
|
|
|
try:
|
|
|
|
if self.apertures[apid]['size'] is not None:
|
|
|
|
self.apertures[apid]['size'] = float(self.apertures[apid]['size']) * distance
|
|
|
|
except KeyError:
|
|
|
|
pass
|
|
|
|
|
2020-02-29 22:52:24 +00:00
|
|
|
new_geometry = []
|
2019-12-29 23:18:56 +00:00
|
|
|
if 'geometry' in self.apertures[apid]:
|
|
|
|
for geo_el in self.apertures[apid]['geometry']:
|
2020-02-29 22:52:24 +00:00
|
|
|
new_geo_el = {}
|
2019-12-29 23:18:56 +00:00
|
|
|
if 'follow' in geo_el:
|
|
|
|
new_geo_el['follow'] = geo_el['follow']
|
|
|
|
size = float(self.apertures[apid]['size'])
|
|
|
|
if isinstance(new_geo_el['follow'], Point):
|
|
|
|
if str(self.apertures[apid]['type']) == 'C':
|
|
|
|
new_geo_el['solid'] = geo_el['follow'].buffer(
|
|
|
|
size / 1.9999,
|
|
|
|
resolution=int(self.steps_per_circle)
|
|
|
|
)
|
|
|
|
elif str(self.apertures[apid]['type']) == 'R':
|
|
|
|
width = self.apertures[apid]['width']
|
|
|
|
height = self.apertures[apid]['height']
|
|
|
|
minx = new_geo_el['follow'].x - width / 2
|
|
|
|
maxx = new_geo_el['follow'].x + width / 2
|
|
|
|
miny = new_geo_el['follow'].y - height / 2
|
|
|
|
maxy = new_geo_el['follow'].y + height / 2
|
|
|
|
|
|
|
|
geo_p = shply_box(minx, miny, maxx, maxy)
|
|
|
|
new_geo_el['solid'] = geo_p
|
|
|
|
else:
|
2020-06-03 17:35:59 +00:00
|
|
|
log.debug("appParsers.ParseGerber.Gerber.buffer() --> "
|
2019-12-29 23:18:56 +00:00
|
|
|
"ap type not supported")
|
|
|
|
else:
|
|
|
|
new_geo_el['solid'] = geo_el['follow'].buffer(
|
|
|
|
size/1.9999,
|
|
|
|
resolution=int(self.steps_per_circle)
|
|
|
|
)
|
|
|
|
if 'clear' in geo_el:
|
|
|
|
new_geo_el['clear'] = geo_el['clear']
|
|
|
|
new_geometry.append(new_geo_el)
|
|
|
|
|
|
|
|
self.apertures[apid]['geometry'] = deepcopy(new_geometry)
|
|
|
|
except Exception as e:
|
|
|
|
log.debug('camlib.Gerber.buffer() Exception --> %s' % str(e))
|
|
|
|
return 'fail'
|
|
|
|
|
|
|
|
# make the new solid_geometry
|
2020-02-29 22:52:24 +00:00
|
|
|
new_solid_geo = []
|
2019-12-29 23:18:56 +00:00
|
|
|
for apid in self.apertures:
|
|
|
|
if 'geometry' in self.apertures[apid]:
|
|
|
|
new_solid_geo += [geo_el['solid'] for geo_el in self.apertures[apid]['geometry']]
|
|
|
|
|
|
|
|
self.solid_geometry = MultiPolygon(new_solid_geo)
|
|
|
|
self.solid_geometry = self.solid_geometry.buffer(0.000001)
|
|
|
|
self.solid_geometry = self.solid_geometry.buffer(-0.000001)
|
2019-12-23 20:59:01 +00:00
|
|
|
|
|
|
|
self.app.inform.emit('[success] %s' % _("Gerber Buffer done."))
|
|
|
|
self.app.proc_container.new_text = ''
|
|
|
|
|
2019-10-12 01:49:50 +00:00
|
|
|
|
|
|
|
def parse_gerber_number(strnumber, int_digits, frac_digits, zeros):
|
|
|
|
"""
|
|
|
|
Parse a single number of Gerber coordinates.
|
|
|
|
|
|
|
|
:param strnumber: String containing a number in decimal digits
|
|
|
|
from a coordinate data block, possibly with a leading sign.
|
|
|
|
:type strnumber: str
|
|
|
|
:param int_digits: Number of digits used for the integer
|
|
|
|
part of the number
|
|
|
|
:type frac_digits: int
|
|
|
|
:param frac_digits: Number of digits used for the fractional
|
|
|
|
part of the number
|
|
|
|
:type frac_digits: int
|
|
|
|
:param zeros: If 'L', leading zeros are removed and trailing zeros are kept. Same situation for 'D' when
|
|
|
|
no zero suppression is done. If 'T', is in reverse.
|
|
|
|
:type zeros: str
|
|
|
|
:return: The number in floating point.
|
|
|
|
:rtype: float
|
|
|
|
"""
|
|
|
|
|
|
|
|
ret_val = None
|
|
|
|
|
|
|
|
if zeros == 'L' or zeros == 'D':
|
|
|
|
ret_val = int(strnumber) * (10 ** (-frac_digits))
|
|
|
|
|
|
|
|
if zeros == 'T':
|
|
|
|
int_val = int(strnumber)
|
|
|
|
ret_val = (int_val * (10 ** ((int_digits + frac_digits) - len(strnumber)))) * (10 ** (-frac_digits))
|
|
|
|
|
|
|
|
return ret_val
|