Use common library for theming

Signed-off-by: Álvaro Brey <alvaro.brey@nextcloud.com>

app/build.gradle

@@ -331,7 +331,9 @@ dependencies {
     gplayImplementation "com.google.firebase:firebase-messaging:23.0.7"
 
     // implementation 'androidx.activity:activity-ktx:1.4.0'
-    implementation project(':material-color-utilities')
+
+    //
+    implementation 'com.github.nextcloud.android-common:ui:4da3363e61ed646e091754147558ee3be346abc5'
 }
 
 task installGitHooks(type: Copy, group: "development") {

app/src/main/java/com/nextcloud/talk/activities/BaseActivity.kt

@@ -68,6 +68,7 @@ open class BaseActivity : AppCompatActivity() {
 
     public override fun onResume() {
         super.onResume()
+
         if (appPreferences.isScreenSecured) {
             window.addFlags(WindowManager.LayoutParams.FLAG_SECURE)
         } else {

app/src/main/java/com/nextcloud/talk/ui/theme/MaterialSchemes.kt

@@ -1,35 +0,0 @@
-/*
- * Nextcloud Talk application
- *
- * @author Andy Scherzinger
- * Copyright (C) 2022 Andy Scherzinger <info@andy-scherzinger.de>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.nextcloud.talk.ui.theme
-
-import scheme.Scheme
-
-interface MaterialSchemes {
-    /**
-     * Schema for light theme
-     */
-    val lightScheme: Scheme
-
-    /**
-     * Schema for light theme
-     */
-    val darkScheme: Scheme
-}

app/src/main/java/com/nextcloud/talk/ui/theme/MaterialSchemesImpl.kt

@@ -20,9 +20,12 @@
 
 package com.nextcloud.talk.ui.theme
 
+import com.nextcloud.android.common.ui.theme.MaterialSchemes
+import com.nextcloud.android.common.ui.theme.ServerTheme
 import scheme.Scheme
 
-class MaterialSchemesImpl(serverTheme: ServerTheme) : MaterialSchemes {
+class MaterialSchemesImpl(serverTheme: ServerTheme) :
+    MaterialSchemes {
     override val lightScheme: Scheme
     override val darkScheme: Scheme
 

app/src/main/java/com/nextcloud/talk/ui/theme/MaterialSchemesProvider.kt

@@ -21,6 +21,7 @@
 
 package com.nextcloud.talk.ui.theme
 
+import com.nextcloud.android.common.ui.theme.MaterialSchemes
 import com.nextcloud.talk.data.user.model.User
 import com.nextcloud.talk.models.json.capabilities.Capabilities
 

app/src/main/java/com/nextcloud/talk/ui/theme/MaterialSchemesProviderImpl.kt

@@ -23,6 +23,7 @@
 
 package com.nextcloud.talk.ui.theme
 
+import com.nextcloud.android.common.ui.theme.MaterialSchemes
 import com.nextcloud.talk.data.user.model.User
 import com.nextcloud.talk.models.json.capabilities.Capabilities
 import com.nextcloud.talk.utils.database.user.CurrentUserProviderNew

app/src/main/java/com/nextcloud/talk/ui/theme/ServerTheme.kt

@@ -1,53 +0,0 @@
-/*
- * Nextcloud Talk application
- *
- * @author Álvaro Brey
- * Copyright (C) 2022 Álvaro Brey
- * Copyright (C) 2022 Nextcloud GmbH
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.nextcloud.talk.ui.theme
-
-import androidx.annotation.ColorInt
-
-interface ServerTheme {
-    @get:ColorInt
-    val primaryColor: Int
-
-    /**
-     * Default element color
-     */
-    @get:ColorInt
-    val colorElement: Int
-
-    /**
-     * Element color for bright backgrounds
-     */
-    @get:ColorInt
-    val colorElementBright: Int
-
-    /**
-     * Element color for dark backgrounds
-     */
-    @get:ColorInt
-    val colorElementDark: Int
-
-    /**
-     * Text color for elements
-     */
-    @get:ColorInt
-    val colorText: Int
-}

app/src/main/java/com/nextcloud/talk/ui/theme/ServerThemeImpl.kt

@@ -23,11 +23,13 @@
 
 package com.nextcloud.talk.ui.theme
 
+import com.nextcloud.android.common.ui.theme.ServerTheme
 import com.nextcloud.talk.R
 import com.nextcloud.talk.models.json.capabilities.ThemingCapability
 import com.nextcloud.talk.utils.ui.ColorUtil
 
-internal class ServerThemeImpl(themingCapability: ThemingCapability?, colorUtil: ColorUtil) : ServerTheme {
+internal class ServerThemeImpl(themingCapability: ThemingCapability?, colorUtil: ColorUtil) :
+    ServerTheme {
 
     override val primaryColor: Int
     override val colorElement: Int

app/src/main/java/com/nextcloud/talk/ui/theme/ThemeModule.kt

@@ -21,6 +21,7 @@
 
 package com.nextcloud.talk.ui.theme
 
+import com.nextcloud.android.common.ui.theme.MaterialSchemes
 import com.nextcloud.talk.dagger.modules.ContextModule
 import com.nextcloud.talk.utils.database.user.UserModule
 import dagger.Binds
@@ -37,8 +38,8 @@ internal abstract class ThemeModule {
 
     companion object {
         @Provides
-        fun provideCurrentMaterialSchemes(themeProvider: MaterialSchemesProvider): MaterialSchemes {
-            return themeProvider.getMaterialSchemesForCurrentUser()
+        fun provideCurrentMaterialSchemes(schemesProvider: MaterialSchemesProvider): MaterialSchemes {
+            return schemesProvider.getMaterialSchemesForCurrentUser()
         }
     }
 }

app/src/main/java/com/nextcloud/talk/ui/theme/ViewThemeUtils.kt

@@ -70,6 +70,7 @@ import com.google.android.material.shape.MaterialShapeDrawable
 import com.google.android.material.tabs.TabLayout
 import com.google.android.material.textfield.TextInputLayout
 import com.google.android.material.textview.MaterialTextView
+import com.nextcloud.android.common.ui.theme.MaterialSchemes
 import com.nextcloud.talk.R
 import com.nextcloud.talk.utils.DisplayUtils
 import com.nextcloud.talk.utils.DrawableUtils

material-color-utilities/.gitignore

@@ -1 +0,0 @@
-/build

material-color-utilities/README.txt

@@ -1,2 +0,0 @@
-Imported from https://github.com/material-foundation/material-color-utilities with license APACHE-2.0,to be substituted
-with a Gradle dependency when they publish it.

material-color-utilities/build.gradle

@@ -1,33 +0,0 @@
-/*
- * Nextcloud Talk application
- *
- * @author Álvaro Brey
- * Copyright (C) 2022 Álvaro Brey
- * Copyright (C) 2022 Nextcloud GmbH
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <https://www.gnu.org/licenses/>.
- */
-
-plugins {
-    id 'java-library'
-}
-
-java {
-    sourceCompatibility = JavaVersion.VERSION_1_7
-    targetCompatibility = JavaVersion.VERSION_1_7
-}
-
-dependencies {
-    implementation 'com.google.errorprone:error_prone_annotations:2.15.0'
-}

material-color-utilities/src/main/java/blend/Blend.java

@@ -1,91 +0,0 @@
-/*
- * Copyright 2021 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.
- */
-
-// This file is automatically generated. Do not modify it.
-
-package blend;
-
-import hct.Cam16;
-import hct.Hct;
-import utils.ColorUtils;
-import utils.MathUtils;
-
-/** Functions for blending in HCT and CAM16. */
-public class Blend {
-  private Blend() {}
-
-  /**
-   * Blend the design color's HCT hue towards the key color's HCT hue, in a way that leaves the
-   * original color recognizable and recognizably shifted towards the key color.
-   *
-   * @param designColor ARGB representation of an arbitrary color.
-   * @param sourceColor ARGB representation of the main theme color.
-   * @return The design color with a hue shifted towards the system's color, a slightly
-   *     warmer/cooler variant of the design color's hue.
-   */
-  public static int harmonize(int designColor, int sourceColor) {
-    Hct fromHct = Hct.fromInt(designColor);
-    Hct toHct = Hct.fromInt(sourceColor);
-    double differenceDegrees = MathUtils.differenceDegrees(fromHct.getHue(), toHct.getHue());
-    double rotationDegrees = Math.min(differenceDegrees * 0.5, 15.0);
-    double outputHue =
-        MathUtils.sanitizeDegreesDouble(
-            fromHct.getHue()
-                + rotationDegrees * MathUtils.rotationDirection(fromHct.getHue(), toHct.getHue()));
-    return Hct.from(outputHue, fromHct.getChroma(), fromHct.getTone()).toInt();
-  }
-
-  /**
-   * Blends hue from one color into another. The chroma and tone of the original color are
-   * maintained.
-   *
-   * @param from ARGB representation of color
-   * @param to ARGB representation of color
-   * @param amount how much blending to perform; 0.0 >= and <= 1.0
-   * @return from, with a hue blended towards to. Chroma and tone are constant.
-   */
-  public static int hctHue(int from, int to, double amount) {
-    int ucs = cam16Ucs(from, to, amount);
-    Cam16 ucsCam = Cam16.fromInt(ucs);
-    Cam16 fromCam = Cam16.fromInt(from);
-    Hct blended = Hct.from(ucsCam.getHue(), fromCam.getChroma(), ColorUtils.lstarFromArgb(from));
-    return blended.toInt();
-  }
-
-  /**
-   * Blend in CAM16-UCS space.
-   *
-   * @param from ARGB representation of color
-   * @param to ARGB representation of color
-   * @param amount how much blending to perform; 0.0 >= and <= 1.0
-   * @return from, blended towards to. Hue, chroma, and tone will change.
-   */
-  public static int cam16Ucs(int from, int to, double amount) {
-    Cam16 fromCam = Cam16.fromInt(from);
-    Cam16 toCam = Cam16.fromInt(to);
-    double fromJ = fromCam.getJstar();
-    double fromA = fromCam.getAstar();
-    double fromB = fromCam.getBstar();
-    double toJ = toCam.getJstar();
-    double toA = toCam.getAstar();
-    double toB = toCam.getBstar();
-    double jstar = fromJ + (toJ - fromJ) * amount;
-    double astar = fromA + (toA - fromA) * amount;
-    double bstar = fromB + (toB - fromB) * amount;
-    return Cam16.fromUcs(jstar, astar, bstar).toInt();
-  }
-}
-

material-color-utilities/src/main/java/hct/Cam16.java

@@ -1,419 +0,0 @@
-/*
- * Copyright 2021 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.
- */
-
-package hct;
-
-import static java.lang.Math.max;
-
-import utils.ColorUtils;
-
-/**
- * CAM16, a color appearance model. Colors are not just defined by their hex code, but rather, a hex
- * code and viewing conditions.
- *
- * <p>CAM16 instances also have coordinates in the CAM16-UCS space, called J*, a*, b*, or jstar,
- * astar, bstar in code. CAM16-UCS is included in the CAM16 specification, and should be used when
- * measuring distances between colors.
- *
- * <p>In traditional color spaces, a color can be identified solely by the observer's measurement of
- * the color. Color appearance models such as CAM16 also use information about the environment where
- * the color was observed, known as the viewing conditions.
- *
- * <p>For example, white under the traditional assumption of a midday sun white point is accurately
- * measured as a slightly chromatic blue by CAM16. (roughly, hue 203, chroma 3, lightness 100)
- */
-public final class Cam16 {
-  // Transforms XYZ color space coordinates to 'cone'/'RGB' responses in CAM16.
-  static final double[][] XYZ_TO_CAM16RGB = {
-    {0.401288, 0.650173, -0.051461},
-    {-0.250268, 1.204414, 0.045854},
-    {-0.002079, 0.048952, 0.953127}
-  };
-
-  // Transforms 'cone'/'RGB' responses in CAM16 to XYZ color space coordinates.
-  static final double[][] CAM16RGB_TO_XYZ = {
-    {1.8620678, -1.0112547, 0.14918678},
-    {0.38752654, 0.62144744, -0.00897398},
-    {-0.01584150, -0.03412294, 1.0499644}
-  };
-
-  // CAM16 color dimensions, see getters for documentation.
-  private final double hue;
-  private final double chroma;
-  private final double j;
-  private final double q;
-  private final double m;
-  private final double s;
-
-  // Coordinates in UCS space. Used to determine color distance, like delta E equations in L*a*b*.
-  private final double jstar;
-  private final double astar;
-  private final double bstar;
-
-  /**
-   * CAM16 instances also have coordinates in the CAM16-UCS space, called J*, a*, b*, or jstar,
-   * astar, bstar in code. CAM16-UCS is included in the CAM16 specification, and is used to measure
-   * distances between colors.
-   */
-  double distance(Cam16 other) {
-    double dJ = getJstar() - other.getJstar();
-    double dA = getAstar() - other.getAstar();
-    double dB = getBstar() - other.getBstar();
-    double dEPrime = Math.sqrt(dJ * dJ + dA * dA + dB * dB);
-    double dE = 1.41 * Math.pow(dEPrime, 0.63);
-    return dE;
-  }
-
-  /** Hue in CAM16 */
-  public double getHue() {
-    return hue;
-  }
-
-  /** Chroma in CAM16 */
-  public double getChroma() {
-    return chroma;
-  }
-
-  /** Lightness in CAM16 */
-  public double getJ() {
-    return j;
-  }
-
-  /**
-   * Brightness in CAM16.
-   *
-   * <p>Prefer lightness, brightness is an absolute quantity. For example, a sheet of white paper is
-   * much brighter viewed in sunlight than in indoor light, but it is the lightest object under any
-   * lighting.
-   */
-  public double getQ() {
-    return q;
-  }
-
-  /**
-   * Colorfulness in CAM16.
-   *
-   * <p>Prefer chroma, colorfulness is an absolute quantity. For example, a yellow toy car is much
-   * more colorful outside than inside, but it has the same chroma in both environments.
-   */
-  public double getM() {
-    return m;
-  }
-
-  /**
-   * Saturation in CAM16.
-   *
-   * <p>Colorfulness in proportion to brightness. Prefer chroma, saturation measures colorfulness
-   * relative to the color's own brightness, where chroma is colorfulness relative to white.
-   */
-  public double getS() {
-    return s;
-  }
-
-  /** Lightness coordinate in CAM16-UCS */
-  public double getJstar() {
-    return jstar;
-  }
-
-  /** a* coordinate in CAM16-UCS */
-  public double getAstar() {
-    return astar;
-  }
-
-  /** b* coordinate in CAM16-UCS */
-  public double getBstar() {
-    return bstar;
-  }
-
-  /**
-   * All of the CAM16 dimensions can be calculated from 3 of the dimensions, in the following
-   * combinations: - {j or q} and {c, m, or s} and hue - jstar, astar, bstar Prefer using a static
-   * method that constructs from 3 of those dimensions. This constructor is intended for those
-   * methods to use to return all possible dimensions.
-   *
-   * @param hue for example, red, orange, yellow, green, etc.
-   * @param chroma informally, colorfulness / color intensity. like saturation in HSL, except
-   *     perceptually accurate.
-   * @param j lightness
-   * @param q brightness; ratio of lightness to white point's lightness
-   * @param m colorfulness
-   * @param s saturation; ratio of chroma to white point's chroma
-   * @param jstar CAM16-UCS J coordinate
-   * @param astar CAM16-UCS a coordinate
-   * @param bstar CAM16-UCS b coordinate
-   */
-  private Cam16(
-      double hue,
-      double chroma,
-      double j,
-      double q,
-      double m,
-      double s,
-      double jstar,
-      double astar,
-      double bstar) {
-    this.hue = hue;
-    this.chroma = chroma;
-    this.j = j;
-    this.q = q;
-    this.m = m;
-    this.s = s;
-    this.jstar = jstar;
-    this.astar = astar;
-    this.bstar = bstar;
-  }
-
-  /**
-   * Create a CAM16 color from a color, assuming the color was viewed in default viewing conditions.
-   *
-   * @param argb ARGB representation of a color.
-   */
-  public static Cam16 fromInt(int argb) {
-    return fromIntInViewingConditions(argb, ViewingConditions.DEFAULT);
-  }
-
-  /**
-   * Create a CAM16 color from a color in defined viewing conditions.
-   *
-   * @param argb ARGB representation of a color.
-   * @param viewingConditions Information about the environment where the color was observed.
-   */
-  // The RGB => XYZ conversion matrix elements are derived scientific constants. While the values
-  // may differ at runtime due to floating point imprecision, keeping the values the same, and
-  // accurate, across implementations takes precedence.
-  @SuppressWarnings("FloatingPointLiteralPrecision")
-  static Cam16 fromIntInViewingConditions(int argb, ViewingConditions viewingConditions) {
-    // Transform ARGB int to XYZ
-    int red = (argb & 0x00ff0000) >> 16;
-    int green = (argb & 0x0000ff00) >> 8;
-    int blue = (argb & 0x000000ff);
-    double redL = ColorUtils.linearized(red);
-    double greenL = ColorUtils.linearized(green);
-    double blueL = ColorUtils.linearized(blue);
-    double x = 0.41233895 * redL + 0.35762064 * greenL + 0.18051042 * blueL;
-    double y = 0.2126 * redL + 0.7152 * greenL + 0.0722 * blueL;
-    double z = 0.01932141 * redL + 0.11916382 * greenL + 0.95034478 * blueL;
-
-    // Transform XYZ to 'cone'/'rgb' responses
-    double[][] matrix = XYZ_TO_CAM16RGB;
-    double rT = (x * matrix[0][0]) + (y * matrix[0][1]) + (z * matrix[0][2]);
-    double gT = (x * matrix[1][0]) + (y * matrix[1][1]) + (z * matrix[1][2]);
-    double bT = (x * matrix[2][0]) + (y * matrix[2][1]) + (z * matrix[2][2]);
-
-    // Discount illuminant
-    double rD = viewingConditions.getRgbD()[0] * rT;
-    double gD = viewingConditions.getRgbD()[1] * gT;
-    double bD = viewingConditions.getRgbD()[2] * bT;
-
-    // Chromatic adaptation
-    double rAF = Math.pow(viewingConditions.getFl() * Math.abs(rD) / 100.0, 0.42);
-    double gAF = Math.pow(viewingConditions.getFl() * Math.abs(gD) / 100.0, 0.42);
-    double bAF = Math.pow(viewingConditions.getFl() * Math.abs(bD) / 100.0, 0.42);
-    double rA = Math.signum(rD) * 400.0 * rAF / (rAF + 27.13);
-    double gA = Math.signum(gD) * 400.0 * gAF / (gAF + 27.13);
-    double bA = Math.signum(bD) * 400.0 * bAF / (bAF + 27.13);
-
-    // redness-greenness
-    double a = (11.0 * rA + -12.0 * gA + bA) / 11.0;
-    // yellowness-blueness
-    double b = (rA + gA - 2.0 * bA) / 9.0;
-
-    // auxiliary components
-    double u = (20.0 * rA + 20.0 * gA + 21.0 * bA) / 20.0;
-    double p2 = (40.0 * rA + 20.0 * gA + bA) / 20.0;
-
-    // hue
-    double atan2 = Math.atan2(b, a);
-    double atanDegrees = Math.toDegrees(atan2);
-    double hue =
-        atanDegrees < 0
-            ? atanDegrees + 360.0
-            : atanDegrees >= 360 ? atanDegrees - 360.0 : atanDegrees;
-    double hueRadians = Math.toRadians(hue);
-
-    // achromatic response to color
-    double ac = p2 * viewingConditions.getNbb();
-
-    // CAM16 lightness and brightness
-    double j =
-        100.0
-            * Math.pow(
-                ac / viewingConditions.getAw(),
-                viewingConditions.getC() * viewingConditions.getZ());
-    double q =
-        4.0
-            / viewingConditions.getC()
-            * Math.sqrt(j / 100.0)
-            * (viewingConditions.getAw() + 4.0)
-            * viewingConditions.getFlRoot();
-
-    // CAM16 chroma, colorfulness, and saturation.
-    double huePrime = (hue < 20.14) ? hue + 360 : hue;
-    double eHue = 0.25 * (Math.cos(Math.toRadians(huePrime) + 2.0) + 3.8);
-    double p1 = 50000.0 / 13.0 * eHue * viewingConditions.getNc() * viewingConditions.getNcb();
-    double t = p1 * Math.hypot(a, b) / (u + 0.305);
-    double alpha =
-        Math.pow(1.64 - Math.pow(0.29, viewingConditions.getN()), 0.73) * Math.pow(t, 0.9);
-    // CAM16 chroma, colorfulness, saturation
-    double c = alpha * Math.sqrt(j / 100.0);
-    double m = c * viewingConditions.getFlRoot();
-    double s =
-        50.0 * Math.sqrt((alpha * viewingConditions.getC()) / (viewingConditions.getAw() + 4.0));
-
-    // CAM16-UCS components
-    double jstar = (1.0 + 100.0 * 0.007) * j / (1.0 + 0.007 * j);
-    double mstar = 1.0 / 0.0228 * Math.log1p(0.0228 * m);
-    double astar = mstar * Math.cos(hueRadians);
-    double bstar = mstar * Math.sin(hueRadians);
-
-    return new Cam16(hue, c, j, q, m, s, jstar, astar, bstar);
-  }
-
-  /**
-   * @param j CAM16 lightness
-   * @param c CAM16 chroma
-   * @param h CAM16 hue
-   */
-  static Cam16 fromJch(double j, double c, double h) {
-    return fromJchInViewingConditions(j, c, h, ViewingConditions.DEFAULT);
-  }
-
-  /**
-   * @param j CAM16 lightness
-   * @param c CAM16 chroma
-   * @param h CAM16 hue
-   * @param viewingConditions Information about the environment where the color was observed.
-   */
-  private static Cam16 fromJchInViewingConditions(
-      double j, double c, double h, ViewingConditions viewingConditions) {
-    double q =
-        4.0
-            / viewingConditions.getC()
-            * Math.sqrt(j / 100.0)
-            * (viewingConditions.getAw() + 4.0)
-            * viewingConditions.getFlRoot();
-    double m = c * viewingConditions.getFlRoot();
-    double alpha = c / Math.sqrt(j / 100.0);
-    double s =
-        50.0 * Math.sqrt((alpha * viewingConditions.getC()) / (viewingConditions.getAw() + 4.0));
-
-    double hueRadians = Math.toRadians(h);
-    double jstar = (1.0 + 100.0 * 0.007) * j / (1.0 + 0.007 * j);
-    double mstar = 1.0 / 0.0228 * Math.log1p(0.0228 * m);
-    double astar = mstar * Math.cos(hueRadians);
-    double bstar = mstar * Math.sin(hueRadians);
-    return new Cam16(h, c, j, q, m, s, jstar, astar, bstar);
-  }
-
-  /**
-   * Create a CAM16 color from CAM16-UCS coordinates.
-   *
-   * @param jstar CAM16-UCS lightness.
-   * @param astar CAM16-UCS a dimension. Like a* in L*a*b*, it is a Cartesian coordinate on the Y
-   *     axis.
-   * @param bstar CAM16-UCS b dimension. Like a* in L*a*b*, it is a Cartesian coordinate on the X
-   *     axis.
-   */
-  public static Cam16 fromUcs(double jstar, double astar, double bstar) {
-
-    return fromUcsInViewingConditions(jstar, astar, bstar, ViewingConditions.DEFAULT);
-  }
-
-  /**
-   * Create a CAM16 color from CAM16-UCS coordinates in defined viewing conditions.
-   *
-   * @param jstar CAM16-UCS lightness.
-   * @param astar CAM16-UCS a dimension. Like a* in L*a*b*, it is a Cartesian coordinate on the Y
-   *     axis.
-   * @param bstar CAM16-UCS b dimension. Like a* in L*a*b*, it is a Cartesian coordinate on the X
-   *     axis.
-   * @param viewingConditions Information about the environment where the color was observed.
-   */
-  public static Cam16 fromUcsInViewingConditions(
-      double jstar, double astar, double bstar, ViewingConditions viewingConditions) {
-
-    double m = Math.hypot(astar, bstar);
-    double m2 = Math.expm1(m * 0.0228) / 0.0228;
-    double c = m2 / viewingConditions.getFlRoot();
-    double h = Math.atan2(bstar, astar) * (180.0 / Math.PI);
-    if (h < 0.0) {
-      h += 360.0;
-    }
-    double j = jstar / (1. - (jstar - 100.) * 0.007);
-    return fromJchInViewingConditions(j, c, h, viewingConditions);
-  }
-
-  /**
-   * ARGB representation of the color. Assumes the color was viewed in default viewing conditions,
-   * which are near-identical to the default viewing conditions for sRGB.
-   */
-  public int toInt() {
-    return viewed(ViewingConditions.DEFAULT);
-  }
-
-  /**
-   * ARGB representation of the color, in defined viewing conditions.
-   *
-   * @param viewingConditions Information about the environment where the color will be viewed.
-   * @return ARGB representation of color
-   */
-  int viewed(ViewingConditions viewingConditions) {
-    double alpha =
-        (getChroma() == 0.0 || getJ() == 0.0) ? 0.0 : getChroma() / Math.sqrt(getJ() / 100.0);
-
-    double t =
-        Math.pow(
-            alpha / Math.pow(1.64 - Math.pow(0.29, viewingConditions.getN()), 0.73), 1.0 / 0.9);
-    double hRad = Math.toRadians(getHue());
-
-    double eHue = 0.25 * (Math.cos(hRad + 2.0) + 3.8);
-    double ac =
-        viewingConditions.getAw()
-            * Math.pow(getJ() / 100.0, 1.0 / viewingConditions.getC() / viewingConditions.getZ());
-    double p1 = eHue * (50000.0 / 13.0) * viewingConditions.getNc() * viewingConditions.getNcb();
-    double p2 = (ac / viewingConditions.getNbb());
-
-    double hSin = Math.sin(hRad);
-    double hCos = Math.cos(hRad);
-
-    double gamma = 23.0 * (p2 + 0.305) * t / (23.0 * p1 + 11.0 * t * hCos + 108.0 * t * hSin);
-    double a = gamma * hCos;
-    double b = gamma * hSin;
-    double rA = (460.0 * p2 + 451.0 * a + 288.0 * b) / 1403.0;
-    double gA = (460.0 * p2 - 891.0 * a - 261.0 * b) / 1403.0;
-    double bA = (460.0 * p2 - 220.0 * a - 6300.0 * b) / 1403.0;
-
-    double rCBase = max(0, (27.13 * Math.abs(rA)) / (400.0 - Math.abs(rA)));
-    double rC =
-        Math.signum(rA) * (100.0 / viewingConditions.getFl()) * Math.pow(rCBase, 1.0 / 0.42);
-    double gCBase = max(0, (27.13 * Math.abs(gA)) / (400.0 - Math.abs(gA)));
-    double gC =
-        Math.signum(gA) * (100.0 / viewingConditions.getFl()) * Math.pow(gCBase, 1.0 / 0.42);
-    double bCBase = max(0, (27.13 * Math.abs(bA)) / (400.0 - Math.abs(bA)));
-    double bC =
-        Math.signum(bA) * (100.0 / viewingConditions.getFl()) * Math.pow(bCBase, 1.0 / 0.42);
-    double rF = rC / viewingConditions.getRgbD()[0];
-    double gF = gC / viewingConditions.getRgbD()[1];
-    double bF = bC / viewingConditions.getRgbD()[2];
-
-    double[][] matrix = CAM16RGB_TO_XYZ;
-    double x = (rF * matrix[0][0]) + (gF * matrix[0][1]) + (bF * matrix[0][2]);
-    double y = (rF * matrix[1][0]) + (gF * matrix[1][1]) + (bF * matrix[1][2]);
-    double z = (rF * matrix[2][0]) + (gF * matrix[2][1]) + (bF * matrix[2][2]);
-
-    return ColorUtils.argbFromXyz(x, y, z);
-  }
-}

material-color-utilities/src/main/java/hct/Hct.java

@@ -1,127 +0,0 @@
-/*
- * Copyright 2021 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.
- */
-
-package hct;
-
-import utils.ColorUtils;
-
-/**
- * A color system built using CAM16 hue and chroma, and L* from L*a*b*.
- *
- * <p>Using L* creates a link between the color system, contrast, and thus accessibility. Contrast
- * ratio depends on relative luminance, or Y in the XYZ color space. L*, or perceptual luminance can
- * be calculated from Y.
- *
- * <p>Unlike Y, L* is linear to human perception, allowing trivial creation of accurate color tones.
- *
- * <p>Unlike contrast ratio, measuring contrast in L* is linear, and simple to calculate. A
- * difference of 40 in HCT tone guarantees a contrast ratio >= 3.0, and a difference of 50
- * guarantees a contrast ratio >= 4.5.
- */
-
-/**
- * HCT, hue, chroma, and tone. A color system that provides a perceptually accurate color
- * measurement system that can also accurately render what colors will appear as in different
- * lighting environments.
- */
-public final class Hct {
-  private double hue;
-  private double chroma;
-  private double tone;
-  private int argb;
-
-  /**
-   * Create an HCT color from hue, chroma, and tone.
-   *
-   * @param hue 0 <= hue < 360; invalid values are corrected.
-   * @param chroma 0 <= chroma < ?; Informally, colorfulness. The color returned may be lower than
-   *     the requested chroma. Chroma has a different maximum for any given hue and tone.
-   * @param tone 0 <= tone <= 100; invalid values are corrected.
-   * @return HCT representation of a color in default viewing conditions.
-   */
-  public static Hct from(double hue, double chroma, double tone) {
-    int argb = HctSolver.solveToInt(hue, chroma, tone);
-    return new Hct(argb);
-  }
-
-  /**
-   * Create an HCT color from a color.
-   *
-   * @param argb ARGB representation of a color.
-   * @return HCT representation of a color in default viewing conditions
-   */
-  public static Hct fromInt(int argb) {
-    return new Hct(argb);
-  }
-
-  private Hct(int argb) {
-    setInternalState(argb);
-  }
-
-  public double getHue() {
-    return hue;
-  }
-
-  public double getChroma() {
-    return chroma;
-  }
-
-  public double getTone() {
-    return tone;
-  }
-
-  public int toInt() {
-    return argb;
-  }
-
-  /**
-   * Set the hue of this color. Chroma may decrease because chroma has a different maximum for any
-   * given hue and tone.
-   *
-   * @param newHue 0 <= newHue < 360; invalid values are corrected.
-   */
-  public void setHue(double newHue) {
-    setInternalState(HctSolver.solveToInt(newHue, chroma, tone));
-  }
-
-  /**
-   * Set the chroma of this color. Chroma may decrease because chroma has a different maximum for
-   * any given hue and tone.
-   *
-   * @param newChroma 0 <= newChroma < ?
-   */
-  public void setChroma(double newChroma) {
-    setInternalState(HctSolver.solveToInt(hue, newChroma, tone));
-  }
-
-  /**
-   * Set the tone of this color. Chroma may decrease because chroma has a different maximum for any
-   * given hue and tone.
-   *
-   * @param newTone 0 <= newTone <= 100; invalid valids are corrected.
-   */
-  public void setTone(double newTone) {
-    setInternalState(HctSolver.solveToInt(hue, chroma, newTone));
-  }
-
-  private void setInternalState(int argb) {
-    this.argb = argb;
-    Cam16 cam = Cam16.fromInt(argb);
-    hue = cam.getHue();
-    chroma = cam.getChroma();
-    this.tone = ColorUtils.lstarFromArgb(argb);
-  }
-}

material-color-utilities/src/main/java/hct/HctSolver.java

@@ -1,672 +0,0 @@
-/*
- * Copyright 2021 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.
- */
-
-// This file is automatically generated. Do not modify it.
-
-package hct;
-
-import utils.ColorUtils;
-import utils.MathUtils;
-
-/** A class that solves the HCT equation. */
-public class HctSolver {
-  private HctSolver() {}
-
-  static final double[][] SCALED_DISCOUNT_FROM_LINRGB =
-      new double[][] {
-        new double[] {
-          0.001200833568784504, 0.002389694492170889, 0.0002795742885861124,
-        },
-        new double[] {
-          0.0005891086651375999, 0.0029785502573438758, 0.0003270666104008398,
-        },
-        new double[] {
-          0.00010146692491640572, 0.0005364214359186694, 0.0032979401770712076,
-        },
-      };
-
-  static final double[][] LINRGB_FROM_SCALED_DISCOUNT =
-      new double[][] {
-        new double[] {
-          1373.2198709594231, -1100.4251190754821, -7.278681089101213,
-        },
-        new double[] {
-          -271.815969077903, 559.6580465940733, -32.46047482791194,
-        },
-        new double[] {
-          1.9622899599665666, -57.173814538844006, 308.7233197812385,
-        },
-      };
-
-  static final double[] Y_FROM_LINRGB = new double[] {0.2126, 0.7152, 0.0722};
-
-  static final double[] CRITICAL_PLANES =
-      new double[] {
-        0.015176349177441876,
-        0.045529047532325624,
-        0.07588174588720938,
-        0.10623444424209313,
-        0.13658714259697685,
-        0.16693984095186062,
-        0.19729253930674434,
-        0.2276452376616281,
-        0.2579979360165119,
-        0.28835063437139563,
-        0.3188300904430532,
-        0.350925934958123,
-        0.3848314933096426,
-        0.42057480301049466,
-        0.458183274052838,
-        0.4976837250274023,
-        0.5391024159806381,
-        0.5824650784040898,
-        0.6277969426914107,
-        0.6751227633498623,
-        0.7244668422128921,
-        0.775853049866786,
-        0.829304845476233,
-        0.8848452951698498,
-        0.942497089126609,
-        1.0022825574869039,
-        1.0642236851973577,
-        1.1283421258858297,
-        1.1946592148522128,
-        1.2631959812511864,
-        1.3339731595349034,
-        1.407011200216447,
-        1.4823302800086415,
-        1.5599503113873272,
-        1.6398909516233677,
-        1.7221716113234105,
-        1.8068114625156377,
-        1.8938294463134073,
-        1.9832442801866852,
-        2.075074464868551,
-        2.1693382909216234,
-        2.2660538449872063,
-        2.36523901573795,
-        2.4669114995532007,
-        2.5710888059345764,
-        2.6777882626779785,
-        2.7870270208169257,
-        2.898822059350997,
-        3.0131901897720907,
-        3.1301480604002863,
-        3.2497121605402226,
-        3.3718988244681087,
-        3.4967242352587946,
-        3.624204428461639,
-        3.754355295633311,
-        3.887192587735158,
-        4.022731918402185,
-        4.160988767090289,
-        4.301978482107941,
-        4.445716283538092,
-        4.592217266055746,
-        4.741496401646282,
-        4.893568542229298,
-        5.048448422192488,
-        5.20615066083972,
-        5.3666897647573375,
-        5.5300801301023865,
-        5.696336044816294,
-        5.865471690767354,
-        6.037501145825082,
-        6.212438385869475,
-        6.390297286737924,
-        6.571091626112461,
-        6.7548350853498045,
-        6.941541251256611,
-        7.131223617812143,
-        7.323895587840543,
-        7.5195704746346665,
-        7.7182615035334345,
-        7.919981813454504,
-        8.124744458384042,
-        8.332562408825165,
-        8.543448553206703,
-        8.757415699253682,
-        8.974476575321063,
-        9.194643831691977,
-        9.417930041841839,
-        9.644347703669503,
-        9.873909240696694,
-        10.106627003236781,
-        10.342513269534024,
-        10.58158024687427,
-        10.8238400726681,
-        11.069304815507364,
-        11.317986476196008,
-        11.569896988756009,
-        11.825048221409341,
-        12.083451977536606,
-        12.345119996613247,
-        12.610063955123938,
-        12.878295467455942,
-        13.149826086772048,
-        13.42466730586372,
-        13.702830557985108,
-        13.984327217668513,
-        14.269168601521828,
-        14.55736596900856,
-        14.848930523210871,
-        15.143873411576273,
-        15.44220572664832,
-        15.743938506781891,
-        16.04908273684337,
-        16.35764934889634,
-        16.66964922287304,
-        16.985093187232053,
-        17.30399201960269,
-        17.62635644741625,
-        17.95219714852476,
-        18.281524751807332,
-        18.614349837764564,
-        18.95068293910138,
-        19.290534541298456,
-        19.633915083172692,
-        19.98083495742689,
-        20.331304511189067,
-        20.685334046541502,
-        21.042933821039977,
-        21.404114048223256,
-        21.76888489811322,
-        22.137256497705877,
-        22.50923893145328,
-        22.884842241736916,
-        23.264076429332462,
-        23.6469514538663,
-        24.033477234264016,
-        24.42366364919083,
-        24.817520537484558,
-        25.21505769858089,
-        25.61628489293138,
-        26.021211842414342,
-        26.429848230738664,
-        26.842203703840827,
-        27.258287870275353,
-        27.678110301598522,
-        28.10168053274597,
-        28.529008062403893,
-        28.96010235337422,
-        29.39497283293396,
-        29.83362889318845,
-        30.276079891419332,
-        30.722335150426627,
-        31.172403958865512,
-        31.62629557157785,
-        32.08401920991837,
-        32.54558406207592,
-        33.010999283389665,
-        33.4802739966603,
-        33.953417292456834,
-        34.430438229418264,
-        34.911345834551085,
-        35.39614910352207,
-        35.88485700094671,
-        36.37747846067349,
-        36.87402238606382,
-        37.37449765026789,
-        37.87891309649659,
-        38.38727753828926,
-        38.89959975977785,
-        39.41588851594697,
-        39.93615253289054,
-        40.460400508064545,
-        40.98864111053629,
-        41.520882981230194,
-        42.05713473317016,
-        42.597404951718396,
-        43.141702194811224,
-        43.6900349931913,
-        44.24241185063697,
-        44.798841244188324,
-        45.35933162437017,
-        45.92389141541209,
-        46.49252901546552,
-        47.065252796817916,
-        47.64207110610409,
-        48.22299226451468,
-        48.808024568002054,
-        49.3971762874833,
-        49.9904556690408,
-        50.587870934119984,
-        51.189430279724725,
-        51.79514187861014,
-        52.40501387947288,
-        53.0190544071392,
-        53.637271562750364,
-        54.259673423945976,
-        54.88626804504493,
-        55.517063457223934,
-        56.15206766869424,
-        56.79128866487574,
-        57.43473440856916,
-        58.08241284012621,
-        58.734331877617365,
-        59.39049941699807,
-        60.05092333227251,
-        60.715611475655585,
-        61.38457167773311,
-        62.057811747619894,
-        62.7353394731159,
-        63.417162620860914,
-        64.10328893648692,
-        64.79372614476921,
-        65.48848194977529,
-        66.18756403501224,
-        66.89098006357258,
-        67.59873767827808,
-        68.31084450182222,
-        69.02730813691093,
-        69.74813616640164,
-        70.47333615344107,
-        71.20291564160104,
-        71.93688215501312,
-        72.67524319850172,
-        73.41800625771542,
-        74.16517879925733,
-        74.9167682708136,
-        75.67278210128072,
-        76.43322770089146,
-        77.1981124613393,
-        77.96744375590167,
-        78.74122893956174,
-        79.51947534912904,
-        80.30219030335869,
-        81.08938110306934,
-        81.88105503125999,
-        82.67721935322541,
-        83.4778813166706,
-        84.28304815182372,
-        85.09272707154808,
-        85.90692527145302,
-        86.72564993000343,
-        87.54890820862819,
-        88.3767072518277,
-        89.2090541872801,
-        90.04595612594655,
-        90.88742016217518,
-        91.73345337380438,
-        92.58406282226491,
-        93.43925555268066,
-        94.29903859396902,
-        95.16341895893969,
-        96.03240364439274,
-        96.9059996312159,
-        97.78421388448044,
-        98.6670533535366,
-        99.55452497210776,
-      };
-
-  /**
-   * Sanitizes a small enough angle in radians.
-   *
-   * @param angle An angle in radians; must not deviate too much from 0.
-   * @return A coterminal angle between 0 and 2pi.
-   */
-  static double sanitizeRadians(double angle) {
-    return (angle + Math.PI * 8) % (Math.PI * 2);
-  }
-
-  /**
-   * Delinearizes an RGB component, returning a floating-point number.
-   *
-   * @param rgbComponent 0.0 <= rgb_component <= 100.0, represents linear R/G/B channel
-   * @return 0.0 <= output <= 255.0, color channel converted to regular RGB space
-   */
-  static double trueDelinearized(double rgbComponent) {
-    double normalized = rgbComponent / 100.0;
-    double delinearized = 0.0;
-    if (normalized <= 0.0031308) {
-      delinearized = normalized * 12.92;
-    } else {
-      delinearized = 1.055 * Math.pow(normalized, 1.0 / 2.4) - 0.055;
-    }
-    return delinearized * 255.0;
-  }
-
-  static double chromaticAdaptation(double component) {
-    double af = Math.pow(Math.abs(component), 0.42);
-    return MathUtils.signum(component) * 400.0 * af / (af + 27.13);
-  }
-
-  /**
-   * Returns the hue of a linear RGB color in CAM16.
-   *
-   * @param linrgb The linear RGB coordinates of a color.
-   * @return The hue of the color in CAM16, in radians.
-   */
-  static double hueOf(double[] linrgb) {
-    double[] scaledDiscount = MathUtils.matrixMultiply(linrgb, SCALED_DISCOUNT_FROM_LINRGB);
-    double rA = chromaticAdaptation(scaledDiscount[0]);
-    double gA = chromaticAdaptation(scaledDiscount[1]);
-    double bA = chromaticAdaptation(scaledDiscount[2]);
-    // redness-greenness
-    double a = (11.0 * rA + -12.0 * gA + bA) / 11.0;
-    // yellowness-blueness
-    double b = (rA + gA - 2.0 * bA) / 9.0;
-    return Math.atan2(b, a);
-  }
-
-  static boolean areInCyclicOrder(double a, double b, double c) {
-    double deltaAB = sanitizeRadians(b - a);
-    double deltaAC = sanitizeRadians(c - a);
-    return deltaAB < deltaAC;
-  }
-
-  /**
-   * Solves the lerp equation.
-   *
-   * @param source The starting number.
-   * @param mid The number in the middle.
-   * @param target The ending number.
-   * @return A number t such that lerp(source, target, t) = mid.
-   */
-  static double intercept(double source, double mid, double target) {
-    return (mid - source) / (target - source);
-  }
-
-  static double[] lerpPoint(double[] source, double t, double[] target) {
-    return new double[] {
-      source[0] + (target[0] - source[0]) * t,
-      source[1] + (target[1] - source[1]) * t,
-      source[2] + (target[2] - source[2]) * t,
-    };
-  }
-
-  /**
-   * Intersects a segment with a plane.
-   *
-   * @param source The coordinates of point A.
-   * @param coordinate The R-, G-, or B-coordinate of the plane.
-   * @param target The coordinates of point B.
-   * @param axis The axis the plane is perpendicular with. (0: R, 1: G, 2: B)
-   * @return The intersection point of the segment AB with the plane R=coordinate, G=coordinate, or
-   *     B=coordinate
-   */
-  static double[] setCoordinate(double[] source, double coordinate, double[] target, int axis) {
-    double t = intercept(source[axis], coordinate, target[axis]);
-    return lerpPoint(source, t, target);
-  }
-
-  static boolean isBounded(double x) {
-    return 0.0 <= x && x <= 100.0;
-  }
-
-  /**
-   * Returns the nth possible vertex of the polygonal intersection.
-   *
-   * @param y The Y value of the plane.
-   * @param n The zero-based index of the point. 0 <= n <= 11.
-   * @return The nth possible vertex of the polygonal intersection of the y plane and the RGB cube,
-   *     in linear RGB coordinates, if it exists. If this possible vertex lies outside of the cube,
-   *     [-1.0, -1.0, -1.0] is returned.
-   */
-  static double[] nthVertex(double y, int n) {
-    double kR = Y_FROM_LINRGB[0];
-    double kG = Y_FROM_LINRGB[1];
-    double kB = Y_FROM_LINRGB[2];
-    double coordA = n % 4 <= 1 ? 0.0 : 100.0;
-    double coordB = n % 2 == 0 ? 0.0 : 100.0;
-    if (n < 4) {
-      double g = coordA;
-      double b = coordB;
-      double r = (y - g * kG - b * kB) / kR;
-      if (isBounded(r)) {
-        return new double[] {r, g, b};
-      } else {
-        return new double[] {-1.0, -1.0, -1.0};
-      }
-    } else if (n < 8) {
-      double b = coordA;
-      double r = coordB;
-      double g = (y - r * kR - b * kB) / kG;
-      if (isBounded(g)) {
-        return new double[] {r, g, b};
-      } else {
-        return new double[] {-1.0, -1.0, -1.0};
-      }
-    } else {
-      double r = coordA;
-      double g = coordB;
-      double b = (y - r * kR - g * kG) / kB;
-      if (isBounded(b)) {
-        return new double[] {r, g, b};
-      } else {
-        return new double[] {-1.0, -1.0, -1.0};
-      }
-    }
-  }
-
-  /**
-   * Finds the segment containing the desired color.
-   *
-   * @param y The Y value of the color.
-   * @param targetHue The hue of the color.
-   * @return A list of two sets of linear RGB coordinates, each corresponding to an endpoint of the
-   *     segment containing the desired color.
-   */
-  static double[][] bisectToSegment(double y, double targetHue) {
-    double[] left = new double[] {-1.0, -1.0, -1.0};
-    double[] right = left;
-    double leftHue = 0.0;
-    double rightHue = 0.0;
-    boolean initialized = false;
-    boolean uncut = true;
-    for (int n = 0; n < 12; n++) {
-      double[] mid = nthVertex(y, n);
-      if (mid[0] < 0) {
-        continue;
-      }
-      double midHue = hueOf(mid);
-      if (!initialized) {
-        left = mid;
-        right = mid;
-        leftHue = midHue;
-        rightHue = midHue;
-        initialized = true;
-        continue;
-      }
-      if (uncut || areInCyclicOrder(leftHue, midHue, rightHue)) {
-        uncut = false;
-        if (areInCyclicOrder(leftHue, targetHue, midHue)) {
-          right = mid;
-          rightHue = midHue;
-        } else {
-          left = mid;
-          leftHue = midHue;
-        }
-      }
-    }
-    return new double[][] {left, right};
-  }
-
-  static double[] midpoint(double[] a, double[] b) {
-    return new double[] {
-      (a[0] + b[0]) / 2, (a[1] + b[1]) / 2, (a[2] + b[2]) / 2,
-    };
-  }
-
-  static int criticalPlaneBelow(double x) {
-    return (int) Math.floor(x - 0.5);
-  }
-
-  static int criticalPlaneAbove(double x) {
-    return (int) Math.ceil(x - 0.5);
-  }
-
-  /**
-   * Finds a color with the given Y and hue on the boundary of the cube.
-   *
-   * @param y The Y value of the color.
-   * @param targetHue The hue of the color.
-   * @return The desired color, in linear RGB coordinates.
-   */
-  static double[] bisectToLimit(double y, double targetHue) {
-    double[][] segment = bisectToSegment(y, targetHue);
-    double[] left = segment[0];
-    double leftHue = hueOf(left);
-    double[] right = segment[1];
-    for (int axis = 0; axis < 3; axis++) {
-      if (left[axis] != right[axis]) {
-        int lPlane = -1;
-        int rPlane = 255;
-        if (left[axis] < right[axis]) {
-          lPlane = criticalPlaneBelow(trueDelinearized(left[axis]));
-          rPlane = criticalPlaneAbove(trueDelinearized(right[axis]));
-        } else {
-          lPlane = criticalPlaneAbove(trueDelinearized(left[axis]));
-          rPlane = criticalPlaneBelow(trueDelinearized(right[axis]));
-        }
-        for (int i = 0; i < 8; i++) {
-          if (Math.abs(rPlane - lPlane) <= 1) {
-            break;
-          } else {
-            int mPlane = (int) Math.floor((lPlane + rPlane) / 2.0);
-            double midPlaneCoordinate = CRITICAL_PLANES[mPlane];
-            double[] mid = setCoordinate(left, midPlaneCoordinate, right, axis);
-            double midHue = hueOf(mid);
-            if (areInCyclicOrder(leftHue, targetHue, midHue)) {
-              right = mid;
-              rPlane = mPlane;
-            } else {
-              left = mid;
-              leftHue = midHue;
-              lPlane = mPlane;
-            }
-          }
-        }
-      }
-    }
-    return midpoint(left, right);
-  }
-
-  static double inverseChromaticAdaptation(double adapted) {
-    double adaptedAbs = Math.abs(adapted);
-    double base = Math.max(0, 27.13 * adaptedAbs / (400.0 - adaptedAbs));
-    return MathUtils.signum(adapted) * Math.pow(base, 1.0 / 0.42);
-  }
-
-  /**
-   * Finds a color with the given hue, chroma, and Y.
-   *
-   * @param hueRadians The desired hue in radians.
-   * @param chroma The desired chroma.
-   * @param y The desired Y.
-   * @return The desired color as a hexadecimal integer, if found; 0 otherwise.
-   */
-  static int findResultByJ(double hueRadians, double chroma, double y) {
-    // Initial estimate of j.
-    double j = Math.sqrt(y) * 11.0;
-    // ===========================================================
-    // Operations inlined from Cam16 to avoid repeated calculation
-    // ===========================================================
-    ViewingConditions viewingConditions = ViewingConditions.DEFAULT;
-    double tInnerCoeff = 1 / Math.pow(1.64 - Math.pow(0.29, viewingConditions.getN()), 0.73);
-    double eHue = 0.25 * (Math.cos(hueRadians + 2.0) + 3.8);
-    double p1 = eHue * (50000.0 / 13.0) * viewingConditions.getNc() * viewingConditions.getNcb();
-    double hSin = Math.sin(hueRadians);
-    double hCos = Math.cos(hueRadians);
-    for (int iterationRound = 0; iterationRound < 5; iterationRound++) {
-      // ===========================================================
-      // Operations inlined from Cam16 to avoid repeated calculation
-      // ===========================================================
-      double jNormalized = j / 100.0;
-      double alpha = chroma == 0.0 || j == 0.0 ? 0.0 : chroma / Math.sqrt(jNormalized);
-      double t = Math.pow(alpha * tInnerCoeff, 1.0 / 0.9);
-      double ac =
-          viewingConditions.getAw()
-              * Math.pow(jNormalized, 1.0 / viewingConditions.getC() / viewingConditions.getZ());
-      double p2 = ac / viewingConditions.getNbb();
-      double gamma = 23.0 * (p2 + 0.305) * t / (23.0 * p1 + 11 * t * hCos + 108.0 * t * hSin);
-      double a = gamma * hCos;
-      double b = gamma * hSin;
-      double rA = (460.0 * p2 + 451.0 * a + 288.0 * b) / 1403.0;
-      double gA = (460.0 * p2 - 891.0 * a - 261.0 * b) / 1403.0;
-      double bA = (460.0 * p2 - 220.0 * a - 6300.0 * b) / 1403.0;
-      double rCScaled = inverseChromaticAdaptation(rA);
-      double gCScaled = inverseChromaticAdaptation(gA);
-      double bCScaled = inverseChromaticAdaptation(bA);
-      double[] linrgb =
-          MathUtils.matrixMultiply(
-              new double[] {rCScaled, gCScaled, bCScaled}, LINRGB_FROM_SCALED_DISCOUNT);
-      // ===========================================================
-      // Operations inlined from Cam16 to avoid repeated calculation
-      // ===========================================================
-      if (linrgb[0] < 0 || linrgb[1] < 0 || linrgb[2] < 0) {
-        return 0;
-      }
-      double kR = Y_FROM_LINRGB[0];
-      double kG = Y_FROM_LINRGB[1];
-      double kB = Y_FROM_LINRGB[2];
-      double fnj = kR * linrgb[0] + kG * linrgb[1] + kB * linrgb[2];
-      if (fnj <= 0) {
-        return 0;
-      }
-      if (iterationRound == 4 || Math.abs(fnj - y) < 0.002) {
-        if (linrgb[0] > 100.01 || linrgb[1] > 100.01 || linrgb[2] > 100.01) {
-          return 0;
-        }
-        return ColorUtils.argbFromLinrgb(linrgb);
-      }
-      // Iterates with Newton method,
-      // Using 2 * fn(j) / j as the approximation of fn'(j)
-      j = j - (fnj - y) * j / (2 * fnj);
-    }
-    return 0;
-  }
-
-  /**
-   * Finds an sRGB color with the given hue, chroma, and L*, if possible.
-   *
-   * @param hueDegrees The desired hue, in degrees.
-   * @param chroma The desired chroma.
-   * @param lstar The desired L*.
-   * @return A hexadecimal representing the sRGB color. The color has sufficiently close hue,
-   *     chroma, and L* to the desired values, if possible; otherwise, the hue and L* will be
-   *     sufficiently close, and chroma will be maximized.
-   */
-  public static int solveToInt(double hueDegrees, double chroma, double lstar) {
-    if (chroma < 0.0001 || lstar < 0.0001 || lstar > 99.9999) {
-      return ColorUtils.argbFromLstar(lstar);
-    }
-    hueDegrees = MathUtils.sanitizeDegreesDouble(hueDegrees);
-    double hueRadians = hueDegrees / 180 * Math.PI;
-    double y = ColorUtils.yFromLstar(lstar);
-    int exactAnswer = findResultByJ(hueRadians, chroma, y);
-    if (exactAnswer != 0) {
-      return exactAnswer;
-    }
-    double[] linrgb = bisectToLimit(y, hueRadians);
-    return ColorUtils.argbFromLinrgb(linrgb);
-  }
-
-  /**
-   * Finds an sRGB color with the given hue, chroma, and L*, if possible.
-   *
-   * @param hueDegrees The desired hue, in degrees.
-   * @param chroma The desired chroma.
-   * @param lstar The desired L*.
-   * @return An CAM16 object representing the sRGB color. The color has sufficiently close hue,
-   *     chroma, and L* to the desired values, if possible; otherwise, the hue and L* will be
-   *     sufficiently close, and chroma will be maximized.
-   */
-  public static Cam16 solveToCam(double hueDegrees, double chroma, double lstar) {
-    return Cam16.fromInt(solveToInt(hueDegrees, chroma, lstar));
-  }
-}
-

material-color-utilities/src/main/java/hct/ViewingConditions.java

@@ -1,197 +0,0 @@
-/*
- * Copyright 2021 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.
- */
-
-package hct;
-
-import utils.ColorUtils;
-import utils.MathUtils;
-
-/**
- * In traditional color spaces, a color can be identified solely by the observer's measurement of
- * the color. Color appearance models such as CAM16 also use information about the environment where
- * the color was observed, known as the viewing conditions.
- *
- * <p>For example, white under the traditional assumption of a midday sun white point is accurately
- * measured as a slightly chromatic blue by CAM16. (roughly, hue 203, chroma 3, lightness 100)
- *
- * <p>This class caches intermediate values of the CAM16 conversion process that depend only on
- * viewing conditions, enabling speed ups.
- */
-public final class ViewingConditions {
-  /** sRGB-like viewing conditions. */
-  public static final ViewingConditions DEFAULT =
-      ViewingConditions.make(
-          new double[] {
-            ColorUtils.whitePointD65()[0],
-            ColorUtils.whitePointD65()[1],
-            ColorUtils.whitePointD65()[2]
-          },
-          (200.0 / Math.PI * ColorUtils.yFromLstar(50.0) / 100.f),
-          50.0,
-          2.0,
-          false);
-
-  private final double aw;
-  private final double nbb;
-  private final double ncb;
-  private final double c;
-  private final double nc;
-  private final double n;
-  private final double[] rgbD;
-  private final double fl;
-  private final double flRoot;
-  private final double z;
-
-  public double getAw() {
-    return aw;
-  }
-
-  public double getN() {
-    return n;
-  }
-
-  public double getNbb() {
-    return nbb;
-  }
-
-  double getNcb() {
-    return ncb;
-  }
-
-  double getC() {
-    return c;
-  }
-
-  double getNc() {
-    return nc;
-  }
-
-  public double[] getRgbD() {
-    return rgbD;
-  }
-
-  double getFl() {
-    return fl;
-  }
-
-  public double getFlRoot() {
-    return flRoot;
-  }
-
-  double getZ() {
-    return z;
-  }
-
-  /**
-   * Create ViewingConditions from a simple, physically relevant, set of parameters.
-   *
-   * @param whitePoint White point, measured in the XYZ color space. default = D65, or sunny day
-   *     afternoon
-   * @param adaptingLuminance The luminance of the adapting field. Informally, how bright it is in
-   *     the room where the color is viewed. Can be calculated from lux by multiplying lux by
-   *     0.0586. default = 11.72, or 200 lux.
-   * @param backgroundLstar The lightness of the area surrounding the color. measured by L* in
-   *     L*a*b*. default = 50.0
-   * @param surround A general description of the lighting surrounding the color. 0 is pitch dark,
-   *     like watching a movie in a theater. 1.0 is a dimly light room, like watching TV at home at
-   *     night. 2.0 means there is no difference between the lighting on the color and around it.
-   *     default = 2.0
-   * @param discountingIlluminant Whether the eye accounts for the tint of the ambient lighting,
-   *     such as knowing an apple is still red in green light. default = false, the eye does not
-   *     perform this process on self-luminous objects like displays.
-   */
-  static ViewingConditions make(
-      double[] whitePoint,
-      double adaptingLuminance,
-      double backgroundLstar,
-      double surround,
-      boolean discountingIlluminant) {
-    // Transform white point XYZ to 'cone'/'rgb' responses
-    double[][] matrix = Cam16.XYZ_TO_CAM16RGB;
-    double[] xyz = whitePoint;
-    double rW = (xyz[0] * matrix[0][0]) + (xyz[1] * matrix[0][1]) + (xyz[2] * matrix[0][2]);
-    double gW = (xyz[0] * matrix[1][0]) + (xyz[1] * matrix[1][1]) + (xyz[2] * matrix[1][2]);
-    double bW = (xyz[0] * matrix[2][0]) + (xyz[1] * matrix[2][1]) + (xyz[2] * matrix[2][2]);
-    double f = 0.8 + (surround / 10.0);
-    double c =
-        (f >= 0.9)
-            ? MathUtils.lerp(0.59, 0.69, ((f - 0.9) * 10.0))
-            : MathUtils.lerp(0.525, 0.59, ((f - 0.8) * 10.0));
-    double d =
-        discountingIlluminant
-            ? 1.0
-            : f * (1.0 - ((1.0 / 3.6) * Math.exp((-adaptingLuminance - 42.0) / 92.0)));
-    d = MathUtils.clampDouble(0.0, 1.0, d);
-    double nc = f;
-    double[] rgbD =
-        new double[] {
-          d * (100.0 / rW) + 1.0 - d, d * (100.0 / gW) + 1.0 - d, d * (100.0 / bW) + 1.0 - d
-        };
-    double k = 1.0 / (5.0 * adaptingLuminance + 1.0);
-    double k4 = k * k * k * k;
-    double k4F = 1.0 - k4;
-    double fl = (k4 * adaptingLuminance) + (0.1 * k4F * k4F * Math.cbrt(5.0 * adaptingLuminance));
-    double n = (ColorUtils.yFromLstar(backgroundLstar) / whitePoint[1]);
-    double z = 1.48 + Math.sqrt(n);
-    double nbb = 0.725 / Math.pow(n, 0.2);
-    double ncb = nbb;
-    double[] rgbAFactors =
-        new double[] {
-          Math.pow(fl * rgbD[0] * rW / 100.0, 0.42),
-          Math.pow(fl * rgbD[1] * gW / 100.0, 0.42),
-          Math.pow(fl * rgbD[2] * bW / 100.0, 0.42)
-        };
-
-    double[] rgbA =
-        new double[] {
-          (400.0 * rgbAFactors[0]) / (rgbAFactors[0] + 27.13),
-          (400.0 * rgbAFactors[1]) / (rgbAFactors[1] + 27.13),
-          (400.0 * rgbAFactors[2]) / (rgbAFactors[2] + 27.13)
-        };
-
-    double aw = ((2.0 * rgbA[0]) + rgbA[1] + (0.05 * rgbA[2])) * nbb;
-    return new ViewingConditions(n, aw, nbb, ncb, c, nc, rgbD, fl, Math.pow(fl, 0.25), z);
-  }
-
-  /**
-   * Parameters are intermediate values of the CAM16 conversion process. Their names are shorthand
-   * for technical color science terminology, this class would not benefit from documenting them
-   * individually. A brief overview is available in the CAM16 specification, and a complete overview
-   * requires a color science textbook, such as Fairchild's Color Appearance Models.
-   */
-  private ViewingConditions(
-      double n,
-      double aw,
-      double nbb,
-      double ncb,
-      double c,
-      double nc,
-      double[] rgbD,
-      double fl,
-      double flRoot,
-      double z) {
-    this.n = n;
-    this.aw = aw;
-    this.nbb = nbb;
-    this.ncb = ncb;
-    this.c = c;
-    this.nc = nc;
-    this.rgbD = rgbD;
-    this.fl = fl;
-    this.flRoot = flRoot;
-    this.z = z;
-  }
-}

material-color-utilities/src/main/java/palettes/CorePalette.java

@@ -1,73 +0,0 @@
-/*
- * Copyright 2021 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.
- */
-
-package palettes;
-
-import static java.lang.Math.max;
-import static java.lang.Math.min;
-
-import hct.Hct;
-
-/**
- * An intermediate concept between the key color for a UI theme, and a full color scheme. 5 sets of
- * tones are generated, all except one use the same hue as the key color, and all vary in chroma.
- */
-public final class CorePalette {
-  public TonalPalette a1;
-  public TonalPalette a2;
-  public TonalPalette a3;
-  public TonalPalette n1;
-  public TonalPalette n2;
-  public TonalPalette error;
-
-  /**
-   * Create key tones from a color.
-   *
-   * @param argb ARGB representation of a color
-   */
-  public static CorePalette of(int argb) {
-    return new CorePalette(argb, false);
-  }
-
-  /**
-   * Create content key tones from a color.
-   *
-   * @param argb ARGB representation of a color
-   */
-  public static CorePalette contentOf(int argb) {
-    return new CorePalette(argb, true);
-  }
-
-  private CorePalette(int argb, boolean isContent) {
-    Hct hct = Hct.fromInt(argb);
-    double hue = hct.getHue();
-    double chroma = hct.getChroma();
-    if (isContent) {
-      this.a1 = TonalPalette.fromHueAndChroma(hue, chroma);
-      this.a2 = TonalPalette.fromHueAndChroma(hue, chroma / 3.);
-      this.a3 = TonalPalette.fromHueAndChroma(hue + 60., chroma / 2.);
-      this.n1 = TonalPalette.fromHueAndChroma(hue, min(chroma / 12., 4.));
-      this.n2 = TonalPalette.fromHueAndChroma(hue, min(chroma / 6., 8.));
-    } else {
-      this.a1 = TonalPalette.fromHueAndChroma(hue, max(48., chroma));
-      this.a2 = TonalPalette.fromHueAndChroma(hue, 16.);
-      this.a3 = TonalPalette.fromHueAndChroma(hue + 60., 24.);
-      this.n1 = TonalPalette.fromHueAndChroma(hue, 4.);
-      this.n2 = TonalPalette.fromHueAndChroma(hue, 8.);
-    }
-    this.error = TonalPalette.fromHueAndChroma(25, 84.);
-  }
-}

material-color-utilities/src/main/java/palettes/TonalPalette.java

@@ -1,75 +0,0 @@
-/*
- * Copyright 2021 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.
- */
-
-package palettes;
-
-import hct.Hct;
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * A convenience class for retrieving colors that are constant in hue and chroma, but vary in tone.
- */
-public final class TonalPalette {
-  Map<Integer, Integer> cache;
-  double hue;
-  double chroma;
-
-  /**
-   * Create tones using the HCT hue and chroma from a color.
-   *
-   * @param argb ARGB representation of a color
-   * @return Tones matching that color's hue and chroma.
-   */
-  public static final TonalPalette fromInt(int argb) {
-    Hct hct = Hct.fromInt(argb);
-    return TonalPalette.fromHueAndChroma(hct.getHue(), hct.getChroma());
-  }
-
-  /**
-   * Create tones from a defined HCT hue and chroma.
-   *
-   * @param hue HCT hue
-   * @param chroma HCT chroma
-   * @return Tones matching hue and chroma.
-   */
-  public static final TonalPalette fromHueAndChroma(double hue, double chroma) {
-    return new TonalPalette(hue, chroma);
-  }
-
-  private TonalPalette(double hue, double chroma) {
-    cache = new HashMap<>();
-    this.hue = hue;
-    this.chroma = chroma;
-  }
-
-  /**
-   * Create an ARGB color with HCT hue and chroma of this Tones instance, and the provided HCT tone.
-   *
-   * @param tone HCT tone, measured from 0 to 100.
-   * @return ARGB representation of a color with that tone.
-   */
-  // AndroidJdkLibsChecker is higher priority than ComputeIfAbsentUseValue (b/119581923)
-  @SuppressWarnings("ComputeIfAbsentUseValue")
-  public int tone(int tone) {
-    Integer color = cache.get(tone);
-    if (color == null) {
-      color = Hct.from(this.hue, this.chroma, tone).toInt();
-      cache.put(tone, color);
-    }
-    return color;
-  }
-}

material-color-utilities/src/main/java/quantize/PointProvider.java

@@ -1,26 +0,0 @@
-/*
- * Copyright 2021 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.
- */
-
-package quantize;
-
-/** An interface to allow use of different color spaces by quantizers. */
-public interface PointProvider {
-  public double[] fromInt(int argb);
-
-  public int toInt(double[] point);
-
-  public double distance(double[] a, double[] b);
-}

material-color-utilities/src/main/java/quantize/PointProviderLab.java

@@ -1,56 +0,0 @@
-/*
- * Copyright 2021 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.
- */
-
-package quantize;
-
-import utils.ColorUtils;
-
-/**
- * Provides conversions needed for K-Means quantization. Converting input to points, and converting
- * the final state of the K-Means algorithm to colors.
- */
-public final class PointProviderLab implements PointProvider {
-  /**
-   * Convert a color represented in ARGB to a 3-element array of L*a*b* coordinates of the color.
-   */
-  @Override
-  public double[] fromInt(int argb) {
-    double[] lab = ColorUtils.labFromArgb(argb);
-    return new double[] {lab[0], lab[1], lab[2]};
-  }
-
-  /** Convert a 3-element array to a color represented in ARGB. */
-  @Override
-  public int toInt(double[] lab) {
-    return ColorUtils.argbFromLab(lab[0], lab[1], lab[2]);
-  }
-
-  /**
-   * Standard CIE 1976 delta E formula also takes the square root, unneeded here. This method is
-   * used by quantization algorithms to compare distance, and the relative ordering is the same,
-   * with or without a square root.
-   *
-   * <p>This relatively minor optimization is helpful because this method is called at least once
-   * for each pixel in an image.
-   */
-  @Override
-  public double distance(double[] one, double[] two) {
-    double dL = (one[0] - two[0]);
-    double dA = (one[1] - two[1]);
-    double dB = (one[2] - two[2]);
-    return (dL * dL + dA * dA + dB * dB);
-  }
-}

material-color-utilities/src/main/java/quantize/Quantizer.java

@@ -1,21 +0,0 @@
-/*
- * Copyright 2021 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.
- */
-
-package quantize;
-
-interface Quantizer {
-  public QuantizerResult quantize(int[] pixels, int maxColors);
-}

material-color-utilities/src/main/java/quantize/QuantizerCelebi.java

@@ -1,57 +0,0 @@
-/*
- * Copyright 2021 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.
- */
-
-package quantize;
-
-import java.util.Map;
-import java.util.Set;
-
-/**
- * An image quantizer that improves on the quality of a standard K-Means algorithm by setting the
- * K-Means initial state to the output of a Wu quantizer, instead of random centroids. Improves on
- * speed by several optimizations, as implemented in Wsmeans, or Weighted Square Means, K-Means with
- * those optimizations.
- *
- * <p>This algorithm was designed by M. Emre Celebi, and was found in their 2011 paper, Improving
- * the Performance of K-Means for Color Quantization. https://arxiv.org/abs/1101.0395
- */
-public final class QuantizerCelebi {
-  private QuantizerCelebi() {}
-
-  /**
-   * Reduce the number of colors needed to represented the input, minimizing the difference between
-   * the original image and the recolored image.
-   *
-   * @param pixels Colors in ARGB format.
-   * @param maxColors The number of colors to divide the image into. A lower number of colors may be
-   *     returned.
-   * @return Map with keys of colors in ARGB format, and values of number of pixels in the original
-   *     image that correspond to the color in the quantized image.
-   */
-  public static Map<Integer, Integer> quantize(int[] pixels, int maxColors) {
-    QuantizerWu wu = new QuantizerWu();
-    QuantizerResult wuResult = wu.quantize(pixels, maxColors);
-
-    Set<Integer> wuClustersAsObjects = wuResult.colorToCount.keySet();
-    int index = 0;
-    int[] wuClusters = new int[wuClustersAsObjects.size()];
-    for (Integer argb : wuClustersAsObjects) {
-      wuClusters[index++] = argb;
-    }
-
-    return QuantizerWsmeans.quantize(pixels, wuClusters, maxColors);
-  }
-}

material-color-utilities/src/main/java/quantize/QuantizerMap.java

@@ -1,41 +0,0 @@
-/*
- * Copyright 2021 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.
- */
-
-package quantize;
-
-import java.util.HashMap;
-import java.util.Map;
-
-/** Creates a dictionary with keys of colors, and values of count of the color */
-public final class QuantizerMap implements Quantizer {
-  Map<Integer, Integer> colorToCount;
-
-  @Override
-  public QuantizerResult quantize(int[] pixels, int colorCount) {
-    final HashMap<Integer, Integer> pixelByCount = new HashMap<>();
-    for (int pixel : pixels) {
-      final Integer currentPixelCount = pixelByCount.get(pixel);
-      final int newPixelCount = currentPixelCount == null ? 1 : currentPixelCount + 1;
-      pixelByCount.put(pixel, newPixelCount);
-    }
-    colorToCount = pixelByCount;
-    return new QuantizerResult(pixelByCount);
-  }
-
-  public Map<Integer, Integer> getColorToCount() {
-    return colorToCount;
-  }
-}

material-color-utilities/src/main/java/quantize/QuantizerResult.java

@@ -1,28 +0,0 @@
-/*
- * Copyright 2021 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.
- */
-
-package quantize;
-
-import java.util.Map;
-
-/** Represents result of a quantizer run */
-public final class QuantizerResult {
-  public final Map<Integer, Integer> colorToCount;
-
-  QuantizerResult(Map<Integer, Integer> colorToCount) {
-    this.colorToCount = colorToCount;
-  }
-}

material-color-utilities/src/main/java/quantize/QuantizerWsmeans.java

@@ -1,229 +0,0 @@
-/*
- * Copyright 2021 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.
- */
-
-package quantize;
-
-import static java.lang.Math.min;
-
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * An image quantizer that improves on the speed of a standard K-Means algorithm by implementing
- * several optimizations, including deduping identical pixels and a triangle inequality rule that
- * reduces the number of comparisons needed to identify which cluster a point should be moved to.
- *
- * <p>Wsmeans stands for Weighted Square Means.
- *
- * <p>This algorithm was designed by M. Emre Celebi, and was found in their 2011 paper, Improving
- * the Performance of K-Means for Color Quantization. https://arxiv.org/abs/1101.0395
- */
-public final class QuantizerWsmeans {
-  private QuantizerWsmeans() {}
-
-  private static final class Distance implements Comparable<Distance> {
-    int index;
-    double distance;
-
-    Distance() {
-      this.index = -1;
-      this.distance = -1;
-    }
-
-    @Override
-    public int compareTo(Distance other) {
-      return ((Double) this.distance).compareTo(other.distance);
-    }
-  }
-
-  private static final int MAX_ITERATIONS = 10;
-  private static final double MIN_MOVEMENT_DISTANCE = 3.0;
-
-  /**
-   * Reduce the number of colors needed to represented the input, minimizing the difference between
-   * the original image and the recolored image.
-   *
-   * @param inputPixels Colors in ARGB format.
-   * @param startingClusters Defines the initial state of the quantizer. Passing an empty array is
-   *     fine, the implementation will create its own initial state that leads to reproducible
-   *     results for the same inputs. Passing an array that is the result of Wu quantization leads
-   *     to higher quality results.
-   * @param maxColors The number of colors to divide the image into. A lower number of colors may be
-   *     returned.
-   * @return Map with keys of colors in ARGB format, values of how many of the input pixels belong
-   *     to the color.
-   */
-  public static Map<Integer, Integer> quantize(
-      int[] inputPixels, int[] startingClusters, int maxColors) {
-    Map<Integer, Integer> pixelToCount = new HashMap<>();
-    double[][] points = new double[inputPixels.length][];
-    int[] pixels = new int[inputPixels.length];
-    PointProvider pointProvider = new PointProviderLab();
-
-    int pointCount = 0;
-    for (int i = 0; i < inputPixels.length; i++) {
-      int inputPixel = inputPixels[i];
-      Integer pixelCount = pixelToCount.get(inputPixel);
-      if (pixelCount == null) {
-        points[pointCount] = pointProvider.fromInt(inputPixel);
-        pixels[pointCount] = inputPixel;
-        pointCount++;
-
-        pixelToCount.put(inputPixel, 1);
-      } else {
-        pixelToCount.put(inputPixel, pixelCount + 1);
-      }
-    }
-
-    int[] counts = new int[pointCount];
-    for (int i = 0; i < pointCount; i++) {
-      int pixel = pixels[i];
-      int count = pixelToCount.get(pixel);
-      counts[i] = count;
-    }
-
-    int clusterCount = min(maxColors, pointCount);
-    if (startingClusters.length != 0) {
-      clusterCount = min(clusterCount, startingClusters.length);
-    }
-
-    double[][] clusters = new double[clusterCount][];
-    int clustersCreated = 0;
-    for (int i = 0; i < startingClusters.length; i++) {
-      clusters[i] = pointProvider.fromInt(startingClusters[i]);
-      clustersCreated++;
-    }
-
-    int additionalClustersNeeded = clusterCount - clustersCreated;
-    if (additionalClustersNeeded > 0) {
-      for (int i = 0; i < additionalClustersNeeded; i++) {}
-    }
-
-    int[] clusterIndices = new int[pointCount];
-    for (int i = 0; i < pointCount; i++) {
-      clusterIndices[i] = (int) Math.floor(Math.random() * clusterCount);
-    }
-
-    int[][] indexMatrix = new int[clusterCount][];
-    for (int i = 0; i < clusterCount; i++) {
-      indexMatrix[i] = new int[clusterCount];
-    }
-
-    Distance[][] distanceToIndexMatrix = new Distance[clusterCount][];
-    for (int i = 0; i < clusterCount; i++) {
-      distanceToIndexMatrix[i] = new Distance[clusterCount];
-      for (int j = 0; j < clusterCount; j++) {
-        distanceToIndexMatrix[i][j] = new Distance();
-      }
-    }
-
-    int[] pixelCountSums = new int[clusterCount];
-    for (int iteration = 0; iteration < MAX_ITERATIONS; iteration++) {
-      for (int i = 0; i < clusterCount; i++) {
-        for (int j = i + 1; j < clusterCount; j++) {
-          double distance = pointProvider.distance(clusters[i], clusters[j]);
-          distanceToIndexMatrix[j][i].distance = distance;
-          distanceToIndexMatrix[j][i].index = i;
-          distanceToIndexMatrix[i][j].distance = distance;
-          distanceToIndexMatrix[i][j].index = j;
-        }
-        Arrays.sort(distanceToIndexMatrix[i]);
-        for (int j = 0; j < clusterCount; j++) {
-          indexMatrix[i][j] = distanceToIndexMatrix[i][j].index;
-        }
-      }
-
-      int pointsMoved = 0;
-      for (int i = 0; i < pointCount; i++) {
-        double[] point = points[i];
-        int previousClusterIndex = clusterIndices[i];
-        double[] previousCluster = clusters[previousClusterIndex];
-        double previousDistance = pointProvider.distance(point, previousCluster);
-
-        double minimumDistance = previousDistance;
-        int newClusterIndex = -1;
-        for (int j = 0; j < clusterCount; j++) {
-          if (distanceToIndexMatrix[previousClusterIndex][j].distance >= 4 * previousDistance) {
-            continue;
-          }
-          double distance = pointProvider.distance(point, clusters[j]);
-          if (distance < minimumDistance) {
-            minimumDistance = distance;
-            newClusterIndex = j;
-          }
-        }
-        if (newClusterIndex != -1) {
-          double distanceChange =
-              Math.abs(Math.sqrt(minimumDistance) - Math.sqrt(previousDistance));
-          if (distanceChange > MIN_MOVEMENT_DISTANCE) {
-            pointsMoved++;
-            clusterIndices[i] = newClusterIndex;
-          }
-        }
-      }
-
-      if (pointsMoved == 0 && iteration != 0) {
-        break;
-      }
-
-      double[] componentASums = new double[clusterCount];
-      double[] componentBSums = new double[clusterCount];
-      double[] componentCSums = new double[clusterCount];
-      Arrays.fill(pixelCountSums, 0);
-      for (int i = 0; i < pointCount; i++) {
-        int clusterIndex = clusterIndices[i];
-        double[] point = points[i];
-        int count = counts[i];
-        pixelCountSums[clusterIndex] += count;
-        componentASums[clusterIndex] += (point[0] * count);
-        componentBSums[clusterIndex] += (point[1] * count);
-        componentCSums[clusterIndex] += (point[2] * count);
-      }
-
-      for (int i = 0; i < clusterCount; i++) {
-        int count = pixelCountSums[i];
-        if (count == 0) {
-          clusters[i] = new double[] {0., 0., 0.};
-          continue;
-        }
-        double a = componentASums[i] / count;
-        double b = componentBSums[i] / count;
-        double c = componentCSums[i] / count;
-        clusters[i][0] = a;
-        clusters[i][1] = b;
-        clusters[i][2] = c;
-      }
-    }
-
-    Map<Integer, Integer> argbToPopulation = new HashMap<>();
-    for (int i = 0; i < clusterCount; i++) {
-      int count = pixelCountSums[i];
-      if (count == 0) {
-        continue;
-      }
-
-      int possibleNewCluster = pointProvider.toInt(clusters[i]);
-      if (argbToPopulation.containsKey(possibleNewCluster)) {
-        continue;
-      }
-
-      argbToPopulation.put(possibleNewCluster, count);
-    }
-
-    return argbToPopulation;
-  }
-}

material-color-utilities/src/main/java/quantize/QuantizerWu.java

@@ -1,406 +0,0 @@
-/*
- * Copyright 2021 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.
- */
-
-package quantize;
-
-import utils.ColorUtils;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * An image quantizer that divides the image's pixels into clusters by recursively cutting an RGB
- * cube, based on the weight of pixels in each area of the cube.
- *
- * <p>The algorithm was described by Xiaolin Wu in Graphic Gems II, published in 1991.
- */
-public final class QuantizerWu implements Quantizer {
-  int[] weights;
-  int[] momentsR;
-  int[] momentsG;
-  int[] momentsB;
-  double[] moments;
-  Box[] cubes;
-
-  // A histogram of all the input colors is constructed. It has the shape of a
-  // cube. The cube would be too large if it contained all 16 million colors:
-  // historical best practice is to use 5 bits  of the 8 in each channel,
-  // reducing the histogram to a volume of ~32,000.
-  private static final int INDEX_BITS = 5;
-  private static final int INDEX_COUNT = 33; // ((1 << INDEX_BITS) + 1)
-  private static final int TOTAL_SIZE = 35937; // INDEX_COUNT * INDEX_COUNT * INDEX_COUNT
-
-  @Override
-  public QuantizerResult quantize(int[] pixels, int colorCount) {
-    QuantizerResult mapResult = new QuantizerMap().quantize(pixels, colorCount);
-    constructHistogram(mapResult.colorToCount);
-    createMoments();
-    CreateBoxesResult createBoxesResult = createBoxes(colorCount);
-    List<Integer> colors = createResult(createBoxesResult.resultCount);
-    HashMap<Integer, Integer> resultMap = new HashMap<>();
-    for (int color : colors) {
-      resultMap.put(color, 0);
-    }
-    return new QuantizerResult(resultMap);
-  }
-
-  static int getIndex(int r, int g, int b) {
-    return (r << (INDEX_BITS * 2)) + (r << (INDEX_BITS + 1)) + r + (g << INDEX_BITS) + g + b;
-  }
-
-  void constructHistogram(Map<Integer, Integer> pixels) {
-    weights = new int[TOTAL_SIZE];
-    momentsR = new int[TOTAL_SIZE];
-    momentsG = new int[TOTAL_SIZE];
-    momentsB = new int[TOTAL_SIZE];
-    moments = new double[TOTAL_SIZE];
-
-    for (Map.Entry<Integer, Integer> pair : pixels.entrySet()) {
-      int pixel = pair.getKey();
-      int count = pair.getValue();
-      int red = ColorUtils.redFromArgb(pixel);
-      int green = ColorUtils.greenFromArgb(pixel);
-      int blue = ColorUtils.blueFromArgb(pixel);
-      int bitsToRemove = 8 - INDEX_BITS;
-      int iR = (red >> bitsToRemove) + 1;
-      int iG = (green >> bitsToRemove) + 1;
-      int iB = (blue >> bitsToRemove) + 1;
-      int index = getIndex(iR, iG, iB);
-      weights[index] += count;
-      momentsR[index] += (red * count);
-      momentsG[index] += (green * count);
-      momentsB[index] += (blue * count);
-      moments[index] += (count * ((red * red) + (green * green) + (blue * blue)));
-    }
-  }
-
-  void createMoments() {
-    for (int r = 1; r < INDEX_COUNT; ++r) {
-      int[] area = new int[INDEX_COUNT];
-      int[] areaR = new int[INDEX_COUNT];
-      int[] areaG = new int[INDEX_COUNT];
-      int[] areaB = new int[INDEX_COUNT];
-      double[] area2 = new double[INDEX_COUNT];
-
-      for (int g = 1; g < INDEX_COUNT; ++g) {
-        int line = 0;
-        int lineR = 0;
-        int lineG = 0;
-        int lineB = 0;
-        double line2 = 0.0;
-        for (int b = 1; b < INDEX_COUNT; ++b) {
-          int index = getIndex(r, g, b);
-          line += weights[index];
-          lineR += momentsR[index];
-          lineG += momentsG[index];
-          lineB += momentsB[index];
-          line2 += moments[index];
-
-          area[b] += line;
-          areaR[b] += lineR;
-          areaG[b] += lineG;
-          areaB[b] += lineB;
-          area2[b] += line2;
-
-          int previousIndex = getIndex(r - 1, g, b);
-          weights[index] = weights[previousIndex] + area[b];
-          momentsR[index] = momentsR[previousIndex] + areaR[b];
-          momentsG[index] = momentsG[previousIndex] + areaG[b];
-          momentsB[index] = momentsB[previousIndex] + areaB[b];
-          moments[index] = moments[previousIndex] + area2[b];
-        }
-      }
-    }
-  }
-
-  CreateBoxesResult createBoxes(int maxColorCount) {
-    cubes = new Box[maxColorCount];
-    for (int i = 0; i < maxColorCount; i++) {
-      cubes[i] = new Box();
-    }
-    double[] volumeVariance = new double[maxColorCount];
-    Box firstBox = cubes[0];
-    firstBox.r1 = INDEX_COUNT - 1;
-    firstBox.g1 = INDEX_COUNT - 1;
-    firstBox.b1 = INDEX_COUNT - 1;
-
-    int generatedColorCount = maxColorCount;
-    int next = 0;
-    for (int i = 1; i < maxColorCount; i++) {
-      if (cut(cubes[next], cubes[i])) {
-        volumeVariance[next] = (cubes[next].vol > 1) ? variance(cubes[next]) : 0.0;
-        volumeVariance[i] = (cubes[i].vol > 1) ? variance(cubes[i]) : 0.0;
-      } else {
-        volumeVariance[next] = 0.0;
-        i--;
-      }
-
-      next = 0;
-
-      double temp = volumeVariance[0];
-      for (int j = 1; j <= i; j++) {
-        if (volumeVariance[j] > temp) {
-          temp = volumeVariance[j];
-          next = j;
-        }
-      }
-      if (temp <= 0.0) {
-        generatedColorCount = i + 1;
-        break;
-      }
-    }
-
-    return new CreateBoxesResult(maxColorCount, generatedColorCount);
-  }
-
-  List<Integer> createResult(int colorCount) {
-    List<Integer> colors = new ArrayList<>();
-    for (int i = 0; i < colorCount; ++i) {
-      Box cube = cubes[i];
-      int weight = volume(cube, weights);
-      if (weight > 0) {
-        int r = volume(cube, momentsR) / weight;
-        int g = volume(cube, momentsG) / weight;
-        int b = volume(cube, momentsB) / weight;
-        int color = (255 << 24) | ((r & 0x0ff) << 16) | ((g & 0x0ff) << 8) | (b & 0x0ff);
-        colors.add(color);
-      }
-    }
-    return colors;
-  }
-
-  double variance(Box cube) {
-    int dr = volume(cube, momentsR);
-    int dg = volume(cube, momentsG);
-    int db = volume(cube, momentsB);
-    double xx =
-        moments[getIndex(cube.r1, cube.g1, cube.b1)]
-            - moments[getIndex(cube.r1, cube.g1, cube.b0)]
-            - moments[getIndex(cube.r1, cube.g0, cube.b1)]
-            + moments[getIndex(cube.r1, cube.g0, cube.b0)]
-            - moments[getIndex(cube.r0, cube.g1, cube.b1)]
-            + moments[getIndex(cube.r0, cube.g1, cube.b0)]
-            + moments[getIndex(cube.r0, cube.g0, cube.b1)]
-            - moments[getIndex(cube.r0, cube.g0, cube.b0)];
-
-    int hypotenuse = dr * dr + dg * dg + db * db;
-    int volume = volume(cube, weights);
-    return xx - (hypotenuse / volume);
-  }
-
-  Boolean cut(Box one, Box two) {
-    int wholeR = volume(one, momentsR);
-    int wholeG = volume(one, momentsG);
-    int wholeB = volume(one, momentsB);
-    int wholeW = volume(one, weights);
-
-    MaximizeResult maxRResult =
-        maximize(one, Direction.RED, one.r0 + 1, one.r1, wholeR, wholeG, wholeB, wholeW);
-    MaximizeResult maxGResult =
-        maximize(one, Direction.GREEN, one.g0 + 1, one.g1, wholeR, wholeG, wholeB, wholeW);
-    MaximizeResult maxBResult =
-        maximize(one, Direction.BLUE, one.b0 + 1, one.b1, wholeR, wholeG, wholeB, wholeW);
-    Direction cutDirection;
-    double maxR = maxRResult.maximum;
-    double maxG = maxGResult.maximum;
-    double maxB = maxBResult.maximum;
-    if (maxR >= maxG && maxR >= maxB) {
-      if (maxRResult.cutLocation < 0) {
-        return false;
-      }
-      cutDirection = Direction.RED;
-    } else if (maxG >= maxR && maxG >= maxB) {
-      cutDirection = Direction.GREEN;
-    } else {
-      cutDirection = Direction.BLUE;
-    }
-
-    two.r1 = one.r1;
-    two.g1 = one.g1;
-    two.b1 = one.b1;
-
-    switch (cutDirection) {
-      case RED:
-        one.r1 = maxRResult.cutLocation;
-        two.r0 = one.r1;
-        two.g0 = one.g0;
-        two.b0 = one.b0;
-        break;
-      case GREEN:
-        one.g1 = maxGResult.cutLocation;
-        two.r0 = one.r0;
-        two.g0 = one.g1;
-        two.b0 = one.b0;
-        break;
-      case BLUE:
-        one.b1 = maxBResult.cutLocation;
-        two.r0 = one.r0;
-        two.g0 = one.g0;
-        two.b0 = one.b1;
-        break;
-    }
-
-    one.vol = (one.r1 - one.r0) * (one.g1 - one.g0) * (one.b1 - one.b0);
-    two.vol = (two.r1 - two.r0) * (two.g1 - two.g0) * (two.b1 - two.b0);
-
-    return true;
-  }
-
-  MaximizeResult maximize(
-      Box cube,
-      Direction direction,
-      int first,
-      int last,
-      int wholeR,
-      int wholeG,
-      int wholeB,
-      int wholeW) {
-    int bottomR = bottom(cube, direction, momentsR);
-    int bottomG = bottom(cube, direction, momentsG);
-    int bottomB = bottom(cube, direction, momentsB);
-    int bottomW = bottom(cube, direction, weights);
-
-    double max = 0.0;
-    int cut = -1;
-
-    int halfR = 0;
-    int halfG = 0;
-    int halfB = 0;
-    int halfW = 0;
-    for (int i = first; i < last; i++) {
-      halfR = bottomR + top(cube, direction, i, momentsR);
-      halfG = bottomG + top(cube, direction, i, momentsG);
-      halfB = bottomB + top(cube, direction, i, momentsB);
-      halfW = bottomW + top(cube, direction, i, weights);
-      if (halfW == 0) {
-        continue;
-      }
-
-      double tempNumerator = halfR * halfR + halfG * halfG + halfB * halfB;
-      double tempDenominator = halfW;
-      double temp = tempNumerator / tempDenominator;
-
-      halfR = wholeR - halfR;
-      halfG = wholeG - halfG;
-      halfB = wholeB - halfB;
-      halfW = wholeW - halfW;
-      if (halfW == 0) {
-        continue;
-      }
-
-      tempNumerator = halfR * halfR + halfG * halfG + halfB * halfB;
-      tempDenominator = halfW;
-      temp += (tempNumerator / tempDenominator);
-
-      if (temp > max) {
-        max = temp;
-        cut = i;
-      }
-    }
-    return new MaximizeResult(cut, max);
-  }
-
-  static int volume(Box cube, int[] moment) {
-    return (moment[getIndex(cube.r1, cube.g1, cube.b1)]
-        - moment[getIndex(cube.r1, cube.g1, cube.b0)]
-        - moment[getIndex(cube.r1, cube.g0, cube.b1)]
-        + moment[getIndex(cube.r1, cube.g0, cube.b0)]
-        - moment[getIndex(cube.r0, cube.g1, cube.b1)]
-        + moment[getIndex(cube.r0, cube.g1, cube.b0)]
-        + moment[getIndex(cube.r0, cube.g0, cube.b1)]
-        - moment[getIndex(cube.r0, cube.g0, cube.b0)]);
-  }
-
-  static int bottom(Box cube, Direction direction, int[] moment) {
-    switch (direction) {
-      case RED:
-        return -moment[getIndex(cube.r0, cube.g1, cube.b1)]
-            + moment[getIndex(cube.r0, cube.g1, cube.b0)]
-            + moment[getIndex(cube.r0, cube.g0, cube.b1)]
-            - moment[getIndex(cube.r0, cube.g0, cube.b0)];
-      case GREEN:
-        return -moment[getIndex(cube.r1, cube.g0, cube.b1)]
-            + moment[getIndex(cube.r1, cube.g0, cube.b0)]
-            + moment[getIndex(cube.r0, cube.g0, cube.b1)]
-            - moment[getIndex(cube.r0, cube.g0, cube.b0)];
-      case BLUE:
-        return -moment[getIndex(cube.r1, cube.g1, cube.b0)]
-            + moment[getIndex(cube.r1, cube.g0, cube.b0)]
-            + moment[getIndex(cube.r0, cube.g1, cube.b0)]
-            - moment[getIndex(cube.r0, cube.g0, cube.b0)];
-    }
-    throw new IllegalArgumentException("unexpected direction " + direction);
-  }
-
-  static int top(Box cube, Direction direction, int position, int[] moment) {
-    switch (direction) {
-      case RED:
-        return (moment[getIndex(position, cube.g1, cube.b1)]
-            - moment[getIndex(position, cube.g1, cube.b0)]
-            - moment[getIndex(position, cube.g0, cube.b1)]
-            + moment[getIndex(position, cube.g0, cube.b0)]);
-      case GREEN:
-        return (moment[getIndex(cube.r1, position, cube.b1)]
-            - moment[getIndex(cube.r1, position, cube.b0)]
-            - moment[getIndex(cube.r0, position, cube.b1)]
-            + moment[getIndex(cube.r0, position, cube.b0)]);
-      case BLUE:
-        return (moment[getIndex(cube.r1, cube.g1, position)]
-            - moment[getIndex(cube.r1, cube.g0, position)]
-            - moment[getIndex(cube.r0, cube.g1, position)]
-            + moment[getIndex(cube.r0, cube.g0, position)]);
-    }
-    throw new IllegalArgumentException("unexpected direction " + direction);
-  }
-
-  private static enum Direction {
-    RED,
-    GREEN,
-    BLUE
-  }
-
-  private static final class MaximizeResult {
-    // < 0 if cut impossible
-    int cutLocation;
-    double maximum;
-
-    MaximizeResult(int cut, double max) {
-      this.cutLocation = cut;
-      this.maximum = max;
-    }
-  }
-
-  private static final class CreateBoxesResult {
-    int requestedCount;
-    int resultCount;
-
-    CreateBoxesResult(int requestedCount, int resultCount) {
-      this.requestedCount = requestedCount;
-      this.resultCount = resultCount;
-    }
-  }
-
-  private static final class Box {
-    int r0 = 0;
-    int r1 = 0;
-    int g0 = 0;
-    int g1 = 0;
-    int b0 = 0;
-    int b1 = 0;
-    int vol = 0;
-  }
-}

material-color-utilities/src/main/java/scheme/Scheme.java

@@ -1,813 +0,0 @@
-/*
- * Copyright 2021 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.
- */
-
-// This file is automatically generated. Do not modify it.
-
-package scheme;
-
-import com.google.errorprone.annotations.CanIgnoreReturnValue;
-import com.google.errorprone.annotations.CheckReturnValue;
-import palettes.CorePalette;
-
-/** Represents a Material color scheme, a mapping of color roles to colors. */
-@CheckReturnValue
-public class Scheme {
-  private int primary;
-  private int onPrimary;
-  private int primaryContainer;
-  private int onPrimaryContainer;
-  private int secondary;
-  private int onSecondary;
-  private int secondaryContainer;
-  private int onSecondaryContainer;
-  private int tertiary;
-  private int onTertiary;
-  private int tertiaryContainer;
-  private int onTertiaryContainer;
-  private int error;
-  private int onError;
-  private int errorContainer;
-  private int onErrorContainer;
-  private int background;
-  private int onBackground;
-  private int surface;
-  private int onSurface;
-  private int surfaceVariant;
-  private int onSurfaceVariant;
-  private int outline;
-  private int outlineVariant;
-  private int shadow;
-  private int scrim;
-  private int inverseSurface;
-  private int inverseOnSurface;
-  private int inversePrimary;
-
-  public Scheme() {}
-
-  public Scheme(
-      int primary,
-      int onPrimary,
-      int primaryContainer,
-      int onPrimaryContainer,
-      int secondary,
-      int onSecondary,
-      int secondaryContainer,
-      int onSecondaryContainer,
-      int tertiary,
-      int onTertiary,
-      int tertiaryContainer,
-      int onTertiaryContainer,
-      int error,
-      int onError,
-      int errorContainer,
-      int onErrorContainer,
-      int background,
-      int onBackground,
-      int surface,
-      int onSurface,
-      int surfaceVariant,
-      int onSurfaceVariant,
-      int outline,
-      int outlineVariant,
-      int shadow,
-      int scrim,
-      int inverseSurface,
-      int inverseOnSurface,
-      int inversePrimary) {
-    super();
-    this.primary = primary;
-    this.onPrimary = onPrimary;
-    this.primaryContainer = primaryContainer;
-    this.onPrimaryContainer = onPrimaryContainer;
-    this.secondary = secondary;
-    this.onSecondary = onSecondary;
-    this.secondaryContainer = secondaryContainer;
-    this.onSecondaryContainer = onSecondaryContainer;
-    this.tertiary = tertiary;
-    this.onTertiary = onTertiary;
-    this.tertiaryContainer = tertiaryContainer;
-    this.onTertiaryContainer = onTertiaryContainer;
-    this.error = error;
-    this.onError = onError;
-    this.errorContainer = errorContainer;
-    this.onErrorContainer = onErrorContainer;
-    this.background = background;
-    this.onBackground = onBackground;
-    this.surface = surface;
-    this.onSurface = onSurface;
-    this.surfaceVariant = surfaceVariant;
-    this.onSurfaceVariant = onSurfaceVariant;
-    this.outline = outline;
-    this.outlineVariant = outlineVariant;
-    this.shadow = shadow;
-    this.scrim = scrim;
-    this.inverseSurface = inverseSurface;
-    this.inverseOnSurface = inverseOnSurface;
-    this.inversePrimary = inversePrimary;
-  }
-
-  public static Scheme light(int argb) {
-    return lightFromCorePalette(CorePalette.of(argb));
-  }
-
-  public static Scheme dark(int argb) {
-    return darkFromCorePalette(CorePalette.of(argb));
-  }
-
-  public static Scheme lightContent(int argb) {
-    return lightFromCorePalette(CorePalette.contentOf(argb));
-  }
-
-  public static Scheme darkContent(int argb) {
-    return darkFromCorePalette(CorePalette.contentOf(argb));
-  }
-
-  private static Scheme lightFromCorePalette(CorePalette core) {
-    return new Scheme()
-        .withPrimary(core.a1.tone(40))
-        .withOnPrimary(core.a1.tone(100))
-        .withPrimaryContainer(core.a1.tone(90))
-        .withOnPrimaryContainer(core.a1.tone(10))
-        .withSecondary(core.a2.tone(40))
-        .withOnSecondary(core.a2.tone(100))
-        .withSecondaryContainer(core.a2.tone(90))
-        .withOnSecondaryContainer(core.a2.tone(10))
-        .withTertiary(core.a3.tone(40))
-        .withOnTertiary(core.a3.tone(100))
-        .withTertiaryContainer(core.a3.tone(90))
-        .withOnTertiaryContainer(core.a3.tone(10))
-        .withError(core.error.tone(40))
-        .withOnError(core.error.tone(100))
-        .withErrorContainer(core.error.tone(90))
-        .withOnErrorContainer(core.error.tone(10))
-        .withBackground(core.n1.tone(99))
-        .withOnBackground(core.n1.tone(10))
-        .withSurface(core.n1.tone(99))
-        .withOnSurface(core.n1.tone(10))
-        .withSurfaceVariant(core.n2.tone(90))
-        .withOnSurfaceVariant(core.n2.tone(30))
-        .withOutline(core.n2.tone(50))
-        .withOutlineVariant(core.n2.tone(80))
-        .withShadow(core.n1.tone(0))
-        .withScrim(core.n1.tone(0))
-        .withInverseSurface(core.n1.tone(20))
-        .withInverseOnSurface(core.n1.tone(95))
-        .withInversePrimary(core.a1.tone(80));
-  }
-
-  private static Scheme darkFromCorePalette(CorePalette core) {
-    return new Scheme()
-        .withPrimary(core.a1.tone(80))
-        .withOnPrimary(core.a1.tone(20))
-        .withPrimaryContainer(core.a1.tone(30))
-        .withOnPrimaryContainer(core.a1.tone(90))
-        .withSecondary(core.a2.tone(80))
-        .withOnSecondary(core.a2.tone(20))
-        .withSecondaryContainer(core.a2.tone(30))
-        .withOnSecondaryContainer(core.a2.tone(90))
-        .withTertiary(core.a3.tone(80))
-        .withOnTertiary(core.a3.tone(20))
-        .withTertiaryContainer(core.a3.tone(30))
-        .withOnTertiaryContainer(core.a3.tone(90))
-        .withError(core.error.tone(80))
-        .withOnError(core.error.tone(20))
-        .withErrorContainer(core.error.tone(30))
-        .withOnErrorContainer(core.error.tone(80))
-        .withBackground(core.n1.tone(10))
-        .withOnBackground(core.n1.tone(90))
-        .withSurface(core.n1.tone(10))
-        .withOnSurface(core.n1.tone(90))
-        .withSurfaceVariant(core.n2.tone(30))
-        .withOnSurfaceVariant(core.n2.tone(80))
-        .withOutline(core.n2.tone(60))
-        .withOutlineVariant(core.n2.tone(30))
-        .withShadow(core.n1.tone(0))
-        .withScrim(core.n1.tone(0))
-        .withInverseSurface(core.n1.tone(90))
-        .withInverseOnSurface(core.n1.tone(20))
-        .withInversePrimary(core.a1.tone(40));
-  }
-
-  public int getPrimary() {
-    return primary;
-  }
-
-  public void setPrimary(int primary) {
-    this.primary = primary;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withPrimary(int primary) {
-    this.primary = primary;
-    return this;
-  }
-
-  public int getOnPrimary() {
-    return onPrimary;
-  }
-
-  public void setOnPrimary(int onPrimary) {
-    this.onPrimary = onPrimary;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withOnPrimary(int onPrimary) {
-    this.onPrimary = onPrimary;
-    return this;
-  }
-
-  public int getPrimaryContainer() {
-    return primaryContainer;
-  }
-
-  public void setPrimaryContainer(int primaryContainer) {
-    this.primaryContainer = primaryContainer;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withPrimaryContainer(int primaryContainer) {
-    this.primaryContainer = primaryContainer;
-    return this;
-  }
-
-  public int getOnPrimaryContainer() {
-    return onPrimaryContainer;
-  }
-
-  public void setOnPrimaryContainer(int onPrimaryContainer) {
-    this.onPrimaryContainer = onPrimaryContainer;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withOnPrimaryContainer(int onPrimaryContainer) {
-    this.onPrimaryContainer = onPrimaryContainer;
-    return this;
-  }
-
-  public int getSecondary() {
-    return secondary;
-  }
-
-  public void setSecondary(int secondary) {
-    this.secondary = secondary;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withSecondary(int secondary) {
-    this.secondary = secondary;
-    return this;
-  }
-
-  public int getOnSecondary() {
-    return onSecondary;
-  }
-
-  public void setOnSecondary(int onSecondary) {
-    this.onSecondary = onSecondary;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withOnSecondary(int onSecondary) {
-    this.onSecondary = onSecondary;
-    return this;
-  }
-
-  public int getSecondaryContainer() {
-    return secondaryContainer;
-  }
-
-  public void setSecondaryContainer(int secondaryContainer) {
-    this.secondaryContainer = secondaryContainer;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withSecondaryContainer(int secondaryContainer) {
-    this.secondaryContainer = secondaryContainer;
-    return this;
-  }
-
-  public int getOnSecondaryContainer() {
-    return onSecondaryContainer;
-  }
-
-  public void setOnSecondaryContainer(int onSecondaryContainer) {
-    this.onSecondaryContainer = onSecondaryContainer;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withOnSecondaryContainer(int onSecondaryContainer) {
-    this.onSecondaryContainer = onSecondaryContainer;
-    return this;
-  }
-
-  public int getTertiary() {
-    return tertiary;
-  }
-
-  public void setTertiary(int tertiary) {
-    this.tertiary = tertiary;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withTertiary(int tertiary) {
-    this.tertiary = tertiary;
-    return this;
-  }
-
-  public int getOnTertiary() {
-    return onTertiary;
-  }
-
-  public void setOnTertiary(int onTertiary) {
-    this.onTertiary = onTertiary;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withOnTertiary(int onTertiary) {
-    this.onTertiary = onTertiary;
-    return this;
-  }
-
-  public int getTertiaryContainer() {
-    return tertiaryContainer;
-  }
-
-  public void setTertiaryContainer(int tertiaryContainer) {
-    this.tertiaryContainer = tertiaryContainer;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withTertiaryContainer(int tertiaryContainer) {
-    this.tertiaryContainer = tertiaryContainer;
-    return this;
-  }
-
-  public int getOnTertiaryContainer() {
-    return onTertiaryContainer;
-  }
-
-  public void setOnTertiaryContainer(int onTertiaryContainer) {
-    this.onTertiaryContainer = onTertiaryContainer;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withOnTertiaryContainer(int onTertiaryContainer) {
-    this.onTertiaryContainer = onTertiaryContainer;
-    return this;
-  }
-
-  public int getError() {
-    return error;
-  }
-
-  public void setError(int error) {
-    this.error = error;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withError(int error) {
-    this.error = error;
-    return this;
-  }
-
-  public int getOnError() {
-    return onError;
-  }
-
-  public void setOnError(int onError) {
-    this.onError = onError;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withOnError(int onError) {
-    this.onError = onError;
-    return this;
-  }
-
-  public int getErrorContainer() {
-    return errorContainer;
-  }
-
-  public void setErrorContainer(int errorContainer) {
-    this.errorContainer = errorContainer;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withErrorContainer(int errorContainer) {
-    this.errorContainer = errorContainer;
-    return this;
-  }
-
-  public int getOnErrorContainer() {
-    return onErrorContainer;
-  }
-
-  public void setOnErrorContainer(int onErrorContainer) {
-    this.onErrorContainer = onErrorContainer;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withOnErrorContainer(int onErrorContainer) {
-    this.onErrorContainer = onErrorContainer;
-    return this;
-  }
-
-  public int getBackground() {
-    return background;
-  }
-
-  public void setBackground(int background) {
-    this.background = background;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withBackground(int background) {
-    this.background = background;
-    return this;
-  }
-
-  public int getOnBackground() {
-    return onBackground;
-  }
-
-  public void setOnBackground(int onBackground) {
-    this.onBackground = onBackground;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withOnBackground(int onBackground) {
-    this.onBackground = onBackground;
-    return this;
-  }
-
-  public int getSurface() {
-    return surface;
-  }
-
-  public void setSurface(int surface) {
-    this.surface = surface;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withSurface(int surface) {
-    this.surface = surface;
-    return this;
-  }
-
-  public int getOnSurface() {
-    return onSurface;
-  }
-
-  public void setOnSurface(int onSurface) {
-    this.onSurface = onSurface;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withOnSurface(int onSurface) {
-    this.onSurface = onSurface;
-    return this;
-  }
-
-  public int getSurfaceVariant() {
-    return surfaceVariant;
-  }
-
-  public void setSurfaceVariant(int surfaceVariant) {
-    this.surfaceVariant = surfaceVariant;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withSurfaceVariant(int surfaceVariant) {
-    this.surfaceVariant = surfaceVariant;
-    return this;
-  }
-
-  public int getOnSurfaceVariant() {
-    return onSurfaceVariant;
-  }
-
-  public void setOnSurfaceVariant(int onSurfaceVariant) {
-    this.onSurfaceVariant = onSurfaceVariant;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withOnSurfaceVariant(int onSurfaceVariant) {
-    this.onSurfaceVariant = onSurfaceVariant;
-    return this;
-  }
-
-  public int getOutline() {
-    return outline;
-  }
-
-  public void setOutline(int outline) {
-    this.outline = outline;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withOutline(int outline) {
-    this.outline = outline;
-    return this;
-  }
-
-  public int getOutlineVariant() {
-    return outlineVariant;
-  }
-
-  public void setOutlineVariant(int outlineVariant) {
-    this.outlineVariant = outlineVariant;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withOutlineVariant(int outlineVariant) {
-    this.outlineVariant = outlineVariant;
-    return this;
-  }
-
-  public int getShadow() {
-    return shadow;
-  }
-
-  public void setShadow(int shadow) {
-    this.shadow = shadow;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withShadow(int shadow) {
-    this.shadow = shadow;
-    return this;
-  }
-
-  public int getScrim() {
-    return scrim;
-  }
-
-  public void setScrim(int scrim) {
-    this.scrim = scrim;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withScrim(int scrim) {
-    this.scrim = scrim;
-    return this;
-  }
-
-  public int getInverseSurface() {
-    return inverseSurface;
-  }
-
-  public void setInverseSurface(int inverseSurface) {
-    this.inverseSurface = inverseSurface;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withInverseSurface(int inverseSurface) {
-    this.inverseSurface = inverseSurface;
-    return this;
-  }
-
-  public int getInverseOnSurface() {
-    return inverseOnSurface;
-  }
-
-  public void setInverseOnSurface(int inverseOnSurface) {
-    this.inverseOnSurface = inverseOnSurface;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withInverseOnSurface(int inverseOnSurface) {
-    this.inverseOnSurface = inverseOnSurface;
-    return this;
-  }
-
-  public int getInversePrimary() {
-    return inversePrimary;
-  }
-
-  public void setInversePrimary(int inversePrimary) {
-    this.inversePrimary = inversePrimary;
-  }
-
-  @CanIgnoreReturnValue
-  public Scheme withInversePrimary(int inversePrimary) {
-    this.inversePrimary = inversePrimary;
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return "Scheme{"
-        + "primary="
-        + primary
-        + ", onPrimary="
-        + onPrimary
-        + ", primaryContainer="
-        + primaryContainer
-        + ", onPrimaryContainer="
-        + onPrimaryContainer
-        + ", secondary="
-        + secondary
-        + ", onSecondary="
-        + onSecondary
-        + ", secondaryContainer="
-        + secondaryContainer
-        + ", onSecondaryContainer="
-        + onSecondaryContainer
-        + ", tertiary="
-        + tertiary
-        + ", onTertiary="
-        + onTertiary
-        + ", tertiaryContainer="
-        + tertiaryContainer
-        + ", onTertiaryContainer="
-        + onTertiaryContainer
-        + ", error="
-        + error
-        + ", onError="
-        + onError
-        + ", errorContainer="
-        + errorContainer
-        + ", onErrorContainer="
-        + onErrorContainer
-        + ", background="
-        + background
-        + ", onBackground="
-        + onBackground
-        + ", surface="
-        + surface
-        + ", onSurface="
-        + onSurface
-        + ", surfaceVariant="
-        + surfaceVariant
-        + ", onSurfaceVariant="
-        + onSurfaceVariant
-        + ", outline="
-        + outline
-        + ", outlineVariant="
-        + outlineVariant
-        + ", shadow="
-        + shadow
-        + ", scrim="
-        + scrim
-        + ", inverseSurface="
-        + inverseSurface
-        + ", inverseOnSurface="
-        + inverseOnSurface
-        + ", inversePrimary="
-        + inversePrimary
-        + '}';
-  }
-
-  @Override
-  public boolean equals(Object object) {
-    if (this == object) {
-      return true;
-    }
-    if (!(object instanceof Scheme)) {
-      return false;
-    }
-    if (!super.equals(object)) {
-      return false;
-    }
-
-    Scheme scheme = (Scheme) object;
-
-    if (primary != scheme.primary) {
-      return false;
-    }
-    if (onPrimary != scheme.onPrimary) {
-      return false;
-    }
-    if (primaryContainer != scheme.primaryContainer) {
-      return false;
-    }
-    if (onPrimaryContainer != scheme.onPrimaryContainer) {
-      return false;
-    }
-    if (secondary != scheme.secondary) {
-      return false;
-    }
-    if (onSecondary != scheme.onSecondary) {
-      return false;
-    }
-    if (secondaryContainer != scheme.secondaryContainer) {
-      return false;
-    }
-    if (onSecondaryContainer != scheme.onSecondaryContainer) {
-      return false;
-    }
-    if (tertiary != scheme.tertiary) {
-      return false;
-    }
-    if (onTertiary != scheme.onTertiary) {
-      return false;
-    }
-    if (tertiaryContainer != scheme.tertiaryContainer) {
-      return false;
-    }
-    if (onTertiaryContainer != scheme.onTertiaryContainer) {
-      return false;
-    }
-    if (error != scheme.error) {
-      return false;
-    }
-    if (onError != scheme.onError) {
-      return false;
-    }
-    if (errorContainer != scheme.errorContainer) {
-      return false;
-    }
-    if (onErrorContainer != scheme.onErrorContainer) {
-      return false;
-    }
-    if (background != scheme.background) {
-      return false;
-    }
-    if (onBackground != scheme.onBackground) {
-      return false;
-    }
-    if (surface != scheme.surface) {
-      return false;
-    }
-    if (onSurface != scheme.onSurface) {
-      return false;
-    }
-    if (surfaceVariant != scheme.surfaceVariant) {
-      return false;
-    }
-    if (onSurfaceVariant != scheme.onSurfaceVariant) {
-      return false;
-    }
-    if (outline != scheme.outline) {
-      return false;
-    }
-    if (outlineVariant != scheme.outlineVariant) {
-      return false;
-    }
-    if (shadow != scheme.shadow) {
-      return false;
-    }
-    if (scrim != scheme.scrim) {
-      return false;
-    }
-    if (inverseSurface != scheme.inverseSurface) {
-      return false;
-    }
-    if (inverseOnSurface != scheme.inverseOnSurface) {
-      return false;
-    }
-    if (inversePrimary != scheme.inversePrimary) {
-      return false;
-    }
-
-    return true;
-  }
-
-  @Override
-  public int hashCode() {
-    int result = super.hashCode();
-    result = 31 * result + primary;
-    result = 31 * result + onPrimary;
-    result = 31 * result + primaryContainer;
-    result = 31 * result + onPrimaryContainer;
-    result = 31 * result + secondary;
-    result = 31 * result + onSecondary;
-    result = 31 * result + secondaryContainer;
-    result = 31 * result + onSecondaryContainer;
-    result = 31 * result + tertiary;
-    result = 31 * result + onTertiary;
-    result = 31 * result + tertiaryContainer;
-    result = 31 * result + onTertiaryContainer;
-    result = 31 * result + error;
-    result = 31 * result + onError;
-    result = 31 * result + errorContainer;
-    result = 31 * result + onErrorContainer;
-    result = 31 * result + background;
-    result = 31 * result + onBackground;
-    result = 31 * result + surface;
-    result = 31 * result + onSurface;
-    result = 31 * result + surfaceVariant;
-    result = 31 * result + onSurfaceVariant;
-    result = 31 * result + outline;
-    result = 31 * result + outlineVariant;
-    result = 31 * result + shadow;
-    result = 31 * result + scrim;
-    result = 31 * result + inverseSurface;
-    result = 31 * result + inverseOnSurface;
-    result = 31 * result + inversePrimary;
-    return result;
-  }
-}

material-color-utilities/src/main/java/score/Score.java

@@ -1,180 +0,0 @@
-/*
- * Copyright 2021 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.
- */
-
-package score;
-
-import hct.Cam16;
-import utils.ColorUtils;
-import utils.MathUtils;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Given a large set of colors, remove colors that are unsuitable for a UI theme, and rank the rest
- * based on suitability.
- *
- * <p>Enables use of a high cluster count for image quantization, thus ensuring colors aren't
- * muddied, while curating the high cluster count to a much smaller number of appropriate choices.
- */
-public final class Score {
-  private static final double CUTOFF_CHROMA = 15.;
-  private static final double CUTOFF_EXCITED_PROPORTION = 0.01;
-  private static final double CUTOFF_TONE = 10.;
-  private static final double TARGET_CHROMA = 48.;
-  private static final double WEIGHT_PROPORTION = 0.7;
-  private static final double WEIGHT_CHROMA_ABOVE = 0.3;
-  private static final double WEIGHT_CHROMA_BELOW = 0.1;
-
-  private Score() {}
-
-  /**
-   * Given a map with keys of colors and values of how often the color appears, rank the colors
-   * based on suitability for being used for a UI theme.
-   *
-   * @param colorsToPopulation map with keys of colors and values of how often the color appears,
-   *     usually from a source image.
-   * @return Colors sorted by suitability for a UI theme. The most suitable color is the first item,
-   *     the least suitable is the last. There will always be at least one color returned. If all
-   *     the input colors were not suitable for a theme, a default fallback color will be provided,
-   *     Google Blue.
-   */
-  public static List<Integer> score(Map<Integer, Integer> colorsToPopulation) {
-    // Determine the total count of all colors.
-    double populationSum = 0.;
-    for (Map.Entry<Integer, Integer> entry : colorsToPopulation.entrySet()) {
-      populationSum += entry.getValue();
-    }
-
-    // Turn the count of each color into a proportion by dividing by the total
-    // count. Also, fill a cache of CAM16 colors representing each color, and
-    // record the proportion of colors for each CAM16 hue.
-    Map<Integer, Cam16> colorsToCam = new HashMap<>();
-    double[] hueProportions = new double[361];
-    for (Map.Entry<Integer, Integer> entry : colorsToPopulation.entrySet()) {
-      int color = entry.getKey();
-      double population = entry.getValue();
-      double proportion = population / populationSum;
-
-      Cam16 cam = Cam16.fromInt(color);
-      colorsToCam.put(color, cam);
-
-      int hue = (int) Math.round(cam.getHue());
-      hueProportions[hue] += proportion;
-    }
-
-    // Determine the proportion of the colors around each color, by summing the
-    // proportions around each color's hue.
-    Map<Integer, Double> colorsToExcitedProportion = new HashMap<>();
-    for (Map.Entry<Integer, Cam16> entry : colorsToCam.entrySet()) {
-      int color = entry.getKey();
-      Cam16 cam = entry.getValue();
-      int hue = (int) Math.round(cam.getHue());
-
-      double excitedProportion = 0.;
-      for (int j = (hue - 15); j < (hue + 15); j++) {
-        int neighborHue = MathUtils.sanitizeDegreesInt(j);
-        excitedProportion += hueProportions[neighborHue];
-      }
-
-      colorsToExcitedProportion.put(color, excitedProportion);
-    }
-
-    // Score the colors by their proportion, as well as how chromatic they are.
-    Map<Integer, Double> colorsToScore = new HashMap<>();
-    for (Map.Entry<Integer, Cam16> entry : colorsToCam.entrySet()) {
-      int color = entry.getKey();
-      Cam16 cam = entry.getValue();
-
-      double proportion = colorsToExcitedProportion.get(color);
-      double proportionScore = proportion * 100.0 * WEIGHT_PROPORTION;
-
-      double chromaWeight =
-          cam.getChroma() < TARGET_CHROMA ? WEIGHT_CHROMA_BELOW : WEIGHT_CHROMA_ABOVE;
-      double chromaScore = (cam.getChroma() - TARGET_CHROMA) * chromaWeight;
-
-      double score = proportionScore + chromaScore;
-      colorsToScore.put(color, score);
-    }
-
-    // Remove colors that are unsuitable, ex. very dark or unchromatic colors.
-    // Also, remove colors that are very similar in hue.
-    List<Integer> filteredColors = filter(colorsToExcitedProportion, colorsToCam);
-    Map<Integer, Double> filteredColorsToScore = new HashMap<>();
-    for (int color : filteredColors) {
-      filteredColorsToScore.put(color, colorsToScore.get(color));
-    }
-
-    // Ensure the list of colors returned is sorted such that the first in the
-    // list is the most suitable, and the last is the least suitable.
-    List<Map.Entry<Integer, Double>> entryList = new ArrayList<>(filteredColorsToScore.entrySet());
-    Collections.sort(entryList, new ScoredComparator());
-    List<Integer> colorsByScoreDescending = new ArrayList<>();
-    for (Map.Entry<Integer, Double> entry : entryList) {
-      int color = entry.getKey();
-      Cam16 cam = colorsToCam.get(color);
-      boolean duplicateHue = false;
-
-      for (Integer alreadyChosenColor : colorsByScoreDescending) {
-        Cam16 alreadyChosenCam = colorsToCam.get(alreadyChosenColor);
-        if (MathUtils.differenceDegrees(cam.getHue(), alreadyChosenCam.getHue()) < 15) {
-          duplicateHue = true;
-          break;
-        }
-      }
-
-      if (duplicateHue) {
-        continue;
-      }
-      colorsByScoreDescending.add(entry.getKey());
-    }
-
-    // Ensure that at least one color is returned.
-    if (colorsByScoreDescending.isEmpty()) {
-      colorsByScoreDescending.add(0xff4285F4); // Google Blue
-    }
-    return colorsByScoreDescending;
-  }
-
-  private static List<Integer> filter(
-      Map<Integer, Double> colorsToExcitedProportion, Map<Integer, Cam16> colorsToCam) {
-    List<Integer> filtered = new ArrayList<>();
-    for (Map.Entry<Integer, Cam16> entry : colorsToCam.entrySet()) {
-      int color = entry.getKey();
-      Cam16 cam = entry.getValue();
-      double proportion = colorsToExcitedProportion.get(color);
-
-      if (cam.getChroma() >= CUTOFF_CHROMA
-          && ColorUtils.lstarFromArgb(color) >= CUTOFF_TONE
-          && proportion >= CUTOFF_EXCITED_PROPORTION) {
-        filtered.add(color);
-      }
-    }
-    return filtered;
-  }
-
-  static class ScoredComparator implements Comparator<Map.Entry<Integer, Double>> {
-    public ScoredComparator() {}
-
-    @Override
-    public int compare(Map.Entry<Integer, Double> entry1, Map.Entry<Integer, Double> entry2) {
-      return -entry1.getValue().compareTo(entry2.getValue());
-    }
-  }
-}

material-color-utilities/src/main/java/utils/ColorUtils.java

@@ -1,252 +0,0 @@
-/*
- * Copyright 2021 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.
- */
-
-// This file is automatically generated. Do not modify it.
-
-package utils;
-
-/**
- * Color science utilities.
- *
- * <p>Utility methods for color science constants and color space conversions that aren't HCT or
- * CAM16.
- */
-public class ColorUtils {
-  private ColorUtils() {}
-
-  static final double[][] SRGB_TO_XYZ =
-      new double[][] {
-        new double[] {0.41233895, 0.35762064, 0.18051042},
-        new double[] {0.2126, 0.7152, 0.0722},
-        new double[] {0.01932141, 0.11916382, 0.95034478},
-      };
-
-  static final double[][] XYZ_TO_SRGB =
-      new double[][] {
-        new double[] {
-          3.2413774792388685, -1.5376652402851851, -0.49885366846268053,
-        },
-        new double[] {
-          -0.9691452513005321, 1.8758853451067872, 0.04156585616912061,
-        },
-        new double[] {
-          0.05562093689691305, -0.20395524564742123, 1.0571799111220335,
-        },
-      };
-
-  static final double[] WHITE_POINT_D65 = new double[] {95.047, 100.0, 108.883};
-
-  /** Converts a color from RGB components to ARGB format. */
-  public static int argbFromRgb(int red, int green, int blue) {
-    return (255 << 24) | ((red & 255) << 16) | ((green & 255) << 8) | (blue & 255);
-  }
-
-  /** Converts a color from linear RGB components to ARGB format. */
-  public static int argbFromLinrgb(double[] linrgb) {
-    int r = delinearized(linrgb[0]);
-    int g = delinearized(linrgb[1]);
-    int b = delinearized(linrgb[2]);
-    return argbFromRgb(r, g, b);
-  }
-
-  /** Returns the alpha component of a color in ARGB format. */
-  public static int alphaFromArgb(int argb) {
-    return (argb >> 24) & 255;
-  }
-
-  /** Returns the red component of a color in ARGB format. */
-  public static int redFromArgb(int argb) {
-    return (argb >> 16) & 255;
-  }
-
-  /** Returns the green component of a color in ARGB format. */
-  public static int greenFromArgb(int argb) {
-    return (argb >> 8) & 255;
-  }
-
-  /** Returns the blue component of a color in ARGB format. */
-  public static int blueFromArgb(int argb) {
-    return argb & 255;
-  }
-
-  /** Returns whether a color in ARGB format is opaque. */
-  public static boolean isOpaque(int argb) {
-    return alphaFromArgb(argb) >= 255;
-  }
-
-  /** Converts a color from ARGB to XYZ. */
-  public static int argbFromXyz(double x, double y, double z) {
-    double[][] matrix = XYZ_TO_SRGB;
-    double linearR = matrix[0][0] * x + matrix[0][1] * y + matrix[0][2] * z;
-    double linearG = matrix[1][0] * x + matrix[1][1] * y + matrix[1][2] * z;
-    double linearB = matrix[2][0] * x + matrix[2][1] * y + matrix[2][2] * z;
-    int r = delinearized(linearR);
-    int g = delinearized(linearG);
-    int b = delinearized(linearB);
-    return argbFromRgb(r, g, b);
-  }
-
-  /** Converts a color from XYZ to ARGB. */
-  public static double[] xyzFromArgb(int argb) {
-    double r = linearized(redFromArgb(argb));
-    double g = linearized(greenFromArgb(argb));
-    double b = linearized(blueFromArgb(argb));
-    return MathUtils.matrixMultiply(new double[] {r, g, b}, SRGB_TO_XYZ);
-  }
-
-  /** Converts a color represented in Lab color space into an ARGB integer. */
-  public static int argbFromLab(double l, double a, double b) {
-    double[] whitePoint = WHITE_POINT_D65;
-    double fy = (l + 16.0) / 116.0;
-    double fx = a / 500.0 + fy;
-    double fz = fy - b / 200.0;
-    double xNormalized = labInvf(fx);
-    double yNormalized = labInvf(fy);
-    double zNormalized = labInvf(fz);
-    double x = xNormalized * whitePoint[0];
-    double y = yNormalized * whitePoint[1];
-    double z = zNormalized * whitePoint[2];
-    return argbFromXyz(x, y, z);
-  }
-
-  /**
-   * Converts a color from ARGB representation to L*a*b* representation.
-   *
-   * @param argb the ARGB representation of a color
-   * @return a Lab object representing the color
-   */
-  public static double[] labFromArgb(int argb) {
-    double linearR = linearized(redFromArgb(argb));
-    double linearG = linearized(greenFromArgb(argb));
-    double linearB = linearized(blueFromArgb(argb));
-    double[][] matrix = SRGB_TO_XYZ;
-    double x = matrix[0][0] * linearR + matrix[0][1] * linearG + matrix[0][2] * linearB;
-    double y = matrix[1][0] * linearR + matrix[1][1] * linearG + matrix[1][2] * linearB;
-    double z = matrix[2][0] * linearR + matrix[2][1] * linearG + matrix[2][2] * linearB;
-    double[] whitePoint = WHITE_POINT_D65;
-    double xNormalized = x / whitePoint[0];
-    double yNormalized = y / whitePoint[1];
-    double zNormalized = z / whitePoint[2];
-    double fx = labF(xNormalized);
-    double fy = labF(yNormalized);
-    double fz = labF(zNormalized);
-    double l = 116.0 * fy - 16;
-    double a = 500.0 * (fx - fy);
-    double b = 200.0 * (fy - fz);
-    return new double[] {l, a, b};
-  }
-
-  /**
-   * Converts an L* value to an ARGB representation.
-   *
-   * @param lstar L* in L*a*b*
-   * @return ARGB representation of grayscale color with lightness matching L*
-   */
-  public static int argbFromLstar(double lstar) {
-    double y = yFromLstar(lstar);
-    int component = delinearized(y);
-    return argbFromRgb(component, component, component);
-  }
-
-  /**
-   * Computes the L* value of a color in ARGB representation.
-   *
-   * @param argb ARGB representation of a color
-   * @return L*, from L*a*b*, coordinate of the color
-   */
-  public static double lstarFromArgb(int argb) {
-    double y = xyzFromArgb(argb)[1];
-    return 116.0 * labF(y / 100.0) - 16.0;
-  }
-
-  /**
-   * Converts an L* value to a Y value.
-   *
-   * <p>L* in L*a*b* and Y in XYZ measure the same quantity, luminance.
-   *
-   * <p>L* measures perceptual luminance, a linear scale. Y in XYZ measures relative luminance, a
-   * logarithmic scale.
-   *
-   * @param lstar L* in L*a*b*
-   * @return Y in XYZ
-   */
-  public static double yFromLstar(double lstar) {
-    return 100.0 * labInvf((lstar + 16.0) / 116.0);
-  }
-
-  /**
-   * Linearizes an RGB component.
-   *
-   * @param rgbComponent 0 <= rgb_component <= 255, represents R/G/B channel
-   * @return 0.0 <= output <= 100.0, color channel converted to linear RGB space
-   */
-  public static double linearized(int rgbComponent) {
-    double normalized = rgbComponent / 255.0;
-    if (normalized <= 0.040449936) {
-      return normalized / 12.92 * 100.0;
-    } else {
-      return Math.pow((normalized + 0.055) / 1.055, 2.4) * 100.0;
-    }
-  }
-
-  /**
-   * Delinearizes an RGB component.
-   *
-   * @param rgbComponent 0.0 <= rgb_component <= 100.0, represents linear R/G/B channel
-   * @return 0 <= output <= 255, color channel converted to regular RGB space
-   */
-  public static int delinearized(double rgbComponent) {
-    double normalized = rgbComponent / 100.0;
-    double delinearized = 0.0;
-    if (normalized <= 0.0031308) {
-      delinearized = normalized * 12.92;
-    } else {
-      delinearized = 1.055 * Math.pow(normalized, 1.0 / 2.4) - 0.055;
-    }
-    return MathUtils.clampInt(0, 255, (int) Math.round(delinearized * 255.0));
-  }
-
-  /**
-   * Returns the standard white point; white on a sunny day.
-   *
-   * @return The white point
-   */
-  public static double[] whitePointD65() {
-    return WHITE_POINT_D65;
-  }
-
-  static double labF(double t) {
-    double e = 216.0 / 24389.0;
-    double kappa = 24389.0 / 27.0;
-    if (t > e) {
-      return Math.pow(t, 1.0 / 3.0);
-    } else {
-      return (kappa * t + 16) / 116;
-    }
-  }
-
-  static double labInvf(double ft) {
-    double e = 216.0 / 24389.0;
-    double kappa = 24389.0 / 27.0;
-    double ft3 = ft * ft * ft;
-    if (ft3 > e) {
-      return ft3;
-    } else {
-      return (116 * ft - 16) / kappa;
-    }
-  }
-}
-

material-color-utilities/src/main/java/utils/MathUtils.java

@@ -1,134 +0,0 @@
-/*
- * Copyright 2021 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.
- */
-
-// This file is automatically generated. Do not modify it.
-
-package utils;
-
-/** Utility methods for mathematical operations. */
-public class MathUtils {
-  private MathUtils() {}
-
-  /**
-   * The signum function.
-   *
-   * @return 1 if num > 0, -1 if num < 0, and 0 if num = 0
-   */
-  public static int signum(double num) {
-    if (num < 0) {
-      return -1;
-    } else if (num == 0) {
-      return 0;
-    } else {
-      return 1;
-    }
-  }
-
-  /**
-   * The linear interpolation function.
-   *
-   * @return start if amount = 0 and stop if amount = 1
-   */
-  public static double lerp(double start, double stop, double amount) {
-    return (1.0 - amount) * start + amount * stop;
-  }
-
-  /**
-   * Clamps an integer between two integers.
-   *
-   * @return input when min <= input <= max, and either min or max otherwise.
-   */
-  public static int clampInt(int min, int max, int input) {
-    if (input < min) {
-      return min;
-    } else if (input > max) {
-      return max;
-    }
-
-    return input;
-  }
-
-  /**
-   * Clamps an integer between two floating-point numbers.
-   *
-   * @return input when min <= input <= max, and either min or max otherwise.
-   */
-  public static double clampDouble(double min, double max, double input) {
-    if (input < min) {
-      return min;
-    } else if (input > max) {
-      return max;
-    }
-
-    return input;
-  }
-
-  /**
-   * Sanitizes a degree measure as an integer.
-   *
-   * @return a degree measure between 0 (inclusive) and 360 (exclusive).
-   */
-  public static int sanitizeDegreesInt(int degrees) {
-    degrees = degrees % 360;
-    if (degrees < 0) {
-      degrees = degrees + 360;
-    }
-    return degrees;
-  }
-
-  /**
-   * Sanitizes a degree measure as a floating-point number.
-   *
-   * @return a degree measure between 0.0 (inclusive) and 360.0 (exclusive).
-   */
-  public static double sanitizeDegreesDouble(double degrees) {
-    degrees = degrees % 360.0;
-    if (degrees < 0) {
-      degrees = degrees + 360.0;
-    }
-    return degrees;
-  }
-
-  /**
-   * Sign of direction change needed to travel from one angle to another.
-   *
-   * <p>For angles that are 180 degrees apart from each other, both directions have the same travel
-   * distance, so either direction is shortest. The value 1.0 is returned in this case.
-   *
-   * @param from The angle travel starts from, in degrees.
-   * @param to The angle travel ends at, in degrees.
-   * @return -1 if decreasing from leads to the shortest travel distance, 1 if increasing from leads
-   *     to the shortest travel distance.
-   */
-  public static double rotationDirection(double from, double to) {
-    double increasingDifference = sanitizeDegreesDouble(to - from);
-    return increasingDifference <= 180.0 ? 1.0 : -1.0;
-  }
-
-  /** Distance of two points on a circle, represented using degrees. */
-  public static double differenceDegrees(double a, double b) {
-    return 180.0 - Math.abs(Math.abs(a - b) - 180.0);
-  }
-
-  /** Multiplies a 1x3 row vector with a 3x3 matrix. */
-  public static double[] matrixMultiply(double[] row, double[][] matrix) {
-    double a = row[0] * matrix[0][0] + row[1] * matrix[0][1] + row[2] * matrix[0][2];
-    double b = row[0] * matrix[1][0] + row[1] * matrix[1][1] + row[2] * matrix[1][2];
-    double c = row[0] * matrix[2][0] + row[1] * matrix[2][1] + row[2] * matrix[2][2];
-    return new double[] {a, b, c};
-  }
-}
-

material-color-utilities/src/main/java/utils/StringUtils.java

@@ -1,34 +0,0 @@
-/*
- * Copyright 2021 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.
- */
-
-package utils;
-
-/** Utility methods for string representations of colors. */
-final class StringUtils {
-  private StringUtils() {}
-
-  /**
-   * Hex string representing color, ex. #ff0000 for red.
-   *
-   * @param argb ARGB representation of a color.
-   */
-  public static String hexFromArgb(int argb) {
-    int red = ColorUtils.redFromArgb(argb);
-    int blue = ColorUtils.blueFromArgb(argb);
-    int green = ColorUtils.greenFromArgb(argb);
-    return String.format("#%02x%02x%02x", red, green, blue);
-  }
-}

settings.gradle

@@ -19,4 +19,9 @@
  */
 
 include ':app'
-include ':material-color-utilities'
+
+includeBuild('../android-common') {
+    dependencySubstitution {
+        substitute module('com.github.nextcloud.android-common:ui') using project(':ui')
+    }
+}