@pirireis/webglobeplugins 0.9.9 → 0.9.10

package/util/gl-util/uniform-block/manager.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniformBlockManager = void 0;
+require("./types");
+const typeSizes = {
+    'float': 4,
+    'vec2': 8,
+    'vec3': 16, // vec3 takes up same space as vec4 due to alignment
+    'vec4': 16,
+    'mat2': 32, // 2 vec4s (16 * 2)
+    'mat3': 48, // 3 vec4s (16 * 3)
+    'mat4': 64, // 4 vec4s (16 * 4)
+    'int': 4,
+    'ivec2': 8,
+    'ivec3': 16,
+    'ivec4': 16,
+    'bool': 4
+};
+const typeAlignments = {
+    'float': 4,
+    'vec2': 8,
+    'vec3': 16,
+    'vec4': 16,
+    'mat2': 16, // aligns to vec4 boundary
+    'mat3': 16, // aligns to vec4 boundary
+    'mat4': 16, // aligns to vec4 boundary
+    'int': 4,
+    'ivec2': 8,
+    'ivec3': 16,
+    'ivec4': 16,
+    'bool': 4
+};
+const typeArrayConstructors = {
+    'float': Float32Array,
+    'vec2': Float32Array,
+    'vec3': Float32Array,
+    'vec4': Float32Array,
+    'mat2': Float32Array,
+    'mat3': Float32Array,
+    'mat4': Float32Array,
+    'int': Int32Array,
+    'ivec2': Int32Array,
+    'ivec3': Int32Array,
+    'ivec4': Int32Array,
+    'bool': Float32Array
+};
+class UniformBlockManager {
+    constructor(blockName, blockMembers, bindingPoint, prefix = "") {
+        this.blockName = blockName;
+        this.blockMembers = blockMembers;
+        this.bindingPoint = bindingPoint;
+        this.prefix = prefix;
+        this.offsetMap = this.__create_LayoutSTD140_OffsetMap();
+        this.size = this.__calculateSize();
+    }
+    glslCode() {
+        let code = `layout(std140) uniform ${this.blockName} {`;
+        for (const member of this.blockMembers) {
+            const { name, type } = member;
+            code += `${type} ${this.prefix}${name};`;
+        }
+        if (this.prefix) {
+            code += `} ${this.prefix};`;
+        }
+        else {
+            code += `};`;
+        }
+        return code;
+    }
+    createUBO(gl, bufferWriteType = "STATIC_DRAW") {
+        const ubo = gl.createBuffer();
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        // @ts-ignore
+        gl.bufferData(gl.UNIFORM_BUFFER, this.size, gl[bufferWriteType]);
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, 0, ubo);
+        for (const member of this.blockMembers) {
+            const { name, type, value = null } = member;
+            ;
+            const offset = this.offsetMap.get(name);
+            const data = (value === null) ? new typeArrayConstructors[type](typeSizes[type] / 4).fill(NaN) : value;
+            gl.bufferSubData(gl.UNIFORM_BUFFER, offset, data);
+        }
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+        return {
+            ubo,
+            update: (nameValueMap) => this.updateUBO(gl, ubo, nameValueMap),
+            bind: () => this.bind(gl, ubo),
+            unbind: () => this.unbind(gl),
+            free: () => gl.deleteBuffer(ubo),
+        };
+    }
+    updateUBO(gl, ubo, nameValueMap) {
+        gl.bindBuffer(gl.UNIFORM_BUFFER, ubo);
+        for (const [name, value] of nameValueMap.entries()) {
+            const offset = this.offsetMap.get(name);
+            if (offset === undefined) {
+                throw new Error(`Uniform block member ${name} not found in offset map.`);
+            }
+            // @ts-ignore
+            const type = this.blockMembers.find(member => member.name === name).type;
+            let data;
+            if (Array.isArray(value)) {
+                data = new typeArrayConstructors[type](value);
+            }
+            else if (typeof value === 'number') {
+                data = new typeArrayConstructors[type]([value]);
+            }
+            else if (value instanceof ArrayBuffer) {
+                data = new typeArrayConstructors[type](value);
+            }
+            else if (ArrayBuffer.isView(value) && !(value instanceof DataView))
+                data = (typeof value === 'number') ? new typeArrayConstructors[type]([value]) : new typeArrayConstructors[type](value);
+            else {
+                throw new Error(`Unsupported value type for ${name}: ${typeof value}`);
+            }
+            console.log("Data to be uploaded:", data);
+            gl.bufferSubData(gl.UNIFORM_BUFFER, offset, data);
+        }
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    }
+    // call this after linking the program
+    assignBindingPoint(gl, program) {
+        const blockIndex = gl.getUniformBlockIndex(program, this.blockName);
+        gl.uniformBlockBinding(program, blockIndex, this.bindingPoint);
+    }
+    // call this before drawing
+    bind(gl, ubo) {
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, this.bindingPoint, ubo);
+    }
+    // call this right after drawing
+    unbind(gl) {
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, this.bindingPoint, null);
+    }
+    // implicit methods
+    __create_LayoutSTD140_OffsetMap() {
+        let offset = 0;
+        const offsetMap = new Map();
+        for (const member of this.blockMembers) {
+            const { name, type } = member;
+            const size = typeSizes[type];
+            const alignment = typeAlignments[type];
+            const padding = (alignment - (offset % alignment)) % alignment;
+            offset += padding;
+            offsetMap.set(name, offset);
+            offset += size;
+        }
+        return offsetMap;
+    }
+    // __create_LayoutSTD140_OffsetMap() should be called before this
+    __calculateSize() {
+        const lastOffset = Array.from(this.offsetMap.values()).pop() || 0;
+        const lastItemAlignment = typeAlignments[this.blockMembers[this.blockMembers.length - 1].type];
+        return lastOffset + lastItemAlignment;
+    }
+}
+exports.UniformBlockManager = UniformBlockManager;

package/util/gl-util/uniform-block/shader.js

@@ -0,0 +1 @@
+"use strict";

package/util/gl-util/uniform-block/types.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * @typedef {string} UniformBlockName
+ *
+ * @typedef {string} GLSLType | mat4, mat3, vec4, vec3, vec2, float, int, bool
+ * @typedef {{name: string, type: GLSLType, value: null|Float32Array}} UniformBlockMember
+ *
+ */

package/util/heatwavedatamanager/datamanager.js

@@ -0,0 +1,152 @@
+"use strict";
+/**
+ * todo:
+ * data must be processed before being set to the cache
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+class DataManager {
+    /**
+     *
+     * @param {Array<number>} timeEpocs | array of time epocs
+     * @param {Function} fetchMethod | fetchMethod(time) => Promise<data>
+     * @param {boolean} autoDownload | auto download data or not
+    */
+    constructor(timeEpocs, fetchMethod, { autoDownload = true } = {}) {
+        this._timeEpocs = timeEpocs.sort((a, b) => a - b);
+        this._datas = [];
+        this._datas.length = timeEpocs.length;
+        // in construction
+        this._dataPromises = [];
+        this._dataPromises.length = timeEpocs.length;
+        this._fetchMethod = fetchMethod;
+        this._callbackmethods = [];
+        this._callbackmethodOwners = [];
+        this._lastTime = -1;
+        this._lastIndex = -1;
+        this.autoDownload(autoDownload);
+    }
+    autoDownload(bool, time) {
+        if (!bool) {
+            this._autoDownload = false;
+            return;
+        }
+        let index = this._lastIndex === -1 ? 0 : this._lastIndex;
+        if (time !== undefined) {
+            if (time < this._timeEpocs[0] || time > this._timeEpocs[this._timeEpocs.length - 1]) {
+                this._autoDownload = bool;
+                return;
+            }
+            index = this._findIndex(time);
+        }
+        if (this._downloadStartIndex === index && this._autoDownload === bool)
+            return;
+        this._downloadStartIndex = index;
+        this._autoDownload = bool;
+        const recursion = (startId, currentDownloadId) => {
+            if (startId !== this._downloadStartIndex)
+                return;
+            if (currentDownloadId < this._timeEpocs.length && this._autoDownload) {
+                this._getData(currentDownloadId).then(() => {
+                    recursion(startId, currentDownloadId + 1);
+                });
+            }
+        };
+        recursion(index, index);
+        // save index as start index
+        //start recursive download
+        // use started id as a flag to stop the download
+    }
+    /**
+     * @param {number} time
+     * It looks like async function is not needed here. changes just overwrites the previous changes.
+     */
+    updateTime(time) {
+        if (time < this._timeEpocs[0] || time > this._timeEpocs[this._timeEpocs.length - 1]) {
+            this._dontRender();
+            return;
+        }
+        this._lastTime = time;
+        const index = this._findIndex(time);
+        const ratio = this._getRatio(time, index);
+        Promise.all([this._getData(index - 1), this._getData(index)]).then((datas) => {
+            if (this._lastTime === time) {
+                this._lastIndex = index;
+                this._ratio = ratio;
+                this._pushCallback(ratio, datas);
+            }
+        });
+    }
+    register(key, callback) {
+        if (this._callbackmethodOwners.indexOf(key) !== -1) {
+            console.warn("key already registered, old one is unregistered");
+            this.unregister(key);
+        }
+        this._callbackmethods.push(callback);
+        this._callbackmethodOwners.push(key);
+        if (this._lastIndex !== -1)
+            callback(this._ratio, this._datas[this._lastIndex - 1], this._datas[this._lastIndex]);
+    }
+    /**
+     * @param {*} key | id of the owner of the callback
+     */
+    unregister(key) {
+        let index = this._callbackmethodOwners.indexOf(key);
+        if (index !== -1) {
+            this._callbackmethods.splice(index, 1);
+            this._callbackmethodOwners.splice(index, 1);
+        }
+        if (this._callbackmethods.length === 0) {
+            this.free();
+        }
+    }
+    free() {
+        this._callbackmethods = [];
+        this._callbackmethodOwners = [];
+        this._autoDownload = false;
+    }
+    _findIndex(time) {
+        const { _timeEpocs } = this;
+        let index = this._lastIndex === -1 ? 1 : this._lastIndex;
+        if (this)
+            if (time < _timeEpocs[index - 1]) {
+                while (index > 1 && time < _timeEpocs[index - 1]) {
+                    index--;
+                }
+            }
+            else if (time > _timeEpocs[index]) {
+                while (index < _timeEpocs.length - 1 && time > _timeEpocs[index]) {
+                    index++;
+                }
+            }
+        return index;
+    }
+    _getRatio(time, index) {
+        return (time - this._timeEpocs[index - 1]) / (this._timeEpocs[index] - this._timeEpocs[index - 1]);
+    }
+    _pushCallback(ratio, datas) {
+        for (let i = 0; i < this._callbackmethods.length; i++) {
+            this._callbackmethods[i](ratio, ...datas);
+        }
+    }
+    async _getData(index) {
+        if (index < 0 || index >= this._timeEpocs.length) {
+            throw new Error("Index out of range");
+        }
+        if (!this._datas[index]) {
+            if (!this._dataPromises[index])
+                this._dataPromises[index] = this._fetchMethod(this._timeEpocs[index]).then((data) => {
+                    this._datas[index] = data;
+                }, (error) => {
+                    console.error("error", error);
+                }).finally(() => {
+                    this._dataPromises[index] = null;
+                });
+        }
+        await this._dataPromises[index];
+        return this._datas[index];
+    }
+    _dontRender() {
+        this._pushCallback(0, [null, null]);
+    }
+}
+exports.default = DataManager;

package/util/heatwavedatamanager/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PointCoordinatesDataCalculator = exports.HeatWaveDataManager = void 0;
+const pointcoordinatesdatacalculator_1 = __importDefault(require("./pointcoordinatesdatacalculator"));
+exports.PointCoordinatesDataCalculator = pointcoordinatesdatacalculator_1.default;
+const datamanager_1 = __importDefault(require("./datamanager"));
+exports.HeatWaveDataManager = datamanager_1.default;

package/util/heatwavedatamanager/pointcoordinatesdatacalculator.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pointcoordsmeta_1 = __importDefault(require("./pointcoordsmeta"));
+const pointObject = (long, lat, posIndex, callback) => {
+    return { long, lat, posIndex, callback };
+};
+class PointCoordinatesDataCalculator {
+    constructor(bbox, width, height) {
+        this._pointObjects = {};
+        this._ratio = 0.0;
+        this._bbox = bbox;
+        this._width = width;
+        this._height = height;
+        this._metaCalculater = new pointcoordsmeta_1.default(bbox, width, height);
+        this._texture0 = null;
+        this._texture1 = null;
+    }
+    /**
+     *
+     * @param {*} key
+     * @param {*} lat
+     * @param {*} long
+     * @param {*} callback | callback(data0, data1, interpolated)
+     */
+    registerPoint(key, long, lat, callback) {
+        if (key in this._pointObjects) {
+            console.warn("key already registered, old one is unregistered");
+            this.unregisterPoint(key);
+        }
+        if (!this._isInBBox(long, lat))
+            return false;
+        const meta = this._metaCalculater.getFlooredMeta(long, lat);
+        this._pointObjects[key] = pointObject(long, lat, meta.index, callback);
+        if (this._texture0 && this._texture1) {
+            const { data0, data1, interpolated } = this._findAPoint(meta.index);
+            callback(data0, data1, interpolated);
+        }
+        return true;
+    }
+    _isInBBox(long, lat) {
+        return lat >= this._bbox[1] && lat <= this._bbox[3] && long >= this._bbox[0] && long <= this._bbox[2];
+    }
+    unregisterPoint(key) {
+        if (!(key in this._pointObjects))
+            return false;
+        delete this._pointObjects[key];
+        return true;
+    }
+    updatePoint(key, long, lat) {
+        if (!(key in this._pointObjects))
+            return false;
+        if (!this._isInBBox(long, lat))
+            return false;
+        this._pointObjects[key].long = long;
+        this._pointObjects[key].lat = lat;
+        const meta = this._metaCalculater.getFlooredMeta(long, lat);
+        this._pointObjects[key].posIndex = meta.index;
+        const { data0, data1, interpolated } = this._findAPoint(meta.index);
+        this._pointObjects[key].callback(data0, data1, interpolated);
+        return true;
+    }
+    /**
+     * @param {Number} ratio 0-1
+     * @param {} textureData0
+     * @param {*} textureData1
+     */
+    updateData(ratio, textureData0 = null, textureData1 = null) {
+        if (!textureData0 && !textureData1) {
+            this._pushPointCallBackEmpty();
+            return;
+        }
+        if (textureData0 && textureData1) {
+            this._texture0 = textureData0;
+            this._texture1 = textureData1;
+        }
+        this._ratio = ratio;
+        this._pushPointCallbackAll();
+    }
+    _findAPoint(posIndex) {
+        const data0 = this._texture0[posIndex];
+        const data1 = this._texture1[posIndex];
+        const interpolated = data0 * (1 - this._ratio) + data1 * this._ratio;
+        return { data0, data1, interpolated };
+    }
+    _pushPointCallbackAll() {
+        for (const key in this._pointObjects) {
+            const { posIndex, callback } = this._pointObjects[key];
+            const { data0, data1, interpolated } = this._findAPoint(posIndex);
+            callback(data0, data1, interpolated);
+        }
+    }
+    _pushPointCallBackEmpty() {
+        for (const key in this._pointObjects) {
+            const { callback } = this._pointObjects[key];
+            callback(null, null, null);
+        }
+    }
+    flush() {
+        this._pointObjects = {};
+    }
+}
+exports.default = PointCoordinatesDataCalculator;
+// function test() {
+//     const cp = window.plugin.getPointCoordinatesDataCalculator();
+//     const bbox = [-15, 25, 70, 60];
+//     cp.registerPoint("left up", -15, 60, (data0, data1, interpolated) => {
+//         console.log("left up", data0, data1, interpolated);
+//     });
+//     cp.registerPoint("right up", 70, 60, (data0, data1, interpolated) => {
+//         console.log("right up", data0, data1, interpolated);
+//     });
+//     cp.registerPoint("left down", -15, 25, (data0, data1, interpolated) => {
+//         console.log("right down", data0, data1, interpolated);
+//     });
+//     cp.registerPoint("right down", 70, 25, (data0, data1, interpolated) => {
+//         console.log("right down", data0, data1, interpolated);
+//     });
+//     return cp;
+// }

package/util/heatwavedatamanager/pointcoordsmeta.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class PointCoordsMeta {
+    constructor(bbox, width, height) {
+        this._bbox = bbox;
+        this._width = width;
+        this._height = height;
+        this._xRatio = this._width / (this._bbox[2] - this._bbox[0]);
+        this._yRatio = this._height / (this._bbox[3] - this._bbox[1]);
+    }
+    getFlooredMeta(long, lat) {
+        let x = (long - this._bbox[0]) * this._xRatio;
+        let y = (this._bbox[3] - lat) * this._yRatio;
+        x = x > 0 ? x - 1 : 0;
+        y = y > 0 ? y - 1 : 0;
+        const index = Math.floor(y) * this._width + Math.floor(x);
+        return { index };
+    }
+}
+exports.default = PointCoordsMeta;

package/util/index.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.heatwavedatamanager = exports.programs = exports.webglobe = exports.geometry = exports.shaderfunctions = exports.webglobjectbuilders = void 0;
+const webglobjectbuilders = __importStar(require("./webglobjectbuilders"));
+exports.webglobjectbuilders = webglobjectbuilders;
+const shaderfunctions = __importStar(require("./shaderfunctions"));
+exports.shaderfunctions = shaderfunctions;
+const geometry = __importStar(require("./geometry"));
+exports.geometry = geometry;
+const webglobe = __importStar(require("./webglobe"));
+exports.webglobe = webglobe;
+const programs = __importStar(require("./programs"));
+exports.programs = programs;
+const heatwavedatamanager = __importStar(require("./heatwavedatamanager"));
+exports.heatwavedatamanager = heatwavedatamanager;
+__exportStar(require("./webglobe"), exports);
+__exportStar(require("./webglobjectbuilders"), exports);
+__exportStar(require("./shaderfunctions"), exports);
+__exportStar(require("./geometry"), exports);
+__exportStar(require("./programs"), exports);
+__exportStar(require("./heatwavedatamanager"), exports);

package/util/interpolation/index.js

@@ -0,0 +1 @@
+"use strict";

package/util/interpolation/timetrack/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorker = void 0;
+const createWorker = () => new Worker(new URL('./web-worker.js', import.meta.url), { type: 'module' });
+exports.createWorker = createWorker;

package/util/interpolation/timetrack/timetrack-interpolator.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GEOMETRY = exports.TimeTrackInterpolator = void 0;
+const search_binary_1 = require("../../algorithms/search-binary");
+const methods_1 = require("../../../Math/methods");
+/**
+ * @typedef {Array<number>} vec3 [x, y, z]
+ * @typedef {Array<number>} vec2 [x, y]
+ * @typedef {Array<number>} vec4 [x, y, z, w]
+ * @typedef {number} fraction a number between 0 and 1
+ * @typedef {Array<number>} wgs84 [long, lat]
+ */
+const GEOMETRY = Object.freeze({
+    CARTESIAN3D: 0,
+    MERCATOR: 1,
+});
+exports.GEOMETRY = GEOMETRY;
+class TimeTrackInterpolator {
+    /**
+     * @typedef Timetrack
+     * @property {Array<vec4>}} coordinates [x,y,z, length]
+     * @property {Array<Number>} times
+     * @param {Array<Timetrack>} timeTracks
+     */
+    constructor({ timeTracks, bbox = null, geometry = GEOMETRY.CARTESIAN3D } = {}) {
+        this.timeTracks = null;
+        this.timeTracksStartTimes = null;
+        this.geometry = geometry;
+        if (timeTracks)
+            this.setTimetracks(timeTracks);
+        if (bbox)
+            this.setBbox(bbox);
+    }
+    setGeometry(geometry) {
+        if (geometry !== GEOMETRY.CARTESIAN3D && geometry !== GEOMETRY.MERCATOR) {
+            throw new Error('Invalid geometry');
+        }
+        this.geometry = geometry;
+    }
+    setTimetracks(timeTracks) {
+        this.timeTracks = timeTracks;
+    }
+    interpolate(time) {
+        const { timeTracks, geometry } = this;
+        if (!timeTracks) {
+            return null;
+        }
+        const resultArray = [];
+        const info = {
+            outOfRange: 0,
+            processed: 0,
+        };
+        for (let i = 0; i < timeTracks.length; i++) {
+            const { times, coordinates } = timeTracks[i];
+            if (times[times.length - 1] < time)
+                continue;
+            info.processed++;
+            const timeIndex = (0, search_binary_1.findFirstIndexInRange)(times, time);
+            if (timeIndex === null) {
+                info.outOfRange++;
+                continue;
+            }
+            const timeFraction = (time - times[timeIndex]) / (times[timeIndex + 1] - times[timeIndex]);
+            const interpolated = (geometry === GEOMETRY.CARTESIAN3D) ?
+                (0, methods_1.sphericalLinearInterpolation_Cartesian3d)(coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction) :
+                (0, methods_1.sphericalLinearInterpolation_Mercator)(coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction);
+            resultArray.push(...interpolated);
+        }
+        return new Float32Array(resultArray);
+    }
+    // implicit methods
+    _orderTimeTracks() {
+        this.timeTracks.sort((a, b) => a.times[0] - b.times[0]);
+    }
+    _setStartTimes() {
+        this.timeTracksStartTimes = this.timeTracks.map(tt => tt.times[0]);
+    }
+}
+exports.TimeTrackInterpolator = TimeTrackInterpolator;