ranger-compiler 3.5.0 → 3.5.2

package/dist/lib/evg/tools/evg_image_tool.rgr

@@ -0,0 +1,488 @@
+; SPDX-License-Identifier: MIT
+
+; ==============================================================================
+; evg_image_tool — a bitmap an agent can actually use
+; ==============================================================================
+;
+;   evg_image_tool <in.png|in.jpg> [--out=prefix] [--preset=poster]
+;                  [--colorCount=N] [--at=PATH] [--index=N] [--width=N]
+;
+; A model handed a photograph can describe it and cannot put it on a screen.
+; The picture is pixels; an EVG document is boxes and paths; and the bridge —
+; `EvgBitmapTracer`, the same one `npm run evg:trace:cli` uses — has been
+; here all along with nothing pointing an agent at it.
+;
+; So this turns an image into the two things an agent can act on:
+;
+;   the picture  as an `svg` node it can insert, written for it as an ops
+;                file, so it never has to carry the path data through its own
+;                context to use it
+;   the colours  as a palette with each one's share of the pixels, so a screen
+;                can be themed from the photograph instead of from a guess
+;
+; --- WHY AN OPS FILE AND NOT A PRINTED SVG ------------------------------------
+;
+; A traced SVG is tens of kilobytes of coordinates. Printing it to stdout would
+; put every one of them through the agent's context on the way back into a
+; patch — paying, in tokens, for numbers no model needs to read. The ops file
+; is the patch already written: `./evg-agent patch doc.evg.json photo.ops.json`
+; and the picture is in the document. What comes back here is the summary: the
+; size, the palette, and where the node landed.
+;
+; --- WHY THE PALETTE IS COUNTED AND NOT INFERRED ------------------------------
+;
+; The share of each colour is counted over the pixels, not read off the number
+; of paths a layer produced: one huge background region and four hundred specks
+; of the same colour say opposite things about which colour the picture IS.
+; Every fourth pixel on each axis is sampled, which is a sixteenth of the work
+; and has never moved a share by a point on a photograph.
+; ==============================================================================
+
+Import "../EvgBitmapTracer.rgr"
+Import "../EVGTreeJson.rgr"
+Import "pkg:image/PNGDecoder.rgr"
+Import "pkg:image/JPEGDecoder.rgr"
+Import "pkg:image/ProgressiveJPEGDecoder.rgr"
+
+class EvgImageTool {
+
+    Constructor () {
+    }
+
+    sfn m@(main):void () {
+        def t (new EvgImageTool())
+        t.run()
+    }
+
+    fn usage:void () {
+        print "evg_image_tool — trace a bitmap into something an EVG document can hold"
+        print ""
+        print "  evg_image_tool <in.png|in.jpg> [--out=prefix] [--preset=NAME]"
+        print "                 [--colorCount=N] [--at=PATH] [--index=N] [--width=N]"
+        print ""
+        print "  --out      prefix for the files written (default: the input, without its suffix)"
+        print "  --preset   lineart | poster | photo | broken | print   (default: poster)"
+        print "  --colorCount  how many colours to trace with"
+        print "  --at       where the ops file inserts the picture (default: 0)"
+        print "  --index    the child index it inserts at (default: 0)"
+        print "  --width    the width to place it at, in px; the height follows the image"
+        print ""
+        print "Writes <prefix>.svg and <prefix>.ops.json, and prints the palette."
+    }
+
+    ; --- arguments ------------------------------------------------------------
+
+    sfn textFlag:string (name:string fallback:string) {
+        def argc:int (shell_arg_cnt)
+        def head:string (name + "=")
+        def n:int (strlen head)
+        def i:int 0
+        while (i < argc) {
+            def a:string (shell_arg i)
+            if ((strlen a) > n) {
+                if ((substring a 0 n) == head) {
+                    return (substring a n (strlen a))
+                }
+            }
+            i = (i + 1)
+        }
+        return fallback
+    }
+
+    sfn intFlag:int (name:string fallback:int) {
+        def v:string (EvgImageTool.textFlag(name ""))
+        if ((strlen v) == 0) {
+            return fallback
+        }
+        return (EvgImageTool.parseInt(v fallback))
+    }
+
+    ; `to_int` on a string is optional-typed and behaves differently per
+    ; target; a digit loop is the same everywhere.
+    sfn parseInt:int (s:string fallback:int) {
+        def n:int (strlen s)
+        if (n == 0) {
+            return fallback
+        }
+        def v:int 0
+        def seen:int 0
+        def i:int 0
+        while (i < n) {
+            def d:int (indexOf "0123456789" (substring s i (i + 1)))
+            if (d < 0) {
+                i = n
+            } {
+                v = ((v * 10) + d)
+                seen = (seen + 1)
+                i = (i + 1)
+            }
+        }
+        if (seen == 0) {
+            return fallback
+        }
+        return v
+    }
+
+    sfn positional@(optional):string () {
+        def argc:int (shell_arg_cnt)
+        def none@(optional):string
+        def i:int 0
+        while (i < argc) {
+            def a:string (shell_arg i)
+            if ((indexOf a "--") == 0) {
+            } {
+                def hit@(optional):string a
+                return hit
+            }
+            i = (i + 1)
+        }
+        return none
+    }
+
+    sfn lastSepOf:int (path:string) {
+        def at:int (0 - 1)
+        def i:int 0
+        while (i < (strlen path)) {
+            def c:int (charAt path i)
+            if ((c == 47) || (c == 92)) {
+                at = i
+            }
+            i = (i + 1)
+        }
+        return at
+    }
+
+    sfn dirOf:string (path:string) {
+        def sep:int (EvgImageTool.lastSepOf(path))
+        if (sep < 0) {
+            return "."
+        }
+        return (substring path 0 sep)
+    }
+
+    sfn fileOf:string (path:string) {
+        def sep:int (EvgImageTool.lastSepOf(path))
+        if (sep < 0) {
+            return path
+        }
+        return (substring path (sep + 1) (strlen path))
+    }
+
+    ; The path without its last suffix, so `photo.png` writes `photo.svg`.
+    sfn stemOf:string (path:string) {
+        def dot:int (0 - 1)
+        def i:int (EvgImageTool.lastSepOf(path))
+        if (i < 0) {
+            i = 0
+        }
+        while (i < (strlen path)) {
+            if ((charAt path i) == 46) {
+                dot = i
+            }
+            i = (i + 1)
+        }
+        if (dot <= 0) {
+            return path
+        }
+        return (substring path 0 dot)
+    }
+
+    ; --- decoding -------------------------------------------------------------
+
+    sfn isProgressiveJpeg:boolean (bytes:buffer) {
+        def n:int (buffer_length bytes)
+        def i:int 2
+        while ((i + 1) < n) {
+            if ((buffer_get bytes i) == 255) {
+                def marker:int (buffer_get bytes (i + 1))
+                if (marker == 194) {
+                    return true
+                }
+                if (marker == 192) {
+                    return false
+                }
+                if (marker == 218) {
+                    return false
+                }
+            }
+            i = (i + 1)
+        }
+        return false
+    }
+
+    fn decodeImage:ImageBuffer (bytes:buffer dir:string file:string) {
+        def n:int (buffer_length bytes)
+        def fail (new ImageBuffer())
+        fail.init(1 1)
+        if (n < 4) {
+            return fail
+        }
+        def b0:int (buffer_get bytes 0)
+        def b1:int (buffer_get bytes 1)
+        if ((b0 == 137) && (b1 == 80)) {
+            def png (new PNGDecoder())
+            return (png.decodeBytes(bytes))
+        }
+        if ((b0 == 255) && (b1 == 216)) {
+            if (EvgImageTool.isProgressiveJpeg(bytes)) {
+                def prog (new ProgressiveJPEGDecoder())
+                return (prog.decode(dir file))
+            }
+            def jpg (new JPEGDecoder())
+            jpg.quiet = true
+            return (jpg.decodeBytes(bytes))
+        }
+        return fail
+    }
+
+    ; --- the palette ----------------------------------------------------------
+
+    sfn hexDigit:int (c:int) {
+        if ((c >= 48) && (c <= 57)) {
+            return (c - 48)
+        }
+        if ((c >= 97) && (c <= 102)) {
+            return ((c - 97) + 10)
+        }
+        if ((c >= 65) && (c <= 70)) {
+            return ((c - 65) + 10)
+        }
+        return 0
+    }
+
+    ; "#1e293b" → the three channels. Anything shorter answers black, which is
+    ; what the tracer's own default is.
+    sfn channelsOf:void (hex:string out:[int]) {
+        if ((strlen hex) < 7) {
+            push out 0
+            push out 0
+            push out 0
+            return
+        }
+        def i:int 1
+        while (i < 7) {
+            def hi:int (EvgImageTool.hexDigit((charAt hex i)))
+            def lo:int (EvgImageTool.hexDigit((charAt hex (i + 1))))
+            push out ((hi * 16) + lo)
+            i = (i + 2)
+        }
+    }
+
+    ; How much of the picture each traced colour actually covers. Every fourth
+    ; pixel on each axis, by nearest palette entry in plain RGB distance — the
+    ; same measure the tracer used to pick them.
+    fn coverage:void (img:ImageBuffer palR:[int] palG:[int] palB:[int] counts:[int]) {
+        def k:int (array_length palR)
+        def i:int 0
+        while (i < k) {
+            push counts 0
+            i = (i + 1)
+        }
+        def step:int 4
+        def y:int 0
+        while (y < (img.height)) {
+            def x:int 0
+            while (x < (img.width)) {
+                def c:Color (img.getPixel(x y))
+                def best:int 0
+                def bestD:int 1000000
+                def j:int 0
+                while (j < k) {
+                    def dr:int ((c.r) - (itemAt palR j))
+                    def dg:int ((c.g) - (itemAt palG j))
+                    def db:int ((c.b) - (itemAt palB j))
+                    def d:int (((dr * dr) + (dg * dg)) + (db * db))
+                    if (d < bestD) {
+                        bestD = d
+                        best = j
+                    }
+                    j = (j + 1)
+                }
+                set counts best ((itemAt counts best) + 1)
+                x = (x + step)
+            }
+            y = (y + step)
+        }
+    }
+
+    ; --- the ops file ---------------------------------------------------------
+
+    ; The patch that puts the picture in the document, written out so the agent
+    ; never handles the path data itself.
+    sfn opsFor:string (at:string index:int svg:string w:int h:int) {
+        def target:string ((at + "/") + (to_string index))
+        def out:string "{\"ops\":[\n"
+        out = (((((out + "  {\"op\":\"insert\",\"at\":") + (EVGTreeJson.str(at))) + ",\"index\":") + (to_string index)) + ",\"tag\":\"svg\"},\n")
+        out = (((out + "  {\"op\":\"set-prop\",\"at\":") + (EVGTreeJson.str(target))) + ",\"prop\":\"width\",\"value\":")
+        out = (((out + (EVGTreeJson.str((to_string w) + "px"))) + "},\n"))
+        out = (((out + "  {\"op\":\"set-prop\",\"at\":") + (EVGTreeJson.str(target))) + ",\"prop\":\"height\",\"value\":")
+        out = (((out + (EVGTreeJson.str((to_string h) + "px"))) + "},\n"))
+        out = (((out + "  {\"op\":\"set-prop\",\"at\":") + (EVGTreeJson.str(target))) + ",\"prop\":\"svg\",\"value\":")
+        out = (((out + (EVGTreeJson.str(svg))) + "}\n"))
+        return (out + "]}\n")
+    }
+
+    ; --- run ------------------------------------------------------------------
+
+    fn run:void () {
+        def argc:int (shell_arg_cnt)
+        if (argc < 1) {
+            this.usage()
+            return
+        }
+        def first@(optional):string (EvgImageTool.positional())
+        if (null? first) {
+            this.usage()
+            return
+        }
+        def inputPath:string (unwrap first)
+        def inDir:string (EvgImageTool.dirOf(inputPath))
+        def inFile:string (EvgImageTool.fileOf(inputPath))
+        if ((file_exists inDir inFile) == false) {
+            print (("{\"error\":\"no such file: " + inputPath) + "\"}")
+            return
+        }
+        def bytes:buffer (buffer_read_file inDir inFile)
+        if ((buffer_length bytes) == 0) {
+            print (("{\"error\":\"cannot read " + inputPath) + "\"}")
+            return
+        }
+        def img:ImageBuffer (this.decodeImage(bytes inDir inFile))
+        if (((img.width) < 2) && ((img.height) < 2)) {
+            print (("{\"error\":\"not a PNG or JPEG this build can decode: " + inputPath) + "\"}")
+            return
+        }
+
+        ; `poster` rather than the bare defaults: a screen wants flat colour
+        ; regions it can put behind text, and a photograph traced at default
+        ; fidelity is a mosaic nobody asked for.
+        def presetName:string (EvgImageTool.textFlag("--preset" "poster"))
+        def opts:EvgTraceOptions (EvgTraceOptions.preset(presetName))
+        def wantColors:int (EvgImageTool.intFlag("--colorCount" 0))
+        if (wantColors > 0) {
+            opts.colorCount = wantColors
+        }
+
+        def tr:EvgBitmapTracer (EvgBitmapTracer.fromImageBuffer(img opts))
+        tr.trace()
+        def svg:string (tr.toSVG())
+
+        def stem:string (EvgImageTool.textFlag("--out" (EvgImageTool.stemOf(inputPath))))
+        def outDir:string (EvgImageTool.dirOf(stem))
+        def outName:string (EvgImageTool.fileOf(stem))
+        write_file outDir (outName + ".svg") svg
+
+        ; The placed size: the image's own, unless a width is given, and then
+        ; the height follows it so nothing is squashed.
+        def placeW:int (img.width)
+        def placeH:int (img.height)
+        def askW:int (EvgImageTool.intFlag("--width" 0))
+        if (askW > 0) {
+            placeW = askW
+            placeH = (idiv (askW * (img.height)) (img.width))
+            if (placeH < 1) {
+                placeH = 1
+            }
+        }
+        def at:string (EvgImageTool.textFlag("--at" "0"))
+        def index:int (EvgImageTool.intFlag("--index" 0))
+        def ops:string (EvgImageTool.opsFor(at index svg placeW placeH))
+        write_file outDir (outName + ".ops.json") ops
+
+        ; --- the answer -------------------------------------------------------
+        def layers:[EvgTraceLayer] (tr.getLayers())
+        def palR:[int]
+        def palG:[int]
+        def palB:[int]
+        def hexes:[string]
+        def li:int 0
+        while (li < (array_length layers)) {
+            def layer:EvgTraceLayer (itemAt layers li)
+            def ch:[int]
+            EvgImageTool.channelsOf(layer.fillHex ch)
+            push palR (itemAt ch 0)
+            push palG (itemAt ch 1)
+            push palB (itemAt ch 2)
+            push hexes layer.fillHex
+            li = (li + 1)
+        }
+        def counts:[int]
+        this.coverage(img palR palG palB counts)
+        def total:int 0
+        def ci:int 0
+        while (ci < (array_length counts)) {
+            total = (total + (itemAt counts ci))
+            ci = (ci + 1)
+        }
+        if (total < 1) {
+            total = 1
+        }
+
+        def out:string "{\"width\":"
+        out = (out + (to_string (img.width)))
+        out = ((out + ",\"height\":") + (to_string (img.height)))
+        out = ((out + ",\"layers\":") + (to_string (tr.layerCount())))
+        out = ((out + ",\"rings\":") + (to_string (tr.ringCount())))
+        out = (out + ",\"colors\":[")
+        ; Biggest share first: the first entry is the colour the picture IS.
+        def used:[int]
+        def u:int 0
+        while (u < (array_length hexes)) {
+            push used 0
+            u = (u + 1)
+        }
+        def wrote:int 0
+        def rank:int 0
+        while (rank < (array_length hexes)) {
+            def bestI:int (0 - 1)
+            def bestC:int (0 - 1)
+            def s:int 0
+            while (s < (array_length hexes)) {
+                if ((itemAt used s) == 0) {
+                    if ((itemAt counts s) > bestC) {
+                        bestC = (itemAt counts s)
+                        bestI = s
+                    }
+                }
+                s = (s + 1)
+            }
+            if (bestI >= 0) {
+                set used bestI 1
+                def pct:int (idiv (((itemAt counts bestI) * 1000) + (idiv total 2)) total)
+                if (wrote > 0) {
+                    out = (out + ",")
+                }
+                out = (out + "\n  {\"hex\":")
+                out = (out + (EVGTreeJson.str((itemAt hexes bestI))))
+                out = ((out + ",\"share\":") + (EvgImageTool.perMille(pct)))
+                out = (out + "}")
+                wrote = (wrote + 1)
+            }
+            rank = (rank + 1)
+        }
+        if (wrote > 0) {
+            out = (out + "\n")
+        }
+        out = (out + "],\"wrote\":{\"svg\":")
+        out = (out + (EVGTreeJson.str((outName + ".svg"))))
+        out = (out + ",\"ops\":")
+        out = (out + (EVGTreeJson.str((outName + ".ops.json"))))
+        out = (out + "},\"insertsAt\":")
+        out = (out + (EVGTreeJson.str((at + "/") + (to_string index))))
+        out = ((out + ",\"placed\":\"") + (to_string placeW))
+        out = (((out + "x") + (to_string placeH)) + "\"}")
+        print out
+    }
+
+    ; Per mille as a fraction, so 0.42 rather than 420 and without a float
+    ; formatter that prints differently on every target.
+    sfn perMille:string (v:int) {
+        def whole:int (idiv v 1000)
+        def frac:int (v - (whole * 1000))
+        def text:string (to_string frac)
+        while ((strlen text) < 3) {
+            text = ("0" + text)
+        }
+        return (((to_string whole) + ".") + text)
+    }
+}

package/dist/lib/evg/tools/evg_trace_bench.rgr

@@ -0,0 +1,114 @@
+; SPDX-License-Identifier: MIT
+
+; ==============================================================================
+; evg_trace_bench.rgr — timing harness for EvgBitmapTracer
+; ==============================================================================
+; Prints JSON lines a Node bench can parse and compare against npm/CLI potrace.
+;
+;   npm run evg:trace:bench
+; ==============================================================================
+
+Import "../EvgBitmapTracer.rgr"
+
+class EvgTraceBench {
+
+    sfn m@(main):void () {
+        def b (new EvgTraceBench())
+        b.runCase("rect_64" 64 64 8 8 48 48 40)
+        b.runCase("rect_256" 256 256 32 32 192 192 20)
+        b.runCase("checker_128" 128 128 0 0 0 0 20)
+        b.runCase("ring_128" 128 128 16 16 96 96 30)
+        print "BENCH_DONE"
+    }
+
+    fn makeRect:EvgBinaryBitmap (w:int h:int x0:int y0:int rw:int rh:int) {
+        def bm:EvgBinaryBitmap (EvgBinaryBitmap.create(w h))
+        def y:int y0
+        while (y < (y0 + rh)) {
+            def x:int x0
+            while (x < (x0 + rw)) {
+                bm.setBit(x y true)
+                x = (x + 1)
+            }
+            y = (y + 1)
+        }
+        return bm
+    }
+
+    fn makeChecker:EvgBinaryBitmap (w:int h:int) {
+        def bm:EvgBinaryBitmap (EvgBinaryBitmap.create(w h))
+        def y:int 0
+        while (y < h) {
+            def x:int 0
+            while (x < w) {
+                def cell:int ((idiv x 8) + (idiv y 8))
+                if (((cell - ((idiv cell 2) * 2)) == 0)) {
+                    bm.setBit(x y true)
+                }
+                x = (x + 1)
+            }
+            y = (y + 1)
+        }
+        return bm
+    }
+
+    fn makeRing:EvgBinaryBitmap (w:int h:int x0:int y0:int rw:int rh:int) {
+        def bm:EvgBinaryBitmap (this.makeRect(w h x0 y0 rw rh))
+        def ix:int (x0 + (idiv rw 4))
+        def iy:int (y0 + (idiv rh 4))
+        def iw:int (idiv rw 2)
+        def ih:int (idiv rh 2)
+        def y:int iy
+        while (y < (iy + ih)) {
+            def x:int ix
+            while (x < (ix + iw)) {
+                bm.setBit(x y false)
+                x = (x + 1)
+            }
+            y = (y + 1)
+        }
+        return bm
+    }
+
+    fn runCase:void (name:string w:int h:int x0:int y0:int rw:int rh:int iters:int) {
+        def bm:EvgBinaryBitmap (EvgBinaryBitmap.create(w h))
+        if (name == "checker_128") {
+            bm = (this.makeChecker(w h))
+        } {
+            if (name == "ring_128") {
+                bm = (this.makeRing(w h x0 y0 rw rh))
+            } {
+                bm = (this.makeRect(w h x0 y0 rw rh))
+            }
+        }
+        def opts:EvgTraceOptions (EvgTraceOptions.defaults())
+        opts.turdsize = 2
+        opts.alphamax = 1.0
+        opts.opttolerance = 0.2
+        opts.optcurve = true
+
+        ; Warmup
+        def warm:EvgBitmapTracer (EvgBitmapTracer.fromBinary(bm opts))
+        warm.trace()
+
+        def i:int 0
+        def last:EvgBitmapTracer warm
+        while (i < iters) {
+            def tr:EvgBitmapTracer (EvgBitmapTracer.fromBinary(bm opts))
+            tr.trace()
+            last = tr
+            i = (i + 1)
+        }
+        def d:string (last.getPathData())
+        def line:string ("BENCH_CASE {" )
+        line = (line + "\"name\":\"" + name + "\",")
+        line = (line + "\"w\":" + (to_string w) + ",")
+        line = (line + "\"h\":" + (to_string h) + ",")
+        line = (line + "\"iters\":" + (to_string iters) + ",")
+        line = (line + "\"rings\":" + (to_string (last.ringCount())) + ",")
+        line = (line + "\"commands\":" + (to_string (last.commandCount())) + ",")
+        line = (line + "\"pathChars\":" + (to_string (strlen d)) + ",")
+        line = (line + "\"svgChars\":" + (to_string (strlen (last.toSVG()))) + "}")
+        print line
+    }
+}