538 lines
20 KiB
Python
538 lines
20 KiB
Python
# coding=utf-8
|
|
"""
|
|
Noyau de calcul de l'extension « Dog Bandana », sans dependance a inkex.
|
|
|
|
Testable avec pytest seul et reutilisable hors Inkscape (scripts, schema
|
|
des parametres).
|
|
|
|
Conventions :
|
|
- un contour (`rings`) est une liste d'anneaux, chaque anneau etant une liste
|
|
de points (x, y) fermee implicitement ; les trous suivent la regle pair-impair ;
|
|
- une polyligne est une liste de points (x, y) ;
|
|
- l'axe y est oriente vers le bas (repere SVG).
|
|
|
|
Le motif est un labyrinthe de Turing (bandes de largeur constante qui
|
|
serpentent, bifurquent et se terminent en bouts ronds) : `turing_pattern`
|
|
renvoie la ligne centrale de chaque bande, a tracer avec un trait a bouts
|
|
ronds. Seule dependance : numpy, fourni avec Inkscape (inkex en depend).
|
|
|
|
Les traits produits passent par `laser_order` avant d'etre ecrits : ils sont
|
|
enchaines et ordonnes pour limiter les deplacements a vide de la tete du laser.
|
|
"""
|
|
|
|
import math
|
|
|
|
import numpy as np
|
|
|
|
|
|
def parse_color(value, default=("#b3b3b3", 1.0)):
|
|
"""Couleur Inkscape (entier RGBA decimal ou 0x..., ou #rrggbb[aa]).
|
|
|
|
Renvoie (couleur CSS #rrggbb, opacite entre 0 et 1). Le parametre
|
|
« color » d'Inkscape arrive sous forme d'entier RGBA ; on le decode
|
|
nous-memes pour ne pas dependre de l'API couleur d'inkex, qui a change
|
|
entre les versions 1.x.
|
|
"""
|
|
text = str(value).strip()
|
|
try:
|
|
if text.startswith("#"):
|
|
digits = text[1:]
|
|
if len(digits) == 3:
|
|
digits = "".join(c * 2 for c in digits)
|
|
if len(digits) == 6:
|
|
digits += "ff"
|
|
if len(digits) != 8:
|
|
return default
|
|
number = int(digits, 16)
|
|
else:
|
|
number = int(text, 0)
|
|
except ValueError:
|
|
return default
|
|
number &= 0xFFFFFFFF
|
|
red, green, blue = (number >> 24) & 255, (number >> 16) & 255, (number >> 8) & 255
|
|
alpha = (number & 255) / 255.0
|
|
return "#{:02x}{:02x}{:02x}".format(red, green, blue), round(alpha, 4)
|
|
|
|
|
|
def polylines_to_d(polylines, precision=4):
|
|
"""Donnees `d` d'un chemin SVG : une polyligne par sous-chemin."""
|
|
fmt = "{:.%df},{:.%df}" % (precision, precision)
|
|
parts = []
|
|
for polyline in polylines:
|
|
if len(polyline) < 2:
|
|
continue
|
|
parts.append("M " + fmt.format(*polyline[0]))
|
|
parts.extend("L " + fmt.format(*point) for point in polyline[1:])
|
|
return " ".join(parts)
|
|
|
|
|
|
# --------------------------------------------------------------------------
|
|
# Ordre de gravure (decoupeuse laser)
|
|
# --------------------------------------------------------------------------
|
|
|
|
def _key(point):
|
|
"""Cle d'un point : deux extremites a 1e-6 pres sont le meme noeud."""
|
|
return round(point[0], 6), round(point[1], 6)
|
|
|
|
|
|
def _is_closed(line):
|
|
return len(line) > 2 and _key(line[0]) == _key(line[-1])
|
|
|
|
|
|
def chain_polylines(polylines):
|
|
"""Met bout a bout les polylignes qui se touchent par leurs extremites.
|
|
|
|
Le laser parcourt alors chaque resultat d'un trait, sans lever la tete.
|
|
Les polylignes sont les aretes d'un graphe dont les noeuds sont leurs
|
|
extremites ; on part d'abord des noeuds de degre impair (bouts de
|
|
branche) : un parcours qui y commence ne peut s'arreter que sur un autre
|
|
noeud impair, ce qui limite le nombre de traits, donc de sauts a vide.
|
|
Une polyligne deja fermee (boucle) est gardee telle quelle.
|
|
"""
|
|
out = []
|
|
points = {}
|
|
adjacency = {} # noeud -> [(numero de polyligne, voisin)]
|
|
lines = [list(line) for line in polylines if len(line) >= 2]
|
|
for index, line in enumerate(lines):
|
|
a, b = _key(line[0]), _key(line[-1])
|
|
if a == b:
|
|
out.append(line)
|
|
continue
|
|
points.setdefault(a, line[0])
|
|
points.setdefault(b, line[-1])
|
|
adjacency.setdefault(a, []).append((index, b))
|
|
adjacency.setdefault(b, []).append((index, a))
|
|
used = [False] * len(lines)
|
|
|
|
def free_edges(node):
|
|
edges = adjacency[node]
|
|
edges[:] = [edge for edge in edges if not used[edge[0]]]
|
|
return edges
|
|
|
|
def walk(node):
|
|
chain = [points[node]]
|
|
while True:
|
|
edges = free_edges(node)
|
|
if not edges:
|
|
return chain
|
|
index, following = edges.pop()
|
|
used[index] = True
|
|
line = lines[index]
|
|
if _key(line[0]) != node:
|
|
line = line[::-1]
|
|
chain.extend(line[1:])
|
|
node = following
|
|
|
|
for node in adjacency:
|
|
if len(free_edges(node)) % 2:
|
|
out.append(walk(node))
|
|
for node in adjacency: # reste : circuits fermes
|
|
while free_edges(node):
|
|
out.append(walk(node))
|
|
return out
|
|
|
|
|
|
def order_polylines(polylines, start=(0.0, 0.0)):
|
|
"""Ordonne les polylignes pour limiter les deplacements a vide du laser.
|
|
|
|
Plus proche voisin : depuis la fin de la polyligne precedente (ou
|
|
`start`), on enchaine sur l'entree libre la plus proche. Une polyligne
|
|
ouverte peut etre parcourue dans les deux sens ; une boucle fermee peut
|
|
commencer a n'importe lequel de ses sommets. Les entrees sont rangees
|
|
dans une grille pour ne pas tout comparer a chaque pas.
|
|
"""
|
|
polylines = [list(line) for line in polylines if len(line) >= 2]
|
|
if not polylines:
|
|
return []
|
|
entries = [] # (numero de polyligne, sommet d'entree)
|
|
for index, line in enumerate(polylines):
|
|
if _is_closed(line):
|
|
entries.extend((index, k) for k in range(len(line) - 1))
|
|
else:
|
|
entries.extend(((index, 0), (index, len(line) - 1)))
|
|
|
|
xs = [polylines[i][k][0] for i, k in entries]
|
|
ys = [polylines[i][k][1] for i, k in entries]
|
|
x0, y0 = min(xs), min(ys)
|
|
width, height = max(xs) - x0, max(ys) - y0
|
|
cell = math.sqrt(width * height / len(entries)) or max(width, height) / len(entries) or 1.0
|
|
nx, ny = int(width / cell), int(height / cell)
|
|
grid = {}
|
|
for entry, x, y in zip(entries, xs, ys):
|
|
grid.setdefault((int((x - x0) / cell), int((y - y0) / cell)), []).append(entry)
|
|
|
|
done = [False] * len(polylines)
|
|
|
|
def ring(cx, cy, r):
|
|
"""Cellules de la grille a distance r (en cellules) de (cx, cy)."""
|
|
if r == 0:
|
|
yield cx, cy
|
|
return
|
|
for gx in range(max(cx - r, 0), min(cx + r, nx) + 1):
|
|
if 0 <= cy - r <= ny:
|
|
yield gx, cy - r
|
|
if 0 <= cy + r <= ny:
|
|
yield gx, cy + r
|
|
for gy in range(max(cy - r + 1, 0), min(cy + r - 1, ny) + 1):
|
|
if 0 <= cx - r <= nx:
|
|
yield cx - r, gy
|
|
if 0 <= cx + r <= nx:
|
|
yield cx + r, gy
|
|
|
|
def nearest(x, y):
|
|
cx = int(math.floor((x - x0) / cell))
|
|
cy = int(math.floor((y - y0) / cell))
|
|
r = max(0, -cx, cx - nx, -cy, cy - ny) # premier anneau dans la grille
|
|
r_max = max(cx, nx - cx, cy, ny - cy, r)
|
|
best, best_d = None, float("inf")
|
|
while r <= r_max and (r - 1) * cell < best_d:
|
|
for key in ring(cx, cy, r):
|
|
bucket = grid.get(key)
|
|
if not bucket:
|
|
continue
|
|
bucket[:] = [e for e in bucket if not done[e[0]]]
|
|
for index, k in bucket:
|
|
px, py = polylines[index][k]
|
|
d = math.hypot(px - x, py - y)
|
|
if d < best_d:
|
|
best, best_d = (index, k), d
|
|
r += 1
|
|
return best
|
|
|
|
ordered = []
|
|
position = start
|
|
for _ in range(len(polylines)):
|
|
index, k = nearest(*position)
|
|
done[index] = True
|
|
line = polylines[index]
|
|
if k == 0:
|
|
pass
|
|
elif not _is_closed(line):
|
|
line = line[::-1]
|
|
else: # boucle : rotation
|
|
line = line[k:-1] + line[:k] + [line[k]]
|
|
ordered.append(line)
|
|
position = line[-1]
|
|
return ordered
|
|
|
|
|
|
def laser_order(polylines, start=(0.0, 0.0)):
|
|
"""Enchaine puis ordonne les traits : a appliquer avant polylines_to_d.
|
|
|
|
`start` : position de la tete (fin du trace precedent, ou origine).
|
|
La position finale est le dernier point de la derniere polyligne.
|
|
"""
|
|
return order_polylines(chain_polylines(polylines), start)
|
|
|
|
|
|
def travel_length(polylines, start=(0.0, 0.0)):
|
|
"""Longueur totale des deplacements a vide (tete levee) entre polylignes."""
|
|
total = 0.0
|
|
position = start
|
|
for line in polylines:
|
|
total += math.hypot(line[0][0] - position[0], line[0][1] - position[1])
|
|
position = line[-1]
|
|
return total
|
|
|
|
|
|
# --------------------------------------------------------------------------
|
|
# Motif de Turing (labyrinthe)
|
|
# --------------------------------------------------------------------------
|
|
#
|
|
# Regime « labyrinthe » de l'equation de Swift-Hohenberg :
|
|
# du/dt = r.u - (1 + laplacien)^2 u - u^3
|
|
# integree sur une grille de pixels couvrant la forme. Partant d'un bruit
|
|
# aleatoire, le champ u s'organise en bandes de periode 2.pi (unites reduites).
|
|
# Les bandes positives sont amincies en squelette d'un pixel, suivi en
|
|
# polylignes, lisse puis simplifie.
|
|
|
|
PIXELS_PER_PERIOD = 8 # resolution du calcul
|
|
STEPS = 60 # pas d'integration : plus, bandes plus longues
|
|
SMOOTHING = 4 # passes de lissage des lignes centrales
|
|
EDGE_MODES = ("cut", "follow")
|
|
MAX_PIXELS = 3000000 # au-dela, calcul trop long dans Inkscape
|
|
|
|
|
|
def rasterize(rings, x0, y0, step, nx, ny):
|
|
"""Masque booleen (ny, nx) des centres de pixels interieurs (pair-impair).
|
|
|
|
Pixel (i, j) : centre en (x0 + (j + 0.5) * step, y0 + (i + 0.5) * step).
|
|
Balayage par lignes : pour chaque ligne, abscisses des intersections avec
|
|
les aretes, triees ; un pixel est dedans s'il a un nombre impair
|
|
d'intersections a sa gauche.
|
|
"""
|
|
mask = np.zeros((ny, nx), dtype=bool)
|
|
edges = [(ring[k], ring[(k + 1) % len(ring)]) for ring in rings
|
|
for k in range(len(ring))]
|
|
if not edges:
|
|
return mask
|
|
ax, ay, bx, by = (np.array(v, dtype=float) for v in zip(
|
|
*[(a[0], a[1], b[0], b[1]) for a, b in edges]))
|
|
columns = x0 + (np.arange(nx) + 0.5) * step
|
|
for i in range(ny):
|
|
y = y0 + (i + 0.5) * step
|
|
# Arete demi-ouverte : un sommet partage n'est compte qu'une fois.
|
|
hit = (ay <= y) != (by <= y)
|
|
if not hit.any():
|
|
continue
|
|
t = (y - ay[hit]) / (by[hit] - ay[hit])
|
|
xs = np.sort(ax[hit] + t * (bx[hit] - ax[hit]))
|
|
mask[i] = np.searchsorted(xs, columns) % 2 == 1
|
|
return mask
|
|
|
|
|
|
def erode(mask, radius):
|
|
"""Erosion du masque par un disque de `radius` pixels.
|
|
|
|
Convolution par FFT : un pixel reste s'il n'y a aucun pixel exterieur
|
|
dans le disque qui l'entoure. La convolution est periodique : la grille
|
|
doit garder une bordure exterieure d'au moins `radius` pixels.
|
|
"""
|
|
if radius <= 0:
|
|
return mask.copy()
|
|
ny, nx = mask.shape
|
|
iy = np.minimum(np.arange(ny), ny - np.arange(ny))[:, None]
|
|
ix = np.minimum(np.arange(nx), nx - np.arange(nx))[None, :]
|
|
disk = (ix ** 2 + iy ** 2 <= radius ** 2).astype(float)
|
|
hits = np.fft.irfft2(np.fft.rfft2((~mask).astype(float)) * np.fft.rfft2(disk),
|
|
s=mask.shape)
|
|
return mask & (hits < 0.5)
|
|
|
|
|
|
def swift_hohenberg(shape, pixels_per_period=PIXELS_PER_PERIOD, seed=1,
|
|
steps=STEPS, outside=None, r=0.35, dt=0.5):
|
|
"""Champ u (ny, nx) du regime labyrinthe.
|
|
|
|
Schema spectral semi-implicite : partie lineaire implicite (stable quel
|
|
que soit le pas de temps), terme cubique explicite ; bords periodiques.
|
|
`outside` (masque booleen, optionnel) : pixels ou u est force a -1 a
|
|
chaque pas ; les bandes s'arretent alors avant ce masque et longent son
|
|
bord, au lieu d'etre coupees net.
|
|
"""
|
|
ny, nx = shape
|
|
rng = np.random.default_rng(seed)
|
|
u = 0.1 * rng.standard_normal((ny, nx))
|
|
spacing = 2 * math.pi / pixels_per_period # pixel en unites reduites
|
|
kx = 2 * math.pi * np.fft.rfftfreq(nx, d=spacing)
|
|
ky = 2 * math.pi * np.fft.fftfreq(ny, d=spacing)
|
|
k2 = ky[:, None] ** 2 + kx[None, :] ** 2
|
|
denominator = 1 - dt * (r - (1 - k2) ** 2)
|
|
for _ in range(steps):
|
|
if outside is not None:
|
|
u[outside] = -1.0
|
|
u_hat = np.fft.rfft2(u - dt * u ** 3)
|
|
u = np.fft.irfft2(u_hat / denominator, s=(ny, nx))
|
|
if outside is not None:
|
|
u[outside] = -1.0
|
|
return u
|
|
|
|
|
|
def skeletonize(binary):
|
|
"""Squelette d'un pixel d'epaisseur (Zhang-Suen), vectorise avec numpy."""
|
|
img = np.pad(binary.astype(np.uint8), 1)
|
|
while True:
|
|
changed = False
|
|
for first in (True, False):
|
|
p2, p3, p4 = img[:-2, 1:-1], img[:-2, 2:], img[1:-1, 2:]
|
|
p5, p6, p7 = img[2:, 2:], img[2:, 1:-1], img[2:, :-2]
|
|
p8, p9 = img[1:-1, :-2], img[:-2, :-2]
|
|
around = [p2, p3, p4, p5, p6, p7, p8, p9, p2]
|
|
neighbours = sum(around[:8])
|
|
transitions = sum(((a == 0) & (b == 1)).astype(np.uint8)
|
|
for a, b in zip(around, around[1:]))
|
|
if first:
|
|
c1, c2 = p2 * p4 * p6, p4 * p6 * p8
|
|
else:
|
|
c1, c2 = p2 * p4 * p8, p2 * p6 * p8
|
|
remove = ((img[1:-1, 1:-1] == 1) & (neighbours >= 2) & (neighbours <= 6)
|
|
& (transitions == 1) & (c1 == 0) & (c2 == 0))
|
|
if remove.any():
|
|
img[1:-1, 1:-1][remove] = 0
|
|
changed = True
|
|
if not changed:
|
|
return img[1:-1, 1:-1].astype(bool)
|
|
|
|
|
|
_NEIGHBOURS = ((-1, 0), (0, 1), (1, 0), (0, -1), (-1, -1), (-1, 1), (1, 1), (1, -1))
|
|
|
|
|
|
def _skeleton_graph(skeleton):
|
|
"""Voisins de chaque pixel du squelette.
|
|
|
|
Liaisons 8-connexes, sauf une diagonale doublee par deux liaisons droites
|
|
(coin en « L ») : elle creerait de faux carrefours.
|
|
"""
|
|
pixels = set(zip(*(index.tolist() for index in np.nonzero(skeleton))))
|
|
graph = {}
|
|
for (i, j) in pixels:
|
|
links = []
|
|
for di, dj in _NEIGHBOURS:
|
|
q = (i + di, j + dj)
|
|
if q not in pixels:
|
|
continue
|
|
if di and dj and ((i + di, j) in pixels or (i, j + dj) in pixels):
|
|
continue
|
|
links.append(q)
|
|
graph[(i, j)] = links
|
|
return graph
|
|
|
|
|
|
def trace_skeleton(skeleton, min_spur=0):
|
|
"""Polylignes de pixels (ligne, colonne) qui suivent le squelette.
|
|
|
|
Chaque branche relie deux noeuds (bouts ou carrefours) ; les boucles sans
|
|
noeud sont suivies a part ; un pixel isole donne une polyligne d'un point.
|
|
Les ergots (branche libre de moins de `min_spur` pixels accrochee a un
|
|
carrefour, artefacts de l'amincissement) sont supprimes.
|
|
"""
|
|
graph = _skeleton_graph(skeleton)
|
|
seen = set() # liaisons deja parcourues
|
|
|
|
def follow(previous, current, line):
|
|
seen.add((previous, current))
|
|
seen.add((current, previous))
|
|
while len(graph[current]) == 2 and current != line[0]:
|
|
line.append(current)
|
|
a, b = graph[current]
|
|
following = b if a == previous else a
|
|
if (current, following) in seen:
|
|
break
|
|
seen.add((current, following))
|
|
seen.add((following, current))
|
|
previous, current = current, following
|
|
line.append(current)
|
|
return line
|
|
|
|
lines = []
|
|
for node in sorted(p for p, links in graph.items() if len(links) != 2):
|
|
if not graph[node]:
|
|
lines.append([node])
|
|
for nxt in graph[node]:
|
|
if (node, nxt) not in seen:
|
|
lines.append(follow(node, nxt, [node]))
|
|
for p in sorted(graph): # boucles isolees
|
|
links = graph[p]
|
|
if len(links) == 2 and (p, links[0]) not in seen:
|
|
lines.append(follow(p, links[0], [p]))
|
|
|
|
if min_spur <= 0:
|
|
return lines
|
|
degree = {p: len(links) for p, links in graph.items()}
|
|
kept = []
|
|
for line in lines:
|
|
ends = sorted((degree[line[0]], degree[line[-1]]))
|
|
if 1 < len(line) <= min_spur and ends[0] == 1 and ends[1] >= 3:
|
|
continue
|
|
kept.append(line)
|
|
return kept
|
|
|
|
|
|
def smooth_polyline(points, passes=2):
|
|
"""Lissage par moyenne glissante (1/4, 1/2, 1/4), extremites fixes.
|
|
|
|
Une boucle fermee (premier point = dernier) est lissee tout du long.
|
|
"""
|
|
if len(points) < 3:
|
|
return [tuple(p) for p in points]
|
|
closed = tuple(points[0]) == tuple(points[-1])
|
|
pts = np.array(points[:-1] if closed else points, dtype=float)
|
|
for _ in range(passes):
|
|
if closed:
|
|
pts = 0.25 * np.roll(pts, 1, 0) + 0.5 * pts + 0.25 * np.roll(pts, -1, 0)
|
|
else:
|
|
inner = 0.25 * pts[:-2] + 0.5 * pts[1:-1] + 0.25 * pts[2:]
|
|
pts = np.vstack((pts[:1], inner, pts[-1:]))
|
|
out = [tuple(p) for p in pts.tolist()]
|
|
if closed:
|
|
out.append(out[0])
|
|
return out
|
|
|
|
|
|
def simplify_polyline(points, tolerance):
|
|
"""Ramer-Douglas-Peucker : ne garde que les sommets utiles a `tolerance` pres."""
|
|
if len(points) < 3:
|
|
return [tuple(p) for p in points]
|
|
pts = np.asarray(points, dtype=float)
|
|
keep = np.zeros(len(pts), dtype=bool)
|
|
keep[0] = keep[-1] = True
|
|
stack = [(0, len(pts) - 1)]
|
|
while stack:
|
|
a, b = stack.pop()
|
|
if b - a < 2:
|
|
continue
|
|
sx, sy = pts[b] - pts[a]
|
|
rel = pts[a + 1:b] - pts[a]
|
|
length = math.hypot(sx, sy)
|
|
if length == 0:
|
|
dist = np.hypot(rel[:, 0], rel[:, 1])
|
|
else:
|
|
dist = np.abs(rel[:, 0] * sy - rel[:, 1] * sx) / length
|
|
k = int(np.argmax(dist))
|
|
if dist[k] > tolerance:
|
|
keep[a + 1 + k] = True
|
|
stack.extend(((a, a + 1 + k), (a + 1 + k, b)))
|
|
return [tuple(p) for p in pts[keep].tolist()]
|
|
|
|
|
|
def _grid(rings, period, pixels_per_period):
|
|
"""Origine, pas et taille (x0, y0, step, nx, ny) de la grille de calcul.
|
|
|
|
Bordure exterieure de deux periodes : le champ y vaut -1 et l'erosion
|
|
par FFT (periodique) ne deborde pas d'un cote sur l'autre.
|
|
"""
|
|
xs = [x for ring in rings for x, _y in ring]
|
|
ys = [y for ring in rings for _x, y in ring]
|
|
step = period / pixels_per_period
|
|
pad = 2 * pixels_per_period
|
|
nx = int(math.ceil((max(xs) - min(xs)) / step)) + 2 * pad
|
|
ny = int(math.ceil((max(ys) - min(ys)) / step)) + 2 * pad
|
|
return min(xs) - pad * step, min(ys) - pad * step, step, nx, ny
|
|
|
|
|
|
def grid_pixels(rings, period, pixels_per_period=PIXELS_PER_PERIOD):
|
|
"""Nombre de pixels de la grille de calcul (0 si rien a calculer)."""
|
|
if period <= 0 or not any(rings):
|
|
return 0
|
|
_x0, _y0, _step, nx, ny = _grid(rings, period, pixels_per_period)
|
|
return nx * ny
|
|
|
|
|
|
def turing_pattern(rings, period, line_width, margin=0.0, seed=1, edge="cut",
|
|
pixels_per_period=PIXELS_PER_PERIOD, steps=STEPS):
|
|
"""Lignes centrales du labyrinthe de Turing qui remplit `rings`.
|
|
|
|
- period : distance entre les lignes centrales de deux bandes voisines ;
|
|
- line_width : epaisseur du trait (bouts ronds compris) : le trait entier
|
|
reste dans la forme ;
|
|
- margin : espace libre entre le bord de la forme et le trait ;
|
|
- seed : graine du tirage aleatoire (autre nombre, autre motif) ;
|
|
- edge : "cut", le motif est calcule sans tenir compte de la forme puis
|
|
coupe a son bord (comme un tissu decoupe) ; "follow", les bandes
|
|
s'arretent avant le bord et le longent.
|
|
|
|
Renvoie des polylignes en coordonnees du document ; un point isole est
|
|
une polyligne de deux points confondus (un trait a bouts ronds le dessine).
|
|
"""
|
|
if period <= 0 or not any(rings):
|
|
return []
|
|
x0, y0, step, nx, ny = _grid(rings, period, pixels_per_period)
|
|
mask = rasterize(rings, x0, y0, step, nx, ny)
|
|
inset = max(0.0, margin) + max(0.0, line_width) / 2
|
|
region = erode(mask, inset / step)
|
|
if not region.any():
|
|
return []
|
|
follow = edge == "follow"
|
|
u = swift_hohenberg(region.shape, pixels_per_period, seed, steps,
|
|
outside=~region if follow else None)
|
|
skeleton = skeletonize(u > 0) & region
|
|
lines = trace_skeleton(skeleton, min_spur=pixels_per_period / 2)
|
|
|
|
out = []
|
|
for line in lines:
|
|
points = [(x0 + (j + 0.5) * step, y0 + (i + 0.5) * step) for i, j in line]
|
|
if len(points) == 1:
|
|
out.append([points[0], points[0]])
|
|
else:
|
|
out.append(simplify_polyline(smooth_polyline(points, SMOOTHING), 0.1 * step))
|
|
return out
|