///|
/// CPU image filters for `Image` buffers (port of p5.js image/filters.js).
/// Filter name and parameters mirror p5's `filter()` calls.
///|
/// Converts to a byte like `Uint8ClampedArray`: clamp, round half to even.
fn filter_byte(value : Double) -> Byte {
if value.is_nan() || value <= 0.0 {
return (0 : Byte)
}
if value >= 255.0 {
return (255 : Byte)
}
let floor = value.floor()
let diff = value - floor
let rounded = if diff > 0.5 {
floor + 1.0
} else if diff < 0.5 {
floor
} else if floor.to_int() % 2 == 0 {
floor
} else {
floor + 1.0
}
rounded.to_int().to_byte()
}
///|
fn filter_luma(pixels : FixedArray[Byte], index : Int32) -> Double {
0.2126 * pixels[index].to_uint().to_double() +
0.7152 * pixels[index + 1].to_uint().to_double() +
0.0722 * pixels[index + 2].to_uint().to_double()
}
///|
fn filter_threshold(pixels : FixedArray[Byte], level : Double) -> Unit {
let threshold = (level * 255.0).floor()
let mut index = 0
while index + 3 < pixels.length() {
let value : Byte = if filter_luma(pixels, index) >= threshold {
(255 : Byte)
} else {
(0 : Byte)
}
pixels[index] = value
pixels[index + 1] = value
pixels[index + 2] = value
index = index + 4
}
}
///|
fn filter_gray(pixels : FixedArray[Byte]) -> Unit {
let mut index = 0
while index + 3 < pixels.length() {
let value = filter_byte(filter_luma(pixels, index))
pixels[index] = value
pixels[index + 1] = value
pixels[index + 2] = value
index = index + 4
}
}
///|
fn filter_opaque(pixels : FixedArray[Byte]) -> Unit {
let mut index = 3
while index < pixels.length() {
pixels[index] = (255 : Byte)
index = index + 4
}
}
///|
fn filter_invert(pixels : FixedArray[Byte]) -> Unit {
let mut index = 0
while index + 3 < pixels.length() {
pixels[index] = (255 - pixels[index].to_uint().reinterpret_as_int()).to_byte()
pixels[index + 1] = (255 - pixels[index + 1].to_uint().reinterpret_as_int()).to_byte()
pixels[index + 2] = (255 - pixels[index + 2].to_uint().reinterpret_as_int()).to_byte()
index = index + 4
}
}
///|
fn filter_posterize(pixels : FixedArray[Byte], levels : Int32) -> Unit {
let levels = levels.max(2).min(255)
let levels_minus = (levels - 1).to_double()
let map = fn(value : Byte) {
filter_byte(
((value.to_uint().reinterpret_as_int() * levels) >> 8).to_double() *
255.0 /
levels_minus,
)
}
let mut index = 0
while index + 3 < pixels.length() {
pixels[index] = map(pixels[index])
pixels[index + 1] = map(pixels[index + 1])
pixels[index + 2] = map(pixels[index + 2])
index = index + 4
}
}
///|
fn filter_luma_index(pixels : FixedArray[Byte], pixel_index : Int32) -> Int32 {
let index = pixel_index * 4
77 * pixels[index].to_uint().reinterpret_as_int() +
151 * pixels[index + 1].to_uint().reinterpret_as_int() +
28 * pixels[index + 2].to_uint().reinterpret_as_int()
}
///|
fn filter_morph(
pixels : FixedArray[Byte],
width : Int32,
dilate : Bool,
) -> Unit {
let count = pixels.length() / 4
if width <= 0 || count == 0 {
return
}
let output = FixedArray::make(count, (0 : Int32))
for index in 0..= row_end { index } else { index + 1 }
let up = if index - width < 0 { 0 } else { index - width }
let down = if index + width >= count { index } else { index + width }
let mut best = index
let mut best_luma = filter_luma_index(pixels, index)
for neighbor in [left, right, up, down] {
let luma = filter_luma_index(pixels, neighbor)
if (dilate && luma > best_luma) || (!dilate && luma < best_luma) {
best = neighbor
best_luma = luma
}
}
output[index] = best
}
let source = pixels.copy()
for index in 0.. Unit {
let radius = radius.round().to_int()
if radius < 1 || width <= 0 {
return
}
let height = pixels.length() / 4 / width
let buffer = FixedArray::make(pixels.length(), 0.0)
for index in 0..<(pixels.length() / 4) {
let alpha = pixels[index * 4 + 3].to_uint().to_double() / 255.0
buffer[index * 4] = pixels[index * 4].to_uint().to_double() * alpha
buffer[index * 4 + 1] = pixels[index * 4 + 1].to_uint().to_double() * alpha
buffer[index * 4 + 2] = pixels[index * 4 + 2].to_uint().to_double() * alpha
buffer[index * 4 + 3] = alpha
}
let temp = FixedArray::make(pixels.length(), 0.0)
let pass = fn(
source : FixedArray[Double],
destination : FixedArray[Double],
horizontal : Bool,
) {
let (outer, inner) = if horizontal {
(height, width)
} else {
(width, height)
}
for o in 0..= 0 {
sum = sum - source[index(subtract) + channel]
count = count - 1
}
}
}
}
}
for _ in 0..<3 {
pass(buffer, temp, true)
pass(temp, buffer, false)
}
for index in 0..<(pixels.length() / 4) {
let alpha = buffer[index * 4 + 3]
let inverse = if alpha > 0.0 { 1.0 / alpha } else { 0.0 }
pixels[index * 4] = filter_byte(buffer[index * 4] * inverse)
pixels[index * 4 + 1] = filter_byte(buffer[index * 4 + 1] * inverse)
pixels[index * 4 + 2] = filter_byte(buffer[index * 4 + 2] * inverse)
pixels[index * 4 + 3] = filter_byte(alpha * 255.0)
}
}
///|
/// Applies a CPU filter in place, like p5's `filter()` on a graphics buffer.
pub fn Image::filter(self : Image, filter : Filter) -> Unit {
match filter {
Threshold(level) => filter_threshold(self.pixels, level)
Gray => filter_gray(self.pixels)
Opaque => filter_opaque(self.pixels)
Invert => filter_invert(self.pixels)
Posterize(levels) => filter_posterize(self.pixels, levels)
Blur(radius) => filter_blur(self.pixels, self.width_, radius)
Erode => filter_morph(self.pixels, self.width_, false)
Dilate => filter_morph(self.pixels, self.width_, true)
}
}
///|
/// Returns a tinted copy (RGB multiplied by `tint`; alpha multiplied too).
pub fn Image::tinted(self : Image, tint : Color) -> Image {
let output = self.copy()
let mut index = 0
while index + 3 < output.pixels.length() {
output.pixels[index] = filter_byte(
output.pixels[index].to_uint().to_double() * tint.r,
)
output.pixels[index + 1] = filter_byte(
output.pixels[index + 1].to_uint().to_double() * tint.g,
)
output.pixels[index + 2] = filter_byte(
output.pixels[index + 2].to_uint().to_double() * tint.b,
)
output.pixels[index + 3] = filter_byte(
output.pixels[index + 3].to_uint().to_double() * tint.a,
)
index = index + 4
}
output
}