from aces_ocio.colorspaces import sony
from aces_ocio.process import Process
-from aces_ocio.utilities import replace, ColorSpace, compact
+from aces_ocio.utilities import (
+ ColorSpace,
+ colorspace_prefixed_name,
+ compact,
+ replace,
+ unpack_default)
__author__ = 'ACES Developers'
__copyright__ = 'Copyright (C) 2014 - 2015 - ACES Developers'
'set_config_default_roles',
'write_config',
'generate_OCIO_transform',
- 'add_colorspace_alias',
+ 'add_colorspace_aliases',
+ 'add_look',
+ 'integrate_looks_into_views',
'create_config',
'generate_LUTs',
'generate_baked_LUTs',
if texture_paint:
config.setRole(ocio.Constants.ROLE_TEXTURE_PAINT, texture_paint)
- # 'rendering' and 'compositing_linear' roles default to the 'scene_linear'
- # value if not set explicitly
+ # *rendering* and *compositing_linear* roles default to the *scene_linear*
+ # value if not set explicitly.
if rendering:
- config.setRole("rendering", rendering)
+ config.setRole('rendering', rendering)
if compositing_linear:
- config.setRole("compositing_linear", compositing_linear)
+ config.setRole('compositing_linear', compositing_linear)
if scene_linear:
config.setRole(ocio.Constants.ROLE_SCENE_LINEAR, scene_linear)
if not rendering:
- config.setRole("rendering", scene_linear)
+ config.setRole('rendering', scene_linear)
if not compositing_linear:
- config.setRole("compositing_linear", scene_linear)
+ config.setRole('compositing_linear', scene_linear)
return True
Return value description.
"""
- interpolation_options = {
- '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}
for transform in transforms:
- # lutFile transform
+ # *lutFile* transform
if transform['type'] == 'lutFile':
- # Create transforms
ocio_transform = ocio.FileTransform()
if 'path' in transform:
ocio_transforms.append(ocio_transform)
- # matrix transform
+ # *matrix* transform
elif transform['type'] == 'matrix':
ocio_transform = ocio.MatrixTransform()
- # MatrixTransform member variables can't be initialized directly.
- # Each must be set individually.
+ # `MatrixTransform` member variables can't be initialized directly,
+ # each must be set individually.
ocio_transform.setMatrix(transform['matrix'])
if 'offset' in transform:
ocio_transforms.append(ocio_transform)
- # exponent transform
+ # *exponent* transform
elif transform['type'] == 'exponent':
ocio_transform = ocio.ExponentTransform()
ocio_transforms.append(ocio_transform)
- # log transform
+ # *log* transform
elif transform['type'] == 'log':
ocio_transform = ocio.LogTransform()
ocio_transforms.append(ocio_transform)
- # color space transform
+ # *colorspace* transform
elif transform['type'] == 'colorspace':
ocio_transform = ocio.ColorSpaceTransform()
ocio_transforms.append(ocio_transform)
- # look transform
+ # *look* transform
elif transform['type'] == 'look':
ocio_transform = ocio.LookTransform()
if 'look' in transform:
ocio_transforms.append(ocio_transform)
- # unknown type
+ # *unknown* type
else:
- print("Ignoring unknown transform type : %s" % transform['type'])
+ print('Ignoring unknown transform type : %s' % transform['type'])
if len(ocio_transforms) > 1:
group_transform = ocio.GroupTransform()
for alias_name in colorspace_alias_names:
if alias_name.lower() == colorspace.name.lower():
- print('Skipping alias creation for %s, alias %s, because lower cased names match' % (
- colorspace.name, alias_name) )
+ print('Skipping alias creation for %s, alias %s, '
+ 'because lower cased names match' % (
+ colorspace.name, alias_name))
continue
print('Adding alias colorspace space %s, alias to %s' % (
description = colorspace.description
if colorspace.aces_transform_id:
- description += "\n\nACES Transform ID : %s" % colorspace.aces_transform_id
+ description += (
+ '\n\nACES Transform ID : %s' % colorspace.aces_transform_id)
ocio_colorspace_alias = ocio.ColorSpace(
name=alias_name,
config.addColorSpace(ocio_colorspace_alias)
-def colorspace_prefixed_name(colorspace):
- prefix = colorspace.family.replace("/", " - ")
- return "%s - %s" % (prefix, colorspace.name)
def add_look(config,
look,
- prefix,
custom_lut_dir,
reference_name,
- config_data,
- multiple_displays=False):
+ config_data):
"""
Object description.
Return value description.
"""
- look_name = look[0]
- look_colorspace = look[1]
- look_lut = look[2]
- look_cccid = None
- if len(look) == 4:
- look_cccid = look[3]
+ look_name, look_colorspace, look_lut, look_cccid = unpack_default(look, 4)
- print('Adding look %s - %s' % (look_name, ", ".join(look)) )
+ print('Adding look %s - %s' % (look_name, ', '.join(look)))
- #
- # Copy look lut
- #
+ # Copy *look LUT* if `custom_lut_dir` is provided.
if custom_lut_dir:
- if not '$' in look_lut:
- print( "Getting ready to copy look lut : %s" % look_lut )
+ if '$' not in look_lut:
+ print('Getting ready to copy look lut : %s' % look_lut)
shutil.copy2(look_lut, custom_lut_dir)
look_lut = os.path.split(look_lut)[1]
else:
- print( "Skipping LUT copy because path contains a context variable" )
+ print('Skipping LUT copy because path contains a context variable')
- #
- # Create OCIO Look
- #
- # Look 1
- print('Adding look to config' )
- lk1 = ocio.Look()
- lk1.setName( look_name )
- lk1.setProcessSpace( look_colorspace )
+ print('Adding look to config')
+ ocio_look = ocio.Look()
+ ocio_look.setName(look_name)
+ ocio_look.setProcessSpace(look_colorspace)
keys = {'type': 'lutFile',
'path': look_lut,
keys['cccid'] = look_cccid
ocio_transform = generate_OCIO_transform([keys])
- lk1.setTransform( ocio_transform )
+ ocio_look.setTransform(ocio_transform)
- # add to config
- config.addLook( lk1 )
+ config.addLook(ocio_look)
- print( "Creating aliased colorspace")
+ print('Creating aliased colorspace')
- #
- # Create OCIO colorspace that references that look
- # - Needed for some implementations that don't process looks well
- # - Also needed for some implementations that don't expose looks well
- #
- look_aliases = ["look_%s" % compact(look_name)]
+ # Creating *OCIO* colorspace referencing the look:
+ # - Needed for implementations that don't process looks properly.
+ # - Needed for implementations that don't expose looks properly.
+ look_aliases = ['look_%s' % compact(look_name)]
colorspace = ColorSpace(look_name,
- aliases=look_aliases,
- description="The %s Look colorspace" % look_name,
- family='Look')
+ aliases=look_aliases,
+ description='The %s Look colorspace' % look_name,
+ family='Look')
colorspace.from_reference_transforms = [{'type': 'look',
- 'look': look_name,
- 'src': reference_name,
- 'dst': reference_name,
- 'direction': 'forward'}]
+ 'look': look_name,
+ 'src': reference_name,
+ 'dst': reference_name,
+ 'direction': 'forward'}]
print('Adding colorspace %s, alias to look %s to config data' % (
look_name, look_name))
- # Add this colorspace into the main list of colorspaces
config_data['colorSpaces'].append(colorspace)
- print("")
+ print()
+
-def integrate_looks_into_views(config,
- looks,
+def integrate_looks_into_views(looks,
reference_name,
config_data,
multiple_displays=False):
type
Return value description.
"""
- look_names = [look[0] for look in looks]
+ look_names = [look[0] for look in looks]
- # Option 1 - Add a 'look' to each Display
- # - Assumes there is a Display for each ACES Output Transform
+ # Option 1
+ # - Adding a *look* per *Display*.
+ # - Assuming there is a *Display* for each *ACES* *Output Transform*.
if multiple_displays:
for look_name in look_names:
config_data['looks'].append(look_name)
# Option 2
- # - Copy each Output Transform colorspace
- # - For each copy, add a LookTransform at the head of the from_reference
- # transform list
- # - Add these new copied colorspaces for the Displays / Views
+ # - Copy each *Output Transform* colorspace.
+ # - For each copy, add a *LookTransform* to the head of the
+ # `from_reference` transform list.
+ # - Add these the copy colorspaces for the *Displays* / *Views*.
else:
for display, view_list in config_data['displays'].iteritems():
- output_colorspace_copy = None
- look_names_string = ""
+ colorspace_c = None
+ look_names_string = ''
for view_name, output_colorspace in view_list.iteritems():
- if view_name == "Output Transform":
+ if view_name == 'Output Transform':
- print( "Adding new View that incorporates looks" )
+ print('Adding new View that incorporates looks')
- # Make a copy of the output colorspace
- output_colorspace_copy = copy.deepcopy(output_colorspace)
+ colorspace_c = copy.deepcopy(output_colorspace)
- #for look_name in look_names:
- for i in range(len(look_names)):
+ for i, look_name in enumerate(look_names):
look_name = look_names[i]
- # Add the LookTransform to the head of the from_reference transform list
- if output_colorspace_copy.from_reference_transforms:
- output_colorspace_copy.from_reference_transforms.insert(i, {'type': 'look',
- 'look': look_name,
- 'src': reference_name,
- 'dst': reference_name,
- 'direction': 'forward'})
-
- # Add the LookTransform to the end of the to_reference transform list
- if output_colorspace_copy.to_reference_transforms:
- inverse_look_name = look_names[len(look_names) -1 -i]
-
- output_colorspace_copy.to_reference_transforms.append({'type': 'look',
- 'look': inverse_look_name,
- 'src': reference_name,
- 'dst': reference_name,
- 'direction': 'inverse'})
-
- if not look_name in config_data['looks']:
+ # Add the `LookTransform` to the head of the
+ # `from_reference` transform list.
+ if colorspace_c.from_reference_transforms:
+ colorspace_c.from_reference_transforms.insert(
+ i,
+ {'type': 'look',
+ 'look': look_name,
+ 'src': reference_name,
+ 'dst': reference_name,
+ 'direction': 'forward'})
+
+ # Add the `LookTransform` to the end of
+ # the `to_reference` transform list.
+ if colorspace_c.to_reference_transforms:
+ inverse_look_name = look_names[
+ len(look_names) - 1 - i]
+
+ colorspace_c.to_reference_transforms.append(
+ {'type': 'look',
+ 'look': inverse_look_name,
+ 'src': reference_name,
+ 'dst': reference_name,
+ 'direction': 'inverse'})
+
+ if look_name not in config_data['looks']:
config_data['looks'].append(look_name)
- look_names_string = ", ".join(look_names)
- output_colorspace_copy.name = "%s with %s" % (output_colorspace.name, look_names_string)
- output_colorspace_copy.aliases = ["out_%s" % compact(output_colorspace_copy.name)]
+ look_names_string = ', '.join(look_names)
+ colorspace_c.name = '%s with %s' % (
+ output_colorspace.name, look_names_string)
+ colorspace_c.aliases = [
+ 'out_%s' % compact(colorspace_c.name)]
- print( "Colorspace that incorporates looks created : %s" % output_colorspace_copy.name )
+ print('Colorspace that incorporates looks '
+ 'created : %s' % colorspace_c.name)
- config_data['colorSpaces'].append(output_colorspace_copy)
+ config_data['colorSpaces'].append(colorspace_c)
- if output_colorspace_copy:
- print( "Adding colorspace that incorporates looks into view list" )
+ if colorspace_c:
+ print('Adding colorspace that incorporates looks '
+ 'into view list')
- # Change the name of the View
- view_list["Output Transform with %s" % look_names_string] = output_colorspace_copy
+ # Updating the *View* name.
+ view_list['Output Transform with %s' % look_names_string] = (
+ colorspace_c)
config_data['displays'][display] = view_list
- #print( "Display : %s, View List : %s" % (display, ", ".join(view_list)) )
-def create_config(config_data,
- aliases=False,
- prefix=False,
- multiple_displays=False,
- look_info=[],
- custom_lut_dir=None):
+def create_config(config_data,
+ aliases=False,
+ prefix=False,
+ multiple_displays=False,
+ look_info=None,
+ custom_lut_dir=None):
"""
Object description.
Return value description.
"""
+ if look_info is None:
+ look_info = []
+
prefixed_names = {}
alias_colorspaces = []
- # Creating the *OCIO* configuration.
config = ocio.Config()
- # Setting configuration description.
config.setDescription('An ACES config generated from python')
- # Setting configuration search path.
- searchPath = ['luts']
+ search_path = ['luts']
if custom_lut_dir:
- searchPath.append('custom')
- config.setSearchPath(':'.join(searchPath))
+ search_path.append('custom')
+ config.setSearchPath(':'.join(search_path))
- # Defining the reference colorspace.
reference_data = config_data['referenceColorSpace']
- # Adding the color space Family into the name
- # Helps with applications that present colorspaces as one long list
+ # Adding the colorspace *Family* into the name which helps with
+ # applications that presenting colorspaces as one a flat list.
if prefix:
prefixed_name = colorspace_prefixed_name(reference_data)
prefixed_names[reference_data.name] = prefixed_name
config.addColorSpace(reference)
- # Add alias
if aliases:
- if reference_data.aliases != []:
- #add_colorspace_alias(config, reference_data,
- # reference_data, reference_data.aliases)
- # defer adding alias colorspaces until end. Helps with some applications
- alias_colorspaces.append([reference_data, reference_data, reference_data.aliases])
+ if reference_data.aliases:
+ # TODO: Explain context for following comment.
+ # Deferring adding alias colorspaces until end, which helps with
+ # some applications.
+ alias_colorspaces.append(
+ [reference_data, reference_data, reference_data.aliases])
+ print()
- print("")
-
- #print( "color spaces : %s" % [x.name for x in sorted(config_data['colorSpaces'])])
-
- #
- # Add Looks and Look colorspaces
- #
- if look_info != []:
+ if look_info:
print('Adding looks')
config_data['looks'] = []
- # Add looks and colorspaces
for look in look_info:
- add_look(config,
- look,
- prefix,
- custom_lut_dir,
- reference_data.name,
- config_data)
+ add_look(config,
+ look,
+ custom_lut_dir,
+ reference_data.name,
+ config_data)
- # Integrate looks with displays, views
- integrate_looks_into_views(config,
- look_info,
- reference_data.name,
- config_data,
- multiple_displays)
+ integrate_looks_into_views(look_info,
+ reference_data.name,
+ config_data,
+ multiple_displays)
- print("")
+ print()
- print('Adding the regular color spaces')
+ print('Adding regular colorspaces')
- # Creating the remaining colorspaces.
for colorspace in sorted(config_data['colorSpaces']):
- # Adding the color space Family into the name
- # Helps with applications that present colorspaces as one long list
+ # Adding the colorspace *Family* into the name which helps with
+ # applications that presenting colorspaces as one a flat list.
if prefix:
prefixed_name = colorspace_prefixed_name(colorspace)
prefixed_names[colorspace.name] = prefixed_name
description = colorspace.description
if colorspace.aces_transform_id:
- description += "\n\nACES Transform ID : %s" % colorspace.aces_transform_id
+ description += (
+ '\n\nACES Transform ID : %s' % colorspace.aces_transform_id)
ocio_colorspace = ocio.ColorSpace(
name=colorspace.name,
config.addColorSpace(ocio_colorspace)
- #
- # Add alias to normal colorspace, using compact name
- #
if aliases:
- if colorspace.aliases != []:
- #add_colorspace_alias(config, reference_data,
- # colorspace, colorspace.aliases)
- # defer adding alias colorspaces until end. Helps with some applications
- alias_colorspaces.append([reference_data, colorspace, colorspace.aliases])
+ if colorspace.aliases:
+ # TODO: Explain context for following comment.
+ # Deferring adding alias colorspaces until end, which helps
+ # with some applications.
+ alias_colorspaces.append(
+ [reference_data, colorspace, colorspace.aliases])
- print('')
+ print()
- print("")
+ print()
- #
- # We add roles early so we can create alias colorspaces with the names of the roles
- # before the rest of the colorspace aliases are added to the config.
- #
+ # Adding roles early so that alias colorspaces can be created
+ # with roles names before remaining colorspace aliases are added
+ # to the configuration.
print('Setting the roles')
if prefix:
set_config_default_roles(
config,
- color_picking=prefixed_names[config_data['roles']['color_picking']],
+ color_picking=prefixed_names[
+ config_data['roles']['color_picking']],
color_timing=prefixed_names[config_data['roles']['color_timing']],
- compositing_log=prefixed_names[config_data['roles']['compositing_log']],
+ compositing_log=prefixed_names[
+ config_data['roles']['compositing_log']],
data=prefixed_names[config_data['roles']['data']],
default=prefixed_names[config_data['roles']['default']],
matte_paint=prefixed_names[config_data['roles']['matte_paint']],
reference=prefixed_names[config_data['roles']['reference']],
scene_linear=prefixed_names[config_data['roles']['scene_linear']],
- texture_paint=prefixed_names[config_data['roles']['texture_paint']])
-
- # Not allowed for the moment. role names can not overlap with colorspace names.
- '''
+ texture_paint=prefixed_names[
+ config_data['roles']['texture_paint']])
+
+ # TODO: Should we remove this dead code path?
+ # Not allowed at the moment as role names can not overlap
+ # with colorspace names.
+ """
# Add the aliased colorspaces for each role
for role_name, role_colorspace_name in config_data['roles'].iteritems():
role_colorspace_prefixed_name = prefixed_names[role_colorspace_name]
- print( "Finding colorspace : %s" % role_colorspace_prefixed_name )
+ print( 'Finding colorspace : %s' % role_colorspace_prefixed_name )
# Find the colorspace pointed to by the role
- role_colorspaces = [colorspace for colorspace in config_data['colorSpaces'] if colorspace.name == role_colorspace_prefixed_name]
+ role_colorspaces = [colorspace
+ for colorspace in config_data['colorSpaces']
+ if colorspace.name == role_colorspace_prefixed_name]
role_colorspace = None
if len(role_colorspaces) > 0:
role_colorspace = role_colorspaces[0]
role_colorspace = reference_data
if role_colorspace:
- print( "Adding an alias colorspace named %s, pointing to %s" % (
+ print( 'Adding an alias colorspace named %s, pointing to %s' % (
role_name, role_colorspace.name))
- add_colorspace_aliases(config, reference_data, role_colorspace, [role_name], 'Roles')
- '''
+ add_colorspace_aliases(
+ config, reference_data, role_colorspace, [role_name], 'Roles')
+ """
else:
set_config_default_roles(
scene_linear=config_data['roles']['scene_linear'],
texture_paint=config_data['roles']['texture_paint'])
- # Not allowed for the moment. role names can not overlap with colorspace names.
- '''
+ # TODO: Should we remove this dead code path?
+ # Not allowed at the moment as role names can not overlap
+ # with colorspace names.
+ """
# Add the aliased colorspaces for each role
for role_name, role_colorspace_name in config_data['roles'].iteritems():
# Find the colorspace pointed to by the role
- role_colorspaces = [colorspace for colorspace in config_data['colorSpaces'] if colorspace.name == role_colorspace_name]
+ role_colorspaces = [colorspace
+ for colorspace in config_data['colorSpaces']
+ if colorspace.name == role_colorspace_name]
role_colorspace = None
if len(role_colorspaces) > 0:
role_colorspace = role_colorspaces[0]
role_colorspace = reference_data
if role_colorspace:
- print( "Adding an alias colorspace named %s, pointing to %s" % (
+ print('Adding an alias colorspace named %s, pointing to %s' % (
role_name, role_colorspace.name))
- add_colorspace_aliases(config, reference_data, role_colorspace, [role_name], 'Roles')
- '''
+ add_colorspace_aliases(
+ config, reference_data, role_colorspace, [role_name], 'Roles')
+ """
- print("")
+ print()
- # We add these at the end as some applications use the order of the colorspaces
- # definitions in the config to order the colorspaces in their selection lists.
- # Other go alphabetically. This should keep the alias colorspaces out of the way
- # for the apps that use the order of definition in the config.
+ # Adding alias colorspaces at the end as some applications use
+ # colorspaces definitions order of the configuration to order
+ # the colorspaces in their selection lists, some applications
+ # use alphabetical ordering.
+ # This should keep the alias colorspaces out of the way for applications
+ # using the configuration order.
print('Adding the alias colorspaces')
for reference, colorspace, aliases in alias_colorspaces:
add_colorspace_aliases(config, reference, colorspace, aliases)
- print("")
+ print()
print('Adding the diplays and views')
- # Set the color_picking role to be the first Display's Output Transform View
+ # Setting the *color_picking* role to be the first *Display*'s
+ # *Output Transform* *View*.
default_display_name = config_data['defaultDisplay']
default_display_views = config_data['displays'][default_display_name]
default_display_colorspace = default_display_views['Output Transform']
config,
color_picking=default_display_colorspace.name)
- # Defining the *views* and *displays*.
- displays = []
- views = []
+ # Defining *Displays* and *Views*.
+ displays, views = [], []
- # Defining a *generic* *display* and *view* setup.
+ # Defining a generic *Display* and *View* setup.
if multiple_displays:
- # Built list of looks to add to Displays
looks = config_data['looks'] if ('looks' in config_data) else []
- looks = ", ".join(looks)
- print( "Creating multiple displays, with looks : %s" % looks)
+ looks = ', '.join(looks)
+ print('Creating multiple displays, with looks : %s' % looks)
- # Note: We don't reorder the Displays to put the 'defaultDisplay' first
- # because OCIO will order them alphabetically when the config is written to disk.
-
- # Create Displays, Views
+ # *Displays* are not reordered to put the *defaultDisplay* first
+ # because *OCIO* will order them alphabetically when the configuration
+ # is written to disk.
for display, view_list in config_data['displays'].iteritems():
for view_name, colorspace in view_list.iteritems():
config.addDisplay(display, view_name, colorspace.name, looks)
- if 'Output Transform' in view_name and looks != "":
- # Add normal View, without looks
+ if 'Output Transform' in view_name and looks != '':
+ # *Views* without *Looks*.
config.addDisplay(display, view_name, colorspace.name)
- # Add View with looks
- view_name_with_looks = "%s with %s" % (view_name, looks)
- config.addDisplay(display, view_name_with_looks, colorspace.name, looks)
+ # *Views* with *Looks*.
+ view_name_with_looks = '%s with %s' % (view_name, looks)
+ config.addDisplay(display, view_name_with_looks,
+ colorspace.name, looks)
else:
config.addDisplay(display, view_name, colorspace.name)
if not (view_name in views):
views.append(view_name)
displays.append(display)
- # Defining the set of *views* and *displays* useful in a *GUI* context.
+ # *Displays* and *Views* useful in a *GUI* context.
else:
single_display_name = 'ACES'
- #single_display_name = config_data['roles']['scene_linear']
displays.append(single_display_name)
- # Make sure the default display is first
+ # Ensuring the *defaultDisplay* is first.
display_names = sorted(config_data['displays'])
- display_names.insert(0, display_names.pop(display_names.index(default_display_name)))
+ display_names.insert(0, display_names.pop(
+ display_names.index(default_display_name)))
- # Built list of looks to add to Displays
looks = config_data['looks'] if ('looks' in config_data) else []
- look_names = ", ".join(looks)
+ look_names = ', '.join(looks)
displays_views_colorspaces = []
- # Create Displays, Views
for display in display_names:
view_list = config_data['displays'][display]
for view_name, colorspace in view_list.iteritems():
if 'Output Transform' in view_name:
- #print( "Adding view for %s" % colorspace.name )
- # We use the Display names as the View names in this case
- # as there is a single Display that contains all views.
- # This works for more applications than not, as of the time of this implementation.
+ # We use the *Display* names as the *View* names in this
+ # case as there is a single *Display* containing all the
+ # *Views*.
+ # This works for more applications than not,as of the time
+ # of this implementation.
- # Maya 2016 doesn't like parentheses in View names
- display_cleaned = replace(display, {')': '', '(': ''})
+ # Autodesk Maya 2016 doesn't support parentheses in
+ # *View* names.
+ sanitised_display = replace(display, {')': '', '(': ''})
- # If View includes looks
+ # *View* with *Looks*.
if 'with' in view_name:
- # Integrate looks into view name
- display_cleaned = "%s with %s" % (display_cleaned, look_names)
-
- viewsWithLooksAtEnd = False
- # Storing combo of display, view and colorspace name in a list so we can
- # add them to the end of the list
- if viewsWithLooksAtEnd:
- displays_views_colorspaces.append([single_display_name, display_cleaned, colorspace.name])
-
- # Or add as normal
+ sanitised_display = '%s with %s' % (
+ sanitised_display, look_names)
+
+ views_with_looks_at_end = False
+ # Storing combo of *Display*, *View* and *Colorspace*
+ # name so they can be added to the end of the list.
+ if views_with_looks_at_end:
+ displays_views_colorspaces.append(
+ [single_display_name, sanitised_display,
+ colorspace.name])
else:
- config.addDisplay(single_display_name, display_cleaned, colorspace.name)
+ config.addDisplay(single_display_name,
+ sanitised_display,
+ colorspace.name)
- # Add to views list
- if not (display_cleaned in views):
- views.append(display_cleaned)
+ if not (sanitised_display in views):
+ views.append(sanitised_display)
- # A normal View
+ # *View* without *Looks*.
else:
- config.addDisplay(single_display_name, display_cleaned, colorspace.name)
+ config.addDisplay(single_display_name,
+ sanitised_display,
+ colorspace.name)
- # Add to views list
- if not (display_cleaned in views):
- views.append(display_cleaned)
+ if not (sanitised_display in views):
+ views.append(sanitised_display)
- # Add to config any display, view combinations that were saved for later
- # This list will be empty unless viewsWithLooksAtEnd is set to True above
+ # Adding to the configuration any *Display*, *View* combinations that
+ # were saved for later.
+ # This list should be empty unless `views_with_looks_at_end` is
+ # set `True` above.
for display_view_colorspace in displays_views_colorspaces:
- single_display_name, display_cleaned, colorspace_name = display_view_colorspace
-
- # Add to config
- config.addDisplay(single_display_name, display_cleaned, colorspace_name)
-
- # Add to views list
- if not (display_cleaned in views):
- views.append(display_cleaned)
+ single_display_name, sanitised_display, colorspace_name = (
+ display_view_colorspace)
+ config.addDisplay(single_display_name,
+ sanitised_display,
+ colorspace_name)
- # Works with Nuke Studio and Mari, but not Nuke
- # single_display_name = 'Utility'
- # displays.append(single_display_name)
+ if not (sanitised_display in views):
+ views.append(sanitised_display)
- raw_display_space_name = config_data['roles']['data']
+ raw_display_space_name = config_data['roles']['data']
log_display_space_name = config_data['roles']['compositing_log']
- # Find the newly-prefixed colorspace names
if prefix:
- #print( prefixed_names )
raw_display_space_name = prefixed_names[raw_display_space_name]
log_display_space_name = prefixed_names[log_display_space_name]
config.addDisplay(single_display_name, 'Log', log_display_space_name)
views.append('Log')
- # Setting the active *displays* and *views*.
config.setActiveDisplays(','.join(sorted(displays)))
config.setActiveViews(','.join(views))
- print("")
+ print()
- # Make sure we didn't create a bad config
+ # Ensuring the configuration is valid.
config.sanityCheck()
- # Reset the colorspace names back to their non-prefixed versions
+ # Resetting colorspace names to their non-prefixed versions.
if prefix:
- # Build the reverse lookup
prefixed_names_inverse = {}
for original, prefixed in prefixed_names.iteritems():
prefixed_names_inverse[prefixed] = original
- # Reset the reference colorspace name
reference_data.name = prefixed_names_inverse[reference_data.name]
- # Reset the rest of the colorspace names
try:
for colorspace in config_data['colorSpaces']:
colorspace.name = prefixed_names_inverse[colorspace.name]
except:
- print( "Prefixed names")
+ print('Prefixed names')
for original, prefixed in prefixed_names.iteritems():
- print( "%s, %s" % (original, prefixed) )
+ print('%s, %s' % (original, prefixed))
- print( "\n")
+ print('\n')
- print( "Inverse Lookup of Prefixed names")
+ print('Inverse Lookup of Prefixed names')
for prefixed, original in prefixed_names_inverse.iteritems():
- print( "%s, %s" % (prefixed, original) )
+ print('%s, %s' % (prefixed, original))
raise
return config
print('generateLUTs - begin')
config_data = {}
- # Initialize a few variables
config_data['displays'] = {}
config_data['colorSpaces'] = []
# *Camera Input Transforms*
# -------------------------------------------------------------------------
- # *ARRI Log-C* to *ACES*.
- arri_colorSpaces = arri.create_colorspaces(lut_directory,
+ # *ARRI Log-C* to *ACES*
+ arri_colorspaces = arri.create_colorspaces(lut_directory,
lut_resolution_1d)
- for cs in arri_colorSpaces:
+ for cs in arri_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)
- # *GoPro Protune* to *ACES*.
+ # *GoPro Protune* to *ACES*
gopro_colorspaces = gopro.create_colorspaces(lut_directory,
lut_resolution_1d)
for cs in gopro_colorspaces:
config_data['colorSpaces'].append(cs)
- # *Panasonic V-Log* to *ACES*.
- panasonic_colorSpaces = panasonic.create_colorspaces(lut_directory,
+ # *Panasonic V-Log* to *ACES*
+ panasonic_colorspaces = panasonic.create_colorspaces(lut_directory,
lut_resolution_1d)
- for cs in panasonic_colorSpaces:
+ for cs in panasonic_colorspaces:
config_data['colorSpaces'].append(cs)
- # *RED* colorspaces 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)
- # *S-Log* to *ACES*.
- sony_colorSpaces = sony.create_colorspaces(lut_directory,
+ # *S-Log* to *ACES*
+ sony_colorspaces = sony.create_colorspaces(lut_directory,
lut_resolution_1d)
- for cs in sony_colorSpaces:
+ for cs in sony_colorspaces:
config_data['colorSpaces'].append(cs)
# -------------------------------------------------------------------------
- # General Color Spaces
+ # General Colorspaces
# -------------------------------------------------------------------------
- general_colorSpaces = general.create_colorspaces(lut_directory,
- lut_resolution_1d,
- lut_resolution_3d)
- for cs in general_colorSpaces:
+ general_colorspaces = general.create_colorspaces(lut_directory,
+ lut_resolution_1d)
+ for cs in general_colorspaces:
config_data['colorSpaces'].append(cs)
- # The *Raw* color space
+ # The *Raw* colorspace
raw = general.create_raw()
config_data['colorSpaces'].append(raw)
- # Override certain roles, for now
+ # Overriding various roles
config_data['roles']['data'] = raw.name
config_data['roles']['reference'] = raw.name
config_data['roles']['texture_paint'] = raw.name
print('generateLUTs - end')
+
return config_data
shaper_name,
baked_directory,
config_path,
- lut_resolution_1d,
lut_resolution_3d,
lut_resolution_shaper=1024,
prefix=False):
odt_info_C = dict(odt_info)
- # Uncomment if you would like to support the older behavior where ODTs
- # that have support for full and legal range output generate a LUT for each.
- '''
+ # Older behavior for *ODTs* that have support for full and legal ranges,
+ # generating a LUT for both ranges.
+ """
# Create two entries for ODTs that have full and legal range support
for odt_ctl_name, odt_values in odt_info.iteritems():
if odt_values['transformHasFullLegalSwitch']:
odt_info_C['%s - Full' % odt_ctl_name] = odt_values_full
del (odt_info_C[odt_ctl_name])
- '''
+ """
- # Generate appropriate LUTs for each ODT
for odt_ctl_name, odt_values in odt_info_C.iteritems():
odt_prefix = odt_values['transformUserNamePrefix']
odt_name = odt_values['transformUserName']
args = ['--iconfig', config_path,
'-v']
if prefix:
- args += ['--inputspace', "ACES - %s" % input_space]
- args += ['--outputspace', "Output - %s" % odt_name]
+ args += ['--inputspace', 'ACES - %s' % input_space]
+ args += ['--outputspace', 'Output - %s' % odt_name]
else:
args += ['--inputspace', input_space]
args += ['--outputspace', odt_name]
odt_name,
input_space)]
if prefix:
- args += ['--shaperspace', "Utility - %s" % shaper_name,
+ args += ['--shaperspace', 'Utility - %s' % shaper_name,
'--shapersize', str(lut_resolution_shaper)]
else:
args += ['--shaperspace', shaper_name,
args = ['--iconfig', config_path,
'-v']
if prefix:
- args += ['--inputspace', "ACES - %s" % input_space]
- args += ['--outputspace', "Output - %s" % odt_name]
+ args += ['--inputspace', 'ACES - %s' % input_space]
+ args += ['--outputspace', 'Output - %s' % odt_name]
else:
args += ['--inputspace', input_space]
args += ['--outputspace', odt_name]
'%s - %s for %s data' % (
odt_prefix, odt_name, input_space)]
if prefix:
- args += ['--shaperspace', "Utility - %s" % shaper_name,
+ args += ['--shaperspace', 'Utility - %s' % shaper_name,
'--shapersize', str(lut_resolution_shaper)]
else:
args += ['--shaperspace', shaper_name,
args = ['--iconfig', config_path,
'-v']
if prefix:
- args += ['--inputspace', "ACES - %s" % input_space]
- args += ['--outputspace', "Output - %s" % odt_name]
+ args += ['--inputspace', 'ACES - %s' % input_space]
+ args += ['--outputspace', 'Output - %s' % odt_name]
else:
args += ['--inputspace', input_space]
args += ['--outputspace', odt_name]
'%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
if prefix:
- lin_shaper_name = "Utility - %s" % lin_shaper_name
+ lin_shaper_name = 'Utility - %s' % lin_shaper_name
args += ['--shaperspace', lin_shaper_name,
'--shapersize', str(lut_resolution_shaper)]
bake_lut.execute()
-def create_config_dir(config_directory,
- bake_secondary_LUTs=False,
+def create_config_dir(config_directory,
+ bake_secondary_luts=False,
custom_lut_dir=None):
"""
Object description.
lut_directory = os.path.join(config_directory, 'luts')
dirs = [config_directory, lut_directory]
- if bake_secondary_LUTs:
+ if bake_secondary_luts:
dirs.extend([os.path.join(config_directory, 'baked'),
os.path.join(config_directory, 'baked', 'flame'),
os.path.join(config_directory, 'baked', 'photoshop'),
config_directory,
lut_resolution_1d=4096,
lut_resolution_3d=64,
- bake_secondary_LUTs=True,
+ bake_secondary_luts=True,
multiple_displays=False,
- look_info=[],
+ look_info=None,
copy_custom_luts=True,
cleanup=True,
prefix_colorspaces_with_family_names=True):
Return value description.
"""
- # Directory for custom LUTs
+ if look_info is None:
+ look_info = []
+
custom_lut_dir = None
if copy_custom_luts:
- custom_lut_dir = os.path.join(config_directory, "custom")
+ custom_lut_dir = os.path.join(config_directory, 'custom')
- lut_directory = create_config_dir(config_directory,
- bake_secondary_LUTs,
+ lut_directory = create_config_dir(config_directory,
+ bake_secondary_luts,
custom_lut_dir)
odt_info = aces.get_ODTs_info(aces_ctl_directory)
cleanup)
print('Creating config - with prefixes, with aliases')
- config = create_config(config_data,
- prefix=prefix_colorspaces_with_family_names,
- aliases=True,
- multiple_displays=multiple_displays,
- look_info=look_info,
- custom_lut_dir=custom_lut_dir)
+ config = create_config(config_data,
+ prefix=prefix_colorspaces_with_family_names,
+ aliases=True,
+ multiple_displays=multiple_displays,
+ look_info=look_info,
+ custom_lut_dir=custom_lut_dir)
print('\n\n\n')
write_config(config,
os.path.join(config_directory, 'config.ocio'))
- if bake_secondary_LUTs:
+ if bake_secondary_luts:
generate_baked_LUTs(odt_info,
shaper_name,
os.path.join(config_directory, 'baked'),
os.path.join(config_directory, 'config.ocio'),
- lut_resolution_1d,
lut_resolution_3d,
lut_resolution_1d,
prefix=prefix_colorspaces_with_family_names)
import optparse
- usage = '%prog [options]\n'
+ usage = '%prog [options]\n'
usage += '\n'
usage += 'An OCIO config generation script for ACES 1.0\n'
usage += '\n'
usage += 'Command line examples'
usage += '\n'
- usage += 'Create a GUI-friendly ACES 1.0 config with no secondary, baked LUTs : \n'
- usage += '\tcreate_aces_config -a /path/to/aces-dev/transforms/ctl --lutResolution1d 1024 --lutResolution3d 33 -c aces_1.0.0 --dontBakeSecondaryLUTs'
+ usage += ('Create a GUI-friendly ACES 1.0 config with no secondary, '
+ 'baked LUTs : \n')
+ usage += ('\tcreate_aces_config -a /path/to/aces-dev/transforms/ctl '
+ '--lutResolution1d 1024 --lutResolution3d 33 -c aces_1.0.0 '
+ '--dontBakeSecondaryLUTs')
usage += '\n'
usage += 'Create a more OCIO-compliant ACES 1.0 config : \n'
- usage += '\tcreate_aces_config -a /path/to/aces-dev/transforms/ctl --lutResolution1d 1024 --lutResolution3d 33 -c aces_1.0.0 --createMultipleDisplays'
+ usage += ('\tcreate_aces_config -a /path/to/aces-dev/transforms/ctl '
+ '--lutResolution1d 1024 --lutResolution3d 33 -c aces_1.0.0 '
+ '--createMultipleDisplays')
usage += '\n'
usage += '\n'
usage += 'Adding custom looks'
usage += '\n'
- usage += 'Create a GUI-friendly ACES 1.0 config with an ACES-style CDL (will be applied in the ACEScc colorspace): \n'
- usage += '\tcreate_aces_config -a /path/to/aces-dev/transforms/ctl --lutResolution1d 1024 --lutResolution3d 33 -c aces_1.0.0 \n\t\t--addACESLookCDL ACESCDLName /path/to/SampleCDL.ccc cc03345'
+ usage += ('Create a GUI-friendly ACES 1.0 config with an ACES-style CDL '
+ '(will be applied in the ACEScc colorspace): \n')
+ usage += ('\tcreate_aces_config -a /path/to/aces-dev/transforms/ctl '
+ '--lutResolution1d 1024 --lutResolution3d 33 -c aces_1.0.0 '
+ '\n\t\t--addACESLookCDL ACESCDLName '
+ '/path/to/SampleCDL.ccc cc03345')
usage += '\n'
usage += 'Create a GUI-friendly ACES 1.0 config with an general CDL: \n'
- usage += '\tcreate_aces_config -a /path/to/aces-dev/transforms/ctl --lutResolution1d 1024 --lutResolution3d 33 -c aces_1.0.0 \n\t\t--addCustomLookCDL CustomCDLName "ACES - ACEScc" /path/to/SampleCDL.ccc cc03345'
+ usage += ('\tcreate_aces_config -a /path/to/aces-dev/transforms/ctl '
+ '--lutResolution1d 1024 --lutResolution3d 33 -c aces_1.0.0 '
+ '\n\t\t--addCustomLookCDL CustomCDLName "ACES - ACEScc" '
+ '/path/to/SampleCDL.ccc cc03345')
usage += '\n'
- usage += '\tIn this example, the CDL will be applied in the ACEScc colorspace, but the user could choose other spaces by changing the argument after the name of the look. \n'
+ usage += ('\tIn this example, the CDL will be applied in the '
+ 'ACEScc colorspace, but the user could choose other spaces '
+ 'by changing the argument after the name of the look. \n')
usage += '\n'
- usage += 'Create a GUI-friendly ACES 1.0 config with an ACES-style LUT (will be applied in the ACEScc colorspace): \n'
- usage += '\tcreate_aces_config -a /path/to/aces-dev/transforms/ctl --lutResolution1d 1024 --lutResolution3d 33 -c aces_1.0.0 \n\t\t--addACESLookLUT ACESLUTName /path/to/SampleCDL.ccc cc03345'
+ usage += ('Create a GUI-friendly ACES 1.0 config with an ACES-style LUT '
+ '(will be applied in the ACEScc colorspace): \n')
+ usage += ('\tcreate_aces_config -a /path/to/aces-dev/transforms/ctl '
+ '--lutResolution1d 1024 --lutResolution3d 33 -c aces_1.0.0 '
+ '\n\t\t--addACESLookLUT ACESLUTName '
+ '/path/to/SampleCDL.ccc cc03345')
usage += '\n'
usage += 'Create a GUI-friendly ACES 1.0 config with an general LUT: \n'
- usage += '\tcreate_aces_config -a /path/to/aces-dev/transforms/ctl --lutResolution1d 1024 --lutResolution3d 33 -c aces_1.0.0 \n\t\t--addCustomLookLUT CustomLUTName "ACES - ACEScc" /path/to/SampleCDL.ccc cc03345'
+ usage += ('\tcreate_aces_config -a /path/to/aces-dev/transforms/ctl '
+ '--lutResolution1d 1024 --lutResolution3d 33 -c aces_1.0.0 '
+ '\n\t\t--addCustomLookLUT CustomLUTName "ACES - ACEScc" '
+ '/path/to/SampleCDL.ccc cc03345')
usage += '\n'
- usage += '\tIn this example, the LUT will be applied in the ACEScc colorspace, but the user could choose other spaces by changing the argument after the name of the look. \n'
+ usage += ('\tIn this example, the LUT will be applied in the '
+ 'ACEScc colorspace, but the user could choose other spaces '
+ 'by changing the argument after the name of the look. \n')
usage += '\n'
look_info = []
+
def look_info_callback(option, opt_str, value, parser):
- print( "look_info_callback" )
- print( option, opt_str, value, parser )
- if opt_str == "--addCustomLookCDL":
+ print('look_info_callback')
+ print(option, opt_str, value, parser)
+ if opt_str == '--addCustomLookCDL':
look_info.append(value)
- elif opt_str == "--addCustomLookLUT":
+ elif opt_str == '--addCustomLookLUT':
look_info.append(value)
- elif opt_str == "--addACESLookCDL":
- look_info.append([value[0], "ACES - ACEScc", value[1], value[2]])
- elif opt_str == "--addACESLookLUT":
- look_info.append([value[0], "ACES - ACEScc", value[1]])
+ elif opt_str == '--addACESLookCDL':
+ look_info.append([value[0], 'ACES - ACEScc', value[1], value[2]])
+ elif opt_str == '--addACESLookLUT':
+ look_info.append([value[0], 'ACES - ACEScc', value[1]])
p = optparse.OptionParser(description='',
prog='create_aces_config',
p.add_option('--dontBakeSecondaryLUTs', action='store_true', default=False)
p.add_option('--keepTempImages', action='store_true', default=False)
- p.add_option('--createMultipleDisplays', action='store_true', default=False)
-
- p.add_option('--addCustomLookLUT', '', type='string', nargs=3,
- action="callback", callback=look_info_callback)
- p.add_option('--addCustomLookCDL', '', type='string', nargs=4,
- action="callback", callback=look_info_callback)
- p.add_option('--addACESLookLUT', '', type='string', nargs=2,
- action="callback", callback=look_info_callback)
- p.add_option('--addACESLookCDL', '', type='string', nargs=3,
- action="callback", callback=look_info_callback)
+ p.add_option('--createMultipleDisplays', action='store_true',
+ default=False)
+
+ p.add_option('--addCustomLookLUT', '', type='string', nargs=3,
+ action='callback', callback=look_info_callback)
+ p.add_option('--addCustomLookCDL', '', type='string', nargs=4,
+ action='callback', callback=look_info_callback)
+ p.add_option('--addACESLookLUT', '', type='string', nargs=2,
+ action='callback', callback=look_info_callback)
+ p.add_option('--addACESLookCDL', '', type='string', nargs=3,
+ action='callback', callback=look_info_callback)
p.add_option('--copyCustomLUTs', action='store_true', default=False)
options, arguments = p.parse_args()
multiple_displays = options.createMultipleDisplays
copy_custom_luts = options.copyCustomLUTs
- print( look_info )
-
- # TODO: Investigate the following statements.
- try:
- args_start = sys.argv.index('--') + 1
- args = sys.argv[args_start:]
- except:
- args_start = len(sys.argv) + 1
- args = []
+ print(look_info)
print('command line : \n%s\n' % ' '.join(sys.argv))
copy_custom_luts,
cleanup_temp_images)
+
if __name__ == '__main__':
main()
projects / OpenColorIO-Configs.git / blobdiff