summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rwxr-xr-xgerber/excellon.py1791
-rw-r--r--gerber/tests/test_excellon.py27
2 files changed, 928 insertions, 890 deletions
diff --git a/gerber/excellon.py b/gerber/excellon.py
index c3de948..5ab062a 100755
--- a/gerber/excellon.py
+++ b/gerber/excellon.py
@@ -1,887 +1,904 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-# Copyright 2014 Hamilton Kibbe <ham@hamiltonkib.be>
-
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-
-# http://www.apache.org/licenses/LICENSE-2.0
-
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-Excellon File module
-====================
-**Excellon file classes**
-
-This module provides Excellon file classes and parsing utilities
-"""
-
-import math
-import operator
-
-from .cam import CamFile, FileSettings
-from .excellon_statements import *
-from .excellon_tool import ExcellonToolDefinitionParser
-from .primitives import Drill, Slot
-from .utils import inch, metric
-
-
-try:
- from cStringIO import StringIO
-except(ImportError):
- from io import StringIO
-
-
-
-def read(filename):
- """ Read data from filename and return an ExcellonFile
- Parameters
- ----------
- filename : string
- Filename of file to parse
-
- Returns
- -------
- file : :class:`gerber.excellon.ExcellonFile`
- An ExcellonFile created from the specified file.
-
- """
- # File object should use settings from source file by default.
- with open(filename, 'rU') as f:
- data = f.read()
- settings = FileSettings(**detect_excellon_format(data))
- return ExcellonParser(settings).parse(filename)
-
-def loads(data, filename=None, settings=None, tools=None):
- """ Read data from string and return an ExcellonFile
- Parameters
- ----------
- data : string
- string containing Excellon file contents
-
- filename : string, optional
- string containing the filename of the data source
-
- tools: dict (optional)
- externally defined tools
-
- Returns
- -------
- file : :class:`gerber.excellon.ExcellonFile`
- An ExcellonFile created from the specified file.
-
- """
- # File object should use settings from source file by default.
- if not settings:
- settings = FileSettings(**detect_excellon_format(data))
- return ExcellonParser(settings, tools).parse_raw(data, filename)
-
-
-class DrillHit(object):
- """Drill feature that is a single drill hole.
-
- Attributes
- ----------
- tool : ExcellonTool
- Tool to drill the hole. Defines the size of the hole that is generated.
- position : tuple(float, float)
- Center position of the drill.
-
- """
- def __init__(self, tool, position):
- self.tool = tool
- self.position = position
-
- def to_inch(self):
- if self.tool.settings.units == 'metric':
- self.tool.to_inch()
- self.position = tuple(map(inch, self.position))
-
- def to_metric(self):
- if self.tool.settings.units == 'inch':
- self.tool.to_metric()
- self.position = tuple(map(metric, self.position))
-
- @property
- def bounding_box(self):
- position = self.position
- radius = self.tool.diameter / 2.
-
- min_x = position[0] - radius
- max_x = position[0] + radius
- min_y = position[1] - radius
- max_y = position[1] + radius
- return ((min_x, max_x), (min_y, max_y))
-
- def offset(self, x_offset=0, y_offset=0):
- self.position = tuple(map(operator.add, self.position, (x_offset, y_offset)))
-
- def __str__(self):
- return 'Hit (%f, %f) {%s}' % (self.position[0], self.position[1], self.tool)
-
-class DrillSlot(object):
- """
- A slot is created between two points. The way the slot is created depends on the statement used to create it
- """
-
- TYPE_ROUT = 1
- TYPE_G85 = 2
-
- def __init__(self, tool, start, end, slot_type):
- self.tool = tool
- self.start = start
- self.end = end
- self.slot_type = slot_type
-
- def to_inch(self):
- if self.tool.settings.units == 'metric':
- self.tool.to_inch()
- self.start = tuple(map(inch, self.start))
- self.end = tuple(map(inch, self.end))
-
- def to_metric(self):
- if self.tool.settings.units == 'inch':
- self.tool.to_metric()
- self.start = tuple(map(metric, self.start))
- self.end = tuple(map(metric, self.end))
-
- @property
- def bounding_box(self):
- start = self.start
- end = self.end
- radius = self.tool.diameter / 2.
- min_x = min(start[0], end[0]) - radius
- max_x = max(start[0], end[0]) + radius
- min_y = min(start[1], end[1]) - radius
- max_y = max(start[1], end[1]) + radius
- return ((min_x, max_x), (min_y, max_y))
-
- def offset(self, x_offset=0, y_offset=0):
- self.start = tuple(map(operator.add, self.start, (x_offset, y_offset)))
- self.end = tuple(map(operator.add, self.end, (x_offset, y_offset)))
-
-
-class ExcellonFile(CamFile):
- """ A class representing a single excellon file
-
- The ExcellonFile class represents a single excellon file.
-
- http://www.excellon.com/manuals/program.htm
- (archived version at https://web.archive.org/web/20150920001043/http://www.excellon.com/manuals/program.htm)
-
- Parameters
- ----------
- tools : list
- list of gerber file statements
-
- hits : list of tuples
- list of drill hits as (<Tool>, (x, y))
-
- settings : dict
- Dictionary of gerber file settings
-
- filename : string
- Filename of the source gerber file
-
- Attributes
- ----------
- units : string
- either 'inch' or 'metric'.
-
- """
-
- def __init__(self, statements, tools, hits, settings, filename=None):
- super(ExcellonFile, self).__init__(statements=statements,
- settings=settings,
- filename=filename)
- self.tools = tools
- self.hits = hits
-
- @property
- def primitives(self):
- """
- Gets the primitives. Note that unlike Gerber, this generates new objects
- """
- primitives = []
- for hit in self.hits:
- if isinstance(hit, DrillHit):
- primitives.append(Drill(hit.position, hit.tool.diameter,
- units=self.settings.units))
- elif isinstance(hit, DrillSlot):
- primitives.append(Slot(hit.start, hit.end, hit.tool.diameter,
- units=self.settings.units))
- else:
- raise ValueError('Unknown hit type')
- return primitives
-
- @property
- def bounding_box(self):
- xmin = ymin = 100000000000
- xmax = ymax = -100000000000
- for hit in self.hits:
- bbox = hit.bounding_box
- xmin = min(bbox[0][0], xmin)
- xmax = max(bbox[0][1], xmax)
- ymin = min(bbox[1][0], ymin)
- ymax = max(bbox[1][1], ymax)
- return ((xmin, xmax), (ymin, ymax))
-
- def report(self, filename=None):
- """ Print or save drill report
- """
- if self.settings.units == 'inch':
- toolfmt = ' T{:0>2d} {:%d.%df} {: >3d} {:f}in.\n' % self.settings.format
- else:
- toolfmt = ' T{:0>2d} {:%d.%df} {: >3d} {:f}mm\n' % self.settings.format
- rprt = '=====================\nExcellon Drill Report\n=====================\n'
- if self.filename is not None:
- rprt += 'NC Drill File: %s\n\n' % self.filename
- rprt += 'Drill File Info:\n----------------\n'
- rprt += (' Data Mode %s\n' % 'Absolute'
- if self.settings.notation == 'absolute' else 'Incremental')
- rprt += (' Units %s\n' % 'Inches'
- if self.settings.units == 'inch' else 'Millimeters')
- rprt += '\nTool List:\n----------\n\n'
- rprt += ' Code Size Hits Path Length\n'
- rprt += ' --------------------------------------\n'
- for tool in iter(self.tools.values()):
- rprt += toolfmt.format(tool.number, tool.diameter,
- tool.hit_count, self.path_length(tool.number))
- if filename is not None:
- with open(filename, 'w') as f:
- f.write(rprt)
- return rprt
-
- def write(self, filename=None):
- filename = filename if filename is not None else self.filename
- with open(filename, 'w') as f:
-
- # Copy the header verbatim
- for statement in self.statements:
- if not isinstance(statement, ToolSelectionStmt):
- f.write(statement.to_excellon(self.settings) + '\n')
- else:
- break
-
- # Write out coordinates for drill hits by tool
- for tool in iter(self.tools.values()):
- f.write(ToolSelectionStmt(tool.number).to_excellon(self.settings) + '\n')
- for hit in self.hits:
- if hit.tool.number == tool.number:
- f.write(CoordinateStmt(
- *hit.position).to_excellon(self.settings) + '\n')
- f.write(EndOfProgramStmt().to_excellon() + '\n')
-
- def to_inch(self):
- """
- Convert units to inches
- """
- if self.units != 'inch':
- for statement in self.statements:
- statement.to_inch()
- for tool in iter(self.tools.values()):
- tool.to_inch()
- #for primitive in self.primitives:
- # primitive.to_inch()
- #for hit in self.hits:
- # hit.to_inch()
- self.units = 'inch'
-
- def to_metric(self):
- """ Convert units to metric
- """
- if self.units != 'metric':
- for statement in self.statements:
- statement.to_metric()
- for tool in iter(self.tools.values()):
- tool.to_metric()
- #for primitive in self.primitives:
- # print("Converting to metric: {}".format(primitive))
- # primitive.to_metric()
- # print(primitive)
- for hit in self.hits:
- hit.to_metric()
- self.units = 'metric'
-
- def offset(self, x_offset=0, y_offset=0):
- for statement in self.statements:
- statement.offset(x_offset, y_offset)
- for primitive in self.primitives:
- primitive.offset(x_offset, y_offset)
- for hit in self. hits:
- hit.offset(x_offset, y_offset)
-
- def path_length(self, tool_number=None):
- """ Return the path length for a given tool
- """
- lengths = {}
- positions = {}
- for hit in self.hits:
- tool = hit.tool
- num = tool.number
- positions[num] = ((0, 0) if positions.get(num) is None
- else positions[num])
- lengths[num] = 0.0 if lengths.get(num) is None else lengths[num]
- lengths[num] = lengths[
- num] + math.hypot(*tuple(map(operator.sub, positions[num], hit.position)))
- positions[num] = hit.position
-
- if tool_number is None:
- return lengths
- else:
- return lengths.get(tool_number)
-
- def hit_count(self, tool_number=None):
- counts = {}
- for tool in iter(self.tools.values()):
- counts[tool.number] = tool.hit_count
- if tool_number is None:
- return counts
- else:
- return counts.get(tool_number)
-
- def update_tool(self, tool_number, **kwargs):
- """ Change parameters of a tool
- """
- if kwargs.get('feed_rate') is not None:
- self.tools[tool_number].feed_rate = kwargs.get('feed_rate')
- if kwargs.get('retract_rate') is not None:
- self.tools[tool_number].retract_rate = kwargs.get('retract_rate')
- if kwargs.get('rpm') is not None:
- self.tools[tool_number].rpm = kwargs.get('rpm')
- if kwargs.get('diameter') is not None:
- self.tools[tool_number].diameter = kwargs.get('diameter')
- if kwargs.get('max_hit_count') is not None:
- self.tools[tool_number].max_hit_count = kwargs.get('max_hit_count')
- if kwargs.get('depth_offset') is not None:
- self.tools[tool_number].depth_offset = kwargs.get('depth_offset')
- # Update drill hits
- newtool = self.tools[tool_number]
- for hit in self.hits:
- if hit.tool.number == newtool.number:
- hit.tool = newtool
-
-
-class ExcellonParser(object):
- """ Excellon File Parser
-
- Parameters
- ----------
- settings : FileSettings or dict-like
- Excellon file settings to use when interpreting the excellon file.
- """
- def __init__(self, settings=None, ext_tools=None):
- self.notation = 'absolute'
- self.units = 'inch'
- self.zeros = 'leading'
- self.format = (2, 4)
- self.state = 'INIT'
- self.statements = []
- self.tools = {}
- self.ext_tools = ext_tools or {}
- self.comment_tools = {}
- self.hits = []
- self.active_tool = None
- self.pos = [0., 0.]
- self.drill_down = False
- # Default for plated is None, which means we don't know
- self.plated = ExcellonTool.PLATED_UNKNOWN
- if settings is not None:
- self.units = settings.units
- self.zeros = settings.zeros
- self.notation = settings.notation
- self.format = settings.format
-
- @property
- def coordinates(self):
- return [(stmt.x, stmt.y) for stmt in self.statements if isinstance(stmt, CoordinateStmt)]
-
- @property
- def bounds(self):
- xmin = ymin = 100000000000
- xmax = ymax = -100000000000
- for x, y in self.coordinates:
- if x is not None:
- xmin = x if x < xmin else xmin
- xmax = x if x > xmax else xmax
- if y is not None:
- ymin = y if y < ymin else ymin
- ymax = y if y > ymax else ymax
- return ((xmin, xmax), (ymin, ymax))
-
- @property
- def hole_sizes(self):
- return [stmt.diameter for stmt in self.statements if isinstance(stmt, ExcellonTool)]
-
- @property
- def hole_count(self):
- return len(self.hits)
-
- def parse(self, filename):
- with open(filename, 'rU') as f:
- data = f.read()
- return self.parse_raw(data, filename)
-
- def parse_raw(self, data, filename=None):
- for line in StringIO(data):
- self._parse_line(line.strip())
- for stmt in self.statements:
- stmt.units = self.units
- return ExcellonFile(self.statements, self.tools, self.hits,
- self._settings(), filename)
-
- def _parse_line(self, line):
- # skip empty lines
- if not line.strip():
- return
-
- if line[0] == ';':
- comment_stmt = CommentStmt.from_excellon(line)
- self.statements.append(comment_stmt)
-
- # get format from altium comment
- if "FILE_FORMAT" in comment_stmt.comment:
- detected_format = tuple(
- [int(x) for x in comment_stmt.comment.split('=')[1].split(":")])
- if detected_format:
- self.format = detected_format
-
- if "TYPE=PLATED" in comment_stmt.comment:
- self.plated = ExcellonTool.PLATED_YES
-
- if "TYPE=NON_PLATED" in comment_stmt.comment:
- self.plated = ExcellonTool.PLATED_NO
-
- if "HEADER:" in comment_stmt.comment:
- self.state = "HEADER"
-
- if " Holesize " in comment_stmt.comment:
- self.state = "HEADER"
-
- # Parse this as a hole definition
- tools = ExcellonToolDefinitionParser(self._settings()).parse_raw(comment_stmt.comment)
- if len(tools) == 1:
- tool = tools[tools.keys()[0]]
- self._add_comment_tool(tool)
-
- elif line[:3] == 'M48':
- self.statements.append(HeaderBeginStmt())
- self.state = 'HEADER'
-
- elif line[0] == '%':
- self.statements.append(RewindStopStmt())
- if self.state == 'HEADER':
- self.state = 'DRILL'
- elif self.state == 'INIT':
- self.state = 'HEADER'
-
- elif line[:3] == 'M00' and self.state == 'DRILL':
- if self.active_tool:
- cur_tool_number = self.active_tool.number
- next_tool = self._get_tool(cur_tool_number + 1)
-
- self.statements.append(NextToolSelectionStmt(self.active_tool, next_tool))
- self.active_tool = next_tool
- else:
- raise Exception('Invalid state exception')
-
- elif line[:3] == 'M95':
- self.statements.append(HeaderEndStmt())
- if self.state == 'HEADER':
- self.state = 'DRILL'
-
- elif line[:3] == 'M15':
- self.statements.append(ZAxisRoutPositionStmt())
- self.drill_down = True
-
- elif line[:3] == 'M16':
- self.statements.append(RetractWithClampingStmt())
- self.drill_down = False
-
- elif line[:3] == 'M17':
- self.statements.append(RetractWithoutClampingStmt())
- self.drill_down = False
-
- elif line[:3] == 'M30':
- stmt = EndOfProgramStmt.from_excellon(line, self._settings())
- self.statements.append(stmt)
-
- elif line[:3] == 'G00':
- self.statements.append(RouteModeStmt())
- self.state = 'ROUT'
-
- stmt = CoordinateStmt.from_excellon(line[3:], self._settings())
- stmt.mode = self.state
-
- x = stmt.x
- y = stmt.y
- self.statements.append(stmt)
- if self.notation == 'absolute':
- if x is not None:
- self.pos[0] = x
- if y is not None:
- self.pos[1] = y
- else:
- if x is not None:
- self.pos[0] += x
- if y is not None:
- self.pos[1] += y
-
- elif line[:3] == 'G01':
- self.statements.append(RouteModeStmt())
- self.state = 'LINEAR'
-
- stmt = CoordinateStmt.from_excellon(line[3:], self._settings())
- stmt.mode = self.state
-
- # The start position is where we were before the rout command
- start = (self.pos[0], self.pos[1])
-
- x = stmt.x
- y = stmt.y
- self.statements.append(stmt)
- if self.notation == 'absolute':
- if x is not None:
- self.pos[0] = x
- if y is not None:
- self.pos[1] = y
- else:
- if x is not None:
- self.pos[0] += x
- if y is not None:
- self.pos[1] += y
-
- # Our ending position
- end = (self.pos[0], self.pos[1])
-
- if self.drill_down:
- if not self.active_tool:
- self.active_tool = self._get_tool(1)
-
- self.hits.append(DrillSlot(self.active_tool, start, end, DrillSlot.TYPE_ROUT))
- self.active_tool._hit()
-
- elif line[:3] == 'G05':
- self.statements.append(DrillModeStmt())
- self.drill_down = False
- self.state = 'DRILL'
-
- elif 'INCH' in line or 'METRIC' in line:
- stmt = UnitStmt.from_excellon(line)
- self.units = stmt.units
- self.zeros = stmt.zeros
- if stmt.format:
- self.format = stmt.format
- self.statements.append(stmt)
-
- elif line[:3] == 'M71' or line[:3] == 'M72':
- stmt = MeasuringModeStmt.from_excellon(line)
- self.units = stmt.units
- self.statements.append(stmt)
-
- elif line[:3] == 'ICI':
- stmt = IncrementalModeStmt.from_excellon(line)
- self.notation = 'incremental' if stmt.mode == 'on' else 'absolute'
- self.statements.append(stmt)
-
- elif line[:3] == 'VER':
- stmt = VersionStmt.from_excellon(line)
- self.statements.append(stmt)
-
- elif line[:4] == 'FMAT':
- stmt = FormatStmt.from_excellon(line)
- self.statements.append(stmt)
- self.format = stmt.format_tuple
-
- elif line[:3] == 'G40':
- self.statements.append(CutterCompensationOffStmt())
-
- elif line[:3] == 'G41':
- self.statements.append(CutterCompensationLeftStmt())
-
- elif line[:3] == 'G42':
- self.statements.append(CutterCompensationRightStmt())
-
- elif line[:3] == 'G90':
- self.statements.append(AbsoluteModeStmt())
- self.notation = 'absolute'
-
- elif line[0] == 'F':
- infeed_rate_stmt = ZAxisInfeedRateStmt.from_excellon(line)
- self.statements.append(infeed_rate_stmt)
-
- elif line[0] == 'T' and self.state == 'HEADER':
- if not ',OFF' in line and not ',ON' in line:
- tool = ExcellonTool.from_excellon(line, self._settings(), None, self.plated)
- self._merge_properties(tool)
- self.tools[tool.number] = tool
- self.statements.append(tool)
- else:
- self.statements.append(UnknownStmt.from_excellon(line))
-
- elif line[0] == 'T' and self.state != 'HEADER':
- stmt = ToolSelectionStmt.from_excellon(line)
- self.statements.append(stmt)
-
- # T0 is used as END marker, just ignore
- if stmt.tool != 0:
- tool = self._get_tool(stmt.tool)
-
- if not tool:
- # FIXME: for weird files with no tools defined, original calc from gerb
- if self._settings().units == "inch":
- diameter = (16 + 8 * stmt.tool) / 1000.0
- else:
- diameter = metric((16 + 8 * stmt.tool) / 1000.0)
-
- tool = ExcellonTool(
- self._settings(), number=stmt.tool, diameter=diameter)
- self.tools[tool.number] = tool
-
- # FIXME: need to add this tool definition inside header to
- # make sure it is properly written
- for i, s in enumerate(self.statements):
- if isinstance(s, ToolSelectionStmt) or isinstance(s, ExcellonTool):
- self.statements.insert(i, tool)
- break
-
- self.active_tool = tool
-
- elif line[0] == 'R' and self.state != 'HEADER':
- stmt = RepeatHoleStmt.from_excellon(line, self._settings())
- self.statements.append(stmt)
- for i in range(stmt.count):
- self.pos[0] += stmt.xdelta if stmt.xdelta is not None else 0
- self.pos[1] += stmt.ydelta if stmt.ydelta is not None else 0
- self.hits.append(DrillHit(self.active_tool, tuple(self.pos)))
- self.active_tool._hit()
-
- elif line[0] in ['X', 'Y']:
- if 'G85' in line:
- stmt = SlotStmt.from_excellon(line, self._settings())
-
- # I don't know if this is actually correct, but it makes sense
- # that this is where the tool would end
- x = stmt.x_end
- y = stmt.y_end
-
- self.statements.append(stmt)
-
- if self.notation == 'absolute':
- if x is not None:
- self.pos[0] = x
- if y is not None:
- self.pos[1] = y
- else:
- if x is not None:
- self.pos[0] += x
- if y is not None:
- self.pos[1] += y
-
- if self.state == 'DRILL' or self.state == 'HEADER':
- if not self.active_tool:
- self.active_tool = self._get_tool(1)
-
- self.hits.append(DrillSlot(self.active_tool, (stmt.x_start, stmt.y_start), (stmt.x_end, stmt.y_end), DrillSlot.TYPE_G85))
- self.active_tool._hit()
- else:
- stmt = CoordinateStmt.from_excellon(line, self._settings())
-
- # We need this in case we are in rout mode
- start = (self.pos[0], self.pos[1])
-
- x = stmt.x
- y = stmt.y
- self.statements.append(stmt)
- if self.notation == 'absolute':
- if x is not None:
- self.pos[0] = x
- if y is not None:
- self.pos[1] = y
- else:
- if x is not None:
- self.pos[0] += x
- if y is not None:
- self.pos[1] += y
-
- if self.state == 'LINEAR' and self.drill_down:
- if not self.active_tool:
- self.active_tool = self._get_tool(1)
-
- self.hits.append(DrillSlot(self.active_tool, start, tuple(self.pos), DrillSlot.TYPE_ROUT))
-
- elif self.state == 'DRILL' or self.state == 'HEADER':
- # Yes, drills in the header doesn't follow the specification, but it there are many
- # files like this
- if not self.active_tool:
- self.active_tool = self._get_tool(1)
-
- self.hits.append(DrillHit(self.active_tool, tuple(self.pos)))
- self.active_tool._hit()
-
- else:
- self.statements.append(UnknownStmt.from_excellon(line))
-
- def _settings(self):
- return FileSettings(units=self.units, format=self.format,
- zeros=self.zeros, notation=self.notation)
-
- def _add_comment_tool(self, tool):
- """
- Add a tool that was defined in the comments to this file.
-
- If we have already found this tool, then we will merge this comment tool definition into
- the information for the tool
- """
-
- existing = self.tools.get(tool.number)
- if existing and existing.plated == None:
- existing.plated = tool.plated
-
- self.comment_tools[tool.number] = tool
-
- def _merge_properties(self, tool):
- """
- When we have externally defined tools, merge the properties of that tool into this one
-
- For now, this is only plated
- """
-
- if tool.plated == ExcellonTool.PLATED_UNKNOWN:
- ext_tool = self.ext_tools.get(tool.number)
-
- if ext_tool:
- tool.plated = ext_tool.plated
-
- def _get_tool(self, toolid):
-
- tool = self.tools.get(toolid)
- if not tool:
- tool = self.comment_tools.get(toolid)
- if tool:
- tool.settings = self._settings()
- self.tools[toolid] = tool
-
- if not tool:
- tool = self.ext_tools.get(toolid)
- if tool:
- tool.settings = self._settings()
- self.tools[toolid] = tool
-
- return tool
-
-def detect_excellon_format(data=None, filename=None):
- """ Detect excellon file decimal format and zero-suppression settings.
-
- Parameters
- ----------
- data : string
- String containing contents of Excellon file.
-
- Returns
- -------
- settings : dict
- Detected excellon file settings. Keys are
- - `format`: decimal format as tuple (<int part>, <decimal part>)
- - `zero_suppression`: zero suppression, 'leading' or 'trailing'
- """
- results = {}
- detected_zeros = None
- detected_format = None
- zeros_options = ('leading', 'trailing', )
- format_options = ((2, 4), (2, 5), (3, 3),)
-
- if data is None and filename is None:
- raise ValueError('Either data or filename arguments must be provided')
- if data is None:
- with open(filename, 'rU') as f:
- data = f.read()
-
- # Check for obvious clues:
- p = ExcellonParser()
- p.parse_raw(data)
-
- # Get zero_suppression from a unit statement
- zero_statements = [stmt.zeros for stmt in p.statements
- if isinstance(stmt, UnitStmt)]
-
- # get format from altium comment
- format_comment = [stmt.comment for stmt in p.statements
- if isinstance(stmt, CommentStmt)
- and 'FILE_FORMAT' in stmt.comment]
-
- detected_format = (tuple([int(val) for val in
- format_comment[0].split('=')[1].split(':')])
- if len(format_comment) == 1 else None)
- detected_zeros = zero_statements[0] if len(zero_statements) == 1 else None
-
- # Bail out here if possible
- if detected_format is not None and detected_zeros is not None:
- return {'format': detected_format, 'zeros': detected_zeros}
-
- # Only look at remaining options
- if detected_format is not None:
- format_options = (detected_format,)
- if detected_zeros is not None:
- zeros_options = (detected_zeros,)
-
- # Brute force all remaining options, and pick the best looking one...
- for zeros in zeros_options:
- for fmt in format_options:
- key = (fmt, zeros)
- settings = FileSettings(zeros=zeros, format=fmt)
- try:
- p = ExcellonParser(settings)
- ef = p.parse_raw(data)
- size = tuple([t[0] - t[1] for t in ef.bounding_box])
- hole_area = 0.0
- for hit in p.hits:
- tool = hit.tool
- hole_area += math.pow(math.pi * tool.diameter / 2., 2)
- results[key] = (size, p.hole_count, hole_area)
- except:
- pass
-
- # See if any of the dimensions are left with only a single option
- formats = set(key[0] for key in iter(results.keys()))
- zeros = set(key[1] for key in iter(results.keys()))
- if len(formats) == 1:
- detected_format = formats.pop()
- if len(zeros) == 1:
- detected_zeros = zeros.pop()
-
- # Bail out here if we got everything....
- if detected_format is not None and detected_zeros is not None:
- return {'format': detected_format, 'zeros': detected_zeros}
-
- # Otherwise score each option and pick the best candidate
- else:
- scores = {}
- for key in results.keys():
- size, count, diameter = results[key]
- scores[key] = _layer_size_score(size, count, diameter)
- minscore = min(scores.values())
- for key in iter(scores.keys()):
- if scores[key] == minscore:
- return {'format': key[0], 'zeros': key[1]}
-
-
-def _layer_size_score(size, hole_count, hole_area):
- """ Heuristic used for determining the correct file number interpretation.
- Lower is better.
- """
- board_area = size[0] * size[1]
- if board_area == 0:
- return 0
-
- hole_percentage = hole_area / board_area
- hole_score = (hole_percentage - 0.25) ** 2
- size_score = (board_area - 8) ** 2
- return hole_score * size_score
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Copyright 2014 Hamilton Kibbe <ham@hamiltonkib.be>
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Excellon File module
+====================
+**Excellon file classes**
+
+This module provides Excellon file classes and parsing utilities
+"""
+
+import math
+import operator
+
+from .cam import CamFile, FileSettings
+from .excellon_statements import *
+from .excellon_tool import ExcellonToolDefinitionParser
+from .primitives import Drill, Slot
+from .utils import inch, metric
+
+
+try:
+ from cStringIO import StringIO
+except(ImportError):
+ from io import StringIO
+
+
+
+def read(filename):
+ """ Read data from filename and return an ExcellonFile
+ Parameters
+ ----------
+ filename : string
+ Filename of file to parse
+
+ Returns
+ -------
+ file : :class:`gerber.excellon.ExcellonFile`
+ An ExcellonFile created from the specified file.
+
+ """
+ # File object should use settings from source file by default.
+ with open(filename, 'rU') as f:
+ data = f.read()
+ settings = FileSettings(**detect_excellon_format(data))
+ return ExcellonParser(settings).parse(filename)
+
+def loads(data, filename=None, settings=None, tools=None):
+ """ Read data from string and return an ExcellonFile
+ Parameters
+ ----------
+ data : string
+ string containing Excellon file contents
+
+ filename : string, optional
+ string containing the filename of the data source
+
+ tools: dict (optional)
+ externally defined tools
+
+ Returns
+ -------
+ file : :class:`gerber.excellon.ExcellonFile`
+ An ExcellonFile created from the specified file.
+
+ """
+ # File object should use settings from source file by default.
+ if not settings:
+ settings = FileSettings(**detect_excellon_format(data))
+ return ExcellonParser(settings, tools).parse_raw(data, filename)
+
+
+class DrillHit(object):
+ """Drill feature that is a single drill hole.
+
+ Attributes
+ ----------
+ tool : ExcellonTool
+ Tool to drill the hole. Defines the size of the hole that is generated.
+ position : tuple(float, float)
+ Center position of the drill.
+
+ """
+ def __init__(self, tool, position):
+ self.tool = tool
+ self.position = position
+
+ def to_inch(self):
+ if self.tool.settings.units == 'metric':
+ self.tool.to_inch()
+ self.position = tuple(map(inch, self.position))
+
+ def to_metric(self):
+ if self.tool.settings.units == 'inch':
+ self.tool.to_metric()
+ self.position = tuple(map(metric, self.position))
+
+ @property
+ def bounding_box(self):
+ position = self.position
+ radius = self.tool.diameter / 2.
+
+ min_x = position[0] - radius
+ max_x = position[0] + radius
+ min_y = position[1] - radius
+ max_y = position[1] + radius
+ return ((min_x, max_x), (min_y, max_y))
+
+ def offset(self, x_offset=0, y_offset=0):
+ self.position = tuple(map(operator.add, self.position, (x_offset, y_offset)))
+
+ def __str__(self):
+ return 'Hit (%f, %f) {%s}' % (self.position[0], self.position[1], self.tool)
+
+class DrillSlot(object):
+ """
+ A slot is created between two points. The way the slot is created depends on the statement used to create it
+ """
+
+ TYPE_ROUT = 1
+ TYPE_G85 = 2
+
+ def __init__(self, tool, start, end, slot_type):
+ self.tool = tool
+ self.start = start
+ self.end = end
+ self.slot_type = slot_type
+
+ def to_inch(self):
+ if self.tool.settings.units == 'metric':
+ self.tool.to_inch()
+ self.start = tuple(map(inch, self.start))
+ self.end = tuple(map(inch, self.end))
+
+ def to_metric(self):
+ if self.tool.settings.units == 'inch':
+ self.tool.to_metric()
+ self.start = tuple(map(metric, self.start))
+ self.end = tuple(map(metric, self.end))
+
+ @property
+ def bounding_box(self):
+ start = self.start
+ end = self.end
+ radius = self.tool.diameter / 2.
+ min_x = min(start[0], end[0]) - radius
+ max_x = max(start[0], end[0]) + radius
+ min_y = min(start[1], end[1]) - radius
+ max_y = max(start[1], end[1]) + radius
+ return ((min_x, max_x), (min_y, max_y))
+
+ def offset(self, x_offset=0, y_offset=0):
+ self.start = tuple(map(operator.add, self.start, (x_offset, y_offset)))
+ self.end = tuple(map(operator.add, self.end, (x_offset, y_offset)))
+
+
+class ExcellonFile(CamFile):
+ """ A class representing a single excellon file
+
+ The ExcellonFile class represents a single excellon file.
+
+ http://www.excellon.com/manuals/program.htm
+ (archived version at https://web.archive.org/web/20150920001043/http://www.excellon.com/manuals/program.htm)
+
+ Parameters
+ ----------
+ tools : list
+ list of gerber file statements
+
+ hits : list of tuples
+ list of drill hits as (<Tool>, (x, y))
+
+ settings : dict
+ Dictionary of gerber file settings
+
+ filename : string
+ Filename of the source gerber file
+
+ Attributes
+ ----------
+ units : string
+ either 'inch' or 'metric'.
+
+ """
+
+ def __init__(self, statements, tools, hits, settings, filename=None):
+ super(ExcellonFile, self).__init__(statements=statements,
+ settings=settings,
+ filename=filename)
+ self.tools = tools
+ self.hits = hits
+
+ @property
+ def primitives(self):
+ """
+ Gets the primitives. Note that unlike Gerber, this generates new objects
+ """
+ primitives = []
+ for hit in self.hits:
+ if isinstance(hit, DrillHit):
+ primitives.append(Drill(hit.position, hit.tool.diameter,
+ units=self.settings.units))
+ elif isinstance(hit, DrillSlot):
+ primitives.append(Slot(hit.start, hit.end, hit.tool.diameter,
+ units=self.settings.units))
+ else:
+ raise ValueError('Unknown hit type')
+ return primitives
+
+ @property
+ def bounding_box(self):
+ xmin = ymin = 100000000000
+ xmax = ymax = -100000000000
+ for hit in self.hits:
+ bbox = hit.bounding_box
+ xmin = min(bbox[0][0], xmin)
+ xmax = max(bbox[0][1], xmax)
+ ymin = min(bbox[1][0], ymin)
+ ymax = max(bbox[1][1], ymax)
+ return ((xmin, xmax), (ymin, ymax))
+
+ def report(self, filename=None):
+ """ Print or save drill report
+ """
+ if self.settings.units == 'inch':
+ toolfmt = ' T{:0>2d} {:%d.%df} {: >3d} {:f}in.\n' % self.settings.format
+ else:
+ toolfmt = ' T{:0>2d} {:%d.%df} {: >3d} {:f}mm\n' % self.settings.format
+ rprt = '=====================\nExcellon Drill Report\n=====================\n'
+ if self.filename is not None:
+ rprt += 'NC Drill File: %s\n\n' % self.filename
+ rprt += 'Drill File Info:\n----------------\n'
+ rprt += (' Data Mode %s\n' % 'Absolute'
+ if self.settings.notation == 'absolute' else 'Incremental')
+ rprt += (' Units %s\n' % 'Inches'
+ if self.settings.units == 'inch' else 'Millimeters')
+ rprt += '\nTool List:\n----------\n\n'
+ rprt += ' Code Size Hits Path Length\n'
+ rprt += ' --------------------------------------\n'
+ for tool in iter(self.tools.values()):
+ rprt += toolfmt.format(tool.number, tool.diameter,
+ tool.hit_count, self.path_length(tool.number))
+ if filename is not None:
+ with open(filename, 'w') as f:
+ f.write(rprt)
+ return rprt
+
+ def write(self, filename=None):
+ filename = filename if filename is not None else self.filename
+ with open(filename, 'w') as f:
+
+ # Copy the header verbatim
+ for statement in self.statements:
+ if not isinstance(statement, ToolSelectionStmt):
+ f.write(statement.to_excellon(self.settings) + '\n')
+ else:
+ break
+
+ # Write out coordinates for drill hits by tool
+ for tool in iter(self.tools.values()):
+ f.write(ToolSelectionStmt(tool.number).to_excellon(self.settings) + '\n')
+ for hit in self.hits:
+ if hit.tool.number == tool.number:
+ f.write(CoordinateStmt(
+ *hit.position).to_excellon(self.settings) + '\n')
+ f.write(EndOfProgramStmt().to_excellon() + '\n')
+
+ def to_inch(self):
+ """
+ Convert units to inches
+ """
+ if self.units != 'inch':
+ for statement in self.statements:
+ statement.to_inch()
+ for tool in iter(self.tools.values()):
+ tool.to_inch()
+ #for primitive in self.primitives:
+ # primitive.to_inch()
+ #for hit in self.hits:
+ # hit.to_inch()
+ self.units = 'inch'
+
+ def to_metric(self):
+ """ Convert units to metric
+ """
+ if self.units != 'metric':
+ for statement in self.statements:
+ statement.to_metric()
+ for tool in iter(self.tools.values()):
+ tool.to_metric()
+ #for primitive in self.primitives:
+ # print("Converting to metric: {}".format(primitive))
+ # primitive.to_metric()
+ # print(primitive)
+ for hit in self.hits:
+ hit.to_metric()
+ self.units = 'metric'
+
+ def offset(self, x_offset=0, y_offset=0):
+ for statement in self.statements:
+ statement.offset(x_offset, y_offset)
+ for primitive in self.primitives:
+ primitive.offset(x_offset, y_offset)
+ for hit in self. hits:
+ hit.offset(x_offset, y_offset)
+
+ def path_length(self, tool_number=None):
+ """ Return the path length for a given tool
+ """
+ lengths = {}
+ positions = {}
+ for hit in self.hits:
+ tool = hit.tool
+ num = tool.number
+ positions[num] = ((0, 0) if positions.get(num) is None
+ else positions[num])
+ lengths[num] = 0.0 if lengths.get(num) is None else lengths[num]
+ lengths[num] = lengths[
+ num] + math.hypot(*tuple(map(operator.sub, positions[num], hit.position)))
+ positions[num] = hit.position
+
+ if tool_number is None:
+ return lengths
+ else:
+ return lengths.get(tool_number)
+
+ def hit_count(self, tool_number=None):
+ counts = {}
+ for tool in iter(self.tools.values()):
+ counts[tool.number] = tool.hit_count
+ if tool_number is None:
+ return counts
+ else:
+ return counts.get(tool_number)
+
+ def update_tool(self, tool_number, **kwargs):
+ """ Change parameters of a tool
+ """
+ if kwargs.get('feed_rate') is not None:
+ self.tools[tool_number].feed_rate = kwargs.get('feed_rate')
+ if kwargs.get('retract_rate') is not None:
+ self.tools[tool_number].retract_rate = kwargs.get('retract_rate')
+ if kwargs.get('rpm') is not None:
+ self.tools[tool_number].rpm = kwargs.get('rpm')
+ if kwargs.get('diameter') is not None:
+ self.tools[tool_number].diameter = kwargs.get('diameter')
+ if kwargs.get('max_hit_count') is not None:
+ self.tools[tool_number].max_hit_count = kwargs.get('max_hit_count')
+ if kwargs.get('depth_offset') is not None:
+ self.tools[tool_number].depth_offset = kwargs.get('depth_offset')
+ # Update drill hits
+ newtool = self.tools[tool_number]
+ for hit in self.hits:
+ if hit.tool.number == newtool.number:
+ hit.tool = newtool
+
+
+class ExcellonParser(object):
+ """ Excellon File Parser
+
+ Parameters
+ ----------
+ settings : FileSettings or dict-like
+ Excellon file settings to use when interpreting the excellon file.
+ """
+ def __init__(self, settings=None, ext_tools=None):
+ self.notation = 'absolute'
+ self.units = 'inch'
+ self.zeros = 'leading'
+ self.format = (2, 4)
+ self.state = 'INIT'
+ self.statements = []
+ self.tools = {}
+ self.ext_tools = ext_tools or {}
+ self.comment_tools = {}
+ self.hits = []
+ self.active_tool = None
+ self.pos = [0., 0.]
+ self.drill_down = False
+ self._previous_line = ''
+ # Default for plated is None, which means we don't know
+ self.plated = ExcellonTool.PLATED_UNKNOWN
+ if settings is not None:
+ self.units = settings.units
+ self.zeros = settings.zeros
+ self.notation = settings.notation
+ self.format = settings.format
+
+ @property
+ def coordinates(self):
+ return [(stmt.x, stmt.y) for stmt in self.statements if isinstance(stmt, CoordinateStmt)]
+
+ @property
+ def bounds(self):
+ xmin = ymin = 100000000000
+ xmax = ymax = -100000000000
+ for x, y in self.coordinates:
+ if x is not None:
+ xmin = x if x < xmin else xmin
+ xmax = x if x > xmax else xmax
+ if y is not None:
+ ymin = y if y < ymin else ymin
+ ymax = y if y > ymax else ymax
+ return ((xmin, xmax), (ymin, ymax))
+
+ @property
+ def hole_sizes(self):
+ return [stmt.diameter for stmt in self.statements if isinstance(stmt, ExcellonTool)]
+
+ @property
+ def hole_count(self):
+ return len(self.hits)
+
+ def parse(self, filename):
+ with open(filename, 'rU') as f:
+ data = f.read()
+ return self.parse_raw(data, filename)
+
+ def parse_raw(self, data, filename=None):
+ for line in StringIO(data):
+ self._parse_line(line.strip())
+ for stmt in self.statements:
+ stmt.units = self.units
+ return ExcellonFile(self.statements, self.tools, self.hits,
+ self._settings(), filename)
+
+ def _parse_line(self, line):
+ # skip empty lines
+ # Prepend previous line's data...
+ line = '{}{}'.format(self._previous_line, line)
+ self._previous_line = ''
+
+ # Skip empty lines
+ if not line.strip():
+ return
+
+ if line[0] == ';':
+ comment_stmt = CommentStmt.from_excellon(line)
+ self.statements.append(comment_stmt)
+
+ # get format from altium comment
+ if "FILE_FORMAT" in comment_stmt.comment:
+ detected_format = tuple(
+ [int(x) for x in comment_stmt.comment.split('=')[1].split(":")])
+ if detected_format:
+ self.format = detected_format
+
+ if "TYPE=PLATED" in comment_stmt.comment:
+ self.plated = ExcellonTool.PLATED_YES
+
+ if "TYPE=NON_PLATED" in comment_stmt.comment:
+ self.plated = ExcellonTool.PLATED_NO
+
+ if "HEADER:" in comment_stmt.comment:
+ self.state = "HEADER"
+
+ if " Holesize " in comment_stmt.comment:
+ self.state = "HEADER"
+
+ # Parse this as a hole definition
+ tools = ExcellonToolDefinitionParser(self._settings()).parse_raw(comment_stmt.comment)
+ if len(tools) == 1:
+ tool = tools[tools.keys()[0]]
+ self._add_comment_tool(tool)
+
+ elif line[:3] == 'M48':
+ self.statements.append(HeaderBeginStmt())
+ self.state = 'HEADER'
+
+ elif line[0] == '%':
+ self.statements.append(RewindStopStmt())
+ if self.state == 'HEADER':
+ self.state = 'DRILL'
+ elif self.state == 'INIT':
+ self.state = 'HEADER'
+
+ elif line[:3] == 'M00' and self.state == 'DRILL':
+ if self.active_tool:
+ cur_tool_number = self.active_tool.number
+ next_tool = self._get_tool(cur_tool_number + 1)
+
+ self.statements.append(NextToolSelectionStmt(self.active_tool, next_tool))
+ self.active_tool = next_tool
+ else:
+ raise Exception('Invalid state exception')
+
+ elif line[:3] == 'M95':
+ self.statements.append(HeaderEndStmt())
+ if self.state == 'HEADER':
+ self.state = 'DRILL'
+
+ elif line[:3] == 'M15':
+ self.statements.append(ZAxisRoutPositionStmt())
+ self.drill_down = True
+
+ elif line[:3] == 'M16':
+ self.statements.append(RetractWithClampingStmt())
+ self.drill_down = False
+
+ elif line[:3] == 'M17':
+ self.statements.append(RetractWithoutClampingStmt())
+ self.drill_down = False
+
+ elif line[:3] == 'M30':
+ stmt = EndOfProgramStmt.from_excellon(line, self._settings())
+ self.statements.append(stmt)
+
+ elif line[:3] == 'G00':
+ # Coordinates may be on the next line
+ if line.strip() == 'G00':
+ self._previous_line = line
+ return
+
+ self.statements.append(RouteModeStmt())
+ self.state = 'ROUT'
+
+ stmt = CoordinateStmt.from_excellon(line[3:], self._settings())
+ stmt.mode = self.state
+
+ x = stmt.x
+ y = stmt.y
+ self.statements.append(stmt)
+ if self.notation == 'absolute':
+ if x is not None:
+ self.pos[0] = x
+ if y is not None:
+ self.pos[1] = y
+ else:
+ if x is not None:
+ self.pos[0] += x
+ if y is not None:
+ self.pos[1] += y
+
+ elif line[:3] == 'G01':
+
+ # Coordinates might be on the next line...
+ if line.strip() == 'G01':
+ self._previous_line = line
+ return
+
+ self.statements.append(RouteModeStmt())
+ self.state = 'LINEAR'
+
+ stmt = CoordinateStmt.from_excellon(line[3:], self._settings())
+ stmt.mode = self.state
+
+ # The start position is where we were before the rout command
+ start = (self.pos[0], self.pos[1])
+
+ x = stmt.x
+ y = stmt.y
+ self.statements.append(stmt)
+ if self.notation == 'absolute':
+ if x is not None:
+ self.pos[0] = x
+ if y is not None:
+ self.pos[1] = y
+ else:
+ if x is not None:
+ self.pos[0] += x
+ if y is not None:
+ self.pos[1] += y
+
+ # Our ending position
+ end = (self.pos[0], self.pos[1])
+
+ if self.drill_down:
+ if not self.active_tool:
+ self.active_tool = self._get_tool(1)
+
+ self.hits.append(DrillSlot(self.active_tool, start, end, DrillSlot.TYPE_ROUT))
+ self.active_tool._hit()
+
+ elif line[:3] == 'G05':
+ self.statements.append(DrillModeStmt())
+ self.drill_down = False
+ self.state = 'DRILL'
+
+ elif 'INCH' in line or 'METRIC' in line:
+ stmt = UnitStmt.from_excellon(line)
+ self.units = stmt.units
+ self.zeros = stmt.zeros
+ if stmt.format:
+ self.format = stmt.format
+ self.statements.append(stmt)
+
+ elif line[:3] == 'M71' or line[:3] == 'M72':
+ stmt = MeasuringModeStmt.from_excellon(line)
+ self.units = stmt.units
+ self.statements.append(stmt)
+
+ elif line[:3] == 'ICI':
+ stmt = IncrementalModeStmt.from_excellon(line)
+ self.notation = 'incremental' if stmt.mode == 'on' else 'absolute'
+ self.statements.append(stmt)
+
+ elif line[:3] == 'VER':
+ stmt = VersionStmt.from_excellon(line)
+ self.statements.append(stmt)
+
+ elif line[:4] == 'FMAT':
+ stmt = FormatStmt.from_excellon(line)
+ self.statements.append(stmt)
+ self.format = stmt.format_tuple
+
+ elif line[:3] == 'G40':
+ self.statements.append(CutterCompensationOffStmt())
+
+ elif line[:3] == 'G41':
+ self.statements.append(CutterCompensationLeftStmt())
+
+ elif line[:3] == 'G42':
+ self.statements.append(CutterCompensationRightStmt())
+
+ elif line[:3] == 'G90':
+ self.statements.append(AbsoluteModeStmt())
+ self.notation = 'absolute'
+
+ elif line[0] == 'F':
+ infeed_rate_stmt = ZAxisInfeedRateStmt.from_excellon(line)
+ self.statements.append(infeed_rate_stmt)
+
+ elif line[0] == 'T' and self.state == 'HEADER':
+ if not ',OFF' in line and not ',ON' in line:
+ tool = ExcellonTool.from_excellon(line, self._settings(), None, self.plated)
+ self._merge_properties(tool)
+ self.tools[tool.number] = tool
+ self.statements.append(tool)
+ else:
+ self.statements.append(UnknownStmt.from_excellon(line))
+
+ elif line[0] == 'T' and self.state != 'HEADER':
+ stmt = ToolSelectionStmt.from_excellon(line)
+ self.statements.append(stmt)
+
+ # T0 is used as END marker, just ignore
+ if stmt.tool != 0:
+ tool = self._get_tool(stmt.tool)
+
+ if not tool:
+ # FIXME: for weird files with no tools defined, original calc from gerb
+ if self._settings().units == "inch":
+ diameter = (16 + 8 * stmt.tool) / 1000.0
+ else:
+ diameter = metric((16 + 8 * stmt.tool) / 1000.0)
+
+ tool = ExcellonTool(
+ self._settings(), number=stmt.tool, diameter=diameter)
+ self.tools[tool.number] = tool
+
+ # FIXME: need to add this tool definition inside header to
+ # make sure it is properly written
+ for i, s in enumerate(self.statements):
+ if isinstance(s, ToolSelectionStmt) or isinstance(s, ExcellonTool):
+ self.statements.insert(i, tool)
+ break
+
+ self.active_tool = tool
+
+ elif line[0] == 'R' and self.state != 'HEADER':
+ stmt = RepeatHoleStmt.from_excellon(line, self._settings())
+ self.statements.append(stmt)
+ for i in range(stmt.count):
+ self.pos[0] += stmt.xdelta if stmt.xdelta is not None else 0
+ self.pos[1] += stmt.ydelta if stmt.ydelta is not None else 0
+ self.hits.append(DrillHit(self.active_tool, tuple(self.pos)))
+ self.active_tool._hit()
+
+ elif line[0] in ['X', 'Y']:
+ if 'G85' in line:
+ stmt = SlotStmt.from_excellon(line, self._settings())
+
+ # I don't know if this is actually correct, but it makes sense
+ # that this is where the tool would end
+ x = stmt.x_end
+ y = stmt.y_end
+
+ self.statements.append(stmt)
+
+ if self.notation == 'absolute':
+ if x is not None:
+ self.pos[0] = x
+ if y is not None:
+ self.pos[1] = y
+ else:
+ if x is not None:
+ self.pos[0] += x
+ if y is not None:
+ self.pos[1] += y
+
+ if self.state == 'DRILL' or self.state == 'HEADER':
+ if not self.active_tool:
+ self.active_tool = self._get_tool(1)
+
+ self.hits.append(DrillSlot(self.active_tool, (stmt.x_start, stmt.y_start), (stmt.x_end, stmt.y_end), DrillSlot.TYPE_G85))
+ self.active_tool._hit()
+ else:
+ stmt = CoordinateStmt.from_excellon(line, self._settings())
+
+ # We need this in case we are in rout mode
+ start = (self.pos[0], self.pos[1])
+
+ x = stmt.x
+ y = stmt.y
+ self.statements.append(stmt)
+ if self.notation == 'absolute':
+ if x is not None:
+ self.pos[0] = x
+ if y is not None:
+ self.pos[1] = y
+ else:
+ if x is not None:
+ self.pos[0] += x
+ if y is not None:
+ self.pos[1] += y
+
+ if self.state == 'LINEAR' and self.drill_down:
+ if not self.active_tool:
+ self.active_tool = self._get_tool(1)
+
+ self.hits.append(DrillSlot(self.active_tool, start, tuple(self.pos), DrillSlot.TYPE_ROUT))
+
+ elif self.state == 'DRILL' or self.state == 'HEADER':
+ # Yes, drills in the header doesn't follow the specification, but it there are many
+ # files like this
+ if not self.active_tool:
+ self.active_tool = self._get_tool(1)
+
+ self.hits.append(DrillHit(self.active_tool, tuple(self.pos)))
+ self.active_tool._hit()
+
+ else:
+ self.statements.append(UnknownStmt.from_excellon(line))
+
+ def _settings(self):
+ return FileSettings(units=self.units, format=self.format,
+ zeros=self.zeros, notation=self.notation)
+
+ def _add_comment_tool(self, tool):
+ """
+ Add a tool that was defined in the comments to this file.
+
+ If we have already found this tool, then we will merge this comment tool definition into
+ the information for the tool
+ """
+
+ existing = self.tools.get(tool.number)
+ if existing and existing.plated == None:
+ existing.plated = tool.plated
+
+ self.comment_tools[tool.number] = tool
+
+ def _merge_properties(self, tool):
+ """
+ When we have externally defined tools, merge the properties of that tool into this one
+
+ For now, this is only plated
+ """
+
+ if tool.plated == ExcellonTool.PLATED_UNKNOWN:
+ ext_tool = self.ext_tools.get(tool.number)
+
+ if ext_tool:
+ tool.plated = ext_tool.plated
+
+ def _get_tool(self, toolid):
+
+ tool = self.tools.get(toolid)
+ if not tool:
+ tool = self.comment_tools.get(toolid)
+ if tool:
+ tool.settings = self._settings()
+ self.tools[toolid] = tool
+
+ if not tool:
+ tool = self.ext_tools.get(toolid)
+ if tool:
+ tool.settings = self._settings()
+ self.tools[toolid] = tool
+
+ return tool
+
+def detect_excellon_format(data=None, filename=None):
+ """ Detect excellon file decimal format and zero-suppression settings.
+
+ Parameters
+ ----------
+ data : string
+ String containing contents of Excellon file.
+
+ Returns
+ -------
+ settings : dict
+ Detected excellon file settings. Keys are
+ - `format`: decimal format as tuple (<int part>, <decimal part>)
+ - `zero_suppression`: zero suppression, 'leading' or 'trailing'
+ """
+ results = {}
+ detected_zeros = None
+ detected_format = None
+ zeros_options = ('leading', 'trailing', )
+ format_options = ((2, 4), (2, 5), (3, 3),)
+
+ if data is None and filename is None:
+ raise ValueError('Either data or filename arguments must be provided')
+ if data is None:
+ with open(filename, 'rU') as f:
+ data = f.read()
+
+ # Check for obvious clues:
+ p = ExcellonParser()
+ p.parse_raw(data)
+
+ # Get zero_suppression from a unit statement
+ zero_statements = [stmt.zeros for stmt in p.statements
+ if isinstance(stmt, UnitStmt)]
+
+ # get format from altium comment
+ format_comment = [stmt.comment for stmt in p.statements
+ if isinstance(stmt, CommentStmt)
+ and 'FILE_FORMAT' in stmt.comment]
+
+ detected_format = (tuple([int(val) for val in
+ format_comment[0].split('=')[1].split(':')])
+ if len(format_comment) == 1 else None)
+ detected_zeros = zero_statements[0] if len(zero_statements) == 1 else None
+
+ # Bail out here if possible
+ if detected_format is not None and detected_zeros is not None:
+ return {'format': detected_format, 'zeros': detected_zeros}
+
+ # Only look at remaining options
+ if detected_format is not None:
+ format_options = (detected_format,)
+ if detected_zeros is not None:
+ zeros_options = (detected_zeros,)
+
+ # Brute force all remaining options, and pick the best looking one...
+ for zeros in zeros_options:
+ for fmt in format_options:
+ key = (fmt, zeros)
+ settings = FileSettings(zeros=zeros, format=fmt)
+ try:
+ p = ExcellonParser(settings)
+ ef = p.parse_raw(data)
+ size = tuple([t[0] - t[1] for t in ef.bounding_box])
+ hole_area = 0.0
+ for hit in p.hits:
+ tool = hit.tool
+ hole_area += math.pow(math.pi * tool.diameter / 2., 2)
+ results[key] = (size, p.hole_count, hole_area)
+ except:
+ pass
+
+ # See if any of the dimensions are left with only a single option
+ formats = set(key[0] for key in iter(results.keys()))
+ zeros = set(key[1] for key in iter(results.keys()))
+ if len(formats) == 1:
+ detected_format = formats.pop()
+ if len(zeros) == 1:
+ detected_zeros = zeros.pop()
+
+ # Bail out here if we got everything....
+ if detected_format is not None and detected_zeros is not None:
+ return {'format': detected_format, 'zeros': detected_zeros}
+
+ # Otherwise score each option and pick the best candidate
+ else:
+ scores = {}
+ for key in results.keys():
+ size, count, diameter = results[key]
+ scores[key] = _layer_size_score(size, count, diameter)
+ minscore = min(scores.values())
+ for key in iter(scores.keys()):
+ if scores[key] == minscore:
+ return {'format': key[0], 'zeros': key[1]}
+
+
+def _layer_size_score(size, hole_count, hole_area):
+ """ Heuristic used for determining the correct file number interpretation.
+ Lower is better.
+ """
+ board_area = size[0] * size[1]
+ if board_area == 0:
+ return 0
+
+ hole_percentage = hole_area / board_area
+ hole_score = (hole_percentage - 0.25) ** 2
+ size_score = (board_area - 8) ** 2
+ return hole_score * size_score
diff --git a/gerber/tests/test_excellon.py b/gerber/tests/test_excellon.py
index 6cddb60..d17791c 100644
--- a/gerber/tests/test_excellon.py
+++ b/gerber/tests/test_excellon.py
@@ -7,7 +7,7 @@ import os
from ..cam import FileSettings
from ..excellon import read, detect_excellon_format, ExcellonFile, ExcellonParser
from ..excellon import DrillHit, DrillSlot
-from ..excellon_statements import ExcellonTool
+from ..excellon_statements import ExcellonTool, RouteModeStmt
from .tests import *
@@ -127,7 +127,7 @@ def test_parse_header():
def test_parse_rout():
p = ExcellonParser(FileSettings())
- p._parse_line('G00 ')
+ p._parse_line('G00X040944Y019842')
assert_equal(p.state, 'ROUT')
p._parse_line('G05 ')
assert_equal(p.state, 'DRILL')
@@ -336,4 +336,25 @@ def test_drill_slot_bounds():
assert_equal(slot.bounding_box, expected)
-#def test_exce
+def test_handling_multi_line_g00_and_g1():
+ """Route Mode statements with coordinates on separate line are handled
+ """
+ test_data = """
+%
+M48
+M72
+T01C0.0236
+%
+T01
+G00
+X040944Y019842
+M15
+G01
+X040944Y020708
+M16
+"""
+ uut = ExcellonParser()
+ uut.parse_raw(test_data)
+ assert_equal(len([stmt for stmt in uut.statements
+ if isinstance(stmt, RouteModeStmt)]), 2)
+
generated by cgit (git 2.34.1) at 2024-11-06 08:12:28 +0000