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