image-in-browser/lib/image/image-data-uint16.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 { PixelUint16 } from './pixel-uint16.js';
import { PixelRangeIterator } from './pixel-range-iterator.js';
import { ColorUint16 } from '../color/color-uint16.js';
export class MemoryImageDataUint16 {
    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.uint16;
    }
    get formatType() {
        return FormatType.uint;
    }
    get buffer() {
        return this._data.buffer;
    }
    get rowStride() {
        return this._width * this._numChannels * 2;
    }
    get iterator() {
        return PixelUint16.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 : 0xffff;
    }
    get maxIndexValue() {
        return 0xffff;
    }
    get hasPalette() {
        return this.palette !== undefined;
    }
    get palette() {
        return this._palette;
    }
    get isHdrFormat() {
        return true;
    }
    get isLdrFormat() {
        return !this.isHdrFormat;
    }
    get bitsPerChannel() {
        return 16;
    }
    constructor(width, height, numChannels, data) {
        this._width = width;
        this._height = height;
        this._numChannels = numChannels;
        this._data =
            data !== null && data !== void 0 ? data : new Uint16Array(this._width * this._height * this._numChannels);
    }
    static palette(width, height, palette) {
        const data = new Uint16Array(width * height);
        const d = new MemoryImageDataUint16(width, height, 1, data);
        d._palette = palette;
        return d;
    }
    static from(other, skipPixels = false) {
        var _a;
        const data = skipPixels
            ? new Uint16Array(other.data.length)
            : other.data.slice();
        const d = new MemoryImageDataUint16(other.width, other.height, other._numChannels, data);
        d._palette = (_a = other.palette) === null || _a === void 0 ? void 0 : _a.clone();
        return d;
    }
    getRange(x, y, width, height) {
        return new PixelRangeIterator(PixelUint16.imageData(this), x, y, width, height);
    }
    getColor(r, g, b, a) {
        return a === undefined
            ? ColorUint16.rgb(Math.trunc(r), Math.trunc(g), Math.trunc(b))
            : ColorUint16.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 PixelUint16) || p.image !== this) {
            p = PixelUint16.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 MemoryImageDataUint16.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 PixelUint16.imageData(this);
    }
}
//# sourceMappingURL=image-data-uint16.js.map