zer0-image-generator 0.6.0 → 0.8.0

data/lib/zer0_image_generator/svg/generators/lowpoly.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require_relative "../../support/py_random"
+
+module Zer0ImageGenerator
+  module Svg
+    module Generators
+      # Faceted low-poly gradient field — port of `tools/svg/examples/lowpoly.py`.
+      #
+      # A jittered triangle grid (interior vertices perturbed, borders pinned so
+      # there are no gaps) painted with a vertical palette gradient, then each
+      # facet is brightened/darkened by smooth value noise so the surface reads
+      # as folded planes catching light, with an off-center radial "sun" glow.
+      # Each facet is stroked in its own fill to close the sub-pixel seams that
+      # float rounding leaves between triangles.
+      #
+      # The committed artwork under `docs/samples/lowpoly-*.svg` was produced by
+      # the Python original, so this port is pinned to byte-identical output:
+      # the sun/jitter draws come off `Support::PyRandom` in the same order,
+      # `math.hypot` is reproduced to the last ULP, and every colour channel is
+      # rounded the way CPython's `round()` rounds.
+      module Lowpoly
+        # vertical gradient stops top -> bottom, then [accent, shadow]
+        PALETTES = {
+          "dusk" => ["#f5a35c", "#e2565b", "#7a3355", "#2b2240", "#ffd27a", "#161227"].freeze,
+          "cyanic" => ["#bfe6e4", "#5bc0be", "#1c7293", "#0b1f3a", "#e8f1f2", "#06101f"].freeze,
+          "moss" => ["#e9edc9", "#a3c9a8", "#3e6b48", "#16241b", "#f2e9c9", "#0c1610"].freeze,
+          "ember" => ["#ffd166", "#f2542d", "#a11d33", "#2a0e1a", "#fff0c2", "#170610"].freeze,
+        }.freeze
+
+        DEFAULT_PALETTE = "dusk"
+
+        W = 1200
+        H = 800
+
+        HALF = Rational(1, 2)
+        private_constant :HALF
+
+        class << self
+          def value_noise(seed)
+            hash = lambda do |ix, iy|
+              n = (ix * 374_761_393) + (iy * 668_265_263) + (seed * 40_503)
+              n = (n ^ (n >> 13)) * 1_274_126_177
+              # `/ 0xFFFF` is true division in Python; fdiv keeps it a Float.
+              ((n ^ (n >> 16)) & 0xFFFF).fdiv(0xFFFF)
+            end
+            smooth = ->(t) { t * t * (3 - (2 * t)) }
+            lambda do |x, y|
+              ix = x.floor
+              iy = y.floor
+              fx = smooth.call(x - ix)
+              fy = smooth.call(y - iy)
+              a = hash.call(ix, iy)
+              b = hash.call(ix + 1, iy)
+              c = hash.call(ix, iy + 1)
+              d = hash.call(ix + 1, iy + 1)
+              ((a * (1 - fx)) + (b * fx)) * (1 - fy) + (((c * (1 - fx)) + (d * fx)) * fy)
+            end
+          end
+
+          # Returns the finished SVG document, newline-terminated.
+          def build(seed, palette, cols = 16, rows = 11)
+            rng = Support::PyRandom.new(seed)
+            noise = value_noise(seed)
+            stops = PALETTES.fetch(palette)
+            grad = stops[0, 4].map { |c| hex(c) }
+            accent = hex(stops[4])
+            shadow = hex(stops[5])
+            cw = W.fdiv(cols)
+            ch = H.fdiv(rows)
+
+            # Sun focus in the upper band, off-center by seed.
+            sx = rng.uniform(0.15, 0.5) * W
+            sy = rng.uniform(0.12, 0.32) * H
+            sun_r = rng.uniform(0.30, 0.42) * H
+
+            pts = {}
+            (0..rows).each do |r|
+              (0..cols).each do |c|
+                x = c * cw
+                y = r * ch
+                if c.positive? && c < cols && r.positive? && r < rows
+                  x += rng.uniform(-0.42, 0.42) * cw
+                  y += rng.uniform(-0.42, 0.42) * ch
+                end
+                pts[[c, r]] = [x, y]
+              end
+            end
+
+            parts = [
+              %(<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 #{W} #{H}" role="img" ) +
+                %(shape-rendering="geometricPrecision">),
+              "<title>Low-poly field, seed #{seed}, palette #{palette}</title>",
+            ]
+
+            facet = lambda do |a, b, c|
+              cx = (a[0] + b[0] + c[0]) / 3
+              cy = (a[1] + b[1] + c[1]) / 3
+              base = grad(grad, cy / H)
+              # value noise -> plane shading; +/- ~14%
+              shade = 0.86 + (0.28 * noise.call(cx / 190, cy / 190))
+              col = base.map { |v| v * shade }
+              # sun glow: blend toward accent within radius; lift shadow tint low
+              dist = hypot(cx - sx, cy - sy)
+              col = lerp(col, accent, ((1 - (dist / sun_r))**2) * 0.8) if dist < sun_r
+              col = lerp(col, shadow, (cy / H - 0.82) / 0.18 * 0.5) if cy > H * 0.82
+              p = "#{fmt(a[0], 1)},#{fmt(a[1], 1)} #{fmt(b[0], 1)},#{fmt(b[1], 1)} " \
+                  "#{fmt(c[0], 1)},#{fmt(c[1], 1)}"
+              rgb = rgb(col)
+              %(<polygon points="#{p}" fill="#{rgb}" stroke="#{rgb}" stroke-width="1"/>)
+            end
+
+            rows.times do |r|
+              cols.times do |c|
+                p00 = pts[[c, r]]
+                p10 = pts[[c + 1, r]]
+                p01 = pts[[c, r + 1]]
+                p11 = pts[[c + 1, r + 1]]
+                # alternate the split diagonal so facets don't all lean one way
+                if (c + r).even?
+                  parts << facet.call(p00, p10, p11)
+                  parts << facet.call(p00, p11, p01)
+                else
+                  parts << facet.call(p00, p10, p01)
+                  parts << facet.call(p10, p11, p01)
+                end
+              end
+            end
+
+            parts << "</svg>"
+            parts.join("\n") + "\n"
+          end
+
+          private
+
+          def hex(c)
+            [1, 3, 5].map { |i| c[i, 2].to_i(16) }
+          end
+
+          def rgb(t)
+            "#" + t.map { |v| format("%02x", [0, [255, round_int(v)].min].max) }.join
+          end
+
+          def lerp(a, b, t)
+            Array.new(3) { |i| a[i] + ((b[i] - a[i]) * t) }
+          end
+
+          def grad(stops, t)
+            t = [0.0, [1.0, t].min].max
+            n = stops.length - 1
+            seg = [(t * n).to_i, n - 1].min
+            lerp(stops[seg], stops[seg + 1], (t * n) - seg)
+          end
+
+          # Python's `round(v)` (no ndigits) -> nearest int, round-half-to-even.
+          def round_int(value)
+            neg = value.negative?
+            scaled = value.abs.to_r
+            whole = scaled.floor
+            remainder = scaled - whole
+            whole += 1 if remainder > HALF || (remainder == HALF && whole.odd?)
+            neg ? -whole : whole
+          end
+
+          # A bit-exact port of CPython 3.8+ `math.hypot` (Hettinger's scaled
+          # 2Sum accumulation). Ruby's `Math.hypot` differs in the last ULP,
+          # which can flip a rounded colour channel and break byte-identity.
+          TWO_POW_27 = 134_217_729.0 # 2**27 + 1, the Veltkamp split constant
+          private_constant :TWO_POW_27
+
+          def two_prod(a, b)
+            prod = a * b
+            ah = (a * TWO_POW_27) - ((a * TWO_POW_27) - a)
+            al = a - ah
+            bh = (b * TWO_POW_27) - ((b * TWO_POW_27) - b)
+            bl = b - bh
+            err = (((ah * bh) - prod) + (ah * bl) + (al * bh)) + (al * bl)
+            [prod, err]
+          end
+
+          def hypot(dx, dy)
+            coords = [dx.abs, dy.abs]
+            max = coords.max
+            return max if max.zero? # avoids 0/0 when both are zero
+
+            _, max_e = Math.frexp(max)
+            scale = Math.ldexp(1.0, -max_e)
+            csum = 1.0
+            frac1 = 0.0
+            frac2 = 0.0
+            coords.each do |c|
+              x = c * scale
+              pr, err = two_prod(x, x)
+              s = csum + pr
+              frac2 += (csum - s) + pr
+              csum = s
+              frac1 += err
+            end
+            h = Math.sqrt((csum - 1.0) + (frac1 + frac2))
+            # one Newton step on the residual, matching CPython's correction
+            pr, err = two_prod(-h, h)
+            s = csum + pr
+            frac2 += (csum - s) + pr
+            csum = s
+            frac1 += err
+            x = (csum - 1.0) + (frac1 + frac2)
+            h += x / (2.0 * h)
+            h / scale
+          end
+
+          # Exact correctly-rounded fixed-point, matching Python's `f"{x:.Nf}"`.
+          def fmt(value, places)
+            negative = value.negative? || (value.zero? && (1.0 / value).negative?)
+            scaled = value.abs.to_r * (10**places)
+            whole = scaled.floor
+            remainder = scaled - whole
+            whole += 1 if remainder > HALF || (remainder == HALF && whole.odd?)
+
+            digits = whole.to_s.rjust(places + 1, "0")
+            text = places.zero? ? digits : "#{digits[0...-places]}.#{digits[-places..]}"
+            negative ? "-#{text}" : text
+          end
+        end
+      end
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  require "fileutils"
+
+  mod = Zer0ImageGenerator::Svg::Generators::Lowpoly
+  opts = { seed: 1, palette: mod::DEFAULT_PALETTE, cols: 16, rows: 11,
+           out: ".sweep/lowpoly.svg" }
+  argv = ARGV.dup
+  until argv.empty?
+    flag = argv.shift
+    val = argv.shift
+    case flag
+    when "--seed" then opts[:seed] = Integer(val)
+    when "--palette" then opts[:palette] = val
+    when "--cols" then opts[:cols] = Integer(val)
+    when "--rows" then opts[:rows] = Integer(val)
+    when "--out" then opts[:out] = val
+    else raise ArgumentError, "unknown flag #{flag.inspect}"
+    end
+  end
+
+  dir = File.dirname(opts[:out])
+  FileUtils.mkdir_p(dir.empty? ? "." : dir)
+  svg = mod.build(opts[:seed], opts[:palette], opts[:cols], opts[:rows])
+  File.write(opts[:out], svg)
+  puts opts[:out]
+end

data/lib/zer0_image_generator/svg/generators/lsystem.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require_relative "../../support/py_random"
+
+module Zer0ImageGenerator
+  module Svg
+    module Generators
+      # L-system botanical generator — port of `tools/svg/examples/lsystem.py`.
+      #
+      # Expand an L-system string, turtle-interpret it into branch segments and
+      # growth tips, shade by branch depth (thick dark trunk -> thin bright
+      # twigs), and drop foliage at the tips. A seeded per-turn angle jitter
+      # keeps the plant organic; four rulesets give four species, four palettes
+      # re-skin without touching geometry.
+      #
+      # The committed artwork under `docs/samples/lsystem-*.svg` was produced by
+      # the Python original, so this port is pinned to byte-identical output:
+      # every draw comes off `Support::PyRandom` in the same order, the
+      # depth-sort is stable exactly as CPython's `sorted` is, and every
+      # interpolated number reproduces the Python f-string / `round()` text.
+      module Lsystem
+        # [bg, trunk, branch, leaf, bloom, sky-glow]
+        PALETTES = {
+          "verdant" => ["#0e1a12", "#4a3327", "#3e6b48", "#8bbf6f", "#f2e9c9", "#1b3326"].freeze,
+          "autumn" => ["#1a1410", "#4a2f20", "#8a4b2f", "#d98324", "#f2c14e", "#2a1d14"].freeze,
+          "sakura" => ["#171320", "#3d2b3d", "#5a4466", "#c98bb9", "#f7d6e6", "#241b2e"].freeze,
+          "frost" => ["#0b1420", "#2a3b4a", "#3e6b7a", "#8bbfd6", "#e8f1f2", "#152532"].freeze,
+        }.freeze
+
+        DEFAULT_PALETTE = "verdant"
+
+        # axiom, rules, base angle (deg), iterations, step length
+        RULESETS = {
+          "bush" => ["X", { "X" => "F+[[X]-X]-F[-FX]+X", "F" => "FF" }.freeze, 22.5, 4, 13.0].freeze,
+          "fern" => ["X", { "X" => "F-[[X]+X]+F[+FX]-X", "F" => "FF" }.freeze, 20.0, 4, 13.0].freeze,
+          "tree" => ["F", { "F" => "FF+[+F-F-F]-[-F+F+F]" }.freeze, 25.0, 4, 9.0].freeze,
+          "weed" => ["F", { "F" => "F[+F]F[-F][F]" }.freeze, 22.0, 4, 8.0].freeze,
+        }.freeze
+
+        DEFAULT_SPECIES = "bush"
+
+        W = 900
+        H = 1100
+        M = 90
+
+        HALF = Rational(1, 2)
+        private_constant :HALF
+
+        # `math.radians(x)` is `x * (pi/180.0)` with the constant folded first;
+        # replicate that association so the angle matches to the last ULP.
+        DEG2RAD = Math::PI / 180.0
+        private_constant :DEG2RAD
+
+        class << self
+          def expand(axiom, rules, iters)
+            s = axiom
+            iters.times { s = s.each_char.map { |c| rules.fetch(c, c) }.join }
+            s
+          end
+
+          def interpret(s, angle, step, jitter, rng)
+            x = 0.0
+            y = 0.0
+            a = -90.0
+            stack = []
+            segs = []
+            tips = []
+            s.each_char do |c|
+              case c
+              when "F"
+                na = a + rng.uniform(-jitter, jitter)
+                nx = x + (step * Math.cos(na * DEG2RAD))
+                ny = y + (step * Math.sin(na * DEG2RAD))
+                segs << [x, y, nx, ny, stack.length]
+                x = nx
+                y = ny
+                a = na
+              when "+"
+                a += angle + rng.uniform(-jitter, jitter)
+              when "-"
+                a -= angle + rng.uniform(-jitter, jitter)
+              when "["
+                stack << [x, y, a]
+              when "]"
+                tips << [x, y, stack.length]
+                x, y, a = stack.pop
+              when "X"
+                tips << [x, y, stack.length]
+              end
+            end
+            [segs, tips]
+          end
+
+          # Returns the finished SVG document, newline-terminated.
+          def build(seed, species, palette, iters_override = nil)
+            rng = Support::PyRandom.new(seed)
+            axiom, rules, angle, iters, step = RULESETS.fetch(species)
+            # Python `if iters_override:` is falsy for both nil AND 0, so a
+            # `--iters 0` keeps the ruleset default just as the original does.
+            iters = iters_override if iters_override && !iters_override.zero?
+            pal = PALETTES.fetch(palette)
+            jitter = 3.0 + (rng.random * 5.0)
+            segs, tips = interpret(expand(axiom, rules, iters), angle, step, jitter, rng)
+            segs = [[0, 0, 0, -10, 0]] if segs.empty?
+
+            xs = segs.flat_map { |s| [s[0], s[2]] }
+            ys = segs.flat_map { |s| [s[1], s[3]] }
+            minx = xs.min
+            maxx = xs.max
+            miny = ys.min
+            maxy = ys.max
+            span_x = [maxx - minx, 1e-6].max
+            span_y = [maxy - miny, 1e-6].max
+            # Python `/` is true division throughout; fdiv guards the fallback
+            # path where a span can still be an Integer.
+            scale = [(W - (2 * M)).fdiv(span_x), (H - (2 * M)).fdiv(span_y)].min
+            ox = ((W - (span_x * scale)) / 2) - (minx * scale)
+            oy = H - M - (maxy * scale) # base sits near the bottom margin
+
+            tx = ->(x) { round_repr(ox + (x * scale), 1) }
+            ty = ->(y) { round_repr(oy + (y * scale), 1) }
+
+            maxd = segs.map { |s| s[4] }.max || 1
+            parts = [
+              %(<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 #{W} #{H}" role="img" ) +
+                %(stroke-linecap="round">),
+              "<title>L-system #{species}, seed #{seed}, palette #{palette}</title>",
+              %(<rect width="#{W}" height="#{H}" fill="#{pal[0]}"/>),
+              %(<ellipse cx="#{W / 2}" cy="#{(H * 0.34).to_i}" rx="#{W / 2}" ry="#{(H * 0.34).to_i}" ) +
+                %(fill="#{pal[5]}" opacity="0.6"/>),
+              %(<ellipse cx="#{W / 2}" cy="#{H - 40}" rx="#{(W * 0.42).to_i}" ry="34" ) +
+                %(fill="#{pal[1]}" opacity="0.5"/>),
+            ]
+
+            # Trunk-first (shallow depth first) so deep twigs don't occlude it.
+            # CPython's `sorted` is stable; pairing each seg with its index and
+            # sorting by [depth, index] reproduces that order (Ruby's sort_by
+            # is not stable on its own).
+            stable_by_depth(segs).each do |x1, y1, x2, y2, d|
+              t = d.fdiv(maxd)
+              color = t < 0.28 ? pal[1] : (t < 0.62 ? pal[2] : pal[3])
+              w = round_repr([0.6, 11 * ((1 - t)**1.7)].max, 2)
+              parts << %(<line x1="#{tx.call(x1)}" y1="#{ty.call(y1)}" ) +
+                       %(x2="#{tx.call(x2)}" y2="#{ty.call(y2)}" ) +
+                       %(stroke="#{color}" stroke-width="#{w}"/>)
+            end
+
+            # Foliage at tips: most leaves, a seeded fraction blooms.
+            tips.each do |x, y, d|
+              next if d < 2
+
+              r = round_val(rng.uniform(3.5, 7.0) * [scale, 1.0].min * 3, 1)
+              if rng.random < 0.16
+                parts << %(<circle cx="#{tx.call(x)}" cy="#{ty.call(y)}" r="#{fmt(r * 1.1, 1)}" ) +
+                         %(fill="#{pal[4]}" opacity="0.95"/>)
+              else
+                parts << %(<circle cx="#{tx.call(x)}" cy="#{ty.call(y)}" r="#{fmt(r, 1)}" ) +
+                         %(fill="#{pal[3]}" opacity="0.75"/>)
+              end
+            end
+
+            parts << "</svg>"
+            parts.join("\n") + "\n"
+          end
+
+          private
+
+          def stable_by_depth(segs)
+            segs.each_with_index.sort_by { |s, i| [s[4], i] }.map(&:first)
+          end
+
+          # Python's `round(x, n)` as a Float (round-half-to-even on the exact
+          # binary value); equal to `float(f"{x:.Nf}")`.
+          def round_val(value, places)
+            Float(fmt(value, places))
+          end
+
+          # Bare `{round(x, n)}` interpolation prints the rounded double's
+          # shortest round-tripping repr. Ruby's Float#to_s matches CPython's
+          # repr for this magnitude range (coordinates < 1e4, stroke widths).
+          def round_repr(value, places)
+            round_val(value, places).to_s
+          end
+
+          # Exact correctly-rounded fixed-point, matching Python's `f"{x:.Nf}"`.
+          def fmt(value, places)
+            negative = value.negative? || (value.zero? && (1.0 / value).negative?)
+            scaled = value.abs.to_r * (10**places)
+            whole = scaled.floor
+            remainder = scaled - whole
+            whole += 1 if remainder > HALF || (remainder == HALF && whole.odd?)
+
+            digits = whole.to_s.rjust(places + 1, "0")
+            text = places.zero? ? digits : "#{digits[0...-places]}.#{digits[-places..]}"
+            negative ? "-#{text}" : text
+          end
+        end
+      end
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  require "fileutils"
+
+  mod = Zer0ImageGenerator::Svg::Generators::Lsystem
+  opts = { seed: 1, species: mod::DEFAULT_SPECIES, palette: mod::DEFAULT_PALETTE,
+           iters: nil, out: ".sweep/lsystem.svg" }
+  argv = ARGV.dup
+  until argv.empty?
+    flag = argv.shift
+    val = argv.shift
+    case flag
+    when "--seed" then opts[:seed] = Integer(val)
+    when "--species" then opts[:species] = val
+    when "--palette" then opts[:palette] = val
+    when "--iters" then opts[:iters] = Integer(val)
+    when "--out" then opts[:out] = val
+    else raise ArgumentError, "unknown flag #{flag.inspect}"
+    end
+  end
+
+  dir = File.dirname(opts[:out])
+  FileUtils.mkdir_p(dir.empty? ? "." : dir)
+  svg = mod.build(opts[:seed], opts[:species], opts[:palette], opts[:iters])
+  File.write(opts[:out], svg)
+  puts opts[:out]
+end

data/lib/zer0_image_generator/svg/generators/mandala.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require_relative "../../support/py_random"
+
+module Zer0ImageGenerator
+  module Svg
+    module Generators
+      # Radial-symmetry mandala — port of `tools/svg/examples/mandala.py`.
+      #
+      # Concentric rings of a motif repeated with N-fold rotational symmetry.
+      # Each ring's motif, radius, count, and palette role is seeded; one ring
+      # is deliberately offset in phase so the piece isn't a perfect test
+      # pattern (house rule: break symmetry in one place). Motifs are defined
+      # once in <defs> and instanced with <use> + rotate, so a dense mandala
+      # stays a few KB.
+      #
+      # The committed artwork under `docs/samples/mandala-*.svg` was produced by
+      # the Python original, so this port is pinned to byte-identical output:
+      # every draw comes off `Support::PyRandom` in the same order, and every
+      # interpolated number is formatted to the same width the f-strings used.
+      module Mandala
+        # [bg, ring-a, ring-b, accent, highlight]
+        PALETTES = {
+          "jewel" => ["#120a24", "#3d2c8d", "#00a8a8", "#f25f5c", "#ffe066"].freeze,
+          "solar" => ["#1a1005", "#7a3b12", "#e08a1e", "#f2c14e", "#fff3d6"].freeze,
+          "ocean" => ["#04121f", "#0b3a5b", "#1c88a8", "#5bc0be", "#e8f1f2"].freeze,
+          "rose" => ["#1a0f16", "#5a2244", "#a83e6f", "#e58fb0", "#f7e0e8"].freeze,
+        }.freeze
+
+        DEFAULT_PALETTE = "jewel"
+
+        SIZE = 800
+        R_MAX = 356
+
+        KINDS = ["petal", "diamond", "dot", "spoke"].freeze
+        FOLDS = [12, 16, 18, 20, 24].freeze
+
+        HALF = Rational(1, 2)
+        private_constant :HALF
+
+        class << self
+          # Returns the finished SVG document, newline-terminated.
+          def build(seed, palette = DEFAULT_PALETTE)
+            rng = Support::PyRandom.new(seed)
+            pal = PALETTES.fetch(palette)
+            # Python's `S / 2` is true division, so the center lands in the
+            # markup as "400.0", not "400" — keep it a Float.
+            center = SIZE / 2.0
+            defs = []
+            layers = []
+
+            fold = rng.choice(FOLDS)
+            bands = rng.randint(5, 7)
+            gap = R_MAX / (bands + 1).to_f
+            radii = Array.new(bands) { |i| gap * (i + 1) } # even bands, no dead space
+            quirk = rng.randrange(bands) # the one band that breaks phase
+
+            parts = [
+              %(<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 #{SIZE} #{SIZE}" role="img">),
+              "<title>Mandala, seed #{seed}, #{fold}-fold, palette #{palette}</title>",
+              %(<rect width="#{SIZE}" height="#{SIZE}" fill="#{pal[0]}"/>),
+              %(<circle cx="#{center}" cy="#{center}" r="#{R_MAX + 22}" fill="none" ) +
+                %(stroke="#{pal[1]}" stroke-width="3"/>),
+              %(<circle cx="#{center}" cy="#{center}" r="#{R_MAX + 12}" fill="none" ) +
+                %(stroke="#{pal[3]}" stroke-width="1.5" opacity="0.7"/>),
+            ]
+
+            radii.each_with_index do |r, i|
+              kind = rng.choice(KINDS)
+              count = i.even? ? fold : fold * 2 # denser alternating bands
+              color = pal[(i % 3) + 1]
+              stroke = rng.random < 0.6 ? pal[4] : "none"
+              h = gap * 0.5 * (kind == "dot" ? 0.5 : 0.95)
+              w = gap * (%w[petal diamond].include?(kind) ? 0.3 : 0.22)
+              mid = "m#{i}"
+              defs << motif_def(mid, kind, h, w, color, stroke)
+              phase = i == quirk ? 180.0 / count : 0.0
+              uses = [%(<g transform="translate(#{center} #{center})">)]
+              count.times do |k|
+                ang = phase + (k * 360.0 / count)
+                uses << %(<use href="##{mid}" transform="rotate(#{fmt(ang, 2)}) ) +
+                         %(translate(0 #{fmt(-r, 1)})"/>)
+              end
+              uses << "</g>"
+              layers << uses.join("\n")
+            end
+
+            # Center rosette: a small ring of petals, then concentric discs
+            defs << motif_def("mc", "petal", gap * 0.55, gap * 0.22, pal[3], pal[4])
+            rosette = [%(<g transform="translate(#{center} #{center})">)]
+            fold.times do |k|
+              rosette << %(<use href="#mc" transform="rotate(#{fmt(k * 360.0 / fold, 2)}) ) +
+                          %(translate(0 #{fmt(-gap * 0.6, 1)})"/>)
+            end
+            rosette << "</g>"
+            layers << rosette.join("\n")
+            layers << %(<circle cx="#{center}" cy="#{center}" r="#{fmt(gap * 0.42, 1)}" fill="#{pal[3]}"/>)
+            layers << %(<circle cx="#{center}" cy="#{center}" r="#{fmt(gap * 0.24, 1)}" fill="#{pal[4]}"/>)
+            layers << %(<circle cx="#{center}" cy="#{center}" r="#{fmt(gap * 0.09, 1)}" fill="#{pal[0]}"/>)
+
+            parts << "<defs>\n#{defs.join("\n")}\n</defs>"
+            parts.concat(layers)
+            parts << "</svg>"
+            "#{parts.join("\n")}\n"
+          end
+
+          private
+
+          # Motif centered at the local origin, long axis radial (±y).
+          #
+          # `sw` collapses to the empty string when there is no stroke, which
+          # leaves a double space in the markup. The samples were generated
+          # that way, so the spacing is part of the contract, not a typo.
+          def motif_def(mid, kind, h, w, color, stroke)
+            sw = stroke == "none" ? "" : %(stroke="#{stroke}" stroke-width="1.5")
+            case kind
+            when "petal"
+              %(<ellipse id="#{mid}" rx="#{fmt(w, 1)}" ry="#{fmt(h, 1)}" ) +
+                %(fill="#{color}" #{sw} opacity="0.92"/>)
+            when "diamond"
+              %(<path id="#{mid}" d="M0 #{fmt(-h, 1)} L #{fmt(w, 1)} 0 ) +
+                %(L 0 #{fmt(h, 1)} L #{fmt(-w, 1)} 0 Z" ) +
+                %(fill="#{color}" #{sw} opacity="0.92"/>)
+            when "dot"
+              %(<circle id="#{mid}" r="#{fmt([3.0, w * 0.8].max, 1)}" fill="#{color}" #{sw}/>)
+            else
+              # spoke: a short radial tick, decorative between bands
+              %(<path id="#{mid}" d="M0 #{fmt(-h, 1)} L 0 #{fmt(h, 1)}" stroke="#{color}" ) +
+                %(stroke-width="#{fmt([1.5, w * 0.35].max, 1)}" stroke-linecap="round"/>)
+            end
+          end
+
+          # Python's `f"{x:.1f}"` correctly rounds the *exact* binary value,
+          # half-to-even. Ruby's `format("%.1f", x)` and `Float#round` both
+          # round the shortest decimal representation instead, half-away —
+          # `13.35` prints "13.3" in Python and "13.4" in Ruby, which is enough
+          # to desync a band of motifs from the committed samples. Rational
+          # arithmetic gives the exact value, so the rounding decision is made
+          # on the same number Python sees.
+          def fmt(value, places)
+            negative = value.negative? || (value.zero? && (1.0 / value).negative?)
+            scaled = value.abs.to_r * (10**places)
+            whole = scaled.floor
+            remainder = scaled - whole
+            whole += 1 if remainder > HALF || (remainder == HALF && whole.odd?)
+
+            digits = whole.to_s.rjust(places + 1, "0")
+            text = places.zero? ? digits : "#{digits[0...-places]}.#{digits[-places..]}"
+            negative ? "-#{text}" : text
+          end
+        end
+      end
+    end
+  end
+end