aces_1.0.0/python/aces_ocio/colorspaces/aces.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 """
   5 Implements support for *ACES* colorspaces conversions and transfer functions.
   6 """
   7
   8 from __future__ import division
   9
  10 import math
  11 import numpy
  12 import os
  13 import pprint
  14 import string
  15 import shutil
  16
  17 import PyOpenColorIO as ocio
  18
  19 from aces_ocio.generate_lut import (
  20     generate_1d_LUT_from_CTL,
  21     generate_3d_LUT_from_CTL,
  22     write_SPI_1d)
  23 from aces_ocio.utilities import (
  24     ColorSpace,
  25     mat44_from_mat33,
  26     sanitize,
  27     compact)
  28
  29 __author__ = 'ACES Developers'
  30 __copyright__ = 'Copyright (C) 2014 - 2015 - ACES Developers'
  31 __license__ = ''
  32 __maintainer__ = 'ACES Developers'
  33 __email__ = 'aces@oscars.org'
  34 __status__ = 'Production'
  35
  36 __all__ = ['ACES_AP1_TO_AP0',
  37            'ACES_AP0_TO_XYZ',
  38            'create_ACES',
  39            'create_ACEScc',
  40            'create_ACESproxy',
  41            'create_ACEScg',
  42            'create_ADX',
  43            'create_ACES_LMT',
  44            'create_ACES_RRT_plus_ODT',
  45            'create_generic_log',
  46            'create_LMTs',
  47            'create_ODTs',
  48            'get_transform_info',
  49            'get_ODTs_info',
  50            'get_LMTs_info',
  51            'create_colorspaces']
  52
  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]
  57
  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]
  62
  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]
  67
  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]
  72
  73
  74 def create_ACES():
  75     """
  76     Object description.
  77
  78     Parameters
  79     ----------
  80     parameter : type
  81         Parameter description.
  82
  83     Returns
  84     -------
  85     type
  86          Return value description.
  87     """
  88
  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]
  99
 100     return aces2065_1
 101
 102
 103 def create_ACEScc(aces_ctl_directory,
 104                   lut_directory,
 105                   lut_resolution_1d,
 106                   cleanup,
 107                   name='ACEScc',
 108                   min_value=0,
 109                   max_value=1,
 110                   input_scale=1):
 111     """
 112     Creates the *ACEScc* colorspace.
 113
 114     Parameters
 115     ----------
 116     parameter : type
 117         Parameter description.
 118
 119     Returns
 120     -------
 121     Colorspace
 122          *ACEScc* colorspace.
 123     """
 124
 125     cs = ColorSpace(name)
 126     cs.description = 'The %s color space' % name
 127     cs.aliases = ['acescc', 'acescc_ap1']
 128     cs.equality_group = ''
 129     cs.family = 'ACES'
 130     cs.is_data = False
 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'
 134
 135     ctls = [os.path.join(aces_ctl_directory,
 136                          'ACEScc',
 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,
 142                          'ACEScg',
 143                          'ACEScsc.ACES_to_ACEScg.a1.0.0.ctl')]
 144     lut = '%s_to_linear.spi1d' % name
 145
 146     lut = sanitize(lut)
 147
 148     generate_1d_LUT_from_CTL(
 149         os.path.join(lut_directory, lut),
 150         ctls,
 151         lut_resolution_1d,
 152         'float',
 153         input_scale,
 154         1,
 155         {},
 156         cleanup,
 157         aces_ctl_directory,
 158         min_value,
 159         max_value,
 160         1)
 161
 162     cs.to_reference_transforms = []
 163     cs.to_reference_transforms.append({
 164         'type': 'lutFile',
 165         'path': lut,
 166         'interpolation': 'linear',
 167         'direction': 'forward'})
 168
 169     # *AP1* primaries to *AP0* primaries.
 170     cs.to_reference_transforms.append({
 171         'type': 'matrix',
 172         'matrix': mat44_from_mat33(ACES_AP1_TO_AP0),
 173         'direction': 'forward'})
 174
 175     cs.from_reference_transforms = []
 176     return cs
 177
 178
 179 def create_ACESproxy(aces_ctl_directory,
 180                      lut_directory,
 181                      lut_resolution_1d,
 182                      cleanup,
 183                      name='ACESproxy'):
 184     """
 185     Creates the *ACESproxy* colorspace.
 186
 187     Parameters
 188     ----------
 189     parameter : type
 190         Parameter description.
 191
 192     Returns
 193     -------
 194     Colorspace
 195          *ACESproxy* colorspace.
 196     """
 197
 198     cs = ColorSpace(name)
 199     cs.description = 'The %s color space' % name
 200     cs.aliases = ['acesproxy', 'acesproxy_ap1']
 201     cs.equality_group = ''
 202     cs.family = 'ACES'
 203     cs.is_data = False
 204
 205     cs.aces_transform_id = 'ACEScsc.ACESproxy10i_to_ACES.a1.0.0'
 206
 207     ctls = [os.path.join(aces_ctl_directory,
 208                          'ACESproxy',
 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,
 214                          'ACEScg',
 215                          'ACEScsc.ACES_to_ACEScg.a1.0.0.ctl')]
 216     lut = '%s_to_linear.spi1d' % name
 217
 218     lut = sanitize(lut)
 219
 220     generate_1d_LUT_from_CTL(
 221         os.path.join(lut_directory, lut),
 222         ctls,
 223         lut_resolution_1d,
 224         'float',
 225         1,
 226         1,
 227         {},
 228         cleanup,
 229         aces_ctl_directory,
 230         0,
 231         1,
 232         1)
 233
 234     cs.to_reference_transforms = []
 235     cs.to_reference_transforms.append({
 236         'type': 'lutFile',
 237         'path': lut,
 238         'interpolation': 'linear',
 239         'direction': 'forward'})
 240
 241     # *AP1* primaries to *AP0* primaries.
 242     cs.to_reference_transforms.append({
 243         'type': 'matrix',
 244         'matrix': mat44_from_mat33(ACES_AP1_TO_AP0),
 245         'direction': 'forward'})
 246
 247     cs.from_reference_transforms = []
 248     return cs
 249
 250
 251 # -------------------------------------------------------------------------
 252 # *ACEScg*
 253 # -------------------------------------------------------------------------
 254 def create_ACEScg(aces_ctl_directory,
 255                   lut_directory,
 256                   lut_resolution_1d,
 257                   cleanup,
 258                   name='ACEScg'):
 259     """
 260     Creates the *ACEScg* colorspace.
 261
 262     Parameters
 263     ----------
 264     parameter : type
 265         Parameter description.
 266
 267     Returns
 268     -------
 269     Colorspace
 270          *ACEScg* colorspace.
 271     """
 272
 273     cs = ColorSpace(name)
 274     cs.description = 'The %s color space' % name
 275     cs.aliases = ['acescg', 'lin_ap1']
 276     cs.equality_group = ''
 277     cs.family = 'ACES'
 278     cs.is_data = False
 279     cs.allocation_type = ocio.Constants.ALLOCATION_LG2
 280     cs.allocation_vars = [-8, 5, 0.00390625]
 281
 282     cs.aces_transform_id = 'ACEScsc.ACEScg_to_ACES.a1.0.0'
 283
 284     cs.to_reference_transforms = []
 285
 286     # *AP1* primaries to *AP0* primaries.
 287     cs.to_reference_transforms.append({
 288         'type': 'matrix',
 289         'matrix': mat44_from_mat33(ACES_AP1_TO_AP0),
 290         'direction': 'forward'})
 291
 292     cs.from_reference_transforms = []
 293
 294     # *AP1* primaries to *AP0* primaries.
 295     cs.from_reference_transforms.append({
 296         'type': 'matrix',
 297         'matrix': mat44_from_mat33(ACES_AP0_TO_AP1),
 298         'direction': 'forward'})
 299
 300     return cs
 301
 302
 303 # -------------------------------------------------------------------------
 304 # *ADX*
 305 # -------------------------------------------------------------------------
 306 def create_ADX(lut_directory,
 307                lut_resolution_1d,
 308                bit_depth=10,
 309                name='ADX'):
 310     """
 311     Creates the *ADX* colorspace.
 312
 313     Parameters
 314     ----------
 315     parameter : type
 316         Parameter description.
 317
 318     Returns
 319     -------
 320     Colorspace
 321          *ADX* colorspace.
 322     """
 323
 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 = ''
 329     cs.family = 'ADX'
 330     cs.is_data = False
 331
 332     if bit_depth == 10:
 333         cs.aces_transform_id = 'ACEScsc.ADX10_to_ACES.a1.0.0'
 334
 335         cs.bit_depth = ocio.Constants.BIT_DEPTH_UINT10
 336         ADX_to_CDD = [1023 / 500, 0, 0, 0,
 337                       0, 1023 / 500, 0, 0,
 338                       0, 0, 1023 / 500, 0,
 339                       0, 0, 0, 1]
 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'
 343
 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,
 348                       0, 0, 0, 1]
 349         offset = [-1520 / 8000, -1520 / 8000, -1520 / 8000, 0]
 350
 351     cs.to_reference_transforms = []
 352
 353     # Converting from *ADX* to *Channel-Dependent Density*.
 354     cs.to_reference_transforms.append({
 355         'type': 'matrix',
 356         'matrix': ADX_to_CDD,
 357         'offset': offset,
 358         'direction': 'forward'})
 359
 360     # Convert from Channel-Dependent Density to Channel-Independent Density
 361     cs.to_reference_transforms.append({
 362         'type': 'matrix',
 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,
 366                    0, 0, 0, 1],
 367         'direction': 'forward'})
 368
 369     # Copied from *Alex Fry*'s *adx_cid_to_rle.py*
 370     def create_CID_to_RLE_LUT():
 371
 372         def interpolate_1d(x, xp, fp):
 373             return numpy.interp(x, xp, fp)
 374
 375         LUT_1D_XP = [-0.190000000000000,
 376                      0.010000000000000,
 377                      0.028000000000000,
 378                      0.054000000000000,
 379                      0.095000000000000,
 380                      0.145000000000000,
 381                      0.220000000000000,
 382                      0.300000000000000,
 383                      0.400000000000000,
 384                      0.500000000000000,
 385                      0.600000000000000]
 386
 387         LUT_1D_FP = [-6.000000000000000,
 388                      -2.721718645000000,
 389                      -2.521718645000000,
 390                      -2.321718645000000,
 391                      -2.121718645000000,
 392                      -1.921718645000000,
 393                      -1.721718645000000,
 394                      -1.521718645000000,
 395                      -1.321718645000000,
 396                      -1.121718645000000,
 397                      -0.926545676714876]
 398
 399         REF_PT = ((7120 - 1520) / 8000 * (100 / 55) -
 400                   math.log(0.18, 10))
 401
 402         def cid_to_rle(x):
 403             if x <= 0.6:
 404                 return interpolate_1d(x, LUT_1D_XP, LUT_1D_FP)
 405             return (100 / 55) * x - REF_PT
 406
 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
 412
 413         num_samples = 2 ** 12
 414         domain = (-0.19, 3)
 415         data = []
 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))
 420
 421         lut = 'ADX_CID_to_RLE.spi1d'
 422         write_SPI_1d(os.path.join(lut_directory, lut),
 423                      domain[0],
 424                      domain[1],
 425                      data,
 426                      num_samples, 1)
 427
 428         return lut
 429
 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({
 434         'type': 'lutFile',
 435         'path': lut,
 436         'interpolation': 'linear',
 437         'direction': 'forward'})
 438
 439     # Converting *Relative Log Exposure* values to
 440     # *Relative Exposure* values.
 441     cs.to_reference_transforms.append({
 442         'type': 'log',
 443         'base': 10,
 444         'direction': 'inverse'})
 445
 446     # Convert *Relative Exposure* values to *ACES* values.
 447     cs.to_reference_transforms.append({
 448         'type': 'matrix',
 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,
 452                    0, 0, 0, 1],
 453         'direction': 'forward'})
 454
 455     cs.from_reference_transforms = []
 456     return cs
 457
 458
 459 # -------------------------------------------------------------------------
 460 # *Generic Log Transform*
 461 # -------------------------------------------------------------------------
 462 def create_generic_log(aces_ctl_directory,
 463                        lut_directory,
 464                        lut_resolution_1d,
 465                        cleanup,
 466                        name='log',
 467                        aliases=None,
 468                        min_value=0,
 469                        max_value=1,
 470                        input_scale=1,
 471                        middle_grey=0.18,
 472                        min_exposure=-6,
 473                        max_exposure=6.5):
 474     """
 475     Creates the *Generic Log* colorspace.
 476
 477     Parameters
 478     ----------
 479     parameter : type
 480         Parameter description.
 481
 482     Returns
 483     -------
 484     Colorspace
 485          *Generic Log* colorspace.
 486     """
 487
 488     if aliases is None:
 489         aliases = []
 490
 491     cs = ColorSpace(name)
 492     cs.description = 'The %s color space' % name
 493     cs.aliases = aliases
 494     cs.equality_group = name
 495     cs.family = 'Utility'
 496     cs.is_data = False
 497
 498     ctls = [os.path.join(
 499         aces_ctl_directory,
 500         'utilities',
 501         'ACESlib.Log2_to_Lin_param.a1.0.0.ctl')]
 502     lut = '%s_to_linear.spi1d' % name
 503
 504     lut = sanitize(lut)
 505
 506     generate_1d_LUT_from_CTL(
 507         os.path.join(lut_directory, lut),
 508         ctls,
 509         lut_resolution_1d,
 510         'float',
 511         input_scale,
 512         1,
 513         {'middleGrey': middle_grey,
 514          'minExposure': min_exposure,
 515          'maxExposure': max_exposure},
 516         cleanup,
 517         aces_ctl_directory,
 518         min_value,
 519         max_value,
 520         1)
 521
 522     cs.to_reference_transforms = []
 523     cs.to_reference_transforms.append({
 524         'type': 'lutFile',
 525         'path': lut,
 526         'interpolation': 'linear',
 527         'direction': 'forward'})
 528
 529     cs.from_reference_transforms = []
 530     return cs
 531
 532
 533 # -------------------------------------------------------------------------
 534 # *base Dolby PQ Transform*
 535 # -------------------------------------------------------------------------
 536 def create_Dolby_PQ(aces_ctl_directory,
 537                    lut_directory,
 538                    lut_resolution_1d,
 539                    cleanup,
 540                    name='pq',
 541                    aliases=None,
 542                    min_value=0.0,
 543                    max_value=1.0,
 544                    input_scale=1.0):
 545     if aliases is None:
 546         aliases = []
 547
 548     cs = ColorSpace(name)
 549     cs.description = 'The %s color space' % name
 550     cs.aliases = aliases
 551     cs.equality_group = name
 552     cs.family = 'Utility'
 553     cs.is_data = False
 554
 555     ctls = [os.path.join(
 556         aces_ctl_directory,
 557         'utilities',
 558         'ACESlib.DolbyPQ_to_Lin.a1.0.0.ctl')]
 559     lut = '%s_to_linear.spi1d' % name
 560
 561     lut = sanitize(lut)
 562
 563     generate_1d_LUT_from_CTL(
 564         os.path.join(lut_directory, lut),
 565         ctls,
 566         lut_resolution_1d,
 567         'float',
 568         input_scale,
 569         1.0,
 570         {},
 571         cleanup,
 572         aces_ctl_directory,
 573         min_value,
 574         max_value)
 575
 576     cs.to_reference_transforms = []
 577     cs.to_reference_transforms.append({
 578         'type': 'lutFile',
 579         'path': lut,
 580         'interpolation': 'linear',
 581         'direction': 'forward'})
 582
 583     cs.from_reference_transforms = []
 584     return cs
 585
 586
 587 # -------------------------------------------------------------------------
 588 # *Dolby PQ Transform that considers a fixed linear range*
 589 # -------------------------------------------------------------------------
 590 def create_Dolby_PQ_scaled(aces_ctl_directory,
 591                           lut_directory,
 592                           lut_resolution_1d,
 593                           cleanup,
 594                           name='pq',
 595                           aliases=None,
 596                           min_value=0.0,
 597                           max_value=1.0,
 598                           input_scale=1.0,
 599                           middle_grey=0.18,
 600                           min_exposure=-6.0,
 601                           max_exposure=6.5):
 602     if aliases is None:
 603         aliases = []
 604
 605     cs = ColorSpace(name)
 606     cs.description = 'The %s color space' % name
 607     cs.aliases = aliases
 608     cs.equality_group = name
 609     cs.family = 'Utility'
 610     cs.is_data = False
 611
 612     ctls = [os.path.join(
 613         aces_ctl_directory,
 614         'utilities',
 615         'ACESlib.DolbyPQ_to_lin_param.a1.0.0.ctl')]
 616     lut = '%s_to_linear.spi1d' % name
 617
 618     lut = sanitize(lut)
 619
 620     generate_1d_LUT_from_CTL(
 621         os.path.join(lut_directory, lut),
 622         ctls,
 623         lut_resolution_1d,
 624         'float',
 625         input_scale,
 626         1.0,
 627         {'middleGrey': middle_grey,
 628          'minExposure': min_exposure,
 629          'maxExposure': max_exposure},
 630         cleanup,
 631         aces_ctl_directory,
 632         min_value,
 633         max_value)
 634
 635     cs.to_reference_transforms = []
 636     cs.to_reference_transforms.append({
 637         'type': 'lutFile',
 638         'path': lut,
 639         'interpolation': 'linear',
 640         'direction': 'forward'})
 641
 642     cs.from_reference_transforms = []
 643     return cs
 644
 645
 646 # -------------------------------------------------------------------------
 647 # *Individual LMT*
 648 # -------------------------------------------------------------------------
 649 def create_ACES_LMT(lmt_name,
 650                     lmt_values,
 651                     shaper_info,
 652                     aces_ctl_directory,
 653                     lut_directory,
 654                     lut_resolution_1d=1024,
 655                     lut_resolution_3d=64,
 656                     cleanup=True,
 657                     aliases=None):
 658     """
 659     Creates the *ACES LMT* colorspace.
 660
 661     Parameters
 662     ----------
 663     parameter : type
 664         Parameter description.
 665
 666     Returns
 667     -------
 668     Colorspace
 669          *ACES LMT* colorspace.
 670     """
 671
 672     if aliases is None:
 673         aliases = []
 674
 675     cs = ColorSpace('%s' % lmt_name)
 676     cs.description = 'The ACES Look Transform: %s' % lmt_name
 677     cs.aliases = aliases
 678     cs.equality_group = ''
 679     cs.family = 'Look'
 680     cs.is_data = False
 681     cs.allocation_type = ocio.Constants.ALLOCATION_LG2
 682     cs.allocation_vars = [-8, 5, 0.00390625]
 683     cs.aces_transform_id = lmt_values['transformID']
 684
 685     pprint.pprint(lmt_values)
 686
 687     # Generating the *shaper* transform.
 688     (shaper_name,
 689      shaper_to_aces_ctl,
 690      shaper_from_aces_ctl,
 691      shaper_input_scale,
 692      shaper_params) = shaper_info
 693
 694     # Add the shaper transform
 695     shaper_lut = '%s_to_linear.spi1d' % shaper_name
 696     shaper_lut = sanitize(shaper_lut)
 697
 698     shaper_ocio_transform = {
 699         'type': 'lutFile',
 700         'path': shaper_lut,
 701         'interpolation': 'linear',
 702         'direction': 'inverse'}
 703
 704     # Generating the forward transform.
 705     cs.from_reference_transforms = []
 706
 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)
 712
 713         lut = sanitize(lut)
 714
 715         generate_3d_LUT_from_CTL(
 716             os.path.join(lut_directory, lut),
 717             ctls,
 718             lut_resolution_3d,
 719             'float',
 720             1 / shaper_input_scale,
 721             1,
 722             shaper_params,
 723             cleanup,
 724             aces_ctl_directory)
 725
 726         cs.from_reference_transforms.append(shaper_ocio_transform)
 727         cs.from_reference_transforms.append({
 728             'type': 'lutFile',
 729             'path': lut,
 730             'interpolation': 'tetrahedral',
 731             'direction': 'forward'})
 732
 733     # Generating the inverse transform.
 734     cs.to_reference_transforms = []
 735
 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         # TODO: Investigate unresolved `odt_name` reference.
 741         lut = 'Inverse.%s.%s.spi3d' % (odt_name, shaper_name)
 742
 743         lut = sanitize(lut)
 744
 745         generate_3d_LUT_from_CTL(
 746             os.path.join(lut_directory, lut),
 747             ctls,
 748             lut_resolution_3d,
 749             'half',
 750             1,
 751             shaper_input_scale,
 752             shaper_params,
 753             cleanup,
 754             aces_ctl_directory,
 755             0)
 756
 757         cs.to_reference_transforms.append({
 758             'type': 'lutFile',
 759             'path': lut,
 760             'interpolation': 'tetrahedral',
 761             'direction': 'forward'})
 762
 763         shaper_inverse = shaper_ocio_transform.copy()
 764         shaper_inverse['direction'] = 'forward'
 765         cs.to_reference_transforms.append(shaper_inverse)
 766
 767     return cs
 768
 769
 770 # -------------------------------------------------------------------------
 771 # *LMTs*
 772 # -------------------------------------------------------------------------
 773 def create_LMTs(aces_ctl_directory,
 774                 lut_directory,
 775                 lut_resolution_1d,
 776                 lut_resolution_3d,
 777                 lmt_info,
 778                 shaper_name,
 779                 cleanup):
 780     """
 781     Object description.
 782
 783     Parameters
 784     ----------
 785     parameter : type
 786         Parameter description.
 787
 788     Returns
 789     -------
 790     type
 791          Return value description.
 792     """
 793
 794     colorspaces = []
 795
 796     # -------------------------------------------------------------------------
 797     # *LMT Shaper*
 798     # -------------------------------------------------------------------------
 799     lmt_lut_resolution_1d = max(4096, lut_resolution_1d)
 800     lmt_lut_resolution_3d = max(65, lut_resolution_3d)
 801
 802     # Defining the *Log 2* shaper.
 803     lmt_shaper_name = 'LMT Shaper'
 804     lmt_shaper_name_aliases = ['crv_lmtshaper']
 805     lmt_params = {
 806         'middleGrey': 0.18,
 807         'minExposure': -10,
 808         'maxExposure': 6.5}
 809
 810     lmt_shaper = create_generic_log(aces_ctl_directory,
 811                                     lut_directory,
 812                                     lmt_lut_resolution_1d,
 813                                     cleanup,
 814                                     name=lmt_shaper_name,
 815                                     middle_grey=lmt_params['middleGrey'],
 816                                     min_exposure=lmt_params['minExposure'],
 817                                     max_exposure=lmt_params['maxExposure'],
 818                                     aliases=lmt_shaper_name_aliases)
 819     colorspaces.append(lmt_shaper)
 820
 821     shaper_input_scale_generic_log2 = 1
 822
 823     # *Log 2* shaper name and *CTL* transforms bundled up.
 824     lmt_shaper_data = [
 825         lmt_shaper_name,
 826         os.path.join('%s',
 827                      'utilities',
 828                      'ACESlib.Log2_to_Lin_param.a1.0.0.ctl'),
 829         os.path.join('%s',
 830                      'utilities',
 831                      'ACESlib.Lin_to_Log2_param.a1.0.0.ctl'),
 832         shaper_input_scale_generic_log2,
 833         lmt_params]
 834
 835     sorted_lmts = sorted(lmt_info.iteritems(), key=lambda x: x[1])
 836     print(sorted_lmts)
 837     for lmt in sorted_lmts:
 838         lmt_name, lmt_values = lmt
 839         lmt_aliases = ['look_%s' % compact(lmt_values['transformUserName'])]
 840         cs = create_ACES_LMT(
 841             lmt_values['transformUserName'],
 842             lmt_values,
 843             lmt_shaper_data,
 844             aces_ctl_directory,
 845             lut_directory,
 846             lmt_lut_resolution_1d,
 847             lmt_lut_resolution_3d,
 848             cleanup,
 849             lmt_aliases)
 850         colorspaces.append(cs)
 851
 852     return colorspaces
 853
 854
 855 # -------------------------------------------------------------------------
 856 # *ACES RRT* with supplied *ODT*.
 857 # -------------------------------------------------------------------------
 858 def create_ACES_RRT_plus_ODT(odt_name,
 859                              odt_values,
 860                              shaper_info,
 861                              aces_ctl_directory,
 862                              lut_directory,
 863                              lut_resolution_1d=1024,
 864                              lut_resolution_3d=64,
 865                              cleanup=True,
 866                              aliases=None):
 867     """
 868     Object description.
 869
 870     Parameters
 871     ----------
 872     parameter : type
 873         Parameter description.
 874
 875     Returns
 876     -------
 877     type
 878          Return value description.
 879     """
 880
 881     if aliases is None:
 882         aliases = []
 883
 884     cs = ColorSpace('%s' % odt_name)
 885     cs.description = '%s - %s Output Transform' % (
 886         odt_values['transformUserNamePrefix'], odt_name)
 887     cs.aliases = aliases
 888     cs.equality_group = ''
 889     cs.family = 'Output'
 890     cs.is_data = False
 891
 892     cs.aces_transform_id = odt_values['transformID']
 893
 894     pprint.pprint(odt_values)
 895
 896     # Generating the *shaper* transform.
 897     (shaper_name,
 898      shaper_to_aces_ctl,
 899      shaper_from_aces_ctl,
 900      shaper_input_scale,
 901      shaper_params) = shaper_info
 902
 903     if 'legalRange' in odt_values:
 904         shaper_params['legalRange'] = odt_values['legalRange']
 905     else:
 906         shaper_params['legalRange'] = 0
 907
 908     # Add the shaper transform
 909     shaper_lut = '%s_to_linear.spi1d' % shaper_name
 910     shaper_lut = sanitize(shaper_lut)
 911
 912     shaper_ocio_transform = {
 913         'type': 'lutFile',
 914         'path': shaper_lut,
 915         'interpolation': 'linear',
 916         'direction': 'inverse'}
 917
 918     # Generating the *forward* transform.
 919     cs.from_reference_transforms = []
 920
 921     if 'transformLUT' in odt_values:
 922         transform_lut_file_name = os.path.basename(
 923             odt_values['transformLUT'])
 924         lut = os.path.join(lut_directory, transform_lut_file_name)
 925         shutil.copy(odt_values['transformLUT'], lut)
 926
 927         cs.from_reference_transforms.append(shaper_ocio_transform)
 928         cs.from_reference_transforms.append({
 929             'type': 'lutFile',
 930             'path': transform_lut_file_name,
 931             'interpolation': 'tetrahedral',
 932             'direction': 'forward'})
 933     elif 'transformCTL' in odt_values:
 934         ctls = [
 935             shaper_to_aces_ctl % aces_ctl_directory,
 936             os.path.join(aces_ctl_directory,
 937                          'rrt',
 938                          'RRT.a1.0.0.ctl'),
 939             os.path.join(aces_ctl_directory,
 940                          'odt',
 941                          odt_values['transformCTL'])]
 942         lut = '%s.RRT.a1.0.0.%s.spi3d' % (shaper_name, odt_name)
 943
 944         lut = sanitize(lut)
 945
 946         generate_3d_LUT_from_CTL(
 947             os.path.join(lut_directory, lut),
 948             # shaperLUT,
 949             ctls,
 950             lut_resolution_3d,
 951             'float',
 952             1 / shaper_input_scale,
 953             1,
 954             shaper_params,
 955             cleanup,
 956             aces_ctl_directory)
 957
 958         cs.from_reference_transforms.append(shaper_ocio_transform)
 959         cs.from_reference_transforms.append({
 960             'type': 'lutFile',
 961             'path': lut,
 962             'interpolation': 'tetrahedral',
 963             'direction': 'forward'})
 964
 965     # Generating the *inverse* transform.
 966     cs.to_reference_transforms = []
 967
 968     if 'transformLUTInverse' in odt_values:
 969         transform_lut_inverse_file_name = os.path.basename(
 970             odt_values['transformLUTInverse'])
 971         lut = os.path.join(lut_directory, transform_lut_inverse_file_name)
 972         shutil.copy(odt_values['transformLUTInverse'], lut)
 973
 974         cs.to_reference_transforms.append({
 975             'type': 'lutFile',
 976             'path': transform_lut_inverse_file_name,
 977             'interpolation': 'tetrahedral',
 978             'direction': 'forward'})
 979
 980         shaper_inverse = shaper_ocio_transform.copy()
 981         shaper_inverse['direction'] = 'forward'
 982         cs.to_reference_transforms.append(shaper_inverse)
 983     elif 'transformCTLInverse' in odt_values:
 984         ctls = [os.path.join(aces_ctl_directory,
 985                              'odt',
 986                              odt_values['transformCTLInverse']),
 987                 os.path.join(aces_ctl_directory,
 988                              'rrt',
 989                              'InvRRT.a1.0.0.ctl'),
 990                 shaper_from_aces_ctl % aces_ctl_directory]
 991         lut = 'InvRRT.a1.0.0.%s.%s.spi3d' % (odt_name, shaper_name)
 992
 993         lut = sanitize(lut)
 994
 995         generate_3d_LUT_from_CTL(
 996             os.path.join(lut_directory, lut),
 997             # None,
 998             ctls,
 999             lut_resolution_3d,
1000             'half',
1001             1,
1002             shaper_input_scale,
1003             shaper_params,
1004             cleanup,
1005             aces_ctl_directory)
1006
1007         cs.to_reference_transforms.append({
1008             'type': 'lutFile',
1009             'path': lut,
1010             'interpolation': 'tetrahedral',
1011             'direction': 'forward'})
1012
1013         shaper_inverse = shaper_ocio_transform.copy()
1014         shaper_inverse['direction'] = 'forward'
1015         cs.to_reference_transforms.append(shaper_inverse)
1016
1017     return cs
1018
1019
1020 # -------------------------------------------------------------------------
1021 # *ODTs*
1022 # -------------------------------------------------------------------------
1023 def create_ODTs(aces_ctl_directory,
1024                 lut_directory,
1025                 lut_resolution_1d,
1026                 lut_resolution_3d,
1027                 odt_info,
1028                 shaper_name,
1029                 cleanup,
1030                 linear_display_space,
1031                 log_display_space):
1032     """
1033     Object description.
1034
1035     Parameters
1036     ----------
1037     parameter : type
1038         Parameter description.
1039
1040     Returns
1041     -------
1042     type
1043          Return value description.
1044     """
1045
1046     colorspaces = []
1047     displays = {}
1048
1049     # -------------------------------------------------------------------------
1050     # *RRT / ODT* Shaper Options
1051     # -------------------------------------------------------------------------
1052     shaper_data = {}
1053
1054     # Defining the *Log 2* shaper.
1055     log2_shaper_name = shaper_name
1056     log2_shaper_name_aliases = ['crv_%s' % compact(log2_shaper_name)]
1057     log2_params = {
1058         'middleGrey': 0.18,
1059         'minExposure': -6,
1060         'maxExposure': 6.5}
1061
1062     log2_shaper_colorspace = create_generic_log(
1063         aces_ctl_directory,
1064         lut_directory,
1065         lut_resolution_1d,
1066         cleanup,
1067         name=log2_shaper_name,
1068         middle_grey=log2_params['middleGrey'],
1069         min_exposure=log2_params['minExposure'],
1070         max_exposure=log2_params['maxExposure'],
1071         aliases=log2_shaper_name_aliases)
1072     colorspaces.append(log2_shaper_colorspace)
1073
1074     shaper_input_scale_generic_log2 = 1
1075
1076     # *Log 2* shaper name and *CTL* transforms bundled up.
1077     log2_shaper_data = [
1078         log2_shaper_name,
1079         os.path.join('%s',
1080                      'utilities',
1081                      'ACESlib.Log2_to_Lin_param.a1.0.0.ctl'),
1082         os.path.join('%s',
1083                      'utilities',
1084                      'ACESlib.Lin_to_Log2_param.a1.0.0.ctl'),
1085         shaper_input_scale_generic_log2,
1086         log2_params]
1087
1088     shaper_data[log2_shaper_name] = log2_shaper_data
1089
1090     # Space with a more user-friendly name. Direct copy otherwise.
1091     log2_shaper_copy_name = 'Log2 Shaper'
1092     log2_shaper_copy_colorspace = ColorSpace(log2_shaper_copy_name)
1093     log2_shaper_copy_colorspace.description = (
1094         'The %s color space' % log2_shaper_copy_name)
1095     log2_shaper_copy_colorspace.aliases = [
1096         'crv_%s' % compact(log2_shaper_copy_name)]
1097     log2_shaper_copy_colorspace.equality_group = log2_shaper_copy_name
1098     log2_shaper_copy_colorspace.family = log2_shaper_colorspace.family
1099     log2_shaper_copy_colorspace.is_data = log2_shaper_colorspace.is_data
1100     log2_shaper_copy_colorspace.to_reference_transforms = list(
1101         log2_shaper_colorspace.to_reference_transforms)
1102     log2_shaper_copy_colorspace.from_reference_transforms = list(
1103         log2_shaper_colorspace.from_reference_transforms)
1104     colorspaces.append(log2_shaper_copy_colorspace)
1105
1106     # Defining the *Log2 shaper that includes the AP1* primaries.
1107     log2_shaper_api1_name = '%s - AP1' % 'Log2 Shaper'
1108     log2_shaper_api1_colorspace = ColorSpace(log2_shaper_api1_name)
1109     log2_shaper_api1_colorspace.description = (
1110         'The %s color space' % log2_shaper_api1_name)
1111     log2_shaper_api1_colorspace.aliases = [
1112         '%s_ap1' % compact(log2_shaper_copy_name)]
1113     log2_shaper_api1_colorspace.equality_group = log2_shaper_api1_name
1114     log2_shaper_api1_colorspace.family = log2_shaper_colorspace.family
1115     log2_shaper_api1_colorspace.is_data = log2_shaper_colorspace.is_data
1116     log2_shaper_api1_colorspace.to_reference_transforms = list(
1117         log2_shaper_colorspace.to_reference_transforms)
1118     log2_shaper_api1_colorspace.from_reference_transforms = list(
1119         log2_shaper_colorspace.from_reference_transforms)
1120
1121     # *AP1* primaries to *AP0* primaries.
1122     log2_shaper_api1_colorspace.to_reference_transforms.append({
1123         'type': 'matrix',
1124         'matrix': mat44_from_mat33(ACES_AP1_TO_AP0),
1125         'direction': 'forward'
1126     })
1127     colorspaces.append(log2_shaper_api1_colorspace)
1128
1129     # Defining the *Log2 shaper that includes the AP1* primaries.
1130     # Named with 'shaper_name' variable. Needed for some LUT baking steps.
1131     shaper_api1_name = '%s - AP1' % shaper_name
1132     shaper_api1_colorspace = ColorSpace(shaper_api1_name)
1133     shaper_api1_colorspace.description = (
1134         'The %s color space' % shaper_api1_name)
1135     shaper_api1_colorspace.aliases = ['%s_ap1' % compact(shaper_name)]
1136     shaper_api1_colorspace.equality_group = shaper_api1_name
1137     shaper_api1_colorspace.family = log2_shaper_colorspace.family
1138     shaper_api1_colorspace.is_data = log2_shaper_colorspace.is_data
1139     shaper_api1_colorspace.to_reference_transforms = list(
1140         log2_shaper_api1_colorspace.to_reference_transforms)
1141     shaper_api1_colorspace.from_reference_transforms = list(
1142         log2_shaper_api1_colorspace.from_reference_transforms)
1143     colorspaces.append(shaper_api1_colorspace)
1144
1145     # Define the base *Dolby PQ Shaper*
1146     #
1147     dolbypq_shaper_name = 'Dolby PQ 10000'
1148     dolbypq_shaper_name_aliases = ['crv_%s' % 'dolbypq_10000']
1149
1150     dolbypq_shaper_colorspace = create_Dolby_PQ(
1151         aces_ctl_directory,
1152         lut_directory,
1153         lut_resolution_1d,
1154         cleanup,
1155         name=dolbypq_shaper_name,
1156         aliases=dolbypq_shaper_name_aliases)
1157     colorspaces.append(dolbypq_shaper_colorspace)
1158
1159     # *Dolby PQ* shaper name and *CTL* transforms bundled up.
1160     dolbypq_shaper_data = [
1161         dolbypq_shaper_name,
1162         os.path.join('%s',
1163                      'utilities',
1164                      'ACESlib.DolbyPQ_to_Lin.a1.0.0.ctl'),
1165         os.path.join('%s',
1166                      'utilities',
1167                      'ACESlib.Lin_to_DolbyPQ.a1.0.0.ctl'),
1168         1.0,
1169         {}]
1170
1171     shaper_data[dolbypq_shaper_name] = dolbypq_shaper_data
1172
1173     # Define the *Dolby PQ Shaper that considers a fixed linear range*
1174     #
1175     dolbypq_scaled_shaper_name = 'Dolby PQ Scaled'
1176     dolbypq_scaled_shaper_name_aliases = ['crv_%s' % 'dolbypq_scaled']
1177
1178     dolbypq_scaled_shaper_colorspace = create_Dolby_PQ_scaled(
1179         aces_ctl_directory,
1180         lut_directory,
1181         lut_resolution_1d,
1182         cleanup,
1183         name=dolbypq_scaled_shaper_name,
1184         aliases=dolbypq_scaled_shaper_name_aliases)
1185     colorspaces.append(dolbypq_scaled_shaper_colorspace)
1186
1187     # *Dolby PQ* shaper name and *CTL* transforms bundled up.
1188     dolbypq_scaled_shaper_data = [
1189         dolbypq_scaled_shaper_name,
1190         os.path.join('%s',
1191                      'utilities',
1192                      'ACESlib.DolbyPQ_to_Lin_param.a1.0.0.ctl'),
1193         os.path.join('%s',
1194                      'utilities',
1195                      'ACESlib.Lin_to_DolbyPQ_param.a1.0.0.ctl'),
1196         1.0,
1197         log2_params]
1198
1199     shaper_data[dolbypq_scaled_shaper_name] = dolbypq_scaled_shaper_data
1200
1201     #
1202     # Pick a specific shaper
1203     #
1204     rrt_shaper = log2_shaper_data
1205     # rrt_shaper = dolbypq_scaled_shaper_data
1206
1207     # *RRT + ODT* combinations.
1208     sorted_odts = sorted(odt_info.iteritems(), key=lambda x: x[1])
1209     print(sorted_odts)
1210     for odt in sorted_odts:
1211         (odt_name, odt_values) = odt
1212
1213         # Generating only full range transform for *ODTs* that can generate
1214         # either *legal* or *full* output.
1215
1216         # Uncomment these lines and the lower section and
1217         # flip the 'legalRange' value to 1 to recover the old behavior,
1218         # where both legal and full range LUTs were generated.
1219         if odt_values['transformHasFullLegalSwitch']:
1220             # odt_name_legal = '%s - Legal' % odt_values['transformUserName']
1221             odt_legal['legalRange'] = 0
1222         # else:
1223         #    odt_name_legal = odt_values['transformUserName']
1224
1225         odt_name_legal = odt_values['transformUserName']
1226
1227         odt_legal = odt_values.copy()
1228
1229         odt_aliases = ['out_%s' % compact(odt_name_legal)]
1230
1231         cs = create_ACES_RRT_plus_ODT(
1232             odt_name_legal,
1233             odt_legal,
1234             rrt_shaper,
1235             aces_ctl_directory,
1236             lut_directory,
1237             lut_resolution_1d,
1238             lut_resolution_3d,
1239             cleanup,
1240             odt_aliases)
1241         colorspaces.append(cs)
1242
1243         displays[odt_name_legal] = {
1244             'Raw': linear_display_space,
1245             'Log': log_display_space,
1246             'Output Transform': cs}
1247
1248         """
1249         # Generating full range transform for *ODTs* that can generate
1250         # either *legal* or *full* output.
1251         if odt_values['transformHasFullLegalSwitch']:
1252             print('Generating full range ODT for %s' % odt_name)
1253
1254             odt_name_full = '%s - Full' % odt_values['transformUserName']
1255             odt_full = odt_values.copy()
1256             odt_full['legalRange'] = 0
1257
1258             odt_full_aliases = ['out_%s' % compact(odt_name_full)]
1259
1260             cs_full = create_ACES_RRT_plus_ODT(
1261                 odt_name_full,
1262                 odt_full,
1263                 rrt_shaper,
1264                 aces_ctl_directory,
1265                 lut_directory,
1266                 lut_resolution_1d,
1267                 lut_resolution_3d,
1268                 cleanup,
1269                 odt_full_aliases)
1270             colorspaces.append(cs_full)
1271
1272             displays[odt_name_full] = {
1273                 'Raw': linear_display_space,
1274                 'Log': log_display_space,
1275                 'Output Transform': cs_full}
1276         """
1277
1278     return colorspaces, displays
1279
1280
1281 def get_transform_info(ctl_transform):
1282     """
1283     Object description.
1284
1285     Parameters
1286     ----------
1287     parameter : type
1288         Parameter description.
1289
1290     Returns
1291     -------
1292     type
1293          Return value description.
1294     """
1295
1296     with open(ctl_transform, 'rb') as fp:
1297         lines = fp.readlines()
1298
1299     # Retrieving the *transform ID* and *User Name*.
1300     transform_id = lines[1][3:].split('<')[1].split('>')[1].strip()
1301     transform_user_name = '-'.join(
1302         lines[2][3:].split('<')[1].split('>')[1].split('-')[1:]).strip()
1303     transform_user_name_prefix = (
1304         lines[2][3:].split('<')[1].split('>')[1].split('-')[0].strip())
1305
1306     # Figuring out if this transform has options
1307     # for processing full and legal range.
1308     transform_full_legal_switch = False
1309     for line in lines:
1310         if line.strip() == 'input varying int legalRange = 0':
1311             # print( '%s has legal range flag' % transform_user_name)
1312             transform_full_legal_switch = True
1313             break
1314
1315     return (transform_id, transform_user_name, transform_user_name_prefix,
1316             transform_full_legal_switch)
1317
1318
1319 def get_ODTs_info(aces_ctl_directory):
1320     """
1321     Object description.
1322
1323     For versions after WGR9.
1324
1325     Parameters
1326     ----------
1327     parameter : type
1328         Parameter description.
1329
1330     Returns
1331     -------
1332     type
1333          Return value description.
1334     """
1335
1336     # TODO: Investigate usage of *files_walker* definition here.
1337     # Credit to *Alex Fry* for the original approach here.
1338     odt_dir = os.path.join(aces_ctl_directory, 'odt')
1339     all_odt = []
1340     for dir_name, subdir_list, file_list in os.walk(odt_dir):
1341         for fname in file_list:
1342             all_odt.append((os.path.join(dir_name, fname)))
1343
1344     odt_ctls = [x for x in all_odt if
1345                 ('InvODT' not in x) and (os.path.split(x)[-1][0] != '.')]
1346
1347     odts = {}
1348
1349     for odt_ctl in odt_ctls:
1350         odt_tokens = os.path.split(odt_ctl)
1351
1352         # Handling nested directories.
1353         odt_path_tokens = os.path.split(odt_tokens[-2])
1354         odt_dir = odt_path_tokens[-1]
1355         while odt_path_tokens[-2][-3:] != 'odt':
1356             odt_path_tokens = os.path.split(odt_path_tokens[-2])
1357             odt_dir = os.path.join(odt_path_tokens[-1], odt_dir)
1358
1359         # Building full name,
1360         transform_ctl = odt_tokens[-1]
1361         odt_name = string.join(transform_ctl.split('.')[1:-1], '.')
1362
1363         # Finding id, user name and user name prefix.
1364         (transform_id,
1365          transform_user_name,
1366          transform_user_name_prefix,
1367          transform_full_legal_switch) = get_transform_info(
1368             os.path.join(aces_ctl_directory, 'odt', odt_dir, transform_ctl))
1369
1370         # Finding inverse.
1371         transform_ctl_inverse = 'InvODT.%s.ctl' % odt_name
1372         if not os.path.exists(
1373                 os.path.join(odt_tokens[-2], transform_ctl_inverse)):
1374             transform_ctl_inverse = None
1375
1376         # Add to list of ODTs
1377         odts[odt_name] = {}
1378         odts[odt_name]['transformCTL'] = os.path.join(odt_dir, transform_ctl)
1379         if transform_ctl_inverse is not None:
1380             odts[odt_name]['transformCTLInverse'] = os.path.join(
1381                 odt_dir, transform_ctl_inverse)
1382
1383         odts[odt_name]['transformID'] = transform_id
1384         odts[odt_name]['transformUserNamePrefix'] = transform_user_name_prefix
1385         odts[odt_name]['transformUserName'] = transform_user_name
1386         odts[odt_name][
1387             'transformHasFullLegalSwitch'] = transform_full_legal_switch
1388
1389         forward_ctl = odts[odt_name]['transformCTL']
1390
1391         print('ODT : %s' % odt_name)
1392         print('\tTransform ID               : %s' % transform_id)
1393         print('\tTransform User Name Prefix : %s' % transform_user_name_prefix)
1394         print('\tTransform User Name        : %s' % transform_user_name)
1395         print(
1396             '\tHas Full / Legal Switch    : %s' % transform_full_legal_switch)
1397         print('\tForward ctl                : %s' % forward_ctl)
1398         if 'transformCTLInverse' in odts[odt_name]:
1399             inverse_ctl = odts[odt_name]['transformCTLInverse']
1400             print('\tInverse ctl                : %s' % inverse_ctl)
1401         else:
1402             print('\tInverse ctl                : %s' % 'None')
1403
1404     print('\n')
1405
1406     return odts
1407
1408
1409 def get_LMTs_info(aces_ctl_directory):
1410     """
1411     Object description.
1412
1413     For versions after WGR9.
1414
1415     Parameters
1416     ----------
1417     parameter : type
1418         Parameter description.
1419
1420     Returns
1421     -------
1422     type
1423          Return value description.
1424     """
1425
1426     # TODO: Investigate refactoring with previous definition.
1427
1428     # Credit to Alex Fry for the original approach here
1429     lmt_dir = os.path.join(aces_ctl_directory, 'lmt')
1430     all_lmt = []
1431     for dir_name, subdir_list, file_list in os.walk(lmt_dir):
1432         for fname in file_list:
1433             all_lmt.append((os.path.join(dir_name, fname)))
1434
1435     lmt_ctls = [x for x in all_lmt if
1436                 ('InvLMT' not in x) and ('README' not in x) and (
1437                     os.path.split(x)[-1][0] != '.')]
1438
1439     lmts = {}
1440
1441     for lmt_ctl in lmt_ctls:
1442         lmt_tokens = os.path.split(lmt_ctl)
1443
1444         # Handlimg nested directories.
1445         lmt_path_tokens = os.path.split(lmt_tokens[-2])
1446         lmt_dir = lmt_path_tokens[-1]
1447         while lmt_path_tokens[-2][-3:] != 'ctl':
1448             lmt_path_tokens = os.path.split(lmt_path_tokens[-2])
1449             lmt_dir = os.path.join(lmt_path_tokens[-1], lmt_dir)
1450
1451         # Building full name.
1452         transform_CTL = lmt_tokens[-1]
1453         lmt_name = string.join(transform_CTL.split('.')[1:-1], '.')
1454
1455         # Finding id, user name and user name prefix.
1456         (transform_id,
1457          transform_user_name,
1458          transform_user_name_prefix,
1459          transform_full_legal_switch) = get_transform_info(
1460             os.path.join(aces_ctl_directory, lmt_dir, transform_CTL))
1461
1462         # Finding inverse.
1463         transform_ctl_inverse = 'InvLMT.%s.ctl' % lmt_name
1464         if not os.path.exists(
1465                 os.path.join(lmt_tokens[-2], transform_ctl_inverse)):
1466             transform_ctl_inverse = None
1467
1468         lmts[lmt_name] = {}
1469         lmts[lmt_name]['transformCTL'] = os.path.join(lmt_dir, transform_CTL)
1470         if transform_ctl_inverse is not None:
1471             lmts[lmt_name]['transformCTLInverse'] = os.path.join(
1472                 lmt_dir, transform_ctl_inverse)
1473
1474         lmts[lmt_name]['transformID'] = transform_id
1475         lmts[lmt_name]['transformUserNamePrefix'] = transform_user_name_prefix
1476         lmts[lmt_name]['transformUserName'] = transform_user_name
1477
1478         forward_ctl = lmts[lmt_name]['transformCTL']
1479
1480         print('LMT : %s' % lmt_name)
1481         print('\tTransform ID               : %s' % transform_id)
1482         print('\tTransform User Name Prefix : %s' % transform_user_name_prefix)
1483         print('\tTransform User Name        : %s' % transform_user_name)
1484         print('\t Forward ctl               : %s' % forward_ctl)
1485         if 'transformCTLInverse' in lmts[lmt_name]:
1486             inverse_ctl = lmts[lmt_name]['transformCTLInverse']
1487             print('\t Inverse ctl                : %s' % inverse_ctl)
1488         else:
1489             print('\t Inverse ctl                : %s' % 'None')
1490
1491     print('\n')
1492
1493     return lmts
1494
1495
1496 def create_colorspaces(aces_ctl_directory,
1497                        lut_directory,
1498                        lut_resolution_1d,
1499                        lut_resolution_3d,
1500                        lmt_info,
1501                        odt_info,
1502                        shaper_name,
1503                        cleanup):
1504     """
1505     Generates the colorspace conversions.
1506
1507     Parameters
1508     ----------
1509     parameter : type
1510         Parameter description.
1511
1512     Returns
1513     -------
1514     type
1515          Return value description.
1516     """
1517
1518     colorspaces = []
1519
1520     ACES = create_ACES()
1521
1522     ACEScc = create_ACEScc(aces_ctl_directory, lut_directory,
1523                            lut_resolution_1d, cleanup,
1524                            min_value=-0.35840, max_value=1.468)
1525     colorspaces.append(ACEScc)
1526
1527     ACESproxy = create_ACESproxy(aces_ctl_directory, lut_directory,
1528                                  lut_resolution_1d, cleanup)
1529     colorspaces.append(ACESproxy)
1530
1531     ACEScg = create_ACEScg(aces_ctl_directory, lut_directory,
1532                            lut_resolution_1d, cleanup)
1533     colorspaces.append(ACEScg)
1534
1535     ADX10 = create_ADX(lut_directory, lut_resolution_1d, bit_depth=10)
1536     colorspaces.append(ADX10)
1537
1538     ADX16 = create_ADX(lut_directory, lut_resolution_1d, bit_depth=16)
1539     colorspaces.append(ADX16)
1540
1541     lmts = create_LMTs(aces_ctl_directory,
1542                        lut_directory,
1543                        lut_resolution_1d,
1544                        lut_resolution_3d,
1545                        lmt_info,
1546                        shaper_name,
1547                        cleanup)
1548     colorspaces.extend(lmts)
1549
1550     odts, displays = create_ODTs(aces_ctl_directory,
1551                                  lut_directory,
1552                                  lut_resolution_1d,
1553                                  lut_resolution_3d,
1554                                  odt_info,
1555                                  shaper_name,
1556                                  cleanup,
1557                                  ACES,
1558                                  ACEScc)
1559     colorspaces.extend(odts)
1560
1561     # Wish there was an automatic way to get this from the CTL
1562     default_display = 'sRGB (D60 sim.)'
1563
1564     roles = {'color_picking': ACEScg.name,
1565              'color_timing': ACEScc.name,
1566              'compositing_log': ACEScc.name,
1567              'data': '',
1568              'default': ACES.name,
1569              'matte_paint': ACEScc.name,
1570              'reference': '',
1571              'scene_linear': ACEScg.name,
1572              'texture_paint': ''}
1573
1574     return ACES, colorspaces, displays, ACEScc, roles, default_display