Transforms¶

Transform¶

class PyOpenColorIO.Transform¶

Transform(*args, **kwargs)¶

getDirection() → PyOpenColorIO.PyOpenColorIO.TransformDirection¶

getTransformType() → PyOpenColorIO.PyOpenColorIO.TransformType¶

setDirection(direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) → None¶

validate() → None¶

AllocationTransform¶

class PyOpenColorIO.AllocationTransform¶

AllocationTransform(*args, **kwargs)¶

Overloaded function.

__init__(self: PyOpenColorIO.PyOpenColorIO.AllocationTransform) -> None
__init__(self: PyOpenColorIO.PyOpenColorIO.AllocationTransform, allocation: PyOpenColorIO.PyOpenColorIO.Allocation = <Allocation.ALLOCATION_UNIFORM: 1>, vars: collections.abc.Sequence[typing.SupportsFloat] = [], direction: PyOpenColorIO.PyOpenColorIO.TransformDirection = <TransformDirection.TRANSFORM_DIR_FORWARD: 0>) -> None

getAllocation() → PyOpenColorIO.PyOpenColorIO.Allocation¶

getDirection() → PyOpenColorIO.PyOpenColorIO.TransformDirection¶

getTransformType() → PyOpenColorIO.PyOpenColorIO.TransformType¶

getVars() → list[float]¶

setAllocation(allocation: PyOpenColorIO.PyOpenColorIO.Allocation) → None¶

setDirection(direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) → None¶

setVars(vars: collections.abc.Sequence[SupportsFloat]) → None¶

validate() → None¶

BuiltinTransform¶

class PyOpenColorIO.BuiltinTransform¶

BuiltinTransform(*args, **kwargs)¶

Overloaded function.

__init__(self: PyOpenColorIO.PyOpenColorIO.BuiltinTransform) -> None
__init__(self: PyOpenColorIO.PyOpenColorIO.BuiltinTransform, style: str = ‘IDENTITY’, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection = <TransformDirection.TRANSFORM_DIR_FORWARD: 0>) -> None

getDescription() → str¶

getDirection() → PyOpenColorIO.PyOpenColorIO.TransformDirection¶

getStyle() → str¶

getTransformType() → PyOpenColorIO.PyOpenColorIO.TransformType¶

setDirection(direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) → None¶

setStyle(style: str) → None¶

validate() → None¶

class BuiltinTransform : public 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.

Public Functions

inline virtual TransformType getTransformType() const noexcept override¶

virtual const char *getStyle() const noexcept = 0¶

virtual 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.

virtual const char *getDescription() const noexcept = 0¶

virtual ~BuiltinTransform() = default¶: Do not use (needed only for pybind11).

Public Static Functions

static BuiltinTransformRcPtr Create()¶

std::ostream &OpenColorIO_v2_6dev::operator<<(std::ostream&, const BuiltinTransform&) noexcept¶

typedef std::shared_ptr<const BuiltinTransform> OpenColorIO_v2_6dev::ConstBuiltinTransformRcPtr¶

typedef std::shared_ptr<BuiltinTransform> OpenColorIO_v2_6dev::BuiltinTransformRcPtr¶

BuiltinTransformRegistry¶

class PyOpenColorIO.BuiltinTransformRegistry¶

BuiltinTransformRegistry() → None¶

getBuiltins() → PyOpenColorIO.PyOpenColorIO.BuiltinTransformRegistry.BuiltinIterator¶

class PyOpenColorIO.BuiltinTransformRegistry.BuiltinStyleIterator¶

self[arg0: SupportsInt] → str¶

iter(self) → PyOpenColorIO.PyOpenColorIO.BuiltinTransformRegistry.BuiltinStyleIterator¶

len(self) → int¶

next(self) → str¶

class PyOpenColorIO.BuiltinTransformRegistry.BuiltinIterator¶

self[arg0: SupportsInt] → tuple¶

iter(self) → PyOpenColorIO.PyOpenColorIO.BuiltinTransformRegistry.BuiltinIterator¶

len(self) → int¶

next(self) → tuple¶

CDLTransform¶

class PyOpenColorIO.CDLTransform¶

static CreateFromFile(src: str, id: str) → PyOpenColorIO.PyOpenColorIO.CDLTransform¶

static CreateGroupFromFile(src: str) → PyOpenColorIO.PyOpenColorIO.GroupTransform¶

CDLTransform(*args, **kwargs)¶

Overloaded function.

__init__(self: PyOpenColorIO.PyOpenColorIO.CDLTransform) -> None
__init__(self: PyOpenColorIO.PyOpenColorIO.CDLTransform, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection = <TransformDirection.TRANSFORM_DIR_FORWARD: 0>) -> None
__init__(self: PyOpenColorIO.PyOpenColorIO.CDLTransform, slope: typing.Annotated[collections.abc.Sequence[typing.SupportsFloat], “FixedSize(3)”] = [1.0, 1.0, 1.0], offset: typing.Annotated[collections.abc.Sequence[typing.SupportsFloat], “FixedSize(3)”] = [0.0, 0.0, 0.0], power: typing.Annotated[collections.abc.Sequence[typing.SupportsFloat], “FixedSize(3)”] = [1.0, 1.0, 1.0], sat: typing.SupportsFloat = 1.0, id: str = ‘’, description: str = ‘’, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection = <TransformDirection.TRANSFORM_DIR_FORWARD: 0>) -> None

equals(other: PyOpenColorIO.PyOpenColorIO.CDLTransform) → bool¶

getDirection() → PyOpenColorIO.PyOpenColorIO.TransformDirection¶

getFirstSOPDescription() → str¶

getFormatMetadata() → PyOpenColorIO.PyOpenColorIO.FormatMetadata¶

getID() → str¶

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

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

getSOP() → Annotated[list[float], 'FixedSize(9)']¶

getSat() → float¶

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

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

getStyle() → PyOpenColorIO.PyOpenColorIO.CDLStyle¶

getTransformType() → PyOpenColorIO.PyOpenColorIO.TransformType¶

setDirection(direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) → None¶

setFirstSOPDescription(description: str) → None¶

setID(id: str) → None¶

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

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

setSOP(vec9: Annotated[collections.abc.Sequence[SupportsFloat], 'FixedSize(9)']) → None¶

setSat(sat: SupportsFloat) → None¶

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

setStyle(style: PyOpenColorIO.PyOpenColorIO.CDLStyle) → None¶

validate() → None¶

class CDLTransform : public Transform ¶

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

ASC_SOP

Slope, offset, power:: out = clamp( (in * slope) + offset ) ^ power

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.

Public Functions

inline virtual TransformType getTransformType() const noexcept override¶

virtual FormatMetadata &getFormatMetadata() noexcept = 0¶

virtual const FormatMetadata &getFormatMetadata() const noexcept = 0¶

virtual bool equals(const CDLTransform &other) const noexcept = 0¶

virtual CDLStyle getStyle() const = 0¶

virtual 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.

virtual void getSlope(double *rgb) const = 0¶

virtual void setSlope(const double *rgb) = 0¶

virtual void getOffset(double *rgb) const = 0¶

virtual void setOffset(const double *rgb) = 0¶

virtual void getPower(double *rgb) const = 0¶

virtual void setPower(const double *rgb) = 0¶

virtual void getSOP(double *vec9) const = 0¶

virtual void setSOP(const double *vec9) = 0¶

virtual double getSat() const = 0¶

virtual void setSat(double sat) = 0¶

virtual void getSatLumaCoefs(double *rgb) const = 0¶: These are hard-coded, by spec, to r709.

virtual const char *getID() const = 0¶: The get/setID methods are now deprecated. The preferred way of interacting with the ID is now via the transform’s formatMetadata.

virtual void setID(const char *id) = 0¶

virtual const char *getFirstSOPDescription() const = 0¶

virtual void setFirstSOPDescription(const char *description) = 0¶

CDLTransform(const CDLTransform&) = delete¶

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

virtual ~CDLTransform() = default¶: Do not use (needed only for pybind11).

Public Static Functions

static CDLTransformRcPtr Create()¶

static CDLTransformRcPtr CreateFromFile(const char *src, const char *cccid)¶: Load the CDL from the src .cdl, .cc, or .ccc file.

Note

The cccid can be the ID of a CDL or the index of the CDL (as string). If cccid is NULL or empty the first CDL is returned. The cccid is case-sensitive. The src must be an absolute path reference, no relative directory or envvar resolution is performed. Throws if file does not contain any CDL or if the specified cccid is not found.

static GroupTransformRcPtr CreateGroupFromFile(const char *src)¶: Load all of the CDLs in a .cdl or .ccc file into a single GroupTransform.

Note

This may be useful as a quicker way for applications to check the contents of each of the CDLs. The src must be an absolute path reference, no relative directory or envvar resolution is performed.

std::ostream &OpenColorIO_v2_6dev::operator<<(std::ostream&, const CDLTransform&)¶

typedef std::shared_ptr<const CDLTransform> OpenColorIO_v2_6dev::ConstCDLTransformRcPtr¶

typedef std::shared_ptr<CDLTransform> OpenColorIO_v2_6dev::CDLTransformRcPtr¶

ColorSpaceTransform¶

class PyOpenColorIO.ColorSpaceTransform¶

ColorSpaceTransform(*args, **kwargs)¶

Overloaded function.

__init__(self: PyOpenColorIO.PyOpenColorIO.ColorSpaceTransform) -> None
__init__(self: PyOpenColorIO.PyOpenColorIO.ColorSpaceTransform, src: str = ‘’, dst: str = ‘’, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection = <TransformDirection.TRANSFORM_DIR_FORWARD: 0>, dataBypass: bool = True) -> None

getDataBypass() → bool¶

getDirection() → PyOpenColorIO.PyOpenColorIO.TransformDirection¶

getDst() → str¶

getSrc() → str¶

getTransformType() → PyOpenColorIO.PyOpenColorIO.TransformType¶

setDataBypass(dataBypass: bool) → None¶

setDirection(direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) → None¶

setDst(dst: str) → None¶

setSrc(src: str) → None¶

validate() → None¶

DisplayViewTransform¶

class PyOpenColorIO.DisplayViewTransform¶

DisplayViewTransform(*args, **kwargs)¶

Overloaded function.

__init__(self: PyOpenColorIO.PyOpenColorIO.DisplayViewTransform) -> None
__init__(self: PyOpenColorIO.PyOpenColorIO.DisplayViewTransform, src: str = ‘’, display: str = ‘’, view: str = ‘’, looksBypass: bool = False, dataBypass: bool = True, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection = <TransformDirection.TRANSFORM_DIR_FORWARD: 0>) -> None

getDataBypass() → bool¶

getDirection() → PyOpenColorIO.PyOpenColorIO.TransformDirection¶

getDisplay() → str¶

getLooksBypass() → bool¶

getSrc() → str¶

getTransformType() → PyOpenColorIO.PyOpenColorIO.TransformType¶

getView() → str¶

setDataBypass(dataBypass: bool) → None¶

setDirection(direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) → None¶

setDisplay(display: str) → None¶

setLooksBypass(looksBypass: bool) → None¶

setSrc(src: str) → None¶

setView(view: str) → None¶

validate() → None¶

ExponentTransform¶

class PyOpenColorIO.ExponentTransform¶

ExponentTransform(*args, **kwargs)¶

Overloaded function.

__init__(self: PyOpenColorIO.PyOpenColorIO.ExponentTransform) -> None
__init__(self: PyOpenColorIO.PyOpenColorIO.ExponentTransform, value: typing.Annotated[collections.abc.Sequence[typing.SupportsFloat], “FixedSize(4)”] = [1.0, 1.0, 1.0, 1.0], negativeStyle: PyOpenColorIO.PyOpenColorIO.NegativeStyle = <NegativeStyle.NEGATIVE_CLAMP: 0>, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection = <TransformDirection.TRANSFORM_DIR_FORWARD: 0>) -> None

equals(other: PyOpenColorIO.PyOpenColorIO.ExponentTransform) → bool¶

getDirection() → PyOpenColorIO.PyOpenColorIO.TransformDirection¶

getFormatMetadata() → PyOpenColorIO.PyOpenColorIO.FormatMetadata¶

getNegativeStyle() → PyOpenColorIO.PyOpenColorIO.NegativeStyle¶

getTransformType() → PyOpenColorIO.PyOpenColorIO.TransformType¶

getValue() → Annotated[list[float], 'FixedSize(4)']¶

setDirection(direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) → None¶

setNegativeStyle(style: PyOpenColorIO.PyOpenColorIO.NegativeStyle) → None¶

setValue(value: Annotated[collections.abc.Sequence[SupportsFloat], 'FixedSize(4)']) → None¶

validate() → None¶

ExponentWithLinearTransform¶

class PyOpenColorIO.ExponentWithLinearTransform¶

ExponentWithLinearTransform(*args, **kwargs)¶

Overloaded function.

__init__(self: PyOpenColorIO.PyOpenColorIO.ExponentWithLinearTransform) -> None
__init__(self: PyOpenColorIO.PyOpenColorIO.ExponentWithLinearTransform, gamma: typing.Annotated[collections.abc.Sequence[typing.SupportsFloat], “FixedSize(4)”] = [1.0, 1.0, 1.0, 1.0], offset: typing.Annotated[collections.abc.Sequence[typing.SupportsFloat], “FixedSize(4)”] = [0.0, 0.0, 0.0, 0.0], negativeStyle: PyOpenColorIO.PyOpenColorIO.NegativeStyle = <NegativeStyle.NEGATIVE_LINEAR: 3>, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection = <TransformDirection.TRANSFORM_DIR_FORWARD: 0>) -> None

equals(other: PyOpenColorIO.PyOpenColorIO.ExponentWithLinearTransform) → bool¶

getDirection() → PyOpenColorIO.PyOpenColorIO.TransformDirection¶

getFormatMetadata() → PyOpenColorIO.PyOpenColorIO.FormatMetadata¶

getGamma() → Annotated[list[float], 'FixedSize(4)']¶

getNegativeStyle() → PyOpenColorIO.PyOpenColorIO.NegativeStyle¶

getOffset() → Annotated[list[float], 'FixedSize(4)']¶

getTransformType() → PyOpenColorIO.PyOpenColorIO.TransformType¶

setDirection(direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) → None¶

setGamma(values: Annotated[collections.abc.Sequence[SupportsFloat], 'FixedSize(4)']) → None¶

setNegativeStyle(style: PyOpenColorIO.PyOpenColorIO.NegativeStyle) → None¶

setOffset(values: Annotated[collections.abc.Sequence[SupportsFloat], 'FixedSize(4)']) → None¶

validate() → None¶

class ExponentWithLinearTransform : public 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.

Public Functions

inline virtual TransformType getTransformType() const noexcept override¶

virtual const FormatMetadata &getFormatMetadata() const noexcept = 0¶

virtual FormatMetadata &getFormatMetadata() noexcept = 0¶

virtual bool equals(const ExponentWithLinearTransform &other) const noexcept = 0¶: Checks if this exactly equals other.

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

virtual 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.

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

virtual 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].

virtual 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.

virtual void setNegativeStyle(NegativeStyle style) = 0¶

ExponentWithLinearTransform(const ExponentWithLinearTransform&) = delete¶

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

virtual ~ExponentWithLinearTransform() = default¶: Do not use (needed only for pybind11).

Public Static Functions

static ExponentWithLinearTransformRcPtr Create()¶

std::ostream &OpenColorIO_v2_6dev::operator<<(std::ostream&, const ExponentWithLinearTransform&)¶

typedef std::shared_ptr<const ExponentWithLinearTransform> OpenColorIO_v2_6dev::ConstExponentWithLinearTransformRcPtr¶

typedef std::shared_ptr<ExponentWithLinearTransform> OpenColorIO_v2_6dev::ExponentWithLinearTransformRcPtr¶

ExposureContrastTransform¶

class PyOpenColorIO.ExposureContrastTransform¶

ExposureContrastTransform(*args, **kwargs)¶

Overloaded function.

__init__(self: PyOpenColorIO.PyOpenColorIO.ExposureContrastTransform) -> None
__init__(self: PyOpenColorIO.PyOpenColorIO.ExposureContrastTransform, style: PyOpenColorIO.PyOpenColorIO.ExposureContrastStyle = <ExposureContrastStyle.EXPOSURE_CONTRAST_LINEAR: 0>, exposure: typing.SupportsFloat = 0.0, contrast: typing.SupportsFloat = 1.0, gamma: typing.SupportsFloat = 1.0, pivot: typing.SupportsFloat = 0.18, logExposureStep: typing.SupportsFloat = 0.088, logMidGray: typing.SupportsFloat = 0.435, dynamicExposure: bool = False, dynamicContrast: bool = False, dynamicGamma: bool = False, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection = <TransformDirection.TRANSFORM_DIR_FORWARD: 0>) -> None

equals(other: PyOpenColorIO.PyOpenColorIO.ExposureContrastTransform) → bool¶

getContrast() → float¶

getDirection() → PyOpenColorIO.PyOpenColorIO.TransformDirection¶

getExposure() → float¶

getFormatMetadata() → PyOpenColorIO.PyOpenColorIO.FormatMetadata¶

getGamma() → float¶

getLogExposureStep() → float¶

getLogMidGray() → float¶

getPivot() → float¶

getStyle() → PyOpenColorIO.PyOpenColorIO.ExposureContrastStyle¶

getTransformType() → PyOpenColorIO.PyOpenColorIO.TransformType¶

isContrastDynamic() → bool¶

isExposureDynamic() → bool¶

isGammaDynamic() → bool¶

makeContrastDynamic() → None¶

makeContrastNonDynamic() → None¶

makeExposureDynamic() → None¶

makeExposureNonDynamic() → None¶

makeGammaDynamic() → None¶

makeGammaNonDynamic() → None¶

setContrast(contrast: SupportsFloat) → None¶

setDirection(direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) → None¶

setExposure(exposure: SupportsFloat) → None¶

setGamma(gamma: SupportsFloat) → None¶

setLogExposureStep(logExposureStep: SupportsFloat) → None¶

setLogMidGray(logMidGray: SupportsFloat) → None¶

setPivot(pivot: SupportsFloat) → None¶

setStyle(style: PyOpenColorIO.PyOpenColorIO.ExposureContrastStyle) → None¶

validate() → None¶

class ExposureContrastTransform : public Transform ¶

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

Public Functions

inline virtual TransformType getTransformType() const noexcept override¶

virtual const FormatMetadata &getFormatMetadata() const noexcept = 0¶

virtual FormatMetadata &getFormatMetadata() noexcept = 0¶

virtual bool equals(const ExposureContrastTransform &other) const noexcept = 0¶: Checks if this exactly equals other.

virtual ExposureContrastStyle getStyle() const = 0¶

virtual void setStyle(ExposureContrastStyle style) = 0¶: Select the algorithm for linear, video or log color spaces.

virtual double getExposure() const = 0¶

virtual 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.

virtual bool isExposureDynamic() const = 0¶: Exposure can be made dynamic so the value can be changed through the CPU or GPU processor, but if there are several ExposureContrastTransform only one can have a dynamic exposure.

virtual void makeExposureDynamic() = 0¶

virtual void makeExposureNonDynamic() = 0¶

virtual double getContrast() const = 0¶

virtual 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.

virtual bool isContrastDynamic() const = 0¶: Contrast can be made dynamic so the value can be changed through the CPU or GPU processor, but if there are several ExposureContrastTransform only one can have a dynamic contrast.

virtual void makeContrastDynamic() = 0¶

virtual void makeContrastNonDynamic() = 0¶

virtual double getGamma() const = 0¶

virtual void setGamma(double gamma) = 0¶

virtual bool isGammaDynamic() const = 0¶: Gamma can be made dynamic so the value can be changed through the CPU or GPU processor, but if there are several ExposureContrastTransform only one can have a dynamic gamma.

virtual void makeGammaDynamic() = 0¶

virtual void makeGammaNonDynamic() = 0¶

virtual double getPivot() const = 0¶

virtual 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.

virtual double getLogExposureStep() const = 0¶

virtual 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.

virtual double getLogMidGray() const = 0¶

virtual 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.

virtual ~ExposureContrastTransform() = default¶: Do not use (needed only for pybind11).

Public Static Functions

static ExposureContrastTransformRcPtr Create()¶

std::ostream &OpenColorIO_v2_6dev::operator<<(std::ostream&, const ExposureContrastTransform&)¶

typedef std::shared_ptr<const ExposureContrastTransform> OpenColorIO_v2_6dev::ConstExposureContrastTransformRcPtr¶

typedef std::shared_ptr<ExposureContrastTransform> OpenColorIO_v2_6dev::ExposureContrastTransformRcPtr¶

FileTransform¶

class PyOpenColorIO.FileTransform¶

static IsFormatExtensionSupported(extension: str) → bool¶

FileTransform(*args, **kwargs)¶

Overloaded function.

__init__(self: PyOpenColorIO.PyOpenColorIO.FileTransform) -> None
__init__(self: PyOpenColorIO.PyOpenColorIO.FileTransform, src: str = ‘’, cccId: str = ‘’, interpolation: PyOpenColorIO.PyOpenColorIO.Interpolation = <Interpolation.INTERP_DEFAULT: 254>, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection = <TransformDirection.TRANSFORM_DIR_FORWARD: 0>) -> None

getCCCId() → str¶

getCDLStyle() → PyOpenColorIO.PyOpenColorIO.CDLStyle¶

getDirection() → PyOpenColorIO.PyOpenColorIO.TransformDirection¶

static getFormats() → PyOpenColorIO.PyOpenColorIO.FileTransform.FormatIterator¶

getInterpolation() → PyOpenColorIO.PyOpenColorIO.Interpolation¶

getSrc() → str¶

getTransformType() → PyOpenColorIO.PyOpenColorIO.TransformType¶

setCCCId(cccId: str) → None¶

setCDLStyle(style: PyOpenColorIO.PyOpenColorIO.CDLStyle) → None¶

setDirection(direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) → None¶

setInterpolation(interpolation: PyOpenColorIO.PyOpenColorIO.Interpolation) → None¶

setSrc(src: str) → None¶

validate() → None¶

class PyOpenColorIO.FileTransform.FormatIterator¶

self[arg0: SupportsInt] → tuple¶

iter(self) → PyOpenColorIO.PyOpenColorIO.FileTransform.FormatIterator¶

len(self) → int¶

next(self) → tuple¶

class FileTransform : public Transform ¶

Public Functions

virtual TransformRcPtr createEditableCopy() const override¶

virtual TransformDirection getDirection() const noexcept override¶

virtual void setDirection(TransformDirection dir) noexcept override¶: Note that this only affects the evaluation and not the values stored in the object.

inline virtual TransformType getTransformType() const noexcept override¶

virtual void validate() const override¶: Will throw if data is not valid.

const char *getSrc() const¶

void setSrc(const char *src)¶

const char *getCCCId() const¶: The cccid can be the ID of a CDL or the index of the CDL (as string). If cccid is NULL or empty the first CDL is returned. The cccid is case-sensitive.

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¶: The file parsers that care about interpolation (LUTs) will try to make use of the requested interpolation method when loading the file. In these cases, if the requested method could not be used, a warning is logged. If no method is provided, or a method cannot be used, INTERP_DEFAULT is used.

void setInterpolation(Interpolation interp)¶

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

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

Public Static Functions

static FileTransformRcPtr Create()¶

static int GetNumFormats()¶: Get the number of LUT readers.

static const char *GetFormatNameByIndex(int index)¶: Get the LUT readers at index, return empty string if an invalid index is specified.

static const char *GetFormatExtensionByIndex(int index)¶: Get the LUT reader extension at index, return empty string if an invalid index is specified.

static bool IsFormatExtensionSupported(const char *extension)¶: Returns true if the extension corresponds to a format supported by FileTransform. The argument is case-insensitive, and a leading dot, if present, is ignored. Note that FileTransform will attempt all format readers on a given file until it is successful, even files that contain an unsupported extension or no extension. However, this function is useful for applications that want to know which files are likely to be LUT files, based on their extension.

std::ostream &OpenColorIO_v2_6dev::operator<<(std::ostream&, const FileTransform&)¶

typedef std::shared_ptr<const FileTransform> OpenColorIO_v2_6dev::ConstFileTransformRcPtr¶

typedef std::shared_ptr<FileTransform> OpenColorIO_v2_6dev::FileTransformRcPtr¶

FixedFunctionTransform¶

class PyOpenColorIO.FixedFunctionTransform¶

FixedFunctionTransform(style: PyOpenColorIO.PyOpenColorIO.FixedFunctionStyle, params: collections.abc.Sequence[typing.SupportsFloat] = [], direction: PyOpenColorIO.PyOpenColorIO.TransformDirection = <TransformDirection.TRANSFORM_DIR_FORWARD: 0>) → None¶

equals(other: PyOpenColorIO.PyOpenColorIO.FixedFunctionTransform) → bool¶

getDirection() → PyOpenColorIO.PyOpenColorIO.TransformDirection¶

getFormatMetadata() → PyOpenColorIO.PyOpenColorIO.FormatMetadata¶

getParams() → list[float]¶

getStyle() → PyOpenColorIO.PyOpenColorIO.FixedFunctionStyle¶

getTransformType() → PyOpenColorIO.PyOpenColorIO.TransformType¶

setDirection(direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) → None¶

setParams(params: collections.abc.Sequence[SupportsFloat]) → None¶

setStyle(style: PyOpenColorIO.PyOpenColorIO.FixedFunctionStyle) → None¶

validate() → None¶

GroupTransform¶

class PyOpenColorIO.GroupTransform¶

static GetWriteFormats() → PyOpenColorIO.PyOpenColorIO.GroupTransform.WriteFormatIterator¶

GroupTransform(*args, **kwargs)¶

Overloaded function.

__init__(self: PyOpenColorIO.PyOpenColorIO.GroupTransform) -> None
__init__(self: PyOpenColorIO.PyOpenColorIO.GroupTransform, transforms: collections.abc.Sequence[PyOpenColorIO.PyOpenColorIO.Transform] = [], direction: PyOpenColorIO.PyOpenColorIO.TransformDirection = <TransformDirection.TRANSFORM_DIR_FORWARD: 0>) -> None

appendTransform(transform: PyOpenColorIO.PyOpenColorIO.Transform) → None¶

getDirection() → PyOpenColorIO.PyOpenColorIO.TransformDirection¶

getFormatMetadata() → PyOpenColorIO.PyOpenColorIO.FormatMetadata¶

getTransformType() → PyOpenColorIO.PyOpenColorIO.TransformType¶

prependTransform(transform: PyOpenColorIO.PyOpenColorIO.Transform) → None¶

setDirection(direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) → None¶

validate() → None¶

write(*args, **kwargs)¶

Overloaded function.

write(self: PyOpenColorIO.PyOpenColorIO.GroupTransform, formatName: str, fileName: str, config: PyOpenColorIO.PyOpenColorIO.Config = None) -> None
write(self: PyOpenColorIO.PyOpenColorIO.GroupTransform, formatName: str, config: PyOpenColorIO.PyOpenColorIO.Config = None) -> str

class PyOpenColorIO.GroupTransform.WriteFormatIterator¶

self[arg0: SupportsInt] → tuple¶

iter(self) → PyOpenColorIO.PyOpenColorIO.GroupTransform.WriteFormatIterator¶

len(self) → int¶

next(self) → tuple¶

class PyOpenColorIO.GroupTransform.TransformIterator¶

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

iter(self) → PyOpenColorIO.PyOpenColorIO.GroupTransform.TransformIterator¶

len(self) → int¶

next(self) → PyOpenColorIO.PyOpenColorIO.Transform¶

class GroupTransform : public Transform ¶

Public Functions

virtual const FormatMetadata &getFormatMetadata() const noexcept = 0¶

virtual FormatMetadata &getFormatMetadata() noexcept = 0¶

virtual ConstTransformRcPtr getTransform(int index) const = 0¶: Throws if index is not allowed.

virtual TransformRcPtr &getTransform(int index) = 0¶: Throws if index is not allowed.

virtual int getNumTransforms() const noexcept = 0¶: Return number of transforms.

virtual void appendTransform(TransformRcPtr transform) noexcept = 0¶: Adds a transform to the end of the group.

virtual void prependTransform(TransformRcPtr transform) noexcept = 0¶: Add a transform at the beginning of the group.

virtual void write(const ConstConfigRcPtr &config, const char *formatName, std::ostream &os) const = 0¶

Write the transforms comprising the group to the stream.

Writing (as opposed to Baking) is a lossless process. An exception is thrown if the processor cannot be losslessly written to the specified file format. Transforms such as FileTransform or ColorSpaceTransform are resolved into write-able simple transforms using the config and context. Supported formats include CTF, CLF, and CDL. All available formats can be listed with the following:

// What are the allowed writing output formats?
std::ostringstream formats;
formats << "Formats to write to: ";
for (int i = 0; i < GroupTransform::GetNumWriteFormats(); ++i)
{
   if (i != 0) formats << ", ";
   formats << GroupTransform::GetFormatNameByIndex(i);
   formats << " (." << GroupTransform::GetFormatExtensionByIndex(i) << ")";
}

GroupTransform(const GroupTransform&) = delete¶

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

virtual ~GroupTransform() = default¶: Do not use (needed only for pybind11).

Public Static Functions

static GroupTransformRcPtr Create()¶

static int GetNumWriteFormats() noexcept¶: Get the number of writers.

static const char *GetFormatNameByIndex(int index) noexcept¶: Get the writer at index, return empty string if an invalid index is specified.

static const char *GetFormatExtensionByIndex(int index) noexcept¶

std::ostream &OpenColorIO_v2_6dev::operator<<(std::ostream&, const GroupTransform&)¶

typedef std::shared_ptr<const GroupTransform> OpenColorIO_v2_6dev::ConstGroupTransformRcPtr¶

typedef std::shared_ptr<GroupTransform> OpenColorIO_v2_6dev::GroupTransformRcPtr¶

LogAffineTransform¶

class PyOpenColorIO.LogAffineTransform¶

LogAffineTransform(*args, **kwargs)¶

Overloaded function.

__init__(self: PyOpenColorIO.PyOpenColorIO.LogAffineTransform) -> None
__init__(self: PyOpenColorIO.PyOpenColorIO.LogAffineTransform, logSideSlope: typing.Annotated[collections.abc.Sequence[typing.SupportsFloat], “FixedSize(3)”] = [1.0, 1.0, 1.0], logSideOffset: typing.Annotated[collections.abc.Sequence[typing.SupportsFloat], “FixedSize(3)”] = [0.0, 0.0, 0.0], linSideSlope: typing.Annotated[collections.abc.Sequence[typing.SupportsFloat], “FixedSize(3)”] = [1.0, 1.0, 1.0], linSideOffset: typing.Annotated[collections.abc.Sequence[typing.SupportsFloat], “FixedSize(3)”] = [0.0, 0.0, 0.0], direction: PyOpenColorIO.PyOpenColorIO.TransformDirection = <TransformDirection.TRANSFORM_DIR_FORWARD: 0>) -> None

equals(other: PyOpenColorIO.PyOpenColorIO.LogAffineTransform) → bool¶

getBase() → float¶

getDirection() → PyOpenColorIO.PyOpenColorIO.TransformDirection¶

getFormatMetadata() → PyOpenColorIO.PyOpenColorIO.FormatMetadata¶

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

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

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

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

getTransformType() → PyOpenColorIO.PyOpenColorIO.TransformType¶

setBase(base: SupportsFloat) → None¶

setDirection(direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) → None¶

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

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

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

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

validate() → None¶

class LogAffineTransform : public 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.

Public Functions

inline virtual TransformType getTransformType() const noexcept override¶

virtual const FormatMetadata &getFormatMetadata() const noexcept = 0¶

virtual FormatMetadata &getFormatMetadata() noexcept = 0¶

virtual bool equals(const LogAffineTransform &other) const noexcept = 0¶: Checks if this exactly equals other.

virtual double getBase() const noexcept = 0¶

virtual void setBase(double base) noexcept = 0¶

virtual void getLogSideSlopeValue(double (&values)[3]) const noexcept = 0¶

virtual void setLogSideSlopeValue(const double (&values)[3]) noexcept = 0¶

virtual void getLogSideOffsetValue(double (&values)[3]) const noexcept = 0¶

virtual void setLogSideOffsetValue(const double (&values)[3]) noexcept = 0¶

virtual void getLinSideSlopeValue(double (&values)[3]) const noexcept = 0¶

virtual void setLinSideSlopeValue(const double (&values)[3]) noexcept = 0¶

virtual void getLinSideOffsetValue(double (&values)[3]) const noexcept = 0¶

virtual void setLinSideOffsetValue(const double (&values)[3]) noexcept = 0¶

LogAffineTransform(const LogAffineTransform&) = delete¶

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

virtual ~LogAffineTransform() = default¶: Do not use (needed only for pybind11).

Public Static Functions

static LogAffineTransformRcPtr Create()¶

std::ostream &OpenColorIO_v2_6dev::operator<<(std::ostream&, const LogAffineTransform&)¶

typedef std::shared_ptr<const LogAffineTransform> OpenColorIO_v2_6dev::ConstLogAffineTransformRcPtr¶

typedef std::shared_ptr<LogAffineTransform> OpenColorIO_v2_6dev::LogAffineTransformRcPtr¶

LogCameraTransform¶

class PyOpenColorIO.LogCameraTransform¶

LogCameraTransform() → None¶

equals(other: PyOpenColorIO.PyOpenColorIO.LogCameraTransform) → bool¶

getBase() → float¶

getDirection() → PyOpenColorIO.PyOpenColorIO.TransformDirection¶

getFormatMetadata() → PyOpenColorIO.PyOpenColorIO.FormatMetadata¶

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

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

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

getLinearSlopeValue() → Annotated[list[float], 'FixedSize(3)']¶: Return LinearSlope or 3 qnan values if not defined.

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

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

getTransformType() → PyOpenColorIO.PyOpenColorIO.TransformType¶

isLinearSlopeValueSet() → bool¶

setBase(base: SupportsFloat) → None¶

setDirection(direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) → None¶

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

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

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

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

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

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

unsetLinearSlopeValue() → None¶

validate() → None¶

class LogCameraTransform : public Transform ¶

Same as 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.

Public Functions

inline virtual TransformType getTransformType() const noexcept override¶

virtual const FormatMetadata &getFormatMetadata() const noexcept = 0¶

virtual FormatMetadata &getFormatMetadata() noexcept = 0¶

virtual bool equals(const LogCameraTransform &other) const noexcept = 0¶: Checks if this exactly equals other.

virtual double getBase() const noexcept = 0¶

virtual void setBase(double base) noexcept = 0¶

virtual void getLogSideSlopeValue(double (&values)[3]) const noexcept = 0¶: Get/Set values for the R, G, B components.

virtual void setLogSideSlopeValue(const double (&values)[3]) noexcept = 0¶

virtual void getLogSideOffsetValue(double (&values)[3]) const noexcept = 0¶

virtual void setLogSideOffsetValue(const double (&values)[3]) noexcept = 0¶

virtual void getLinSideSlopeValue(double (&values)[3]) const noexcept = 0¶

virtual void setLinSideSlopeValue(const double (&values)[3]) noexcept = 0¶

virtual void getLinSideOffsetValue(double (&values)[3]) const noexcept = 0¶

virtual void setLinSideOffsetValue(const double (&values)[3]) noexcept = 0¶

virtual void getLinSideBreakValue(double (&values)[3]) const noexcept = 0¶

virtual void setLinSideBreakValue(const double (&values)[3]) noexcept = 0¶

virtual bool getLinearSlopeValue(double (&values)[3]) const = 0¶: Return true if LinearSlope values were set, false if they were not.

virtual void setLinearSlopeValue(const double (&values)[3]) = 0¶: Set LinearSlope value.

Note

You must call setLinSideBreakValue before calling this.

virtual void unsetLinearSlopeValue() = 0¶: Remove LinearSlope values so that default values are used.

LogCameraTransform(const LogCameraTransform&) = delete¶

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

virtual ~LogCameraTransform() = default¶: Do not use (needed only for pybind11).

Public Static Functions

static LogCameraTransformRcPtr Create(const double (&linSideBreakValues)[3])¶: LinSideBreak must be set for the transform to be valid (there is no default).

std::ostream &OpenColorIO_v2_6dev::operator<<(std::ostream&, const LogCameraTransform&)¶

typedef std::shared_ptr<const LogCameraTransform> OpenColorIO_v2_6dev::ConstLogCameraTransformRcPtr¶

typedef std::shared_ptr<LogCameraTransform> OpenColorIO_v2_6dev::LogCameraTransformRcPtr¶

LogTransform¶

class PyOpenColorIO.LogTransform¶

LogTransform(*args, **kwargs)¶

Overloaded function.

__init__(self: PyOpenColorIO.PyOpenColorIO.LogTransform) -> None
__init__(self: PyOpenColorIO.PyOpenColorIO.LogTransform, base: typing.SupportsFloat = 2.0, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection = <TransformDirection.TRANSFORM_DIR_FORWARD: 0>) -> None

equals(other: PyOpenColorIO.PyOpenColorIO.LogTransform) → bool¶

getBase() → float¶

getDirection() → PyOpenColorIO.PyOpenColorIO.TransformDirection¶

getFormatMetadata() → PyOpenColorIO.PyOpenColorIO.FormatMetadata¶

getTransformType() → PyOpenColorIO.PyOpenColorIO.TransformType¶

setBase(base: SupportsFloat) → None¶

setDirection(direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) → None¶

validate() → None¶

LookTransform¶

class PyOpenColorIO.LookTransform¶

LookTransform(*args, **kwargs)¶

Overloaded function.

__init__(self: PyOpenColorIO.PyOpenColorIO.LookTransform) -> None
__init__(self: PyOpenColorIO.PyOpenColorIO.LookTransform, src: str, dst: str, looks: str = ‘’, skipColorSpaceConversion: bool = False, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection = <TransformDirection.TRANSFORM_DIR_FORWARD: 0>) -> None

getDirection() → PyOpenColorIO.PyOpenColorIO.TransformDirection¶

getDst() → str¶

getLooks() → str¶

getSkipColorSpaceConversion() → bool¶

getSrc() → str¶

getTransformType() → PyOpenColorIO.PyOpenColorIO.TransformType¶

setDirection(direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) → None¶

setDst(dst: str) → None¶

setLooks(looks: str) → None¶

setSkipColorSpaceConversion(skipColorSpaceConversion: bool) → None¶

setSrc(src: str) → None¶

validate() → None¶

Lut1DTransform¶

class PyOpenColorIO.Lut1DTransform¶

Lut1DTransform(*args, **kwargs)¶

Overloaded function.

__init__(self: PyOpenColorIO.PyOpenColorIO.Lut1DTransform) -> None
__init__(self: PyOpenColorIO.PyOpenColorIO.Lut1DTransform, length: typing.SupportsInt, inputHalfDomain: bool) -> None
__init__(self: PyOpenColorIO.PyOpenColorIO.Lut1DTransform, length: typing.SupportsInt = 2, inputHalfDomain: bool = False, outputRawHalfs: bool = False, fileOutputBitDepth: PyOpenColorIO.PyOpenColorIO.BitDepth = <BitDepth.BIT_DEPTH_UNKNOWN: 0>, hueAdjust: PyOpenColorIO.PyOpenColorIO.Lut1DHueAdjust = <Lut1DHueAdjust.HUE_NONE: 0>, interpolation: PyOpenColorIO.PyOpenColorIO.Interpolation = <Interpolation.INTERP_DEFAULT: 254>, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection = <TransformDirection.TRANSFORM_DIR_FORWARD: 0>) -> None

equals(other: PyOpenColorIO.PyOpenColorIO.Lut1DTransform) → bool¶

getData() → numpy.ndarray¶

getDirection() → PyOpenColorIO.PyOpenColorIO.TransformDirection¶

getFileOutputBitDepth() → PyOpenColorIO.PyOpenColorIO.BitDepth¶

getFormatMetadata() → PyOpenColorIO.PyOpenColorIO.FormatMetadata¶

getHueAdjust() → PyOpenColorIO.PyOpenColorIO.Lut1DHueAdjust¶

getInputHalfDomain() → bool¶

getInterpolation() → PyOpenColorIO.PyOpenColorIO.Interpolation¶

getLength() → int¶

getOutputRawHalfs() → bool¶

getTransformType() → PyOpenColorIO.PyOpenColorIO.TransformType¶

getValue(index: SupportsInt) → tuple¶

setData(data: typing_extensions.Buffer) → None¶

setDirection(direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) → None¶

setFileOutputBitDepth(bitDepth: PyOpenColorIO.PyOpenColorIO.BitDepth) → None¶

setHueAdjust(hueAdjust: PyOpenColorIO.PyOpenColorIO.Lut1DHueAdjust) → None¶

setInputHalfDomain(isHalfDomain: bool) → None¶

setInterpolation(interpolation: PyOpenColorIO.PyOpenColorIO.Interpolation) → None¶

setLength(length: SupportsInt) → None¶

setOutputRawHalfs(isRawHalfs: bool) → None¶

setValue(index: SupportsInt, r: SupportsFloat, g: SupportsFloat, b: SupportsFloat) → None¶

validate() → None¶

class Lut1DTransform : public Transform ¶

Represents a 1D-LUT transform.

Public Functions

inline virtual TransformType getTransformType() const noexcept override¶

virtual BitDepth getFileOutputBitDepth() const noexcept = 0¶

virtual 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.

virtual const FormatMetadata &getFormatMetadata() const noexcept = 0¶

virtual FormatMetadata &getFormatMetadata() noexcept = 0¶

virtual bool equals(const Lut1DTransform &other) const noexcept = 0¶: Checks if this exactly equals other.

virtual unsigned long getLength() const = 0¶

virtual void setLength(unsigned long length) = 0¶: Changing the length will reset the LUT to identity. Will throw for lengths longer than 1024x1024.

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

virtual 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.

virtual bool getInputHalfDomain() const noexcept = 0¶

virtual 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.

virtual bool getOutputRawHalfs() const noexcept = 0¶

virtual 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.

virtual Lut1DHueAdjust getHueAdjust() const noexcept = 0¶

virtual void setHueAdjust(Lut1DHueAdjust algo) = 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.

virtual Interpolation getInterpolation() const = 0¶

virtual void setInterpolation(Interpolation algo) = 0¶

Lut1DTransform(const Lut1DTransform&) = delete¶

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

virtual ~Lut1DTransform() = default¶: Do not use (needed only for pybind11).

Public Static Functions

static Lut1DTransformRcPtr Create()¶: Create an identity 1D-LUT of length two.

static 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.

std::ostream &OpenColorIO_v2_6dev::operator<<(std::ostream&, const Lut1DTransform&)¶

typedef std::shared_ptr<const Lut1DTransform> OpenColorIO_v2_6dev::ConstLut1DTransformRcPtr¶

typedef std::shared_ptr<Lut1DTransform> OpenColorIO_v2_6dev::Lut1DTransformRcPtr¶

Lut3DTransform¶

class PyOpenColorIO.Lut3DTransform¶

Lut3DTransform(*args, **kwargs)¶

Overloaded function.

__init__(self: PyOpenColorIO.PyOpenColorIO.Lut3DTransform) -> None
__init__(self: PyOpenColorIO.PyOpenColorIO.Lut3DTransform, gridSize: typing.SupportsInt) -> None
__init__(self: PyOpenColorIO.PyOpenColorIO.Lut3DTransform, gridSize: typing.SupportsInt = 2, fileOutputBitDepth: PyOpenColorIO.PyOpenColorIO.BitDepth = <BitDepth.BIT_DEPTH_UNKNOWN: 0>, interpolation: PyOpenColorIO.PyOpenColorIO.Interpolation = <Interpolation.INTERP_DEFAULT: 254>, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection = <TransformDirection.TRANSFORM_DIR_FORWARD: 0>) -> None

equals(other: PyOpenColorIO.PyOpenColorIO.Lut3DTransform) → bool¶

getData() → numpy.ndarray¶

getDirection() → PyOpenColorIO.PyOpenColorIO.TransformDirection¶

getFileOutputBitDepth() → PyOpenColorIO.PyOpenColorIO.BitDepth¶

getFormatMetadata() → PyOpenColorIO.PyOpenColorIO.FormatMetadata¶

getGridSize() → int¶

getInterpolation() → PyOpenColorIO.PyOpenColorIO.Interpolation¶

getTransformType() → PyOpenColorIO.PyOpenColorIO.TransformType¶

getValue(indexR: SupportsInt, indexG: SupportsInt, indexB: SupportsInt) → tuple¶

setData(data: typing_extensions.Buffer) → None¶

setDirection(direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) → None¶

setFileOutputBitDepth(bitDepth: PyOpenColorIO.PyOpenColorIO.BitDepth) → None¶

setGridSize(gridSize: SupportsInt) → None¶

setInterpolation(interpolation: PyOpenColorIO.PyOpenColorIO.Interpolation) → None¶

setValue(indexR: SupportsInt, indexG: SupportsInt, indexB: SupportsInt, r: SupportsFloat, g: SupportsFloat, b: SupportsFloat) → None¶

validate() → None¶

class Lut3DTransform : public Transform ¶

Represents a 3D-LUT transform.

Public Functions

inline virtual TransformType getTransformType() const noexcept override¶

virtual BitDepth getFileOutputBitDepth() const noexcept = 0¶

virtual 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.

virtual const FormatMetadata &getFormatMetadata() const noexcept = 0¶

virtual FormatMetadata &getFormatMetadata() noexcept = 0¶

virtual bool equals(const Lut3DTransform &other) const noexcept = 0¶: Checks if this exactly equals other.

virtual unsigned long getGridSize() const = 0¶

virtual void setGridSize(unsigned long gridSize) = 0¶: Changing the grid size will reset the LUT to identity. Will throw for grid sizes larger than 129.

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

virtual 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.

virtual Interpolation getInterpolation() const = 0¶

virtual void setInterpolation(Interpolation algo) = 0¶

Lut3DTransform(const Lut3DTransform&) = delete¶

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

virtual ~Lut3DTransform() = default¶: Do not use (needed only for pybind11).

Public Static Functions

static Lut3DTransformRcPtr Create()¶: Create an identity 3D-LUT of size 2x2x2.

static Lut3DTransformRcPtr Create(unsigned long gridSize)¶: Create an identity 3D-LUT with specific grid size. Will throw for grid size larger than 129.

std::ostream &OpenColorIO_v2_6dev::operator<<(std::ostream&, const Lut3DTransform&)¶

typedef std::shared_ptr<const Lut3DTransform> OpenColorIO_v2_6dev::ConstLut3DTransformRcPtr¶

typedef std::shared_ptr<Lut3DTransform> OpenColorIO_v2_6dev::Lut3DTransformRcPtr¶

MatrixTransform¶

class PyOpenColorIO.MatrixTransform¶

static Fit(oldMin: Annotated[collections.abc.Sequence[SupportsFloat], 'FixedSize(4)'] = [0.0, 0.0, 0.0, 0.0], oldMax: Annotated[collections.abc.Sequence[SupportsFloat], 'FixedSize(4)'] = [1.0, 1.0, 1.0, 1.0], newMin: Annotated[collections.abc.Sequence[SupportsFloat], 'FixedSize(4)'] = [0.0, 0.0, 0.0, 0.0], newMax: Annotated[collections.abc.Sequence[SupportsFloat], 'FixedSize(4)'] = [1.0, 1.0, 1.0, 1.0]) → PyOpenColorIO.PyOpenColorIO.MatrixTransform¶

static Identity() → PyOpenColorIO.PyOpenColorIO.MatrixTransform¶

static Sat(sat: SupportsFloat, lumaCoef: Annotated[collections.abc.Sequence[SupportsFloat], 'FixedSize(3)']) → PyOpenColorIO.PyOpenColorIO.MatrixTransform¶

static Scale(scale: Annotated[collections.abc.Sequence[SupportsFloat], 'FixedSize(4)']) → PyOpenColorIO.PyOpenColorIO.MatrixTransform¶

static View(channelHot: Annotated[collections.abc.Sequence[SupportsInt], 'FixedSize(4)'], lumaCoef: Annotated[collections.abc.Sequence[SupportsFloat], 'FixedSize(3)']) → PyOpenColorIO.PyOpenColorIO.MatrixTransform¶

MatrixTransform(*args, **kwargs)¶

Overloaded function.

__init__(self: PyOpenColorIO.PyOpenColorIO.MatrixTransform) -> None
__init__(self: PyOpenColorIO.PyOpenColorIO.MatrixTransform, matrix: typing.Annotated[collections.abc.Sequence[typing.SupportsFloat], “FixedSize(16)”] = [1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0], offset: typing.Annotated[collections.abc.Sequence[typing.SupportsFloat], “FixedSize(4)”] = [0.0, 0.0, 0.0, 0.0], direction: PyOpenColorIO.PyOpenColorIO.TransformDirection = <TransformDirection.TRANSFORM_DIR_FORWARD: 0>) -> None

equals(other: PyOpenColorIO.PyOpenColorIO.MatrixTransform) → bool¶

getDirection() → PyOpenColorIO.PyOpenColorIO.TransformDirection¶

getFileInputBitDepth() → PyOpenColorIO.PyOpenColorIO.BitDepth¶

getFileOutputBitDepth() → PyOpenColorIO.PyOpenColorIO.BitDepth¶

getFormatMetadata() → PyOpenColorIO.PyOpenColorIO.FormatMetadata¶

getMatrix() → Annotated[list[float], 'FixedSize(16)']¶

getOffset() → Annotated[list[float], 'FixedSize(4)']¶

getTransformType() → PyOpenColorIO.PyOpenColorIO.TransformType¶

setDirection(direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) → None¶

setFileInputBitDepth(bitDepth: PyOpenColorIO.PyOpenColorIO.BitDepth) → None¶

setFileOutputBitDepth(bitDepth: PyOpenColorIO.PyOpenColorIO.BitDepth) → None¶

setMatrix(matrix: Annotated[collections.abc.Sequence[SupportsFloat], 'FixedSize(16)']) → None¶

setOffset(offset: Annotated[collections.abc.Sequence[SupportsFloat], 'FixedSize(4)']) → None¶

validate() → None¶

class MatrixTransform : public Transform ¶

Represents an MX+B Matrix transform.

Note

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

Public Functions

inline virtual TransformType getTransformType() const noexcept override¶

virtual const FormatMetadata &getFormatMetadata() const noexcept = 0¶

virtual FormatMetadata &getFormatMetadata() noexcept = 0¶

virtual bool equals(const MatrixTransform &other) const noexcept = 0¶: Checks if this exactly equals other.

virtual void getMatrix(double *m44) const = 0¶

virtual 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].

virtual void getOffset(double *offset4) const = 0¶

virtual 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].

virtual BitDepth getFileInputBitDepth() const noexcept = 0¶

Get the bit-depths associated with the matrix values read from a file or set the bit-depths of values to be written to a file (for file formats such as CLF that support multiple bit-depths).

In a format such as CLF, the matrix values are scaled to take pixels at the specified inBitDepth to pixels at the specified outBitDepth. This complicates the interpretation of the matrix values and so this object always holds normalized values and scaling is done on the way from or to file formats such as CLF.

virtual void setFileInputBitDepth(BitDepth bitDepth) noexcept = 0¶

virtual BitDepth getFileOutputBitDepth() const noexcept = 0¶

virtual void setFileOutputBitDepth(BitDepth bitDepth) noexcept = 0¶

MatrixTransform(const MatrixTransform&) = delete¶

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

virtual ~MatrixTransform() = default¶: Do not use (needed only for pybind11).

Public Static Functions

static MatrixTransformRcPtr Create()¶

static void Fit(double *m44, double *offset4, const double *oldmin4, const double *oldmax4, const double *newmin4, const double *newmax4)¶

Convenience functions

Build the matrix and offset corresponding to higher-level concepts.

Note

These can throw an exception if for any component oldmin == oldmax. (divide by 0)

static void Identity(double *m44, double *offset4)¶

static void Sat(double *m44, double *offset4, double sat, const double *lumaCoef3)¶

static void Scale(double *m44, double *offset4, const double *scale4)¶

static void View(double *m44, double *offset4, int *channelHot4, const double *lumaCoef3)¶

std::ostream &OpenColorIO_v2_6dev::operator<<(std::ostream&, const MatrixTransform&) noexcept¶

typedef std::shared_ptr<const MatrixTransform> OpenColorIO_v2_6dev::ConstMatrixTransformRcPtr¶

typedef std::shared_ptr<MatrixTransform> OpenColorIO_v2_6dev::MatrixTransformRcPtr¶

RangeTransform¶

class PyOpenColorIO.RangeTransform¶

RangeTransform(*args, **kwargs)¶

Overloaded function.

__init__(self: PyOpenColorIO.PyOpenColorIO.RangeTransform) -> None
__init__(self: PyOpenColorIO.PyOpenColorIO.RangeTransform, minInValue: typing.SupportsFloat = nan, maxInValue: typing.SupportsFloat = nan, minOutValue: typing.SupportsFloat = nan, maxOutValue: typing.SupportsFloat = nan, direction: PyOpenColorIO.PyOpenColorIO.TransformDirection = <TransformDirection.TRANSFORM_DIR_FORWARD: 0>) -> None

equals(other: PyOpenColorIO.PyOpenColorIO.RangeTransform) → bool¶

getDirection() → PyOpenColorIO.PyOpenColorIO.TransformDirection¶

getFileInputBitDepth() → PyOpenColorIO.PyOpenColorIO.BitDepth¶

getFileOutputBitDepth() → PyOpenColorIO.PyOpenColorIO.BitDepth¶

getFormatMetadata() → PyOpenColorIO.PyOpenColorIO.FormatMetadata¶

getMaxInValue() → float¶

getMaxOutValue() → float¶

getMinInValue() → float¶

getMinOutValue() → float¶

getStyle() → PyOpenColorIO.PyOpenColorIO.RangeStyle¶

getTransformType() → PyOpenColorIO.PyOpenColorIO.TransformType¶

hasMaxInValue() → bool¶

hasMaxOutValue() → bool¶

hasMinInValue() → bool¶

hasMinOutValue() → bool¶

setDirection(direction: PyOpenColorIO.PyOpenColorIO.TransformDirection) → None¶

setFileInputBitDepth(bitDepth: PyOpenColorIO.PyOpenColorIO.BitDepth) → None¶

setFileOutputBitDepth(bitDepth: PyOpenColorIO.PyOpenColorIO.BitDepth) → None¶

setMaxInValue(value: SupportsFloat) → None¶

setMaxOutValue(value: SupportsFloat) → None¶

setMinInValue(value: SupportsFloat) → None¶

setMinOutValue(value: SupportsFloat) → None¶

setStyle(style: PyOpenColorIO.PyOpenColorIO.RangeStyle) → None¶

unsetMaxInValue() → None¶

unsetMaxOutValue() → None¶

unsetMinInValue() → None¶

unsetMinOutValue() → None¶

validate() → None¶

class RangeTransform : public 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.

Note

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

Note

Changing the transform direction does not modify the in/out values — they are always specified with respect to the “forward” direction.

Public Functions

inline virtual TransformType getTransformType() const noexcept override¶

virtual RangeStyle getStyle() const noexcept = 0¶

virtual void setStyle(RangeStyle style) noexcept = 0¶: Set the Range style to clamp or not input values.

virtual const FormatMetadata &getFormatMetadata() const noexcept = 0¶

virtual FormatMetadata &getFormatMetadata() noexcept = 0¶

virtual bool equals(const RangeTransform &other) const noexcept = 0¶: Checks if this equals other.

virtual BitDepth getFileInputBitDepth() const noexcept = 0¶

File bit-depth

In a format such as CLF, the range values are scaled to take pixels at the specified inBitDepth to pixels at the specified outBitDepth. This complicates the interpretation of the range values and so this object always holds normalized values and scaling is done on the way from or to file formats such as CLF. Get the bit-depths associated with the range values read from a file or set the bit-depths of values to be written to a file (for file formats such as CLF that support multiple bit-depths).

virtual void setFileInputBitDepth(BitDepth bitDepth) noexcept = 0¶

virtual BitDepth getFileOutputBitDepth() const noexcept = 0¶

virtual void setFileOutputBitDepth(BitDepth bitDepth) noexcept = 0¶

virtual double getMinInValue() const noexcept = 0¶

Get the minimum value for the input.

Range values

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” input depth, a MaxInValue of 1023 in the file is normalized to 1.0. Likewise, for an output depth of “12i”, a MaxOutValue of 4095 in the file is normalized to 1.0. The values here are unclamped and may extend outside [0,1].

virtual void setMinInValue(double val) noexcept = 0¶: Set the minimum value for the input.

virtual bool hasMinInValue() const noexcept = 0¶: Is the minimum value for the input set?

virtual void unsetMinInValue() noexcept = 0¶: Unset the minimum value for the input.

virtual void setMaxInValue(double val) noexcept = 0¶: Set the maximum value for the input.

virtual double getMaxInValue() const noexcept = 0¶: Get the maximum value for the input.

virtual bool hasMaxInValue() const noexcept = 0¶: Is the maximum value for the input set?

virtual void unsetMaxInValue() noexcept = 0¶: Unset the maximum value for the input.

virtual void setMinOutValue(double val) noexcept = 0¶: Set the minimum value for the output.

virtual double getMinOutValue() const noexcept = 0¶: Get the minimum value for the output.

virtual bool hasMinOutValue() const noexcept = 0¶: Is the minimum value for the output set?

virtual void unsetMinOutValue() noexcept = 0¶: Unset the minimum value for the output.

virtual void setMaxOutValue(double val) noexcept = 0¶: Set the maximum value for the output.

virtual double getMaxOutValue() const noexcept = 0¶: Get the maximum value for the output.

virtual bool hasMaxOutValue() const noexcept = 0¶: Is the maximum value for the output set?

virtual void unsetMaxOutValue() noexcept = 0¶: Unset the maximum value for the output.

RangeTransform(const RangeTransform&) = delete¶

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

virtual ~RangeTransform() = default¶: Do not use (needed only for pybind11).

Public Static Functions

static RangeTransformRcPtr Create()¶: Creates an instance of RangeTransform.

std::ostream &OpenColorIO_v2_6dev::operator<<(std::ostream&, const RangeTransform&) noexcept¶

typedef std::shared_ptr<const RangeTransform> OpenColorIO_v2_6dev::ConstRangeTransformRcPtr¶

typedef std::shared_ptr<RangeTransform> OpenColorIO_v2_6dev::RangeTransformRcPtr¶