#!/usr/bin/env python3 # coding=utf-8 """ Genere le schema explicatif des parametres de l'extension. python docs/schema_parametres.py # les deux versions python docs/schema_parametres.py fr # docs/parametres.svg + .png (README) python docs/schema_parametres.py en # docs/parameters_en.svg # + images/parameters_en.png (onglet # « Help » de la boite de dialogue) Les formes sont calculees par dog_bandana_core (memes fonctions que l'extension), le schema reste donc fidele au resultat reel. L'export PNG passe par inkscape.com, qui attend la fin de l'export (contrairement au raccourci Chocolatey « inkscape »). """ import math import os import subprocess import sys HERE = os.path.dirname(os.path.abspath(__file__)) ROOT = os.path.dirname(HERE) sys.path.insert(0, ROOT) import dog_bandana_core # noqa: E402 W, H = 1400, 1280 # 4 panneaux de 700 x 640 INK = "#343a40" # element principal GHOST = "#dde1e5" # elements secondaires / voisins DIM = "#d9480f" # cotes DIM2 = "#1971c2" # cotes secondaires EDGE = "#212529" # contour des formes FONT = "font-family:Arial,Helvetica,sans-serif" INKSCAPE = [r"C:\Program Files\Inkscape\bin\inkscape.com", "/usr/bin/inkscape", "/Applications/Inkscape.app/Contents/MacOS/inkscape"] # Version par langue : textes, fichiers produits, largeur du PNG et agrandissement # des textes (la version anglaise est affichee reduite dans la boite de dialogue : # 900 px de large, textes x 1.25 pour rester lisibles). VERSIONS = { "fr": { "svg": os.path.join(HERE, "parametres.svg"), "png": os.path.join(HERE, "parametres.png"), "png_width": 1400, "font_scale": 1.0, "text": { "title1": "Période et épaisseur du trait", "period": "Période", "width": "Épaisseur", "note1": ["Période : d'axe en axe de deux lignes voisines.", "Épaisseur : celle du trait, à bouts ronds ; la moitié", "de la période donne autant de noir que de blanc."], "title2": "Itérations", "default": "{} (défaut)", "iterations": "plus d'itérations", "note2": ["Peu d'itérations : points et lignes courtes ; beaucoup :", "longues lignes régulières. La graine aléatoire change", "le dessin en gardant le même aspect."], "title3": "Au bord de la forme", "cut": "Couper les lignes", "follow": "Longer le bord", "note3": ["Couper : le motif est découpé comme un tissu.", "Longer : les lignes s'arrêtent avant le bord et le suivent."], "title4": "Marge", "margin": "Marge", "note4": ["Espace libre entre le bord de la forme et les traits", "(bouts ronds compris). À 0, les traits touchent le bord."], }, }, "en": { "svg": os.path.join(HERE, "parameters_en.svg"), "png": os.path.join(ROOT, "images", "parameters_en.png"), "png_width": 900, "font_scale": 1.25, "text": { "title1": "Period and line width", "period": "Period", "width": "Width", "note1": ["Period: center to center of two neighbouring lines.", "Width: round-capped stroke; half the period", "gives as much black as white."], "title2": "Iterations", "default": "{} (default)", "iterations": "more iterations", "note2": ["Few iterations: dots and short lines; many:", "long regular lines. The random seed changes", "the drawing, not its look."], "title3": "At the shape edge", "cut": "Cut the lines", "follow": "Follow the edge", "note3": ["Cut: the pattern is cut like fabric.", "Follow: lines stop before the edge, run along it."], "title4": "Margin", "margin": "Margin", "note4": ["Free space between the shape edge and the", "strokes (round tips included). 0: strokes touch it."], }, }, } def _unit(angle): """Vecteur unitaire, angle en degres, sens anti-horaire a l'ecran (y vers le bas).""" a = math.radians(angle) return math.cos(a), -math.sin(a) out = [] T = {} FS = 1.0 def fmt(v): return "{:.2f}".format(v).rstrip("0").rstrip(".") def pts(polyline): return " ".join("{},{}".format(fmt(x), fmt(y)) for x, y in polyline) def polyline(points, color, width, extra=""): out.append(''.format(pts(points), color, fmt(width), extra)) def motif(polylines, color, width): for pl in polylines: polyline(pl, color, width) def text(x, y, s, size=17, color=INK, anchor="start", weight="normal", halo=True): style = "{};font-size:{}px;font-weight:{};fill:{}".format( FONT, fmt(size * FS), weight, color) if halo: style += ";paint-order:stroke;stroke:#ffffff;stroke-width:5px;stroke-linejoin:round" out.append('{}'.format( fmt(x), fmt(y), anchor, style, s)) def note(x, y, lines): """Legende de bas de panneau, derniere ligne sur la ligne de base `y`.""" step = 22 * FS for k, line in enumerate(lines): text(x, y - (len(lines) - 1 - k) * step, line, size=16, halo=False) def arrow_head(tip, direction, color, size=9): ux, uy = direction nx, ny = -uy, ux base = (tip[0] - size * ux, tip[1] - size * uy) out.append(''.format(pts([ tip, (base[0] + 0.45 * size * nx, base[1] + 0.45 * size * ny), (base[0] - 0.45 * size * nx, base[1] - 0.45 * size * ny)]), color)) def dimension(p, q, offset, label, color=DIM, label_pos=0.5, label_shift=18, size=17): """Cote entre p et q, decalee de `offset` perpendiculairement.""" dx, dy = q[0] - p[0], q[1] - p[1] length = math.hypot(dx, dy) ux, uy = dx / length, dy / length nx, ny = -uy, ux a = (p[0] + offset * nx, p[1] + offset * ny) b = (q[0] + offset * nx, q[1] + offset * ny) sign = 1 if offset >= 0 else -1 for base, end in ((p, a), (q, b)): polyline([(base[0] + sign * 4 * nx, base[1] + sign * 4 * ny), (end[0] + sign * 6 * nx, end[1] + sign * 6 * ny)], color, 1, 'stroke-dasharray="3,3"') polyline([a, b], color, 1.6) arrow_head(a, (-ux, -uy), color) arrow_head(b, (ux, uy), color) lx = a[0] + label_pos * (b[0] - a[0]) + sign * label_shift * FS * nx ly = a[1] + label_pos * (b[1] - a[1]) + sign * label_shift * FS * ny + 6 * FS text(lx, ly, label, size=size, color=color, anchor="middle", weight="bold") def arc(center, radius, a0, a1, color, label=None, label_radius=None, size=16): """Arc de a0 a a1 degres (sens anti-horaire a l'ecran), fleche au bout.""" steps = 40 points = [] for k in range(steps + 1): ux, uy = _unit(a0 + (a1 - a0) * k / steps) points.append((center[0] + radius * ux, center[1] + radius * uy)) polyline(points[:-2], color, 1.6) last, before = points[-1], points[-3] d = math.hypot(last[0] - before[0], last[1] - before[1]) arrow_head(last, ((last[0] - before[0]) / d, (last[1] - before[1]) / d), color, 8) if label: ux, uy = _unit((a0 + a1) / 2) r = label_radius or radius + 24 text(center[0] + r * ux, center[1] + r * uy + 6 * FS, label, size=size, color=color, anchor="middle", weight="bold") def circle_ring(cx, cy, r, n=180): return [(cx + r * math.cos(2 * math.pi * k / n), cy + r * math.sin(2 * math.pi * k / n)) for k in range(n)] def panel_title(x, y, number, title): text(x, y, "{} {}".format(number, title), size=22, weight="bold", halo=False) # -------------------------------------------------------------------------- # Panneaux : un par parametre (ou groupe de parametres), numerotes 1 a 4. # Motifs calcules par dog_bandana_core.turing_pattern, comme dans l'extension. # -------------------------------------------------------------------------- def strokes(polylines, color, width): """Traits a bouts ronds, comme ceux produits par l'extension.""" for pl in polylines: out.append(''.format( pts(pl), color, fmt(width))) def outline(rings, color=EDGE, width=2, extra=""): d = " ".join("M " + " L ".join("{},{}".format(fmt(x), fmt(y)) for x, y in ring) + " Z" for ring in rings) out.append(''.format( d, color, fmt(width), extra)) def rect_ring(x0, y0, x1, y1): return [(x0, y0), (x1, y0), (x1, y1), (x0, y1)] def crossings(polylines, x): """Intersections des polylignes avec la verticale x : (y, pente, numero).""" found = [] for index, pl in enumerate(polylines): for (ax, ay), (bx, by) in zip(pl, pl[1:]): if (ax <= x) != (bx <= x): t = (x - ax) / (bx - ax) found.append((ay + t * (by - ay), abs((by - ay) / (bx - ax)), index)) return sorted(found) def panel_1(): """Periode et epaisseur : cotes sur deux lignes voisines bien paralleles.""" period, width = 64, 28 region = rect_ring(60, 90, 640, 530) def near(cuts, index, y): return any(i == index and abs(cy - y) < 6 for cy, _s, i in cuts) # Cherche deux lignes voisines presque horizontales sur une bonne longueur # (verticales x - 70, x, x + 70), espacees d'environ une periode : les # cotes tiennent dans l'espace blanc entre elles. best = None for seed in range(1, 9): lines = dog_bandana_core.turing_pattern([region], period, width, seed=seed, steps=150) for x in range(250, 480, 6): cuts = crossings(lines, x) left, right = crossings(lines, x - 70), crossings(lines, x + 70) for (y1, s1, i1), (y2, s2, i2) in zip(cuts, cuts[1:]): if not (170 < y1 < 400 and i1 != i2): continue if not all(near(c, i, y) for c in (left, right) for i, y in ((i1, y1), (i2, y2))): continue score = abs(y2 - y1 - period) + 30 * (s1 + s2) + abs(x - 360) / 20 if best is None or score < best[0]: best = (score, lines, x, y1, y2, i1, i2) _score, lines, x, y1, y2, i1, i2 = best panel_title(30, 50, 1, T["title1"]) strokes([pl for k, pl in enumerate(lines) if k not in (i1, i2)], GHOST, width) strokes([lines[i1], lines[i2]], INK, width) outline([region], EDGE, 2) # Periode : d'axe en axe ; epaisseur : bord a bord d'une meme ligne. for y in (y1, y2): polyline([(x - 25, y), (x + 25, y)], DIM, 1.4, 'stroke-dasharray="4,3"') dimension((x, y1), (x, y2), 0, "") text(x + 12, (y1 + y2) / 2 + 6, T["period"], color=DIM, weight="bold") # Epaisseur sur la ligne du bas, legende dessous (zone claire). xw = x - 70 dimension((xw, y2 - width / 2), (xw, y2 + width / 2), 0, "", color=DIM2) text(xw, y2 + width / 2 + 28, T["width"], color=DIM2, anchor="middle", weight="bold") note(30, 610, T["note1"]) def panel_2(): """Iterations : meme graine, trois durees d'evolution.""" ox = 700 panel_title(ox + 30, 50, 2, T["title2"]) size, gap = 190, 25 for k, steps in enumerate((20, 60, 300)): x0 = ox + 30 + k * (size + gap) region = rect_ring(x0, 130, x0 + size, 130 + size) lines = dog_bandana_core.turing_pattern([region], 20, 9, seed=5, steps=steps) strokes(lines, INK, 9) outline([region], EDGE, 2) label = T["default"].format(steps) if steps == 60 else str(steps) text(x0 + size / 2, 130 + size + 40, label, size=20, color=DIM, anchor="middle", weight="bold") arrow_y = 420 polyline([(ox + 60, arrow_y), (ox + 630, arrow_y)], DIM2, 1.6) arrow_head((ox + 640, arrow_y), (1, 0), DIM2) text(ox + 345, arrow_y + 30, T["iterations"], color=DIM2, anchor="middle", weight="bold") note(ox + 30, 610, T["note2"]) def panel_3(): """Bord de la forme : motif coupe (tissu decoupe) ou qui longe le bord.""" oy = 640 panel_title(30, oy + 50, 3, T["title3"]) for k, edge in enumerate(("cut", "follow")): cx, cy, r = 190 + k * 320, oy + 270, 140 ring = circle_ring(cx, cy, r) lines = dog_bandana_core.turing_pattern([ring], 24, 11, seed=2, edge=edge) strokes(lines, INK, 11) outline([ring], EDGE, 2) text(cx, cy + r + 40, T[edge], size=19, color=DIM, anchor="middle", weight="bold") note(30, oy + 610, T["note3"]) def panel_4(): """Marge : espace libre entre le bord et les traits.""" ox, oy = 700, 640 panel_title(ox + 30, oy + 50, 4, T["title4"]) margin, period, width = 40, 30, 14 x0, y0, x1, y1 = ox + 70, oy + 90, ox + 630, oy + 470 lines = dog_bandana_core.turing_pattern([rect_ring(x0, y0, x1, y1)], period, width, margin=margin, seed=6) strokes(lines, INK, width) outline([rect_ring(x0, y0, x1, y1)], EDGE, 2.5) outline([rect_ring(x0 + margin, y0 + margin, x1 - margin, y1 - margin)], DIM2, 1.5, 'stroke-dasharray="6,4"') dimension((x0, y1 + 22), (x0 + margin, y1 + 22), 0, "", color=DIM) text(x0 + margin + 12, y1 + 29, T["margin"], color=DIM, weight="bold") note(ox + 30, oy + 610, T["note4"]) def export_png(svg_path, png_path, width): exe = next((path for path in INKSCAPE if os.path.exists(path)), None) if exe is None: print("Inkscape introuvable : exporter {} a la main".format(svg_path)) return os.makedirs(os.path.dirname(png_path), exist_ok=True) subprocess.run([exe, svg_path, "--export-type=png", "--export-width={}".format(width), "--export-filename={}".format(png_path)], check=True, stderr=subprocess.DEVNULL) print(png_path) def build(language): global FS version = VERSIONS[language] out.clear() T.clear() T.update(version["text"]) FS = version["font_scale"] out.append(''.format(W, H)) for x1, y1, x2, y2 in ((700, 20, 700, H - 20), (20, 640, W - 20, 640)): out.append(''.format(x1, y1, x2, y2)) panel_1() panel_2() panel_3() panel_4() svg = ('\n' '\n{2}\n\n').format(W, H, "\n".join(out)) with open(version["svg"], "w", encoding="utf-8", newline="\n") as handle: handle.write(svg) print(version["svg"]) export_png(version["svg"], version["png"], version["png_width"]) def main(argv): languages = argv or sorted(VERSIONS) for language in languages: build(language) if __name__ == "__main__": main(sys.argv[1:])