2 # -*- coding: utf-8 -*-
5 Implements support for *ACES* colorspaces conversions and transfer functions.
15 import PyOpenColorIO as ocio
17 from aces_ocio.generate_lut import (
18 generate_1d_LUT_from_CTL,
19 generate_3d_LUT_from_CTL,
21 from aces_ocio.utilities import (
28 __author__ = 'ACES Developers'
29 __copyright__ = 'Copyright (C) 2014 - 2015 - ACES Developers'
31 __maintainer__ = 'ACES Developers'
32 __email__ = 'aces@oscars.org'
33 __status__ = 'Production'
35 __all__ = ['ACES_AP1_TO_AP0',
44 'create_ACES_RRT_plus_ODT',
52 # -------------------------------------------------------------------------
54 # -------------------------------------------------------------------------
56 # Matrix converting *ACES AP1* primaries to *AP0*.
57 ACES_AP1_TO_AP0 = [0.6954522414, 0.1406786965, 0.1638690622,
58 0.0447945634, 0.8596711185, 0.0955343182,
59 -0.0055258826, 0.0040252103, 1.0015006723]
61 # Matrix converting *ACES AP0* primaries to *XYZ*.
62 ACES_AP0_TO_XYZ = [0.9525523959, 0.0000000000, 0.0000936786,
63 0.3439664498, 0.7281660966, -0.0721325464,
64 0.0000000000, 0.0000000000, 1.0088251844]
66 # -------------------------------------------------------------------------
68 # -------------------------------------------------------------------------
69 def create_ACEScc(aces_CTL_directory,
83 Parameter description.
88 Return value description.
92 cs.description = 'The %s color space' % name
93 cs.aliases = ["acescc_ap1"]
94 cs.equality_group = ''
98 ctls = [os.path.join(aces_CTL_directory,
100 'ACEScsc.ACEScc_to_ACES.a1.0.0.ctl'),
101 # This transform gets back to the *AP1* primaries.
102 # Useful as the 1d LUT is only covering the transfer function.
103 # The primaries switch is covered by the matrix below:
104 os.path.join(aces_CTL_directory,
106 'ACEScsc.ACES_to_ACEScg.a1.0.0.ctl')]
107 lut = '%s_to_ACES.spi1d' % name
111 generate_1d_LUT_from_CTL(
112 os.path.join(lut_directory, lut),
124 cs.to_reference_transforms = []
125 cs.to_reference_transforms.append({
128 'interpolation': 'linear',
129 'direction': 'forward'})
131 # *AP1* primaries to *AP0* primaries.
132 cs.to_reference_transforms.append({
134 'matrix': mat44_from_mat33(ACES_AP1_TO_AP0),
135 'direction': 'forward'})
137 cs.from_reference_transforms = []
141 # -------------------------------------------------------------------------
143 # -------------------------------------------------------------------------
144 def create_ACESproxy(aces_CTL_directory,
155 Parameter description.
160 Return value description.
163 cs = ColorSpace(name)
164 cs.description = 'The %s color space' % name
165 cs.aliases = ["acesproxy_ap1"]
166 cs.equality_group = ''
170 ctls = [os.path.join(aces_CTL_directory,
172 'ACEScsc.ACESproxy10i_to_ACES.a1.0.0.ctl'),
173 # This transform gets back to the *AP1* primaries.
174 # Useful as the 1d LUT is only covering the transfer function.
175 # The primaries switch is covered by the matrix below:
176 os.path.join(aces_CTL_directory,
178 'ACEScsc.ACES_to_ACEScg.a1.0.0.ctl')]
179 lut = '%s_to_aces.spi1d' % name
183 generate_1d_LUT_from_CTL(
184 os.path.join(lut_directory, lut),
194 cs.to_reference_transforms = []
195 cs.to_reference_transforms.append({
198 'interpolation': 'linear',
199 'direction': 'forward'
202 # *AP1* primaries to *AP0* primaries.
203 cs.to_reference_transforms.append({
205 'matrix': mat44_from_mat33(ACES_AP1_TO_AP0),
206 'direction': 'forward'
209 cs.from_reference_transforms = []
213 # -------------------------------------------------------------------------
215 # -------------------------------------------------------------------------
216 def create_ACEScg(aces_CTL_directory,
227 Parameter description.
232 Return value description.
235 cs = ColorSpace(name)
236 cs.description = 'The %s color space' % name
237 cs.aliases = ["lin_ap1"]
238 cs.equality_group = ''
242 cs.to_reference_transforms = []
244 # *AP1* primaries to *AP0* primaries.
245 cs.to_reference_transforms.append({
247 'matrix': mat44_from_mat33(ACES_AP1_TO_AP0),
248 'direction': 'forward'})
250 cs.from_reference_transforms = []
254 # -------------------------------------------------------------------------
256 # -------------------------------------------------------------------------
257 def create_ADX(lut_directory,
267 Parameter description.
272 Return value description.
275 name = '%s%s' % (name, bit_depth)
276 cs = ColorSpace(name)
277 cs.description = '%s color space - used for film scans' % name
278 cs.aliases = ["adx%s" % str(bit_depth)]
279 cs.equality_group = ''
284 cs.bit_depth = ocio.Constants.BIT_DEPTH_UINT10
285 adx_to_cdd = [1023.0 / 500.0, 0.0, 0.0, 0.0,
286 0.0, 1023.0 / 500.0, 0.0, 0.0,
287 0.0, 0.0, 1023.0 / 500.0, 0.0,
289 offset = [-95.0 / 500.0, -95.0 / 500.0, -95.0 / 500.0, 0.0]
290 elif bit_depth == 16:
291 cs.bit_depth = ocio.Constants.BIT_DEPTH_UINT16
292 adx_to_cdd = [65535.0 / 8000.0, 0.0, 0.0, 0.0,
293 0.0, 65535.0 / 8000.0, 0.0, 0.0,
294 0.0, 0.0, 65535.0 / 8000.0, 0.0,
296 offset = [-1520.0 / 8000.0, -1520.0 / 8000.0, -1520.0 / 8000.0,
299 cs.to_reference_transforms = []
301 # Converting from *ADX* to *Channel-Dependent Density*.
302 cs.to_reference_transforms.append({
304 'matrix': adx_to_cdd,
306 'direction': 'forward'})
308 # Convert from Channel-Dependent Density to Channel-Independent Density
309 cs.to_reference_transforms.append({
311 'matrix': [0.75573, 0.22197, 0.02230, 0,
312 0.05901, 0.96928, -0.02829, 0,
313 0.16134, 0.07406, 0.76460, 0,
315 'direction': 'forward'})
317 # Copied from *Alex Fry*'s *adx_cid_to_rle.py*
318 def create_CID_to_RLE_LUT():
320 def interpolate_1D(x, xp, fp):
321 return numpy.interp(x, xp, fp)
323 LUT_1D_xp = [-0.190000000000000,
335 LUT_1D_fp = [-6.000000000000000,
347 REF_PT = ((7120.0 - 1520.0) / 8000.0 * (100.0 / 55.0) -
348 math.log(0.18, 10.0))
352 return interpolate_1D(x, LUT_1D_xp, LUT_1D_fp)
353 return (100.0 / 55.0) * x - REF_PT
355 def fit(value, from_min, from_max, to_min, to_max):
356 if from_min == from_max:
357 raise ValueError('from_min == from_max')
358 return (value - from_min) / (from_max - from_min) * (
359 to_max - to_min) + to_min
361 NUM_SAMPLES = 2 ** 12
364 for i in xrange(NUM_SAMPLES):
365 x = i / (NUM_SAMPLES - 1.0)
366 x = fit(x, 0.0, 1.0, RANGE[0], RANGE[1])
367 data.append(cid_to_rle(x))
369 lut = 'ADX_CID_to_RLE.spi1d'
370 write_SPI_1d(os.path.join(lut_directory, lut),
378 # Converting *Channel Independent Density* values to
379 # *Relative Log Exposure* values.
380 lut = create_CID_to_RLE_LUT()
381 cs.to_reference_transforms.append({
384 'interpolation': 'linear',
385 'direction': 'forward'})
387 # Converting *Relative Log Exposure* values to
388 # *Relative Exposure* values.
389 cs.to_reference_transforms.append({
392 'direction': 'inverse'})
394 # Convert *Relative Exposure* values to *ACES* values.
395 cs.to_reference_transforms.append({
397 'matrix': [0.72286, 0.12630, 0.15084, 0,
398 0.11923, 0.76418, 0.11659, 0,
399 0.01427, 0.08213, 0.90359, 0,
401 'direction': 'forward'})
403 cs.from_reference_transforms = []
407 # -------------------------------------------------------------------------
408 # *Generic Log Transform*
409 # -------------------------------------------------------------------------
410 def create_generic_log(aces_CTL_directory,
428 Parameter description.
433 Return value description.
436 cs = ColorSpace(name)
437 cs.description = 'The %s color space' % name
439 cs.equality_group = name
440 cs.family = 'Utility'
443 ctls = [os.path.join(
446 'ACESlib.OCIO_shaper_log2_to_lin_param.a1.0.0.ctl')]
447 lut = '%s_to_aces.spi1d' % name
451 generate_1d_LUT_from_CTL(
452 os.path.join(lut_directory, lut),
458 {'middleGrey': middle_grey,
459 'minExposure': min_exposure,
460 'maxExposure': max_exposure},
466 cs.to_reference_transforms = []
467 cs.to_reference_transforms.append({
470 'interpolation': 'linear',
471 'direction': 'forward'})
473 cs.from_reference_transforms = []
477 # -------------------------------------------------------------------------
479 # -------------------------------------------------------------------------
480 def create_ACES_LMT(lmt_name,
485 lut_resolution_1d=1024,
486 lut_resolution_3d=64,
495 Parameter description.
500 Return value description.
503 cs = ColorSpace('%s' % lmt_name)
504 cs.description = 'The ACES Look Transform: %s' % lmt_name
506 cs.equality_group = ''
510 pprint.pprint(lmt_values)
512 # Generating the *shaper* transform.
515 shaper_from_ACES_CTL,
517 shaper_params) = shaper_info
519 shaper_lut = '%s_to_aces.spi1d' % shaper_name
520 if not os.path.exists(os.path.join(lut_directory, shaper_lut)):
521 ctls = [shaper_to_ACES_CTL % aces_CTL_directory]
523 shaper_lut = sanitize(shaper_lut)
525 generate_1d_LUT_from_CTL(
526 os.path.join(lut_directory, shaper_lut),
530 1.0 / shaper_input_scale,
536 shaper_OCIO_transform = {
539 'interpolation': 'linear',
540 'direction': 'inverse'}
542 # Generating the forward transform.
543 cs.from_reference_transforms = []
545 if 'transformCTL' in lmt_values:
546 ctls = [shaper_to_ACES_CTL % aces_CTL_directory,
547 os.path.join(aces_CTL_directory,
548 lmt_values['transformCTL'])]
549 lut = '%s.%s.spi3d' % (shaper_name, lmt_name)
553 generate_3d_LUT_from_CTL(
554 os.path.join(lut_directory, lut),
558 1.0 / shaper_input_scale,
564 cs.from_reference_transforms.append(shaper_OCIO_transform)
565 cs.from_reference_transforms.append({
568 'interpolation': 'tetrahedral',
569 'direction': 'forward'
572 # Generating the inverse transform.
573 cs.to_reference_transforms = []
575 if 'transformCTLInverse' in lmt_values:
576 ctls = [os.path.join(aces_CTL_directory,
577 # TODO: Investigate "odt_values" undeclared
579 odt_values['transformCTLInverse']),
580 shaper_from_ACES_CTL % aces_CTL_directory]
581 lut = 'Inverse.%s.%s.spi3d' % (odt_name, shaper_name)
585 generate_3d_LUT_from_CTL(
586 os.path.join(lut_directory, lut),
596 cs.to_reference_transforms.append({
599 'interpolation': 'tetrahedral',
600 'direction': 'forward'})
602 shaper_inverse = shaper_OCIO_transform.copy()
603 shaper_inverse['direction'] = 'forward'
604 cs.to_reference_transforms.append(shaper_inverse)
609 # -------------------------------------------------------------------------
611 # -------------------------------------------------------------------------
612 def create_lmts(aces_CTL_directory,
625 Parameter description.
630 Return value description.
635 # -------------------------------------------------------------------------
637 # -------------------------------------------------------------------------
638 lmt_lut_resolution_1d = max(4096, lut_resolution_1d)
639 lmt_lut_resolution_3d = max(65, lut_resolution_3d)
641 # Defining the *Log 2* shaper.
642 lmt_shaper_name = 'LMT Shaper'
643 lmt_shaper_name_aliases = ['crv_lmtshaper']
646 'minExposure': -10.0,
649 lmt_shaper = create_generic_log(aces_CTL_directory,
651 lmt_lut_resolution_1d,
653 name=lmt_shaper_name,
654 middle_grey=lmt_params['middleGrey'],
655 min_exposure=lmt_params['minExposure'],
656 max_exposure=lmt_params['maxExposure'],
657 aliases=lmt_shaper_name_aliases)
658 colorspaces.append(lmt_shaper)
660 shaper_input_scale_generic_log2 = 1.0
662 # *Log 2* shaper name and *CTL* transforms bundled up.
667 'ACESlib.OCIO_shaper_log2_to_lin_param.a1.0.0.ctl'),
670 'ACESlib.OCIO_shaper_lin_to_log2_param.a1.0.0.ctl'),
671 shaper_input_scale_generic_log2,
674 sorted_LMTs = sorted(lmt_info.iteritems(), key=lambda x: x[1])
676 for lmt in sorted_LMTs:
677 (lmt_name, lmt_values) = lmt
678 lmt_aliases = ["look_%s" % compact(lmt_values['transformUserName'])]
679 cs = create_ACES_LMT(
680 lmt_values['transformUserName'],
685 lmt_lut_resolution_1d,
686 lmt_lut_resolution_3d,
689 colorspaces.append(cs)
694 # -------------------------------------------------------------------------
695 # *ACES RRT* with supplied *ODT*.
696 # -------------------------------------------------------------------------
697 def create_ACES_RRT_plus_ODT(odt_name,
702 lut_resolution_1d=1024,
703 lut_resolution_3d=64,
712 Parameter description.
717 Return value description.
720 cs = ColorSpace('%s' % odt_name)
721 cs.description = '%s - %s Output Transform' % (
722 odt_values['transformUserNamePrefix'], odt_name)
724 cs.equality_group = ''
728 pprint.pprint(odt_values)
730 # Generating the *shaper* transform.
733 shaper_from_ACES_CTL,
735 shaper_params) = shaper_info
737 if 'legalRange' in odt_values:
738 shaper_params['legalRange'] = odt_values['legalRange']
740 shaper_params['legalRange'] = 0
742 shaper_lut = '%s_to_aces.spi1d' % shaper_name
743 if not os.path.exists(os.path.join(lut_directory, shaper_lut)):
744 ctls = [shaper_to_ACES_CTL % aces_CTL_directory]
746 shaper_lut = sanitize(shaper_lut)
748 generate_1d_LUT_from_CTL(
749 os.path.join(lut_directory, shaper_lut),
753 1.0 / shaper_input_scale,
759 shaper_OCIO_transform = {
762 'interpolation': 'linear',
763 'direction': 'inverse'}
765 # Generating the *forward* transform.
766 cs.from_reference_transforms = []
768 if 'transformLUT' in odt_values:
769 transform_LUT_file_name = os.path.basename(
770 odt_values['transformLUT'])
771 lut = os.path.join(lut_directory, transform_LUT_file_name)
772 shutil.copy(odt_values['transformLUT'], lut)
774 cs.from_reference_transforms.append(shaper_OCIO_transform)
775 cs.from_reference_transforms.append({
777 'path': transform_LUT_file_name,
778 'interpolation': 'tetrahedral',
779 'direction': 'forward'})
780 elif 'transformCTL' in odt_values:
782 shaper_to_ACES_CTL % aces_CTL_directory,
783 os.path.join(aces_CTL_directory,
786 os.path.join(aces_CTL_directory,
788 odt_values['transformCTL'])]
789 lut = '%s.RRT.a1.0.0.%s.spi3d' % (shaper_name, odt_name)
793 generate_3d_LUT_from_CTL(
794 os.path.join(lut_directory, lut),
799 1.0 / shaper_input_scale,
805 cs.from_reference_transforms.append(shaper_OCIO_transform)
806 cs.from_reference_transforms.append({
809 'interpolation': 'tetrahedral',
810 'direction': 'forward'})
812 # Generating the *inverse* transform.
813 cs.to_reference_transforms = []
815 if 'transformLUTInverse' in odt_values:
816 transform_LUT_inverse_file_name = os.path.basename(
817 odt_values['transformLUTInverse'])
818 lut = os.path.join(lut_directory, transform_LUT_inverse_file_name)
819 shutil.copy(odt_values['transformLUTInverse'], lut)
821 cs.to_reference_transforms.append({
823 'path': transform_LUT_inverse_file_name,
824 'interpolation': 'tetrahedral',
825 'direction': 'forward'})
827 shaper_inverse = shaper_OCIO_transform.copy()
828 shaper_inverse['direction'] = 'forward'
829 cs.to_reference_transforms.append(shaper_inverse)
830 elif 'transformCTLInverse' in odt_values:
831 ctls = [os.path.join(aces_CTL_directory,
833 odt_values['transformCTLInverse']),
834 os.path.join(aces_CTL_directory,
836 'InvRRT.a1.0.0.ctl'),
837 shaper_from_ACES_CTL % aces_CTL_directory]
838 lut = 'InvRRT.a1.0.0.%s.%s.spi3d' % (odt_name, shaper_name)
842 generate_3d_LUT_from_CTL(
843 os.path.join(lut_directory, lut),
854 cs.to_reference_transforms.append({
857 'interpolation': 'tetrahedral',
858 'direction': 'forward'})
860 shaper_inverse = shaper_OCIO_transform.copy()
861 shaper_inverse['direction'] = 'forward'
862 cs.to_reference_transforms.append(shaper_inverse)
867 # -------------------------------------------------------------------------
869 # -------------------------------------------------------------------------
870 def create_odts(aces_CTL_directory,
877 linear_display_space,
885 Parameter description.
890 Return value description.
896 # -------------------------------------------------------------------------
897 # *RRT / ODT* Shaper Options
898 # -------------------------------------------------------------------------
901 # Defining the *Log 2* shaper.
902 log2_shaper_name = shaper_name
903 log2_shaper_name_aliases = ["crv_%s" % compact(shaper_name)]
909 log2_shaper = create_generic_log(
914 name=log2_shaper_name,
915 middle_grey=log2_params['middleGrey'],
916 min_exposure=log2_params['minExposure'],
917 max_exposure=log2_params['maxExposure'],
918 aliases=log2_shaper_name_aliases)
919 colorspaces.append(log2_shaper)
921 shaper_input_scale_generic_log2 = 1.0
923 # *Log 2* shaper name and *CTL* transforms bundled up.
928 'ACESlib.OCIO_shaper_log2_to_lin_param.a1.0.0.ctl'),
931 'ACESlib.OCIO_shaper_lin_to_log2_param.a1.0.0.ctl'),
932 shaper_input_scale_generic_log2,
935 shaper_data[log2_shaper_name] = log2_shaper_data
937 # Shaper that also includes the AP1 primaries.
938 # Needed for some LUT baking steps.
939 log2_shaper_api1_name_aliases = ["%s_ap1" % compact(shaper_name)]
940 log2_shaper_AP1 = create_generic_log(
945 name=log2_shaper_name,
946 middle_grey=log2_params['middleGrey'],
947 min_exposure=log2_params['minExposure'],
948 max_exposure=log2_params['maxExposure'],
949 aliases=log2_shaper_api1_name_aliases)
950 log2_shaper_AP1.name = '%s - AP1' % log2_shaper_AP1.name
952 # *AP1* primaries to *AP0* primaries.
953 log2_shaper_AP1.to_reference_transforms.append({
955 'matrix': mat44_from_mat33(ACES_AP1_TO_AP0),
956 'direction': 'forward'
958 colorspaces.append(log2_shaper_AP1)
960 rrt_shaper = log2_shaper_data
962 # *RRT + ODT* combinations.
963 sorted_odts = sorted(odt_info.iteritems(), key=lambda x: x[1])
965 for odt in sorted_odts:
966 (odt_name, odt_values) = odt
968 # Generating legal range transform for *ODTs* that can generate
969 # either *legal* or *full* output.
970 if odt_values['transformHasFullLegalSwitch']:
971 odt_name_legal = '%s - Legal' % odt_values['transformUserName']
973 odt_name_legal = odt_values['transformUserName']
975 odt_legal = odt_values.copy()
976 odt_legal['legalRange'] = 1
978 odt_aliases = ["out_%s" % compact(odt_name_legal)]
980 cs = create_ACES_RRT_plus_ODT(
990 colorspaces.append(cs)
992 displays[odt_name_legal] = {
993 'Linear': linear_display_space,
994 'Log': log_display_space,
995 'Output Transform': cs}
998 # Generating full range transform for *ODTs* that can generate
999 # either *legal* or *full* output.
1000 if odt_values['transformHasFullLegalSwitch']:
1001 print('Generating full range ODT for %s' % odt_name)
1003 odt_name_full = '%s - Full' % odt_values['transformUserName']
1004 odt_full = odt_values.copy()
1005 odt_full['legalRange'] = 0
1007 odt_full_aliases = ["out_%s" % compact(odt_name_full)]
1009 cs_full = create_ACES_RRT_plus_ODT(
1019 colorspaces.append(cs_full)
1021 displays[odt_name_full] = {
1022 'Linear': linear_display_space,
1023 'Log': log_display_space,
1024 'Output Transform': cs_full}
1026 return (colorspaces, displays)
1036 Parameter description.
1041 Return value description.
1044 # Defining the reference colorspace.
1045 ACES = ColorSpace('ACES2065-1')
1046 ACES.description = (
1047 'The Academy Color Encoding System reference color space')
1048 ACES.equality_group = ''
1049 ACES.aliases = ["lin_ap0", "aces"]
1050 ACES.family = 'ACES'
1051 ACES.is_data = False
1052 ACES.allocation_type = ocio.Constants.ALLOCATION_LG2
1053 ACES.allocation_vars = [-15, 6]
1058 def get_transform_info(ctl_transform):
1065 Parameter description.
1070 Return value description.
1073 with open(ctl_transform, 'rb') as fp:
1074 lines = fp.readlines()
1076 # Retrieving the *transform ID* and *User Name*.
1077 transform_id = lines[1][3:].split('<')[1].split('>')[1].strip()
1078 transform_user_name = '-'.join(
1079 lines[2][3:].split('<')[1].split('>')[1].split('-')[1:]).strip()
1080 transform_user_name_prefix = (
1081 lines[2][3:].split('<')[1].split('>')[1].split('-')[0].strip())
1083 # Figuring out if this transform has options for processing full and legal range
1084 transform_full_legal_switch = False
1086 if line.strip() == "input varying int legalRange = 0":
1087 # print( "%s has legal range flag" % transform_user_name)
1088 transform_full_legal_switch = True
1091 return (transform_id, transform_user_name, transform_user_name_prefix,
1092 transform_full_legal_switch)
1095 def get_ODT_info(aces_CTL_directory):
1099 For versions after WGR9.
1104 Parameter description.
1109 Return value description.
1112 # TODO: Investigate usage of *files_walker* definition here.
1113 # Credit to *Alex Fry* for the original approach here.
1114 odt_dir = os.path.join(aces_CTL_directory, 'odt')
1116 for dir_name, subdir_list, file_list in os.walk(odt_dir):
1117 for fname in file_list:
1118 all_odt.append((os.path.join(dir_name, fname)))
1120 odt_CTLs = [x for x in all_odt if
1121 ('InvODT' not in x) and (os.path.split(x)[-1][0] != '.')]
1125 for odt_CTL in odt_CTLs:
1126 odt_tokens = os.path.split(odt_CTL)
1128 # Handling nested directories.
1129 odt_path_tokens = os.path.split(odt_tokens[-2])
1130 odt_dir = odt_path_tokens[-1]
1131 while odt_path_tokens[-2][-3:] != 'odt':
1132 odt_path_tokens = os.path.split(odt_path_tokens[-2])
1133 odt_dir = os.path.join(odt_path_tokens[-1], odt_dir)
1135 # Building full name,
1136 transform_CTL = odt_tokens[-1]
1137 odt_name = string.join(transform_CTL.split('.')[1:-1], '.')
1139 # Finding id, user name and user name prefix.
1141 transform_user_name,
1142 transform_user_name_prefix,
1143 transform_full_legal_switch) = get_transform_info(
1144 os.path.join(aces_CTL_directory, 'odt', odt_dir, transform_CTL))
1147 transform_CTL_inverse = 'InvODT.%s.ctl' % odt_name
1148 if not os.path.exists(
1149 os.path.join(odt_tokens[-2], transform_CTL_inverse)):
1150 transform_CTL_inverse = None
1152 # Add to list of ODTs
1154 odts[odt_name]['transformCTL'] = os.path.join(odt_dir, transform_CTL)
1155 if transform_CTL_inverse is not None:
1156 odts[odt_name]['transformCTLInverse'] = os.path.join(
1157 odt_dir, transform_CTL_inverse)
1159 odts[odt_name]['transformID'] = transform_ID
1160 odts[odt_name]['transformUserNamePrefix'] = transform_user_name_prefix
1161 odts[odt_name]['transformUserName'] = transform_user_name
1163 'transformHasFullLegalSwitch'] = transform_full_legal_switch
1165 forward_CTL = odts[odt_name]['transformCTL']
1167 print('ODT : %s' % odt_name)
1168 print('\tTransform ID : %s' % transform_ID)
1169 print('\tTransform User Name Prefix : %s' % transform_user_name_prefix)
1170 print('\tTransform User Name : %s' % transform_user_name)
1172 '\tHas Full / Legal Switch : %s' % transform_full_legal_switch)
1173 print('\tForward ctl : %s' % forward_CTL)
1174 if 'transformCTLInverse' in odts[odt_name]:
1175 inverse_CTL = odts[odt_name]['transformCTLInverse']
1176 print('\tInverse ctl : %s' % inverse_CTL)
1178 print('\tInverse ctl : %s' % 'None')
1185 def get_LMT_info(aces_CTL_directory):
1189 For versions after WGR9.
1194 Parameter description.
1199 Return value description.
1202 # TODO: Investigate refactoring with previous definition.
1204 # Credit to Alex Fry for the original approach here
1205 lmt_dir = os.path.join(aces_CTL_directory, 'lmt')
1207 for dir_name, subdir_list, file_list in os.walk(lmt_dir):
1208 for fname in file_list:
1209 all_lmt.append((os.path.join(dir_name, fname)))
1211 lmt_CTLs = [x for x in all_lmt if
1212 ('InvLMT' not in x) and ('README' not in x) and (
1213 os.path.split(x)[-1][0] != '.')]
1217 for lmt_CTL in lmt_CTLs:
1218 lmt_tokens = os.path.split(lmt_CTL)
1220 # Handlimg nested directories.
1221 lmt_path_tokens = os.path.split(lmt_tokens[-2])
1222 lmt_dir = lmt_path_tokens[-1]
1223 while lmt_path_tokens[-2][-3:] != 'ctl':
1224 lmt_path_tokens = os.path.split(lmt_path_tokens[-2])
1225 lmt_dir = os.path.join(lmt_path_tokens[-1], lmt_dir)
1227 # Building full name.
1228 transform_CTL = lmt_tokens[-1]
1229 lmt_name = string.join(transform_CTL.split('.')[1:-1], '.')
1231 # Finding id, user name and user name prefix.
1233 transform_user_name,
1234 transform_user_name_prefix,
1235 transform_full_legal_switch) = get_transform_info(
1236 os.path.join(aces_CTL_directory, lmt_dir, transform_CTL))
1239 transform_CTL_inverse = 'InvLMT.%s.ctl' % lmt_name
1240 if not os.path.exists(
1241 os.path.join(lmt_tokens[-2], transform_CTL_inverse)):
1242 transform_CTL_inverse = None
1245 lmts[lmt_name]['transformCTL'] = os.path.join(lmt_dir, transform_CTL)
1246 if transform_CTL_inverse is not None:
1247 lmts[lmt_name]['transformCTLInverse'] = os.path.join(
1248 lmt_dir, transform_CTL_inverse)
1250 lmts[lmt_name]['transformID'] = transform_ID
1251 lmts[lmt_name]['transformUserNamePrefix'] = transform_user_name_prefix
1252 lmts[lmt_name]['transformUserName'] = transform_user_name
1254 forward_CTL = lmts[lmt_name]['transformCTL']
1256 print('LMT : %s' % lmt_name)
1257 print('\tTransform ID : %s' % transform_ID)
1258 print('\tTransform User Name Prefix : %s' % transform_user_name_prefix)
1259 print('\tTransform User Name : %s' % transform_user_name)
1260 print('\t Forward ctl : %s' % forward_CTL)
1261 if 'transformCTLInverse' in lmts[lmt_name]:
1262 inverse_CTL = lmts[lmt_name]['transformCTLInverse']
1263 print('\t Inverse ctl : %s' % inverse_CTL)
1265 print('\t Inverse ctl : %s' % 'None')
1272 def create_colorspaces(aces_CTL_directory,
1281 Generates the colorspace conversions.
1286 Parameter description.
1291 Return value description.
1296 ACES = create_aces()
1298 ACEScc = create_ACEScc(aces_CTL_directory, lut_directory,
1299 lut_resolution_1d, cleanup)
1300 colorspaces.append(ACEScc)
1302 ACESproxy = create_ACESproxy(aces_CTL_directory, lut_directory,
1303 lut_resolution_1d, cleanup)
1304 colorspaces.append(ACESproxy)
1306 ACEScg = create_ACEScg(aces_CTL_directory, lut_directory,
1307 lut_resolution_1d, cleanup)
1308 colorspaces.append(ACEScg)
1310 ADX10 = create_ADX(lut_directory, lut_resolution_1d, bit_depth=10)
1311 colorspaces.append(ADX10)
1313 ADX16 = create_ADX(lut_directory, lut_resolution_1d, bit_depth=16)
1314 colorspaces.append(ADX16)
1316 lmts = create_lmts(aces_CTL_directory,
1323 colorspaces.extend(lmts)
1325 odts, displays = create_odts(aces_CTL_directory,
1334 colorspaces.extend(odts)
1336 return ACES, colorspaces, displays, ACEScc