--- /dev/null
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Implements support for general colorspaces conversions and transfer functions.
+"""
+
+from __future__ import division
+
+import array
+import os
+
+import PyOpenColorIO as ocio
+
+import aces_ocio.generate_lut as genlut
+from aces_ocio.colorspaces import aces
+from aces_ocio.utilities import ColorSpace, mat44_from_mat33
+
+__author__ = 'ACES Developers'
+__copyright__ = 'Copyright (C) 2014 - 2015 - ACES Developers'
+__license__ = ''
+__maintainer__ = 'ACES Developers'
+__email__ = 'aces@oscars.org'
+__status__ = 'Production'
+
+__all__ = ['create_matrix_colorspace',
+ 'create_transfer_colorspace',
+ 'create_matrix_plus_transfer_colorspace',
+ 'transfer_function_sRGB_to_linear',
+ 'transfer_function_Rec709_to_linear',
+ 'transfer_function_Rec2020_10bit_to_linear',
+ 'transfer_function_Rec2020_12bit_to_linear',
+ 'transfer_function_Rec1886_to_linear',
+ 'create_colorspaces',
+ 'create_raw']
+
+
+# -------------------------------------------------------------------------
+# *Matrix Transform*
+# -------------------------------------------------------------------------
+def create_matrix_colorspace(name='matrix',
+ from_reference_values=None,
+ to_reference_values=None,
+ aliases=None):
+ """
+ Creates a ColorSpace that only uses *Matrix Transforms*
+
+ Parameters
+ ----------
+ name : str, optional
+ Aliases for this colorspace
+ from_reference_values : list of matrices
+ List of matrices to convert from the reference colorspace to this space
+ to_reference_values : list of matrices
+ List of matrices to convert to the reference colorspace from this space
+ aliases : list of str, optional
+ Aliases for this colorspace
+
+ Returns
+ -------
+ ColorSpace
+ A *Matrix Transform*-based ColorSpace
+ """
+
+ if from_reference_values is None:
+ from_reference_values = []
+
+ if to_reference_values is None:
+ to_reference_values = []
+
+ if aliases is None:
+ aliases = []
+
+ cs = ColorSpace(name)
+ cs.description = 'The %s color space' % name
+ cs.aliases = aliases
+ cs.equality_group = name
+ cs.family = 'Utility'
+ cs.is_data = False
+
+ # A linear space needs allocation variables.
+ cs.allocation_type = ocio.Constants.ALLOCATION_UNIFORM
+ cs.allocation_vars = [0, 1]
+
+ cs.to_reference_transforms = []
+ if to_reference_values:
+ for matrix in to_reference_values:
+ cs.to_reference_transforms.append({
+ 'type': 'matrix',
+ 'matrix': mat44_from_mat33(matrix),
+ 'direction': 'forward'})
+
+ cs.from_reference_transforms = []
+ if from_reference_values:
+ for matrix in from_reference_values:
+ cs.from_reference_transforms.append({
+ 'type': 'matrix',
+ 'matrix': mat44_from_mat33(matrix),
+ 'direction': 'forward'})
+
+ return cs
+
+
+# -------------------------------------------------------------------------
+# *Transfer Function Transform*
+# -------------------------------------------------------------------------
+def create_transfer_colorspace(name='transfer',
+ transfer_function_name='transfer_function',
+ transfer_function=lambda x: x,
+ lut_directory='/tmp',
+ lut_resolution_1d=1024,
+ aliases=None):
+ """
+ Creates a ColorSpace that only uses transfer functions encoded as 1D LUTs
+
+ Parameters
+ ----------
+ name : str, optional
+ Aliases for this colorspace
+ transfer_function_name : str, optional
+ The name of the transfer function
+ transfer_function : function, optional
+ The transfer function to be evaluated
+ lut_directory : str or unicode
+ The directory to use when generating LUTs
+ lut_resolution_1d : int
+ The resolution of generated 1D LUTs
+ aliases : list of str
+ Aliases for this colorspace
+
+ Returns
+ -------
+ ColorSpace
+ A *LUT1D Transform*-based ColorSpace representing a transfer function
+ """
+
+ if aliases is None:
+ aliases = []
+
+ cs = ColorSpace(name)
+ cs.description = 'The %s color space' % name
+ cs.aliases = aliases
+ cs.equality_group = name
+ cs.family = 'Utility'
+ cs.is_data = False
+
+ # A linear space needs allocation variables.
+ cs.allocation_type = ocio.Constants.ALLOCATION_UNIFORM
+ cs.allocation_vars = [0, 1]
+
+ # Sampling the transfer function.
+ data = array.array('f', '\0' * lut_resolution_1d * 4)
+ for c in range(lut_resolution_1d):
+ data[c] = transfer_function(c / (lut_resolution_1d - 1))
+
+ # Writing the sampled data to a *LUT*.
+ lut = '%s_to_linear.spi1d' % transfer_function_name
+ genlut.write_SPI_1d(
+ os.path.join(lut_directory, lut),
+ 0,
+ 1,
+ data,
+ lut_resolution_1d,
+ 1)
+
+ # Creating the *to_reference* transforms.
+ cs.to_reference_transforms = []
+ cs.to_reference_transforms.append({
+ 'type': 'lutFile',
+ 'path': lut,
+ 'interpolation': 'linear',
+ 'direction': 'forward'})
+
+ # Creating the *from_reference* transforms.
+ cs.from_reference_transforms = []
+
+ return cs
+
+
+# -------------------------------------------------------------------------
+# *Transfer Function + Matrix Transform*
+# -------------------------------------------------------------------------
+def create_matrix_plus_transfer_colorspace(
+ name='matrix_plus_transfer',
+ transfer_function_name='transfer_function',
+ transfer_function=lambda x: x,
+ lut_directory='/tmp',
+ lut_resolution_1d=1024,
+ from_reference_values=None,
+ to_reference_values=None,
+ aliases=None):
+ """
+ Creates a ColorSpace that uses transfer functions encoded as 1D LUTs and
+ matrice
+
+ Parameters
+ ----------
+ name : str, optional
+ Aliases for this colorspace
+ transfer_function_name : str, optional
+ The name of the transfer function
+ transfer_function : function, optional
+ The transfer function to be evaluated
+ lut_directory : str or unicode
+ The directory to use when generating LUTs
+ lut_resolution_1d : int
+ The resolution of generated 1D LUTs
+ from_reference_values : list of matrices
+ List of matrices to convert from the reference colorspace to this space
+ to_reference_values : list of matrices
+ List of matrices to convert to the reference colorspace from this space
+ aliases : list of str
+ Aliases for this colorspace
+
+ Returns
+ -------
+ ColorSpace
+ A *Matrx and LUT1D Transform*-based ColorSpace representing a transfer
+ function and matrix
+ """
+
+ if from_reference_values is None:
+ from_reference_values = []
+
+ if to_reference_values is None:
+ to_reference_values = []
+
+ if aliases is None:
+ aliases = []
+
+ cs = ColorSpace(name)
+ cs.description = 'The %s color space' % name
+ cs.aliases = aliases
+ cs.equality_group = name
+ cs.family = 'Utility'
+ cs.is_data = False
+
+ # A linear space needs allocation variables.
+ cs.allocation_type = ocio.Constants.ALLOCATION_UNIFORM
+ cs.allocation_vars = [0, 1]
+
+ # Sampling the transfer function.
+ data = array.array('f', '\0' * lut_resolution_1d * 4)
+ for c in range(lut_resolution_1d):
+ data[c] = transfer_function(c / (lut_resolution_1d - 1))
+
+ # Writing the sampled data to a *LUT*.
+ lut = '%s_to_linear.spi1d' % transfer_function_name
+ genlut.write_SPI_1d(
+ os.path.join(lut_directory, lut),
+ 0,
+ 1,
+ data,
+ lut_resolution_1d,
+ 1)
+
+ # Creating the *to_reference* transforms.
+ cs.to_reference_transforms = []
+ if to_reference_values:
+ cs.to_reference_transforms.append({
+ 'type': 'lutFile',
+ 'path': lut,
+ 'interpolation': 'linear',
+ 'direction': 'forward'})
+
+ for matrix in to_reference_values:
+ cs.to_reference_transforms.append({
+ 'type': 'matrix',
+ 'matrix': mat44_from_mat33(matrix),
+ 'direction': 'forward'})
+
+ # Creating the *from_reference* transforms.
+ cs.from_reference_transforms = []
+ if from_reference_values:
+ for matrix in from_reference_values:
+ cs.from_reference_transforms.append({
+ 'type': 'matrix',
+ 'matrix': mat44_from_mat33(matrix),
+ 'direction': 'forward'})
+
+ cs.from_reference_transforms.append({
+ 'type': 'lutFile',
+ 'path': lut,
+ 'interpolation': 'linear',
+ 'direction': 'inverse'})
+
+ return cs
+
+
+# Transfer functions for standard colorspaces.
+def transfer_function_sRGB_to_linear(v):
+ """
+ The sRGB (IEC 61966-2-1) transfer function
+
+ Parameters
+ ----------
+ v : float
+ The normalized value to pass through the function
+
+ Returns
+ -------
+ float
+ A converted value
+ """
+ a = 1.055
+ b = 0.04045
+ d = 12.92
+ g = 2.4
+
+ if v < b:
+ return v / d
+ return pow(((v + (a - 1)) / a), g)
+
+
+def transfer_function_Rec709_to_linear(v):
+ """
+ The Rec.709 transfer function
+
+ Parameters
+ ----------
+ v : float
+ The normalized value to pass through the function
+
+ Returns
+ -------
+ float
+ A converted value
+ """
+ a = 1.099
+ b = 0.018
+ d = 4.5
+ g = (1.0 / 0.45)
+
+ if v < b * d:
+ return v / d
+
+ return pow(((v + (a - 1)) / a), g)
+
+
+def transfer_function_Rec2020_10bit_to_linear(v):
+ """
+ The Rec.2020 10-bit transfer function
+
+ Parameters
+ ----------
+ v : float
+ The normalized value to pass through the function
+
+ Returns
+ -------
+ float
+ A converted value
+ """
+ a = 1.099
+ b = 0.018
+ d = 4.5
+ g = (1.0 / 0.45)
+
+ if v < b * d:
+ return v / d
+
+ return pow(((v + (a - 1)) / a), g)
+
+
+def transfer_function_Rec2020_12bit_to_linear(v):
+ """
+ The Rec.2020 12-bit transfer function
+
+ Parameters
+ ----------
+ v : float
+ The normalized value to pass through the function
+
+ Returns
+ -------
+ float
+ A converted value
+ """
+ a = 1.0993
+ b = 0.0181
+ d = 4.5
+ g = (1.0 / 0.45)
+
+ if v < b * d:
+ return v / d
+
+ return pow(((v + (a - 1)) / a), g)
+
+
+def transfer_function_Rec1886_to_linear(v):
+ """
+ The Rec.1886 transfer function
+
+ Parameters
+ ----------
+ v : float
+ The normalized value to pass through the function
+
+ Returns
+ -------
+ float
+ A converted value
+ """
+ g = 2.4
+ Lw = 1
+ Lb = 0
+
+ # Ignoring legal to full scaling for now.
+ # v = (1023.0*v - 64.0)/876.0
+
+ t = pow(Lw, 1.0 / g) - pow(Lb, 1.0 / g)
+ a = pow(t, g)
+ b = pow(Lb, 1.0 / g) / t
+
+ return a * pow(max((v + b), 0.0), g)
+
+
+def create_colorspaces(lut_directory,
+ lut_resolution_1d):
+ """
+ Generates the colorspace conversions.
+
+ Parameters
+ ----------
+ lut_directory : str or unicode
+ The directory to use when generating LUTs
+ lut_resolution_1d : int
+ The resolution of generated 1D LUTs
+
+ Returns
+ -------
+ list
+ A list of colorspaces for general colorspaces and encodings
+ """
+
+ colorspaces = []
+
+ # -------------------------------------------------------------------------
+ # XYZ
+ # -------------------------------------------------------------------------
+ cs = create_matrix_colorspace('XYZ - D60',
+ to_reference_values=[aces.ACES_XYZ_TO_AP0],
+ from_reference_values=[aces.ACES_AP0_TO_XYZ],
+ aliases=['lin_xyz_d60'])
+ colorspaces.append(cs)
+
+ # -------------------------------------------------------------------------
+ # P3-D60
+ # -------------------------------------------------------------------------
+ # *ACES* to *Linear*, *P3D60* primaries
+ XYZ_to_P3D60 = [2.4027414142, -0.8974841639, -0.3880533700,
+ -0.8325796487, 1.7692317536, 0.0237127115,
+ 0.0388233815, -0.0824996856, 1.0363685997]
+
+ cs = create_matrix_colorspace(
+ 'Linear - P3-D60',
+ from_reference_values=[aces.ACES_AP0_TO_XYZ, XYZ_to_P3D60],
+ aliases=['lin_p3d60'])
+ colorspaces.append(cs)
+
+ # -------------------------------------------------------------------------
+ # P3-DCI
+ # -------------------------------------------------------------------------
+ # *ACES* to *Linear*, *P3DCI* primaries, using Bradford chromatic
+ # adaptation
+ XYZ_to_P3DCI = [2.66286135, -1.11031783, -0.42271635,
+ -0.82282376, 1.75861704, 0.02502194,
+ 0.03932561, -0.08383448, 1.0372175]
+
+ cs = create_matrix_colorspace(
+ 'Linear - P3-DCI',
+ from_reference_values=[aces.ACES_AP0_TO_XYZ, XYZ_to_P3DCI],
+ aliases=['lin_p3dci'])
+ colorspaces.append(cs)
+
+ # -------------------------------------------------------------------------
+ # sRGB
+ # -------------------------------------------------------------------------
+ # *sRGB* and *Rec 709* use the same gamut.
+
+ # *ACES* to *Linear*, *Rec. 709* primaries, D65 white point, using
+ # Bradford chromatic adaptation
+ XYZ_to_Rec709 = [3.20959735, -1.55742955, -0.49580497,
+ -0.97098887, 1.88517118, 0.03948941,
+ 0.05971934, -0.21010444, 1.14312482]
+
+ cs = create_matrix_colorspace(
+ 'Linear - sRGB',
+ from_reference_values=[aces.ACES_AP0_TO_XYZ, XYZ_to_Rec709],
+ aliases=['lin_srgb'])
+ colorspaces.append(cs)
+
+ # *Linear* to *sRGB* Transfer Function*
+ cs = create_transfer_colorspace(
+ 'Curve - sRGB',
+ 'sRGB',
+ transfer_function_sRGB_to_linear,
+ lut_directory,
+ lut_resolution_1d,
+ aliases=['crv_srgb'])
+ colorspaces.append(cs)
+
+ # *ACES* to *sRGB* Primaries + Transfer Function*
+ cs = create_matrix_plus_transfer_colorspace(
+ 'sRGB - Texture',
+ 'sRGB',
+ transfer_function_sRGB_to_linear,
+ lut_directory,
+ lut_resolution_1d,
+ from_reference_values=[aces.ACES_AP0_TO_XYZ, XYZ_to_Rec709],
+ aliases=['srgb_texture'])
+ colorspaces.append(cs)
+
+ # -------------------------------------------------------------------------
+ # Rec 709
+ # -------------------------------------------------------------------------
+ # *sRGB* and *Rec 709* use the same gamut.
+ cs = create_matrix_colorspace(
+ 'Linear - Rec.709',
+ from_reference_values=[aces.ACES_AP0_TO_XYZ, XYZ_to_Rec709],
+ aliases=['lin_rec709'])
+ colorspaces.append(cs)
+
+ # *Linear* to *Rec. 709* Transfer Function*
+ cs = create_transfer_colorspace(
+ 'Curve - Rec.709',
+ 'rec709',
+ transfer_function_Rec709_to_linear,
+ lut_directory,
+ lut_resolution_1d,
+ aliases=['crv_rec709'])
+ colorspaces.append(cs)
+
+ # *ACES* to *Rec. 709* Primaries + Transfer Function*
+ cs = create_matrix_plus_transfer_colorspace(
+ 'Rec.709 - Camera',
+ 'rec709',
+ transfer_function_Rec709_to_linear,
+ lut_directory,
+ lut_resolution_1d,
+ from_reference_values=[aces.ACES_AP0_TO_XYZ, XYZ_to_Rec709],
+ aliases=['rec709_camera'])
+ colorspaces.append(cs)
+
+ # -------------------------------------------------------------------------
+ # Rec 2020
+ # -------------------------------------------------------------------------
+ # *ACES* to *Linear*, *Rec. 2020* primaries, D65 white point, using
+ # Bradford chromatic adaptation
+ XYZ_to_Rec2020 = [1.69662619, -0.36551982, -0.24857099,
+ -0.67039877, 1.62348187, 0.01503821,
+ 0.02063163, -0.04775634, 1.01910818]
+
+ cs = create_matrix_colorspace(
+ 'Linear - Rec.2020',
+ from_reference_values=[aces.ACES_AP0_TO_XYZ, XYZ_to_Rec2020],
+ aliases=['lin_rec2020'])
+ colorspaces.append(cs)
+
+ # *Linear* to *Rec. 2020 10 bit* Transfer Function*
+ cs = create_transfer_colorspace(
+ 'Curve - Rec.2020',
+ 'rec2020',
+ transfer_function_Rec2020_10bit_to_linear,
+ lut_directory,
+ lut_resolution_1d,
+ aliases=['crv_rec2020'])
+ colorspaces.append(cs)
+
+ # *ACES* to *Rec. 2020 10 bit* Primaries + Transfer Function*
+ cs = create_matrix_plus_transfer_colorspace(
+ 'Rec.2020 - Camera',
+ 'rec2020',
+ transfer_function_Rec2020_10bit_to_linear,
+ lut_directory,
+ lut_resolution_1d,
+ from_reference_values=[aces.ACES_AP0_TO_XYZ, XYZ_to_Rec2020],
+ aliases=['rec2020_camera'])
+ colorspaces.append(cs)
+
+ # -------------------------------------------------------------------------
+ # Rec 1886
+ # -------------------------------------------------------------------------
+ # *Linear* to *Rec.1886* Transfer Function*
+ cs = create_transfer_colorspace(
+ 'Curve - Rec.1886',
+ 'rec1886',
+ transfer_function_Rec1886_to_linear,
+ lut_directory,
+ lut_resolution_1d,
+ aliases=['crv_rec1886'])
+ colorspaces.append(cs)
+
+ # *ACES* to *Rec. 709* Primaries + Transfer Function*
+ cs = create_matrix_plus_transfer_colorspace(
+ 'Rec.709 - Display',
+ 'rec1886',
+ transfer_function_Rec1886_to_linear,
+ lut_directory,
+ lut_resolution_1d,
+ from_reference_values=[aces.ACES_AP0_TO_XYZ, XYZ_to_Rec709],
+ aliases=['rec709_display'])
+ colorspaces.append(cs)
+
+ # *ACES* to *Rec. 2020* Primaries + Transfer Function*
+ cs = create_matrix_plus_transfer_colorspace(
+ 'Rec.2020 - Display',
+ 'rec1886',
+ transfer_function_Rec1886_to_linear,
+ lut_directory,
+ lut_resolution_1d,
+ from_reference_values=[aces.ACES_AP0_TO_XYZ, XYZ_to_Rec2020],
+ aliases=['rec2020_display'])
+ colorspaces.append(cs)
+
+ # -------------------------------------------------------------------------
+ # ProPhoto
+ # -------------------------------------------------------------------------
+ # *ACES* to *Linear*, *Pro Photo* primaries, D50 white point, using
+ # Bradford chromatic adaptation
+ AP0_to_RIMM = [1.2412367771, -0.1685692287, -0.0726675484,
+ 0.0061203066, 1.083151174, -0.0892714806,
+ -0.0032853314, 0.0099796402, 0.9933056912]
+
+ cs = create_matrix_colorspace(
+ 'Linear - RIMM ROMM (ProPhoto)',
+ from_reference_values=[AP0_to_RIMM],
+ aliases=['lin_prophoto', 'lin_rimm'])
+ colorspaces.append(cs)
+
+ # -------------------------------------------------------------------------
+ # Adobe RGB
+ # -------------------------------------------------------------------------
+ # *ACES* to *Linear*, *Adobe RGB* primaries, D65 white point, using
+ # Bradford chromatic adaptation
+ AP0_to_ADOBERGB = [1.7245603168, -0.4199935942, -0.3045667227,
+ -0.2764799142, 1.3727190877, -0.0962391734,
+ -0.0261255258, -0.0901747807, 1.1163003065]
+
+ cs = create_matrix_colorspace(
+ 'Linear - Adobe RGB',
+ from_reference_values=[AP0_to_ADOBERGB],
+ aliases=['lin_adobergb'])
+ colorspaces.append(cs)
+
+ # -------------------------------------------------------------------------
+ # Adobe Wide Gamut RGB
+ # -------------------------------------------------------------------------
+ # *ACES* to *Linear*, *Adobe Wide Gamut RGB* primaries, D50 white point,
+ # using Bradford chromatic adaptation
+ AP0_to_ADOBEWIDEGAMUT = [1.3809814778, -0.1158594573, -0.2651220205,
+ 0.0057015535, 1.0402949043, -0.0459964578,
+ -0.0038908746, -0.0597091815, 1.0636000561]
+
+ cs = create_matrix_colorspace(
+ 'Linear - Adobe Wide Gamut RGB',
+ from_reference_values=[AP0_to_ADOBEWIDEGAMUT],
+ aliases=['lin_adobewidegamutrgb'])
+ colorspaces.append(cs)
+
+ return colorspaces
+
+
+def create_raw():
+ """
+ Creates the *raw* color space
+
+ Parameters
+ ----------
+ None
+
+ Returns
+ -------
+ ColorSpace
+ *raw* and all its identifying information
+ """
+ # *Raw* utility space
+ name = 'Raw'
+ raw = ColorSpace(name)
+ raw.description = 'The %s color space' % name
+ raw.aliases = ['raw']
+ raw.equality_group = name
+ raw.family = 'Utility'
+ raw.is_data = True
+
+ return raw
projects / OpenColorIO-Configs.git / blobdiff