Add key colors for palettes and latest scheme changes.

PiperOrigin-RevId: 538195437

Author: Material Eng

cpp/dynamiccolor/dynamic_color_test.cc

@@ -46,11 +46,11 @@ TEST(DynamicColorTest, One) {
   EXPECT_EQ((unsigned int)(MaterialDynamicColors::Background().GetArgb(s)),
             0xfffff8f6);
   EXPECT_EQ((unsigned int)(MaterialDynamicColors::OnBackground().GetArgb(s)),
-            0xff241816);
+            0xff261715);
   EXPECT_EQ((unsigned int)(MaterialDynamicColors::Surface().GetArgb(s)),
             0xfffff8f6);
   EXPECT_EQ((unsigned int)(MaterialDynamicColors::SurfaceDim().GetArgb(s)),
-            0xffecd5d1);
+            0xfff0d4cf);
   EXPECT_EQ((unsigned int)(MaterialDynamicColors::SurfaceBright().GetArgb(s)),
             0xfffff8f6);
   EXPECT_EQ(
@@ -65,20 +65,20 @@ TEST(DynamicColorTest, One) {
       0xffffe9e6);
   EXPECT_EQ(
       (unsigned int)(MaterialDynamicColors::SurfaceContainerHigh().GetArgb(s)),
-      0xfffbe3df);
+      0xffffe2dd);
   EXPECT_EQ(
       (unsigned int)(MaterialDynamicColors::SurfaceContainerHighest().GetArgb(
           s)),
-      0xfff5ddda);
+      0xfff9dcd8);
   EXPECT_EQ((unsigned int)(MaterialDynamicColors::OnSurface().GetArgb(s)),
-            0xff241816);
+            0xff261715);
   EXPECT_EQ((unsigned int)(MaterialDynamicColors::SurfaceVariant().GetArgb(s)),
             0xfffddbd5);
   EXPECT_EQ(
       (unsigned int)(MaterialDynamicColors::OnSurfaceVariant().GetArgb(s)),
       0xff58413d);
   EXPECT_EQ((unsigned int)(MaterialDynamicColors::InverseSurface().GetArgb(s)),
-            0xff3b2d2b);
+            0xff3d2c29);
   EXPECT_EQ(
       (unsigned int)(MaterialDynamicColors::InverseOnSurface().GetArgb(s)),
       0xffffedeb);

cpp/dynamiccolor/material_dynamic_colors.cc

@@ -164,6 +164,66 @@ DynamicColor highestSurface(const DynamicScheme& s) {
                    : MaterialDynamicColors::SurfaceDim();
 }
 
+DynamicColor MaterialDynamicColors::PrimaryPaletteKeyColor() {
+  return DynamicColor::FromPalette(
+      /*palette*/ [](const DynamicScheme& s)
+                      -> TonalPalette { return s.primary_palette; },
+      /*tone*/
+      [](const DynamicScheme& s) -> double {
+        return s.primary_palette.get_key_color().get_tone();
+      },
+      /*toneDeltaConstraint*/ std::nullopt,
+      /*background*/ std::nullopt);
+}
+
+DynamicColor MaterialDynamicColors::SecondaryPaletteKeyColor() {
+  return DynamicColor::FromPalette(
+      /*palette*/ [](const DynamicScheme& s)
+                      -> TonalPalette { return s.secondary_palette; },
+      /*tone*/
+      [](const DynamicScheme& s) -> double {
+        return s.secondary_palette.get_key_color().get_tone();
+      },
+      /*toneDeltaConstraint*/ std::nullopt,
+      /*background*/ std::nullopt);
+}
+
+DynamicColor MaterialDynamicColors::TertiaryPaletteKeyColor() {
+  return DynamicColor::FromPalette(
+      /*palette*/ [](const DynamicScheme& s)
+                      -> TonalPalette { return s.tertiary_palette; },
+      /*tone*/
+      [](const DynamicScheme& s) -> double {
+        return s.tertiary_palette.get_key_color().get_tone();
+      },
+      /*toneDeltaConstraint*/ std::nullopt,
+      /*background*/ std::nullopt);
+}
+
+DynamicColor MaterialDynamicColors::NeutralPaletteKeyColor() {
+  return DynamicColor::FromPalette(
+      /*palette*/ [](const DynamicScheme& s)
+                      -> TonalPalette { return s.neutral_palette; },
+      /*tone*/
+      [](const DynamicScheme& s) -> double {
+        return s.neutral_palette.get_key_color().get_tone();
+      },
+      /*toneDeltaConstraint*/ std::nullopt,
+      /*background*/ std::nullopt);
+}
+
+DynamicColor MaterialDynamicColors::NeutralVariantPaletteKeyColor() {
+  return DynamicColor::FromPalette(
+      /*palette*/ [](const DynamicScheme& s)
+                      -> TonalPalette { return s.neutral_variant_palette; },
+      /*tone*/
+      [](const DynamicScheme& s) -> double {
+        return s.neutral_variant_palette.get_key_color().get_tone();
+      },
+      /*toneDeltaConstraint*/ std::nullopt,
+      /*background*/ std::nullopt);
+}
+
 DynamicColor MaterialDynamicColors::Background() {
   return DynamicColor::FromPalette(
       /*palette*/ [](const DynamicScheme& s)

cpp/dynamiccolor/material_dynamic_colors.h

@@ -23,6 +23,11 @@ namespace material_color_utilities {
 
 class MaterialDynamicColors {
  public:
+  static DynamicColor PrimaryPaletteKeyColor();
+  static DynamicColor SecondaryPaletteKeyColor();
+  static DynamicColor TertiaryPaletteKeyColor();
+  static DynamicColor NeutralPaletteKeyColor();
+  static DynamicColor NeutralVariantPaletteKeyColor();
   static DynamicColor Background();
   static DynamicColor OnBackground();
   static DynamicColor Surface();

cpp/palettes/tones.cc

@@ -16,19 +16,34 @@
 
 #include "cpp/palettes/tones.h"
 
-#include <cstdlib>
-
 #include "cpp/cam/cam.h"
+#include "cpp/cam/hct.h"
 
 namespace material_color_utilities {
 
-TonalPalette::TonalPalette(Argb argb) {
+TonalPalette::TonalPalette(Argb argb) : key_color_(0.0, 0.0, 0.0) {
   Cam cam = CamFromInt(argb);
   hue_ = cam.hue;
   chroma_ = cam.chroma;
+  key_color_ = createKeyColor(cam.hue, cam.chroma);
+}
+
+TonalPalette::TonalPalette(Hct hct)
+    : key_color_(hct.get_hue(), hct.get_chroma(), hct.get_tone()) {
+  hue_ = hct.get_hue();
+  chroma_ = hct.get_chroma();
 }
 
-TonalPalette::TonalPalette(double hue, double chroma) {
+TonalPalette::TonalPalette(double hue, double chroma)
+    : key_color_(hue, chroma, 0.0) {
+  hue_ = hue;
+  chroma_ = chroma;
+  key_color_ = createKeyColor(hue, chroma);
+}
+
+TonalPalette::TonalPalette(double hue, double chroma, Hct key_color)
+    : key_color_(key_color.get_hue(), key_color.get_chroma(),
+                 key_color.get_tone()) {
   hue_ = hue;
   chroma_ = chroma;
 }
@@ -37,4 +52,38 @@ Argb TonalPalette::get(double tone) const {
   return IntFromHcl(hue_, chroma_, tone);
 }
 
+Hct TonalPalette::createKeyColor(double hue, double chroma) {
+  double start_tone = 50.0;
+  Hct smallest_delta_hct(hue, chroma, start_tone);
+  double smallest_delta = abs(smallest_delta_hct.get_chroma() - chroma);
+  // Starting from T50, check T+/-delta to see if they match the requested
+  // chroma.
+  //
+  // Starts from T50 because T50 has the most chroma available, on
+  // average. Thus it is most likely to have a direct answer and minimize
+  // iteration.
+  for (double delta = 1.0; delta < 50.0; delta += 1.0) {
+    // Termination condition rounding instead of minimizing delta to avoid
+    // case where requested chroma is 16.51, and the closest chroma is 16.49.
+    // Error is minimized, but when rounded and displayed, requested chroma
+    // is 17, key color's chroma is 16.
+    if (round(chroma) == round(smallest_delta_hct.get_chroma())) {
+      return smallest_delta_hct;
+    }
+    Hct hct_add(hue, chroma, start_tone + delta);
+    double hct_add_delta = abs(hct_add.get_chroma() - chroma);
+    if (hct_add_delta < smallest_delta) {
+      smallest_delta = hct_add_delta;
+      smallest_delta_hct = hct_add;
+    }
+    Hct hct_subtract(hue, chroma, start_tone - delta);
+    double hct_subtract_delta = abs(hct_subtract.get_chroma() - chroma);
+    if (hct_subtract_delta < smallest_delta) {
+      smallest_delta = hct_subtract_delta;
+      smallest_delta_hct = hct_subtract;
+    }
+  }
+  return smallest_delta_hct;
+}
+
 }  // namespace material_color_utilities

cpp/palettes/tones.h

@@ -17,14 +17,17 @@
 #ifndef CPP_PALETTES_TONES_H_
 #define CPP_PALETTES_TONES_H_
 
+#include "cpp/cam/hct.h"
 #include "cpp/utils/utils.h"
 
 namespace material_color_utilities {
 
 class TonalPalette {
  public:
   explicit TonalPalette(Argb argb);
+  TonalPalette(Hct hct);
   TonalPalette(double hue, double chroma);
+  TonalPalette(double hue, double chroma, Hct key_color);
 
   /**
    * Returns the color for a given tone in this palette.
@@ -36,10 +39,14 @@ class TonalPalette {
 
   double get_hue() const { return hue_; }
   double get_chroma() const { return chroma_; }
+  Hct get_key_color() const { return key_color_; }
 
  private:
   double hue_;
   double chroma_;
+  Hct key_color_;
+
+  Hct createKeyColor(double hue, double chroma);
 };
 
 }  // namespace material_color_utilities

cpp/scheme/scheme_expressive.cc

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "cpp/scheme/scheme_expressive.h"
+
+#include "cpp/cam/hct.h"
+#include "cpp/palettes/tones.h"
+#include "cpp/scheme/dynamic_scheme.h"
+#include "cpp/scheme/variant.h"
+
+namespace material_color_utilities {
+
+const std::vector<double> kHues = {0, 21, 51, 121, 151, 191, 271, 321, 360};
+
+const std::vector<double> kSecondaryRotations = {45, 95, 45, 20, 45,
+                                                 90, 45, 45, 45};
+
+const std::vector<double> kTertiaryRotations = {120, 120, 20,  45, 20,
+                                                15,  20,  120, 120};
+
+SchemeExpressive::SchemeExpressive(Hct set_source_color_hct, bool set_is_dark,
+                                   double set_contrast_level)
+    : DynamicScheme(
+          /*source_color_argb:*/ set_source_color_hct.ToInt(),
+          /*variant:*/ Variant::kExpressive,
+          /*contrast_level:*/ set_contrast_level,
+          /*is_dark:*/ set_is_dark,
+          /*primary_palette:*/
+          TonalPalette(set_source_color_hct.get_hue() + 240.0, 40.0),
+          /*secondary_palette:*/
+          TonalPalette(DynamicScheme::GetRotatedHue(set_source_color_hct, kHues,
+                                                    kSecondaryRotations),
+                       24.0),
+          /*tertiary_palette:*/
+          TonalPalette(DynamicScheme::GetRotatedHue(set_source_color_hct, kHues,
+                                                    kTertiaryRotations),
+                       32.0),
+          /*neutral_palette:*/
+          TonalPalette(set_source_color_hct.get_hue() + 15.0, 8.0),
+          /*neutral_variant_palette:*/
+          TonalPalette(set_source_color_hct.get_hue() + 15, 12.0)) {}
+
+SchemeExpressive::SchemeExpressive(Hct set_source_color_hct, bool set_is_dark)
+    : SchemeExpressive::SchemeExpressive(set_source_color_hct, set_is_dark,
+                                         0.0) {}
+
+}  // namespace material_color_utilities

cpp/scheme/scheme_expressive.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef CPP_SCHEME_SCHEME_EXPRESSIVE_H_
+#define CPP_SCHEME_SCHEME_EXPRESSIVE_H_
+
+#include "cpp/cam/hct.h"
+#include "cpp/scheme/dynamic_scheme.h"
+
+namespace material_color_utilities {
+
+struct SchemeExpressive : public DynamicScheme {
+  SchemeExpressive(Hct source_color_hct, bool is_dark, double contrast_level);
+  SchemeExpressive(Hct source_color_hct, bool is_dark);
+};
+
+}  // namespace material_color_utilities
+
+#endif  // CPP_SCHEME_SCHEME_EXPRESSIVE_H_