def test_rgbcurve(self):
"""
Test the GradingRGBCurve, creation, default value, modification.
"""
rgbLin = OCIO.GradingRGBCurve(OCIO.GRADING_LIN)
defLin = OCIO.GradingBSplineCurve(3)
cpts = defLin.getControlPoints()
cpts[0] = OCIO.GradingControlPoint(-7, -7)
cpts[1] = OCIO.GradingControlPoint(0, 0)
cpts[2] = OCIO.GradingControlPoint(7, 7)
assertEqualBSpline(self, rgbLin.red, defLin)
assertEqualBSpline(self, rgbLin.green, defLin)
assertEqualBSpline(self, rgbLin.blue, defLin)
assertEqualBSpline(self, rgbLin.master, defLin)
rgbLog = OCIO.GradingRGBCurve(OCIO.GRADING_LOG)
defLog = OCIO.GradingBSplineCurve(3)
cpts = defLog.getControlPoints()
cpts[0] = OCIO.GradingControlPoint(0, 0)
cpts[1] = OCIO.GradingControlPoint(0.5, 0.5)
cpts[2] = OCIO.GradingControlPoint(1, 1)
assertEqualBSpline(self, rgbLog.red, defLog)
assertEqualBSpline(self, rgbLog.green, defLog)
assertEqualBSpline(self, rgbLog.blue, defLog)
assertEqualBSpline(self, rgbLog.master, defLog)
with self.assertRaises(AssertionError):
assertEqualBSpline(self, rgbLog.master, defLin)
rgbVideo = OCIO.GradingRGBCurve(OCIO.GRADING_LOG)
assertEqualRGBCurve(self, rgbLog, rgbVideo)
def test_bspline(self):
"""
Test the GradingBSplineCurve: creation, control point modification, validation.
"""
bs = OCIO.GradingBSplineCurve(5)
cpts = bs.getControlPoints()
# First control point (i.e. cpts[0]) defaults to {0, 0}.
cpts[1] = OCIO.GradingControlPoint(0.1, 0.5)
cpts[2] = OCIO.GradingControlPoint(0.4, 0.6)
cpts[3] = OCIO.GradingControlPoint(0.6, 0.7)
cpts[4] = OCIO.GradingControlPoint(1, 1)
self.assertIsNone(bs.validate())
# Move point 4 before point 3 on the x axis so that the control points are not anymore
# monotonic. Then, it must throw an exception.
cpts[4] = OCIO.GradingControlPoint(0.5, 1)
with self.assertRaises(OCIO.Exception):
bs.validate()
# Restore valid data.
cpts[4] = OCIO.GradingControlPoint(1, 1)
bs2 = OCIO.GradingBSplineCurve(
[0, 0, 0.1, 0.5, 0.4, 0.6, 0.6, 0.7, 1, 1])
cpts2 = bs2.getControlPoints()
assertEqualBSpline(self, bs, bs2)
bs3 = OCIO.GradingBSplineCurve(4)
cpts3 = bs3.getControlPoints()
cpts3[1] = OCIO.GradingControlPoint(0.1, 0.5)
cpts3[2] = OCIO.GradingControlPoint(0.4, 0.6)
cpts3[3] = OCIO.GradingControlPoint(0.6, 0.7)
with self.assertRaises(AssertionError):
assertEqualBSpline(self, bs, bs3)
bs4 = OCIO.GradingBSplineCurve(6)
cpts4 = bs4.getControlPoints()
cpts4[1] = OCIO.GradingControlPoint(0.1, 0.5)
cpts4[2] = OCIO.GradingControlPoint(0.4, 0.6)
cpts4[3] = OCIO.GradingControlPoint(0.6, 0.7)
cpts4[4] = OCIO.GradingControlPoint(1, 1)
cpts4[5] = OCIO.GradingControlPoint(1.2, 1.1)
with self.assertRaises(AssertionError):
assertEqualBSpline(self, bs, bs4)
bs5 = OCIO.GradingBSplineCurve(5)
cpts5 = bs5.getControlPoints()
cpts5[1] = OCIO.GradingControlPoint(0.1, 0.5)
# Different x value.
cpts5[2] = OCIO.GradingControlPoint(0.5, 0.6)
cpts5[3] = OCIO.GradingControlPoint(0.6, 0.7)
cpts5[4] = OCIO.GradingControlPoint(1, 1)
with self.assertRaises(AssertionError):
assertEqualBSpline(self, bs, bs5)
def test_vector_uniform(self):
if not np:
logger.warning("NumPy not found. Skipping test!")
return
# Test dynamic GradingRGBCurve
a_curve = OCIO.GradingBSplineCurve([1.0, 2.0, 3.0, 4.0])
rgb_curve = OCIO.GradingRGBCurve(a_curve, a_curve, a_curve, a_curve)
tr = OCIO.GradingRGBCurveTransform(values=rgb_curve, dynamic=True)
config = OCIO.Config()
proc = config.getProcessor(tr)
desc = OCIO.GpuShaderDesc.CreateShaderDesc()
gpu_proc = proc.getDefaultGPUProcessor()
gpu_proc.extractGpuShaderInfo(desc)
uniforms = desc.getUniforms()
self.assertEqual(len(uniforms), 5)
self.assertEqual(uniforms[0][0], "ocio_grading_rgbcurve_knotsOffsets")
self.assertEqual(uniforms[0][1].type, OCIO.UNIFORM_VECTOR_INT)
vector_int = uniforms[0][1].getVectorInt()
self.assertTrue(isinstance(vector_int, np.ndarray))
self.assertEqual(vector_int.dtype, np.intc)
self.assertTrue(
np.array_equal(vector_int,
np.array([0, 2, 2, 2, 4, 2, 6, 2], dtype=np.intc)))
self.assertEqual(uniforms[1][0], "ocio_grading_rgbcurve_knots")
self.assertEqual(uniforms[1][1].type, OCIO.UNIFORM_VECTOR_FLOAT)
vector_float = uniforms[1][1].getVectorFloat()
self.assertTrue(isinstance(vector_float, np.ndarray))
self.assertEqual(vector_float.dtype, np.float32)
self.assertTrue(
np.array_equal(
vector_float,
np.array([1.0, 3.0, 1.0, 3.0, 1.0, 3.0, 1.0, 3.0],
dtype=np.float32)))
# Can dynamically modify uniforms
b_curve = OCIO.GradingBSplineCurve([5.0, 6.0, 7.0, 8.0])
dyn_rgb_curve = desc.getDynamicProperty(
OCIO.DYNAMIC_PROPERTY_GRADING_RGBCURVE)
dyn_rgb_curve.setGradingRGBCurve(
OCIO.GradingRGBCurve(b_curve, b_curve, b_curve, b_curve))
self.assertTrue(
np.array_equal(
uniforms[1][1].getVectorFloat(),
np.array([5.0, 7.0, 5.0, 7.0, 5.0, 7.0, 5.0, 7.0],
dtype=np.float32)))
def test_contructor(self):
"""
Test GradingRGBCurveTransform constructor without and with keywords.
"""
gct = OCIO.GradingRGBCurveTransform()
self.assertEqual(gct.getStyle(), OCIO.GRADING_LOG)
assertEqualRGBCurve(self, gct.getValue(), self.valDefaultLog)
self.assertEqual(gct.isDynamic(), False)
self.assertEqual(gct.getBypassLinToLog(), False)
self.assertEqual(gct.getDirection(), OCIO.TRANSFORM_DIR_FORWARD)
gct = OCIO.GradingRGBCurveTransform(OCIO.GRADING_LIN)
self.assertEqual(gct.getStyle(), OCIO.GRADING_LIN)
assertEqualRGBCurve(self, gct.getValue(), self.valDefaultLin)
self.assertEqual(gct.isDynamic(), False)
self.assertEqual(gct.getBypassLinToLog(), False)
self.assertEqual(gct.getDirection(), OCIO.TRANSFORM_DIR_FORWARD)
vals = OCIO.GradingRGBCurve(OCIO.GRADING_LOG)
vals.red = OCIO.GradingBSplineCurve(4)
cpts = vals.red.getControlPoints()
cpts[0] = OCIO.GradingControlPoint(0.0, 0.1)
cpts[1] = OCIO.GradingControlPoint(0.1, 0.5)
cpts[2] = OCIO.GradingControlPoint(0.4, 0.6)
cpts[3] = OCIO.GradingControlPoint(0.6, 0.7)
gct = OCIO.GradingRGBCurveTransform(style=OCIO.GRADING_VIDEO,
values=vals,
dynamic=True,
dir=OCIO.TRANSFORM_DIR_INVERSE)
self.assertEqual(gct.getStyle(), OCIO.GRADING_VIDEO)
self.assertEqual(gct.isDynamic(), True)
self.assertEqual(gct.getDirection(), OCIO.TRANSFORM_DIR_INVERSE)
assertEqualRGBCurve(self, gct.getValue(), vals)
def test_apply_inverse(self):
"""
Test applying transform with inversion.
"""
gct = OCIO.GradingRGBCurveTransform(OCIO.GRADING_LOG)
vals = OCIO.GradingRGBCurve(OCIO.GRADING_LOG)
vals.red = OCIO.GradingBSplineCurve(
[0, 0, 0.4, 0.2, 0.5, 0.7, 0.6, 1.5, 1, 2.1])
vals.green = OCIO.GradingBSplineCurve([-0.1, -0.5, 0.5, 0.2, 1.5, 1.1])
vals.blue = OCIO.GradingBSplineCurve([0, 0, 1, 1])
vals.master = OCIO.GradingBSplineCurve(
[0, -0.2, 0.3, 0.7, 1.2, 1.5, 2.5, 2.2])
gct.setValue(vals)
cfg = OCIO.Config().CreateRaw()
proc = cfg.getProcessor(gct)
cpu = proc.getDefaultCPUProcessor()
# Apply the transform and keep the result.
pixel = [0.48, 0.18, 0.18]
rgb1 = cpu.applyRGB(pixel)
# The processing did something.
self.assertAlmostEqual(1.010323, rgb1[0], delta=1e-5)
self.assertAlmostEqual(-0.770639, rgb1[1], delta=1e-5)
self.assertAlmostEqual(0.398450, rgb1[2], delta=1e-5)
# Invert.
gct.setDirection(OCIO.TRANSFORM_DIR_INVERSE)
proc = cfg.getProcessor(gct)
cpu = proc.getDefaultCPUProcessor()
pixel2 = cpu.applyRGB(rgb1)
# Invert back to original value.
self.assertAlmostEqual(pixel[0], pixel2[0], delta=1e-5)
self.assertAlmostEqual(pixel[1], pixel2[1], delta=1e-5)
self.assertAlmostEqual(pixel[2], pixel2[2], delta=1e-5)
def test_validation(self):
"""
Test validate() and setValue().
"""
gct = OCIO.GradingRGBCurveTransform(OCIO.GRADING_LOG)
gct.validate()
# 3rd control point x is lower than 2nd control point x.
vals = OCIO.GradingRGBCurve(OCIO.GRADING_LOG)
vals.red = OCIO.GradingBSplineCurve([0, 0, 0.5, 0.2, 0.2, 0.5, 1, 1])
with self.assertRaises(OCIO.Exception):
gct.setValue(vals)
def test_apply_with_slopes(self):
"""
Test applying transform with supplied slopes.
"""
gct = OCIO.GradingRGBCurveTransform(OCIO.GRADING_LOG)
vals = OCIO.GradingRGBCurve(OCIO.GRADING_LOG)
vals.master = OCIO.GradingBSplineCurve([
-5.26017743, -4., -3.75502745, -3.57868829, -2.24987747,
-1.82131329, -0.74472749, 0.68124124, 1.06145248, 2.87457742,
2.86763245, 3.83406206, 4.67381243, 4.
])
gct.setValue(vals)
self.assertEqual(gct.slopesAreDefault(OCIO.RGB_MASTER), True)
slopes = [0., 0.55982688, 1.77532247, 1.55, 0.8787017, 0.18374463, 0.]
for i in range(0, len(slopes)):
gct.setSlope(OCIO.RGB_MASTER, i, slopes[i])
gct.validate()
self.assertAlmostEqual(1.55,
gct.getSlope(OCIO.RGB_MASTER, 3),
delta=1e-5)
self.assertEqual(gct.slopesAreDefault(OCIO.RGB_MASTER), False)
self.assertEqual(gct.slopesAreDefault(OCIO.RGB_RED), True)
cfg = OCIO.Config().CreateRaw()
proc = cfg.getProcessor(gct)
cpu = proc.getDefaultCPUProcessor()
# Apply the transform and keep the result.
pixel = [-3., -1., 1.]
rgb1 = cpu.applyRGB(pixel)
# Test that the slopes were used (the values are significantly different without slopes).
self.assertAlmostEqual(-2.92582282, rgb1[0], delta=1e-5)
self.assertAlmostEqual(0.28069129, rgb1[1], delta=1e-5)
self.assertAlmostEqual(2.81987724, rgb1[2], delta=1e-5)
