///|
/// Gabor-like filter parameters.
#derive(Debug)
pub(all) enum Gabor {
Disabled
/// Weights `[[w1, w2]; 3]` (per channel X, Y, B).
Enabled(FixedArray[FixedArray[Float]])
}
///|
pub fn Gabor::default() -> Gabor {
Enabled(FixedArray::makei(3, _ => [0.115169525, 0.061248592]))
}
///|
pub fn Gabor::parse(
bs : @bitstream.Bitstream,
) -> Gabor raise @bitstream.JxlError {
let gab_enabled = bs.read_bool()
if !gab_enabled {
return Disabled
}
let custom = bs.read_bool()
if !custom {
return Gabor::default()
}
let weights : FixedArray[FixedArray[Float]] = FixedArray::makei(3, _ => {
FixedArray::make(2, (0.0 : Float))
})
for chan_weight in weights {
for i in 0..<2 {
chan_weight[i] = bs.read_f16_as_f32()
}
let w0 : Float = chan_weight[0]
let w1 : Float = chan_weight[1]
if ((1.0 : Float) + (w0 + w1) * 4.0).abs() < f32_epsilon {
raise ValidationFailed(
"Gaborish weights lead to near 0 unnormalized kernel",
)
}
}
Enabled(weights)
}
///|
pub fn Gabor::enabled(self : Gabor) -> Bool {
self is Enabled(_)
}
///|
let f32_epsilon : Float = 1.1920929e-7
///|
#derive(Debug)
pub(all) enum EdgePreservingFilter {
Disabled
Enabled(EpfParams)
}
///|
#derive(Debug)
pub(all) struct EpfParams {
iters : Int32
sharp_lut : FixedArray[Float]
channel_scale : FixedArray[Float]
sigma : EpfSigma
sigma_for_modular : Float
}
///|
pub fn EdgePreservingFilter::enabled(self : EdgePreservingFilter) -> Bool {
self is Enabled(_)
}
///|
pub fn EdgePreservingFilter::default() -> EdgePreservingFilter {
Enabled(EpfParams::default())
}
///|
fn epf_sharp_lut_default() -> FixedArray[Float] {
[
0.0,
(1.0 : Float) / 7.0,
(2.0 : Float) / 7.0,
(3.0 : Float) / 7.0,
(4.0 : Float) / 7.0,
(5.0 : Float) / 7.0,
(6.0 : Float) / 7.0,
1.0,
]
}
///|
fn epf_channel_scale_default() -> FixedArray[Float] {
[40.0, 5.0, 3.5]
}
///|
pub fn EpfParams::default() -> EpfParams {
{
iters: 2,
sharp_lut: epf_sharp_lut_default(),
channel_scale: epf_channel_scale_default(),
sigma: EpfSigma::default(),
sigma_for_modular: 1.0,
}
}
///|
pub fn EdgePreservingFilter::parse(
bs : @bitstream.Bitstream,
encoding : Encoding,
) -> EdgePreservingFilter raise @bitstream.JxlError {
let iters = bs.read_bits(2).reinterpret_as_int()
if iters == 0 {
return Disabled
}
let sharp_custom = if encoding == VarDct { bs.read_bool() } else { false }
let sharp_lut = if sharp_custom {
let ret = FixedArray::make(8, (0.0 : Float))
for i in 0..<8 {
ret[i] = bs.read_f16_as_f32()
}
ret
} else {
epf_sharp_lut_default()
}
let weight_custom = bs.read_bool()
let channel_scale = if weight_custom {
let ret = FixedArray::make(3, (0.0 : Float))
for i in 0..<3 {
ret[i] = bs.read_f16_as_f32()
}
bs.read_bits(32) |> ignore // ignored
ret
} else {
epf_channel_scale_default()
}
let sigma_custom = bs.read_bool()
let sigma = if sigma_custom {
EpfSigma::parse(bs, encoding)
} else {
EpfSigma::default()
}
let sigma_for_modular : Float = if encoding == Modular {
bs.read_f16_as_f32()
} else {
1.0
}
Enabled({ iters, sharp_lut, channel_scale, sigma, sigma_for_modular, })
}
///|
#derive(Debug)
pub(all) struct EpfSigma {
quant_mul : Float
pass0_sigma_scale : Float
pass2_sigma_scale : Float
border_sad_mul : Float
}
///|
pub fn EpfSigma::default() -> EpfSigma {
{
quant_mul: 0.46,
pass0_sigma_scale: 0.9,
pass2_sigma_scale: 6.5,
border_sad_mul: (2.0 : Float) / 3.0,
}
}
///|
pub fn EpfSigma::parse(
bs : @bitstream.Bitstream,
encoding : Encoding,
) -> EpfSigma raise @bitstream.JxlError {
let quant_mul : Float = if encoding == VarDct {
bs.read_f16_as_f32()
} else {
0.46
}
let pass0_sigma_scale = bs.read_f16_as_f32()
let pass2_sigma_scale = bs.read_f16_as_f32()
let border_sad_mul = bs.read_f16_as_f32()
{ quant_mul, pass0_sigma_scale, pass2_sigma_scale, border_sad_mul, }
}