dymokomi/luce-image
Source of release 0.45.0
## 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*)¶ms[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))