molstar
Version:
A comprehensive macromolecular library.
125 lines • 5.53 kB
JavaScript
/**
* Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
*
* Adapted from NGL.
*
* @author David Sehnal <david.sehnal@gmail.com>
* @author Alexander Rose <alexander.rose@weirdbyte.de>
*/
import { __awaiter, __generator } from "tslib";
import { Vec3 } from '../../../mol-math/linear-algebra';
import { chunkedSubtask, Task } from '../../../mol-task';
import { parseFloat as fastParseFloat } from '../common/text/number-parser';
import { Tokenizer } from '../common/text/tokenizer';
import { ReaderResult as Result } from '../result';
import { utf8Read } from '../../common/utf8';
function readHeader(tokenizer) {
var header = { h: Vec3() };
var headerByteCount = 0;
var deltaLineCount = 0;
var reWhitespace = /\s+/g;
while (true) {
var line = Tokenizer.readLine(tokenizer);
var ls = void 0;
if (line.startsWith('object 1')) {
ls = line.split(reWhitespace);
header.dim = Vec3.create(parseInt(ls[5]), parseInt(ls[6]), parseInt(ls[7]));
}
else if (line.startsWith('origin')) {
ls = line.split(reWhitespace);
header.min = Vec3.create(parseFloat(ls[1]), parseFloat(ls[2]), parseFloat(ls[3]));
}
else if (line.startsWith('delta')) {
ls = line.split(reWhitespace);
if (deltaLineCount === 0) {
header.h[0] = parseFloat(ls[1]);
}
else if (deltaLineCount === 1) {
header.h[1] = parseFloat(ls[2]);
}
else if (deltaLineCount === 2) {
header.h[2] = parseFloat(ls[3]);
}
deltaLineCount += 1;
}
else if (line.startsWith('object 3')) {
headerByteCount += line.length + 1;
break;
}
headerByteCount += line.length + 1;
}
return { header: header, headerByteCount: headerByteCount };
}
function readValuesText(ctx, tokenizer, header) {
var N = header.dim[0] * header.dim[1] * header.dim[2];
var chunkSize = 100 * 100 * 100;
var data = new Float64Array(N);
var offset = 0;
return chunkedSubtask(ctx, chunkSize, data, function (count, data) {
var max = Math.min(N, offset + count);
for (var i = offset; i < max; i++) {
Tokenizer.skipWhitespace(tokenizer);
tokenizer.tokenStart = tokenizer.position;
Tokenizer.eatValue(tokenizer);
data[i] = fastParseFloat(tokenizer.data, tokenizer.tokenStart, tokenizer.tokenEnd);
}
offset = max;
return max === N ? 0 : chunkSize;
}, function (ctx, _, i) { return ctx.update({ current: Math.min(i, N), max: N }); });
}
function parseText(taskCtx, data, name) {
return __awaiter(this, void 0, void 0, function () {
var tokenizer, header, values;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, taskCtx.update('Reading header...')];
case 1:
_a.sent();
tokenizer = Tokenizer(data);
header = readHeader(tokenizer).header;
return [4 /*yield*/, taskCtx.update('Reading values...')];
case 2:
_a.sent();
return [4 /*yield*/, readValuesText(taskCtx, tokenizer, header)];
case 3:
values = _a.sent();
return [2 /*return*/, Result.success({ header: header, values: values, name: name })];
}
});
});
}
function parseBinary(taskCtx, data, name) {
return __awaiter(this, void 0, void 0, function () {
var headerString, tokenizer, _a, header, headerByteCount, size, dv, values, i;
return __generator(this, function (_b) {
switch (_b.label) {
case 0: return [4 /*yield*/, taskCtx.update('Reading header...')];
case 1:
_b.sent();
headerString = utf8Read(data, 0, 1000);
tokenizer = Tokenizer(headerString);
_a = readHeader(tokenizer), header = _a.header, headerByteCount = _a.headerByteCount;
return [4 /*yield*/, taskCtx.update('Reading values...')];
case 2:
_b.sent();
size = header.dim[0] * header.dim[1] * header.dim[2];
dv = new DataView(data.buffer, data.byteOffset + headerByteCount);
values = new Float64Array(size);
for (i = 0; i < size; i++) {
values[i] = dv.getFloat64(i * 8, true);
}
// TODO: why doesnt this work? throw "attempting to construct out-of-bounds TypedArray"
// const values = new Float64Array(data.buffer, data.byteOffset + headerByteCount, header.dim[0] * header.dim[1] * header.dim[2]);
return [2 /*return*/, Result.success({ header: header, values: values, name: name })];
}
});
});
}
export function parseDx(data, name) {
return Task.create('Parse Cube', function (taskCtx) {
if (typeof data === 'string')
return parseText(taskCtx, data, name);
return parseBinary(taskCtx, data, name);
});
}
//# sourceMappingURL=parser.js.map