slimfits/lib/utils/LinearTransformers.js

Package for loading data stored in FITS data format

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var interfaces_1 = require("../interfaces");
var Uint8LinearTransformer = /** @class */ (function () {
    function Uint8LinearTransformer() {
    }
    Uint8LinearTransformer.prototype.transform = function (data, scale, zero) {
        var outData = new Uint8Array(data.length);
        for (var i = 0; i < data.length; i++) {
            outData[i] = (data[i] - zero) / scale;
        }
        return outData;
    };
    Uint8LinearTransformer.prototype.transformBack = function (data, scale, zero) {
        if (!(data instanceof Uint8Array)) {
            throw new Error('unrecognized type');
        }
        if (scale === 1 && zero === -128) {
            return this.transformBackToInt8(data, scale, zero);
        }
        return this.transformBackToUint8(data, scale, zero);
    };
    Uint8LinearTransformer.prototype.transformBackToInt8 = function (data, scale, zero) {
        var outData = new Int8Array(data.length);
        for (var i = 0; i < data.length; i++) {
            outData[i] = data[i] * scale + zero;
        }
        return outData;
    };
    Uint8LinearTransformer.prototype.transformBackToUint8 = function (data, scale, zero) {
        for (var i = 0; i < data.length; i++) {
            data[i] = data[i] * scale + zero;
        }
        return data;
    };
    return Uint8LinearTransformer;
}());
exports.Uint8LinearTransformer = Uint8LinearTransformer;
var Int16LinearTransformer = /** @class */ (function () {
    function Int16LinearTransformer() {
    }
    Int16LinearTransformer.prototype.transform = function (data, scale, zero) {
        var outData = new Int16Array(data.length);
        for (var i = 0; i < data.length; i++) {
            outData[i] = (data[i] - zero) / scale;
        }
        return outData;
    };
    Int16LinearTransformer.prototype.transformBack = function (data, scale, zero) {
        if (!(data instanceof Int16Array)) {
            throw new Error('unrecognized type');
        }
        if (scale === 1 && zero >= 32767) {
            return this.transformBackToUint16(data, scale, zero);
        }
        return this.transformBackToInt16(data, scale, zero);
    };
    Int16LinearTransformer.prototype.transformBackToUint16 = function (data, scale, zero) {
        var outData = new Uint16Array(data.length);
        for (var i = 0; i < data.length; i++) {
            outData[i] = data[i] * scale + zero;
        }
        return outData;
    };
    Int16LinearTransformer.prototype.transformBackToInt16 = function (data, scale, zero) {
        for (var i = 0; i < data.length; i++) {
            data[i] = data[i] * scale + zero;
        }
        return data;
    };
    return Int16LinearTransformer;
}());
exports.Int16LinearTransformer = Int16LinearTransformer;
var Int32LinearTransformer = /** @class */ (function () {
    function Int32LinearTransformer() {
    }
    Int32LinearTransformer.prototype.transform = function (data, scale, zero) {
        var outData = new Int32Array(data.length);
        for (var i = 0; i < data.length; i++) {
            outData[i] = (data[i] - zero) / scale;
        }
        return outData;
    };
    Int32LinearTransformer.prototype.transformBack = function (data, scale, zero) {
        if (!(data instanceof Int32Array)) {
            throw new Error('unrecognized type');
        }
        if (scale === 1 && zero >= 2147483647) {
            return this.transformBackToUint32(data, scale, zero);
        }
        return this.transformBackToInt32(data, scale, zero);
    };
    Int32LinearTransformer.prototype.transformBackToUint32 = function (data, scale, zero) {
        var outData = new Uint32Array(data.length);
        for (var i = 0; i < data.length; i++) {
            outData[i] = data[i] * scale + zero;
        }
        return outData;
    };
    Int32LinearTransformer.prototype.transformBackToInt32 = function (data, scale, zero) {
        for (var i = 0; i < data.length; i++) {
            data[i] = data[i] * scale + zero;
        }
        return data;
    };
    return Int32LinearTransformer;
}());
exports.Int32LinearTransformer = Int32LinearTransformer;
var Float32LinearTransformer = /** @class */ (function () {
    function Float32LinearTransformer() {
    }
    Float32LinearTransformer.prototype.transform = function (data, scale, zero) {
        var outData = new Float32Array(data.length);
        for (var i = 0; i < data.length; i++) {
            outData[i] = (data[i] - zero) / scale;
        }
        return outData;
    };
    Float32LinearTransformer.prototype.transformBack = function (data, scale, zero) {
        if (!(data instanceof Float32Array)) {
            throw new Error('unrecognized type');
        }
        for (var i = 0; i < data.length; i++) {
            data[i] = data[i] * scale + zero;
        }
        return data;
    };
    return Float32LinearTransformer;
}());
exports.Float32LinearTransformer = Float32LinearTransformer;
var Float64LinearTransformer = /** @class */ (function () {
    function Float64LinearTransformer() {
    }
    Float64LinearTransformer.prototype.transform = function (data, scale, zero) {
        var outData = new Float64Array(data.length);
        for (var i = 0; i < data.length; i++) {
            outData[i] = (data[i] - zero) / scale;
        }
        return outData;
    };
    Float64LinearTransformer.prototype.transformBack = function (data, scale, zero) {
        if (!(data instanceof Float64Array)) {
            throw new Error('unrecognized type');
        }
        for (var i = 0; i < data.length; i++) {
            data[i] = data[i] * scale + zero;
        }
        return data;
    };
    return Float64LinearTransformer;
}());
exports.Float64LinearTransformer = Float64LinearTransformer;
var registeredTransformers = {
    Uint8: new Uint8LinearTransformer(),
    Int16: new Int16LinearTransformer(),
    Int32: new Int32LinearTransformer(),
    // 'Int64': Int64LinearTransformer, // <- we don't have it in JS!
    Float32: new Float32LinearTransformer(),
    Float64: new Float64LinearTransformer()
};
exports.LinearTransformers = {
    registeredTransformers: registeredTransformers,
    getTransformerFor: function (b) {
        var transformer;
        switch (b) {
            case interfaces_1.BitPix.Uint8:
                transformer = registeredTransformers.Uint8;
                break;
            case interfaces_1.BitPix.Int16:
                transformer = registeredTransformers.Int16;
                break;
            case interfaces_1.BitPix.Int32:
                transformer = registeredTransformers.Int32;
                break;
            case interfaces_1.BitPix.Float32:
                transformer = registeredTransformers.Float32;
                break;
            case interfaces_1.BitPix.Float64:
                transformer = registeredTransformers.Float64;
                break;
            default:
                throw new Error('no transformer for this BitPix');
        }
        return transformer;
    }
};
//# sourceMappingURL=LinearTransformers.js.map