2 # -*- coding: utf-8 -*-
5 Implements support for *ACES* colorspaces conversions and transfer functions.
8 from __future__ import division
18 import PyOpenColorIO as ocio
20 from aces_ocio.generate_lut import (
21 generate_1d_LUT_from_CTL,
22 generate_3d_LUT_from_CTL,
24 from aces_ocio.utilities import (
30 __author__ = 'ACES Developers'
31 __copyright__ = 'Copyright (C) 2014 - 2015 - ACES Developers'
33 __maintainer__ = 'ACES Developers'
34 __email__ = 'aces@oscars.org'
35 __status__ = 'Production'
37 __all__ = ['ACES_AP1_TO_AP0',
48 'create_Dolby_PQ_shaper',
51 'create_ACES_RRT_plus_ODT',
53 'create_shapers_dolbypq'
54 'create_shapers_log2',
61 # Matrix converting *ACES AP1* primaries to *ACES AP0*.
62 ACES_AP1_TO_AP0 = [0.6954522414, 0.1406786965, 0.1638690622,
63 0.0447945634, 0.8596711185, 0.0955343182,
64 -0.0055258826, 0.0040252103, 1.0015006723]
66 # Matrix converting *ACES AP0* primaries to *ACES AP1*.
67 ACES_AP0_TO_AP1 = [1.4514393161, -0.2365107469, -0.2149285693,
68 -0.0765537734, 1.1762296998, -0.0996759264,
69 0.0083161484, -0.0060324498, 0.9977163014]
71 # Matrix converting *ACES AP0* primaries to *XYZ*.
72 ACES_AP0_TO_XYZ = [0.9525523959, 0.0000000000, 0.0000936786,
73 0.3439664498, 0.7281660966, -0.0721325464,
74 0.0000000000, 0.0000000000, 1.0088251844]
76 # Matrix converting *ACES AP0* primaries to *XYZ*.
77 ACES_XYZ_TO_AP0 = [1.0498110175, 0.0000000000, -0.0000974845,
78 -0.4959030231, 1.3733130458, 0.0982400361,
79 0.0000000000, 0.0000000000, 0.9912520182]
89 Parameter description.
94 Return value description.
97 # Defining the reference colorspace.
98 aces2065_1 = ColorSpace('ACES2065-1')
99 aces2065_1.description = (
100 'The Academy Color Encoding System reference color space')
101 aces2065_1.equality_group = ''
102 aces2065_1.aliases = ['lin_ap0', 'aces']
103 aces2065_1.family = 'ACES'
104 aces2065_1.is_data = False
105 aces2065_1.allocation_type = ocio.Constants.ALLOCATION_LG2
106 aces2065_1.allocation_vars = [-8, 5, 0.00390625]
111 def create_ACEScc(aces_ctl_directory,
120 Creates the *ACEScc* colorspace.
125 Parameter description.
133 cs = ColorSpace(name)
134 cs.description = 'The %s color space' % name
135 cs.aliases = ['acescc', 'acescc_ap1']
136 cs.equality_group = ''
139 cs.allocation_type = ocio.Constants.ALLOCATION_UNIFORM
140 cs.allocation_vars = [min_value, max_value]
141 cs.aces_transform_id = 'ACEScsc.ACEScc_to_ACES.a1.0.0'
143 ctls = [os.path.join(aces_ctl_directory,
145 'ACEScsc.ACEScc_to_ACES.a1.0.0.ctl'),
146 # This transform gets back to the *AP1* primaries.
147 # Useful as the 1d LUT is only covering the transfer function.
148 # The primaries switch is covered by the matrix below:
149 os.path.join(aces_ctl_directory,
151 'ACEScsc.ACES_to_ACEScg.a1.0.0.ctl')]
152 lut = '%s_to_linear.spi1d' % name
156 generate_1d_LUT_from_CTL(
157 os.path.join(lut_directory, lut),
170 cs.to_reference_transforms = []
171 cs.to_reference_transforms.append({
174 'interpolation': 'linear',
175 'direction': 'forward'})
177 # *AP1* primaries to *AP0* primaries
178 cs.to_reference_transforms.append({
180 'matrix': mat44_from_mat33(ACES_AP1_TO_AP0),
181 'direction': 'forward'})
183 cs.from_reference_transforms = []
187 def create_ACESproxy(aces_ctl_directory,
193 Creates the *ACESproxy* colorspace.
198 Parameter description.
203 *ACESproxy* colorspace.
206 cs = ColorSpace(name)
207 cs.description = 'The %s color space' % name
208 cs.aliases = ['acesproxy', 'acesproxy_ap1']
209 cs.equality_group = ''
213 cs.aces_transform_id = 'ACEScsc.ACESproxy10i_to_ACES.a1.0.0'
215 ctls = [os.path.join(aces_ctl_directory,
217 'ACEScsc.ACESproxy10i_to_ACES.a1.0.0.ctl'),
218 # This transform gets back to the *AP1* primaries.
219 # Useful as the 1d LUT is only covering the transfer function.
220 # The primaries switch is covered by the matrix below:
221 os.path.join(aces_ctl_directory,
223 'ACEScsc.ACES_to_ACEScg.a1.0.0.ctl')]
224 lut = '%s_to_linear.spi1d' % name
228 generate_1d_LUT_from_CTL(
229 os.path.join(lut_directory, lut),
242 cs.to_reference_transforms = []
243 cs.to_reference_transforms.append({
246 'interpolation': 'linear',
247 'direction': 'forward'})
249 # *AP1* primaries to *AP0* primaries
250 cs.to_reference_transforms.append({
252 'matrix': mat44_from_mat33(ACES_AP1_TO_AP0),
253 'direction': 'forward'})
255 cs.from_reference_transforms = []
259 # -------------------------------------------------------------------------
261 # -------------------------------------------------------------------------
264 Creates the *ACEScg* colorspace.
269 Parameter description.
279 cs = ColorSpace(name)
280 cs.description = 'The %s color space' % name
281 cs.aliases = ['acescg', 'lin_ap1']
282 cs.equality_group = ''
285 cs.allocation_type = ocio.Constants.ALLOCATION_LG2
286 cs.allocation_vars = [-8, 5, 0.00390625]
288 cs.aces_transform_id = 'ACEScsc.ACEScg_to_ACES.a1.0.0'
290 cs.to_reference_transforms = []
292 # *AP1* primaries to *AP0* primaries
293 cs.to_reference_transforms.append({
295 'matrix': mat44_from_mat33(ACES_AP1_TO_AP0),
296 'direction': 'forward'})
298 cs.from_reference_transforms = []
300 # Commented out because having specifying the inverse matrix causes
301 # some of OCIO's checks to see if a set of transforms can be collapsed
304 # *AP1* primaries to *AP0* primaries
305 #cs.from_reference_transforms.append({
307 # 'matrix': mat44_from_mat33(ACES_AP0_TO_AP1),
308 # 'direction': 'forward'})
313 # -------------------------------------------------------------------------
315 # -------------------------------------------------------------------------
316 def create_ADX(lut_directory,
320 Creates the *ADX* colorspace.
325 Parameter description.
333 name = '%s%s' % (name, bit_depth)
334 cs = ColorSpace(name)
335 cs.description = '%s color space - used for film scans' % name
336 cs.aliases = ['adx%s' % str(bit_depth)]
337 cs.equality_group = ''
342 cs.aces_transform_id = 'ACEScsc.ADX10_to_ACES.a1.0.0'
344 cs.bit_depth = ocio.Constants.BIT_DEPTH_UINT10
345 ADX_to_CDD = [1023 / 500, 0, 0, 0,
349 offset = [-95 / 500, -95 / 500, -95 / 500, 0]
350 elif bit_depth == 16:
351 cs.aces_transform_id = 'ACEScsc.ADX16_to_ACES.a1.0.0'
353 cs.bit_depth = ocio.Constants.BIT_DEPTH_UINT16
354 ADX_to_CDD = [65535 / 8000, 0, 0, 0,
355 0, 65535 / 8000, 0, 0,
356 0, 0, 65535 / 8000, 0,
358 offset = [-1520 / 8000, -1520 / 8000, -1520 / 8000, 0]
360 cs.to_reference_transforms = []
362 # Converting from *ADX* to *Channel-Dependent Density*.
363 cs.to_reference_transforms.append({
365 'matrix': ADX_to_CDD,
367 'direction': 'forward'})
369 # Converting from *Channel-Dependent Density* to
370 # *Channel-Independent Density*.
371 cs.to_reference_transforms.append({
373 'matrix': [0.75573, 0.22197, 0.02230, 0,
374 0.05901, 0.96928, -0.02829, 0,
375 0.16134, 0.07406, 0.76460, 0,
377 'direction': 'forward'})
379 # Copied from *Alex Fry*'s *adx_cid_to_rle.py*
380 def create_CID_to_RLE_LUT():
382 def interpolate_1d(x, xp, fp):
383 return numpy.interp(x, xp, fp)
385 LUT_1D_XP = [-0.190000000000000,
397 LUT_1D_FP = [-6.000000000000000,
409 REF_PT = ((7120 - 1520) / 8000 * (100 / 55) -
414 return interpolate_1d(x, LUT_1D_XP, LUT_1D_FP)
415 return (100 / 55) * x - REF_PT
417 def fit(value, from_min, from_max, to_min, to_max):
418 if from_min == from_max:
419 raise ValueError('from_min == from_max')
420 return (value - from_min) / (from_max - from_min) * (
421 to_max - to_min) + to_min
423 num_samples = 2 ** 12
426 for i in xrange(num_samples):
427 x = i / (num_samples - 1)
428 x = fit(x, 0, 1, domain[0], domain[1])
429 data.append(cid_to_rle(x))
431 lut = 'ADX_CID_to_RLE.spi1d'
432 write_SPI_1d(os.path.join(lut_directory, lut),
440 # Converting *Channel Independent Density* values to
441 # *Relative Log Exposure* values.
442 lut = create_CID_to_RLE_LUT()
443 cs.to_reference_transforms.append({
446 'interpolation': 'linear',
447 'direction': 'forward'})
449 # Converting *Relative Log Exposure* values to
450 # *Relative Exposure* values.
451 cs.to_reference_transforms.append({
454 'direction': 'inverse'})
456 # Convert *Relative Exposure* values to *ACES* values.
457 cs.to_reference_transforms.append({
459 'matrix': [0.72286, 0.12630, 0.15084, 0,
460 0.11923, 0.76418, 0.11659, 0,
461 0.01427, 0.08213, 0.90359, 0,
463 'direction': 'forward'})
465 cs.from_reference_transforms = []
469 # -------------------------------------------------------------------------
470 # Generic *Log* Transform
471 # -------------------------------------------------------------------------
472 def create_generic_log(aces_ctl_directory,
485 Creates the *Generic Log* colorspace.
490 Parameter description.
495 *Generic Log* colorspace.
501 cs = ColorSpace(name)
502 cs.description = 'The %s color space' % name
504 cs.equality_group = name
505 cs.family = 'Utility'
508 ctls = [os.path.join(
511 'ACESlib.Log2_to_Lin_param.a1.0.0.ctl')]
512 lut = '%s_to_linear.spi1d' % name
516 generate_1d_LUT_from_CTL(
517 os.path.join(lut_directory, lut),
523 {'middleGrey': middle_grey,
524 'minExposure': min_exposure,
525 'maxExposure': max_exposure},
532 cs.to_reference_transforms = []
533 cs.to_reference_transforms.append({
536 'interpolation': 'linear',
537 'direction': 'forward'})
539 cs.from_reference_transforms = []
543 # -------------------------------------------------------------------------
544 # Base *Dolby PQ* Transform
545 # -------------------------------------------------------------------------
546 def create_Dolby_PQ(aces_ctl_directory,
558 cs = ColorSpace(name)
559 cs.description = 'The %s color space' % name
561 cs.equality_group = name
562 cs.family = 'Utility'
565 ctls = [os.path.join(
568 'ACESlib.DolbyPQ_to_Lin.a1.0.0.ctl')]
569 lut = '%s_to_linear.spi1d' % name
573 generate_1d_LUT_from_CTL(
574 os.path.join(lut_directory, lut),
586 cs.to_reference_transforms = []
587 cs.to_reference_transforms.append({
590 'interpolation': 'linear',
591 'direction': 'forward'})
593 cs.from_reference_transforms = []
597 # -------------------------------------------------------------------------
598 # *Dolby PQ* Transform - Fixed Linear Range
599 # -------------------------------------------------------------------------
600 def create_Dolby_PQ_shaper(aces_ctl_directory,
615 cs = ColorSpace(name)
616 cs.description = 'The %s color space' % name
618 cs.equality_group = name
619 cs.family = 'Utility'
622 ctls = [os.path.join(
625 'ACESlib.OCIOshaper_to_Lin_param.a1.0.0.ctl')]
626 lut = '%s_to_linear.spi1d' % name
630 generate_1d_LUT_from_CTL(
631 os.path.join(lut_directory, lut),
637 {'middleGrey': middle_grey,
638 'minExposure': min_exposure,
639 'maxExposure': max_exposure},
645 cs.to_reference_transforms = []
646 cs.to_reference_transforms.append({
649 'interpolation': 'linear',
650 'direction': 'forward'})
652 cs.from_reference_transforms = []
656 # -------------------------------------------------------------------------
658 # -------------------------------------------------------------------------
659 def create_ACES_LMT(lmt_name,
664 lut_resolution_3d=64,
668 Creates the *ACES LMT* colorspace.
673 Parameter description.
678 *ACES LMT* colorspace.
684 cs = ColorSpace('%s' % lmt_name)
685 cs.description = 'The ACES Look Transform: %s' % lmt_name
687 cs.equality_group = ''
690 cs.allocation_type = ocio.Constants.ALLOCATION_LG2
691 cs.allocation_vars = [-8, 5, 0.00390625]
692 cs.aces_transform_id = lmt_values['transformID']
694 pprint.pprint(lmt_values)
696 # Generating the *shaper* transform.
699 shaper_from_aces_ctl,
701 shaper_params) = shaper_info
703 shaper_lut = '%s_to_linear.spi1d' % shaper_name
704 shaper_lut = sanitize(shaper_lut)
706 shaper_ocio_transform = {
709 'interpolation': 'linear',
710 'direction': 'inverse'}
712 # Generating the forward transform.
713 cs.from_reference_transforms = []
715 if 'transformCTL' in lmt_values:
716 ctls = [shaper_to_aces_ctl % aces_ctl_directory,
717 os.path.join(aces_ctl_directory,
718 lmt_values['transformCTL'])]
719 lut = '%s.%s.spi3d' % (shaper_name, lmt_name)
723 generate_3d_LUT_from_CTL(
724 os.path.join(lut_directory, lut),
728 1 / shaper_input_scale,
734 cs.from_reference_transforms.append(shaper_ocio_transform)
735 cs.from_reference_transforms.append({
738 'interpolation': 'tetrahedral',
739 'direction': 'forward'})
741 # Generating the inverse transform.
742 cs.to_reference_transforms = []
744 if 'transformCTLInverse' in lmt_values:
745 ctls = [os.path.join(aces_ctl_directory,
746 lmt_values['transformCTLInverse']),
747 shaper_from_aces_ctl % aces_ctl_directory]
748 lut = 'Inverse.%s.%s.spi3d' % (lmt_name, shaper_name)
752 generate_3d_LUT_from_CTL(
753 os.path.join(lut_directory, lut),
764 cs.to_reference_transforms.append({
767 'interpolation': 'tetrahedral',
768 'direction': 'forward'})
770 shaper_inverse = shaper_ocio_transform.copy()
771 shaper_inverse['direction'] = 'forward'
772 cs.to_reference_transforms.append(shaper_inverse)
777 # -------------------------------------------------------------------------
779 # -------------------------------------------------------------------------
780 def create_LMTs(aces_ctl_directory,
792 Parameter description.
797 Return value description.
802 # -------------------------------------------------------------------------
804 # -------------------------------------------------------------------------
805 lmt_lut_resolution_1d = max(4096, lut_resolution_1d)
806 lmt_lut_resolution_3d = max(65, lut_resolution_3d)
808 # Defining the *Log 2* shaper.
809 lmt_shaper_name = 'LMT Shaper'
810 lmt_shaper_name_aliases = ['crv_lmtshaper']
816 lmt_shaper = create_generic_log(aces_ctl_directory,
818 lmt_lut_resolution_1d,
820 name=lmt_shaper_name,
821 middle_grey=lmt_params['middleGrey'],
822 min_exposure=lmt_params['minExposure'],
823 max_exposure=lmt_params['maxExposure'],
824 aliases=lmt_shaper_name_aliases)
825 colorspaces.append(lmt_shaper)
827 shaper_input_scale_generic_log2 = 1
829 # *Log 2* shaper name and *CTL* transforms bundled up.
834 'ACESlib.Log2_to_Lin_param.a1.0.0.ctl'),
837 'ACESlib.Lin_to_Log2_param.a1.0.0.ctl'),
838 shaper_input_scale_generic_log2,
841 sorted_lmts = sorted(lmt_info.iteritems(), key=lambda x: x[1])
843 for lmt in sorted_lmts:
844 lmt_name, lmt_values = lmt
845 lmt_aliases = ['look_%s' % compact(lmt_values['transformUserName'])]
846 cs = create_ACES_LMT(
847 lmt_values['transformUserName'],
852 lmt_lut_resolution_3d,
855 colorspaces.append(cs)
860 # -------------------------------------------------------------------------
861 # *ACES RRT* with supplied *ODT*.
862 # -------------------------------------------------------------------------
863 def create_ACES_RRT_plus_ODT(odt_name,
868 lut_resolution_3d=64,
877 Parameter description.
882 Return value description.
888 cs = ColorSpace('%s' % odt_name)
889 cs.description = '%s - %s Output Transform' % (
890 odt_values['transformUserNamePrefix'], odt_name)
892 cs.equality_group = ''
896 cs.aces_transform_id = odt_values['transformID']
898 pprint.pprint(odt_values)
900 # Generating the *shaper* transform.
903 shaper_from_aces_ctl,
905 shaper_params) = shaper_info
907 if 'legalRange' in odt_values:
908 shaper_params['legalRange'] = odt_values['legalRange']
910 shaper_params['legalRange'] = 0
912 shaper_lut = '%s_to_linear.spi1d' % shaper_name
913 shaper_lut = sanitize(shaper_lut)
915 shaper_ocio_transform = {
918 'interpolation': 'linear',
919 'direction': 'inverse'}
921 # Generating the *forward* transform.
922 cs.from_reference_transforms = []
924 if 'transformLUT' in odt_values:
925 transform_lut_file_name = os.path.basename(
926 odt_values['transformLUT'])
927 lut = os.path.join(lut_directory, transform_lut_file_name)
928 shutil.copy(odt_values['transformLUT'], lut)
930 cs.from_reference_transforms.append(shaper_ocio_transform)
931 cs.from_reference_transforms.append({
933 'path': transform_lut_file_name,
934 'interpolation': 'tetrahedral',
935 'direction': 'forward'})
936 elif 'transformCTL' in odt_values:
938 shaper_to_aces_ctl % aces_ctl_directory,
939 os.path.join(aces_ctl_directory,
942 os.path.join(aces_ctl_directory,
944 odt_values['transformCTL'])]
945 lut = '%s.RRT.a1.0.0.%s.spi3d' % (shaper_name, odt_name)
949 generate_3d_LUT_from_CTL(
950 os.path.join(lut_directory, lut),
954 1 / shaper_input_scale,
960 cs.from_reference_transforms.append(shaper_ocio_transform)
961 cs.from_reference_transforms.append({
964 'interpolation': 'tetrahedral',
965 'direction': 'forward'})
967 # Generating the *inverse* transform.
968 cs.to_reference_transforms = []
970 if 'transformLUTInverse' in odt_values:
971 transform_lut_inverse_file_name = os.path.basename(
972 odt_values['transformLUTInverse'])
973 lut = os.path.join(lut_directory, transform_lut_inverse_file_name)
974 shutil.copy(odt_values['transformLUTInverse'], lut)
976 cs.to_reference_transforms.append({
978 'path': transform_lut_inverse_file_name,
979 'interpolation': 'tetrahedral',
980 'direction': 'forward'})
982 shaper_inverse = shaper_ocio_transform.copy()
983 shaper_inverse['direction'] = 'forward'
984 cs.to_reference_transforms.append(shaper_inverse)
985 elif 'transformCTLInverse' in odt_values:
986 ctls = [os.path.join(aces_ctl_directory,
988 odt_values['transformCTLInverse']),
989 os.path.join(aces_ctl_directory,
991 'InvRRT.a1.0.0.ctl'),
992 shaper_from_aces_ctl % aces_ctl_directory]
993 lut = 'InvRRT.a1.0.0.%s.%s.spi3d' % (odt_name, shaper_name)
997 generate_3d_LUT_from_CTL(
998 os.path.join(lut_directory, lut),
1008 cs.to_reference_transforms.append({
1011 'interpolation': 'tetrahedral',
1012 'direction': 'forward'})
1014 shaper_inverse = shaper_ocio_transform.copy()
1015 shaper_inverse['direction'] = 'forward'
1016 cs.to_reference_transforms.append(shaper_inverse)
1020 # -------------------------------------------------------------------------
1022 # -------------------------------------------------------------------------
1023 def create_shapers_log2(aces_ctl_directory,
1034 # Defining the *Log 2* shaper for *ODTs covering 48 nit output*.
1035 log2_shaper_name = shaper_name
1036 log2_shaper_name_aliases = ['crv_%s' % compact(log2_shaper_name)]
1038 'middleGrey': middle_grey,
1039 'minExposure': min_exposure,
1040 'maxExposure': max_exposure}
1042 log2_shaper_colorspace = create_generic_log(
1047 name=log2_shaper_name,
1048 middle_grey=log2_params['middleGrey'],
1049 min_exposure=log2_params['minExposure'],
1050 max_exposure=log2_params['maxExposure'],
1051 aliases=log2_shaper_name_aliases)
1052 colorspaces.append(log2_shaper_colorspace)
1054 shaper_input_scale_generic_log2 = 1
1056 # *Log 2* shaper name and *CTL* transforms bundled up.
1057 log2_shaper_data = [
1061 'ACESlib.Log2_to_Lin_param.a1.0.0.ctl'),
1064 'ACESlib.Lin_to_Log2_param.a1.0.0.ctl'),
1065 shaper_input_scale_generic_log2,
1068 shaper_data[log2_shaper_name] = log2_shaper_data
1070 # Defining the *Log2 shaper that includes the AP1* primaries.
1071 log2_shaper_api1_name = '%s - AP1' % log2_shaper_name
1072 log2_shaper_api1_colorspace = copy.deepcopy(log2_shaper_colorspace)
1074 log2_shaper_api1_colorspace.name = log2_shaper_api1_name
1075 log2_shaper_api1_colorspace.description = (
1076 'The %s color space' % log2_shaper_api1_name)
1077 log2_shaper_api1_colorspace.aliases = [
1078 '%s_ap1' % compact(log2_shaper_name)]
1079 log2_shaper_api1_colorspace.equality_group = log2_shaper_api1_name
1081 # *AP1* primaries to *AP0* primaries
1082 log2_shaper_api1_colorspace.to_reference_transforms.append({
1084 'matrix': mat44_from_mat33(ACES_AP1_TO_AP0),
1085 'direction': 'forward'
1087 colorspaces.append(log2_shaper_api1_colorspace)
1089 return shaper_data, colorspaces
1091 # -------------------------------------------------------------------------
1092 # *Dolby PQ-based Shapers*
1093 # -------------------------------------------------------------------------
1094 def create_shapers_dolbypq(aces_ctl_directory,
1105 # Define the *Dolby PQ Shaper that considers a fixed linear range*
1106 dolby_pq_shaper_name = shaper_name
1107 dolby_pq_shaper_name_aliases = ['crv_%s' % compact(dolby_pq_shaper_name)]
1110 'middleGrey': middle_grey,
1111 'minExposure': min_exposure,
1112 'maxExposure': max_exposure}
1114 dolby_pq_shaper_colorspace = create_Dolby_PQ_shaper(
1119 name=dolby_pq_shaper_name,
1120 aliases=dolby_pq_shaper_name_aliases,
1121 middle_grey=dolby_pq_params['middleGrey'],
1122 min_exposure=dolby_pq_params['minExposure'],
1123 max_exposure=dolby_pq_params['maxExposure'])
1124 colorspaces.append(dolby_pq_shaper_colorspace)
1126 # *Dolby PQ* shaper name and *CTL* transforms bundled up.
1127 dolby_pq_shaper_data = [
1128 dolby_pq_shaper_name,
1131 'ACESlib.OCIOshaper_to_Lin_param.a1.0.0.ctl'),
1134 'ACESlib.Lin_to_OCIOshaper_param.a1.0.0.ctl'),
1138 shaper_data[dolby_pq_shaper_name] = dolby_pq_shaper_data
1140 # Defining the *Log2 shaper that includes the AP1* primaries.
1141 dolby_pq_shaper_api1_name = '%s - AP1' % dolby_pq_shaper_name
1142 dolby_pq_shaper_api1_colorspace = copy.deepcopy(dolby_pq_shaper_colorspace)
1144 dolby_pq_shaper_api1_colorspace.name = dolby_pq_shaper_api1_name
1145 dolby_pq_shaper_api1_colorspace.description = (
1146 'The %s color space' % dolby_pq_shaper_api1_name)
1147 dolby_pq_shaper_api1_colorspace.aliases = [
1148 '%s_ap1' % compact(dolby_pq_shaper_name)]
1149 dolby_pq_shaper_api1_colorspace.equality_group = dolby_pq_shaper_api1_name
1151 # *AP1* primaries to *AP0* primaries
1152 dolby_pq_shaper_api1_colorspace.to_reference_transforms.append({
1154 'matrix': mat44_from_mat33(ACES_AP1_TO_AP0),
1155 'direction': 'forward'
1157 colorspaces.append(dolby_pq_shaper_api1_colorspace)
1159 return shaper_data, colorspaces
1162 # -------------------------------------------------------------------------
1164 # -------------------------------------------------------------------------
1165 def create_shapers(aces_ctl_directory,
1173 # Define the base *Log2 48 nits shaper*
1175 (log2_48nits_shaper_data,
1176 log2_48nits_colorspaces) = create_shapers_log2(aces_ctl_directory,
1180 'Log2 48 nits Shaper',
1184 colorspaces.extend(log2_48nits_colorspaces)
1185 shaper_data.update(log2_48nits_shaper_data)
1187 # Define the base *Log2 1000 nits shaper*
1189 (log2_1000nits_shaper_data,
1190 log2_1000nits_colorspaces) = create_shapers_log2(aces_ctl_directory,
1194 'Log2 1000 nits Shaper',
1198 colorspaces.extend(log2_1000nits_colorspaces)
1199 shaper_data.update(log2_1000nits_shaper_data)
1201 # Define the base *Log2 2000 nits shaper*
1203 (log2_2000nits_shaper_data,
1204 log2_2000nits_colorspaces) = create_shapers_log2(aces_ctl_directory,
1208 'Log2 2000 nits Shaper',
1212 colorspaces.extend(log2_2000nits_colorspaces)
1213 shaper_data.update(log2_2000nits_shaper_data)
1215 # Define the base *Log2 4000 nits shaper*
1217 (log2_4000nits_shaper_data,
1218 log2_4000nits_colorspaces) = create_shapers_log2(aces_ctl_directory,
1222 'Log2 4000 nits Shaper',
1226 colorspaces.extend(log2_4000nits_colorspaces)
1227 shaper_data.update(log2_4000nits_shaper_data)
1229 # Define the base *Dolby PQ transfer function*
1231 dolby_pq_shaper_name = 'Dolby PQ 10000'
1232 dolby_pq_shaper_name_aliases = ['crv_%s' % 'dolbypq_10000']
1234 dolby_pq_shaper_colorspace = create_Dolby_PQ(
1239 name=dolby_pq_shaper_name,
1240 aliases=dolby_pq_shaper_name_aliases)
1241 colorspaces.append(dolby_pq_shaper_colorspace)
1243 # *Dolby PQ* shaper name and *CTL* transforms bundled up.
1244 dolby_pq_shaper_data = [
1245 dolby_pq_shaper_name,
1248 'ACESlib.DolbyPQ_to_Lin.a1.0.0.ctl'),
1251 'ACESlib.Lin_to_DolbyPQ.a1.0.0.ctl'),
1255 shaper_data[dolby_pq_shaper_name] = dolby_pq_shaper_data
1257 # Define the *Dolby PQ 48 nits shaper*
1259 (dolbypq_48nits_shaper_data,
1260 dolbypq_48nits_colorspaces) = create_shapers_dolbypq(aces_ctl_directory,
1264 'Dolby PQ 48 nits Shaper',
1268 colorspaces.extend(dolbypq_48nits_colorspaces)
1269 shaper_data.update(dolbypq_48nits_shaper_data)
1271 # Define the *Dolby PQ 1000 nits shaper*
1273 (dolbypq_1000nits_shaper_data,
1274 dolbypq_1000nits_colorspaces) = create_shapers_dolbypq(aces_ctl_directory,
1278 'Dolby PQ 1000 nits Shaper',
1282 colorspaces.extend(dolbypq_1000nits_colorspaces)
1283 shaper_data.update(dolbypq_1000nits_shaper_data)
1285 # Define the *Dolby PQ 2000 nits shaper*
1287 (dolbypq_2000nits_shaper_data,
1288 dolbypq_2000nits_colorspaces) = create_shapers_dolbypq(aces_ctl_directory,
1292 'Dolby PQ 2000 nits Shaper',
1296 colorspaces.extend(dolbypq_2000nits_colorspaces)
1297 shaper_data.update(dolbypq_2000nits_shaper_data)
1299 # Define the *Dolby PQ 4000 nits shaper*
1301 (dolbypq_4000nits_shaper_data,
1302 dolbypq_4000nits_colorspaces) = create_shapers_dolbypq(aces_ctl_directory,
1306 'Dolby PQ 4000 nits Shaper',
1310 colorspaces.extend(dolbypq_4000nits_colorspaces)
1311 shaper_data.update(dolbypq_4000nits_shaper_data)
1313 return shaper_data, colorspaces
1315 # -------------------------------------------------------------------------
1317 # -------------------------------------------------------------------------
1318 def create_ODTs(aces_ctl_directory,
1325 linear_display_space,
1333 Parameter description.
1338 Return value description.
1344 # -------------------------------------------------------------------------
1345 # *RRT / ODT* Shaper Options
1346 # -------------------------------------------------------------------------
1347 shaper_data, shaper_colorspaces = create_shapers(aces_ctl_directory,
1352 colorspaces.extend(shaper_colorspaces)
1354 # Assumes shaper has variants covering the range expected by the
1355 # 48 nit, 1000 nit, 2000 nit and 4000 nit Ouput Transforms
1356 rrt_shaper_48nits = shaper_data[shaper_name]
1357 rrt_shaper_1000nits = shaper_data[shaper_name.replace("48 nits", "1000 nits")]
1358 rrt_shaper_2000nits = shaper_data[shaper_name.replace("48 nits", "2000 nits")]
1359 rrt_shaper_4000nits = shaper_data[shaper_name.replace("48 nits", "4000 nits")]
1361 # *RRT + ODT* combinations.
1362 sorted_odts = sorted(odt_info.iteritems(), key=lambda x: x[1])
1364 for odt in sorted_odts:
1365 (odt_name, odt_values) = odt
1367 if odt_values['transformHasFullLegalSwitch']:
1368 odt_legal['legalRange'] = 0
1370 odt_name_legal = odt_values['transformUserName']
1371 odt_legal = odt_values.copy()
1372 odt_aliases = ['out_%s' % compact(odt_name_legal)]
1374 if odt_name_legal in ['P3-D60 PQ (1000 nits)']:
1375 rrt_shaper = rrt_shaper_1000nits
1376 elif odt_name_legal in ['P3-D60 PQ (2000 nits)']:
1377 rrt_shaper = rrt_shaper_2000nits
1378 elif odt_name_legal in ['P3-D60 PQ (4000 nits)']:
1379 rrt_shaper = rrt_shaper_4000nits
1381 rrt_shaper = rrt_shaper_48nits
1383 cs = create_ACES_RRT_plus_ODT(
1392 colorspaces.append(cs)
1394 displays[odt_name_legal] = {
1395 'Raw': linear_display_space,
1396 'Log': log_display_space,
1397 'Output Transform': cs}
1399 return colorspaces, displays
1402 def get_transform_info(ctl_transform):
1409 Parameter description.
1414 Return value description.
1417 with open(ctl_transform, 'rb') as fp:
1418 lines = fp.readlines()
1420 # Retrieving the *transform ID* and *User Name*.
1421 transform_id = lines[1][3:].split('<')[1].split('>')[1].strip()
1422 transform_user_name = '-'.join(
1423 lines[2][3:].split('<')[1].split('>')[1].split('-')[1:]).strip()
1424 transform_user_name_prefix = (
1425 lines[2][3:].split('<')[1].split('>')[1].split('-')[0].strip())
1427 # Figuring out if this transform has options for processing *full* and
1429 transform_full_legal_switch = False
1431 if line.strip() == 'input varying int legalRange = 0':
1432 # print( '%s has legal range flag' % transform_user_name)
1433 transform_full_legal_switch = True
1436 return (transform_id,
1437 transform_user_name,
1438 transform_user_name_prefix,
1439 transform_full_legal_switch)
1442 def get_ODTs_info(aces_ctl_directory):
1446 For versions after WGR9.
1451 Parameter description.
1456 Return value description.
1459 # TODO: Investigate usage of *files_walker* definition here.
1460 # Credit to *Alex Fry* for the original approach here.
1461 odt_dir = os.path.join(aces_ctl_directory, 'odt')
1463 for dir_name, subdir_list, file_list in os.walk(odt_dir):
1464 for fname in file_list:
1465 all_odt.append((os.path.join(dir_name, fname)))
1467 odt_ctls = [x for x in all_odt if
1468 ('InvODT' not in x) and (os.path.split(x)[-1][0] != '.')]
1472 for odt_ctl in odt_ctls:
1473 odt_tokens = os.path.split(odt_ctl)
1475 # Handling nested directories.
1476 odt_path_tokens = os.path.split(odt_tokens[-2])
1477 odt_dir = odt_path_tokens[-1]
1478 while odt_path_tokens[-2][-3:] != 'odt':
1479 odt_path_tokens = os.path.split(odt_path_tokens[-2])
1480 odt_dir = os.path.join(odt_path_tokens[-1], odt_dir)
1482 # Building full name.
1483 transform_ctl = odt_tokens[-1]
1484 odt_name = string.join(transform_ctl.split('.')[1:-1], '.')
1486 # Finding id, user name and user name prefix.
1488 transform_user_name,
1489 transform_user_name_prefix,
1490 transform_full_legal_switch) = get_transform_info(
1491 os.path.join(aces_ctl_directory, 'odt', odt_dir, transform_ctl))
1494 transform_ctl_inverse = 'InvODT.%s.ctl' % odt_name
1495 if not os.path.exists(
1496 os.path.join(odt_tokens[-2], transform_ctl_inverse)):
1497 transform_ctl_inverse = None
1499 # Adding to list of *ODTs*.
1501 odts[odt_name]['transformCTL'] = os.path.join(odt_dir, transform_ctl)
1502 if transform_ctl_inverse is not None:
1503 odts[odt_name]['transformCTLInverse'] = os.path.join(
1504 odt_dir, transform_ctl_inverse)
1506 odts[odt_name]['transformID'] = transform_id
1507 odts[odt_name]['transformUserNamePrefix'] = transform_user_name_prefix
1508 odts[odt_name]['transformUserName'] = transform_user_name
1510 'transformHasFullLegalSwitch'] = transform_full_legal_switch
1512 forward_ctl = odts[odt_name]['transformCTL']
1514 print('ODT : %s' % odt_name)
1515 print('\tTransform ID : %s' % transform_id)
1516 print('\tTransform User Name Prefix : %s' % transform_user_name_prefix)
1517 print('\tTransform User Name : %s' % transform_user_name)
1519 '\tHas Full / Legal Switch : %s' % transform_full_legal_switch)
1520 print('\tForward ctl : %s' % forward_ctl)
1521 if 'transformCTLInverse' in odts[odt_name]:
1522 inverse_ctl = odts[odt_name]['transformCTLInverse']
1523 print('\tInverse ctl : %s' % inverse_ctl)
1525 print('\tInverse ctl : %s' % 'None')
1532 def get_LMTs_info(aces_ctl_directory):
1536 For versions after WGR9.
1541 Parameter description.
1546 Return value description.
1549 # TODO: Investigate refactoring with previous definition.
1551 # Credit to Alex Fry for the original approach here
1552 lmt_dir = os.path.join(aces_ctl_directory, 'lmt')
1554 for dir_name, subdir_list, file_list in os.walk(lmt_dir):
1555 for fname in file_list:
1556 all_lmt.append((os.path.join(dir_name, fname)))
1558 lmt_ctls = [x for x in all_lmt if
1559 ('InvLMT' not in x) and ('README' not in x) and (
1560 os.path.split(x)[-1][0] != '.')]
1564 for lmt_ctl in lmt_ctls:
1565 lmt_tokens = os.path.split(lmt_ctl)
1567 # Handlimg nested directories.
1568 lmt_path_tokens = os.path.split(lmt_tokens[-2])
1569 lmt_dir = lmt_path_tokens[-1]
1570 while lmt_path_tokens[-2][-3:] != 'ctl':
1571 lmt_path_tokens = os.path.split(lmt_path_tokens[-2])
1572 lmt_dir = os.path.join(lmt_path_tokens[-1], lmt_dir)
1574 # Building full name.
1575 transform_ctl = lmt_tokens[-1]
1576 lmt_name = string.join(transform_ctl.split('.')[1:-1], '.')
1578 # Finding id, user name and user name prefix.
1580 transform_user_name,
1581 transform_user_name_prefix,
1582 transform_full_legal_switch) = get_transform_info(
1583 os.path.join(aces_ctl_directory, lmt_dir, transform_ctl))
1586 transform_ctl_inverse = 'InvLMT.%s.ctl' % lmt_name
1587 if not os.path.exists(
1588 os.path.join(lmt_tokens[-2], transform_ctl_inverse)):
1589 transform_ctl_inverse = None
1592 lmts[lmt_name]['transformCTL'] = os.path.join(lmt_dir, transform_ctl)
1593 if transform_ctl_inverse is not None:
1594 lmts[lmt_name]['transformCTLInverse'] = os.path.join(
1595 lmt_dir, transform_ctl_inverse)
1597 lmts[lmt_name]['transformID'] = transform_id
1598 lmts[lmt_name]['transformUserNamePrefix'] = transform_user_name_prefix
1599 lmts[lmt_name]['transformUserName'] = transform_user_name
1601 forward_ctl = lmts[lmt_name]['transformCTL']
1603 print('LMT : %s' % lmt_name)
1604 print('\tTransform ID : %s' % transform_id)
1605 print('\tTransform User Name Prefix : %s' % transform_user_name_prefix)
1606 print('\tTransform User Name : %s' % transform_user_name)
1607 print('\t Forward ctl : %s' % forward_ctl)
1608 if 'transformCTLInverse' in lmts[lmt_name]:
1609 inverse_ctl = lmts[lmt_name]['transformCTLInverse']
1610 print('\t Inverse ctl : %s' % inverse_ctl)
1612 print('\t Inverse ctl : %s' % 'None')
1619 def create_colorspaces(aces_ctl_directory,
1628 Generates the colorspace conversions.
1633 Parameter description.
1638 Return value description.
1643 ACES = create_ACES()
1645 ACEScc = create_ACEScc(aces_ctl_directory, lut_directory,
1646 lut_resolution_1d, cleanup,
1647 min_value=-0.35840, max_value=1.468)
1648 colorspaces.append(ACEScc)
1650 ACESproxy = create_ACESproxy(aces_ctl_directory, lut_directory,
1651 lut_resolution_1d, cleanup)
1652 colorspaces.append(ACESproxy)
1654 ACEScg = create_ACEScg()
1655 colorspaces.append(ACEScg)
1657 ADX10 = create_ADX(lut_directory, bit_depth=10)
1658 colorspaces.append(ADX10)
1660 ADX16 = create_ADX(lut_directory, bit_depth=16)
1661 colorspaces.append(ADX16)
1663 lmts = create_LMTs(aces_ctl_directory,
1669 colorspaces.extend(lmts)
1671 odts, displays = create_ODTs(aces_ctl_directory,
1680 colorspaces.extend(odts)
1682 # TODO: Investigate if there is a way to retrieve these values from *CTL*.
1683 default_display = 'sRGB (D60 sim.)'
1684 color_picking = 'Rec.709'
1686 roles = {'color_picking': color_picking,
1687 'color_timing': ACEScc.name,
1688 'compositing_log': ACEScc.name,
1690 'default': ACES.name,
1691 'matte_paint': ACEScc.name,
1693 'scene_linear': ACEScg.name,
1694 'texture_paint': '',
1695 'compositing_linear': ACEScg.name,
1696 'rendering': ACEScg.name}
1698 return ACES, colorspaces, displays, ACEScc, roles, default_display