image-in-browser/lib/image/image-data-uint32.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 { PixelUint32 } from './pixel-uint32.js';
import { PixelRangeIterator } from './pixel-range-iterator.js';
import { ColorUint32 } from '../color/color-uint32.js';
export class MemoryImageDataUint32 {
    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.uint32;
    }
    get formatType() {
        return FormatType.uint;
    }
    get buffer() {
        return this._data.buffer;
    }
    get rowStride() {
        return this._width * this._numChannels * 4;
    }
    get iterator() {
        return PixelUint32.imageData(this);
    }
    get byteLength() {
        return this._data.byteLength;
    }
    get length() {
        return this._data.byteLength;
    }
    get maxChannelValue() {
        return 0xffffffff;
    }
    get maxIndexValue() {
        return 0xffffffff;
    }
    get hasPalette() {
        return this.palette !== undefined;
    }
    get palette() {
        return undefined;
    }
    get isHdrFormat() {
        return true;
    }
    get isLdrFormat() {
        return !this.isHdrFormat;
    }
    get bitsPerChannel() {
        return 32;
    }
    constructor(width, height, numChannels, data) {
        this._width = width;
        this._height = height;
        this._numChannels = numChannels;
        this._data =
            data !== null && data !== void 0 ? data : new Uint32Array(this._width * this._height * this._numChannels);
    }
    static from(other, skipPixels = false) {
        const data = skipPixels
            ? new Uint32Array(other.data.length)
            : other.data.slice();
        return new MemoryImageDataUint32(other.width, other.height, other._numChannels, data);
    }
    getRange(x, y, width, height) {
        return new PixelRangeIterator(PixelUint32.imageData(this), x, y, width, height);
    }
    getColor(r, g, b, a) {
        return a === undefined
            ? ColorUint32.rgb(Math.trunc(r), Math.trunc(g), Math.trunc(b))
            : ColorUint32.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 PixelUint32) || p.image !== this) {
            p = PixelUint32.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) {
        const index = y * this._width * this._numChannels + x * this.numChannels;
        this.data[index] = Math.trunc(r);
    }
    setPixelRgb(x, y, r, g, b) {
        const index = y * this._width * this._numChannels + x * this._numChannels;
        this._data[index] = Math.trunc(r);
        if (this._numChannels > 1) {
            this._data[index + 1] = Math.trunc(g);
            if (this._numChannels > 2) {
                this._data[index + 2] = Math.trunc(b);
            }
        }
    }
    setPixelRgba(x, y, r, g, b, a) {
        const index = y * this._width * this._numChannels + x * this._numChannels;
        this._data[index] = Math.trunc(r);
        if (this._numChannels > 1) {
            this._data[index + 1] = Math.trunc(g);
            if (this._numChannels > 2) {
                this._data[index + 2] = Math.trunc(b);
                if (this._numChannels > 3) {
                    this._data[index + 3] = Math.trunc(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 MemoryImageDataUint32.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 PixelUint32.imageData(this);
    }
}
//# sourceMappingURL=image-data-uint32.js.map