2 # -*- coding: utf-8 -*-
5 Defines objects creating the *ACES* configuration.
16 import PyOpenColorIO as ocio
18 import aces_ocio.create_arri_colorspaces as arri
19 import aces_ocio.create_canon_colorspaces as canon
20 import aces_ocio.create_red_colorspaces as red
21 import aces_ocio.create_sony_colorspaces as sony
22 from aces_ocio.generate_lut import (
23 generate_1d_LUT_from_CTL,
24 generate_3d_LUT_from_CTL,
26 from aces_ocio.process import Process
27 from aces_ocio.utilities import ColorSpace, mat44_from_mat33, sanitize_path, compact
29 __author__ = 'ACES Developers'
30 __copyright__ = 'Copyright (C) 2014 - 2015 - ACES Developers'
32 __maintainer__ = 'ACES Developers'
33 __email__ = 'aces@oscars.org'
34 __status__ = 'Production'
36 __all__ = ['ACES_OCIO_CTL_DIRECTORY_ENVIRON',
37 'ACES_OCIO_CONFIGURATION_DIRECTORY_ENVIRON',
38 'set_config_default_roles',
40 'generate_OCIO_transform',
43 'generate_baked_LUTs',
51 ACES_OCIO_CTL_DIRECTORY_ENVIRON = 'ACES_OCIO_CTL_DIRECTORY'
52 ACES_OCIO_CONFIGURATION_DIRECTORY_ENVIRON = 'ACES_OCIO_CONFIGURATION_DIRECTORY'
55 def set_config_default_roles(config,
66 Sets given *OCIO* configuration default roles.
72 color_picking : str or unicode
73 Color picking role title.
74 color_timing : str or unicode
75 Color timing role title.
76 compositing_log : str or unicode
77 Compositing log role title.
80 default : str or unicode
82 matte_paint : str or unicode
83 Matte painting role title.
84 reference : str or unicode
86 scene_linear : str or unicode
87 Scene linear role title.
88 texture_paint : str or unicode
89 Texture painting role title.
98 config.setRole(ocio.Constants.ROLE_COLOR_PICKING, color_picking)
100 config.setRole(ocio.Constants.ROLE_COLOR_TIMING, color_timing)
102 config.setRole(ocio.Constants.ROLE_COMPOSITING_LOG, compositing_log)
104 config.setRole(ocio.Constants.ROLE_DATA, data)
106 config.setRole(ocio.Constants.ROLE_DEFAULT, default)
108 config.setRole(ocio.Constants.ROLE_MATTE_PAINT, matte_paint)
110 config.setRole(ocio.Constants.ROLE_REFERENCE, reference)
112 config.setRole(ocio.Constants.ROLE_SCENE_LINEAR, scene_linear)
114 config.setRole(ocio.Constants.ROLE_TEXTURE_PAINT, texture_paint)
119 def write_config(config, config_path, sanity_check=True):
121 Writes the configuration to given path.
126 Parameter description.
131 Return value description.
139 print 'Configuration was not written due to a failed Sanity Check'
142 with open(config_path, mode='w') as fp:
143 fp.write(config.serialize())
146 def generate_OCIO_transform(transforms):
153 Parameter description.
158 Return value description.
161 interpolation_options = {
162 'linear': ocio.Constants.INTERP_LINEAR,
163 'nearest': ocio.Constants.INTERP_NEAREST,
164 'tetrahedral': ocio.Constants.INTERP_TETRAHEDRAL
166 direction_options = {
167 'forward': ocio.Constants.TRANSFORM_DIR_FORWARD,
168 'inverse': ocio.Constants.TRANSFORM_DIR_INVERSE
173 for transform in transforms:
176 if transform['type'] == 'lutFile':
177 ocio_transform = ocio.FileTransform(
178 src=transform['path'],
179 interpolation=interpolation_options[
180 transform['interpolation']],
181 direction=direction_options[transform['direction']])
182 ocio_transforms.append(ocio_transform)
185 elif transform['type'] == 'matrix':
186 ocio_transform = ocio.MatrixTransform()
187 # MatrixTransform member variables can't be initialized directly.
188 # Each must be set individually.
189 ocio_transform.setMatrix(transform['matrix'])
191 if 'offset' in transform:
192 ocio_transform.setOffset(transform['offset'])
194 if 'direction' in transform:
195 ocio_transform.setDirection(
196 direction_options[transform['direction']])
198 ocio_transforms.append(ocio_transform)
201 elif transform['type'] == 'exponent':
202 ocio_transform = ocio.ExponentTransform()
203 ocio_transform.setValue(transform['value'])
204 ocio_transforms.append(ocio_transform)
207 elif transform['type'] == 'log':
208 ocio_transform = ocio.LogTransform(
209 base=transform['base'],
210 direction=direction_options[transform['direction']])
212 ocio_transforms.append(ocio_transform)
214 # color space transform
215 elif transform['type'] == 'colorspace':
216 ocio_transform = ocio.ColorSpaceTransform( src=transform['src'],
217 dst=transform['dst'],
218 direction=direction_options['forward'] )
219 ocio_transforms.append(ocio_transform)
223 print("Ignoring unknown transform type : %s" % transform['type'])
225 if len(ocio_transforms) > 1:
226 group_transform = ocio.GroupTransform()
227 for transform in ocio_transforms:
228 group_transform.push_back(transform)
229 transform = group_transform
231 transform = ocio_transforms[0]
235 def add_colorspace_alias(config, reference_colorspace, colorspace, colorspace_alias_names):
242 Parameter description.
247 Return value description.
250 for alias_name in colorspace_alias_names:
251 if alias_name == colorspace.name.lower():
254 print( "Adding alias colorspace space %s, alias to %s" % (
255 alias_name, colorspace.name))
257 compact_family_name = "Aliases"
259 ocio_colorspace_alias = ocio.ColorSpace(
261 bitDepth=colorspace.bit_depth,
262 description=colorspace.description,
263 equalityGroup=colorspace.equality_group,
264 family=compact_family_name,
265 isData=colorspace.is_data,
266 allocation=colorspace.allocation_type,
267 allocationVars=colorspace.allocation_vars)
269 if colorspace.to_reference_transforms != []:
270 print("Generating To-Reference transforms")
271 ocio_transform = generate_OCIO_transform([{
272 'type': 'colorspace',
273 'src': colorspace.name,
274 'dst': reference_colorspace.name,
275 'direction': 'forward'
277 ocio_colorspace_alias.setTransform(
279 ocio.Constants.COLORSPACE_DIR_TO_REFERENCE)
281 if colorspace.from_reference_transforms != []:
282 print("Generating From-Reference transforms")
283 ocio_transform = generate_OCIO_transform([{
284 'type': 'colorspace',
285 'src': reference_colorspace.name,
286 'dst': colorspace.name,
287 'direction': 'forward'
289 ocio_colorspace_alias.setTransform(
291 ocio.Constants.COLORSPACE_DIR_FROM_REFERENCE)
293 config.addColorSpace(ocio_colorspace_alias)
296 def create_config(config_data, nuke=False):
303 Parameter description.
308 Return value description.
311 # Creating the *OCIO* configuration.
312 config = ocio.Config()
314 # Setting configuration overall values.
315 config.setDescription('An ACES config generated from python')
316 config.setSearchPath('luts')
318 # Defining the reference colorspace.
319 reference_data = config_data['referenceColorSpace']
320 print('Adding the reference color space : %s' % reference_data.name)
322 reference = ocio.ColorSpace(
323 name=reference_data.name,
324 bitDepth=reference_data.bit_depth,
325 description=reference_data.description,
326 equalityGroup=reference_data.equality_group,
327 family=reference_data.family,
328 isData=reference_data.is_data,
329 allocation=reference_data.allocation_type,
330 allocationVars=reference_data.allocation_vars)
332 config.addColorSpace(reference)
335 if reference_data.aliases != []:
336 add_colorspace_alias(config, reference_data,
337 reference_data, reference_data.aliases)
341 # Creating the remaining colorspaces.
342 for colorspace in sorted(config_data['colorSpaces']):
343 print('Creating new color space : %s' % colorspace.name)
345 ocio_colorspace = ocio.ColorSpace(
346 name=colorspace.name,
347 bitDepth=colorspace.bit_depth,
348 description=colorspace.description,
349 equalityGroup=colorspace.equality_group,
350 family=colorspace.family,
351 isData=colorspace.is_data,
352 allocation=colorspace.allocation_type,
353 allocationVars=colorspace.allocation_vars)
355 if colorspace.to_reference_transforms:
356 print('Generating To-Reference transforms')
357 ocio_transform = generate_OCIO_transform(
358 colorspace.to_reference_transforms)
359 ocio_colorspace.setTransform(
361 ocio.Constants.COLORSPACE_DIR_TO_REFERENCE)
363 if colorspace.from_reference_transforms:
364 print('Generating From-Reference transforms')
365 ocio_transform = generate_OCIO_transform(
366 colorspace.from_reference_transforms)
367 ocio_colorspace.setTransform(
369 ocio.Constants.COLORSPACE_DIR_FROM_REFERENCE)
371 config.addColorSpace(ocio_colorspace)
374 # Add alias to normal colorspace, using compact name
376 if colorspace.aliases != []:
377 add_colorspace_alias(config, reference_data,
378 colorspace, colorspace.aliases)
382 # Defining the *views* and *displays*.
386 # Defining a *generic* *display* and *view* setup.
388 for display, view_list in config_data['displays'].iteritems():
389 for view_name, colorspace in view_list.iteritems():
390 config.addDisplay(display, view_name, colorspace.name)
391 if not (view_name in views):
392 views.append(view_name)
393 displays.append(display)
394 # Defining the *Nuke* specific set of *views* and *displays*.
396 for display, view_list in config_data['displays'].iteritems():
397 for view_name, colorspace in view_list.iteritems():
398 if view_name == 'Output Transform':
400 config.addDisplay(display, view_name, colorspace.name)
401 if not (view_name in views):
402 views.append(view_name)
403 displays.append(display)
405 config.addDisplay('linear', 'View', 'ACES2065-1')
406 displays.append('linear')
407 config.addDisplay('log', 'View', 'ACEScc')
408 displays.append('log')
410 # Setting the active *displays* and *views*.
411 config.setActiveDisplays(','.join(sorted(displays)))
412 config.setActiveViews(','.join(views))
414 set_config_default_roles(
416 color_picking=reference.getName(),
417 color_timing=reference.getName(),
418 compositing_log=reference.getName(),
419 data=reference.getName(),
420 default=reference.getName(),
421 matte_paint=reference.getName(),
422 reference=reference.getName(),
423 scene_linear=reference.getName(),
424 texture_paint=reference.getName())
431 def generate_LUTs(odt_info,
436 lut_resolution_1d=4096,
437 lut_resolution_3d=64,
445 Parameter description.
450 Colorspaces and transforms converting between those colorspaces and
451 the reference colorspace, *ACES*.
454 print('generateLUTs - begin')
457 # Defining the reference colorspace.
458 ACES = ColorSpace('ACES2065-1')
460 'The Academy Color Encoding System reference color space')
461 ACES.equality_group = ''
462 ACES.aliases = ["lin_ap0", "aces"]
465 ACES.allocation_type = ocio.Constants.ALLOCATION_LG2
466 ACES.allocation_vars = [-15, 6]
468 config_data['referenceColorSpace'] = ACES
470 config_data['displays'] = {}
471 config_data['colorSpaces'] = []
473 # Matrix converting *ACES AP1* primaries to *AP0*.
474 ACES_AP1_to_AP0 = [0.6954522414, 0.1406786965, 0.1638690622,
475 0.0447945634, 0.8596711185, 0.0955343182,
476 -0.0055258826, 0.0040252103, 1.0015006723]
478 # Matrix converting *ACES AP0* primaries to *XYZ*.
479 ACES_AP0_to_XYZ = [0.9525523959, 0.0000000000, 0.0000936786,
480 0.3439664498, 0.7281660966, -0.0721325464,
481 0.0000000000, 0.0000000000, 1.0088251844]
483 # -------------------------------------------------------------------------
485 # -------------------------------------------------------------------------
486 def create_ACEScc(name='ACEScc',
490 cs = ColorSpace(name)
491 cs.description = 'The %s color space' % name
492 cs.aliases = ["acescc_ap1"]
493 cs.equality_group = ''
497 ctls = [os.path.join(aces_CTL_directory,
499 'ACEScsc.ACEScc_to_ACES.a1.0.0.ctl'),
500 # This transform gets back to the *AP1* primaries.
501 # Useful as the 1d LUT is only covering the transfer function.
502 # The primaries switch is covered by the matrix below:
503 os.path.join(aces_CTL_directory,
505 'ACEScsc.ACES_to_ACEScg.a1.0.0.ctl')]
506 lut = '%s_to_ACES.spi1d' % name
508 lut = sanitize_path(lut)
510 generate_1d_LUT_from_CTL(
511 os.path.join(lut_directory, lut),
523 cs.to_reference_transforms = []
524 cs.to_reference_transforms.append({
527 'interpolation': 'linear',
528 'direction': 'forward'})
530 # *AP1* primaries to *AP0* primaries.
531 cs.to_reference_transforms.append({
533 'matrix': mat44_from_mat33(ACES_AP1_to_AP0),
534 'direction': 'forward'})
536 cs.from_reference_transforms = []
539 ACEScc = create_ACEScc()
540 config_data['colorSpaces'].append(ACEScc)
542 # -------------------------------------------------------------------------
544 # -------------------------------------------------------------------------
545 def create_ACESproxy(name='ACESproxy'):
546 cs = ColorSpace(name)
547 cs.description = 'The %s color space' % name
548 cs.aliases = ["acesproxy_ap1"]
549 cs.equality_group = ''
553 ctls = [os.path.join(aces_CTL_directory,
555 'ACEScsc.ACESproxy10i_to_ACES.a1.0.0.ctl'),
556 # This transform gets back to the *AP1* primaries.
557 # Useful as the 1d LUT is only covering the transfer function.
558 # The primaries switch is covered by the matrix below:
559 os.path.join(aces_CTL_directory,
561 'ACEScsc.ACES_to_ACEScg.a1.0.0.ctl')]
562 lut = '%s_to_aces.spi1d' % name
564 lut = sanitize_path(lut)
566 generate_1d_LUT_from_CTL(
567 os.path.join(lut_directory, lut),
577 cs.to_reference_transforms = []
578 cs.to_reference_transforms.append({
581 'interpolation': 'linear',
582 'direction': 'forward'
585 # *AP1* primaries to *AP0* primaries.
586 cs.to_reference_transforms.append({
588 'matrix': mat44_from_mat33(ACES_AP1_to_AP0),
589 'direction': 'forward'
592 cs.from_reference_transforms = []
595 ACESproxy = create_ACESproxy()
596 config_data['colorSpaces'].append(ACESproxy)
598 # -------------------------------------------------------------------------
600 # -------------------------------------------------------------------------
601 def create_ACEScg(name='ACEScg'):
602 cs = ColorSpace(name)
603 cs.description = 'The %s color space' % name
604 cs.aliases = ["lin_ap1"]
605 cs.equality_group = ''
609 cs.to_reference_transforms = []
611 # *AP1* primaries to *AP0* primaries.
612 cs.to_reference_transforms.append({
614 'matrix': mat44_from_mat33(ACES_AP1_to_AP0),
615 'direction': 'forward'
618 cs.from_reference_transforms = []
621 ACEScg = create_ACEScg()
622 config_data['colorSpaces'].append(ACEScg)
624 # -------------------------------------------------------------------------
626 # -------------------------------------------------------------------------
627 def create_ADX(bit_depth=10, name='ADX'):
628 name = '%s%s' % (name, bit_depth)
629 cs = ColorSpace(name)
630 cs.description = '%s color space - used for film scans' % name
631 cs.aliases = ["adx%s" % str(bit_depth)]
632 cs.equality_group = ''
637 cs.bit_depth = ocio.Constants.BIT_DEPTH_UINT10
638 adx_to_cdd = [1023.0 / 500.0, 0.0, 0.0, 0.0,
639 0.0, 1023.0 / 500.0, 0.0, 0.0,
640 0.0, 0.0, 1023.0 / 500.0, 0.0,
642 offset = [-95.0 / 500.0, -95.0 / 500.0, -95.0 / 500.0, 0.0]
643 elif bit_depth == 16:
644 cs.bit_depth = ocio.Constants.BIT_DEPTH_UINT16
645 adx_to_cdd = [65535.0 / 8000.0, 0.0, 0.0, 0.0,
646 0.0, 65535.0 / 8000.0, 0.0, 0.0,
647 0.0, 0.0, 65535.0 / 8000.0, 0.0,
649 offset = [-1520.0 / 8000.0, -1520.0 / 8000.0, -1520.0 / 8000.0,
652 cs.to_reference_transforms = []
654 # Converting from *ADX* to *Channel-Dependent Density*.
655 cs.to_reference_transforms.append({
657 'matrix': adx_to_cdd,
659 'direction': 'forward'})
661 # Convert from Channel-Dependent Density to Channel-Independent Density
662 cs.to_reference_transforms.append({
664 'matrix': [0.75573, 0.22197, 0.02230, 0,
665 0.05901, 0.96928, -0.02829, 0,
666 0.16134, 0.07406, 0.76460, 0,
668 'direction': 'forward'})
670 # Copied from *Alex Fry*'s *adx_cid_to_rle.py*
671 def create_CID_to_RLE_LUT():
673 def interpolate_1D(x, xp, fp):
674 return numpy.interp(x, xp, fp)
676 LUT_1D_xp = [-0.190000000000000,
688 LUT_1D_fp = [-6.000000000000000,
700 REF_PT = ((7120.0 - 1520.0) / 8000.0 * (100.0 / 55.0) -
701 math.log(0.18, 10.0))
705 return interpolate_1D(x, LUT_1D_xp, LUT_1D_fp)
706 return (100.0 / 55.0) * x - REF_PT
708 def fit(value, from_min, from_max, to_min, to_max):
709 if from_min == from_max:
710 raise ValueError('from_min == from_max')
711 return (value - from_min) / (from_max - from_min) * (
712 to_max - to_min) + to_min
714 NUM_SAMPLES = 2 ** 12
717 for i in xrange(NUM_SAMPLES):
718 x = i / (NUM_SAMPLES - 1.0)
719 x = fit(x, 0.0, 1.0, RANGE[0], RANGE[1])
720 data.append(cid_to_rle(x))
722 lut = 'ADX_CID_to_RLE.spi1d'
723 write_SPI_1d(os.path.join(lut_directory, lut),
731 # Converting *Channel Independent Density* values to
732 # *Relative Log Exposure* values.
733 lut = create_CID_to_RLE_LUT()
734 cs.to_reference_transforms.append({
737 'interpolation': 'linear',
738 'direction': 'forward'})
740 # Converting *Relative Log Exposure* values to
741 # *Relative Exposure* values.
742 cs.to_reference_transforms.append({
745 'direction': 'inverse'})
747 # Convert *Relative Exposure* values to *ACES* values.
748 cs.to_reference_transforms.append({
750 'matrix': [0.72286, 0.12630, 0.15084, 0,
751 0.11923, 0.76418, 0.11659, 0,
752 0.01427, 0.08213, 0.90359, 0,
754 'direction': 'forward'})
756 cs.from_reference_transforms = []
759 ADX10 = create_ADX(bit_depth=10)
760 config_data['colorSpaces'].append(ADX10)
762 ADX16 = create_ADX(bit_depth=16)
763 config_data['colorSpaces'].append(ADX16)
765 # -------------------------------------------------------------------------
766 # *Camera Input Transforms*
767 # -------------------------------------------------------------------------
769 # *RED* colorspaces to *ACES*.
770 red_colorspaces = red.create_colorspaces(lut_directory, lut_resolution_1d)
771 for cs in red_colorspaces:
772 config_data['colorSpaces'].append(cs)
774 # *Canon-Log* to *ACES*.
775 canon_colorspaces = canon.create_colorspaces(lut_directory,
777 for cs in canon_colorspaces:
778 config_data['colorSpaces'].append(cs)
781 sony_colorSpaces = sony.create_colorspaces(lut_directory,
783 for cs in sony_colorSpaces:
784 config_data['colorSpaces'].append(cs)
787 arri_colorSpaces = arri.create_colorspaces(lut_directory,
789 for cs in arri_colorSpaces:
790 config_data['colorSpaces'].append(cs)
792 # -------------------------------------------------------------------------
793 # *Generic Log Transform*
794 # -------------------------------------------------------------------------
795 def create_generic_log(name='log',
803 lut_resolution_1d=lut_resolution_1d):
804 cs = ColorSpace(name)
805 cs.description = 'The %s color space' % name
807 cs.equality_group = name
808 cs.family = 'Utility'
811 ctls = [os.path.join(
814 'ACESlib.OCIO_shaper_log2_to_lin_param.a1.0.0.ctl')]
815 lut = '%s_to_aces.spi1d' % name
817 lut = sanitize_path(lut)
819 generate_1d_LUT_from_CTL(
820 os.path.join(lut_directory, lut),
826 {'middleGrey': middle_grey,
827 'minExposure': min_exposure,
828 'maxExposure': max_exposure},
834 cs.to_reference_transforms = []
835 cs.to_reference_transforms.append({
838 'interpolation': 'linear',
839 'direction': 'forward'})
841 cs.from_reference_transforms = []
844 # -------------------------------------------------------------------------
846 # -------------------------------------------------------------------------
847 def create_ACES_LMT(lmt_name,
850 lut_resolution_1d=1024,
851 lut_resolution_3d=64,
854 cs = ColorSpace('%s' % lmt_name)
855 cs.description = 'The ACES Look Transform: %s' % lmt_name
857 cs.equality_group = ''
861 pprint.pprint(lmt_values)
863 # Generating the *shaper* transform.
866 shaper_from_ACES_CTL,
868 shaper_params) = shaper_info
870 shaper_lut = '%s_to_aces.spi1d' % shaper_name
871 if not os.path.exists(os.path.join(lut_directory, shaper_lut)):
872 ctls = [shaper_to_ACES_CTL % aces_CTL_directory]
874 shaper_lut = sanitize_path(shaper_lut)
876 generate_1d_LUT_from_CTL(
877 os.path.join(lut_directory, shaper_lut),
881 1.0 / shaper_input_scale,
887 shaper_OCIO_transform = {
890 'interpolation': 'linear',
891 'direction': 'inverse'}
893 # Generating the forward transform.
894 cs.from_reference_transforms = []
896 if 'transformCTL' in lmt_values:
897 ctls = [shaper_to_ACES_CTL % aces_CTL_directory,
898 os.path.join(aces_CTL_directory,
899 lmt_values['transformCTL'])]
900 lut = '%s.%s.spi3d' % (shaper_name, lmt_name)
902 lut = sanitize_path(lut)
904 generate_3d_LUT_from_CTL(
905 os.path.join(lut_directory, lut),
909 1.0 / shaper_input_scale,
915 cs.from_reference_transforms.append(shaper_OCIO_transform)
916 cs.from_reference_transforms.append({
919 'interpolation': 'tetrahedral',
920 'direction': 'forward'
923 # Generating the inverse transform.
924 cs.to_reference_transforms = []
926 if 'transformCTLInverse' in lmt_values:
927 ctls = [os.path.join(aces_CTL_directory,
928 odt_values['transformCTLInverse']),
929 shaper_from_ACES_CTL % aces_CTL_directory]
930 lut = 'Inverse.%s.%s.spi3d' % (odt_name, shaper_name)
932 lut = sanitize_path(lut)
934 generate_3d_LUT_from_CTL(
935 os.path.join(lut_directory, lut),
945 cs.to_reference_transforms.append({
948 'interpolation': 'tetrahedral',
949 'direction': 'forward'})
951 shaper_inverse = shaper_OCIO_transform.copy()
952 shaper_inverse['direction'] = 'forward'
953 cs.to_reference_transforms.append(shaper_inverse)
957 # -------------------------------------------------------------------------
959 # -------------------------------------------------------------------------
961 lmt_lut_resolution_1d = max(4096, lut_resolution_1d)
962 lmt_lut_resolution_3d = max(65, lut_resolution_3d)
964 # Defining the *Log 2* shaper.
965 lmt_shaper_name = 'LMT Shaper'
966 lmt_shaper_name_aliases = ['crv_lmtshaper']
969 'minExposure': -10.0,
972 lmt_shaper = create_generic_log(name=lmt_shaper_name,
973 middle_grey=lmt_params['middleGrey'],
974 min_exposure=lmt_params['minExposure'],
975 max_exposure=lmt_params['maxExposure'],
976 lut_resolution_1d=lmt_lut_resolution_1d,
977 aliases=lmt_shaper_name_aliases)
978 config_data['colorSpaces'].append(lmt_shaper)
980 shaper_input_scale_generic_log2 = 1.0
982 # *Log 2* shaper name and *CTL* transforms bundled up.
987 'ACESlib.OCIO_shaper_log2_to_lin_param.a1.0.0.ctl'),
990 'ACESlib.OCIO_shaper_lin_to_log2_param.a1.0.0.ctl'),
991 shaper_input_scale_generic_log2,
994 sorted_LMTs = sorted(lmt_info.iteritems(), key=lambda x: x[1])
996 for lmt in sorted_LMTs:
997 (lmt_name, lmt_values) = lmt
998 lmt_aliases = ["look_%s" % compact(lmt_values['transformUserName'])]
999 cs = create_ACES_LMT(
1000 lmt_values['transformUserName'],
1003 lmt_lut_resolution_1d,
1004 lmt_lut_resolution_3d,
1007 config_data['colorSpaces'].append(cs)
1009 # -------------------------------------------------------------------------
1010 # *ACES RRT* with supplied *ODT*.
1011 # -------------------------------------------------------------------------
1012 def create_ACES_RRT_plus_ODT(odt_name,
1015 lut_resolution_1d=1024,
1016 lut_resolution_3d=64,
1019 cs = ColorSpace('%s' % odt_name)
1020 cs.description = '%s - %s Output Transform' % (
1021 odt_values['transformUserNamePrefix'], odt_name)
1022 cs.aliases = aliases
1023 cs.equality_group = ''
1024 cs.family = 'Output'
1027 pprint.pprint(odt_values)
1029 # Generating the *shaper* transform.
1032 shaper_from_ACES_CTL,
1034 shaper_params) = shaper_info
1036 if 'legalRange' in odt_values:
1037 shaper_params['legalRange'] = odt_values['legalRange']
1039 shaper_params['legalRange'] = 0
1041 shaper_lut = '%s_to_aces.spi1d' % shaper_name
1042 if not os.path.exists(os.path.join(lut_directory, shaper_lut)):
1043 ctls = [shaper_to_ACES_CTL % aces_CTL_directory]
1045 shaper_lut = sanitize_path(shaper_lut)
1047 generate_1d_LUT_from_CTL(
1048 os.path.join(lut_directory, shaper_lut),
1052 1.0 / shaper_input_scale,
1058 shaper_OCIO_transform = {
1061 'interpolation': 'linear',
1062 'direction': 'inverse'}
1064 # Generating the *forward* transform.
1065 cs.from_reference_transforms = []
1067 if 'transformLUT' in odt_values:
1068 transform_LUT_file_name = os.path.basename(
1069 odt_values['transformLUT'])
1070 lut = os.path.join(lut_directory, transform_LUT_file_name)
1071 shutil.copy(odt_values['transformLUT'], lut)
1073 cs.from_reference_transforms.append(shaper_OCIO_transform)
1074 cs.from_reference_transforms.append({
1076 'path': transform_LUT_file_name,
1077 'interpolation': 'tetrahedral',
1078 'direction': 'forward'})
1079 elif 'transformCTL' in odt_values:
1081 shaper_to_ACES_CTL % aces_CTL_directory,
1082 os.path.join(aces_CTL_directory,
1085 os.path.join(aces_CTL_directory,
1087 odt_values['transformCTL'])]
1088 lut = '%s.RRT.a1.0.0.%s.spi3d' % (shaper_name, odt_name)
1090 lut = sanitize_path(lut)
1092 generate_3d_LUT_from_CTL(
1093 os.path.join(lut_directory, lut),
1098 1.0 / shaper_input_scale,
1104 cs.from_reference_transforms.append(shaper_OCIO_transform)
1105 cs.from_reference_transforms.append({
1108 'interpolation': 'tetrahedral',
1109 'direction': 'forward'})
1111 # Generating the *inverse* transform.
1112 cs.to_reference_transforms = []
1114 if 'transformLUTInverse' in odt_values:
1115 transform_LUT_inverse_file_name = os.path.basename(
1116 odt_values['transformLUTInverse'])
1117 lut = os.path.join(lut_directory, transform_LUT_inverse_file_name)
1118 shutil.copy(odt_values['transformLUTInverse'], lut)
1120 cs.to_reference_transforms.append({
1122 'path': transform_LUT_inverse_file_name,
1123 'interpolation': 'tetrahedral',
1124 'direction': 'forward'})
1126 shaper_inverse = shaper_OCIO_transform.copy()
1127 shaper_inverse['direction'] = 'forward'
1128 cs.to_reference_transforms.append(shaper_inverse)
1129 elif 'transformCTLInverse' in odt_values:
1130 ctls = [os.path.join(aces_CTL_directory,
1132 odt_values['transformCTLInverse']),
1133 os.path.join(aces_CTL_directory,
1135 'InvRRT.a1.0.0.ctl'),
1136 shaper_from_ACES_CTL % aces_CTL_directory]
1137 lut = 'InvRRT.a1.0.0.%s.%s.spi3d' % (odt_name, shaper_name)
1139 lut = sanitize_path(lut)
1141 generate_3d_LUT_from_CTL(
1142 os.path.join(lut_directory, lut),
1153 cs.to_reference_transforms.append({
1156 'interpolation': 'tetrahedral',
1157 'direction': 'forward'})
1159 shaper_inverse = shaper_OCIO_transform.copy()
1160 shaper_inverse['direction'] = 'forward'
1161 cs.to_reference_transforms.append(shaper_inverse)
1165 # -------------------------------------------------------------------------
1166 # *RRT / ODT* Shaper Options
1167 # -------------------------------------------------------------------------
1170 # Defining the *Log 2* shaper.
1171 log2_shaper_name = shaper_name
1172 log2_shaper_name_aliases = ["crv_%s" % compact(shaper_name)]
1175 'minExposure': -6.0,
1178 log2_shaper = create_generic_log(
1179 name=log2_shaper_name,
1180 middle_grey=log2_params['middleGrey'],
1181 min_exposure=log2_params['minExposure'],
1182 max_exposure=log2_params['maxExposure'],
1183 aliases=log2_shaper_name_aliases)
1184 config_data['colorSpaces'].append(log2_shaper)
1186 shaper_input_scale_generic_log2 = 1.0
1188 # *Log 2* shaper name and *CTL* transforms bundled up.
1189 log2_shaper_data = [
1193 'ACESlib.OCIO_shaper_log2_to_lin_param.a1.0.0.ctl'),
1196 'ACESlib.OCIO_shaper_lin_to_log2_param.a1.0.0.ctl'),
1197 shaper_input_scale_generic_log2,
1200 shaper_data[log2_shaper_name] = log2_shaper_data
1202 # Shaper that also includes the AP1 primaries.
1203 # Needed for some LUT baking steps.
1204 log2_shaper_api1_name_aliases = ["%s_ap1" % compact(shaper_name)]
1205 log2_shaper_AP1 = create_generic_log(
1206 name=log2_shaper_name,
1207 middle_grey=log2_params['middleGrey'],
1208 min_exposure=log2_params['minExposure'],
1209 max_exposure=log2_params['maxExposure'],
1210 aliases=log2_shaper_api1_name_aliases)
1211 log2_shaper_AP1.name = '%s - AP1' % log2_shaper_AP1.name
1213 # *AP1* primaries to *AP0* primaries.
1214 log2_shaper_AP1.to_reference_transforms.append({
1216 'matrix': mat44_from_mat33(ACES_AP1_to_AP0),
1217 'direction': 'forward'
1219 config_data['colorSpaces'].append(log2_shaper_AP1)
1221 rrt_shaper = log2_shaper_data
1223 # *RRT + ODT* combinations.
1224 sorted_odts = sorted(odt_info.iteritems(), key=lambda x: x[1])
1226 for odt in sorted_odts:
1227 (odt_name, odt_values) = odt
1229 # Handling *ODTs* that can generate either *legal* or *full* output.
1230 if odt_name in ['Academy.Rec2020_100nits_dim.a1.0.0',
1231 'Academy.Rec709_100nits_dim.a1.0.0',
1232 'Academy.Rec709_D60sim_100nits_dim.a1.0.0']:
1233 odt_name_legal = '%s - Legal' % odt_values['transformUserName']
1235 odt_name_legal = odt_values['transformUserName']
1237 odt_legal = odt_values.copy()
1238 odt_legal['legalRange'] = 1
1240 odt_aliases = ["out_%s" % compact(odt_name_legal)]
1242 cs = create_ACES_RRT_plus_ODT(
1250 config_data['colorSpaces'].append(cs)
1252 config_data['displays'][odt_name_legal] = {
1255 'Output Transform': cs}
1257 if odt_name in ['Academy.Rec2020_100nits_dim.a1.0.0',
1258 'Academy.Rec709_100nits_dim.a1.0.0',
1259 'Academy.Rec709_D60sim_100nits_dim.a1.0.0']:
1260 print('Generating full range ODT for %s' % odt_name)
1262 odt_name_full = '%s - Full' % odt_values['transformUserName']
1263 odt_full = odt_values.copy()
1264 odt_full['legalRange'] = 0
1266 odt_full_aliases = ["out_%s" % compact(odt_name_full)]
1268 cs_full = create_ACES_RRT_plus_ODT(
1276 config_data['colorSpaces'].append(cs_full)
1278 config_data['displays'][odt_name_full] = {
1281 'Output Transform': cs_full}
1283 # -------------------------------------------------------------------------
1284 # Generic Matrix transform
1285 # -------------------------------------------------------------------------
1286 def create_generic_matrix(name='matrix',
1287 from_reference_values=None,
1288 to_reference_values=None,
1291 if from_reference_values is None:
1292 from_reference_values = []
1293 if to_reference_values is None:
1294 to_reference_values = []
1296 cs = ColorSpace(name)
1297 cs.description = 'The %s color space' % name
1299 cs.equality_group = name
1300 cs.family = 'Utility'
1303 cs.to_reference_transforms = []
1304 if to_reference_values:
1305 for matrix in to_reference_values:
1306 cs.to_reference_transforms.append({
1308 'matrix': mat44_from_mat33(matrix),
1309 'direction': 'forward'})
1311 cs.from_reference_transforms = []
1312 if from_reference_values:
1313 for matrix in from_reference_values:
1314 cs.from_reference_transforms.append({
1316 'matrix': mat44_from_mat33(matrix),
1317 'direction': 'forward'})
1321 cs = create_generic_matrix('XYZ',
1322 from_reference_values=[ACES_AP0_to_XYZ],
1323 aliases=["lin_xyz"])
1324 config_data['colorSpaces'].append(cs)
1326 cs = create_generic_matrix(
1328 to_reference_values=[ACES_AP1_to_AP0],
1329 aliases=["lin_ap1"])
1330 config_data['colorSpaces'].append(cs)
1332 # *ACES* to *Linear*, *P3D60* primaries.
1333 XYZ_to_P3D60 = [2.4027414142, -0.8974841639, -0.3880533700,
1334 -0.8325796487, 1.7692317536, 0.0237127115,
1335 0.0388233815, -0.0824996856, 1.0363685997]
1337 cs = create_generic_matrix(
1339 from_reference_values=[ACES_AP0_to_XYZ, XYZ_to_P3D60],
1340 aliases=["lin_p3d60"])
1341 config_data['colorSpaces'].append(cs)
1343 # *ACES* to *Linear*, *P3DCI* primaries.
1344 XYZ_to_P3DCI = [2.7253940305, -1.0180030062, -0.4401631952,
1345 -0.7951680258, 1.6897320548, 0.0226471906,
1346 0.0412418914, -0.0876390192, 1.1009293786]
1348 cs = create_generic_matrix(
1350 from_reference_values=[ACES_AP0_to_XYZ, XYZ_to_P3DCI],
1351 aliases=["lin_p3dci"])
1352 config_data['colorSpaces'].append(cs)
1354 # *ACES* to *Linear*, *Rec. 709* primaries.
1355 XYZ_to_Rec709 = [3.2409699419, -1.5373831776, -0.4986107603,
1356 -0.9692436363, 1.8759675015, 0.0415550574,
1357 0.0556300797, -0.2039769589, 1.0569715142]
1359 cs = create_generic_matrix(
1361 from_reference_values=[ACES_AP0_to_XYZ, XYZ_to_Rec709],
1362 aliases=["lin_rec709"])
1363 config_data['colorSpaces'].append(cs)
1365 # *ACES* to *Linear*, *Rec. 2020* primaries.
1366 XYZ_to_Rec2020 = [1.7166511880, -0.3556707838, -0.2533662814,
1367 -0.6666843518, 1.6164812366, 0.0157685458,
1368 0.0176398574, -0.0427706133, 0.9421031212]
1370 cs = create_generic_matrix(
1371 'Linear - Rec.2020',
1372 from_reference_values=[ACES_AP0_to_XYZ, XYZ_to_Rec2020],
1373 aliases=["lin_rec2020"])
1374 config_data['colorSpaces'].append(cs)
1376 print('generateLUTs - end')
1380 def generate_baked_LUTs(odt_info,
1386 lut_resolution_shaper=1024):
1393 Parameter description.
1398 Return value description.
1401 odt_info_C = dict(odt_info)
1402 for odt_CTL_name, odt_values in odt_info.iteritems():
1403 if odt_CTL_name in ['Academy.Rec2020_100nits_dim.a1.0.0',
1404 'Academy.Rec709_100nits_dim.a1.0.0',
1405 'Academy.Rec709_D60sim_100nits_dim.a1.0.0']:
1406 odt_name = odt_values['transformUserName']
1408 odt_values_legal = dict(odt_values)
1409 odt_values_legal['transformUserName'] = '%s - Legal' % odt_name
1410 odt_info_C['%s - Legal' % odt_CTL_name] = odt_values_legal
1412 odt_values_full = dict(odt_values)
1413 odt_values_full['transformUserName'] = '%s - Full' % odt_name
1414 odt_info_C['%s - Full' % odt_CTL_name] = odt_values_full
1416 del (odt_info_C[odt_CTL_name])
1418 for odt_CTL_name, odt_values in odt_info_C.iteritems():
1419 odt_prefix = odt_values['transformUserNamePrefix']
1420 odt_name = odt_values['transformUserName']
1423 for input_space in ['ACEScc', 'ACESproxy']:
1424 args = ['--iconfig', config_path,
1426 '--inputspace', input_space]
1427 args += ['--outputspace', '%s' % odt_name]
1428 args += ['--description',
1429 '%s - %s for %s data' % (odt_prefix,
1432 args += ['--shaperspace', shaper_name,
1433 '--shapersize', str(lut_resolution_shaper)]
1434 args += ['--cubesize', str(lut_resolution_3d)]
1435 args += ['--format',
1437 os.path.join(baked_directory,
1439 '%s for %s.icc' % (odt_name, input_space))]
1441 bake_LUT = Process(description='bake a LUT',
1447 for input_space in ['ACEScc', 'ACESproxy']:
1448 args = ['--iconfig', config_path,
1450 '--inputspace', input_space]
1451 args += ['--outputspace', '%s' % odt_name]
1452 args += ['--description',
1453 '%s - %s for %s data' % (
1454 odt_prefix, odt_name, input_space)]
1455 args += ['--shaperspace', shaper_name,
1456 '--shapersize', str(lut_resolution_shaper)]
1457 args += ['--cubesize', str(lut_resolution_3d)]
1459 fargs = ['--format',
1464 '%s for %s Flame.3dl' % (odt_name, input_space))]
1465 bake_LUT = Process(description='bake a LUT',
1467 args=(args + fargs))
1470 largs = ['--format',
1475 '%s for %s Lustre.3dl' % (odt_name, input_space))]
1476 bake_LUT = Process(description='bake a LUT',
1478 args=(args + largs))
1482 for input_space in ['ACEScg', 'ACES2065-1']:
1483 args = ['--iconfig', config_path,
1485 '--inputspace', input_space]
1486 args += ['--outputspace', '%s' % odt_name]
1487 args += ['--description',
1488 '%s - %s for %s data' % (
1489 odt_prefix, odt_name, input_space)]
1490 if input_space == 'ACEScg':
1491 lin_shaper_name = '%s - AP1' % shaper_name
1493 lin_shaper_name = shaper_name
1494 args += ['--shaperspace', lin_shaper_name,
1495 '--shapersize', str(lut_resolution_shaper)]
1497 args += ['--cubesize', str(lut_resolution_3d)]
1499 margs = ['--format',
1504 '%s for %s Maya.csp' % (odt_name, input_space))]
1505 bake_LUT = Process(description='bake a LUT',
1507 args=(args + margs))
1510 hargs = ['--format',
1515 '%s for %s Houdini.lut' % (odt_name, input_space))]
1516 bake_LUT = Process(description='bake a LUT',
1518 args=(args + hargs))
1522 def create_config_dir(config_directory, bake_secondary_LUTs):
1529 Parameter description.
1534 Return value description.
1537 dirs = [config_directory, os.path.join(config_directory, 'luts')]
1538 if bake_secondary_LUTs:
1539 dirs.extend([os.path.join(config_directory, 'baked'),
1540 os.path.join(config_directory, 'baked', 'flame'),
1541 os.path.join(config_directory, 'baked', 'photoshop'),
1542 os.path.join(config_directory, 'baked', 'houdini'),
1543 os.path.join(config_directory, 'baked', 'lustre'),
1544 os.path.join(config_directory, 'baked', 'maya')])
1547 not os.path.exists(d) and os.mkdir(d)
1550 def get_transform_info(ctl_transform):
1557 Parameter description.
1562 Return value description.
1565 with open(ctl_transform, 'rb') as fp:
1566 lines = fp.readlines()
1568 # Retrieving the *transform ID* and *User Name*.
1569 transform_id = lines[1][3:].split('<')[1].split('>')[1].strip()
1570 transform_user_name = '-'.join(
1571 lines[2][3:].split('<')[1].split('>')[1].split('-')[1:]).strip()
1572 transform_user_name_prefix = (
1573 lines[2][3:].split('<')[1].split('>')[1].split('-')[0].strip())
1575 return transform_id, transform_user_name, transform_user_name_prefix
1578 def get_ODT_info(aces_CTL_directory):
1582 For versions after WGR9.
1587 Parameter description.
1592 Return value description.
1595 # TODO: Investigate usage of *files_walker* definition here.
1596 # Credit to *Alex Fry* for the original approach here.
1597 odt_dir = os.path.join(aces_CTL_directory, 'odt')
1599 for dir_name, subdir_list, file_list in os.walk(odt_dir):
1600 for fname in file_list:
1601 all_odt.append((os.path.join(dir_name, fname)))
1603 odt_CTLs = [x for x in all_odt if
1604 ('InvODT' not in x) and (os.path.split(x)[-1][0] != '.')]
1608 for odt_CTL in odt_CTLs:
1609 odt_tokens = os.path.split(odt_CTL)
1611 # Handling nested directories.
1612 odt_path_tokens = os.path.split(odt_tokens[-2])
1613 odt_dir = odt_path_tokens[-1]
1614 while odt_path_tokens[-2][-3:] != 'odt':
1615 odt_path_tokens = os.path.split(odt_path_tokens[-2])
1616 odt_dir = os.path.join(odt_path_tokens[-1], odt_dir)
1618 # Building full name,
1619 transform_CTL = odt_tokens[-1]
1620 odt_name = string.join(transform_CTL.split('.')[1:-1], '.')
1622 # Finding id, user name and user name prefix.
1624 transform_user_name,
1625 transform_user_name_prefix) = get_transform_info(
1626 os.path.join(aces_CTL_directory, 'odt', odt_dir, transform_CTL))
1629 transform_CTL_inverse = 'InvODT.%s.ctl' % odt_name
1630 if not os.path.exists(
1631 os.path.join(odt_tokens[-2], transform_CTL_inverse)):
1632 transform_CTL_inverse = None
1634 # Add to list of ODTs
1636 odts[odt_name]['transformCTL'] = os.path.join(odt_dir, transform_CTL)
1637 if transform_CTL_inverse is not None:
1638 odts[odt_name]['transformCTLInverse'] = os.path.join(
1639 odt_dir, transform_CTL_inverse)
1641 odts[odt_name]['transformID'] = transform_ID
1642 odts[odt_name]['transformUserNamePrefix'] = transform_user_name_prefix
1643 odts[odt_name]['transformUserName'] = transform_user_name
1645 forward_CTL = odts[odt_name]['transformCTL']
1647 print('ODT : %s' % odt_name)
1648 print('\tTransform ID : %s' % transform_ID)
1649 print('\tTransform User Name Prefix : %s' % transform_user_name_prefix)
1650 print('\tTransform User Name : %s' % transform_user_name)
1651 print('\tForward ctl : %s' % forward_CTL)
1652 if 'transformCTLInverse' in odts[odt_name]:
1653 inverse_CTL = odts[odt_name]['transformCTLInverse']
1654 print('\tInverse ctl : %s' % inverse_CTL)
1656 print('\tInverse ctl : %s' % 'None')
1663 def get_LMT_info(aces_CTL_directory):
1667 For versions after WGR9.
1672 Parameter description.
1677 Return value description.
1680 # TODO: Investigate refactoring with previous definition.
1682 # Credit to Alex Fry for the original approach here
1683 lmt_dir = os.path.join(aces_CTL_directory, 'lmt')
1685 for dir_name, subdir_list, file_list in os.walk(lmt_dir):
1686 for fname in file_list:
1687 all_lmt.append((os.path.join(dir_name, fname)))
1689 lmt_CTLs = [x for x in all_lmt if
1690 ('InvLMT' not in x) and ('README' not in x) and (
1691 os.path.split(x)[-1][0] != '.')]
1695 for lmt_CTL in lmt_CTLs:
1696 lmt_tokens = os.path.split(lmt_CTL)
1698 # Handlimg nested directories.
1699 lmt_path_tokens = os.path.split(lmt_tokens[-2])
1700 lmt_dir = lmt_path_tokens[-1]
1701 while lmt_path_tokens[-2][-3:] != 'ctl':
1702 lmt_path_tokens = os.path.split(lmt_path_tokens[-2])
1703 lmt_dir = os.path.join(lmt_path_tokens[-1], lmt_dir)
1705 # Building full name.
1706 transform_CTL = lmt_tokens[-1]
1707 lmt_name = string.join(transform_CTL.split('.')[1:-1], '.')
1709 # Finding id, user name and user name prefix.
1711 transform_user_name,
1712 transform_user_name_prefix) = get_transform_info(
1713 os.path.join(aces_CTL_directory, lmt_dir, transform_CTL))
1716 transform_CTL_inverse = 'InvLMT.%s.ctl' % lmt_name
1717 if not os.path.exists(
1718 os.path.join(lmt_tokens[-2], transform_CTL_inverse)):
1719 transform_CTL_inverse = None
1722 lmts[lmt_name]['transformCTL'] = os.path.join(lmt_dir, transform_CTL)
1723 if transform_CTL_inverse is not None:
1724 lmts[lmt_name]['transformCTLInverse'] = os.path.join(
1725 lmt_dir, transform_CTL_inverse)
1727 lmts[lmt_name]['transformID'] = transform_ID
1728 lmts[lmt_name]['transformUserNamePrefix'] = transform_user_name_prefix
1729 lmts[lmt_name]['transformUserName'] = transform_user_name
1731 forward_CTL = lmts[lmt_name]['transformCTL']
1733 print('LMT : %s' % lmt_name)
1734 print('\tTransform ID : %s' % transform_ID)
1735 print('\tTransform User Name Prefix : %s' % transform_user_name_prefix)
1736 print('\tTransform User Name : %s' % transform_user_name)
1737 print('\t Forward ctl : %s' % forward_CTL)
1738 if 'transformCTLInverse' in lmts[lmt_name]:
1739 inverse_CTL = lmts[lmt_name]['transformCTLInverse']
1740 print('\t Inverse ctl : %s' % inverse_CTL)
1742 print('\t Inverse ctl : %s' % 'None')
1749 def create_ACES_config(aces_CTL_directory,
1751 lut_resolution_1d=4096,
1752 lut_resolution_3d=64,
1753 bake_secondary_LUTs=True,
1756 Creates the ACES configuration.
1761 Parameter description.
1766 Return value description.
1769 odt_info = get_ODT_info(aces_CTL_directory)
1770 lmt_info = get_LMT_info(aces_CTL_directory)
1772 create_config_dir(config_directory, bake_secondary_LUTs)
1774 lut_directory = os.path.join(config_directory, 'luts')
1775 shaper_name = 'Output Shaper'
1776 config_data = generate_LUTs(odt_info,
1785 print('Creating "generic" config')
1786 config = create_config(config_data)
1789 write_config(config,
1790 os.path.join(config_directory, 'config.ocio'))
1792 print('Creating "Nuke" config')
1793 nuke_config = create_config(config_data, nuke=True)
1796 write_config(nuke_config,
1797 os.path.join(config_directory, 'nuke_config.ocio'))
1799 if bake_secondary_LUTs:
1800 generate_baked_LUTs(odt_info,
1802 os.path.join(config_directory, 'baked'),
1803 os.path.join(config_directory, 'config.ocio'),
1818 Parameter description.
1823 Return value description.
1828 p = optparse.OptionParser(description='An OCIO config generation script',
1829 prog='createACESConfig',
1830 version='createACESConfig 0.1',
1831 usage='%prog [options]')
1832 p.add_option('--acesCTLDir', '-a', default=os.environ.get(
1833 ACES_OCIO_CTL_DIRECTORY_ENVIRON, None))
1834 p.add_option('--configDir', '-c', default=os.environ.get(
1835 ACES_OCIO_CONFIGURATION_DIRECTORY_ENVIRON, None))
1836 p.add_option('--lutResolution1d', default=4096)
1837 p.add_option('--lutResolution3d', default=64)
1838 p.add_option('--dontBakeSecondaryLUTs', action='store_true')
1839 p.add_option('--keepTempImages', action='store_true')
1841 options, arguments = p.parse_args()
1843 aces_CTL_directory = options.acesCTLDir
1844 config_directory = options.configDir
1845 lut_resolution_1d = int(options.lutResolution1d)
1846 lut_resolution_3d = int(options.lutResolution3d)
1847 bake_secondary_LUTs = not options.dontBakeSecondaryLUTs
1848 cleanup_temp_images = not options.keepTempImages
1850 # TODO: Investigate the following statements.
1852 args_start = sys.argv.index('--') + 1
1853 args = sys.argv[args_start:]
1855 args_start = len(sys.argv) + 1
1858 print('command line : \n%s\n' % ' '.join(sys.argv))
1860 assert aces_CTL_directory is not None, (
1861 'process: No "{0}" environment variable defined or no "ACES CTL" '
1862 'directory specified'.format(
1863 ACES_OCIO_CTL_DIRECTORY_ENVIRON))
1865 assert config_directory is not None, (
1866 'process: No "{0}" environment variable defined or no configuration '
1867 'directory specified'.format(
1868 ACES_OCIO_CONFIGURATION_DIRECTORY_ENVIRON))
1870 return create_ACES_config(aces_CTL_directory,
1874 bake_secondary_LUTs,
1875 cleanup_temp_images)
1878 if __name__ == '__main__':