color-elements 0.0.1 → 0.0.3

package/lib/colorjs.io/src/spaces/cam16.js

@@ -1,362 +0,0 @@
-import ColorSpace from "../space.js";
-import {multiplyMatrices, interpolate, copySign, spow, zdiv, bisectLeft} from "../util.js";
-import {constrain} from "../angles.js";
-import xyz_d65 from "./xyz-d65.js";
-import {WHITES} from "../adapt.js";
-
-const white = WHITES.D65;
-const adaptedCoef = 0.42;
-const adaptedCoefInv = 1 / adaptedCoef;
-const tau = 2 * Math.PI;
-
-const cat16 = [
-	[  0.401288,  0.650173, -0.051461 ],
-	[ -0.250268,  1.204414,  0.045854 ],
-	[ -0.002079,  0.048952,  0.953127 ],
-];
-
-const cat16Inv = [
-	[1.8620678550872327, -1.0112546305316843, 0.14918677544445175],
-	[0.38752654323613717, 0.6214474419314753, -0.008973985167612518],
-	[-0.015841498849333856, -0.03412293802851557, 1.0499644368778496],
-];
-
-const m1 = [
-	[460.0, 451.0, 288.0],
-	[460.0, -891.0, -261.0],
-	[460.0, -220.0, -6300.0],
-];
-
-const surroundMap = {
-	dark: [0.8, 0.525, 0.8],
-	dim: [0.9, 0.59, 0.9],
-	average: [1, 0.69, 1],
-};
-
-const hueQuadMap = {
-	// Red, Yellow, Green, Blue, Red
-	h: [20.14, 90.00, 164.25, 237.53, 380.14],
-	e: [0.8, 0.7, 1.0, 1.2, 0.8],
-	H: [0.0, 100.0, 200.0, 300.0, 400.0],
-};
-
-const rad2deg = 180 / Math.PI;
-const deg2rad = Math.PI / 180;
-
-export function adapt (coords, fl) {
-	const temp = coords.map(c => {
-		const x = spow(fl * Math.abs(c) * 0.01, adaptedCoef);
-		return 400 * copySign(x, c) / (x + 27.13);
-	});
-	return temp;
-}
-
-export function unadapt (adapted, fl) {
-	const constant = 100 / fl * (27.13 ** adaptedCoefInv);
-	return adapted.map(c => {
-		const cabs = Math.abs(c);
-		return copySign(constant * spow(cabs / (400 - cabs), adaptedCoefInv), c);
-	});
-}
-
-export function hueQuadrature (h) {
-	let hp = constrain(h);
-	if (hp <= hueQuadMap.h[0]) {
-		hp += 360;
-	}
-
-	const i = bisectLeft(hueQuadMap.h, hp) - 1;
-	const [hi, hii] = hueQuadMap.h.slice(i, i + 2);
-	const [ei, eii] = hueQuadMap.e.slice(i, i + 2);
-	const Hi = hueQuadMap.H[i];
-
-	const t = (hp - hi) / ei;
-	return Hi + (100 * t) / (t + (hii - hp) / eii);
-}
-
-export function invHueQuadrature (H) {
-	let Hp = ((H % 400 + 400) % 400);
-	const i = Math.floor(0.01 * Hp);
-	Hp = Hp % 100;
-	const [hi, hii] = hueQuadMap.h.slice(i, i + 2);
-	const [ei, eii] = hueQuadMap.e.slice(i, i + 2);
-
-	return constrain(
-		(Hp * (eii * hi - ei * hii) - 100 * hi * eii) /
-		(Hp * (eii - ei) - 100 * eii),
-	);
-}
-
-export function environment (
-	refWhite,
-	adaptingLuminance,
-	backgroundLuminance,
-	surround,
-	discounting,
-) {
-
-	const env = {};
-
-	env.discounting = discounting;
-	env.refWhite = refWhite;
-	env.surround = surround;
-	const xyzW = refWhite.map(c => {
-		return c * 100;
-	});
-
-	// The average luminance of the environment in `cd/m^2cd/m` (a.k.a. nits)
-	env.la = adaptingLuminance;
-	// The relative luminance of the nearby background
-	env.yb = backgroundLuminance;
-	// Absolute luminance of the reference white.
-	const yw = xyzW[1];
-
-	// Cone response for reference white
-	const rgbW = multiplyMatrices(cat16, xyzW);
-
-	// Surround: dark, dim, and average
-	surround = surroundMap[env.surround];
-	const f = surround[0];
-	env.c = surround[1];
-	env.nc = surround[2];
-
-	const k = 1 / (5 * env.la + 1);
-	const k4 = k ** 4;
-
-	// Factor of luminance level adaptation
-	env.fl = (k4 * env.la + 0.1 * (1 - k4) * (1 - k4) * Math.cbrt(5 * env.la));
-	env.flRoot = env.fl ** 0.25;
-
-	env.n = env.yb / yw;
-	env.z = 1.48 + Math.sqrt(env.n);
-	env.nbb = 0.725 * (env.n ** -0.2);
-	env.ncb = env.nbb;
-
-	// Degree of adaptation calculating if not discounting
-	// illuminant (assumed eye is fully adapted)
-	const d = (discounting) ?
-		1 :
-		Math.max(
-			Math.min(f * (1 - 1 / 3.6 * Math.exp((-env.la - 42) / 92)), 1),
-			0,
-		);
-	env.dRgb = rgbW.map(c => {
-		return interpolate(1, yw / c, d);
-	});
-	env.dRgbInv = env.dRgb.map(c => {
-		return 1 / c;
-	});
-
-	// Achromatic response
-	const rgbCW = rgbW.map((c, i) => {
-		return c * env.dRgb[i];
-	});
-	const rgbAW = adapt(rgbCW, env.fl);
-	env.aW = env.nbb * (2 * rgbAW[0] + rgbAW[1] + 0.05 * rgbAW[2]);
-
-	// console.log(env);
-
-	return env;
-}
-
-// Pre-calculate everything we can with the viewing conditions
-const viewingConditions = environment(
-	white,
-	64 / Math.PI * 0.2, 20,
-	"average",
-	false,
-);
-
-export function fromCam16 (cam16, env) {
-
-	// These check ensure one, and only one attribute for a
-	// given category is provided.
-	if (!((cam16.J !== undefined) ^ (cam16.Q !== undefined))) {
-		throw new Error("Conversion requires one and only one: 'J' or 'Q'");
-	}
-
-	if (!((cam16.C !== undefined) ^ (cam16.M !== undefined) ^ (cam16.s !== undefined))) {
-		throw new Error("Conversion requires one and only one: 'C', 'M' or 's'");
-	}
-
-	// Hue is absolutely required
-	if (!((cam16.h !== undefined) ^ (cam16.H !== undefined))) {
-		throw new Error("Conversion requires one and only one: 'h' or 'H'");
-	}
-
-	// Black
-	if (cam16.J === 0.0 || cam16.Q === 0.0) {
-		return [0.0, 0.0, 0.0];
-	}
-
-	// Break hue into Cartesian components
-	let hRad = 0.0;
-	if (cam16.h !== undefined) {
-		hRad = constrain(cam16.h) * deg2rad;
-	}
-	else {
-		hRad = invHueQuadrature(cam16.H) * deg2rad;
-	}
-
-	const cosh = Math.cos(hRad);
-	const sinh = Math.sin(hRad);
-
-	// Calculate `Jroot` from one of the lightness derived coordinates.
-	let Jroot = 0.0;
-	if (cam16.J !== undefined) {
-		Jroot = spow(cam16.J, 1 / 2) * 0.1;
-	}
-	else if (cam16.Q !== undefined) {
-		Jroot = 0.25 * env.c * cam16.Q / ((env.aW + 4) * env.flRoot);
-	}
-
-	// Calculate the `t` value from one of the chroma derived coordinates
-	let alpha = 0.0;
-	if (cam16.C !== undefined) {
-		alpha = cam16.C / Jroot;
-	}
-	else if (cam16.M !== undefined) {
-		alpha = (cam16.M / env.flRoot) / Jroot;
-	}
-	else if (cam16.s !== undefined) {
-		alpha = 0.0004 * (cam16.s ** 2) * (env.aW + 4) / env.c;
-	}
-	const t = spow(
-		alpha * Math.pow(1.64 - Math.pow(0.29, env.n), -0.73),
-		10 / 9,
-	);
-
-	// Eccentricity
-	const et = 0.25 * (Math.cos(hRad + 2) + 3.8);
-
-	// Achromatic response
-	const A = env.aW * spow(Jroot, 2 / env.c / env.z);
-
-	// Calculate red-green and yellow-blue components
-	const p1 = 5e4 / 13 * env.nc * env.ncb * et;
-	const p2 = A / env.nbb;
-	const r = (
-		23 * (p2 + 0.305) *
-		zdiv(t, 23 * p1 + t * (11 * cosh + 108 * sinh))
-	);
-	const a = r * cosh;
-	const b = r * sinh;
-
-	// Calculate back from cone response to XYZ
-	const rgb_c = unadapt(
-		multiplyMatrices(m1, [p2, a, b]).map(c => {
-			return c * 1 / 1403;
-		}),
-		env.fl,
-	);
-	return multiplyMatrices(
-		cat16Inv,
-		rgb_c.map((c, i) => {
-			return c * env.dRgbInv[i];
-		}),
-	).map(c => {
-		return c / 100;
-	});
-}
-
-
-export function toCam16 (xyzd65, env) {
-	// Cone response
-	const xyz100 = xyzd65.map(c => {
-		return c * 100;
-	});
-	const rgbA = adapt(
-		multiplyMatrices(cat16, xyz100).map((c, i) => {
-			return c * env.dRgb[i];
-		}),
-		env.fl,
-	);
-
-	// Calculate hue from red-green and yellow-blue components
-	const a = rgbA[0] + (-12 * rgbA[1] + rgbA[2]) / 11;
-	const b = (rgbA[0] + rgbA[1] - 2 * rgbA[2]) / 9;
-	const hRad = ((Math.atan2(b, a) % tau) + tau) % tau;
-
-	// Eccentricity
-	const et = 0.25 * (Math.cos(hRad + 2) + 3.8);
-
-	const t = (
-		5e4 / 13 * env.nc * env.ncb *
-		zdiv(
-			et * Math.sqrt(a ** 2 + b ** 2),
-			rgbA[0] + rgbA[1] + 1.05 * rgbA[2] + 0.305,
-		)
-	);
-	const alpha = spow(t, 0.9) * Math.pow(1.64 - Math.pow(0.29, env.n), 0.73);
-
-	// Achromatic response
-	const A = env.nbb * (2 * rgbA[0] + rgbA[1] + 0.05 * rgbA[2]);
-
-	const Jroot = spow(A / env.aW, 0.5 * env.c * env.z);
-
-	// Lightness
-	const J = 100 * spow(Jroot, 2);
-
-	// Brightness
-	const Q = (4 / env.c * Jroot * (env.aW + 4) * env.flRoot);
-
-	// Chroma
-	const C = alpha * Jroot;
-
-	// Colorfulness
-	const M = C * env.flRoot;
-
-	// Hue
-	const h = constrain(hRad * rad2deg);
-
-	// Hue quadrature
-	const H = hueQuadrature(h);
-
-	// Saturation
-	const s = 50 * spow(env.c * alpha / (env.aW + 4), 1 / 2);
-
-	// console.log({J: J, C: C, h: h, s: s, Q: Q, M: M, H: H});
-
-	return {J: J, C: C, h: h, s: s, Q: Q, M: M, H: H};
-}
-
-
-// Provided as a way to directly evaluate the CAM16 model
-// https://observablehq.com/@jrus/cam16: reference implementation
-// https://arxiv.org/pdf/1802.06067.pdf: Nico Schlömer
-// https://onlinelibrary.wiley.com/doi/pdf/10.1002/col.22324: hue quadrature
-// https://www.researchgate.net/publication/318152296_Comprehensive_color_solutions_CAM16_CAT16_and_CAM16-UCS
-// Results compared against: https://github.com/colour-science/colour
-export default new ColorSpace({
-	id: "cam16-jmh",
-	cssId: "--cam16-jmh",
-	name: "CAM16-JMh",
-	coords: {
-		j: {
-			refRange: [0, 100],
-			name: "J",
-		},
-		m: {
-			refRange: [0, 105.0],
-			name: "Colorfulness",
-		},
-		h: {
-			refRange: [0, 360],
-			type: "angle",
-			name: "Hue",
-		},
-	},
-
-	base: xyz_d65,
-
-	fromBase (xyz) {
-		const cam16 = toCam16(xyz, viewingConditions);
-		return [cam16.J, cam16.M, cam16.h];
-	},
-	toBase (cam16) {
-		return fromCam16(
-			{J: cam16[0], M: cam16[1], h: cam16[2]},
-			viewingConditions,
-		);
-	},
-});

package/lib/colorjs.io/src/spaces/hct.js

@@ -1,157 +0,0 @@
-import ColorSpace from "../space.js";
-import {constrain} from "../angles.js";
-import xyz_d65 from "./xyz-d65.js";
-import {fromCam16, toCam16, environment} from "./cam16.js";
-import {WHITES} from "../adapt.js";
-
-const white = WHITES.D65;
-const ε = 216 / 24389;  // 6^3/29^3 == (24/116)^3
-const κ = 24389 / 27;   // 29^3/3^3
-
-function toLstar (y) {
-	// Convert XYZ Y to L*
-
-	const fy = (y > ε) ? Math.cbrt(y) : (κ * y + 16) / 116;
-	return (116.0 * fy) - 16.0;
-}
-
-function fromLstar (lstar) {
-	// Convert L* back to XYZ Y
-
-	return (lstar > 8) ?  Math.pow((lstar + 16) / 116, 3) : lstar / κ;
-}
-
-function fromHct (coords, env) {
-	// Use Newton's method to try and converge as quick as possible or
-	// converge as close as we can. While the requested precision is achieved
-	// most of the time, it may not always be achievable. Especially past the
-	// visible spectrum, the algorithm will likely struggle to get the same
-	// precision. If, for whatever reason, we cannot achieve the accuracy we
-	// seek in the allotted iterations, just return the closest we were able to
-	// get.
-
-	let [h, c, t] = coords;
-	let xyz = [];
-	let j = 0;
-
-	// Shortcut out for black
-	if (t === 0) {
-		return [0.0, 0.0, 0.0];
-	}
-
-	// Calculate the Y we need to target
-	let y = fromLstar(t);
-
-	// A better initial guess yields better results. Polynomials come from
-	// curve fitting the T vs J response.
-	if (t > 0) {
-		j = 0.00379058511492914 * t ** 2 + 0.608983189401032 * t + 0.9155088574762233;
-	}
-	else {
-		j = 9.514440756550361e-06 * t ** 2 + 0.08693057439788597 * t - 21.928975842194614;
-	}
-
-	// Threshold of how close is close enough, and max number of attempts.
-	// More precision and more attempts means more time spent iterating. Higher
-	// required precision gives more accuracy but also increases the chance of
-	// not hitting the goal. 2e-12 allows us to convert round trip with
-	// reasonable accuracy of six decimal places or more.
-	const threshold = 2e-12;
-	const max_attempts = 15;
-
-	let attempt = 0;
-	let last = Infinity;
-	let best = j;
-
-	// Try to find a J such that the returned y matches the returned y of the L*
-	while (attempt <= max_attempts) {
-		xyz = fromCam16({J: j, C: c, h: h}, env);
-
-		// If we are within range, return XYZ
-		// If we are closer than last time, save the values
-		const delta = Math.abs(xyz[1] - y);
-		if (delta < last) {
-			if (delta <= threshold) {
-				return xyz;
-			}
-			best = j;
-			last = delta;
-		}
-
-		// f(j_root) = (j ** (1 / 2)) * 0.1
-		// f(j) = ((f(j_root) * 100) ** 2) / j - 1 = 0
-		// f(j_root) = Y = y / 100
-		// f(j) = (y ** 2) / j - 1
-		// f'(j) = (2 * y) / j
-		j = j - (xyz[1] - y) * j / (2 * xyz[1]);
-
-		attempt += 1;
-	}
-
-	// We could not acquire the precision we desired,
-	// return our closest attempt.
-	return fromCam16({J: j, C: c, h: h}, env);
-}
-
-function toHct (xyz, env) {
-	// Calculate HCT by taking the L* of CIE LCh D65 and CAM16 chroma and hue.
-
-	const t = toLstar(xyz[1]);
-	if (t === 0.0) {
-		return [0.0, 0.0, 0.0];
-	}
-	const cam16 = toCam16(xyz, viewingConditions);
-	return [constrain(cam16.h), cam16.C, t];
-}
-
-// Pre-calculate everything we can with the viewing conditions
-export const viewingConditions = environment(
-	white, 200 / Math.PI * fromLstar(50.0),
-	fromLstar(50.0) * 100,
-	"average",
-	false,
-);
-
-// https://material.io/blog/science-of-color-design
-// This is not a port of the material-color-utilities,
-// but instead implements the full color space as described,
-// combining CAM16 JCh and Lab D65. This does not clamp conversion
-// to HCT to specific chroma bands and provides support for wider
-// gamuts than Google currently supports and does so at a greater
-// precision (> 8 bits back to sRGB).
-// This implementation comes from https://github.com/facelessuser/coloraide
-// which is licensed under MIT.
-export default new ColorSpace({
-	id: "hct",
-	name: "HCT",
-	coords: {
-		h: {
-			refRange: [0, 360],
-			type: "angle",
-			name: "Hue",
-		},
-		c: {
-			refRange: [0, 145],
-			name: "Colorfulness",
-		},
-		t: {
-			refRange: [0, 100],
-			name: "Tone",
-		},
-	},
-
-	base: xyz_d65,
-
-	fromBase (xyz) {
-		return toHct(xyz, viewingConditions);
-	},
-	toBase (hct) {
-		return fromHct(hct, viewingConditions);
-	},
-	formats: {
-		color: {
-			id: "--hct",
-			coords: ["<number> | <angle>", "<percentage> | <number>", "<percentage> | <number>"],
-		},
-	},
-});

package/lib/colorjs.io/src/spaces/hpluv.js

@@ -1,130 +0,0 @@
-/*
-Adapted from: https://github.com/hsluv/hsluv-javascript/blob/14b49e6cf9a9137916096b8487a5372626b57ba4/src/hsluv.ts
-
-Copyright (c) 2012-2022 Alexei Boronine
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-
-import ColorSpace from "../space.js";
-import LCHuv from "./lchuv.js";
-import {fromXYZ_M} from "./srgb-linear.js";
-import {skipNone} from "../util.js";
-import {calculateBoundingLines} from "./hsluv.js";
-
-const ε = 216 / 24389;  // 6^3/29^3 == (24/116)^3
-const κ = 24389 / 27;   // 29^3/3^3
-
-const m_r0 = fromXYZ_M[0][0];
-const m_r1 = fromXYZ_M[0][1];
-const m_r2 = fromXYZ_M[0][2];
-const m_g0 = fromXYZ_M[1][0];
-const m_g1 = fromXYZ_M[1][1];
-const m_g2 = fromXYZ_M[1][2];
-const m_b0 = fromXYZ_M[2][0];
-const m_b1 = fromXYZ_M[2][1];
-const m_b2 = fromXYZ_M[2][2];
-
-function distanceFromOrigin (slope, intercept) {
-	return Math.abs(intercept) / Math.sqrt(Math.pow(slope, 2) + 1);
-}
-
-function calcMaxChromaHpluv (lines) {
-	let r0 = distanceFromOrigin(lines.r0s, lines.r0i);
-	let r1 = distanceFromOrigin(lines.r1s, lines.r1i);
-	let g0 = distanceFromOrigin(lines.g0s, lines.g0i);
-	let g1 = distanceFromOrigin(lines.g1s, lines.g1i);
-	let b0 = distanceFromOrigin(lines.b0s, lines.b0i);
-	let b1 = distanceFromOrigin(lines.b1s, lines.b1i);
-
-	return Math.min(r0, r1, g0, g1, b0, b1);
-}
-
-export default new ColorSpace({
-	id: "hpluv",
-	name: "HPLuv",
-	coords: {
-		h: {
-			refRange: [0, 360],
-			type: "angle",
-			name: "Hue",
-		},
-		s: {
-			range: [0, 100],
-			name: "Saturation",
-		},
-		l: {
-			range: [0, 100],
-			name: "Lightness",
-		},
-	},
-
-	base: LCHuv,
-	gamutSpace: "self",
-
-	// Convert LCHuv to HPLuv
-	fromBase (lch) {
-		let [l, c, h] = [skipNone(lch[0]), skipNone(lch[1]), skipNone(lch[2])];
-		let s;
-
-		if (l > 99.9999999) {
-			s = 0;
-			l = 100;
-		}
-		else if (l < 0.00000001) {
-			s = 0;
-			l = 0;
-		}
-		else {
-			let lines = calculateBoundingLines(l);
-			let max = calcMaxChromaHpluv(lines);
-			s = c / max * 100;
-		}
-		return [h, s, l];
-	},
-
-	// Convert HPLuv to LCHuv
-	toBase (hsl) {
-		let [h, s, l] = [skipNone(hsl[0]), skipNone(hsl[1]), skipNone(hsl[2])];
-		let c;
-
-		if (l > 99.9999999) {
-			l = 100;
-			c = 0;
-		}
-		else if (l < 0.00000001) {
-			l = 0;
-			c = 0;
-		}
-		else {
-			let lines = calculateBoundingLines(l);
-			let max = calcMaxChromaHpluv(lines, h);
-			c = max / 100 * s;
-		}
-
-		return [l, c, h];
-	},
-
-	formats: {
-		color: {
-			id: "--hpluv",
-			coords: ["<number> | <angle>", "<percentage> | <number>", "<percentage> | <number>"],
-		},
-	},
-});