summaryrefslogtreecommitdiff
path: root/gerber/primitives.py
diff options
context:
space:
mode:
Diffstat (limited to 'gerber/primitives.py')
-rw-r--r--gerber/primitives.py524
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
generated by cgit (git 2.34.1) at 2024-07-05 12:23:24 +0000