Config¶

class PyOpenColorIO.Config¶

class ActiveDisplaysListIterator¶

ActiveDisplaysListIterator(*args, **kwargs)¶

class ActiveViewsListIterator¶

ActiveViewsListIterator(*args, **kwargs)¶

static AreViewsEqual(first: PyOpenColorIO.PyOpenColorIO.Config, second: PyOpenColorIO.PyOpenColorIO.Config, dispName: str, viewName: str) → bool¶

static AreVirtualViewsEqual(first: PyOpenColorIO.PyOpenColorIO.Config, second: PyOpenColorIO.PyOpenColorIO.Config, viewName: str) → bool¶

static CreateFromBuiltinConfig(arg0: str) → PyOpenColorIO.PyOpenColorIO.Config¶

static CreateFromConfigIOProxy(arg0: OpenColorIO_v2_5::ConfigIOProxy) → PyOpenColorIO.PyOpenColorIO.Config¶

static CreateFromEnv() → PyOpenColorIO.PyOpenColorIO.Config¶

static CreateFromFile(fileName: str) → PyOpenColorIO.PyOpenColorIO.Config¶

static CreateFromStream(str: str) → PyOpenColorIO.PyOpenColorIO.Config¶

static CreateRaw() → PyOpenColorIO.PyOpenColorIO.Config¶

class DisplayAllIterator¶

DisplayAllIterator(*args, **kwargs)¶

static GetProcessorFromBuiltinColorSpace(builtinColorSpaceName: str, srcConfig: PyOpenColorIO.PyOpenColorIO.Config, srcColorSpaceName: str) → PyOpenColorIO.PyOpenColorIO.Processor¶

static GetProcessorFromConfigs(*args, **kwargs)¶

Overloaded function.

GetProcessorFromConfigs(srcConfig: PyOpenColorIO.PyOpenColorIO.Config, srcColorSpaceName: str, dstConfig: PyOpenColorIO.PyOpenColorIO.Config, dstColorSpaceName: str) -> PyOpenColorIO.PyOpenColorIO.Processor
GetProcessorFromConfigs(srcContext: PyOpenColorIO.PyOpenColorIO.Context, srcConfig: PyOpenColorIO.PyOpenColorIO.Config, srcColorSpaceName: str, dstContext: PyOpenColorIO.PyOpenColorIO.Context, dstConfig: PyOpenColorIO.PyOpenColorIO.Config, dstColorSpaceName: str) -> PyOpenColorIO.PyOpenColorIO.Processor
GetProcessorFromConfigs(srcConfig: PyOpenColorIO.PyOpenColorIO.Config, srcColorSpaceName: str, srcInterchangeName: str, dstConfig: PyOpenColorIO.PyOpenColorIO.Config, dstColorSpaceName: str, dstInterchangeName: str) -> PyOpenColorIO.PyOpenColorIO.Processor
GetProcessorFromConfigs(srcContext: PyOpenColorIO.PyOpenColorIO.Context, srcConfig: PyOpenColorIO.PyOpenColorIO.Config, srcColorSpaceName: str, srcInterchangeName: str, dstContext: PyOpenColorIO.PyOpenColorIO.Context, dstConfig: PyOpenColorIO.PyOpenColorIO.Config, dstColorSpaceName: str, dstInterchangeName: str) -> PyOpenColorIO.PyOpenColorIO.Processor
GetProcessorFromConfigs(srcConfig: PyOpenColorIO.PyOpenColorIO.Config, srcColorSpaceName: str, dstConfig: PyOpenColorIO.PyOpenColorIO.Config, dstDisplay: str, dstView: str, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) -> PyOpenColorIO.PyOpenColorIO.Processor
GetProcessorFromConfigs(srcContext: PyOpenColorIO.PyOpenColorIO.Context, srcConfig: PyOpenColorIO.PyOpenColorIO.Config, srcColorSpaceName: str, dstContext: PyOpenColorIO.PyOpenColorIO.Context, dstConfig: PyOpenColorIO.PyOpenColorIO.Config, dstView: str, dstDisplay: str, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) -> PyOpenColorIO.PyOpenColorIO.Processor
GetProcessorFromConfigs(srcConfig: PyOpenColorIO.PyOpenColorIO.Config, srcColorSpaceName: str, srcInterchangeName: str, dstConfig: PyOpenColorIO.PyOpenColorIO.Config, dstDisplay: str, dstView: str, dstInterchangeName: str, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) -> PyOpenColorIO.PyOpenColorIO.Processor
GetProcessorFromConfigs(srcContext: PyOpenColorIO.PyOpenColorIO.Context, srcConfig: PyOpenColorIO.PyOpenColorIO.Config, srcColorSpaceName: str, srcInterchangeName: str, dstContext: PyOpenColorIO.PyOpenColorIO.Context, dstConfig: PyOpenColorIO.PyOpenColorIO.Config, dstDisplay: str, dstView: str, dstInterchangeName: str, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) -> PyOpenColorIO.PyOpenColorIO.Processor

static GetProcessorToBuiltinColorSpace(srcConfig: PyOpenColorIO.PyOpenColorIO.Config, srcColorSpaceName: str, builtinColorSpaceName: str) → PyOpenColorIO.PyOpenColorIO.Processor¶

static IdentifyBuiltinColorSpace(srcConfig: PyOpenColorIO.PyOpenColorIO.Config, builtinConfig: PyOpenColorIO.PyOpenColorIO.Config, builtinColorSpaceName: str) → str¶

static IdentifyInterchangeSpace(srcConfig: PyOpenColorIO.PyOpenColorIO.Config, srcColorSpaceName: str, builtinConfig: PyOpenColorIO.PyOpenColorIO.Config, builtinColorSpaceName: str) → tuple[str, str]¶

class ViewForViewTypeIterator¶

ViewForViewTypeIterator(*args, **kwargs)¶

class VirtualViewIterator¶

VirtualViewIterator(*args, **kwargs)¶

VirtualViewIterator() → None¶

str(self) → str¶

addActiveDisplay(display: str) → None¶

addActiveView(view: str) → None¶

addColorSpace(colorSpace: PyOpenColorIO.PyOpenColorIO.ColorSpace) → None¶

addDisplaySharedView(display: str, view: str) → None¶

addDisplayView(*args, **kwargs)¶

Overloaded function.

addDisplayView(self: PyOpenColorIO.PyOpenColorIO.Config, display: str, view: str, colorSpaceName: str, looks: str = ‘’) -> None
addDisplayView(self: PyOpenColorIO.PyOpenColorIO.Config, display: str, view: str, viewTransform: str, displayColorSpaceName: str, looks: str = ‘’, ruleName: str = ‘’, description: str = ‘’) -> None

addEnvironmentVar(name: str, defaultValue: str) → None¶

addLook(look: PyOpenColorIO.PyOpenColorIO.Look) → None¶

addNamedTransform(namedTransform: PyOpenColorIO.PyOpenColorIO.NamedTransform) → None¶

addSearchPath(path: str) → None¶

addSharedView(view: str, viewTransformName: str, colorSpaceName: str, looks: str = '', ruleName: str = '', description: str = '') → None¶

addViewTransform(viewTransform: PyOpenColorIO.PyOpenColorIO.ViewTransform) → None¶

addVirtualDisplaySharedView(sharedView: str) → None¶

addVirtualDisplayView(view: str, viewTransformName: str, colorSpaceName: str, looks: str = '', ruleName: str = '', description: str = '') → None¶

archive(arg0: str) → None¶

clearActiveDisplays() → None¶

clearActiveViews() → None¶

clearColorSpaces() → None¶

clearDisplays() → None¶

clearEnvironmentVars() → None¶

clearLooks() → None¶

clearNamedTransforms() → None¶

clearProcessorCache() → None¶

clearSearchPaths() → None¶

clearSharedViews() → None¶

clearViewTransforms() → None¶

clearVirtualDisplay() → None¶

filepathOnlyMatchesDefaultRule(filePath: str) → bool¶

getActiveDisplays() → PyOpenColorIO.PyOpenColorIO.Config.ActiveDisplaysListIterator¶

getActiveViews() → PyOpenColorIO.PyOpenColorIO.Config.ActiveViewsListIterator¶

getCacheID(*args, **kwargs)¶

Overloaded function.

getCacheID(self: PyOpenColorIO.PyOpenColorIO.Config) -> str
getCacheID(self: PyOpenColorIO.PyOpenColorIO.Config, context: PyOpenColorIO.PyOpenColorIO.Context) -> str

getCanonicalName(name: str) → str¶

getColorSpace(name: str) → PyOpenColorIO.PyOpenColorIO.ColorSpace¶

getColorSpaceFromFilepath(filePath: str) → tuple¶

getColorSpaceNames(*args, **kwargs)¶

Overloaded function.

getColorSpaceNames(self: PyOpenColorIO.PyOpenColorIO.Config, searchReferenceType: PyOpenColorIO.PyOpenColorIO.SearchReferenceSpaceType, visibility: PyOpenColorIO.PyOpenColorIO.ColorSpaceVisibility) -> PyOpenColorIO.PyOpenColorIO.Config.ColorSpaceNameIterator
getColorSpaceNames(self: PyOpenColorIO.PyOpenColorIO.Config) -> PyOpenColorIO.PyOpenColorIO.Config.ActiveColorSpaceNameIterator

getColorSpaces(*args, **kwargs)¶

Overloaded function.

getColorSpaces(self: PyOpenColorIO.PyOpenColorIO.Config, category: str) -> PyOpenColorIO.PyOpenColorIO.ColorSpaceSet
getColorSpaces(self: PyOpenColorIO.PyOpenColorIO.Config, searchReferenceType: PyOpenColorIO.PyOpenColorIO.SearchReferenceSpaceType, visibility: PyOpenColorIO.PyOpenColorIO.ColorSpaceVisibility) -> PyOpenColorIO.PyOpenColorIO.Config.ColorSpaceIterator
getColorSpaces(self: PyOpenColorIO.PyOpenColorIO.Config) -> PyOpenColorIO.PyOpenColorIO.Config.ActiveColorSpaceIterator

getConfigIOProxy() → OpenColorIO_v2_5::ConfigIOProxy¶

getCurrentContext() → PyOpenColorIO.PyOpenColorIO.Context¶

getDefaultDisplay() → str¶

getDefaultLumaCoefs() → Annotated[list[float], 'FixedSize(3)']¶

getDefaultSceneToDisplayViewTransform() → PyOpenColorIO.PyOpenColorIO.ViewTransform¶

getDefaultView(*args, **kwargs)¶

Overloaded function.

getDefaultView(self: PyOpenColorIO.PyOpenColorIO.Config, display: str) -> str
getDefaultView(self: PyOpenColorIO.PyOpenColorIO.Config, display: str, colorSpacename: str) -> str

getDefaultViewTransformName() → str¶

getDescription() → str¶

getDisplayViewColorSpaceName(display: str, view: str) → str¶

getDisplayViewDescription(display: str, view: str) → str¶

getDisplayViewLooks(display: str, view: str) → str¶

getDisplayViewRule(display: str, view: str) → str¶

getDisplayViewTransformName(display: str, view: str) → str¶

getDisplays() → PyOpenColorIO.PyOpenColorIO.Config.DisplayIterator¶

getDisplaysAll() → PyOpenColorIO.PyOpenColorIO.Config.DisplayAllIterator¶

getEnvironmentMode() → PyOpenColorIO.PyOpenColorIO.EnvironmentMode¶

getEnvironmentVarDefault(name: str) → str¶

getEnvironmentVarNames() → PyOpenColorIO.PyOpenColorIO.Config.EnvironmentVarNameIterator¶

getFamilySeparator() → str¶

getFileRules() → PyOpenColorIO.PyOpenColorIO.FileRules¶

getInactiveColorSpaces() → str¶

getLook(name: str) → PyOpenColorIO.PyOpenColorIO.Look¶

getLookNames() → PyOpenColorIO.PyOpenColorIO.Config.LookNameIterator¶

getLooks() → PyOpenColorIO.PyOpenColorIO.Config.LookIterator¶

getMajorVersion() → int¶

getMinorVersion() → int¶

getName() → str¶

getNamedTransform(name: str) → PyOpenColorIO.PyOpenColorIO.NamedTransform¶

getNamedTransformNames(*args, **kwargs)¶

Overloaded function.

getNamedTransformNames(self: PyOpenColorIO.PyOpenColorIO.Config, visibility: PyOpenColorIO.PyOpenColorIO.NamedTransformVisibility) -> PyOpenColorIO.PyOpenColorIO.Config.NamedTransformNameIterator
getNamedTransformNames(self: PyOpenColorIO.PyOpenColorIO.Config) -> PyOpenColorIO.PyOpenColorIO.Config.ActiveNamedTransformNameIterator

getNamedTransforms(*args, **kwargs)¶

Overloaded function.

getNamedTransforms(self: PyOpenColorIO.PyOpenColorIO.Config, visibility: PyOpenColorIO.PyOpenColorIO.NamedTransformVisibility) -> PyOpenColorIO.PyOpenColorIO.Config.NamedTransformIterator
getNamedTransforms(self: PyOpenColorIO.PyOpenColorIO.Config) -> PyOpenColorIO.PyOpenColorIO.Config.ActiveNamedTransformIterator

getNumActiveDisplays() → int¶

getNumActiveViews() → int¶

getProcessor(*args, **kwargs)¶

Overloaded function.

getProcessor(self: PyOpenColorIO.PyOpenColorIO.Config, srcColorSpace: PyOpenColorIO.PyOpenColorIO.ColorSpace, dstColorSpace: PyOpenColorIO.PyOpenColorIO.ColorSpace) -> PyOpenColorIO.PyOpenColorIO.Processor
getProcessor(self: PyOpenColorIO.PyOpenColorIO.Config, context: PyOpenColorIO.PyOpenColorIO.Context, srcColorSpace: PyOpenColorIO.PyOpenColorIO.ColorSpace, dstColorSpace: PyOpenColorIO.PyOpenColorIO.ColorSpace) -> PyOpenColorIO.PyOpenColorIO.Processor
getProcessor(self: PyOpenColorIO.PyOpenColorIO.Config, srcColorSpaceName: str, dstColorSpaceName: str) -> PyOpenColorIO.PyOpenColorIO.Processor
getProcessor(self: PyOpenColorIO.PyOpenColorIO.Config, context: PyOpenColorIO.PyOpenColorIO.Context, srcColorSpaceName: str, dstColorSpaceName: str) -> PyOpenColorIO.PyOpenColorIO.Processor
getProcessor(self: PyOpenColorIO.PyOpenColorIO.Config, srcColorSpaceName: str, display: str, view: str, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) -> PyOpenColorIO.PyOpenColorIO.Processor
getProcessor(self: PyOpenColorIO.PyOpenColorIO.Config, context: PyOpenColorIO.PyOpenColorIO.Context, srcColorSpaceName: str, display: str, view: str, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) -> PyOpenColorIO.PyOpenColorIO.Processor
getProcessor(self: PyOpenColorIO.PyOpenColorIO.Config, namedTransform: PyOpenColorIO.PyOpenColorIO.NamedTransform, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) -> PyOpenColorIO.PyOpenColorIO.Processor
getProcessor(self: PyOpenColorIO.PyOpenColorIO.Config, context: PyOpenColorIO.PyOpenColorIO.Context, namedTransform: PyOpenColorIO.PyOpenColorIO.NamedTransform, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) -> PyOpenColorIO.PyOpenColorIO.Processor
getProcessor(self: PyOpenColorIO.PyOpenColorIO.Config, namedTransformName: str, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) -> PyOpenColorIO.PyOpenColorIO.Processor
getProcessor(self: PyOpenColorIO.PyOpenColorIO.Config, context: PyOpenColorIO.PyOpenColorIO.Context, namedTransformName: str, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) -> PyOpenColorIO.PyOpenColorIO.Processor
getProcessor(self: PyOpenColorIO.PyOpenColorIO.Config, transform: PyOpenColorIO.PyOpenColorIO.Transform) -> PyOpenColorIO.PyOpenColorIO.Processor
getProcessor(self: PyOpenColorIO.PyOpenColorIO.Config, transform: PyOpenColorIO.PyOpenColorIO.Transform, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) -> PyOpenColorIO.PyOpenColorIO.Processor
getProcessor(self: PyOpenColorIO.PyOpenColorIO.Config, context: PyOpenColorIO.PyOpenColorIO.Context, transform: PyOpenColorIO.PyOpenColorIO.Transform, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) -> PyOpenColorIO.PyOpenColorIO.Processor

getRoleColorSpace(roleName: str) → str¶

getRoleNames() → PyOpenColorIO.PyOpenColorIO.Config.RoleNameIterator¶

getRoles() → PyOpenColorIO.PyOpenColorIO.Config.RoleColorSpaceIterator¶

getSearchPath() → str¶

getSearchPaths() → PyOpenColorIO.PyOpenColorIO.Config.SearchPathIterator¶

getSharedViews() → PyOpenColorIO.PyOpenColorIO.Config.SharedViewIterator¶

getViewTransform(name: str) → PyOpenColorIO.PyOpenColorIO.ViewTransform¶

getViewTransformNames() → PyOpenColorIO.PyOpenColorIO.Config.ViewTransformNameIterator¶

getViewTransforms() → PyOpenColorIO.PyOpenColorIO.Config.ViewTransformIterator¶

getViewingRules() → PyOpenColorIO.PyOpenColorIO.ViewingRules¶

getViews(*args, **kwargs)¶

Overloaded function.

getViews(self: PyOpenColorIO.PyOpenColorIO.Config, display: str) -> PyOpenColorIO.PyOpenColorIO.Config.ViewIterator
getViews(self: PyOpenColorIO.PyOpenColorIO.Config, type: PyOpenColorIO.PyOpenColorIO.ViewType, display: str) -> PyOpenColorIO.PyOpenColorIO.Config.ViewForViewTypeIterator
getViews(self: PyOpenColorIO.PyOpenColorIO.Config, display: str, colorSpaceName: str) -> PyOpenColorIO.PyOpenColorIO.Config.ViewForColorSpaceIterator

getVirtualDisplayViewColorSpaceName(view: str) → str¶

getVirtualDisplayViewDescription(view: str) → str¶

getVirtualDisplayViewLooks(view: str) → str¶

getVirtualDisplayViewRule(view: str) → str¶

getVirtualDisplayViewTransformName(view: str) → str¶

getVirtualDisplayViews(display: PyOpenColorIO.PyOpenColorIO.ViewType) → PyOpenColorIO.PyOpenColorIO.Config.VirtualViewIterator¶

getWorkingDir() → str¶

hasRole(role: str) → bool¶

hasView(display: str, view: str) → bool¶

hasVirtualView(view: str) → bool¶

instantiateDisplayFromICCProfile(ICCProfileFilepath: str) → int¶

instantiateDisplayFromMonitorName(monitorName: str) → int¶

isArchivable() → bool¶

isColorSpaceLinear(colorSpace: str, referenceSpaceType: PyOpenColorIO.PyOpenColorIO.ReferenceSpaceType) → bool¶

isColorSpaceUsed(name: str) → bool¶

isDisplayTemporary(display: str) → bool¶

isInactiveColorSpace(colorspace: str) → bool¶

isStrictParsingEnabled() → bool¶

isViewShared(display: str, view: str) → bool¶

isVirtualViewShared(view: str) → bool¶

loadEnvironment() → None¶

parseColorSpaceFromString(str: str) → str¶

removeActiveDisplay(display: str) → None¶

removeActiveView(view: str) → None¶

removeColorSpace(name: str) → None¶

removeDisplayView(display: str, view: str) → None¶

removeSharedView(view: str) → None¶

removeVirtualDisplayView(view: str) → None¶

serialize(*args, **kwargs)¶

Overloaded function.

serialize(self: PyOpenColorIO.PyOpenColorIO.Config, fileName: str) -> None
serialize(self: PyOpenColorIO.PyOpenColorIO.Config) -> str

setActiveDisplays(displays: str) → None¶

setActiveViews(views: str) → None¶

setConfigIOProxy(ciop: OpenColorIO_v2_5::ConfigIOProxy) → None¶

setDefaultLumaCoefs(rgb: Annotated[collections.abc.Sequence[SupportsFloat], 'FixedSize(3)']) → None¶

setDefaultViewTransformName(name: str) → None¶

setDescription(description: str) → None¶

setDisplayTemporary(display: str, isTemporary: bool) → None¶

setEnvironmentMode(mode: PyOpenColorIO.PyOpenColorIO.EnvironmentMode) → None¶

setFamilySeparator(separator: str) → None¶

setFileRules(fileRules: PyOpenColorIO.PyOpenColorIO.FileRules) → None¶

setInactiveColorSpaces(inactiveColorSpaces: str) → None¶

setMajorVersion(major: SupportsInt) → None¶

setMinorVersion(minor: SupportsInt) → None¶

setName(name: str) → None¶

setProcessorCacheFlags(flags: PyOpenColorIO.PyOpenColorIO.ProcessorCacheFlags) → None¶

setRole(role: str, colorSpaceName: str) → None¶

setSearchPath(path: str) → None¶

setStrictParsingEnabled(enabled: bool) → None¶

setVersion(major: SupportsInt, minor: SupportsInt) → None¶

setViewingRules(ViewingRules: PyOpenColorIO.PyOpenColorIO.ViewingRules) → None¶

setWorkingDir(dirName: str) → None¶

upgradeToLatestVersion() → None¶

validate() → None¶

class PyOpenColorIO.Config.EnvironmentVarNameIterator¶

self[arg0: SupportsInt] → str¶

iter(self) → PyOpenColorIO.PyOpenColorIO.Config.EnvironmentVarNameIterator¶

len(self) → int¶

next(self) → str¶

class PyOpenColorIO.Config.SearchPathIterator¶

self[arg0: SupportsInt] → str¶

iter(self) → PyOpenColorIO.PyOpenColorIO.Config.SearchPathIterator¶

len(self) → int¶

next(self) → str¶

class PyOpenColorIO.Config.ColorSpaceNameIterator¶

self[arg0: SupportsInt] → str¶

iter(self) → PyOpenColorIO.PyOpenColorIO.Config.ColorSpaceNameIterator¶

len(self) → int¶

next(self) → str¶

class PyOpenColorIO.Config.ColorSpaceIterator¶

self[arg0: SupportsInt] → PyOpenColorIO.PyOpenColorIO.ColorSpace¶

iter(self) → PyOpenColorIO.PyOpenColorIO.Config.ColorSpaceIterator¶

len(self) → int¶

next(self) → PyOpenColorIO.PyOpenColorIO.ColorSpace¶

class PyOpenColorIO.Config.ActiveColorSpaceNameIterator¶

self[arg0: SupportsInt] → str¶

iter(self) → PyOpenColorIO.PyOpenColorIO.Config.ActiveColorSpaceNameIterator¶

len(self) → int¶

next(self) → str¶

class PyOpenColorIO.Config.ActiveColorSpaceIterator¶

self[arg0: SupportsInt] → PyOpenColorIO.PyOpenColorIO.ColorSpace¶

iter(self) → PyOpenColorIO.PyOpenColorIO.Config.ActiveColorSpaceIterator¶

len(self) → int¶

next(self) → PyOpenColorIO.PyOpenColorIO.ColorSpace¶

class PyOpenColorIO.Config.RoleNameIterator¶

self[arg0: SupportsInt] → str¶

iter(self) → PyOpenColorIO.PyOpenColorIO.Config.RoleNameIterator¶

len(self) → int¶

next(self) → str¶

class PyOpenColorIO.Config.RoleColorSpaceIterator¶

self[arg0: SupportsInt] → tuple¶

iter(self) → PyOpenColorIO.PyOpenColorIO.Config.RoleColorSpaceIterator¶

len(self) → int¶

next(self) → tuple¶

class PyOpenColorIO.Config.DisplayIterator¶

self[arg0: SupportsInt] → str¶

iter(self) → PyOpenColorIO.PyOpenColorIO.Config.DisplayIterator¶

len(self) → int¶

next(self) → str¶

class PyOpenColorIO.Config.SharedViewIterator¶

self[arg0: SupportsInt] → str¶

iter(self) → PyOpenColorIO.PyOpenColorIO.Config.SharedViewIterator¶

len(self) → int¶

next(self) → str¶

class PyOpenColorIO.Config.ViewIterator¶

self[arg0: SupportsInt] → str¶

iter(self) → PyOpenColorIO.PyOpenColorIO.Config.ViewIterator¶

len(self) → int¶

next(self) → str¶

class PyOpenColorIO.Config.ViewForColorSpaceIterator¶

self[arg0: SupportsInt] → str¶

iter(self) → PyOpenColorIO.PyOpenColorIO.Config.ViewForColorSpaceIterator¶

len(self) → int¶

next(self) → str¶

class PyOpenColorIO.Config.LookNameIterator¶

self[arg0: SupportsInt] → str¶

iter(self) → PyOpenColorIO.PyOpenColorIO.Config.LookNameIterator¶

len(self) → int¶

next(self) → str¶

class PyOpenColorIO.Config.LookIterator¶

self[arg0: SupportsInt] → PyOpenColorIO.PyOpenColorIO.Look¶

iter(self) → PyOpenColorIO.PyOpenColorIO.Config.LookIterator¶

len(self) → int¶

next(self) → PyOpenColorIO.PyOpenColorIO.Look¶

class PyOpenColorIO.Config.ViewTransformNameIterator¶

self[arg0: SupportsInt] → str¶

iter(self) → PyOpenColorIO.PyOpenColorIO.Config.ViewTransformNameIterator¶

len(self) → int¶

next(self) → str¶

class PyOpenColorIO.Config.ViewTransformIterator¶

self[arg0: SupportsInt] → PyOpenColorIO.PyOpenColorIO.ViewTransform¶

iter(self) → PyOpenColorIO.PyOpenColorIO.Config.ViewTransformIterator¶

len(self) → int¶

next(self) → PyOpenColorIO.PyOpenColorIO.ViewTransform¶

class PyOpenColorIO.Config.NamedTransformNameIterator¶

self[arg0: SupportsInt] → str¶

iter(self) → PyOpenColorIO.PyOpenColorIO.Config.NamedTransformNameIterator¶

len(self) → int¶

next(self) → str¶

class PyOpenColorIO.Config.NamedTransformIterator¶

self[arg0: SupportsInt] → PyOpenColorIO.PyOpenColorIO.NamedTransform¶

iter(self) → PyOpenColorIO.PyOpenColorIO.Config.NamedTransformIterator¶

len(self) → int¶

next(self) → PyOpenColorIO.PyOpenColorIO.NamedTransform¶

class PyOpenColorIO.Config.ActiveNamedTransformNameIterator¶

self[arg0: SupportsInt] → str¶

iter(self) → PyOpenColorIO.PyOpenColorIO.Config.ActiveNamedTransformNameIterator¶

len(self) → int¶

next(self) → str¶

class PyOpenColorIO.Config.ActiveNamedTransformIterator¶

self[arg0: SupportsInt] → PyOpenColorIO.PyOpenColorIO.NamedTransform¶

iter(self) → PyOpenColorIO.PyOpenColorIO.Config.ActiveNamedTransformIterator¶

len(self) → int¶

next(self) → PyOpenColorIO.PyOpenColorIO.NamedTransform¶

ConstConfigRcPtr OpenColorIO_v2_7dev::GetCurrentConfig()¶: Get the current configuration.

void OpenColorIO_v2_7dev::SetCurrentConfig(const ConstConfigRcPtr &config)¶: Set the current configuration. This will then store a copy of the specified config.

class Config¶

A config defines all the color spaces to be available at runtime.

The color configuration (Config) is the main object for interacting with this library. It encapsulates all of the information necessary to use customized ColorSpaceTransform and DisplayViewTransform operations.

See the user-guide for more information on selecting, creating, and working with custom color configurations.

For applications interested in using only one color config at a time (this is the vast majority of apps), their API would traditionally get the global configuration and use that, as opposed to creating a new one. This simplifies the use case for plugins and bindings, as it alleviates the need to pass around configuration handles.

An example of an application where this would not be sufficient would be a multi-threaded image proxy server (daemon), which wished to handle multiple show configurations in a single process concurrently. This app would need to keep multiple configurations alive, and to manage them appropriately.

Roughly speaking, a novice user should select a default configuration that most closely approximates the use case (animation, visual effects, etc.), and set the :envvar:OCIO environment variable to point at the root of that configuration.

See developers-usageexamples

Note

Initialization using environment variables is typically preferable in a multi-app ecosystem, as it allows all applications to be consistently configured.

Public Functions

ConfigRcPtr createEditableCopy() const¶

unsigned int getMajorVersion() const¶: Get the configuration major version.

void setMajorVersion(unsigned int major)¶

Set the configuration major version.

Throws if it is not supported. Resets minor to the most recent minor for the given major.

unsigned int getMinorVersion() const¶: Get the configuration minor version.

void setMinorVersion(unsigned int minor)¶: Set the configuration minor version. Throws if it is not supported for the current major.

void setVersion(unsigned int major, unsigned int minor)¶: Set the configuration major and minor versions. Throws if version is not supported.

void upgradeToLatestVersion() noexcept¶: Allows an older config to be serialized as the current version.

void validate() const¶

Performs a thorough validation for the most common user errors.

This will throw an exception if the config is malformed. The most common error occurs when references are made to colorspaces that do not exist.

const char *getName() const noexcept¶

Get/set a name string for the config.

The name string may be used to communicate config update details or similar information to workflows external to OCIO in cases where the config path/filename itself does not provide adequate information.

void setName(const char *name) noexcept¶

char getFamilySeparator() const¶

Get the family separator.

A single character used to separate the family string into tokens for use in hierarchical menus. Defaults to ‘/’.

void setFamilySeparator(char separator)¶

Set the family separator.

Succeeds if the characters is null or a valid character from the ASCII table i.e. from value 32 (i.e. space) to 126 (i.e. ‘~’); otherwise, it throws an exception.

const char *getDescription() const¶

void setDescription(const char *description)¶

void serialize(std::ostream &os) const¶

Returns the string representation of the Config in YAML text form.

This is typically stored on disk in a file with the extension .ocio. NB: This does not validate the config. Applications should validate before serializing.

const char *getCacheID() const¶

This will produce a hash of the all colorspace definitions, etc. All external references, such as files used in FileTransforms, etc., will be incorporated into the cacheID. While the contents of the files are not read, the file system is queried for relevant information (mtime, inode) so that the config’s cacheID will change when the underlying luts are updated.

If a context is not provided, the current Context will be used.

If a null context is provided, file references will not be taken into account (this is essentially a hash of Config::serialize).

const char *getCacheID(const ConstContextRcPtr &context) const¶

ConstContextRcPtr getCurrentContext() const¶

void addEnvironmentVar(const char *name, const char *defaultValue)¶: Add (or update) an environment variable with a default value. But it removes it if the default value is null.

int getNumEnvironmentVars() const¶

const char *getEnvironmentVarNameByIndex(int index) const¶

const char *getEnvironmentVarDefault(const char *name) const¶

void clearEnvironmentVars()¶

void setEnvironmentMode(EnvironmentMode mode) noexcept¶

The EnvironmentMode controls the behavior of loadEnvironment.

ENV_ENVIRONMENT_LOAD_PREDEFINED - Only update vars already added to the Context.
ENV_ENVIRONMENT_LOAD_ALL - Load all env. vars into the Context.

Client programs generally will not use these methods because the EnvironmentMode is set automatically when a Config is loaded. If the Config has an “environment” section, the mode is set to LOAD_PREDEFINED, and otherwise set to LOAD_ALL.

Note

Loading ALL the env. vars may reduce performance and reduce cache efficiency.

EnvironmentMode getEnvironmentMode() const noexcept¶

void loadEnvironment() noexcept¶: Initialize the environment/context variables in the Config’s Context.

const char *getSearchPath() const¶

void setSearchPath(const char *path)¶

Set all search paths as a concatenated string, use ‘:’ to separate the paths.

See addSearchPath for a more robust and platform-agnostic method of setting the search paths.

int getNumSearchPaths() const¶

const char *getSearchPath(int index) const¶

Get a search path from the list.

The paths are in the order they will be searched (that is, highest to lowest priority).

void clearSearchPaths()¶

void addSearchPath(const char *path)¶

Add a single search path to the end of the list.

Paths may be either absolute or relative. Relative paths are relative to the working directory. Forward slashes will be normalized to reverse for Windows. Environment (context) variables may be used in paths.

const char *getWorkingDir() const¶

void setWorkingDir(const char *dirname)¶: The working directory defaults to the location of the config file. It is used to convert any relative paths to absolute. If no search paths have been set, the working directory will be used as the fallback search path. No environment (context) variables may be used in the working directory.

ColorSpaceSetRcPtr getColorSpaces(const char *category) const¶: Get all active color spaces having a specific category in the order they appear in the config file.

Note

If the category is null or empty, the method returns all the active color spaces like getNumColorSpaces and getColorSpaceNameByIndex do.

Note

It’s worth noticing that the method returns a copy of the selected color spaces decoupling the result from the config. Hence, any changes on the config do not affect the existing color space sets, and vice-versa.

int getNumColorSpaces(SearchReferenceSpaceType searchReferenceType, ColorSpaceVisibility visibility) const¶: Work on the color spaces selected by the reference color space type and visibility.

const char *getColorSpaceNameByIndex(SearchReferenceSpaceType searchReferenceType, ColorSpaceVisibility visibility, int index) const¶

Work on the color spaces selected by the reference color space type and visibility (active or inactive).

Return empty for invalid index.

int getNumColorSpaces() const¶: Work on the active color spaces only.

Note

Only works from the list of active color spaces.

const char *getColorSpaceNameByIndex(int index) const¶: Work on the active color spaces only and return null for invalid index.

Note

Only works from the list of active color spaces.

int getIndexForColorSpace(const char *name) const¶: Get an index from the active color spaces only and return -1 if the name is not found.

Note

The fcn accepts either a color space name, role name, or alias. (Color space names take precedence over roles.)

ConstColorSpaceRcPtr getColorSpace(const char *name) const¶: Get the color space from all the color spaces (i.e. active and inactive) and return null if the name is not found.

Note

The fcn accepts either a color space name, role name, or alias. (Color space names take precedence over roles.)

const char *getCanonicalName(const char *name) const¶: Accepts an alias, role name, named transform name, or color space name and returns the color space name or the named transform name.

void addColorSpace(const ConstColorSpaceRcPtr &cs)¶: Add a color space to the configuration.

Note

If another color space is already present with the same name, this will overwrite it. This stores a copy of the specified color space.

Note

Adding a color space to a Config does not affect any ColorSpaceSet sets that have already been created.

void removeColorSpace(const char *name)¶: Remove a color space from the configuration.

Note

It does not throw an exception. Name must be the canonical name. If a role name or alias is provided or if the name is not in the config, nothing is done.

Note

Removing a color space from a Config does not affect any ColorSpaceSet sets that have already been created.

bool isColorSpaceUsed(const char *name) const noexcept¶: Return true if the color space is used by a transform, a role, a look, a (display, view) pair, or a file rule. The argument may be either an alias or the canonical name. While searching the config, aliases are always resolved to their canonical names for comparison.

void clearColorSpaces()¶: Remove all the color spaces from the configuration.

Note

Removing color spaces from a Config does not affect any ColorSpaceSet sets that have already been created.

void setInactiveColorSpaces(const char *inactiveColorSpaces)¶

Set/get a list of inactive color space or named transform names.

Notes:

List can contain color space and/or named transform names.
The inactive spaces are color spaces that should not appear in application menus.
These color spaces will still work in Config::getProcessor calls.
The argument is a comma-delimited string. A null or empty string empties the list.
The environment variable OCIO_INACTIVE_COLORSPACES may also be used to set the inactive color space list.
The env. var. takes precedence over the inactive_colorspaces list in the config file.
Setting the list via the API takes precedence over either the env. var. or the config file list.

const char *getInactiveColorSpaces() const¶

bool isInactiveColorSpace(const char *colorspace) const noexcept¶: Return true if the color space name is present in the inactive_colorspaces list.

bool isColorSpaceLinear(const char *colorSpace, ReferenceSpaceType referenceSpaceType) const¶

Return true if the specified color space is linear.

The determination of linearity is made with respect to one of the two reference spaces (i.e., either the scene-referred one or the display-referred one). If the reference space type of the color space is the opposite of the requested reference space type, false is returned immediately rather than trying to invoke the default view transform to convert between the reference spaces.

Note: This function relies on heuristics that may sometimes give an incorrect result. For example, if the encoding attribute is not set appropriately or the sampled values fail to detect non-linearity.

The algorithm proceeds as follows: — If the color space isdata attribute is true, return false. — If the reference space type of the color space differs from the requested reference space type, return false. — If the color space’s encoding attribute is present, return true if it matches the expected reference space type (i.e., “scene-linear” for REFERENCE_SPACE_SCENE or “display-linear” for REFERENCE_SPACE_DISPLAY) and false otherwise. — If the color space has no to_reference or from_reference transform, return true. — Evaluate several points through the color space’s transform and check if the output only differs by a scale factor (which may be different per channel, e.g. allowing an arbitrary matrix transform, with no offset).

Note that the encoding test happens before the sampled value test to give config authors ultimate control over the linearity determination. For example, they could set the encoding attribute to indicate linearity if they want to ignore some areas of non-linearity (e.g., at extreme values). Or they could set it to indicate that a color space should not be considered linear, even if it is, in a mathematical sense.

Parameters:

colorSpace – Color space to evaluate.
referenceSpaceType – Evaluate linearity with respect to the specified reference space (either scene-referred or display-referred).

ConstColorSpaceRcPtr findColorSpaceForID(const char *idString) const¶

Find the color space in this config identified by a Color Interop ID, per the ASWF Color Interop Forum ColorInteropID recommendation.

Only color space names and aliases are searched (not the interop_id attribute). The following steps are tried in order, and the first match is returned:

idString itself is looked up directly.
If idString contains a ‘:’, the leftmost namespace and one separator are stripped (only one level, regardless of how many colons remain) and the remainder is looked up.
If step 2 failed, and the stripped remainder string from step 2 is of the form “local:BASE” (exactly one colon), and the namespace removed in step 2 equals the sanitized form of this config’s own getName(), BASE is looked up. Since the BASE of such an ID was itself generated by sanitizing a color space name (see generateLocalIDForColorSpace), this step compares BASE against the sanitized form of the color space names and aliases, rather than against the names as they appear in the config.

Parameters:: idString – A color interop ID.
Returns:: The matching color space, or null if not found (including for a null or empty idString).

std::string generateLocalIDForColorSpace(const char *srcColorSpaceName) const¶

Generate an on-demand local Color Interop ID for a color space in this config, per the ASWF Color Interop Forum ColorInteropID recommendation.

The result has the form “<CONFIG-NAME>:local:<BASE>”, where CONFIG-NAME is from getName() and then sanitized per the recommendation’s Annex C sanitizeIDToken algorithm. The canonical name and the aliases of the color space are then checked to see if any are left unmodified by sanitization. If so, the first one found is used for BASE. Otherwise, the sanitized canonical color space name is used for BASE.

This should only be called if getInteropID returns nothing and LocateBuiltinColorSpace was unable to find an equivalent to this color space in a built-in config (which has interop IDs populated). In fact, this method ignores an interop ID in the color space, if present, to allow calculating the local ID, if necessary.

Parameters:: srcColorSpaceName – Name, role, or alias of an existing color space in this config.
Throws:: Exception – if srcColorSpaceName does not resolve to a color space in this config, or if getName() is empty or matches one of the built-in config names that is already populated with interop IDs.
Returns:: The generated ID.

void setRole(const char *role, const char *colorSpaceName)¶

Methods related to Roles.

A role allows a config author to indicate that a given color space should be used for a particular purpose.

Role names may be passed to most functions that accept color space names, such as getColorSpace. So for example, you may find the name of the color space assigned to the scene_linear role by getting the color space object for “scene_linear” and then calling getName on the color space object.

Note

Setting the colorSpaceName name to a null string unsets it.

int getNumRoles() const¶

bool hasRole(const char *role) const¶: Return true if the role has been defined.

const char *getRoleName(int index) const¶

Get the role name at index, this will return values like ‘scene_linear’, ‘compositing_log’.

Return empty string if index is out of range.

const char *getRoleColorSpace(int index) const¶

Get the role color space at index.

Return empty string if index is out of range.

const char *getRoleColorSpace(const char *roleName) const noexcept¶

Get the color space name used for the specified role.

Return an empty string if the role is not present

bool isViewShared(const char *dispName, const char *viewName) const¶

Check if a view within a given display is referencing one of the config’s shared views.

Methods related to displays and views.

The following methods only manipulate active displays and views. Active displays and views are defined from an env. variable or from the config file.

Looks is a potentially comma (or colon) delimited list of lookNames, Where +/- prefixes are optionally allowed to denote forward/inverse look specification. (And forward is assumed in the absence of either)

Add shared view (or replace existing one with same name). Shared views are defined at config level and can be referenced by several displays. Either provide a view transform and a display color space or just a color space (and a null view transform). Looks, rule and description are optional, they can be null or empty.

Shared views using a view transform may use the token <USE_DISPLAY_NAME> for the color space (see :c:var:OCIO_VIEW_USE_DISPLAY_NAME). In that case, when the view is referenced in a display, the display color space that is used will be the one matching the display name. In other words, the view will be customized based on the display it is used in. validate will throw if the config does not contain the matching display color space.

void addSharedView(const char *view, const char *viewTransformName, const char *colorSpaceName, const char *looks, const char *ruleName, const char *description)¶: Will throw if view or colorSpaceName are null or empty.

void addSharedView(const char *view, const char *viewTransformName, const char *colorSpaceName, const char *looks, const char *ruleName, const char *description, const std::vector<std::string> &aliases)¶

As above, but also sets the view’s aliases.

Will throw if view or colorSpaceName are null or empty, or if an alias collides with the name or an alias of another shared view.

void removeSharedView(const char *view)¶: Remove a shared view. Will throw if the view does not exist.

void clearSharedViews()¶: Clear all shared views. This will throw if any displays are still using the shared views.

const char *getDefaultDisplay() const¶

int getNumDisplays() const¶

const char *getDisplay(int index) const¶: Will return “” if the index is invalid.

const char *getDefaultView(const char *display) const¶

const char *getDefaultView(const char *display, const char *colorspaceName) const¶

int getNumViews(const char *display) const¶: Return the number of active views attached to the display including the number of shared views if any. Return 0 if display does not exist.

const char *getView(const char *display, int index) const¶

int getNumViews(const char *display, const char *colorspaceName) const¶: If the config has ViewingRules, get the number of active Views for this colorspace. (If there are no rules, it returns all of them.)

const char *getView(const char *display, const char *colorspaceName, int index) const¶

const char *getDisplayViewTransformName(const char *display, const char *view) const¶: Returns the view_transform attribute of the (display, view) pair. View can be a shared view of the display. If display is null or empty, config shared views are used.

const char *getDisplayViewColorSpaceName(const char *display, const char *view) const¶: Returns the colorspace attribute of the (display, view) pair. (Note that this may be either a color space or a display color space.) See getResolvedDisplayViewColorSpaceName to first resolve any display or view aliases.

const char *getDisplayViewLooks(const char *display, const char *view) const¶: Returns the looks attribute of a (display, view) pair.

const char *getDisplayViewRule(const char *display, const char *view) const noexcept¶: Returns the rule attribute of a (display, view) pair.

const char *getDisplayViewDescription(const char *display, const char *view) const noexcept¶: Returns the description attribute of a (display, view) pair.

int getNumDisplayViewAliases(const char *display, const char *view) const noexcept¶: Get the number of aliases of a (display, view) pair. If display is null or empty, config shared views are used.

const char *getDisplayViewAlias(const char *display, const char *view, int index) const noexcept¶

Get an alias of a (display, view) pair, by index. If display is null or empty, config shared views are used.

Returns “” if the (display, view) pair does not exist or index is out of range.

bool hasDisplayViewAlias(const char *display, const char *view, const char *alias) const noexcept¶: Convenience method to check whether a (display, view) pair has a specific alias. If display is null or empty, config shared views are used.

bool hasView(const char *dispName, const char *viewName) const¶

Determine if a display and view exist.

This returns false if either the display or view doesn’t exist. It works regardless of whether the display or view are active, and it works regardless of whether the view is display-defined or if the display has this as a shared view. It will only check config-level shared views if dispName is null. It will not check config level shared views if dispName is not null.

void addDisplayView(const char *display, const char *view, const char *colorSpaceName, const char *looks)¶: For the (display, view) pair, specify which color space and look to use. If a look is not desired, then just pass a null or empty string.

void addDisplayView(const char *display, const char *view, const char *viewTransformName, const char *colorSpaceName, const char *looks, const char *ruleName, const char *description)¶

For the (display, view) pair, specify the color space or alternatively specify the view transform and display color space. The looks, viewing rule, and description are optional. Pass a null or empty string for any optional arguments. If the view already exists, it is replaced.

Will throw if:

Display, view or colorSpace are null or empty.
Display already has a shared view with the same name.

void addDisplayView(const char *display, const char *view, const char *viewTransformName, const char *colorSpaceName, const char *looks, const char *ruleName, const char *description, const std::vector<std::string> &aliases)¶

As above, but also sets the view’s aliases.

Will throw if:

Display, view or colorSpace are null or empty.
Display already has a shared view with the same name.
An alias collides with the name or an alias of another view in this display, whether display-defined or a shared view referenced by this display.

void addDisplaySharedView(const char *display, const char *sharedView)¶

Add a (reference to a) shared view to a display.

The shared view must be part of the config. See addSharedView

This will throw if:

Display or view are null or empty.
Display already has a view (shared or not) with the same name.

void removeDisplayView(const char *display, const char *view)¶

Remove the view and the display if no more views.

It does not remove the associated color space. If the view name is a shared view, it only removes the reference to the view from the display but the shared view, remains in the config.

Will throw if the view does not exist.

void clearDisplays()¶: Clear all the displays.

bool getUseDisplayAliases() const noexcept¶

This property on the Config object allows config authors to use aliases for display names. This feature is off by default.

Methods that involve resolving display and view aliases.

Corresponds to the “use_display_aliases” config file attribute, which is only written to the file when true. Requires config version 2.6 or higher (validation will fail if this is enabled on an older config).

void setUseDisplayAliases(bool enabled) noexcept¶

const char *getCanonicalDisplayName(const char *displayName) const¶

Resolve display name aliases.

If the argument does not match an existing display, a fallback checks if getColorSpace returns a display color space. If so, it checks to see if there is a display whose name matches that color space name or one of its aliases.

This fallback is only performed if getUseDisplayAliases is true.

Returns “” if no display can be found, even with the fallback.

const char *getCanonicalViewName(const char *displayName, const char *viewName) const¶

Resolve view name aliases.

If the arguments do not directly match an existing (display, view) pair, this looks for a view used by the display (whether display-defined or a referenced shared view, active or inactive) that has viewName as one of its aliases (see addDisplayView and addSharedView).

The displayName is first resolved via getCanonicalDisplayName.

Returns “” if no display and view can be found, even with the fallback, or if the arguments are null or empty.

const char *getResolvedDisplayViewColorSpaceName(const char *displayName, const char *viewName) const¶

Returns the name of the color space that a (display, view) pair uses.

This is similar to getDisplayViewColorSpaceName, but it first attempts to resolve displayName and viewName (which could be aliases) to their canonical names, via getCanonicalDisplayName and getCanonicalViewName. And unlike that function, the displayName may not be empty.

In addition, if the display_colorspace of a shared view is <USE_DISPLAY_NAME>, that is resolved to the name of the view’s display.

Note that, as with getDisplayViewColorSpaceName, the returned name may be that of a named transform rather than a color space (this is allowed for views that have no view_transform).

Returns either the canonical name of the view’s color space or, if that does not find a result, the raw color space string (which would likely be used in an error message). If the (display, view) pair cannot even be resolved, it returns “”.

const char *getDisplayDescription(const char *displayName) const¶

Return the description of the display color space associated with displayName.

If displayName matches the canonical name of a display color space, its description is returned. If getUseDisplayAliases is true, the search is broadened to include display color spaces that have displayName as an alias.

Returns “” if no such display color space can be found.

bool hasVirtualView(const char *viewName) const¶

Determine if a virtual view exists.

Methods related to the Virtual Display.

… (See descriptions for the non-virtual methods above.)

The virtual display is the way to incorporate the ICC monitor profile for a user’s display into OCIO. The views that are defined for the virtual display are the views that are used to create a new display for an ICC profile. They serve as a kind of template that lets OCIO know how to build the new display.

Typically the views will define a View Transform and set the colorSpaceName to “<USE_DISPLAY_NAME>” so that it will use the display color space with the same name as the display, in this case corresponding to the ICC profile.

This returns false if the virtual view doesn’t exist. It works regardless of whether the virtual view is active, and it works regardless of whether the virtual view is display-defined or if the display has this as a shared virtual view.

bool isVirtualViewShared(const char *viewName) const¶: Check if a given virtual view is referencing one of the config’s shared views.

void addVirtualDisplayView(const char *view, const char *viewTransformName, const char *colorSpaceName, const char *looks, const char *ruleName, const char *description)¶

void addVirtualDisplaySharedView(const char *sharedView)¶

int getVirtualDisplayNumViews(ViewType type) const noexcept¶: Get the number of views associated to the virtual display.

const char *getVirtualDisplayView(ViewType type, int index) const noexcept¶: Get the view name at a specific index.

const char *getVirtualDisplayViewTransformName(const char *view) const noexcept¶

const char *getVirtualDisplayViewColorSpaceName(const char *view) const noexcept¶

const char *getVirtualDisplayViewLooks(const char *view) const noexcept¶

const char *getVirtualDisplayViewRule(const char *view) const noexcept¶

const char *getVirtualDisplayViewDescription(const char *view) const noexcept¶

void removeVirtualDisplayView(const char *view) noexcept¶: Remove the view from the virtual display.

void clearVirtualDisplay() noexcept¶: Clear the virtual display.

int instantiateDisplayFromMonitorName(const char *monitorName)¶

Instantiate a new display from a virtual display, using the monitor name.

This method uses the virtual display to create an actual display for the given monitorName. The new display will receive the views from the virtual display.

After the ICC profile is read, a display name will be created by combining the description text from the profile with the monitorName obtained from the OS. Use the SystemMonitors class to obtain the list of monitorName strings for the displays connected to the computer.

A new display color space will also be created using the display name. It will have a from_display_reference transform that is a FileTransform pointing to the ICC profile.

Any instantiated display color spaces for a virtual display are intended to be temporary (i.e. last as long as the current session). By default, they are not saved when writing a config file. If there is a need to make it a permanent color space, it may be desirable to copy the ICC profile somewhere under the config search_path.

Will throw if the config does not have a virtual display or if the monitorName does not exist.

If there is already a display or a display color space with the name monitorName, it will be replaced/updated.

Returns the index of the display.

int instantiateDisplayFromICCProfile(const char *ICCProfileFilepath)¶

Instantiate a new display from a virtual display, using an ICC profile.

On platforms such as Linux, where the SystemMonitors class is not able to obtain a list of ICC profiles from the OS, this method may be used to manually specify a path to an ICC profile.

Will throw if the virtual display definition is missing from the config.

Returns the index of the display.

void setActiveDisplays(const char *displays)¶

The Active Displays list allows end users, config authors, and client apps to filter and reorder of the list of displays available in a user-interface. The list may be left empty to indicate all displays are active.

The first active display is the config’s Default Display.

If the active list would remove all displays from a config, it is ignored (though the config won’t validate).

When serialized in the config, commas are used as separators. However, if a display name contains a comma, the name will be enclosed in quotes so its comma is not a separator.

The OCIO_ACTIVE_DISPLAYS environment variable will override the active list specified in the config file as well as any modifications made by the client app. These functions only get and set what is in the config object and do not take into account the override and thus may not represent the actual user experience.

Display aliases may not be used in the active list, use getCanonicalDisplayName to convert any aliases to their canonical name. Set all active displays at once as a comma or colon delimited string. This replaces any previous contents of the list.

const char *getActiveDisplays() const¶: Get a string with all active displays (as it would appear in a config file). Commas are always used as the separator.

int getNumActiveDisplays() const¶: Get the number of active displays.

const char *getActiveDisplay(int index) const¶: Get a single active display, by index. Returns nullptr if the index is out of range.

void addActiveDisplay(const char *display)¶: Add a single active display to the end of the list. If the display is already present, no action is taken.

void removeActiveDisplay(const char *display)¶: Remove a single display. Will throw if the display is not present.

void clearActiveDisplays()¶: Clear the active displays list.

void setActiveViews(const char *views)¶

The Active Views list allows end users, config authors, and client apps to filter and reorder of the list of views available in a user-interface. The list may be left empty to indicate all views are active.

The first active view for a display is its Default View.

If the active list would remove all views from a display, the list is ignored for that display and all views are shown for it.

When serialized in the config, commas are used as separators. However, if a view name contains a comma, the name will be enclosed in quotes so its comma is not a separator.

The OCIO_ACTIVE_VIEWS environment variable will override the active list specified in the config file as well as any modifications made by the client app. These functions only get and set what is in the config object and do not take into account the override and thus may not represent the actual user experience.

View aliases may not be used in the active list, use getCanonicalViewName to convert any aliases to their canonical name. Set all active views at once as a comma or colon delimited string. This replaces any previous contents of the list.

const char *getActiveViews() const¶: Get a string with all active views (as it would appear in a config file). Commas are always used as the separator.

int getNumActiveViews() const¶: Get the number of active views.

const char *getActiveView(int index) const¶: Get a single active view, by index. Returns nullptr if the index is out of range.

void addActiveView(const char *view)¶: Add a single active view to the end of the list. If the view is already present, no action is taken.

void removeActiveView(const char *view)¶: Remove a single view. Will throw if the view is not present.

void clearActiveViews()¶: Clear the active views list.

int getNumDisplaysAll() const noexcept¶: Get all displays in the config, ignoring the active_displays list.

const char *getDisplayAll(int index) const noexcept¶

int getDisplayAllByName(const char*) const noexcept¶

bool isDisplayTemporary(int index) const noexcept¶: Will be true for a display that was instantiated from a virtual display. These displays are intended to be temporary (i.e. for the current session) and are not saved to a config file.

void setDisplayTemporary(int index, bool isTemporary) noexcept¶: Allows setting the flag that controls whether a display is temporary. This may be helpful, for example, to share a config with a temporary instantiated display with an OFX plug-in.

int getNumViews(ViewType type, const char *display) const¶: Get either the shared or display-defined views for a display. The active_views list is ignored. Passing a null or empty display (with type=VIEW_SHARED) returns the contents of the shared_views section of the config. Return 0 if display does not exist.

const char *getView(ViewType type, const char *display, int index) const¶

ConstViewingRulesRcPtr getViewingRules() const noexcept¶: Get read-only version of the viewing rules.

void setViewingRules(ConstViewingRulesRcPtr viewingRules)¶: Set viewing rules.

Note

The argument is cloned.

void getDefaultLumaCoefs(double *rgb) const¶: Get the default coefficients for computing luma.

Note

There is no “1 size fits all” set of luma coefficients. (The values are typically different for each colorspace, and the application of them may be nonsensical depending on the intensity coding anyways). Thus, the ‘right’ answer is to make these functions on the ColorSpace class. However, it’s often useful to have a config-wide default so here it is. We will add the colorspace specific luma call if/when another client is interesting in using it.

void setDefaultLumaCoefs(const double *rgb)¶: These should be normalized (sum to 1.0 exactly).

ConstLookRcPtr getLook(const char *name) const¶

int getNumLooks() const¶

const char *getLookNameByIndex(int index) const¶

void addLook(const ConstLookRcPtr &look)¶

void clearLooks()¶

int getNumViewTransforms() const noexcept¶

ConstViewTransformRcPtr getViewTransform(const char *name) const noexcept¶

const char *getViewTransformNameByIndex(int i) const noexcept¶

void addViewTransform(const ConstViewTransformRcPtr &viewTransform)¶

ConstViewTransformRcPtr getDefaultSceneToDisplayViewTransform() const¶: This view transform is the one that will be used by default if a ColorSpaceTransform is needed between a scene-referred and display-referred color space. The config author may specify a transform to use via the default_view_transform entry in the config. If that is not present, or does not return a valid view transform from the scene-referred connection space, the fall-back is to use the first valid view transform in the config. Returns a null ConstTransformRcPtr if there isn’t one.

const char *getDefaultViewTransformName() const noexcept¶

Get or set the default_view_transform string from the config.

Note that if this is not the name of a valid view transform from the scene-referred connection space, it will be ignored.

void setDefaultViewTransformName(const char *defaultName) noexcept¶

void clearViewTransforms()¶

int getNumNamedTransforms(NamedTransformVisibility visibility) const noexcept¶

Work on the named transforms selected by visibility.

Methods related to named transforms.

const char *getNamedTransformNameByIndex(NamedTransformVisibility visibility, int index) const noexcept¶

Work on the named transforms selected by visibility (active or inactive).

Return an empty string for invalid index.

int getNumNamedTransforms() const noexcept¶: Work on the active named transforms only.

const char *getNamedTransformNameByIndex(int index) const noexcept¶: Work on the active named transforms only and return an empty string for invalid index.

int getIndexForNamedTransform(const char *name) const noexcept¶: Get an index from the active named transforms only and return -1 if the name is not found.

ConstNamedTransformRcPtr getNamedTransform(const char *name) const noexcept¶: Get the named transform from all the named transforms (i.e. active and inactive) and return null if the name is not found.

void addNamedTransform(const ConstNamedTransformRcPtr &namedTransform)¶: Add or replace named transform.

Note

Throws if namedTransform is null, name is missing, or no transform is set. Also throws if the name or the aliases conflict with names or aliases already in the config.

void removeNamedTransform(const char *name)¶: Remove a named transform. (Does nothing if name is not found.).

void clearNamedTransforms()¶: Clear all named transforms.

ConstFileRulesRcPtr getFileRules() const noexcept¶: Get read-only version of the file rules.

void setFileRules(ConstFileRulesRcPtr fileRules)¶: Set file rules.

Note

The argument is cloned.

const char *getColorSpaceFromFilepath(const char *filePath) const¶: Get the color space of the first rule that matched filePath. (For v1 configs, this is equivalent to calling parseColorSpaceFromString with strictparsing set to false.)

const char *getColorSpaceFromFilepath(const char *filePath, size_t &ruleIndex) const¶: Most applications will use the preceding method, but this method may be used for applications that want to know which was the highest priority rule to match filePath. getNumCustomKeys and custom keys methods may then be used to get additional information about the matching rule.

bool filepathOnlyMatchesDefaultRule(const char *filePath) const¶: Returns true if the only rule matched by filePath is the default rule. This is a convenience method for applications that want to require the user to manually choose a color space when strictParsing is true and no other rules match.

const char *parseColorSpaceFromString(const char *str) const¶

Given the specified string, get the longest, right-most, colorspace substring that appears.

If strict parsing is enabled, and no color space is found, return an empty string.
If strict parsing is disabled, return ROLE_DEFAULT (if defined).
If the default role is not defined, return an empty string.

bool isStrictParsingEnabled() const¶

void setStrictParsingEnabled(bool enabled)¶

ConstProcessorRcPtr getProcessor(const ConstContextRcPtr &context, const ConstColorSpaceRcPtr &srcColorSpace, const ConstColorSpaceRcPtr &dstColorSpace) const¶: Get the processor to apply a ColorSpaceTransform from a source to a destination color space.

ConstProcessorRcPtr getProcessor(const ConstColorSpaceRcPtr &srcColorSpace, const ConstColorSpaceRcPtr &dstColorSpace) const¶

ConstProcessorRcPtr getProcessor(const char *srcColorSpaceName, const char *dstColorSpaceName) const¶: Note

Names can be colorspace name, role name, or a combination of both.

ConstProcessorRcPtr getProcessor(const ConstContextRcPtr &context, const char *srcColorSpaceName, const char *dstColorSpaceName) const¶

ConstProcessorRcPtr getProcessor(const char *srcColorSpaceName, const char *display, const char *view, TransformDirection direction) const¶: Get the processor to apply a DisplayViewTransform for a display and view. Refer to the Display/View Registration section above for more info on the display and view arguments.

ConstProcessorRcPtr getProcessor(const ConstContextRcPtr &context, const char *srcColorSpaceName, const char *display, const char *view, TransformDirection direction) const¶

ConstProcessorRcPtr getProcessor(const ConstNamedTransformRcPtr &namedTransform, TransformDirection direction) const¶: Get the processor to apply a NamedTransform in the specified direction.

ConstProcessorRcPtr getProcessor(const ConstContextRcPtr &context, const ConstNamedTransformRcPtr &namedTransform, TransformDirection direction) const¶

ConstProcessorRcPtr getProcessor(const char *namedTransformName, TransformDirection direction) const¶

ConstProcessorRcPtr getProcessor(const ConstContextRcPtr &context, const char *namedTransformName, TransformDirection direction) const¶

ConstProcessorRcPtr getProcessor(const ConstTransformRcPtr &transform) const¶

Get the processor for the specified transform.

Not often needed, but will allow for the re-use of atomic OCIO functionality (such as to apply an individual LUT file).

ConstProcessorRcPtr getProcessor(const ConstTransformRcPtr &transform, TransformDirection direction) const¶

ConstProcessorRcPtr getProcessor(const ConstContextRcPtr &context, const ConstTransformRcPtr &transform, TransformDirection direction) const¶

ProcessorCacheFlags getProcessorCacheFlags() const noexcept¶: Get the Processor Cache flags.

void setProcessorCacheFlags(ProcessorCacheFlags flags) const noexcept¶

Control the caching of processors in the config instance. By default, caching is on.

The flags allow turning caching off entirely or only turning it off if dynamic properties are being used by the processor.

void clearProcessorCache() noexcept¶

Clears this config’s cache of Processor, CPUProcessor, and GPUProcessor instances.

This must be done if any of the LUT files used by these Processors have been modified. Note that setProcessorCacheFlags(PROCESSOR_CACHE_OFF) turns off caching but does not clear any existing cache.

void setConfigIOProxy(ConfigIOProxyRcPtr ciop)¶: Set the ConfigIOProxy object used to provision the config and LUTs from somewhere other than the file system. (This is set on the config’s embedded Context object.)

ConfigIOProxyRcPtr getConfigIOProxy() const¶

bool isArchivable() const¶

Verify if the config is archivable.

A config is not archivable if any of the following are true: — The working directory is not set — It contains FileTransforms with a src outside the working directory — The search path contains paths outside the working directory — The search path contains paths that start with a context variable

Context variables are allowed but the intent is that they may only resolve to paths that are within or below the working directory. This is because the archiving function will only archive files that are within the working directory in order to ensure that if it is later expanded, that it will not create any files outside this directory.

For example, a context variable on the search path intended to contain the name of a sub-directory under the working directory must have the form “./$DIR_NAME” rather than just “$DIR_NAME” to be considered archivable. This is imperfect since there is no way to prevent the context variable from creating a path outside the working dir, but it should at least draw attention to the fact that the archive would fail if used with context vars that try to abuse the intended functionality.

Returns:: bool Archivable if true.

void archive(std::ostream &ostream) const¶

Archive the config and its LUTs into the specified output stream.

The config is archived by serializing the Config object into a file named “config.ocio” and then walking through the current working directory and any sub-directories. Any files that have an extension matching a supported LUT file format are added to the archive. Any files that do not have an extension (or have some unsupported LUT extension, including .ocio), will not be added to the archive. To reiterate, it is the in-memory Config object that is archived, and not any .ocio file in the current working directory. The directory structure relative to the working directory is preserved. No files outside the working directory are archived so that if it is later expanded, no files will be created outside the working dir.

The reason the archive is created using all supported LUT file extensions rather than by trying to resolve all the FileTransforms in the Config to specific files is because of the goal to allow context variables to continue to work.

If a Config is created with CreateFromStream, CreateFromFile with an OCIOZ archive, or CreateFromConfigIOProxy, it cannot be archived unless the working directory is manually set to a directory that contains any necessary LUT files.

The provided output stream must be closed by the caller, if necessary (e.g., an ofstream).

Parameters:: ostream – The output stream to write to.

Config(const Config&) = delete¶

Config &operator=(const Config&) = delete¶

~Config()¶: Do not use (needed only for pybind11).

Public Static Functions

static ConfigRcPtr Create()¶

Create an empty config of the current version.

Note that an empty config will not pass validation since required elements will be missing.

Returns:: The Config object.

static ConstConfigRcPtr CreateRaw()¶

Create a fall-back config.

This may be useful to allow client apps to launch in cases when the supplied config path is not loadable.

Returns:: The Config object.

static ConstConfigRcPtr CreateFromEnv()¶

Create a configuration using the OCIO environment variable.

Also supports the OCIO URI format for Built-in configs and supports archived configs. See CreateFromFile.

If the variable is missing or empty, returns the same result as CreateRaw.

Returns:: The Config object.

static ConstConfigRcPtr CreateFromFile(const char *filename)¶

Create a configuration using a specific config file.

Supports the OCIO URI format for Built-in configs. See CreateFromBuiltinConfig.

Supports archived configs (.ocioz files).

Throws:: Exception – If the file may not be read or does not parse.
Returns:: The Config object.

static ConstConfigRcPtr CreateFromStream(std::istream &istream)¶

Create a configuration using a stream.

Note that CreateFromStream does not set the working directory so the caller would need to set that separately in order to resolve FileTransforms. This function is typically only used for self-contained configs (no LUTs).

Configs created from CreateFromStream can not be archived unless the working directory is set and contains any necessary LUT files.

Parameters:: istream – Stream to the config.
Throws:: Exception – If the stream does not parse.
Returns:: The Config object.

static ConstConfigRcPtr CreateFromConfigIOProxy(ConfigIOProxyRcPtr ciop)¶

Create a config from the supplied ConfigIOProxy object. This allows the calling program to directly provide the config and associated LUTs rather than reading them from the standard file system.

See the ConfigIOProxy class documentation for more info.

Parameters:: ciop – ConfigIOProxy object providing access to the config’s files.
Throws:: Exception – If the config may not be read from the proxy, or does not parse.
Returns:: The Config object.

static ConstConfigRcPtr CreateFromBuiltinConfig(const char *configName)¶

Create a configuration using an OCIO built-in config.

Also supports the following OCIO URI format for Built-in configs: “ocio://default” - Default Built-in config. “ocio://cg-config-latest” - Latest Built-in CG config. “ocio://studio-config-latest” - Latest Built-in Studio config. “ocio://<CONFIG NAME>” - A specific Built-in config.

The available configNames are:

ACES Studio config, contains a more complete collection of color spaces and displays: “studio-config-v1.0.0_aces-v1.3_ocio-v2.1” “studio-config-v2.1.0_aces-v1.3_ocio-v2.3” “studio-config-v2.2.0_aces-v1.3_ocio-v2.4” “studio-config-v4.0.0_aces-v2.0_ocio-v2.5” “studio-config-v5.0.0_aces-v2.1_ocio-v2.6”

ACES CG config, basic color spaces for computer graphics apps: “cg-config-v1.0.0_aces-v1.3_ocio-v2.1” “cg-config-v2.1.0_aces-v1.3_ocio-v2.3” “cg-config-v2.2.0_aces-v1.3_ocio-v2.4” “cg-config-v4.0.0_aces-v2.0_ocio-v2.5” “cg-config-v5.0.0_aces-v2.1_ocio-v2.6”

More information is available at: https://github.com/AcademySoftwareFoundation/OpenColorIO-Config-ACES

Information about the available configs is available from the BuiltinConfigRegistry.

Parameters:: configName – Built-in config name (with or without the “ocio://” URI prefix).
Throws:: Exception – If the configName is not recognized.
Returns:: One of the configs built into the OCIO library.

static char GetDefaultFamilySeparator() noexcept¶: Get the default family separator i.e. ‘/’ .

static const char *IdentifyBuiltinColorSpace(const ConstConfigRcPtr &srcConfig, const ConstConfigRcPtr &builtinConfig, const char *builtinColorSpaceName)¶

Find the name of the color space in the source config that is the same as a color space in the default built-in config. For example, setting the builtinColorSpaceName to “sRGB - Texture” (a color space name from that config), would return the name for the corresponding sRGB texture space in the current config (or empty if it was not found). Note that this method relies on heuristics which may evolve over time and which may not work on all configs.

The method only looks at active color spaces. If the interchange roles are missing and heuristics are used, only scene-referred color spaces are searched.

Parameters:

srcConfig – The config to search for the desired color space.
builtinConfig – The built-in config to use. See CreateFromBuiltinConfig.
builtinColorSpaceName – Color space name in the built-in default config.

Throws:

Exception – if an interchange space cannot be found or the equivalent space cannot be found.

Returns:

Matching color space name from the source config. Empty if not found.

static const char *LocateBuiltinColorSpace(const ConstConfigRcPtr &srcConfig, const char *srcColorSpaceName, const ConstConfigRcPtr &builtinConfig)¶

Find the name of the color space in the given built-in config that is equivalent to the color space in the source config. This is useful as a way of finding a color interop ID for a color space that doesn’t have one, since the recent built-in configs have the ID populated for all color spaces. Note that this method relies on heuristics which may evolve over time and which may not work on all configs.

Both active and inactive color spaces are searched in the built-in config (note that this differs from IdentifyBuiltinColorSpace, which only searches the active color spaces of the source config).

A built-in color space is evaluated by processing test colors and comparing to the source color space. The interchange roles are used to make this comparison independent of the reference spaces in the configs. If the source config does not have the interchange roles, heuristics will be used but these may be less accurate or may not identify the reference space, particularly for display-referred spaces.

Note that the set of test results (the “fingerprints”) for the built-in config are expensive to calculate, since it requires building a Processor for each of its color spaces. They are calculated on the first call and then cached on the builtinConfig until the config is modified. For that reason, an application that calls this method more than once should hold on to the built-in config object rather than calling CreateFromBuiltinConfig each time.

Parameters:

srcConfig – The config containing the color space to locate an equivalent for.
srcColorSpaceName – Color space name in the source config. Roles and aliases may be used, and inactive color spaces are allowed.
builtinConfig – The built-in config to search. See CreateFromBuiltinConfig.

Throws:

Exception – if the source color space does not exist or if an interchange space cannot be found in srcConfig.

Returns:

Matching color space name from the built-in config. Empty if not found.

static void IdentifyInterchangeSpace(const char **srcInterchangeName, const char **builtinInterchangeName, const ConstConfigRcPtr &srcConfig, const char *srcColorSpaceName, const ConstConfigRcPtr &builtinConfig, const char *builtinColorSpaceName)¶

Identify the two names of a common color space that exists in both the given config and the provided built-in config that may be used for converting color spaces between the two configs. If both configs have the interchange role set, than the color spaces set to that role will be returned. Otherwise, heuristics will be used to try and identify a known color space in the source config. These are the same heuristics that are used for other methods such as identifyBuiltinColorSpace and GetProcessorTo/FromBuiltinColorSpace.

Using this method in connection with GetProcessorFromConfigs is more efficient if you need to call GetProcessorTo/FromBuiltinColorSpace multiple times since it is only necessary to run the heuristics once (to identify the interchange spaces).

The srcColorSpaceName and builtinColorSpace name are used to decide which interchange role to use (scene- or display-referred). However, they are not used if the interchange roles are not present and the heuristics are used. It is actually only the ReferenceSpaceType of the color spaces that are used, so it is not necessary to call this function multiple times if all the spaces are of the same type. (These are the same arguments that would also be set if you were instead calling GetProcessorTo/FromBuiltinColorSpace.)

Parameters:

srcInterchangeName – [out] Color space name from the source config.
builtinInterchangeName – [out] Corresponding color space name from the built-in config.
srcConfig – The config to search for the desired color space.
srcColorSpaceName – Color space name in the given config to convert to/from.
builtinConfig – The built-in config to use. See CreateFromBuiltinConfig.
builtinColorSpaceName – Color space name in the default built-in config.

Throws:

Exception – if either the srcInterchange or builtinInterchange cannot be identified.

static bool AreViewsEqual(const ConstConfigRcPtr &first, const ConstConfigRcPtr &second, const char *dispName, const char *viewName)¶

Compare views in a pair of configs.

Will return false if either of the views does not exist. This will return true even if the view is display-defined in one config and a reference to a shared view in the other config (both within the same display), as long as the contents match. The description text (if any) is ignored, since it is not a functional difference.

Note that the comparison is only on the strings contained in the view definition, the function does not attempt to compare that the color spaces or view transforms being referenced are identical (only that they have the same name).

static bool AreVirtualViewsEqual(const ConstConfigRcPtr &first, const ConstConfigRcPtr &second, const char *viewName)¶

Compare virtual views in a pair of configs.

Will return false if either of the virtual views does not exist. This will return true even if the virtual view is display-defined in one config and a reference to a shared virtual view in the other config, as long as the contents match.

The description text (if any) is ignored, since it is not a functional difference.

static ConstProcessorRcPtr GetProcessorToBuiltinColorSpace(ConstConfigRcPtr srcConfig, const char *srcColorSpaceName, const char *builtinColorSpaceName)¶

Get a Processor to or from a known external color space.

These methods provide a way to interface color spaces in a config with known standard external color spaces. The set of external color space are those contained in the current default Built-in config. This includes common spaces such as “Linear Rec.709 (sRGB)”, “sRGB - Texture”, “ACEScg”, and “ACES2065-1”.

If the source config defines the necessary Interchange Role (typically “aces_interchange”), then the conversion will be well-defined and equivalent to calling GetProcessorFromConfigs with the source config and the Built-in config.

However, if the Interchange Roles are not present, heuristics will be used to try and identify a common color space in the source config that may be used to allow the conversion to proceed. If the heuristics fail to find a suitable space, an exception is thrown. The heuristics may evolve, so the results returned by this function for a given source config and color space may change in future releases of the library. However, the Interchange Roles are required in config versions 2.2 and higher, so it is hoped that the need for the heuristics will decrease over time.

Parameters:

srcConfig – The user’s source config.
srcColorSpaceName – The name of the color space in the source config.
builtinColorSpaceName – The name of the color space in the current default Built-in config.

Throws:

Exception – if either the src or builtin interchange space cannot be identified.

static ConstProcessorRcPtr GetProcessorFromBuiltinColorSpace(const char *builtinColorSpaceName, ConstConfigRcPtr srcConfig, const char *srcColorSpaceName)¶

See description of GetProcessorToBuiltinColorSpace.

Parameters:

builtinColorSpaceName – The name of the color space in the current default Built-in config.
srcConfig – The user’s source config.
srcColorSpaceName – The name of the color space in the source config.

static ConstProcessorRcPtr GetProcessorFromConfigs(const ConstConfigRcPtr &srcConfig, const char *srcColorSpaceName, const ConstConfigRcPtr &dstConfig, const char *dstColorSpaceName)¶

Get a processor to convert between color spaces in two separate configs.

This relies on both configs having the aces_interchange role (when srcName is scene-referred) or the role cie_xyz_d65_interchange (when srcName is display-referred) defined. An exception is thrown if that is not the case.

static ConstProcessorRcPtr GetProcessorFromConfigs(const ConstContextRcPtr &srcContext, const ConstConfigRcPtr &srcConfig, const char *srcColorSpaceName, const ConstContextRcPtr &dstContext, const ConstConfigRcPtr &dstConfig, const char *dstColorSpaceName)¶

static ConstProcessorRcPtr GetProcessorFromConfigs(const ConstConfigRcPtr &srcConfig, const char *srcColorSpaceName, const char *srcInterchangeName, const ConstConfigRcPtr &dstConfig, const char *dstColorSpaceName, const char *dstInterchangeName)¶

The srcInterchangeName and dstInterchangeName must refer to a pair of color spaces in the two configs that are the same. A role name may also be used.

Note: For all of the two-config GetProcessor functions, if either the source or destination color spaces are data spaces, the entire processor will be a no-op.

static ConstProcessorRcPtr GetProcessorFromConfigs(const ConstContextRcPtr &srcContext, const ConstConfigRcPtr &srcConfig, const char *srcColorSpaceName, const char *srcInterchangeName, const ConstContextRcPtr &dstContext, const ConstConfigRcPtr &dstConfig, const char *dstColorSpaceName, const char *dstInterchangeName)¶

static ConstProcessorRcPtr GetProcessorFromConfigs(const ConstConfigRcPtr &srcConfig, const char *srcColorSpaceName, const ConstConfigRcPtr &dstConfig, const char *dstDisplay, const char *dstView, TransformDirection direction)¶: Get a processor to convert from a color space to a display and view in two separate configs.

static ConstProcessorRcPtr GetProcessorFromConfigs(const ConstContextRcPtr &srcContext, const ConstConfigRcPtr &srcConfig, const char *srcColorSpaceName, const ConstContextRcPtr &dstContext, const ConstConfigRcPtr &dstConfig, const char *dstDisplay, const char *dstView, TransformDirection direction)¶

static ConstProcessorRcPtr GetProcessorFromConfigs(const ConstConfigRcPtr &srcConfig, const char *srcColorSpaceName, const char *srcInterchangeName, const ConstConfigRcPtr &dstConfig, const char *dstDisplay, const char *dstView, const char *dstInterchangeName, TransformDirection direction)¶: The srcInterchangeName and dstInterchangeName must refer to a pair of color spaces in the two configs that are the same. A role name may also be used.

static ConstProcessorRcPtr GetProcessorFromConfigs(const ConstContextRcPtr &srcContext, const ConstConfigRcPtr &srcConfig, const char *srcColorSpaceName, const char *srcInterchangeName, const ConstContextRcPtr &dstContext, const ConstConfigRcPtr &dstConfig, const char *dstDisplay, const char *dstView, const char *dstInterchangeName, TransformDirection direction)¶

std::ostream &OpenColorIO_v2_7dev::operator<<(std::ostream&, const Config&)¶

typedef std::shared_ptr<const Config> OpenColorIO_v2_7dev::ConstConfigRcPtr¶

typedef std::shared_ptr<Config> OpenColorIO_v2_7dev::ConfigRcPtr¶

Constants: Roles, Shared View