imagescript 1.3.1 → 3.1.0

package/dist/codecs/quantize.js

@@ -0,0 +1,302 @@
+const WR = 3, WG = 4, WB = 2;
+export function dominantColor(pixels, include, clusters = 8) {
+    const { palette, weights } = medianCut(pixels, clusters, 4, include);
+    if (!weights.length)
+        return null;
+    let best = 0;
+    for (let i = 1; i < weights.length; i++)
+        if (weights[i] > weights[best])
+            best = i;
+    return [Math.round(palette[best * 3]), Math.round(palette[best * 3 + 1]), Math.round(palette[best * 3 + 2])];
+}
+export function quantize(pixels, width, { maxColors = 256, quality = 95 } = {}) {
+    const length = pixels.length >> 2;
+    let hasTransparency = false;
+    for (let i = 3; i < pixels.length; i += 4)
+        if (pixels[i] < 128) {
+            hasTransparency = true;
+            break;
+        }
+    quality = Math.min(100, Math.max(1, quality));
+    const limit = Math.min(maxColors, Math.round(8 * 32 ** (Math.min(quality, 90) / 90)));
+    const colors = hasTransparency ? limit - 1 : limit;
+    const exact = exactPalette(pixels, colors);
+    let palette, indices;
+    if (exact)
+        ({ palette, indices } = exact);
+    else {
+        palette = Uint8Array.from(medianCut(pixels, colors, Math.ceil(quality / 25)).palette, Math.round);
+        indices = ditherMap(pixels, width, palette, palette.length / 3);
+    }
+    let transparentIndex = -1;
+    if (hasTransparency) {
+        transparentIndex = palette.length / 3;
+        const padded = new Uint8Array(palette.length + 3);
+        padded.set(palette);
+        palette = padded;
+        for (let i = 0; i < length; i++)
+            if (pixels[i * 4 + 3] < 128)
+                indices[i] = transparentIndex;
+    }
+    return { palette, indices, transparentIndex };
+}
+function exactPalette(pixels, limit) {
+    const lookup = new Map();
+    const indices = new Uint8Array(pixels.length >> 2);
+    const palette = [];
+    for (let i = 0, p = 0; i < pixels.length; i += 4, p++) {
+        if (pixels[i + 3] < 128)
+            continue;
+        const key = pixels[i] << 16 | pixels[i + 1] << 8 | pixels[i + 2];
+        let index = lookup.get(key);
+        if (index === undefined) {
+            if (lookup.size >= limit)
+                return null;
+            index = lookup.size;
+            lookup.set(key, index);
+            palette.push(pixels[i], pixels[i + 1], pixels[i + 2]);
+        }
+        indices[p] = index;
+    }
+    if (!palette.length)
+        palette.push(0, 0, 0);
+    return { palette: Uint8Array.from(palette), indices };
+}
+function medianCut(pixels, colors, iterations, include) {
+    const count = new Float64Array(32768);
+    const sumR = new Float64Array(32768);
+    const sumG = new Float64Array(32768);
+    const sumB = new Float64Array(32768);
+    for (let i = 0; i < pixels.length; i += 4) {
+        if (pixels[i + 3] < 128)
+            continue;
+        const r = pixels[i], g = pixels[i + 1], b = pixels[i + 2];
+        if (include && !include(r, g, b))
+            continue;
+        const bin = (r >> 3) << 10 | (g >> 3) << 5 | b >> 3;
+        count[bin]++;
+        sumR[bin] += r;
+        sumG[bin] += g;
+        sumB[bin] += b;
+    }
+    let n = 0;
+    for (let i = 0; i < 32768; i++)
+        if (count[i])
+            n++;
+    const points = { c: [new Float64Array(n), new Float64Array(n), new Float64Array(n)], w: new Float64Array(n) };
+    for (let i = 0, p = 0; i < 32768; i++) {
+        if (!count[i])
+            continue;
+        points.c[0][p] = sumR[i] / count[i];
+        points.c[1][p] = sumG[i] / count[i];
+        points.c[2][p] = sumB[i] / count[i];
+        points.w[p++] = count[i];
+    }
+    if (!n)
+        return { palette: new Float64Array(0), weights: new Float64Array(0) };
+    const boxes = [makeBox(points, Int32Array.from({ length: n }, (_, i) => i))];
+    const scratch = new Int32Array(n);
+    while (boxes.length < colors) {
+        let target = -1;
+        for (let i = 0; i < boxes.length; i++)
+            if (boxes[i].members.length > 1 && (target === -1 || boxes[i].error > boxes[target].error))
+                target = i;
+        if (target === -1)
+            break;
+        const { members, axis, weight } = boxes[target];
+        sortBy(members, points.c[axis], scratch);
+        const half = weight / 2;
+        let split = 1;
+        for (let acc = 0; split < members.length - 1; split++) {
+            acc += points.w[members[split - 1]];
+            if (acc >= half)
+                break;
+        }
+        boxes.splice(target, 1, makeBox(points, members.subarray(0, split)), makeBox(points, members.subarray(split)));
+    }
+    const palette = new Float64Array(boxes.length * 3);
+    boxes.forEach((box, i) => palette.set(box.mean, i * 3));
+    const entries = boxes.length;
+    const [pr, pg, pb] = points.c, pw = points.w;
+    const weights = Float64Array.from(boxes, box => box.weight);
+    for (let iteration = 0; iteration < iterations; iteration++) {
+        const acc = new Float64Array(entries * 4);
+        const nearest = nearestSearch(palette, entries);
+        for (let i = 0; i < n; i++) {
+            const index = nearest(pr[i], pg[i], pb[i]);
+            acc[index * 4] += pr[i] * pw[i];
+            acc[index * 4 + 1] += pg[i] * pw[i];
+            acc[index * 4 + 2] += pb[i] * pw[i];
+            acc[index * 4 + 3] += pw[i];
+        }
+        for (let i = 0; i < entries; i++) {
+            const w = weights[i] = acc[i * 4 + 3];
+            if (!w)
+                continue;
+            palette[i * 3] = acc[i * 4] / w;
+            palette[i * 3 + 1] = acc[i * 4 + 1] / w;
+            palette[i * 3 + 2] = acc[i * 4 + 2] / w;
+        }
+    }
+    return { palette, weights };
+}
+function makeBox({ c: [r, g, b], w }, members) {
+    let weight = 0;
+    const sum = [0, 0, 0];
+    const sq = [0, 0, 0];
+    for (let m = 0; m < members.length; m++) {
+        const i = members[m];
+        weight += w[i];
+        sum[0] += r[i] * w[i];
+        sq[0] += r[i] * r[i] * w[i];
+        sum[1] += g[i] * w[i];
+        sq[1] += g[i] * g[i] * w[i];
+        sum[2] += b[i] * w[i];
+        sq[2] += b[i] * b[i] * w[i];
+    }
+    const mean = sum.map(v => v / weight);
+    const error = sq.map((v, k) => (v - sum[k] * mean[k]) * [WR, WG, WB][k]);
+    const axis = error.indexOf(Math.max(...error));
+    return { members, weight, mean, axis, error: error[0] + error[1] + error[2] };
+}
+function sortBy(indices, keys, scratch) {
+    const n = indices.length;
+    const RUN = 16;
+    for (let start = 0; start < n; start += RUN) {
+        const end = Math.min(n, start + RUN);
+        for (let i = start + 1; i < end; i++) {
+            const v = indices[i], key = keys[v];
+            let j = i - 1;
+            for (; j >= start && keys[indices[j]] > key; j--)
+                indices[j + 1] = indices[j];
+            indices[j + 1] = v;
+        }
+    }
+    let src = indices, dst = scratch.subarray(0, n);
+    for (let width = RUN; width < n; width *= 2) {
+        for (let start = 0; start < n; start += 2 * width) {
+            const mid = Math.min(n, start + width), end = Math.min(n, start + 2 * width);
+            let i = start, j = mid, o = start;
+            if (mid >= end || keys[src[mid - 1]] <= keys[src[mid]]) {
+                dst.set(src.subarray(start, end), start);
+                continue;
+            }
+            while (i < mid && j < end)
+                dst[o++] = keys[src[j]] < keys[src[i]] ? src[j++] : src[i++];
+            while (i < mid)
+                dst[o++] = src[i++];
+            while (j < end)
+                dst[o++] = src[j++];
+        }
+        [src, dst] = [dst, src];
+    }
+    if (src !== indices)
+        indices.set(src);
+}
+function nearestSearch(palette, entries) {
+    const weights = [WR, WG, WB];
+    let axis = 0, spread = -1;
+    for (let k = 0; k < 3; k++) {
+        let min = Infinity, max = -Infinity;
+        for (let i = 0; i < entries; i++) {
+            min = Math.min(min, palette[i * 3 + k]);
+            max = Math.max(max, palette[i * 3 + k]);
+        }
+        if ((max - min) * weights[k] > spread) {
+            spread = (max - min) * weights[k];
+            axis = k;
+        }
+    }
+    const order = Int32Array.from({ length: entries }, (_, i) => i).sort((a, b) => palette[a * 3 + axis] - palette[b * 3 + axis]);
+    const keys = Float64Array.from(order, i => palette[i * 3 + axis]);
+    const weight = weights[axis];
+    return (r, g, b) => {
+        const key = axis === 0 ? r : axis === 1 ? g : b;
+        let best = 0, bestDistance = Infinity;
+        const test = (i) => {
+            const dr = r - palette[i * 3], dg = g - palette[i * 3 + 1], db = b - palette[i * 3 + 2];
+            const distance = WR * dr * dr + WG * dg * dg + WB * db * db;
+            if (distance < bestDistance || (distance === bestDistance && i < best)) {
+                bestDistance = distance;
+                best = i;
+            }
+        };
+        let lo = 0, hi = entries;
+        while (lo < hi) {
+            const mid = lo + hi >> 1;
+            if (keys[mid] < key)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        for (let up = lo, down = lo - 1; up < entries || down >= 0;) {
+            if (up < entries) {
+                const d = key - keys[up];
+                if (weight * d * d > bestDistance)
+                    up = entries;
+                else
+                    test(order[up++]);
+            }
+            if (down >= 0) {
+                const d = key - keys[down];
+                if (weight * d * d > bestDistance)
+                    down = -1;
+                else
+                    test(order[down--]);
+            }
+        }
+        return best;
+    };
+}
+function createLookup(palette, entries) {
+    const cache = new Int16Array(1 << 18).fill(-1);
+    const nearest = nearestSearch(palette, entries);
+    return (r, g, b) => {
+        const key = (r >> 2) << 12 | (g >> 2) << 6 | b >> 2;
+        let index = cache[key];
+        if (index === -1)
+            index = cache[key] = nearest(r, g, b);
+        return index;
+    };
+}
+function ditherMap(pixels, width, palette, entries) {
+    const height = (pixels.length >> 2) / width;
+    const lookup = createLookup(palette, entries);
+    const indices = new Uint8Array(pixels.length >> 2);
+    let current = new Float32Array((width + 2) * 3);
+    let next = new Float32Array((width + 2) * 3);
+    const strength = 0.85;
+    for (let y = 0; y < height; y++) {
+        const reverse = y & 1;
+        for (let step = 0; step < width; step++) {
+            const x = reverse ? width - 1 - step : step;
+            const p = y * width + x;
+            const e = (x + 1) * 3;
+            if (pixels[p * 4 + 3] < 128)
+                continue;
+            const r = clamp(pixels[p * 4] + current[e] * strength);
+            const g = clamp(pixels[p * 4 + 1] + current[e + 1] * strength);
+            const b = clamp(pixels[p * 4 + 2] + current[e + 2] * strength);
+            const index = indices[p] = lookup(r, g, b);
+            const er = r - palette[index * 3];
+            const eg = g - palette[index * 3 + 1];
+            const eb = b - palette[index * 3 + 2];
+            const forward = reverse ? -3 : 3;
+            diffuse(current, next, e, forward, er);
+            diffuse(current, next, e + 1, forward, eg);
+            diffuse(current, next, e + 2, forward, eb);
+        }
+        [current, next] = [next, current];
+        next.fill(0);
+    }
+    return indices;
+}
+function diffuse(current, next, i, forward, error) {
+    current[i + forward] += error * 7 / 16;
+    next[i - forward] += error * 3 / 16;
+    next[i] += error * 5 / 16;
+    next[i + forward] += error / 16;
+}
+function clamp(v) {
+    return v < 0 ? 0 : v > 255 ? 255 : v | 0;
+}

package/dist/codecs/tga.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Whether the data looks like a TGA. Older TGAs have no signature, so this checks that the header is consistent
+ */
+export declare function isTGA(d: Uint8Array): boolean;
+/**
+ * Decodes a TGA into RGBA
+ */
+export declare function decode(d: Uint8Array): {
+    width: number;
+    height: number;
+    pixels: Uint8Array;
+};
+/**
+ * Encodes RGBA pixels into a run length encoded TGA (32 bit with alpha, 24 bit if opaque), top left origin
+ */
+export declare function encode(rgba: Uint8Array, width: number, height: number): Uint8Array;

package/dist/codecs/tga.js

@@ -0,0 +1,203 @@
+const SIGNATURE = 'TRUEVISION-XFILE.\0';
+function readHeader(d) {
+    if (d.length < 18)
+        return null;
+    return {
+        idLength: d[0],
+        colorMapType: d[1],
+        imageType: d[2],
+        mapFirst: d[3] | d[4] << 8,
+        mapLength: d[5] | d[6] << 8,
+        mapEntrySize: d[7],
+        width: d[12] | d[13] << 8,
+        height: d[14] | d[15] << 8,
+        depth: d[16],
+        alphaBits: d[17] & 15,
+        rightToLeft: (d[17] & 16) !== 0,
+        topToBottom: (d[17] & 32) !== 0
+    };
+}
+function hasFooter(d) {
+    if (d.length < 44)
+        return false;
+    for (let i = 0; i < SIGNATURE.length; i++)
+        if (d[d.length - 18 + i] !== SIGNATURE.charCodeAt(i))
+            return false;
+    return true;
+}
+export function isTGA(d) {
+    const h = readHeader(d);
+    if (!h)
+        return false;
+    if (hasFooter(d))
+        return true;
+    const base = h.imageType & ~8;
+    if (h.colorMapType > 1 || ![1, 2, 3].includes(base) || h.imageType > 11 || (h.imageType & 4))
+        return false;
+    if (!h.width || !h.height || d[17] & 0xc0)
+        return false;
+    if (base === 1 && (h.colorMapType !== 1 || (h.depth !== 8 && h.depth !== 16)))
+        return false;
+    if (base === 2 && ![15, 16, 24, 32].includes(h.depth))
+        return false;
+    if (base === 3 && h.depth !== 8 && h.depth !== 16)
+        return false;
+    if (h.colorMapType === 1 && ![8, 15, 16, 24, 32].includes(h.mapEntrySize))
+        return false;
+    const mapBytes = h.colorMapType ? h.mapLength * Math.ceil(h.mapEntrySize / 8) : 0;
+    const dataStart = 18 + h.idLength + mapBytes;
+    const pixelBytes = h.width * h.height * Math.ceil(h.depth / 8);
+    return h.imageType & 8 ? d.length > dataStart : d.length >= dataStart + pixelBytes;
+}
+function readColor(d, o, bits, alphaBits, out, p) {
+    if (bits === 8) {
+        out[p] = out[p + 1] = out[p + 2] = d[o];
+        out[p + 3] = 255;
+    }
+    else if (bits === 15 || bits === 16) {
+        const v = d[o] | d[o + 1] << 8;
+        out[p] = (v >> 10 & 31) * 255 / 31 | 0;
+        out[p + 1] = (v >> 5 & 31) * 255 / 31 | 0;
+        out[p + 2] = (v & 31) * 255 / 31 | 0;
+        out[p + 3] = 255;
+    }
+    else {
+        out[p] = d[o + 2];
+        out[p + 1] = d[o + 1];
+        out[p + 2] = d[o];
+        out[p + 3] = bits === 32 && alphaBits ? d[o + 3] : 255;
+    }
+}
+export function decode(d) {
+    const h = readHeader(d);
+    if (!h || !isTGA(d))
+        throw new Error('TGA: invalid header');
+    const { width, height, depth } = h;
+    const base = h.imageType & ~8, rle = (h.imageType & 8) !== 0;
+    const bytesPerPixel = Math.ceil(depth / 8);
+    let offset = 18 + h.idLength;
+    let palette = null;
+    if (h.colorMapType === 1) {
+        const entryBytes = Math.ceil(h.mapEntrySize / 8);
+        palette = new Uint8Array((h.mapFirst + h.mapLength) * 4);
+        for (let i = 0; i < h.mapLength; i++) {
+            if (offset + entryBytes > d.length)
+                throw new Error('TGA: truncated color map');
+            readColor(d, offset, h.mapEntrySize, h.alphaBits, palette, (h.mapFirst + i) * 4);
+            offset += entryBytes;
+        }
+    }
+    if (base === 1 && !palette)
+        throw new Error('TGA: color mapped image without color map');
+    const count = width * height;
+    const stored = new Uint8Array(count * 4);
+    const pixel = (o, p) => {
+        if (base === 1) {
+            const index = depth === 16 ? d[o] | d[o + 1] << 8 : d[o];
+            const pal = palette;
+            if (index * 4 + 3 < pal.length)
+                stored.set(pal.subarray(index * 4, index * 4 + 4), p);
+            else
+                stored[p + 3] = 255;
+        }
+        else if (base === 3) {
+            stored[p] = stored[p + 1] = stored[p + 2] = d[o];
+            stored[p + 3] = depth === 16 ? d[o + 1] : 255;
+        }
+        else
+            readColor(d, o, depth, h.alphaBits, stored, p);
+    };
+    if (!rle) {
+        if (offset + count * bytesPerPixel > d.length)
+            throw new Error('TGA: truncated image data');
+        for (let i = 0; i < count; i++)
+            pixel(offset + i * bytesPerPixel, i * 4);
+    }
+    else {
+        for (let i = 0; i < count;) {
+            if (offset >= d.length)
+                throw new Error('TGA: truncated image data');
+            const header = d[offset++];
+            const n = (header & 127) + 1;
+            if (offset + (header & 128 ? 1 : n) * bytesPerPixel > d.length)
+                throw new Error('TGA: truncated image data');
+            if (header & 128) {
+                pixel(offset, i * 4);
+                for (let k = 1; k < n && i + k < count; k++)
+                    stored.copyWithin((i + k) * 4, i * 4, i * 4 + 4);
+                offset += bytesPerPixel;
+            }
+            else {
+                for (let k = 0; k < n && i + k < count; k++)
+                    pixel(offset + k * bytesPerPixel, (i + k) * 4);
+                offset += n * bytesPerPixel;
+            }
+            i += n;
+        }
+    }
+    if (!h.topToBottom || h.rightToLeft) {
+        const pixels = new Uint8Array(count * 4);
+        const src = new Uint32Array(stored.buffer), dst = new Uint32Array(pixels.buffer);
+        for (let y = 0; y < height; y++) {
+            const sy = h.topToBottom ? y : height - 1 - y;
+            for (let x = 0; x < width; x++)
+                dst[y * width + x] = src[sy * width + (h.rightToLeft ? width - 1 - x : x)];
+        }
+        return { width, height, pixels };
+    }
+    return { width, height, pixels: stored };
+}
+export function encode(rgba, width, height) {
+    if (width < 1 || height < 1 || width > 65535 || height > 65535)
+        throw new RangeError('TGA: dimensions must be 1-65535');
+    let opaque = true;
+    for (let i = 3; i < rgba.length; i += 4)
+        if (rgba[i] !== 255) {
+            opaque = false;
+            break;
+        }
+    const bpp = opaque ? 3 : 4;
+    const count = width * height;
+    if (rgba.byteOffset % 4)
+        rgba = rgba.slice(0, count * 4);
+    const pixels = new Uint32Array(rgba.buffer, rgba.byteOffset, count);
+    const out = new Uint8Array(18 + count * bpp + Math.ceil(count / 128) + 26);
+    out[2] = 10;
+    out[12] = width & 255;
+    out[13] = width >> 8;
+    out[14] = height & 255;
+    out[15] = height >> 8;
+    out[16] = bpp * 8;
+    out[17] = 32 | (opaque ? 0 : 8);
+    let o = 18;
+    const put = (i) => {
+        const p = i * 4;
+        out[o++] = rgba[p + 2];
+        out[o++] = rgba[p + 1];
+        out[o++] = rgba[p];
+        if (bpp === 4)
+            out[o++] = rgba[p + 3];
+    };
+    for (let i = 0; i < count;) {
+        let run = 1;
+        while (run < 128 && i + run < count && pixels[i + run] === pixels[i])
+            run++;
+        if (run >= 2) {
+            out[o++] = 128 | run - 1;
+            put(i);
+            i += run;
+            continue;
+        }
+        let raw = 1;
+        while (raw < 128 && i + raw < count && !(i + raw + 1 < count && pixels[i + raw] === pixels[i + raw + 1]))
+            raw++;
+        out[o++] = raw - 1;
+        for (let k = 0; k < raw; k++)
+            put(i + k);
+        i += raw;
+    }
+    o += 8;
+    for (let i = 0; i < SIGNATURE.length; i++)
+        out[o++] = SIGNATURE.charCodeAt(i);
+    return out.slice(0, o);
+}

package/dist/codecs/tiff.d.ts

@@ -0,0 +1,6 @@
+export declare function decode(data: Uint8Array): Promise<{
+    width: number;
+    height: number;
+    pixels: Uint8Array;
+    orientation: number;
+}>;