@pirireis/webglobeplugins 0.10.10-alpha → 0.10.11-alpha

package/timetracks/programpoint.js

@@ -1,144 +0,0 @@
-import { createProgram, shaderfunctions } from "../util";
-import { CameraUniformBlockTotem, globeProgramCache } from "../programs";
-const vertexShader = `#version 300 es
-
-layout(std140) uniform GlobeCamera {
-    mat4 view; // 64 bytes           0
-    mat4 projection; // 64 bytes     64
-    vec3 translate; // 12 bytes      128
-    bool is3D; // 4 bytes            140
-    vec2 mapWH; // 8 bytes           144
-    vec2 screenWH; //  8 bytes       152
-    float z_level; // 4 bytes        160
-};
-
-layout(std140) uniform Globals {
-    float head_time;
-    float final_opacity;
-    float point_size;
-};
-
-in vec3 start_position;
-in float start_time;
-in vec3 start_color;
-in vec3 end_position;
-in float end_time;
-in vec3 end_color;
-out vec4 v_color;
-
-` + shaderfunctions.pixelXYToCartesian3DPoint + shaderfunctions.pixelXYToCartesian2DPoint + `
-
-void main() {
-    if (head_time < start_time || head_time > end_time) { return; }
-    float t = (head_time - start_time) / (end_time - start_time);
-    vec3 position = mix(start_position, end_position, t);
-    if (is3D){
-        vec3 pos = pixelXYToCartesian3DPoint(position);
-        gl_Position = projection * view * vec4(pos - translate, 1.0);
-    }  else {
-        vec2 xy = pixelXYToCartesian2DPoint(position.xy, translate.xy, mapWH, screenWH);
-        gl_Position = projection * vec4(xy.x, xy.y, 0.0, 1.0);
-    }
-    v_color = vec4(mix(start_color, end_color, t), final_opacity);
-    gl_PointSize = point_size;
-}`;
-const fragmentShader = `#version 300 es
-precision highp float;
-in vec4 v_color;
-out vec4 outColor;
-void main() {
-    outColor = v_color;
-}`;
-export default class {
-    constructor(gl, globe, attrBuffer, options) {
-        this.gl = gl;
-        this._cameraBlockBindingPoint = 0;
-        this._globalsBlockBindingPoint = 1;
-        this.cameraUniformBlockTotem = globeProgramCache.getProgram(globe, CameraUniformBlockTotem);
-        this._vao = gl.createVertexArray();
-        this._attbuffer = attrBuffer;
-        this.program = this._createProgram();
-        this._drawCount = 0;
-        this._globalsbuffer = gl.createBuffer();
-        {
-            const { gl, _globalsbuffer } = this;
-            gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
-            gl.bufferData(gl.UNIFORM_BUFFER, 12, gl.STREAM_DRAW);
-            gl.bufferSubData(gl.UNIFORM_BUFFER, 0, new Float32Array([0, options.opacity, options.pointSize]));
-            gl.bindBufferBase(gl.UNIFORM_BUFFER, this._globalsBlockBindingPoint, _globalsbuffer);
-            gl.bindBuffer(gl.UNIFORM_BUFFER, null);
-        }
-    }
-    _createProgram() {
-        const gl = this.gl;
-        const program = createProgram(gl, vertexShader, fragmentShader);
-        const ubo = this.cameraUniformBlockTotem.getUBO(); // ubo bl
-        const cameraBlockIndex = gl.getUniformBlockIndex(program, "GlobeCamera");
-        gl.uniformBlockBinding(program, cameraBlockIndex, this._cameraBlockBindingPoint);
-        const globalsBlockIndex = gl.getUniformBlockIndex(program, "Globals");
-        gl.bindBufferBase(gl.UNIFORM_BUFFER, this._cameraBlockBindingPoint, ubo);
-        gl.uniformBlockBinding(program, globalsBlockIndex, this._globalsBlockBindingPoint);
-        gl.bindBufferBase(gl.UNIFORM_BUFFER, this._globalsBlockBindingPoint, this._globalsbuffer);
-        // numaralarda yanlışlık olabilir
-        const start_position = gl.getAttribLocation(program, "start_position");
-        const start_time = gl.getAttribLocation(program, "start_time");
-        const start_color = gl.getAttribLocation(program, "start_color");
-        const end_position = gl.getAttribLocation(program, "end_position");
-        const end_time = gl.getAttribLocation(program, "end_time");
-        const end_color = gl.getAttribLocation(program, "end_color");
-        gl.bindVertexArray(this._vao);
-        gl.bindBuffer(gl.ARRAY_BUFFER, this._attbuffer);
-        gl.enableVertexAttribArray(start_position);
-        gl.vertexAttribPointer(start_position, 3, gl.FLOAT, false, 72, 0);
-        gl.enableVertexAttribArray(start_time);
-        gl.vertexAttribPointer(start_time, 1, gl.FLOAT, false, 72, 12);
-        gl.enableVertexAttribArray(start_color);
-        gl.vertexAttribPointer(start_color, 3, gl.FLOAT, false, 72, 16);
-        gl.enableVertexAttribArray(end_position);
-        gl.vertexAttribPointer(end_position, 3, gl.FLOAT, false, 72, 36);
-        gl.enableVertexAttribArray(end_time);
-        gl.vertexAttribPointer(end_time, 1, gl.FLOAT, false, 72, 48);
-        gl.enableVertexAttribArray(end_color);
-        gl.vertexAttribPointer(end_color, 3, gl.FLOAT, false, 72, 52);
-        gl.bindVertexArray(null);
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-        return program;
-    }
-    setOpacity(opacity) {
-        const { gl, _globalsbuffer } = this;
-        gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
-        gl.bufferSubData(gl.UNIFORM_BUFFER, 4, new Float32Array([opacity]));
-        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
-    }
-    setDrawCount(count) {
-        this._drawCount = count;
-    }
-    setPointSize(size) {
-        const { gl, _globalsbuffer } = this;
-        gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
-        gl.bufferSubData(gl.UNIFORM_BUFFER, 8, new Float32Array([size]));
-        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
-    }
-    setHeadTime(time) {
-        const { gl, _globalsbuffer } = this;
-        gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
-        gl.bufferSubData(gl.UNIFORM_BUFFER, 0, new Float32Array([time]));
-        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
-    }
-    draw() {
-        const { gl, program, _vao, _drawCount } = this;
-        gl.useProgram(program);
-        gl.bindVertexArray(_vao);
-        gl.disable(gl.DEPTH_TEST);
-        gl.drawArrays(gl.POINTS, 0, _drawCount);
-        gl.enable(gl.DEPTH_TEST);
-        gl.bindVertexArray(null);
-    }
-    free() {
-        const { gl, _vao, _globalsbuffer, program } = this;
-        gl.deleteVertexArray(_vao);
-        // gl.deleteBuffer(_attbuffer);
-        gl.deleteBuffer(_globalsbuffer);
-        gl.deleteProgram(program);
-    }
-}

package/util/heatwavedatamanager/pointcoordinatesdatacalculator1.js

@@ -1,116 +0,0 @@
-import PointCoordsMeta from "./pointcoordsmeta";
-const pointObject = (long, lat, posIndex, callback) => {
-    return { long, lat, posIndex, callback };
-};
-export default 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(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 index = this._metaCalculater.getFlooredIndex(long, lat);
-        this._pointObjects[key] = pointObject(long, lat, index, callback);
-        if (this._texture0 && this._texture1) {
-            const { data0, data1, interpolated } = this._findAPoint(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 index = this._metaCalculater.getFlooredIndex(long, lat);
-        this._pointObjects[key].posIndex = index;
-        const { data0, data1, interpolated } = this._findAPoint(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 = {};
-    }
-}
-// function test() {
-//     const cp = window.plugin.getTexturePointSampler();
-//     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/interpolation/timetrack/web-worker-str.js

@@ -1,180 +0,0 @@
-const webworkerStr = `
-
-const WORLD_RADIUS_3D = 6378.137;
-const WORLD_RADIUS_MERCATOR = 6378136.99911;
-
-const dot3 = (a, b) => {
-    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-}
-
-const sphericalLinearInterpolation_UnitVector = (normalizedA, normalizedB, ratio) => {
-    const theta = Math.acos(dot3(normalizedA, normalizedB));
-    if (theta < 0.000001) return normalizedA; // CALIBRATE?
-    const sinTheta = Math.sin(theta);
-    const result = [
-        (Math.sin((1.0 - ratio) * theta) * normalizedA[0] + Math.sin(ratio * theta) * normalizedB[0]) / sinTheta,
-        (Math.sin((1.0 - ratio) * theta) * normalizedA[1] + Math.sin(ratio * theta) * normalizedB[1]) / sinTheta,
-        (Math.sin((1.0 - ratio) * theta) * normalizedA[2] + Math.sin(ratio * theta) * normalizedB[2]) / sinTheta
-    ];
-    return result;
-}
-
-const radianToMercator = (xy) => {
-    return [WORLD_RADIUS_MERCATOR * xy[0], WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + xy[1] / 2))];
-}
-
-
-const cartesian3dToRadian = (cartesian) => {
-    const x = cartesian[0];
-    const y = cartesian[1];
-    const z = cartesian[2];
-    // const length = Math.sqrt(x * x + y * y + z * z);
-    const long = Math.atan2(y, x);
-    const lat = Math.asin(z)// length);
-    return [long, lat];
-}
-
-
-const sphericalLinearInterpolation_Mercator = (normalizedA, normalizedB, ratio) => {
-    const unitVector = sphericalLinearInterpolation_UnitVector(normalizedA, normalizedB, ratio);
-    const angles = cartesian3dToRadian(unitVector);
-    return radianToMercator(angles);
-}
-
-const sphericalLinearInterpolation_Cartesian3d = (a, b, ratio) => {
-    const unitVector = sphericalLinearInterpolation_UnitVector(a, b, ratio);
-    const height = a[3] + (b[3] - a[3]) * ratio;
-    return [unitVector[0] * height, unitVector[1] * height, unitVector[2] * height];
-}
-
-const findFirstIndexInRange = (container, value) => {
-    let start = 0;
-    let end = container.length - 1;
-    let mid = 0;
-    while (start <= end) {
-        mid = Math.floor((start + end) / 2);
-        if (container[mid] <= value && value <= container[mid + 1]) return mid;
-        if (container[mid] < value) start = mid + 1;
-        else end = mid - 1;
-    }
-    return null;
-}
-
-const GEOMETRY = Object.freeze({
-    CARTESIAN3D: 0,
-    MERCATOR: 1,
-});
-
-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 = findFirstIndexInRange(times, time);
-            if (timeIndex === null) { info.outOfRange++; continue; }
-            const timeFraction = (time - times[timeIndex]) / (times[timeIndex + 1] - times[timeIndex]);
-            const interpolated = (geometry === GEOMETRY.CARTESIAN3D) ?
-                sphericalLinearInterpolation_Cartesian3d(coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction) :
-                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]);
-    }
-}
-
-const interpolator = new TimeTrackInterpolator({ geometry: GEOMETRY.CARTESIAN3D });
-
-/* eslint-disable-next-line no-restricted-globals */
-self.onmessage = function (e) {
-
-    const { geometry = null, timeTracks = null, time = null } = e.data;
-
-    if (geometry !== null) {
-        try {
-            interpolator.setGeometry(geometry);
-        } catch (error) {
-            /* eslint-disable-next-line no-restricted-globals */
-            self.postMessage({ error: error.message });
-            return;
-        }
-    }
-
-    if (timeTracks !== null) {
-        try {
-            interpolator.setTimetracks(timeTracks);
-        } catch (error) {
-            /* eslint-disable-next-line no-restricted-globals */
-            self.postMessage({ error: error.message });
-            return;
-        }
-    }
-
-    if (time !== null) {
-        try {
-            const result = interpolator.interpolate(time);
-            if(result === null) {
-                /* eslint-disable-next-line no-restricted-globals */
-                self.postMessage({ error: 'No TimeTracks Data' });
-                return;
-            }
-            /* eslint-disable-next-line no-restricted-globals */
-            self.postMessage(result, [result.buffer]);
-            return;
-        } catch (error) {
-            /* eslint-disable-next-line no-restricted-globals */
-            self.postMessage({ error: error.message });
-            return;
-        }
-    }
-    /* eslint-disable-next-line no-restricted-globals */
-    self.postMessage(true);
-}
-    `;
-export { webworkerStr };