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