summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--gerbonara/aperture_macros/expression.py68
-rw-r--r--gerbonara/aperture_macros/parse.py183
-rw-r--r--gerbonara/aperture_macros/primitive.py194
-rw-r--r--gerbonara/apertures.py203
-rw-r--r--gerbonara/cad/kicad/footprints.py74
-rw-r--r--gerbonara/cad/primitives.py39
-rw-r--r--gerbonara/graphic_objects.py8
-rw-r--r--gerbonara/utils.py25
8 files changed, 381 insertions, 413 deletions
diff --git a/gerbonara/aperture_macros/expression.py b/gerbonara/aperture_macros/expression.py
index 0b2168f..63f1e42 100644
--- a/gerbonara/aperture_macros/expression.py
+++ b/gerbonara/aperture_macros/expression.py
@@ -3,17 +3,20 @@
# Copyright 2021 Jan Sebastian Götte <gerbonara@jaseg.de>
+from dataclasses import dataclass
import operator
import re
import ast
-from ..utils import MM, Inch, MILLIMETERS_PER_INCH
+from ..utils import LengthUnit, MM, Inch, MILLIMETERS_PER_INCH
def expr(obj):
return obj if isinstance(obj, Expression) else ConstantExpression(obj)
+_make_expr = expr
+@dataclass(frozen=True, slots=True)
class Expression:
def optimized(self, variable_binding={}):
return self
@@ -63,13 +66,18 @@ class Expression:
def __pos__(self):
return self
+
+@dataclass(frozen=True, slots=True)
class UnitExpression(Expression):
+ expr: Expression
+ unit: LengthUnit
+
def __init__(self, expr, unit):
- if isinstance(expr, Expression):
- self._expr = expr
- else:
- self._expr = ConstantExpression(expr)
- self.unit = unit
+ expr = _make_expr(expr)
+ if isinstance(expr, UnitExpression):
+ expr = expr.converted(unit)
+ object.__setattr__(self, 'expr', expr)
+ object.__setattr__(self, 'unit', unit)
def to_gerber(self, unit=None):
return self.converted(unit).optimized().to_gerber()
@@ -77,23 +85,23 @@ class UnitExpression(Expression):
def __eq__(self, other):
return type(other) == type(self) and \
self.unit == other.unit and\
- self._expr == other._expr
+ self.expr == other.expr
def __str__(self):
- return f'<{self._expr.to_gerber()} {self.unit}>'
+ return f'<{self.expr.to_gerber()} {self.unit}>'
def __repr__(self):
- return f'<UE {self._expr.to_gerber()} {self.unit}>'
+ return f'<UE {self.expr.to_gerber()} {self.unit}>'
def converted(self, unit):
if self.unit is None or unit is None or self.unit == unit:
- return self._expr
+ return self.expr
elif MM == unit:
- return self._expr * MILLIMETERS_PER_INCH
+ return self.expr * MILLIMETERS_PER_INCH
elif Inch == unit:
- return self._expr / MILLIMETERS_PER_INCH
+ return self.expr / MILLIMETERS_PER_INCH
else:
raise ValueError(f'invalid unit {unit}, must be "inch" or "mm".')
@@ -103,12 +111,12 @@ class UnitExpression(Expression):
raise ValueError('Unit mismatch: Can only add/subtract UnitExpression from UnitExpression, not scalar.')
if self.unit == other.unit or self.unit is None or other.unit is None:
- return UnitExpression(self._expr + other._expr, self.unit)
+ return UnitExpression(self.expr + other.expr, self.unit)
if other.unit == 'mm': # -> and self.unit == 'inch'
- return UnitExpression(self._expr + (other._expr / MILLIMETERS_PER_INCH), self.unit)
+ return UnitExpression(self.expr + (other.expr / MILLIMETERS_PER_INCH), self.unit)
else: # other.unit == 'inch' and self.unit == 'mm'
- return UnitExpression(self._expr + (other._expr * MILLIMETERS_PER_INCH), self.unit)
+ return UnitExpression(self.expr + (other.expr * MILLIMETERS_PER_INCH), self.unit)
def __radd__(self, other):
# left hand side cannot have been an UnitExpression or __radd__ would not have been called
@@ -122,27 +130,26 @@ class UnitExpression(Expression):
raise ValueError('Unit mismatch: Can only add/subtract UnitExpression from UnitExpression, not scalar.')
def __mul__(self, other):
- return UnitExpression(self._expr * other, self.unit)
+ return UnitExpression(self.expr * other, self.unit)
def __rmul__(self, other):
- return UnitExpression(other * self._expr, self.unit)
+ return UnitExpression(other * self.expr, self.unit)
def __truediv__(self, other):
- return UnitExpression(self._expr / other, self.unit)
+ return UnitExpression(self.expr / other, self.unit)
def __rtruediv__(self, other):
- return UnitExpression(other / self._expr, self.unit)
+ return UnitExpression(other / self.expr, self.unit)
def __neg__(self):
- return UnitExpression(-self._expr, self.unit)
+ return UnitExpression(-self.expr, self.unit)
def __pos__(self):
return self
-
+@dataclass(frozen=True, slots=True)
class ConstantExpression(Expression):
- def __init__(self, value):
- self.value = value
+ value: float
def __float__(self):
return float(self.value)
@@ -154,9 +161,9 @@ class ConstantExpression(Expression):
return f'{self.value:.6f}'.rstrip('0').rstrip('.')
+@dataclass(frozen=True, slots=True)
class VariableExpression(Expression):
- def __init__(self, number):
- self.number = number
+ number: int
def optimized(self, variable_binding={}):
if self.number in variable_binding:
@@ -171,11 +178,16 @@ class VariableExpression(Expression):
return f'${self.number}'
+@dataclass(frozen=True, slots=True)
class OperatorExpression(Expression):
+ op: str
+ l: Expression
+ r: Expression
+
def __init__(self, op, l, r):
- self.op = op
- self.l = ConstantExpression(l) if isinstance(l, (int, float)) else l
- self.r = ConstantExpression(r) if isinstance(r, (int, float)) else r
+ object.__setattr__(self, 'op', op)
+ object.__setattr__(self, 'l', expr(l))
+ object.__setattr__(self, 'r', expr(r))
def __eq__(self, other):
return type(self) == type(other) and \
diff --git a/gerbonara/aperture_macros/parse.py b/gerbonara/aperture_macros/parse.py
index 84c35e0..72703ae 100644
--- a/gerbonara/aperture_macros/parse.py
+++ b/gerbonara/aperture_macros/parse.py
@@ -3,6 +3,7 @@
# Copyright 2021 Jan Sebastian Götte <gerbonara@jaseg.de>
+from dataclasses import dataclass, field, replace
import operator
import re
import ast
@@ -46,16 +47,23 @@ def _parse_expression(expr):
raise SyntaxError('Invalid aperture macro expression') from e
return _map_expression(parsed)
+@dataclass(frozen=True, slots=True)
class ApertureMacro:
- def __init__(self, name=None, primitives=None, variables=None):
- self._name = name
- self.comments = []
- self.variables = variables or {}
- self.primitives = primitives or []
+ name: str = None
+ primitives: tuple = ()
+ variables: tuple = ()
+ comments: tuple = ()
+
+ def __post_init__(self):
+ if self.name is None:
+ # We can't use field(default_factory=...) here because that factory doesn't get a reference to the instance.
+ object.__setattr__(self, 'name', f'gn_{hash(self):x}')
@classmethod
def parse_macro(cls, name, body, unit):
- macro = cls(name)
+ comments = []
+ variables = {}
+ primitives = []
blocks = body.split('*')
for block in blocks:
@@ -63,7 +71,7 @@ class ApertureMacro:
continue
if block.startswith('0 '): # comment
- macro.comments.append(block[2:])
+ comments.append(block[2:])
continue
block = re.sub(r'\s', '', block)
@@ -71,28 +79,18 @@ class ApertureMacro:
if block[0] == '$': # variable definition
name, expr = block.partition('=')
number = int(name[1:])
- if number in macro.variables:
+ if number in variables:
raise SyntaxError(f'Re-definition of aperture macro variable {number} inside macro')
- macro.variables[number] = _parse_expression(expr)
+ variables[number] = _parse_expression(expr)
else: # primitive
primitive, *args = block.split(',')
args = [ _parse_expression(arg) for arg in args ]
primitive = ap.PRIMITIVE_CLASSES[int(primitive)](unit=unit, args=args)
- macro.primitives.append(primitive)
-
- return macro
-
- @property
- def name(self):
- if self._name is not None:
- return self._name
- else:
- return f'gn_{hash(self)}'
+ primitives.append(primitive)
- @name.setter
- def name(self, name):
- self._name = name
+ variables = [variables.get(i+1) for i in range(max(variables.keys()))]
+ return kls(name, tuple(primitives), tuple(variables), tuple(primitives))
def __str__(self):
return f'<Aperture macro {self.name}, variables {str(self.variables)}, primitives {self.primitives}>'
@@ -100,54 +98,41 @@ class ApertureMacro:
def __repr__(self):
return str(self)
- def __eq__(self, other):
- return hasattr(other, 'to_gerber') and self.to_gerber() == other.to_gerber()
-
- def __hash__(self):
- return hash(self.to_gerber())
-
def dilated(self, offset, unit=MM):
- dup = copy.deepcopy(self)
new_primitives = []
- for primitive in dup.primitives:
+ for primitive in self.primitives:
try:
if primitive.exposure.calculate():
- primitive.dilate(offset, unit)
- new_primitives.append(primitive)
+ new_primitives += primitive.dilated(offset, unit)
except IndexError:
warnings.warn('Cannot dilate aperture macro primitive with exposure value computed from macro variable.')
pass
- dup.primitives = new_primitives
- return dup
+ return replace(self, primitives=tuple(new_primitives))
def to_gerber(self, unit=None):
comments = [ str(c) for c in self.comments ]
- variable_defs = [ f'${var.to_gerber(unit)}={expr}' for var, expr in self.variables.items() ]
+ variable_defs = [ f'${var.to_gerber(unit)}={expr}' for var, expr in enumerate(self.variables, start=1) ]
primitive_defs = [ prim.to_gerber(unit) for prim in self.primitives ]
return '*\n'.join(comments + variable_defs + primitive_defs)
def to_graphic_primitives(self, offset, rotation, parameters : [float], unit=None, polarity_dark=True):
- variables = dict(self.variables)
+ variables = {i: v for i, v in enumerate(self.variables, start=1)}
for number, value in enumerate(parameters, start=1):
if number in variables:
- raise SyntaxError(f'Re-definition of aperture macro variable {i} through parameter {value}')
+ raise SyntaxError(f'Re-definition of aperture macro variable {number} through parameter {value}')
variables[number] = value
for primitive in self.primitives:
yield from primitive.to_graphic_primitives(offset, rotation, variables, unit, polarity_dark)
def rotated(self, angle):
- dup = copy.deepcopy(self)
- for primitive in dup.primitives:
- # aperture macro primitives use degree counter-clockwise, our API uses radians clockwise
- primitive.rotation -= rad_to_deg(angle)
- return dup
+ # aperture macro primitives use degree counter-clockwise, our API uses radians clockwise
+ return replace(self, primitives=tuple(
+ replace(primitive, rotation=primitive.rotation - rad_to_deg(angle)) for primitive in self.primitives))
def scaled(self, scale):
- dup = copy.deepcopy(self)
- for primitive in dup.primitives:
- primitive.scale(scale)
- return dup
+ return replace(self, primitives=tuple(
+ primitive.scaled(scale) for primitive in self.primitives))
var = VariableExpression
@@ -155,83 +140,81 @@ deg_per_rad = 180 / math.pi
class GenericMacros:
- _generic_hole = lambda n: [
- ap.Circle('mm', [0, var(n), 0, 0]),
- ap.CenterLine('mm', [0, var(n), var(n+1), 0, 0, var(n+2) * -deg_per_rad])]
+ _generic_hole = lambda n: (ap.Circle('mm', 0, var(n), 0, 0),)
# NOTE: All generic macros have rotation values specified in **clockwise radians** like the rest of the user-facing
# API.
- circle = ApertureMacro('GNC', [
- ap.Circle('mm', [1, var(1), 0, 0, var(4) * -deg_per_rad]),
- *_generic_hole(2)])
+ circle = ApertureMacro('GNC', (
+ ap.Circle('mm', 1, var(1), 0, 0, var(4) * -deg_per_rad),
+ *_generic_hole(2)))
- rect = ApertureMacro('GNR', [
- ap.CenterLine('mm', [1, var(1), var(2), 0, 0, var(5) * -deg_per_rad]),
- *_generic_hole(3)])
+ rect = ApertureMacro('GNR', (
+ ap.CenterLine('mm', 1, var(1), var(2), 0, 0, var(5) * -deg_per_rad),
+ *_generic_hole(3)))
# params: width, height, corner radius, *hole, rotation
- rounded_rect = ApertureMacro('GRR', [
- ap.CenterLine('mm', [1, var(1)-2*var(3), var(2), 0, 0, var(6) * -deg_per_rad]),
- ap.CenterLine('mm', [1, var(1), var(2)-2*var(3), 0, 0, var(6) * -deg_per_rad]),
- ap.Circle('mm', [1, var(3)*2, +(var(1)/2-var(3)), +(var(2)/2-var(3)), var(6) * -deg_per_rad]),
- ap.Circle('mm', [1, var(3)*2, +(var(1)/2-var(3)), -(var(2)/2-var(3)), var(6) * -deg_per_rad]),
- ap.Circle('mm', [1, var(3)*2, -(var(1)/2-var(3)), +(var(2)/2-var(3)), var(6) * -deg_per_rad]),
- ap.Circle('mm', [1, var(3)*2, -(var(1)/2-var(3)), -(var(2)/2-var(3)), var(6) * -deg_per_rad]),
- *_generic_hole(4)])
+ rounded_rect = ApertureMacro('GRR', (
+ ap.CenterLine('mm', 1, var(1)-2*var(3), var(2), 0, 0, var(6) * -deg_per_rad),
+ ap.CenterLine('mm', 1, var(1), var(2)-2*var(3), 0, 0, var(6) * -deg_per_rad),
+ ap.Circle('mm', 1, var(3)*2, +(var(1)/2-var(3)), +(var(2)/2-var(3)), var(6) * -deg_per_rad),
+ ap.Circle('mm', 1, var(3)*2, +(var(1)/2-var(3)), -(var(2)/2-var(3)), var(6) * -deg_per_rad),
+ ap.Circle('mm', 1, var(3)*2, -(var(1)/2-var(3)), +(var(2)/2-var(3)), var(6) * -deg_per_rad),
+ ap.Circle('mm', 1, var(3)*2, -(var(1)/2-var(3)), -(var(2)/2-var(3)), var(6) * -deg_per_rad),
+ *_generic_hole(4)))
# params: width, height, length difference between narrow side (top) and wide side (bottom), *hole, rotation
- isosceles_trapezoid = ApertureMacro('GTR', [
- ap.Outline('mm', [1, 4,
- var(1)/-2, var(2)/-2,
+ isosceles_trapezoid = ApertureMacro('GTR', (
+ ap.Outline('mm', 1, 4,
+ (var(1)/-2, var(2)/-2,
var(1)/-2+var(3)/2, var(2)/2,
var(1)/2-var(3)/2, var(2)/2,
var(1)/2, var(2)/-2,
- var(1)/-2, var(2)/-2,
- var(6) * -deg_per_rad]),
- *_generic_hole(4)])
+ var(1)/-2, var(2)/-2,),
+ var(6) * -deg_per_rad),
+ *_generic_hole(4)))
# params: width, height, length difference between narrow side (top) and wide side (bottom), margin, *hole, rotation
- rounded_isosceles_trapezoid = ApertureMacro('GRTR', [
- ap.Outline('mm', [1, 4,
- var(1)/-2, var(2)/-2,
+ rounded_isosceles_trapezoid = ApertureMacro('GRTR', (
+ ap.Outline('mm', 1, 4,
+ (var(1)/-2, var(2)/-2,
var(1)/-2+var(3)/2, var(2)/2,
var(1)/2-var(3)/2, var(2)/2,
var(1)/2, var(2)/-2,
+ var(1)/-2, var(2)/-2,),
+ var(6) * -deg_per_rad),
+ ap.VectorLine('mm', 1, var(4)*2,
var(1)/-2, var(2)/-2,
- var(6) * -deg_per_rad]),
- ap.VectorLine('mm', [1, var(4)*2,
- var(1)/-2, var(2)/-2,
- var(1)/-2+var(3)/2, var(2)/2,]),
- ap.VectorLine('mm', [1, var(4)*2,
+ var(1)/-2+var(3)/2, var(2)/2,),
+ ap.VectorLine('mm', 1, var(4)*2,
var(1)/-2+var(3)/2, var(2)/2,
- var(1)/2-var(3)/2, var(2)/2,]),
- ap.VectorLine('mm', [1, var(4)*2,
+ var(1)/2-var(3)/2, var(2)/2,),
+ ap.VectorLine('mm', 1, var(4)*2,
var(1)/2-var(3)/2, var(2)/2,
- var(1)/2, var(2)/-2,]),
- ap.VectorLine('mm', [1, var(4)*2,
+ var(1)/2, var(2)/-2,),
+ ap.VectorLine('mm', 1, var(4)*2,
var(1)/2, var(2)/-2,
- var(1)/-2, var(2)/-2,]),
- ap.Circle('mm', [1, var(4)*2,
- var(1)/-2, var(2)/-2,]),
- ap.Circle('mm', [1, var(4)*2,
- var(1)/-2+var(3)/2, var(2)/2,]),
- ap.Circle('mm', [1, var(4)*2,
- var(1)/2-var(3)/2, var(2)/2,]),
- ap.Circle('mm', [1, var(4)*2,
- var(1)/2, var(2)/-2,]),
- *_generic_hole(5)])
+ var(1)/-2, var(2)/-2,),
+ ap.Circle('mm', 1, var(4)*2,
+ var(1)/-2, var(2)/-2,),
+ ap.Circle('mm', 1, var(4)*2,
+ var(1)/-2+var(3)/2, var(2)/2,),
+ ap.Circle('mm', 1, var(4)*2,
+ var(1)/2-var(3)/2, var(2)/2,),
+ ap.Circle('mm', 1, var(4)*2,
+ var(1)/2, var(2)/-2,),
+ *_generic_hole(5)))
# w must be larger than h
# params: width, height, *hole, rotation
- obround = ApertureMacro('GNO', [
- ap.CenterLine('mm', [1, var(1)-var(2), var(2), 0, 0, var(5) * -deg_per_rad]),
- ap.Circle('mm', [1, var(2), +(var(1)-var(2))/2, 0, var(5) * -deg_per_rad]),
- ap.Circle('mm', [1, var(2), -(var(1)-var(2))/2, 0, var(5) * -deg_per_rad]),
- *_generic_hole(3) ])
-
- polygon = ApertureMacro('GNP', [
- ap.Polygon('mm', [1, var(2), 0, 0, var(1), var(3) * -deg_per_rad]),
- ap.Circle('mm', [0, var(4), 0, 0])])
+ obround = ApertureMacro('GNO', (
+ ap.CenterLine('mm', 1, var(1)-var(2), var(2), 0, 0, var(5) * -deg_per_rad),
+ ap.Circle('mm', 1, var(2), +(var(1)-var(2))/2, 0, var(5) * -deg_per_rad),
+ ap.Circle('mm', 1, var(2), -(var(1)-var(2))/2, 0, var(5) * -deg_per_rad),
+ *_generic_hole(3) ))
+
+ polygon = ApertureMacro('GNP', (
+ ap.Polygon('mm', 1, var(2), 0, 0, var(1), var(3) * -deg_per_rad),
+ ap.Circle('mm', 0, var(4), 0, 0)))
if __name__ == '__main__':
diff --git a/gerbonara/aperture_macros/primitive.py b/gerbonara/aperture_macros/primitive.py
index e424623..5700743 100644
--- a/gerbonara/aperture_macros/primitive.py
+++ b/gerbonara/aperture_macros/primitive.py
@@ -7,12 +7,13 @@
import warnings
import contextlib
import math
+from dataclasses import dataclass, fields
from .expression import Expression, UnitExpression, ConstantExpression, expr
from .. import graphic_primitives as gp
from .. import graphic_objects as go
-from ..utils import rotate_point
+from ..utils import rotate_point, LengthUnit
def point_distance(a, b):
@@ -30,24 +31,20 @@ def rad_to_deg(a):
return a * (180 / math.pi)
+@dataclass(frozen=True, slots=True)
class Primitive:
- def __init__(self, unit, args):
- self.unit = unit
-
- if len(args) > len(type(self).__annotations__):
- raise ValueError(f'Too many arguments ({len(args)}) for aperture macro primitive {self.code} ({type(self)})')
-
- for arg, (name, fieldtype) in zip(args, type(self).__annotations__.items()):
- arg = expr(arg) # convert int/float to Expression object
-
- if fieldtype == UnitExpression:
- setattr(self, name, UnitExpression(arg, unit))
- else:
- setattr(self, name, arg)
+ unit: LengthUnit
+ exposure : Expression
- for name in type(self).__annotations__:
- if not hasattr(self, name):
- raise ValueError(f'Too few arguments ({len(args)}) for aperture macro primitive {self.code} ({type(self)})')
+ def __post_init__(self):
+ for field in fields(self):
+ if field.type == UnitExpression:
+ value = getattr(self, field.name)
+ if not isinstance(value, UnitExpression):
+ value = UnitExpression(expr(value), self.unit)
+ object.__setattr__(self, field.name, value)
+ elif field.type == Expression:
+ object.__setattr__(self, field.name, expr(getattr(self, field.name)))
def to_gerber(self, unit=None):
return f'{self.code},' + ','.join(
@@ -60,6 +57,10 @@ class Primitive:
def __repr__(self):
return str(self)
+ @classmethod
+ def from_arglist(kls, arglist):
+ return kls(*arglist)
+
class Calculator:
def __init__(self, instance, variable_binding={}, unit=None):
self.instance = instance
@@ -79,19 +80,14 @@ class Primitive:
return expr.calculate(self.variable_binding, self.unit)
+@dataclass(frozen=True, slots=True)
class Circle(Primitive):
code = 1
- exposure : Expression
diameter : UnitExpression
# center x/y
x : UnitExpression
y : UnitExpression
- rotation : Expression = None
-
- def __init__(self, unit, args):
- super().__init__(unit, args)
- if self.rotation is None:
- self.rotation = ConstantExpression(0)
+ rotation : Expression = 0
def to_graphic_primitives(self, offset, rotation, variable_binding={}, unit=None, polarity_dark=True):
with self.Calculator(self, variable_binding, unit) as calc:
@@ -99,24 +95,23 @@ class Circle(Primitive):
x, y = x+offset[0], y+offset[1]
return [ gp.Circle(x, y, calc.diameter/2, polarity_dark=(bool(calc.exposure) == polarity_dark)) ]
- def dilate(self, offset, unit):
- self.diameter += UnitExpression(offset, unit)
+ def dilated(self, offset, unit):
+ return replace(self, diameter=self.diameter + UnitExpression(offset, unit))
- def scale(self, scale):
- self.x *= UnitExpression(scale)
- self.y *= UnitExpression(scale)
- self.diameter *= UnitExpression(scale)
+ def scaled(self, scale):
+ return replace(self, x=self.x * UnitExpression(scale), y=self.y * UnitExpression(scale),
+ diameter=self.diameter * UnitExpression(scale))
+@dataclass(frozen=True, slots=True)
class VectorLine(Primitive):
code = 20
- exposure : Expression
width : UnitExpression
start_x : UnitExpression
start_y : UnitExpression
end_x : UnitExpression
end_y : UnitExpression
- rotation : Expression = None
+ rotation : Expression = 0
def to_graphic_primitives(self, offset, rotation, variable_binding={}, unit=None, polarity_dark=True):
with self.Calculator(self, variable_binding, unit) as calc:
@@ -133,25 +128,26 @@ class VectorLine(Primitive):
return [ gp.Rectangle(center_x, center_y, length, calc.width, rotation=rotation,
polarity_dark=(bool(calc.exposure) == polarity_dark)) ]
- def dilate(self, offset, unit):
- self.width += UnitExpression(2*offset, unit)
+ def dilated(self, offset, unit):
+ return replace(self, width=self.width + UnitExpression(2*offset, unit))
- def scale(self, scale):
- self.start_x *= UnitExpression(scale)
- self.start_y *= UnitExpression(scale)
- self.end_x *= UnitExpression(scale)
- self.end_y *= UnitExpression(scale)
+ def scaled(self, scale):
+ return replace(self,
+ start_x=self.start_x * UnitExpression(scale),
+ start_y=self.start_y * UnitExpression(scale),
+ end_x=self.end_x * UnitExpression(scale),
+ end_y=self.end_y * UnitExpression(scale))
+@dataclass(frozen=True, slots=True)
class CenterLine(Primitive):
code = 21
- exposure : Expression
width : UnitExpression
height : UnitExpression
# center x/y
- x : UnitExpression
- y : UnitExpression
- rotation : Expression
+ x : UnitExpression = 0
+ y : UnitExpression = 0
+ rotation : Expression = 0
def to_graphic_primitives(self, offset, rotation, variable_binding={}, unit=None, polarity_dark=True):
with self.Calculator(self, variable_binding, unit) as calc:
@@ -162,25 +158,26 @@ class CenterLine(Primitive):
return [ gp.Rectangle(x, y, w, h, rotation, polarity_dark=(bool(calc.exposure) == polarity_dark)) ]
- def dilate(self, offset, unit):
- self.width += UnitExpression(2*offset, unit)
+ def dilated(self, offset, unit):
+ return replace(self, width=self.width + UnitExpression(2*offset, unit))
- def scale(self, scale):
- self.width *= UnitExpression(scale)
- self.height *= UnitExpression(scale)
- self.x *= UnitExpression(scale)
- self.y *= UnitExpression(scale)
+ def scaled(self, scale):
+ return replace(self,
+ width=self.width * UnitExpression(scale),
+ height=self.height * UnitExpression(scale),
+ x=self.x * UnitExpression(scale),
+ y=self.y * UnitExpression(scale))
+@dataclass(frozen=True, slots=True)
class Polygon(Primitive):
code = 5
- exposure : Expression
n_vertices : Expression
# center x/y
x : UnitExpression
y : UnitExpression
diameter : UnitExpression
- rotation : Expression
+ rotation : Expression = 0
def to_graphic_primitives(self, offset, rotation, variable_binding={}, unit=None, polarity_dark=True):
with self.Calculator(self, variable_binding, unit) as calc:
@@ -190,25 +187,26 @@ class Polygon(Primitive):
return [ gp.ArcPoly.from_regular_polygon(calc.x, calc.y, calc.diameter/2, calc.n_vertices, rotation,
polarity_dark=(bool(calc.exposure) == polarity_dark)) ]
- def dilate(self, offset, unit):
- self.diameter += UnitExpression(2*offset, unit)
+ def dilated(self, offset, unit):
+ return replace(self, diameter=self.diameter + UnitExpression(2*offset, unit))
def scale(self, scale):
- self.diameter *= UnitExpression(scale)
- self.x *= UnitExpression(scale)
- self.y *= UnitExpression(scale)
+ return replace(self,
+ diameter=self.diameter * UnitExpression(scale),
+ x=self.x * UnitExpression(scale),
+ y=self.y * UnitExpression(scale))
+@dataclass(frozen=True, slots=True)
class Thermal(Primitive):
code = 7
- exposure : Expression
# center x/y
x : UnitExpression
y : UnitExpression
d_outer : UnitExpression
d_inner : UnitExpression
gap_w : UnitExpression
- rotation : Expression
+ rotation : Expression = 0
def to_graphic_primitives(self, offset, rotation, variable_binding={}, unit=None, polarity_dark=True):
with self.Calculator(self, variable_binding, unit) as calc:
@@ -231,74 +229,86 @@ class Thermal(Primitive):
warnings.warn('Attempted dilation of macro aperture thermal primitive. This is not supported.')
def scale(self, scale):
- self.d_outer *= UnitExpression(scale)
- self.d_inner *= UnitExpression(scale)
- self.gap_w *= UnitExpression(scale)
- self.x *= UnitExpression(scale)
- self.y *= UnitExpression(scale)
+ return replace(self,
+ d_outer=self.d_outer * UnitExpression(scale),
+ d_inner=self.d_inner * UnitExpression(scale),
+ gap_w=self.gap_w * UnitExpression(scale),
+ x=self.x * UnitExpression(scale),
+ y=self.y * UnitExpression(scale))
+@dataclass(frozen=True, slots=True)
class Outline(Primitive):
code = 4
+ length: Expression
+ coords: tuple
+ rotation: Expression = 0
- def __init__(self, unit, args):
- if len(args) < 10:
- raise ValueError(f'Invalid aperture macro outline primitive, not enough parameters ({len(args)}).')
- if len(args) > 5004:
- raise ValueError(f'Invalid aperture macro outline primitive, too many points ({len(args)//2-2}).')
-
- self.exposure = expr(args.pop(0))
+ def __post_init__(self):
+ if self.length is None:
+ object.__setattr__(self, 'length', expr(len(self.coords)//2-1))
+ else:
+ object.__setattr__(self, 'length', expr(self.length))
+ object.__setattr__(self, 'rotation', expr(self.rotation))
+ object.__setattr__(self, 'exposure', expr(self.exposure))
- # length arg must not contain variables (that would not make sense)
- length_arg = (args.pop(0) * ConstantExpression(1)).calculate()
+ if self.length.calculate() != len(self.coords)//2-1:
+ raise ValueError('length must exactly equal number of segments, which is the number of points minus one')
- if length_arg != len(args)//2-1:
- raise ValueError(f'Invalid aperture macro outline primitive, given size {length_arg} does not match length of coordinate list({len(args)//2-1}).')
+ if self.coords[-2:] != self.coords[:2]:
+ raise ValueError('Last point must equal first point')
- if len(args) % 2 == 1:
- self.rotation = expr(args.pop())
- else:
- self.rotation = ConstantExpression(0.0)
+ object.__setattr__(self, 'coords', tuple(
+ UnitExpression(coord, self.unit) for coord in self.coords))
- if args[0] != args[-2] or args[1] != args[-1]:
- raise ValueError(f'Invalid aperture macro outline primitive, polygon is not closed {args[2:4], args[-3:-1]}')
+ @property
+ def points(self):
+ for x, y in zip(self.coords[0::2], self.coords[1::2]):
+ yield x, y
- self.coords = [(UnitExpression(x, unit), UnitExpression(y, unit)) for x, y in zip(args[0::2], args[1::2])]
+ @classmethod
+ def from_arglist(kls, arglist):
+ if len(arglist[3:]) % 2 == 0:
+ return kls(unit=arglist[0], exposure=arglist[1], length=arglist[2], coords=arglist[3:], rotation=0)
+ else:
+ return kls(unit=arglist[0], exposure=arglist[1], length=arglist[2], coords=arglist[3:-1], rotation=arglist[-1])
def __str__(self):
return f'<Outline {len(self.coords)} points>'
def to_gerber(self, unit=None):
- coords = ','.join(coord.to_gerber(unit) for xy in self.coords for coord in xy)
+ coords = ','.join(coord.to_gerber(unit) for coord in self.coords)
return f'{self.code},{self.exposure.to_gerber()},{len(self.coords)-1},{coords},{self.rotation.to_gerber()}'
def to_graphic_primitives(self, offset, rotation, variable_binding={}, unit=None, polarity_dark=True):
with self.Calculator(self, variable_binding, unit) as calc:
rotation += deg_to_rad(calc.rotation)
- bound_coords = [ rotate_point(calc(x), calc(y), -rotation, 0, 0) for x, y in self.coords ]
+ bound_coords = [ rotate_point(calc(x), calc(y), -rotation, 0, 0) for x, y in self.points ]
bound_coords = [ (x+offset[0], y+offset[1]) for x, y in bound_coords ]
bound_radii = [None] * len(bound_coords)
return [gp.ArcPoly(bound_coords, bound_radii, polarity_dark=(bool(calc.exposure) == polarity_dark))]
- def dilate(self, offset, unit):
+ def dilated(self, offset, unit):
# we would need a whole polygon offset/clipping library here
warnings.warn('Attempted dilation of macro aperture outline primitive. This is not supported.')
- def scale(self, scale):
- self.coords = [(x*UnitExpression(scale), y*UnitExpression(scale)) for x, y in self.coords]
+ def scaled(self, scale):
+ return replace(self, coords=tuple(x*scale for x in self.coords))
+@dataclass(frozen=True, slots=True)
class Comment:
code = 0
-
- def __init__(self, comment):
- self.comment = comment
+ comment: str
def to_gerber(self, unit=None):
return f'0 {self.comment}'
- def scale(self, scale):
- pass
+ def dilated(self, offset, unit):
+ return self
+
+ def scaled(self, scale):
+ return self
PRIMITIVE_CLASSES = {
diff --git a/gerbonara/apertures.py b/gerbonara/apertures.py
index 73a6e9c..512b4dd 100644
--- a/gerbonara/apertures.py
+++ b/gerbonara/apertures.py
@@ -17,20 +17,17 @@
#
import math
-from dataclasses import dataclass, replace, field, fields, InitVar
+from dataclasses import dataclass, replace, field, fields, InitVar, KW_ONLY
+from functools import lru_cache
from .aperture_macros.parse import GenericMacros
-from .utils import MM, Inch, sum_bounds
+from .utils import LengthUnit, MM, Inch, sum_bounds
from . import graphic_primitives as gp
def _flash_hole(self, x, y, unit=None, polarity_dark=True):
- if getattr(self, 'hole_rect_h', None) is not None:
- w, h = self.unit.convert_to(unit, self.hole_dia), self.unit.convert_to(unit, self.hole_rect_h)
- return [*self._primitives(x, y, unit, polarity_dark),
- gp.Rectangle(x, y, w, h, rotation=self.rotation, polarity_dark=(not polarity_dark))]
- elif self.hole_dia is not None:
+ if self.hole_dia is not None:
return [*self._primitives(x, y, unit, polarity_dark),
gp.Circle(x, y, self.unit.convert_to(unit, self.hole_dia/2), polarity_dark=(not polarity_dark))]
else:
@@ -40,7 +37,7 @@ def _strip_right(*args):
args = list(args)
while args and args[-1] is None:
args.pop()
- return args
+ return tuple(args)
def _none_close(a, b):
if a is None and b is None:
@@ -57,39 +54,14 @@ class Length:
def __init__(self, obj_type):
self.type = obj_type
-@dataclass
+@dataclass(frozen=True, slots=True)
class Aperture:
""" Base class for all apertures. """
-
- # hackety hack: Work around python < 3.10 not having dataclasses.KW_ONLY.
- #
- # For details, refer to graphic_objects.py
- def __init_subclass__(cls):
- #: :py:class:`gerbonara.utils.LengthUnit` used for all length fields of this aperture.
- cls.unit = None
- #: GerberX2 attributes of this aperture. Note that this will only contain aperture attributes, not file attributes.
- #: File attributes are stored in the :py:attr:`~.GerberFile.attrs` of the :py:class:`.GerberFile`.
- cls.attrs = field(default_factory=dict)
- #: Aperture index this aperture had when it was read from the Gerber file. This field is purely informational since
- #: apertures are de-duplicated and re-numbered when writing a Gerber file. For `D10`, this field would be `10`. When
- #: you programmatically create a new aperture, you do not have to set this.
- cls.original_number = None
-
- d = {'unit': str, 'attrs': dict, 'original_number': int}
- if hasattr(cls, '__annotations__'):
- cls.__annotations__.update(d)
- else:
- cls.__annotations__ = d
-
- @property
- def hole_shape(self):
- """ Get shape of hole based on :py:attr:`hole_dia` and :py:attr:`hole_rect_h`: "rect" or "circle" or None. """
- if getattr(self, 'hole_rect_h') is not None:
- return 'rect'
- elif getattr(self, 'hole_dia') is not None:
- return 'circle'
- else:
- return None
+ _ : KW_ONLY
+ unit: LengthUnit = None
+ attrs: tuple = None
+ original_number: int = None
+ _bounding_box: tuple = None
def _params(self, unit=None):
out = []
@@ -119,7 +91,10 @@ class Aperture:
return self._primitives(x, y, unit, polarity_dark)
def bounding_box(self, unit=None):
- return sum_bounds((prim.bounding_box() for prim in self.flash(0, 0, unit, True)))
+ if self._bounding_box is None:
+ object.__setattr__(self, '_bounding_box',
+ sum_bounds((prim.bounding_box() for prim in self.flash(0, 0, MM, True))))
+ return MM.convert_bounds_to(unit, self._bounding_box)
def equivalent_width(self, unit=None):
""" Get the width of a line interpolated using this aperture in the given :py:class:`~.LengthUnit`.
@@ -133,16 +108,12 @@ class Aperture:
:rtype: str
"""
- # Hack: The standard aperture shapes C, R, O do not have a rotation parameter. To make this API easier to use,
- # we emulate this parameter. Our circle, rectangle and oblong classes below have a rotation parameter. Only at
- # export time during to_gerber, this parameter is evaluated.
unit = settings.unit if settings else None
- actual_inst = self.rotated()
- params = 'X'.join(f'{float(par):.4}' for par in actual_inst._params(unit) if par is not None)
+ params = 'X'.join(f'{float(par):.4}' for par in self._params(unit) if par is not None)
if params:
- return f'{actual_inst._gerber_shape_code},{params}'
+ return f'{self._gerber_shape_code},{params}'
else:
- return actual_inst._gerber_shape_code
+ return self._gerber_shape_code
def to_macro(self):
""" Convert this :py:class:`.Aperture` into an :py:class:`.ApertureMacro` inside an
@@ -150,24 +121,10 @@ class Aperture:
"""
raise NotImplementedError()
- def __eq__(self, other):
- """ Compare two apertures. Apertures are compared based on their Gerber representation. Two apertures are
- considered equal if their Gerber aperture definitions are identical.
- """
- # We need to choose some unit here.
- return hasattr(other, 'to_gerber') and self.to_gerber(MM) == other.to_gerber(MM)
-
- def _rotate_hole_90(self):
- if self.hole_rect_h is None:
- return {'hole_dia': self.hole_dia, 'hole_rect_h': None}
- else:
- return {'hole_dia': self.hole_rect_h, 'hole_rect_h': self.hole_dia}
-
-@dataclass(unsafe_hash=True)
+@dataclass(frozen=True, slots=True)
class ExcellonTool(Aperture):
""" Special Aperture_ subclass for use in :py:class:`.ExcellonFile`. Similar to :py:class:`.CircleAperture`, but
- does not have :py:attr:`.CircleAperture.hole_dia` or :py:attr:`.CircleAperture.hole_rect_h`, and has the additional
- :py:attr:`plated` attribute.
+ does not have :py:attr:`.CircleAperture.hole_dia`, and has the additional :py:attr:`plated` attribute.
"""
_gerber_shape_code = 'C'
_human_readable_shape = 'drill'
@@ -183,18 +140,6 @@ class ExcellonTool(Aperture):
def to_xnc(self, settings):
return 'C' + settings.write_excellon_value(self.diameter, self.unit)
- def __eq__(self, other):
- """ Compare two :py:class:`.ExcellonTool` instances. They are considered equal if their diameter and plating
- match.
- """
- if not isinstance(other, ExcellonTool):
- return False
-
- if not self.plated == other.plated:
- return False
-
- return _none_close(self.diameter, self.unit(other.diameter, other.unit))
-
def __str__(self):
plated = '' if self.plated is None else (' plated' if self.plated else ' non-plated')
return f'<Excellon Tool d={self.diameter:.3f}{plated} [{self.unit}]>'
@@ -207,17 +152,18 @@ class ExcellonTool(Aperture):
offset = unit(offset, self.unit)
return replace(self, diameter=self.diameter+2*offset)
+ @lru_cache()
def rotated(self, angle=0):
return self
- def to_macro(self):
+ def to_macro(self, rotation=0):
return ApertureMacroInstance(GenericMacros.circle, self._params(unit=MM))
def _params(self, unit=None):
- return [self.unit.convert_to(unit, self.diameter)]
+ return (self.unit.convert_to(unit, self.diameter),)
-@dataclass
+@dataclass(frozen=True, slots=True)
class CircleAperture(Aperture):
""" Besides flashing circles or rings, CircleApertures are used to set the width of a
:py:class:`~.graphic_objects.Line` or :py:class:`~.graphic_objects.Arc`.
@@ -228,10 +174,6 @@ class CircleAperture(Aperture):
diameter : Length(float)
#: float with the hole diameter of this aperture in :py:attr:`unit` units. ``0`` for no hole.
hole_dia : Length(float) = None
- #: float or None. If not None, specifies a rectangular hole of size `hole_dia * hole_rect_h` instead of a round hole.
- hole_rect_h : Length(float) = None
- # float with radians. This is only used for rectangular holes (as circles are rotationally symmetric).
- rotation : float = 0
def _primitives(self, x, y, unit=None, polarity_dark=True):
return [ gp.Circle(x, y, self.unit.convert_to(unit, self.diameter/2), polarity_dark=polarity_dark) ]
@@ -246,31 +188,27 @@ class CircleAperture(Aperture):
def dilated(self, offset, unit=MM):
offset = self.unit(offset, unit)
- return replace(self, diameter=self.diameter+2*offset, hole_dia=None, hole_rect_h=None)
+ return replace(self, diameter=self.diameter+2*offset, hole_dia=None)
+ @lru_cache()
def rotated(self, angle=0):
- if math.isclose((self.rotation+angle) % (2*math.pi), 0, abs_tol=1e-6) or self.hole_rect_h is None:
- return self
- else:
- return self.to_macro(self.rotation+angle)
+ return self
def scaled(self, scale):
return replace(self,
diameter=self.diameter*scale,
- hole_dia=None if self.hole_dia is None else self.hole_dia*scale,
- hole_rect_h=None if self.hole_rect_h is None else self.hole_rect_h*scale)
+ hole_dia=None if self.hole_dia is None else self.hole_dia*scale)
- def to_macro(self):
+ def to_macro(self, rotation=0):
return ApertureMacroInstance(GenericMacros.circle, self._params(unit=MM))
def _params(self, unit=None):
return _strip_right(
self.unit.convert_to(unit, self.diameter),
- self.unit.convert_to(unit, self.hole_dia),
- self.unit.convert_to(unit, self.hole_rect_h))
+ self.unit.convert_to(unit, self.hole_dia))
-@dataclass
+@dataclass(frozen=True, slots=True)
class RectangleAperture(Aperture):
""" Gerber rectangle aperture. Can only be used for flashes, since the line width of an interpolation of a rectangle
aperture is not well-defined and there is no tool that implements it in a geometrically correct way. """
@@ -282,14 +220,10 @@ class RectangleAperture(Aperture):
h : Length(float)
#: float with the hole diameter of this aperture in :py:attr:`unit` units. ``0`` for no hole.
hole_dia : Length(float) = None
- #: float or None. If not None, specifies a rectangular hole of size `hole_dia * hole_rect_h` instead of a round hole.
- hole_rect_h : Length(float) = None
- # Rotation in radians. This rotates both the aperture and the rectangular hole if it has one.
- rotation : float = 0 # radians
def _primitives(self, x, y, unit=None, polarity_dark=True):
return [ gp.Rectangle(x, y, self.unit.convert_to(unit, self.w), self.unit.convert_to(unit, self.h),
- rotation=self.rotation, polarity_dark=polarity_dark) ]
+ rotation=0, polarity_dark=polarity_dark) ]
def __str__(self):
return f'<rect aperture {self.w:.3}x{self.h:.3} [{self.unit}]>'
@@ -301,42 +235,39 @@ class RectangleAperture(Aperture):
def dilated(self, offset, unit=MM):
offset = self.unit(offset, unit)
- return replace(self, w=self.w+2*offset, h=self.h+2*offset, hole_dia=None, hole_rect_h=None)
+ return replace(self, w=self.w+2*offset, h=self.h+2*offset, hole_dia=None)
+ @lru_cache()
def rotated(self, angle=0):
- self.rotation += angle
- if math.isclose(self.rotation % math.pi, 0):
- self.rotation = 0
+ if math.isclose(angle % math.pi, 0):
return self
- elif math.isclose(self.rotation % math.pi, math.pi/2):
- return replace(self, w=self.h, h=self.w, **self._rotate_hole_90(), rotation=0)
+ elif math.isclose(angle % math.pi, math.pi/2):
+ return replace(self, w=self.h, h=self.w, hole_dia=self.hole_dia)
else: # odd angle
- return self.to_macro()
+ return self.to_macro(angle)
def scaled(self, scale):
return replace(self,
w=self.w*scale,
h=self.h*scale,
- hole_dia=None if self.hole_dia is None else self.hole_dia*scale,
- hole_rect_h=None if self.hole_rect_h is None else self.hole_rect_h*scale)
+ hole_dia=None if self.hole_dia is None else self.hole_dia*scale)
def to_macro(self, rotation=0):
return ApertureMacroInstance(GenericMacros.rect,
[MM(self.w, self.unit),
MM(self.h, self.unit),
MM(self.hole_dia, self.unit) or 0,
- MM(self.hole_rect_h, self.unit) or 0,
- self.rotation + rotation])
+ 0,
+ rotation])
def _params(self, unit=None):
return _strip_right(
self.unit.convert_to(unit, self.w),
self.unit.convert_to(unit, self.h),
- self.unit.convert_to(unit, self.hole_dia),
- self.unit.convert_to(unit, self.hole_rect_h))
+ self.unit.convert_to(unit, self.hole_dia))
-@dataclass
+@dataclass(frozen=True, slots=True)
class ObroundAperture(Aperture):
""" Aperture whose shape is the convex hull of two circles of equal radii.
@@ -352,14 +283,10 @@ class ObroundAperture(Aperture):
h : Length(float)
#: float with the hole diameter of this aperture in :py:attr:`unit` units. ``0`` for no hole.
hole_dia : Length(float) = None
- #: float or None. If not None, specifies a rectangular hole of size `hole_dia * hole_rect_h` instead of a round hole.
- hole_rect_h : Length(float) = None
- #: Rotation in radians. This rotates both the aperture and the rectangular hole if it has one.
- rotation : float = 0
def _primitives(self, x, y, unit=None, polarity_dark=True):
return [ gp.Line.from_obround(x, y, self.unit.convert_to(unit, self.w), self.unit.convert_to(unit, self.h),
- rotation=self.rotation, polarity_dark=polarity_dark) ]
+ polarity_dark=polarity_dark) ]
def __str__(self):
return f'<obround aperture {self.w:.3}x{self.h:.3} [{self.unit}]>'
@@ -368,13 +295,14 @@ class ObroundAperture(Aperture):
def dilated(self, offset, unit=MM):
offset = self.unit(offset, unit)
- return replace(self, w=self.w+2*offset, h=self.h+2*offset, hole_dia=None, hole_rect_h=None)
+ return replace(self, w=self.w+2*offset, h=self.h+2*offset, hole_dia=None)
+ @lru_cache()
def rotated(self, angle=0):
- if math.isclose((angle + self.rotation) % math.pi, 0, abs_tol=1e-6):
+ if math.isclose(angle % math.pi, 0, abs_tol=1e-6):
return self
- elif math.isclose((angle + self.rotation) % math.pi, math.pi/2, abs_tol=1e-6):
- return replace(self, w=self.h, h=self.w, **self._rotate_hole_90(), rotation=0)
+ elif math.isclose(angle % math.pi, math.pi/2, abs_tol=1e-6):
+ return replace(self, w=self.h, h=self.w, hole_dia=self.hole_dia)
else:
return self.to_macro(angle)
@@ -382,32 +310,31 @@ class ObroundAperture(Aperture):
return replace(self,
w=self.w*scale,
h=self.h*scale,
- hole_dia=None if self.hole_dia is None else self.hole_dia*scale,
- hole_rect_h=None if self.hole_rect_h is None else self.hole_rect_h*scale)
+ hole_dia=None if self.hole_dia is None else self.hole_dia*scale)
def to_macro(self, rotation=0):
# generic macro only supports w > h so flip x/y if h > w
if self.w > self.h:
inst = self
else:
- inst = replace(self, w=self.h, h=self.w, **self._rotate_hole_90(), rotation=self.rotation-math.pi/2)
+ rotation -= -math.pi/2
+ inst = replace(self, w=self.h, h=self.w, hole_dia=self.hole_dia)
return ApertureMacroInstance(GenericMacros.obround,
[MM(inst.w, self.unit),
MM(inst.h, self.unit),
MM(inst.hole_dia, self.unit) or 0,
- MM(inst.hole_rect_h, self.unit) or 0,
+ 0,
inst.rotation + rotation])
def _params(self, unit=None):
return _strip_right(
self.unit.convert_to(unit, self.w),
self.unit.convert_to(unit, self.h),
- self.unit.convert_to(unit, self.hole_dia),
- self.unit.convert_to(unit, self.hole_rect_h))
+ self.unit.convert_to(unit, self.hole_dia))
-@dataclass
+@dataclass(frozen=True, slots=True)
class PolygonAperture(Aperture):
""" Aperture whose shape is a regular n-sided polygon (e.g. pentagon, hexagon etc.). Note that this only supports
round holes.
@@ -439,6 +366,7 @@ class PolygonAperture(Aperture):
flash = _flash_hole
+ @lru_cache()
def rotated(self, angle=0):
if angle != 0:
return replace(self, rotatio=self.rotation + angle)
@@ -465,7 +393,7 @@ class PolygonAperture(Aperture):
else:
return self.unit.convert_to(unit, self.diameter), self.n_vertices
-@dataclass
+@dataclass(frozen=True, slots=True)
class ApertureMacroInstance(Aperture):
""" One instance of an aperture macro. An aperture macro defined with an ``AM`` statement can be instantiated by
multiple ``AD`` aperture definition statements using different parameters. An :py:class:`.ApertureMacroInstance` is
@@ -477,10 +405,7 @@ class ApertureMacroInstance(Aperture):
macro : object
#: The parameters to the :py:class:`.ApertureMacro`. All elements should be floats or ints. The first item in the
#: list is parameter ``$1``, the second is ``$2`` etc.
- parameters : list = field(default_factory=list)
- #: Aperture rotation in radians. When saving, a copy of the :py:class:`.ApertureMacro` is re-written with this
- #: rotation.
- rotation : float = 0
+ parameters : tuple = ()
@property
def _gerber_shape_code(self):
@@ -488,30 +413,26 @@ class ApertureMacroInstance(Aperture):
def _primitives(self, x, y, unit=None, polarity_dark=True):
out = list(self.macro.to_graphic_primitives(
- offset=(x, y), rotation=self.rotation,
+ offset=(x, y), rotation=0,
parameters=self.parameters, unit=unit, polarity_dark=polarity_dark))
return out
def dilated(self, offset, unit=MM):
return replace(self, macro=self.macro.dilated(offset, unit))
+ @lru_cache()
def rotated(self, angle=0):
- if math.isclose((self.rotation+angle) % (2*math.pi), 0):
+ if math.isclose(angle % (2*math.pi), 0):
return self
else:
return self.to_macro(angle)
def to_macro(self, rotation=0):
- return replace(self, macro=self.macro.rotated(self.rotation+rotation), rotation=0)
+ return replace(self, macro=self.macro.rotated(rotation))
def scaled(self, scale):
return replace(self, macro=self.macro.scaled(scale))
- def __eq__(self, other):
- return hasattr(other, 'macro') and self.macro == other.macro and \
- hasattr(other, 'parameters') and self.parameters == other.parameters and \
- hasattr(other, 'rotation') and self.rotation == other.rotation
-
def _params(self, unit=None):
# We ignore "unit" here as we convert the actual macro, not this instantiation.
# We do this because here we do not have information about which parameter has which physical units.
diff --git a/gerbonara/cad/kicad/footprints.py b/gerbonara/cad/kicad/footprints.py
index 428d5ea..d7ccc9f 100644
--- a/gerbonara/cad/kicad/footprints.py
+++ b/gerbonara/cad/kicad/footprints.py
@@ -55,7 +55,7 @@ class Text:
effects: TextEffect = field(default_factory=TextEffect)
tstamp: Timestamp = None
- def render(self, variables={}):
+ def render(self, variables={}, cache=None):
if self.hide: # why
return
@@ -76,7 +76,7 @@ class TextBox:
stroke: Stroke = field(default_factory=Stroke)
render_cache: RenderCache = None
- def render(self, variables={}):
+ def render(self, variables={}, cache=None):
yield from gr.TextBox.render(self, variables=variables)
@@ -90,7 +90,7 @@ class Line:
locked: Flag() = False
tstamp: Timestamp = None
- def render(self, variables=None):
+ def render(self, variables=None, cache=None):
dasher = Dasher(self)
dasher.move(self.start.x, self.start.y)
dasher.line(self.end.x, self.end.y)
@@ -110,7 +110,7 @@ class Rectangle:
locked: Flag() = False
tstamp: Timestamp = None
- def render(self, variables=None):
+ def render(self, variables=None, cache=None):
x1, y1 = self.start.x, self.start.y
x2, y2 = self.end.x, self.end.y
x1, x2 = min(x1, x2), max(x1, x2)
@@ -143,7 +143,7 @@ class Circle:
locked: Flag() = False
tstamp: Timestamp = None
- def render(self, variables=None):
+ def render(self, variables=None, cache=None):
x, y = self.center.x, self.center.y
r = math.dist((x, y), (self.end.x, self.end.y)) # insane
@@ -178,7 +178,7 @@ class Arc:
tstamp: Timestamp = None
- def render(self, variables=None):
+ def render(self, variables=None, cache=None):
mx, my = self.mid.x, self.mid.y
x1, y1 = self.start.x, self.start.y
x2, y2 = self.end.x, self.end.y
@@ -230,7 +230,7 @@ class Polygon:
locked: Flag() = False
tstamp: Timestamp = None
- def render(self, variables=None):
+ def render(self, variables=None, cache=None):
if len(self.pts.xy) < 2:
return
@@ -257,7 +257,7 @@ class Curve:
locked: Flag() = False
tstamp: Timestamp = None
- def render(self, variables=None):
+ def render(self, variables=None, cache=None):
raise NotImplementedError('Bezier rendering is not yet supported. Please raise an issue and provide an example file.')
@@ -297,7 +297,7 @@ class Dimension:
format: DimensionFormat = field(default_factory=DimensionFormat)
style: DimensionStyle = field(default_factory=DimensionStyle)
- def render(self, variables=None):
+ def render(self, variables=None, cache=None):
raise NotImplementedError()
@@ -383,7 +383,7 @@ class Pad:
options: OmitDefault(CustomPadOptions) = None
primitives: OmitDefault(CustomPadPrimitives) = None
- def render(self, variables=None, margin=None):
+ def render(self, variables=None, margin=None, cache=None):
#if self.type in (Atom.connect, Atom.np_thru_hole):
# return
if self.drill and self.drill.offset:
@@ -391,7 +391,17 @@ class Pad:
else:
ox, oy = 0, 0
- yield go.Flash(self.at.x+ox, self.at.y+oy, self.aperture(margin), unit=MM)
+ cache_key = id(self), margin
+ if cache and cache_key in cache:
+ aperture = cache[cache_key]
+
+ elif cache is not None:
+ aperture = cache[cache_key] = self.aperture(margin)
+
+ else:
+ aperture = self.aperture(margin)
+
+ yield go.Flash(self.at.x+ox, self.at.y+oy, aperture, unit=MM)
def aperture(self, margin=None):
rotation = -math.radians(self.at.rotation)
@@ -403,10 +413,10 @@ class Pad:
elif self.shape == Atom.rect:
if margin > 0:
return ap.ApertureMacroInstance(GenericMacros.rounded_rect,
- [self.size.x+2*margin, self.size.y+2*margin,
+ (self.size.x+2*margin, self.size.y+2*margin,
margin,
0, 0, # no hole
- rotation], unit=MM)
+ rotation), unit=MM)
else:
return ap.RectangleAperture(self.size.x+2*margin, self.size.y+2*margin, unit=MM).rotated(rotation)
@@ -434,27 +444,27 @@ class Pad:
alpha = math.atan(y / dy) if dy > 0 else 0
return ap.ApertureMacroInstance(GenericMacros.isosceles_trapezoid,
- [x+dy+2*margin*math.cos(alpha), y+2*margin,
+ (x+dy+2*margin*math.cos(alpha), y+2*margin,
2*dy,
0, 0, # no hole
- rotation], unit=MM)
+ rotation), unit=MM)
else:
return ap.ApertureMacroInstance(GenericMacros.rounded_isosceles_trapezoid,
- [x+dy, y,
+ (x+dy, y,
2*dy, margin,
0, 0, # no hole
- rotation], unit=MM)
+ rotation), unit=MM)
elif self.shape == Atom.roundrect:
x, y = self.size.x, self.size.y
r = min(x, y) * self.roundrect_rratio
if margin > -r:
return ap.ApertureMacroInstance(GenericMacros.rounded_rect,
- [x+2*margin, y+2*margin,
+ (x+2*margin, y+2*margin,
r+margin,
0, 0, # no hole
- rotation], unit=MM)
+ rotation), unit=MM)
else:
return ap.RectangleAperture(x+margin, y+margin, unit=MM).rotated(rotation)
@@ -485,20 +495,20 @@ class Pad:
if self.options:
if self.options.anchor == Atom.rect and self.size.x > 0 and self.size.y > 0:
if margin <= 0:
- primitives.append(amp.CenterLine(MM, [1, self.size.x+2*margin, self.size.y+2*margin, 0, 0, 0]))
+ primitives.append(amp.CenterLine(MM, 1, self.size.x+2*margin, self.size.y+2*margin, 0, 0, 0))
else: # margin > 0
- primitives.append(amp.CenterLine(MM, [1, self.size.x+2*margin, self.size.y, 0, 0, 0]))
- primitives.append(amp.CenterLine(MM, [1, self.size.x, self.size.y+2*margin, 0, 0, 0]))
- primitives.append(amp.Circle(MM, [1, 2*margin, -self.size.x/2, -self.size.y/2]))
- primitives.append(amp.Circle(MM, [1, 2*margin, -self.size.x/2, +self.size.y/2]))
- primitives.append(amp.Circle(MM, [1, 2*margin, +self.size.x/2, -self.size.y/2]))
- primitives.append(amp.Circle(MM, [1, 2*margin, +self.size.x/2, +self.size.y/2]))
+ primitives.append(amp.CenterLine(MM, 1, self.size.x+2*margin, self.size.y, 0, 0, 0))
+ primitives.append(amp.CenterLine(MM, 1, self.size.x, self.size.y+2*margin, 0, 0, 0))
+ primitives.append(amp.Circle(MM, 1, 2*margin, -self.size.x/2, -self.size.y/2))
+ primitives.append(amp.Circle(MM, 1, 2*margin, -self.size.x/2, +self.size.y/2))
+ primitives.append(amp.Circle(MM, 1, 2*margin, +self.size.x/2, -self.size.y/2))
+ primitives.append(amp.Circle(MM, 1, 2*margin, +self.size.x/2, +self.size.y/2))
elif self.options.anchor == Atom.circle and self.size.x > 0:
- primitives.append(amp.Circle(MM, [1, self.size.x+2*margin, 0, 0, 0]))
+ primitives.append(amp.Circle(MM, 1, self.size.x+2*margin, 0, 0, 0))
- macro = ApertureMacro(primitives=primitives).rotated(rotation)
+ macro = ApertureMacro(primitives=tuple(primitives)).rotated(rotation)
return ap.ApertureMacroInstance(macro, unit=MM)
def render_drill(self):
@@ -645,7 +655,7 @@ class Footprint:
(self.dimensions if text else []),
(self.pads if pads else []))
- def render(self, layer_stack, layer_map, x=0, y=0, rotation=0, text=False, side=None, variables={}):
+ def render(self, layer_stack, layer_map, x=0, y=0, rotation=0, text=False, side=None, variables={}, cache=None):
x += self.at.x
y += self.at.y
rotation += math.radians(self.at.rotation)
@@ -687,7 +697,7 @@ class Footprint:
else:
margin = None
- for fe in obj.render(margin=margin):
+ for fe in obj.render(margin=margin, cache=cache):
fe.rotate(rotation)
fe.offset(x, y, MM)
if isinstance(fe, go.Flash) and fe.aperture:
@@ -745,7 +755,7 @@ class FootprintInstance(Positioned):
value: str = None
variables: dict = field(default_factory=lambda: {})
- def render(self, layer_stack):
+ def render(self, layer_stack, cache=None):
x, y, rotation = self.abs_pos
x, y = MM(x, self.unit), MM(y, self.unit)
@@ -763,7 +773,7 @@ class FootprintInstance(Positioned):
x=x, y=y, rotation=rotation,
side=self.side,
text=(not self.hide_text),
- variables=variables)
+ variables=variables, cache=cache)
def bounding_box(self, unit=MM):
return offset_bounds(self.sexp.bounding_box(unit), unit(self.x, self.unit), unit(self.y, self.unit))
diff --git a/gerbonara/cad/primitives.py b/gerbonara/cad/primitives.py
index ce69bae..28347b5 100644
--- a/gerbonara/cad/primitives.py
+++ b/gerbonara/cad/primitives.py
@@ -117,8 +117,9 @@ class Board:
if layer_stack is None:
layer_stack = LayerStack()
+ cache = {}
for obj in chain(self.objects):
- obj.render(layer_stack)
+ obj.render(layer_stack, cache)
layer_stack['mechanical', 'outline'].objects.extend(self.outline)
layer_stack['top', 'silk'].objects.extend(self.extra_silk_top)
@@ -189,13 +190,13 @@ class ObjectGroup(Positioned):
drill_pth: list = field(default_factory=list)
objects: list = field(default_factory=list)
- def render(self, layer_stack):
+ def render(self, layer_stack, cache=None):
x, y, rotation = self.abs_pos
top, bottom = ('bottom', 'top') if self.side == 'bottom' else ('top', 'bottom')
for obj in self.objects:
obj.parent = self
- obj.render(layer_stack)
+ obj.render(layer_stack, cache=cache)
for target, source in [
(layer_stack[top, 'copper'], self.top_copper),
@@ -251,7 +252,7 @@ class Text(Positioned):
layer: str = 'silk'
polarity_dark: bool = True
- def render(self, layer_stack):
+ def render(self, layer_stack, cache=None):
obj_x, obj_y, rotation = self.abs_pos
global newstroke_font
@@ -299,6 +300,26 @@ class Text(Positioned):
obj.offset(obj_x, obj_y)
layer_stack[self.side, self.layer].objects.append(obj)
+ def bounding_box(self, unit=MM):
+ approx_w = len(self.text)*self.font_size*0.75 + self.stroke_width
+ approx_h = self.font_size + self.stroke_width
+
+ if self.h_align == 'left':
+ x0 = 0
+ elif self.h_align == 'center':
+ x0 = -approx_w/2
+ elif self.h_align == 'right':
+ x0 = -approx_w
+
+ if self.v_align == 'top':
+ y0 = -approx_h
+ elif self.v_align == 'middle':
+ y0 = -approx_h/2
+ elif self.v_align == 'bottom':
+ y0 = 0
+
+ return (self.x+x0, self.y+y0), (self.x+x0+approx_w, self.y+y0+approx_h)
+
@dataclass
class Pad(Positioned):
@@ -312,7 +333,7 @@ class SMDPad(Pad):
paste_aperture: Aperture
silk_features: list = field(default_factory=list)
- def render(self, layer_stack):
+ def render(self, layer_stack, cache=None):
x, y, rotation = self.abs_pos
layer_stack[self.side, 'copper'].objects.append(Flash(x, y, self.copper_aperture.rotated(rotation), unit=self.unit))
layer_stack[self.side, 'mask' ].objects.append(Flash(x, y, self.mask_aperture.rotated(rotation), unit=self.unit))
@@ -356,7 +377,7 @@ class THTPad(Pad):
if (self.pad_top.side, self.pad_bottom.side) != ('top', 'bottom'):
raise ValueError(f'The top and bottom pads must have side set to top and bottom, respectively. Currently, the top pad side is set to "{self.pad_top.side}" and the bottom pad side to "{self.pad_bottom.side}".')
- def render(self, layer_stack):
+ def render(self, layer_stack, cache=None):
x, y, rotation = self.abs_pos
self.pad_top.parent = self
self.pad_top.render(layer_stack)
@@ -415,7 +436,7 @@ class Hole(Positioned):
diameter: float
mask_copper_margin: float = 0.2
- def render(self, layer_stack):
+ def render(self, layer_stack, cache=None):
x, y, rotation = self.abs_pos
hole = Flash(x, y, ExcellonTool(self.diameter, plated=False, unit=self.unit), unit=self.unit)
@@ -436,7 +457,7 @@ class Via(Positioned):
diameter: float
hole: float
- def render(self, layer_stack):
+ def render(self, layer_stack, cache=None):
x, y, rotation = self.abs_pos
aperture = CircleAperture(diameter=self.diameter, unit=self.unit)
@@ -627,7 +648,7 @@ class Trace:
return self._round_over(points, aperture)
- def render(self, layer_stack):
+ def render(self, layer_stack, cache=None):
layer_stack[self.side, 'copper'].objects.extend(self._to_graphic_objects())
def _route_demo():
diff --git a/gerbonara/graphic_objects.py b/gerbonara/graphic_objects.py
index bc205db..80590a7 100644
--- a/gerbonara/graphic_objects.py
+++ b/gerbonara/graphic_objects.py
@@ -373,7 +373,7 @@ class Region(GraphicObject):
if points[-1] != points[0]:
points.append(points[0])
- yield amp.Outline(self.unit, [int(self.polarity_dark), len(points)-1, *(coord for p in points for coord in p)])
+ yield amp.Outline(self.unit, int(self.polarity_dark), len(points)-1, tuple(coord for p in points for coord in p))
def to_primitives(self, unit=None):
if unit == self.unit:
@@ -503,9 +503,9 @@ class Line(GraphicObject):
def _aperture_macro_primitives(self):
obj = self.converted(MM) # Gerbonara aperture macros use MM units.
width = obj.aperture.equivalent_width(MM)
- yield amp.VectorLine(MM, [int(self.polarity_dark), width, obj.x1, obj.y1, obj.x2, obj.y2, 0])
- yield amp.Circle(MM, [int(self.polarity_dark), width, obj.x1, obj.y1])
- yield amp.Circle(MM, [int(self.polarity_dark), width, obj.x2, obj.y2])
+ yield amp.VectorLine(MM, int(self.polarity_dark), width, obj.x1, obj.y1, obj.x2, obj.y2, 0)
+ yield amp.Circle(MM, int(self.polarity_dark), width, obj.x1, obj.y1)
+ yield amp.Circle(MM, int(self.polarity_dark), width, obj.x2, obj.y2)
def to_statements(self, gs):
yield from gs.set_polarity(self.polarity_dark)
diff --git a/gerbonara/utils.py b/gerbonara/utils.py
index c1868af..12ac787 100644
--- a/gerbonara/utils.py
+++ b/gerbonara/utils.py
@@ -25,6 +25,7 @@ gerber.utils
This module provides utility functions for working with Gerber and Excellon files.
"""
+from dataclasses import dataclass
import os
import re
import textwrap
@@ -57,6 +58,7 @@ class RegexMatcher:
return False
+@dataclass(frozen=True, slots=True)
class LengthUnit:
""" Convenience length unit class. Used in :py:class:`.GraphicObject` and :py:class:`.Aperture` to store lenght
information. Provides a number of useful unit conversion functions.
@@ -64,13 +66,9 @@ class LengthUnit:
Singleton, use only global instances ``utils.MM`` and ``utils.Inch``.
"""
- def __init__(self, name, shorthand, this_in_mm):
- self.name = name
- self.shorthand = shorthand
- self.factor = this_in_mm
-
- def __hash__(self):
- return hash((self.name, self.shorthand, self.factor))
+ name: str
+ shorthand: str
+ this_in_mm: float
def convert_from(self, unit, value):
""" Convert ``value`` from ``unit`` into this unit.
@@ -112,6 +110,19 @@ class LengthUnit:
max_y = self.convert_from(unit, max_y)
return (min_x, min_y), (max_x, max_y)
+ def convert_bounds_to(self, unit, value):
+ """ :py:meth:`.LengthUnit.convert_to` but for ((min_x, min_y), (max_x, max_y)) bounding box tuples. """
+
+ if value is None:
+ return None
+
+ (min_x, min_y), (max_x, max_y) = value
+ min_x = self.convert_to(unit, min_x)
+ min_y = self.convert_to(unit, min_y)
+ max_x = self.convert_to(unit, max_x)
+ max_y = self.convert_to(unit, max_y)
+ return (min_x, min_y), (max_x, max_y)
+
def format(self, value):
""" Return a human-readdable string representing value in this unit.
generated by cgit (git 2.34.1) at 2024-11-27 06:48:10 +0000