2545da79b5
- updated the convert_any2geo() method such that resulting geometry objects have the tools attribute required in the newer versions of the app
2539 lines
113 KiB
Python
2539 lines
113 KiB
Python
from PyQt5 import QtWidgets
|
|
from camlib import Geometry, arc, arc_angle, ApertureMacro, grace
|
|
|
|
import numpy as np
|
|
import traceback
|
|
from copy import deepcopy
|
|
|
|
from shapely.ops import unary_union, linemerge
|
|
import shapely.affinity as affinity
|
|
from shapely.geometry import box as shply_box
|
|
|
|
from lxml import etree as ET
|
|
import ezdxf
|
|
|
|
from appParsers.ParseDXF import *
|
|
from appParsers.ParseSVG import svgparselength, getsvggeo, svgparse_viewbox
|
|
|
|
import gettext
|
|
import builtins
|
|
|
|
if '_' not in builtins.__dict__:
|
|
_ = gettext.gettext
|
|
|
|
log = logging.getLogger('base')
|
|
|
|
|
|
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
|
|
# }
|
|
|
|
app = None
|
|
|
|
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"])
|
|
self.decimals = self.app.decimals
|
|
|
|
# Initialize parent
|
|
Geometry.__init__(self, geo_steps_per_circle=self.steps_per_circle)
|
|
|
|
# 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:
|
|
self.units = self.app.defaults['gerber_def_units']
|
|
|
|
# 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'(.*)%$')
|
|
|
|
# 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
|
|
|
|
self.use_buffer_for_union = self.app.defaults["gerber_use_buffer_for_union"]
|
|
|
|
# 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']
|
|
|
|
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
|
|
raise grace
|
|
|
|
# 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')
|
|
except Exception:
|
|
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]),
|
|
"size": np.sqrt(float(paramList[0]) ** 2 + float(paramList[1]) ** 2)} # Hack
|
|
return apid
|
|
|
|
if apertureType == "O": # Obround
|
|
self.apertures[apid] = {"type": "O",
|
|
"width": float(paramList[0]),
|
|
"height": float(paramList[1]),
|
|
"size": np.sqrt(float(paramList[0]) ** 2 + float(paramList[1]) ** 2)} # Hack
|
|
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",
|
|
# "size": 0.0,
|
|
"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.
|
|
# Only then they are combined via unary_union and added or
|
|
# 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
|
|
current_x = 0
|
|
current_y = 0
|
|
previous_x = 0
|
|
previous_y = 0
|
|
|
|
current_d = None
|
|
|
|
# Absolute or Relative/Incremental coordinates
|
|
# Not implemented
|
|
# absolute = True
|
|
|
|
# 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").lower()))
|
|
try:
|
|
for gline in glines:
|
|
if self.app.abort_flag:
|
|
# graceful abort requested by the user
|
|
raise grace
|
|
|
|
line_num += 1
|
|
self.source_file += gline + '\n'
|
|
|
|
# Cleanup #
|
|
gline = gline.strip(' \r\n')
|
|
# log.debug("Line=%3s %s" % (line_num, gline))
|
|
|
|
# ###############################################################
|
|
# ################ Ignored lines ############################
|
|
# ################ Comments ############################
|
|
# ###############################################################
|
|
match = self.comm_re.search(gline)
|
|
if match:
|
|
continue
|
|
|
|
# ###############################################################
|
|
# ################ Polarity change #############################
|
|
# ######## Example: %LPD*% or %LPC*% ###################
|
|
# ######## If polarity changes, creates geometry from current #
|
|
# ######## buffer, then adds or subtracts accordingly. #
|
|
# ###############################################################
|
|
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
|
|
try:
|
|
path_length = len(path)
|
|
except TypeError:
|
|
path_length = 1
|
|
|
|
if path_length > 1 and current_polarity != new_polarity:
|
|
|
|
# finish the current path and add it to the storage
|
|
# --- Buffered ----
|
|
width = self.apertures[last_path_aperture]["size"]
|
|
|
|
geo_dict = {}
|
|
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))
|
|
if not geo_s.is_empty and geo_s.is_valid:
|
|
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:
|
|
self.apertures[last_path_aperture] = {}
|
|
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
|
|
try:
|
|
buff_length = len(poly_buffer)
|
|
except TypeError:
|
|
buff_length = 1
|
|
|
|
if buff_length > 0:
|
|
if current_polarity == 'D':
|
|
self.solid_geometry = self.solid_geometry.union(unary_union(poly_buffer))
|
|
|
|
else:
|
|
self.solid_geometry = self.solid_geometry.difference(unary_union(poly_buffer))
|
|
|
|
# follow_buffer = []
|
|
poly_buffer = []
|
|
|
|
current_polarity = new_polarity
|
|
continue
|
|
|
|
# ################################################################
|
|
# ##################### Number format ###########################
|
|
# ##################### Example: %FSLAX24Y24*% #################
|
|
# ################################################################
|
|
|
|
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
|
|
|
|
# ################################################################
|
|
# ######################## Mode (IN/MM) #######################
|
|
# ##################### Example: %MOIN*% #####################
|
|
# ################################################################
|
|
match = self.mode_re.search(gline)
|
|
if match:
|
|
self.units = match.group(1)
|
|
log.debug("Gerber units found = %s" % self.units)
|
|
# Changed for issue #80
|
|
# self.convert_units(match.group(1))
|
|
self.conversion_done = True
|
|
continue
|
|
|
|
# ################################################################
|
|
# Combined Number format and Mode --- Allegro does this ##########
|
|
# ################################################################
|
|
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)
|
|
|
|
self.units = match.group(5)
|
|
log.debug("Gerber units found = %s" % self.units)
|
|
# Changed for issue #80
|
|
# self.convert_units(match.group(5))
|
|
self.conversion_done = True
|
|
continue
|
|
|
|
# ################################################################
|
|
# #### Search for OrCAD way for having Number format ########
|
|
# ################################################################
|
|
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)
|
|
|
|
self.units = match.group(1)
|
|
log.debug("Gerber units found = %s" % self.units)
|
|
# Changed for issue #80
|
|
# self.convert_units(match.group(5))
|
|
self.conversion_done = True
|
|
continue
|
|
|
|
# ################################################################
|
|
# ############ Units (G70/1) OBSOLETE ######################
|
|
# ################################################################
|
|
match = self.units_re.search(gline)
|
|
if match:
|
|
obs_gerber_units = {'0': 'IN', '1': 'MM'}[match.group(1)]
|
|
self.units = obs_gerber_units
|
|
log.warning("Gerber obsolete units found = %s" % obs_gerber_units)
|
|
# Changed for issue #80
|
|
# self.convert_units({'0': 'IN', '1': 'MM'}[match.group(1)])
|
|
self.conversion_done = True
|
|
continue
|
|
|
|
# ################################################################
|
|
# ##### Absolute/relative coordinates G90/1 OBSOLETE ###########
|
|
# ################################################################
|
|
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
|
|
|
|
# ################################################################
|
|
# Aperture Macros ################################################
|
|
# Having this at the beginning will slow things down
|
|
# but macros can have complicated statements than could
|
|
# be caught by other patterns.
|
|
# ################################################################
|
|
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
|
|
|
|
# ################################################################
|
|
# ############## Aperture definitions %ADD... #################
|
|
# ################################################################
|
|
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
|
|
|
|
# ################################################################
|
|
# ################ Operation code alone #########################
|
|
# ########### Operation code alone, usually just D03 (Flash) ###
|
|
# self.opcode_re = re.compile(r'^D0?([123])\*$')
|
|
# ################################################################
|
|
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:
|
|
# log.debug("Bare op-code %d." % current_operation_code)
|
|
geo_dict = {}
|
|
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:
|
|
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))
|
|
|
|
except IndexError:
|
|
log.warning("Line %d: %s -> Nothing there to flash!" % (line_num, gline))
|
|
|
|
continue
|
|
|
|
# ################################################################
|
|
# ################ Tool/aperture change ########################
|
|
# ################ Example: D12* ########################
|
|
# ################################################################
|
|
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.
|
|
if self.apertures[current_aperture]["type"] != "AM":
|
|
if self.apertures[current_aperture]["size"] == 0:
|
|
self.apertures[current_aperture]["size"] = 10 ** -self.decimals
|
|
# log.debug(self.apertures[current_aperture])
|
|
|
|
# Take care of the current path with the previous tool
|
|
try:
|
|
path_length = len(path)
|
|
except TypeError:
|
|
path_length = 1
|
|
|
|
if path_length > 1:
|
|
if self.apertures[last_path_aperture]["type"] == 'R':
|
|
# do nothing because 'R' type moving aperture is none at once
|
|
pass
|
|
else:
|
|
geo_dict = {}
|
|
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:
|
|
self.apertures[last_path_aperture] = {}
|
|
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
|
|
|
|
# ################################################################
|
|
# ################ G36* - Begin region ########################
|
|
# ################################################################
|
|
if self.regionon_re.search(gline):
|
|
try:
|
|
path_length = len(path)
|
|
except TypeError:
|
|
path_length = 1
|
|
|
|
if path_length > 1:
|
|
# Take care of what is left in the path
|
|
|
|
geo_dict = {}
|
|
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:
|
|
self.apertures[last_path_aperture] = {}
|
|
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
|
|
|
|
# ################################################################
|
|
# ################ G37* - End region ########################
|
|
# ################################################################
|
|
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
|
|
self.apertures['0']['geometry'] = []
|
|
|
|
# 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:
|
|
try:
|
|
path_length = len(path)
|
|
except TypeError:
|
|
path_length = 1
|
|
|
|
if path_length == 1:
|
|
# this means that the geometry was prepared previously and we just need to add it
|
|
geo_dict = {}
|
|
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.
|
|
try:
|
|
path_length = len(path)
|
|
except TypeError:
|
|
path_length = 1
|
|
|
|
if path_length < 3:
|
|
# 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 ---
|
|
geo_dict = {}
|
|
if current_aperture in self.apertures:
|
|
# the following line breaks loading of Circuit Studio Gerber files
|
|
# buff_value = float(self.apertures[current_aperture]['size']) / 2.0
|
|
# 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
|
|
else:
|
|
region_geo = Polygon(path)
|
|
|
|
region_f = region_geo.exterior
|
|
if not region_f.is_empty:
|
|
follow_buffer.append(region_f)
|
|
geo_dict['follow'] = region_f
|
|
|
|
region_s = region_geo
|
|
if not region_s.is_valid:
|
|
region_s = region_s.buffer(0, int(self.steps_per_circle))
|
|
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)
|
|
|
|
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
|
|
|
|
# ################################################################
|
|
# ################ G01/2/3* - Interpolation mode change #########
|
|
# #### Can occur along with coordinates and operation code but ##
|
|
# #### sometimes by itself (handled here). #####################
|
|
# #### Example: G01* #####################
|
|
# ################################################################
|
|
match = self.interp_re.search(gline)
|
|
if match:
|
|
current_interpolation_mode = int(match.group(1))
|
|
continue
|
|
|
|
# ################################################################
|
|
# ######### G01 - Linear interpolation plus flashes #############
|
|
# ######### Operation code (D0x) missing is deprecated #########
|
|
# REGEX: r'^(?:G0?(1))?(?:X(-?\d+))?(?:Y(-?\d+))?(?:D0([123]))?\*$'
|
|
# ################################################################
|
|
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))
|
|
# except Exception:
|
|
# 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])
|
|
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]]
|
|
|
|
# treat the case when there is a flash inside a Gerber Region when the current_aperture
|
|
# is None
|
|
if current_aperture is None:
|
|
pass
|
|
else:
|
|
# --- 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))
|
|
|
|
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))
|
|
|
|
geo_dict = {}
|
|
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:
|
|
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))
|
|
except Exception:
|
|
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:
|
|
try:
|
|
path_length = len(path)
|
|
except TypeError:
|
|
path_length = 1
|
|
|
|
if path_length > 1:
|
|
geo_s = None
|
|
|
|
geo_dict = {}
|
|
# --- 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:
|
|
self.apertures[last_path_aperture] = {}
|
|
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.
|
|
try:
|
|
path_length = len(path)
|
|
except TypeError:
|
|
path_length = 1
|
|
|
|
if path_length > 1:
|
|
# --- Buffered ----
|
|
geo_dict = {}
|
|
|
|
# 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
|
|
except Exception:
|
|
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:
|
|
self.apertures[last_path_aperture] = {}
|
|
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
|
|
geo_dict = {}
|
|
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:
|
|
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))
|
|
|
|
# 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
|
|
|
|
# ################################################################
|
|
# ######### G74/75* - Single or multiple quadrant arcs ##########
|
|
# ################################################################
|
|
match = self.quad_re.search(gline)
|
|
if match:
|
|
if match.group(1) == '4':
|
|
quadrant_mode = 'SINGLE'
|
|
else:
|
|
quadrant_mode = 'MULTI'
|
|
continue
|
|
|
|
# ################################################################
|
|
# ######### 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 #########
|
|
# ################################################################
|
|
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)
|
|
except Exception:
|
|
circular_x = current_x
|
|
|
|
try:
|
|
circular_y = parse_gerber_number(circular_y,
|
|
self.int_digits, self.frac_digits, self.gerber_zeros)
|
|
except Exception:
|
|
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)
|
|
except Exception:
|
|
i = 0
|
|
|
|
try:
|
|
j = parse_gerber_number(j, self.int_digits, self.frac_digits, self.gerber_zeros)
|
|
except Exception:
|
|
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)
|
|
try:
|
|
path_length = len(path)
|
|
except TypeError:
|
|
path_length = 1
|
|
|
|
if path_length > 1:
|
|
geo_dict = {}
|
|
|
|
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:
|
|
self.apertures[last_path_aperture] = {}
|
|
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]
|
|
radius = np.sqrt(i ** 2 + j ** 2)
|
|
start = np.arctan2(-j, -i) # Start angle
|
|
# 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:
|
|
stop = np.arctan2(-center[1] + circular_y, -center[0] + circular_x) # Stop angle
|
|
|
|
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:
|
|
radius = np.sqrt(i ** 2 + j ** 2)
|
|
|
|
# Make sure radius to start is the same as radius to end.
|
|
radius2 = np.sqrt((center[0] - circular_x) ** 2 + (center[1] - circular_y) ** 2)
|
|
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
|
|
|
|
start = np.arctan2(-j, -i) # Start angle
|
|
stop = np.arctan2(-center[1] + circular_y, -center[0] + circular_x) # Stop angle
|
|
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" %
|
|
(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))
|
|
|
|
if angle <= (np.pi + 1e-6) / 2:
|
|
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)
|
|
|
|
# ################################################################
|
|
# ######### EOF - END OF FILE ####################################
|
|
# ################################################################
|
|
match = self.eof_re.search(gline)
|
|
if match:
|
|
continue
|
|
|
|
# ################################################################
|
|
# ######### Line did not match any pattern. Warn user. ##########
|
|
# ################################################################
|
|
log.warning("Line ignored (%d): %s" % (line_num, gline))
|
|
# provide the app with a way to process the GUI events when in a blocking loop
|
|
QtWidgets.QApplication.processEvents()
|
|
|
|
try:
|
|
path_length = len(path)
|
|
except TypeError:
|
|
path_length = 1
|
|
|
|
if path_length > 1:
|
|
# 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 ---
|
|
|
|
geo_dict = {}
|
|
# 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:
|
|
self.apertures[last_path_aperture] = {}
|
|
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
|
|
try:
|
|
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:
|
|
if buff_length == 0 and sol_geo_length in [0, 1] and self.solid_geometry.area == 0:
|
|
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))
|
|
return 'fail'
|
|
|
|
log.warning("Joining %d polygons." % buff_length)
|
|
self.app.inform.emit('%s: %d.' % (_("Gerber processing. Joining polygons"), buff_length))
|
|
|
|
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)
|
|
log.warning("Union(buffer) done.")
|
|
|
|
else:
|
|
log.debug("Union by union()...")
|
|
new_poly = unary_union(poly_buffer)
|
|
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:
|
|
self.solid_geometry = self.solid_geometry.union(new_poly)
|
|
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
|
|
|
|
# FIX for issue #347 - Sprint Layout generate Gerber files when the copper pour is enabled
|
|
# 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']:
|
|
candidate_geo = []
|
|
try:
|
|
for p in self.solid_geometry:
|
|
candidate_geo.append(p.buffer(-0.0000001))
|
|
except TypeError:
|
|
candidate_geo.append(self.solid_geometry.buffer(-0.0000001))
|
|
self.solid_geometry = candidate_geo
|
|
|
|
# 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)
|
|
# except Exception:
|
|
# pass
|
|
else:
|
|
self.solid_geometry = self.solid_geometry.difference(new_poly)
|
|
|
|
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)
|
|
|
|
# init this for the following operations
|
|
self.conversion_done = False
|
|
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))
|
|
return unary_union([c1, c2]).convex_hull
|
|
|
|
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):
|
|
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))
|
|
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()
|
|
#
|
|
# self.solid_geometry = unary_union(self.buffered_paths +
|
|
# [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
|
|
|
|
def bounds(self, flatten=None):
|
|
"""
|
|
Returns coordinates of rectangular bounds
|
|
of Gerber geometry: (xmin, ymin, xmax, ymax).
|
|
|
|
:param flatten: Not used, it is here for compatibility with base class method
|
|
:return: None
|
|
"""
|
|
|
|
log.debug("parseGerber.Gerber.bounds()")
|
|
|
|
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:
|
|
minx = np.Inf
|
|
miny = np.Inf
|
|
maxx = -np.Inf
|
|
maxy = -np.Inf
|
|
|
|
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
|
|
|
|
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
|
|
it again in descendants.
|
|
|
|
:param obj_units: "IN" or "MM"
|
|
:type obj_units: str
|
|
: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
|
|
|
|
def import_svg(self, filename, object_type='gerber', flip=True, units=None):
|
|
"""
|
|
Imports shapes from an SVG file into the object's geometry.
|
|
|
|
: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
|
|
:return: None
|
|
"""
|
|
|
|
log.debug("appParsers.ParseGerber.Gerber.import_svg()")
|
|
|
|
# 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
|
|
|
|
units = self.app.defaults['units'] if units is None else units
|
|
res = self.app.defaults['gerber_circle_steps']
|
|
factor = svgparse_viewbox(svg_root)
|
|
geos = getsvggeo(svg_root, 'gerber', units=units, res=res, factor=factor)
|
|
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:
|
|
self.solid_geometry = []
|
|
|
|
# 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
|
|
try:
|
|
geos_length = len(geos)
|
|
except TypeError:
|
|
geos_length = 1
|
|
|
|
if geos_length == 1:
|
|
geo_qrcode = [Polygon(geos[0].exterior)]
|
|
for i_el in geos[0].interiors:
|
|
geo_qrcode.append(Polygon(i_el).buffer(0, resolution=res))
|
|
geos = [poly for poly in geo_qrcode]
|
|
|
|
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:
|
|
self.apertures['0'] = {
|
|
'type': 'REG',
|
|
'size': 0.0,
|
|
'geometry': []
|
|
}
|
|
|
|
for pol in self.solid_geometry:
|
|
new_el = {'solid': pol, 'follow': pol.exterior}
|
|
self.apertures['0']['geometry'].append(new_el)
|
|
|
|
def import_dxf_as_gerber(self, filename, units='MM'):
|
|
"""
|
|
Imports shapes from an DXF file into the Gerber object 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'] = {
|
|
'type': 'REG',
|
|
'size': 0.0,
|
|
'geometry': []
|
|
}
|
|
|
|
for pol in flat_geo:
|
|
new_el = {'solid': pol, 'follow': pol}
|
|
self.apertures['0']['geometry'].append(deepcopy(new_el))
|
|
|
|
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
|
|
:param point: reference point for scaling operation
|
|
:rtype : None
|
|
"""
|
|
log.debug("parseGerber.Gerber.scale()")
|
|
|
|
try:
|
|
xfactor = float(xfactor)
|
|
except Exception:
|
|
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)
|
|
except Exception:
|
|
self.app.inform.emit('[ERROR_NOTCL] %s' %
|
|
_("Scale factor has to be a number: integer or float."))
|
|
return
|
|
|
|
if xfactor == 0 and yfactor == 0:
|
|
return
|
|
|
|
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:
|
|
self.geo_len = len(self.solid_geometry)
|
|
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:
|
|
new_geometry = []
|
|
if 'geometry' in self.apertures[apid]:
|
|
for geo_el in self.apertures[apid]['geometry']:
|
|
new_geo_el = {}
|
|
if 'solid' in geo_el:
|
|
new_geo_el['solid'] = scale_geom(geo_el['solid'])
|
|
if 'follow' in geo_el:
|
|
new_geo_el['follow'] = scale_geom(geo_el['follow'])
|
|
if 'clear' in geo_el:
|
|
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
|
|
|
|
except Exception as e:
|
|
log.debug('camlib.Gerber.scale() Exception --> %s' % str(e))
|
|
return 'fail'
|
|
|
|
self.app.inform.emit('[success] %s' % _("Done."))
|
|
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
|
|
"""
|
|
log.debug("parseGerber.Gerber.offset()")
|
|
|
|
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
|
|
|
|
if dx == 0 and dy == 0:
|
|
return
|
|
|
|
# variables to display the percentage of work done
|
|
self.geo_len = 0
|
|
try:
|
|
self.geo_len = len(self.solid_geometry)
|
|
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' % _("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
|
|
"""
|
|
log.debug("parseGerber.Gerber.mirror()")
|
|
|
|
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:
|
|
self.geo_len = len(self.solid_geometry)
|
|
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' % _("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
|
|
: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
|
|
"""
|
|
log.debug("parseGerber.Gerber.skew()")
|
|
|
|
px, py = point
|
|
|
|
if angle_x == 0 and angle_y == 0:
|
|
return
|
|
|
|
# variables to display the percentage of work done
|
|
self.geo_len = 0
|
|
try:
|
|
self.geo_len = len(self.solid_geometry)
|
|
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'
|
|
|
|
self.app.inform.emit('[success] %s' % _("Done."))
|
|
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:
|
|
"""
|
|
log.debug("parseGerber.Gerber.rotate()")
|
|
|
|
px, py = point
|
|
|
|
if angle == 0:
|
|
return
|
|
|
|
# variables to display the percentage of work done
|
|
self.geo_len = 0
|
|
try:
|
|
self.geo_len = len(self.solid_geometry)
|
|
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'
|
|
self.app.inform.emit('[success] %s' % _("Done."))
|
|
self.app.proc_container.new_text = ''
|
|
|
|
def buffer(self, distance, join=2, factor=None):
|
|
"""
|
|
|
|
: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)
|
|
:return:
|
|
"""
|
|
log.debug("parseGerber.Gerber.buffer()")
|
|
|
|
if distance == 0:
|
|
return
|
|
|
|
# variables to display the percentage of work done
|
|
self.geo_len = 0
|
|
try:
|
|
self.geo_len = len(self.solid_geometry)
|
|
except (TypeError, ValueError):
|
|
self.geo_len = 1
|
|
|
|
self.old_disp_number = 0
|
|
self.el_count = 0
|
|
|
|
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
|
|
|
|
return obj.buffer(distance, resolution=int(self.steps_per_circle), join_style=join)
|
|
|
|
except AttributeError:
|
|
return obj
|
|
|
|
res = buffer_geom(self.solid_geometry)
|
|
try:
|
|
__ = iter(res)
|
|
self.solid_geometry = res
|
|
except TypeError:
|
|
self.solid_geometry = [res]
|
|
|
|
# we need to buffer the geometry stored in the Gerber apertures, too
|
|
try:
|
|
for apid in self.apertures:
|
|
new_geometry = []
|
|
if 'geometry' in self.apertures[apid]:
|
|
for geo_el in self.apertures[apid]['geometry']:
|
|
new_geo_el = {}
|
|
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)
|
|
|
|
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
|
|
|
|
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
|
|
|
|
new_geometry = []
|
|
if 'geometry' in self.apertures[apid]:
|
|
for geo_el in self.apertures[apid]['geometry']:
|
|
new_geo_el = {}
|
|
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:
|
|
log.debug("appParsers.ParseGerber.Gerber.buffer() --> "
|
|
"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
|
|
new_solid_geo = []
|
|
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)
|
|
|
|
self.app.inform.emit('[success] %s' % _("Gerber Buffer done."))
|
|
self.app.proc_container.new_text = ''
|
|
|
|
|
|
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
|