X-Git-Url: http://users.mur.at/ms/git/gitweb/?p=OpenColorIO-Configs.git;a=blobdiff_plain;f=aces_1.0.1%2Fpython%2Faces_ocio%2Fcolorspaces%2Faces.py;fp=aces_1.0.1%2Fpython%2Faces_ocio%2Fcolorspaces%2Faces.py;h=12453e2be7e86a39bf118fbd0c6c9938ad1f04da;hp=0000000000000000000000000000000000000000;hb=22e6f32dc4ea25f99c83a6226cc4907b30b1cfcd;hpb=18a75430917db571c2846873510f77086d885479 diff --git a/aces_1.0.1/python/aces_ocio/colorspaces/aces.py b/aces_1.0.1/python/aces_ocio/colorspaces/aces.py new file mode 100644 index 0000000..12453e2 --- /dev/null +++ b/aces_1.0.1/python/aces_ocio/colorspaces/aces.py @@ -0,0 +1,1986 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +""" +Implements support for *ACES* colorspaces conversions and transfer functions. +""" + +from __future__ import division + +import copy +import math +import numpy +import os +import pprint +import string +import shutil + +import PyOpenColorIO as ocio + +from aces_ocio.generate_lut import ( + generate_1d_LUT_from_CTL, + generate_3d_LUT_from_CTL, + write_SPI_1d) +from aces_ocio.utilities import ( + ColorSpace, + mat44_from_mat33, + sanitize, + compact) + +__author__ = 'ACES Developers' +__copyright__ = 'Copyright (C) 2014 - 2015 - ACES Developers' +__license__ = '' +__maintainer__ = 'ACES Developers' +__email__ = 'aces@oscars.org' +__status__ = 'Production' + +__all__ = ['ACES_AP1_TO_AP0', + 'ACES_AP0_TO_AP1', + 'ACES_AP0_TO_XYZ', + 'ACES_XYZ_TO_AP0', + 'create_ACES', + 'create_ACEScc', + 'create_ACESproxy', + 'create_ACEScg', + 'create_ADX', + 'create_generic_log', + 'create_Dolby_PQ', + 'create_Dolby_PQ_shaper', + 'create_ACES_LMT', + 'create_LMTs', + 'create_ACES_RRT_plus_ODT', + 'create_ODTs', + 'create_shapers_dolbypq' + 'create_shapers_log2', + 'create_shapers', + 'get_transform_info', + 'get_ODTs_info', + 'get_LMTs_info', + 'create_colorspaces'] + +# Matrix converting *ACES AP1* primaries to *ACES AP0*. +ACES_AP1_TO_AP0 = [0.6954522414, 0.1406786965, 0.1638690622, + 0.0447945634, 0.8596711185, 0.0955343182, + -0.0055258826, 0.0040252103, 1.0015006723] + +# Matrix converting *ACES AP0* primaries to *ACES AP1*. +ACES_AP0_TO_AP1 = [1.4514393161, -0.2365107469, -0.2149285693, + -0.0765537734, 1.1762296998, -0.0996759264, + 0.0083161484, -0.0060324498, 0.9977163014] + +# Matrix converting *ACES AP0* primaries to *XYZ*. +ACES_AP0_TO_XYZ = [0.9525523959, 0.0000000000, 0.0000936786, + 0.3439664498, 0.7281660966, -0.0721325464, + 0.0000000000, 0.0000000000, 1.0088251844] + +# Matrix converting *ACES AP0* primaries to *XYZ*. +ACES_XYZ_TO_AP0 = [1.0498110175, 0.0000000000, -0.0000974845, + -0.4959030231, 1.3733130458, 0.0982400361, + 0.0000000000, 0.0000000000, 0.9912520182] + + +def create_ACES(): + """ + Creates the *ACES2065-1* reference color space + + Parameters + ---------- + None + + Returns + ------- + ColorSpace + *ACES2065-1* and all its identifying information + """ + + # Defining the reference colorspace. + aces2065_1 = ColorSpace('ACES2065-1') + aces2065_1.description = ( + 'The Academy Color Encoding System reference color space') + aces2065_1.equality_group = '' + aces2065_1.aliases = ['lin_ap0', 'aces'] + aces2065_1.family = 'ACES' + aces2065_1.is_data = False + aces2065_1.allocation_type = ocio.Constants.ALLOCATION_LG2 + aces2065_1.allocation_vars = [-8, 5, 0.00390625] + + return aces2065_1 + + +def create_ACEScc(aces_ctl_directory, + lut_directory, + lut_resolution_1d, + cleanup, + name='ACEScc', + min_value=0, + max_value=1, + input_scale=1): + """ + Creates the *ACEScc* reference color space + + Parameters + ---------- + aces_ctl_directory : str or unicode + The path to the aces 'transforms/ctl/utilities' + lut_directory : str or unicode + The directory to use when generating LUTs + lut_resolution_1d : int + The resolution of generated 1D LUTs + cleanup : bool + Whether or not to clean up the intermediate images + name : str or unicode, optional + The name of the ColorSpace + min_value : float, optional + The minimum value to consider for the space + max_value : float, optional + The maximum value to consider for the space + input_scale : float, optional + A scale factor to divide input values + + Returns + ------- + ColorSpace + *ACEScc* and all its identifying information + """ + + cs = ColorSpace(name) + cs.description = 'The %s color space' % name + cs.aliases = ['acescc', 'acescc_ap1'] + cs.equality_group = '' + cs.family = 'ACES' + cs.is_data = False + cs.allocation_type = ocio.Constants.ALLOCATION_UNIFORM + cs.allocation_vars = [min_value, max_value] + cs.aces_transform_id = 'ACEScsc.ACEScc_to_ACES.a1.0.1' + + ctls = [os.path.join(aces_ctl_directory, + 'ACEScc', + 'ACEScsc.ACEScc_to_ACES.a1.0.1.ctl'), + # This transform gets back to the *AP1* primaries. + # Useful as the 1d LUT is only covering the transfer function. + # The primaries switch is covered by the matrix below: + os.path.join(aces_ctl_directory, + 'ACEScg', + 'ACEScsc.ACES_to_ACEScg.a1.0.1.ctl')] + lut = '%s_to_linear.spi1d' % name + + lut = sanitize(lut) + + generate_1d_LUT_from_CTL( + os.path.join(lut_directory, lut), + ctls, + lut_resolution_1d, + 'float', + input_scale, + 1, + {}, + cleanup, + aces_ctl_directory, + min_value, + max_value, + 1) + + cs.to_reference_transforms = [] + cs.to_reference_transforms.append({ + 'type': 'lutFile', + 'path': lut, + 'interpolation': 'linear', + 'direction': 'forward'}) + + # *AP1* primaries to *AP0* primaries + cs.to_reference_transforms.append({ + 'type': 'matrix', + 'matrix': mat44_from_mat33(ACES_AP1_TO_AP0), + 'direction': 'forward'}) + + cs.from_reference_transforms = [] + return cs + + +def create_ACESproxy(aces_ctl_directory, + lut_directory, + lut_resolution_1d, + cleanup, + name='ACESproxy'): + """ + Creates the *ACESproxy* color space + + Parameters + ---------- + aces_ctl_directory : str or unicode + The path to the aces 'transforms/ctl/utilities' + lut_directory : str or unicode + The directory to use when generating LUTs + lut_resolution_1d : int + The resolution of generated 1D LUTs + cleanup : bool + Whether or not to clean up the intermediate images + name : str or unicode, optional + The name of the ColorSpace + + Returns + ------- + ColorSpace + *ACESproxy* and all its identifying information + """ + + cs = ColorSpace(name) + cs.description = 'The %s color space' % name + cs.aliases = ['acesproxy', 'acesproxy_ap1'] + cs.equality_group = '' + cs.family = 'ACES' + cs.is_data = False + + cs.aces_transform_id = 'ACEScsc.ACESproxy10i_to_ACES.a1.0.1' + + ctls = [os.path.join(aces_ctl_directory, + 'ACESproxy', + 'ACEScsc.ACESproxy10i_to_ACES.a1.0.1.ctl'), + # This transform gets back to the *AP1* primaries. + # Useful as the 1d LUT is only covering the transfer function. + # The primaries switch is covered by the matrix below: + os.path.join(aces_ctl_directory, + 'ACEScg', + 'ACEScsc.ACES_to_ACEScg.a1.0.1.ctl')] + lut = '%s_to_linear.spi1d' % name + + lut = sanitize(lut) + + generate_1d_LUT_from_CTL( + os.path.join(lut_directory, lut), + ctls, + lut_resolution_1d, + 'float', + 1, + 1, + {}, + cleanup, + aces_ctl_directory, + 0, + 1, + 1) + + cs.to_reference_transforms = [] + cs.to_reference_transforms.append({ + 'type': 'lutFile', + 'path': lut, + 'interpolation': 'linear', + 'direction': 'forward'}) + + # *AP1* primaries to *AP0* primaries + cs.to_reference_transforms.append({ + 'type': 'matrix', + 'matrix': mat44_from_mat33(ACES_AP1_TO_AP0), + 'direction': 'forward'}) + + cs.from_reference_transforms = [] + return cs + + +# ------------------------------------------------------------------------- +# *ACEScg* +# ------------------------------------------------------------------------- +def create_ACEScg(): + """ + Creates the *ACEScg* color space + + Parameters + ---------- + None + + Returns + ------- + ColorSpace + *ACEScg* and all its identifying information + """ + + name = 'ACEScg' + + cs = ColorSpace(name) + cs.description = 'The %s color space' % name + cs.aliases = ['acescg', 'lin_ap1'] + cs.equality_group = '' + cs.family = 'ACES' + cs.is_data = False + cs.allocation_type = ocio.Constants.ALLOCATION_LG2 + cs.allocation_vars = [-8, 5, 0.00390625] + + cs.aces_transform_id = 'ACEScsc.ACEScg_to_ACES.a1.0.1' + + cs.to_reference_transforms = [] + + # *AP1* primaries to *AP0* primaries + cs.to_reference_transforms.append({ + 'type': 'matrix', + 'matrix': mat44_from_mat33(ACES_AP1_TO_AP0), + 'direction': 'forward'}) + + cs.from_reference_transforms = [] + + # Commented out because specifying the inverse matrix causes some + # of OCIO's checks to see if a set of transforms can be collapsed + # to fail. + + # *AP1* primaries to *AP0* primaries + #cs.from_reference_transforms.append({ + # 'type': 'matrix', + # 'matrix': mat44_from_mat33(ACES_AP0_TO_AP1), + # 'direction': 'forward'}) + + return cs + + +# ------------------------------------------------------------------------- +# *ADX* +# ------------------------------------------------------------------------- +def create_ADX(lut_directory, + bit_depth=10, + name='ADX'): + """ + Creates the *ADX* color space + + Parameters + ---------- + lut_directory : str or unicode + The directory to use when generating LUTs + bit_depth : int + Choose either 10 or 16 bit ADX + name : str or unicode, optional + The name of the ColorSpace + + Returns + ------- + ColorSpace + *ADX* and all its identifying information + """ + + name = '%s%s' % (name, bit_depth) + cs = ColorSpace(name) + cs.description = '%s color space - used for film scans' % name + cs.aliases = ['adx%s' % str(bit_depth)] + cs.equality_group = '' + cs.family = 'ADX' + cs.is_data = False + + if bit_depth == 10: + cs.aces_transform_id = 'ACEScsc.ADX10_to_ACES.a1.0.1' + + cs.bit_depth = ocio.Constants.BIT_DEPTH_UINT10 + ADX_to_CDD = [1023 / 500, 0, 0, 0, + 0, 1023 / 500, 0, 0, + 0, 0, 1023 / 500, 0, + 0, 0, 0, 1] + offset = [-95 / 500, -95 / 500, -95 / 500, 0] + elif bit_depth == 16: + cs.aces_transform_id = 'ACEScsc.ADX16_to_ACES.a1.0.1' + + cs.bit_depth = ocio.Constants.BIT_DEPTH_UINT16 + ADX_to_CDD = [65535 / 8000, 0, 0, 0, + 0, 65535 / 8000, 0, 0, + 0, 0, 65535 / 8000, 0, + 0, 0, 0, 1] + offset = [-1520 / 8000, -1520 / 8000, -1520 / 8000, 0] + + cs.to_reference_transforms = [] + + # Converting from *ADX* to *Channel-Dependent Density*. + cs.to_reference_transforms.append({ + 'type': 'matrix', + 'matrix': ADX_to_CDD, + 'offset': offset, + 'direction': 'forward'}) + + # Converting from *Channel-Dependent Density* to + # *Channel-Independent Density*. + cs.to_reference_transforms.append({ + 'type': 'matrix', + 'matrix': [0.75573, 0.22197, 0.02230, 0, + 0.05901, 0.96928, -0.02829, 0, + 0.16134, 0.07406, 0.76460, 0, + 0, 0, 0, 1], + 'direction': 'forward'}) + + # Copied from *Alex Fry*'s *adx_cid_to_rle.py* + def create_CID_to_RLE_LUT(): + + def interpolate_1d(x, xp, fp): + return numpy.interp(x, xp, fp) + + LUT_1D_XP = [-0.190000000000000, + 0.010000000000000, + 0.028000000000000, + 0.054000000000000, + 0.095000000000000, + 0.145000000000000, + 0.220000000000000, + 0.300000000000000, + 0.400000000000000, + 0.500000000000000, + 0.600000000000000] + + LUT_1D_FP = [-6.000000000000000, + -2.721718645000000, + -2.521718645000000, + -2.321718645000000, + -2.121718645000000, + -1.921718645000000, + -1.721718645000000, + -1.521718645000000, + -1.321718645000000, + -1.121718645000000, + -0.926545676714876] + + REF_PT = ((7120 - 1520) / 8000 * (100 / 55) - + math.log(0.18, 10)) + + def cid_to_rle(x): + if x <= 0.6: + return interpolate_1d(x, LUT_1D_XP, LUT_1D_FP) + return (100 / 55) * x - REF_PT + + def fit(value, from_min, from_max, to_min, to_max): + if from_min == from_max: + raise ValueError('from_min == from_max') + return (value - from_min) / (from_max - from_min) * ( + to_max - to_min) + to_min + + num_samples = 2 ** 12 + domain = (-0.19, 3) + data = [] + for i in xrange(num_samples): + x = i / (num_samples - 1) + x = fit(x, 0, 1, domain[0], domain[1]) + data.append(cid_to_rle(x)) + + lut = 'ADX_CID_to_RLE.spi1d' + write_SPI_1d(os.path.join(lut_directory, lut), + domain[0], + domain[1], + data, + num_samples, 1) + + return lut + + # Converting *Channel Independent Density* values to + # *Relative Log Exposure* values. + lut = create_CID_to_RLE_LUT() + cs.to_reference_transforms.append({ + 'type': 'lutFile', + 'path': lut, + 'interpolation': 'linear', + 'direction': 'forward'}) + + # Converting *Relative Log Exposure* values to + # *Relative Exposure* values. + cs.to_reference_transforms.append({ + 'type': 'log', + 'base': 10, + 'direction': 'inverse'}) + + # Convert *Relative Exposure* values to *ACES* values. + cs.to_reference_transforms.append({ + 'type': 'matrix', + 'matrix': [0.72286, 0.12630, 0.15084, 0, + 0.11923, 0.76418, 0.11659, 0, + 0.01427, 0.08213, 0.90359, 0, + 0, 0, 0, 1], + 'direction': 'forward'}) + + cs.from_reference_transforms = [] + return cs + + +# ------------------------------------------------------------------------- +# Generic *Log* Transform +# ------------------------------------------------------------------------- +def create_generic_log(aces_ctl_directory, + lut_directory, + lut_resolution_1d, + cleanup, + name='log', + aliases=None, + min_value=0, + max_value=1, + input_scale=1, + middle_grey=0.18, + min_exposure=-6.5, + max_exposure=6.5): + """ + Creates the *Generic Log* colorspace. + + Parameters + ---------- + aces_ctl_directory : str or unicode + The path to the aces 'transforms/ctl/utilities' + lut_directory : str or unicode + The directory to use when generating LUTs + lut_resolution_1d : int + The resolution of generated 1D LUTs + cleanup : bool + Whether or not to clean up the intermediate images + name : str or unicode, optional + The name of the ColorSpace + aliases : list of str or unicode, optional + The alias names to use for the ColorSpace + min_value : float, optional + The minimum value to consider for the space + max_value : float, optional + The maximum value to consider for the space + input_scale : float, optional + A scale factor to divide input values + middle_grey : float, optional + The middle of the dynamic range covered by the transfer function + min_exposure : float, optional + The offset from middle grey, in stops, that defines the low end of the dynamic + range covered by the transfer function + max_exposure : float, optional + The offset from middle grey, in stops, that defines the high end of the dynamic + range covered by the transfer function + + Returns + ------- + ColorSpace + *Generic Log* colorspace. + """ + + 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 + + ctls = [os.path.join( + aces_ctl_directory, + 'utilities', + 'ACESlib.Log2_to_Lin_param.a1.0.1.ctl')] + lut = '%s_to_linear.spi1d' % name + + lut = sanitize(lut) + + generate_1d_LUT_from_CTL( + os.path.join(lut_directory, lut), + ctls, + lut_resolution_1d, + 'float', + input_scale, + 1, + {'middleGrey': middle_grey, + 'minExposure': min_exposure, + 'maxExposure': max_exposure}, + cleanup, + aces_ctl_directory, + min_value, + max_value, + 1) + + cs.to_reference_transforms = [] + cs.to_reference_transforms.append({ + 'type': 'lutFile', + 'path': lut, + 'interpolation': 'linear', + 'direction': 'forward'}) + + cs.from_reference_transforms = [] + return cs + + +# ------------------------------------------------------------------------- +# Base *Dolby PQ* Transform +# ------------------------------------------------------------------------- +def create_Dolby_PQ(aces_ctl_directory, + lut_directory, + lut_resolution_1d, + cleanup, + name='pq', + aliases=None, + min_value=0.0, + max_value=1.0, + input_scale=1.0): + """ + Creates the generic *Dolby PQ* colorspace. + + Parameters + ---------- + aces_ctl_directory : str or unicode + The path to the aces 'transforms/ctl/utilities' + lut_directory : str or unicode + The directory to use when generating LUTs + lut_resolution_1d : int + The resolution of generated 1D LUTs + cleanup : bool + Whether or not to clean up the intermediate images + name : str or unicode, optional + The name of the ColorSpace + aliases : list of str or unicode, optional + The alias names to use for the ColorSpace + min_value : float, optional + The minimum value to consider for the space + max_value : float, optional + The maximum value to consider for the space + input_scale : float, optional + A scale factor to divide input values + + Returns + ------- + ColorSpace + Generic *Dolby PQ* colorspace. + """ + + 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 + + ctls = [os.path.join( + aces_ctl_directory, + 'utilities', + 'ACESlib.DolbyPQ_to_Lin.a1.0.1.ctl')] + lut = '%s_to_linear.spi1d' % name + + lut = sanitize(lut) + + generate_1d_LUT_from_CTL( + os.path.join(lut_directory, lut), + ctls, + lut_resolution_1d, + 'float', + input_scale, + 1.0, + {}, + cleanup, + aces_ctl_directory, + min_value, + max_value) + + cs.to_reference_transforms = [] + cs.to_reference_transforms.append({ + 'type': 'lutFile', + 'path': lut, + 'interpolation': 'linear', + 'direction': 'forward'}) + + cs.from_reference_transforms = [] + return cs + + +# ------------------------------------------------------------------------- +# *Dolby PQ* Transform - Fixed Linear Range +# ------------------------------------------------------------------------- +def create_Dolby_PQ_shaper(aces_ctl_directory, + lut_directory, + lut_resolution_1d, + cleanup, + name='pq', + aliases=None, + min_value=0.0, + max_value=1.0, + input_scale=1.0, + middle_grey=0.18, + min_exposure=-6.5, + max_exposure=6.5): + """ + Creates a *Dolby PQ* colorspace that covers a specific dynamic range + + Parameters + ---------- + aces_ctl_directory : str or unicode + The path to the aces 'transforms/ctl/utilities' + lut_directory : str or unicode + The directory to use when generating LUTs + lut_resolution_1d : int + The resolution of generated 1D LUTs + cleanup : bool + Whether or not to clean up the intermediate images + name : str or unicode, optional + The name of the ColorSpace + aliases : list of str or unicode, optional + The alias names to use for the ColorSpace + min_value : float, optional + The minimum value to consider for the space + max_value : float, optional + The maximum value to consider for the space + input_scale : float, optional + A scale factor to divide input values + middle_grey : float, optional + The middle of the dynamic range covered by the transfer function + min_exposure : float, optional + The offset from middle grey, in stops, that defines the low end of the dynamic + range covered by the transfer function + max_exposure : float, optional + The offset from middle grey, in stops, that defines the high end of the dynamic + range covered by the transfer function + + Returns + ------- + ColorSpace + A *Dolby PQ* colorspace that covers a specific dynamic range + """ + + 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 + + ctls = [os.path.join( + aces_ctl_directory, + 'utilities', + 'ACESlib.OCIOshaper_to_Lin_param.a1.0.1.ctl')] + lut = '%s_to_linear.spi1d' % name + + lut = sanitize(lut) + + generate_1d_LUT_from_CTL( + os.path.join(lut_directory, lut), + ctls, + lut_resolution_1d, + 'float', + input_scale, + 1.0, + {'middleGrey': middle_grey, + 'minExposure': min_exposure, + 'maxExposure': max_exposure}, + cleanup, + aces_ctl_directory, + min_value, + max_value) + + cs.to_reference_transforms = [] + cs.to_reference_transforms.append({ + 'type': 'lutFile', + 'path': lut, + 'interpolation': 'linear', + 'direction': 'forward'}) + + cs.from_reference_transforms = [] + return cs + + +# ------------------------------------------------------------------------- +# Individual *LMT* +# ------------------------------------------------------------------------- +def create_ACES_LMT(lmt_name, + lmt_values, + shaper_info, + aces_ctl_directory, + lut_directory, + lut_resolution_3d=64, + cleanup=True, + aliases=None): + """ + Creates an *ACES Look Transform (LMT)* colorspace. + + Parameters + ---------- + lmt_name : str or unicode + The name of the Look Transform (LMT) + lmt_values : dict + A collection of values that define the Look Transform's attributes and behavior + shaper_info : dict + A collection of values that define the Shaper to use when generating LUTs to + represent the Look Transform + aces_ctl_directory : str or unicode + The path to the aces 'transforms/ctl/utilities' + lut_directory : str or unicode + The directory to use when generating LUTs + lut_resolution_3d : int, optional + The resolution of generated 3D LUTs + cleanup : bool, optional + Whether or not to clean up the intermediate images + aliases : list of str or unicode, optional + The alias names to use for the ColorSpace + + Returns + ------- + ColorSpace + An *ACES LMT* colorspace. + """ + + if aliases is None: + aliases = [] + + cs = ColorSpace('%s' % lmt_name) + cs.description = 'The ACES Look Transform: %s' % lmt_name + cs.aliases = aliases + cs.equality_group = '' + cs.family = 'Look' + cs.is_data = False + cs.allocation_type = ocio.Constants.ALLOCATION_LG2 + cs.allocation_vars = [-8, 5, 0.00390625] + cs.aces_transform_id = lmt_values['transformID'] + + pprint.pprint(lmt_values) + + # Generating the *shaper* transform. + (shaper_name, + shaper_to_aces_ctl, + shaper_from_aces_ctl, + shaper_input_scale, + shaper_params) = shaper_info + + shaper_lut = '%s_to_linear.spi1d' % shaper_name + shaper_lut = sanitize(shaper_lut) + + shaper_ocio_transform = { + 'type': 'lutFile', + 'path': shaper_lut, + 'interpolation': 'linear', + 'direction': 'inverse'} + + # Generating the forward transform. + cs.from_reference_transforms = [] + + if 'transformCTL' in lmt_values: + ctls = [shaper_to_aces_ctl % aces_ctl_directory, + os.path.join(aces_ctl_directory, + lmt_values['transformCTL'])] + lut = '%s.%s.spi3d' % (shaper_name, lmt_name) + + lut = sanitize(lut) + + generate_3d_LUT_from_CTL( + os.path.join(lut_directory, lut), + ctls, + lut_resolution_3d, + 'float', + 1 / shaper_input_scale, + 1, + shaper_params, + cleanup, + aces_ctl_directory) + + cs.from_reference_transforms.append(shaper_ocio_transform) + cs.from_reference_transforms.append({ + 'type': 'lutFile', + 'path': lut, + 'interpolation': 'tetrahedral', + 'direction': 'forward'}) + + # Generating the inverse transform. + cs.to_reference_transforms = [] + + if 'transformCTLInverse' in lmt_values: + ctls = [os.path.join(aces_ctl_directory, + lmt_values['transformCTLInverse']), + shaper_from_aces_ctl % aces_ctl_directory] + lut = 'Inverse.%s.%s.spi3d' % (lmt_name, shaper_name) + + lut = sanitize(lut) + + generate_3d_LUT_from_CTL( + os.path.join(lut_directory, lut), + ctls, + lut_resolution_3d, + 'half', + 1, + shaper_input_scale, + shaper_params, + cleanup, + aces_ctl_directory, + 0) + + cs.to_reference_transforms.append({ + 'type': 'lutFile', + 'path': lut, + 'interpolation': 'tetrahedral', + 'direction': 'forward'}) + + shaper_inverse = shaper_ocio_transform.copy() + shaper_inverse['direction'] = 'forward' + cs.to_reference_transforms.append(shaper_inverse) + + return cs + + +# ------------------------------------------------------------------------- +# *LMTs* +# ------------------------------------------------------------------------- +def create_LMTs(aces_ctl_directory, + lut_directory, + lut_resolution_1d, + lut_resolution_3d, + lmt_info, + cleanup): + """ + Create ColorSpaces representing the *ACES Look Transforms* + + Parameters + ---------- + aces_ctl_directory : str or unicode + The path to the aces 'transforms/ctl/utilities' + lut_directory : str or unicode + The directory to use when generating LUTs + lut_resolution_1d : int + The resolution of generated 1D LUTs + lut_resolution_3d : int + The resolution of generated 3D LUTs + cleanup : bool + Whether or not to clean up the intermediate images + aliases : list of str or unicode, optional + The alias names to use for the ColorSpace + lmt_info : dict + A collection of values that define the Look Transforms that need to be + generated + + Returns + ------- + list of ColorSpaces + ColorSpaces representing the *ACES Look Transforms* + """ + + colorspaces = [] + + # ------------------------------------------------------------------------- + # *LMT Shaper* + # ------------------------------------------------------------------------- + lmt_lut_resolution_1d = max(4096, lut_resolution_1d) + lmt_lut_resolution_3d = max(65, lut_resolution_3d) + + # Defining the *Log 2* shaper. + lmt_shaper_name = 'LMT Shaper' + lmt_shaper_name_aliases = ['crv_lmtshaper'] + lmt_params = { + 'middleGrey': 0.18, + 'minExposure': -10, + 'maxExposure': 6.5} + + lmt_shaper = create_generic_log(aces_ctl_directory, + lut_directory, + lmt_lut_resolution_1d, + cleanup, + name=lmt_shaper_name, + middle_grey=lmt_params['middleGrey'], + min_exposure=lmt_params['minExposure'], + max_exposure=lmt_params['maxExposure'], + aliases=lmt_shaper_name_aliases) + colorspaces.append(lmt_shaper) + + shaper_input_scale_generic_log2 = 1 + + # *Log 2* shaper name and *CTL* transforms bundled up. + lmt_shaper_data = [ + lmt_shaper_name, + os.path.join('%s', + 'utilities', + 'ACESlib.Log2_to_Lin_param.a1.0.1.ctl'), + os.path.join('%s', + 'utilities', + 'ACESlib.Lin_to_Log2_param.a1.0.1.ctl'), + shaper_input_scale_generic_log2, + lmt_params] + + sorted_lmts = sorted(lmt_info.iteritems(), key=lambda x: x[1]) + print(sorted_lmts) + for lmt in sorted_lmts: + lmt_name, lmt_values = lmt + lmt_aliases = ['look_%s' % compact(lmt_values['transformUserName'])] + cs = create_ACES_LMT( + lmt_values['transformUserName'], + lmt_values, + lmt_shaper_data, + aces_ctl_directory, + lut_directory, + lmt_lut_resolution_3d, + cleanup, + lmt_aliases) + colorspaces.append(cs) + + return colorspaces + + +# ------------------------------------------------------------------------- +# *ACES RRT* with supplied *ODT*. +# ------------------------------------------------------------------------- +def create_ACES_RRT_plus_ODT(odt_name, + odt_values, + shaper_info, + aces_ctl_directory, + lut_directory, + lut_resolution_3d=64, + cleanup=True, + aliases=None): + """ + Creates an *ACES Output Transform (RRT + ODT)* colorspace. + + Parameters + ---------- + odt_name : str or unicode + The name of the Output Transform (RRT + ODT) + odt_values : dict + A collection of values that define the Output Transform's attributes and behavior + shaper_info : dict + A collection of values that define the Shaper to use when generating LUTs to + represent the Output Transform + aces_ctl_directory : str or unicode + The path to the aces 'transforms/ctl/utilities' + lut_directory : str or unicode + The directory to use when generating LUTs + lut_resolution_3d : int, optional + The resolution of generated 3D LUTs + cleanup : bool, optional + Whether or not to clean up the intermediate images + aliases : list of str or unicode, optional + The alias names to use for the ColorSpace + + Returns + ------- + ColorSpace + An *ACES Output Transform (RRT + ODT)* colorspace. + """ + + if aliases is None: + aliases = [] + + cs = ColorSpace('%s' % odt_name) + cs.description = '%s - %s Output Transform' % ( + odt_values['transformUserNamePrefix'], odt_name) + cs.aliases = aliases + cs.equality_group = '' + cs.family = 'Output' + cs.is_data = False + + cs.aces_transform_id = odt_values['transformID'] + + pprint.pprint(odt_values) + + # Generating the *shaper* transform. + (shaper_name, + shaper_to_aces_ctl, + shaper_from_aces_ctl, + shaper_input_scale, + shaper_params) = shaper_info + + if 'legalRange' in odt_values: + shaper_params['legalRange'] = odt_values['legalRange'] + else: + shaper_params['legalRange'] = 0 + + shaper_lut = '%s_to_linear.spi1d' % shaper_name + shaper_lut = sanitize(shaper_lut) + + shaper_ocio_transform = { + 'type': 'lutFile', + 'path': shaper_lut, + 'interpolation': 'linear', + 'direction': 'inverse'} + + # Generating the *forward* transform. + cs.from_reference_transforms = [] + + if 'transformLUT' in odt_values: + transform_lut_file_name = os.path.basename( + odt_values['transformLUT']) + lut = os.path.join(lut_directory, transform_lut_file_name) + shutil.copy(odt_values['transformLUT'], lut) + + cs.from_reference_transforms.append(shaper_ocio_transform) + cs.from_reference_transforms.append({ + 'type': 'lutFile', + 'path': transform_lut_file_name, + 'interpolation': 'tetrahedral', + 'direction': 'forward'}) + elif 'transformCTL' in odt_values: + ctls = [ + shaper_to_aces_ctl % aces_ctl_directory, + os.path.join(aces_ctl_directory, + 'rrt', + 'RRT.a1.0.1.ctl'), + os.path.join(aces_ctl_directory, + 'odt', + odt_values['transformCTL'])] + lut = '%s.RRT.a1.0.1.%s.spi3d' % (shaper_name, odt_name) + + lut = sanitize(lut) + + generate_3d_LUT_from_CTL( + os.path.join(lut_directory, lut), + ctls, + lut_resolution_3d, + 'float', + 1 / shaper_input_scale, + 1, + shaper_params, + cleanup, + aces_ctl_directory) + + cs.from_reference_transforms.append(shaper_ocio_transform) + cs.from_reference_transforms.append({ + 'type': 'lutFile', + 'path': lut, + 'interpolation': 'tetrahedral', + 'direction': 'forward'}) + + # Generating the *inverse* transform. + cs.to_reference_transforms = [] + + if 'transformLUTInverse' in odt_values: + transform_lut_inverse_file_name = os.path.basename( + odt_values['transformLUTInverse']) + lut = os.path.join(lut_directory, transform_lut_inverse_file_name) + shutil.copy(odt_values['transformLUTInverse'], lut) + + cs.to_reference_transforms.append({ + 'type': 'lutFile', + 'path': transform_lut_inverse_file_name, + 'interpolation': 'tetrahedral', + 'direction': 'forward'}) + + shaper_inverse = shaper_ocio_transform.copy() + shaper_inverse['direction'] = 'forward' + cs.to_reference_transforms.append(shaper_inverse) + elif 'transformCTLInverse' in odt_values: + ctls = [os.path.join(aces_ctl_directory, + 'odt', + odt_values['transformCTLInverse']), + os.path.join(aces_ctl_directory, + 'rrt', + 'InvRRT.a1.0.1.ctl'), + shaper_from_aces_ctl % aces_ctl_directory] + lut = 'InvRRT.a1.0.1.%s.%s.spi3d' % (odt_name, shaper_name) + + lut = sanitize(lut) + + generate_3d_LUT_from_CTL( + os.path.join(lut_directory, lut), + ctls, + lut_resolution_3d, + 'half', + 1, + shaper_input_scale, + shaper_params, + cleanup, + aces_ctl_directory) + + cs.to_reference_transforms.append({ + 'type': 'lutFile', + 'path': lut, + 'interpolation': 'tetrahedral', + 'direction': 'forward'}) + + shaper_inverse = shaper_ocio_transform.copy() + shaper_inverse['direction'] = 'forward' + cs.to_reference_transforms.append(shaper_inverse) + + return cs + +# ------------------------------------------------------------------------- +# *Log 2 Shapers* +# ------------------------------------------------------------------------- +def create_shapers_log2(aces_ctl_directory, + lut_directory, + lut_resolution_1d, + cleanup, + shaper_name, + middle_grey, + min_exposure, + max_exposure): + """ + Creates a *Log base 2* colorspace that covers a specific dynamic range + + Parameters + ---------- + aces_ctl_directory : str or unicode + The path to the aces 'transforms/ctl/utilities' + lut_directory : str or unicode + The directory to use when generating LUTs + lut_resolution_1d : int + The resolution of generated 1D LUTs + cleanup : bool + Whether or not to clean up the intermediate images + shaper_name : str or unicode, optional + The name of the ColorSpace + middle_grey : float + The middle of the dynamic range covered by the transfer function + min_exposure : float + The offset from middle grey, in stops, that defines the low end of the dynamic + range covered by the transfer function + max_exposure : float + The offset from middle grey, in stops, that defines the high end of the dynamic + range covered by the transfer function + + Returns + ------- + ColorSpace + A *Log base 2* colorspace that covers a specific dynamic range + """ + + colorspaces = [] + shaper_data = {} + + # Defining the *Log 2* shaper for *ODTs covering 48 nit output*. + log2_shaper_name = shaper_name + log2_shaper_name_aliases = ['crv_%s' % compact(log2_shaper_name)] + log2_params = { + 'middleGrey': middle_grey, + 'minExposure': min_exposure, + 'maxExposure': max_exposure} + + log2_shaper_colorspace = create_generic_log( + aces_ctl_directory, + lut_directory, + lut_resolution_1d, + cleanup, + name=log2_shaper_name, + middle_grey=log2_params['middleGrey'], + min_exposure=log2_params['minExposure'], + max_exposure=log2_params['maxExposure'], + aliases=log2_shaper_name_aliases) + colorspaces.append(log2_shaper_colorspace) + + shaper_input_scale_generic_log2 = 1 + + # *Log 2* shaper name and *CTL* transforms bundled up. + log2_shaper_data = [ + log2_shaper_name, + os.path.join('%s', + 'utilities', + 'ACESlib.Log2_to_Lin_param.a1.0.1.ctl'), + os.path.join('%s', + 'utilities', + 'ACESlib.Lin_to_Log2_param.a1.0.1.ctl'), + shaper_input_scale_generic_log2, + log2_params] + + shaper_data[log2_shaper_name] = log2_shaper_data + + # Defining the *Log2 shaper that includes the AP1* primaries. + log2_shaper_api1_name = '%s - AP1' % log2_shaper_name + log2_shaper_api1_colorspace = copy.deepcopy(log2_shaper_colorspace) + + log2_shaper_api1_colorspace.name = log2_shaper_api1_name + log2_shaper_api1_colorspace.description = ( + 'The %s color space' % log2_shaper_api1_name) + log2_shaper_api1_colorspace.aliases = [ + '%s_ap1' % compact(log2_shaper_name)] + log2_shaper_api1_colorspace.equality_group = log2_shaper_api1_name + + # *AP1* primaries to *AP0* primaries + log2_shaper_api1_colorspace.to_reference_transforms.append({ + 'type': 'matrix', + 'matrix': mat44_from_mat33(ACES_AP1_TO_AP0), + 'direction': 'forward' + }) + colorspaces.append(log2_shaper_api1_colorspace) + + return shaper_data, colorspaces + +# ------------------------------------------------------------------------- +# *Dolby PQ-based Shapers* +# ------------------------------------------------------------------------- +def create_shapers_dolbypq(aces_ctl_directory, + lut_directory, + lut_resolution_1d, + cleanup, + shaper_name, + middle_grey, + min_exposure, + max_exposure): + """ + Creates two *Dolby PQ* colorspaces, one with now gamut conversion, the other with + the conversion from *ACES* *AP0* to *AP1* + + Parameters + ---------- + aces_ctl_directory : str or unicode + The path to the aces 'transforms/ctl/utilities' + lut_directory : str or unicode + The directory to use when generating LUTs + lut_resolution_1d : int + The resolution of generated 1D LUTs + cleanup : bool + Whether or not to clean up the intermediate images + shaper_name : str or unicode, optional + The name of the ColorSpace + middle_grey : float + The middle of the dynamic range covered by the transfer function + min_exposure : float + The offset from middle grey, in stops, that defines the low end of the dynamic + range covered by the transfer function + max_exposure : float + The offset from middle grey, in stops, that defines the high end of the dynamic + range covered by the transfer function + + Returns + ------- + dict + Values defining a Shaper + list of ColorSpaces + A list of *Dolby PQ* colorspaces that covers a specific dynamic range + """ + colorspaces = [] + shaper_data = {} + + # Define the *Dolby PQ Shaper that considers a fixed linear range* + dolby_pq_shaper_name = shaper_name + dolby_pq_shaper_name_aliases = ['crv_%s' % compact(dolby_pq_shaper_name)] + + dolby_pq_params = { + 'middleGrey': middle_grey, + 'minExposure': min_exposure, + 'maxExposure': max_exposure} + + dolby_pq_shaper_colorspace = create_Dolby_PQ_shaper( + aces_ctl_directory, + lut_directory, + lut_resolution_1d, + cleanup, + name=dolby_pq_shaper_name, + aliases=dolby_pq_shaper_name_aliases, + middle_grey=dolby_pq_params['middleGrey'], + min_exposure=dolby_pq_params['minExposure'], + max_exposure=dolby_pq_params['maxExposure']) + colorspaces.append(dolby_pq_shaper_colorspace) + + # *Dolby PQ* shaper name and *CTL* transforms bundled up. + dolby_pq_shaper_data = [ + dolby_pq_shaper_name, + os.path.join('%s', + 'utilities', + 'ACESlib.OCIOshaper_to_Lin_param.a1.0.1.ctl'), + os.path.join('%s', + 'utilities', + 'ACESlib.Lin_to_OCIOshaper_param.a1.0.1.ctl'), + 1.0, + dolby_pq_params] + + shaper_data[dolby_pq_shaper_name] = dolby_pq_shaper_data + + # Defining the *Dolby PQ shaper that includes the AP1* primaries. + dolby_pq_shaper_api1_name = '%s - AP1' % dolby_pq_shaper_name + dolby_pq_shaper_api1_colorspace = copy.deepcopy(dolby_pq_shaper_colorspace) + + dolby_pq_shaper_api1_colorspace.name = dolby_pq_shaper_api1_name + dolby_pq_shaper_api1_colorspace.description = ( + 'The %s color space' % dolby_pq_shaper_api1_name) + dolby_pq_shaper_api1_colorspace.aliases = [ + '%s_ap1' % compact(dolby_pq_shaper_name)] + dolby_pq_shaper_api1_colorspace.equality_group = dolby_pq_shaper_api1_name + + # *AP1* primaries to *AP0* primaries + dolby_pq_shaper_api1_colorspace.to_reference_transforms.append({ + 'type': 'matrix', + 'matrix': mat44_from_mat33(ACES_AP1_TO_AP0), + 'direction': 'forward' + }) + colorspaces.append(dolby_pq_shaper_api1_colorspace) + + return shaper_data, colorspaces + + +# ------------------------------------------------------------------------- +# *Shapers* +# ------------------------------------------------------------------------- +def create_shapers(aces_ctl_directory, + lut_directory, + lut_resolution_1d, + cleanup): + + """ + Creates sets of shaper colorspaces covering the *Log 2* and *Dolby PQ* + transfer functions and dynamic ranges suitable of use with the 48 nit, + 1000 nit, 2000 nit and 4000 nit *ACES Output Transforms* + + Parameters + ---------- + aces_ctl_directory : str or unicode + The path to the aces 'transforms/ctl/utilities' + lut_directory : str or unicode + The directory to use when generating LUTs + lut_resolution_1d : int + The resolution of generated 1D LUTs + cleanup : bool + Whether or not to clean up the intermediate images + + Returns + ------- + list of dicts + Values defining a set of Shapers + list of ColorSpaces + A list of Shaper colorspaces that covers a varying dynamic ranges and + transfer functions + """ + + colorspaces = [] + shaper_data = {} + + # Define the base *Log2 48 nits shaper* + # + (log2_48nits_shaper_data, + log2_48nits_colorspaces) = create_shapers_log2(aces_ctl_directory, + lut_directory, + lut_resolution_1d, + cleanup, + 'Log2 48 nits Shaper', + 0.18, + -6.5, + 6.5) + colorspaces.extend(log2_48nits_colorspaces) + shaper_data.update(log2_48nits_shaper_data) + + # Define the base *Log2 1000 nits shaper* + # + (log2_1000nits_shaper_data, + log2_1000nits_colorspaces) = create_shapers_log2(aces_ctl_directory, + lut_directory, + lut_resolution_1d, + cleanup, + 'Log2 1000 nits Shaper', + 0.18, + -12.0, + 10.0) + colorspaces.extend(log2_1000nits_colorspaces) + shaper_data.update(log2_1000nits_shaper_data) + + # Define the base *Log2 2000 nits shaper* + # + (log2_2000nits_shaper_data, + log2_2000nits_colorspaces) = create_shapers_log2(aces_ctl_directory, + lut_directory, + lut_resolution_1d, + cleanup, + 'Log2 2000 nits Shaper', + 0.18, + -12.0, + 11.0) + colorspaces.extend(log2_2000nits_colorspaces) + shaper_data.update(log2_2000nits_shaper_data) + + # Define the base *Log2 4000 nits shaper* + # + (log2_4000nits_shaper_data, + log2_4000nits_colorspaces) = create_shapers_log2(aces_ctl_directory, + lut_directory, + lut_resolution_1d, + cleanup, + 'Log2 4000 nits Shaper', + 0.18, + -12.0, + 12.0) + colorspaces.extend(log2_4000nits_colorspaces) + shaper_data.update(log2_4000nits_shaper_data) + + # Define the base *Dolby PQ transfer function* + # + dolby_pq_shaper_name = 'Dolby PQ 10000' + dolby_pq_shaper_name_aliases = ['crv_%s' % 'dolbypq_10000'] + + dolby_pq_shaper_colorspace = create_Dolby_PQ( + aces_ctl_directory, + lut_directory, + lut_resolution_1d, + cleanup, + name=dolby_pq_shaper_name, + aliases=dolby_pq_shaper_name_aliases) + colorspaces.append(dolby_pq_shaper_colorspace) + + # *Dolby PQ* shaper name and *CTL* transforms bundled up. + dolby_pq_shaper_data = [ + dolby_pq_shaper_name, + os.path.join('%s', + 'utilities', + 'ACESlib.DolbyPQ_to_Lin.a1.0.1.ctl'), + os.path.join('%s', + 'utilities', + 'ACESlib.Lin_to_DolbyPQ.a1.0.1.ctl'), + 1.0, + {}] + + shaper_data[dolby_pq_shaper_name] = dolby_pq_shaper_data + + # Define the *Dolby PQ 48 nits shaper* + # + (dolbypq_48nits_shaper_data, + dolbypq_48nits_colorspaces) = create_shapers_dolbypq(aces_ctl_directory, + lut_directory, + lut_resolution_1d, + cleanup, + 'Dolby PQ 48 nits Shaper', + 0.18, + -6.5, + 6.5) + colorspaces.extend(dolbypq_48nits_colorspaces) + shaper_data.update(dolbypq_48nits_shaper_data) + + # Define the *Dolby PQ 1000 nits shaper* + # + (dolbypq_1000nits_shaper_data, + dolbypq_1000nits_colorspaces) = create_shapers_dolbypq(aces_ctl_directory, + lut_directory, + lut_resolution_1d, + cleanup, + 'Dolby PQ 1000 nits Shaper', + 0.18, + -12.0, + 10.0) + colorspaces.extend(dolbypq_1000nits_colorspaces) + shaper_data.update(dolbypq_1000nits_shaper_data) + + # Define the *Dolby PQ 2000 nits shaper* + # + (dolbypq_2000nits_shaper_data, + dolbypq_2000nits_colorspaces) = create_shapers_dolbypq(aces_ctl_directory, + lut_directory, + lut_resolution_1d, + cleanup, + 'Dolby PQ 2000 nits Shaper', + 0.18, + -12.0, + 11.0) + colorspaces.extend(dolbypq_2000nits_colorspaces) + shaper_data.update(dolbypq_2000nits_shaper_data) + + # Define the *Dolby PQ 4000 nits shaper* + # + (dolbypq_4000nits_shaper_data, + dolbypq_4000nits_colorspaces) = create_shapers_dolbypq(aces_ctl_directory, + lut_directory, + lut_resolution_1d, + cleanup, + 'Dolby PQ 4000 nits Shaper', + 0.18, + -12.0, + 12.0) + colorspaces.extend(dolbypq_4000nits_colorspaces) + shaper_data.update(dolbypq_4000nits_shaper_data) + + return shaper_data, colorspaces + +# ------------------------------------------------------------------------- +# *ODTs* +# ------------------------------------------------------------------------- +def create_ODTs(aces_ctl_directory, + lut_directory, + lut_resolution_1d, + lut_resolution_3d, + odt_info, + shaper_name, + cleanup, + linear_display_space, + log_display_space): + """ + Create ColorSpaces representing the *ACES Output Transforms* + + Parameters + ---------- + aces_ctl_directory : str or unicode + The path to the aces 'transforms/ctl/utilities' + lut_directory : str or unicode + The directory to use when generating LUTs + lut_resolution_1d : int + The resolution of generated 1D LUTs + lut_resolution_3d : int + The resolution of generated 3D LUTs + odt_info : dict + A collection of values that define the Output Transforms that need to be + generated + shaper_name : str or unicode, optional + The name of Shaper ColorSpace to use when generating LUTs + cleanup : bool + Whether or not to clean up the intermediate images + linear_display_space : lstr or unicode + The name of the ColorSpace to use for the raw or linear View + log_display_space : lstr or unicode + The name of the ColorSpace to use for the log View + + Returns + ------- + list of ColorSpaces + ColorSpaces representing the *ACES Output Transforms* + list of dicts + Collections of names and ColorSpaces corresponding to the Displays and + Views + """ + + colorspaces = [] + displays = {} + + # ------------------------------------------------------------------------- + # *RRT / ODT* Shaper Options + # ------------------------------------------------------------------------- + shaper_data, shaper_colorspaces = create_shapers(aces_ctl_directory, + lut_directory, + lut_resolution_1d, + cleanup) + + colorspaces.extend(shaper_colorspaces) + + # Assumes shaper has variants covering the range expected by the + # 48 nit, 1000 nit, 2000 nit and 4000 nit Ouput Transforms + rrt_shaper_48nits = shaper_data[shaper_name] + rrt_shaper_1000nits = shaper_data[shaper_name.replace("48 nits", "1000 nits")] + rrt_shaper_2000nits = shaper_data[shaper_name.replace("48 nits", "2000 nits")] + rrt_shaper_4000nits = shaper_data[shaper_name.replace("48 nits", "4000 nits")] + + # *RRT + ODT* combinations. + sorted_odts = sorted(odt_info.iteritems(), key=lambda x: x[1]) + print(sorted_odts) + for odt in sorted_odts: + (odt_name, odt_values) = odt + + if odt_values['transformHasFullLegalSwitch']: + odt_legal['legalRange'] = 0 + + odt_name_legal = odt_values['transformUserName'] + odt_legal = odt_values.copy() + odt_aliases = ['out_%s' % compact(odt_name_legal)] + + if odt_name_legal in ['P3-D60 ST2048 (1000 nits)', 'Rec.2020 ST2048 (1000 nits)']: + rrt_shaper = rrt_shaper_1000nits + elif odt_name_legal in ['P3-D60 ST2048 (2000 nits)']: + rrt_shaper = rrt_shaper_2000nits + elif odt_name_legal in ['P3-D60 ST2048 (4000 nits)']: + rrt_shaper = rrt_shaper_4000nits + else: + rrt_shaper = rrt_shaper_48nits + + cs = create_ACES_RRT_plus_ODT( + odt_name_legal, + odt_legal, + rrt_shaper, + aces_ctl_directory, + lut_directory, + lut_resolution_3d, + cleanup, + odt_aliases) + colorspaces.append(cs) + + displays[odt_name_legal] = { + 'Raw': linear_display_space, + 'Log': log_display_space, + 'Output Transform': cs} + + return colorspaces, displays + + +def get_transform_info(ctl_transform): + """ + Returns the information stored in first couple of lines of an official + *ACES Transform* CTL file + + Parameters + ---------- + ctl_transform : str or unicode + The path to the CTL file to be scraped. + + Returns + ------- + tuple + Combination of Transform ID, User Name, User Name Prefix and Full/Legal + switch + """ + + with open(ctl_transform, 'rb') as fp: + lines = fp.readlines() + + # Retrieving the *transform ID* and *User Name*. + transform_id = lines[1][3:].split('<')[1].split('>')[1].strip() + transform_user_name = '-'.join( + lines[2][3:].split('<')[1].split('>')[1].split('-')[1:]).strip() + transform_user_name_prefix = ( + lines[2][3:].split('<')[1].split('>')[1].split('-')[0].strip()) + + # Figuring out if this transform has options for processing *full* and + # *legal* ranges. + transform_full_legal_switch = False + for line in lines: + if line.strip() == 'input varying int legalRange = 0': + # print( '%s has legal range flag' % transform_user_name) + transform_full_legal_switch = True + break + + return (transform_id, + transform_user_name, + transform_user_name_prefix, + transform_full_legal_switch) + + +def get_ODTs_info(aces_ctl_directory): + """ + Returns the information describing the names and CTL files associated with + the *ACES Output Transforms* in a given ACES release + + Parameters + ---------- + aces_ctl_directory : str or unicode + The path to the base *ACES* CTL directory + + Returns + ------- + dict of dicts + Collecton of dicts, one describing each *ACES Output Transform* + """ + + # TODO: Investigate usage of *files_walker* definition here. + # Credit to *Alex Fry* for the original approach here. + odt_dir = os.path.join(aces_ctl_directory, 'odt') + all_odt = [] + for dir_name, subdir_list, file_list in os.walk(odt_dir): + for fname in file_list: + all_odt.append((os.path.join(dir_name, fname))) + + odt_ctls = [x for x in all_odt if + ('InvODT' not in x) and (os.path.split(x)[-1][0] != '.')] + + odts = {} + + for odt_ctl in odt_ctls: + odt_tokens = os.path.split(odt_ctl) + + # Handling nested directories. + odt_path_tokens = os.path.split(odt_tokens[-2]) + odt_dir = odt_path_tokens[-1] + while odt_path_tokens[-2][-3:] != 'odt': + odt_path_tokens = os.path.split(odt_path_tokens[-2]) + odt_dir = os.path.join(odt_path_tokens[-1], odt_dir) + + # Building full name. + transform_ctl = odt_tokens[-1] + odt_name = string.join(transform_ctl.split('.')[1:-1], '.') + + # Finding id, user name and user name prefix. + (transform_id, + transform_user_name, + transform_user_name_prefix, + transform_full_legal_switch) = get_transform_info( + os.path.join(aces_ctl_directory, 'odt', odt_dir, transform_ctl)) + + # Finding inverse. + transform_ctl_inverse = 'InvODT.%s.ctl' % odt_name + if not os.path.exists( + os.path.join(odt_tokens[-2], transform_ctl_inverse)): + transform_ctl_inverse = None + + # Adding to list of *ODTs*. + odts[odt_name] = {} + odts[odt_name]['transformCTL'] = os.path.join(odt_dir, transform_ctl) + if transform_ctl_inverse is not None: + odts[odt_name]['transformCTLInverse'] = os.path.join( + odt_dir, transform_ctl_inverse) + + odts[odt_name]['transformID'] = transform_id + odts[odt_name]['transformUserNamePrefix'] = transform_user_name_prefix + odts[odt_name]['transformUserName'] = transform_user_name + odts[odt_name][ + 'transformHasFullLegalSwitch'] = transform_full_legal_switch + + forward_ctl = odts[odt_name]['transformCTL'] + + print('ODT : %s' % odt_name) + print('\tTransform ID : %s' % transform_id) + print('\tTransform User Name Prefix : %s' % transform_user_name_prefix) + print('\tTransform User Name : %s' % transform_user_name) + print( + '\tHas Full / Legal Switch : %s' % transform_full_legal_switch) + print('\tForward ctl : %s' % forward_ctl) + if 'transformCTLInverse' in odts[odt_name]: + inverse_ctl = odts[odt_name]['transformCTLInverse'] + print('\tInverse ctl : %s' % inverse_ctl) + else: + print('\tInverse ctl : %s' % 'None') + + print('\n') + + return odts + + +def get_LMTs_info(aces_ctl_directory): + """ + Returns the information describing the names and CTL files associated with + the *ACES Look Transforms* in a given ACES release + + Parameters + ---------- + aces_ctl_directory : str or unicode + The path to the base *ACES* CTL directory + + Returns + ------- + dict of dicts + Collecton of dicts, one describing each *ACES Look Transform* + """ + + # TODO: Investigate refactoring with previous definition. + + # Credit to Alex Fry for the original approach here + lmt_dir = os.path.join(aces_ctl_directory, 'lmt') + all_lmt = [] + for dir_name, subdir_list, file_list in os.walk(lmt_dir): + for fname in file_list: + all_lmt.append((os.path.join(dir_name, fname))) + + lmt_ctls = [x for x in all_lmt if + ('InvLMT' not in x) and ('README' not in x) and ( + os.path.split(x)[-1][0] != '.')] + + lmts = {} + + for lmt_ctl in lmt_ctls: + lmt_tokens = os.path.split(lmt_ctl) + + # Handlimg nested directories. + lmt_path_tokens = os.path.split(lmt_tokens[-2]) + lmt_dir = lmt_path_tokens[-1] + while lmt_path_tokens[-2][-3:] != 'ctl': + lmt_path_tokens = os.path.split(lmt_path_tokens[-2]) + lmt_dir = os.path.join(lmt_path_tokens[-1], lmt_dir) + + # Building full name. + transform_ctl = lmt_tokens[-1] + lmt_name = string.join(transform_ctl.split('.')[1:-1], '.') + + # Finding id, user name and user name prefix. + (transform_id, + transform_user_name, + transform_user_name_prefix, + transform_full_legal_switch) = get_transform_info( + os.path.join(aces_ctl_directory, lmt_dir, transform_ctl)) + + # Finding inverse. + transform_ctl_inverse = 'InvLMT.%s.ctl' % lmt_name + if not os.path.exists( + os.path.join(lmt_tokens[-2], transform_ctl_inverse)): + transform_ctl_inverse = None + + lmts[lmt_name] = {} + lmts[lmt_name]['transformCTL'] = os.path.join(lmt_dir, transform_ctl) + if transform_ctl_inverse is not None: + lmts[lmt_name]['transformCTLInverse'] = os.path.join( + lmt_dir, transform_ctl_inverse) + + lmts[lmt_name]['transformID'] = transform_id + lmts[lmt_name]['transformUserNamePrefix'] = transform_user_name_prefix + lmts[lmt_name]['transformUserName'] = transform_user_name + + forward_ctl = lmts[lmt_name]['transformCTL'] + + print('LMT : %s' % lmt_name) + print('\tTransform ID : %s' % transform_id) + print('\tTransform User Name Prefix : %s' % transform_user_name_prefix) + print('\tTransform User Name : %s' % transform_user_name) + print('\t Forward ctl : %s' % forward_ctl) + if 'transformCTLInverse' in lmts[lmt_name]: + inverse_ctl = lmts[lmt_name]['transformCTLInverse'] + print('\t Inverse ctl : %s' % inverse_ctl) + else: + print('\t Inverse ctl : %s' % 'None') + + print('\n') + + return lmts + + +def create_colorspaces(aces_ctl_directory, + lut_directory, + lut_resolution_1d, + lut_resolution_3d, + lmt_info, + odt_info, + shaper_name, + cleanup): + """ + Generates the *ACES* colorspaces, displays and views + + Parameters + ---------- + aces_ctl_directory : str or unicode + The path to the aces 'transforms/ctl/utilities' + lut_directory : str or unicode + The directory to use when generating LUTs + lut_resolution_1d : int + The resolution of generated 1D LUTs + lut_resolution_3d : int + The resolution of generated 3D LUTs + lmt_info : dict + A collection of values that define the Look Transforms that need to be + generated + odt_info : dict + A collection of values that define the Output Transforms that need to be + generated + shaper_name : str or unicode, optional + The name of Shaper ColorSpace to use when generating LUTs + cleanup : bool + Whether or not to clean up the intermediate images + + Returns + ------- + tuple + A collection of values defining + the reference colorspace : ACES + a list of the colorspaces created + a list of the displays created + a list of the general log colorspace + a list of the role assignments + the name of the default display + """ + + colorspaces = [] + + ACES = create_ACES() + + ACEScc = create_ACEScc(aces_ctl_directory, lut_directory, + lut_resolution_1d, cleanup, + min_value=-0.35840, max_value=1.468) + colorspaces.append(ACEScc) + + ACESproxy = create_ACESproxy(aces_ctl_directory, lut_directory, + lut_resolution_1d, cleanup) + colorspaces.append(ACESproxy) + + ACEScg = create_ACEScg() + colorspaces.append(ACEScg) + + ADX10 = create_ADX(lut_directory, bit_depth=10) + colorspaces.append(ADX10) + + ADX16 = create_ADX(lut_directory, bit_depth=16) + colorspaces.append(ADX16) + + lmts = create_LMTs(aces_ctl_directory, + lut_directory, + lut_resolution_1d, + lut_resolution_3d, + lmt_info, + cleanup) + colorspaces.extend(lmts) + + odts, displays = create_ODTs(aces_ctl_directory, + lut_directory, + lut_resolution_1d, + lut_resolution_3d, + odt_info, + shaper_name, + cleanup, + ACES, + ACEScc) + colorspaces.extend(odts) + + # TODO: Investigate if there is a way to retrieve these values from *CTL*. + default_display = 'sRGB (D60 sim.)' + color_picking = 'Rec.709' + + roles = {'color_picking': color_picking, + 'color_timing': ACEScc.name, + 'compositing_log': ACEScc.name, + 'data': '', + 'default': ACES.name, + 'matte_paint': ACEScc.name, + 'reference': '', + 'scene_linear': ACEScg.name, + 'texture_paint': '', + 'compositing_linear': ACEScg.name, + 'rendering': ACEScg.name} + + return ACES, colorspaces, displays, ACEScc, roles, default_display