Merge pull request #99 from ampas/feature/calculate_camera_npm_and_primaries

Feature/calculate camera npm and primaries

Author: KelSolaar

aces/idt/core/common.py

@@ -91,6 +91,7 @@
     "calculate_clipped_exposures",
     "create_samples_macbeth_image",
     "interpolate_nan_values",
+    "calculate_camera_npm_and_primaries_wp",
 ]
 
 LOGGER = logging.getLogger(__name__)
@@ -968,3 +969,58 @@ def interpolate_nan_values(array: np.array) -> np.array:
     final_array = np.where(np.isnan(array), interpolated_df.to_numpy(), array)
 
     return final_array
+
+
+def calculate_camera_npm_and_primaries_wp(
+    input_matrix: np.array,
+    target_white_point: str = "D65",
+    cat: str = "Bradford",
+    observer: str = "CIE 1931 2 Degree Standard Observer",
+) -> Tuple[np.array, np.array, np.array]:
+    """
+    Calculate the camera's npm matrix (RGB to XYZ), it also returns the cameras
+    primaries, and whitepoint.
+
+    Parameters
+    ----------
+    input_matrix: np.array
+        The camera's calculated or known RGB to ACES2065-1 matrix
+
+    target_white_point: str
+        The target whitepoint to calculate the camera's npm matrix for
+    cat: str
+        The chromatic adaptation transform to use
+
+    observer: str
+        The observer to use for the chromatic adaptation
+
+    Returns
+    -------
+    Tuple[np.array, np.array, np.array]
+        The camera's npm matrix, the camera's primaries, and the camera's whitepoint
+
+    """
+
+    camera_rgb_to_xyz = RGB_COLOURSPACE_ACES2065_1.matrix_RGB_to_XYZ @ np.array(
+        input_matrix
+    )
+
+    # Get the xy chromaticity coordinates of the source and target whitepoints
+    source_whitepoint_xy = colour.CCS_ILLUMINANTS[observer]["D60"]
+    target_whitepoint_xy = colour.CCS_ILLUMINANTS[observer][target_white_point]
+
+    # Convert chromaticity coordinates to XYZ tristimulus values
+    source_whitepoint = colour.xy_to_XYZ(source_whitepoint_xy)
+    target_whitepoint = colour.xy_to_XYZ(target_whitepoint_xy)
+
+    # Compute the chromatic adaptation matrix using the given CAT
+    cat_matrix = colour.adaptation.matrix_chromatic_adaptation_VonKries(
+        source_whitepoint, target_whitepoint, transform=cat
+    )
+
+    # Apply the chromatic adaptation matrix to the camera's RGB to XYZ matrix
+    computed_camera_npm = cat_matrix @ camera_rgb_to_xyz
+
+    # Compute the camera's whitepoint and primaries
+    primaries, whitepoint = colour.primaries_whitepoint(computed_camera_npm)
+    return computed_camera_npm, primaries, whitepoint

aces/idt/generators/base_generator.py

@@ -117,6 +117,9 @@ def __init__(self, project_settings):
         self._M = None
         self._RGB_w = None
         self._k = None
+        self._npm = None
+        self._primaries = None
+        self._whitepoint = None
 
         self._image_grey_card_sampling = None
         self._image_colour_checker_segmentation = None
@@ -283,6 +286,45 @@ def k(self) -> NDArrayFloat | None:
 
         return self._k
 
+    @property
+    def npm(self) -> NDArrayFloat | None:
+        """
+        Getter property for the camera's RGB to XYZ matrix.
+
+        Returns
+        -------
+        :class:`NDArray` or None
+            Camera's RGB to XYZ matrix.
+        """
+
+        return self._npm
+
+    @property
+    def primaries(self) -> NDArrayFloat | None:
+        """
+        Getter property for the camera's primaries.
+
+        Returns
+        -------
+        :class:`NDArray` or None
+            Camera's primaries.
+        """
+
+        return self._primaries
+
+    @property
+    def whitepoint(self) -> NDArrayFloat | None:
+        """
+        Getter property for the camera's whitepoint.
+
+        Returns
+        -------
+        :class:`NDArray` or None
+            Camera's whitepoint.
+        """
+
+        return self._whitepoint
+
     @property
     def samples_analysis(self) -> NDArrayFloat | None:
         """

aces/idt/generators/prosumer_camera.py

@@ -496,6 +496,17 @@ def optimise(self) -> Tuple[NDArrayFloat]:
 
         self._M = finaliser_function(self._M)
 
+        # Calculate and store the camera npm, the primaries and the whitepoint
+        (
+            self._npm,
+            self._primaries,
+            self._whitepoint,
+        ) = common.calculate_camera_npm_and_primaries_wp(
+            self._M,
+            target_white_point=self.project_settings.illuminant,
+            cat=self.project_settings.cat,
+        )
+
         return self._M, self._RGB_w, self._k
 
     def png_measured_camera_samples(self) -> str | None:

tests/test_common.py

@@ -45,6 +45,34 @@ def test_generate_reference_colour_checker(self):
         result = common.generate_reference_colour_checker()
         self.assertTrue(np.allclose(expected, result, atol=1e-20))
 
+    def test_calculate_camera_npm_and_primaries_wp(self):
+        """Test generating a camera npm from an RGB to AP0 matrix"""
+        input_matrix = [
+            [0.785043, 0.083844, 0.131118],
+            [0.023172, 1.087892, -0.111055],
+            [-0.073769, -0.314639, 1.388537],
+        ]
+
+        npm, primaries, wp = common.calculate_camera_npm_and_primaries_wp(input_matrix)
+
+        expected_npm = [
+            [0.7353579, 0.06867992, 0.14646275],
+            [0.28673187, 0.84296573, -0.1297009],
+            [-0.07965591, -0.34720223, 1.5155319],
+        ]
+
+        expected_primaries = [
+            [0.7802753326723714, 0.3042461485259778],
+            [0.1216772523298739, 1.4934459215643787],
+            [0.09558399073520502, -0.08464493023427101],
+        ]
+
+        expected_wp = [0.31274994, 0.32903601]
+
+        self.assertTrue(np.allclose(expected_npm, npm, atol=1e-6))
+        self.assertTrue(np.allclose(expected_primaries, primaries, atol=1e-6))
+        self.assertTrue(np.allclose(expected_wp, wp, atol=1e-6))
+
 
 class TestExposureClippingMask(TestIDTBase):
     """