wip new API

Author: MichaelMauderer

colour_clf_io/__init__.py

@@ -103,6 +103,13 @@
 __change_version__ = "1"
 __version__ = f"{__major_version__}.{__minor_version__}.{__change_version__}"
 
+try:
+    from colour_clf_io.processing import CLFProcessList
+
+    __all__ += ["CLFProcessList"]
+except ImportError:
+    pass
+
 
 def read_clf_from_file(path: str | Path) -> ProcessList:
     """

colour_clf_io/processing.py

@@ -833,48 +833,65 @@ def as_LUT_sequence_item(  # noqa: PLR0911
     raise RuntimeError(message)
 
 
-def apply(
-    process_list: clf.ProcessList,
-    value: NDArrayFloat,
-    normalised_values: bool = False,
-) -> NDArrayFloat:
-    """
-    Apply the transformation described by the given :class:`colour_clf_io.ProcessList`
-    to the given value.
-
-    Parameters
-    ----------
-        process_list
-            The :class:`colour_clf_io.ProcessList` instance to apply.
-        value
-            Input value in the form of an array. Shape and data format need to be
-            compatible with the given `process_list`.
-        normalised_values
-            Indicates whether the input values are normalised to the range 0..1. If
-            this is the case, the range will be expanded to the input range expected
-            by the given `process_list`.
-
-    Returns
-    -------
-    :class:`NDArrayFloat`
-        Result of applying the given :class:`colour_clf_io.ProcessList`.
-
-    Raises
-    ------
-    :class:`CLFExecutionError`
-        If the given *process_list* is invalid according to the CLF specification
-        (e.g., missing or invalid parameters).
-    """
-    if not normalised_values:
-        value = value / process_list.process_nodes[0].in_bit_depth.scale_factor()
-
-    lut_sequence_items = [
-        as_LUT_sequence_item(node) for node in process_list.process_nodes
-    ]
-    sequence = LUTSequence(*lut_sequence_items)
-    result = sequence.apply(value)
-
-    if not normalised_values:
-        result = result * process_list.process_nodes[-1].out_bit_depth.scale_factor()
-
-    return result
+# def apply(
+#     process_list: clf.ProcessList,
+#     value: NDArrayFloat,
+#     normalised_values: bool = False,
+# ) -> NDArrayFloat:
+#     """
+#     Apply the transformation described by the given :class:`colour_clf_io.ProcessList`
+#     to the given value.
+#
+#     Parameters
+#     ----------
+#         process_list
+#             The :class:`colour_clf_io.ProcessList` instance to apply.
+#         value
+#             Input value in the form of an array. Shape and data format need to be
+#             compatible with the given `process_list`.
+#         normalised_values
+#             Indicates whether the input values are normalised to the range 0..1. If
+#             this is the case, the range will be expanded to the input range expected
+#             by the given `process_list`.
+#
+#     Returns
+#     -------
+#     :class:`NDArrayFloat`
+#         Result of applying the given :class:`colour_clf_io.ProcessList`.
+#
+#     Raises
+#     ------
+#     :class:`CLFExecutionError`
+#         If the given *process_list* is invalid according to the CLF specification
+#         (e.g., missing or invalid parameters).
+#     """
+#     if not normalised_values:
+#         value = value / process_list.process_nodes[0].in_bit_depth.scale_factor()
+#
+#     lut_sequence_items = [
+#         as_LUT_sequence_item(node) for node in process_list.process_nodes
+#     ]
+#     sequence = LUTSequence(*lut_sequence_items)
+#     result = sequence.apply(value)
+#
+#     if not normalised_values:
+#         result = result * process_list.process_nodes[-1].out_bit_depth.scale_factor()
+#
+#     return result
+
+
+class CLFProcessList(LUTSequence):
+    """
+    Defines a *LUT* sequence created from a `colour_clf_io.ProcessList`. Creates the
+    nodes needed to execute the transformation described in the *Process List*.
+    """
+
+    def __init__(
+        self,
+        process_list: clf.ProcessList,
+    ) -> None:
+        lut_sequence_items = [
+            as_LUT_sequence_item(node) for node in process_list.process_nodes
+        ]
+        sequence = LUTSequence(*lut_sequence_items)
+        super().__init__(*sequence)

colour_clf_io/tests/processing/test_common.py

@@ -10,7 +10,7 @@
 import numpy as np
 
 import colour_clf_io as clf
-from colour_clf_io.processing import apply
+from colour_clf_io.processing import CLFProcessList
 
 __all__ = [
     "assert_ocio_consistency",
@@ -100,6 +100,35 @@ def result_as_array(result_text: str) -> NDArrayFloat:
     return np.array(result_values)
 
 
+def apply_input_normalisation(
+    process_list: clf.processing.CLFProcessList,
+    lut_sequence: clf.processing.CLFProcessList,
+) -> None:
+    input_scale = process_list.process_nodes[0].in_bit_depth.scale_factor()
+    output_scale = process_list.process_nodes[-1].out_bit_depth.scale_factor()
+
+    pre_scaling_node = clf.processing.Range(
+        clf.Range(
+            min_in_value=0,
+            max_in_value=input_scale,
+            min_out_value=0,
+            max_out_value=1,
+            style=clf.RangeStyle.NO_CLAMP,
+        )
+    )
+    post_scaling_node = clf.processing.Range(
+        clf.Range(
+            min_in_value=0,
+            max_in_value=1,
+            min_out_value=0,
+            max_out_value=output_scale,
+        )
+    )
+    sequence = process_list.sequence
+    sequence = [pre_scaling_node, *sequence, post_scaling_node]
+    process_list.sequence = sequence
+
+
 def assert_ocio_consistency(
     value: NDArrayFloat, snippet: str, err_msg: str = "", decimals: int = 5
 ) -> None:
@@ -110,7 +139,9 @@ def assert_ocio_consistency(
     if process_list is None:
         err = "Invalid CLF snippet."
         raise AssertionError(err)
-    process_list_output = apply(process_list, value, normalised_values=True)
+    lut_sequence = CLFProcessList(process_list)
+    apply_input_normalisation(process_list, lut_sequence)
+    process_list_output = lut_sequence.apply(value)
     value_tuple = value[0], value[1], value[2]
     ocio_output = ocio_output_for_snippet(snippet, value_tuple)
     # Note: OCIO only accepts 16-bit floats so the precision agreement is limited.
@@ -119,17 +150,19 @@ def assert_ocio_consistency(
     )
 
 
-def assert_ocio_consistency_for_file(value_rgb: NDArrayFloat, clf_path: str) -> None:
+def assert_ocio_consistency_for_file(value: NDArrayFloat, clf_path: str) -> None:
     """Assert that the colour library calculates the same output as the OCIO reference
     implementation for the given file.
     """
 
-    clf_data = clf.read_clf_from_file(clf_path)
-    if clf_data is None:
+    process_list = clf.read_clf_from_file(clf_path)
+    if process_list is None:
         err = "Invalid CLF snippet."
         raise AssertionError(err)
-    process_list_output = apply(clf_data, value_rgb, normalised_values=True)
-    ocio_output = ocio_output_for_file(clf_path, value_rgb)
+    lut_sequence = CLFProcessList(process_list)
+    apply_input_normalisation(process_list, lut_sequence)
+    process_list_output = lut_sequence.apply(value)
+    ocio_output = ocio_output_for_file(clf_path, value)
     np.testing.assert_array_almost_equal(process_list_output, ocio_output)