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