def get_camera_colorspaces(family=""):
colorspaces = []
# get Camera Log colorspaces from Builtins
for name, description in ocio.BuiltinTransformRegistry().getBuiltins():
if name.endswith("to_ACES2065-1"):
colorspaces.append(
ocio.ColorSpace(
name=description.split("Convert ")[-1].split(" to ")[0],
family=family,
encoding="log",
toReference=ocio.BuiltinTransform(name),
))
return colorspaces
def test_multi_reference(self):
# Registry is a singleton. Make sure multiple Python
# instances can be held.
instances = []
for i in range(10):
instances.append(OCIO.BuiltinTransformRegistry())
# Other instances should still function after deleting one. The
# underlying C++ object is not deleted.
instance_0 = instances.pop(0)
self.assertEqual(len(instances), 9)
del instance_0
# Variable is no longer defined
with self.assertRaises(NameError):
len(instance_0)
# Test underlying C++ reference validity by accessing registry
# data for each instance.
for instance in instances:
self.assertGreaterEqual(len(instance), 1)
self.assertEqual(len(instance), len(self.REGISTRY))
def generate_config_aces(
config_name=None,
validate=True,
describe=ColorspaceDescriptionStyle.SHORT_UNION,
config_mapping_file_path=ACES_CONFIG_REFERENCE_MAPPING_FILE_PATH,
analytical=True,
additional_data=False):
"""
Generates the *aces-dev* reference implementation *OpenColorIO* Config
using the *Mapping* method.
The Config generation is constrained by a *CSV* file exported from the
*Reference Config - Mapping* sheet from a
`Google Sheets file <https://docs.google.com/spreadsheets/d/\
1SXPt-USy3HlV2G2qAvh9zit6ZCINDOlfKT07yXJdWLg>`__. The *Google Sheets* file
was originally authored using the output of the *aces-dev* conversion graph
to support the discussions of the *OpenColorIO* *Working Group* on the
design of the *aces-dev* reference implementation *OpenColorIO* Config.
The resulting mapping is the outcome of those discussions and leverages the
new *OpenColorIO 2* display architecture while factoring many transforms.
Parameters
----------
config_name : unicode, optional
*OpenColorIO* config file name, if given the config will be written to
disk.
validate : bool, optional
Whether to validate the config.
describe : int, optional
Any value from the
:class:`opencolorio_config_aces.ColorspaceDescriptionStyle` enum.
config_mapping_file_path : unicode, optional
Path to the *CSV* mapping file used by the *Mapping* method.
analytical : bool, optional
Whether to generate *OpenColorIO* transform families that analytically
match the given *ACES* *CTL* transform, i.e. true to the *aces-dev*
reference but not necessarily user friendly.
additional_data : bool, optional
Whether to return additional data.
Returns
-------
Config or tuple
*OpenColorIO* config or tuple of *OpenColorIO* config,
:class:`opencolorio_config_aces.ConfigData` class instance and dict of
*OpenColorIO* colorspaces and
:class:`opencolorio_config_aces.config.reference.CTLTransform` class
instances.
"""
import PyOpenColorIO as ocio
ctl_transforms = unclassify_ctl_transforms(
classify_aces_ctl_transforms(discover_aces_ctl_transforms()))
builtin_transforms = [
builtin for builtin in ocio.BuiltinTransformRegistry()
]
config_mapping = defaultdict(list)
with open(config_mapping_file_path) as csv_file:
dict_reader = csv.DictReader(csv_file,
delimiter=',',
fieldnames=[
'ordering',
'aces_transform_id',
'builtin_transform_style',
'linked_display_colorspace_style',
'interface',
'encoding',
'categories',
])
# Skipping the first header line.
next(dict_reader)
for transform_data in dict_reader:
# Checking whether the "BuiltinTransform" style exists.
style = transform_data['builtin_transform_style']
if style:
assert (style in builtin_transforms), (
f'"{style}" "BuiltinTransform" style does not '
f'exist!')
# Checking whether the linked "DisplayColorspace"
# "BuiltinTransform" style exists.
style = transform_data['linked_display_colorspace_style']
if style:
assert (style in builtin_transforms), (
f'"{style}" "BuiltinTransform" style does not '
f'exist!')
# Finding the "CTLTransform" class instance that matches given
# "ACEStransformID", if it does not exist, there is a critical
# mismatch in the mapping with *aces-dev*.
aces_transform_id = transform_data['aces_transform_id']
filtered_ctl_transforms = [
ctl_transform for ctl_transform in ctl_transforms
if ctl_transform.aces_transform_id.aces_transform_id ==
aces_transform_id
]
ctl_transform = next(iter(filtered_ctl_transforms), None)
assert ctl_transform is not None, (
f'"aces-dev" has no transform with "{aces_transform_id}" '
f'ACEStransformID, please cross-check the '
f'"{config_mapping_file_path}" config mapping file and '
f'the "aces-dev" "CTL" transforms!')
transform_data['ctl_transform'] = ctl_transform
config_mapping[transform_data['builtin_transform_style']].append(
transform_data)
colorspaces = []
looks = []
displays, display_names = [], []
view_transforms, view_transform_names = [], []
shared_views = []
aces_family_prefix = 'CSC' if analytical else 'ACES'
scene_reference_colorspace = colorspace_factory(
f'{aces_family_prefix} - {ACES_CONFIG_REFERENCE_COLORSPACE}',
'ACES',
description=(
'The "Academy Color Encoding System" reference colorspace.'),
encoding='scene-linear')
display_reference_colorspace = colorspace_factory(
'CIE-XYZ-D65',
description='The "CIE XYZ (D65)" display connection colorspace.',
reference_space=ocio.REFERENCE_SPACE_DISPLAY)
raw_colorspace = colorspace_factory(
'Utility - Raw',
'Utility',
description='The utility "Raw" colorspace.',
is_data=True)
colorspaces += [
scene_reference_colorspace,
display_reference_colorspace,
raw_colorspace,
]
for style, transforms_data in config_mapping.items():
if transforms_data[0]['interface'] == 'ViewTransform':
view_transform = style_to_view_transform(style, [
transform_data['ctl_transform']
for transform_data in transforms_data
], describe)
view_transforms.append(view_transform)
view_transform_name = view_transform.getName()
view_transform_names.append(view_transform_name)
for transform_data in transforms_data:
display_style = transform_data[
'linked_display_colorspace_style']
display = style_to_display_colorspace(
display_style,
encoding=transform_data.get('encoding'),
categories=transform_data.get('categories'))
display_name = display.getName()
if display_name not in display_names:
displays.append(display)
display_names.append(display_name)
shared_views.append({
'display': display_name,
'view': view_transform_name,
'view_transform': view_transform_name,
})
else:
for transform_data in transforms_data:
ctl_transform = transform_data['ctl_transform']
if transform_data['interface'] == 'Look':
look = ctl_transform_to_look(
ctl_transform,
describe,
analytical=analytical,
forward_transform=create_builtin_transform(style),
process_space=scene_reference_colorspace.getName(),
)
looks.append(look)
else:
colorspace = ctl_transform_to_colorspace(
ctl_transform,
describe,
analytical=analytical,
to_reference=create_builtin_transform(style),
encoding=transform_data.get('encoding'),
categories=transform_data.get('categories'))
colorspaces.append(colorspace)
untonemapped_view_transform = view_transform_factory(
'Un-tone-mapped',
from_reference=ocio.BuiltinTransform(
'UTILITY - ACES-AP0_to_CIE-XYZ-D65_BFD'),
)
untonemapped_view_transform_name = untonemapped_view_transform.getName()
for display in display_names:
shared_views.append({
'display': display,
'view': untonemapped_view_transform_name,
'view_transform': untonemapped_view_transform_name,
})
data = ConfigData(
description=(
f'The "Academy Color Encoding System" (ACES) "Reference Config".'
f'\n\n'
f'This "OpenColorIO" config is a strict and quasi-analytical '
f'implementation of "aces-dev" and is designed as a reference for '
f'software developers. It is not a replacement for the previous '
f'"ACES" configs nor the "ACES Studio Config".'
f'\n\n'
f'Generated with "OpenColorIO-Config-ACES" {git_describe()} '
f'on the {datetime.now().strftime("%Y/%m/%d at %H:%M")}.'),
roles={
ocio.ROLE_COLOR_TIMING: f'{aces_family_prefix} - ACEScct',
ocio.ROLE_COMPOSITING_LOG: f'{aces_family_prefix} - ACEScct',
ocio.ROLE_DATA: 'Utility - Raw',
ocio.ROLE_DEFAULT: scene_reference_colorspace.getName(),
ocio.ROLE_INTERCHANGE_DISPLAY:
display_reference_colorspace.getName(),
ocio.ROLE_INTERCHANGE_SCENE: scene_reference_colorspace.getName(),
ocio.ROLE_REFERENCE: scene_reference_colorspace.getName(),
ocio.ROLE_RENDERING: f'{aces_family_prefix} - ACEScg',
ocio.ROLE_SCENE_LINEAR: f'{aces_family_prefix} - ACEScg',
},
colorspaces=colorspaces + displays,
looks=looks,
view_transforms=view_transforms + [untonemapped_view_transform],
shared_views=shared_views,
views=shared_views + [{
'display': display,
'view': 'Raw',
'colorspace': 'Utility - Raw'
} for display in display_names],
active_displays=display_names,
active_views=view_transform_names + ['Raw'],
file_rules=[{
'name': 'Default',
'colorspace': scene_reference_colorspace.getName()
}],
inactive_colorspaces=['CIE-XYZ-D65'],
default_view_transform=untonemapped_view_transform.getName(),
profile_version=2)
config = generate_config(data, config_name, validate)
if additional_data:
return config, data
else:
return config
def setUpClass(cls):
cls.REGISTRY = OCIO.BuiltinTransformRegistry()
