gronod/talk-android
1
0
Fork 1
mirror of https://github.com/nextcloud/talk-android synced 2025-03-05 22:05:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use common library for theming

Browse Source 
Signed-off-by: Álvaro Brey <alvaro.brey@nextcloud.com>
This commit is contained in:
Álvaro Brey 2022-08-25 17:38:25 +02:00 committed by Andy Scherzinger
parent f0efcbaaca
commit d18fc7c9f8
No known key found for this signature in database
GPG Key ID: 6CADC7E3523C308B
34 changed files with 23 additions and 4061 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
app/build.gradle
View File

@ -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") {

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

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

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

@ -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
}

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

@ -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

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

@ -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

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

@ -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

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

@ -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
}

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

@ -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

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

@ -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()
}
}
}

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

@ -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

1
material-color-utilities/.gitignore vendored
View File

@ -1 +0,0 @@
/build

2
material-color-utilities/README.txt
View File

@ -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.

33
material-color-utilities/build.gradle
View File

@ -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'
}

91
material-color-utilities/src/main/java/blend/Blend.java
View File

@ -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();
}
}

419
material-color-utilities/src/main/java/hct/Cam16.java
View File

@ -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);
}
}

127
material-color-utilities/src/main/java/hct/Hct.java
View File

@ -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);
}
}

672
material-color-utilities/src/main/java/hct/HctSolver.java
View File

@ -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));
}
}

197
material-color-utilities/src/main/java/hct/ViewingConditions.java
View File

@ -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;
}
}

73
material-color-utilities/src/main/java/palettes/CorePalette.java
View File

@ -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.);
}
}

75
material-color-utilities/src/main/java/palettes/TonalPalette.java
View File

@ -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;
}
}

26
material-color-utilities/src/main/java/quantize/PointProvider.java
View File

@ -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);
}

56
material-color-utilities/src/main/java/quantize/PointProviderLab.java
View File

@ -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);
}
}

21
material-color-utilities/src/main/java/quantize/Quantizer.java
View File

@ -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);
}

57
material-color-utilities/src/main/java/quantize/QuantizerCelebi.java
View File

@ -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);
}
}

41
material-color-utilities/src/main/java/quantize/QuantizerMap.java
View File

@ -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;
}
}

28
material-color-utilities/src/main/java/quantize/QuantizerResult.java
View File

@ -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;
}
}

229
material-color-utilities/src/main/java/quantize/QuantizerWsmeans.java
View File

@ -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;
}
}

406
material-color-utilities/src/main/java/quantize/QuantizerWu.java
View File

@ -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;
}
}

813
material-color-utilities/src/main/java/scheme/Scheme.java
View File

@ -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;
}
}

180
material-color-utilities/src/main/java/score/Score.java
View File

@ -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());
}
}
}

252
material-color-utilities/src/main/java/utils/ColorUtils.java
View File

@ -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;
}
}
}

134
material-color-utilities/src/main/java/utils/MathUtils.java
View File

@ -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};
}
}

34
material-color-utilities/src/main/java/utils/StringUtils.java
View File

@ -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);
}
}

7
settings.gradle
View File

@ -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')
}
}