molstar 3.0.1 → 3.0.2

package/lib/commonjs/servers/volume/common/data-format.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * Taken/adapted from DensityServer (https://github.com/dsehnal/DensityServer)
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readHeader = exports.encodeHeader = void 0;
+var tslib_1 = require("tslib");
+var Schema = (0, tslib_1.__importStar)(require("./binary-schema"));
+var _schema;
+(function (_schema) {
+    var array = Schema.array, obj = Schema.obj, int = Schema.int, bool = Schema.bool, float = Schema.float, str = Schema.str;
+    _schema.schema = obj([
+        ['formatVersion', str],
+        ['axisOrder', array(int)],
+        ['origin', array(float)],
+        ['dimensions', array(float)],
+        ['spacegroup', obj([
+                ['number', int],
+                ['size', array(float)],
+                ['angles', array(float)],
+                ['isPeriodic', bool],
+            ])],
+        ['channels', array(str)],
+        ['valueType', str],
+        ['blockSize', int],
+        ['sampling', array(obj([
+                ['byteOffset', float],
+                ['rate', int],
+                ['valuesInfo', array(obj([
+                        ['mean', float],
+                        ['sigma', float],
+                        ['min', float],
+                        ['max', float]
+                    ]))],
+                ['sampleCount', array(int)]
+            ]))]
+    ]);
+})(_schema || (_schema = {}));
+var headerSchema = _schema.schema;
+function encodeHeader(header) {
+    return Schema.encode(headerSchema, header);
+}
+exports.encodeHeader = encodeHeader;
+function readHeader(file) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        var buffer, headerSize, header;
+        return (0, tslib_1.__generator)(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, file.readBuffer(0, 4 * 4096)];
+                case 1:
+                    buffer = (_a.sent()).buffer;
+                    headerSize = buffer.readInt32LE(0);
+                    if (!(headerSize > buffer.byteLength - 4)) return [3 /*break*/, 3];
+                    return [4 /*yield*/, file.readBuffer(0, headerSize + 4)];
+                case 2:
+                    buffer = (_a.sent()).buffer;
+                    _a.label = 3;
+                case 3:
+                    header = Schema.decode(headerSchema, buffer, 4);
+                    return [2 /*return*/, { header: header, dataOffset: headerSize + 4 }];
+            }
+        });
+    });
+}
+exports.readHeader = readHeader;
+//# sourceMappingURL=data-format.js.map

package/lib/commonjs/servers/volume/common/file.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * Taken/adapted from DensityServer (https://github.com/dsehnal/DensityServer)
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+import { FileHandle } from '../../../mol-io/common/file-handle';
+export declare function openRead(filename: string): Promise<number>;
+export declare function exists(filename: string): boolean;
+export declare function createFile(filename: string): Promise<number>;
+export declare function writeInt(file: FileHandle, value: number, position: number): Promise<void>;

package/lib/commonjs/servers/volume/common/file.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * Taken/adapted from DensityServer (https://github.com/dsehnal/DensityServer)
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeInt = exports.createFile = exports.exists = exports.openRead = void 0;
+var tslib_1 = require("tslib");
+var fs = (0, tslib_1.__importStar)(require("fs"));
+var path = (0, tslib_1.__importStar)(require("path"));
+var simple_buffer_1 = require("../../../mol-io/common/simple-buffer");
+function openRead(filename) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        var _this = this;
+        return (0, tslib_1.__generator)(this, function (_a) {
+            return [2 /*return*/, new Promise(function (res, rej) {
+                    fs.open(filename, 'r', function (err, file) { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
+                        return (0, tslib_1.__generator)(this, function (_a) {
+                            if (err) {
+                                rej(err);
+                                return [2 /*return*/];
+                            }
+                            try {
+                                res(file);
+                            }
+                            catch (e) {
+                                fs.closeSync(file);
+                            }
+                            return [2 /*return*/];
+                        });
+                    }); });
+                })];
+        });
+    });
+}
+exports.openRead = openRead;
+function makeDir(path, root) {
+    var dirs = path.split(/\/|\\/g), dir = dirs.shift();
+    root = (root || '') + dir + '/';
+    try {
+        fs.mkdirSync(root);
+    }
+    catch (e) {
+        if (!fs.statSync(root).isDirectory())
+            throw new Error(e);
+    }
+    return !dirs.length || makeDir(dirs.join('/'), root);
+}
+function exists(filename) {
+    return fs.existsSync(filename);
+}
+exports.exists = exists;
+function createFile(filename) {
+    return new Promise(function (res, rej) {
+        if (fs.existsSync(filename))
+            fs.unlinkSync(filename);
+        makeDir(path.dirname(filename));
+        fs.open(filename, 'w', function (err, file) {
+            if (err)
+                rej(err);
+            else
+                res(file);
+        });
+    });
+}
+exports.createFile = createFile;
+var smallBuffer = simple_buffer_1.SimpleBuffer.fromBuffer(Buffer.alloc(8));
+function writeInt(file, value, position) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        return (0, tslib_1.__generator)(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    smallBuffer.writeInt32LE(value, 0);
+                    return [4 /*yield*/, file.writeBuffer(position, smallBuffer, 4)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.writeInt = writeInt;
+//# sourceMappingURL=file.js.map

package/lib/commonjs/servers/volume/config.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2019-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+declare const DefaultServerConfig: {
+    apiPrefix: string;
+    defaultPort: number;
+    shutdownTimeoutMinutes: number;
+    shutdownTimeoutVarianceMinutes: number;
+    idMap: [string, string][];
+};
+export interface ServerJsonConfig {
+    cfg?: string;
+    printCfg?: any;
+    cfgTemplate?: any;
+}
+export declare type ServerConfig = typeof DefaultServerConfig;
+export declare const ServerConfig: {
+    apiPrefix: string;
+    defaultPort: number;
+    shutdownTimeoutMinutes: number;
+    shutdownTimeoutVarianceMinutes: number;
+    idMap: [string, string][];
+};
+declare const DefaultLimitsConfig: {
+    maxRequestBlockCount: number;
+    maxFractionalBoxVolume: number;
+    maxOutputSizeInVoxelCountByPrecisionLevel: number[];
+};
+export declare type LimitsConfig = typeof DefaultLimitsConfig;
+export declare const LimitsConfig: {
+    maxRequestBlockCount: number;
+    maxFractionalBoxVolume: number;
+    maxOutputSizeInVoxelCountByPrecisionLevel: number[];
+};
+export declare function configureServer(): void;
+export declare function configureLocal(): {
+    maxRequestBlockCount: number;
+    maxFractionalBoxVolume: number;
+    maxOutputSizeInVoxelCountByPrecisionLevel: number[];
+} & {
+    jobs: string;
+    jobsTemplate: any;
+};
+export {};

package/lib/commonjs/servers/volume/config.js

@@ -0,0 +1,197 @@
+"use strict";
+/**
+ * Copyright (c) 2019-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureLocal = exports.configureServer = exports.LimitsConfig = exports.ServerConfig = void 0;
+var tslib_1 = require("tslib");
+var argparse = (0, tslib_1.__importStar)(require("argparse"));
+var type_helpers_1 = require("../../mol-util/type-helpers");
+var version_1 = require("./server/version");
+var fs = (0, tslib_1.__importStar)(require("fs"));
+var DefaultServerConfig = {
+    apiPrefix: '/VolumeServer',
+    defaultPort: 1337,
+    shutdownTimeoutMinutes: 24 * 60,
+    shutdownTimeoutVarianceMinutes: 60,
+    idMap: []
+};
+function addLimitsArgs(parser) {
+    parser.add_argument('--maxRequestBlockCount', {
+        default: DefaultLimitsConfig.maxRequestBlockCount,
+        metavar: 'COUNT',
+        help: "Maximum number of blocks that could be read in 1 query.\nThis is somewhat tied to the maxOutputSizeInVoxelCountByPrecisionLevel\nin that the <maximum number of voxel> = maxRequestBlockCount * <block size>^3.\nThe default block size is 96 which corresponds to 28,311,552 voxels with 32 max blocks."
+    });
+    parser.add_argument('--maxFractionalBoxVolume', {
+        default: DefaultLimitsConfig.maxFractionalBoxVolume,
+        metavar: 'VOLUME',
+        help: "The maximum fractional volume of the query box (to prevent queries that are too big)."
+    });
+    parser.add_argument('--maxOutputSizeInVoxelCountByPrecisionLevel', {
+        nargs: '+',
+        default: DefaultLimitsConfig.maxOutputSizeInVoxelCountByPrecisionLevel,
+        metavar: 'LEVEL',
+        help: "What is the (approximate) maximum desired size in voxel count by precision level\nRule of thumb: <response gzipped size> in [<voxel count> / 8, <voxel count> / 4].\nThe maximum number of voxels is tied to maxRequestBlockCount."
+    });
+}
+function addServerArgs(parser) {
+    parser.add_argument('--apiPrefix', {
+        default: DefaultServerConfig.apiPrefix,
+        metavar: 'PREFIX',
+        help: "Specify the prefix of the API, i.e. <host>/<apiPrefix>/<API queries>"
+    });
+    parser.add_argument('--defaultPort', {
+        default: DefaultServerConfig.defaultPort,
+        metavar: 'PORT',
+        type: 'int',
+        help: "Specify the port the server is running on"
+    });
+    parser.add_argument('--shutdownTimeoutMinutes', {
+        default: DefaultServerConfig.shutdownTimeoutMinutes,
+        metavar: 'TIME',
+        type: 'int',
+        help: "0 for off, server will shut down after this amount of minutes."
+    });
+    parser.add_argument('--shutdownTimeoutVarianceMinutes', {
+        default: DefaultServerConfig.shutdownTimeoutVarianceMinutes,
+        metavar: 'VARIANCE',
+        type: 'int',
+        help: "modifies the shutdown timer by +/- timeoutVarianceMinutes (to avoid multiple instances shutting at the same time)"
+    });
+    parser.add_argument('--idMap', {
+        nargs: 2,
+        action: 'append',
+        metavar: ['TYPE', 'PATH'],
+        help: [
+            'Map `id`s for a `type` to a file path.',
+            'Example: x-ray \'../../data/mdb/xray/${id}-ccp4.mdb\'',
+            '',
+            '  - JS expressions can be used inside ${}, e.g. \'${id.substr(1, 2)}/${id}.mdb\'',
+            '  - Can be specified multiple times.',
+            '  - The `TYPE` variable (e.g. `x-ray`) is arbitrary and depends on how you plan to use the server.',
+            '    By default, Mol* Viewer uses `x-ray` and `em`, but any particular use case may vary. '
+        ].join('\n'),
+    });
+}
+function addJsonConfigArgs(parser) {
+    parser.add_argument('--cfg', {
+        help: [
+            'JSON config file path',
+            'If a property is not specified, cmd line param/OS variable/default value are used.'
+        ].join('\n'),
+        required: false,
+    });
+    parser.add_argument('--printCfg', { help: 'Print current config for validation and exit.', required: false, action: 'store_true' });
+    parser.add_argument('--cfgTemplate', { help: 'Prints default JSON config template to be modified and exits.', required: false, action: 'store_true' });
+}
+exports.ServerConfig = (0, tslib_1.__assign)({}, DefaultServerConfig);
+function setServerConfig(config) {
+    for (var _i = 0, _a = (0, type_helpers_1.ObjectKeys)(exports.ServerConfig); _i < _a.length; _i++) {
+        var k = _a[_i];
+        if (config[k] !== void 0)
+            exports.ServerConfig[k] = config[k];
+    }
+}
+function validateServerConfig() {
+    if (!exports.ServerConfig.idMap || exports.ServerConfig.idMap.length === 0) {
+        throw new Error("Please provide 'idMap' configuration. See [-h] for available options.");
+    }
+}
+var DefaultLimitsConfig = {
+    maxRequestBlockCount: 32,
+    maxFractionalBoxVolume: 1024,
+    maxOutputSizeInVoxelCountByPrecisionLevel: [
+        0.5 * 1024 * 1024,
+        1 * 1024 * 1024,
+        2 * 1024 * 1024,
+        4 * 1024 * 1024,
+        8 * 1024 * 1024,
+        16 * 1024 * 1024,
+        24 * 1024 * 1024
+    ]
+};
+exports.LimitsConfig = (0, tslib_1.__assign)({}, DefaultLimitsConfig);
+function setLimitsConfig(config) {
+    for (var _i = 0, _a = (0, type_helpers_1.ObjectKeys)(exports.LimitsConfig); _i < _a.length; _i++) {
+        var k = _a[_i];
+        if (config[k] !== void 0)
+            exports.LimitsConfig[k] = config[k];
+    }
+}
+function setConfig(config) {
+    setServerConfig(config);
+    setLimitsConfig(config);
+}
+var ServerConfigTemplate = (0, tslib_1.__assign)((0, tslib_1.__assign)((0, tslib_1.__assign)({}, DefaultServerConfig), { idMap: [
+        ['x-ray', './path-to-xray-data/${id.substr(1, 2)}/${id}.mdb'],
+        ['em', './path-to-em-data/emd-${id}.mdb']
+    ] }), DefaultLimitsConfig);
+function configureServer() {
+    var parser = new argparse.ArgumentParser({
+        // version: VOLUME_SERVER_VERSION,
+        add_help: true,
+        description: version_1.VOLUME_SERVER_HEADER
+    });
+    addJsonConfigArgs(parser);
+    addServerArgs(parser);
+    addLimitsArgs(parser);
+    var config = parser.parse_args();
+    if (!!config.cfgTemplate) {
+        console.log(JSON.stringify(ServerConfigTemplate, null, 2));
+        process.exit(0);
+    }
+    try {
+        setConfig(config); // sets the config for global use
+        if (config.cfg) {
+            var cfg = JSON.parse(fs.readFileSync(config.cfg, 'utf8'));
+            setConfig(cfg);
+        }
+        if (config.printCfg) {
+            console.log(JSON.stringify((0, tslib_1.__assign)((0, tslib_1.__assign)({}, exports.ServerConfig), exports.LimitsConfig), null, 2));
+            process.exit(0);
+        }
+        validateServerConfig();
+    }
+    catch (e) {
+        console.error('' + e);
+        process.exit(1);
+    }
+}
+exports.configureServer = configureServer;
+function configureLocal() {
+    var parser = new argparse.ArgumentParser({
+        // version: VOLUME_SERVER_VERSION,
+        add_help: true,
+        description: version_1.VOLUME_SERVER_HEADER
+    });
+    parser.add_argument('--jobs', { help: "Path to a JSON file with job specification.", required: false });
+    parser.add_argument('--jobsTemplate', { help: 'Print example template for jobs.json and exit.', required: false, action: 'store_true' });
+    addJsonConfigArgs(parser);
+    addLimitsArgs(parser);
+    var config = parser.parse_args();
+    if (config.cfgTemplate) {
+        console.log(JSON.stringify(DefaultLimitsConfig, null, 2));
+        process.exit(0);
+    }
+    try {
+        setLimitsConfig(config); // sets the config for global use
+        if (config.cfg) {
+            var cfg = JSON.parse(fs.readFileSync(config.cfg, 'utf8'));
+            setLimitsConfig(cfg);
+        }
+        if (config.printCfg) {
+            console.log(JSON.stringify(exports.LimitsConfig, null, 2));
+            process.exit(0);
+        }
+        return config;
+    }
+    catch (e) {
+        console.error('' + e);
+        process.exit(1);
+    }
+}
+exports.configureLocal = configureLocal;
+//# sourceMappingURL=config.js.map

package/lib/commonjs/servers/volume/pack/data-model.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.samplingBlockCount = exports.createHeader = void 0;
+var FORMAT_VERSION = '1.0.0';
+function createHeader(ctx) {
+    var header = ctx.channels[0].data.header;
+    var grid = header.grid;
+    function normalize(data) {
+        return [data[0] / grid[0], data[1] / grid[1], data[2] / grid[2]];
+    }
+    return {
+        formatVersion: FORMAT_VERSION,
+        valueType: header.valueType,
+        blockSize: ctx.blockSize,
+        axisOrder: header.axisOrder,
+        origin: normalize(header.origin),
+        dimensions: normalize(header.extent),
+        spacegroup: { number: header.spacegroupNumber, size: header.cellSize, angles: header.cellAngles, isPeriodic: ctx.isPeriodic },
+        channels: ctx.channels.map(function (c) { return c.data.header.name; }),
+        sampling: ctx.sampling.map(function (s) {
+            var N = s.sampleCount[0] * s.sampleCount[1] * s.sampleCount[2];
+            var valuesInfo = [];
+            for (var _i = 0, _a = s.valuesInfo; _i < _a.length; _i++) {
+                var _b = _a[_i], sum = _b.sum, sqSum = _b.sqSum, min = _b.min, max = _b.max;
+                var mean = sum / N;
+                var sigma = Math.sqrt(Math.max(0, sqSum / N - mean * mean));
+                valuesInfo.push({ mean: mean, sigma: sigma, min: min, max: max });
+            }
+            return {
+                byteOffset: s.byteOffset,
+                rate: s.rate,
+                valuesInfo: valuesInfo,
+                sampleCount: s.sampleCount,
+            };
+        })
+    };
+}
+exports.createHeader = createHeader;
+function samplingBlockCount(sampling, blockSize) {
+    return sampling.sampleCount.map(function (c) { return Math.ceil(c / blockSize); }).reduce(function (c, v) { return c * v; }, 1);
+}
+exports.samplingBlockCount = samplingBlockCount;
+//# sourceMappingURL=data-model.js.map

package/lib/commonjs/servers/volume/pack/downsampling.js

@@ -0,0 +1,168 @@
+"use strict";
+/**
+ * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * Taken/adapted from DensityServer (https://github.com/dsehnal/DensityServer)
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.finalize = exports.downsampleLayer = void 0;
+/**
+ * Downsamples each slice of input data and checks if there is enough data to perform
+ * higher rate downsampling.
+ */
+function downsampleLayer(ctx) {
+    for (var i = 0, _ii = ctx.sampling.length - 1; i < _ii; i++) {
+        var s = ctx.sampling[i];
+        downsampleSlice(ctx, s);
+        if (canDownsampleBuffer(s, false)) {
+            downsampleBuffer(ctx.kernel, s, ctx.sampling[i + 1], ctx.blockSize);
+        }
+        else {
+            break;
+        }
+    }
+}
+exports.downsampleLayer = downsampleLayer;
+/**
+ * When the "native" (rate = 1) sampling is finished, there might still
+ * be some data left to be processed for the higher rate samplings.
+ */
+function finalize(ctx) {
+    for (var i = 0, _ii = ctx.sampling.length - 1; i < _ii; i++) {
+        var s = ctx.sampling[i];
+        // skip downsampling the 1st slice because that is guaranteed to be done in "downsampleLayer"
+        if (i > 0)
+            downsampleSlice(ctx, s);
+        // this is different from downsample layer in that it does not need 2 extra slices but just 1 is enough.
+        if (canDownsampleBuffer(s, true)) {
+            downsampleBuffer(ctx.kernel, s, ctx.sampling[i + 1], ctx.blockSize);
+        }
+        else {
+            break;
+        }
+    }
+}
+exports.finalize = finalize;
+/**
+ * The functions downsampleH and downsampleHK both essentially do the
+ * same thing: downsample along H (1st axis in axis order) and K (2nd axis in axis order) axes respectively.
+ *
+ * The reason there are two copies of almost the same code is performance:
+ * Both functions use a different memory layout to improve cache coherency
+ *  - downsampleU uses the H axis as the fastest moving one
+ *  - downsampleUV uses the K axis as the fastest moving one
+ */
+function conv(w, c, src, b, i0, i1, i2, i3, i4) {
+    return w * (c[0] * src[b + i0] + c[1] * src[b + i1] + c[2] * src[b + i2] + c[3] * src[b + i3] + c[4] * src[b + i4]);
+}
+/**
+ * Map from L-th slice in src to an array of dimensions (srcDims[1], (srcDims[0] / 2), 1),
+ * flipping the 1st and 2nd axis in the process to optimize cache coherency for downsampleUV call
+ * (i.e. use (K, H, L) axis order).
+ */
+function downsampleH(kernel, srcDims, src, srcLOffset, buffer) {
+    var target = buffer.downsampleH;
+    var sizeH = srcDims[0], sizeK = srcDims[1], srcBaseOffset = srcLOffset * sizeH * sizeK;
+    var targetH = Math.floor((sizeH + 1) / 2);
+    var isEven = sizeH % 2 === 0;
+    var w = 1.0 / kernel.coefficientSum;
+    var c = kernel.coefficients;
+    for (var k = 0; k < sizeK; k++) {
+        var srcOffset = srcBaseOffset + k * sizeH;
+        var targetOffset = k;
+        target[targetOffset] = conv(w, c, src, srcOffset, 0, 0, 0, 1, 2);
+        for (var h = 1; h < targetH - 1; h++) {
+            srcOffset += 2;
+            targetOffset += sizeK;
+            target[targetOffset] = conv(w, c, src, srcOffset, -2, -1, 0, 1, 2);
+        }
+        srcOffset += 2;
+        targetOffset += sizeK;
+        if (isEven)
+            target[targetOffset] = conv(w, c, src, srcOffset, -2, -1, 0, 1, 1);
+        else
+            target[targetOffset] = conv(w, c, src, srcOffset, -2, -1, 0, 0, 0);
+    }
+}
+/**
+ * Downsample first axis in the slice present in buffer.downsampleH
+ * The result is written into the "cyclical" downsampleHk buffer
+ * in the (L, H, K) axis order.
+ */
+function downsampleHK(kernel, dimsX, buffer) {
+    var src = buffer.downsampleH, target = buffer.downsampleHK, slicesWritten = buffer.slicesWritten;
+    var kernelSize = kernel.size;
+    var sizeH = dimsX[0], sizeK = dimsX[1];
+    var targetH = Math.floor((sizeH + 1) / 2);
+    var isEven = sizeH % 2 === 0;
+    var targetSliceSize = kernelSize * sizeK;
+    var targetBaseOffset = slicesWritten % kernelSize;
+    var w = 1.0 / kernel.coefficientSum;
+    var c = kernel.coefficients;
+    for (var k = 0; k < sizeK; k++) {
+        var sourceOffset = k * sizeH;
+        var targetOffset = targetBaseOffset + k * kernelSize;
+        target[targetOffset] = conv(w, c, src, sourceOffset, 0, 0, 0, 1, 2);
+        for (var h = 1; h < targetH - 1; h++) {
+            sourceOffset += 2;
+            targetOffset += targetSliceSize;
+            target[targetOffset] = conv(w, c, src, sourceOffset, -2, -1, 0, 1, 2);
+        }
+        sourceOffset += 2;
+        targetOffset += targetSliceSize;
+        if (isEven)
+            target[targetOffset] = conv(w, c, src, sourceOffset, -2, -1, 0, 1, 1);
+        else
+            target[targetOffset] = conv(w, c, src, sourceOffset, -2, -1, 0, 0, 0);
+    }
+    buffer.slicesWritten++;
+}
+/** Calls downsampleH and downsampleHk for each input channel separately. */
+function downsampleSlice(ctx, sampling) {
+    var dimsU = [sampling.sampleCount[1], Math.floor((sampling.sampleCount[0] + 1) / 2)];
+    for (var i = 0, _ii = sampling.blocks.values.length; i < _ii; i++) {
+        downsampleH(ctx.kernel, sampling.sampleCount, sampling.blocks.values[i], sampling.blocks.slicesWritten - 1, sampling.downsampling[i]);
+        downsampleHK(ctx.kernel, dimsU, sampling.downsampling[i]);
+    }
+}
+/** Determine if a buffer has enough data to be downsampled */
+function canDownsampleBuffer(source, finishing) {
+    var buffer = source.downsampling[0];
+    var delta = buffer.slicesWritten - buffer.startSliceIndex;
+    return (finishing && delta > 0) || (delta > 2 && (delta - 3) % 2 === 0);
+}
+/** Downsample data in the buffer */
+function downsampleBuffer(kernel, source, target, blockSize) {
+    var downsampling = source.downsampling;
+    var _a = downsampling[0], slicesWritten = _a.slicesWritten, startSliceIndex = _a.startSliceIndex;
+    var sizeH = target.sampleCount[0], sizeK = target.sampleCount[1], sizeHK = sizeH * sizeK;
+    var kernelSize = kernel.size;
+    var w = 1.0 / kernel.coefficientSum;
+    var c = kernel.coefficients;
+    // Indices to the 1st dimeninsion in the cyclic buffer.
+    var i0 = Math.max(0, startSliceIndex - 2) % kernelSize;
+    var i1 = Math.max(0, startSliceIndex - 1) % kernelSize;
+    var i2 = startSliceIndex % kernelSize;
+    var i3 = Math.min(slicesWritten, startSliceIndex + 1) % kernelSize;
+    var i4 = Math.min(slicesWritten, startSliceIndex + 2) % kernelSize;
+    var channelCount = downsampling.length;
+    var valuesBaseOffset = target.blocks.slicesWritten * sizeHK;
+    for (var channelIndex = 0; channelIndex < channelCount; channelIndex++) {
+        var src = downsampling[channelIndex].downsampleHK;
+        var values = target.blocks.values[channelIndex];
+        for (var k = 0; k < sizeK; k++) {
+            var valuesOffset = valuesBaseOffset + k * sizeH;
+            for (var h = 0; h < sizeH; h++) {
+                var sO = kernelSize * h + kernelSize * k * sizeH;
+                var s = conv(w, c, src, sO, i0, i1, i2, i3, i4);
+                values[valuesOffset + h] = s;
+            }
+        }
+        // we have "consume" two layers of the buffer.
+        downsampling[channelIndex].startSliceIndex += 2;
+    }
+    target.blocks.slicesWritten++;
+}
+//# sourceMappingURL=downsampling.js.map