Color Utilities

import {
  euclideanDistance,
  redmeanDistance,
  cie76Distance,
  ciede2000Distance,
  oklabDistance,
  getDistanceFunction,
  findNearestColor,
  createPaletteMatcher,
  findNearestColors,
  mapImageToPalette,
  rgbToLab,
  rgbToOklab,
  quantizeBits,
  quantizeGenesis,
  quantizeCPC,
  expandVGA6to8,
  GENESIS_DAC_NORMAL,
  GENESIS_DAC_SHADOW,
  GENESIS_DAC_HIGHLIGHT,
  LEVELS,
} from 'bitmapped/color';

function euclideanDistance(a: RGB, b: RGB): number;

import { euclideanDistance } from 'bitmapped/color';
 
const d = euclideanDistance(
  { r: 255, g: 0, b: 0 },
  { r: 0, g: 255, b: 0 },
);
// d ≈ 360.62

function redmeanDistance(a: RGB, b: RGB): number;

import { redmeanDistance } from 'bitmapped/color';
 
const d = redmeanDistance(
  { r: 255, g: 0, b: 0 },
  { r: 0, g: 255, b: 0 },
);
// d ≈ 584.58

function cie76Distance(a: RGB, b: RGB): number;

import { cie76Distance } from 'bitmapped/color';
 
const d = cie76Distance(
  { r: 255, g: 0, b: 0 },
  { r: 0, g: 255, b: 0 },
);
// d ≈ 170.57

function ciede2000Distance(a: RGB, b: RGB): number;

import { ciede2000Distance } from 'bitmapped/color';
 
const d = ciede2000Distance(
  { r: 255, g: 0, b: 0 },
  { r: 0, g: 255, b: 0 },
);
// d ≈ 72.19

function oklabDistance(a: RGB, b: RGB): number;

import { oklabDistance } from 'bitmapped/color';
 
const d = oklabDistance(
  { r: 255, g: 0, b: 0 },
  { r: 0, g: 255, b: 0 },
);
// d ≈ 0.52

function getDistanceFunction(
  algorithm: DistanceAlgorithm,
): (a: RGB, b: RGB) => number;

import { getDistanceFunction } from 'bitmapped/color';
 
const distFn = getDistanceFunction('oklab');
const d = distFn({ r: 100, g: 50, b: 200 }, { r: 110, g: 60, b: 190 });

function findNearestColor(
  color: RGB,
  palette: Palette,
  algorithm?: DistanceAlgorithm,
): PaletteColor;

import { findNearestColor } from 'bitmapped/color';
 
const palette = [
  { color: { r: 0, g: 0, b: 0 }, name: 'Black' },
  { color: { r: 255, g: 255, b: 255 }, name: 'White' },
  { color: { r: 255, g: 0, b: 0 }, name: 'Red' },
];
 
const match = findNearestColor(
  { r: 200, g: 30, b: 20 },
  palette,
  'oklab',
);
// match → { color: { r: 255, g: 0, b: 0 }, name: 'Red' }

function createPaletteMatcher(
  palette: Palette,
  algorithm?: DistanceAlgorithm,
): (color: RGB) => PaletteColor;

import { createPaletteMatcher } from 'bitmapped/color';
 
const matcher = createPaletteMatcher(palette, 'ciede2000');
 
// Match many pixels efficiently
for (const pixel of pixels) {
  const nearest = matcher(pixel);
  // ...
}

function findNearestColors(
  color: RGB,
  palette: Palette,
  n: number,
  algorithm?: DistanceAlgorithm,
): PaletteColor[];

import { findNearestColors } from 'bitmapped/color';
 
const top3 = findNearestColors(
  { r: 128, g: 64, b: 200 },
  palette,
  3,
  'oklab',
);
// top3[0] is the closest, top3[2] is the third-closest

function mapImageToPalette(
  imageData: ImageData,
  palette: Palette,
  algorithm?: DistanceAlgorithm,
): ImageData;

import { mapImageToPalette } from 'bitmapped/color';
import { getPreset } from 'bitmapped/presets';
 
const gb = getPreset('gameboy-dmg')!;
const result = mapImageToPalette(imageData, gb.palette!, 'oklab');
// result is a new ImageData with only Game Boy colors

function rgbToLab(color: RGB): LabColor;

import { rgbToLab } from 'bitmapped/color';
 
const lab = rgbToLab({ r: 255, g: 128, b: 0 });
// lab → { L: 69.48, a: 38.85, b: 74.99 }

function rgbToOklab(color: RGB): OklabColor;

import { rgbToOklab } from 'bitmapped/color';
 
const ok = rgbToOklab({ r: 255, g: 128, b: 0 });
// ok → { L: 0.79, a: 0.06, b: 0.16 }

function quantizeBits(value: number, bits: number): number;

import { quantizeBits } from 'bitmapped/color';
 
quantizeBits(200, 3); // 3-bit: 8 levels → 219
quantizeBits(200, 2); // 2-bit: 4 levels → 170
quantizeBits(200, 1); // 1-bit: 2 levels → 255

function quantizeGenesis(value: number): number;

import { quantizeGenesis } from 'bitmapped/color';
 
quantizeGenesis(100); // → 87
quantizeGenesis(200); // → 206
quantizeGenesis(50);  // → 52

function quantizeCPC(value: number): number;

import { quantizeCPC } from 'bitmapped/color';
 
quantizeCPC(30);  // → 0
quantizeCPC(100); // → 128
quantizeCPC(220); // → 255

function expandVGA6to8(value: number): number;

import { expandVGA6to8 } from 'bitmapped/color';
 
expandVGA6to8(0);  // → 0
expandVGA6to8(32); // → 130
expandVGA6to8(63); // → 255

const GENESIS_DAC_NORMAL: readonly [0, 52, 87, 116, 144, 172, 206, 255];

const GENESIS_DAC_SHADOW: readonly [0, 29, 52, 70, 87, 101, 116, 130];

const GENESIS_DAC_HIGHLIGHT: readonly [130, 144, 158, 172, 187, 206, 228, 255];

const LEVELS: Record<number, readonly number[]>;

import { LEVELS } from 'bitmapped/color';
 
LEVELS[3]; // → [0, 36, 73, 109, 146, 182, 219, 255]
LEVELS[4]; // → [0, 17, 34, 51, ..., 238, 255]