Grading Transforms¶

GradingPrimaryTransform¶

class PyOpenColorIO.GradingPrimaryTransform¶

Primary color correction controls.

This transform is for making basic color correction adjustments to an image such as brightness, contrast, or saturation.

The controls are customized for linear, logarithmic, and video color encodings. - Linear controls: Exposure, Contrast, Pivot, Offset, Saturation, Black Clip, White Clip. - Log controls: Brightness, Contrast, Pivot, Log Gamma, Saturation, Black Clip, White Clip, Black Pivot White Pivot. - Video controls : Lift, Gamma, Gain, Offset, Saturation, Black Clip, White Clip, Black Pivot White Pivot.

The controls are dynamic, so they may be adjusted even after the Transform has been included in a Processor.

GradingPrimaryTransform(*args, **kwargs)¶

Overloaded function.

__init__(self: PyOpenColorIO.GradingPrimaryTransform, values: PyOpenColorIO.GradingPrimary, style: PyOpenColorIO.GradingStyle = <GradingStyle.GRADING_LOG: 0>, dynamic: bool = False, dir: PyOpenColorIO.TransformDirection = <TransformDirection.TRANSFORM_DIR_FORWARD: 0>) -> None

Creates an instance of GradingPrimaryTransform.

__init__(self: PyOpenColorIO.GradingPrimaryTransform, style: PyOpenColorIO.GradingStyle = <GradingStyle.GRADING_LOG: 0>, dynamic: bool = False, dir: PyOpenColorIO.TransformDirection = <TransformDirection.TRANSFORM_DIR_FORWARD: 0>) -> None

Creates an instance of GradingPrimaryTransform.

str(self)¶: Return str(self).

getDirection() → PyOpenColorIO.TransformDirection ¶

getFormatMetadata() → PyOpenColorIO.FormatMetadata ¶

getStyle() → PyOpenColorIO.GradingStyle ¶: Adjusts the behavior of the transform for log, linear, or video color space encodings.

getTransformType() → PyOpenColorIO.TransformType ¶

getValue() → PyOpenColorIO.GradingPrimary ¶

isDynamic() → bool¶: Parameters can be made dynamic so the values can be changed through the CPU or GPU processor, but if there are several GradingPrimaryTransform only one can have dynamic parameters.

makeDynamic() → None¶

makeNonDynamic() → None¶

setDirection(direction: PyOpenColorIO.TransformDirection) → None¶: Note that this only affects the evaluation and not the values stored in the object.

setStyle(style: PyOpenColorIO.GradingStyle) → None¶: Will reset value to style’s defaults if style is not the current style.

setValue(values: PyOpenColorIO.GradingPrimary) → None¶: Throws if value is not valid.

validate() → None¶: Will throw if data is not valid.

class OpenColorIO_v2_0::GradingPrimaryTransform : public Transform ¶

Primary color correction controls.

This transform is for making basic color correction adjustments to an image such as brightness, contrast, or saturation.

The controls are customized for linear, logarithmic, and video color encodings.

Linear controls: Exposure, Contrast, Pivot, Offset, Saturation, Black Clip, White Clip.
Log controls: Brightness, Contrast, Pivot, Log Gamma, Saturation, Black Clip, White Clip, Black Pivot White Pivot.
Video controls : Lift, Gamma, Gain, Offset, Saturation, Black Clip, White Clip, Black Pivot White Pivot.

The controls are dynamic, so they may be adjusted even after the Transform has been included in a Processor.

Public Functions

TransformType getTransformType() const noexcept override¶

const FormatMetadata &getFormatMetadata() const noexcept = 0¶

FormatMetadata &getFormatMetadata() noexcept = 0¶

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

GradingStyle getStyle() const noexcept = 0¶: Adjusts the behavior of the transform for log, linear, or video color space encodings.

void setStyle(GradingStyle style) noexcept = 0¶: Will reset value to style’s defaults if style is not the current style.

const GradingPrimary &getValue() const = 0¶

void setValue(const GradingPrimary &values) = 0¶: Throws if value is not valid.

bool isDynamic() const noexcept = 0¶: Parameters can be made dynamic so the values can be changed through the CPU or GPU processor, but if there are several GradingPrimaryTransform only one can have dynamic parameters.

void makeDynamic() noexcept = 0¶

void makeNonDynamic() noexcept = 0¶

GradingPrimaryTransform(const GradingPrimaryTransform&) = delete¶

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

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

Public Static Functions

GradingPrimaryTransformRcPtr Create(GradingStyle style)¶: Creates an instance of GradingPrimaryTransform.

std::ostream &OpenColorIO_v2_0::operator<<(std::ostream&, const GradingPrimaryTransform&) noexcept¶

typedef std::shared_ptr<const GradingPrimaryTransform> OpenColorIO_v2_0::ConstGradingPrimaryTransformRcPtr¶

typedef std::shared_ptr<GradingPrimaryTransform> OpenColorIO_v2_0::GradingPrimaryTransformRcPtr¶

GradingPrimary¶

class PyOpenColorIO.GradingPrimary¶

Grading primary values.

NoClampBlack = -1.7976931348623157e+308¶

NoClampWhite = 1.7976931348623157e+308¶

GradingPrimary(arg0: PyOpenColorIO.GradingStyle) → None¶

property brightness¶

property clampBlack¶

property clampWhite¶

property contrast¶

property exposure¶

property gain¶

property gamma¶

property lift¶

property offset¶

property pivot¶

property pivotBlack¶

property pivotWhite¶

property saturation¶

validate(arg0: PyOpenColorIO.GradingStyle) → None¶: The valid range for each parameter varies.

struct OpenColorIO_v2_0::GradingPrimary¶

Grading primary values.

Public Functions

GradingPrimary() = delete¶

GradingPrimary(const GradingPrimary&) = default¶

GradingPrimary(GradingStyle style)¶

void validate(GradingStyle style) const¶: The valid range for each parameter varies.

Public Members

GradingRGBM m_brightness = {0.0, 0.0, 0.0, 0.0}¶

GradingRGBM m_contrast = {1.0, 1.0, 1.0, 1.0}¶

GradingRGBM m_gamma = {1.0, 1.0, 1.0, 1.0}¶

GradingRGBM m_offset = {0.0, 0.0, 0.0, 0.0}¶

GradingRGBM m_exposure = {0.0, 0.0, 0.0, 0.0}¶

GradingRGBM m_lift = {0.0, 0.0, 0.0, 0.0}¶

GradingRGBM m_gain = {1.0, 1.0, 1.0, 1.0}¶

double m_saturation = {1.0}¶

double m_pivot¶

double m_pivotBlack = {0.0}¶

double m_pivotWhite = {1.0}¶

double m_clampBlack¶

double m_clampWhite¶

Public Static Functions

double NoClampBlack()¶

double NoClampWhite()¶

std::ostream &OpenColorIO_v2_0::operator<<(std::ostream&, const GradingPrimary&)¶

GradingRGBM¶

class PyOpenColorIO.GradingRGBM¶

Used by the grading transforms to hold the red, green, blue, and master components of a single parameter. The master component affects all three channels (RGB).

GradingRGBM(*args, **kwargs)¶

Overloaded function.

__init__(self: PyOpenColorIO.GradingRGBM) -> None
__init__(self: PyOpenColorIO.GradingRGBM, red: float, green: float, blue: float, master: float) -> None

property blue¶

property green¶

property master¶

property red¶

struct OpenColorIO_v2_0::GradingRGBM¶

Used by the grading transforms to hold the red, green, blue, and master components of a single parameter. The master component affects all three channels (RGB).

Public Functions

GradingRGBM() = default¶

GradingRGBM(const GradingRGBM&) = default¶

GradingRGBM(double red, double green, double blue, double master)¶

GradingRGBM(const double (&rgbm)[4])¶

Public Members

double m_red = {0.}¶

double m_green = {0.}¶

double m_blue = {0.}¶

double m_master = {0.}¶

std::ostream &OpenColorIO_v2_0::operator<<(std::ostream&, const GradingRGBM&)¶

GradingRGBCurveTransform¶

class PyOpenColorIO.GradingRGBCurveTransform¶

RGB curve color correction controls.

This transform allows for modifying tone reproduction via B-spline curves.

There is an R, G, and B curve along with a Master curve (that applies to R, G, and B). Each curve is specified via the x and y coordinates of its control points. A monotonic spline is fit to the control points. The x coordinates must be non-decreasing. When the grading style is linear, the units for the control points are photographic stops relative to 0.18.

The control points are dynamic, so they may be adjusted even after the Transform is included in a Processor.

GradingRGBCurveTransform(*args, **kwargs)¶

Overloaded function.

__init__(self: PyOpenColorIO.GradingRGBCurveTransform, values: PyOpenColorIO.GradingRGBCurve, style: PyOpenColorIO.GradingStyle = <GradingStyle.GRADING_LOG: 0>, dynamic: bool = False, dir: PyOpenColorIO.TransformDirection = <TransformDirection.TRANSFORM_DIR_FORWARD: 0>) -> None

Creates an instance of GradingPrimaryTransform.

__init__(self: PyOpenColorIO.GradingRGBCurveTransform, style: PyOpenColorIO.GradingStyle = <GradingStyle.GRADING_LOG: 0>, dynamic: bool = False, dir: PyOpenColorIO.TransformDirection = <TransformDirection.TRANSFORM_DIR_FORWARD: 0>) -> None

Creates an instance of GradingPrimaryTransform.

str(self)¶: Return str(self).

getBypassLinToLog() → bool¶: The scene-linear grading style applies a lin-to-log transform to the pixel values before going through the curve. However, in some cases (e.g. drawing curves in a UI) it may be useful to bypass the lin-to-log. Default value is false.

getDirection() → PyOpenColorIO.TransformDirection ¶

getFormatMetadata() → PyOpenColorIO.FormatMetadata ¶

getSlope(channel: PyOpenColorIO.RGBCurveType, index: int) → float¶: It is possible to provide a desired slope value for each control point. The number of slopes is always the same as the number of control points and so the control points must be set before setting the slopes. The slopes are primarily intended for use by config authors looking to match a specific shape with as few control points as possible, they are not intended to be exposed to a user interface for direct manipulation. When a curve is being generated for creative purposes it is better to let OCIO calculate the slopes automatically.

getStyle() → PyOpenColorIO.GradingStyle ¶: Adjusts the behavior of the transform for log, linear, or video color space encodings.

getTransformType() → PyOpenColorIO.TransformType ¶

getValue() → PyOpenColorIO.GradingRGBCurve ¶

isDynamic() → bool¶: Parameters can be made dynamic so the values can be changed through the CPU or GPU processor, but if there are several GradingRGBCurveTransform only one can have dynamic parameters.

makeDynamic() → None¶

makeNonDynamic() → None¶

setBypassLinToLog(bypass: bool) → None¶

setDirection(direction: PyOpenColorIO.TransformDirection) → None¶: Note that this only affects the evaluation and not the values stored in the object.

setSlope(channel: PyOpenColorIO.RGBCurveType, index: int, slope: float) → None¶

setStyle(style: PyOpenColorIO.GradingStyle) → None¶: Will reset value to style’s defaults if style is not the current style.

setValue(values: PyOpenColorIO.GradingRGBCurve) → None¶: Throws if value is not valid.

slopesAreDefault(channel: PyOpenColorIO.RGBCurveType) → bool¶

validate() → None¶: Will throw if data is not valid.

class OpenColorIO_v2_0::GradingRGBCurveTransform : public Transform ¶

RGB curve color correction controls.

This transform allows for modifying tone reproduction via B-spline curves.

There is an R, G, and B curve along with a Master curve (that applies to R, G, and B). Each curve is specified via the x and y coordinates of its control points. A monotonic spline is fit to the control points. The x coordinates must be non-decreasing. When the grading style is linear, the units for the control points are photographic stops relative to 0.18.

The control points are dynamic, so they may be adjusted even after the Transform is included in a Processor.

Public Functions

TransformType getTransformType() const noexcept override¶

const FormatMetadata &getFormatMetadata() const noexcept = 0¶

FormatMetadata &getFormatMetadata() noexcept = 0¶

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

GradingStyle getStyle() const noexcept = 0¶: Adjusts the behavior of the transform for log, linear, or video color space encodings.

void setStyle(GradingStyle style) noexcept = 0¶: Will reset value to style’s defaults if style is not the current style.

const ConstGradingRGBCurveRcPtr getValue() const = 0¶

void setValue(const ConstGradingRGBCurveRcPtr &values) = 0¶: Throws if value is not valid.

float getSlope(RGBCurveType c, size_t index) const = 0¶: It is possible to provide a desired slope value for each control point. The number of slopes is always the same as the number of control points and so the control points must be set before setting the slopes. The slopes are primarily intended for use by config authors looking to match a specific shape with as few control points as possible, they are not intended to be exposed to a user interface for direct manipulation. When a curve is being generated for creative purposes it is better to let OCIO calculate the slopes automatically.

void setSlope(RGBCurveType c, size_t index, float slope) = 0¶

bool slopesAreDefault(RGBCurveType c) const = 0¶

bool getBypassLinToLog() const = 0¶: The scene-linear grading style applies a lin-to-log transform to the pixel values before going through the curve. However, in some cases (e.g. drawing curves in a UI) it may be useful to bypass the lin-to-log. Default value is false.

void setBypassLinToLog(bool bypass) = 0¶

bool isDynamic() const noexcept = 0¶: Parameters can be made dynamic so the values can be changed through the CPU or GPU processor, but if there are several GradingRGBCurveTransform only one can have dynamic parameters.

void makeDynamic() noexcept = 0¶

void makeNonDynamic() noexcept = 0¶

GradingRGBCurveTransform(const GradingRGBCurveTransform&) = delete¶

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

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

Public Static Functions

GradingRGBCurveTransformRcPtr Create(GradingStyle style)¶: Creates an instance of GradingPrimaryTransform.

std::ostream &OpenColorIO_v2_0::operator<<(std::ostream&, const GradingRGBCurveTransform&) noexcept¶

typedef std::shared_ptr<const GradingRGBCurveTransform> OpenColorIO_v2_0::ConstGradingRGBCurveTransformRcPtr¶

typedef std::shared_ptr<GradingRGBCurveTransform> OpenColorIO_v2_0::GradingRGBCurveTransformRcPtr¶

GradingRGBCurve¶

class PyOpenColorIO.GradingRGBCurve¶

A set of red, green, blue and master curves. It is used by RGBCurveTransform and can be used as a dynamic property (see DynamicPropertyGradingRGBCurve).

GradingRGBCurve(*args, **kwargs)¶

Overloaded function.

__init__(self: PyOpenColorIO.GradingRGBCurve, style: PyOpenColorIO.GradingStyle) -> None

Do not use (needed only for pybind11).

__init__(self: PyOpenColorIO.GradingRGBCurve, red: PyOpenColorIO.GradingBSplineCurve = <control_points=[<x=0, y=0><x=0.5, y=0.5><x=1, y=1>]>, green: PyOpenColorIO.GradingBSplineCurve = <control_points=[<x=0, y=0><x=0.5, y=0.5><x=1, y=1>]>, blue: PyOpenColorIO.GradingBSplineCurve = <control_points=[<x=0, y=0><x=0.5, y=0.5><x=1, y=1>]>, master: PyOpenColorIO.GradingBSplineCurve = <control_points=[<x=0, y=0><x=0.5, y=0.5><x=1, y=1>]>) -> None

property blue¶

property green¶

property master¶

property red¶

class OpenColorIO_v2_0::GradingRGBCurve¶

A set of red, green, blue and master curves. It is used by RGBCurveTransform and can be used as a dynamic property (see DynamicPropertyGradingRGBCurve).

Public Functions

GradingRGBCurveRcPtr createEditableCopy() const = 0¶

void validate() const = 0¶

bool isIdentity() const = 0¶

ConstGradingBSplineCurveRcPtr getCurve(RGBCurveType c) const = 0¶

GradingBSplineCurveRcPtr getCurve(RGBCurveType c) = 0¶

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

Public Static Functions

GradingRGBCurveRcPtr Create(GradingStyle style)¶

GradingRGBCurveRcPtr Create(const ConstGradingRGBCurveRcPtr &rhs)¶

GradingRGBCurveRcPtr Create(const ConstGradingBSplineCurveRcPtr &red, const ConstGradingBSplineCurveRcPtr &green, const ConstGradingBSplineCurveRcPtr &blue, const ConstGradingBSplineCurveRcPtr &master)¶

std::ostream &OpenColorIO_v2_0::operator<<(std::ostream&, const GradingRGBCurve&)¶

typedef std::shared_ptr<const GradingRGBCurve> OpenColorIO_v2_0::ConstGradingRGBCurveRcPtr¶

typedef std::shared_ptr<GradingRGBCurve> OpenColorIO_v2_0::GradingRGBCurveRcPtr¶

GradingControlPoint¶

class PyOpenColorIO.GradingControlPoint¶

2D control point used by GradingBSplineCurve.

GradingControlPoint(*args, **kwargs)¶

Overloaded function.

__init__(self: PyOpenColorIO.GradingControlPoint) -> None
__init__(self: PyOpenColorIO.GradingControlPoint, x: float = 0.0, y: float = 0.0) -> None

property x¶

property y¶

struct OpenColorIO_v2_0::GradingControlPoint¶

2D control point used by GradingBSplineCurve.

Public Functions

GradingControlPoint() = default¶

GradingControlPoint(const GradingControlPoint&) = default¶

GradingControlPoint(float x, float y)¶

Public Members

float m_x = {0.f}¶

float m_y = {0.f}¶

std::ostream &OpenColorIO_v2_0::operator<<(std::ostream&, const GradingControlPoint&)¶

GradingBSplineCurve¶

class PyOpenColorIO.GradingBSplineCurve¶

A BSpline curve defined with GradingControlPoint.

GradingBSplineCurve(*args, **kwargs)¶

Overloaded function.

__init__(self: PyOpenColorIO.GradingBSplineCurve, size: int) -> None

Create a BSpline curve with a specified number of control points.

__init__(self: PyOpenColorIO.GradingBSplineCurve, arg0: List[float]) -> None

Create a BSpline curve with a list of control points.

getControlPoints() → PyOpenColorIO.GradingBSplineCurve.GradingControlPointIterator ¶

setNumControlPoints(size: int) → None¶

validate() → None¶

class PyOpenColorIO.GradingBSplineCurve.GradingControlPointIterator¶

self[arg0: int] → PyOpenColorIO.GradingControlPoint ¶

iter(self) → PyOpenColorIO.GradingBSplineCurve.GradingControlPointIterator ¶

len(self) → int¶

next(self) → PyOpenColorIO.GradingControlPoint ¶

self[arg0: int] = arg1: PyOpenColorIO.GradingControlPoint → None¶

class OpenColorIO_v2_0::GradingBSplineCurve¶

A BSpline curve defined with GradingControlPoint.

Public Functions

GradingBSplineCurveRcPtr createEditableCopy() const = 0¶

size_t getNumControlPoints() const noexcept = 0¶

void setNumControlPoints(size_t size) = 0¶

const GradingControlPoint &getControlPoint(size_t index) const = 0¶

GradingControlPoint &getControlPoint(size_t index) = 0¶

float getSlope(size_t index) const = 0¶

void setSlope(size_t index, float slope) = 0¶

bool slopesAreDefault() const = 0¶

void validate() const = 0¶

GradingBSplineCurve(const GradingBSplineCurve&) = delete¶

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

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

Public Static Functions

GradingBSplineCurveRcPtr Create(size_t size)¶: Create a BSpline curve with a specified number of control points.

GradingBSplineCurveRcPtr Create(std::initializer_list<GradingControlPoint> values)¶: Create a BSpline curve with a list of control points.

std::ostream &OpenColorIO_v2_0::operator<<(std::ostream&, const GradingBSplineCurve&)¶

typedef std::shared_ptr<const GradingBSplineCurve> OpenColorIO_v2_0::ConstGradingBSplineCurveRcPtr¶

typedef std::shared_ptr<GradingBSplineCurve> OpenColorIO_v2_0::GradingBSplineCurveRcPtr¶

GradingToneTransform¶

class PyOpenColorIO.GradingToneTransform¶

Tonal color correction controls.

This transform is for making fine adjustments to tone reproduction in specific tonal ranges.

There are five tonal controls and each one has two parameters to control its range: - Blacks (start, width) - Shadows(start, pivot) - Midtones(center, width) - Highlights(start, pivot) - Whites(start, width)

The transform has three styles that adjust the response and default ranges for linear, logarithimic, and video color encodings. The defaults vary based on the style. When the style is linear, the units for start/width/etc. are photographic stops relative to 0.18.

Each control allows R, G, B adjustments and a Master adjustment.

There is also an S-contrast control for imparting an S-shape curve.

The controls are dynamic, so they may be adjusted even after the Transform has been included in a Processor.

GradingToneTransform(*args, **kwargs)¶

Overloaded function.

__init__(self: PyOpenColorIO.GradingToneTransform, values: PyOpenColorIO.GradingTone, style: PyOpenColorIO.GradingStyle = <GradingStyle.GRADING_LOG: 0>, dynamic: bool = False, dir: PyOpenColorIO.TransformDirection = <TransformDirection.TRANSFORM_DIR_FORWARD: 0>) -> None

Creates an instance of GradingToneTransform.

__init__(self: PyOpenColorIO.GradingToneTransform, style: PyOpenColorIO.GradingStyle = <GradingStyle.GRADING_LOG: 0>, dynamic: bool = False, dir: PyOpenColorIO.TransformDirection = <TransformDirection.TRANSFORM_DIR_FORWARD: 0>) -> None

Creates an instance of GradingToneTransform.

str(self)¶: Return str(self).

getDirection() → PyOpenColorIO.TransformDirection ¶

getFormatMetadata() → PyOpenColorIO.FormatMetadata ¶

getStyle() → PyOpenColorIO.GradingStyle ¶: Adjusts the behavior of the transform for log, linear, or video color space encodings.

getTransformType() → PyOpenColorIO.TransformType ¶

getValue() → PyOpenColorIO.GradingTone ¶

isDynamic() → bool¶: Parameters can be made dynamic so the values can be changed through the CPU or GPU processor, but if there are several GradingToneTransform only one can have dynamic parameters.

makeDynamic() → None¶

makeNonDynamic() → None¶

setDirection(direction: PyOpenColorIO.TransformDirection) → None¶: Note that this only affects the evaluation and not the values stored in the object.

setStyle(style: PyOpenColorIO.GradingStyle) → None¶: Will reset value to style’s defaults if style is not the current style.

setValue(values: PyOpenColorIO.GradingTone) → None¶

validate() → None¶: Will throw if data is not valid.

class OpenColorIO_v2_0::GradingToneTransform : public Transform ¶

Tonal color correction controls.

This transform is for making fine adjustments to tone reproduction in specific tonal ranges.

There are five tonal controls and each one has two parameters to control its range:

Blacks (start, width)
Shadows(start, pivot)
Midtones(center, width)
Highlights(start, pivot)
Whites(start, width)

The transform has three styles that adjust the response and default ranges for linear, logarithimic, and video color encodings. The defaults vary based on the style. When the style is linear, the units for start/width/etc. are photographic stops relative to 0.18.

Each control allows R, G, B adjustments and a Master adjustment.

There is also an S-contrast control for imparting an S-shape curve.

The controls are dynamic, so they may be adjusted even after the Transform has been included in a Processor.

Public Functions

TransformType getTransformType() const noexcept override¶

const FormatMetadata &getFormatMetadata() const noexcept = 0¶

FormatMetadata &getFormatMetadata() noexcept = 0¶

bool equals(const GradingToneTransform &other) const noexcept = 0¶

GradingStyle getStyle() const noexcept = 0¶: Adjusts the behavior of the transform for log, linear, or video color space encodings.

void setStyle(GradingStyle style) noexcept = 0¶: Will reset value to style’s defaults if style is not the current style.

const GradingTone &getValue() const = 0¶

void setValue(const GradingTone &values) = 0¶

bool isDynamic() const noexcept = 0¶: Parameters can be made dynamic so the values can be changed through the CPU or GPU processor, but if there are several GradingToneTransform only one can have dynamic parameters.

void makeDynamic() noexcept = 0¶

void makeNonDynamic() noexcept = 0¶

GradingToneTransform(const GradingToneTransform&) = delete¶

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

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

Public Static Functions

GradingToneTransformRcPtr Create(GradingStyle style)¶: Creates an instance of GradingToneTransform.

std::ostream &OpenColorIO_v2_0::operator<<(std::ostream&, const GradingToneTransform&) noexcept¶

typedef std::shared_ptr<const GradingToneTransform> OpenColorIO_v2_0::ConstGradingToneTransformRcPtr¶

typedef std::shared_ptr<GradingToneTransform> OpenColorIO_v2_0::GradingToneTransformRcPtr¶

GradingTone¶

class PyOpenColorIO.GradingTone¶

Grading tone values.

GradingTone(arg0: PyOpenColorIO.GradingStyle) → None¶

property blacks¶

property highlights¶

property midtones¶

property scontrast¶

property shadows¶

validate() → None¶: The valid range for each parameter varies. The client is expected to enforce these bounds in the UI.

property whites¶

struct OpenColorIO_v2_0::GradingTone¶

Grading tone values.

Public Functions

GradingTone() = delete¶

GradingTone(const GradingTone&) = default¶

GradingTone(GradingStyle style)¶

void validate() const¶: The valid range for each parameter varies. The client is expected to enforce these bounds in the UI.

Public Members

GradingRGBMSW m_blacks¶

GradingRGBMSW m_shadows¶

GradingRGBMSW m_midtones¶

GradingRGBMSW m_highlights¶

GradingRGBMSW m_whites¶

double m_scontrast = {1.0}¶

std::ostream &OpenColorIO_v2_0::operator<<(std::ostream&, const GradingTone&)¶

GradingRGBMSW¶

class PyOpenColorIO.GradingRGBMSW¶

Used by the grading tone transforms to hold the red, green, blue, master, start, and width components of a single parameter. The master component affects all three channels (RGB). The start and width components control the range of tones affected. Although this struct simply uses “start” and “width” for all the range values, the actual user-facing name changes based on the parameter.

GradingRGBMSW(*args, **kwargs)¶

Overloaded function.

__init__(self: PyOpenColorIO.GradingRGBMSW) -> None
__init__(self: PyOpenColorIO.GradingRGBMSW, red: float, green: float, blue: float, master: float, start: float, width: float) -> None
__init__(self: PyOpenColorIO.GradingRGBMSW, start: float, width: float) -> None

property blue¶

property green¶

property master¶

property red¶

property start¶

property width¶

struct OpenColorIO_v2_0::GradingRGBMSW¶

Used by the grading tone transforms to hold the red, green, blue, master, start, and width components of a single parameter. The master component affects all three channels (RGB). The start and width components control the range of tones affected. Although this struct simply uses “start” and “width” for all the range values, the actual user-facing name changes based on the parameter.

Public Functions

GradingRGBMSW() = default¶

GradingRGBMSW(const GradingRGBMSW&) = default¶

GradingRGBMSW(double red, double green, double blue, double master, double start, double width)¶

GradingRGBMSW(const double (&rgbmsw)[6])¶

GradingRGBMSW(double start, double width)¶

Public Members

double m_red = {1.}¶

double m_green = {1.}¶

double m_blue = {1.}¶

double m_master = {1.}¶

double m_start = {0.}¶

double m_width = {1.}¶

std::ostream &OpenColorIO_v2_0::operator<<(std::ostream&, const GradingRGBMSW&)¶