#! /usr/bin/env python # -*- coding: utf-8 -*- # copyright 2016 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. 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): """ Base class for all Cam file primitives Parameters --------- level_polarity : string Polarity of the parameter. May be 'dark' or 'clear'. Dark indicates a "positive" primitive, i.e. indicating where coppper should remain, and clear indicates a negative primitive, such as where copper should be removed. clear primitives are often used to create cutouts in region pours. rotation : float Rotation of a primitive about its origin in degrees. Positive rotation is counter-clockwise as viewed from the board top. units : string Units in which primitive was defined. 'inch' or 'metric' net_name : string Name of the electrical net the primitive belongs to """ def __init__(self, level_polarity='dark', rotation=0, units=None, net_name=None): self.level_polarity = level_polarity self.net_name = net_name self._to_convert = list() self._memoized = list() self._units = units self._rotation = rotation self._cos_theta = math.cos(math.radians(rotation)) self._sin_theta = math.sin(math.radians(rotation)) self._bounding_box = None 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__ @property def units(self): return self._units @units.setter def units(self, value): self._changed() self._units = value @property def rotation(self): return self._rotation @rotation.setter def rotation(self, value): self._changed() self._rotation = value self._cos_theta = math.cos(math.radians(value)) self._sin_theta = math.sin(math.radians(value)) @property def vertices(self): return None @property def segments(self): if self._segments is None: if self.vertices is not None and len(self.vertices): self._segments = [segment for segment in combinations(self.vertices, 2)] return self._segments @property def bounding_box(self): """ Calculate axis-aligned bounding box will be helpful for sweep & prune during DRC clearance checks. Return ((min x, max x), (min y, max y)) """ 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. """ if self.units == 'metric': self.units = 'inch' for attr, value in [(attr, getattr(self, attr)) for attr in self._to_convert]: if hasattr(value, 'to_inch'): value.to_inch() else: try: if len(value) > 1: if hasattr(value[0], 'to_inch'): for v in value: v.to_inch() elif isinstance(value[0], tuple): setattr(self, attr, [tuple(map(inch, point)) for point in value]) else: setattr(self, attr, tuple(map(inch, value))) except: if value is not None: setattr(self, attr, inch(value)) def to_metric(self): """ Convert primitive units to metric. """ if self.units == 'inch': self.units = 'metric' for attr, value in [(attr, getattr(self, attr)) for attr in self._to_convert]: if hasattr(value, 'to_metric'): value.to_metric() else: try: if len(value) > 1: if hasattr(value[0], 'to_metric'): for v in value: v.to_metric() elif isinstance(value[0], tuple): setattr(self, attr, [tuple(map(metric, point)) for point in value]) else: setattr(self, attr, tuple(map(metric, value))) except: if value is not None: setattr(self, attr, metric(value)) def offset(self, x_offset=0, y_offset=0): """ Move the primitive by the specified x and y offset amount. values are specified in the primitive's native units """ if hasattr(self, 'position'): self._changed() self.position = tuple([coord + offset for coord, offset in zip(self.position, (x_offset, y_offset))]) def to_statement(self): pass def _changed(self): """ Clear memoized properties. Forces a recalculation next time any memoized propery is queried. This must be called from a subclass every time a parameter that affects a memoized property is changed. The easiest way to do this is to call _changed() from property.setter methods. """ self._bounding_box = None self._vertices = None self._segments = None for attr in self._memoized: setattr(self, attr, None) class Line(Primitive): """ """ def __init__(self, start, end, aperture, level_polarity=None, **kwargs): super(Line, self).__init__(**kwargs) self.level_polarity = level_polarity self._start = start self._end = end self.aperture = aperture self._to_convert = ['start', 'end', 'aperture'] @property def flashed(self): return False @property def start(self): return self._start @start.setter def start(self, value): self._changed() self._start = value @property def end(self): return self._end @end.setter def end(self, value): self._changed() self._end = value @property def angle(self): delta_x, delta_y = tuple( [end - start for end, start in zip(self.end, self.start)]) angle = math.atan2(delta_y, delta_x) return angle @property def bounding_box(self): if self._bounding_box is None: if isinstance(self.aperture, Circle): width_2 = self.aperture.radius height_2 = width_2 else: width_2 = self.aperture.width / 2. height_2 = self.aperture.height / 2. min_x = min(self.start[0], self.end[0]) - width_2 max_x = max(self.start[0], self.end[0]) + width_2 min_y = min(self.start[1], self.end[1]) - height_2 max_y = max(self.start[1], self.end[1]) + height_2 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): if self._vertices is None: start = self.start end = self.end if isinstance(self.aperture, Rectangle): width = self.aperture.width height = self.aperture.height # Find all the corners of the start and end position start_ll = (start[0] - (width / 2.), start[1] - (height / 2.)) start_lr = (start[0] + (width / 2.), start[1] - (height / 2.)) start_ul = (start[0] - (width / 2.), start[1] + (height / 2.)) start_ur = (start[0] + (width / 2.), start[1] + (height / 2.)) end_ll = (end[0] - (width / 2.), end[1] - (height / 2.)) end_lr = (end[0] + (width / 2.), end[1] - (height / 2.)) end_ul = (end[0] - (width / 2.), end[1] + (height / 2.)) end_ur = (end[0] + (width / 2.), end[1] + (height / 2.)) # The line is defined by the convex hull of the points self._vertices = convex_hull((start_ll, start_lr, start_ul, start_ur, end_ll, end_lr, end_ul, end_ur)) elif isinstance(self.aperture, Polygon): points = [map(add, point, vertex) for vertex in self.aperture.vertices for point in (start, end)] self._vertices = convex_hull(points) return self._vertices def offset(self, x_offset=0, y_offset=0): self._changed() self.start = tuple([coord + offset for coord, offset in zip(self.start, (x_offset, y_offset))]) 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) def __str__(self): return "<Line {} to {}>".format(self.start, self.end) def __repr__(self): return str(self) class Arc(Primitive): """ """ def __init__(self, start, end, center, direction, aperture, quadrant_mode, level_polarity=None, **kwargs): super(Arc, self).__init__(**kwargs) self.level_polarity = level_polarity 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 @start.setter def start(self, value): self._changed() self._start = value @property def end(self): return self._end @end.setter def end(self, value): self._changed() self._end = value @property def center(self): return self._center @center.setter def center(self, value): self._changed() 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)]) return math.sqrt(dy ** 2 + dx ** 2) @property def start_angle(self): dx, dy = tuple([start - center for start, center in zip(self.start, self.center)]) return math.atan2(dy, dx) @property def end_angle(self): dx, dy = tuple([end - center for end, center in zip(self.end, self.center)]) return math.atan2(dy, dx) @property def sweep_angle(self): two_pi = 2 * math.pi theta0 = (self.start_angle + two_pi) % two_pi theta1 = (self.end_angle + two_pi) % two_pi if self.direction == 'counterclockwise': return abs(theta1 - theta0) else: theta0 += two_pi return abs(theta0 - theta1) % two_pi @property def bounding_box(self): if self._bounding_box is None: 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.quadrant_mode == 'multi-quadrant': 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))) or ((theta1 > math.pi / 2.) and (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)) or ((theta1 > math.pi) and (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) or ((theta1 > math.pi * 1.5) and (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)) or ((theta0 > math.pi / 2.) and (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)) or ((theta0 > math.pi) and (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)) or ((theta0 > math.pi * 1.5) and (theta0 <= theta1))): points.append((self.center[0], self.center[1] - self.radius)) x, y = zip(*points) if hasattr(self.aperture, 'radius'): min_x = min(x) - self.aperture.radius max_x = max(x) + self.aperture.radius min_y = min(y) - self.aperture.radius max_y = max(y) + self.aperture.radius else: min_x = min(x) - self.aperture.width max_x = max(x) + self.aperture.width min_y = min(y) - self.aperture.height max_y = max(y) + self.aperture.height 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.quadrant_mode == 'multi-quadrant': 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))) or ((theta1 > math.pi / 2.) and (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)) or ((theta1 > math.pi) and (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) or ((theta1 > math.pi * 1.5) and (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)) or ((theta0 > math.pi / 2.) and (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)) or ((theta0 > math.pi) and (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)) or ((theta0 > math.pi * 1.5) and (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))) self.end = tuple(map(add, self.end, (x_offset, y_offset))) self.center = tuple(map(add, self.center, (x_offset, y_offset))) class Circle(Primitive): """ """ def __init__(self, position, diameter, hole_diameter=None, hole_width=0, hole_height=0, **kwargs): super(Circle, self).__init__(**kwargs) validate_coordinates(position) self._position = position self._diameter = diameter self.hole_diameter = hole_diameter self.hole_width = hole_width self.hole_height = hole_height self._to_convert = ['position', 'diameter', 'hole_diameter', 'hole_width', 'hole_height'] @property def flashed(self): return True @property def position(self): return self._position @position.setter def position(self, value): self._changed() self._position = value @property def diameter(self): return self._diameter @diameter.setter def diameter(self, value): self._changed() self._diameter = value @property def radius(self): 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 max_x = self.position[0] + self.radius min_y = self.position[1] - self.radius max_y = self.position[1] + self.radius 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) self._position = position self._width = width self._height = height self._to_convert = ['position', 'width', 'height'] @property def flashed(self): return True @property def position(self): return self._position @position.setter def position(self, value): self._changed() self._position = value @property def width(self): return self._width @width.setter def width(self, value): self._changed() self._width = value @property def height(self): return self._height @height.setter def height(self, value): self._changed() self._height = value @property def bounding_box(self): if self._bounding_box is None: min_x = self.position[0] - (self.axis_aligned_width / 2.0) max_x = self.position[0] + (self.axis_aligned_width / 2.0) min_y = self.position[1] - (self.axis_aligned_height / 2.0) max_y = self.position[1] + (self.axis_aligned_height / 2.0) self._bounding_box = ((min_x, max_x), (min_y, max_y)) return self._bounding_box @property def axis_aligned_width(self): ux = (self.width / 2.) * math.cos(math.radians(self.rotation)) vx = (self.height / 2.) * \ math.cos(math.radians(self.rotation) + (math.pi / 2.)) return 2 * math.sqrt((ux * ux) + (vx * vx)) @property def axis_aligned_height(self): uy = (self.width / 2.) * math.sin(math.radians(self.rotation)) vy = (self.height / 2.) * \ math.sin(math.radians(self.rotation) + (math.pi / 2.)) return 2 * math.sqrt((uy * uy) + (vy * vy)) 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, hole_diameter=0, hole_width=0, hole_height=0, **kwargs): super(Rectangle, self).__init__(**kwargs) validate_coordinates(position) self._position = position self._width = width self._height = height self.hole_diameter = hole_diameter self.hole_width = hole_width self.hole_height = hole_height self._to_convert = ['position', 'width', 'height', 'hole_diameter', 'hole_width', 'hole_height'] # 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 @position.setter def position(self, value): self._changed() self._position = value @property def width(self): return self._width @width.setter def width(self, value): self._changed() self._width = value @property def height(self): return self._height @height.setter def height(self, value): self._changed() 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.)) @property def bounding_box(self): if self._bounding_box is None: ll = (self.position[0] - (self.axis_aligned_width / 2.), self.position[1] - (self.axis_aligned_height / 2.)) ur = (self.position[0] + (self.axis_aligned_width / 2.), self.position[1] + (self.axis_aligned_height / 2.)) self._bounding_box = ((ll[0], ur[0]), (ll[1], ur[1])) return self._bounding_box @property def vertices(self): if self._vertices is None: delta_w = self.width / 2. delta_h = self.height / 2. ll = ((self.position[0] - delta_w), (self.position[1] - delta_h)) ul = ((self.position[0] - delta_w), (self.position[1] + delta_h)) ur = ((self.position[0] + delta_w), (self.position[1] + delta_h)) lr = ((self.position[0] + delta_w), (self.position[1] - delta_h)) self._vertices = [((x * self._cos_theta - y * self._sin_theta), (x * self._sin_theta + y * self._cos_theta)) for x, y in [ll, ul, ur, lr]] return self._vertices @property def axis_aligned_width(self): 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) 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) def __str__(self): return "<Rectangle W {} H {} R {}>".format(self.width, self.height, self.rotation * 180/math.pi) def __repr__(self): return self.__str__() class Diamond(Primitive): """ """ def __init__(self, position, width, height, **kwargs): super(Diamond, self).__init__(**kwargs) validate_coordinates(position) self._position = position self._width = width self._height = height self._to_convert = ['position', 'width', 'height'] @property def flashed(self): return True @property def position(self): return self._position @position.setter def position(self, value): self._changed() self._position = value @property def width(self): return self._width @width.setter def width(self, value): self._changed() self._width = value @property def height(self): return self._height @height.setter def height(self, value): self._changed() self._height = value @property def bounding_box(self): if self._bounding_box is None: ll = (self.position[0] - (self.axis_aligned_width / 2.), self.position[1] - (self.axis_aligned_height / 2.)) ur = (self.position[0] + (self.axis_aligned_width / 2.), self.position[1] + (self.axis_aligned_height / 2.)) self._bounding_box = ((ll[0], ur[0]), (ll[1], ur[1])) return self._bounding_box @property def vertices(self): if self._vertices is None: delta_w = self.width / 2. delta_h = self.height / 2. top = (self.position[0], (self.position[1] + delta_h)) right = ((self.position[0] + delta_w), self.position[1]) bottom = (self.position[0], (self.position[1] - delta_h)) left = ((self.position[0] - delta_w), self.position[1]) self._vertices = [(((x * self._cos_theta) - (y * self._sin_theta)), ((x * self._sin_theta) + (y * self._cos_theta))) for x, y in [top, right, bottom, left]] return self._vertices @property def axis_aligned_width(self): 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) class ChamferRectangle(Primitive): """ """ def __init__(self, position, width, height, chamfer, corners=None, **kwargs): super(ChamferRectangle, self).__init__(**kwargs) validate_coordinates(position) self._position = position self._width = width self._height = height self._chamfer = chamfer self._corners = corners if corners is not None else [True] * 4 self._to_convert = ['position', 'width', 'height', 'chamfer'] @property def flashed(self): return True @property def position(self): return self._position @position.setter def position(self, value): self._changed() self._position = value @property def width(self): return self._width @width.setter def width(self, value): self._changed() self._width = value @property def height(self): return self._height @height.setter def height(self, value): self._changed() self._height = value @property def chamfer(self): return self._chamfer @chamfer.setter def chamfer(self, value): self._changed() self._chamfer = value @property def corners(self): return self._corners @corners.setter def corners(self, value): self._changed() self._corners = value @property def bounding_box(self): if self._bounding_box is None: ll = (self.position[0] - (self.axis_aligned_width / 2.), self.position[1] - (self.axis_aligned_height / 2.)) ur = (self.position[0] + (self.axis_aligned_width / 2.), self.position[1] + (self.axis_aligned_height / 2.)) self._bounding_box = ((ll[0], ur[0]), (ll[1], ur[1])) return self._bounding_box @property def vertices(self): if self._vertices is None: vertices = [] delta_w = self.width / 2. delta_h = self.height / 2. # order is UR, UL, LL, LR rect_corners = [ ((self.position[0] + delta_w), (self.position[1] + delta_h)), ((self.position[0] - delta_w), (self.position[1] + delta_h)), ((self.position[0] - delta_w), (self.position[1] - delta_h)), ((self.position[0] + delta_w), (self.position[1] - delta_h)) ] for idx, params in enumerate(zip(rect_corners, self.corners)): corner, chamfered = params x, y = corner if chamfered: if idx == 0: vertices.append((x - self.chamfer, y)) vertices.append((x, y - self.chamfer)) elif idx == 1: vertices.append((x + self.chamfer, y)) vertices.append((x, y - self.chamfer)) elif idx == 2: vertices.append((x + self.chamfer, y)) vertices.append((x, y + self.chamfer)) elif idx == 3: vertices.append((x - self.chamfer, y)) vertices.append((x, y + self.chamfer)) else: vertices.append(corner) 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 @property def axis_aligned_width(self): 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) class RoundRectangle(Primitive): """ """ def __init__(self, position, width, height, radius, corners, **kwargs): super(RoundRectangle, self).__init__(**kwargs) validate_coordinates(position) self._position = position self._width = width self._height = height self._radius = radius self._corners = corners self._to_convert = ['position', 'width', 'height', 'radius'] @property def flashed(self): return True @property def position(self): return self._position @position.setter def position(self, value): self._changed() self._position = value @property def width(self): return self._width @width.setter def width(self, value): self._changed() self._width = value @property def height(self): return self._height @height.setter def height(self, value): self._changed() self._height = value @property def radius(self): return self._radius @radius.setter def radius(self, value): self._changed() self._radius = value @property def corners(self): return self._corners @corners.setter def corners(self, value): self._changed() self._corners = value @property def bounding_box(self): if self._bounding_box is None: ll = (self.position[0] - (self.axis_aligned_width / 2.), self.position[1] - (self.axis_aligned_height / 2.)) ur = (self.position[0] + (self.axis_aligned_width / 2.), self.position[1] + (self.axis_aligned_height / 2.)) self._bounding_box = ((ll[0], ur[0]), (ll[1], ur[1])) return self._bounding_box @property def axis_aligned_width(self): 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) class Obround(Primitive): """ """ def __init__(self, position, width, height, hole_diameter=0, hole_width=0,hole_height=0, **kwargs): super(Obround, self).__init__(**kwargs) validate_coordinates(position) self._position = position self._width = width self._height = height self.hole_diameter = hole_diameter self.hole_width = hole_width self.hole_height = hole_height self._to_convert = ['position', 'width', 'height', 'hole_diameter', 'hole_width', 'hole_height' ] @property def flashed(self): return True @property def position(self): return self._position @position.setter def position(self, value): self._changed() self._position = value @property def width(self): return self._width @width.setter def width(self, value): self._changed() self._width = value @property def height(self): return self._height @height.setter def height(self, value): self._changed() 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' @property def bounding_box(self): if self._bounding_box is None: ll = (self.position[0] - (self.axis_aligned_width / 2.), self.position[1] - (self.axis_aligned_height / 2.)) ur = (self.position[0] + (self.axis_aligned_width / 2.), self.position[1] + (self.axis_aligned_height / 2.)) self._bounding_box = ((ll[0], ur[0]), (ll[1], ur[1])) return self._bounding_box @property def subshapes(self): if self.orientation == 'vertical': circle1 = Circle((self.position[0], self.position[1] + (self.height - self.width) / 2.), self.width) circle2 = Circle((self.position[0], self.position[1] - (self.height - self.width) / 2.), self.width) rect = Rectangle(self.position, self.width, (self.height - self.width)) else: circle1 = Circle((self.position[0] - (self.height - self.width) / 2., self.position[1]), self.height) circle2 = Circle((self.position[0] + (self.height - self.width) / 2., self.position[1]), self.height) rect = Rectangle(self.position, (self.width - self.height), self.height) return {'circle1': circle1, 'circle2': circle2, 'rectangle': rect} @property def axis_aligned_width(self): 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) class Polygon(Primitive): """ Polygon flash defined by a set number of sides. """ def __init__(self, position, sides, radius, hole_diameter=0, hole_width=0, hole_height=0, **kwargs): super(Polygon, self).__init__(**kwargs) validate_coordinates(position) self._position = position self.sides = sides self._radius = radius self.hole_diameter = hole_diameter self.hole_width = hole_width self.hole_height = hole_height self._to_convert = ['position', 'radius', 'hole_diameter', 'hole_width', 'hole_height'] @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): return self._position @position.setter def position(self, value): self._changed() self._position = value @property def radius(self): return self._radius @radius.setter def radius(self, value): self._changed() self._radius = value @property def bounding_box(self): if self._bounding_box is None: min_x = self.position[0] - self.radius max_x = self.position[0] + self.radius min_y = self.position[1] - self.radius max_y = self.position[1] + self.radius 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 delta_angle = 360.0 / self.sides points = [] for i in range(self.sides): points.append( rotate_point((self.position[0] + self.radius, self.position[1]), offset + delta_angle * i, self.position)) return points 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: 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 @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): """ """ def __init__(self, primitives, **kwargs): super(Region, self).__init__(**kwargs) self.primitives = primitives 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_no_aperture 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) class RoundButterfly(Primitive): """ A circle with two diagonally-opposite quadrants removed """ def __init__(self, position, diameter, **kwargs): super(RoundButterfly, self).__init__(**kwargs) validate_coordinates(position) self.position = position 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. @property def bounding_box(self): if self._bounding_box is None: min_x = self.position[0] - self.radius max_x = self.position[0] + self.radius min_y = self.position[1] - self.radius max_y = self.position[1] + self.radius self._bounding_box = ((min_x, max_x), (min_y, max_y)) return self._bounding_box class SquareButterfly(Primitive): """ A square with two diagonally-opposite quadrants removed """ def __init__(self, position, side, **kwargs): super(SquareButterfly, self).__init__(**kwargs) validate_coordinates(position) self.position = position 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: min_x = self.position[0] - (self.side / 2.) max_x = self.position[0] + (self.side / 2.) min_y = self.position[1] - (self.side / 2.) max_y = self.position[1] + (self.side / 2.) self._bounding_box = ((min_x, max_x), (min_y, max_y)) return self._bounding_box class Donut(Primitive): """ A Shape with an identical concentric shape removed from its center """ def __init__(self, position, shape, inner_diameter, outer_diameter, **kwargs): super(Donut, self).__init__(**kwargs) validate_coordinates(position) self.position = position if shape not in ('round', 'square', 'hexagon', 'octagon'): raise ValueError( 'Valid shapes are round, square, hexagon or octagon') self.shape = shape if inner_diameter >= outer_diameter: raise ValueError( 'Outer diameter must be larger than inner diameter.') self.inner_diameter = inner_diameter self.outer_diameter = outer_diameter if self.shape in ('round', 'square', 'octagon'): self.width = outer_diameter self.height = outer_diameter else: # 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: ll = (self.position[0] - (self.width / 2.), self.position[1] - (self.height / 2.)) ur = (self.position[0] + (self.width / 2.), self.position[1] + (self.height / 2.)) self._bounding_box = ((ll[0], ur[0]), (ll[1], ur[1])) return self._bounding_box class SquareRoundDonut(Primitive): """ A Square with a circular cutout in the center """ def __init__(self, position, inner_diameter, outer_diameter, **kwargs): super(SquareRoundDonut, self).__init__(**kwargs) validate_coordinates(position) self.position = position if inner_diameter >= outer_diameter: raise ValueError( 'Outer diameter must be larger than inner diameter.') self.inner_diameter = inner_diameter self.outer_diameter = outer_diameter 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]) 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 class Drill(Primitive): """ A drill hole """ def __init__(self, position, diameter, **kwargs): super(Drill, self).__init__('dark', **kwargs) validate_coordinates(position) self._position = position self._diameter = diameter self._to_convert = ['position', 'diameter'] @property def flashed(self): return False @property def position(self): return self._position @position.setter def position(self, value): self._changed() self._position = value @property def diameter(self): return self._diameter @diameter.setter def diameter(self, value): self._changed() self._diameter = value @property def radius(self): return self.diameter / 2. @property def bounding_box(self): if self._bounding_box is None: min_x = self.position[0] - self.radius max_x = self.position[0] + self.radius min_y = self.position[1] - self.radius max_y = self.position[1] + self.radius 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 %s (%f, %f)>' % (self.diameter, self.units, self.position[0], self.position[1]) class Slot(Primitive): """ A drilled slot """ def __init__(self, start, end, diameter, **kwargs): super(Slot, self).__init__('dark', **kwargs) validate_coordinates(start) validate_coordinates(end) self.start = start self.end = end self.diameter = diameter self._to_convert = ['start', 'end', 'diameter'] @property def flashed(self): return False @property def bounding_box(self): if self._bounding_box is None: radius = self.diameter / 2. 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 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.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 """ def __init__(self, position, net_name, layer, **kwargs): super(TestRecord, self).__init__(**kwargs) validate_coordinates(position) self.position = position self.net_name = net_name self.layer = layer self._to_convert = ['position']