Port Dynamic Color to C++.

PiperOrigin-RevId: 527822851

Author: Material Eng

cpp/cam/cam.cc

@@ -18,8 +18,6 @@
 
 #include <assert.h>
 #include <math.h>
-#include <stdio.h>
-#include <stdlib.h>
 
 #include "cpp/cam/hct_solver.h"
 #include "cpp/cam/viewing_conditions.h"
@@ -206,4 +204,60 @@ Argb IntFromHcl(double hue, double chroma, double lstar) {
   return SolveToInt(hue, chroma, lstar);
 }
 
+Cam CamFromXyzAndViewingConditions(
+    double x, double y, double z, const ViewingConditions &viewing_conditions) {
+  // Convert XYZ to 'cone'/'rgb' responses
+  double r_c = 0.401288 * x + 0.650173 * y - 0.051461 * z;
+  double g_c = -0.250268 * x + 1.204414 * y + 0.045854 * z;
+  double b_c = -0.002079 * x + 0.048952 * y + 0.953127 * z;
+
+  // Discount illuminant.
+  double r_d = viewing_conditions.rgb_d[0] * r_c;
+  double g_d = viewing_conditions.rgb_d[1] * g_c;
+  double b_d = viewing_conditions.rgb_d[2] * b_c;
+
+  // Chromatic adaptation.
+  double r_af = pow(viewing_conditions.fl * fabs(r_d) / 100.0, 0.42);
+  double g_af = pow(viewing_conditions.fl * fabs(g_d) / 100.0, 0.42);
+  double b_af = pow(viewing_conditions.fl * fabs(b_d) / 100.0, 0.42);
+  double r_a = Signum(r_d) * 400.0 * r_af / (r_af + 27.13);
+  double g_a = Signum(g_d) * 400.0 * g_af / (g_af + 27.13);
+  double b_a = Signum(b_d) * 400.0 * b_af / (b_af + 27.13);
+
+  // Redness-greenness
+  double a = (11.0 * r_a + -12.0 * g_a + b_a) / 11.0;
+  double b = (r_a + g_a - 2.0 * b_a) / 9.0;
+  double u = (20.0 * r_a + 20.0 * g_a + 21.0 * b_a) / 20.0;
+  double p2 = (40.0 * r_a + 20.0 * g_a + b_a) / 20.0;
+
+  double radians = atan2(b, a);
+  double degrees = radians * 180.0 / kPi;
+  double hue = SanitizeDegreesDouble(degrees);
+  double hue_radians = hue * kPi / 180.0;
+  double ac = p2 * viewing_conditions.nbb;
+
+  double j = 100.0 * pow(ac / viewing_conditions.aw,
+                         viewing_conditions.c * viewing_conditions.z);
+  double q = (4.0 / viewing_conditions.c) * sqrt(j / 100.0) *
+             (viewing_conditions.aw + 4.0) * viewing_conditions.fl_root;
+  double hue_prime = hue < 20.14 ? hue + 360 : hue;
+  double e_hue = 0.25 * (cos(hue_prime * kPi / 180.0 + 2.0) + 3.8);
+  double p1 =
+      50000.0 / 13.0 * e_hue * viewing_conditions.n_c * viewing_conditions.ncb;
+  double t = p1 * sqrt(a * a + b * b) / (u + 0.305);
+  double alpha =
+      pow(t, 0.9) *
+      pow(1.64 - pow(0.29, viewing_conditions.background_y_to_white_point_y),
+          0.73);
+  double c = alpha * sqrt(j / 100.0);
+  double m = c * viewing_conditions.fl_root;
+  double s = 50.0 * sqrt((alpha * viewing_conditions.c) /
+                         (viewing_conditions.aw + 4.0));
+  double jstar = (1.0 + 100.0 * 0.007) * j / (1.0 + 0.007 * j);
+  double mstar = 1.0 / 0.0228 * log(1.0 + 0.0228 * m);
+  double astar = mstar * cos(hue_radians);
+  double bstar = mstar * sin(hue_radians);
+  return {hue, c, j, q, m, s, jstar, astar, bstar};
+}
+
 }  // namespace material_color_utilities

cpp/cam/cam.h

@@ -42,6 +42,12 @@ Argb IntFromHcl(double hue, double chroma, double lstar);
 Argb IntFromCam(Cam cam);
 Cam CamFromUcsAndViewingConditions(double jstar, double astar, double bstar,
                                    const ViewingConditions &viewing_conditions);
+/**
+ * Given color expressed in the XYZ color space and viewed
+ * in [viewingConditions], converts the color to CAM16.
+ */
+Cam CamFromXyzAndViewingConditions(double x, double y, double z,
+                                   const ViewingConditions &viewing_conditions);
 
 }  // namespace material_color_utilities
 #endif  // CPP_CAM_CAM_H_

cpp/cam/hct.cc

@@ -26,13 +26,13 @@ Hct::Hct(double hue, double chroma, double tone) {
 
 Hct::Hct(Argb argb) { SetInternalState(argb); }
 
-double Hct::get_hue() { return hue_; }
+double Hct::get_hue() const { return hue_; }
 
-double Hct::get_chroma() { return chroma_; }
+double Hct::get_chroma() const { return chroma_; }
 
-double Hct::get_tone() { return tone_; }
+double Hct::get_tone() const { return tone_; }
 
-Argb Hct::ToInt() { return argb_; }
+Argb Hct::ToInt() const { return argb_; }
 
 void Hct::set_hue(double new_hue) {
   SetInternalState(SolveToInt(new_hue, chroma_, tone_));

cpp/cam/hct.h

@@ -66,28 +66,28 @@ class Hct {
    *
    * @return hue of the color, in degrees.
    */
-  double get_hue();
+  double get_hue() const;
 
   /**
    * Returns the chroma of the color.
    *
    * @return chroma of the color.
    */
-  double get_chroma();
+  double get_chroma() const;
 
   /**
    * Returns the tone of the color.
    *
    * @return tone of the color, satisfying 0 <= tone <= 100.
    */
-  double get_tone();
+  double get_tone() const;
 
   /**
    * Returns the color in ARGB format.
    *
    * @return an integer, representing the color in ARGB format.
    */
-  Argb ToInt();
+  Argb ToInt() const;
 
   /**
    * Sets the hue of this color. Chroma may decrease because chroma has a