2 # -*- coding: utf-8 -*-
5 Implements support for *ACES* colorspaces conversions and transfer functions.
8 from __future__ import division
17 import PyOpenColorIO as ocio
19 from aces_ocio.generate_lut import (
20 generate_1d_LUT_from_CTL,
21 generate_3d_LUT_from_CTL,
23 from aces_ocio.utilities import (
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_AP1_TO_AP0',
44 'create_ACES_RRT_plus_ODT',
53 # Matrix converting *ACES AP1* primaries to *ACES AP0*.
54 ACES_AP1_TO_AP0 = [0.6954522414, 0.1406786965, 0.1638690622,
55 0.0447945634, 0.8596711185, 0.0955343182,
56 -0.0055258826, 0.0040252103, 1.0015006723]
58 # Matrix converting *ACES AP0* primaries to *ACES AP1*.
59 ACES_AP0_TO_AP1 = [1.4514393161, -0.2365107469, -0.2149285693,
60 -0.0765537734, 1.1762296998, -0.0996759264,
61 0.0083161484, -0.0060324498, 0.9977163014]
63 # Matrix converting *ACES AP0* primaries to *XYZ*.
64 ACES_AP0_TO_XYZ = [0.9525523959, 0.0000000000, 0.0000936786,
65 0.3439664498, 0.7281660966, -0.0721325464,
66 0.0000000000, 0.0000000000, 1.0088251844]
68 # Matrix converting *ACES AP0* primaries to *XYZ*.
69 ACES_XYZ_TO_AP0 = [1.0498110175, 0.0000000000, -0.0000974845,
70 -0.4959030231, 1.3733130458, 0.0982400361,
71 0.0000000000, 0.0000000000, 0.9912520182]
81 Parameter description.
86 Return value description.
89 # Defining the reference colorspace.
90 aces2065_1 = ColorSpace('ACES2065-1')
91 aces2065_1.description = (
92 'The Academy Color Encoding System reference color space')
93 aces2065_1.equality_group = ''
94 aces2065_1.aliases = ['lin_ap0', 'aces']
95 aces2065_1.family = 'ACES'
96 aces2065_1.is_data = False
97 aces2065_1.allocation_type = ocio.Constants.ALLOCATION_LG2
98 aces2065_1.allocation_vars = [-8, 5, 0.00390625]
103 def create_ACEScc(aces_ctl_directory,
112 Creates the *ACEScc* colorspace.
117 Parameter description.
125 cs = ColorSpace(name)
126 cs.description = 'The %s color space' % name
127 cs.aliases = ['acescc', 'acescc_ap1']
128 cs.equality_group = ''
131 cs.allocation_type = ocio.Constants.ALLOCATION_UNIFORM
132 cs.allocation_vars = [min_value, max_value]
133 cs.aces_transform_id = 'ACEScsc.ACEScc_to_ACES.a1.0.0'
135 ctls = [os.path.join(aces_ctl_directory,
137 'ACEScsc.ACEScc_to_ACES.a1.0.0.ctl'),
138 # This transform gets back to the *AP1* primaries.
139 # Useful as the 1d LUT is only covering the transfer function.
140 # The primaries switch is covered by the matrix below:
141 os.path.join(aces_ctl_directory,
143 'ACEScsc.ACES_to_ACEScg.a1.0.0.ctl')]
144 lut = '%s_to_linear.spi1d' % name
148 generate_1d_LUT_from_CTL(
149 os.path.join(lut_directory, lut),
162 cs.to_reference_transforms = []
163 cs.to_reference_transforms.append({
166 'interpolation': 'linear',
167 'direction': 'forward'})
169 # *AP1* primaries to *AP0* primaries.
170 cs.to_reference_transforms.append({
172 'matrix': mat44_from_mat33(ACES_AP1_TO_AP0),
173 'direction': 'forward'})
175 cs.from_reference_transforms = []
179 def create_ACESproxy(aces_ctl_directory,
185 Creates the *ACESproxy* colorspace.
190 Parameter description.
195 *ACESproxy* colorspace.
198 cs = ColorSpace(name)
199 cs.description = 'The %s color space' % name
200 cs.aliases = ['acesproxy', 'acesproxy_ap1']
201 cs.equality_group = ''
205 cs.aces_transform_id = 'ACEScsc.ACESproxy10i_to_ACES.a1.0.0'
207 ctls = [os.path.join(aces_ctl_directory,
209 'ACEScsc.ACESproxy10i_to_ACES.a1.0.0.ctl'),
210 # This transform gets back to the *AP1* primaries.
211 # Useful as the 1d LUT is only covering the transfer function.
212 # The primaries switch is covered by the matrix below:
213 os.path.join(aces_ctl_directory,
215 'ACEScsc.ACES_to_ACEScg.a1.0.0.ctl')]
216 lut = '%s_to_linear.spi1d' % name
220 generate_1d_LUT_from_CTL(
221 os.path.join(lut_directory, lut),
234 cs.to_reference_transforms = []
235 cs.to_reference_transforms.append({
238 'interpolation': 'linear',
239 'direction': 'forward'})
241 # *AP1* primaries to *AP0* primaries.
242 cs.to_reference_transforms.append({
244 'matrix': mat44_from_mat33(ACES_AP1_TO_AP0),
245 'direction': 'forward'})
247 cs.from_reference_transforms = []
251 # -------------------------------------------------------------------------
253 # -------------------------------------------------------------------------
254 def create_ACEScg(aces_ctl_directory,
260 Creates the *ACEScg* colorspace.
265 Parameter description.
273 cs = ColorSpace(name)
274 cs.description = 'The %s color space' % name
275 cs.aliases = ['acescg', 'lin_ap1']
276 cs.equality_group = ''
279 cs.allocation_type = ocio.Constants.ALLOCATION_LG2
280 cs.allocation_vars = [-8, 5, 0.00390625]
282 cs.aces_transform_id = 'ACEScsc.ACEScg_to_ACES.a1.0.0'
284 cs.to_reference_transforms = []
286 # *AP1* primaries to *AP0* primaries.
287 cs.to_reference_transforms.append({
289 'matrix': mat44_from_mat33(ACES_AP1_TO_AP0),
290 'direction': 'forward'})
292 cs.from_reference_transforms = []
294 # *AP1* primaries to *AP0* primaries.
295 cs.from_reference_transforms.append({
297 'matrix': mat44_from_mat33(ACES_AP0_TO_AP1),
298 'direction': 'forward'})
303 # -------------------------------------------------------------------------
305 # -------------------------------------------------------------------------
306 def create_ADX(lut_directory,
311 Creates the *ADX* colorspace.
316 Parameter description.
324 name = '%s%s' % (name, bit_depth)
325 cs = ColorSpace(name)
326 cs.description = '%s color space - used for film scans' % name
327 cs.aliases = ['adx%s' % str(bit_depth)]
328 cs.equality_group = ''
333 cs.aces_transform_id = 'ACEScsc.ADX10_to_ACES.a1.0.0'
335 cs.bit_depth = ocio.Constants.BIT_DEPTH_UINT10
336 ADX_to_CDD = [1023 / 500, 0, 0, 0,
340 offset = [-95 / 500, -95 / 500, -95 / 500, 0]
341 elif bit_depth == 16:
342 cs.aces_transform_id = 'ACEScsc.ADX16_to_ACES.a1.0.0'
344 cs.bit_depth = ocio.Constants.BIT_DEPTH_UINT16
345 ADX_to_CDD = [65535 / 8000, 0, 0, 0,
346 0, 65535 / 8000, 0, 0,
347 0, 0, 65535 / 8000, 0,
349 offset = [-1520 / 8000, -1520 / 8000, -1520 / 8000, 0]
351 cs.to_reference_transforms = []
353 # Converting from *ADX* to *Channel-Dependent Density*.
354 cs.to_reference_transforms.append({
356 'matrix': ADX_to_CDD,
358 'direction': 'forward'})
360 # Convert from Channel-Dependent Density to Channel-Independent Density
361 cs.to_reference_transforms.append({
363 'matrix': [0.75573, 0.22197, 0.02230, 0,
364 0.05901, 0.96928, -0.02829, 0,
365 0.16134, 0.07406, 0.76460, 0,
367 'direction': 'forward'})
369 # Copied from *Alex Fry*'s *adx_cid_to_rle.py*
370 def create_CID_to_RLE_LUT():
372 def interpolate_1D(x, xp, fp):
373 return numpy.interp(x, xp, fp)
375 LUT_1D_xp = [-0.190000000000000,
387 LUT_1D_fp = [-6.000000000000000,
399 REF_PT = ((7120 - 1520) / 8000 * (100 / 55) -
404 return interpolate_1D(x, LUT_1D_xp, LUT_1D_fp)
405 return (100 / 55) * x - REF_PT
407 def fit(value, from_min, from_max, to_min, to_max):
408 if from_min == from_max:
409 raise ValueError('from_min == from_max')
410 return (value - from_min) / (from_max - from_min) * (
411 to_max - to_min) + to_min
413 num_samples = 2 ** 12
416 for i in xrange(num_samples):
417 x = i / (num_samples - 1)
418 x = fit(x, 0, 1, domain[0], domain[1])
419 data.append(cid_to_rle(x))
421 lut = 'ADX_CID_to_RLE.spi1d'
422 write_SPI_1d(os.path.join(lut_directory, lut),
430 # Converting *Channel Independent Density* values to
431 # *Relative Log Exposure* values.
432 lut = create_CID_to_RLE_LUT()
433 cs.to_reference_transforms.append({
436 'interpolation': 'linear',
437 'direction': 'forward'})
439 # Converting *Relative Log Exposure* values to
440 # *Relative Exposure* values.
441 cs.to_reference_transforms.append({
444 'direction': 'inverse'})
446 # Convert *Relative Exposure* values to *ACES* values.
447 cs.to_reference_transforms.append({
449 'matrix': [0.72286, 0.12630, 0.15084, 0,
450 0.11923, 0.76418, 0.11659, 0,
451 0.01427, 0.08213, 0.90359, 0,
453 'direction': 'forward'})
455 cs.from_reference_transforms = []
459 # -------------------------------------------------------------------------
460 # *Generic Log Transform*
461 # -------------------------------------------------------------------------
462 def create_generic_log(aces_ctl_directory,
475 Creates the *Generic Log* colorspace.
480 Parameter description.
485 *Generic Log* colorspace.
491 cs = ColorSpace(name)
492 cs.description = 'The %s color space' % name
494 cs.equality_group = name
495 cs.family = 'Utility'
498 ctls = [os.path.join(
501 'ACESlib.Log2_to_Lin_param.a1.0.0.ctl')]
502 lut = '%s_to_linear.spi1d' % name
506 generate_1d_LUT_from_CTL(
507 os.path.join(lut_directory, lut),
513 {'middleGrey': middle_grey,
514 'minExposure': min_exposure,
515 'maxExposure': max_exposure},
522 cs.to_reference_transforms = []
523 cs.to_reference_transforms.append({
526 'interpolation': 'linear',
527 'direction': 'forward'})
529 cs.from_reference_transforms = []
533 # -------------------------------------------------------------------------
534 # *base Dolby PQ Transform*
535 # -------------------------------------------------------------------------
536 def create_dolbypq(aces_CTL_directory,
548 cs = ColorSpace(name)
549 cs.description = 'The %s color space' % name
551 cs.equality_group = name
552 cs.family = 'Utility'
555 ctls = [os.path.join(
558 'ACESlib.DolbyPQ_to_Lin.a1.0.0.ctl')]
559 lut = '%s_to_linear.spi1d' % name
563 generate_1d_LUT_from_CTL(
564 os.path.join(lut_directory, lut),
576 cs.to_reference_transforms = []
577 cs.to_reference_transforms.append({
580 'interpolation': 'linear',
581 'direction': 'forward'})
583 cs.from_reference_transforms = []
587 # -------------------------------------------------------------------------
588 # *Dolby PQ Transform that considers a fixed linear range*
589 # -------------------------------------------------------------------------
590 def create_dolbypq_scaled(aces_CTL_directory,
605 cs = ColorSpace(name)
606 cs.description = 'The %s color space' % name
608 cs.equality_group = name
609 cs.family = 'Utility'
612 ctls = [os.path.join(
615 'ACESlib.DolbyPQ_to_lin_param.a1.0.0.ctl')]
616 lut = '%s_to_linear.spi1d' % name
620 generate_1d_LUT_from_CTL(
621 os.path.join(lut_directory, lut),
627 {'middleGrey': middle_grey,
628 'minExposure': min_exposure,
629 'maxExposure': max_exposure},
635 cs.to_reference_transforms = []
636 cs.to_reference_transforms.append({
639 'interpolation': 'linear',
640 'direction': 'forward'})
642 cs.from_reference_transforms = []
646 # -------------------------------------------------------------------------
648 # -------------------------------------------------------------------------
649 def create_ACES_LMT(lmt_name,
654 lut_resolution_1d=1024,
655 lut_resolution_3d=64,
659 Creates the *ACES LMT* colorspace.
664 Parameter description.
669 *ACES LMT* colorspace.
675 cs = ColorSpace('%s' % lmt_name)
676 cs.description = 'The ACES Look Transform: %s' % lmt_name
678 cs.equality_group = ''
681 cs.allocation_type = ocio.Constants.ALLOCATION_LG2
682 cs.allocation_vars = [-8, 5, 0.00390625]
683 cs.aces_transform_id = lmt_values['transformID']
685 pprint.pprint(lmt_values)
687 # Generating the *shaper* transform.
690 shaper_from_ACES_CTL,
692 shaper_params) = shaper_info
694 # Add the shaper transform
695 shaper_lut = '%s_to_linear.spi1d' % shaper_name
696 shaper_lut = sanitize(shaper_lut)
698 shaper_OCIO_transform = {
701 'interpolation': 'linear',
702 'direction': 'inverse'}
704 # Generating the forward transform.
705 cs.from_reference_transforms = []
707 if 'transformCTL' in lmt_values:
708 ctls = [shaper_to_ACES_CTL % aces_ctl_directory,
709 os.path.join(aces_ctl_directory,
710 lmt_values['transformCTL'])]
711 lut = '%s.%s.spi3d' % (shaper_name, lmt_name)
715 generate_3d_LUT_from_CTL(
716 os.path.join(lut_directory, lut),
720 1 / shaper_input_scale,
726 cs.from_reference_transforms.append(shaper_OCIO_transform)
727 cs.from_reference_transforms.append({
730 'interpolation': 'tetrahedral',
731 'direction': 'forward'})
733 # Generating the inverse transform.
734 cs.to_reference_transforms = []
736 if 'transformCTLInverse' in lmt_values:
737 ctls = [os.path.join(aces_ctl_directory,
738 lmt_values['transformCTLInverse']),
739 shaper_from_ACES_CTL % aces_ctl_directory]
740 lut = 'Inverse.%s.%s.spi3d' % (odt_name, shaper_name)
744 generate_3d_LUT_from_CTL(
745 os.path.join(lut_directory, lut),
756 cs.to_reference_transforms.append({
759 'interpolation': 'tetrahedral',
760 'direction': 'forward'})
762 shaper_inverse = shaper_OCIO_transform.copy()
763 shaper_inverse['direction'] = 'forward'
764 cs.to_reference_transforms.append(shaper_inverse)
769 # -------------------------------------------------------------------------
771 # -------------------------------------------------------------------------
772 def create_LMTs(aces_ctl_directory,
785 Parameter description.
790 Return value description.
795 # -------------------------------------------------------------------------
797 # -------------------------------------------------------------------------
798 lmt_lut_resolution_1d = max(4096, lut_resolution_1d)
799 lmt_lut_resolution_3d = max(65, lut_resolution_3d)
801 # Defining the *Log 2* shaper.
802 lmt_shaper_name = 'LMT Shaper'
803 lmt_shaper_name_aliases = ['crv_lmtshaper']
809 lmt_shaper = create_generic_log(aces_ctl_directory,
811 lmt_lut_resolution_1d,
813 name=lmt_shaper_name,
814 middle_grey=lmt_params['middleGrey'],
815 min_exposure=lmt_params['minExposure'],
816 max_exposure=lmt_params['maxExposure'],
817 aliases=lmt_shaper_name_aliases)
818 colorspaces.append(lmt_shaper)
820 shaper_input_scale_generic_log2 = 1
822 # *Log 2* shaper name and *CTL* transforms bundled up.
827 'ACESlib.Log2_to_Lin_param.a1.0.0.ctl'),
830 'ACESlib.Lin_to_Log2_param.a1.0.0.ctl'),
831 shaper_input_scale_generic_log2,
834 sorted_LMTs = sorted(lmt_info.iteritems(), key=lambda x: x[1])
836 for lmt in sorted_LMTs:
837 lmt_name, lmt_values = lmt
838 lmt_aliases = ['look_%s' % compact(lmt_values['transformUserName'])]
839 cs = create_ACES_LMT(
840 lmt_values['transformUserName'],
845 lmt_lut_resolution_1d,
846 lmt_lut_resolution_3d,
849 colorspaces.append(cs)
854 # -------------------------------------------------------------------------
855 # *ACES RRT* with supplied *ODT*.
856 # -------------------------------------------------------------------------
857 def create_ACES_RRT_plus_ODT(odt_name,
862 lut_resolution_1d=1024,
863 lut_resolution_3d=64,
872 Parameter description.
877 Return value description.
883 cs = ColorSpace('%s' % odt_name)
884 cs.description = '%s - %s Output Transform' % (
885 odt_values['transformUserNamePrefix'], odt_name)
887 cs.equality_group = ''
891 cs.aces_transform_id = odt_values['transformID']
893 pprint.pprint(odt_values)
895 # Generating the *shaper* transform.
898 shaper_from_ACES_CTL,
900 shaper_params) = shaper_info
902 if 'legalRange' in odt_values:
903 shaper_params['legalRange'] = odt_values['legalRange']
905 shaper_params['legalRange'] = 0
907 # Add the shaper transform
908 shaper_lut = '%s_to_linear.spi1d' % shaper_name
909 shaper_lut = sanitize(shaper_lut)
911 shaper_OCIO_transform = {
914 'interpolation': 'linear',
915 'direction': 'inverse'}
917 # Generating the *forward* transform.
918 cs.from_reference_transforms = []
920 if 'transformLUT' in odt_values:
921 transform_LUT_file_name = os.path.basename(
922 odt_values['transformLUT'])
923 lut = os.path.join(lut_directory, transform_LUT_file_name)
924 shutil.copy(odt_values['transformLUT'], lut)
926 cs.from_reference_transforms.append(shaper_OCIO_transform)
927 cs.from_reference_transforms.append({
929 'path': transform_LUT_file_name,
930 'interpolation': 'tetrahedral',
931 'direction': 'forward'})
932 elif 'transformCTL' in odt_values:
934 shaper_to_ACES_CTL % aces_ctl_directory,
935 os.path.join(aces_ctl_directory,
938 os.path.join(aces_ctl_directory,
940 odt_values['transformCTL'])]
941 lut = '%s.RRT.a1.0.0.%s.spi3d' % (shaper_name, odt_name)
945 generate_3d_LUT_from_CTL(
946 os.path.join(lut_directory, lut),
951 1 / shaper_input_scale,
957 cs.from_reference_transforms.append(shaper_OCIO_transform)
958 cs.from_reference_transforms.append({
961 'interpolation': 'tetrahedral',
962 'direction': 'forward'})
964 # Generating the *inverse* transform.
965 cs.to_reference_transforms = []
967 if 'transformLUTInverse' in odt_values:
968 transform_LUT_inverse_file_name = os.path.basename(
969 odt_values['transformLUTInverse'])
970 lut = os.path.join(lut_directory, transform_LUT_inverse_file_name)
971 shutil.copy(odt_values['transformLUTInverse'], lut)
973 cs.to_reference_transforms.append({
975 'path': transform_LUT_inverse_file_name,
976 'interpolation': 'tetrahedral',
977 'direction': 'forward'})
979 shaper_inverse = shaper_OCIO_transform.copy()
980 shaper_inverse['direction'] = 'forward'
981 cs.to_reference_transforms.append(shaper_inverse)
982 elif 'transformCTLInverse' in odt_values:
983 ctls = [os.path.join(aces_ctl_directory,
985 odt_values['transformCTLInverse']),
986 os.path.join(aces_ctl_directory,
988 'InvRRT.a1.0.0.ctl'),
989 shaper_from_ACES_CTL % aces_ctl_directory]
990 lut = 'InvRRT.a1.0.0.%s.%s.spi3d' % (odt_name, shaper_name)
994 generate_3d_LUT_from_CTL(
995 os.path.join(lut_directory, lut),
1006 cs.to_reference_transforms.append({
1009 'interpolation': 'tetrahedral',
1010 'direction': 'forward'})
1012 shaper_inverse = shaper_OCIO_transform.copy()
1013 shaper_inverse['direction'] = 'forward'
1014 cs.to_reference_transforms.append(shaper_inverse)
1019 # -------------------------------------------------------------------------
1021 # -------------------------------------------------------------------------
1022 def create_ODTs(aces_ctl_directory,
1029 linear_display_space,
1037 Parameter description.
1042 Return value description.
1048 # -------------------------------------------------------------------------
1049 # *RRT / ODT* Shaper Options
1050 # -------------------------------------------------------------------------
1053 # Defining the *Log 2* shaper.
1054 log2_shaper_name = shaper_name
1055 log2_shaper_name_aliases = ['crv_%s' % compact(log2_shaper_name)]
1061 log2_shaper_colorspace = create_generic_log(
1066 name=log2_shaper_name,
1067 middle_grey=log2_params['middleGrey'],
1068 min_exposure=log2_params['minExposure'],
1069 max_exposure=log2_params['maxExposure'],
1070 aliases=log2_shaper_name_aliases)
1071 colorspaces.append(log2_shaper_colorspace)
1073 shaper_input_scale_generic_log2 = 1
1075 # *Log 2* shaper name and *CTL* transforms bundled up.
1076 log2_shaper_data = [
1080 'ACESlib.Log2_to_Lin_param.a1.0.0.ctl'),
1083 'ACESlib.Lin_to_Log2_param.a1.0.0.ctl'),
1084 shaper_input_scale_generic_log2,
1087 shaper_data[log2_shaper_name] = log2_shaper_data
1089 # Space with a more user-friendly name. Direct copy otherwise.
1090 log2_shaper_copy_name = 'Log2 Shaper'
1091 log2_shaper_copy_colorspace = ColorSpace(log2_shaper_copy_name)
1092 log2_shaper_copy_colorspace.description = 'The %s color space' % log2_shaper_copy_name
1093 log2_shaper_copy_colorspace.aliases = [
1094 'crv_%s' % compact(log2_shaper_copy_name)]
1095 log2_shaper_copy_colorspace.equality_group = log2_shaper_copy_name
1096 log2_shaper_copy_colorspace.family = log2_shaper_colorspace.family
1097 log2_shaper_copy_colorspace.is_data = log2_shaper_colorspace.is_data
1098 log2_shaper_copy_colorspace.to_reference_transforms = list(
1099 log2_shaper_colorspace.to_reference_transforms)
1100 log2_shaper_copy_colorspace.from_reference_transforms = list(
1101 log2_shaper_colorspace.from_reference_transforms)
1102 colorspaces.append(log2_shaper_copy_colorspace)
1104 # Defining the *Log2 shaper that includes the AP1* primaries.
1105 log2_shaper_api1_name = '%s - AP1' % 'Log2 Shaper'
1106 log2_shaper_api1_colorspace = ColorSpace(log2_shaper_api1_name)
1107 log2_shaper_api1_colorspace.description = 'The %s color space' % log2_shaper_api1_name
1108 log2_shaper_api1_colorspace.aliases = [
1109 '%s_ap1' % compact(log2_shaper_copy_name)]
1110 log2_shaper_api1_colorspace.equality_group = log2_shaper_api1_name
1111 log2_shaper_api1_colorspace.family = log2_shaper_colorspace.family
1112 log2_shaper_api1_colorspace.is_data = log2_shaper_colorspace.is_data
1113 log2_shaper_api1_colorspace.to_reference_transforms = list(
1114 log2_shaper_colorspace.to_reference_transforms)
1115 log2_shaper_api1_colorspace.from_reference_transforms = list(
1116 log2_shaper_colorspace.from_reference_transforms)
1118 # *AP1* primaries to *AP0* primaries.
1119 log2_shaper_api1_colorspace.to_reference_transforms.append({
1121 'matrix': mat44_from_mat33(ACES_AP1_TO_AP0),
1122 'direction': 'forward'
1124 colorspaces.append(log2_shaper_api1_colorspace)
1126 # Defining the *Log2 shaper that includes the AP1* primaries.
1127 # Named with 'shaper_name' variable. Needed for some LUT baking steps.
1128 shaper_api1_name = '%s - AP1' % shaper_name
1129 shaper_api1_colorspace = ColorSpace(shaper_api1_name)
1130 shaper_api1_colorspace.description = 'The %s color space' % shaper_api1_name
1131 shaper_api1_colorspace.aliases = ['%s_ap1' % compact(shaper_name)]
1132 shaper_api1_colorspace.equality_group = shaper_api1_name
1133 shaper_api1_colorspace.family = log2_shaper_colorspace.family
1134 shaper_api1_colorspace.is_data = log2_shaper_colorspace.is_data
1135 shaper_api1_colorspace.to_reference_transforms = list(
1136 log2_shaper_api1_colorspace.to_reference_transforms)
1137 shaper_api1_colorspace.from_reference_transforms = list(
1138 log2_shaper_api1_colorspace.from_reference_transforms)
1139 colorspaces.append(shaper_api1_colorspace)
1141 # Define the base *Dolby PQ Shaper*
1143 dolbypq_shaper_name = 'Dolby PQ 10000'
1144 dolbypq_shaper_name_aliases = ['crv_%s' % 'dolbypq_10000']
1146 dolbypq_shaper_colorspace = create_dolbypq(
1151 name=dolbypq_shaper_name,
1152 aliases=dolbypq_shaper_name_aliases)
1153 colorspaces.append(dolbypq_shaper_colorspace)
1155 # *Dolby PQ* shaper name and *CTL* transforms bundled up.
1156 dolbypq_shaper_data = [
1157 dolbypq_shaper_name,
1160 'ACESlib.DolbyPQ_to_Lin.a1.0.0.ctl'),
1163 'ACESlib.Lin_to_DolbyPQ.a1.0.0.ctl'),
1167 shaper_data[dolbypq_shaper_name] = dolbypq_shaper_data
1169 # Define the *Dolby PQ Shaper that considers a fixed linear range*
1171 dolbypq_scaled_shaper_name = 'Dolby PQ Scaled'
1172 dolbypq_scaled_shaper_name_aliases = ['crv_%s' % 'dolbypq_scaled']
1174 dolbypq_scaled_shaper_colorspace = create_dolbypq_scaled(
1179 name=dolbypq_scaled_shaper_name,
1180 aliases=dolbypq_scaled_shaper_name_aliases)
1181 colorspaces.append(dolbypq_scaled_shaper_colorspace)
1183 # *Dolby PQ* shaper name and *CTL* transforms bundled up.
1184 dolbypq_scaled_shaper_data = [
1185 dolbypq_scaled_shaper_name,
1188 'ACESlib.DolbyPQ_to_Lin_param.a1.0.0.ctl'),
1191 'ACESlib.Lin_to_DolbyPQ_param.a1.0.0.ctl'),
1195 shaper_data[dolbypq_scaled_shaper_name] = dolbypq_scaled_shaper_data
1198 # Pick a specific shaper
1200 rrt_shaper = log2_shaper_data
1201 # rrt_shaper = dolbypq_scaled_shaper_data
1203 # *RRT + ODT* combinations.
1204 sorted_odts = sorted(odt_info.iteritems(), key=lambda x: x[1])
1206 for odt in sorted_odts:
1207 (odt_name, odt_values) = odt
1209 # Generating only full range transform for *ODTs* that can generate
1210 # either *legal* or *full* output.
1212 # Uncomment these lines and the lower section and flip the 'legalRange' value to 1
1213 # to recover the old behavior, where both legal and full range LUTs were generated
1214 if odt_values['transformHasFullLegalSwitch']:
1215 # odt_name_legal = '%s - Legal' % odt_values['transformUserName']
1216 odt_legal['legalRange'] = 0
1218 # odt_name_legal = odt_values['transformUserName']
1220 odt_name_legal = odt_values['transformUserName']
1222 odt_legal = odt_values.copy()
1224 odt_aliases = ['out_%s' % compact(odt_name_legal)]
1226 cs = create_ACES_RRT_plus_ODT(
1236 colorspaces.append(cs)
1238 displays[odt_name_legal] = {
1239 'Raw': linear_display_space,
1240 'Log': log_display_space,
1241 'Output Transform': cs}
1244 # Generating full range transform for *ODTs* that can generate
1245 # either *legal* or *full* output.
1246 if odt_values['transformHasFullLegalSwitch']:
1247 print('Generating full range ODT for %s' % odt_name)
1249 odt_name_full = '%s - Full' % odt_values['transformUserName']
1250 odt_full = odt_values.copy()
1251 odt_full['legalRange'] = 0
1253 odt_full_aliases = ['out_%s' % compact(odt_name_full)]
1255 cs_full = create_ACES_RRT_plus_ODT(
1265 colorspaces.append(cs_full)
1267 displays[odt_name_full] = {
1268 'Raw': linear_display_space,
1269 'Log': log_display_space,
1270 'Output Transform': cs_full}
1273 return (colorspaces, displays)
1276 def get_transform_info(ctl_transform):
1283 Parameter description.
1288 Return value description.
1291 with open(ctl_transform, 'rb') as fp:
1292 lines = fp.readlines()
1294 # Retrieving the *transform ID* and *User Name*.
1295 transform_id = lines[1][3:].split('<')[1].split('>')[1].strip()
1296 transform_user_name = '-'.join(
1297 lines[2][3:].split('<')[1].split('>')[1].split('-')[1:]).strip()
1298 transform_user_name_prefix = (
1299 lines[2][3:].split('<')[1].split('>')[1].split('-')[0].strip())
1301 # Figuring out if this transform has options for processing full and legal range
1302 transform_full_legal_switch = False
1304 if line.strip() == 'input varying int legalRange = 0':
1305 # print( '%s has legal range flag' % transform_user_name)
1306 transform_full_legal_switch = True
1309 return (transform_id, transform_user_name, transform_user_name_prefix,
1310 transform_full_legal_switch)
1313 def get_ODTs_info(aces_ctl_directory):
1317 For versions after WGR9.
1322 Parameter description.
1327 Return value description.
1330 # TODO: Investigate usage of *files_walker* definition here.
1331 # Credit to *Alex Fry* for the original approach here.
1332 odt_dir = os.path.join(aces_ctl_directory, 'odt')
1334 for dir_name, subdir_list, file_list in os.walk(odt_dir):
1335 for fname in file_list:
1336 all_odt.append((os.path.join(dir_name, fname)))
1338 odt_CTLs = [x for x in all_odt if
1339 ('InvODT' not in x) and (os.path.split(x)[-1][0] != '.')]
1343 for odt_CTL in odt_CTLs:
1344 odt_tokens = os.path.split(odt_CTL)
1346 # Handling nested directories.
1347 odt_path_tokens = os.path.split(odt_tokens[-2])
1348 odt_dir = odt_path_tokens[-1]
1349 while odt_path_tokens[-2][-3:] != 'odt':
1350 odt_path_tokens = os.path.split(odt_path_tokens[-2])
1351 odt_dir = os.path.join(odt_path_tokens[-1], odt_dir)
1353 # Building full name,
1354 transform_CTL = odt_tokens[-1]
1355 odt_name = string.join(transform_CTL.split('.')[1:-1], '.')
1357 # Finding id, user name and user name prefix.
1359 transform_user_name,
1360 transform_user_name_prefix,
1361 transform_full_legal_switch) = get_transform_info(
1362 os.path.join(aces_ctl_directory, 'odt', odt_dir, transform_CTL))
1365 transform_CTL_inverse = 'InvODT.%s.ctl' % odt_name
1366 if not os.path.exists(
1367 os.path.join(odt_tokens[-2], transform_CTL_inverse)):
1368 transform_CTL_inverse = None
1370 # Add to list of ODTs
1372 odts[odt_name]['transformCTL'] = os.path.join(odt_dir, transform_CTL)
1373 if transform_CTL_inverse is not None:
1374 odts[odt_name]['transformCTLInverse'] = os.path.join(
1375 odt_dir, transform_CTL_inverse)
1377 odts[odt_name]['transformID'] = transform_ID
1378 odts[odt_name]['transformUserNamePrefix'] = transform_user_name_prefix
1379 odts[odt_name]['transformUserName'] = transform_user_name
1381 'transformHasFullLegalSwitch'] = transform_full_legal_switch
1383 forward_CTL = odts[odt_name]['transformCTL']
1385 print('ODT : %s' % odt_name)
1386 print('\tTransform ID : %s' % transform_ID)
1387 print('\tTransform User Name Prefix : %s' % transform_user_name_prefix)
1388 print('\tTransform User Name : %s' % transform_user_name)
1390 '\tHas Full / Legal Switch : %s' % transform_full_legal_switch)
1391 print('\tForward ctl : %s' % forward_CTL)
1392 if 'transformCTLInverse' in odts[odt_name]:
1393 inverse_CTL = odts[odt_name]['transformCTLInverse']
1394 print('\tInverse ctl : %s' % inverse_CTL)
1396 print('\tInverse ctl : %s' % 'None')
1403 def get_LMTs_info(aces_ctl_directory):
1407 For versions after WGR9.
1412 Parameter description.
1417 Return value description.
1420 # TODO: Investigate refactoring with previous definition.
1422 # Credit to Alex Fry for the original approach here
1423 lmt_dir = os.path.join(aces_ctl_directory, 'lmt')
1425 for dir_name, subdir_list, file_list in os.walk(lmt_dir):
1426 for fname in file_list:
1427 all_lmt.append((os.path.join(dir_name, fname)))
1429 lmt_CTLs = [x for x in all_lmt if
1430 ('InvLMT' not in x) and ('README' not in x) and (
1431 os.path.split(x)[-1][0] != '.')]
1435 for lmt_CTL in lmt_CTLs:
1436 lmt_tokens = os.path.split(lmt_CTL)
1438 # Handlimg nested directories.
1439 lmt_path_tokens = os.path.split(lmt_tokens[-2])
1440 lmt_dir = lmt_path_tokens[-1]
1441 while lmt_path_tokens[-2][-3:] != 'ctl':
1442 lmt_path_tokens = os.path.split(lmt_path_tokens[-2])
1443 lmt_dir = os.path.join(lmt_path_tokens[-1], lmt_dir)
1445 # Building full name.
1446 transform_CTL = lmt_tokens[-1]
1447 lmt_name = string.join(transform_CTL.split('.')[1:-1], '.')
1449 # Finding id, user name and user name prefix.
1451 transform_user_name,
1452 transform_user_name_prefix,
1453 transform_full_legal_switch) = get_transform_info(
1454 os.path.join(aces_ctl_directory, lmt_dir, transform_CTL))
1457 transform_CTL_inverse = 'InvLMT.%s.ctl' % lmt_name
1458 if not os.path.exists(
1459 os.path.join(lmt_tokens[-2], transform_CTL_inverse)):
1460 transform_CTL_inverse = None
1463 lmts[lmt_name]['transformCTL'] = os.path.join(lmt_dir, transform_CTL)
1464 if transform_CTL_inverse is not None:
1465 lmts[lmt_name]['transformCTLInverse'] = os.path.join(
1466 lmt_dir, transform_CTL_inverse)
1468 lmts[lmt_name]['transformID'] = transform_ID
1469 lmts[lmt_name]['transformUserNamePrefix'] = transform_user_name_prefix
1470 lmts[lmt_name]['transformUserName'] = transform_user_name
1472 forward_CTL = lmts[lmt_name]['transformCTL']
1474 print('LMT : %s' % lmt_name)
1475 print('\tTransform ID : %s' % transform_ID)
1476 print('\tTransform User Name Prefix : %s' % transform_user_name_prefix)
1477 print('\tTransform User Name : %s' % transform_user_name)
1478 print('\t Forward ctl : %s' % forward_CTL)
1479 if 'transformCTLInverse' in lmts[lmt_name]:
1480 inverse_CTL = lmts[lmt_name]['transformCTLInverse']
1481 print('\t Inverse ctl : %s' % inverse_CTL)
1483 print('\t Inverse ctl : %s' % 'None')
1490 def create_colorspaces(aces_ctl_directory,
1499 Generates the colorspace conversions.
1504 Parameter description.
1509 Return value description.
1514 ACES = create_ACES()
1516 ACEScc = create_ACEScc(aces_ctl_directory, lut_directory,
1517 lut_resolution_1d, cleanup,
1518 min_value=-0.35840, max_value=1.468)
1519 colorspaces.append(ACEScc)
1521 ACESproxy = create_ACESproxy(aces_ctl_directory, lut_directory,
1522 lut_resolution_1d, cleanup)
1523 colorspaces.append(ACESproxy)
1525 ACEScg = create_ACEScg(aces_ctl_directory, lut_directory,
1526 lut_resolution_1d, cleanup)
1527 colorspaces.append(ACEScg)
1529 ADX10 = create_ADX(lut_directory, lut_resolution_1d, bit_depth=10)
1530 colorspaces.append(ADX10)
1532 ADX16 = create_ADX(lut_directory, lut_resolution_1d, bit_depth=16)
1533 colorspaces.append(ADX16)
1535 lmts = create_LMTs(aces_ctl_directory,
1542 colorspaces.extend(lmts)
1544 odts, displays = create_ODTs(aces_ctl_directory,
1553 colorspaces.extend(odts)
1555 # Wish there was an automatic way to get this from the CTL
1556 defaultDisplay = 'sRGB (D60 sim.)'
1558 roles = {'color_picking': ACEScg.name,
1559 'color_timing': ACEScc.name,
1560 'compositing_log': ACEScc.name,
1562 'default': ACES.name,
1563 'matte_paint': ACEScc.name,
1565 'scene_linear': ACEScg.name,
1566 'texture_paint': ''}
1568 return ACES, colorspaces, displays, ACEScc, roles, defaultDisplay