Version initiale de l'extension Inkscape de remplissage tête de mort
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
commit
e3383d0caa
25 files changed
+3746
No files matched your search
@@ -0,0 +1,585 @@
|
||||
# coding=utf-8
|
||||
"""
|
||||
Noyau de calcul de l'extension « Skull Pattern Fill », sans dependance a inkex.
|
||||
|
||||
Testable avec pytest seul et reutilisable hors Inkscape (scripts, schema
|
||||
des parametres).
|
||||
|
||||
Le remplissage reprend le principe du motif de reference (doc/patern.png) :
|
||||
un meme crane, repete a des tailles, des angles et en miroir differents, les
|
||||
cranes s'empilant sans laisser de vide ; les petits sont dessines d'abord,
|
||||
les grands viennent par-dessus.
|
||||
|
||||
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) ;
|
||||
- une boucle de Bezier est une liste de segments cubiques (p0, c1, c2, p3),
|
||||
fermee ;
|
||||
- le crane est dessine dans un repere unite : centre en (0, 0), hauteur 1
|
||||
(y de -0,5 a 0,5), largeur 0,80 ; c'est le dessin de doc/dessin.svg sans
|
||||
ses cornes, vu de trois quarts et tourne vers la gauche ;
|
||||
- l'axe y est oriente vers le bas (repere SVG).
|
||||
"""
|
||||
|
||||
import math
|
||||
import random
|
||||
|
||||
from skull_drawing import BODY_D, INK_D
|
||||
|
||||
|
||||
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)
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Le crane
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
def parse_loops(d):
|
||||
"""Donnees `d` en commandes absolues M, C, Z -> boucles de Bezier.
|
||||
|
||||
Ne lit que la forme produite par docs/extraire_crane.py (et par
|
||||
loops_to_d) : un sous-chemin par boucle, uniquement des cubiques.
|
||||
"""
|
||||
loops, loop, start, current = [], None, None, None
|
||||
tokens = d.replace(",", " ").split()
|
||||
i = 0
|
||||
while i < len(tokens):
|
||||
command = tokens[i]
|
||||
if command == "M":
|
||||
start = current = (float(tokens[i + 1]), float(tokens[i + 2]))
|
||||
loop = []
|
||||
i += 3
|
||||
elif command == "C":
|
||||
values = [float(v) for v in tokens[i + 1:i + 7]]
|
||||
c1, c2, p3 = tuple(values[0:2]), tuple(values[2:4]), tuple(values[4:6])
|
||||
loop.append((current, c1, c2, p3))
|
||||
current = p3
|
||||
i += 7
|
||||
elif command == "Z":
|
||||
if current != start:
|
||||
loop.append((current, current, start, start))
|
||||
loops.append(loop)
|
||||
current = start
|
||||
i += 1
|
||||
else:
|
||||
raise ValueError("commande non geree : {}".format(command))
|
||||
return loops
|
||||
|
||||
|
||||
_GEOMETRY = None
|
||||
|
||||
|
||||
def skull_geometry():
|
||||
"""Le crane dans son repere unite : (silhouette, encre).
|
||||
|
||||
Dessin de doc/dessin.svg, cornes retirees (donnees de skull_drawing.py,
|
||||
regenerees par docs/extraire_crane.py). `silhouette` est le contour
|
||||
exterieur, a remplir de la couleur de l'os pour cacher les cranes du
|
||||
dessous ; `encre` est le trait et les ombres, un seul chemin a remplir
|
||||
en regle non nulle (les trous blancs tournent en sens inverse).
|
||||
"""
|
||||
global _GEOMETRY
|
||||
if _GEOMETRY is None:
|
||||
_GEOMETRY = (parse_loops(BODY_D), parse_loops(INK_D))
|
||||
return _GEOMETRY
|
||||
|
||||
|
||||
def placement_matrix(x, y, size, angle=0.0, mirror=False):
|
||||
"""Matrice affine (a, b, c, d, e, f) du repere unite vers le document.
|
||||
|
||||
Ordre : miroir horizontal, mise a l'echelle `size`, rotation `angle`
|
||||
(degres, sens horaire a l'ecran comme dans Inkscape), translation.
|
||||
"""
|
||||
rad = math.radians(angle)
|
||||
cos_a, sin_a = math.cos(rad) * size, math.sin(rad) * size
|
||||
sx = -1.0 if mirror else 1.0
|
||||
return (cos_a * sx, sin_a * sx, -sin_a, cos_a, x, y)
|
||||
|
||||
|
||||
def apply_matrix(matrix, point):
|
||||
a, b, c, d, e, f = matrix
|
||||
return (a * point[0] + c * point[1] + e, b * point[0] + d * point[1] + f)
|
||||
|
||||
|
||||
def loops_to_d(loops, matrix=(1, 0, 0, 1, 0, 0), precision=3):
|
||||
"""Donnees `d` (M, C, Z absolus) de boucles de Bezier transformees.
|
||||
|
||||
Une transformation affine laisse une courbe de Bezier de meme forme :
|
||||
transformer les points de controle suffit, le chemin produit n'a pas
|
||||
besoin d'attribut `transform`.
|
||||
"""
|
||||
fmt = "{:.%df},{:.%df}" % (precision, precision)
|
||||
parts = []
|
||||
for loop in loops:
|
||||
start = apply_matrix(matrix, loop[0][0])
|
||||
parts.append("M " + fmt.format(*start))
|
||||
for _p0, c1, c2, p3 in loop:
|
||||
parts.append("C " + " ".join(fmt.format(*apply_matrix(matrix, p))
|
||||
for p in (c1, c2, p3)))
|
||||
parts.append("Z")
|
||||
return " ".join(parts)
|
||||
|
||||
|
||||
def skull_paths(placement, precision=3):
|
||||
"""(d de la silhouette, d de l'encre) d'un crane place."""
|
||||
matrix = placement_matrix(*placement)
|
||||
return tuple(loops_to_d(loops, matrix, precision) for loops in skull_geometry())
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Region a remplir
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
def rings_bbox(rings):
|
||||
xs = [x for ring in rings for x, _y in ring]
|
||||
ys = [y for ring in rings for _x, y in ring]
|
||||
if not xs:
|
||||
return None
|
||||
return min(xs), min(ys), max(xs), max(ys)
|
||||
|
||||
|
||||
def point_in_rings(point, rings):
|
||||
"""Point dans la region (regle pair-impair, les trous sont exclus)."""
|
||||
x, y = point
|
||||
inside = False
|
||||
for ring in rings:
|
||||
n = len(ring)
|
||||
for i in range(n):
|
||||
x1, y1 = ring[i]
|
||||
x2, y2 = ring[(i + 1) % n]
|
||||
if (y1 > y) != (y2 > y):
|
||||
if x < x1 + (y - y1) * (x2 - x1) / (y2 - y1):
|
||||
inside = not inside
|
||||
return inside
|
||||
|
||||
|
||||
def distance_to_rings(point, rings):
|
||||
"""Distance d'un point au bord de la region."""
|
||||
px, py = point
|
||||
best = float("inf")
|
||||
for ring in rings:
|
||||
n = len(ring)
|
||||
for i in range(n):
|
||||
x1, y1 = ring[i]
|
||||
x2, y2 = ring[(i + 1) % n]
|
||||
dx, dy = x2 - x1, y2 - y1
|
||||
length2 = dx * dx + dy * dy
|
||||
t = 0.0 if not length2 else max(0.0, min(1.0, ((px - x1) * dx + (py - y1) * dy) / length2))
|
||||
best = min(best, math.hypot(px - x1 - t * dx, py - y1 - t * dy))
|
||||
return best
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Geometrie visible
|
||||
#
|
||||
# Destination : la gravure laser. La machine grave tout trait present dans
|
||||
# le fichier, meme cache sous un autre objet ou rendu invisible par un
|
||||
# masque. On ne produit donc que l'encre reellement visible :
|
||||
# - pour chaque crane, son encre, limitee a la forme, moins les silhouettes
|
||||
# de tous les cranes poses au-dessus de lui ;
|
||||
# - les interstices : la forme moins l'union de toutes les silhouettes.
|
||||
# Les silhouettes elles-memes (le blanc de l'os) ne sont pas ecrites.
|
||||
#
|
||||
# Les calculs se font sur des polygones (courbes aplaties) avec le moteur
|
||||
# booleen de boolean_ops. L'encre se lit en regle pair-impair (equivalente,
|
||||
# pour ce dessin, a sa regle non nulle : ses trous tournent en sens inverse
|
||||
# et ne se chevauchent pas) ; les silhouettes, toutes remises dans le meme
|
||||
# sens, en regle non nulle, ce qui revient a leur union.
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
IDENTITY = (1.0, 0.0, 0.0, 1.0, 0.0, 0.0)
|
||||
|
||||
|
||||
def _bezier_point(q, t):
|
||||
s = 1.0 - t
|
||||
a, b, c, d = s * s * s, 3 * s * s * t, 3 * s * t * t, t * t * t
|
||||
return (a * q[0][0] + b * q[1][0] + c * q[2][0] + d * q[3][0],
|
||||
a * q[0][1] + b * q[1][1] + c * q[2][1] + d * q[3][1])
|
||||
|
||||
|
||||
def flatten_loops(loops, matrix=IDENTITY, step=0.01):
|
||||
"""Boucles de Bezier transformees -> anneaux (polygones fermes).
|
||||
|
||||
Chaque courbe est decoupee en morceaux d'au plus `step` environ (longueur
|
||||
du polygone de controle), 24 au plus.
|
||||
"""
|
||||
rings = []
|
||||
for loop in loops:
|
||||
ring = []
|
||||
for segment in loop:
|
||||
q = [apply_matrix(matrix, p) for p in segment]
|
||||
length = sum(math.hypot(b[0] - a[0], b[1] - a[1]) for a, b in zip(q, q[1:]))
|
||||
count = max(1, min(24, int(math.ceil(length / step))))
|
||||
ring.extend(_bezier_point(q, k / count) for k in range(count))
|
||||
if len(ring) >= 3:
|
||||
rings.append(ring)
|
||||
return rings
|
||||
|
||||
|
||||
def simplify_ring(ring, tolerance):
|
||||
"""Anneau simplifie (Douglas-Peucker) : ecart au trace d'origine <= tolerance."""
|
||||
n = len(ring)
|
||||
if n < 4:
|
||||
return ring
|
||||
# On coupe l'anneau en deux au point le plus eloigne du premier.
|
||||
far = max(range(n), key=lambda i: (ring[i][0] - ring[0][0]) ** 2 + (ring[i][1] - ring[0][1]) ** 2)
|
||||
keep = [False] * (n + 1)
|
||||
keep[0] = keep[far] = keep[n] = True
|
||||
points = ring + [ring[0]]
|
||||
stack = [(0, far), (far, n)]
|
||||
while stack:
|
||||
i, j = stack.pop()
|
||||
a, b = points[i], points[j]
|
||||
dx, dy = b[0] - a[0], b[1] - a[1]
|
||||
norm = math.hypot(dx, dy)
|
||||
best, index = tolerance, None
|
||||
for k in range(i + 1, j):
|
||||
p = points[k]
|
||||
if norm:
|
||||
dist = abs(dx * (p[1] - a[1]) - dy * (p[0] - a[0])) / norm
|
||||
else:
|
||||
dist = math.hypot(p[0] - a[0], p[1] - a[1])
|
||||
if dist > best:
|
||||
best, index = dist, k
|
||||
if index is not None:
|
||||
keep[index] = True
|
||||
stack.append((i, index))
|
||||
stack.append((index, j))
|
||||
result = [points[k] for k in range(n) if keep[k]]
|
||||
return result if len(result) >= 3 else ring
|
||||
|
||||
|
||||
def rings_to_d(rings, precision=2):
|
||||
"""Donnees `d` compactes d'anneaux fermes : M absolu, puis l relatifs.
|
||||
|
||||
Les ecarts sont pris entre points deja arrondis : ils ne cumulent pas
|
||||
d'erreur. Les points confondus apres arrondi sont omis.
|
||||
"""
|
||||
scale = 10 ** precision
|
||||
|
||||
def num(v):
|
||||
text = "{:.{}f}".format(v / scale, precision).rstrip("0").rstrip(".")
|
||||
return "0" if text in ("", "-0") else text
|
||||
|
||||
parts = []
|
||||
for ring in rings:
|
||||
pts = [(int(round(x * scale)), int(round(y * scale))) for x, y in ring]
|
||||
kept = [pts[0]]
|
||||
for p in pts[1:]:
|
||||
if p != kept[-1]:
|
||||
kept.append(p)
|
||||
if len(kept) < 3:
|
||||
continue
|
||||
parts.append("M{},{}l".format(num(kept[0][0]), num(kept[0][1])))
|
||||
parts.append(" ".join("{},{}".format(num(b[0] - a[0]), num(b[1] - a[1]))
|
||||
for a, b in zip(kept, kept[1:])))
|
||||
parts.append("z")
|
||||
return "".join(parts)
|
||||
|
||||
|
||||
def ring_area(ring):
|
||||
"""Aire signee (positive dans le sens horaire a l'ecran, y vers le bas)."""
|
||||
return 0.5 * sum(a[0] * b[1] - b[0] * a[1] for a, b in zip(ring, ring[1:] + ring[:1]))
|
||||
|
||||
|
||||
def _ring_bbox(ring):
|
||||
xs = [p[0] for p in ring]
|
||||
ys = [p[1] for p in ring]
|
||||
return min(xs), min(ys), max(xs), max(ys)
|
||||
|
||||
|
||||
def _boxes_overlap(a, b):
|
||||
return a[0] <= b[2] and b[0] <= a[2] and a[1] <= b[3] and b[1] <= a[3]
|
||||
|
||||
|
||||
class _EdgeGrid(object):
|
||||
"""Cases traversees par les cotes d'anneaux : dit vite si une boite
|
||||
est loin de tout bord."""
|
||||
|
||||
def __init__(self, rings):
|
||||
edges = [(r[i], r[(i + 1) % len(r)]) for r in rings for i in range(len(r))]
|
||||
total = sum(math.hypot(b[0] - a[0], b[1] - a[1]) for a, b in edges)
|
||||
self.cell = max(4.0 * total / max(len(edges), 1), 1e-9)
|
||||
self.cells = set()
|
||||
c = self.cell
|
||||
for a, b in edges:
|
||||
for i in range(int(math.floor(min(a[0], b[0]) / c)), int(math.floor(max(a[0], b[0]) / c)) + 1):
|
||||
for j in range(int(math.floor(min(a[1], b[1]) / c)), int(math.floor(max(a[1], b[1]) / c)) + 1):
|
||||
self.cells.add((i, j))
|
||||
|
||||
def touches(self, box):
|
||||
c = self.cell
|
||||
for i in range(int(math.floor(box[0] / c)), int(math.floor(box[2] / c)) + 1):
|
||||
for j in range(int(math.floor(box[1] / c)), int(math.floor(box[3] / c)) + 1):
|
||||
if (i, j) in self.cells:
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
class Region(object):
|
||||
"""Region a remplir : anneaux en regle pair-impair."""
|
||||
|
||||
def __init__(self, rings):
|
||||
self.rings = [ring for ring in rings if len(ring) >= 3]
|
||||
self.box = rings_bbox(self.rings)
|
||||
self.grid = _EdgeGrid(self.rings)
|
||||
|
||||
def contains(self, point):
|
||||
return point_in_rings(point, self.rings)
|
||||
|
||||
|
||||
|
||||
_RADIUS = None
|
||||
|
||||
|
||||
def skull_radius():
|
||||
"""Rayon du disque contenant le crane, pour une hauteur 1."""
|
||||
global _RADIUS
|
||||
if _RADIUS is None:
|
||||
body, _ink = skull_geometry()
|
||||
_RADIUS = max(math.hypot(*p) for seg in body[0] for p in seg)
|
||||
return _RADIUS
|
||||
|
||||
|
||||
_FLAT = {}
|
||||
|
||||
|
||||
def _flat_skull(step):
|
||||
"""Crane aplati et simplifie une fois pour toutes, dans son repere unite.
|
||||
|
||||
Renvoie (silhouette, anneaux d'encre). La silhouette est remise dans le
|
||||
sens horaire, pour que l'union des silhouettes en regle non nulle ne
|
||||
fasse pas de trou la ou deux cranes de sens opposes se chevauchent.
|
||||
"""
|
||||
if step not in _FLAT:
|
||||
body, ink = skull_geometry()
|
||||
# Ecart tolere : 0,25 % de la hauteur (moins d'un dixieme de
|
||||
# millimetre sur un crane de 30 mm, sous la finesse d'un laser).
|
||||
tolerance = 0.25 * step
|
||||
outline = simplify_ring(flatten_loops(body, step=step)[0], tolerance)
|
||||
if ring_area(outline) < 0:
|
||||
outline = outline[::-1]
|
||||
rings = [simplify_ring(ring, tolerance) for ring in flatten_loops(ink, step=step)]
|
||||
_FLAT[step] = (outline, rings)
|
||||
return _FLAT[step]
|
||||
|
||||
|
||||
def _move(ring, matrix):
|
||||
a, b, c, d, e, f = matrix
|
||||
return [(a * x + c * y + e, b * x + d * y + f) for x, y in ring]
|
||||
|
||||
|
||||
class _Placed(object):
|
||||
"""Crane place : silhouette et encre en coordonnees du document."""
|
||||
|
||||
def __init__(self, placement, step):
|
||||
outline, rings = _flat_skull(step)
|
||||
matrix = placement_matrix(*placement)
|
||||
self.placement = placement
|
||||
self.body = _move(outline, matrix)
|
||||
if placement[4]:
|
||||
# Le miroir inverse le sens de parcours : on le retablit.
|
||||
self.body.reverse()
|
||||
self.box = _ring_bbox(self.body)
|
||||
self.ink = [_move(ring, matrix) for ring in rings]
|
||||
|
||||
|
||||
def visible_skulls(placements, region, step=0.01, progress=None):
|
||||
"""Encre visible de chaque crane : [(placement, anneaux pair-impair)].
|
||||
|
||||
`placements` est dans l'ordre de dessin (du dessous vers le dessus).
|
||||
Un crane entierement cache n'apparait pas. `progress(k, total)`, s'il est
|
||||
donne, est appele apres chaque crane.
|
||||
"""
|
||||
from boolean_ops import boolean
|
||||
|
||||
skulls = [_Placed(p, step) for p in placements]
|
||||
# Index des silhouettes par cases, pour trouver vite celles du dessus.
|
||||
cell = max((max(s.box[2] - s.box[0], s.box[3] - s.box[1]) for s in skulls), default=1.0)
|
||||
grid = {}
|
||||
for k, s in enumerate(skulls):
|
||||
for i in range(int(math.floor(s.box[0] / cell)), int(math.floor(s.box[2] / cell)) + 1):
|
||||
for j in range(int(math.floor(s.box[1] / cell)), int(math.floor(s.box[3] / cell)) + 1):
|
||||
grid.setdefault((i, j), []).append(k)
|
||||
|
||||
result = []
|
||||
for k, skull in enumerate(skulls):
|
||||
above = set()
|
||||
box = skull.box
|
||||
for i in range(int(math.floor(box[0] / cell)), int(math.floor(box[2] / cell)) + 1):
|
||||
for j in range(int(math.floor(box[1] / cell)), int(math.floor(box[3] / cell)) + 1):
|
||||
for other in grid.get((i, j), ()):
|
||||
if other > k and _boxes_overlap(box, skulls[other].box):
|
||||
above.add(other)
|
||||
covers = [skulls[o] for o in sorted(above)]
|
||||
|
||||
border = region.grid.touches(box)
|
||||
if not border and not region.contains(skull.body[0]):
|
||||
# Loin du bord et dehors : entierement hors de la forme.
|
||||
if progress:
|
||||
progress(k + 1, len(skulls))
|
||||
continue
|
||||
if not covers and not border:
|
||||
# Ni recouvert ni au bord : toute l'encre est visible.
|
||||
result.append((skull.placement, list(skull.ink)))
|
||||
if progress:
|
||||
progress(k + 1, len(skulls))
|
||||
continue
|
||||
|
||||
# Partie visible de la silhouette : petit polygone, vite calcule.
|
||||
# Vide, le crane est entierement cache.
|
||||
sets = [([skull.body], "nonzero"), ([c.body for c in covers], "nonzero")]
|
||||
if border:
|
||||
sets.append((region.rings, "evenodd"))
|
||||
shown = boolean(sets, lambda inside: inside[0] and not inside[1] and inside[2])
|
||||
else:
|
||||
shown = boolean(sets, lambda inside: inside[0] and not inside[1])
|
||||
kept = []
|
||||
if shown:
|
||||
# Les anneaux d'encre loin du bord de cette partie visible sont
|
||||
# gardes ou ecartes d'un coup ; les autres sont intersectes avec
|
||||
# elle (l'intersection se distribue sur le OU exclusif).
|
||||
edges = _EdgeGrid(shown)
|
||||
work = []
|
||||
for ring in skull.ink:
|
||||
ring_box = _ring_bbox(ring)
|
||||
if edges.touches(ring_box):
|
||||
work.append(ring)
|
||||
elif point_in_rings(ring[0], shown):
|
||||
kept.append(ring)
|
||||
if work:
|
||||
kept.extend(boolean([(work, "evenodd"), (shown, "evenodd")],
|
||||
lambda inside: inside[0] and inside[1]))
|
||||
if kept:
|
||||
result.append((skull.placement, kept))
|
||||
if progress:
|
||||
progress(k + 1, len(skulls))
|
||||
return result
|
||||
|
||||
|
||||
def visible_gaps(placements, region, step=0.01):
|
||||
"""Interstices : la forme moins l'union des silhouettes des cranes."""
|
||||
from boolean_ops import boolean
|
||||
bodies = [_Placed(p, step).body for p in placements]
|
||||
return boolean([(region.rings, "evenodd"), (bodies, "nonzero")],
|
||||
lambda inside: inside[0] and not inside[1])
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Placement
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
def random_size(rng, size_min, size_max, exponent=3.0):
|
||||
"""Taille tiree selon une loi de puissance tronquee sur [min, max].
|
||||
|
||||
Densite proportionnelle a s^-exponent : beaucoup de petits cranes, peu
|
||||
de grands ; avec 3, chaque octave de tailles couvre une surface
|
||||
comparable, comme dans le motif de reference.
|
||||
"""
|
||||
if size_max <= size_min:
|
||||
return size_min
|
||||
k = 1.0 - exponent
|
||||
lo, hi = size_min ** k, size_max ** k
|
||||
return (lo + rng.random() * (hi - lo)) ** (1.0 / k)
|
||||
|
||||
|
||||
def estimate_count(rings, size_min, spacing):
|
||||
"""Nombre de positions candidates (pour refuser un calcul demesure)."""
|
||||
box = rings_bbox(rings)
|
||||
if box is None or size_min <= 0 or spacing <= 0:
|
||||
return 0
|
||||
step = size_min * spacing
|
||||
return int(((box[2] - box[0]) / step + 2) * ((box[3] - box[1]) / step + 2))
|
||||
|
||||
|
||||
def skull_placements(rings, size_min, size_max, spacing=0.7, max_rotation=30.0,
|
||||
mirror=True, seed=1, origin=(0.0, 0.0)):
|
||||
"""Positions des cranes couvrant la region.
|
||||
|
||||
Une grille, de pas `spacing` x taille minimale, decalee une ligne sur
|
||||
deux et secouee au hasard, donne une position par case : la couverture
|
||||
est assuree par les petits cranes. Chaque position recoit une taille
|
||||
(loi de puissance), un angle dans [-max_rotation, max_rotation] et un
|
||||
miroir aleatoire. On ne garde que les cranes qui touchent la region.
|
||||
|
||||
`origin` cale la grille (origine du document par defaut) : deux formes
|
||||
voisines remplies avec la meme graine partagent les memes positions.
|
||||
|
||||
Renvoie des tuples (x, y, taille, angle, miroir), du plus petit au plus
|
||||
grand : dessines dans cet ordre, les grands cranes passent devant.
|
||||
"""
|
||||
box = rings_bbox(rings)
|
||||
if box is None or size_min <= 0:
|
||||
return []
|
||||
size_max = max(size_max, size_min)
|
||||
step = size_min * spacing
|
||||
if step <= 0:
|
||||
return []
|
||||
row_h = step * 0.866
|
||||
margin = size_max * skull_radius()
|
||||
x0, y0, x1, y1 = box[0] - margin, box[1] - margin, box[2] + margin, box[3] + margin
|
||||
|
||||
j_start = int(math.floor((y0 - origin[1]) / row_h))
|
||||
j_end = int(math.ceil((y1 - origin[1]) / row_h))
|
||||
i_start = int(math.floor((x0 - origin[0]) / step)) - 1
|
||||
i_end = int(math.ceil((x1 - origin[0]) / step)) + 1
|
||||
|
||||
result = []
|
||||
for j in range(j_start, j_end + 1):
|
||||
for i in range(i_start, i_end + 1):
|
||||
# Une graine par case : le tirage ne depend pas de l'etendue de la
|
||||
# region, donc pas de la forme remplie.
|
||||
rng = random.Random((seed * 73856093) ^ (i * 19349663) ^ (j * 83492791))
|
||||
x = origin[0] + (i + 0.5 * (j % 2) + (rng.random() - 0.5) * 0.6) * step
|
||||
y = origin[1] + (j + (rng.random() - 0.5) * 0.6) * row_h
|
||||
size = random_size(rng, size_min, size_max)
|
||||
angle = (rng.random() * 2.0 - 1.0) * max_rotation
|
||||
flip = mirror and rng.random() < 0.5
|
||||
if not (x0 <= x <= x1 and y0 <= y <= y1):
|
||||
continue
|
||||
# Un crane tient dans un disque de rayon skull_radius() x taille.
|
||||
if not point_in_rings((x, y), rings) and \
|
||||
distance_to_rings((x, y), rings) > skull_radius() * size:
|
||||
continue
|
||||
result.append((x, y, size, angle, flip))
|
||||
result.sort(key=lambda p: p[2])
|
||||
return result
|
||||
Reference in new issue
Block a user