@dilemmagx/palette 0.2.0 → 0.2.2

package/dist/cli.js

@@ -10067,6 +10067,15 @@ function registerBuiltInAlgorithms() {
     const sourceArgb = argbFromHex(input.baseColor);
     return buildMonetPaletteFromSourceArgb(sourceArgb, resolveMonetCount(input.count, 6));
   });
+  registerAlgorithm("dominant", async (input) => {
+    if (input.buffer) {
+      const colors = await extractDominantPalette(input.buffer, resolveCount(input.count, 8));
+      if (colors.length > 0) {
+        return colors;
+      }
+    }
+    return buildHslPaletteColors(input, "monochrome");
+  });
 }
 registerBuiltInAlgorithms();
 async function buildPaletteResult(input, algorithm) {
@@ -10199,6 +10208,74 @@ async function extractMonetPalette(buffer, count) {
   const sourceArgb = ranked[0] ?? sampled[0];
   return buildMonetPaletteFromSourceArgb(sourceArgb, count);
 }
+async function extractDominantPalette(buffer, count) {
+  const { data, info } = await (0, import_sharp.default)(buffer).resize({ width: 96, height: 96, fit: "inside" }).removeAlpha().raw().toBuffer({ resolveWithObject: true });
+  const step = info.channels;
+  const pixels = [];
+  for (let i = 0; i < data.length; i += step) {
+    const r = data[i] ?? 0;
+    const g = data[i + 1] ?? 0;
+    const b = data[i + 2] ?? 0;
+    pixels.push(argbFromRgb(r, g, b));
+  }
+  if (pixels.length === 0) return [];
+  const sampled = downsamplePixels(pixels, 2400);
+  const quantized = QuantizerCelebi.quantize(sampled, 128);
+  const entries = Array.from(quantized.entries()).map(([argb, population]) => ({
+    rgb: argbToRgb(argb),
+    count: population
+  }));
+  if (entries.length === 0) return [];
+  entries.sort((a, b) => {
+    const countDelta = b.count - a.count;
+    if (countDelta !== 0) return countDelta;
+    return rgbKey(a.rgb) - rgbKey(b.rgb);
+  });
+  const totalCount = entries.reduce((sum, entry) => sum + entry.count, 0);
+  const coverageTarget = 0.95;
+  const candidateEntries = [];
+  let coverage = 0;
+  for (const entry of entries) {
+    if (candidateEntries.length >= count) {
+      candidateEntries.push(entry);
+      continue;
+    }
+    candidateEntries.push(entry);
+    coverage += entry.count / Math.max(1, totalCount);
+    if (coverage >= coverageTarget) {
+      break;
+    }
+  }
+  if (candidateEntries.length < count) {
+    candidateEntries.splice(0, candidateEntries.length, ...entries);
+  }
+  if (entries.length <= count) {
+    return entries.map((entry) => rgbToHex(entry.rgb));
+  }
+  const maxCount = Math.max(1, entries[0]?.count ?? 1);
+  const seeds = [candidateEntries[0].rgb];
+  while (seeds.length < count) {
+    let best = null;
+    let bestScore = -1;
+    for (const entry of candidateEntries) {
+      if (seeds.some((seed) => rgbDistanceSq(seed, entry.rgb) === 0)) continue;
+      let minDist = Number.POSITIVE_INFINITY;
+      for (const seed of seeds) {
+        minDist = Math.min(minDist, rgbDistanceSq(seed, entry.rgb));
+      }
+      const weight = entry.count / maxCount;
+      const score = minDist * (0.2 + Math.sqrt(weight));
+      if (score > bestScore + 1e-9 || Math.abs(score - bestScore) <= 1e-9 && best !== null && rgbKey(entry.rgb) < rgbKey(best.rgb)) {
+        bestScore = score;
+        best = entry;
+      }
+    }
+    if (!best) break;
+    seeds.push(best.rgb);
+  }
+  const refined = refineCentroids(seeds, entries);
+  return refined.slice(0, count).map((color) => rgbToHex(color));
+}
 function resolveCount(count, fallback) {
   if (!count) return fallback;
   return Math.max(2, Math.min(12, Math.floor(count)));
@@ -10299,6 +10376,50 @@ async function fetchBuffer(url) {
 function clamp(value, min, max) {
   return Math.min(max, Math.max(min, value));
 }
+function rgbDistanceSq(a, b) {
+  const dr = a.r - b.r;
+  const dg = a.g - b.g;
+  const db = a.b - b.b;
+  return dr * dr + dg * dg + db * db;
+}
+function rgbKey(color) {
+  return (color.r << 16) + (color.g << 8) + color.b;
+}
+function argbToRgb(argb) {
+  return {
+    r: argb >>> 16 & 255,
+    g: argb >>> 8 & 255,
+    b: argb & 255
+  };
+}
+function refineCentroids(seeds, entries) {
+  const accum = seeds.map(() => ({ r: 0, g: 0, b: 0, count: 0 }));
+  for (const entry of entries) {
+    let bestIndex = 0;
+    let bestDist = Number.POSITIVE_INFINITY;
+    for (let i = 0; i < seeds.length; i += 1) {
+      const dist = rgbDistanceSq(seeds[i], entry.rgb);
+      if (dist < bestDist) {
+        bestDist = dist;
+        bestIndex = i;
+      }
+    }
+    const target = accum[bestIndex];
+    target.r += entry.rgb.r * entry.count;
+    target.g += entry.rgb.g * entry.count;
+    target.b += entry.rgb.b * entry.count;
+    target.count += entry.count;
+  }
+  return seeds.map((seed, index) => {
+    const bucket = accum[index];
+    if (!bucket || bucket.count === 0) return seed;
+    return {
+      r: clamp(bucket.r / bucket.count, 0, 255),
+      g: clamp(bucket.g / bucket.count, 0, 255),
+      b: clamp(bucket.b / bucket.count, 0, 255)
+    };
+  });
+}
 function normalizeHue(hue) {
   const normalized = hue % 360;
   return normalized < 0 ? normalized + 360 : normalized;

package/dist/core.d.ts

@@ -5,7 +5,7 @@ export type InputType = 'hex' | 'datauri' | 'url' | 'path';
 /**
  * Built-in palette algorithms.
  */
-export type BuiltInPaletteAlgorithm = 'analogous' | 'complementary' | 'triadic' | 'tetradic' | 'split-complementary' | 'monochrome' | 'monet';
+export type BuiltInPaletteAlgorithm = 'analogous' | 'complementary' | 'triadic' | 'tetradic' | 'split-complementary' | 'monochrome' | 'monet' | 'dominant';
 /**
  * Palette algorithm name, including custom algorithms.
  */