import string
import sys
-# TODO: This restores the capability of running the script without having
-# added the package to PYTHONPATH, this is ugly and should ideally replaced by
-# dedicated executable in a /bin directory.
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-
-import PyOpenColorIO as OCIO
+import PyOpenColorIO as ocio
import aces_ocio.create_arri_colorspaces as arri
import aces_ocio.create_canon_colorspaces as canon
generate_3d_LUT_from_CTL,
write_SPI_1d)
from aces_ocio.process import Process
-from aces_ocio.utilities import ColorSpace, mat44_from_mat33
+from aces_ocio.utilities import ColorSpace, mat44_from_mat33, sanitize_path
__author__ = 'ACES Developers'
__copyright__ = 'Copyright (C) 2014 - 2015 - ACES Developers'
def set_config_default_roles(config,
- color_picking="",
- color_timing="",
- compositing_log="",
- data="",
- default="",
- matte_paint="",
- reference="",
- scene_linear="",
- texture_paint=""):
+ color_picking='',
+ color_timing='',
+ compositing_log='',
+ data='',
+ default='',
+ matte_paint='',
+ reference='',
+ scene_linear='',
+ texture_paint=''):
"""
Sets given *OCIO* configuration default roles.
"""
if color_picking:
- config.setRole(OCIO.Constants.ROLE_COLOR_PICKING, color_picking)
+ config.setRole(ocio.Constants.ROLE_COLOR_PICKING, color_picking)
if color_timing:
- config.setRole(OCIO.Constants.ROLE_COLOR_TIMING, color_timing)
+ config.setRole(ocio.Constants.ROLE_COLOR_TIMING, color_timing)
if compositing_log:
- config.setRole(OCIO.Constants.ROLE_COMPOSITING_LOG, compositing_log)
+ config.setRole(ocio.Constants.ROLE_COMPOSITING_LOG, compositing_log)
if data:
- config.setRole(OCIO.Constants.ROLE_DATA, data)
+ config.setRole(ocio.Constants.ROLE_DATA, data)
if default:
- config.setRole(OCIO.Constants.ROLE_DEFAULT, default)
+ config.setRole(ocio.Constants.ROLE_DEFAULT, default)
if matte_paint:
- config.setRole(OCIO.Constants.ROLE_MATTE_PAINT, matte_paint)
+ config.setRole(ocio.Constants.ROLE_MATTE_PAINT, matte_paint)
if reference:
- config.setRole(OCIO.Constants.ROLE_REFERENCE, reference)
+ config.setRole(ocio.Constants.ROLE_REFERENCE, reference)
if scene_linear:
- config.setRole(OCIO.Constants.ROLE_SCENE_LINEAR, scene_linear)
+ config.setRole(ocio.Constants.ROLE_SCENE_LINEAR, scene_linear)
if texture_paint:
- config.setRole(OCIO.Constants.ROLE_TEXTURE_PAINT, texture_paint)
+ config.setRole(ocio.Constants.ROLE_TEXTURE_PAINT, texture_paint)
return True
config.sanityCheck()
except Exception, e:
print e
- print "Configuration was not written due to a failed Sanity Check"
+ print 'Configuration was not written due to a failed Sanity Check'
return
- # sys.exit()
- file_handle = open(config_path, mode='w')
- file_handle.write(config.serialize())
- file_handle.close()
+ with open(config_path, mode='w') as fp:
+ fp.write(config.serialize())
def generate_OCIO_transform(transforms):
Return value description.
"""
- # print("Generating transforms")
-
interpolation_options = {
- 'linear': OCIO.Constants.INTERP_LINEAR,
- 'nearest': OCIO.Constants.INTERP_NEAREST,
- 'tetrahedral': OCIO.Constants.INTERP_TETRAHEDRAL
+ 'linear': ocio.Constants.INTERP_LINEAR,
+ 'nearest': ocio.Constants.INTERP_NEAREST,
+ 'tetrahedral': ocio.Constants.INTERP_TETRAHEDRAL
}
direction_options = {
- 'forward': OCIO.Constants.TRANSFORM_DIR_FORWARD,
- 'inverse': OCIO.Constants.TRANSFORM_DIR_INVERSE
+ 'forward': ocio.Constants.TRANSFORM_DIR_FORWARD,
+ 'inverse': ocio.Constants.TRANSFORM_DIR_INVERSE
}
ocio_transforms = []
for transform in transforms:
if transform['type'] == 'lutFile':
- ocio_transform = OCIO.FileTransform(
+ ocio_transform = ocio.FileTransform(
src=transform['path'],
interpolation=interpolation_options[
transform['interpolation']],
direction=direction_options[transform['direction']])
ocio_transforms.append(ocio_transform)
elif transform['type'] == 'matrix':
- ocio_transform = OCIO.MatrixTransform()
- # MatrixTransform member variables can't be initialized directly.
- # Each must be set individually.
+ ocio_transform = ocio.MatrixTransform()
+ # MatrixTransform member variables can't be initialized directly
+ # and must be set individually.
ocio_transform.setMatrix(transform['matrix'])
if 'offset' in transform:
ocio_transforms.append(ocio_transform)
elif transform['type'] == 'exponent':
- ocio_transform = OCIO.ExponentTransform()
+ ocio_transform = ocio.ExponentTransform()
ocio_transform.setValue(transform['value'])
ocio_transforms.append(ocio_transform)
elif transform['type'] == 'log':
- ocio_transform = OCIO.LogTransform(
+ ocio_transform = ocio.LogTransform(
base=transform['base'],
direction=direction_options[transform['direction']])
ocio_transforms.append(ocio_transform)
else:
- print("Ignoring unknown transform type : %s" % transform['type'])
+ print('Ignoring unknown transform type : %s' % transform['type'])
- # Build a group transform if necessary
if len(ocio_transforms) > 1:
- transform_G = OCIO.GroupTransform()
+ group_transform = ocio.GroupTransform()
for transform in ocio_transforms:
- transform_G.push_back(transform)
- transform = transform_G
-
- # Or take the first transform from the list
+ group_transform.push_back(transform)
+ transform = group_transform
else:
transform = ocio_transforms[0]
Return value description.
"""
- # Create the config
- config = OCIO.Config()
+ # Creating the *OCIO* configuration.
+ config = ocio.Config()
- #
- # Set config wide values
- #
- config.setDescription("An ACES config generated from python")
- config.setSearchPath("luts")
+ # Setting configuration overall values.
+ config.setDescription('An ACES config generated from python')
+ config.setSearchPath('luts')
- #
- # Define the reference color space
- #
+ # Defining the reference colorspace.
reference_data = config_data['referenceColorSpace']
- print("Adding the reference color space : %s" % reference_data.name)
+ print('Adding the reference color space : %s' % reference_data.name)
- # Create a color space
- reference = OCIO.ColorSpace(
+ reference = ocio.ColorSpace(
name=reference_data.name,
bitDepth=reference_data.bit_depth,
description=reference_data.description,
allocation=reference_data.allocation_type,
allocationVars=reference_data.allocation_vars)
- # Add to config
config.addColorSpace(reference)
- #
- # Create the rest of the color spaces
- #
+ # Creating the remaining colorspaces.
for colorspace in sorted(config_data['colorSpaces']):
- print("Creating new color space : %s" % colorspace.name)
+ print('Creating new color space : %s' % colorspace.name)
- ocio_colorspace = OCIO.ColorSpace(
+ ocio_colorspace = ocio.ColorSpace(
name=colorspace.name,
bitDepth=colorspace.bit_depth,
description=colorspace.description,
allocation=colorspace.allocation_type,
allocationVars=colorspace.allocation_vars)
- if colorspace.to_reference_transforms != []:
- print("Generating To-Reference transforms")
+ if colorspace.to_reference_transforms:
+ print('Generating To-Reference transforms')
ocio_transform = generate_OCIO_transform(
colorspace.to_reference_transforms)
ocio_colorspace.setTransform(
ocio_transform,
- OCIO.Constants.COLORSPACE_DIR_TO_REFERENCE)
+ ocio.Constants.COLORSPACE_DIR_TO_REFERENCE)
- if colorspace.from_reference_transforms != []:
- print("Generating From-Reference transforms")
+ if colorspace.from_reference_transforms:
+ print('Generating From-Reference transforms')
ocio_transform = generate_OCIO_transform(
colorspace.from_reference_transforms)
ocio_colorspace.setTransform(
ocio_transform,
- OCIO.Constants.COLORSPACE_DIR_FROM_REFERENCE)
+ ocio.Constants.COLORSPACE_DIR_FROM_REFERENCE)
config.addColorSpace(ocio_colorspace)
- print("")
+ print('')
- #
- # Define the views and displays
- #
+ # Defining the *views* and *displays*.
displays = []
views = []
- # Generic display and view setup
+ # Defining a *generic* *display* and *view* setup.
if not nuke:
for display, view_list in config_data['displays'].iteritems():
for view_name, colorspace in view_list.iteritems():
if not (view_name in views):
views.append(view_name)
displays.append(display)
- # A Nuke specific set of views and displays
- #
- # XXX
- # A few names: Output Transform, ACES, ACEScc, are hard-coded here.
- # Would be better to automate.
- #
+ # Defining the *Nuke* specific set of *views* and *displays*.
else:
for display, view_list in config_data['displays'].iteritems():
for view_name, colorspace in view_list.iteritems():
- if (view_name == 'Output Transform'):
+ if view_name == 'Output Transform':
view_name = 'View'
config.addDisplay(display, view_name, colorspace.name)
if not (view_name in views):
config.addDisplay('log', 'View', 'ACEScc')
displays.append('log')
- # Set active displays and views
+ # Setting the active *displays* and *views*.
config.setActiveDisplays(','.join(sorted(displays)))
config.setActiveViews(','.join(views))
- #
- # Need to generalize this at some point
- #
-
- # Add Default Roles
set_config_default_roles(
config,
color_picking=reference.getName(),
scene_linear=reference.getName(),
texture_paint=reference.getName())
- # Check to make sure we didn't screw something up
config.sanityCheck()
return config
the reference colorspace, *ACES*.
"""
- print("generateLUTs - begin")
+ print('generateLUTs - begin')
config_data = {}
- #
- # Define the reference color space
- #
+ # Defining the reference colorspace.
ACES = ColorSpace('ACES2065-1')
ACES.description = (
'The Academy Color Encoding System reference color space')
ACES.equality_group = ''
ACES.family = 'ACES'
ACES.is_data = False
- ACES.allocation_type = OCIO.Constants.ALLOCATION_LG2
+ ACES.allocation_type = ocio.Constants.ALLOCATION_LG2
ACES.allocation_vars = [-15, 6]
config_data['referenceColorSpace'] = ACES
- #
- # Define the displays
- #
config_data['displays'] = {}
-
- #
- # Define the other color spaces
- #
config_data['colorSpaces'] = []
- # Matrix converting ACES AP1 primaries to AP0
+ # Matrix converting *ACES AP1* primaries to *AP0*.
ACES_AP1_to_AP0 = [0.6954522414, 0.1406786965, 0.1638690622,
0.0447945634, 0.8596711185, 0.0955343182,
-0.0055258826, 0.0040252103, 1.0015006723]
- # Matrix converting ACES AP0 primaries to XYZ
+ # Matrix converting *ACES AP0* primaries to *XYZ*.
ACES_AP0_to_XYZ = [0.9525523959, 0.0000000000, 0.0000936786,
0.3439664498, 0.7281660966, -0.0721325464,
0.0000000000, 0.0000000000, 1.0088251844]
- #
- # ACEScc
- #
+ # -------------------------------------------------------------------------
+ # *ACEScc*
+ # -------------------------------------------------------------------------
def create_ACEScc(name='ACEScc',
min_value=0.0,
max_value=1.0,
input_scale=1.0):
cs = ColorSpace(name)
- cs.description = "The %s color space" % name
+ cs.description = 'The %s color space' % name
cs.equality_group = ''
cs.family = 'ACES'
cs.is_data = False
- ctls = [
- '%s/ACEScc/ACEScsc.ACEScc_to_ACES.a1.0.0.ctl' % aces_CTL_directory,
- # This transform gets back to the AP1 primaries
- # Useful as the 1d LUT is only covering the transfer function
- # The primaries switch is covered by the matrix below
- '%s/ACEScg/ACEScsc.ACES_to_ACEScg.a1.0.0.ctl' % aces_CTL_directory
- ]
- lut = "%s_to_ACES.spi1d" % name
+ ctls = [os.path.join(aces_CTL_directory,
+ 'ACEScc',
+ 'ACEScsc.ACEScc_to_ACES.a1.0.0.ctl'),
+ # This transform gets back to the *AP1* primaries.
+ # Useful as the 1d LUT is only covering the transfer function.
+ # The primaries switch is covered by the matrix below:
+ os.path.join(aces_CTL_directory,
+ 'ACEScg',
+ 'ACEScsc.ACES_to_ACEScg.a1.0.0.ctl')]
+ lut = '%s_to_ACES.spi1d' % name
- # Remove spaces and parentheses
- lut = lut.replace(' ', '_').replace(')', '_').replace('(', '_')
+ lut = sanitize_path(lut)
generate_1d_LUT_from_CTL(
- lut_directory + "/" + lut,
+ os.path.join(lut_directory, lut),
ctls,
lut_resolution_1d,
'float',
'type': 'lutFile',
'path': lut,
'interpolation': 'linear',
- 'direction': 'forward'
- })
+ 'direction': 'forward'})
- # AP1 primaries to AP0 primaries
+ # *AP1* primaries to *AP0* primaries.
cs.to_reference_transforms.append({
'type': 'matrix',
'matrix': mat44_from_mat33(ACES_AP1_to_AP0),
- 'direction': 'forward'
- })
+ 'direction': 'forward'})
cs.from_reference_transforms = []
return cs
ACEScc = create_ACEScc()
config_data['colorSpaces'].append(ACEScc)
- #
- # ACESproxy
- #
+ # -------------------------------------------------------------------------
+ # *ACESproxy*
+ # -------------------------------------------------------------------------
def create_ACESproxy(name='ACESproxy'):
cs = ColorSpace(name)
- cs.description = "The %s color space" % name
+ cs.description = 'The %s color space' % name
cs.equality_group = ''
cs.family = 'ACES'
cs.is_data = False
- ctls = [
- '%s/ACESproxy/ACEScsc.ACESproxy10i_to_ACES.a1.0.0.ctl' % (
- aces_CTL_directory),
- # This transform gets back to the AP1 primaries
- # Useful as the 1d LUT is only covering the transfer function
- # The primaries switch is covered by the matrix below
- '%s/ACEScg/ACEScsc.ACES_to_ACEScg.a1.0.0.ctl' % aces_CTL_directory
- ]
- lut = "%s_to_aces.spi1d" % name
+ ctls = [os.path.join(aces_CTL_directory,
+ 'ACESproxy',
+ 'ACEScsc.ACESproxy10i_to_ACES.a1.0.0.ctl'),
+ # This transform gets back to the *AP1* primaries.
+ # Useful as the 1d LUT is only covering the transfer function.
+ # The primaries switch is covered by the matrix below:
+ os.path.join(aces_CTL_directory,
+ 'ACEScg',
+ 'ACEScsc.ACES_to_ACEScg.a1.0.0.ctl')]
+ lut = '%s_to_aces.spi1d' % name
- # Remove spaces and parentheses
- lut = lut.replace(' ', '_').replace(')', '_').replace('(', '_')
+ lut = sanitize_path(lut)
generate_1d_LUT_from_CTL(
- lut_directory + "/" + lut,
+ os.path.join(lut_directory, lut),
ctls,
lut_resolution_1d,
'uint16',
'direction': 'forward'
})
- # AP1 primaries to AP0 primaries
+ # *AP1* primaries to *AP0* primaries.
cs.to_reference_transforms.append({
'type': 'matrix',
'matrix': mat44_from_mat33(ACES_AP1_to_AP0),
ACESproxy = create_ACESproxy()
config_data['colorSpaces'].append(ACESproxy)
- #
- # ACEScg
- #
+ # -------------------------------------------------------------------------
+ # *ACEScg*
+ # -------------------------------------------------------------------------
def create_ACEScg(name='ACEScg'):
cs = ColorSpace(name)
- cs.description = "The %s color space" % name
+ cs.description = 'The %s color space' % name
cs.equality_group = ''
cs.family = 'ACES'
cs.is_data = False
cs.to_reference_transforms = []
- # AP1 primaries to AP0 primaries
+ # *AP1* primaries to *AP0* primaries.
cs.to_reference_transforms.append({
'type': 'matrix',
'matrix': mat44_from_mat33(ACES_AP1_to_AP0),
ACEScg = create_ACEScg()
config_data['colorSpaces'].append(ACEScg)
- #
- # ADX
- #
+ # -------------------------------------------------------------------------
+ # *ADX*
+ # -------------------------------------------------------------------------
def create_ADX(bit_depth=10, name='ADX'):
- name = "%s%s" % (name, bit_depth)
+ name = '%s%s' % (name, bit_depth)
cs = ColorSpace(name)
- cs.description = "%s color space - used for film scans" % name
+ cs.description = '%s color space - used for film scans' % name
cs.equality_group = ''
cs.family = 'ADX'
cs.is_data = False
if bit_depth == 10:
- cs.bit_depth = bit_depth = OCIO.Constants.BIT_DEPTH_UINT10
+ cs.bit_depth = ocio.Constants.BIT_DEPTH_UINT10
adx_to_cdd = [1023.0 / 500.0, 0.0, 0.0, 0.0,
0.0, 1023.0 / 500.0, 0.0, 0.0,
0.0, 0.0, 1023.0 / 500.0, 0.0,
0.0, 0.0, 0.0, 1.0]
offset = [-95.0 / 500.0, -95.0 / 500.0, -95.0 / 500.0, 0.0]
elif bit_depth == 16:
- cs.bit_depth = bit_depth = OCIO.Constants.BIT_DEPTH_UINT16
+ cs.bit_depth = ocio.Constants.BIT_DEPTH_UINT16
adx_to_cdd = [65535.0 / 8000.0, 0.0, 0.0, 0.0,
0.0, 65535.0 / 8000.0, 0.0, 0.0,
0.0, 0.0, 65535.0 / 8000.0, 0.0,
cs.to_reference_transforms = []
- # Convert from ADX to Channel-Dependent Density
+ # Converting from *ADX* to *Channel-Dependent Density*.
cs.to_reference_transforms.append({
'type': 'matrix',
'matrix': adx_to_cdd,
'offset': offset,
- 'direction': 'forward'
- })
+ 'direction': 'forward'})
# Convert from Channel-Dependent Density to Channel-Independent Density
cs.to_reference_transforms.append({
0.05901, 0.96928, -0.02829, 0,
0.16134, 0.07406, 0.76460, 0,
0.0, 0.0, 0.0, 1.0],
- 'direction': 'forward'
- })
+ 'direction': 'forward'})
- # Copied from Alex Fry's adx_cid_to_rle.py
+ # Copied from *Alex Fry*'s *adx_cid_to_rle.py*
def create_CID_to_RLE_LUT():
+
def interpolate_1D(x, xp, fp):
return numpy.interp(x, xp, fp)
def fit(value, from_min, from_max, to_min, to_max):
if from_min == from_max:
- raise ValueError("from_min == from_max")
+ raise ValueError('from_min == from_max')
return (value - from_min) / (from_max - from_min) * (
to_max - to_min) + to_min
data.append(cid_to_rle(x))
lut = 'ADX_CID_to_RLE.spi1d'
- write_SPI_1d(lut_directory + "/" + lut, RANGE[0], RANGE[1],
+ write_SPI_1d(os.path.join(lut_directory, lut),
+ RANGE[0],
+ RANGE[1],
data,
NUM_SAMPLES, 1)
return lut
- # Convert Channel Independent Density values to Relative Log Exposure
- # values.
+ # Converting *Channel Independent Density* values to
+ # *Relative Log Exposure* values.
lut = create_CID_to_RLE_LUT()
cs.to_reference_transforms.append({
'type': 'lutFile',
'path': lut,
'interpolation': 'linear',
- 'direction': 'forward'
- })
+ 'direction': 'forward'})
- # Convert Relative Log Exposure values to Relative Exposure values
+ # Converting *Relative Log Exposure* values to
+ # *Relative Exposure* values.
cs.to_reference_transforms.append({
'type': 'log',
'base': 10,
- 'direction': 'inverse'
- })
+ 'direction': 'inverse'})
- # Convert Relative Exposure values to ACES values
+ # Convert *Relative Exposure* values to *ACES* values.
cs.to_reference_transforms.append({
'type': 'matrix',
'matrix': [0.72286, 0.12630, 0.15084, 0,
0.11923, 0.76418, 0.11659, 0,
0.01427, 0.08213, 0.90359, 0,
0.0, 0.0, 0.0, 1.0],
- 'direction': 'forward'
- })
+ 'direction': 'forward'})
cs.from_reference_transforms = []
return cs
ADX16 = create_ADX(bit_depth=16)
config_data['colorSpaces'].append(ADX16)
- #
- # Camera Input Transforms
- #
+ # -------------------------------------------------------------------------
+ # *Camera Input Transforms*
+ # -------------------------------------------------------------------------
- # RED color spaces to ACES
+ # *RED* colorspaces to *ACES*.
red_colorspaces = red.create_colorspaces(lut_directory, lut_resolution_1d)
for cs in red_colorspaces:
config_data['colorSpaces'].append(cs)
- # Canon-Log to ACES
+ # *Canon-Log* to *ACES*.
canon_colorspaces = canon.create_colorspaces(lut_directory,
lut_resolution_1d)
for cs in canon_colorspaces:
config_data['colorSpaces'].append(cs)
- # S-Log to ACES
+ # *S-Log* to *ACES*.
sony_colorSpaces = sony.create_colorspaces(lut_directory,
lut_resolution_1d)
for cs in sony_colorSpaces:
config_data['colorSpaces'].append(cs)
- # Log-C to ACES
+ # *Log-C* to *ACES*.
arri_colorSpaces = arri.create_colorspaces(lut_directory,
lut_resolution_1d)
for cs in arri_colorSpaces:
config_data['colorSpaces'].append(cs)
- #
- # Generic log transform
- #
+ # -------------------------------------------------------------------------
+ # *Generic Log Transform*
+ # -------------------------------------------------------------------------
def create_generic_log(name='log',
min_value=0.0,
max_value=1.0,
max_exposure=6.5,
lut_resolution_1d=lut_resolution_1d):
cs = ColorSpace(name)
- cs.description = "The %s color space" % name
+ cs.description = 'The %s color space' % name
cs.equality_group = name
cs.family = 'Utility'
cs.is_data = False
- ctls = [
- '%s/utilities/ACESlib.OCIO_shaper_log2_to_lin_param.a1.0.0.ctl' % (
- aces_CTL_directory)]
- lut = "%s_to_aces.spi1d" % name
+ ctls = [os.path.join(
+ aces_CTL_directory,
+ 'utilities',
+ 'ACESlib.OCIO_shaper_log2_to_lin_param.a1.0.0.ctl')]
+ lut = '%s_to_aces.spi1d' % name
- # Remove spaces and parentheses
- lut = lut.replace(' ', '_').replace(')', '_').replace('(', '_')
+ lut = sanitize_path(lut)
generate_1d_LUT_from_CTL(
- lut_directory + "/" + lut,
+ os.path.join(lut_directory, lut),
ctls,
lut_resolution_1d,
'float',
input_scale,
1.0,
- {
- 'middleGrey': middle_grey,
- 'minExposure': min_exposure,
- 'maxExposure': max_exposure
- },
+ {'middleGrey': middle_grey,
+ 'minExposure': min_exposure,
+ 'maxExposure': max_exposure},
cleanup,
aces_CTL_directory,
min_value,
'type': 'lutFile',
'path': lut,
'interpolation': 'linear',
- 'direction': 'forward'
- })
+ 'direction': 'forward'})
cs.from_reference_transforms = []
return cs
- #
- # ACES LMTs
- #
+ # -------------------------------------------------------------------------
+ # *ACES LMTs*
+ # -------------------------------------------------------------------------
def create_ACES_LMT(lmt_name,
lmt_values,
shaper_info,
lut_resolution_1d=1024,
lut_resolution_3d=64,
cleanup=True):
- cs = ColorSpace("%s" % lmt_name)
- cs.description = "The ACES Look Transform: %s" % lmt_name
+ cs = ColorSpace('%s' % lmt_name)
+ cs.description = 'The ACES Look Transform: %s' % lmt_name
cs.equality_group = ''
cs.family = 'Look'
cs.is_data = False
pprint.pprint(lmt_values)
- #
- # Generate the shaper transform
- #
+ # Generating the *shaper* transform.
(shaper_name,
shaper_to_ACES_CTL,
shaper_from_ACES_CTL,
shaper_input_scale,
shaper_params) = shaper_info
- shaper_lut = "%s_to_aces.spi1d" % shaper_name
- if (not os.path.exists(lut_directory + "/" + shaper_lut)):
+ shaper_lut = '%s_to_aces.spi1d' % shaper_name
+ if not os.path.exists(os.path.join(lut_directory, shaper_lut)):
ctls = [shaper_to_ACES_CTL % aces_CTL_directory]
- # Remove spaces and parentheses
- shaper_lut = shaper_lut.replace(
- ' ', '_').replace(')', '_').replace('(', '_')
+ shaper_lut = sanitize_path(shaper_lut)
generate_1d_LUT_from_CTL(
- lut_directory + "/" + shaper_lut,
+ os.path.join(lut_directory, shaper_lut),
ctls,
lut_resolution_1d,
'float',
'type': 'lutFile',
'path': shaper_lut,
'interpolation': 'linear',
- 'direction': 'inverse'
- }
+ 'direction': 'inverse'}
- #
- # Generate the forward transform
- #
+ # Generating the forward transform.
cs.from_reference_transforms = []
if 'transformCTL' in lmt_values:
- ctls = [
- shaper_to_ACES_CTL % aces_CTL_directory,
- '%s/%s' % (aces_CTL_directory, lmt_values['transformCTL'])
- ]
- lut = "%s.%s.spi3d" % (shaper_name, lmt_name)
+ ctls = [shaper_to_ACES_CTL % aces_CTL_directory,
+ os.path.join(aces_CTL_directory,
+ lmt_values['transformCTL'])]
+ lut = '%s.%s.spi3d' % (shaper_name, lmt_name)
- # Remove spaces and parentheses
- lut = lut.replace(' ', '_').replace(')', '_').replace('(', '_')
+ lut = sanitize_path(lut)
generate_3d_LUT_from_CTL(
- lut_directory + "/" + lut,
+ os.path.join(lut_directory, lut),
ctls,
lut_resolution_3d,
'float',
'direction': 'forward'
})
- #
- # Generate the inverse transform
- #
+ # Generating the inverse transform.
cs.to_reference_transforms = []
if 'transformCTLInverse' in lmt_values:
- ctls = [
- '%s/%s' % (
- aces_CTL_directory, odt_values['transformCTLInverse']),
- shaper_from_ACES_CTL % aces_CTL_directory
- ]
- lut = "Inverse.%s.%s.spi3d" % (odt_name, shaper_name)
+ ctls = [os.path.join(aces_CTL_directory,
+ odt_values['transformCTLInverse']),
+ shaper_from_ACES_CTL % aces_CTL_directory]
+ lut = 'Inverse.%s.%s.spi3d' % (odt_name, shaper_name)
- # Remove spaces and parentheses
- lut = lut.replace(' ', '_').replace(')', '_').replace('(', '_')
+ lut = sanitize_path(lut)
generate_3d_LUT_from_CTL(
- lut_directory + "/" + lut,
+ os.path.join(lut_directory, lut),
ctls,
lut_resolution_3d,
'half',
'type': 'lutFile',
'path': lut,
'interpolation': 'tetrahedral',
- 'direction': 'forward'
- })
+ 'direction': 'forward'})
shaper_inverse = shaper_OCIO_transform.copy()
shaper_inverse['direction'] = 'forward'
return cs
- #
- # LMT Shaper
- #
+ # -------------------------------------------------------------------------
+ # *LMT Shaper*
+ # -------------------------------------------------------------------------
lmt_lut_resolution_1d = max(4096, lut_resolution_1d)
lmt_lut_resolution_3d = max(65, lut_resolution_3d)
- # Log 2 shaper
+ # Defining the *Log 2* shaper.
lmt_shaper_name = 'LMT Shaper'
lmt_params = {
'middleGrey': 0.18,
'minExposure': -10.0,
- 'maxExposure': 6.5
- }
+ 'maxExposure': 6.5}
+
lmt_shaper = create_generic_log(name=lmt_shaper_name,
middle_grey=lmt_params['middleGrey'],
min_exposure=lmt_params['minExposure'],
shaper_input_scale_generic_log2 = 1.0
- # Log 2 shaper name and CTL transforms bundled up
+ # *Log 2* shaper name and *CTL* transforms bundled up.
lmt_shaper_data = [
lmt_shaper_name,
- '%s/utilities/ACESlib.OCIO_shaper_log2_to_lin_param.a1.0.0.ctl',
- '%s/utilities/ACESlib.OCIO_shaper_lin_to_log2_param.a1.0.0.ctl',
+ os.path.join('%s',
+ 'utilities',
+ 'ACESlib.OCIO_shaper_log2_to_lin_param.a1.0.0.ctl'),
+ os.path.join('%s',
+ 'utilities',
+ 'ACESlib.OCIO_shaper_lin_to_log2_param.a1.0.0.ctl'),
shaper_input_scale_generic_log2,
- lmt_params
- ]
+ lmt_params]
sorted_LMTs = sorted(lmt_info.iteritems(), key=lambda x: x[1])
print(sorted_LMTs)
cleanup)
config_data['colorSpaces'].append(cs)
- #
- # ACES RRT with the supplied ODT
- #
+ # -------------------------------------------------------------------------
+ # *ACES RRT* with supplied *ODT*.
+ # -------------------------------------------------------------------------
def create_ACES_RRT_plus_ODT(odt_name,
odt_values,
shaper_info,
lut_resolution_1d=1024,
lut_resolution_3d=64,
cleanup=True):
- cs = ColorSpace("%s" % odt_name)
- cs.description = "%s - %s Output Transform" % (
+ cs = ColorSpace('%s' % odt_name)
+ cs.description = '%s - %s Output Transform' % (
odt_values['transformUserNamePrefix'], odt_name)
cs.equality_group = ''
cs.family = 'Output'
pprint.pprint(odt_values)
- #
- # Generate the shaper transform
- #
- # if 'shaperCTL' in odtValues:
+ # Generating the *shaper* transform.
(shaper_name,
shaper_to_ACES_CTL,
shaper_from_ACES_CTL,
else:
shaper_params['legalRange'] = 0
- shaper_lut = "%s_to_aces.spi1d" % shaper_name
- if (not os.path.exists(lut_directory + "/" + shaper_lut)):
+ shaper_lut = '%s_to_aces.spi1d' % shaper_name
+ if not os.path.exists(os.path.join(lut_directory, shaper_lut)):
ctls = [shaper_to_ACES_CTL % aces_CTL_directory]
- # Remove spaces and parentheses
- shaper_lut = shaper_lut.replace(
- ' ', '_').replace(')', '_').replace('(', '_')
+ shaper_lut = sanitize_path(shaper_lut)
generate_1d_LUT_from_CTL(
- lut_directory + "/" + shaper_lut,
+ os.path.join(lut_directory, shaper_lut),
ctls,
lut_resolution_1d,
'float',
'type': 'lutFile',
'path': shaper_lut,
'interpolation': 'linear',
- 'direction': 'inverse'
- }
+ 'direction': 'inverse'}
- #
- # Generate the forward transform
- #
+ # Generating the *forward* transform.
cs.from_reference_transforms = []
if 'transformLUT' in odt_values:
- # Copy into the lut dir
transform_LUT_file_name = os.path.basename(
odt_values['transformLUT'])
- lut = lut_directory + "/" + transform_LUT_file_name
+ lut = os.path.join(lut_directory, transform_LUT_file_name)
shutil.copy(odt_values['transformLUT'], lut)
cs.from_reference_transforms.append(shaper_OCIO_transform)
'type': 'lutFile',
'path': transform_LUT_file_name,
'interpolation': 'tetrahedral',
- 'direction': 'forward'
- })
+ 'direction': 'forward'})
elif 'transformCTL' in odt_values:
- # shaperLut
-
ctls = [
shaper_to_ACES_CTL % aces_CTL_directory,
- '%s/rrt/RRT.a1.0.0.ctl' % aces_CTL_directory,
- '%s/odt/%s' % (aces_CTL_directory, odt_values['transformCTL'])
- ]
- lut = "%s.RRT.a1.0.0.%s.spi3d" % (shaper_name, odt_name)
-
- # Remove spaces and parentheses
- lut = lut.replace(' ', '_').replace(')', '_').replace('(', '_')
-
- generate_3d_LUT_from_CTL(lut_directory + "/" + lut,
- # shaperLUT,
- ctls,
- lut_resolution_3d,
- 'float',
- 1.0 / shaper_input_scale,
- 1.0,
- shaper_params,
- cleanup,
- aces_CTL_directory)
+ os.path.join(aces_CTL_directory,
+ 'rrt',
+ 'RRT.a1.0.0.ctl'),
+ os.path.join(aces_CTL_directory,
+ 'odt',
+ odt_values['transformCTL'])]
+ lut = '%s.RRT.a1.0.0.%s.spi3d' % (shaper_name, odt_name)
+
+ lut = sanitize_path(lut)
+
+ generate_3d_LUT_from_CTL(
+ os.path.join(lut_directory, lut),
+ # shaperLUT,
+ ctls,
+ lut_resolution_3d,
+ 'float',
+ 1.0 / shaper_input_scale,
+ 1.0,
+ shaper_params,
+ cleanup,
+ aces_CTL_directory)
cs.from_reference_transforms.append(shaper_OCIO_transform)
cs.from_reference_transforms.append({
'type': 'lutFile',
'path': lut,
'interpolation': 'tetrahedral',
- 'direction': 'forward'
- })
+ 'direction': 'forward'})
- #
- # Generate the inverse transform
- #
+ # Generating the *inverse* transform.
cs.to_reference_transforms = []
if 'transformLUTInverse' in odt_values:
- # Copy into the lut dir
transform_LUT_inverse_file_name = os.path.basename(
odt_values['transformLUTInverse'])
- lut = lut_directory + "/" + transform_LUT_inverse_file_name
+ lut = os.path.join(lut_directory, transform_LUT_inverse_file_name)
shutil.copy(odt_values['transformLUTInverse'], lut)
cs.to_reference_transforms.append({
'type': 'lutFile',
'path': transform_LUT_inverse_file_name,
'interpolation': 'tetrahedral',
- 'direction': 'forward'
- })
+ 'direction': 'forward'})
shaper_inverse = shaper_OCIO_transform.copy()
shaper_inverse['direction'] = 'forward'
cs.to_reference_transforms.append(shaper_inverse)
elif 'transformCTLInverse' in odt_values:
- ctls = [
- '%s/odt/%s' % (
- aces_CTL_directory, odt_values['transformCTLInverse']),
- '%s/rrt/InvRRT.a1.0.0.ctl' % aces_CTL_directory,
- shaper_from_ACES_CTL % aces_CTL_directory
- ]
- lut = "InvRRT.a1.0.0.%s.%s.spi3d" % (odt_name, shaper_name)
+ ctls = [os.path.join(aces_CTL_directory,
+ 'odt',
+ odt_values['transformCTLInverse']),
+ os.path.join(aces_CTL_directory,
+ 'rrt',
+ 'InvRRT.a1.0.0.ctl'),
+ shaper_from_ACES_CTL % aces_CTL_directory]
+ lut = 'InvRRT.a1.0.0.%s.%s.spi3d' % (odt_name, shaper_name)
- # Remove spaces and parentheses
- lut = lut.replace(' ', '_').replace(')', '_').replace('(', '_')
+ lut = sanitize_path(lut)
generate_3d_LUT_from_CTL(
- lut_directory + "/" + lut,
+ os.path.join(lut_directory, lut),
# None,
ctls,
lut_resolution_3d,
'type': 'lutFile',
'path': lut,
'interpolation': 'tetrahedral',
- 'direction': 'forward'
- })
+ 'direction': 'forward'})
shaper_inverse = shaper_OCIO_transform.copy()
shaper_inverse['direction'] = 'forward'
return cs
- #
- # RRT/ODT shaper options
- #
+ # -------------------------------------------------------------------------
+ # *RRT / ODT* Shaper Options
+ # -------------------------------------------------------------------------
shaper_data = {}
- # Log 2 shaper
+ # Defining the *Log 2* shaper.
log2_shaper_name = shaper_name
log2_params = {
'middleGrey': 0.18,
'minExposure': -6.0,
- 'maxExposure': 6.5
- }
+ 'maxExposure': 6.5}
+
log2_shaper = create_generic_log(
name=log2_shaper_name,
middle_grey=log2_params['middleGrey'],
shaper_input_scale_generic_log2 = 1.0
- # Log 2 shaper name and CTL transforms bundled up
+ # *Log 2* shaper name and *CTL* transforms bundled up.
log2_shaper_data = [
log2_shaper_name,
- '%s/utilities/ACESlib.OCIO_shaper_log2_to_lin_param.a1.0.0.ctl',
- '%s/utilities/ACESlib.OCIO_shaper_lin_to_log2_param.a1.0.0.ctl',
+ os.path.join('%s',
+ 'utilities',
+ 'ACESlib.OCIO_shaper_log2_to_lin_param.a1.0.0.ctl'),
+ os.path.join('%s',
+ 'utilities',
+ 'ACESlib.OCIO_shaper_lin_to_log2_param.a1.0.0.ctl'),
shaper_input_scale_generic_log2,
- log2_params
- ]
+ log2_params]
shaper_data[log2_shaper_name] = log2_shaper_data
- #
- # Shaper that also includes the AP1 primaries
- # - Needed for some LUT baking steps
- #
+ # Shaper that also includes the AP1 primaries.
+ # Needed for some LUT baking steps.
log2_shaper_AP1 = create_generic_log(
name=log2_shaper_name,
middle_grey=log2_params['middleGrey'],
min_exposure=log2_params['minExposure'],
max_exposure=log2_params['maxExposure'])
- log2_shaper_AP1.name = "%s - AP1" % log2_shaper_AP1.name
- # AP1 primaries to AP0 primaries
+ log2_shaper_AP1.name = '%s - AP1' % log2_shaper_AP1.name
+
+ # *AP1* primaries to *AP0* primaries.
log2_shaper_AP1.to_reference_transforms.append({
'type': 'matrix',
'matrix': mat44_from_mat33(ACES_AP1_to_AP0),
})
config_data['colorSpaces'].append(log2_shaper_AP1)
- #
- # Choose your shaper
- #
- rrt_shaper_name = log2_shaper_name
rrt_shaper = log2_shaper_data
- #
- # RRT + ODT Combinations
- #
+ # *RRT + ODT* combinations.
sorted_odts = sorted(odt_info.iteritems(), key=lambda x: x[1])
print(sorted_odts)
for odt in sorted_odts:
(odt_name, odt_values) = odt
- # Have to handle ODTs that can generate either legal or full output
+ # Handling *ODTs* that can generate either *legal* or *full* output.
if odt_name in ['Academy.Rec2020_100nits_dim.a1.0.0',
'Academy.Rec709_100nits_dim.a1.0.0',
'Academy.Rec709_D60sim_100nits_dim.a1.0.0']:
cleanup)
config_data['colorSpaces'].append(cs)
- # Create a display entry using this color space
config_data['displays'][odt_name_legal] = {
'Linear': ACES,
'Log': ACEScc,
if odt_name in ['Academy.Rec2020_100nits_dim.a1.0.0',
'Academy.Rec709_100nits_dim.a1.0.0',
'Academy.Rec709_D60sim_100nits_dim.a1.0.0']:
- print("Generating full range ODT for %s" % odt_name)
+ print('Generating full range ODT for %s' % odt_name)
- odt_name_full = "%s - Full" % odt_values['transformUserName']
+ odt_name_full = '%s - Full' % odt_values['transformUserName']
odt_full = odt_values.copy()
odt_full['legalRange'] = 0
cleanup)
config_data['colorSpaces'].append(cs_full)
- # Create a display entry using this color space
config_data['displays'][odt_name_full] = {
'Linear': ACES,
'Log': ACEScc,
'Output Transform': cs_full}
- #
+ # -------------------------------------------------------------------------
# Generic Matrix transform
- #
+ # -------------------------------------------------------------------------
def create_generic_matrix(name='matrix',
- from_reference_values=[],
- to_reference_values=[]):
+ from_reference_values=None,
+ to_reference_values=None):
+
+ if from_reference_values is None:
+ from_reference_values = []
+ if to_reference_values is None:
+ to_reference_values = []
+
cs = ColorSpace(name)
- cs.description = "The %s color space" % name
+ cs.description = 'The %s color space' % name
cs.equality_group = name
cs.family = 'Utility'
cs.is_data = False
cs.to_reference_transforms = []
- if to_reference_values != []:
+ if to_reference_values:
for matrix in to_reference_values:
cs.to_reference_transforms.append({
'type': 'matrix',
'matrix': mat44_from_mat33(matrix),
- 'direction': 'forward'
- })
+ 'direction': 'forward'})
cs.from_reference_transforms = []
- if from_reference_values != []:
+ if from_reference_values:
for matrix in from_reference_values:
cs.from_reference_transforms.append({
'type': 'matrix',
'matrix': mat44_from_mat33(matrix),
- 'direction': 'forward'
- })
+ 'direction': 'forward'})
return cs
'Linear - AP1', to_reference_values=[ACES_AP1_to_AP0])
config_data['colorSpaces'].append(cs)
- # ACES to Linear, P3D60 primaries
+ # *ACES* to *Linear*, *P3D60* primaries.
XYZ_to_P3D60 = [2.4027414142, -0.8974841639, -0.3880533700,
-0.8325796487, 1.7692317536, 0.0237127115,
0.0388233815, -0.0824996856, 1.0363685997]
from_reference_values=[ACES_AP0_to_XYZ, XYZ_to_P3D60])
config_data['colorSpaces'].append(cs)
- # ACES to Linear, P3D60 primaries
+ # *ACES* to *Linear*, *P3DCI* primaries.
XYZ_to_P3DCI = [2.7253940305, -1.0180030062, -0.4401631952,
-0.7951680258, 1.6897320548, 0.0226471906,
0.0412418914, -0.0876390192, 1.1009293786]
from_reference_values=[ACES_AP0_to_XYZ, XYZ_to_P3DCI])
config_data['colorSpaces'].append(cs)
- # ACES to Linear, Rec 709 primaries
+ # *ACES* to *Linear*, *Rec. 709* primaries.
XYZ_to_Rec709 = [3.2409699419, -1.5373831776, -0.4986107603,
-0.9692436363, 1.8759675015, 0.0415550574,
0.0556300797, -0.2039769589, 1.0569715142]
from_reference_values=[ACES_AP0_to_XYZ, XYZ_to_Rec709])
config_data['colorSpaces'].append(cs)
- # ACES to Linear, Rec 2020 primaries
+ # *ACES* to *Linear*, *Rec. 2020* primaries.
XYZ_to_Rec2020 = [1.7166511880, -0.3556707838, -0.2533662814,
-0.6666843518, 1.6164812366, 0.0157685458,
0.0176398574, -0.0427706133, 0.9421031212]
from_reference_values=[ACES_AP0_to_XYZ, XYZ_to_Rec2020])
config_data['colorSpaces'].append(cs)
- print("generateLUTs - end")
+ print('generateLUTs - end')
return config_data
Return value description.
"""
- # Add the legal and full variations into this list
odt_info_C = dict(odt_info)
for odt_CTL_name, odt_values in odt_info.iteritems():
if odt_CTL_name in ['Academy.Rec2020_100nits_dim.a1.0.0',
'Academy.Rec709_100nits_dim.a1.0.0',
'Academy.Rec709_D60sim_100nits_dim.a1.0.0']:
- odt_name = odt_values["transformUserName"]
+ odt_name = odt_values['transformUserName']
odt_values_legal = dict(odt_values)
- odt_values_legal["transformUserName"] = "%s - Legal" % odt_name
- odt_info_C["%s - Legal" % odt_CTL_name] = odt_values_legal
+ odt_values_legal['transformUserName'] = '%s - Legal' % odt_name
+ odt_info_C['%s - Legal' % odt_CTL_name] = odt_values_legal
odt_values_full = dict(odt_values)
- odt_values_full["transformUserName"] = "%s - Full" % odt_name
- odt_info_C["%s - Full" % odt_CTL_name] = odt_values_full
+ odt_values_full['transformUserName'] = '%s - Full' % odt_name
+ odt_info_C['%s - Full' % odt_CTL_name] = odt_values_full
del (odt_info_C[odt_CTL_name])
for odt_CTL_name, odt_values in odt_info_C.iteritems():
- odt_prefix = odt_values["transformUserNamePrefix"]
- odt_name = odt_values["transformUserName"]
-
- # For Photoshop
- for input_space in ["ACEScc", "ACESproxy"]:
- args = ["--iconfig", config_path,
- "-v",
- "--inputspace", input_space]
- args += ["--outputspace", "%s" % odt_name]
- args += ["--description",
- "%s - %s for %s data" % (odt_prefix,
+ odt_prefix = odt_values['transformUserNamePrefix']
+ odt_name = odt_values['transformUserName']
+
+ # *Photoshop*
+ for input_space in ['ACEScc', 'ACESproxy']:
+ args = ['--iconfig', config_path,
+ '-v',
+ '--inputspace', input_space]
+ args += ['--outputspace', '%s' % odt_name]
+ args += ['--description',
+ '%s - %s for %s data' % (odt_prefix,
odt_name,
input_space)]
- args += ["--shaperspace", shaper_name,
- "--shapersize", str(lut_resolution_shaper)]
- args += ["--cubesize", str(lut_resolution_3d)]
- args += ["--format",
- "icc",
- "%s/photoshop/%s for %s.icc" % (baked_directory,
- odt_name,
- input_space)]
-
- bake_LUT = Process(description="bake a LUT",
- cmd="ociobakelut",
+ args += ['--shaperspace', shaper_name,
+ '--shapersize', str(lut_resolution_shaper)]
+ args += ['--cubesize', str(lut_resolution_3d)]
+ args += ['--format',
+ 'icc',
+ os.path.join(baked_directory,
+ 'photoshop',
+ '%s for %s.icc' % (odt_name, input_space))]
+
+ bake_LUT = Process(description='bake a LUT',
+ cmd='ociobakelut',
args=args)
bake_LUT.execute()
- # For Flame, Lustre
- for input_space in ["ACEScc", "ACESproxy"]:
- args = ["--iconfig", config_path,
- "-v",
- "--inputspace", input_space]
- args += ["--outputspace", "%s" % odt_name]
- args += ["--description",
- "%s - %s for %s data" % (
+ # *Flame*, *Lustre*
+ for input_space in ['ACEScc', 'ACESproxy']:
+ args = ['--iconfig', config_path,
+ '-v',
+ '--inputspace', input_space]
+ args += ['--outputspace', '%s' % odt_name]
+ args += ['--description',
+ '%s - %s for %s data' % (
odt_prefix, odt_name, input_space)]
- args += ["--shaperspace", shaper_name,
- "--shapersize", str(lut_resolution_shaper)]
- args += ["--cubesize", str(lut_resolution_3d)]
-
- fargs = ["--format", "flame", "%s/flame/%s for %s Flame.3dl" % (
- baked_directory, odt_name, input_space)]
- bake_LUT = Process(description="bake a LUT",
- cmd="ociobakelut",
+ args += ['--shaperspace', shaper_name,
+ '--shapersize', str(lut_resolution_shaper)]
+ args += ['--cubesize', str(lut_resolution_3d)]
+
+ fargs = ['--format',
+ 'flame',
+ os.path.join(
+ baked_directory,
+ 'flame',
+ '%s for %s Flame.3dl' % (odt_name, input_space))]
+ bake_LUT = Process(description='bake a LUT',
+ cmd='ociobakelut',
args=(args + fargs))
bake_LUT.execute()
- largs = ["--format", "lustre", "%s/lustre/%s for %s Lustre.3dl" % (
- baked_directory, odt_name, input_space)]
- bake_LUT = Process(description="bake a LUT",
- cmd="ociobakelut",
+ largs = ['--format',
+ 'lustre',
+ os.path.join(
+ baked_directory,
+ 'lustre',
+ '%s for %s Lustre.3dl' % (odt_name, input_space))]
+ bake_LUT = Process(description='bake a LUT',
+ cmd='ociobakelut',
args=(args + largs))
bake_LUT.execute()
- # For Maya, Houdini
- for input_space in ["ACEScg", "ACES2065-1"]:
- args = ["--iconfig", config_path,
- "-v",
- "--inputspace", input_space]
- args += ["--outputspace", "%s" % odt_name]
- args += ["--description",
- "%s - %s for %s data" % (
+ # *Maya*, *Houdini*
+ for input_space in ['ACEScg', 'ACES2065-1']:
+ args = ['--iconfig', config_path,
+ '-v',
+ '--inputspace', input_space]
+ args += ['--outputspace', '%s' % odt_name]
+ args += ['--description',
+ '%s - %s for %s data' % (
odt_prefix, odt_name, input_space)]
if input_space == 'ACEScg':
- lin_shaper_name = "%s - AP1" % shaper_name
+ lin_shaper_name = '%s - AP1' % shaper_name
else:
lin_shaper_name = shaper_name
- args += ["--shaperspace", lin_shaper_name,
- "--shapersize", str(lut_resolution_shaper)]
-
- args += ["--cubesize", str(lut_resolution_3d)]
-
- margs = ["--format", "cinespace", "%s/maya/%s for %s Maya.csp" % (
- baked_directory, odt_name, input_space)]
- bake_LUT = Process(description="bake a LUT",
- cmd="ociobakelut",
+ args += ['--shaperspace', lin_shaper_name,
+ '--shapersize', str(lut_resolution_shaper)]
+
+ args += ['--cubesize', str(lut_resolution_3d)]
+
+ margs = ['--format',
+ 'cinespace',
+ os.path.join(
+ baked_directory,
+ 'maya',
+ '%s for %s Maya.csp' % (odt_name, input_space))]
+ bake_LUT = Process(description='bake a LUT',
+ cmd='ociobakelut',
args=(args + margs))
bake_LUT.execute()
- hargs = ["--format", "houdini",
- "%s/houdini/%s for %s Houdini.lut" % (
- baked_directory, odt_name, input_space)]
- bake_LUT = Process(description="bake a LUT",
- cmd="ociobakelut",
+ hargs = ['--format',
+ 'houdini',
+ os.path.join(
+ baked_directory,
+ 'houdini',
+ '%s for %s Houdini.lut' % (odt_name, input_space))]
+ bake_LUT = Process(description='bake a LUT',
+ cmd='ociobakelut',
args=(args + hargs))
bake_LUT.execute()
Return value description.
"""
- dirs = [config_directory, "%s/luts" % config_directory]
+ dirs = [config_directory, os.path.join(config_directory, 'luts')]
if bake_secondary_LUTs:
- dirs.extend(["%s/baked" % config_directory,
- "%s/baked/flame" % config_directory,
- "%s/baked/photoshop" % config_directory,
- "%s/baked/houdini" % config_directory,
- "%s/baked/lustre" % config_directory,
- "%s/baked/maya" % config_directory])
+ dirs.extend([os.path.join(config_directory, 'baked'),
+ os.path.join(config_directory, 'baked', 'flame'),
+ os.path.join(config_directory, 'baked', 'photoshop'),
+ os.path.join(config_directory, 'baked', 'houdini'),
+ os.path.join(config_directory, 'baked', 'lustre'),
+ os.path.join(config_directory, 'baked', 'maya')])
for d in dirs:
not os.path.exists(d) and os.mkdir(d)
Return value description.
"""
- # TODO: Use *with* statement.
- fp = open(ctl_transform, 'rb')
+ with open(ctl_transform, 'rb') as fp:
+ lines = fp.readlines()
- # Read lines
- lines = fp.readlines()
-
- # Grab transform ID and User Name
- transform_ID = lines[1][3:].split('<')[1].split('>')[1].strip()
- # print(transformID)
+ # Retrieving the *transform ID* and *User Name*.
+ transform_id = lines[1][3:].split('<')[1].split('>')[1].strip()
transform_user_name = '-'.join(
lines[2][3:].split('<')[1].split('>')[1].split('-')[1:]).strip()
transform_user_name_prefix = (
lines[2][3:].split('<')[1].split('>')[1].split('-')[0].strip())
- # print(transformUserName)
- fp.close()
- return transform_ID, transform_user_name, transform_user_name_prefix
+ return transform_id, transform_user_name, transform_user_name_prefix
def get_ODT_info(aces_CTL_directory):
"""
# TODO: Investigate usage of *files_walker* definition here.
- # Credit to Alex Fry for the original approach here
- odt_dir = os.path.join(aces_CTL_directory, "odt")
+ # Credit to *Alex Fry* for the original approach here.
+ odt_dir = os.path.join(aces_CTL_directory, 'odt')
all_odt = []
for dir_name, subdir_list, file_list in os.walk(odt_dir):
for fname in file_list:
all_odt.append((os.path.join(dir_name, fname)))
odt_CTLs = [x for x in all_odt if
- ("InvODT" not in x) and (os.path.split(x)[-1][0] != '.')]
-
- # print odtCTLs
+ ('InvODT' not in x) and (os.path.split(x)[-1][0] != '.')]
odts = {}
for odt_CTL in odt_CTLs:
odt_tokens = os.path.split(odt_CTL)
- # print(odtTokens)
- # Handle nested directories
+ # Handling nested directories.
odt_path_tokens = os.path.split(odt_tokens[-2])
odt_dir = odt_path_tokens[-1]
while odt_path_tokens[-2][-3:] != 'odt':
odt_path_tokens = os.path.split(odt_path_tokens[-2])
odt_dir = os.path.join(odt_path_tokens[-1], odt_dir)
- # Build full name
- # print("odtDir : %s" % odtDir)
+ # Building full name,
transform_CTL = odt_tokens[-1]
- # print(transformCTL)
odt_name = string.join(transform_CTL.split('.')[1:-1], '.')
- # print(odtName)
- # Find id, user name and user name prefix
+ # Finding id, user name and user name prefix.
(transform_ID,
transform_user_name,
transform_user_name_prefix) = get_transform_info(
- "%s/odt/%s/%s" % (aces_CTL_directory, odt_dir, transform_CTL))
+ os.path.join(aces_CTL_directory, 'odt', odt_dir, transform_CTL))
- # Find inverse
- transform_CTL_inverse = "InvODT.%s.ctl" % odt_name
+ # Finding inverse.
+ transform_CTL_inverse = 'InvODT.%s.ctl' % odt_name
if not os.path.exists(
os.path.join(odt_tokens[-2], transform_CTL_inverse)):
transform_CTL_inverse = None
- # print(transformCTLInverse)
# Add to list of ODTs
odts[odt_name] = {}
odts[odt_name]['transformCTL'] = os.path.join(odt_dir, transform_CTL)
- if transform_CTL_inverse != None:
+ if transform_CTL_inverse is not None:
odts[odt_name]['transformCTLInverse'] = os.path.join(
odt_dir, transform_CTL_inverse)
odts[odt_name]['transformUserNamePrefix'] = transform_user_name_prefix
odts[odt_name]['transformUserName'] = transform_user_name
- print("ODT : %s" % odt_name)
- print("\tTransform ID : %s" % transform_ID)
- print("\tTransform User Name Prefix : %s" % transform_user_name_prefix)
- print("\tTransform User Name : %s" % transform_user_name)
- print("\tForward ctl : %s" % (
- odts[odt_name]['transformCTL']))
+ forward_CTL = odts[odt_name]['transformCTL']
+
+ print('ODT : %s' % odt_name)
+ print('\tTransform ID : %s' % transform_ID)
+ print('\tTransform User Name Prefix : %s' % transform_user_name_prefix)
+ print('\tTransform User Name : %s' % transform_user_name)
+ print('\tForward ctl : %s' % forward_CTL)
if 'transformCTLInverse' in odts[odt_name]:
- print("\tInverse ctl : %s" % (
- odts[odt_name]['transformCTLInverse']))
+ inverse_CTL = odts[odt_name]['transformCTLInverse']
+ print('\tInverse ctl : %s' % inverse_CTL)
else:
- print("\tInverse ctl : %s" % "None")
+ print('\tInverse ctl : %s' % 'None')
- print("\n")
+ print('\n')
return odts
# TODO: Investigate refactoring with previous definition.
# Credit to Alex Fry for the original approach here
- lmt_dir = os.path.join(aces_CTL_directory, "lmt")
+ lmt_dir = os.path.join(aces_CTL_directory, 'lmt')
all_lmt = []
for dir_name, subdir_list, file_list in os.walk(lmt_dir):
for fname in file_list:
all_lmt.append((os.path.join(dir_name, fname)))
lmt_CTLs = [x for x in all_lmt if
- ("InvLMT" not in x) and ("README" not in x) and (
+ ('InvLMT' not in x) and ('README' not in x) and (
os.path.split(x)[-1][0] != '.')]
- # print lmtCTLs
-
lmts = {}
for lmt_CTL in lmt_CTLs:
lmt_tokens = os.path.split(lmt_CTL)
- # print(lmtTokens)
- # Handle nested directories
+ # Handlimg nested directories.
lmt_path_tokens = os.path.split(lmt_tokens[-2])
lmt_dir = lmt_path_tokens[-1]
while lmt_path_tokens[-2][-3:] != 'ctl':
lmt_path_tokens = os.path.split(lmt_path_tokens[-2])
lmt_dir = os.path.join(lmt_path_tokens[-1], lmt_dir)
- # Build full name
- # print("lmtDir : %s" % lmtDir)
+ # Building full name.
transform_CTL = lmt_tokens[-1]
- # print(transformCTL)
lmt_name = string.join(transform_CTL.split('.')[1:-1], '.')
- # print(lmtName)
- # Find id, user name and user name prefix
+ # Finding id, user name and user name prefix.
(transform_ID,
transform_user_name,
transform_user_name_prefix) = get_transform_info(
- "%s/%s/%s" % (aces_CTL_directory, lmt_dir, transform_CTL))
+ os.path.join(aces_CTL_directory, lmt_dir, transform_CTL))
- # Find inverse
- transform_CTL_inverse = "InvLMT.%s.ctl" % lmt_name
+ # Finding inverse.
+ transform_CTL_inverse = 'InvLMT.%s.ctl' % lmt_name
if not os.path.exists(
os.path.join(lmt_tokens[-2], transform_CTL_inverse)):
transform_CTL_inverse = None
- # print(transformCTLInverse)
- # Add to list of LMTs
lmts[lmt_name] = {}
lmts[lmt_name]['transformCTL'] = os.path.join(lmt_dir, transform_CTL)
- if transform_CTL_inverse != None:
- # TODO: Check unresolved *odt_name* referemce.
- lmts[odt_name]['transformCTLInverse'] = os.path.join(
+ if transform_CTL_inverse is not None:
+ lmts[lmt_name]['transformCTLInverse'] = os.path.join(
lmt_dir, transform_CTL_inverse)
lmts[lmt_name]['transformID'] = transform_ID
lmts[lmt_name]['transformUserNamePrefix'] = transform_user_name_prefix
lmts[lmt_name]['transformUserName'] = transform_user_name
- print("LMT : %s" % lmt_name)
- print("\tTransform ID : %s" % transform_ID)
- print("\tTransform User Name Prefix : %s" % transform_user_name_prefix)
- print("\tTransform User Name : %s" % transform_user_name)
- print("\t Forward ctl : %s" % lmts[lmt_name]['transformCTL'])
+ forward_CTL = lmts[lmt_name]['transformCTL']
+
+ print('LMT : %s' % lmt_name)
+ print('\tTransform ID : %s' % transform_ID)
+ print('\tTransform User Name Prefix : %s' % transform_user_name_prefix)
+ print('\tTransform User Name : %s' % transform_user_name)
+ print('\t Forward ctl : %s' % forward_CTL)
if 'transformCTLInverse' in lmts[lmt_name]:
- print("\t Inverse ctl : %s" % (
- lmts[lmt_name]['transformCTLInverse']))
+ inverse_CTL = lmts[lmt_name]['transformCTLInverse']
+ print('\t Inverse ctl : %s' % inverse_CTL)
else:
- print("\t Inverse ctl : %s" % "None")
+ print('\t Inverse ctl : %s' % 'None')
- print("\n")
+ print('\n')
return lmts
Return value description.
"""
- # Get ODT names and CTL paths
odt_info = get_ODT_info(aces_CTL_directory)
-
- # Get ODT names and CTL paths
lmt_info = get_LMT_info(aces_CTL_directory)
- # Create config dir
create_config_dir(config_directory, bake_secondary_LUTs)
- # Generate config data and LUTs for different transforms
- lut_directory = "%s/luts" % config_directory
+ lut_directory = os.path.join(config_directory, 'luts')
shaper_name = 'Output Shaper'
config_data = generate_LUTs(odt_info,
lmt_info,
lut_resolution_3d,
cleanup)
- # Create the config using the generated LUTs
- print("Creating generic config")
+ print('Creating "generic" config')
config = create_config(config_data)
- print("\n\n\n")
+ print('\n\n\n')
- # Write the config to disk
- write_config(config, "%s/config.ocio" % config_directory)
+ write_config(config,
+ os.path.join(config_directory, 'config.ocio'))
- # Create a config that will work well with Nuke using the previously
- # generated LUTs.
- print("Creating Nuke-specific config")
+ print('Creating "Nuke" config')
nuke_config = create_config(config_data, nuke=True)
- print("\n\n\n")
+ print('\n\n\n')
- # Write the config to disk
- write_config(nuke_config, "%s/nuke_config.ocio" % config_directory)
+ write_config(nuke_config,
+ os.path.join(config_directory, 'nuke_config.ocio'))
- # Bake secondary LUTs using the config
if bake_secondary_LUTs:
generate_baked_LUTs(odt_info,
shaper_name,
- "%s/baked" % config_directory,
- "%s/config.ocio" % config_directory,
+ os.path.join(config_directory, 'baked'),
+ os.path.join(config_directory, 'config.ocio'),
lut_resolution_1d,
lut_resolution_3d,
lut_resolution_1d)
version='createACESConfig 0.1',
usage='%prog [options]')
p.add_option('--acesCTLDir', '-a', default=os.environ.get(
- 'ACES_OCIO_CTL_DIRECTORY', None))
+ ACES_OCIO_CTL_DIRECTORY_ENVIRON, None))
p.add_option('--configDir', '-c', default=os.environ.get(
- 'ACES_OCIO_CONFIGURATION_DIRECTORY', None))
+ ACES_OCIO_CONFIGURATION_DIRECTORY_ENVIRON, None))
p.add_option('--lutResolution1d', default=4096)
p.add_option('--lutResolution3d', default=64)
- p.add_option('--dontBakeSecondaryLUTs', action="store_true")
- p.add_option('--keepTempImages', action="store_true")
+ p.add_option('--dontBakeSecondaryLUTs', action='store_true')
+ p.add_option('--keepTempImages', action='store_true')
options, arguments = p.parse_args()
- #
- # Get options
- #
aces_CTL_directory = options.acesCTLDir
config_directory = options.configDir
lut_resolution_1d = int(options.lutResolution1d)
lut_resolution_3d = int(options.lutResolution3d)
- bake_secondary_LUTs = not (options.dontBakeSecondaryLUTs)
- cleanup_temp_images = not (options.keepTempImages)
+ bake_secondary_LUTs = not options.dontBakeSecondaryLUTs
+ cleanup_temp_images = not options.keepTempImages
+ # TODO: Investigate the following statements.
try:
args_start = sys.argv.index('--') + 1
args = sys.argv[args_start:]
args_start = len(sys.argv) + 1
args = []
- print("command line : \n%s\n" % " ".join(sys.argv))
-
- # TODO: Use assertion and mention environment variables.
- if not aces_CTL_directory:
- print("process: No ACES CTL directory specified")
- return
- if not config_directory:
- print("process: No configuration directory specified")
- return
- #
- # Generate the configuration
- #
+ print('command line : \n%s\n' % ' '.join(sys.argv))
+
+ assert aces_CTL_directory is not None, (
+ 'process: No "{0}" environment variable defined or no "ACES CTL" '
+ 'directory specified'.format(
+ ACES_OCIO_CTL_DIRECTORY_ENVIRON))
+
+ assert config_directory is not None, (
+ 'process: No "{0}" environment variable defined or no configuration '
+ 'directory specified'.format(
+ ACES_OCIO_CONFIGURATION_DIRECTORY_ENVIRON))
+
return create_ACES_config(aces_CTL_directory,
config_directory,
lut_resolution_1d,
Return value description.
"""
- # print("Generate 1d LUT image - %s" % ramp1dPath)
-
- # open image
- format = os.path.splitext(ramp_1d_path)[1]
ramp = oiio.ImageOutput.create(ramp_1d_path)
- # set image specs
spec = oiio.ImageSpec()
spec.set_format(oiio.FLOAT)
# spec.format.basetype = oiio.FLOAT
ramp.open(ramp_1d_path, spec, oiio.Create)
- data = array.array("f",
- "\0" * spec.width * spec.height * spec.nchannels * 4)
+ data = array.array('f',
+ '\0' * spec.width * spec.height * spec.nchannels * 4)
for i in range(resolution):
value = float(i) / (resolution - 1) * (
max_value - min_value) + min_value
Return value description.
"""
- f = file(filename, 'w')
- f.write("Version 1\n")
- f.write("From %f %f\n" % (from_min, from_max))
- f.write("Length %d\n" % entries)
- f.write("Components %d\n" % (min(3, channels)))
- f.write("{\n")
- for i in range(0, entries):
- entry = ""
- for j in range(0, min(3, channels)):
- entry = "%s %s" % (entry, data[i * channels + j])
- f.write(" %s\n" % entry)
- f.write("}\n")
- f.close()
+ with open(filename, 'w') as fp:
+ fp.write('Version 1\n')
+ fp.write('From %f %f\n' % (from_min, from_max))
+ fp.write('Length %d\n' % entries)
+ fp.write('Components %d\n' % (min(3, channels)))
+ fp.write('{\n')
+ for i in range(0, entries):
+ entry = ''
+ for j in range(0, min(3, channels)):
+ entry = '%s %s' % (entry, data[i * channels + j])
+ fp.write(' %s\n' % entry)
+ fp.write('}\n')
def generate_1d_LUT_from_image(ramp_1d_path,
"""
if output_path is None:
- output_path = ramp_1d_path + ".spi1d"
+ output_path = '%s.%s' % (ramp_1d_path, 'spi1d')
- # open image
ramp = oiio.ImageInput.open(ramp_1d_path)
- # get image specs
spec = ramp.spec()
- type = spec.format.basetype
width = spec.width
- height = spec.height
channels = spec.nchannels
- # get data
- # Force data to be read as float. The Python API doesn't handle
- # half-floats well yet.
+ # Forcibly read data as float, the Python API doesn't handle half-float
+ # well yet.
type = oiio.FLOAT
data = ramp.read_image(type)
Return value description.
"""
- args = ["--generate",
- "--cubesize",
+ args = ['--generate',
+ '--cubesize',
str(resolution),
- "--maxwidth",
+ '--maxwidth',
str(resolution * resolution),
- "--output",
+ '--output',
ramp_3d_path]
- lut_extract = Process(description="generate a 3d LUT image",
- cmd="ociolutimage",
+ lut_extract = Process(description='generate a 3d LUT image',
+ cmd='ociolutimage',
args=args)
lut_extract.execute()
"""
if output_path is None:
- output_path = ramp_3d_path + ".spi3d"
+ output_path = '%s.%s' % (ramp_3d_path, 'spi1d')
- args = ["--extract",
- "--cubesize",
+ args = ['--extract',
+ '--cubesize',
str(resolution),
- "--maxwidth",
+ '--maxwidth',
str(resolution * resolution),
- "--input",
+ '--input',
ramp_3d_path,
- "--output",
+ '--output',
output_path]
- lut_extract = Process(description="extract a 3d LUT",
- cmd="ociolutimage",
+ lut_extract = Process(description='extract a 3d LUT',
+ cmd='ociolutimage',
args=args)
lut_extract.execute()
def apply_CTL_to_image(input_image,
output_image,
- ctl_paths=[],
+ ctl_paths=None,
input_scale=1.0,
output_scale=1.0,
- global_params={},
+ global_params=None,
aces_CTL_directory=None):
"""
Object description.
Return value description.
"""
+ if ctl_paths is None:
+ ctl_paths = []
+ if global_params is None:
+ global_params = {}
+
if len(ctl_paths) > 0:
ctlenv = os.environ
- if aces_CTL_directory != None:
- if os.path.split(aces_CTL_directory)[1] != "utilities":
- ctl_module_path = "%s/utilities" % aces_CTL_directory
+ if aces_CTL_directory is not None:
+ if os.path.split(aces_CTL_directory)[1] != 'utilities':
+ ctl_module_path = os.path.join(aces_CTL_directory, 'utilities')
else:
ctl_module_path = aces_CTL_directory
ctlenv['CTL_MODULE_PATH'] = ctl_module_path
args = []
for ctl in ctl_paths:
args += ['-ctl', ctl]
- args += ["-force"]
- # args += ["-verbose"]
- args += ["-input_scale", str(input_scale)]
- args += ["-output_scale", str(output_scale)]
- args += ["-global_param1", "aIn", "1.0"]
+ args += ['-force']
+ args += ['-input_scale', str(input_scale)]
+ args += ['-output_scale', str(output_scale)]
+ args += ['-global_param1', 'aIn', '1.0']
for key, value in global_params.iteritems():
- args += ["-global_param1", key, str(value)]
+ args += ['-global_param1', key, str(value)]
args += [input_image]
args += [output_image]
- # print("args : %s" % args)
-
- ctlp = Process(description="a ctlrender process",
- cmd="ctlrender",
+ ctlp = Process(description='a ctlrender process',
+ cmd='ctlrender',
args=args, env=ctlenv)
ctlp.execute()
"""
args = [input_image,
- "-d",
+ '-d',
depth,
- "-o",
+ '-o',
output_image]
- convert = Process(description="convert image bit depth",
- cmd="oiiotool",
+ convert = Process(description='convert image bit depth',
+ cmd='oiiotool',
args=args)
convert.execute()
identity_LUT_bit_depth='half',
input_scale=1.0,
output_scale=1.0,
- global_params={},
+ global_params=None,
cleanup=True,
aces_CTL_directory=None,
min_value=0.0,
Return value description.
"""
- # print(lutPath)
- # print(ctlPaths)
+ if global_params is None:
+ global_params = {}
lut_path_base = os.path.splitext(lut_path)[0]
- identity_LUT_image_float = lut_path_base + ".float.tiff"
+ identity_LUT_image_float = '%s.%s.%s' % (lut_path_base, 'float', 'tiff')
generate_1d_LUT_image(identity_LUT_image_float,
lut_resolution,
min_value,
max_value)
if identity_LUT_bit_depth != 'half':
- identity_LUT_image = lut_path_base + ".uint16.tiff"
+ identity_LUT_image = '%s.%s.%s' % (lut_path_base, 'uint16', 'tiff')
convert_bit_depth(identity_LUT_image_float,
identity_LUT_image,
identity_LUT_bit_depth)
else:
identity_LUT_image = identity_LUT_image_float
- transformed_LUT_image = lut_path_base + ".transformed.exr"
+ transformed_LUT_image = '%s.%s.%s' % (lut_path_base, 'transformed', 'exr')
apply_CTL_to_image(identity_LUT_image,
transformed_LUT_image,
ctl_paths,
Return value description.
"""
- # open image
transformed = oiio.ImageInput.open(transformed_LUT_image)
- # get image specs
transformed_spec = transformed.spec()
- type = transformed_spec.format.basetype
width = transformed_spec.width
height = transformed_spec.height
channels = transformed_spec.nchannels
- # rotate or not
if width != lut_resolution * lut_resolution or height != lut_resolution:
- print(("Correcting image as resolution is off. "
- "Found %d x %d. Expected %d x %d") % (
+ print(('Correcting image as resolution is off. '
+ 'Found %d x %d. Expected %d x %d') % (
width,
height,
lut_resolution * lut_resolution,
lut_resolution))
- print("Generating %s" % corrected_LUT_image)
+ print('Generating %s' % corrected_LUT_image)
- #
- # We're going to generate a new correct image
- #
-
- # Get the source data
- # Force data to be read as float. The Python API doesn't handle
- # half-floats well yet.
+ # Forcibly read data as float, the Python API doesn't handle half-float
+ # well yet.
type = oiio.FLOAT
source_data = transformed.read_image(type)
- format = os.path.splitext(corrected_LUT_image)[1]
correct = oiio.ImageOutput.create(corrected_LUT_image)
- # set image specs
correct_spec = oiio.ImageSpec()
correct_spec.set_format(oiio.FLOAT)
correct_spec.width = height
correct.open(corrected_LUT_image, correct_spec, oiio.Create)
- dest_data = array.array("f",
- ("\0" * correct_spec.width *
+ dest_data = array.array('f',
+ ('\0' * correct_spec.width *
correct_spec.height *
correct_spec.nchannels * 4))
for j in range(0, correct_spec.height):
for i in range(0, correct_spec.width):
for c in range(0, correct_spec.nchannels):
- # print(i, j, c)
dest_data[(correct_spec.nchannels *
correct_spec.width * j +
correct_spec.nchannels * i + c)] = (
identity_LUT_bit_depth='half',
input_scale=1.0,
output_scale=1.0,
- global_params={},
+ global_params=None,
cleanup=True,
aces_CTL_directory=None):
"""
Return value description.
"""
- # print(lutPath)
- # print(ctlPaths)
+ if global_params is None:
+ global_params = {}
lut_path_base = os.path.splitext(lut_path)[0]
- identity_LUT_image_float = lut_path_base + ".float.tiff"
+ identity_LUT_image_float = '%s.%s.%s' % (lut_path_base, 'float', 'tiff')
generate_3d_LUT_image(identity_LUT_image_float, lut_resolution)
if identity_LUT_bit_depth != 'half':
- identity_LUT_image = (lut_path_base +
- "." +
- identity_LUT_bit_depth +
- ".tiff")
+ identity_LUT_image = '%s.%s.%s' % (lut_path_base,
+ identity_LUT_bit_depth,
+ 'tiff')
convert_bit_depth(identity_LUT_image_float,
identity_LUT_image,
identity_LUT_bit_depth)
else:
identity_LUT_image = identity_LUT_image_float
- transformed_LUT_image = lut_path_base + ".transformed.exr"
+ transformed_LUT_image = '%s.%s.%s' % (lut_path_base, 'transformed', 'exr')
apply_CTL_to_image(identity_LUT_image,
transformed_LUT_image,
ctl_paths,
global_params,
aces_CTL_directory)
- corrected_LUT_image = lut_path_base + ".correct.exr"
+ corrected_LUT_image = '%s.%s.%s' % (lut_path_base, 'correct', 'exr')
corrected_LUT_image = correct_LUT_image(transformed_LUT_image,
corrected_LUT_image,
lut_resolution)
os.remove(transformed_LUT_image)
if corrected_LUT_image != transformed_LUT_image:
os.remove(corrected_LUT_image)
- # os.remove(correctedLUTImage)
def main():
version='0.01',
usage='%prog [options]')
- p.add_option('--lut', '-l', type="string", default="")
- p.add_option('--ctl', '-c', type="string", action="append")
- p.add_option('--lut_resolution_1d', '', type="int", default=1024)
- p.add_option('--lut_resolution_3d', '', type="int", default=33)
- p.add_option('--ctlReleasePath', '-r', type="string", default="")
- p.add_option('--bitDepth', '-b', type="string", default="float")
- p.add_option('--keepTempImages', '', action="store_true")
- p.add_option('--minValue', '', type="float", default=0.0)
- p.add_option('--maxValue', '', type="float", default=1.0)
- p.add_option('--inputScale', '', type="float", default=1.0)
- p.add_option('--outputScale', '', type="float", default=1.0)
- p.add_option('--ctlRenderParam', '-p', type="string", nargs=2,
- action="append")
-
- p.add_option('--generate1d', '', action="store_true")
- p.add_option('--generate3d', '', action="store_true")
+ p.add_option('--lut', '-l', type='string', default='')
+ p.add_option('--ctl', '-c', type='string', action='append')
+ p.add_option('--lutResolution1d', '', type='int', default=1024)
+ p.add_option('--lutResolution3d', '', type='int', default=33)
+ p.add_option('--ctlReleasePath', '-r', type='string', default='')
+ p.add_option('--bitDepth', '-b', type='string', default='float')
+ p.add_option('--keepTempImages', '', action='store_true')
+ p.add_option('--minValue', '', type='float', default=0.0)
+ p.add_option('--maxValue', '', type='float', default=1.0)
+ p.add_option('--inputScale', '', type='float', default=1.0)
+ p.add_option('--outputScale', '', type='float', default=1.0)
+ p.add_option('--ctlRenderParam', '-p', type='string', nargs=2,
+ action='append')
+
+ p.add_option('--generate1d', '', action='store_true')
+ p.add_option('--generate3d', '', action='store_true')
options, arguments = p.parse_args()
- #
- # Get options
- #
lut = options.lut
ctls = options.ctl
lut_resolution_1d = options.lut_resolution_1d
ctl_release_path = options.ctlReleasePath
generate_1d = options.generate1d is True
generate_3d = options.generate3d is True
- bitdepth = options.bitDepth
+ bit_depth = options.bitDepth
cleanup = not options.keepTempImages
params = {}
- if options.ctlRenderParam != None:
+ if options.ctlRenderParam is not None:
for param in options.ctlRenderParam:
params[param[0]] = float(param[1])
args_start = len(sys.argv) + 1
args = []
- # print("command line : \n%s\n" % " ".join(sys.argv))
-
- #
- # Generate LUTs
- #
if generate_1d:
- print("1D LUT generation options")
+ print('1D LUT generation options')
else:
- print("3D LUT generation options")
-
- print("lut : %s" % lut)
- print("ctls : %s" % ctls)
- print("lut res 1d : %s" % lut_resolution_1d)
- print("lut res 3d : %s" % lut_resolution_3d)
- print("min value : %s" % min_value)
- print("max value : %s" % max_value)
- print("input scale : %s" % input_scale)
- print("output scale : %s" % output_scale)
- print("ctl render params : %s" % params)
- print("ctl release path : %s" % ctl_release_path)
- print("bit depth of input : %s" % bitdepth)
- print("cleanup temp images : %s" % cleanup)
+ print('3D LUT generation options')
+
+ print('lut : %s' % lut)
+ print('ctls : %s' % ctls)
+ print('lut res 1d : %s' % lut_resolution_1d)
+ print('lut res 3d : %s' % lut_resolution_3d)
+ print('min value : %s' % min_value)
+ print('max value : %s' % max_value)
+ print('input scale : %s' % input_scale)
+ print('output scale : %s' % output_scale)
+ print('ctl render params : %s' % params)
+ print('ctl release path : %s' % ctl_release_path)
+ print('bit depth of input : %s' % bit_depth)
+ print('cleanup temp images : %s' % cleanup)
if generate_1d:
generate_1d_LUT_from_CTL(lut,
ctls,
lut_resolution_1d,
- bitdepth,
+ bit_depth,
input_scale,
output_scale,
params,
generate_3d_LUT_from_CTL(lut,
ctls,
lut_resolution_3d,
- bitdepth,
+ bit_depth,
input_scale,
output_scale,
params,
cleanup,
ctl_release_path)
else:
- print(("\n\nNo LUT generated. "
- "You must choose either 1D or 3D LUT generation\n\n"))
+ print(('\n\nNo LUT generated. '
+ 'You must choose either 1D or 3D LUT generation\n\n'))
if __name__ == '__main__':
projects / OpenColorIO-Configs.git / commitdiff