Support for the G85 slot statement

6 files changed, 322 insertions, 32 deletions

diff --git a/gerber/excellon.py b/gerber/excellon.py
index 0637b23..f9bb18a 100755
--- a/gerber/excellon.py
+++ b/gerber/excellon.py
@@ -34,7 +34,7 @@ except(ImportError):
 from .excellon_statements import *

 from .excellon_tool import ExcellonToolDefinitionParser

 from .cam import CamFile, FileSettings

-from .primitives import Drill

+from .primitives import Drill, Slot

 from .utils import inch, metric

 

 

@@ -93,6 +93,51 @@ class DrillHit(object):
         if self.tool.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))

+            

+            

+class DrillSlot(object):

+    """

+    A slot is created between two points. The way the slot is created depends on the statement used to create it

+    """

+    

+    def __init__(self, tool, start, end):

+        self.tool = tool

+        self.start = start

+        self.end = end

+

+    def to_inch(self):

+        if self.tool.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.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))

 

 

 class ExcellonFile(CamFile):

@@ -131,7 +176,17 @@ class ExcellonFile(CamFile):
 

     @property

     def primitives(self):

-        return [Drill(hit.position, hit.tool.diameter, hit, units=self.settings.units) for hit in self.hits]

+        

+        primitives = []

+        for hit in self.hits:

+            if isinstance(hit, DrillHit):

+                primitives.append(Drill(hit.position, hit.tool.diameter, hit, units=self.settings.units))

+            elif isinstance(hit, DrillSlot):

+                primitives.append(Slot(hit.start, hit.end, hit.tool.diameter, hit, units=self.settings.units))

+            else:

+                raise ValueError('Unknown hit type')

+                

+        return primitives

 

 

     @property

@@ -139,12 +194,11 @@ class ExcellonFile(CamFile):
         xmin = ymin = 100000000000

         xmax = ymax = -100000000000

         for hit in self.hits:

-            radius = hit.tool.diameter / 2.

-            x, y = hit.position

-            xmin = min(x - radius, xmin)

-            xmax = max(x + radius, xmax)

-            ymin = min(y - radius, ymin)

-            ymax = max(y + radius, ymax)

+            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):

@@ -545,26 +599,54 @@ class ExcellonParser(object):
                 self.active_tool._hit()

 

         elif line[0] in ['X', 'Y']:

-            stmt = CoordinateStmt.from_excellon(line, self._settings())

-            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 == 'DRILL':

-                if not self.active_tool:

-                    self.active_tool = self._get_tool(1)

+            if 'G85' in line:

+                stmt = SlotStmt.from_excellon(line, self._settings())

                 

-                self.hits.append(DrillHit(self.active_tool, tuple(self.pos)))

-                self.active_tool._hit()

+                # 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':

+                    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)))

+                    self.active_tool._hit()

+            else:

+                stmt = CoordinateStmt.from_excellon(line, self._settings())

+                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 == 'DRILL':

+                    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))

 

diff --git a/gerber/excellon_statements.py b/gerber/excellon_statements.py
index cabdf6c..a6a5a5e 100644
--- a/gerber/excellon_statements.py
+++ b/gerber/excellon_statements.py
@@ -37,7 +37,7 @@ __all__ = ['ExcellonTool', 'ToolSelectionStmt', 'CoordinateStmt',
            'RetractWithClampingStmt', 'RetractWithoutClampingStmt',
            'CutterCompensationOffStmt', 'CutterCompensationLeftStmt',
            'CutterCompensationRightStmt', 'ZAxisInfeedRateStmt',
-           'NextToolSelectionStmt']
+           'NextToolSelectionStmt', 'SlotStmt']
 
 
 class ExcellonStatement(object):
@@ -645,6 +645,12 @@ class EndOfProgramStmt(ExcellonStatement):
             self.y += y_offset
 
 class UnitStmt(ExcellonStatement):
+    
+    @classmethod
+    def from_settings(cls, settings):
+        """Create the unit statement from the FileSettings"""
+        
+        return cls(settings.units, settings.zeros)
 
     @classmethod
     def from_excellon(cls, line, **kwargs):
@@ -827,6 +833,128 @@ class UnknownStmt(ExcellonStatement):
         return "<Unknown Statement: %s>" % self.stmt
 
 
+class SlotStmt(ExcellonStatement):
+    """
+    G85 statement.  Defines a slot created by multiple drills between two specified points.
+    
+    Format is two coordinates, split by G85in the middle, for example, XnY0nG85XnYn
+    """
+    
+    @classmethod
+    def from_points(cls, start, end):
+        
+        return cls(start[0], start[1], end[0], end[1])
+    
+    @classmethod
+    def from_excellon(cls, line, settings, **kwargs):
+        # Split the line based on the G85 separator
+        sub_coords = line.split('G85')
+        (x_start_coord, y_start_coord) = SlotStmt.parse_sub_coords(sub_coords[0], settings)
+        (x_end_coord, y_end_coord) = SlotStmt.parse_sub_coords(sub_coords[1], settings)
+        
+            
+        c = cls(x_start_coord, y_start_coord, x_end_coord, y_end_coord, **kwargs)
+        c.units = settings.units
+        return c  
+        
+    @staticmethod
+    def parse_sub_coords(line, settings):
+        
+        x_coord = None
+        y_coord = None
+        
+        if line[0] == 'X':
+            splitline = line.strip('X').split('Y')
+            x_coord = parse_gerber_value(splitline[0], settings.format,
+                                         settings.zero_suppression)
+            if len(splitline) == 2:
+                y_coord = parse_gerber_value(splitline[1], settings.format,
+                                             settings.zero_suppression)
+        else:
+            y_coord = parse_gerber_value(line.strip(' Y'), settings.format,
+                                         settings.zero_suppression)
+            
+        return (x_coord, y_coord)
+
+
+    def __init__(self, x_start=None, y_start=None, x_end=None, y_end=None, **kwargs):
+        super(SlotStmt, self).__init__(**kwargs)
+        self.x_start = x_start
+        self.y_start = y_start
+        self.x_end = x_end
+        self.y_end = y_end
+        self.mode = None
+
+    def to_excellon(self, settings):
+        stmt = ''
+
+        if self.x_start is not None:
+            stmt += 'X%s' % write_gerber_value(self.x_start, settings.format,
+                                               settings.zero_suppression)
+        if self.y_start is not None:
+            stmt += 'Y%s' % write_gerber_value(self.y_start, settings.format,
+                                               settings.zero_suppression)
+            
+        stmt += 'G85'
+        
+        if self.x_end is not None:
+            stmt += 'X%s' % write_gerber_value(self.x_end, settings.format,
+                                               settings.zero_suppression)
+        if self.y_end is not None:
+            stmt += 'Y%s' % write_gerber_value(self.y_end, settings.format,
+                                               settings.zero_suppression)
+        
+        return stmt
+
+    def to_inch(self):
+        if self.units == 'metric':
+            self.units = 'inch'
+            if self.x_start is not None:
+                self.x_start = inch(self.x_start)
+            if self.y_start is not None:
+                self.y_start = inch(self.y_start)
+            if self.x_end is not None:
+                self.x_end = inch(self.x_end)
+            if self.y_end is not None:
+                self.y_end = inch(self.y_end)
+
+    def to_metric(self):
+        if self.units == 'inch':
+            self.units = 'metric'
+            if self.x_start is not None:
+                self.x_start = metric(self.x_start)
+            if self.y_start is not None:
+                self.y_start = metric(self.y_start)
+            if self.x_end is not None:
+                self.x_end = metric(self.x_end)
+            if self.y_end is not None:
+                self.y_end = metric(self.y_end)
+
+    def offset(self, x_offset=0, y_offset=0):
+        if self.x_start is not None:
+            self.x_start += x_offset
+        if self.y_start is not None:
+            self.y_start += y_offset
+        if self.x_end is not None:
+            self.x_end += x_offset
+        if self.y_end is not None:
+            self.y_end += y_offset
+
+    def __str__(self):
+        start_str = ''
+        if self.x_start is not None:
+            start_str += 'X: %g ' % self.x_start
+        if self.y_start is not None:
+            start_str += 'Y: %g ' % self.y_start
+            
+        end_str = ''
+        if self.x_end is not None:
+            end_str += 'X: %g ' % self.x_end
+        if self.y_end is not None:
+            end_str += 'Y: %g ' % self.y_end
+
+        return '<Slot Statement: %s to %s>' % (start_str, end_str)
+
 def pairwise(iterator):
     """ Iterate over list taking two elements at a time.
 
diff --git a/gerber/primitives.py b/gerber/primitives.py
index e5ff35f..3ecf0db 100644
--- a/gerber/primitives.py
+++ b/gerber/primitives.py
@@ -1109,6 +1109,42 @@ class Drill(Primitive):
 

     def offset(self, x_offset=0, y_offset=0):

         self.position = tuple(map(add, self.position, (x_offset, y_offset)))

+        

+        

+class Slot(Primitive):

+    """ A drilled slot

+    """

+    def __init__(self, start, end, diameter, hit, **kwargs):

+        super(Slot, self).__init__('dark', **kwargs)

+        validate_coordinates(start)

+        validate_coordinates(end)

+        self.start = start

+        self.end = end

+        self.diameter = diameter

+        self.hit = hit

+        self._to_convert = ['start', 'end', 'diameter']

+        

+    @property 

+    def flashed(self):

+        return False

+

+    @property

+    def radius(self):

+        return self.diameter / 2.

+

+    @property

+    def bounding_box(self):

+        radius = self.radius

+        min_x = min(self.start[0], self.end[0]) - radius

+        max_x = max(self.start[0], self.end[0]) + radius

+        min_y = min(self.start[1], self.end[1]) - radius

+        max_y = max(self.start[1], self.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(add, self.start, (x_offset, y_offset)))

+        self.end = tuple(map(add, self.end, (x_offset, y_offset)))

+

 

 class TestRecord(Primitive):

     """ Netlist Test record

diff --git a/gerber/render/cairo_backend.py b/gerber/render/cairo_backend.py
index 7be7e6a..d895e5c 100644
--- a/gerber/render/cairo_backend.py
+++ b/gerber/render/cairo_backend.py
@@ -173,6 +173,20 @@ class GerberCairoContext(GerberContext):
     def _render_drill(self, circle, color):

         self._render_circle(circle, color)

         

+    def _render_slot(self, slot, color):

+        start = map(mul, slot.start, self.scale)

+        end = map(mul, slot.end, self.scale)

+        

+        width = slot.diameter

+

+        self.ctx.set_source_rgba(color[0], color[1], color[2], self.alpha)

+        self.ctx.set_operator(cairo.OPERATOR_OVER if (slot.level_polarity == "dark" and not self.invert) else cairo.OPERATOR_CLEAR)

+        self.ctx.set_line_width(width * self.scale[0])

+        self.ctx.set_line_cap(cairo.LINE_CAP_ROUND)

+        self.ctx.move_to(*start)

+        self.ctx.line_to(*end)

+        self.ctx.stroke()

+        

     def _render_amgroup(self, amgroup, color):

         for primitive in amgroup.primitives:

             self.render(primitive)

diff --git a/gerber/render/excellon_backend.py b/gerber/render/excellon_backend.py
index f5cec1a..eb79f1b 100644
--- a/gerber/render/excellon_backend.py
+++ b/gerber/render/excellon_backend.py
@@ -9,6 +9,7 @@ class ExcellonContext(GerberContext):
         self.comments = []
         self.header = []
         self.tool_def = []
+        self.body_start = [RewindStopStmt()]
         self.body = []
         self.start = [HeaderBeginStmt()]
         self.end = [EndOfProgramStmt()]
@@ -19,14 +20,22 @@ class ExcellonContext(GerberContext):
         
         self.settings = settings
 
-        self._start_header(settings)
+        self._start_header()
+        self._start_comments()
         
-    def _start_header(self, settings):
-        pass
+    def _start_header(self):
+        """Create the header from the settings"""
+        
+        self.header.append(UnitStmt.from_settings(self.settings))
+        
+    def _start_comments(self):
+        
+        # Write the digits used - this isn't valid Excellon statement, so we write as a comment
+        self.comments.append(CommentStmt('FILE_FORMAT=%d:%d' % (self.settings.format[0], self.settings.format[1])))
         
     @property
     def statements(self):
-        return self.start + self.comments + self.header + self.body + self.end
+        return self.start + self.comments + self.header + self.body_start + self.body + self.end
         
     def set_bounds(self, bounds):
         pass
@@ -69,10 +78,26 @@ class ExcellonContext(GerberContext):
     
         if tool != self.cur_tool:
             self.body.append(ToolSelectionStmt(tool.number))
+            self.cur_tool = tool
             
         point = self._simplify_point(drill.position)
         self._pos = drill.position
         self.body.append(CoordinateStmt.from_point(point))
+        
+    def _render_slot(self, slot, color):
+        
+        tool = slot.hit.tool
+        if not tool in self.handled_tools:
+            self.handled_tools.add(tool)
+            self.header.append(ExcellonTool.from_tool(tool))
+    
+        if tool != self.cur_tool:
+            self.body.append(ToolSelectionStmt(tool.number))
+            self.cur_tool = tool
+            
+        # Slots don't use simplified points
+        self._pos = slot.end
+        self.body.append(SlotStmt.from_points(slot.start, slot.end))
 
     def _render_inverted_layer(self):
         pass
diff --git a/gerber/render/render.py b/gerber/render/render.py
index b518385..a5ae38e 100644
--- a/gerber/render/render.py
+++ b/gerber/render/render.py
@@ -150,6 +150,8 @@ class GerberContext(object):
             self._render_polygon(primitive, color)
         elif isinstance(primitive, Drill):
             self._render_drill(primitive, self.drill_color)
+        elif isinstance(primitive, Slot):
+            self._render_slot(primitive, self.drill_color)
         elif isinstance(primitive, AMGroup):
             self._render_amgroup(primitive, color)
         elif isinstance(primitive, Outline):
@@ -183,6 +185,9 @@ class GerberContext(object):
     def _render_drill(self, primitive, color):
         pass
     
+    def _render_slot(self, primitive, color):
+        pass
+    
     def _render_amgroup(self, primitive, color):
         pass