From 00b5038051339b435360790792b7422b4b1947f2 Mon Sep 17 00:00:00 2001 From: Haarm-Pieter Duiker Date: Thu, 20 Aug 2015 15:13:21 -0700 Subject: [PATCH] Created and used shapers appropriate to HDR Output Transform. User can choose to use either Log2 or a scaled Dolby PQ as shaper functions. Log2 is still the default. --- aces_1.0.0/python/aces_ocio/colorspaces/aces.py | 431 +++++++++++++++-------- aces_1.0.0/python/aces_ocio/generate_config.py | 46 ++- 2 files changed, 318 insertions(+), 159 deletions(-) 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 3b34319..fc23937 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 @@ -44,11 +45,14 @@ __all__ = ['ACES_AP1_TO_AP0', 'create_ADX', 'create_generic_log', 'create_Dolby_PQ', - 'create_Dolby_PQ_scaled', + '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', @@ -293,11 +297,15 @@ def create_ACEScg(): cs.from_reference_transforms = [] + # 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'}) + #cs.from_reference_transforms.append({ + # 'type': 'matrix', + # 'matrix': mat44_from_mat33(ACES_AP0_TO_AP1), + # 'direction': 'forward'}) return cs @@ -471,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. @@ -589,7 +597,7 @@ def create_Dolby_PQ(aces_ctl_directory, # ------------------------------------------------------------------------- # *Dolby PQ* Transform - Fixed Linear Range # ------------------------------------------------------------------------- -def create_Dolby_PQ_scaled(aces_ctl_directory, +def create_Dolby_PQ_shaper(aces_ctl_directory, lut_directory, lut_resolution_1d, cleanup, @@ -599,7 +607,7 @@ def create_Dolby_PQ_scaled(aces_ctl_directory, max_value=1.0, input_scale=1.0, middle_grey=0.18, - min_exposure=-6.0, + min_exposure=-6.5, max_exposure=6.5): if aliases is None: aliases = [] @@ -614,7 +622,7 @@ def create_Dolby_PQ_scaled(aces_ctl_directory, ctls = [os.path.join( aces_ctl_directory, 'utilities', - 'ACESlib.OCIOshaper_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) @@ -1009,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, @@ -1080,36 +1067,16 @@ 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 log2_shaper_api1_colorspace.to_reference_transforms.append({ @@ -1119,34 +1086,41 @@ 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 and 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* - # - dolby_pq_shaper_name = 'Dolby PQ 10000' - dolby_pq_shaper_name_aliases = ['crv_%s' % 'dolbypq_10000'] + return shaper_data, colorspaces - dolby_pq_shaper_colorspace = create_Dolby_PQ( +# ------------------------------------------------------------------------- +# *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)] + + 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) + 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. @@ -1154,44 +1128,235 @@ def create_ODTs(aces_ctl_directory, 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[dolby_pq_shaper_name] = dolby_pq_shaper_data - # Define the *Dolby PQ Shaper that considers a fixed linear range* - dolby_pq_scaled_shaper_name = 'Dolby PQ Scaled' - dolby_pq_scaled_shaper_name_aliases = ['crv_%s' % 'dolbypq_scaled'] + # 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 = {} - dolby_pq_scaled_shaper_colorspace = create_Dolby_PQ_scaled( + # 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 48nits 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 1000nits 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 2000nits 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 4000nits 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_scaled_shaper_name, - aliases=dolby_pq_scaled_shaper_name_aliases) - colorspaces.append(dolby_pq_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. - dolby_pq_scaled_shaper_data = [ - dolby_pq_scaled_shaper_name, + dolby_pq_shaper_data = [ + dolby_pq_shaper_name, os.path.join('%s', 'utilities', - 'ACESlib.OCIOshaper_to_Lin_param.a1.0.0.ctl'), + 'ACESlib.DolbyPQ_to_Lin.a1.0.0.ctl'), os.path.join('%s', 'utilities', - 'ACESlib.Lin_to_OCIOshaper_param.a1.0.0.ctl'), + 'ACESlib.Lin_to_DolbyPQ.a1.0.0.ctl'), 1.0, - log2_params] + {}] + + 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 48nits 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 1000nits 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 2000nits 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 4000nits 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) - shaper_data[dolby_pq_scaled_shaper_name] = dolby_pq_scaled_shaper_data + colorspaces.extend(shaper_colorspaces) - rrt_shaper = log2_shaper_data - # rrt_shaper = dolby_pq_scaled_shaper_data + # 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("48nits", "1000nits")] + rrt_shaper_2000nits = shaper_data[shaper_name.replace("48nits", "2000nits")] + rrt_shaper_4000nits = shaper_data[shaper_name.replace("48nits", "4000nits")] # *RRT + ODT* combinations. sorted_odts = sorted(odt_info.iteritems(), key=lambda x: x[1]) @@ -1199,24 +1364,22 @@ def create_ODTs(aces_ctl_directory, for odt in sorted_odts: (odt_name, odt_values) = odt - # Defining 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 restore the old behavior, - # where both *legal* or *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, @@ -1233,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 diff --git a/aces_1.0.0/python/aces_ocio/generate_config.py b/aces_1.0.0/python/aces_ocio/generate_config.py index 3dcd2c6..7d4ea60 100755 --- a/aces_1.0.0/python/aces_ocio/generate_config.py +++ b/aces_1.0.0/python/aces_ocio/generate_config.py @@ -1133,6 +1133,15 @@ def generate_baked_LUTs(odt_info, odt_prefix = odt_values['transformUserNamePrefix'] odt_name = odt_values['transformUserName'] + if odt_name in ['P3-D60 PQ (1000 nits)']: + odt_shaper = shaper_name.replace("48nits", "1000nits") + elif odt_name in ['P3-D60 PQ (2000 nits)']: + odt_shaper = shaper_name.replace("48nits", "2000nits") + elif odt_name in ['P3-D60 PQ (4000 nits)']: + odt_shaper = shaper_name.replace("48nits", "4000nits") + else: + odt_shaper = shaper_name + # *Photoshop* for input_space in ['ACEScc', 'ACESproxy']: args = ['--iconfig', config_path, @@ -1149,10 +1158,10 @@ def generate_baked_LUTs(odt_info, odt_name, input_space)] if prefix: - args += ['--shaperspace', 'Utility - %s' % shaper_name, + args += ['--shaperspace', 'Utility - %s' % odt_shaper, '--shapersize', str(lut_resolution_shaper)] else: - args += ['--shaperspace', shaper_name, + args += ['--shaperspace', odt_shaper, '--shapersize', str(lut_resolution_shaper)] args += ['--cubesize', str(lut_resolution_3d)] args += ['--format', @@ -1180,10 +1189,10 @@ def generate_baked_LUTs(odt_info, '%s - %s for %s data' % ( odt_prefix, odt_name, input_space)] if prefix: - args += ['--shaperspace', 'Utility - %s' % shaper_name, + args += ['--shaperspace', 'Utility - %s' % odt_shaper, '--shapersize', str(lut_resolution_shaper)] else: - args += ['--shaperspace', shaper_name, + args += ['--shaperspace', odt_shaper, '--shapersize', str(lut_resolution_shaper)] args += ['--cubesize', str(lut_resolution_3d)] @@ -1223,9 +1232,9 @@ def generate_baked_LUTs(odt_info, '%s - %s for %s data' % ( odt_prefix, odt_name, input_space)] if input_space == 'ACEScg': - lin_shaper_name = '%s - AP1' % shaper_name + lin_shaper_name = '%s - AP1' % odt_shaper else: - lin_shaper_name = shaper_name + lin_shaper_name = odt_shaper if prefix: lin_shaper_name = 'Utility - %s' % lin_shaper_name args += ['--shaperspace', lin_shaper_name, @@ -1302,7 +1311,8 @@ def generate_config(aces_ctl_directory, look_info=None, copy_custom_luts=True, cleanup=True, - prefix_colorspaces_with_family_names=True): + prefix_colorspaces_with_family_names=True, + shaper_base_name='Log2'): """ Creates the ACES configuration. @@ -1331,7 +1341,11 @@ def generate_config(aces_ctl_directory, odt_info = aces.get_ODTs_info(aces_ctl_directory) lmt_info = aces.get_LMTs_info(aces_ctl_directory) - shaper_name = 'Output Shaper' + if shaper_base_name == 'DolbyPQ': + shaper_name = 'Dolby PQ 48nits Shaper' + else: + shaper_name = 'Log2 48nits Shaper' + config_data = create_config_data(odt_info, lmt_info, shaper_name, @@ -1436,7 +1450,13 @@ def main(): 'ACEScc colorspace, but the user could choose other spaces ' 'by changing the argument after the name of the look. \n') usage += '\n' - + usage += ('Create a GUI-friendly ACES 1.0 config using the Dolby PQ ' + 'transfer function as the shaper: \n') + usage += ('\tcreate_aces_config -a /path/to/aces-dev/transforms/ctl ' + '--lutResolution1d 1024 --lutResolution3d 33 -c aces_1.0.0 ' + '--shaper DolbyPQ') + usage += '\n' + look_info = [] def look_info_callback(option, opt_str, value, parser): @@ -1477,6 +1497,8 @@ def main(): action='callback', callback=look_info_callback) p.add_option('--copyCustomLUTs', action='store_true', default=False) + p.add_option('--shaper', '-s', default='Log2') + options, arguments = p.parse_args() aces_ctl_directory = options.acesCTLDir @@ -1487,6 +1509,8 @@ def main(): cleanup_temp_images = not options.keepTempImages multiple_displays = options.createMultipleDisplays copy_custom_luts = options.copyCustomLUTs + shaper_base_name = options.shaper + prefix = True print(look_info) @@ -1510,7 +1534,9 @@ def main(): multiple_displays, look_info, copy_custom_luts, - cleanup_temp_images) + cleanup_temp_images, + prefix, + shaper_base_name) if __name__ == '__main__': -- 1.7.10.4