Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-image

Source of release 0.45.0

0.45.0 / src / adjust.lucb

## Destructive adjustments: a layer's tiles rewritten through one fragment
## program, tile by tile. Only tiles the layer has are touched; the rest stay
## transparent. The caller keeps the tiles from before for undo.
from luce_gpu import gpu
import memory
from luce_std import math
from luce_canvas.tiles import Tiles, tile_size, tile_texture
from document import Document
from shaders import adjust_frag_words, adjust_frag_msl
from luce_raster.errors import invalid

## The adjustments `adjust.frag` knows, by number.
pub let brightness_contrast: u32 = 0
pub let hue_saturation: u32 = 1
pub let invert: u32 = 2
pub let levels: u32 = 3
pub let desaturate: u32 = 4
pub let threshold: u32 = 5
pub let posterize: u32 = 6
pub let curves: u32 = 7
pub let exposure: u32 = 8
pub let black_white: u32 = 9
pub let color_balance: u32 = 10
pub let gradient_map: u32 = 11
pub let vignette: u32 = 12
pub let grain: u32 = 13
pub let noise: u32 = 14
## A Gaussian blur of what is below, p0 its radius in pixels (0.5..250): only
## ever a layer, which the compositor draws itself (composite.lucb) since it
## needs the neighbouring cells; the adjust pass leaves pixels as they are.
pub let blur: u32 = 15
pub let camera_raw: u32 = 16
## Image › Adjustments › Replace Color: a hue/saturation/lightness shift as far
## as a pixel is near sampled colors (adjust.frag lists its parameters).
pub let replace_color: u32 = 17
pub let adjustment_count: u32 = 18
## How many parameters an adjustment takes at most.
pub let parameter_count: usize = 23

## The pipeline a device needs to adjust, built once.
## Whether `kind` and `values` make an adjustment.
func check(kind: u32, values: const f64[], table: gpu.Texture?) -> !:
    if kind >= adjustment_count:
        error(invalid, "no such adjustment")
    if kind == curves and table == none:
        error(invalid, "curves need their table")
    if values.length > parameter_count:
        error(invalid, "too many adjustment parameters")
    for value in values:
        if not math.is_finite(value):
            error(invalid, "adjustment parameters must be finite")

## Where a tile lies: its first pixel and the canvas's size, for the kinds
## that depend on where a pixel is (vignette, grain, noise).
pub struct Place:
    pub var x: u32
    pub var y: u32
    pub var width: u32
    pub var height: u32

pub struct Adjuster:
    var owner: gpu.Device
    var shader: gpu.Shader
    var pipeline: gpu.Pipeline

    pub static func create(device: gpu.Device) -> Adjuster!:
        var shader = try gpu.Shader.create(device, adjust_frag_words, adjust_frag_msl)
        errdefer shader.destroy()
        var pipeline = try gpu.Pipeline.create(device, shader, gpu.Blend.replace, gpu.Format.rgba16_float)
        errdefer pipeline.destroy()
        return Adjuster(owner = device, shader = shader, pipeline = pipeline)

    ## Rewrite every tile of `layer` with adjustment `kind` and its parameters,
    ## at most `parameter_count`, as `adjust.frag` lists them (the rest are 0);
    ## `curves` reads its 256×1 table from `table`. This is the destructive
    ## path: the pixels change once.
    pub func apply(document: Document*, layer: u64, kind: u32, values: const f64[], table: gpu.Texture? = none, on_mask: bool = false) -> !:
        try check(kind, values, table)
        let target = document.find(layer) else error(invalid, "no such layer")
        let tiles = try target.edited_tiles(on_mask)
        for row in 0..<tiles.rows():
            for column in 0..<tiles.columns():
                let source = (try tiles.texture(column, row)) else continue
                let place = Place(x = column * tile_size, y = row * tile_size, width = tiles.width(), height = tiles.height())
                var fresh = try self.adjusted(source, kind, values, table, place)
                errdefer fresh.destroy()
                try tiles.set(column, row, fresh)
        target.revision += 1

    ## A new tile holding `source` adjusted: the destructive path's pass, and
    ## how the compositor evaluates an adjustment layer over what is below it.
    pub func adjusted(source: gpu.Texture, kind: u32, values: const f64[], table: gpu.Texture? = none, place: Place = Place(x = 0, y = 0, width = tile_size, height = tile_size)) -> gpu.Texture!:
        try check(kind, values, table)
        # The kind, the parameters, then where the tile lies.
        var params: f32[28]
        for index in 0..<(usize)28:
            params[index] = 0.0
        params[0] = (f32)kind
        for index in 0..<values.length:
            params[index + 1] = (f32)values[index]
        params[24] = (f32)place.x
        params[25] = (f32)place.y
        params[26] = (f32)place.width
        params[27] = (f32)place.height
        # Binding 2 is read only by curves; the others get the tile again.
        let images: gpu.Texture[2] = [source, table else source]
        var fresh = try tile_texture(self.owner)
        errdefer fresh.destroy()
        let frame = try fresh.frame()
        defer frame.release()
        let area = try frame.value().target()
        defer area.release()
        try gpu.shade(area.value(), self.pipeline, gpu.Rect(width = (f64)tile_size, height = (f64)tile_size), u8[]((u8*)&params[0], 112), images, gpu.Filter.nearest)
        _ = try frame.value().present(gpu.Color(0.0, 0.0, 0.0, 0.0))
        return fresh

    pub func destroy():
        self.pipeline.destroy()
        self.shader.destroy()

test "adjustments rewrite a layer's tiles":
    var device = gpu.Device.open() catch failure:
        assert(failure.code == gpu.unavailable)
        return
    defer device.destroy()
    var document = try Document.create(device, 300, 40)
    defer document.destroy()
    let layer = try document.add_layer("Color")
    let count = (usize)300 * 40 * 4
    let pixels = try new f32[count] --- in memory.heap
    defer free(pixels) in memory.heap
    for index in 0..<count:
        pixels[index] = 0.0
    # Opaque red on the left tile only.
    for y in 0..<(usize)40:
        for x in 0..<(usize)200:
            pixels[(y * 300 + x) * 4] = 1.0
            pixels[(y * 300 + x) * 4 + 3] = 1.0
    var tiles = try Tiles.create(device, 300, 40)
    try tiles.write(pixels)
    try document.set_tiles(layer, tiles)
    var adjuster = try Adjuster.create(device)
    defer adjuster.destroy()
    var no_values: f64[]
    try adjuster.apply(&document, layer, invert, no_values)
    let current = (document.find(layer) else trap("layer")).tiles() else trap("tiles")
    try current.read(pixels)
    # Inverted red is cyan; the empty right tile stays empty; alpha is kept.
    assert(pixels[(20 * 300 + 100) * 4] < 0.01 and pixels[(20 * 300 + 100) * 4 + 1] > 0.99 and pixels[(20 * 300 + 100) * 4 + 3] == 1.0)
    assert(not current.painted(1, 0))
    try adjuster.apply(&document, layer, desaturate, no_values)
    try current.read(pixels)
    let grey = pixels[(20 * 300 + 100) * 4]
    assert(grey > 0.3 and grey < 0.6 and math.abs((f64)grey - (f64)pixels[(20 * 300 + 100) * 4 + 2]) < 0.01)
    var rejected = false
    adjuster.apply(&document, layer, 99, no_values) catch failure:
        assert(failure.code == invalid)
        rejected = true
    assert(rejected)

## One adjustment of a strip of four pixels — red, green, blue and mid grey,
## opaque, linear light — read back.
func adjusted(device: gpu.Device, adjuster: Adjuster*, kind: u32, values: const f64[], pixels: f32[]) -> !:
    var document = try Document.create(device, 4, 1)
    defer document.destroy()
    let layer = try document.add_layer("Strip")
    for index in 0..<(usize)16:
        pixels[index] = 0.0
    pixels[0] = 1.0
    pixels[5] = 1.0
    pixels[10] = 1.0
    pixels[12] = 0.2140
    pixels[13] = 0.2140
    pixels[14] = 0.2140
    for at in 0..<(usize)4:
        pixels[at * 4 + 3] = 1.0
    var tiles = try Tiles.create(device, 4, 1)
    try tiles.write(pixels)
    try document.set_tiles(layer, tiles)
    try adjuster.apply(&document, layer, kind, values)
    let current = (document.find(layer) else trap("layer")).tiles() else trap("tiles")
    try current.read(pixels)

func near(a: f32, b: f64, tolerance: f64 = 0.02) -> bool:
    return math.abs((f64)a - b) < tolerance

test "the wider adjustments: levels by channel, hue ranges, exposure, black and white, balance, gradient map":
    var device = gpu.Device.open() catch failure:
        assert(failure.code == gpu.unavailable)
        return
    defer device.destroy()
    var adjuster = try Adjuster.create(device)
    defer adjuster.destroy()
    let pixels = try new f32[16] --- in memory.heap
    defer free(pixels) in memory.heap
    # Levels on the red channel alone: output white 0.5 halves red's encoded value; green and blue keep theirs.
    try adjusted(device, &adjuster, levels, [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.5], pixels)
    assert(near(pixels[0], 0.2140) and near(pixels[5], 1.0) and near(pixels[10], 1.0))
    # A reds-only hue turn of a third makes red green and leaves green alone.
    var hue: f64[23]
    for index in 0..<(usize)23:
        hue[index] = 0.0
    hue[3] = 1.0 / 3.0
    try adjusted(device, &adjuster, hue_saturation, hue[..<23], pixels)
    assert(near(pixels[0], 0.0) and near(pixels[1], 1.0) and near(pixels[5], 1.0) and near(pixels[4], 0.0))
    # Colorize: everything takes the master's hue (blue) and saturation.
    hue[3] = 0.0
    hue[0] = 2.0 / 3.0
    hue[1] = 1.0
    hue[21] = 1.0
    try adjusted(device, &adjuster, hue_saturation, hue[..<23], pixels)
    assert(pixels[2] > pixels[0] and pixels[6] > pixels[5] and pixels[14] > pixels[12])
    # One stop more exposure doubles light.
    try adjusted(device, &adjuster, exposure, [1.0, 0.0, 1.0], pixels)
    assert(near(pixels[12], 0.4280) and near(pixels[0], 1.0))
    # Black and white: red counted fully, green not at all.
    try adjusted(device, &adjuster, black_white, [1.0, 0.6, 0.0, 0.6, 0.2, 0.8, 0.0, 0.0, 0.0], pixels)
    assert(near(pixels[0], 1.0) and near(pixels[1], 1.0) and near(pixels[4], 0.0) and near(pixels[6], 0.0))
    # Color balance: midtones toward red warm the grey and keep it with luminosity preserved... roughly.
    try adjusted(device, &adjuster, color_balance, [0.0, 0.0, 0.0, 0.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], pixels)
    assert(pixels[12] > 0.3 and near(pixels[13], 0.2140))
    # Gradient map from black to red: the grey becomes a darker red.
    try adjusted(device, &adjuster, gradient_map, [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0], pixels)
    assert(pixels[12] > 0.0 and near(pixels[13], 0.0) and near(pixels[14], 0.0) and near(pixels[1], 0.0))

test "vignette, grain and noise depend on where a pixel is, the same across tiles":
    var device = gpu.Device.open() catch failure:
        assert(failure.code == gpu.unavailable)
        return
    defer device.destroy()
    var document = try Document.create(device, 512, 64)
    defer document.destroy()
    let layer = try document.add_layer("Grey")
    let count = (usize)512 * 64 * 4
    let pixels = try new f32[count] --- in memory.heap
    defer free(pixels) in memory.heap
    for at in 0..<(usize)512 * 64:
        for channel in 0..<(usize)3:
            pixels[at * 4 + channel] = 0.2140
        pixels[at * 4 + 3] = 1.0
    var tiles = try Tiles.create(device, 512, 64)
    try tiles.write(pixels)
    try document.set_tiles(layer, tiles)
    var adjuster = try Adjuster.create(device)
    defer adjuster.destroy()
    # A dark vignette leaves the centre and darkens the corners, symmetrically across the tile edge.
    let darken: f64[4] = [-1.0, 0.2, 0.0, 0.5]
    try adjuster.apply(&document, layer, vignette, darken)
    let current = (document.find(layer) else trap("layer")).tiles() else trap("tiles")
    try current.read(pixels)
    let centre = pixels[(32 * 512 + 256) * 4]
    let corner = pixels[(1 * 512 + 1) * 4]
    let mirrored = pixels[(1 * 512 + 510) * 4]
    assert(math.abs((f64)centre - 0.2140) < 0.01 and corner < 0.02 and math.abs((f64)corner - (f64)mirrored) < 0.002)
    # Grain moves greys in step across the channels; noise moves them apart.
    for at in 0..<(usize)512 * 64:
        for channel in 0..<(usize)3:
            pixels[at * 4 + channel] = 0.2140
    try current.write(pixels)
    let grainy: f64[3] = [0.5, 1.0, 1.0]
    try adjuster.apply(&document, layer, grain, grainy)
    try current.read(pixels)
    var moved = 0
    for x in 250..<(usize)262:
        let at = (10 * 512 + x) * 4
        assert(pixels[at] == pixels[at + 1] and pixels[at + 1] == pixels[at + 2])
        if math.abs((f64)pixels[at] - 0.2140) > 0.002:
            moved += 1
    assert(moved >= 8)
    for at in 0..<(usize)512 * 64:
        for channel in 0..<(usize)3:
            pixels[at * 4 + channel] = 0.2140
    try current.write(pixels)
    let noisy: f64[3] = [0.2, 0.0, 0.0]
    try adjuster.apply(&document, layer, noise, noisy)
    try current.read(pixels)
    var apart = 0
    for x in 0..<(usize)16:
        let at = (5 * 512 + x) * 4
        if pixels[at] != pixels[at + 1]:
            apart += 1
    assert(apart >= 12)

test "camera raw warms with temperature, brightens with exposure and leaves grey grey at rest":
    var device = gpu.Device.open() catch failure:
        assert(failure.code == gpu.unavailable)
        return
    defer device.destroy()
    var adjuster = try Adjuster.create(device)
    defer adjuster.destroy()
    let pixels = try new f32[16] --- in memory.heap
    defer free(pixels) in memory.heap
    let rest: f64[10] = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
    try adjusted(device, &adjuster, camera_raw, rest, pixels)
    assert(math.abs((f64)pixels[12] - 0.2140) < 0.003 and math.abs((f64)pixels[14] - 0.2140) < 0.003)
    let warm: f64[10] = [1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
    try adjusted(device, &adjuster, camera_raw, warm, pixels)
    assert(pixels[12] > pixels[14] + 0.05 and pixels[13] > 0.3)

test "replace color shifts only what is near the samples, and a subtracted sample takes it back":
    var device = gpu.Device.open() catch failure:
        assert(failure.code == gpu.unavailable)
        return
    defer device.destroy()
    var adjuster = try Adjuster.create(device)
    defer adjuster.destroy()
    let pixels = try new f32[16] --- in memory.heap
    defer free(pixels) in memory.heap
    # Red sampled, a third of a turn: red turns green, the others stay.
    let reds: f64[8] = [1.0 / 3.0, 0.0, 0.0, 40.0, 1.0, 1.0, 0.0, 0.0]
    try adjusted(device, &adjuster, replace_color, reds, pixels)
    assert(near(pixels[0], 0.0) and near(pixels[1], 1.0) and near(pixels[2], 0.0))
    assert(near(pixels[4], 0.0) and near(pixels[5], 1.0) and near(pixels[10], 1.0) and near(pixels[12], 0.2140, 0.003))
    # The same red also subtracted: nothing is replaced.
    let taken: f64[11] = [1.0 / 3.0, 0.0, 0.0, 40.0, 2.0, 1.0, 0.0, 0.0, -2.0, 0.0, 0.0]
    try adjusted(device, &adjuster, replace_color, taken, pixels)
    assert(near(pixels[0], 1.0) and near(pixels[1], 0.0))
    # The grey alone at no fuzziness, lightened all the way: white, the red untouched.
    let grey: f64[8] = [0.0, 0.0, 1.0, 0.0, 1.0, 0.2140, 0.2140, 0.2140]
    try adjusted(device, &adjuster, replace_color, grey, pixels)
    assert(near(pixels[12], 1.0) and near(pixels[0], 1.0) and near(pixels[1], 0.0))