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)