X-Git-Url: http://users.mur.at/ms/git/gitweb/?a=blobdiff_plain;f=aces_1.0.0%2Fpython%2Faces_ocio%2Fcolorspaces%2Faces.py;h=a299c161d4fd340f639d6078a62c8fd40c164354;hb=160c7be84e9d9e555b6d5340e2bfb8a6cd6e59ba;hp=c3e725e22df316ab8552b92e9e4de605bcc700df;hpb=918520c7cc16aa549e2af0f57b630905063bad19;p=OpenColorIO-Configs.git diff --git a/aces_1.0.0/python/aces_ocio/colorspaces/aces.py b/aces_1.0.0/python/aces_ocio/colorspaces/aces.py index c3e725e..a299c16 100644 --- a/aces_1.0.0/python/aces_ocio/colorspaces/aces.py +++ b/aces_1.0.0/python/aces_ocio/colorspaces/aces.py @@ -7,6 +7,7 @@ Implements support for *ACES* colorspaces conversions and transfer functions. from __future__ import division +import copy import math import numpy import os @@ -34,17 +35,24 @@ __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_ACES_LMT', - 'create_ACES_RRT_plus_ODT', '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', @@ -166,7 +174,7 @@ def create_ACEScc(aces_ctl_directory, 'interpolation': 'linear', 'direction': 'forward'}) - # *AP1* primaries to *AP0* primaries. + # *AP1* primaries to *AP0* primaries cs.to_reference_transforms.append({ 'type': 'matrix', 'matrix': mat44_from_mat33(ACES_AP1_TO_AP0), @@ -238,7 +246,7 @@ def create_ACESproxy(aces_ctl_directory, 'interpolation': 'linear', 'direction': 'forward'}) - # *AP1* primaries to *AP0* primaries. + # *AP1* primaries to *AP0* primaries cs.to_reference_transforms.append({ 'type': 'matrix', 'matrix': mat44_from_mat33(ACES_AP1_TO_AP0), @@ -251,11 +259,7 @@ def create_ACESproxy(aces_ctl_directory, # ------------------------------------------------------------------------- # *ACEScg* # ------------------------------------------------------------------------- -def create_ACEScg(aces_ctl_directory, - lut_directory, - lut_resolution_1d, - cleanup, - name='ACEScg'): +def create_ACEScg(): """ Creates the *ACEScg* colorspace. @@ -270,6 +274,8 @@ def create_ACEScg(aces_ctl_directory, *ACEScg* colorspace. """ + name = 'ACEScg' + cs = ColorSpace(name) cs.description = 'The %s color space' % name cs.aliases = ['acescg', 'lin_ap1'] @@ -283,7 +289,7 @@ def create_ACEScg(aces_ctl_directory, cs.to_reference_transforms = [] - # *AP1* primaries to *AP0* primaries. + # *AP1* primaries to *AP0* primaries cs.to_reference_transforms.append({ 'type': 'matrix', 'matrix': mat44_from_mat33(ACES_AP1_TO_AP0), @@ -291,11 +297,15 @@ def create_ACEScg(aces_ctl_directory, cs.from_reference_transforms = [] - # *AP1* primaries to *AP0* primaries. - cs.from_reference_transforms.append({ - 'type': 'matrix', - 'matrix': mat44_from_mat33(ACES_AP0_TO_AP1), - 'direction': 'forward'}) + # Commented out because having 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 @@ -304,7 +314,6 @@ def create_ACEScg(aces_ctl_directory, # *ADX* # ------------------------------------------------------------------------- def create_ADX(lut_directory, - lut_resolution_1d, bit_depth=10, name='ADX'): """ @@ -357,7 +366,8 @@ def create_ADX(lut_directory, 'offset': offset, 'direction': 'forward'}) - # Convert from Channel-Dependent Density to Channel-Independent Density + # Converting from *Channel-Dependent Density* to + # *Channel-Independent Density*. cs.to_reference_transforms.append({ 'type': 'matrix', 'matrix': [0.75573, 0.22197, 0.02230, 0, @@ -457,7 +467,7 @@ def create_ADX(lut_directory, # ------------------------------------------------------------------------- -# *Generic Log Transform* +# Generic *Log* Transform # ------------------------------------------------------------------------- def create_generic_log(aces_ctl_directory, lut_directory, @@ -469,7 +479,7 @@ def create_generic_log(aces_ctl_directory, max_value=1, input_scale=1, middle_grey=0.18, - min_exposure=-6, + min_exposure=-6.5, max_exposure=6.5): """ Creates the *Generic Log* colorspace. @@ -531,17 +541,17 @@ def create_generic_log(aces_ctl_directory, # ------------------------------------------------------------------------- -# *base Dolby PQ Transform* +# 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): + lut_directory, + lut_resolution_1d, + cleanup, + name='pq', + aliases=None, + min_value=0.0, + max_value=1.0, + input_scale=1.0): if aliases is None: aliases = [] @@ -585,20 +595,20 @@ def create_Dolby_PQ(aces_ctl_directory, # ------------------------------------------------------------------------- -# *Dolby PQ Transform that considers a fixed linear range* +# *Dolby PQ* Transform - Fixed Linear Range # ------------------------------------------------------------------------- -def create_Dolby_PQ_scaled(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.0, - max_exposure=6.5): +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): if aliases is None: aliases = [] @@ -612,7 +622,7 @@ def create_Dolby_PQ_scaled(aces_ctl_directory, ctls = [os.path.join( aces_ctl_directory, 'utilities', - 'ACESlib.DolbyPQ_to_lin_param.a1.0.0.ctl')] + 'ACESlib.OCIOshaper_to_Lin_param.a1.0.0.ctl')] lut = '%s_to_linear.spi1d' % name lut = sanitize(lut) @@ -644,14 +654,13 @@ def create_Dolby_PQ_scaled(aces_ctl_directory, # ------------------------------------------------------------------------- -# *Individual LMT* +# Individual *LMT* # ------------------------------------------------------------------------- def create_ACES_LMT(lmt_name, lmt_values, shaper_info, aces_ctl_directory, lut_directory, - lut_resolution_1d=1024, lut_resolution_3d=64, cleanup=True, aliases=None): @@ -691,7 +700,6 @@ def create_ACES_LMT(lmt_name, shaper_input_scale, shaper_params) = shaper_info - # Add the shaper transform shaper_lut = '%s_to_linear.spi1d' % shaper_name shaper_lut = sanitize(shaper_lut) @@ -737,8 +745,7 @@ def create_ACES_LMT(lmt_name, ctls = [os.path.join(aces_ctl_directory, lmt_values['transformCTLInverse']), shaper_from_aces_ctl % aces_ctl_directory] - # TODO: Investigate unresolved `odt_name` reference. - lut = 'Inverse.%s.%s.spi3d' % (odt_name, shaper_name) + lut = 'Inverse.%s.%s.spi3d' % (lmt_name, shaper_name) lut = sanitize(lut) @@ -775,7 +782,6 @@ def create_LMTs(aces_ctl_directory, lut_resolution_1d, lut_resolution_3d, lmt_info, - shaper_name, cleanup): """ Object description. @@ -843,7 +849,6 @@ def create_LMTs(aces_ctl_directory, lmt_shaper_data, aces_ctl_directory, lut_directory, - lmt_lut_resolution_1d, lmt_lut_resolution_3d, cleanup, lmt_aliases) @@ -860,7 +865,6 @@ def create_ACES_RRT_plus_ODT(odt_name, shaper_info, aces_ctl_directory, lut_directory, - lut_resolution_1d=1024, lut_resolution_3d=64, cleanup=True, aliases=None): @@ -905,7 +909,6 @@ def create_ACES_RRT_plus_ODT(odt_name, else: shaper_params['legalRange'] = 0 - # Add the shaper transform shaper_lut = '%s_to_linear.spi1d' % shaper_name shaper_lut = sanitize(shaper_lut) @@ -945,7 +948,6 @@ def create_ACES_RRT_plus_ODT(odt_name, generate_3d_LUT_from_CTL( os.path.join(lut_directory, lut), - # shaperLUT, ctls, lut_resolution_3d, 'float', @@ -994,7 +996,6 @@ def create_ACES_RRT_plus_ODT(odt_name, generate_3d_LUT_from_CTL( os.path.join(lut_directory, lut), - # None, ctls, lut_resolution_3d, 'half', @@ -1016,48 +1017,27 @@ def create_ACES_RRT_plus_ODT(odt_name, return cs - # ------------------------------------------------------------------------- -# *ODTs* +# *Log 2 Shapers* # ------------------------------------------------------------------------- -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): - """ - Object description. - - Parameters - ---------- - parameter : type - Parameter description. - - Returns - ------- - type - Return value description. - """ - +def create_shapers_log2(aces_ctl_directory, + lut_directory, + lut_resolution_1d, + cleanup, + shaper_name, + middle_grey, + min_exposure, + max_exposure): colorspaces = [] - displays = {} - - # ------------------------------------------------------------------------- - # *RRT / ODT* Shaper Options - # ------------------------------------------------------------------------- shaper_data = {} - # Defining the *Log 2* shaper. + # 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': 0.18, - 'minExposure': -6, - 'maxExposure': 6.5} + 'middleGrey': middle_grey, + 'minExposure': min_exposure, + 'maxExposure': max_exposure} log2_shaper_colorspace = create_generic_log( aces_ctl_directory, @@ -1087,38 +1067,18 @@ def create_ODTs(aces_ctl_directory, shaper_data[log2_shaper_name] = log2_shaper_data - # Space with a more user-friendly name. Direct copy otherwise. - log2_shaper_copy_name = 'Log2 Shaper' - log2_shaper_copy_colorspace = ColorSpace(log2_shaper_copy_name) - log2_shaper_copy_colorspace.description = ( - 'The %s color space' % log2_shaper_copy_name) - log2_shaper_copy_colorspace.aliases = [ - 'crv_%s' % compact(log2_shaper_copy_name)] - log2_shaper_copy_colorspace.equality_group = log2_shaper_copy_name - log2_shaper_copy_colorspace.family = log2_shaper_colorspace.family - log2_shaper_copy_colorspace.is_data = log2_shaper_colorspace.is_data - log2_shaper_copy_colorspace.to_reference_transforms = list( - log2_shaper_colorspace.to_reference_transforms) - log2_shaper_copy_colorspace.from_reference_transforms = list( - log2_shaper_colorspace.from_reference_transforms) - colorspaces.append(log2_shaper_copy_colorspace) - # Defining the *Log2 shaper that includes the AP1* primaries. - log2_shaper_api1_name = '%s - AP1' % 'Log2 Shaper' - log2_shaper_api1_colorspace = ColorSpace(log2_shaper_api1_name) + 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_copy_name)] + '%s_ap1' % compact(log2_shaper_name)] log2_shaper_api1_colorspace.equality_group = log2_shaper_api1_name - log2_shaper_api1_colorspace.family = log2_shaper_colorspace.family - log2_shaper_api1_colorspace.is_data = log2_shaper_colorspace.is_data - log2_shaper_api1_colorspace.to_reference_transforms = list( - log2_shaper_colorspace.to_reference_transforms) - log2_shaper_api1_colorspace.from_reference_transforms = list( - log2_shaper_colorspace.from_reference_transforms) - - # *AP1* primaries to *AP0* primaries. + + # *AP1* primaries to *AP0* primaries log2_shaper_api1_colorspace.to_reference_transforms.append({ 'type': 'matrix', 'matrix': mat44_from_mat33(ACES_AP1_TO_AP0), @@ -1126,83 +1086,277 @@ def create_ODTs(aces_ctl_directory, }) colorspaces.append(log2_shaper_api1_colorspace) - # Defining the *Log2 shaper that includes the AP1* primaries. - # Named with 'shaper_name' variable. Needed for some LUT baking steps. - shaper_api1_name = '%s - AP1' % shaper_name - shaper_api1_colorspace = ColorSpace(shaper_api1_name) - shaper_api1_colorspace.description = ( - 'The %s color space' % shaper_api1_name) - shaper_api1_colorspace.aliases = ['%s_ap1' % compact(shaper_name)] - shaper_api1_colorspace.equality_group = shaper_api1_name - shaper_api1_colorspace.family = log2_shaper_colorspace.family - shaper_api1_colorspace.is_data = log2_shaper_colorspace.is_data - shaper_api1_colorspace.to_reference_transforms = list( - log2_shaper_api1_colorspace.to_reference_transforms) - shaper_api1_colorspace.from_reference_transforms = list( - log2_shaper_api1_colorspace.from_reference_transforms) - colorspaces.append(shaper_api1_colorspace) - - # Define the base *Dolby PQ Shaper* - # - dolbypq_shaper_name = 'Dolby PQ 10000' - dolbypq_shaper_name_aliases = ['crv_%s' % 'dolbypq_10000'] + 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): + 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)] - dolbypq_shaper_colorspace = create_Dolby_PQ( + 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=dolbypq_shaper_name, - aliases=dolbypq_shaper_name_aliases) - colorspaces.append(dolbypq_shaper_colorspace) + 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. - dolbypq_shaper_data = [ - dolbypq_shaper_name, + dolby_pq_shaper_data = [ + dolby_pq_shaper_name, os.path.join('%s', 'utilities', - 'ACESlib.DolbyPQ_to_Lin.a1.0.0.ctl'), + 'ACESlib.OCIOshaper_to_Lin_param.a1.0.0.ctl'), os.path.join('%s', 'utilities', - 'ACESlib.Lin_to_DolbyPQ.a1.0.0.ctl'), + 'ACESlib.Lin_to_OCIOshaper_param.a1.0.0.ctl'), 1.0, - {}] + dolby_pq_params] - shaper_data[dolbypq_shaper_name] = dolbypq_shaper_data + shaper_data[dolby_pq_shaper_name] = dolby_pq_shaper_data - # Define the *Dolby PQ Shaper that considers a fixed linear range* + # Defining the *Log2 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): + + 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* # - dolbypq_scaled_shaper_name = 'Dolby PQ Scaled' - dolbypq_scaled_shaper_name_aliases = ['crv_%s' % 'dolbypq_scaled'] + (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'] - dolbypq_scaled_shaper_colorspace = create_Dolby_PQ_scaled( + dolby_pq_shaper_colorspace = create_Dolby_PQ( aces_ctl_directory, lut_directory, lut_resolution_1d, cleanup, - name=dolbypq_scaled_shaper_name, - aliases=dolbypq_scaled_shaper_name_aliases) - colorspaces.append(dolbypq_scaled_shaper_colorspace) + 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. - dolbypq_scaled_shaper_data = [ - dolbypq_scaled_shaper_name, + dolby_pq_shaper_data = [ + dolby_pq_shaper_name, os.path.join('%s', 'utilities', - 'ACESlib.DolbyPQ_to_Lin_param.a1.0.0.ctl'), + 'ACESlib.DolbyPQ_to_Lin.a1.0.0.ctl'), os.path.join('%s', 'utilities', - 'ACESlib.Lin_to_DolbyPQ_param.a1.0.0.ctl'), + 'ACESlib.Lin_to_DolbyPQ.a1.0.0.ctl'), 1.0, - log2_params] + {}] - shaper_data[dolbypq_scaled_shaper_name] = dolbypq_scaled_shaper_data + 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* # - # Pick a specific 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* # - rrt_shaper = log2_shaper_data - # rrt_shaper = dolbypq_scaled_shaper_data + (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): + """ + Object description. + + Parameters + ---------- + parameter : type + Parameter description. + + Returns + ------- + type + Return value description. + """ + + 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]) @@ -1210,31 +1364,28 @@ def create_ODTs(aces_ctl_directory, for odt in sorted_odts: (odt_name, odt_values) = odt - # Generating only full range transform for *ODTs* that can generate - # either *legal* or *full* output. - - # Uncomment these lines and the lower section and - # flip the 'legalRange' value to 1 to recover the old behavior, - # where both legal and full range LUTs were generated. if odt_values['transformHasFullLegalSwitch']: - # odt_name_legal = '%s - Legal' % odt_values['transformUserName'] odt_legal['legalRange'] = 0 - # else: - # odt_name_legal = odt_values['transformUserName'] 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 PQ (1000 nits)']: + rrt_shaper = rrt_shaper_1000nits + elif odt_name_legal in ['P3-D60 PQ (2000 nits)']: + rrt_shaper = rrt_shaper_2000nits + elif odt_name_legal in ['P3-D60 PQ (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_1d, lut_resolution_3d, cleanup, odt_aliases) @@ -1245,36 +1396,6 @@ def create_ODTs(aces_ctl_directory, 'Log': log_display_space, 'Output Transform': cs} - """ - # Generating full range transform for *ODTs* that can generate - # either *legal* or *full* output. - if odt_values['transformHasFullLegalSwitch']: - print('Generating full range ODT for %s' % odt_name) - - odt_name_full = '%s - Full' % odt_values['transformUserName'] - odt_full = odt_values.copy() - odt_full['legalRange'] = 0 - - odt_full_aliases = ['out_%s' % compact(odt_name_full)] - - cs_full = create_ACES_RRT_plus_ODT( - odt_name_full, - odt_full, - rrt_shaper, - aces_ctl_directory, - lut_directory, - lut_resolution_1d, - lut_resolution_3d, - cleanup, - odt_full_aliases) - colorspaces.append(cs_full) - - displays[odt_name_full] = { - 'Raw': linear_display_space, - 'Log': log_display_space, - 'Output Transform': cs_full} - """ - return colorspaces, displays @@ -1303,8 +1424,8 @@ def get_transform_info(ctl_transform): 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 range. + # 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': @@ -1312,7 +1433,9 @@ def get_transform_info(ctl_transform): transform_full_legal_switch = True break - return (transform_id, transform_user_name, transform_user_name_prefix, + return (transform_id, + transform_user_name, + transform_user_name_prefix, transform_full_legal_switch) @@ -1356,7 +1479,7 @@ def get_ODTs_info(aces_ctl_directory): odt_path_tokens = os.path.split(odt_path_tokens[-2]) odt_dir = os.path.join(odt_path_tokens[-1], odt_dir) - # Building full name, + # Building full name. transform_ctl = odt_tokens[-1] odt_name = string.join(transform_ctl.split('.')[1:-1], '.') @@ -1373,7 +1496,7 @@ def get_ODTs_info(aces_ctl_directory): os.path.join(odt_tokens[-2], transform_ctl_inverse)): transform_ctl_inverse = None - # Add to list of ODTs + # 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: @@ -1449,15 +1572,15 @@ def get_LMTs_info(aces_ctl_directory): 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], '.') + 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)) + os.path.join(aces_ctl_directory, lmt_dir, transform_ctl)) # Finding inverse. transform_ctl_inverse = 'InvLMT.%s.ctl' % lmt_name @@ -1466,7 +1589,7 @@ def get_LMTs_info(aces_ctl_directory): transform_ctl_inverse = None lmts[lmt_name] = {} - lmts[lmt_name]['transformCTL'] = os.path.join(lmt_dir, transform_CTL) + 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) @@ -1528,14 +1651,13 @@ def create_colorspaces(aces_ctl_directory, lut_resolution_1d, cleanup) colorspaces.append(ACESproxy) - ACEScg = create_ACEScg(aces_ctl_directory, lut_directory, - lut_resolution_1d, cleanup) + ACEScg = create_ACEScg() colorspaces.append(ACEScg) - ADX10 = create_ADX(lut_directory, lut_resolution_1d, bit_depth=10) + ADX10 = create_ADX(lut_directory, bit_depth=10) colorspaces.append(ADX10) - ADX16 = create_ADX(lut_directory, lut_resolution_1d, bit_depth=16) + ADX16 = create_ADX(lut_directory, bit_depth=16) colorspaces.append(ADX16) lmts = create_LMTs(aces_ctl_directory, @@ -1543,7 +1665,6 @@ def create_colorspaces(aces_ctl_directory, lut_resolution_1d, lut_resolution_3d, lmt_info, - shaper_name, cleanup) colorspaces.extend(lmts) @@ -1558,10 +1679,11 @@ def create_colorspaces(aces_ctl_directory, ACEScc) colorspaces.extend(odts) - # Wish there was an automatic way to get this from the CTL + # 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': ACEScg.name, + roles = {'color_picking': color_picking, 'color_timing': ACEScc.name, 'compositing_log': ACEScc.name, 'data': '', @@ -1569,6 +1691,8 @@ def create_colorspaces(aces_ctl_directory, 'matte_paint': ACEScc.name, 'reference': '', 'scene_linear': ACEScg.name, - 'texture_paint': ''} + 'texture_paint': '', + 'compositing_linear': ACEScg.name, + 'rendering': ACEScg.name} return ACES, colorspaces, displays, ACEScc, roles, default_display