Esempio n. 1
0
    def test_validate_params(self):
        """
        Test the validate() method for params.
        Initialization must have the correct number of params required for the style (possibly
        none).
        """

        self.tr = OCIO.FixedFunctionTransform(style=self.TEST_STYLE,
                                              direction=self.TEST_DIRECTION)

        self.assertIsNone(self.tr.validate())

        self.tr.setParams(self.TEST_PARAMS)
        with self.assertRaises(OCIO.Exception):
            self.tr.validate()

        self.tr.setStyle(OCIO.FIXED_FUNCTION_REC2100_SURROUND)
        self.tr.setParams([0.78])
        self.assertIsNone(self.tr.validate())

        self.tr.setStyle(OCIO.FIXED_FUNCTION_ACES_GAMUT_COMP_13)
        self.tr.setParams([1.147, 1.264, 1.312, 0.815, 0.803, 0.880, 1.2])
        self.assertIsNone(self.tr.validate())

        # Invalid parameter count
        self.tr.setStyle(OCIO.FIXED_FUNCTION_ACES_GAMUT_COMP_13)
        self.tr.setParams([1.0])
        with self.assertRaises(OCIO.Exception):
            self.assertIsNone(self.tr.validate())

        # Invalid parameter range
        self.tr.setStyle(OCIO.FIXED_FUNCTION_ACES_GAMUT_COMP_13)
        self.tr.setParams([1.147, 1.264, 1.312, 0.815, 0.803, 0.880, 0.5])
        with self.assertRaises(OCIO.Exception):
            self.assertIsNone(self.tr.validate())
Esempio n. 2
0
    def test_constructor_wrong_parameter_type(self):
        """
        Test FixedFunctionTransform constructor with a wrong parameter type.
        """

        for invalid in (None, 1):
            with self.assertRaises(TypeError):
                fixed_func_tr = OCIO.FixedFunctionTransform(invalid)
Esempio n. 3
0
    def test_constructor_with_keywords(self):
        """
        Test FixedFunctionTransform constructor with keywords and validate its values.
        """

        fixed_func_tr = OCIO.FixedFunctionTransform(
            style=self.TEST_STYLE, params=[], direction=self.TEST_DIRECTION)

        self.assertEqual(fixed_func_tr.getStyle(), self.TEST_STYLE)
        self.assertEqual(fixed_func_tr.getParams(), [])
        self.assertEqual(fixed_func_tr.getDirection(), self.TEST_DIRECTION)

        # With keywords not in their proper order.
        fixed_func_tr2 = OCIO.FixedFunctionTransform(
            direction=self.TEST_DIRECTION, style=self.TEST_STYLE, params=[])

        self.assertEqual(fixed_func_tr2.getStyle(), self.TEST_STYLE)
        self.assertEqual(fixed_func_tr2.getParams(), [])
        self.assertEqual(fixed_func_tr2.getDirection(), self.TEST_DIRECTION)
Esempio n. 4
0
    def test_constructor_with_positional(self):
        """
        Test FixedFunctionTransform constructor without keywords and validate its values.
        """

        fixed_func_tr = OCIO.FixedFunctionTransform(self.TEST_STYLE, [],
                                                    self.TEST_DIRECTION)

        self.assertEqual(fixed_func_tr.getStyle(), self.TEST_STYLE)
        self.assertEqual(fixed_func_tr.getParams(), [])
        self.assertEqual(fixed_func_tr.getDirection(), self.TEST_DIRECTION)
Esempio n. 5
0
    def test_constructor_with_positional(self):
        """
        Test GroupTransform constructor without keywords and validate its values.
        """

        tr_list = [OCIO.MatrixTransform(), OCIO.FixedFunctionTransform()]

        group_tr = OCIO.GroupTransform(tr_list, self.TEST_DIRECTION)

        self.assertEqual(group_tr.__len__(), 2)
        self.assertEqual(group_tr.getDirection(), self.TEST_DIRECTION)
Esempio n. 6
0
    def test_validate_params(self):
        """
        Test the validate() method for params.
        Params must be empty on initialization.
        """

        with self.assertRaises(OCIO.Exception):
            self.fixed_func_tr = OCIO.FixedFunctionTransform(
                style=self.TEST_STYLE,
                params=self.TEST_PARAMS,
                direction=self.TEST_DIRECTION)
Esempio n. 7
0
    def test_has_channel_crosstalk(self):
        self.assertFalse(self.default_cpu_proc_fwd.hasChannelCrosstalk())
        self.assertFalse(self.default_cpu_proc_inv.hasChannelCrosstalk())
        self.assertFalse(self.half_cpu_proc_fwd.hasChannelCrosstalk())
        self.assertFalse(self.half_cpu_proc_inv.hasChannelCrosstalk())
        self.assertFalse(self.uint16_cpu_proc_fwd.hasChannelCrosstalk())
        self.assertFalse(self.uint16_cpu_proc_inv.hasChannelCrosstalk())
        self.assertFalse(self.uint8_cpu_proc_fwd.hasChannelCrosstalk())
        self.assertFalse(self.uint8_cpu_proc_inv.hasChannelCrosstalk())

        hsv_proc = self.config.getProcessor(
            OCIO.FixedFunctionTransform(OCIO.FIXED_FUNCTION_RGB_TO_HSV))
        hsv_cpu_proc = hsv_proc.getDefaultCPUProcessor()
        self.assertTrue(hsv_cpu_proc.hasChannelCrosstalk())
Esempio n. 8
0
    def test_append_transform(self):
        """
        Test the appendTransform() method.
        """

        # Default GroupTransform length should be 0 without append.
        self.assertEqual(self.group_tr.__len__(), 0)

        matrix_tr = OCIO.MatrixTransform()
        ff_tr = OCIO.FixedFunctionTransform()

        self.group_tr.appendTransform(matrix_tr)
        self.group_tr.appendTransform(ff_tr)

        self.assertEqual(self.group_tr.__len__(), 2)

        iterator = self.group_tr.__iter__()
        for i in [matrix_tr, ff_tr]:
            self.assertEqual(i, next(iterator))
Esempio n. 9
0
    def test_constructor_with_keywords(self):
        """
        Test GroupTransform constructor with keywords and validate its values.
        """

        tr_list = [OCIO.MatrixTransform(), OCIO.FixedFunctionTransform()]

        group_tr = OCIO.GroupTransform(transforms=tr_list,
                                       direction=self.TEST_DIRECTION)

        self.assertEqual(group_tr.__len__(), 2)
        self.assertEqual(group_tr.getDirection(), self.TEST_DIRECTION)

        # With keywords not in their proper order.
        group_tr2 = OCIO.GroupTransform(direction=self.TEST_DIRECTION,
                                        transforms=tr_list)

        self.assertEqual(group_tr2.__len__(), 2)
        self.assertEqual(group_tr2.getDirection(), self.TEST_DIRECTION)
    def test_validate_params(self):
        """
        Test the validate() method for params.
        Initialization must have the correct number of params required for the style (possibly
        none).
        """

        self.fixed_func_tr = OCIO.FixedFunctionTransform(
            style=self.TEST_STYLE, direction=self.TEST_DIRECTION)

        self.assertIsNone(self.fixed_func_tr.validate())

        self.fixed_func_tr.setParams(self.TEST_PARAMS)
        with self.assertRaises(OCIO.Exception):
            self.fixed_func_tr.validate()

        self.fixed_func_tr.setStyle(OCIO.FIXED_FUNCTION_REC2100_SURROUND)
        self.fixed_func_tr.setParams([0.78])
        self.assertIsNone(self.fixed_func_tr.validate())
Esempio n. 11
0
    def test_prepend_transform(self):
        """
        Test the prependTransform() method.
        """

        # Default GroupTransform length should be 0 without prepend.
        self.assertEqual(self.group_tr.__len__(), 0)

        matrix_tr = OCIO.MatrixTransform()
        ff_tr = OCIO.FixedFunctionTransform()

        self.group_tr.prependTransform(matrix_tr)
        self.group_tr.prependTransform(ff_tr)

        self.assertEqual(self.group_tr.__len__(), 2)

        # FixedFunctionTransform goes in front due to prepend.
        iterator = self.group_tr.__iter__()
        for i in [ff_tr, matrix_tr]:
            self.assertEqual(i, next(iterator))
Esempio n. 12
0
    def test_constructor_with_keywords(self):
        """
        Test FixedFunctionTransform constructor with keywords and validate its values.
        Initialization must have the correct number of params required for the style (possibly
        none).
        """

        fixed_func_tr = OCIO.FixedFunctionTransform(
            style=self.TEST_STYLE,
            params=[],
            direction=self.TEST_DIRECTION)

        self.assertEqual(fixed_func_tr.getStyle(), self.TEST_STYLE)
        self.assertEqual(fixed_func_tr.getParams(), [])
        self.assertEqual(fixed_func_tr.getDirection(), self.TEST_DIRECTION)

        # With keywords not in their proper order.
        fixed_func_tr2 = OCIO.FixedFunctionTransform(
            direction=self.TEST_DIRECTION,
            style=self.TEST_STYLE,
            params=[])

        self.assertEqual(fixed_func_tr2.getStyle(), self.TEST_STYLE)
        self.assertEqual(fixed_func_tr2.getParams(), [])
        self.assertEqual(fixed_func_tr2.getDirection(), self.TEST_DIRECTION)

        with self.assertRaises(OCIO.Exception):
            self.tr = OCIO.FixedFunctionTransform(
                style=self.TEST_STYLE,
                params=self.TEST_PARAMS,
                direction=self.TEST_DIRECTION)

        self.tr = OCIO.FixedFunctionTransform(
            style=OCIO.FIXED_FUNCTION_REC2100_SURROUND,
            params=[0.78])

        params = self.tr.getParams()
        self.assertEqual(len(params), 1)
        self.assertEqual(params[0], 0.78)

        with self.assertRaises(OCIO.Exception):
            self.tr = OCIO.FixedFunctionTransform(
                style=OCIO.FIXED_FUNCTION_REC2100_SURROUND,
                params=[0.78, 0.42])

        with self.assertRaises(OCIO.Exception):
            self.tr = OCIO.FixedFunctionTransform(
                style=OCIO.FIXED_FUNCTION_REC2100_SURROUND)
Esempio n. 13
0
 def setUp(self):
     self.tr = OCIO.FixedFunctionTransform(
         OCIO.FIXED_FUNCTION_ACES_RED_MOD_03)
    def test_get_processor(self):
        """
        Test the getProcessor function.
        """
        cfg = OCIO.Config().CreateFromStream(SAMPLE_CONFIG)
        dvt = OCIO.DisplayViewTransform(src='in_1', display='DISP_2', view='VIEW_2')
        pipeline = OCIO.LegacyViewingPipeline()
        pipeline.setDisplayViewTransform(dvt)

        mat = OCIO.MatrixTransform.Scale([1.1, 1.2, 1.1, 1.])
        pipeline.setChannelView(mat)
        ff = OCIO.FixedFunctionTransform()
        pipeline.setLinearCC(ff)

        proc = pipeline.getProcessor(cfg)
        grp = proc.createGroupTransform()
        self.assertEqual(len(grp), 8)

        # Color space conversion from in_1 to scene_linear role (lin_1 color space).

        t = grp[0]
        self.assertEqual(t.getTransformType(), OCIO.TRANSFORM_TYPE_EXPONENT)
        self.assertEqual(t.getDirection(), OCIO.TRANSFORM_DIR_FORWARD)
        self.assertEqual(t.getValue(), [2.6, 2.6, 2.6, 1.])

        # LinearCC transform.

        t = grp[1]
        self.assertEqual(t.getTransformType(), OCIO.TRANSFORM_TYPE_FIXED_FUNCTION)
        self.assertEqual(t.getDirection(), OCIO.TRANSFORM_DIR_FORWARD)

        # Apply the looks, channel view, and view transform.

        # Lin_1 to look3 process space (log_1).

        t = grp[2]
        self.assertEqual(t.getTransformType(), OCIO.TRANSFORM_TYPE_LOG)
        self.assertEqual(t.getDirection(), OCIO.TRANSFORM_DIR_FORWARD)
        self.assertEqual(t.getBase(), 2.)

        # Look_3 transform.

        t = grp[3]
        self.assertEqual(t.getTransformType(), OCIO.TRANSFORM_TYPE_CDL)
        self.assertEqual(t.getDirection(), OCIO.TRANSFORM_DIR_FORWARD)
        self.assertEqual(t.getSlope(), [1., 2., 1.])

        # Look_3 & look_4 have the same process space, no color space conversion.

        # Look_4 transform.

        t = grp[4]
        self.assertEqual(t.getTransformType(), OCIO.TRANSFORM_TYPE_CDL)
        self.assertEqual(t.getDirection(), OCIO.TRANSFORM_DIR_INVERSE)
        self.assertEqual(t.getSlope(), [1.2, 2.2, 1.2])

        # Channel View transform (no color space conversion).

        t = grp[5]
        self.assertEqual(t.getTransformType(), OCIO.TRANSFORM_TYPE_MATRIX)
        self.assertEqual(t.getDirection(), OCIO.TRANSFORM_DIR_FORWARD)
        m44 = t.getMatrix()
        self.assertEqual(m44[0],  1.1)
        self.assertEqual(m44[1],  0)
        self.assertEqual(m44[2],  0)
        self.assertEqual(m44[3],  0)
        self.assertEqual(m44[5],  1.2)
        self.assertEqual(m44[10],  1.1)

        # Look_4 process color space (log_1) to reference.

        t = grp[6]
        self.assertEqual(t.getTransformType(), OCIO.TRANSFORM_TYPE_LOG)
        self.assertEqual(t.getDirection(), OCIO.TRANSFORM_DIR_INVERSE)
        self.assertEqual(t.getBase(), 2.)

        # Reference to view_2 color space.

        t = grp[7]
        self.assertEqual(t.getTransformType(), OCIO.TRANSFORM_TYPE_EXPONENT)
        self.assertEqual(t.getDirection(), OCIO.TRANSFORM_DIR_INVERSE)
        self.assertEqual(t.getValue(), [2.4, 2.4, 2.4, 1.])
Esempio n. 15
0
 def setUp(self):
     self.fixed_func_tr = OCIO.FixedFunctionTransform()