///|
fn lum(c : Array[Double]) -> Double {
0.3 * c[0] + 0.59 * c[1] + 0.11 * c[2]
}
///|
fn sat(c : Array[Double]) -> Double {
c[0].max(c[1]).max(c[2]) - c[0].min(c[1]).min(c[2])
}
///|
fn set_lum(c : Array[Double], l : Double) -> Array[Double] {
let d = l - lum(c)
let r = c.map(fn(v) { v + d })
let n = r[0].min(r[1]).min(r[2])
let x = r[0].max(r[1]).max(r[2])
if n < 0.0 {
for i in 0..<3 {
r[i] = l + (r[i] - l) * l / (l - n)
}
}
if x > 1.0 {
for i in 0..<3 {
r[i] = l + (r[i] - l) * (1.0 - l) / (x - l)
}
}
r
}
///|
fn set_sat(c : Array[Double], s : Double) -> Array[Double] {
let lo = c[0].min(c[1]).min(c[2])
let hi = c[0].max(c[1]).max(c[2])
if hi == lo {
[0.0, 0.0, 0.0]
} else {
c.map(fn(v) { (v - lo) * s / (hi - lo) })
}
}
///|
fn channel(b : Double, s : Double, op : String) -> Double {
match op {
"svg:multiply" => b * s
"svg:screen" => b + s - b * s
"svg:overlay" =>
if b <= 0.5 {
2.0 * b * s
} else {
1.0 - 2.0 * (1.0 - b) * (1.0 - s)
}
"svg:darken" => b.min(s)
"svg:lighten" => b.max(s)
"svg:color-dodge" =>
if b == 0.0 {
0.0
} else if s == 1.0 {
1.0
} else {
(b / (1.0 - s)).min(1.0)
}
"svg:color-burn" =>
if b == 1.0 {
1.0
} else if s == 0.0 {
0.0
} else {
1.0 - ((1.0 - b) / s).min(1.0)
}
"svg:hard-light" =>
if s <= 0.5 {
2.0 * b * s
} else {
1.0 - 2.0 * (1.0 - b) * (1.0 - s)
}
"svg:soft-light" =>
if s <= 0.5 {
b - (1.0 - 2.0 * s) * b * (1.0 - b)
} else {
let d = if b <= 0.25 {
((16.0 * b - 12.0) * b + 4.0) * b
} else {
b.sqrt()
}
b + (2.0 * s - 1.0) * (d - b)
}
"svg:difference" => (b - s).abs()
_ => s
}
}
///|
pub fn composite_pixel(
backdrop : Array[Double],
source : Array[Double],
op : String,
) -> Array[Double] raise OraError {
if backdrop.length() != 4 || source.length() != 4 {
raise InvalidDocument("Pixel requires four channels")
}
for
v in [
backdrop[0],
backdrop[1],
backdrop[2],
backdrop[3],
source[0],
source[1],
source[2],
source[3],
] {
if v.is_nan() || v < 0.0 || v > 1.0 {
raise InvalidDocument("Pixel channels must be finite in [0,1]")
}
}
let ab = backdrop[3]
let a = source[3]
let blend = match op {
"svg:hue" => set_lum(set_sat(source, sat(backdrop)), lum(backdrop))
"svg:saturation" => set_lum(set_sat(backdrop, sat(source)), lum(backdrop))
"svg:color" => set_lum(source, lum(backdrop))
"svg:luminosity" => set_lum(backdrop, lum(source))
"svg:src-over"
| "svg:multiply"
| "svg:screen"
| "svg:overlay"
| "svg:darken"
| "svg:lighten"
| "svg:color-dodge"
| "svg:color-burn"
| "svg:hard-light"
| "svg:soft-light"
| "svg:difference"
| "svg:plus"
| "svg:dst-in"
| "svg:dst-out"
| "svg:src-atop"
| "svg:dst-atop" =>
[
channel(backdrop[0], source[0], op),
channel(backdrop[1], source[1], op),
channel(backdrop[2], source[2], op),
]
_ => raise Unsupported("Unknown composite operation: " + op)
}
let (fa, fb) = match op {
"svg:dst-in" => (0.0, a)
"svg:dst-out" => (0.0, 1.0 - a)
"svg:src-atop" => (ab, 1.0 - a)
"svg:dst-atop" => (1.0 - ab, a)
"svg:plus" => (1.0, 1.0)
_ => (1.0, 1.0 - a)
}
let alpha = (a * fa + ab * fb).min(1.0)
let out = [0.0, 0.0, 0.0, alpha]
if alpha > 0.0 {
for i in 0..<3 {
let cs = if op == "svg:plus" ||
op == "svg:dst-in" ||
op == "svg:dst-out" ||
op == "svg:src-atop" ||
op == "svg:dst-atop" {
source[i]
} else {
(1.0 - ab) * source[i] + ab * blend[i]
}
out[i] = ((a * fa * cs + ab * fb * backdrop[i]).min(1.0) / alpha)
.max(0.0)
.min(1.0)
}
}
out
}