Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-color

Source of release 0.8.2

0.8.2 / tests / icc / transfer_function.lucb

#==============================================================================================
#
#   tests/icc/transfer_function - kinds, values and inverses of transfer functions
#
#==============================================================================================

test "transfer functions are classified as skcms classifies them":
    assert(srgb_transfer_function.kind() == .srgbish and srgb_inverse_transfer_function.kind() == .srgbish)
    assert(TransferFunction.pq(203.0).kind() == .pq and TransferFunction.hlg(203.0, 1000.0, 1.2).kind() == .hlg)
    let pqish = TransferFunction.pqish(-107.0 / 128.0, 1.0, 32.0 / 2523.0, 2413.0 / 128.0, -2392.0 / 128.0, 8192.0 / 1305.0)
    assert(pqish.is_pqish() and TransferFunction.hlgish(2.0, 2.0, 5.6, 0.28, 0.55).is_hlgish())
    # Negative a, c, d or g, a non-whole marker, an unknown marker and a stray PQ field fail.
    assert(TransferFunction(g = 2.2, a = -1.0, b = 0.0, c = 0.0, d = 0.0, e = 0.0, f = 0.0).kind() == .invalid)
    assert(TransferFunction(g = -2.5, a = 1.0, b = 0.0, c = 0.0, d = 0.0, e = 0.0, f = 0.0).kind() == .invalid)
    assert(TransferFunction(g = -7.0, a = 1.0, b = 0.0, c = 0.0, d = 0.0, e = 0.0, f = 0.0).kind() == .invalid)
    assert(TransferFunction(g = -5.0, a = 203.0, b = 1.0, c = 0.0, d = 0.0, e = 0.0, f = 0.0).kind() == .invalid)
    assert(TransferFunction(g = 2.2, a = 1.0, b = -1.0, c = 0.0, d = 0.5, e = 0.0, f = 0.0).kind() == .invalid)

test "transfer functions evaluate to skcms's bits":
    assert(has_bits(srgb_transfer_function.eval(0.5), 0x3e5b2100))
    # Negative inputs mirror.
    assert(has_bits(srgb_transfer_function.eval(-0.25), 0xbd5056c0))
    assert(has_bits(srgb_inverse_transfer_function.eval(0.2), 0x3ef81600))
    assert(has_bits(TransferFunction.pq(203.0).eval(0.5), 0x3c172b80))
    assert(has_bits(TransferFunction.hlg(203.0, 1000.0, 1.2).eval(0.75), 0x3e87a958))
    let pqish = TransferFunction.pqish(-107.0 / 128.0, 1.0, 32.0 / 2523.0, 2413.0 / 128.0, -2392.0 / 128.0, 8192.0 / 1305.0)
    assert(has_bits(pqish.eval(0.5), 0x3c172b80))
    let hlgish = TransferFunction.hlgish(2.0, 2.0, 1.0 / 0.17883277, 0.28466892, 0.55991073)
    assert(has_bits(hlgish.eval(0.8), 0x4083a042))
    let invalid = TransferFunction(g = -9.0, a = 1.0, b = 0.0, c = 0.0, d = 0.0, e = 0.0, f = 0.0)
    assert(invalid.eval(0.5) == 0.0)

test "inverses are skcms's and keep f(1) at 1":
    let inv = srgb_transfer_function.invert() else trap("sRGB inverts")
    assert(tf_has_bits(&inv, [0x3ed55555, 0x3f919280, 0x80000000, 0x414eb852, 0x3b4d2e31, 0xbd612800, 0x80000000]))
    assert(same_transfer_function(&inv, &srgb_inverse_transfer_function))
    assert(inv.eval(srgb_transfer_function.eval(1.0)) == 1.0)
    let pqish = TransferFunction.pqish(-107.0 / 128.0, 1.0, 32.0 / 2523.0, 2413.0 / 128.0, -2392.0 / 128.0, 8192.0 / 1305.0)
    let pq_inv = pqish.invert() else trap("PQ-ish inverts")
    assert(tf_has_bits(&pq_inv, [0xc0000000, 0x3f560000, 0x4196d000, 0x3e232000, 0x3f800000, 0x41958000, 0x429db000]))
    assert(has_bits(pq_inv.eval(0.25), 0x3f59f040))
    let hlgish = TransferFunction.hlgish(2.0, 2.0, 1.0 / 0.17883277, 0.28466892, 0.55991073)
    let hlg_inv = hlgish.invert() else trap("HLG-ish inverts")
    assert(hlg_inv.kind() == .hlginvish)
    assert(tf_has_bits(&hlg_inv, [0xc0800000, 0x3f000000, 0x3f000000, 0x3e371ff0, 0x3e91c020, 0x3f0f564f, 0x00000000]))
    assert(has_bits(hlg_inv.eval(3.0), 0x3f3d1185))
    let back = hlg_inv.invert() else trap("HLG-inv-ish inverts")
    assert(back.kind() == .hlgish)
    # PQ and HLG proper, and a discontinuous curve, do not invert.
    assert(TransferFunction.pq(203.0).invert() == none and TransferFunction.hlg(203.0, 1000.0, 1.2).invert() == none)
    let broken = TransferFunction(g = 2.4, a = 1.0, b = 0.0, c = 1.0, d = 0.5, e = 0.0, f = 0.1)
    assert(broken.invert() == none)

test "a tabulated curve evaluates and is approximated":
    let p = test_profile("gray-ktrc.icc")
    let curve = p.trc[0]
    assert(curve.table_entries == 1024 and curve.table_16.length == 2048)
    assert(curve.eval(0.0) == 0.0 and curve.eval(1.0) == 1.0 and curve.eval(2.0) == 1.0 and curve.eval(-1.0) == 0.0)
    assert(near(curve.eval(0.5), srgb_transfer_function.eval(0.5), 0.0001))
    let (tf, err) = curve.approximate() else trap("the table approximates")
    assert(tf_has_bits(&tf, [0x40195095, 0x3f731500, 0x3d4aa055, 0x3d9f26b5, 0x3d382e0c, 0x39b60000, 0x00000000]))
    assert(has_bits(err, 0x3b0130c0))
    assert(curve.are_approximate_inverses(&srgb_inverse_transfer_function))
    # A parametric curve has nothing to approximate.
    let parametric = Curve(parametric = srgb_transfer_function)
    assert(parametric.approximate() == none)