http://mathling.com/colour/tonemap  library module

Variable: $HABLIC-DEFAULTS as xs:double*

Default Hablic constants
A=shoulder strength, B=linear strength, C=linear angle,
D=toe strength, E=toe numerator, F=toe denominator, E/F=toe angle

Function: ACES
declare function ACES($colour as map(xs:string,item()*)) as map(xs:string,item()*)

ACES()
Perform ACES (Academy Color Encoding System) filmic tone mapping

Params

• colour as map(xs:string,item()*): XYZ colour

Returns

• map(xs:string,item()*): remapped XYZ colour point

declare function this:ACES(
  $colour as map(xs:string,item()*)
) as map(xs:string,item()*)
{
  this:ACESv($colour=>xyz:raw-coordinates())=>xyz:to-xyz()
}

Function: ACESv
declare function ACESv($colour as xs:double*) as xs:double*

ACESv()
Perform ACES (Academy Color Encoding System) filmic tone mapping

Params

• colour as xs:double*: XYZ input colour as raw coordinates

Returns

• xs:double*: remapped XYZ colour vector

declare function this:ACESv(
  $colour as xs:double*
) as xs:double*
{
  (: Multiply input matrix by input colour :)
  let $v := (
    v:dot((0.59719E0, 0.35458E0, 0.04823E0), $colour),
    v:dot((0.07600E0, 0.90834E0, 0.01566E0), $colour),
    v:dot((0.02840E0, 0.13383E0, 0.84777E0), $colour)
  )
  (: Curve fitting :)
  let $a := (: v * (v + 0.0245786) - 0.000090537 :)
    $v=>
      v:multiply($v=>v:plus(0.0245786E0))=>
      v:plus(-0.000090537E0)
  let $b := (: v * (0.983729 * v + 0.4329510) + 0.238081 :)
    $v=>
      v:multiply(($v=>v:times(0.983729E0))=>v:plus(0.4329510E0))=>
      v:plus(0.238081E0)
  let $ab := $a=>v:divide($b)
  (: Multiply by output matrix to get output colour :)
  let $m2ab := (
    (1.60475E0, -0.53108E0, -0.07367E0)=>v:dot($ab),
    (-0.10208E0, 1.10813E0, -0.00605E0)=>v:dot($ab),
    (-0.00327E0, -0.07276E0, 1.07602E0)=>v:dot($ab)
  )
  return (
    $m2ab
  )
}

Function: Hablic
declare function Hablic($colour as map(xs:string,item()*)) as map(xs:string,item()*)

Hablic()
Hablic tone mapping with default values.

Params

• colour as map(xs:string,item()*): XYZ point

Returns

• map(xs:string,item()*): remapped XYZ colour point

declare function this:Hablic(
  $colour as map(xs:string,item()*)
) as map(xs:string,item()*)
{
  this:Hablic($colour, 2.0E0, 11.2E0, $this:HABLIC-DEFAULTS)
}

Function: Hablicv
declare function Hablicv($colour as xs:double*) as xs:double*

Hablicv()
Hablic tone mapping with default values.

Params

• colour as xs:double*: XYZ input colour as raw coordinates

Returns

• xs:double*: remapped XYZ colour vector

declare function this:Hablicv($colour as xs:double*) as xs:double*
{
  this:Hablicv($colour, 2.0E0, 11.2E0, $this:HABLIC-DEFAULTS)
}

Function: Hablic
declare function Hablic($colour as map(xs:string,item()*),
  $exposure as xs:double) as map(xs:string,item()*)

Hablic()
Hablic tone mapping with default values except for exposure.

Params

• colour as map(xs:string,item()*): XYZ input colour as raw coordinates
• exposure as xs:double: amount of exposure

Returns

• map(xs:string,item()*): remapped XYZ colour point

declare function this:Hablic(
  $colour as map(xs:string,item()*),
  $exposure as xs:double
) as map(xs:string,item()*)
{
  this:Hablic($colour, $exposure, 11.2E0, $this:HABLIC-DEFAULTS)
}

Function: Hablicv
declare function Hablicv($colour as xs:double*,
  $exposure as xs:double) as xs:double*

Hablicv()
Hablic tone mapping with default values except for exposure.

Params

• colour as xs:double*: XYZ input colour as raw coordinates
• exposure as xs:double: amount of exposure

Returns

• xs:double*: remapped XYZ colour vector

declare function this:Hablicv(
  $colour as xs:double*,
  $exposure as xs:double
) as xs:double*
{
  this:Hablicv($colour, $exposure, 11.2E0, $this:HABLIC-DEFAULTS)
}

Function: Hablic
declare function Hablic($colour as map(xs:string,item()*),
  $exposure as xs:double,
  $white as xs:double) as map(xs:string,item()*)

Hablic()
Hablic tone mapping with default curve constants.

Params

• colour as map(xs:string,item()*): XYZ colour point
• exposure as xs:double: amount of exposure
• white as xs:double: white point

Returns

• map(xs:string,item()*): remapped XYZ colour point

declare function this:Hablic(
  $colour as map(xs:string,item()*),
  $exposure as xs:double,
  $white as xs:double
) as map(xs:string,item()*)
{
  this:Hablic($colour, $exposure, $white, $this:HABLIC-DEFAULTS)
}

Function: Hablicv
declare function Hablicv($colour as xs:double*,
  $exposure as xs:double,
  $white as xs:double) as xs:double*

Hablicv()
Hablic tone mapping with default curve constants.

Params

• colour as xs:double*: XYZ input colour as raw coordinates
• exposure as xs:double: amount of exposure
• white as xs:double: white point

Returns

• xs:double*: remapped XYZ colour vector

declare function this:Hablicv(
  $colour as xs:double*,
  $exposure as xs:double,
  $white as xs:double
) as xs:double*
{
  this:Hablicv($colour, $exposure, $white, $this:HABLIC-DEFAULTS)
}

Function: Hablic
declare function Hablic($colour as map(xs:string,item()*),
  $exposure as xs:double,
  $white as xs:double,
  $curve as xs:double*) as map(xs:string,item()*)

Hablic()
Hablic tone mapping with specific parameters.

Params

• colour as map(xs:string,item()*): XYZ colour point
• exposure as xs:double: amount of exposure
• white as xs:double: white point
• curve as xs:double*: Hablic constants in order (A, B, C, D, E, F)

Returns

• map(xs:string,item()*): remapped XYZ colour point

declare function this:Hablic(
  $colour as map(xs:string,item()*),
  $exposure as xs:double,
  $white as xs:double,
  $curve as xs:double*
) as map(xs:string,item()*)
{
  xyz:to-xyz(
    this:Hablic-partial(xyz:raw-coordinates($colour), $curve)=>
      v:divide(this:Hablic-partial($white, $curve))
  )
}

Function: Hablicv
declare function Hablicv($colour as xs:double*,
  $exposure as xs:double,
  $white as xs:double,
  $curve as xs:double*) as xs:double*

Hablicv()
Hablic tone mapping with specific parameters.

Params

• colour as xs:double*: XYZ input colour as raw coordinates
• exposure as xs:double: amount of exposure
• white as xs:double: white point
• curve as xs:double*: Hablic constants in order (A, B, C, D, E, F)

Returns

• xs:double*: remapped XYZ colour vector

declare function this:Hablicv(
  $colour as xs:double*,
  $exposure as xs:double,
  $white as xs:double,
  $curve as xs:double*
) as xs:double*
{
  this:Hablic-partial($colour, $curve)=>
    v:divide(this:Hablic-partial($white, $curve))
}

Function: simple-Reinhard
declare function simple-Reinhard($colour as map(xs:string,item()*)) as map(xs:string,item()*)

simple-Reinhard()
Basic Reinhard tonemapping: tends to grey out colours

Params

• colour as map(xs:string,item()*): XYZ colour point

Returns

• map(xs:string,item()*): remapped XYZ colour point

declare function this:simple-Reinhard(
  $colour as map(xs:string,item()*)
) as map(xs:string,item()*)
{
  xyz:to-xyz(this:simple-Reinhardv(xyz:raw-coordinates($colour)))
}

Function: simple-Reinhardv
declare function simple-Reinhardv($colour as xs:double) as xs:double*

simple-Reinhardv()
Basic Reinhard tonemapping: tends to grey out colours

Params

• colour as xs:double: XYZ input colour as raw coordinates

Returns

• xs:double*: remapped XYZ colour vector

declare function this:simple-Reinhardv(
  $colour as xs:double
) as xs:double*
{
  $colour=>v:divide($colour=>v:plus(1E0))
}

Function: Reinhard
declare function Reinhard($colour as map(xs:string,item()*),
  $white as xs:double) as map(xs:string,item()*)

Reinhard()
(Extended) Reinhard tonemapping with luminance

Params

• colour as map(xs:string,item()*): XYZ colour point
• white as xs:double: white point

Returns

• map(xs:string,item()*): remapped XYZ colour point

declare function this:Reinhard(
  $colour as map(xs:string,item()*),
  $white as xs:double
) as map(xs:string,item()*)
{
  xyz:to-xyz(this:Reinhardv(xyz:raw-coordinates($colour), $white))
}

Function: Reinhardv
declare function Reinhardv($colour as xs:double*,
  $white as xs:double) as xs:double*

Reinhardv()
(Extended) Reinhard tonemapping with luminance

Params

• colour as xs:double*: XYZ input colour as raw coordinates
• white as xs:double: white point

Returns

• xs:double*: remapped XYZ colour vector

declare function this:Reinhardv(
  $colour as xs:double*,
  $white as xs:double
) as xs:double*
{
  let $l-old := this:luminancev($colour)
  let $numerator := $l-old * (1E0 + ($l-old div ($white*$white)))
  let $l-new := $numerator div (1E0 + $l-old)
  return this:luminatev($colour, $l-new)
}

Function: luminance
declare function luminance($colour as map(xs:string,item()*)) as xs:double

luminance()
Get luminance of an XYZ value.

Params

• colour as map(xs:string,item()*): XYZ colour point

Returns

• xs:double: luminance of the colour

declare function this:luminance(
  $colour as map(xs:string,item()*)
) as xs:double
{
  xyz:raw-coordinates($colour)=>v:dot((0.2125E0, 0.7152E0, 0.0722E0))
}

Function: luminancev
declare function luminancev($colour as xs:double*) as xs:double

luminance()
Get luminance of an XYZ value.

Params

• colour as xs:double*: XYZ input colour as raw coordinates

Returns

• xs:double: luminance of the colour

declare function this:luminancev($colour as xs:double*) as xs:double
{
  let $res := $colour=>v:dot((0.2125E0, 0.7152E0, 0.0722E0))
  return (
    if (some $c in $res satisfies $c != $c) then (
      trace((), "luninance XYZ=>NaN: "||util:quote($colour))
    ) else (),
    $res
  )
}

Function: luminate
declare function luminate($colour as map(xs:string,item()*),
  $luminance as xs:double) as map(xs:string,item()*)

luminate()
Change the luminance to the new luminance.

Params

• colour as map(xs:string,item()*): XYZ input colour as raw coordinates
• luminance as xs:double: Output luminance

Returns

• map(xs:string,item()*): luminated XYZ colour point

declare function this:luminate(
  $colour as map(xs:string,item()*),
  $luminance as xs:double
) as map(xs:string,item()*)
{
  this:luminatev(xyz:raw-coordinates($colour), $luminance)=>xyz:to-xyz()
}

Function: luminatev
declare function luminatev($colour as xs:double*,
  $luminance as xs:double) as xs:double*

luminatev()
Change the luminance to the new luminance.

Params

• colour as xs:double*: XYZ input colour as raw coordinates
• luminance as xs:double: Output luminance

Returns

• xs:double*: luminated XYZ colour vector

declare function this:luminatev(
  $colour as xs:double*,
  $luminance as xs:double
) as xs:double*
{
  let $l := this:luminancev($colour)
  return
    if ($l = 0)
    then (0.0, 0.0, 0.0) (: black :)
    else $colour=>v:times($luminance div $l)
}

Function: shade
declare function shade($colour as map(xs:string,item()*),
  $brightness as xs:double) as map(xs:string,item()*)

shade()
Shade the colour by multiplying by the brightness value.
Unlike luminate in that we don't normalize by the actual brightness.

Params

• colour as map(xs:string,item()*): XYZ input colour as raw coordinates
• brightness as xs:double: Output brightness [0.0,1.0]

Returns

• map(xs:string,item()*): shaded XYZ colour point

declare function this:shade(
  $colour as map(xs:string,item()*),
  $brightness as xs:double
) as map(xs:string,item()*)
{
  this:shadev(xyz:raw-coordinates($colour), $brightness)=>xyz:to-xyz()
}

Function: shadev
declare function shadev($colour as xs:double*,
  $brightness as xs:double) as xs:double*

shadev()
Shade the colour by multiplying by the brightness value.

Params

• colour as xs:double*: XYZ input colour as raw coordinates
• brightness as xs:double: Output brightness [0.0,1.0]

Returns

• xs:double*: shaded XYZ colour vector

declare function this:shadev(
  $colour as xs:double*,
  $brightness as xs:double
) as xs:double*
{
  $colour=>v:times($brightness)
}

Function: saturate
declare function saturate($colour as map(xs:string,item()*)) as map(xs:string,item()*)

saturate()
Generally the final step in tone-mapping: clamping colour values
If you use just this you'll get washed out whites

Params

• colour as map(xs:string,item()*): XYZ colour point

Returns

• map(xs:string,item()*): clamped XYZ colour point

declare function this:saturate(
  $colour as map(xs:string,item()*)
) as map(xs:string,item()*)
{
  xyz:saturate($colour)
}

Function: saturatev
declare function saturatev($colour as xs:double*) as xs:double*

saturatev()
Generally the final step in tone-mapping: clamping colour values
If you use just this you'll get washed out whites

Params

• colour as xs:double*: XYZ input colour as raw coordinates

Returns

• xs:double*: clamped XYZ colour vector

declare function this:saturatev($colour as xs:double*) as xs:double*
{
  v:clamp($colour, 0.0E0, 1.0E0)
}

Function: gamma
declare function gamma($colour as map(xs:string,item()*)) as map(xs:string,item()*)

gamma()
Inverse OETF gamma correction assuming 2.2 gamma display

Params

• colour as map(xs:string,item()*): XYZ colour point

Returns

• map(xs:string,item()*): corrected XYZ colour point

declare function this:gamma(
  $colour as map(xs:string,item()*)
) as map(xs:string,item()*)
{
  this:gammav(xyz:raw-coordinates($colour))=>xyz:to-xyz()
}

Function: gammav
declare function gammav($colour as xs:double*) as xs:double*

gammav()
Inverse OETF gamma correction assuming 2.2 gamma display

Params

• colour as xs:double*: XYZ colour vector

Returns

• xs:double*: corrected XYZ colour vector

declare function this:gammav($colour as xs:double*) as xs:double*
{
  v:map(
    function($c as xs:double) { math:pow($c, 1E0 div 2.2E0) }, 
    $colour
  )
}

Function: cmyk-snap
declare function cmyk-snap($colour as map(xs:string,item()*)) as map(xs:string,item()*)

cmyk-snap()
Roundtrip to CMYK and back to get colours as printed.

Params

• colour as map(xs:string,item()*): RGB colour

Returns

• map(xs:string,item()*): RGB colour mapped through CMYK and back

declare function this:cmyk-snap(
  $colour as map(xs:string,item()*)
) as map(xs:string,item()*)
{
  $colour=>cs:rgb-to-cmyk()=>cs:cmyk-to-rgb()
}