Merge pull request #58 from garretfick/merge-curtacircuitos

Epic merge from @garretfick 

Thanks a lot @garretfick and @hamiltonkibbe.

1 files changed, 502 insertions, 22 deletions

diff --git a/gerber/primitives.py b/gerber/primitives.py
index fa611df..bd93e04 100644
--- a/gerber/primitives.py
+++ b/gerber/primitives.py
@@ -19,8 +19,10 @@
 import math

 from operator import add

 from itertools import combinations

-

 from .utils import validate_coordinates, inch, metric, convex_hull

+from .utils import rotate_point, nearly_equal

+

+

 

 

 class Primitive(object):

@@ -59,6 +61,13 @@ class Primitive(object):
         self._vertices = None

         self._segments = None

 

+    @property

+    def flashed(self):

+        '''Is this a flashed primitive'''

+

+        raise NotImplementedError('Is flashed must be '

+                                  'implemented in subclass')

+

     def __eq__(self, other):

         return self.__dict__ == other.__dict__

 

@@ -105,6 +114,17 @@ class Primitive(object):
         raise NotImplementedError('Bounding box calculation must be '

                                   'implemented in subclass')

 

+    @property

+    def bounding_box_no_aperture(self):

+        """ Calculate bouxing box without considering the aperture

+

+        for most objects, this is the same as the bounding_box, but is different for

+        Lines and Arcs (which are not flashed)

+

+        Return ((min x, max x), (min y, max y))

+        """

+        return self.bounding_box

+

     def to_inch(self):

         """ Convert primitive units to inches.

         """

@@ -166,6 +186,9 @@ class Primitive(object):
                                    in zip(self.position,

                                           (x_offset, y_offset))])

 

+    def to_statement(self):

+        pass

+

     def _changed(self):

         """ Clear memoized properties.

 

@@ -180,7 +203,6 @@ class Primitive(object):
         for attr in self._memoized:

             setattr(self, attr, None)

 

-

 class Line(Primitive):

     """

     """

@@ -193,6 +215,10 @@ class Line(Primitive):
         self._to_convert = ['start', 'end', 'aperture']

 

     @property

+    def flashed(self):

+        return False

+

+    @property

     def start(self):

         return self._start

 

@@ -210,7 +236,6 @@ class Line(Primitive):
         self._changed()

         self._end = value

 

-

     @property

     def angle(self):

         delta_x, delta_y = tuple(

@@ -234,6 +259,14 @@ class Line(Primitive):
             self._bounding_box = ((min_x, max_x), (min_y, max_y))

         return self._bounding_box

 

+    @property

+    def bounding_box_no_aperture(self):

+        '''Gets the bounding box without the aperture'''

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

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

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

+        max_y = max(self.start[1], self.end[1])

+        return ((min_x, max_x), (min_y, max_y))

 

     @property

     def vertices(self):

@@ -265,21 +298,36 @@ class Line(Primitive):
         self.end = tuple([coord + offset for coord, offset

                           in zip(self.end, (x_offset, y_offset))])

 

+    def equivalent(self, other, offset):

+

+        if not isinstance(other, Line):

+            return False

+

+        equiv_start = tuple(map(add, other.start, offset))

+        equiv_end = tuple(map(add, other.end, offset))

+

+

+        return nearly_equal(self.start, equiv_start) and nearly_equal(self.end, equiv_end)

 

 class Arc(Primitive):

     """

     """

 

-    def __init__(self, start, end, center, direction, aperture, **kwargs):

+    def __init__(self, start, end, center, direction, aperture, quadrant_mode, **kwargs):

         super(Arc, self).__init__(**kwargs)

         self._start = start

         self._end = end

         self._center = center

         self.direction = direction

         self.aperture = aperture

+        self._quadrant_mode = quadrant_mode

         self._to_convert = ['start', 'end', 'center', 'aperture']

 

     @property

+    def flashed(self):

+        return False

+

+    @property

     def start(self):

         return self._start

 

@@ -307,6 +355,15 @@ class Arc(Primitive):
         self._center = value

 

     @property

+    def quadrant_mode(self):

+        return self._quadrant_mode

+

+    @quadrant_mode.setter

+    def quadrant_mode(self, quadrant_mode):

+        self._changed()

+        self._quadrant_mode = quadrant_mode

+

+    @property

     def radius(self):

         dy, dx = tuple([start - center for start, center

                         in zip(self.start, self.center)])

@@ -380,6 +437,47 @@ class Arc(Primitive):
             self._bounding_box = ((min_x, max_x), (min_y, max_y))

         return self._bounding_box

 

+    @property

+    def bounding_box_no_aperture(self):

+        '''Gets the bounding box without considering the aperture'''

+        two_pi = 2 * math.pi

+        theta0 = (self.start_angle + two_pi) % two_pi

+        theta1 = (self.end_angle + two_pi) % two_pi

+        points = [self.start, self.end]

+        if self.direction == 'counterclockwise':

+            # Passes through 0 degrees

+            if theta0 > theta1:

+                points.append((self.center[0] + self.radius, self.center[1]))

+            # Passes through 90 degrees

+            if theta0 <= math.pi / 2. and (theta1 >= math.pi / 2. or theta1 < theta0):

+                points.append((self.center[0], self.center[1] + self.radius))

+            # Passes through 180 degrees

+            if theta0 <= math.pi and (theta1 >= math.pi or theta1 < theta0):

+                points.append((self.center[0] - self.radius, self.center[1]))

+            # Passes through 270 degrees

+            if theta0 <= math.pi * 1.5 and (theta1 >= math.pi * 1.5 or theta1 < theta0):

+                points.append((self.center[0], self.center[1] - self.radius ))

+        else:

+            # Passes through 0 degrees

+            if theta1 > theta0:

+                points.append((self.center[0] + self.radius, self.center[1]))

+            # Passes through 90 degrees

+            if theta1 <= math.pi / 2. and (theta0 >= math.pi / 2. or theta0 < theta1):

+                points.append((self.center[0], self.center[1] + self.radius))

+            # Passes through 180 degrees

+            if theta1 <= math.pi and (theta0 >= math.pi or theta0 < theta1):

+                points.append((self.center[0] - self.radius, self.center[1]))

+            # Passes through 270 degrees

+            if theta1 <= math.pi * 1.5 and (theta0 >= math.pi * 1.5 or theta0 < theta1):

+                points.append((self.center[0], self.center[1] - self.radius ))

+        x, y = zip(*points)

+

+        min_x = min(x)

+        max_x = max(x)

+        min_y = min(y)

+        max_y = max(y)

+        return ((min_x, max_x), (min_y, max_y))

+

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

         self._changed()

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

@@ -391,12 +489,17 @@ class Circle(Primitive):
     """

     """

 

-    def __init__(self, position, diameter, **kwargs):

+    def __init__(self, position, diameter, hole_diameter = None, **kwargs):

         super(Circle, self).__init__(**kwargs)

         validate_coordinates(position)

         self._position = position

         self._diameter = diameter

-        self._to_convert = ['position', 'diameter']

+        self.hole_diameter = hole_diameter

+        self._to_convert = ['position', 'diameter', 'hole_diameter']

+

+    @property

+    def flashed(self):

+        return True

 

     @property

     def position(self):

@@ -421,6 +524,12 @@ class Circle(Primitive):
         return self.diameter / 2.

 

     @property

+    def hole_radius(self):

+        if self.hole_diameter != None:

+            return self.hole_diameter / 2.

+        return None

+

+    @property

     def bounding_box(self):

         if self._bounding_box is None:

             min_x = self.position[0] - self.radius

@@ -430,11 +539,26 @@ class Circle(Primitive):
             self._bounding_box = ((min_x, max_x), (min_y, max_y))

         return self._bounding_box

 

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

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

+

+    def equivalent(self, other, offset):

+        '''Is this the same as the other circle, ignoring the offiset?'''

+

+        if not isinstance(other, Circle):

+            return False

+

+        if self.diameter != other.diameter or self.hole_diameter != other.hole_diameter:

+            return False

+

+        equiv_position = tuple(map(add, other.position, offset))

+

+        return nearly_equal(self.position, equiv_position)

+

 

 class Ellipse(Primitive):

     """

     """

-

     def __init__(self, position, width, height, **kwargs):

         super(Ellipse, self).__init__(**kwargs)

         validate_coordinates(position)

@@ -444,6 +568,10 @@ class Ellipse(Primitive):
         self._to_convert = ['position', 'width', 'height']

 

     @property

+    def flashed(self):

+        return True

+

+    @property

     def position(self):

         return self._position

 

@@ -497,19 +625,29 @@ class Ellipse(Primitive):
 

 class Rectangle(Primitive):

     """

+    When rotated, the rotation is about the center point.

+

+    Only aperture macro generated Rectangle objects can be rotated. If you aren't in a AMGroup,

+    then you don't need to worry about rotation

     """

 

-    def __init__(self, position, width, height, **kwargs):

+    def __init__(self, position, width, height, hole_diameter=0, **kwargs):

         super(Rectangle, self).__init__(**kwargs)

         validate_coordinates(position)

         self._position = position

         self._width = width

         self._height = height

-        self._to_convert = ['position', 'width', 'height']

+        self.hole_diameter = hole_diameter

+        self._to_convert = ['position', 'width', 'height', 'hole_diameter']

+        # TODO These are probably wrong when rotated

         self._lower_left = None

         self._upper_right = None

 

     @property

+    def flashed(self):

+        return True

+

+    @property

     def position(self):

         return self._position

 

@@ -537,6 +675,18 @@ class Rectangle(Primitive):
         self._height = value

 

     @property

+    def hole_radius(self):

+        """The radius of the hole. If there is no hole, returns None"""

+        if self.hole_diameter != None:

+            return self.hole_diameter / 2.

+        return None

+

+    @property

+    def upper_right(self):

+        return (self.position[0] + (self.axis_aligned_width / 2.),

+                self.position[1] + (self.axis_aligned_height / 2.))

+

+    @property

     def lower_left(self):

         return (self.position[0] - (self.axis_aligned_width / 2.),

                 self.position[1] - (self.axis_aligned_height / 2.))

@@ -567,11 +717,24 @@ class Rectangle(Primitive):
 

     @property

     def axis_aligned_width(self):

-        return (self._cos_theta * self.width) + (self._sin_theta * self.height)

+        return (self._cos_theta * self.width + self._sin_theta * self.height)

 

     @property

     def axis_aligned_height(self):

-        return (self._cos_theta * self.height) + (self._sin_theta * self.width)

+        return (self._cos_theta * self.height + self._sin_theta * self.width)

+

+    def equivalent(self, other, offset):

+        """Is this the same as the other rect, ignoring the offset?"""

+

+        if not isinstance(other, Rectangle):

+            return False

+

+        if self.width != other.width or self.height != other.height or self.rotation != other.rotation or self.hole_diameter != other.hole_diameter:

+            return False

+

+        equiv_position = tuple(map(add, other.position, offset))

+

+        return nearly_equal(self.position, equiv_position)

 

 

 class Diamond(Primitive):

@@ -587,6 +750,10 @@ class Diamond(Primitive):
         self._to_convert = ['position', 'width', 'height']

 

     @property

+    def flashed(self):

+        return True

+

+    @property

     def position(self):

         return self._position

 

@@ -639,11 +806,11 @@ class Diamond(Primitive):
 

     @property

     def axis_aligned_width(self):

-        return (self._cos_theta * self.width) + (self._sin_theta * self.height)

+        return (self._cos_theta * self.width + self._sin_theta * self.height)

 

     @property

     def axis_aligned_height(self):

-        return (self._cos_theta * self.height) + (self._sin_theta * self.width)

+        return (self._cos_theta * self.height + self._sin_theta * self.width)

 

 

 class ChamferRectangle(Primitive):

@@ -660,6 +827,10 @@ class ChamferRectangle(Primitive):
         self._to_convert = ['position', 'width', 'height', 'chamfer']

 

     @property

+    def flashed(self):

+        return True

+

+    @property

     def position(self):

         return self._position

 

@@ -775,6 +946,10 @@ class RoundRectangle(Primitive):
         self._to_convert = ['position', 'width', 'height', 'radius']

 

     @property

+    def flashed(self):

+        return True

+

+    @property

     def position(self):

         return self._position

 

@@ -844,13 +1019,18 @@ class Obround(Primitive):
     """

     """

 

-    def __init__(self, position, width, height, **kwargs):

+    def __init__(self, position, width, height, hole_diameter=0, **kwargs):

         super(Obround, self).__init__(**kwargs)

         validate_coordinates(position)

         self._position = position

         self._width = width

         self._height = height

-        self._to_convert = ['position', 'width', 'height']

+        self.hole_diameter = hole_diameter

+        self._to_convert = ['position', 'width', 'height', 'hole_diameter']

+

+    @property

+    def flashed(self):

+        return True

 

     @property

     def position(self):

@@ -880,6 +1060,14 @@ class Obround(Primitive):
         self._height = value

 

     @property

+    def hole_radius(self):

+        """The radius of the hole. If there is no hole, returns None"""

+        if self.hole_diameter != None:

+            return self.hole_diameter / 2.

+

+        return None

+

+    @property

     def orientation(self):

         return 'vertical' if self.height > self.width else 'horizontal'

 

@@ -926,15 +1114,30 @@ class Obround(Primitive):
 

 class Polygon(Primitive):

     """

+    Polygon flash defined by a set number of sides.

     """

-

-    def __init__(self, position, sides, radius, **kwargs):

+    def __init__(self, position, sides, radius, hole_diameter, **kwargs):

         super(Polygon, self).__init__(**kwargs)

         validate_coordinates(position)

         self._position = position

         self.sides = sides

         self._radius = radius

-        self._to_convert = ['position', 'radius']

+        self.hole_diameter = hole_diameter

+        self._to_convert = ['position', 'radius', 'hole_diameter']

+

+    @property

+    def flashed(self):

+        return True

+

+    @property

+    def diameter(self):

+        return self.radius * 2

+

+    @property

+    def hole_radius(self):

+        if self.hole_diameter != None:

+            return self.hole_diameter / 2.

+        return None

 

     @property

     def position(self):

@@ -964,6 +1167,183 @@ class Polygon(Primitive):
             self._bounding_box = ((min_x, max_x), (min_y, max_y))

         return self._bounding_box

 

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

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

+

+    @property

+    def vertices(self):

+

+        offset = self.rotation

+        da = 360.0 / self.sides

+

+        points = []

+        for i in xrange(self.sides):

+            points.append(rotate_point((self.position[0] + self.radius, self.position[1]), offset + da * i, self.position))

+

+        return points

+

+    @property

+    def vertices(self):

+        if self._vertices is None:

+            theta = math.radians(360/self.sides)

+            vertices = [(self.position[0] + (math.cos(theta * side) * self.radius),

+                         self.position[1] + (math.sin(theta * side) * self.radius))

+                        for side in range(self.sides)]

+            self._vertices = [(((x * self._cos_theta) - (y * self._sin_theta)),

+                               ((x * self._sin_theta) + (y * self._cos_theta)))

+                              for x, y in vertices]

+        return self._vertices

+

+    def equivalent(self, other, offset):

+        """

+        Is this the outline the same as the other, ignoring the position offset?

+        """

+

+        # Quick check if it even makes sense to compare them

+        if type(self) != type(other) or self.sides != other.sides or self.radius != other.radius:

+            return False

+

+        equiv_pos = tuple(map(add, other.position, offset))

+

+        return nearly_equal(self.position, equiv_pos)

+

+

+class AMGroup(Primitive):

+    """

+    """

+    def __init__(self, amprimitives, stmt = None, **kwargs):

+        """

+

+        stmt : The original statment that generated this, since it is really hard to re-generate from primitives

+        """

+        super(AMGroup, self).__init__(**kwargs)

+

+        self.primitives = []

+        for amprim in amprimitives:

+            prim = amprim.to_primitive(self.units)

+            if isinstance(prim, list):

+                for p in prim:

+                    self.primitives.append(p)

+            elif prim:

+                self.primitives.append(prim)

+        self._position = None

+        self._to_convert = ['_position', 'primitives']

+        self.stmt = stmt

+

+    def to_inch(self):

+        if self.units == 'metric':

+            super(AMGroup, self).to_inch()

+

+            # If we also have a stmt, convert that too

+            if self.stmt:

+                self.stmt.to_inch()

+

+

+    def to_metric(self):

+        if self.units == 'inch':

+            super(AMGroup, self).to_metric()

+

+            # If we also have a stmt, convert that too

+            if self.stmt:

+                self.stmt.to_metric()

+

+    @property

+    def flashed(self):

+        return True

+

+    @property

+    def bounding_box(self):

+        # TODO Make this cached like other items

+        xlims, ylims = zip(*[p.bounding_box for p in self.primitives])

+        minx, maxx = zip(*xlims)

+        miny, maxy = zip(*ylims)

+        min_x = min(minx)

+        max_x = max(maxx)

+        min_y = min(miny)

+        max_y = max(maxy)

+        return ((min_x, max_x), (min_y, max_y))

+

+    @property

+    def position(self):

+        return self._position

+

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

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

+

+        for primitive in self.primitives:

+            primitive.offset(x_offset, y_offset)

+

+    @position.setter

+    def position(self, new_pos):

+        '''

+        Sets the position of the AMGroup.

+        This offset all of the objects by the specified distance.

+        '''

+

+        if self._position:

+            dx = new_pos[0] - self._position[0]

+            dy = new_pos[1] - self._position[1]

+        else:

+            dx = new_pos[0]

+            dy = new_pos[1]

+

+        for primitive in self.primitives:

+            primitive.offset(dx, dy)

+

+        self._position = new_pos

+

+    def equivalent(self, other, offset):

+        '''

+        Is this the macro group the same as the other, ignoring the position offset?

+        '''

+

+        if len(self.primitives) != len(other.primitives):

+            return False

+

+        # We know they have the same number of primitives, so now check them all

+        for i in range(0, len(self.primitives)):

+            if not self.primitives[i].equivalent(other.primitives[i], offset):

+                return False

+

+        # If we didn't find any differences, then they are the same

+        return True

+

+class Outline(Primitive):

+    """

+    Outlines only exist as the rendering for a apeture macro outline.

+    They don't exist outside of AMGroup objects

+    """

+

+    def __init__(self, primitives, **kwargs):

+        super(Outline, self).__init__(**kwargs)

+        self.primitives = primitives

+        self._to_convert = ['primitives']

+

+        if self.primitives[0].start != self.primitives[-1].end:

+            raise ValueError('Outline must be closed')

+

+    @property

+    def flashed(self):

+        return True

+

+    @property

+    def bounding_box(self):

+        if self._bounding_box is None:

+            xlims, ylims = zip(*[p.bounding_box for p in self.primitives])

+            minx, maxx = zip(*xlims)

+            miny, maxy = zip(*ylims)

+            min_x = min(minx)

+            max_x = max(maxx)

+            min_y = min(miny)

+            max_y = max(maxy)

+            self._bounding_box = ((min_x, max_x), (min_y, max_y))

+        return self._bounding_box

+

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

+        self._changed()

+        for p in self.primitives:

+            p.offset(x_offset, y_offset)

+

     @property

     def vertices(self):

         if self._vertices is None:

@@ -976,6 +1356,25 @@ class Polygon(Primitive):
                               for x, y in vertices]

         return self._vertices

 

+    @property

+    def width(self):

+        bounding_box = self.bounding_box()

+        return bounding_box[0][1] - bounding_box[0][0]

+

+    def equivalent(self, other, offset):

+        '''

+        Is this the outline the same as the other, ignoring the position offset?

+        '''

+

+        # Quick check if it even makes sense to compare them

+        if type(self) != type(other) or len(self.primitives) != len(other.primitives):

+            return False

+

+        for i in range(0, len(self.primitives)):

+            if not self.primitives[i].equivalent(other.primitives[i], offset):

+                return False

+

+        return True

 

 class Region(Primitive):

     """

@@ -987,9 +1386,13 @@ class Region(Primitive):
         self._to_convert = ['primitives']

 

     @property

+    def flashed(self):

+        return False

+

+    @property

     def bounding_box(self):

         if self._bounding_box is None:

-            xlims, ylims = zip(*[p.bounding_box for p in self.primitives])

+            xlims, ylims = zip(*[p.bounding_box_no_aperture for p in self.primitives])

             minx, maxx = zip(*xlims)

             miny, maxy = zip(*ylims)

             min_x = min(minx)

@@ -1016,6 +1419,12 @@ class RoundButterfly(Primitive):
         self.diameter = diameter

         self._to_convert = ['position', 'diameter']

 

+        # TODO This does not reset bounding box correctly

+

+    @property

+    def flashed(self):

+        return True

+

     @property

     def radius(self):

         return self.diameter / 2.

@@ -1042,6 +1451,12 @@ class SquareButterfly(Primitive):
         self.side = side

         self._to_convert = ['position', 'side']

 

+        # TODO This does not reset bounding box correctly

+

+    @property

+    def flashed(self):

+        return True

+

     @property

     def bounding_box(self):

         if self._bounding_box is None:

@@ -1078,9 +1493,26 @@ class Donut(Primitive):
             # Hexagon

             self.width = 0.5 * math.sqrt(3.) * outer_diameter

             self.height = outer_diameter

+

         self._to_convert = ['position', 'width',

                             'height', 'inner_diameter', 'outer_diameter']

 

+        # TODO This does not reset bounding box correctly

+

+    @property

+    def flashed(self):

+        return True

+

+    @property

+    def lower_left(self):

+        return (self.position[0] - (self.width / 2.),

+                self.position[1] - (self.height / 2.))

+

+    @property

+    def upper_right(self):

+        return (self.position[0] + (self.width / 2.),

+                self.position[1] + (self.height / 2.))

+

     @property

     def bounding_box(self):

         if self._bounding_box is None:

@@ -1108,6 +1540,10 @@ class SquareRoundDonut(Primitive):
         self._to_convert = ['position', 'inner_diameter', 'outer_diameter']

 

     @property

+    def flashed(self):

+        return True

+

+    @property

     def bounding_box(self):

         if self._bounding_box is None:

             ll = tuple([c - self.outer_diameter / 2. for c in self.position])

@@ -1119,13 +1555,19 @@ class SquareRoundDonut(Primitive):
 class Drill(Primitive):

     """ A drill hole

     """

-

-    def __init__(self, position, diameter, **kwargs):

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

         super(Drill, self).__init__('dark', **kwargs)

         validate_coordinates(position)

         self._position = position

         self._diameter = diameter

-        self._to_convert = ['position', 'diameter']

+        self.hit = hit

+        self._to_convert = ['position', 'diameter', 'hit']

+

+        # TODO Ths won't handle the hit updates correctly

+

+    @property

+    def flashed(self):

+        return False

 

     @property

     def position(self):

@@ -1159,6 +1601,44 @@ class Drill(Primitive):
             self._bounding_box = ((min_x, max_x), (min_y, max_y))

         return self._bounding_box

 

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

+        self._changed()

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

+

+    def __str__(self):

+        return '<Drill %f (%f, %f) [%s]>' % (self.diameter, self.position[0], self.position[1], self.hit)

+

+

+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', 'hit']

+

+        # TODO this needs to use cached bounding box

+

+    @property

+    def flashed(self):

+        return False

+

+    def bounding_box(self):

+        if self._bounding_box is None:

+            ll = tuple([c - self.outer_diameter / 2. for c in self.position])

+            ur = tuple([c + self.outer_diameter / 2. for c in self.position])

+            self._bounding_box = ((ll[0], ur[0]), (ll[1], ur[1]))

+        return self._bounding_box

+

+    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