summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--docs/index.rst3
-rw-r--r--gerbonara/cad/kicad/symbols.py2
-rw-r--r--gerbonara/graphic_objects.py156
-rw-r--r--gerbonara/graphic_primitives.py102
-rw-r--r--gerbonara/tests/test_kicad_footprints.py2
-rw-r--r--gerbonara/utils.py67
6 files changed, 213 insertions, 119 deletions
diff --git a/docs/index.rst b/docs/index.rst
index 45dbc1b..71d91ec 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -48,6 +48,7 @@ Features
cli
api-concepts
+ examples
file-api
object-api
apertures
@@ -74,6 +75,8 @@ Then, you are ready to read and write gerber files:
w, h = stack.outline.size('mm')
print(f'Board size is {w:.1f} mm x {h:.1f} mm')
+You can find some more elaborate examples in this doc's :ref:`Examples section<examples-doc>`.
+
Command-Line Interface
======================
diff --git a/gerbonara/cad/kicad/symbols.py b/gerbonara/cad/kicad/symbols.py
index 45f8ec0..972dd55 100644
--- a/gerbonara/cad/kicad/symbols.py
+++ b/gerbonara/cad/kicad/symbols.py
@@ -285,7 +285,7 @@ class Arc:
x2, y2 = self.mid.x-x1, self.mid.y-x2
x3, y3 = (self.end.x - x1)/2, (self.end.y - y1)/2
clockwise = math.atan2(x2*y3-x3*y2, x2*x3+y2*y3) > 0
- return arc_bounds(x1, y1, self.end.x, self.end.y, cx-x1, cy-y1, clockwise)
+ return arc_bounds(x1, y1, self.end.x, self.end.y, cx, cy, clockwise)
def to_svg(self, colorscheme=Colorscheme.KiCad):
diff --git a/gerbonara/graphic_objects.py b/gerbonara/graphic_objects.py
index 2b9dc3e..14cfc66 100644
--- a/gerbonara/graphic_objects.py
+++ b/gerbonara/graphic_objects.py
@@ -19,9 +19,9 @@
import math
import copy
from dataclasses import dataclass, astuple, field, fields
-from itertools import zip_longest
+from itertools import zip_longest, pairwise, islice, cycle
-from .utils import MM, InterpMode, to_unit, rotate_point, sum_bounds
+from .utils import MM, InterpMode, to_unit, rotate_point, sum_bounds, approximate_arc, sweep_angle
from . import graphic_primitives as gp
from .aperture_macros import primitive as amp
@@ -278,9 +278,15 @@ class Region(GraphicObject):
* A region is always exactly one connected component.
* A region must not overlap itself anywhere.
* A region cannot have holes.
+ * The last outline point of the region must be equal to the first.
There is one exception from the last two rules: To emulate a region with a hole in it, *cut-ins* are allowed. At a
cut-in, the region is allowed to touch (but never overlap!) itself.
+
+ When ``arc_centers`` is empty, this region has only straight outline segments. When ``arc_centers`` is not empty,
+ the i-th entry defines the i-th outline segment, with a ``None`` entry designating a straight line segment.
+ An arc is defined by a ``(clockwise, (cx, cy))`` tuple, where ``clockwise`` can be ``True`` for a clockwise arc, or
+ ``False`` for a counter-clockwise arc. ``cx`` and ``cy`` are the absolute coordinates of the arc's center.
"""
def __init__(self, outline=None, arc_centers=None, *, unit=MM, polarity_dark=True):
@@ -304,8 +310,8 @@ class Region(GraphicObject):
def _rotate(self, angle, cx=0, cy=0):
self.outline = [ gp.rotate_point(x, y, angle, cx, cy) for x, y in self.outline ]
self.arc_centers = [
- (arc[0], gp.rotate_point(*arc[1], angle, cx-p[0], cy-p[1])) if arc else None
- for p, arc in zip_longest(self.outline, self.arc_centers) ]
+ (arc[0], gp.rotate_point(*arc[1], angle, cx, cy)) if arc else None
+ for arc in self.arc_centers ]
def _scale(self, factor):
self.outline = [ (x*factor, y*factor) for x, y in self.outline ]
@@ -322,6 +328,10 @@ class Region(GraphicObject):
(x, y+h),
], unit=unit)
+ @classmethod
+ def from_arc_poly(kls, arc_poly, polarity_dark=True, unit=MM):
+ return kls(arc_poly.outline, arc_poly.arc_centers, polarity_dark=polarity_dark, unit=unit)
+
def append(self, obj):
if obj.unit != self.unit:
obj = obj.converted(self.unit)
@@ -331,48 +341,49 @@ class Region(GraphicObject):
self.outline.append(obj.p2)
if isinstance(obj, Arc):
- self.arc_centers.append((obj.clockwise, obj.center_relative))
+ self.arc_centers.append((obj.clockwise, obj.center))
else:
self.arc_centers.append(None)
- def close(self):
- if not self.outline:
- return
+ def iter_segments(self, tolerance=1e-6):
+ for points, arc in zip_longest(pairwise(self.outline), self.arc_centers):
+ if arc:
+ if points:
+ yield *points, arc
+ else:
+ yield self.outline[-1], self.outline[0], arc
+ return
+ else:
+ if not points:
+ break
+ yield *points, (None, (None, None))
- if self.outline[-1] != self.outline[0]:
- self.outline.append(self.outline[0])
+ # Close outline if necessary.
+ if math.dist(self.outline[0], self.outline[-1]) > tolerance:
+ yield self.outline[-1], self.outline[0], (None, (None, None))
def outline_objects(self, aperture=None):
- for p1, p2, arc in zip_longest(self.outline, self.outline[1:] + self.outline[:1], self.arc_centers):
- if arc:
- clockwise, pc = arc
- yield Arc(*p1, *p2, *pc, clockwise, aperture=aperture, unit=self.unit, polarity_dark=self.polarity_dark)
+ for p1, p2, (clockwise, center) in self.iter_segments():
+ if center:
+ yield Arc(*p1, *p2, *center, clockwise, aperture=aperture, unit=self.unit, polarity_dark=self.polarity_dark)
else:
yield Line(*p1, *p2, aperture=aperture, unit=self.unit, polarity_dark=self.polarity_dark)
- def _aperture_macro_primitives(self, max_error=1e-2, unit=MM):
+ def _aperture_macro_primitives(self, max_error=1e-2, clip_max_error=True, unit=MM):
# unit is only for max_error, the resulting primitives will always be in MM
if len(self.outline) < 2:
return
- points = [self.outline[0]]
- for p1, p2, arc in zip_longest(self.outline[:-1], self.outline[1:], self.arc_centers):
- if arc:
- clockwise, pc = arc
- #r = math.hypot(*pc) # arc center is relative to p1.
- #d = math.dist(p1, p2)
- #err = r - math.sqrt(r**2 - (d/(2*n))**2)
- #n = math.ceil(1/(2*math.sqrt(r**2 - (r - max_err)**2)/d))
- arc = Arc(*p1, *p2, *pc, clockwise, unit=self.unit, polarity_dark=self.polarity_dark, aperture=None)
- for line in arc.approximate(max_error=max_error, unit=unit):
- points.append(line.p2)
-
+ points = []
+ for p1, p2, (clockwise, center) in self.iter_segments():
+ if center:
+ for p in approximate_arc(*center, *p1, *p2, clockwise,
+ max_error=max_error, clip_max_error=clip_max_error):
+ points.append(p)
+ points.pop()
else:
- points.append(p2)
-
- if points[-1] != points[0]:
- points.append(points[0])
+ points.append(p1)
yield amp.Outline(self.unit, int(self.polarity_dark), len(points)-1, tuple(coord for p in points for coord in p))
@@ -389,6 +400,9 @@ class Region(GraphicObject):
yield gp.ArcPoly(conv_outline, conv_arc, polarity_dark=self.polarity_dark)
def to_statements(self, gs):
+ if len(self.outline) < 3:
+ return
+
yield from gs.set_polarity(self.polarity_dark)
yield 'G36*'
# Repeat interpolation mode at start of region statement to work around gerbv bug. Without this, gerbv will
@@ -398,32 +412,24 @@ class Region(GraphicObject):
yield from gs.set_current_point(self.outline[0], unit=self.unit)
- for point, arc_center in zip_longest(self.outline[1:], self.arc_centers):
- if point is None and arc_center is None:
+ for previous_point, point, (clockwise, center) in self.iter_segments():
+ if point is None and center is None:
break
- if arc_center is None:
- yield from gs.set_interpolation_mode(InterpMode.LINEAR)
+ x = gs.file_settings.write_gerber_value(point[0], self.unit)
+ y = gs.file_settings.write_gerber_value(point[1], self.unit)
- x = gs.file_settings.write_gerber_value(point[0], self.unit)
- y = gs.file_settings.write_gerber_value(point[1], self.unit)
+ if clockwise is None:
+ yield from gs.set_interpolation_mode(InterpMode.LINEAR)
yield f'X{x}Y{y}D01*'
- gs.update_point(*point, unit=self.unit)
-
else:
- clockwise, (cx, cy) = arc_center
- x2, y2 = point
yield from gs.set_interpolation_mode(InterpMode.CIRCULAR_CW if clockwise else InterpMode.CIRCULAR_CCW)
-
- x = gs.file_settings.write_gerber_value(x2, self.unit)
- y = gs.file_settings.write_gerber_value(y2, self.unit)
- # TODO are these coordinates absolute or relative now?!
- i = gs.file_settings.write_gerber_value(cx, self.unit)
- j = gs.file_settings.write_gerber_value(cy, self.unit)
+ i = gs.file_settings.write_gerber_value(center[0]-previous_point[0], self.unit)
+ j = gs.file_settings.write_gerber_value(center[1]-previous_point[1], self.unit)
yield f'X{x}Y{y}I{i}J{j}D01*'
- gs.update_point(x2, y2, unit=self.unit)
+ gs.update_point(*point, unit=self.unit)
yield 'G37*'
@@ -605,22 +611,8 @@ class Arc(GraphicObject):
:returns: Angle in clockwise radian between ``0`` and ``2*math.pi``
:rtype: float
"""
- cx, cy = self.cx + self.x1, self.cy + self.y1
- x1, y1 = self.x1 - cx, self.y1 - cy
- x2, y2 = self.x2 - cx, self.y2 - cy
-
- a1, a2 = math.atan2(y1, x1), math.atan2(y2, x2)
- f = abs(a2 - a1)
- if not self.clockwise:
- if a2 > a1:
- return a2 - a1
- else:
- return 2*math.pi - abs(a2 - a1)
- else:
- if a1 > a2:
- return a1 - a2
- else:
- return 2*math.pi - abs(a1 - a2)
+
+ return sweep_angle(self.cx+self.x1, self.cy+self.y1, self.x1, self.y1, self.x2, self.y2, self.clockwise)
@property
def p1(self):
@@ -677,34 +669,16 @@ class Arc(GraphicObject):
:returns: list of :py:class:`~.graphic_objects.Line` instances.
:rtype: list
"""
- # TODO the max_angle calculation below is a bit off -- we over-estimate the error, and thus produce finer
- # results than necessary. Fix this.
-
- r = math.hypot(self.cx, self.cy)
max_error = self.unit(max_error, unit)
- if clip_max_error:
- # 1 - math.sqrt(1 - 0.5*math.sqrt(2))
- max_error = min(max_error, r*0.4588038998538031)
-
- elif max_error >= r:
- return [Line(*self.p1, *self.p2, aperture=self.aperture, polarity_dark=self.polarity_dark, unit=self.unit)]
-
- # see https://www.mathopenref.com/sagitta.html
- l = math.sqrt(r**2 - (r - max_error)**2)
-
- angle_max = math.asin(l/r)
- sweep_angle = self.sweep_angle()
- num_segments = math.ceil(sweep_angle / angle_max)
- angle = sweep_angle / num_segments
-
- if not self.clockwise:
- angle = -angle
-
- cx, cy = self.center
- points = [ rotate_point(self.x1, self.y1, i*angle, cx, cy) for i in range(num_segments + 1) ]
- return [ Line(*p1, *p2, aperture=self.aperture, polarity_dark=self.polarity_dark, unit=self.unit)
- for p1, p2 in zip(points[0::], points[1::]) ]
+ return [Line(*p1, *p2, aperture=self.aperture, polarity_dark=self.polarity_dark, unit=self.unit)
+ for p1, p2 in pairwise(approximate_arc(
+ self.cx+self.x1, self.cy+self.y1,
+ self.x1, self.y1,
+ self.x2, self.y2,
+ self.clockwise,
+ max_error=max_error,
+ clip_max_error=clip_max_error))]
def _rotate(self, rotation, cx=0, cy=0):
# rotate center first since we need old x1, y1 here
@@ -726,7 +700,7 @@ class Arc(GraphicObject):
w = self.aperture.equivalent_width(unit) if self.aperture else 0
return gp.Arc(x1=conv.x1, y1=conv.y1,
x2=conv.x2, y2=conv.y2,
- cx=conv.cx, cy=conv.cy,
+ cx=conv.cx+conv.x1, cy=conv.cy+conv.y1,
clockwise=self.clockwise,
width=w,
polarity_dark=self.polarity_dark)
diff --git a/gerbonara/graphic_primitives.py b/gerbonara/graphic_primitives.py
index ea8fd9f..e136efb 100644
--- a/gerbonara/graphic_primitives.py
+++ b/gerbonara/graphic_primitives.py
@@ -19,7 +19,7 @@
import math
import itertools
-from dataclasses import dataclass, replace
+from dataclasses import dataclass, replace, field
from .utils import *
@@ -79,6 +79,10 @@ class Circle(GraphicPrimitive):
color = fg if self.polarity_dark else bg
return tag('circle', cx=prec(self.x), cy=prec(self.y), r=prec(self.r), fill=color)
+ def to_arc_poly(self):
+ return ArcPoly([(self.x-self.r, self.y), (self.x+self.r, self.y)],
+ [(True, (self.x, self.y)), (True, (self.x, self.y))])
+
@dataclass(frozen=True)
class ArcPoly(GraphicPrimitive):
@@ -88,28 +92,51 @@ class ArcPoly(GraphicPrimitive):
#: connected.
outline : list
#: Must be either None (all segments are straight lines) or same length as outline.
- #: Straight line segments have None entry.
- arc_centers : list = None
+ #: Straight line segments have None entry. Arc segments have (clockwise, (cx, cy)) tuple with cx, cy being absolute
+ #: coords.
+ arc_centers : list = field(default_factory=list)
@property
def segments(self):
""" Return an iterator through all *segments* of this polygon. For each outline segment (line or arc), this
- iterator will yield a ``(p1, p2, center)`` tuple. If the segment is a straight line, ``center`` will be
- ``None``.
+ iterator will yield a ``(p1, p2, (clockwise, center))`` tuple. If the segment is a straight line, ``clockwise``
+ will be ``None``.
"""
- ol = self.outline
- return itertools.zip_longest(ol, ol[1:] + [ol[0]], self.arc_centers or [])
+ for points, arc in itertools.zip_longest(itertools.pairwise(self.outline), self.arc_centers):
+ if arc:
+ if points:
+ yield *points, arc
+ else:
+ yield self.outline[-1], self.outline[0], arc
+ return
+ else:
+ if not points:
+ break
+ yield *points, (None, (None, None))
+
+ # Close outline if necessary.
+ if math.dist(self.outline[0], self.outline[-1]) > 1e-6:
+ yield self.outline[-1], self.outline[0], (None, (None, None))
+
+ def approximate_arcs(self, max_error=1e-2, clip_max_error=True):
+ outline = []
+ for p1, p2, (clockwise, center) in self.segments():
+ if clockwise is None:
+ outline.append(p1)
+ else:
+ outline.extend(approximate_arc(cx, cy, x1, y1, x2, y2, clockwise,
+ max_error=max_error, clip_max_error=clip_max_error))
+ outline.pop() # remove arc end point
+ return type(self)(outline)
def bounding_box(self):
bbox = (None, None), (None, None)
- for (x1, y1), (x2, y2), arc in self.segments:
- if arc:
- clockwise, (cx, cy) = arc
- bbox = add_bounds(bbox, arc_bounds(x1, y1, x2, y2, cx, cy, clockwise))
-
- else:
+ for (x1, y1), (x2, y2), (clockwise, (cx, cy)) in self.segments:
+ if clockwise is None:
line_bounds = (min(x1, x2), min(y1, y2)), (max(x1, x2), max(y1, y2))
bbox = add_bounds(bbox, line_bounds)
+ else:
+ bbox = add_bounds(bbox, arc_bounds(x1, y1, x2, y2, cx, cy, clockwise))
return bbox
@classmethod
@@ -149,6 +176,9 @@ class ArcPoly(GraphicPrimitive):
color = fg if self.polarity_dark else bg
return tag('path', d=' '.join(self.path_d()), fill=color)
+ def to_arc_poly(self):
+ return self
+
@dataclass(frozen=True)
class Line(GraphicPrimitive):
@@ -191,6 +221,24 @@ class Line(GraphicPrimitive):
return tag('path', d=f'M {float(self.x1):.6} {float(self.y1):.6} L {float(self.x2):.6} {float(self.y2):.6}',
fill='none', stroke=color, stroke_width=str(width))
+ def to_arc_poly(self):
+ l = math.dist((self.x1, self.y1), (self.x2, self.y2))
+ dx, dy = self.x2-self.x1, self.y2-self.y1
+ nx, ny = -dy/l, dx/l
+ rx, ry = nx*self.width/2, ny*self.width/2
+ return ArcPoly([
+ (self.x1+rx, self.y1+ry),
+ (self.x1-rx, self.y1-ry),
+ (self.x2-rx, self.y2-ry),
+ (self.x2+rx, self.y2+ry),
+ ], [
+ (True, (self.x1, self.y1)),
+ None,
+ (True, (self.x2, self.y2)),
+ None,
+ ])
+
+
@dataclass(frozen=True)
class Arc(GraphicPrimitive):
""" Circular arc with line width ``width`` going from ``(x1, y1)`` to ``(x2, y2)`` around center at ``(cx, cy)``. """
@@ -202,9 +250,9 @@ class Arc(GraphicPrimitive):
x2 : float
#: End Y coodinate
y2 : float
- #: Center X coordinate relative to ``x1``
+ #: Center X coordinate (absolute)
cx : float
- #: Center Y coordinate relative to ``y1``
+ #: Center Y coordinate (absolute)
cy : float
#: ``True`` if this arc is clockwise from start to end. Selects between the large arc and the small arc given this
#: start, end and center
@@ -214,11 +262,10 @@ class Arc(GraphicPrimitive):
@property
def is_circle(self):
- return math.isclose(self.x1, self.x2) and math.isclose(self.y1, self.y2)
+ return math.isclose(self.x1, self.x2, abs_tol=1e-6) and math.isclose(self.y1, self.y2, abs_tol=1e-6)
def flip(self):
- return replace(self, x1=self.x2, y1=self.y2, x2=self.x1, y2=self.y1,
- cx=(self.x1 + self.cx) - self.x2, cy=(self.y1 + self.cy) - self.y2, clockwise=not self.clockwise)
+ return replace(self, x1=self.x2, y1=self.y2, x2=self.x1, y2=self.y1, clockwise=not self.clockwise)
def bounding_box(self):
r = self.width/2
@@ -232,6 +279,25 @@ class Arc(GraphicPrimitive):
return tag('path', d=f'M {float(self.x1):.6} {float(self.y1):.6} {arc}',
fill='none', stroke=color, stroke_width=width)
+ def to_arc_poly(self):
+ r = math.dist((self.x1, self.y1), (self.cx, self.cy))
+ dx1, dy1 = self.x1-self.cx, self.y1-self.cy
+ nx1, ny1 = dx1/r * self.width/2, dy1/r * self.width/2
+ dx2, dy2 = self.x2-self.cx, self.y2-self.cy
+ nx2, ny2 = dx2/r * self.width/2, dy2/r * self.width/2
+ return ArcPoly([
+ (self.x1+nx1, self.y1+nx1),
+ (self.x1-nx1, self.y1-nx1),
+ (self.x2-nx2, self.y2-nx2),
+ (self.x2+nx2, self.y2+nx2),
+ ], [
+ (self.clockwise, (self.x1, self.y1)),
+ (self.clockwise, (self.cx, self.cy)),
+ (self.clockwise, (self.x2, self.y2)),
+ (self.clockwise, (self.cx, self.cy)),
+ ])
+
+
@dataclass(frozen=True)
class Rectangle(GraphicPrimitive):
#: **Center** X coordinate
diff --git a/gerbonara/tests/test_kicad_footprints.py b/gerbonara/tests/test_kicad_footprints.py
index 07d64a7..663037b 100644
--- a/gerbonara/tests/test_kicad_footprints.py
+++ b/gerbonara/tests/test_kicad_footprints.py
@@ -142,7 +142,7 @@ def _parse_path_d(path):
cx = mx - nx*nl
cy = my - ny*nl
- (min_x, min_y), (max_x, max_y) = arc_bounds(last_x, last_y, ax, ay, cx-last_x, cy-last_y, clockwise=(not sweep))
+ (min_x, min_y), (max_x, max_y) = arc_bounds(last_x, last_y, ax, ay, cx, cy, clockwise=(not sweep))
min_x -= sr
min_y -= sr
max_x += sr
diff --git a/gerbonara/utils.py b/gerbonara/utils.py
index c7336e6..892b217 100644
--- a/gerbonara/utils.py
+++ b/gerbonara/utils.py
@@ -244,6 +244,59 @@ def rotate_point(x, y, angle, cx=0, cy=0):
cy + (x - cx) * math.sin(-angle) + (y - cy) * math.cos(-angle))
+def sweep_angle(cx, cy, x1, y1, x2, y2, clockwise):
+ """ Calculate absolute sweep angle of arc. This is always a positive number.
+
+ :returns: Angle in clockwise radian between ``0`` and ``2*math.pi``
+ :rtype: float
+ """
+ x1, y1 = x1-cx, y1-cy
+ x2, y2 = x2-cx, y2-cy
+
+ a1, a2 = math.atan2(y1, x1), math.atan2(y2, x2)
+ f = abs(a2 - a1)
+ if not clockwise:
+ if a2 > a1:
+ return a2 - a1
+ else:
+ return 2*math.pi - abs(a2 - a1)
+ else:
+ if a1 > a2:
+ return a1 - a2
+ else:
+ return 2*math.pi - abs(a1 - a2)
+
+
+def approximate_arc(cx, cy, x1, y1, x2, y2, clockwise, max_error=1e-2, clip_max_error=True):
+ # TODO the max_angle calculation below is a bit off -- we over-estimate the error, and thus produce finer
+ # results than necessary. Fix this.
+
+ r = math.dist((x1, y1), (cx, cy))
+
+ if clip_max_error:
+ # 1 - math.sqrt(1 - 0.5*math.sqrt(2))
+ max_error = min(max_error, r*0.4588038998538031)
+
+ elif max_error >= r:
+ yield (x1, y1)
+ yield (x2, y2)
+ return
+
+ # see https://www.mathopenref.com/sagitta.html
+ l = math.sqrt(r**2 - (r - max_error)**2)
+
+ angle_max = math.asin(l/r)
+ sweep_angle = sweep_angle(cx, cy, x1, y1, x2, y2, clockwise)
+ num_segments = math.ceil(sweep_angle / angle_max)
+ angle = sweep_angle / num_segments
+
+ if not clockwise:
+ angle = -angle
+
+ for i in range(num_segments + 1):
+ yield rotate_point(x1, y1, i*angle, cx, cy)
+
+
def min_none(a, b):
""" Like the ``min(..)`` builtin, but if either value is ``None``, returns the other. """
if a is None:
@@ -340,11 +393,9 @@ def arc_bounds(x1, y1, x2, y2, cx, cy, clockwise):
# This solution manages to handle circular arcs given in gerber format (with explicit center and endpoints, plus
# sweep direction instead of a format with e.g. angles and radius) without any trigonometric functions (e.g. atan2).
#
- # cx, cy are relative to p1.
+ # cx, cy are in absolute coordinates.
# Center arc on cx, cy
- cx += x1
- cy += y1
x1 -= cx
x2 -= cx
y1 -= cy
@@ -461,25 +512,25 @@ def point_line_distance(l1, l2, p):
def svg_arc(old, new, center, clockwise):
- """ Format an SVG circular arc "A" path data entry given an arc in Gerber notation (i.e. with center relative to
- first point).
+ """ Format an SVG circular arc "A" path data entry given an arc in Gerber notation (but with center in absolute
+ coordinates).
:rtype: str
"""
- r = float(math.hypot(*center))
+ r = float(math.dist(old, center))
# invert sweep flag since the svg y axis is mirrored
sweep_flag = int(not clockwise)
# In the degenerate case where old == new, we always take the long way around. To represent this "full-circle arc"
# in SVG, we have to split it into two.
if math.isclose(math.dist(old, new), 0):
- intermediate = old[0] + 2*center[0], old[1] + 2*center[1]
+ intermediate = old[0] + 2*(center[0]-old[0]), old[1] + 2*(center[1]-old[1])
# Note that we have to preserve the sweep flag to avoid causing self-intersections by flipping the direction of
# a circular cutin
return f'A {r:.6} {r:.6} 0 1 {sweep_flag} {float(intermediate[0]):.6} {float(intermediate[1]):.6} ' +\
f'A {r:.6} {r:.6} 0 1 {sweep_flag} {float(new[0]):.6} {float(new[1]):.6}'
else: # normal case
- d = point_line_distance(old, new, (old[0]+center[0], old[1]+center[1]))
+ d = point_line_distance(old, new, center[0], center[1])
large_arc = int((d < 0) == clockwise)
return f'A {r:.6} {r:.6} 0 {large_arc} {sweep_flag} {float(new[0]):.6} {float(new[1]):.6}'