dymokomi/luce-image
Source of release 0.45.0
0.45.0 / 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)