image-in-browser/lib/image/image-data-uint2.js

Package for encoding / decoding images, transforming images, applying filters, drawing primitives on images on the client side (no need for server Node.js)

import { Format, FormatType } from '../color/format.js';
import { getImageDataBytes, } from './image-data.js';
import { PixelUint2 } from './pixel-uint2.js';
import { PixelRangeIterator } from './pixel-range-iterator.js';
import { ColorUint2 } from '../color/color-uint2.js';
export class MemoryImageDataUint2 {
    get width() {
        return this._width;
    }
    set width(v) {
        this._width = v;
    }
    get height() {
        return this._height;
    }
    set height(v) {
        this._height = v;
    }
    get data() {
        return this._data;
    }
    get numChannels() {
        return this._numChannels;
    }
    get format() {
        return Format.uint2;
    }
    get formatType() {
        return FormatType.uint;
    }
    get buffer() {
        return this._data.buffer;
    }
    get rowStride() {
        return this._rowStride;
    }
    get iterator() {
        return PixelUint2.imageData(this);
    }
    get byteLength() {
        return this._data.byteLength;
    }
    get length() {
        return this._data.byteLength;
    }
    get maxChannelValue() {
        var _a, _b;
        return (_b = (_a = this._palette) === null || _a === void 0 ? void 0 : _a.maxChannelValue) !== null && _b !== void 0 ? _b : 3;
    }
    get maxIndexValue() {
        return 1;
    }
    get hasPalette() {
        return this.palette !== undefined;
    }
    get palette() {
        return this._palette;
    }
    set palette(p) {
        this._palette = p;
    }
    get isHdrFormat() {
        return false;
    }
    get isLdrFormat() {
        return !this.isHdrFormat;
    }
    get bitsPerChannel() {
        return 2;
    }
    constructor(width, height, numChannels, data) {
        this._width = width;
        this._height = height;
        this._numChannels = numChannels;
        this._rowStride = Math.ceil((this._width * (this._numChannels << 1)) / 8);
        this._palette = undefined;
        this._data =
            data !== null && data !== void 0 ? data : new Uint8Array(Math.max(this._rowStride * this._height, 1));
    }
    static palette(width, height, palette) {
        const rowStride = Math.ceil(width / 4);
        const data = new Uint8Array(Math.max(rowStride * height, 1));
        const d = new MemoryImageDataUint2(width, height, 1, data);
        d._rowStride = rowStride;
        d._palette = palette;
        return d;
    }
    static from(other, skipPixels = false) {
        var _a;
        const data = skipPixels
            ? new Uint8Array(other.data.length)
            : other.data.slice();
        const d = new MemoryImageDataUint2(other.width, other.height, other._numChannels, data);
        d._rowStride = other.rowStride;
        d._palette = (_a = other.palette) === null || _a === void 0 ? void 0 : _a.clone();
        return d;
    }
    getRange(x, y, width, height) {
        return new PixelRangeIterator(PixelUint2.imageData(this), x, y, width, height);
    }
    getColor(r, g, b, a) {
        return a === undefined
            ? ColorUint2.rgb(Math.trunc(r), Math.trunc(g), Math.trunc(b))
            : ColorUint2.rgba(Math.trunc(r), Math.trunc(g), Math.trunc(b), Math.trunc(a));
    }
    getPixel(x, y, pixel) {
        let p = pixel;
        if (p === undefined || !(p instanceof PixelUint2) || p.image !== this) {
            p = PixelUint2.imageData(this);
        }
        p.setPosition(x, y);
        return p;
    }
    setPixel(x, y, p) {
        this.setPixelRgba(x, y, p.r, p.g, p.b, p.a);
    }
    setPixelR(x, y, r) {
        var _a;
        if (this._numChannels < 1) {
            return;
        }
        (_a = this._pixel) !== null && _a !== void 0 ? _a : (this._pixel = PixelUint2.imageData(this));
        this._pixel.setPosition(x, y);
        this._pixel.index = r;
    }
    setPixelRgb(x, y, r, g, b) {
        var _a;
        if (this._numChannels < 1) {
            return;
        }
        (_a = this._pixel) !== null && _a !== void 0 ? _a : (this._pixel = PixelUint2.imageData(this));
        this._pixel.setPosition(x, y);
        this._pixel.setRgb(r, g, b);
    }
    setPixelRgba(x, y, r, g, b, a) {
        var _a;
        if (this._numChannels < 1) {
            return;
        }
        (_a = this._pixel) !== null && _a !== void 0 ? _a : (this._pixel = PixelUint2.imageData(this));
        this._pixel.setPosition(x, y);
        this._pixel.setRgba(r, g, b, a);
    }
    setPixelRgbSafe(x, y, r, g, b) {
        if (x < 0 || x >= this.width || y < 0 || y >= this.height) {
            return;
        }
        this.setPixelRgb(x, y, r, g, b);
    }
    setPixelRgbaSafe(x, y, r, g, b, a) {
        if (x < 0 || x >= this.width || y < 0 || y >= this.height) {
            return;
        }
        this.setPixelRgba(x, y, r, g, b, a);
    }
    clear(_c) { }
    clone(skipPixels = false) {
        return MemoryImageDataUint2.from(this, skipPixels);
    }
    toUint8Array() {
        return new Uint8Array(this.buffer);
    }
    getBytes(opt) {
        return getImageDataBytes(this, opt);
    }
    toString() {
        return `${this.constructor.name} (w: ${this._width}, h: ${this._height}, ch: ${this._numChannels})`;
    }
    [Symbol.iterator]() {
        return PixelUint2.imageData(this);
    }
}
//# sourceMappingURL=image-data-uint2.js.map