slimfits
Version:
Package for loading data stored in FITS data format
134 lines • 6.91 kB
JavaScript
import { Constants, BitPix, BitPixUtils } from '../interfaces';
import { KeywordsManager } from '../utils/KeywordsManager';
import { ArrayUtils } from '../utils/ArrayUtils';
var BinaryTableDataReader = /** @class */ (function () {
function BinaryTableDataReader() {
}
Object.defineProperty(BinaryTableDataReader.prototype, "name", {
get: function () {
return 'binary table data';
},
enumerable: true,
configurable: true
});
BinaryTableDataReader.prototype.canReadData = function (header) {
return KeywordsManager.hasValueFromList(header, 'XTENSION', ['BINTABLE', 'A3DTABLE']) &&
!KeywordsManager.hasValue(header, 'ZIMAGE', true);
};
BinaryTableDataReader.prototype.readDataSize = function (header) {
var rowsCount = KeywordsManager.getValue(header, 'NAXIS2', 1);
var rowByteLength = KeywordsManager.getValue(header, 'NAXIS1', 1);
var pcount = KeywordsManager.getValue(header, 'PCOUNT', 0);
return Math.ceil((pcount + rowByteLength * rowsCount) / Constants.blockLength) * Constants.blockLength;
};
BinaryTableDataReader.prototype.readDataAsync = function (file, offsetBytes, header) {
var rowsCount = KeywordsManager.getValue(header, 'NAXIS2', 0);
var rowByteLength = KeywordsManager.getValue(header, 'NAXIS1', 0);
var heapOffset = KeywordsManager.getValue(header, 'THEAP', 0);
if (heapOffset === 0) {
heapOffset += rowsCount * rowByteLength;
}
var gapPlusHeapSize = KeywordsManager.getValue(header, 'PCOUNT', 0);
var heapSize = gapPlusHeapSize - Math.max(0, heapOffset - rowsCount * rowByteLength);
var rowByteOffset = 0;
var arrayTFORM = new RegExp('(\\d*)(P?[ABIJKED])(?:\\((\\d+)\\)){0,1}');
var converters = header.filter(function (k) { return k.key.indexOf('TFORM') === 0 && arrayTFORM.test(k.value); }).map(function (k) {
var result = arrayTFORM.exec(k.value);
if (result === null) {
throw new Error('unsupported converter found');
}
var count = parseInt(result[1], 10);
if (result[2].startsWith('Q')) {
throw new Error('64bit array pointers for variable length arrays are unsupported');
}
var name = k.key.replace('TFORM', 'TTYPE');
var columnName = header.filter(function (x) { return x.key === name; })[0].value;
var isPointer = result[2].startsWith('P');
var format = isPointer ? result[2][1] : result[2];
var byteOffset = rowByteOffset;
var dataType = BitPixUtils.getBitPixForLetter(format);
rowByteOffset += isPointer ? 2 * BitPixUtils.getByteSize(BitPix.Int32) : count * BitPixUtils.getByteSize(dataType);
return { format: format, count: count, byteOffset: byteOffset, isPointer: isPointer, columnName: columnName };
});
if (converters.some(function (x) { return x.isPointer; })) { // contains variable length column
var promises = [
file.getDataAsync(offsetBytes, rowsCount * rowByteLength, BitPix.Uint8),
file.getDataAsync(offsetBytes + heapOffset, heapSize, BitPix.Uint8)
];
return Promise.all(promises)
.then(function (results) {
var _a = results.map(function (x) { return x.buffer; }), data = _a[0], heap = _a[1];
return converters.map(function (c) {
if (c.isPointer) {
var pointers = BinaryTableDataReader.readColumn(data, rowsCount, rowByteLength, c.byteOffset, 2, 'J');
return { name: c.columnName, data: BinaryTableDataReader.convertToTiles(pointers, heap, c.format) };
}
else {
return { name: c.columnName, data: BinaryTableDataReader.readColumn(data, rowsCount, rowByteLength, c.byteOffset, c.count, c.format) };
}
});
});
}
else {
return file.getDataAsync(offsetBytes, rowsCount * rowByteLength, BitPix.Uint8)
.then(function (data) {
return converters.map(function (c) {
return { name: c.columnName, data: BinaryTableDataReader.readColumn(data.buffer, rowsCount, rowByteLength, c.byteOffset, c.count, c.format) };
});
});
}
};
BinaryTableDataReader.convertToTiles = function (pointers, heap, format) {
var dataType = BitPixUtils.getBitPixForLetter(format);
var tiles = [];
var rowsCount = pointers.length;
switch (dataType) {
case BitPix.Char:
for (var i = 0; i < rowsCount; i++) {
tiles.push(new Uint8Array(heap, pointers[i][1], pointers[i][0]));
}
break;
case BitPix.Uint8:
for (var i = 0; i < rowsCount; i++) {
tiles.push(new Uint8Array(heap, pointers[i][1], pointers[i][0]));
}
break;
case BitPix.Int16:
for (var i = 0; i < rowsCount; i++) {
tiles.push(new Int16Array(heap, pointers[i][1], pointers[i][0]));
}
break;
case BitPix.Int32:
for (var i = 0; i < rowsCount; i++) {
tiles.push(new Int32Array(heap, pointers[i][1], pointers[i][0]));
}
break;
case BitPix.Int64:
throw new Error('unsupported 64bit array element type');
case BitPix.Float32:
for (var i = 0; i < rowsCount; i++) {
tiles.push(new Float32Array(heap, pointers[i][1], pointers[i][0]));
}
break;
case BitPix.Float32:
for (var i = 0; i < rowsCount; i++) {
tiles.push(new Float64Array(heap, pointers[i][1], pointers[i][0]));
}
break;
}
return tiles;
};
BinaryTableDataReader.readColumn = function (source, rows, rowByteWidth, rowByteOffset, width, format) {
if (width === 0) {
return [];
}
var dataType = BitPixUtils.getBitPixForLetter(format);
var buffer = new ArrayBuffer(BitPixUtils.getByteSize(dataType) * rows * width);
ArrayUtils.pluckColumn(source, buffer, rows, rowByteWidth, rowByteOffset, width, dataType, true);
var chunks = ArrayUtils.chunk(buffer, dataType, width);
return format === 'A' ? chunks.map(function (chunk) { return String.fromCharCode.apply(null, chunk); }) : chunks;
};
return BinaryTableDataReader;
}());
export { BinaryTableDataReader };
//# sourceMappingURL=BinaryTableDataReader.js.map