@pirireis/webglobeplugins 0.16.7 → 0.17.0

package/Math/tessellation/triangle-tessellation-meta.js

@@ -118,7 +118,7 @@ function showMeta(triangleMeta) {
  * @param angle
  * @param dimension false for longitude (meridian) true for latitude (parallel)
  */
-function getPoints(triangleMeta, angle, dimension) {
+export function getPoints(triangleMeta, angle, dimension) {
     // console.log("getPoints called with angle:", angle * 180 / Math.PI, "dimension:", dimension ? 'latitude' : 'longitude');
     // find which arcs are cut by plane
     const radians = angle;
@@ -147,12 +147,12 @@ function getPoints(triangleMeta, angle, dimension) {
         }
         const count = pointsOnArc(arc, _plane, _resultPoints);
         if (count === 1) {
-            result.push([..._resultPoints[0]]);
+            result.push([[..._resultPoints[0]], vec3ToLongLatRadians(_resultPoints[0])]);
         }
         else if (count === 2) {
             // throw new Error('Unexpected 2 cut points on arc, should be max 1'); // TODO DELETE this line later
-            result.push([..._resultPoints[0]]);
-            result.push([..._resultPoints[1]]); // TODO: this is a fix for a bug, need to investigate later
+            result.push([[..._resultPoints[0]], vec3ToLongLatRadians(_resultPoints[0])]);
+            result.push([[..._resultPoints[1]], vec3ToLongLatRadians(_resultPoints[1])]); // TODO: this is a fix for a bug, need to investigate later
         }
         resultsFromDistinctArcs += 1;
     }
@@ -168,7 +168,7 @@ function getPoints(triangleMeta, angle, dimension) {
             "bbox:" + triangleMeta.bbox.min[0] * 180 / Math.PI + ", " + triangleMeta.bbox.min[1] * 180 / Math.PI + ", " + triangleMeta.bbox.max[0] * 180 / Math.PI + ", " + triangleMeta.bbox.max[1] * 180 / Math.PI + "\n";
         showMeta(triangleMeta);
         for (let res of result) {
-            const ll = vec3ToLongLatRadians(res);
+            const ll = res[1];
             console.log("Point: " + ll[0] * 180 / Math.PI + ", " + ll[1] * 180 / Math.PI + "\n");
         }
         throw new Error(`Unexpected cut count for tile cut, got: ${result.length}, angle: ${angle * 180 / Math.PI}, dimension: ${dimension ? 'latitude' : 'longitude'} \n` + text);
@@ -179,10 +179,10 @@ function getPoints(triangleMeta, angle, dimension) {
     }
     result.sort((a, b) => {
         if (dimension) {
-            return a[1] - b[1]; // sort by y for longitude cuts
+            return a[0][1] - b[0][1]; // sort by y for longitude cuts
         }
         else {
-            return a[0] - b[0]; // sort by x for latitude cuts
+            return a[1][0] - b[1][0]; // sort by x for latitude cuts
         }
     });
     return result;
@@ -239,15 +239,13 @@ export function getAllPoints(triangleMeta, zoom, innerCuts = TILE_DEM_STEPCOUNT)
         for (let i = 0; i < concurances.length; i += 2) {
             const p0 = concurances[i];
             const p1 = concurances[i + 1];
-            points.push(...p0);
-            points.push(...p1);
-            const p0LongLat = vec3ToLongLatRadians(p0);
-            const p1LongLat = vec3ToLongLatRadians(p1);
-            longLatPoints.push(...p0LongLat);
-            longLatPoints.push(...p1LongLat);
-            fillBetweenInParallels(lat, p0LongLat, p1LongLat, lonLengthRadian, points, longLatPoints);
-            if (length(p0) < 0.99 || length(p1) < 0.99 || length(p0) > 1.01 || length(p1) > 1.01) {
-                console.warn("Warning: Cut point is not on unit sphere!", length(p0), length(p1));
+            points.push(...p0[0]);
+            longLatPoints.push(...p0[1]);
+            fillBetweenInParallels(lat, p0[1], p1[1], lonLengthRadian, points, longLatPoints);
+            points.push(...p1[0]);
+            longLatPoints.push(...p1[1]);
+            if (length(p0[0]) < 0.99 || length(p1[0]) < 0.99 || length(p0[0]) > 1.01 || length(p1[0]) > 1.01) {
+                console.warn("Warning: Cut point is not on unit sphere!", length(p0[0]), length(p1[0]));
             }
         }
         currentY -= latInnerStep;
@@ -258,15 +256,13 @@ export function getAllPoints(triangleMeta, zoom, innerCuts = TILE_DEM_STEPCOUNT)
         currentLong += lonLengthRadian; // since start point is already added
     while (currentLong < endMeridianRadian) {
         const [p0, p1] = getPoints(triangleMeta, currentLong, false);
-        const p0LongLat = vec3ToLongLatRadians(p0);
-        const p1LongLat = vec3ToLongLatRadians(p1);
-        if (!isOnTileEdge(p0LongLat, zoom)) {
-            points.push(...p0);
-            longLatPoints.push(...p0LongLat);
+        if (!isOnTileEdge(p0[1], zoom)) {
+            points.push(...p0[0]);
+            longLatPoints.push(...p0[1]);
         }
-        if (!isOnTileEdge(p1LongLat, zoom)) {
-            points.push(...p1);
-            longLatPoints.push(...p1LongLat);
+        if (!isOnTileEdge(p1[1], zoom)) {
+            points.push(...p1[0]);
+            longLatPoints.push(...p1[1]);
         }
         currentLong += lonLengthRadian;
     }
@@ -274,7 +270,7 @@ export function getAllPoints(triangleMeta, zoom, innerCuts = TILE_DEM_STEPCOUNT)
     let indices = delaunator.triangles;
     const edgeIndexes = shellPoints.map((e, index) => index * 2); // edge points are always first points in list
     indices = filteroutEdgeConnections(indices, edgeIndexes);
-    rotateIndices(indices);
+    // rotateIndices(indices);
     return { vec3s: new Float32Array(points), longLats: new Float32Array(longLatPoints), indices: indices };
 }
 function fillBetweenInParallels(lat, p1, p2, step, fillVec3Arr, longLatPoints) {
@@ -292,18 +288,18 @@ function fillBetweenInParallels(lat, p1, p2, step, fillVec3Arr, longLatPoints) {
         current += step;
     }
 }
-function filterDuplicate(vec3s) {
-    const result = [];
+function filterDuplicate(points) {
+    const result = [points[0]];
     let dublicate = false;
-    for (let i = 0; i < vec3s.length; i++) {
+    for (let i = 1; i < points.length; i++) {
         for (let j = 0; j < result.length; j++) {
-            if (equals(vec3s[i], result[j])) {
+            if (equals(points[i][0], result[j][0])) {
                 dublicate = true;
                 break;
             }
         }
         if (!dublicate) {
-            result.push(vec3s[i]);
+            result.push(points[i]);
         }
     }
     return result;
@@ -366,5 +362,155 @@ function shredTriangleTessellationMeta(triangleMeta, zoomLevel) {
  *
  * still all triangles should have some sort of cached tessellation to fast render on rapit earth rotation
  */
-// function partialTessellation(triangleMeta: TriangleTessellationMeta, limits: BBox[], zoomLevel: number, innerCuts: number): { vec3s: Float32Array, longLats: Float32Array, indices: Uint32Array } {
-// }
+/**
+ * Creates a mesh for a spherical triangle, tessellated only within the
+ * regions specified by the `limits` array.
+ *
+ * @param triangleMeta The metadata for the spherical triangle.
+ * @param limits An array of bounding boxes and their associated zoom levels to tessellate.
+ * @param innerCuts The number of subdivisions within each tile (e.g., TILE_DEM_STEPCOUNT).
+ * @returns A set of arrays (vec3s, longLats, indices) representing the partial mesh.
+ */
+export function partialTessellation(triangleMeta, limits, innerCuts) {
+    // TODO: pointMap can be local variable and cleaned after function call to avoid reinitialization overhead
+    const pointMap = new Map(); // Key: "lon|lat", Value: index
+    const allVec3s = [];
+    const allLongLats = [];
+    let pointCounter = 0;
+    /**
+     * Precision for coordinate keys in the map. 1e-12 radians is
+     * extremely small (sub-millimeter on Earth's surface) and avoids
+     * floating point inaccuracies causing duplicate points.
+     */
+    const KEY_PRECISION = 10;
+    /**
+     * Adds a point to the vertex arrays if it doesn't already exist.
+     * Returns the index of the point (new or existing).
+     */
+    const addPoint = (longLat, vec3) => {
+        const key = `${longLat[0].toPrecision(KEY_PRECISION)}|${longLat[1].toPrecision(KEY_PRECISION)}`;
+        let index = pointMap.get(key);
+        if (index !== undefined) {
+            return index; // Point already exists
+        }
+        // Point is new, add it
+        const v3 = vec3 || createUnitVectorFromLongLat(longLat);
+        allVec3s.push(...v3);
+        allLongLats.push(...longLat);
+        index = pointCounter++;
+        pointMap.set(key, index);
+        return index;
+    };
+    // 1. Add triangle's "shell" (for Delaunay) and "edge" (vertices/limits) points
+    // These points constrain the triangulation.
+    const shellPointIndices = [];
+    const edgePoints = getEdgePoints(triangleMeta);
+    // Assuming shellPoints and edgePoints have the same length and correspond
+    const shellPointCount = Math.min(triangleMeta.shellPoints.length, edgePoints.length);
+    for (let i = 0; i < shellPointCount; i++) {
+        // Add the "shell" point (for Delaunay stability)
+        shellPointIndices.push(addPoint(triangleMeta.shellPoints[i]));
+        // Add the actual "edge" point (triangle vertex or limit point)
+        addPoint(vec3ToLongLatRadians(edgePoints[i]), edgePoints[i]);
+    }
+    // 2. Iterate through each tile limit
+    for (const { bbox: tileBBox, zoom } of limits) {
+        // 2a. Calculate the intersection BBOX (the area we'll work on)
+        const workBBox = {
+            min: [
+                Math.max(triangleMeta.bbox.min[0], tileBBox.min[0]),
+                Math.max(triangleMeta.bbox.min[1], tileBBox.min[1])
+            ],
+            max: [
+                Math.min(triangleMeta.bbox.max[0], tileBBox.max[0]),
+                Math.min(triangleMeta.bbox.max[1], tileBBox.max[1])
+            ],
+        };
+        // If the intersection is invalid (no overlap), skip this tile
+        if (workBBox.min[0] >= workBBox.max[0] || workBBox.min[1] >= workBBox.max[1]) {
+            continue;
+        }
+        // 2b. Calculate grid steps for this tile's zoom
+        const tileCount = TILE_COUNTS[zoom];
+        const lonStep = (2 * Math.PI) / tileCount / innerCuts;
+        const latStep = 1.0 / innerCuts; // This is in tileY units
+        // 2c. Generate Latitude (Parallel) Points
+        const startTileY = latToTileY(workBBox.max[1], zoom); // max lat -> min tileY
+        const endTileY = latToTileY(workBBox.min[1], zoom); // min lat -> max tileY
+        let currentY = Math.ceil(startTileY / latStep) * latStep;
+        if (currentY < startTileY - 1e-9)
+            currentY += latStep; // Ensure we start inside or on edge
+        while (currentY <= endTileY + 1e-9) {
+            const lat = tileYtoLat(currentY, zoom);
+            // Skip if rounding put us slightly outside the work box
+            if (lat < workBBox.min[1] - 1e-9 || lat > workBBox.max[1] + 1e-9) {
+                currentY += latStep;
+                continue;
+            }
+            // Find where this latitude line intersects the triangle
+            const intersections = getPoints(triangleMeta, lat, true);
+            for (let i = 0; i < intersections.length; i += 2) {
+                const p0 = intersections[i]; // [Vec3, LongLatRadian]
+                const p1 = intersections[i + 1];
+                // Find the segment of this latitude line that is *inside* both
+                // the triangle (p0-p1) AND the tile BBOX (workBBox)
+                const triMinLon = Math.min(p0[1][0], p1[1][0]);
+                const triMaxLon = Math.max(p0[1][0], p1[1][0]);
+                const segMinLon = Math.max(workBBox.min[0], triMinLon);
+                const segMaxLon = Math.min(workBBox.max[0], triMaxLon);
+                // If this clipped segment is valid, generate points
+                if (segMinLon < segMaxLon - 1e-9) {
+                    // Add the exact start and end points of the clipped segment
+                    addPoint([segMinLon, lat]);
+                    addPoint([segMaxLon, lat]);
+                    // Add fill points *between* them
+                    let currentLon = Math.ceil(segMinLon / lonStep) * lonStep;
+                    if (currentLon < segMinLon - 1e-9)
+                        currentLon += lonStep;
+                    while (currentLon < segMaxLon - 1e-9) {
+                        addPoint([currentLon, lat]);
+                        currentLon += lonStep;
+                    }
+                }
+            }
+            currentY += latStep;
+        }
+        // 2d. Generate Longitude (Meridian) Points
+        const startLon = workBBox.min[0];
+        const endLon = workBBox.max[0];
+        let currentLon = Math.ceil(startLon / lonStep) * lonStep;
+        if (currentLon < startLon - 1e-9)
+            currentLon += lonStep;
+        while (currentLon <= endLon + 1e-9) {
+            // Find where this longitude line intersects the triangle
+            const intersections = getPoints(triangleMeta, currentLon, false);
+            for (const p of intersections) {
+                const pLongLat = p[1];
+                // Check if this point is inside the *workBBox*
+                if (pLongLat[1] >= workBBox.min[1] - 1e-9 &&
+                    pLongLat[1] <= workBBox.max[1] + 1e-9) {
+                    addPoint(pLongLat, p[0]);
+                }
+            }
+            currentLon += lonStep;
+        }
+    } // End loop over limits
+    // 3. Triangulate
+    // We must have at least 3 points to make a triangle
+    if (pointCounter < 3) {
+        return {
+            vec3s: new Float32Array(),
+            longLats: new Float32Array(),
+            indices: new Uint32Array(),
+        };
+    }
+    const delaunator = new Delaunator(allLongLats);
+    let indices = delaunator.triangles;
+    // 4. Filter out triangles connected to the "shell" points
+    indices = filteroutEdgeConnections(indices, shellPointIndices);
+    return {
+        vec3s: new Float32Array(allVec3s),
+        longLats: new Float32Array(allLongLats),
+        indices: indices,
+    };
+}

package/Math/tessellation/triangle-tessellation.js

@@ -2,9 +2,13 @@
  * @author Toprak Ozturk
  *
  */
-import { createTriangleTessellationMeta, getAllPoints } from "./triangle-tessellation-meta";
+import { createTriangleTessellationMeta, getAllPoints, partialTessellation } from "./triangle-tessellation-meta";
 export function test1(zoomLevel, p1, p2, p3) {
     const triangleMeta = createTriangleTessellationMeta(p1, p2, p3);
     const { vec3s, longLats, indices } = getAllPoints(triangleMeta, zoomLevel);
     return { vec3s, longLats, indices };
 }
+export function partialTest(bboxZooms, p1, p2, p3) {
+    const triangleMeta = createTriangleTessellationMeta(p1, p2, p3);
+    return partialTessellation(triangleMeta, bboxZooms, 5);
+}

package/compass-rose/compass-text-writer.js

@@ -1,17 +1,5 @@
-import { CSZMode, CSMeasureTextPositionTypes } from "@pirireis/webglobe";
-// const defaultStyle = {
-//     textFont: {
-//         name: 'Arial',
-//         textColor: '#FFFFFF', // beyaz
-//         hollowColor: '#000000', // siyah
-//         size: 12, // piksel
-//         hollow: true,
-//         bold: true,
-//         italic: false,
-//     },
-//     opacity: 1.0,
-//     zMode: CSZMode.Z_GROUND_PERVERTEX,
-// }
+// filepath: d:\webglobeplugins\webglobePlugin\src\webglobeplugins\compass-rose\compass-text-writer.ts
+import { CSMeasureTextPositionTypes } from "@pirireis/webglobe";
 /**
  * TODOs:
  * 1) update all if initials change (propably need a context and a callback to iterate over data)
@@ -21,19 +9,32 @@ import { CSZMode, CSMeasureTextPositionTypes } from "@pirireis/webglobe";
 const yGapFit = -2;
 const xGapFit = -5;
 export class PixelPaddingCompassTextWriter {
+    globe;
+    itemMap;
+    font;
+    northFont;
+    doDraw;
+    angle;
+    angles;
+    texts;
+    positions;
+    _lastNorthAngle;
+    offsets;
+    keyAdaptor;
+    opacity;
     constructor(globe, { font = {
         name: 'Arial',
-        textColor: '#FFFFFF', // beyaz
-        hollowColor: '#000000', // siyah
-        size: 12, // piksel
+        textColor: '#FFFFFF',
+        hollowColor: '#000000',
+        size: 12,
         hollow: true,
         bold: true,
         italic: false,
     }, northFont = {
         name: 'Arial',
-        textColor: '#BB0000', // beyaz
-        hollowColor: '#000000', // siyah
-        size: 14, // piksel
+        textColor: '#BB0000',
+        hollowColor: '#000000',
+        size: 14,
         hollow: true,
         bold: true,
         italic: false,
@@ -56,17 +57,16 @@ export class PixelPaddingCompassTextWriter {
                 this.positions.push(null);
             }
             this.angles.push(currentAngle);
-            if (currentAngle == 0) {
+            if (currentAngle === 0) {
                 this.texts.push("K");
             }
             else {
-                // to string 3 chars fill left with 0
                 this.texts.push(currentAngle.toString().padStart(3, '0'));
             }
             currentAngle += this.angle;
         }
         this._lastNorthAngle = globe.api_GetCurrentLookInfo()["NorthAng"] * (Math.PI / 180);
-        this.offsets = this.__offset(this._lastNorthAngle);
+        this.offsets = this.__offset();
     }
     setKeyAdaptor(adaptor) {
         this.keyAdaptor = adaptor;
@@ -86,7 +86,6 @@ export class PixelPaddingCompassTextWriter {
     _checkSetOffsets() {
         const { globe } = this;
         const newAngle = globe.api_GetCurrentLookInfo()["NorthAng"] * (Math.PI / 180);
-        ;
         if (newAngle !== this._lastNorthAngle) {
             this._lastNorthAngle = newAngle;
             this.offsets = this.__offset();
@@ -96,42 +95,49 @@ export class PixelPaddingCompassTextWriter {
         if (!this.doDraw)
             return;
         const { globe, font, opacity: opacity_, northFont, itemMap, texts, angles, positions } = this;
-        this._checkSetOffsets(); //  zMode: CSZMode.Z_GROUND_PERVERTEX,
+        this._checkSetOffsets();
         const offsets = this.offsets;
         for (const [key, { center, radius, opacity = null }] of itemMap) {
-            const o = opacity === null ? opacity_ : opacity * opacity_;
-            if (center.x !== null && center.y !== null) {
+            const o = opacity === null ? (opacity_ ?? 1.0) : opacity * (opacity_ ?? 1.0);
+            if (center && radius !== undefined) {
+                const { x, y } = center;
+                if (x === null || y === null)
+                    continue;
                 offsets.forEach(({ offsetX, offsetY }, i) => {
                     const text = texts[i];
                     const angle = angles[i];
                     font.position = positions[i];
                     if (angle === 0) {
-                        globe.api_DrawContextTextMultiLine(text, northFont, o, { x: center.x + offsetX * radius + xGapFit, y: center.y + offsetY * radius + yGapFit });
+                        globe.api_DrawContextTextMultiLine(text, northFont, o, { x: x + offsetX * radius + xGapFit, y: y + offsetY * radius + yGapFit });
                     }
                     else {
-                        globe.api_DrawContextTextMultiLine(text, font, o, { x: center.x + offsetX * radius + xGapFit, y: center.y + offsetY * radius + yGapFit });
+                        globe.api_DrawContextTextMultiLine(text, font, o, { x: x + offsetX * radius + xGapFit, y: y + offsetY * radius + yGapFit });
                     }
                 });
             }
         }
     }
-    insertTextItem(key, x, y, radius = undefined) {
+    insertTextItem(key, x, y, radius) {
         const item = this.getItem(key);
         item.center = { x, y };
         if (radius === undefined)
             return;
-        if (item.radius != undefined && item.radius === radius)
+        if (item.radius !== undefined && item.radius === radius)
             return;
         item.radius = radius;
     }
     getItem(key) {
-        if (!this.itemMap.has(key))
+        if (!this.itemMap.has(key)) {
             this.itemMap.set(key, {});
+        }
         return this.itemMap.get(key);
     }
     __calculateOffset(angle) {
         const rAngle = (angle - 90) * (Math.PI / 180);
-        return { offsetX: Math.cos(rAngle + this._lastNorthAngle), offsetY: Math.sin(rAngle + this._lastNorthAngle) };
+        return {
+            offsetX: Math.cos(rAngle + this._lastNorthAngle),
+            offsetY: Math.sin(rAngle + this._lastNorthAngle)
+        };
     }
     __offset() {
         const angle = this.angle;

package/constants.js

@@ -1,3 +1,6 @@
+export const CSRenderPassPluginKeys = ["supportNormalPass",
+    "supportSelectedPass",
+    "supportEditingPass"];
 export const GLOBE_DEFAULT_MIN_LOD = 2;
 export const GLOBE_DEFAULT_MAX_LOD = 25;
 export const POLE2 = 12756274.0;

package/{util/heatwavedatamanager → heatwave}/datamanager.js

@@ -2,7 +2,7 @@
  * todo:
  * data must be processed before being set to the cache
  */
-export default class DataManager {
+export class DataManager {
     /**
      *
      * @param {Array<number>} timeEpocs | array of time epocs

package/heatwave/{plugins/heatwaveglobeshell.js → heatwave.js}

@@ -1,7 +1,9 @@
-import { getColorRampModed, DataManager, } from "../../util/index";
-import { TexturePointSampler } from "../../util/heatwavedatamanager/texture-point-sampler";
-import { GlobeShellWiggle, Float2LegendWithRatio } from "../../programs";
-import { opacityCheck } from "../../util/check/typecheck";
+import { getColorRampModed } from "../util/webglobjectbuilders";
+import { DataManager } from "./datamanager";
+import { TexturePointSampler } from "./texture-point-sampler";
+import { BBOXGlobeShell } from "../semiplugins/shell/bbox-renderer";
+import { Float2LegendWithRatio } from "../programs/float2legendwithratio";
+import { opacityCheck } from "../util/check/typecheck";
 /**
  * @param id : string
  * @param dataManager : DataManager
@@ -9,7 +11,7 @@ import { opacityCheck } from "../../util/check/typecheck";
  * @param dataWidthHeight : {width: number, height: number}
  * @param options : {bbox: number[], minMaxEdges: {min: number, max: number}, escapeValue: number, resolution: number[], meshPartition: number[]}
  */
-export default class HeatWaveGlobeShellPlugin {
+export class HeatWavePlugin {
     constructor(id, dataManager, colorRampData, dataWidthHeight, { bbox = [-180, -90, 180, 90], minMaxEdges = { min: -99999, max: 99999 }, escapeValue = 99999, resolution = [2056, 2056], yFlip = true, } = {}) {
         this.id = id;
         this.dataManager = dataManager;
@@ -152,7 +154,7 @@ export default class HeatWaveGlobeShellPlugin {
         this.setEscapeValue(this._escapeValue);
     }
     _init(globe, gl) {
-        this.globeShell = new GlobeShellWiggle(gl, globe, {
+        this.globeShell = new BBOXGlobeShell(gl, globe, {
             minLon: this._bbox[0],
             minLat: this._bbox[1],
             maxLon: this._bbox[2],

package/heatwave/index.js

@@ -1,3 +1,5 @@
-import HeatWavePlugin from './plugins/heatwaveglobeshell';
-import { IsobarRasterToVector } from './isobar/plugin';
-export { HeatWavePlugin, IsobarRasterToVector };
+import { DataManager } from "./datamanager.js";
+import { HeatWavePlugin } from "./heatwave.js";
+import { IsobarRasterToVector } from "./isobar.js";
+import { TexturePointSampler } from "./texture-point-sampler";
+export { DataManager, HeatWavePlugin, IsobarRasterToVector, TexturePointSampler };

package/heatwave/{isobar/plugin.js → isobar.js}

@@ -1,7 +1,8 @@
-import { ShapesOnGlobeProgram, latLongToPixelXY } from "../../util";
-import ContourMipmap, { scaleParameters } from "./quadtreecontours";
-import ObjectArrayLabels from "./objectarraylabels";
-import { isBoolean, opacityCheck } from "../../util/check/typecheck";
+import { DrawFromPixelCoords, } from "../util/programs/draw-from-pixel-coords";
+import { latLongToPixelXY } from "../util/geometry/index";
+import ContourMipmap, { scaleParameters } from "../Math/contour/quadtreecontours";
+import ObjectArrayLabels from "../write-text/objectarraylabels";
+import { isBoolean, opacityCheck } from "../util/check/typecheck";
 export class IsobarRasterToVector {
     /**
      * @typedef {Object} IsobarData
@@ -151,7 +152,7 @@ export class IsobarRasterToVector {
     init(globe, gl) {
         this.gl = gl;
         this.globe = globe;
-        this.program = new ShapesOnGlobeProgram(gl, globe, 'line_strip');
+        this.program = new DrawFromPixelCoords(gl, globe, 'line_strip');
         if (this._isLabelsOn) {
             this._createLabelsLayer();
             this._labelsLayer.addToMap();

package/{util/heatwavedatamanager → heatwave}/texture-point-sampler.js

@@ -1,4 +1,25 @@
-import PointCoordsMeta from "./pointcoordsmeta";
+class PointCoordsMeta {
+    _bbox;
+    _width;
+    _height;
+    _xRatio;
+    _yRatio;
+    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]);
+    }
+    getFlooredIndex(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;
+    }
+}
 const pointObject = (long, lat, posIndex, callback) => {
     return { long, lat, posIndex, callback };
 };
@@ -103,7 +124,7 @@ export class TexturePointSampler {
     }
     flush(callEmptyCallback = false) {
         if (callEmptyCallback) {
-            for (const [key, { callback }] of this._pointObjects.entries()) {
+            for (const [, { callback }] of this._pointObjects.entries()) {
                 callback(null, null, null);
             }
         }
@@ -141,7 +162,7 @@ export class TexturePointSampler {
             }
         }
         else {
-            for (const [key, { callback }] of this._pointObjects.entries()) {
+            for (const [, { callback }] of this._pointObjects.entries()) {
                 callback(null, null, null);
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@pirireis/webglobeplugins",
-    "version": "0.16.7",
+    "version": "0.17.0",
     "main": "index.js",
     "author": "Toprak Nihat Deniz Ozturk",
     "license": "MIT",
@@ -8,9 +8,11 @@
         "build": "tsc"
     },
     "dependencies": {
-        "@pirireis/webglobe": "^6.2.22",
         "delaunator": "^5.0.1",
         "earcut": "^3.0.2",
         "rbush": "^4.0.1"
+    },
+    "peerDependencies": {
+        "@pirireis/webglobe": "^6.2.22"
     }
 }

package/programs/arrowfield/{object.js → arrow-field.js}

@@ -4,7 +4,7 @@
 import Logic from './logic';
 import { globeProgramCache } from '../programcache';
 import { longlatbbox2normalbbox } from "../util";
-export default class ArrowField {
+export class ArrowField {
     constructor(gl, globe, { minLon = -180, maxLon = 180, minLat = -90, maxLat = 90, height = 0, opacity = 1, color = [0.04, 0.2, 0.8], targetWidth = 100, targetHeight = 100, dataWidth = null, dataHeight = null, tailLengthRatio = 1, wingLengthRatio = 0.5, noDataValue = null,
     // maxMagnitude = null
      } = {}) {

package/programs/arrowfield/logic.js

@@ -1,4 +1,4 @@
-import { createProgram } from "../../util";
+import { createProgram } from "../../util/webglobjectbuilders";
 import { globeProgramCache } from "../programcache";
 import { CameraUniformBlockTotem } from "../totems";
 const arrowVertexShader = `#version 300 es