@jax-data-science/sci-image-visualizer 0.1.0

package/esm2022/lib/store/class-color.util.mjs

@@ -0,0 +1,52 @@
+export function normalizeLabel(s) {
+    return (s ?? '').trim().toLowerCase();
+}
+/** Stable, non-negative 32-bit string hash (identical across runs and machines). */
+export function hashString(s) {
+    let h = 0;
+    for (let i = 0; i < s.length; i++) {
+        h = (Math.imul(31, h) + s.charCodeAt(i)) | 0;
+    }
+    // Fold to non-negative without the Math.abs(INT_MIN) overflow pitfall.
+    return h < 0 ? ~h : h;
+}
+function hslToHex(hDeg, sPct, lPct) {
+    const s = sPct / 100;
+    const l = lPct / 100;
+    const k = (n) => (n + hDeg / 30) % 12;
+    const a = s * Math.min(l, 1 - l);
+    const channel = (n) => {
+        const v = l - a * Math.max(-1, Math.min(k(n) - 3, 9 - k(n), 1));
+        return Math.round(255 * v).toString(16).padStart(2, '0');
+    };
+    return `#${channel(0)}${channel(8)}${channel(4)}`.toUpperCase();
+}
+/** Find the preset matching `label` under the set's match mode. */
+export function findPreset(label, set) {
+    if (!label || !set?.classes)
+        return undefined;
+    if (set.matchMode === 'normalized') {
+        const n = normalizeLabel(label);
+        return set.classes.find((c) => normalizeLabel(c.name) === n);
+    }
+    return set.classes.find((c) => c.name === label);
+}
+/**
+ * Deterministic fallback colour for an unknown class name: index into the palette by a
+ * stable hash of the (normalized) name; if the palette is empty, generate a golden-angle
+ * HSL hue. Same name -> same colour, every run.
+ */
+export function fallbackColorFor(label, palette) {
+    const key = normalizeLabel(label);
+    if (palette && palette.length > 0) {
+        return palette[hashString(key) % palette.length];
+    }
+    const hue = (hashString(key) * 137.508) % 360;
+    return hslToHex(hue, 65, 50);
+}
+/** Resolve a colour for `label`: a matching preset's colour, else the deterministic fallback. */
+export function colorForLabel(label, set) {
+    const preset = findPreset(label, set);
+    return preset ? preset.color : fallbackColorFor(label, set.fallbackPalette);
+}
+//# sourceMappingURL=data:application/json;base64,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