Transforms

Caution

API Docs are a work in progress, expect them to improve over time.

FormatMetadata

class FormatMetadata

The FormatMetadata class is intended to be a generic container to hold metadata from various file formats.

This class provides a hierarchical metadata container. A metadata object is similar to an element in XML. It contains:

  • A name string (e.g. “Description”).

  • A value string (e.g. “updated viewing LUT”).

  • A list of attributes (name, value) string pairs (e.g. “version”, “1.5”).

  • And a list of child sub-elements, which are also objects implementing FormatMetadata.

C++

Python

const char *getName() const = 0
void setName(const char*) = 0
const char *getValue() const = 0
void setValue(const char*) = 0
int getNumAttributes() const = 0
const char *getAttributeName(int i) const = 0
const char *getAttributeValue(int i) const = 0
void addAttribute(const char *name, const char *value) = 0

Add an attribute with a given name and value. If an attribute with the same name already exists, the value is replaced.

int getNumChildrenElements() const = 0
const FormatMetadata &getChildElement(int i) const = 0
FormatMetadata &getChildElement(int i) = 0
FormatMetadata &addChildElement(const char *name, const char *value) = 0

Add a child element with a given name and value. Name has to be non-empty. Value may be empty, particularly if this element will have children. Return a reference to the added element.

void clear() = 0
FormatMetadata &operator=(const FormatMetadata &rhs) = 0
FormatMetadata(const FormatMetadata &rhs) = delete
~FormatMetadata()
class AttributeIterator
class AttributeNameIterator
class ChildElementIterator
class ConstChildElementIterator
addChildElement(self: PyOpenColorIO.FormatMetadata, name: str, value: str) → `PyOpenColorIO.FormatMetadata`_
clear(self: PyOpenColorIO.FormatMetadata) → None
getAttributes(self: PyOpenColorIO.FormatMetadata) → OpenColorIO_v2_0dev::PyIterator<OpenColorIO_v2_0dev::FormatMetadata const&, 1>
getChildElements(*args, **kwargs)

Overloaded function.

  1. getChildElements(self: PyOpenColorIO.FormatMetadata) → OpenColorIO_v2_0dev::PyIterator<OpenColorIO_v2_0dev::FormatMetadata const&, 2>
  2. getChildElements(self: PyOpenColorIO.FormatMetadata) → OpenColorIO_v2_0dev::PyIterator<OpenColorIO_v2_0dev::FormatMetadata&, 3>
getName(self: PyOpenColorIO.FormatMetadata) → str
getValue(self: PyOpenColorIO.FormatMetadata) → str
setName(self: PyOpenColorIO.FormatMetadata, name: str) → None
setValue(self: PyOpenColorIO.FormatMetadata, value: str) → None

Transform

class Transform

Base class for all the transform classes.

Subclassed by OpenColorIO::AllocationTransform, OpenColorIO::BuiltinTransform, OpenColorIO::CDLTransform, OpenColorIO::ColorSpaceTransform, OpenColorIO::DisplayViewTransform, OpenColorIO::ExponentTransform, OpenColorIO::ExponentWithLinearTransform, OpenColorIO::ExposureContrastTransform, OpenColorIO::FileTransform, OpenColorIO::FixedFunctionTransform, OpenColorIO::GroupTransform, OpenColorIO::LogAffineTransform, OpenColorIO::LogCameraTransform, OpenColorIO::LogTransform, OpenColorIO::LookTransform, OpenColorIO::Lut1DTransform, OpenColorIO::Lut3DTransform, OpenColorIO::MatrixTransform, OpenColorIO::RangeTransform

C++

C++

Python

TransformRcPtr createEditableCopy() const = 0
TransformDirection getDirection() const noexcept = 0
void setDirection(TransformDirection dir) noexcept = 0

Note that this only affects the evaluation and not the values stored in the object.

void validate() const

Will throw if data is not valid.

Transform(const Transform&) = delete
Transform &operator=(const Transform&) = delete
~Transform() = default
getDirection(self: PyOpenColorIO.Transform) → PyOpenColorIO.TransformDirection
setDirection(self: PyOpenColorIO.Transform, direction: PyOpenColorIO.TransformDirection) → None
validate(self: PyOpenColorIO.Transform) → None

AllocationTransform

class AllocationTransform : public OpenColorIO::Transform

Forward direction wraps the ‘expanded’ range into the specified, often compressed, range.

C++

Python

TransformRcPtr createEditableCopy() const override
TransformDirection getDirection() const noexcept override
void setDirection(TransformDirection dir) noexcept override

Note that this only affects the evaluation and not the values stored in the object.

void validate() const override

Will throw if data is not valid.

Allocation getAllocation() const
void setAllocation(Allocation allocation)
int getNumVars() const
void getVars(float *vars) const
void setVars(int numvars, const float *vars)
`AllocationTransform`_ &operator=(const AllocationTransform&) = delete
~AllocationTransform()

-[ Public Static Functions ]-

AllocationTransformRcPtr Create()
getAllocation(self: PyOpenColorIO.AllocationTransform) → PyOpenColorIO.Allocation
getVars(self: PyOpenColorIO.AllocationTransform) → List[float]
setAllocation(self: PyOpenColorIO.AllocationTransform, allocation: PyOpenColorIO.Allocation) → None
setVars(self: PyOpenColorIO.AllocationTransform, vars: List[float]) → None

BuiltinTransform

class BuiltinTransform : public OpenColorIO::Transform

A built-in transform is similar to a FileTransform, but without the file. OCIO knows how to build a set of commonly used transforms on-demand, thus avoiding the need for external files and simplifying config authoring.

C++

Python

const char *getStyle() const noexcept = 0
void setStyle(const char *style) = 0

Select an existing built-in transform style from the list accessible through :cpp:class:BuiltinTransformRegistry. The style is the ID string that identifies which transform to apply.

const char *getDescription() const noexcept = 0
~BuiltinTransform() = default

-[ Public Static Functions ]-

BuiltinTransformRcPtr Create()
getDescription(self: PyOpenColorIO.BuiltinTransform) → str
getStyle(self: PyOpenColorIO.BuiltinTransform) → str
setStyle(self: PyOpenColorIO.BuiltinTransform, style: str) → None

CDLTransform

class CDLTransform : public OpenColorIO::Transform

An implementation of the ASC Color Decision List (CDL), based on the ASC v1.2 specification.

Note ​ If the config version is 1, negative values are clamped if the power is not 1.0. For config version 2 and higher, the negative handling is controlled by the CDL style.

C++

Python

FormatMetadata &getFormatMetadata() noexcept = 0
const FormatMetadata &getFormatMetadata() const noexcept = 0
bool equals(const CDLTransform &other) const noexcept = 0
CDLStyle getStyle() const = 0
void setStyle(CDLStyle style) = 0

Use CDL_ASC to clamp values to [0,1] per the ASC spec. Use NO_CLAMP to never clamp values (regardless of whether power is 1.0). The NO_CLAMP option passes negatives through unchanged (like the NEGATIVE_PASS_THRU style of ExponentTransform). The default style is CDL_NO_CLAMP.

const char *getXML() const = 0
void setXML(const char *xml) = 0

The default style is CDL_NO_CLAMP.

void getSlope(double *rgb) const = 0
void setSlope(const double *rgb) = 0
void getOffset(double *rgb) const = 0
void setOffset(const double *rgb) = 0
void getPower(double *rgb) const = 0
void setPower(const double *rgb) = 0
void getSOP(double *vec9) const = 0
void setSOP(const double *vec9) = 0
double getSat() const = 0
void setSat(double sat) = 0
void getSatLumaCoefs(double *rgb) const = 0

These are hard-coded, by spec, to r709.

const char *getID() const = 0

Unique Identifier for this correction.

void setID(const char *id) = 0
const char *getDescription() const = 0

Deprecated. Use getFormatMetadata. First textual description of color correction (stored on the SOP). If there is already a description, the setter will replace it with the supplied text.

void setDescription(const char *desc) = 0

Deprecated. Use getFormatMetadata.

CDLTransform(const CDLTransform&) = delete
`CDLTransform`_ &operator=(const CDLTransform&) = delete
~CDLTransform() = default

-[ Public Static Functions ]-

CDLTransformRcPtr Create()
CDLTransformRcPtr CreateFromFile(const char *src, const char

*cccid)

Load the CDL from the src .cc or .ccc file. If a .ccc is used, the cccid must also be specified src must be an absolute path reference, no relative directory or envvar resolution is performed.

static CreateFromFile(src: str, id: str) -> `PyOpenColorIO.CDLTransform`_
equals(self: PyOpenColorIO.CDLTransform, other: PyOpenColorIO.CDLTransform) → bool
getDescription(self: PyOpenColorIO.CDLTransform) → str
getFormatMetadata(*args, **kwargs)

Overloaded function.

  1. ..py:method:: getFormatMetadata(self: PyOpenColorIO.CDLTransform) -> PyOpenColorIO.FormatMetadata

  2. ..py:method:: getFormatMetadata(self: PyOpenColorIO.CDLTransform) -> PyOpenColorIO.FormatMetadata

getID(self: PyOpenColorIO.CDLTransform) → str
getOffset(self: PyOpenColorIO.CDLTransform) → List[float[3]]
getPower(self: PyOpenColorIO.CDLTransform) → List[float[3]]
getSOP(self: PyOpenColorIO.CDLTransform) → List[float[9]]
getSat(self: PyOpenColorIO.CDLTransform) → float
getSatLumaCoefs(self: PyOpenColorIO.CDLTransform) → List[float[3]]
getSlope(self: PyOpenColorIO.CDLTransform) → List[float[3]]
getStyle(self: PyOpenColorIO.CDLTransform) → PyOpenColorIO.CDLStyle
getXML(self: PyOpenColorIO.CDLTransform) → str
setDescription(self: PyOpenColorIO.CDLTransform, description: str) → None
setID(self: PyOpenColorIO.CDLTransform, id: str) → None
setOffset(self: PyOpenColorIO.CDLTransform, rgb: List[float[3]]) → None
setPower(self: PyOpenColorIO.CDLTransform, rgb: List[float[3]]) → None
setSOP(self: PyOpenColorIO.CDLTransform, vec9: List[float[9]]) → None
setSat(self: PyOpenColorIO.CDLTransform, sat: float) → None
setSlope(self: PyOpenColorIO.CDLTransform, rgb: List[float[3]]) → None
setStyle(*args, **kwargs)

Overloaded function.

  1. ..py:method:: setStyle(self: PyOpenColorIO.CDLTransform, style: PyOpenColorIO.CDLStyle) -> None

  2. ..py:method:: setStyle(self: PyOpenColorIO.CDLTransform, style: PyOpenColorIO.CDLStyle) -> None

setXML(self: PyOpenColorIO.CDLTransform, xml: str) → None

ColorSpaceTransform

class ColorSpaceTransform : public OpenColorIO::Transform

C++

Python

TransformRcPtr createEditableCopy() const override
TransformDirection getDirection() const noexcept override
void setDirection(TransformDirection dir) noexcept override

Note that this only affects the evaluation and not the values stored in the object.

void validate() const override

Will throw if data is not valid.

const char *getSrc() const
void setSrc(const char *src)
const char *getDst() const
void setDst(const char *dst)
bool getDataBypass() const noexcept

Data color spaces do not get processed when true (which is the default).

void setDataBypass(bool enabled) noexcept
`ColorSpaceTransform`_ &operator=(const ColorSpaceTransform&) = delete
~ColorSpaceTransform()

-[ Public Static Functions ]-

ColorSpaceTransformRcPtr Create()
getDataBypass(self: PyOpenColorIO.ColorSpaceTransform) → bool
getDst(self: PyOpenColorIO.ColorSpaceTransform) → str
getSrc(self: PyOpenColorIO.ColorSpaceTransform) → str
setDataBypass(self: PyOpenColorIO.ColorSpaceTransform, dataBypass: bool) → None
setDst(self: PyOpenColorIO.ColorSpaceTransform, dst: str) → None
setSrc(self: PyOpenColorIO.ColorSpaceTransform, src: str) → None

DisplayViewTransform

class DisplayViewTransform : public OpenColorIO::Transform

C++

Python

TransformRcPtr createEditableCopy() const override
TransformDirection getDirection() const noexcept override
void setDirection(TransformDirection dir) noexcept override

Note that this only affects the evaluation and not the values stored in the object.

void validate() const override

Will throw if data is not valid.

const char *getSrc() const
void setSrc(const char *name)

Specify the incoming color space.

const char *getDisplay() const
void setDisplay(const char *display)

Specify which display to use.

const char *getView() const
void setView(const char *view)

Specify which view transform to use.

bool getLooksBypass() const
void setLooksBypass(bool bypass)

Looks will be bypassed when true (the default is false).

bool getDataBypass() const noexcept
void setDataBypass(bool bypass) noexcept

Data color spaces do not get processed when true (which is the default).

~DisplayViewTransform()

-[ Public Static Functions ]-

DisplayViewTransformRcPtr Create()
getDataBypass(self: PyOpenColorIO.DisplayViewTransform) → bool
getDisplay(self: PyOpenColorIO.DisplayViewTransform) → str
getLooksBypass(self: PyOpenColorIO.DisplayViewTransform) → bool
getSrc(self: PyOpenColorIO.DisplayViewTransform) → str
getView(self: PyOpenColorIO.DisplayViewTransform) → str
setDataBypass(self: PyOpenColorIO.DisplayViewTransform, dataBypass: bool) → None
setDisplay(self: PyOpenColorIO.DisplayViewTransform, display: str) → None
setLooksBypass(self: PyOpenColorIO.DisplayViewTransform, looksBypass: bool) → None
setSrc(self: PyOpenColorIO.DisplayViewTransform, src: str) → None
setView(self: PyOpenColorIO.DisplayViewTransform, view: str) → None

DynamicProperty

class DynamicProperty

Allows transform parameter values to be set on-the-fly (after finalization). For example, to modify the exposure in a viewport.

C++

Python

DynamicPropertyType getType() const = 0
DynamicPropertyValueType getValueType() const = 0
double getDoubleValue() const = 0
void setValue(double value) = 0
bool isDynamic() const = 0
`DynamicProperty`_ &operator=(const DynamicProperty&) = delete
~DynamicProperty()
getDoubleValue(self: PyOpenColorIO.DynamicProperty) → float
getType(self: PyOpenColorIO.DynamicProperty) → PyOpenColorIO.DynamicPropertyType
getValueType(self: PyOpenColorIO.DynamicProperty) → PyOpenColorIO.DynamicPropertyValueType
isDynamic(self: PyOpenColorIO.DynamicProperty) → bool
setValue(self: PyOpenColorIO.DynamicProperty, value: float) → None

ExponentTransform

class ExponentTransform : public OpenColorIO::Transform

Represents exponent transform: pow( clamp(color), value ).

​.. note:: For configs with version == 1: Negative style is ignored and if the exponent is 1.0, this will not clamp. Otherwise, the input color will be clamped between [0.0, inf]. For configs with version > 1: Negative value handling may be specified via setNegativeStyle.

C++

Python

const FormatMetadata &getFormatMetadata() const noexcept = 0
FormatMetadata &getFormatMetadata() noexcept = 0
bool equals(const ExponentTransform &other) const noexcept = 0

Checks if this exactly equals other.

void getValue(double (&vec4)[4]) const noexcept = 0
void setValue(const double (&vec4)[4]) noexcept = 0
NegativeStyle getNegativeStyle() const = 0

Specifies how negative values are handled. Legal values:

  • NEGATIVE_CLAMP Clamp negative values (default).

  • NEGATIVE_MIRROR Positive curve is rotated 180 degrees around

the origin to handle negatives.

  • NEGATIVE_PASS_THRU Negative values are passed through

unchanged.

void setNegativeStyle(NegativeStyle style) = 0
ExponentTransform(const ExponentTransform&) = delete
`ExponentTransform`_ &operator=(const ExponentTransform&) = delete
~ExponentTransform() = default

-[ Public Static Functions ]-

ExponentTransformRcPtr Create()
equals(self: PyOpenColorIO.ExponentTransform, other: PyOpenColorIO.ExponentTransform) → bool
getFormatMetadata(*args, **kwargs)

Overloaded function.

  1. getFormatMetadata(self: PyOpenColorIO.ExponentTransform) → PyOpenColorIO.FormatMetadata
  2. getFormatMetadata(self: PyOpenColorIO.ExponentTransform) → PyOpenColorIO.FormatMetadata
getNegativeStyle(self: PyOpenColorIO.ExponentTransform) → PyOpenColorIO.NegativeStyle
getValue(self: PyOpenColorIO.ExponentTransform) → List[float[4]]
setNegativeStyle(self: PyOpenColorIO.ExponentTransform, style: PyOpenColorIO.NegativeStyle) → None
setValue(self: PyOpenColorIO.ExponentTransform, value: List[float[4]]) → None

ExponentWithLinearTransform

**class ExponentWithLinearTransform : public OpenColorIO::Transform **

Represents power functions with a linear section in the shadows such as sRGB and L*.

The basic formula is:

pow( (x + offset)/(1 + offset), gamma ) with the breakpoint at offset/(gamma - 1).

Negative values are never clamped.

C++

C++

Python

const FormatMetadata &getFormatMetadata() const noexcept = 0
FormatMetadata &getFormatMetadata() noexcept = 0
bool equals(const ExponentWithLinearTransform &other) const noexcept = 0**

Checks if this exactly equals other.

void getGamma(double (&values)[4]) const noexcept = 0
void setGamma(const double (&values)[4]) noexcept = 0

Set the exponent value for the power function for R, G, B, A.

Note The gamma values must be in the range of [1, 10]. Set the transform direction to inverse to obtain the effect of values less than 1.

void getOffset(double (&values)[4]) const noexcept = 0
void setOffset(const double (&values)[4]) noexcept = 0

Set the offset value for the power function for R, G, B, A.

Note The offset values must be in the range [0, 0.9].

NegativeStyle getNegativeStyle() const = 0

Specifies how negative values are handled. Legal values:

  • NEGATIVE_LINEAR Linear segment continues into negatives

(default).

  • NEGATIVE_MIRROR Positive curve is rotated 180 degrees around

the origin to handle negatives.

void setNegativeStyle(NegativeStyle style) = 0
ExponentWithLinearTransform(const ExponentWithLinearTransform&) = delete
`ExponentWithLinearTransform`_ &operator=(const ExponentWithLinearTransform&) = delete
~ExponentWithLinearTransform() = default

-[ Public Static Functions ]-

ExponentWithLinearTransformRcPtr Create()
equals(self: PyOpenColorIO.ExponentWithLinearTransform, other: PyOpenColorIO.ExponentWithLinearTransform) → bool
getFormatMetadata(*args, **kwargs)

Overloaded function.

  1. getFormatMetadata(self: PyOpenColorIO.ExponentWithLinearTransform) → PyOpenColorIO.FormatMetadata
  2. getFormatMetadata(self: PyOpenColorIO.ExponentWithLinearTransform) → PyOpenColorIO.FormatMetadata
getGamma(self: PyOpenColorIO.ExponentWithLinearTransform) → List[float[4]]
getNegativeStyle(self: PyOpenColorIO.ExponentWithLinearTransform) → PyOpenColorIO.NegativeStyle
getOffset(self: PyOpenColorIO.ExponentWithLinearTransform) → List[float[4]]
setGamma(self: PyOpenColorIO.ExponentWithLinearTransform, values: List[float[4]]) → None
setNegativeStyle(self: PyOpenColorIO.ExponentWithLinearTransform, style: PyOpenColorIO.NegativeStyle) → None
setOffset(self: PyOpenColorIO.ExponentWithLinearTransform, values: List[float[4]]) → None

ExposureContrastTransform

**class ExposureContrastTransform : public OpenColorIO::Transform **

Applies exposure, gamma, and pivoted contrast adjustments. Adjusts the math to be appropriate for linear, logarithmic, or video color spaces.

C++

C++

Python

const FormatMetadata &getFormatMetadata() const noexcept = 0
FormatMetadata &getFormatMetadata() noexcept = 0**
bool equals(const ExposureContrastTransform &other) const noexcept = 0**

Checks if this exactly equals other.

ExposureContrastStyle getStyle() const = 0
void setStyle(ExposureContrastStyle style) = 0

Select the algorithm for linear, video or log color spaces.

double getExposure() const = 0
void setExposure(double exposure) = 0

Applies an exposure adjustment. The value is in units of stops (regardless of style), for example, a value of -1 would be equivalent to reducing the lighting by one half.

bool isExposureDynamic() const = 0
void makeExposureDynamic() = 0
double getContrast() const = 0
void setContrast(double contrast) = 0

Applies a contrast/gamma adjustment around a pivot point. The contrast and gamma are mathematically the same, but two controls are provided to enable the use of separate dynamic parameters. Contrast is usually a scene-referred adjustment that pivots around gray whereas gamma is usually a display-referred adjustment that pivots around white.

bool isContrastDynamic() const = 0
void makeContrastDynamic() = 0
double getGamma() const = 0
void setGamma(double gamma) = 0
bool isGammaDynamic() const = 0
void makeGammaDynamic() = 0
double getPivot() const = 0
void setPivot(double pivot) = 0

Set the pivot point around which the contrast and gamma controls will work. Regardless of whether linear/video/log-style is being used, the pivot is always expressed in linear. In other words, a pivot of 0.18 is always mid-gray.

double getLogExposureStep() const = 0
void setLogExposureStep(double logExposureStep) = 0

Set the increment needed to move one stop for the log-style algorithm. For example, ACEScct is 0.057, LogC is roughly 0.074, and Cineon is roughly 90/1023 = 0.088. The default value is 0.088.

double getLogMidGray() const = 0
void setLogMidGray(double logMidGray) = 0

Set the position of 18% gray for use by the log-style algorithm. For example, ACEScct is about 0.41, LogC is about 0.39, and ADX10 is 445/1023 = 0.435. The default value is 0.435.

~ExposureContrastTransform() = default
ExposureContrastTransformRcPtr Create()
equals(self: PyOpenColorIO.ExposureContrastTransform, other: PyOpenColorIO.ExposureContrastTransform) → bool
getContrast(self: PyOpenColorIO.ExposureContrastTransform) → float
getExposure(self: PyOpenColorIO.ExposureContrastTransform) → float
getFormatMetadata(*args, **kwargs)

Overloaded function.

  1. getFormatMetadata(self: PyOpenColorIO.ExposureContrastTransform) → PyOpenColorIO.FormatMetadata
  2. getFormatMetadata(self: PyOpenColorIO.ExposureContrastTransform) → PyOpenColorIO.FormatMetadata
getGamma(self: PyOpenColorIO.ExposureContrastTransform) → float
getLogExposureStep(self: PyOpenColorIO.ExposureContrastTransform) → float
getLogMidGray(self: PyOpenColorIO.ExposureContrastTransform) → float
getPivot(self: PyOpenColorIO.ExposureContrastTransform) → float
getStyle(self: PyOpenColorIO.ExposureContrastTransform) → PyOpenColorIO.ExposureContrastStyle
isContrastDynamic(self: PyOpenColorIO.ExposureContrastTransform) → bool
isExposureDynamic(self: PyOpenColorIO.ExposureContrastTransform) → bool
isGammaDynamic(self: PyOpenColorIO.ExposureContrastTransform) → bool
makeContrastDynamic(self: PyOpenColorIO.ExposureContrastTransform) → None
makeExposureDynamic(self: PyOpenColorIO.ExposureContrastTransform) → None
makeGammaDynamic(self: PyOpenColorIO.ExposureContrastTransform) → None
setContrast(self: PyOpenColorIO.ExposureContrastTransform, contrast: float) → None
setExposure(self: PyOpenColorIO.ExposureContrastTransform, exposure: float) → None
setGamma(self: PyOpenColorIO.ExposureContrastTransform, gamma: float) → None
setLogExposureStep(self: PyOpenColorIO.ExposureContrastTransform, logExposureStep: float) → None
setLogMidGray(self: PyOpenColorIO.ExposureContrastTransform, logMidGray: float) → None
setPivot(self: PyOpenColorIO.ExposureContrastTransform, pivot: float) → None
setStyle(self: PyOpenColorIO.ExposureContrastTransform, style: PyOpenColorIO.ExposureContrastStyle) → None

FileTransform

class FileTransform : public OpenColorIO::Transform

C++

Python

TransformRcPtr createEditableCopy() const override
TransformDirection getDirection() const noexcept override
void setDirection(TransformDirection dir) noexcept override

Note that this only affects the evaluation and not the values stored in the object.

void validate() const override

Will throw if data is not valid.

const char *getSrc() const
void setSrc(const char *src)
const char *getCCCId() const
void setCCCId(const char *id)
CDLStyle getCDLStyle() const
void setCDLStyle(CDLStyle)

Can be used with CDL, CC & CCC formats to specify the clamping behavior of the CDLTransform. Default is CDL_NO_CLAMP.

Interpolation getInterpolation() const
void setInterpolation(Interpolation interp)
`FileTransform`_ &operator=(const FileTransform&) = delete
~FileTransform()

-[ Public Static Functions ]-

FileTransformRcPtr Create()
int getNumFormats()

Get the number of LUT readers.

const char *getFormatNameByIndex(int index)

Get the LUT readers at index, return empty string if an invalid index is specified.

const char *getFormatExtensionByIndex(int index)

Get the LUT reader extension at index, return empty string if an invalid index is specified.

class FormatIterator
getCCCId(self: PyOpenColorIO.FileTransform) → str
getCDLStyle(self: PyOpenColorIO.FileTransform) → PyOpenColorIO.CDLStyle
getFormats() → OpenColorIO_v2_0dev::PyIterator<std::shared_ptr<OpenColorIO_v2_0dev::FileTransform>, 0>
getInterpolation(self: PyOpenColorIO.FileTransform) → PyOpenColorIO.Interpolation
getSrc(self: PyOpenColorIO.FileTransform) → str
setCCCId(self: PyOpenColorIO.FileTransform, cccId: str) → None
setCDLStyle(self: PyOpenColorIO.FileTransform, style: PyOpenColorIO.CDLStyle) → None
setInterpolation(self: PyOpenColorIO.FileTransform, interpolation: PyOpenColorIO.Interpolation) → None
setSrc(self: PyOpenColorIO.FileTransform, src: str) → None

FixedFunctionTransform

class FixedFunctionTransform : public OpenColorIO::Transform

Provides a set of hard-coded algorithmic building blocks that are needed to accurately implement various common color transformations.

C++

const FormatMetadata &getFormatMetadata() const noexcept = 0
FormatMetadata &getFormatMetadata() noexcept = 0
bool equals(const FixedFunctionTransform &other) const noexcept = 0

Checks if this exactly equals other.

FixedFunctionStyle getStyle() const = 0
void setStyle(FixedFunctionStyle style) = 0

Select which algorithm to use.

size_t getNumParams() const = 0
void getParams(double *params) const = 0
void setParams(const double *params, size_t num) = 0

Set the parameters (for functions that require them).

FixedFunctionTransform(const FixedFunctionTransform&) = delete
`FixedFunctionTransform`_ &operator=(const FixedFunctionTransform&) = delete
~FixedFunctionTransform() = default

-[ Public Static Functions ]-

FixedFunctionTransformRcPtr Create()

Python

equals(self: PyOpenColorIO.FixedFunctionTransform, other: PyOpenColorIO.FixedFunctionTransform) → bool
getFormatMetadata(*args, **kwargs)

Overloaded function.

  1. getFormatMetadata(self: PyOpenColorIO.FixedFunctionTransform) → PyOpenColorIO.FormatMetadata
  2. getFormatMetadata(self: PyOpenColorIO.FixedFunctionTransform) → PyOpenColorIO.FormatMetadata
getParams(self: PyOpenColorIO.FixedFunctionTransform) List[float]
getStyle(self: PyOpenColorIO.FixedFunctionTransform) PyOpenColorIO.FixedFunctionStyle
setParams(self: PyOpenColorIO.FixedFunctionTransform, para List[float]) → None
setStyle(self: PyOpenColorIO.FixedFunctionTransform, sty PyOpenColorIO.FixedFunctionStyle) → None

GroupTransform

**class GroupTransform : public OpenColorIO::Transform

C++

Python

TransformRcPtr createEditableCopy() const override
TransformDirection getDirection() const noexcept override
void setDirection(TransformDirection dir) noexcept override

Note that this only affects the evaluation and not the values stored in the object.

void validate() const override

Will throw if data is not valid.

const FormatMetadata &getFormatMetadata() const noexcept
FormatMetadata &getFormatMetadata() noexcept
ConstTransformRcPtr getTransform(int index) const
TransformRcPtr &getTransform(int index)
int getNumTransforms() const
void appendTransform(TransformRcPtr transform)

Adds a transform to the end of the group.

void prependTransform(TransformRcPtr transform)

Add a transform at the beginning of the group.

`GroupTransform`_ &operator=(const GroupTransform&) = delete
~GroupTransform()

-[ Public Static Functions ]-

GroupTransformRcPtr Create()
class TransformIterator
appendTransform(self: PyOpenColorIO.GroupTransform, transform: PyOpenColorIO.Transform) → None
getFormatMetadata(*args, **kwargs)

Overloaded function.

  1. getFormatMetadata(self: PyOpenColorIO.GroupTransform) → PyOpenColorIO.FormatMetadata
  2. getFormatMetadata(self: PyOpenColorIO.GroupTransform) → PyOpenColorIO.FormatMetadata
prependTransform(self: PyOpenColorIO.GroupTransform, transform: PyOpenColorIO.Transform) → None

LogAffineTransform

class LogAffineTransform : public OpenColorIO::Transform

Applies a logarithm with an affine transform before and after. Represents the Cineon lin-to-log type transforms:

logSideSlope * log( linSideSlope * color + linSideOffset, base) + logSideOffset

  • Default values are: 1. * log( 1. * color + 0., 2.) + 0.

  • The alpha channel is not affected.

C++

Python

const FormatMetadata &getFormatMetadata() const noexcept = 0
FormatMetadata &getFormatMetadata() noexcept = 0
bool equals(const LogAffineTransform &other) const noexcept = 0

Checks if this exactly equals other.

double getBase() const noexcept = 0
void setBase(double base) noexcept = 0
void getLogSideSlopeValue(double (&values)[3]) const noexcept = 0
void setLogSideSlopeValue(const double (&values)[3]) noexcept = 0
void getLogSideOffsetValue(double (&values)[3]) const noexcept = 0
void setLogSideOffsetValue(const double (&values)[3]) noexcept = 0
void getLinSideSlopeValue(double (&values)[3]) const noexcept = 0
void setLinSideSlopeValue(const double (&values)[3]) noexcept = 0
void getLinSideOffsetValue(double (&values)[3]) const noexcept = 0
void setLinSideOffsetValue(const double (&values)[3]) noexcept = 0
LogAffineTransform(const LogAffineTransform&) = delete
`LogAffineTransform`_ &operator=(const LogAffineTransform&) = delete
~LogAffineTransform() = default

-[ Public Static Functions ]-

LogAffineTransformRcPtr Create()
equals(self: PyOpenColorIO.LogAffineTransform, other: PyOpenColorIO.LogAffineTransform) → bool
getBase(self: PyOpenColorIO.LogAffineTransform) → float
getFormatMetadata(*args, **kwargs)

Overloaded function.

  1. getFormatMetadata(self: PyOpenColorIO.LogAffineTransform) → PyOpenColorIO.FormatMetadata
  2. getFormatMetadata(self: PyOpenColorIO.LogAffineTransform) → PyOpenColorIO.FormatMetadata
getLinSideOffsetValue(self: PyOpenColorIO.LogAffineTransform) → List[float[3]]
getLinSideSlopeValue(self: PyOpenColorIO.LogAffineTransform) → List[float[3]]
getLogSideOffsetValue(self: PyOpenColorIO.LogAffineTransform) → List[float[3]]
getLogSideSlopeValue(self: PyOpenColorIO.LogAffineTransform) → List[float[3]]
setBase(self: PyOpenColorIO.LogAffineTransform, base: float) → None
setLinSideOffsetValue(self: PyOpenColorIO.LogAffineTransform, values: List[float[3]]) → None
setLinSideSlopeValue(self: PyOpenColorIO.LogAffineTransform, values: List[float[3]]) → None
setLogSideOffsetValue(self: PyOpenColorIO.LogAffineTransform, values: List[float[3]]) → None
setLogSideSlopeValue(self: PyOpenColorIO.LogAffineTransform, values: List[float[3]]) → None

LogCameraTransform

class LogCameraTransform : public OpenColorIO::Transform

Same as :cpp:class:LogAffineTransform but with the addition of a linear segment near black. This formula is used for many camera logs (e.g., LogC) as well as ACEScct.

  • The linSideBreak specifies the point on the linear axis where

the log and linear segments meet. It must be set (there is no default).

  • The linearSlope specifies the slope of the linear segment of the

forward (linToLog) transform. By default it is set equal to the slope of the log curve at the break point.

C++

Python

const FormatMetadata &getFormatMetadata() const noexcept = 0
FormatMetadata &getFormatMetadata() noexcept = 0
bool equals(const LogCameraTransform &other) const noexcept = 0

Checks if this exactly equals other.

double getBase() const noexcept = 0
void setBase(double base) noexcept = 0
void getLogSideSlopeValue(double (&values)[3]) const noexcept = 0
void setLogSideSlopeValue(const double (&values)[3]) noexcept = 0
void getLogSideOffsetValue(double (&values)[3]) const noexcept = 0
void setLogSideOffsetValue(const double (&values)[3]) noexcept = 0
void getLinSideSlopeValue(double (&values)[3]) const noexcept = 0
void setLinSideSlopeValue(const double (&values)[3]) noexcept = 0
void getLinSideOffsetValue(double (&values)[3]) const noexcept = 0
void setLinSideOffsetValue(const double (&values)[3]) noexcept = 0
bool getLinSideBreakValue(double (&values)[3]) const noexcept = 0

Return true if LinSideBreak values were set, false if they were not.

void setLinSideBreakValue(const double (&values)[3]) noexcept = 0
bool getLinearSlopeValue(double (&values)[3]) const = 0

Return true if LinearSlope values were set, false if they were not.

void setLinearSlopeValue(const double (&values)[3]) = 0

Set LinearSlope value.

Note You must call setLinSideBreakValue before calling this.

void unsetLinearSlopeValue() = 0

Remove LinearSlope values so that default values are used.

LogCameraTransform(const LogCameraTransform&) = delete
`LogCameraTransform`_ &operator=(const LogCameraTransform&) = delete
~LogCameraTransform() = default

-[ Public Static Functions ]-

LogCameraTransformRcPtr Create()
equals(self: PyOpenColorIO.LogCameraTransform, other:

PyOpenColorIO.LogCameraTransform) -> bool

getBase(self: PyOpenColorIO.LogCameraTransform) → float
getFormatMetadata(*args, **kwargs)

Overloaded function.

  1. getFormatMetadata(self: PyOpenColorIO.LogCameraTransform) → PyOpenColorIO.FormatMetadata
  2. getFormatMetadata(self: PyOpenColorIO.LogCameraTransform) → PyOpenColorIO.FormatMetadata
getLinSideBreakValue(self: PyOpenColorIO.LogCameraTransform) → List[float[3]]
getLinSideOffsetValue(self: PyOpenColorIO.LogCameraTransform) → List[float[3]]
getLinSideSlopeValue(self: PyOpenColorIO.LogCameraTransform) → List[float[3]]
getLinearSlopeValue(self: PyOpenColorIO.LogCameraTransform) → List[float[3]]
getLogSideOffsetValue(self: PyOpenColorIO.LogCameraTransform) → List[float[3]]
getLogSideSlopeValue(self: PyOpenColorIO.LogCameraTransform) → List[float[3]]
setBase(self: PyOpenColorIO.LogCameraTransform, base: float) → None
setLinSideBreakValue(self: PyOpenColorIO.LogCameraTransform, values: List[float[3]]) → None
setLinSideOffsetValue(self: PyOpenColorIO.LogCameraTransform, values: List[float[3]]) → None
setLinSideSlopeValue(self: PyOpenColorIO.LogCameraTransform, values: List[float[3]]) → None
setLinearSlopeValue(self: PyOpenColorIO.LogCameraTransform, values: List[float[3]]) → None
setLogSideOffsetValue(self: PyOpenColorIO.LogCameraTransform, values: List[float[3]]) → None
setLogSideSlopeValue(self: PyOpenColorIO.LogCameraTransform, values: List[float[3]]) → None
unsetLinearSlopeValue(self: PyOpenColorIO.LogCameraTransform) → None

LogTransform

class LogTransform : public OpenColorIO::Transform

Represents log transform: log(color, base)

  • The input will be clamped for negative numbers.

  • Default base is 2.0.

  • The alpha channel is not affected.

C++

Python

const FormatMetadata &getFormatMetadata() const noexcept = 0
FormatMetadata &getFormatMetadata() noexcept = 0
bool equals(const LogTransform &other) const noexcept = 0

Checks if this exactly equals other.

double getBase() const noexcept = 0
void setBase(double val) noexcept = 0
LogTransform(const LogTransform&) = delete
`LogTransform`_ &operator=(const LogTransform&) = delete
~LogTransform() = default

-[ Public Static Functions ]-

LogTransformRcPtr Create()
equals(self: PyOpenColorIO.LogTransform, other: PyOpenColorIO.LogTransform) → bool
getBase(self: PyOpenColorIO.LogTransform) → float
getFormatMetadata(*args, **kwargs)

Overloaded function.

  1. getFormatMetadata(self: PyOpenColorIO.LogTransform) → PyOpenColorIO.FormatMetadata
  2. getFormatMetadata(self: PyOpenColorIO.LogTransform) → PyOpenColorIO.FormatMetadata
setBase(self: PyOpenColorIO.LogTransform, base: float) → None

LookTransform

class LookTransform : public OpenColorIO::Transform

C++

Python

TransformRcPtr createEditableCopy() const override**
TransformDirection getDirection() const noexcept override**
void setDirection(TransformDirection dir) noexcept override**

Note that this only affects the evaluation and not the values stored in the object.

void validate() const override**

Will throw if data is not valid.

const char *getSrc() const**
void setSrc(const char *src)**
const char *getDst() const**
void setDst(const char *dst)**
const char *getLooks() const**
void setLooks(const char *looks)**

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

bool getSkipColorSpaceConversion() const**
void setSkipColorSpaceConversion(bool skip)**
`LookTransform`_ &operator=(const LookTransform&) = delete**
~LookTransform()**

Do not use (needed only for pybind11).

-[ Public Static Functions ]-

LookTransformRcPtr Create()**
const char *GetLooksResultColorSpace(const ConstConfigRcPtr &config, const ConstContextRcPtr &context, const char *looks)**

Return the name of the color space after applying looks in the forward direction but without converting to the destination color space. This is equivalent to the process space of the last look in the look sequence (and takes into account that a look fall-back may be used).

getDst(self: PyOpenColorIO.LookTransform) → str
getLooks(self: PyOpenColorIO.LookTransform) → str
getSkipColorSpaceConversion(self: PyOpenColorIO.LookTransform) → bool
getSrc(self: PyOpenColorIO.LookTransform) → str
setDst(self: PyOpenColorIO.LookTransform, dst: str) → None
setLooks(self: PyOpenColorIO.LookTransform, looks: str) → None
setSkipColorSpaceConversion(self: PyOpenColorIO.LookTransform, skipColorSpaceConversion: bool) → None
setSrc(self: PyOpenColorIO.LookTransform, src: str) → None

Lut1DTransform

class Lut1DTransform : public OpenColorIO::Transform

Represents a 1D-LUT transform.

C++

BitDepth getFileOutputBitDepth() const noexcept = 0
void setFileOutputBitDepth(BitDepth bitDepth) noexcept = 0

Get the bit-depth associated with the LUT values read from a file or set the bit-depth of values to be written to a file (for file formats such as CLF that support multiple bit-depths). However, note that the values stored in the object are always normalized.

const FormatMetadata &getFormatMetadata() const noexcept = 0
FormatMetadata &getFormatMetadata() noexcept = 0
bool equals(const Lut1DTransform &other) const noexcept = 0

Checks if this exactly equals other.

unsigned long getLength() const = 0
void setLength(unsigned long length) = 0

Changing the length will reset the LUT to identity. Will throw for lengths longer than 1024x1024.

void getValue(unsigned long index, float &r, float &g, float &b) const = 0
void setValue(unsigned long index, float r, float g, float b) = 0

Set the values of a LUT1D. Will throw if the index is outside of the range from 0 to (length-1).

The LUT values are always for the “forward” LUT, regardless of how the transform direction is set.

These values are normalized relative to what may be stored in any given LUT files. For example in a CLF file using a “10i” output depth, a value of 1023 in the file is normalized to 1.0. The values here are unclamped and may extend outside [0,1].

LUTs in various file formats may only provide values for one channel where R, G, B are the same. Even in that case, you should provide three equal values to the setter.

bool getInputHalfDomain() const noexcept = 0
void setInputHalfDomain(bool isHalfDomain) noexcept = 0

In a half-domain LUT, the contents of the LUT specify the desired value of the function for each half-float value. Therefore, the length of the LUT must be 65536 entries or else `validate()`_ will throw.

bool getOutputRawHalfs() const noexcept = 0
void setOutputRawHalfs(bool isRawHalfs) noexcept = 0

Set OutputRawHalfs to true if you want to output the LUT contents as 16-bit floating point values expressed as unsigned 16-bit integers representing the equivalent bit pattern. For example, the value 1.0 would be written as the integer 15360 because it has the same bit-pattern. Note that this implies the values will be quantized to a 16-bit float. Note that this setting only controls the output formatting (where supported) and not the values for getValue/setValue. The only file formats that currently support this are CLF and CTF.

Lut1DHueAdjust getHueAdjust() const noexcept = 0
void setHueAdjust(Lut1DHueAdjust algo) noexcept = 0

The 1D-LUT transform optionally supports a hue adjustment feature that was used in some versions of ACES. This adjusts the hue of the result to approximately match the input.

Interpolation getInterpolation() const = 0
void setInterpolation(Interpolation algo) = 0
Lut1DTransform(const Lut1DTransform&) = delete
`Lut1DTransform`_ &operator=(const Lut1DTransform&) = delete
~Lut1DTransform() = default

-[ Public Static Functions ]-

Lut1DTransformRcPtr Create()

Create an identity 1D-LUT of length two.

Lut1DTransformRcPtr Create(unsigned long length, bool isHalfDomain)

Create an identity 1D-LUT with specific length and half-domain setting. Will throw for lengths longer than 1024x1024.

Python

equals(self: PyOpenColorIO.Lut1DTransform, other: PyOpenColorIO.Lut1DTransform) → bool
getData(self: PyOpenColorIO.Lut1DTransform) → array
getFileOutputBitDepth(self: PyOpenColorIO.Lut1DTransform) → PyOpenColorIO.BitDepth
getFormatMetadata(*args, **kwargs)**

Overloaded function.

  1. getFormatMetadata(self: PyOpenColorIO.Lut1DTransform) → PyOpenColorIO.FormatMetadata
  2. getFormatMetadata(self: PyOpenColorIO.Lut1DTransform) → PyOpenColorIO.FormatMetadata
getHueAdjust(self: PyOpenColorIO.Lut1DTransform) → PyOpenColorIO.Lut1DHueAdjust
getInputHalfDomain(self: PyOpenColorIO.Lut1DTransform) → bool
getInterpolation(self: PyOpenColorIO.Lut1DTransform) → PyOpenColorIO.Interpolation
getLength(self: PyOpenColorIO.Lut1DTransform) → int
getOutputRawHalfs(self: PyOpenColorIO.Lut1DTransform) → bool
getValue(self: PyOpenColorIO.Lut1DTransform, index: int) → tuple
setData(self: PyOpenColorIO.Lut1DTransform, data: buffer) → None
setFileOutputBitDepth(self: PyOpenColorIO.Lut1DTransform, bitDepth: PyOpenColorIO.BitDepth) → None
setHueAdjust(self: PyOpenColorIO.Lut1DTransform, hueAdjust: PyOpenColorIO.Lut1DHueAdjust) → None
setInputHalfDomain(self: PyOpenColorIO.Lut1DTransform, isHalfDomain: bool) → None
setInterpolation(self: PyOpenColorIO.Lut1DTransform, interpolation: PyOpenColorIO.Interpolation) → None
setLength(self: PyOpenColorIO.Lut1DTransform, length: int) → None
setOutputRawHalfs(self: PyOpenColorIO.Lut1DTransform, isRawHalfs: bool) → None
setValue(self: PyOpenColorIO.Lut1DTransform, index: int, r: float, g: float, b: float) → None

Lut3DTransform

class Lut3DTransform : public OpenColorIO::Transform

Represents a 3D-LUT transform.

C++

Python

BitDepth getFileOutputBitDepth() const noexcept = 0
void setFileOutputBitDepth(BitDepth bitDepth) noexcept = 0

Get the bit-depth associated with the LUT values read from a file or set the bit-depth of values to be written to a file (for file formats such as CLF that support multiple bit-depths). However, note that the values stored in the object are always normalized.

const FormatMetadata &getFormatMetadata() const noexcept = 0
FormatMetadata &getFormatMetadata() noexcept = 0
bool equals(const Lut3DTransform &other) const noexcept = 0

Checks if this exactly equals other.

unsigned long getGridSize() const = 0
void setGridSize(unsigned long gridSize) = 0

Changing the grid size will reset the LUT to identity. Will throw for grid sizes larger than 129.

void getValue(unsigned long indexR, unsigned long indexG, unsigned long indexB, float &r, float &g, float &b) const = 0
void setValue(unsigned long indexR, unsigned long indexG, unsigned long indexB, float r, float g, float b) = 0

Set the values of a 3D-LUT. Will throw if an index is outside of the range from 0 to (gridSize-1).

The LUT values are always for the “forward” LUT, regardless of how the transform direction is set.

These values are normalized relative to what may be stored in any given LUT files. For example in a CLF file using a “10i” output depth, a value of 1023 in the file is normalized to 1.0. The values here are unclamped and may extend outside [0,1].

void setInterpolation(Interpolation algo) = 0
Lut3DTransform(const Lut3DTransform&) = delete
`Lut3DTransform`_ &operator=(const Lut3DTransform&) = delete
~Lut3DTransform() = default

-[ Public Static Functions ]-

Lut3DTransformRcPtr Create()

Create an identity 3D-LUT of size 2x2x2.

Lut3DTransformRcPtr Create(unsigned long gridSize)

Create an identity 3D-LUT with specific grid size. Will throw for grid size larger than 129.

equals(self: PyOpenColorIO.Lut3DTransform, other: PyOpenColorIO.Lut3DTransform) → bool
getData(self: PyOpenColorIO.Lut3DTransform) → array
getFileOutputBitDepth(self: PyOpenColorIO.Lut3DTransform) → PyOpenColorIO.BitDepth
getFormatMetadata(*args, **kwargs)

Overloaded function.

  1. getFormatMetadata(self: PyOpenColorIO.Lut3DTransform) → PyOpenColorIO.FormatMetadata
  2. getFormatMetadata(self: PyOpenColorIO.Lut3DTransform) → PyOpenColorIO.FormatMetadata
getGridSize(self: PyOpenColorIO.Lut3DTransform) → int
getInterpolation(self: PyOpenColorIO.Lut3DTransform) → PyOpenColorIO.Interpolation
getValue(self: PyOpenColorIO.Lut3DTransform, indexR: int, indexG: int, indexB: int) → tuple
setData(self: PyOpenColorIO.Lut3DTransform, data: buffer) → None
setFileOutputBitDepth(self: PyOpenColorIO.Lut3DTransform, bitDepth: PyOpenColorIO.BitDepth) → None
setGridSize(self: PyOpenColorIO.Lut3DTransform, gridSize: int) → None
setInterpolation(self: PyOpenColorIO.Lut3DTransform, interpolation: PyOpenColorIO.Interpolation) → None
setValue(self: PyOpenColorIO.Lut3DTransform, indexR: int, indexG: int, indexB: int, r: float, g: float, b: float) → None

MatrixTransform

class MatrixTransform : public OpenColorIO::Transform

Represents an MX+B Matrix transform.

Note For singular matrices, an inverse direction will throw an exception during finalization.

C++

Python

const FormatMetadata &getFormatMetadata() const noexcept = 0
FormatMetadata &getFormatMetadata() noexcept = 0
bool equals(const MatrixTransform &other) const noexcept = 0

Checks if this exactly equals other.

void getMatrix(double *m44) const = 0
void setMatrix(const double *m44) = 0

Get or set the values of a Matrix. Expects 16 values, where the first four are the coefficients to generate the R output channel from R, G, B, A input channels.

The Matrix values are always for the “forward” Matrix, regardless of how the transform direction is set.

These values are normalized relative to what may be stored in file formats such as CLF. For example in a CLF file using a “32f” input depth and “10i” output depth, a value of 1023 in the file is normalized to 1.0. The values here are unclamped and may extend outside [0,1].

void getOffset(double *offset4) const = 0
void setOffset(const double *offset4) = 0

Get or set the R, G, B, A offsets to be applied after the matrix.

These values are normalized relative to what may be stored in file formats such as CLF. For example, in a CLF file using a “10i” output depth, a value of 1023 in the file is normalized to 1.0. The values here are unclamped and may extend outside [0,1].

BitDepth getFileInputBitDepth() const noexcept = 0
void setFileInputBitDepth(BitDepth bitDepth) noexcept = 0
BitDepth getFileOutputBitDepth() const noexcept = 0
void setFileOutputBitDepth(BitDepth bitDepth) noexcept = 0
MatrixTransform(const MatrixTransform&) = delete
`MatrixTransform`_ &operator=(const MatrixTransform&) = delete
~MatrixTransform() = default

-[ Public Static Functions ]-

MatrixTransformRcPtr Create()
void Fit(double *m44, double *offset4, const double *oldmin4, const double *oldmax4, const double *newmin4, const double *newmax4)
void Identity(double *m44, double *offset4)
void Sat(double *m44, double *offset4, double sat, const double *lumaCoef3)
void Scale(double *m44, double *offset4, const double *scale4)
void View(double *m44, double *offset4, int *channelHot4, const double *lumaCoef3)
Fit(oldMin: List[float[4]] = [0.0, 0.0, 0.0, 0.0], oldMax: List[float[4]] = [1.0, 1.0, 1.0, 1.0], newMin: List[float[4]] = [0.0, 0.0, 0.0, 0.0], newMax: List[float[4]] = [1.0, 1.0, 1.0, 1.0]) → `PyOpenColorIO.MatrixTransform`_
Identity() → `PyOpenColorIO.MatrixTransform`_
Sat(sat: float, lumaCoef: List[float[3]]) → `PyOpenColorIO.MatrixTransform`_
Scale(scale: List[float[4]]) → `PyOpenColorIO.MatrixTransform`_
View(channelHot: List[int[4]], lumaCoef: List[float[3]]) → `PyOpenColorIO.MatrixTransform`_
equals(self: PyOpenColorIO.MatrixTransform, other: PyOpenColorIO.MatrixTransform) → bool
getFileInputBitDepth(self: PyOpenColorIO.MatrixTransform) → PyOpenColorIO.BitDepth
getFileOutputBitDepth(self: PyOpenColorIO.MatrixTransform) → PyOpenColorIO.BitDepth
getFormatMetadata(*args, **kwargs)

Overloaded function.

  1. getFormatMetadata(self: PyOpenColorIO.MatrixTransform) → PyOpenColorIO.FormatMetadata
  2. getFormatMetadata(self: PyOpenColorIO.MatrixTransform) → PyOpenColorIO.FormatMetadata
getMatrix(self: PyOpenColorIO.MatrixTransform) → List[float[16]]
getOffset(self: PyOpenColorIO.MatrixTransform) → List[float[4]]
setFileInputBitDepth(self: PyOpenColorIO.MatrixTransform, bitDepth: PyOpenColorIO.BitDepth) → None
setFileOutputBitDepth(self: PyOpenColorIO.MatrixTransform, bitDepth: PyOpenColorIO.BitDepth) → None
setMatrix(self: PyOpenColorIO.MatrixTransform, matrix: List[float[16]]) → None
setOffset(self: PyOpenColorIO.MatrixTransform, offset: List[float[4]]) → None

RangeTransform

class RangeTransform : public OpenColorIO::Transform

Represents a range transform

The Range is used to apply an affine transform (scale & offset) and clamps values to min/max bounds on all color components except the alpha. The scale and offset values are computed from the input and output bounds.

Refer to section 7.2.4 in specification S-2014-006 “A Common File Format

for Look-Up Tables” from the Academy of Motion Picture Arts and Sciences and the American Society of Cinematographers.

The “noClamp” style described in the specification S-2014-006 becomes a MatrixOp at the processor level.

C++

Python

RangeStyle getStyle() const noexcept = 0
void setStyle(RangeStyle style) noexcept = 0

Set the Range style to clamp or not input values.

const FormatMetadata &getFormatMetadata() const noexcept = 0
FormatMetadata &getFormatMetadata() noexcept = 0
bool equals(const RangeTransform &other) const noexcept = 0

Checks if this equals other.

BitDepth getFileInputBitDepth() const noexcept = 0
void setFileInputBitDepth(BitDepth bitDepth) noexcept = 0
BitDepth getFileOutputBitDepth() const noexcept = 0
void setFileOutputBitDepth(BitDepth bitDepth) noexcept = 0
double getMinInValue() const noexcept = 0

Get the minimum value for the input.

void setMinInValue(double val) noexcept = 0

Set the minimum value for the input.

bool hasMinInValue() const noexcept = 0

Is the minimum value for the input set?

void unsetMinInValue() noexcept = 0

Unset the minimum value for the input.

void setMaxInValue(double val) noexcept = 0

Set the maximum value for the input.

double getMaxInValue() const noexcept = 0

Get the maximum value for the input.

bool hasMaxInValue() const noexcept = 0

Is the maximum value for the input set?

void unsetMaxInValue() noexcept = 0

Unset the maximum value for the input.

void setMinOutValue(double val) noexcept = 0

Set the minimum value for the output.

double getMinOutValue() const noexcept = 0

Get the minimum value for the output.

bool hasMinOutValue() const noexcept = 0

Is the minimum value for the output set?

void unsetMinOutValue() noexcept = 0

Unset the minimum value for the output.

void setMaxOutValue(double val) noexcept = 0

Set the maximum value for the output.

double getMaxOutValue() const noexcept = 0

Get the maximum value for the output.

bool hasMaxOutValue() const noexcept = 0

Is the maximum value for the output set?

void unsetMaxOutValue() noexcept = 0

Unset the maximum value for the output.

RangeTransform(const RangeTransform&) = delete
`RangeTransform`_ &operator=(const RangeTransform&) = delete
~RangeTransform() = default

-[ Public Static Functions ]-

RangeTransformRcPtr Create()

Creates an instance of RangeTransform.

equals(self: PyOpenColorIO.RangeTransform, other: PyOpenColorIO.RangeTransform) → bool
getFileInputBitDepth(self: PyOpenColorIO.RangeTransform) → PyOpenColorIO.BitDepth
getFileOutputBitDepth(self: PyOpenColorIO.RangeTransform) → PyOpenColorIO.BitDepth
getFormatMetadata(*args, **kwargs)**

Overloaded function.

  1. getFormatMetadata(self: PyOpenColorIO.RangeTransform) → PyOpenColorIO.FormatMetadata
  2. getFormatMetadata(self: PyOpenColorIO.RangeTransform) → PyOpenColorIO.FormatMetadata
getMaxInValue(self: PyOpenColorIO.RangeTransform) → float
getMaxOutValue(self: PyOpenColorIO.RangeTransform) → float
getMinInValue(self: PyOpenColorIO.RangeTransform) → float
getMinOutValue(self: PyOpenColorIO.RangeTransform) → float
getStyle(self: PyOpenColorIO.RangeTransform) → PyOpenColorIO.RangeStyle
hasMaxInValue(self: PyOpenColorIO.RangeTransform) → bool
hasMaxOutValue(self: PyOpenColorIO.RangeTransform) → bool
hasMinInValue(self: PyOpenColorIO.RangeTransform) → bool
hasMinOutValue(self: PyOpenColorIO.RangeTransform) → bool
setFileInputBitDepth(self: PyOpenColorIO.RangeTransform, bitDepth: PyOpenColorIO.BitDepth) → None
setFileOutputBitDepth(self: PyOpenColorIO.RangeTransform, bitDepth: PyOpenColorIO.BitDepth) → None
setMaxInValue(self: PyOpenColorIO.RangeTransform, value: float) → None
setMaxOutValue(self: PyOpenColorIO.RangeTransform, value: float) → None
setMinInValue(self: PyOpenColorIO.RangeTransform, value: float) → None
setMinOutValue(self: PyOpenColorIO.RangeTransform, value: float) → None
setStyle(self: PyOpenColorIO.RangeTransform, style: PyOpenColorIO.RangeStyle) → None
unsetMaxOutValue(*args, **kwargs)

Overloaded function.

  1. unsetMaxOutValue(self: PyOpenColorIO.RangeTransform) → None
  2. unsetMaxOutValue(self: PyOpenColorIO.RangeTransform) → None
unsetMinInValue(self: PyOpenColorIO.RangeTransform) → None
unsetMinOutValue(self: PyOpenColorIO.RangeTransform) → None