aces_1.0.0/python/aces_ocio/create_red_colorspaces.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 """
   5 Implements support for *RED* colorspaces conversions and transfer functions.
   6 """
   7
   8 import array
   9 import os
  10
  11 import aces_ocio.generate_lut as genlut
  12 from aces_ocio.utilities import ColorSpace, mat44_from_mat33
  13
  14 __author__ = 'ACES Developers'
  15 __copyright__ = 'Copyright (C) 2014 - 2015 - ACES Developers'
  16 __license__ = ''
  17 __maintainer__ = 'ACES Developers'
  18 __email__ = 'aces@oscars.org'
  19 __status__ = 'Production'
  20
  21 __all__ = ['create_RED_log_film',
  22            'create_colorspaces']
  23
  24
  25 def create_RED_log_film(gamut,
  26                         transfer_function,
  27                         name,
  28                         lut_directory,
  29                         lut_resolution_1d):
  30     """
  31     Object description.
  32
  33     RED colorspaces to ACES.
  34
  35     Parameters
  36     ----------
  37     parameter : type
  38         Parameter description.
  39
  40     Returns
  41     -------
  42     type
  43          Return value description.
  44     """
  45
  46     name = '%s - %s' % (transfer_function, gamut)
  47     if transfer_function == '':
  48         name = 'Linear - %s' % gamut
  49     if gamut == '':
  50         name = '%s' % transfer_function
  51
  52     cs = ColorSpace(name)
  53     cs.description = name
  54     cs.equality_group = ''
  55     cs.family = 'RED'
  56     cs.is_data = False
  57
  58     def cineon_to_linear(code_value):
  59         n_gamma = 0.6
  60         black_point = 95.0
  61         white_point = 685.0
  62         code_value_to_density = 0.002
  63
  64         black_linear = pow(10.0, (black_point - white_point) * (
  65             code_value_to_density / n_gamma))
  66         code_linear = pow(10.0, (code_value - white_point) * (
  67             code_value_to_density / n_gamma))
  68
  69         return (code_linear - black_linear) / (1.0 - black_linear)
  70
  71     cs.to_reference_transforms = []
  72
  73     if transfer_function == 'REDlogFilm':
  74         data = array.array('f', '\0' * lut_resolution_1d * 4)
  75         for c in range(lut_resolution_1d):
  76             data[c] = cineon_to_linear(1023.0 * c / (lut_resolution_1d - 1))
  77
  78         lut = 'CineonLog_to_linear.spi1d'
  79         genlut.write_SPI_1d(
  80             os.path.join(lut_directory, lut),
  81             0.0,
  82             1.0,
  83             data,
  84             lut_resolution_1d,
  85             1)
  86
  87         cs.to_reference_transforms.append({
  88             'type': 'lutFile',
  89             'path': lut,
  90             'interpolation': 'linear',
  91             'direction': 'forward'})
  92
  93     if gamut == 'DRAGONcolor':
  94         cs.to_reference_transforms.append({
  95             'type': 'matrix',
  96             'matrix': mat44_from_mat33([0.532279, 0.376648, 0.091073,
  97                                         0.046344, 0.974513, -0.020860,
  98                                         -0.053976, -0.000320, 1.054267]),
  99             'direction': 'forward'})
 100     elif gamut == 'DRAGONcolor2':
 101         cs.to_reference_transforms.append({
 102             'type': 'matrix',
 103             'matrix': mat44_from_mat33([0.468452, 0.331484, 0.200064,
 104                                         0.040787, 0.857658, 0.101553,
 105                                         -0.047504, -0.000282, 1.047756]),
 106             'direction': 'forward'})
 107     elif gamut == 'REDcolor2':
 108         cs.to_reference_transforms.append({
 109             'type': 'matrix',
 110             'matrix': mat44_from_mat33([0.480997, 0.402289, 0.116714,
 111                                         -0.004938, 1.000154, 0.004781,
 112                                         -0.105257, 0.025320, 1.079907]),
 113             'direction': 'forward'})
 114     elif gamut == 'REDcolor3':
 115         cs.to_reference_transforms.append({
 116             'type': 'matrix',
 117             'matrix': mat44_from_mat33([0.512136, 0.360370, 0.127494,
 118                                         0.070377, 0.903884, 0.025737,
 119                                         -0.020824, 0.017671, 1.003123]),
 120             'direction': 'forward'})
 121     elif gamut == 'REDcolor4':
 122         cs.to_reference_transforms.append({
 123             'type': 'matrix',
 124             'matrix': mat44_from_mat33([0.474202, 0.333677, 0.192121,
 125                                         0.065164, 0.836932, 0.097901,
 126                                         -0.019281, 0.016362, 1.002889]),
 127             'direction': 'forward'})
 128
 129     cs.from_reference_transforms = []
 130     return cs
 131
 132
 133 def create_colorspaces(lut_directory, lut_resolution_1d):
 134     """
 135     Generates the colorspace conversions.
 136
 137     Parameters
 138     ----------
 139     parameter : type
 140         Parameter description.
 141
 142     Returns
 143     -------
 144     type
 145          Return value description.
 146     """
 147
 148     colorspaces = []
 149
 150     # Full conversion
 151     RED_log_film_dragon = create_RED_log_film(
 152         'DRAGONcolor',
 153         'REDlogFilm',
 154         'REDlogFilm',
 155         lut_directory,
 156         lut_resolution_1d)
 157     colorspaces.append(RED_log_film_dragon)
 158
 159     RED_log_film_dragon2 = create_RED_log_film(
 160         'DRAGONcolor2',
 161         'REDlogFilm',
 162         'REDlogFilm',
 163         lut_directory,
 164         lut_resolution_1d)
 165     colorspaces.append(RED_log_film_dragon2)
 166
 167     RED_log_film_color2 = create_RED_log_film(
 168         'REDcolor2',
 169         'REDlogFilm',
 170         'REDlogFilm',
 171         lut_directory,
 172         lut_resolution_1d)
 173     colorspaces.append(RED_log_film_color2)
 174
 175     RED_log_film_color3 = create_RED_log_film(
 176         'REDcolor3',
 177         'REDlogFilm',
 178         'REDlogFilm',
 179         lut_directory,
 180         lut_resolution_1d)
 181     colorspaces.append(RED_log_film_color3)
 182
 183     RED_log_film_color4 = create_RED_log_film(
 184         'REDcolor4',
 185         'REDlogFilm',
 186         'REDlogFilm',
 187         lut_directory,
 188         lut_resolution_1d)
 189     colorspaces.append(RED_log_film_color4)
 190
 191     # Linearization only
 192     RED_log_film_dragon = create_RED_log_film(
 193         '',
 194         'REDlogFilm',
 195         'REDlogFilm',
 196         lut_directory,
 197         lut_resolution_1d)
 198     colorspaces.append(RED_log_film_dragon)
 199
 200     # Primaries only
 201     RED_log_film_dragon = create_RED_log_film(
 202         'DRAGONcolor',
 203         '',
 204         'REDlogFilm',
 205         lut_directory,
 206         lut_resolution_1d)
 207     colorspaces.append(RED_log_film_dragon)
 208
 209     RED_log_film_dragon2 = create_RED_log_film(
 210         'DRAGONcolor2',
 211         '',
 212         'REDlogFilm',
 213         lut_directory,
 214         lut_resolution_1d)
 215     colorspaces.append(RED_log_film_dragon2)
 216
 217     RED_log_film_color2 = create_RED_log_film(
 218         'REDcolor2',
 219         '',
 220         'REDlogFilm',
 221         lut_directory,
 222         lut_resolution_1d)
 223     colorspaces.append(RED_log_film_color2)
 224
 225     RED_log_film_color3 = create_RED_log_film(
 226         'REDcolor3',
 227         '',
 228         'REDlogFilm',
 229         lut_directory,
 230         lut_resolution_1d)
 231     colorspaces.append(RED_log_film_color3)
 232
 233     RED_log_film_color4 = create_RED_log_film(
 234         'REDcolor4',
 235         '',
 236         'REDlogFilm',
 237         lut_directory,
 238         lut_resolution_1d)
 239     colorspaces.append(RED_log_film_color4)
 240
 241     return colorspaces