Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-image

Source of release 0.45.1

0.45.1 / src / brush_files.lucb

#==============================================================================================
#
#   brush_files - Brush masks from pictures and files, kept as PNG
#
#   DESCRIPTION:
#       luce-painting's BrushMask is coverage bytes. Here a mask is made from any picture
#       the Image API opens (a pasted image, a file, the selection's pixels: Define Brush
#       Preset) and kept as a grayscale PNG, dark where it paints, as Photoshop shows a
#       brush: in a file, or as base64 text inside a brush file.
#
#==============================================================================================

import interop
import memory
from luce_painting.brush_mask import BrushMask
from image import Image
from luce_raster.errors import invalid

## A mask of `image`, dark (and opaque) where it paints, at its size scaled
## down to fit 1024 pixels a side.
pub func brush_mask_of(image: interop.Reference[Image]) -> interop.Reference[BrushMask]!:
    let source = image.value()
    let width = try source.width()
    let height = try source.height()
    if width == 0 or height == 0:
        error(invalid, "the image is empty")
    let converted = try source.convert("RGBA")
    defer converted.release()
    let rgba = try converted.value().rgba8()
    defer free(rgba) in memory.heap
    return try BrushMask.from_rgba8(rgba, width, height)

## A mask from a picture file (a PNG `save_brush_mask` wrote included).
pub func open_brush_mask(path: str) -> interop.Reference[BrushMask]!:
    let image = try Image.open(path)
    defer image.release()
    return try brush_mask_of(image)

## Keep `mask` at `path` as a grayscale PNG, black where it paints.
pub func save_brush_mask(mask: interop.Reference[BrushMask], path: str) -> !:
    let image = try gray_image(mask)
    defer image.release()
    try image.value().save(path, "png")

## The PNG `save_brush_mask` writes, as base64 text: a brush file carries its
## images this way.
pub func brush_mask_png_text(mask: interop.Reference[BrushMask]) -> interop.Owned[str]!:
    let image = try gray_image(mask)
    defer image.release()
    let encoded = try image.value().encode("png")
    defer free(encoded) in memory.heap
    let text = try new u8[(encoded.length + 2) // 3 * 4] --- in memory.heap
    defer free(text) in memory.heap
    base64_encode(encoded, text)
    return try interop.copy_text((str)text)

## A mask from `brush_mask_png_text`'s text.
pub func brush_mask_from_png_text(text: str) -> interop.Reference[BrushMask]!:
    let decoded = try base64_decode(text.bytes)
    defer free(decoded) in memory.heap
    let image = try Image.open_bytes(decoded)
    defer image.release()
    return try brush_mask_of(image)

## `mask` as a grayscale image, black where it paints.
func gray_image(mask: interop.Reference[BrushMask]) -> interop.Reference[Image]!:
    let held = mask.value()
    let columns = (usize)(try held.width())
    let rows = (usize)(try held.height())
    let pixels = try held.coverage()
    let image = try Image.create("L", columns, rows)
    errdefer image.release()
    let target = image.value()
    for y in 0..<rows:
        for x in 0..<columns:
            try target.put_sample(x, y, 0, 255.0 - (f64)pixels[y * columns + x])
    return image

let base64_letters: str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

## `data` as padded base64 into `text`, which holds exactly its length.
func base64_encode(data: const u8[], text: u8[]):
    var at: usize = 0
    var index: usize = 0
    while index < data.length:
        let first = (u32)data[index]
        let second = (u32)data[index + 1] if index + 1 < data.length else 0
        let third = (u32)data[index + 2] if index + 2 < data.length else 0
        let bits = (first << 16) | (second << 8) | third
        text[at] = base64_letters.bytes[(usize)((bits >> 18) & 63)]
        text[at + 1] = base64_letters.bytes[(usize)((bits >> 12) & 63)]
        text[at + 2] = base64_letters.bytes[(usize)((bits >> 6) & 63)] if index + 1 < data.length else '='
        text[at + 3] = base64_letters.bytes[(usize)(bits & 63)] if index + 2 < data.length else '='
        at += 4
        index += 3

## The bytes of base64 `text` (on the heap, the caller's); whitespace is skipped.
func base64_decode(text: const u8[]) -> u8[]!:
    let out = try new u8[text.length // 4 * 3 + 3] --- in memory.heap
    errdefer free(out) in memory.heap
    var bits: u32 = 0
    var held: u32 = 0
    var count: usize = 0
    for byte in text:
        var value: u32 = 64
        if byte >= 'A' and byte <= 'Z':
            value = (u32)(byte - 'A')
        elif byte >= 'a' and byte <= 'z':
            value = (u32)(byte - 'a') + 26
        elif byte >= '0' and byte <= '9':
            value = (u32)(byte - '0') + 52
        elif byte == '+':
            value = 62
        elif byte == '/':
            value = 63
        elif byte == '=' or byte == ' ' or byte == '\n' or byte == '\r' or byte == '\t':
            continue
        else:
            error(invalid, "the brush image text is not base64")
        bits = (bits << 6) | value
        held += 6
        if held >= 8:
            held -= 8
            out[count] = (u8)((bits >> held) & 255)
            count += 1
    let kept = try new u8[count] --- in memory.heap
    memory.copy(kept, out, count)
    free(out) in memory.heap
    return kept

test "a pasted picture becomes a mask, from its PNG or its raw pixels":
    var rgba: u8[16] = [0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 255]
    let plain = try Image.from_rgba8(2, 2, rgba[..<16])
    defer plain.release()
    let png = try plain.value().encode("png")
    defer free(png) in memory.heap
    let encoded = try Image.open_bytes(png)
    defer encoded.release()
    for source in [encoded, plain]:
        let mask = try brush_mask_of(source)
        defer mask.release()
        let pixels = try mask.value().coverage()
        assert(pixels.length == 4 and pixels[0] == 255 and pixels[1] == 0 and pixels[2] == 0 and pixels[3] == 255)

test "a mask kept as PNG comes back the same":
    let mask = try BrushMask.create(24, 16)
    defer mask.release()
    try mask.value().dab(8.0, 8.0, 5.0, 0.5, 1.0)
    let path = "/tmp/luce-image-brush-mask-test.png"
    try save_brush_mask(mask, path)
    let back = try open_brush_mask(path)
    defer back.release()
    let a = try mask.value().coverage()
    let b = try back.value().coverage()
    assert(a.length == b.length)
    for index in 0..<a.length:
        assert(a[index] == b[index])

test "a mask travels as base64 PNG text and comes back the same":
    let mask = try BrushMask.create(20, 10)
    defer mask.release()
    try mask.value().dab(6.0, 5.0, 4.0, 0.3, 1.0)
    let text = try brush_mask_png_text(mask)
    let back = try brush_mask_from_png_text(text.value)
    text.release()
    defer back.release()
    let a = try mask.value().coverage()
    let b = try back.value().coverage()
    assert(a.length == b.length)
    for index in 0..<a.length:
        assert(a[index] == b[index])
    var plain: u8[5] = [1, 2, 3, 250, 251]
    var letters: u8[8]
    base64_encode(plain[..<5], letters[..<8])
    assert((str)letters[..<8] == "AQID+vs=")
    let decoded = try base64_decode(letters[..<8])
    defer free(decoded) in memory.heap
    assert(decoded.length == 5 and decoded[3] == 250 and decoded[4] == 251)