Repository: colour-science/colour

Issue:
Implement support for "hdr-CIELab" and "hdr-IPT" (2011) colourspaces.
References
---
- Fairchild, M. D., & Chen, P. (2011). Brightness , Lightness , and Specifying Color in High-Dynamic-Range Scenes and Images. doi:10.1117/12.872075
- #347 
- #321

Discussion:
KelSolaar: This one should be quick to review, it implements support for the 2011 parameterisation of *hdr-CIELAB* and *hdr-IPT*.
coveralls: 
[![Coverage Status](https://coveralls.io/builds/14584447/badge)](https://coveralls.io/builds/14584447)

Coverage increased (+0.01%) to 97.926% when pulling **2d6f04d257a19b30973ee93d130f6295d3c32623 on feature/hdr_cielab_ipt_2011** into **158bd4441886e49c0431e4b444298ed0426ac6d5 on develop**.

coveralls: 
[![Coverage Status](https://coveralls.io/builds/14584447/badge)](https://coveralls.io/builds/14584447)

Coverage increased (+0.01%) to 97.926% when pulling **2d6f04d257a19b30973ee93d130f6295d3c32623 on feature/hdr_cielab_ipt_2011** into **158bd4441886e49c0431e4b444298ed0426ac6d5 on develop**.

codacy-bot: 
![Codacy](https://www.codacy.com/assets/images/favicon.png) Here is an overview of what got changed by this pull request:


```diff

Complexity increasing per file
==============================
- colour/colorimetry/luminance.py  1
- colour/models/hdr_ipt.py  1
- colour/models/hdr_cie_lab.py  1
         
```


See the complete overview on [Codacy](https://www.codacy.com/app/colour-science/colour/pullRequest?prid=1190092&bid=6137186)
        

Patch:
diff --git a/colour/colorimetry/__init__.py b/colour/colorimetry/__init__.py
index edeadca44..c14274bca 100644
--- a/colour/colorimetry/__init__.py
+++ b/colour/colorimetry/__init__.py
@@ -21,11 +21,13 @@ from .lefs import (mesopic_luminous_efficiency_function,
 from .lightness import LIGHTNESS_METHODS
 from .lightness import lightness
 from .lightness import (lightness_Glasser1958, lightness_Wyszecki1963,
-                        lightness_CIE1976, lightness_Fairchild2010)
+                        lightness_CIE1976, lightness_Fairchild2010,
+                        lightness_Fairchild2011)
 from .luminance import LUMINANCE_METHODS
 from .luminance import luminance
 from .luminance import (luminance_Newhall1943, luminance_ASTMD153508,
-                        luminance_CIE1976, luminance_Fairchild2010)
+                        luminance_CIE1976, luminance_Fairchild2010,
+                        luminance_Fairchild2011)
 from .dominant import (dominant_wavelength, complementary_wavelength,
                        excitation_purity, colorimetric_purity)
 from .photometry import (luminous_flux, luminous_efficiency, luminous_efficacy)
@@ -74,13 +76,13 @@ __all__ += ['LIGHTNESS_METHODS']
 __all__ += ['lightness']
 __all__ += [
     'lightness_Glasser1958', 'lightness_Wyszecki1963', 'lightness_CIE1976',
-    'lightness_Fairchild2010'
+    'lightness_Fairchild2010', 'lightness_Fairchild2011'
 ]
 __all__ += ['LUMINANCE_METHODS']
 __all__ += ['luminance']
 __all__ += [
     'luminance_Newhall1943', 'luminance_ASTMD153508', 'luminance_CIE1976',
-    'luminance_Fairchild2010'
+    'luminance_Fairchild2010', 'luminance_Fairchild2011'
 ]
 __all__ += [
     'dominant_wavelength', 'complementary_wavelength', 'excitation_purity',
diff --git a/colour/colorimetry/lightness.py b/colour/colorimetry/lightness.py
index bcbaca685..19f02635f 100644
--- a/colour/colorimetry/lightness.py
+++ b/colour/colorimetry/lightness.py
@@ -17,6 +17,8 @@ The following methods are available:
     *luminance* :math:`Y` as per *CIE 1976* recommendation.
 -   :func:`lightness_Fairchild2010`: *Lightness* :math:`L_{hdr}` computation
     of given *luminance* :math:`Y` using *Fairchild and Wyble (2010)* method.
+-   :func:`lightness_Fairchild2011`: *Lightness* :math:`L_{hdr}` computation
+    of given *luminance* :math:`Y` using *Fairchild and Chen (2011)* method.
 
 See Also
 --------
@@ -48,7 +50,8 @@ __status__ = 'Production'
 
 __all__ = [
     'lightness_Glasser1958', 'lightness_Wyszecki1963', 'lightness_CIE1976',
-    'lightness_Fairchild2010', 'LIGHTNESS_METHODS', 'lightness'
+    'lightness_Fairchild2010', 'lightness_Fairchild2011', 'LIGHTNESS_METHODS',
+    'lightness'
 ]
 
 
@@ -183,7 +186,7 @@ def lightness_CIE1976(Y, Y_n=100):
     return Lstar
 
 
-def lightness_Fairchild2010(Y, epsilon=2):
+def lightness_Fairchild2010(Y, epsilon=1.836):
     """
     Computes *Lightness* :math:`L_{hdr}` of given *luminance* :math:`Y` using
     *Fairchild and Wyble (2010)* method according to *Michealis-Menten*
@@ -218,14 +221,73 @@ def lightness_Fairchild2010(Y, epsilon=2):
 
     Examples
     --------
-    >>> lightness_Fairchild2010(10.08 / 100, 1.836)  # doctest: +ELLIPSIS
+    >>> lightness_Fairchild2010(10.08 / 100)  # doctest: +ELLIPSIS
     24.9022902...
     """
 
+    maximum_perception = 100
+
     Y = np.asarray(Y)
 
-    L_hdr = reaction_rate_MichealisMenten(Y ** epsilon, 100, 0.184 **
-                                          epsilon) + 0.02
+    L_hdr = reaction_rate_MichealisMenten(Y ** epsilon, maximum_perception,
+                                          0.184 ** epsilon) + 0.02
+
+    return L_hdr
+
+
+def lightness_Fairchild2011(Y, epsilon=0.710, method='hdr-CIELAB'):
+    """
+    Computes *Lightness* :math:`L_{hdr}` of given *luminance* :math:`Y` using
+    *Fairchild and Chen (2011)* method accordingly to *Michealis-Menten*
+    kinetics.
+
+    Parameters
+    ----------
+    Y : array_like
+        *luminance* :math:`Y`.
+    epsilon : numeric or array_like, optional
+        :math:`\epsilon` exponent.
+    method : unicode, optional
+        **{'hdr-CIELAB', 'hdr-IPT'}**,
+        *Lightness* :math:`L_{hdr}` computation method.
+
+    Returns
+    -------
+    array_like
+        *Lightness* :math:`L_{hdr}`.
+
+    Warning
+    -------
+    The input domain of that definition is non standard!
+
+    Notes
+    -----
+    -   Input *luminance* :math:`Y` is in domain [0, :math:`\infty`].
+
+    References
+    ----------
+    .. [7]  Fairchild, M. D., & Chen, P. (2011). Brightness, Lightness, and
+            Specifying Color in High-Dynamic-Range Scenes and Images.
+            doi:10.1117/12.872075
+
+    Examples
+    --------
+    >>> lightness_Fairchild2011(10.08 / 100)  # doctest: +ELLIPSIS
+    26.45950981...
+    >>> lightness_Fairchild2011(10.08 / 100, method='hdr-IPT')
+    ... # doctest: +ELLIPSIS
+    26.3524672...
+    """
+
+    Y = np.asarray(Y)
+
+    if method.lower() == 'hdr-cielab':
+        maximum_perception = 247
+    else:
+        maximum_perception = 246
+
+    L_hdr = reaction_rate_MichealisMenten(Y ** epsilon, maximum_perception, 2
+                                          ** epsilon) + 0.02
 
     return L_hdr
 
@@ -234,13 +296,15 @@ LIGHTNESS_METHODS = CaseInsensitiveMapping({
     'Glasser 1958': lightness_Glasser1958,
     'Wyszecki 1963': lightness_Wyszecki1963,
     'CIE 1976': lightness_CIE1976,
-    'Fairchild 2010': lightness_Fairchild2010
+    'Fairchild 2010': lightness_Fairchild2010,
+    'Fairchild 2011': lightness_Fairchild2011
 })
 """
 Supported *Lightness* computations methods.
 
 LIGHTNESS_METHODS : CaseInsensitiveMapping
-    **{'Glasser 1958', 'Wyszecki 1963', 'CIE 1976', 'Fairchild 2010'}**
+    **{'Glasser 1958', 'Wyszecki 1963', 'CIE 1976', 'Fairchild 2010',
+    'Fairchild 2011'}**
 
 Aliases:
 
@@ -258,7 +322,8 @@ def lightness(Y, method='CIE 1976', **kwargs):
     Y : numeric or array_like
         *luminance* :math:`Y`.
     method : unicode, optional
-        **{'CIE 1976', 'Glasser 1958', 'Wyszecki 1963', 'Fairchild 2010'}**,
+        **{'CIE 1976', 'Glasser 1958', 'Wyszecki 1963', 'Fairchild 2010',
+        'Fairchild 2011'}**,
         Computation method.
 
     Other Parameters
@@ -267,7 +332,7 @@ def lightness(Y, method='CIE 1976', **kwargs):
         {:func:`lightness_CIE1976`},
         White reference *luminance* :math:`Y_n`.
     epsilon : numeric or array_like, optional
-        {:func:`lightness_Fairchild2010`},
+        {:func:`lightness_Fairchild2010`, :func:`lightness_Fairchild2011`},
         :math:`\epsilon` exponent.
 
     Returns
diff --git a/colour/colorimetry/luminance.py b/colour/colorimetry/luminance.py
index 9af677107..8e60fe58e 100644
--- a/colour/colorimetry/luminance.py
+++ b/colour/colorimetry/luminance.py
@@ -17,6 +17,8 @@ The following methods are available:
     *Lightness* :math:`L^*` as per *CIE 1976* recommendation.
 -   :func:`luminance_Fairchild2010`: *luminance* :math:`Y` computation of given
     *Lightness* :math:`L_{hdr}` using *Fairchild and Wyble (2010)* method.
+-   :func:`luminance_Fairchild2011`: *luminance* :math:`Y` computation of given
+    *Lightness* :math:`L_{hdr}` using *Fairchild and Chen (2011)* method.
 
 See Also
 --------
@@ -42,7 +44,8 @@ __status__ = 'Production'
 
 __all__ = [
     'luminance_Newhall1943', 'luminance_ASTMD153508', 'luminance_CIE1976',
-    'luminance_Fairchild2010', 'LUMINANCE_METHODS', 'luminance'
+    'luminance_Fairchild2010', 'luminance_Fairchild2011', 'LUMINANCE_METHODS',
+    'luminance'
 ]
 
 
@@ -175,7 +178,7 @@ def luminance_CIE1976(Lstar, Y_n=100):
     return Y
 
 
-def luminance_Fairchild2010(L_hdr, epsilon=2):
+def luminance_Fairchild2010(L_hdr, epsilon=1.836):
     """
     Computes *luminance* :math:`Y` of given *Lightness* :math:`L_{hdr}` using
     *Fairchild and Wyble (2010)* method according to *Michealis-Menten*
@@ -225,11 +228,71 @@ def luminance_Fairchild2010(L_hdr, epsilon=2):
     return Y
 
 
+def luminance_Fairchild2011(L_hdr, epsilon=0.710, method='hdr-CIELAB'):
+    """
+    Computes *luminance* :math:`Y` of given *Lightness* :math:`L_{hdr}` using
+    *Fairchild and Chen (2011)* method accordingly to *Michealis-Menten*
+    kinetics.
+
+    Parameters
+    ----------
+    L_hdr : array_like
+        *Lightness* :math:`L_{hdr}`.
+    epsilon : numeric or array_like, optional
+        :math:`\epsilon` exponent.
+    method : unicode, optional
+        **{'hdr-CIELAB', 'hdr-IPT'}**,
+        *Lightness* :math:`L_{hdr}` computation method.
+
+    Returns
+    -------
+    array_like
+        *luminance* :math:`Y`.
+
+    Warning
+    -------
+    The output range of that definition is non standard!
+
+    Notes
+    -----
+    -   Output *luminance* :math:`Y` is in range [0, math:`\infty`].
+
+    References
+    ----------
+    .. [5]  Fairchild, M. D., & Chen, P. (2011). Brightness, Lightness, and
+            Specifying Color in High-Dynamic-Range Scenes and Images.
+            doi:10.1117/12.872075
+
+    Examples
+    --------
+    >>> luminance_Fairchild2011(26.459509817572265)  # doctest: +ELLIPSIS
+    0.1007999...
+    >>> luminance_Fairchild2011(26.352467267703549, method='hdr-IPT')
+    ... # doctest: +ELLIPSIS
+    0.1007999...
+    """
+
+    L_hdr = np.asarray(L_hdr)
+
+    if method.lower() == 'hdr-cielab':
+        maximum_perception = 247
+    else:
+        maximum_perception = 246
+
+    Y = np.exp(
+        np.log(
+            substrate_concentration_MichealisMenten(
+                L_hdr - 0.02, maximum_perception, 2 ** epsilon)) / epsilon)
+
+    return Y
+
+
 LUMINANCE_METHODS = CaseInsensitiveMapping({
     'Newhall 1943': luminance_Newhall1943,
     'ASTM D1535-08': luminance_ASTMD153508,
     'CIE 1976': luminance_CIE1976,
-    'Fairchild 2010': luminance_Fairchild2010
+    'Fairchild 2010': luminance_Fairchild2010,
+    'Fairchild 2011': luminance_Fairchild2011
 })
 """
 Supported *luminance* computations methods.
@@ -256,7 +319,8 @@ def luminance(LV, method='CIE 1976', **kwargs):
     LV : numeric or array_like
         *Lightness* :math:`L^*` or *Munsell* value :math:`V`.
     method : unicode, optional
-        **{'CIE 1976', 'Newhall 1943', 'ASTM D1535-08', 'Fairchild 2010'}**,
+        **{'CIE 1976', 'Newhall 1943', 'ASTM D1535-08', 'Fairchild 2010',
+        'Fairchild 2011'}**,
         Computation method.
 
     Other Parameters
@@ -265,7 +329,7 @@ def luminance(LV, method='CIE 1976', **kwargs):
         {:func:`luminance_CIE1976`},
         White reference *luminance* :math:`Y_n`.
     epsilon : numeric or array_like, optional
-        {:func:`lightness_Fairchild2010`},
+        {:func:`lightness_Fairchild2010`, :func:`lightness_Fairchild2011`},
         :math:`\epsilon` exponent.
 
     Returns
diff --git a/colour/models/__init__.py b/colour/models/__init__.py
index 41d5ab8c8..4b0dab467 100644
--- a/colour/models/__init__.py
+++ b/colour/models/__init__.py
@@ -10,12 +10,13 @@ from .cie_luv import (XYZ_to_Luv, Luv_to_XYZ, Luv_to_uv, Luv_uv_to_xy,
                       Luv_to_LCHuv, LCHuv_to_Luv)
 from .cie_ucs import XYZ_to_UCS, UCS_to_XYZ, UCS_to_uv, UCS_uv_to_xy
 from .cie_uvw import XYZ_to_UVW
-from .hdr_cie_lab import XYZ_to_hdr_CIELab, hdr_CIELab_to_XYZ
+from .hdr_cie_lab import (HDR_CIELAB_METHODS, XYZ_to_hdr_CIELab,
+                          hdr_CIELab_to_XYZ)
 from .hunter_lab import (XYZ_to_K_ab_HunterLab1966, XYZ_to_Hunter_Lab,
                          Hunter_Lab_to_XYZ)
 from .hunter_rdab import XYZ_to_Hunter_Rdab
 from .ipt import XYZ_to_IPT, IPT_to_XYZ, IPT_hue_angle
-from .hdr_ipt import XYZ_to_hdr_IPT, hdr_IPT_to_XYZ
+from .hdr_ipt import HDR_IPT_METHODS, XYZ_to_hdr_IPT, hdr_IPT_to_XYZ
 from .ucs_luo2006 import (JMh_CIECAM02_to_CAM02LCD, CAM02LCD_to_JMh_CIECAM02,
                           JMh_CIECAM02_to_CAM02SCD, CAM02SCD_to_JMh_CIECAM02,
                           JMh_CIECAM02_to_CAM02UCS, CAM02UCS_to_JMh_CIECAM02)
@@ -37,14 +38,14 @@ __all__ += [
 ]
 __all__ += ['XYZ_to_UCS', 'UCS_to_XYZ', 'UCS_to_uv', 'UCS_uv_to_xy']
 __all__ += ['XYZ_to_UVW']
-__all__ += ['XYZ_to_hdr_CIELab', 'hdr_CIELab_to_XYZ']
+__all__ += ['HDR_CIELAB_METHODS', 'XYZ_to_hdr_CIELab', 'hdr_CIELab_to_XYZ']
 __all__ += [
     'XYZ_to_K_ab_HunterLab1966', 'XYZ_to_Hunter_Lab', 'Hunter_Lab_to_XYZ',
     'XYZ_to_Hunter_Rdab'
 ]
 __all__ += ['XYZ_to_Hunter_Rdab']
 __all__ += ['XYZ_to_IPT', 'IPT_to_XYZ', 'IPT_hue_angle']
-__all__ += ['XYZ_to_hdr_IPT', 'hdr_IPT_to_XYZ']
+__all__ += ['HDR_IPT_METHODS', 'XYZ_to_hdr_IPT', 'hdr_IPT_to_XYZ']
 __all__ += [
     'JMh_CIECAM02_to_CAM02LCD', 'CAM02LCD_to_JMh_CIECAM02',
     'JMh_CIECAM02_to_CAM02SCD', 'CAM02SCD_to_JMh_CIECAM02',
diff --git a/colour/models/hdr_cie_lab.py b/colour/models/hdr_cie_lab.py
index a943b8fe5..6476afc3b 100644
--- a/colour/models/hdr_cie_lab.py
+++ b/colour/models/hdr_cie_lab.py
@@ -21,14 +21,18 @@ References
         Simple Models for Describing the Color of High-Dynamic-Range and
         Wide-Color-Gamut Images. In Proc. of Color and Imaging Conference
         (pp. 322–326). ISBN:9781629932156
+.. [2]  Fairchild, M. D., & Chen, P. (2011). Brightness, Lightness, and
+        Specifying Color in High-Dynamic-Range Scenes and Images.
+        doi:10.1117/12.872075
 """
 
 from __future__ import division, unicode_literals
 
 import numpy as np
 
-from colour.colorimetry import (ILLUMINANTS, lightness_Fairchild2010,
-                                luminance_Fairchild2010)
+from colour.colorimetry import (
+    ILLUMINANTS, lightness_Fairchild2010, lightness_Fairchild2011,
+    luminance_Fairchild2010, luminance_Fairchild2011)
 from colour.models import xy_to_xyY, xyY_to_XYZ
 from colour.utilities import tsplit, tstack
 
@@ -39,14 +43,77 @@ __maintainer__ = 'Colour Developers'
 __email__ = 'colour-science@googlegroups.com'
 __status__ = 'Production'
 
-__all__ = ['XYZ_to_hdr_CIELab', 'hdr_CIELab_to_XYZ', 'exponent_hdr_CIELab']
+__all__ = [
+    'HDR_CIELAB_METHODS', 'exponent_hdr_CIELab', 'XYZ_to_hdr_CIELab',
+    'hdr_CIELab_to_XYZ'
+]
+
+HDR_CIELAB_METHODS = ('Fairchild 2010', 'Fairchild 2011')
+"""
+Supported *hdr-CIELAB* colourspace computation methods.
+
+HDR_CIELAB_METHODS : tuple
+    **{'Fairchild 2011', 'Fairchild 2010'}**
+"""
+
+
+def exponent_hdr_CIELab(Y_s, Y_abs, method='Fairchild 2011'):
+    """
+    Computes *hdr-CIELAB* colourspace *Lightness* :math:`\epsilon` exponent
+    using *Fairchild and Wyble (2010)* or *Fairchild and Chen (2011)* method.
+
+    Parameters
+    ----------
+    Y_s : numeric or array_like
+        Relative luminance :math:`Y_s` of the surround in range [0, 1].
+    Y_abs : numeric or array_like
+        Absolute luminance :math:`Y_{abs}` of the scene diffuse white in
+        :math:`cd/m^2`.
+    method : unicode, optional
+        **{'Fairchild 2011', 'Fairchild 2010'}**,
+        Computation method.
+
+    Returns
+    -------
+    array_like
+        *hdr-CIELAB* colourspace *Lightness* :math:`\epsilon` exponent.
+
+    Examples
+    --------
+    >>> exponent_hdr_CIELab(0.2, 100)  # doctest: +ELLIPSIS
+    0.7099276...
+    >>> exponent_hdr_CIELab(0.2, 100, method='Fairchild 2010')
+    ... # doctest: +ELLIPSIS
+    1.8360198...
+    """
+
+    Y_s = np.asarray(Y_s)
+    Y_abs = np.asarray(Y_abs)
+
+    method_l = method.lower()
+    assert method.lower() in [
+        m.lower() for m in HDR_CIELAB_METHODS
+    ], ('"{0}" method is invalid, must be one of {1}!'.format(
+        method, HDR_CIELAB_METHODS))
+
+    if method_l == 'fairchild 2010':
+        epsilon = 1.50
+    else:
+        epsilon = 0.58
+
+    sf = 1.25 - 0.25 * (Y_s / 0.184)
+    lf = np.log(318) / np.log(Y_abs)
+    epsilon *= sf * lf
+
+    return epsilon
 
 
 def XYZ_to_hdr_CIELab(
         XYZ,
         illuminant=ILLUMINANTS['CIE 1931 2 Degree Standard Observer']['D50'],
         Y_s=0.2,
-        Y_abs=100):
+        Y_abs=100,
+        method='Fairchild 2011'):
     """
     Converts from *CIE XYZ* tristimulus values to *hdr-CIELAB* colourspace.
 
@@ -62,6 +129,9 @@ def XYZ_to_hdr_CIELab(
     Y_abs : numeric or array_like
         Absolute luminance :math:`Y_{abs}` of the scene diffuse white in
         :math:`cd/m^2`.
+    method : unicode, optional
+        **{'Fairchild 2011', 'Fairchild 2010'}**,
+        Computation method.
 
     Returns
     -------
@@ -85,17 +155,30 @@ def XYZ_to_hdr_CIELab(
     --------
     >>> XYZ = np.array([0.07049534, 0.10080000, 0.09558313])
     >>> XYZ_to_hdr_CIELab(XYZ)  # doctest: +ELLIPSIS
-    array([ 24.9020664..., -46.8312760..., -10.14274843])
+    array([ 26.4646106..., -24.613326 ...,  -4.8479681...])
+    >>> XYZ_to_hdr_CIELab(XYZ, method='Fairchild 2010')  # doctest: +ELLIPSIS
+    array([ 24.9020664..., -46.8312760..., -10.1427484...])
     """
 
     X, Y, Z = tsplit(XYZ)
     X_n, Y_n, Z_n = tsplit(xyY_to_XYZ(xy_to_xyY(illuminant)))
 
-    e = exponent_hdr_CIELab(Y_s, Y_abs)
+    method_l = method.lower()
+    assert method.lower() in [
+        m.lower() for m in HDR_CIELAB_METHODS
+    ], ('"{0}" method is invalid, must be one of {1}!'.format(
+        method, HDR_CIELAB_METHODS))
+
+    if method_l == 'fairchild 2010':
+        lightness_callable = lightness_Fairchild2010
+    else:
+        lightness_callable = lightness_Fairchild2011
 
-    L_hdr = lightness_Fairchild2010(Y / Y_n, e)
-    a_hdr = 5 * (lightness_Fairchild2010(X / X_n, e) - L_hdr)
-    b_hdr = 2 * (L_hdr - lightness_Fairchild2010(Z / Z_n, e))
+    e = exponent_hdr_CIELab(Y_s, Y_abs, method)
+
+    L_hdr = lightness_callable(Y / Y_n, e)
+    a_hdr = 5 * (lightness_callable(X / X_n, e) - L_hdr)
+    b_hdr = 2 * (L_hdr - lightness_callable(Z / Z_n, e))
 
     Lab_hdr = tstack((L_hdr, a_hdr, b_hdr))
 
@@ -106,7 +189,8 @@ def hdr_CIELab_to_XYZ(
         Lab_hdr,
         illuminant=ILLUMINANTS['CIE 1931 2 Degree Standard Observer']['D50'],
         Y_s=0.2,
-        Y_abs=100):
+        Y_abs=100,
+        method='Fairchild 2011'):
     """
     Converts from *hdr-CIELAB* colourspace to *CIE XYZ* tristimulus values.
 
@@ -122,6 +206,9 @@ def hdr_CIELab_to_XYZ(
     Y_abs : numeric or array_like
         Absolute luminance :math:`Y_{abs}` of the scene diffuse white in
         :math:`cd/m^2`.
+    method : unicode, optional
+        **{'Fairchild 2011', 'Fairchild 2010'}**,
+        Computation method.
 
     Returns
     -------
@@ -136,53 +223,35 @@ def hdr_CIELab_to_XYZ(
 
     Examples
     --------
-    >>> Lab_hdr = np.array([24.90206646, -46.83127607, -10.14274843])
+    >>> Lab_hdr = np.array([26.46461067, -24.613326, -4.84796811])
     >>> hdr_CIELab_to_XYZ(Lab_hdr)  # doctest: +ELLIPSIS
     array([ 0.0704953...,  0.1008    ,  0.0955831...])
+    >>> Lab_hdr = np.array([24.90206646, -46.83127607, -10.14274843])
+    >>> hdr_CIELab_to_XYZ(Lab_hdr, method='Fairchild 2010')
+    ... # doctest: +ELLIPSIS
+    array([ 0.0704953...,  0.1008    ,  0.0955831...])
     """
 
     L_hdr, a_hdr, b_hdr = tsplit(Lab_hdr)
     X_n, Y_n, Z_n = tsplit(xyY_to_XYZ(xy_to_xyY(illuminant)))
 
-    e = exponent_hdr_CIELab(Y_s, Y_abs)
-
-    Y = luminance_Fairchild2010(L_hdr, e) * Y_n
-    X = luminance_Fairchild2010((a_hdr + 5 * L_hdr) / 5, e) * X_n
-    Z = luminance_Fairchild2010((-b_hdr + 2 * L_hdr) / 2, e) * Z_n
-
-    XYZ = tstack((X, Y, Z))
-
-    return XYZ
-
-
-def exponent_hdr_CIELab(Y_s, Y_abs):
-    """
-    Computes *hdr-CIELAB* colourspace *Lightness* :math:`\epsilon` exponent.
-
-    Parameters
-    ----------
-    Y_s : numeric or array_like
-        Relative luminance :math:`Y_s` of the surround in range [0, 1].
-    Y_abs : numeric or array_like
-        Absolute luminance :math:`Y_{abs}` of the scene diffuse white in
-        :math:`cd/m^2`.
+    method_l = method.lower()
+    assert method.lower() in [
+        m.lower() for m in HDR_CIELAB_METHODS
+    ], ('"{0}" method is invalid, must be one of {1}!'.format(
+        method, HDR_CIELAB_METHODS))
 
-    Returns
-    -------
-    array_like
-        *hdr-CIELAB* colourspace *Lightness* :math:`\epsilon` exponent.
+    if method_l == 'fairchild 2010':
+        luminance_callable = luminance_Fairchild2010
+    else:
+        luminance_callable = luminance_Fairchild2011
 
-    Examples
-    --------
-    >>> exponent_hdr_CIELab(0.2, 100)  # doctest: +ELLIPSIS
-    1.8360198...
-    """
+    e = exponent_hdr_CIELab(Y_s, Y_abs, method)
 
-    Y_s = np.asarray(Y_s)
-    Y_abs = np.asarray(Y_abs)
+    Y = luminance_callable(L_hdr, e) * Y_n
+    X = luminance_callable((a_hdr + 5 * L_hdr) / 5, e) * X_n
+    Z = luminance_callable((-b_hdr + 2 * L_hdr) / 2, e) * Z_n
 
-    lf = np.log(318) / np.log(Y_abs)
-    sf = 1.25 - 0.25 * (Y_s / 0.184)
-    epsilon = 1.50 * sf * lf
+    XYZ = tstack((X, Y, Z))
 
-    return epsilon
+    return XYZ
diff --git a/colour/models/hdr_ipt.py b/colour/models/hdr_ipt.py
index 8cc91cbb1..c1050bffe 100644
--- a/colour/models/hdr_ipt.py
+++ b/colour/models/hdr_ipt.py
@@ -21,13 +21,18 @@ References
         Simple Models for Describing the Color of High-Dynamic-Range and
         Wide-Color-Gamut Images. In Proc. of Color and Imaging Conference
         (pp. 322–326). ISBN:9781629932156
+.. [2]  Fairchild, M. D., & Chen, P. (2011). Brightness, Lightness, and
+        Specifying Color in High-Dynamic-Range Scenes and Images.
+        doi:10.1117/12.872075
 """
 
 from __future__ import division, unicode_literals
 
 import numpy as np
 
-from colour.colorimetry import lightness_Fairchild2010, luminance_Fairchild2010
+from colour.colorimetry import (
+    lightness_Fairchild2010, lightness_Fairchild2011, luminance_Fairchild2010,
+    luminance_Fairchild2011)
 from colour.models.ipt import (IPT_XYZ_TO_LMS_MATRIX, IPT_LMS_TO_XYZ_MATRIX,
                                IPT_LMS_TO_IPT_MATRIX, IPT_IPT_TO_LMS_MATRIX)
 from colour.utilities import dot_vector
@@ -39,10 +44,71 @@ __maintainer__ = 'Colour Developers'
 __email__ = 'colour-science@googlegroups.com'
 __status__ = 'Production'
 
-__all__ = ['XYZ_to_hdr_IPT', 'hdr_IPT_to_XYZ', 'exponent_hdr_IPT']
+__all__ = [
+    'HDR_IPT_METHODS', 'exponent_hdr_IPT', 'XYZ_to_hdr_IPT', 'hdr_IPT_to_XYZ'
+]
 
+HDR_IPT_METHODS = ('Fairchild 2010', 'Fairchild 2011')
+"""
+Supported *hdr-IPT* colourspace computation methods.
+
+HDR_IPT_METHODS : tuple
+    **{'Fairchild 2011', 'Fairchild 2010'}**
+"""
 
-def XYZ_to_hdr_IPT(XYZ, Y_s=0.2, Y_abs=100):
+
+def exponent_hdr_IPT(Y_s, Y_abs, method='Fairchild 2011'):
+    """
+    Computes *hdr-IPT* colourspace *Lightness* :math:`\epsilon` exponent using
+    *Fairchild and Wyble (2010)* or *Fairchild and Chen (2011)* method.
+
+    Parameters
+    ----------
+    Y_s : numeric or array_like
+        Relative luminance :math:`Y_s` of the surround in range [0, 1].
+    Y_abs : numeric or array_like
+        Absolute luminance :math:`Y_{abs}` of the scene diffuse white in
+        :math:`cd/m^2`.
+    method : unicode, optional
+        **{'Fairchild 2011', 'Fairchild 2010'}**,
+        Computation method.
+
+    Returns
+    -------
+    array_like
+        *hdr-IPT* colourspace *Lightness* :math:`\epsilon` exponent.
+
+    Examples
+    --------
+    >>> exponent_hdr_IPT(0.2, 100)  # doctest: +ELLIPSIS
+    0.7221678...
+    >>> exponent_hdr_IPT(0.2, 100, method='Fairchild 2010')
+    ... # doctest: +ELLIPSIS
+    1.6891383...
+    """
+
+    Y_s = np.asarray(Y_s)
+    Y_abs = np.asarray(Y_abs)
+
+    method_l = method.lower()
+    assert method.lower() in [
+        m.lower() for m in HDR_IPT_METHODS
+    ], ('"{0}" method is invalid, must be one of {1}!'.format(
+        method, HDR_IPT_METHODS))
+
+    if method_l == 'fairchild 2010':
+        epsilon = 1.38
+    else:
+        epsilon = 0.59
+
+    lf = np.log(318) / np.log(Y_abs)
+    sf = 1.25 - 0.25 * (Y_s / 0.184)
+    epsilon *= sf * lf
+
+    return epsilon
+
+
+def XYZ_to_hdr_IPT(XYZ, Y_s=0.2, Y_abs=100, method='Fairchild 2011'):
     """
     Converts from *CIE XYZ* tristimulus values to *hdr-IPT* colourspace.
 
@@ -55,6 +121,9 @@ def XYZ_to_hdr_IPT(XYZ, Y_s=0.2, Y_abs=100):
     Y_abs : numeric or array_like
         Absolute luminance :math:`Y_{abs}` of the scene diffuse white in
         :math:`cd/m^2`.
+    method : unicode, optional
+        **{'Fairchild 2011', 'Fairchild 2010'}**,
+        Computation method.
 
     Returns
     -------
@@ -70,19 +139,32 @@ def XYZ_to_hdr_IPT(XYZ, Y_s=0.2, Y_abs=100):
     --------
     >>> XYZ = np.array([0.96907232, 1.00000000, 1.12179215])
     >>> XYZ_to_hdr_IPT(XYZ)  # doctest: +ELLIPSIS
+    array([ 93.5317473...,   1.8564156...,  -1.3292254...])
+    >>> XYZ_to_hdr_IPT(XYZ, method='Fairchild 2010')  # doctest: +ELLIPSIS
     array([ 94.6592917...,   0.3804177...,  -0.2673118...])
     """
 
-    e = exponent_hdr_IPT(Y_s, Y_abs)[..., np.newaxis]
+    method_l = method.lower()
+    assert method.lower() in [
+        m.lower() for m in HDR_IPT_METHODS
+    ], ('"{0}" method is invalid, must be one of {1}!'.format(
+        method, HDR_IPT_METHODS))
+
+    if method_l == 'fairchild 2010':
+        lightness_callable = lightness_Fairchild2010
+    else:
+        lightness_callable = lightness_Fairchild2011
+
+    e = exponent_hdr_IPT(Y_s, Y_abs, method)[..., np.newaxis]
 
     LMS = dot_vector(IPT_XYZ_TO_LMS_MATRIX, XYZ)
-    LMS_prime = np.sign(LMS) * np.abs(lightness_Fairchild2010(LMS, e))
+    LMS_prime = np.sign(LMS) * np.abs(lightness_callable(LMS, e))
     IPT = dot_vector(IPT_LMS_TO_IPT_MATRIX, LMS_prime)
 
     return IPT
 
 
-def hdr_IPT_to_XYZ(IPT_hdr, Y_s=0.2, Y_abs=100):
+def hdr_IPT_to_XYZ(IPT_hdr, Y_s=0.2, Y_abs=100, method='Fairchild 2011'):
     """
     Converts from *hdr-IPT* colourspace to *CIE XYZ* tristimulus values.
 
@@ -95,6 +177,9 @@ def hdr_IPT_to_XYZ(IPT_hdr, Y_s=0.2, Y_abs=100):
     Y_abs : numeric or array_like
         Absolute luminance :math:`Y_{abs}` of the scene diffuse white in
         :math:`cd/m^2`.
+    method : unicode, optional
+        **{'Fairchild 2011', 'Fairchild 2010'}**,
+        Computation method.
 
     Returns
     -------
@@ -103,48 +188,30 @@ def hdr_IPT_to_XYZ(IPT_hdr, Y_s=0.2, Y_abs=100):
 
     Examples
     --------
-    >>> IPT_hdr = np.array([94.65929175, 0.38041773, -0.26731187])
+    >>> IPT_hdr = np.array([93.53174734, 1.85641567, -1.32922546])
     >>> hdr_IPT_to_XYZ(IPT_hdr)  # doctest: +ELLIPSIS
     array([ 0.9690723...,  1.        ,  1.1217921...])
+    >>> IPT_hdr = np.array([94.65929175, 0.38041773, -0.26731187])
+    >>> hdr_IPT_to_XYZ(IPT_hdr, method='Fairchild 2010')
+    ... # doctest: +ELLIPSIS
+    array([ 0.9690723...,  1.        ,  1.1217921...])
     """
 
-    e = exponent_hdr_IPT(Y_s, Y_abs)[..., np.newaxis]
+    method_l = method.lower()
+    assert method.lower() in [
+        m.lower() for m in HDR_IPT_METHODS
+    ], ('"{0}" method is invalid, must be one of {1}!'.format(
+        method, HDR_IPT_METHODS))
+
+    if method_l == 'fairchild 2010':
+        luminance_callable = luminance_Fairchild2010
+    else:
+        luminance_callable = luminance_Fairchild2011
+
+    e = exponent_hdr_IPT(Y_s, Y_abs, method)[..., np.newaxis]
 
     LMS = dot_vector(IPT_IPT_TO_LMS_MATRIX, IPT_hdr)
-    LMS_prime = np.sign(LMS) * np.abs(luminance_Fairchild2010(LMS, e))
+    LMS_prime = np.sign(LMS) * np.abs(luminance_callable(LMS, e))
     XYZ = dot_vector(IPT_LMS_TO_XYZ_MATRIX, LMS_prime)
 
     return XYZ
-
-
-def exponent_hdr_IPT(Y_s, Y_abs):
-    """
-    Computes *hdr-IPT* colourspace *Lightness* :math:`\epsilon` exponent.
-
-    Parameters
-    ----------
-    Y_s : numeric or array_like
-        Relative luminance :math:`Y_s` of the surround in range [0, 1].
-    Y_abs : numeric or array_like
-        Absolute luminance :math:`Y_{abs}` of the scene diffuse white in
-        :math:`cd/m^2`.
-
-    Returns
-    -------
-    array_like
-        *hdr-IPT* colourspace *Lightness* :math:`\epsilon` exponent.
-
-    Examples
-    --------
-    >>> exponent_hdr_IPT(0.2, 100)  # doctest: +ELLIPSIS
-    1.6891383...
-    """
-
-    Y_s = np.asarray(Y_s)
-    Y_abs = np.asarray(Y_abs)
-
-    lf = np.log(318) / np.log(Y_abs)
-    sf = 1.25 - 0.25 * (Y_s / 0.184)
-    epsilon = 1.38 * sf * lf
-
-    return epsilon


Test patch:
diff --git a/colour/colorimetry/tests/test_lightness.py b/colour/colorimetry/tests/test_lightness.py
index 6f8bc5dc1..808cea398 100644
--- a/colour/colorimetry/tests/test_lightness.py
+++ b/colour/colorimetry/tests/test_lightness.py
@@ -10,7 +10,8 @@ import numpy as np
 import unittest
 
 from colour.colorimetry import (lightness_Glasser1958, lightness_Wyszecki1963,
-                                lightness_CIE1976, lightness_Fairchild2010)
+                                lightness_CIE1976, lightness_Fairchild2010,
+                                lightness_Fairchild2011)
 from colour.utilities import ignore_numpy_errors
 
 __author__ = 'Colour Developers'
@@ -22,7 +23,8 @@ __status__ = 'Production'
 
 __all__ = [
     'TestLightnessGlasser1958', 'TestLightnessWyszecki1963',
-    'TestLightnessCIE1976', 'TestLightnessFairchild2010'
+    'TestLightnessCIE1976', 'TestLightnessFairchild2010',
+    'TestLightnessFairchild2011'
 ]
 
 
@@ -206,22 +208,22 @@ class TestLightnessFairchild2010(unittest.TestCase):
         """
 
         self.assertAlmostEqual(
-            lightness_Fairchild2010(10.08 / 100), 23.10363383, places=7)
+            lightness_Fairchild2010(10.08 / 100), 24.90229027, places=7)
 
         self.assertAlmostEqual(
-            lightness_Fairchild2010(56.76 / 100), 90.51057574, places=7)
+            lightness_Fairchild2010(56.76 / 100), 88.79756887, places=7)
 
         self.assertAlmostEqual(
-            lightness_Fairchild2010(98.32 / 100), 96.636221285, places=7)
+            lightness_Fairchild2010(98.32 / 100), 95.61301852, places=7)
 
         self.assertAlmostEqual(
             lightness_Fairchild2010(10.08 / 100, 2.75), 16.06420271, places=7)
 
         self.assertAlmostEqual(
-            lightness_Fairchild2010(1008), 100.01999667, places=7)
+            lightness_Fairchild2010(1008), 100.019986327374240, places=7)
 
         self.assertAlmostEqual(
-            lightness_Fairchild2010(100800), 100.01999999, places=7)
+            lightness_Fairchild2010(100800), 100.019999997090270, places=7)
 
     def test_n_dimensional_lightness_Fairchild2010(self):
         """
@@ -230,7 +232,7 @@ class TestLightnessFairchild2010(unittest.TestCase):
         """
 
         Y = 10.08 / 100
-        L = 23.10363383
+        L = 24.90229027
         np.testing.assert_almost_equal(
             lightness_Fairchild2010(Y), L, decimal=7)
 
@@ -260,5 +262,72 @@ class TestLightnessFairchild2010(unittest.TestCase):
             np.array([-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan]))
 
 
+class TestLightnessFairchild2011(unittest.TestCase):
+    """
+    Defines :func:`colour.colorimetry.lightness.lightness_Fairchild2011`
+    definition unit tests methods.
+    """
+
+    def test_lightness_Fairchild2011(self):
+        """
+        Tests :func:`colour.colorimetry.lightness.lightness_Fairchild2011`
+        definition.
+        """
+
+        self.assertAlmostEqual(
+            lightness_Fairchild2011(10.08 / 100), 26.45950982, places=7)
+
+        self.assertAlmostEqual(
+            lightness_Fairchild2011(56.76 / 100), 71.70846602, places=7)
+
+        self.assertAlmostEqual(
+            lightness_Fairchild2011(98.32 / 100), 93.03097540, places=7)
+
+        self.assertAlmostEqual(
+            lightness_Fairchild2011(10.08 / 100, 2.75), 0.08672116, places=7)
+
+        self.assertAlmostEqual(
+            lightness_Fairchild2011(1008), 244.07716521, places=7)
+
+        self.assertAlmostEqual(
+            lightness_Fairchild2011(100800), 246.90681934, places=7)
+
+    def test_n_dimensional_lightness_Fairchild2011(self):
+        """
+        Tests :func:`colour.colorimetry.lightness.lightness_Fairchild2011`
+        definition n-dimensional arrays support.
+        """
+
+        Y = 10.08 / 100
+        L = 26.45950982
+        np.testing.assert_almost_equal(
+            lightness_Fairchild2011(Y), L, decimal=7)
+
+        Y = np.tile(Y, 6)
+        L = np.tile(L, 6)
+        np.testing.assert_almost_equal(
+            lightness_Fairchild2011(Y), L, decimal=7)
+
+        Y = np.reshape(Y, (2, 3))
+        L = np.reshape(L, (2, 3))
+        np.testing.assert_almost_equal(
+            lightness_Fairchild2011(Y), L, decimal=7)
+
+        Y = np.reshape(Y, (2, 3, 1))
+        L = np.reshape(L, (2, 3, 1))
+        np.testing.assert_almost_equal(
+            lightness_Fairchild2011(Y), L, decimal=7)
+
+    @ignore_numpy_errors
+    def test_nan_lightness_Fairchild2011(self):
+        """
+        Tests :func:`colour.colorimetry.lightness.lightness_Fairchild2011`
+        definition nan support.
+        """
+
+        lightness_Fairchild2011(
+            np.array([-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan]))
+
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/colour/colorimetry/tests/test_luminance.py b/colour/colorimetry/tests/test_luminance.py
index 8b8cb07d8..c73e017b9 100644
--- a/colour/colorimetry/tests/test_luminance.py
+++ b/colour/colorimetry/tests/test_luminance.py
@@ -11,7 +11,7 @@ import unittest
 
 from colour.colorimetry.luminance import (
     luminance_Newhall1943, luminance_CIE1976, luminance_ASTMD153508,
-    luminance_Fairchild2010)
+    luminance_Fairchild2010, luminance_Fairchild2011)
 from colour.utilities import ignore_numpy_errors
 
 __author__ = 'Colour Developers'
@@ -23,7 +23,8 @@ __status__ = 'Production'
 
 __all__ = [
     'TestLuminanceNewhall1943', 'TestLuminanceASTMD153508',
-    'TestLuminanceCIE1976', 'TestLuminanceFairchild2010'
+    'TestLuminanceCIE1976', 'TestLuminanceFairchild2010',
+    'TestLuminanceFairchild2011'
 ]
 
 
@@ -210,13 +211,13 @@ class TestLuminanceFairchild2010(unittest.TestCase):
         """
 
         self.assertAlmostEqual(
-            luminance_Fairchild2010(23.103633825753175), 0.10079999, places=7)
+            luminance_Fairchild2010(24.902290269546651), 0.10079999, places=7)
 
         self.assertAlmostEqual(
-            luminance_Fairchild2010(90.510575738115122), 0.56759999, places=7)
+            luminance_Fairchild2010(88.797568871771162), 0.56759999, places=7)
 
         self.assertAlmostEqual(
-            luminance_Fairchild2010(96.636221285055527), 0.98319999, places=7)
+            luminance_Fairchild2010(95.613018520289828), 0.98319999, places=7)
 
         self.assertAlmostEqual(
             luminance_Fairchild2010(16.064202706248068, 2.75),
@@ -224,13 +225,13 @@ class TestLuminanceFairchild2010(unittest.TestCase):
             places=7)
 
         self.assertAlmostEqual(
-            luminance_Fairchild2010(100.01999666792653),
-            1007.99999963,
+            luminance_Fairchild2010(100.019986327374240),
+            1008.00000024,
             places=7)
 
         self.assertAlmostEqual(
-            luminance_Fairchild2010(100.01999999966679),
-            100800.82383352,
+            luminance_Fairchild2010(100.019999997090270),
+            100799.92312466,
             places=7)
 
     def test_n_dimensional_luminance_Fairchild2010(self):
@@ -239,7 +240,7 @@ class TestLuminanceFairchild2010(unittest.TestCase):
         definition n-dimensional arrays support.
         """
 
-        L_hdr = 23.103633825753175
+        L_hdr = 24.902290269546651
         Y = 10.08 / 100
         np.testing.assert_almost_equal(
             luminance_Fairchild2010(L_hdr), Y, decimal=7)
@@ -270,5 +271,78 @@ class TestLuminanceFairchild2010(unittest.TestCase):
             np.array([-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan]))
 
 
+class TestLuminanceFairchild2011(unittest.TestCase):
+    """
+    Defines :func:`colour.colorimetry.luminance.luminance_Fairchild2011`
+    definition unit tests methods.
+    """
+
+    def test_luminance_Fairchild2011(self):
+        """
+        Tests :func:`colour.colorimetry.luminance.luminance_Fairchild2011`
+        definition.
+        """
+
+        self.assertAlmostEqual(
+            luminance_Fairchild2011(26.459509817572265), 0.10079999, places=7)
+
+        self.assertAlmostEqual(
+            luminance_Fairchild2011(71.708466023819625), 0.56759999, places=7)
+
+        self.assertAlmostEqual(
+            luminance_Fairchild2011(93.030975393206475), 0.98319999, places=7)
+
+        self.assertAlmostEqual(
+            luminance_Fairchild2011(0.08672116154998, 2.75),
+            0.10079999,
+            places=7)
+
+        self.assertAlmostEqual(
+            luminance_Fairchild2011(244.07716520973938),
+            1008.00000000,
+            places=7)
+
+        self.assertAlmostEqual(
+            luminance_Fairchild2011(246.90681933957006),
+            100800.00000000,
+            places=7)
+
+    def test_n_dimensional_luminance_Fairchild2011(self):
+        """
+        Tests :func:`colour.colorimetry.lightness.luminance_Fairchild2011`
+        definition n-dimensional arrays support.
+        """
+
+        L_hdr = 26.459509817572265
+        Y = 10.08 / 100
+        np.testing.assert_almost_equal(
+            luminance_Fairchild2011(L_hdr), Y, decimal=7)
+
+        L_hdr = np.tile(L_hdr, 6)
+        Y = np.tile(Y, 6)
+        np.testing.assert_almost_equal(
+            luminance_Fairchild2011(L_hdr), Y, decimal=7)
+
+        L_hdr = np.reshape(L_hdr, (2, 3))
+        Y = np.reshape(Y, (2, 3))
+        np.testing.assert_almost_equal(
+            luminance_Fairchild2011(L_hdr), Y, decimal=7)
+
+        L_hdr = np.reshape(L_hdr, (2, 3, 1))
+        Y = np.reshape(Y, (2, 3, 1))
+        np.testing.assert_almost_equal(
+            luminance_Fairchild2011(L_hdr), Y, decimal=7)
+
+    @ignore_numpy_errors
+    def test_nan_luminance_Fairchild2011(self):
+        """
+        Tests :func:`colour.colorimetry.luminance.luminance_Fairchild2011`
+        definition nan support.
+        """
+
+        luminance_Fairchild2011(
+            np.array([-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan]))
+
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/colour/models/tests/test_hdr_cie_lab.py b/colour/models/tests/test_hdr_cie_lab.py
index 64c4db540..7b38c6645 100644
--- a/colour/models/tests/test_hdr_cie_lab.py
+++ b/colour/models/tests/test_hdr_cie_lab.py
@@ -22,10 +22,77 @@ __email__ = 'colour-science@googlegroups.com'
 __status__ = 'Production'
 
 __all__ = [
-    'TestXYZ_to_hdr_CIELab', 'TestHdr_CIELab_to_XYZ', 'TestExponent_hdr_CIELab'
+    'TestExponent_hdr_CIELab', 'TestXYZ_to_hdr_CIELab', 'TestHdr_CIELab_to_XYZ'
 ]
 
 
+class TestExponent_hdr_CIELab(unittest.TestCase):
+    """
+    Defines :func:`colour.models.hdr_cie_lab.exponent_hdr_CIELab`
+    definition unit tests methods.
+    """
+
+    def test_exponent_hdr_CIELab(self):
+        """
+        Tests :func:`colour.models.hdr_cie_lab.exponent_hdr_CIELab`
+        definition.
+        """
+
+        self.assertAlmostEqual(
+            exponent_hdr_CIELab(0.2, 100), 0.709927693821670, places=7)
+
+        self.assertAlmostEqual(
+            exponent_hdr_CIELab(0.4, 100), 0.512725556648984, places=7)
+
+        self.assertAlmostEqual(
+            exponent_hdr_CIELab(0.4, 100, method='Fairchild 2010'),
+            1.326014370643925,
+            places=7)
+
+        self.assertAlmostEqual(
+            exponent_hdr_CIELab(0.2, 1000), 0.473285129214447, places=7)
+
+    def test_n_dimensional_exponent_hdr_CIELab(self):
+        """
+        Tests :func:`colour.models.hdr_cie_lab.exponent_hdr_CIELab`
+        definition n-dimensional arrays support.
+        """
+
+        Y_s = 0.2
+        Y_abs = 100
+        e = 0.709927693821670
+        np.testing.assert_almost_equal(
+            exponent_hdr_CIELab(Y_s, Y_abs), e, decimal=7)
+
+        Y_s = np.tile(Y_s, 6)
+        Y_abs = np.tile(Y_abs, 6)
+        e = np.tile(e, 6)
+        np.testing.assert_almost_equal(
+            exponent_hdr_CIELab(Y_s, Y_abs), e, decimal=7)
+
+        Y_s = np.reshape(Y_s, (2, 3))
+        Y_abs = np.reshape(Y_abs, (2, 3))
+        e = np.reshape(e, (2, 3))
+        np.testing.assert_almost_equal(
+            exponent_hdr_CIELab(Y_s, Y_abs), e, decimal=7)
+
+        Y_s = np.reshape(Y_s, (2, 3, 1))
+        Y_abs = np.reshape(Y_abs, (2, 3, 1))
+        e = np.reshape(e, (2, 3, 1))
+        np.testing.assert_almost_equal(
+            exponent_hdr_CIELab(Y_s, Y_abs), e, decimal=7)
+
+    @ignore_numpy_errors
+    def test_nan_exponent_hdr_CIELab(self):
+        """
+        Tests :func:`colour.models.hdr_cie_lab.exponent_hdr_CIELab`
+        definition nan support.
+        """
+
+        cases = np.array([-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan])
+        exponent_hdr_CIELab(cases, cases)
+
+
 class TestXYZ_to_hdr_CIELab(unittest.TestCase):
     """
     Defines :func:`colour.models.hdr_cie_lab.XYZ_to_hdr_CIELab` definition unit
@@ -39,26 +106,34 @@ class TestXYZ_to_hdr_CIELab(unittest.TestCase):
 
         np.testing.assert_almost_equal(
             XYZ_to_hdr_CIELab(np.array([0.07049534, 0.10080000, 0.09558313])),
-            np.array([24.90206646, -46.83127607, -10.14274843]),
+            np.array([26.46461067, -24.61332600, -4.84796811]),
             decimal=7)
 
         np.testing.assert_almost_equal(
             XYZ_to_hdr_CIELab(
                 np.array([0.07049534, 0.10080000, 0.09558313]),
                 np.array([0.44757, 0.40745])),
+            np.array([26.46461067, -33.35816986, -42.86850246]),
+            decimal=7)
+
+        np.testing.assert_almost_equal(
+            XYZ_to_hdr_CIELab(
+                np.array([0.07049534, 0.10080000, 0.09558313]),
+                np.array([0.44757, 0.40745]),
+                method='Fairchild 2010'),
             np.array([24.90206646, -61.24983919, -83.63902870]),
             decimal=7)
 
         np.testing.assert_almost_equal(
             XYZ_to_hdr_CIELab(
                 np.array([0.07049534, 0.10080000, 0.09558313]), Y_s=0.5),
-            np.array([34.44227938, -36.51485775, -6.87279617]),
+            np.array([55.57158803, -27.58973060, -5.03923267]),
             decimal=7)
 
         np.testing.assert_almost_equal(
             XYZ_to_hdr_CIELab(
                 np.array([0.07049534, 0.10080000, 0.09558313]), Y_abs=1000),
-            np.array([32.39463250, -39.77445283, -7.66690737]),
+            np.array([48.33166805, -28.18355309, -5.21974184]),
             decimal=7)
 
     def test_n_dimensional_XYZ_to_hdr_CIELab(self):
@@ -71,7 +146,7 @@ class TestXYZ_to_hdr_CIELab(unittest.TestCase):
         illuminant = np.array([0.34570, 0.35850])
         Y_s = 0.2
         Y_abs = 100
-        Lab_hdr = np.array([24.90206646, -46.83127607, -10.14274843])
+        Lab_hdr = np.array([26.46461067, -24.61332600, -4.84796811])
         np.testing.assert_almost_equal(
             XYZ_to_hdr_CIELab(XYZ, illuminant, Y_s, Y_abs), Lab_hdr, decimal=7)
 
@@ -124,26 +199,26 @@ class TestHdr_CIELab_to_XYZ(unittest.TestCase):
 
         np.testing.assert_almost_equal(
             hdr_CIELab_to_XYZ(
-                np.array([24.90206646, -46.83127607, -10.14274843])),
+                np.array([26.46461067, -24.61332600, -4.84796811])),
             np.array([0.07049534, 0.10080000, 0.09558313]),
             decimal=7)
 
         np.testing.assert_almost_equal(
             hdr_CIELab_to_XYZ(
-                np.array([24.90206646, -61.24983919, -83.63902870]),
+                np.array([26.46461067, -33.35816986, -42.86850246]),
                 np.array([0.44757, 0.40745])),
             np.array([0.07049534, 0.10080000, 0.09558313]),
             decimal=7)
 
         np.testing.assert_almost_equal(
             hdr_CIELab_to_XYZ(
-                np.array([34.44227938, -36.51485775, -6.87279617]), Y_s=0.5),
+                np.array([55.57158803, -27.58973060, -5.03923267]), Y_s=0.5),
             np.array([0.07049534, 0.10080000, 0.09558313]),
             decimal=7)
 
         np.testing.assert_almost_equal(
             hdr_CIELab_to_XYZ(
-                np.array([32.39463250, -39.77445283, -7.66690737]),
+                np.array([48.33166805, -28.18355309, -5.21974184]),
                 Y_abs=1000),
             np.array([0.07049534, 0.10080000, 0.09558313]),
             decimal=7)
@@ -154,7 +229,7 @@ class TestHdr_CIELab_to_XYZ(unittest.TestCase):
         n-dimensions support.
         """
 
-        Lab_hdr = np.array([24.90206646, -46.83127607, -10.14274843])
+        Lab_hdr = np.array([26.46461067, -24.61332600, -4.84796811])
         illuminant = np.array([0.34570, 0.35850])
         Y_s = 0.2
         Y_abs = 100
@@ -198,67 +273,5 @@ class TestHdr_CIELab_to_XYZ(unittest.TestCase):
             hdr_CIELab_to_XYZ(Lab_hdr, illuminant, Y_s, Y_abs)
 
 
-class TestExponent_hdr_CIELab(unittest.TestCase):
-    """
-    Defines :func:`colour.models.hdr_cie_lab.exponent_hdr_CIELab`
-    definition unit tests methods.
-    """
-
-    def test_exponent_hdr_CIELab(self):
-        """
-        Tests :func:`colour.models.hdr_cie_lab.exponent_hdr_CIELab`
-        definition.
-        """
-
-        self.assertAlmostEqual(
-            exponent_hdr_CIELab(0.2, 100), 1.836019897814665, places=7)
-
-        self.assertAlmostEqual(
-            exponent_hdr_CIELab(0.4, 100), 1.326014370643925, places=7)
-
-        self.assertAlmostEqual(
-            exponent_hdr_CIELab(0.2, 1000), 1.224013265209777, places=7)
-
-    def test_n_dimensional_exponent_hdr_CIELab(self):
-        """
-        Tests :func:`colour.models.hdr_cie_lab.exponent_hdr_CIELab`
-        definition n-dimensional arrays support.
-        """
-
-        Y_s = 0.2
-        Y_abs = 100
-        e = 1.836019897814665
-        np.testing.assert_almost_equal(
-            exponent_hdr_CIELab(Y_s, Y_abs), e, decimal=7)
-
-        Y_s = np.tile(Y_s, 6)
-        Y_abs = np.tile(Y_abs, 6)
-        e = np.tile(e, 6)
-        np.testing.assert_almost_equal(
-            exponent_hdr_CIELab(Y_s, Y_abs), e, decimal=7)
-
-        Y_s = np.reshape(Y_s, (2, 3))
-        Y_abs = np.reshape(Y_abs, (2, 3))
-        e = np.reshape(e, (2, 3))
-        np.testing.assert_almost_equal(
-            exponent_hdr_CIELab(Y_s, Y_abs), e, decimal=7)
-
-        Y_s = np.reshape(Y_s, (2, 3, 1))
-        Y_abs = np.reshape(Y_abs, (2, 3, 1))
-        e = np.reshape(e, (2, 3, 1))
-        np.testing.assert_almost_equal(
-            exponent_hdr_CIELab(Y_s, Y_abs), e, decimal=7)
-
-    @ignore_numpy_errors
-    def test_nan_exponent_hdr_CIELab(self):
-        """
-        Tests :func:`colour.models.hdr_cie_lab.exponent_hdr_CIELab`
-        definition nan support.
-        """
-
-        cases = np.array([-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan])
-        exponent_hdr_CIELab(cases, cases)
-
-
 if __name__ == '__main__':
     unittest.main()
diff --git a/colour/models/tests/test_hdr_ipt.py b/colour/models/tests/test_hdr_ipt.py
index 92eb4a45b..181f2b19e 100644
--- a/colour/models/tests/test_hdr_ipt.py
+++ b/colour/models/tests/test_hdr_ipt.py
@@ -21,7 +21,74 @@ __maintainer__ = 'Colour Developers'
 __email__ = 'colour-science@googlegroups.com'
 __status__ = 'Production'
 
-__all__ = ['TestXYZ_to_hdr_IPT', 'TestHdr_IPT_to_XYZ', 'TestExponent_hdr_IPT']
+__all__ = ['TestExponent_hdr_IPT', 'TestXYZ_to_hdr_IPT', 'TestHdr_IPT_to_XYZ']
+
+
+class TestExponent_hdr_IPT(unittest.TestCase):
+    """
+    Defines :func:`colour.models.hdr_ipt.exponent_hdr_IPT`
+    definition unit tests methods.
+    """
+
+    def test_exponent_hdr_IPT(self):
+        """
+        Tests :func:`colour.models.hdr_ipt.exponent_hdr_IPT`
+        definition.
+        """
+
+        self.assertAlmostEqual(
+            exponent_hdr_IPT(0.2, 100), 0.722167826473768, places=7)
+
+        self.assertAlmostEqual(
+            exponent_hdr_IPT(0.4, 100), 0.521565652453277, places=7)
+
+        self.assertAlmostEqual(
+            exponent_hdr_IPT(0.4, 100, method='Fairchild 2010'),
+            1.219933220992410,
+            places=7)
+
+        self.assertAlmostEqual(
+            exponent_hdr_IPT(0.2, 1000), 0.481445217649179, places=7)
+
+    def test_n_dimensional_exponent_hdr_IPT(self):
+        """
+        Tests :func:`colour.models.hdr_ipt.exponent_hdr_IPT`
+        definition n-dimensional arrays support.
+        """
+
+        Y_s = 0.2
+        Y_abs = 100
+        e = 0.722167826473768
+        np.testing.assert_almost_equal(
+            exponent_hdr_IPT(Y_s, Y_abs), e, decimal=7)
+
+        Y_s = np.tile(Y_s, 6)
+        Y_abs = np.tile(Y_abs, 6)
+        e = np.tile(e, 6)
+        np.testing.assert_almost_equal(
+            exponent_hdr_IPT(Y_s, Y_abs), e, decimal=7)
+
+        Y_s = np.reshape(Y_s, (2, 3))
+        Y_abs = np.reshape(Y_abs, (2, 3))
+        e = np.reshape(e, (2, 3))
+        np.testing.assert_almost_equal(
+            exponent_hdr_IPT(Y_s, Y_abs), e, decimal=7)
+
+        Y_s = np.reshape(Y_s, (2, 3, 1))
+        Y_abs = np.reshape(Y_abs, (2, 3, 1))
+        e = np.reshape(e, (2, 3, 1))
+        np.testing.assert_almost_equal(
+            exponent_hdr_IPT(Y_s, Y_abs), e, decimal=7)
+
+    @ignore_numpy_errors
+    def test_nan_exponent_hdr_IPT(self):
+        """
+        Tests :func:`colour.models.hdr_ipt.exponent_hdr_IPT`
+        definition nan support.
+        """
+
+        cases = np.array([-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan])
+        exponent_hdr_IPT(cases, cases)
 
 
 class TestXYZ_to_hdr_IPT(unittest.TestCase):
@@ -37,19 +104,26 @@ class TestXYZ_to_hdr_IPT(unittest.TestCase):
 
         np.testing.assert_almost_equal(
             XYZ_to_hdr_IPT(np.array([0.07049534, 0.10080000, 0.09558313])),
+            np.array([24.88927680, -11.44574144, 1.63147707]),
+            decimal=7)
+
+        np.testing.assert_almost_equal(
+            XYZ_to_hdr_IPT(
+                np.array([0.07049534, 0.10080000, 0.09558313]),
+                method='Fairchild 2010'),
             np.array([25.18261761, -22.62111297, 3.18511729]),
             decimal=7)
 
         np.testing.assert_almost_equal(
             XYZ_to_hdr_IPT(
                 np.array([0.07049534, 0.10080000, 0.09558313]), Y_s=0.5),
-            np.array([34.60312115, -15.70974390, 2.26601353]),
+            np.array([53.85070486, -12.48767103, 1.80705844]),
             decimal=7)
 
         np.testing.assert_almost_equal(
             XYZ_to_hdr_IPT(
                 np.array([0.25506814, 0.19150000, 0.08849752]), Y_abs=1000),
-            np.array([47.18074546, 32.38073691, 29.13827648]),
+            np.array([57.49548734, 25.88213868, 21.85080772]),
             decimal=7)
 
     def test_n_dimensional_XYZ_to_hdr_IPT(self):
@@ -61,7 +135,7 @@ class TestXYZ_to_hdr_IPT(unittest.TestCase):
         XYZ = np.array([0.07049534, 0.10080000, 0.09558313])
         Y_s = 0.2
         Y_abs = 100
-        IPT_hdr = np.array([25.18261761, -22.62111297, 3.18511729])
+        IPT_hdr = np.array([24.88927680, -11.44574144, 1.63147707])
         np.testing.assert_almost_equal(
             XYZ_to_hdr_IPT(XYZ, Y_s, Y_abs), IPT_hdr, decimal=7)
 
@@ -110,19 +184,26 @@ class TestHdr_IPT_to_XYZ(unittest.TestCase):
         """
 
         np.testing.assert_almost_equal(
-            hdr_IPT_to_XYZ(np.array([25.18261761, -22.62111297, 3.18511729])),
+            hdr_IPT_to_XYZ(np.array([24.88927680, -11.44574144, 1.63147707])),
             np.array([0.07049534, 0.10080000, 0.09558313]),
             decimal=7)
 
         np.testing.assert_almost_equal(
             hdr_IPT_to_XYZ(
-                np.array([34.60312115, -15.70974390, 2.26601353]), Y_s=0.5),
+                np.array([25.18261761, -22.62111297, 3.18511729]),
+                method='Fairchild 2010'),
             np.array([0.07049534, 0.10080000, 0.09558313]),
             decimal=7)
 
         np.testing.assert_almost_equal(
             hdr_IPT_to_XYZ(
-                np.array([47.18074546, 32.38073691, 29.13827648]), Y_abs=1000),
+                np.array([53.85070486, -12.48767103, 1.80705844]), Y_s=0.5),
+            np.array([0.07049534, 0.10080000, 0.09558313]),
+            decimal=7)
+
+        np.testing.assert_almost_equal(
+            hdr_IPT_to_XYZ(
+                np.array([57.49548734, 25.88213868, 21.85080772]), Y_abs=1000),
             np.array([0.25506814, 0.19150000, 0.08849752]),
             decimal=7)
 
@@ -132,7 +213,7 @@ class TestHdr_IPT_to_XYZ(unittest.TestCase):
         n-dimensions support.
         """
 
-        IPT_hdr = np.array([25.18261761, -22.62111297, 3.18511729])
+        IPT_hdr = np.array([24.88927680, -11.44574144, 1.63147707])
         Y_s = 0.2
         Y_abs = 100
         XYZ = np.array([0.07049534, 0.10080000, 0.09558313])
@@ -172,67 +253,5 @@ class TestHdr_IPT_to_XYZ(unittest.TestCase):
             hdr_IPT_to_XYZ(IPT_hdr, Y_s, Y_abs)
 
 
-class TestExponent_hdr_IPT(unittest.TestCase):
-    """
-    Defines :func:`colour.models.hdr_ipt.exponent_hdr_IPT`
-    definition unit tests methods.
-    """
-
-    def test_exponent_hdr_IPT(self):
-        """
-        Tests :func:`colour.models.hdr_ipt.exponent_hdr_IPT`
-        definition.
-        """
-
-        self.assertAlmostEqual(
-            exponent_hdr_IPT(0.2, 100), 1.689138305989492, places=7)
-
-        self.assertAlmostEqual(
-            exponent_hdr_IPT(0.4, 100), 1.219933220992410, places=7)
-
-        self.assertAlmostEqual(
-            exponent_hdr_IPT(0.2, 1000), 1.126092203992995, places=7)
-
-    def test_n_dimensional_exponent_hdr_IPT(self):
-        """
-        Tests :func:`colour.models.hdr_ipt.exponent_hdr_IPT`
-        definition n-dimensional arrays support.
-        """
-
-        Y_s = 0.2
-        Y_abs = 100
-        e = 1.689138305989492
-        np.testing.assert_almost_equal(
-            exponent_hdr_IPT(Y_s, Y_abs), e, decimal=7)
-
-        Y_s = np.tile(Y_s, 6)
-        Y_abs = np.tile(Y_abs, 6)
-        e = np.tile(e, 6)
-        np.testing.assert_almost_equal(
-            exponent_hdr_IPT(Y_s, Y_abs), e, decimal=7)
-
-        Y_s = np.reshape(Y_s, (2, 3))
-        Y_abs = np.reshape(Y_abs, (2, 3))
-        e = np.reshape(e, (2, 3))
-        np.testing.assert_almost_equal(
-            exponent_hdr_IPT(Y_s, Y_abs), e, decimal=7)
-
-        Y_s = np.reshape(Y_s, (2, 3, 1))
-        Y_abs = np.reshape(Y_abs, (2, 3, 1))
-        e = np.reshape(e, (2, 3, 1))
-        np.testing.assert_almost_equal(
-            exponent_hdr_IPT(Y_s, Y_abs), e, decimal=7)
-
-    @ignore_numpy_errors
-    def test_nan_exponent_hdr_IPT(self):
-        """
-        Tests :func:`colour.models.hdr_ipt.exponent_hdr_IPT`
-        definition nan support.
-        """
-
-        cases = np.array([-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan])
-        exponent_hdr_IPT(cases, cases)
-
-
 if __name__ == '__main__':
     unittest.main()