@pirireis/webglobeplugins 1.0.2 → 1.0.4

package/semiplugins/shape-on-terrain/terrain-polygon/data/master-worker.ts

@@ -1,209 +0,0 @@
-/// <reference lib="webworker" />
-
-import { PolygonInput, WorkerInput, WorkerOutput, BBOXZOOMDATA } from "../types";
-
-interface WorkerWrapper {
-    worker: Worker;
-    inProgress: boolean;
-    insertDeleteQueue: (PolygonInput | string)[];
-    lastBBOXData: BBOXZOOMDATA | null;
-    itemCount: number;
-    lastOutput: WorkerOutput | null;
-}
-
-const _workers: WorkerWrapper[] = [];
-const _workerMap: Map<string, number> = new Map();
-let _maxWorkers = 4; // Default, updated in init
-let _nextWorkerIndex = 0;
-
-// Configuration state to pass to new workers or re-broadcast
-let _pickableState: boolean | undefined;
-let _variativeColorsOn: boolean | undefined;
-
-// Initialize workers
-function initWorkers() {
-    _maxWorkers = Math.max(1, (navigator.hardwareConcurrency || 4) - 1);
-    for (let i = 0; i < _maxWorkers; i++) {
-        addWorker();
-    }
-}
-
-function addWorker() {
-    // @ts-ignore
-    const worker = new Worker(new URL("./worker.js", import.meta.url), { type: 'module' });
-
-    const wrapper: WorkerWrapper = {
-        worker,
-        inProgress: false,
-        insertDeleteQueue: [],
-        lastBBOXData: null,
-        itemCount: 0,
-        lastOutput: null
-    };
-
-    worker.onmessage = (event: MessageEvent<WorkerOutput>) => {
-        wrapper.inProgress = false;
-        wrapper.lastOutput = event.data;
-        mergeAndSendResults();
-        sendToSubWorker(wrapper);
-    };
-
-    // Initialize sub-worker with current global state
-    worker.postMessage({
-        pickableState: _pickableState,
-        variativeColorsOn: _variativeColorsOn,
-        insertDeleteQueue: [],
-        bboxes: null,
-    });
-
-    _workers.push(wrapper);
-}
-
-function mergeAndSendResults() {
-    let totalVec3s = 0;
-    let totalIndices = 0;
-    let totalLongLats = 0;
-    let totalPickIndices = 0;
-    let totalVariativeColors = 0;
-
-    const validOutputs: WorkerOutput[] = [];
-
-    for (const w of _workers) {
-        if (w.lastOutput) {
-            validOutputs.push(w.lastOutput);
-            totalVec3s += w.lastOutput.vec3s.length;
-            totalIndices += w.lastOutput.indices.length;
-            totalLongLats += w.lastOutput.longLats.length;
-            if (w.lastOutput.pickIndices) totalPickIndices += w.lastOutput.pickIndices.length;
-            if (w.lastOutput.variativeColors) totalVariativeColors += w.lastOutput.variativeColors.length;
-        }
-    }
-
-    if (validOutputs.length === 0) return;
-
-    const merged: WorkerOutput = {
-        vec3s: new Float32Array(totalVec3s),
-        indices: new Uint32Array(totalIndices),
-        longLats: new Float32Array(totalLongLats),
-        pickIndices: totalPickIndices > 0 ? new Float32Array(totalPickIndices) : null,
-        variativeColors: totalVariativeColors > 0 ? new Float32Array(totalVariativeColors) : null
-    };
-
-    let offsetVec3s = 0;
-    let offsetIndices = 0;
-    let offsetLongLats = 0;
-    let offsetPickIndices = 0;
-    let offsetVariativeColors = 0;
-    let vertexOffset = 0;
-
-    for (const out of validOutputs) {
-        merged.vec3s.set(out.vec3s, offsetVec3s);
-        offsetVec3s += out.vec3s.length;
-
-        for (let i = 0; i < out.indices.length; i++) {
-            merged.indices[offsetIndices + i] = out.indices[i] + vertexOffset;
-        }
-        offsetIndices += out.indices.length;
-        vertexOffset += out.vec3s.length / 3;
-
-        merged.longLats.set(out.longLats, offsetLongLats);
-        offsetLongLats += out.longLats.length;
-
-        if (merged.pickIndices && out.pickIndices) {
-            merged.pickIndices.set(out.pickIndices, offsetPickIndices);
-            offsetPickIndices += out.pickIndices.length;
-        }
-
-        if (merged.variativeColors && out.variativeColors) {
-            merged.variativeColors.set(out.variativeColors, offsetVariativeColors);
-            offsetVariativeColors += out.variativeColors.length;
-        }
-    }
-
-    // Send merged result to Main Thread
-    self.postMessage(merged, [
-        merged.vec3s.buffer,
-        merged.indices.buffer,
-        merged.longLats.buffer,
-        ...(merged.pickIndices ? [merged.pickIndices.buffer] : []),
-        ...(merged.variativeColors ? [merged.variativeColors.buffer] : [])
-    ]);
-}
-
-function sendToSubWorker(wrapper: WorkerWrapper) {
-    if (wrapper.inProgress) return;
-    if (wrapper.insertDeleteQueue.length === 0 && wrapper.lastBBOXData === null) return;
-
-    wrapper.inProgress = true;
-    wrapper.worker.postMessage({
-        pickableState: undefined, // State is set on init, only send updates if needed
-        variativeColorsOn: undefined,
-        bboxes: wrapper.lastBBOXData,
-        insertDeleteQueue: wrapper.insertDeleteQueue,
-    } as WorkerInput);
-
-    wrapper.lastBBOXData = null;
-    wrapper.insertDeleteQueue = [];
-}
-
-function triggerAllWorkers() {
-    for (const w of _workers) {
-        sendToSubWorker(w);
-    }
-}
-
-// Handle messages from Main Thread
-self.onmessage = (event: MessageEvent<WorkerInput>) => {
-    const { bboxes, insertDeleteQueue, pickableState, variativeColorsOn } = event.data;
-
-    // Initialize if not already done
-    if (_workers.length === 0) {
-        _pickableState = pickableState;
-        _variativeColorsOn = variativeColorsOn;
-        initWorkers();
-    }
-
-    // Handle BBOX updates
-    if (bboxes) {
-        for (const w of _workers) {
-            w.lastBBOXData = bboxes;
-        }
-    }
-
-    // Handle Insert/Delete
-    if (insertDeleteQueue && insertDeleteQueue.length > 0) {
-        if (insertDeleteQueue[0] === "__CLEAR_ALL_ITEMS__") {
-            _workerMap.clear();
-            for (const w of _workers) {
-                w.insertDeleteQueue = ["__CLEAR_ALL_ITEMS__"];
-                w.itemCount = 0;
-                w.lastOutput = null;
-            }
-        } else {
-            for (const item of insertDeleteQueue) {
-                if (typeof item === 'string') {
-                    // Delete
-                    const workerIdx = _workerMap.get(item);
-                    if (workerIdx !== undefined) {
-                        _workers[workerIdx].insertDeleteQueue.push(item);
-                        _workers[workerIdx].itemCount--;
-                        _workerMap.delete(item);
-                    }
-                } else {
-                    // Insert
-                    let workerIdx = _workerMap.get(item.key);
-                    if (workerIdx === undefined) {
-                        workerIdx = _nextWorkerIndex;
-                        _workerMap.set(item.key, workerIdx);
-                        _workers[workerIdx].itemCount++;
-                        _nextWorkerIndex = (_nextWorkerIndex + 1) % _workers.length;
-                    }
-                    _workers[workerIdx].insertDeleteQueue.push(item.key);
-                }
-            }
-        }
-    }
-
-    // Trigger all workers to process the new data
-    triggerAllWorkers();
-}

package/semiplugins/shape-on-terrain/terrain-polygon/data/polygon-to-triangles.ts

@@ -1,144 +0,0 @@
-/**
- * # Purpose
- * Divide long edges of polygons into smaller segments
- * 
- * This algorithm should be called after earcutting / triangulation. 
- * Then earcut should run second time to further divide long edges.
- * 
- * populate points on a arc between two given points on a sphere
- * 
- */
-
-
-import { Radian } from "../../../../types";
-
-import { PolygonPluginInput, TrianglesMiddleData } from "../types";
-import { haversine } from "../../../../Math/haversine";
-
-
-import earcut from "earcut";
-
-
-/**
- * 
- */
-
-function __pointsInBetweenGreateCircle(
-    lat1: Radian,
-    lon1: Radian,
-    lat2: Radian,
-    lon2: Radian,
-    unitSphereDistance: number
-): number[] | null {
-    const points: number[] = [];
-
-    const d1 = haversine(lat1, lon1, lat2, lon2);
-    if (d1 <= unitSphereDistance) {
-        return null;
-    }
-
-    const numSegments = Math.ceil(d1 / unitSphereDistance);
-    for (let i = 1; i < numSegments; i++) {
-        const f = i / numSegments;
-        const A = Math.sin((1 - f) * d1) / Math.sin(d1);
-        const B = Math.sin(f * d1) / Math.sin(d1);
-        const x = A * Math.cos(lat1) * Math.cos(lon1) + B * Math.cos(lat2) * Math.cos(lon2);
-        const y = A * Math.cos(lat1) * Math.sin(lon1) + B * Math.cos(lat2) * Math.sin(lon2);
-        const z = A * Math.sin(lat1) + B * Math.sin(lat2);
-        const latN = Math.atan2(z, Math.sqrt(x * x + y * y));
-        const lonN = Math.atan2(y, x);
-        points.push(latN, lonN);
-    }
-
-    return points;
-}
-
-
-
-function _dividePolygonEdgeSize(
-    polygon: PolygonPluginInput,
-    kmThreshold: number
-): PolygonPluginInput {
-    const unitSphereDistance = kmThreshold / 6371; // Earth radius in km
-
-    const newGeometries = polygon.geometry.map(geom => {
-        const { vertices, holes } = geom;
-        const newVertices: number[] = [];
-        const newHoles: number[] = [];
-
-        const processRing = (start: number, end: number) => {
-            for (let i = start; i < end; i++) {
-                const long1 = vertices[2 * i];
-                const lat1 = vertices[2 * i + 1];
-                const next_i = (i + 1 < end) ? i + 1 : start;
-                const long2 = vertices[2 * next_i];
-                const lat2 = vertices[2 * next_i + 1];
-
-                newVertices.push(long1, lat1);
-                const extraPoints = __pointsInBetweenGreateCircle(
-                    lat1, long1, lat2, long2, unitSphereDistance
-                );
-                if (extraPoints) {
-                    newVertices.push(...extraPoints);
-                }
-            }
-        };
-
-        const shellEnd = holes.length > 0 ? holes[0] : vertices.length / 2;
-        processRing(0, shellEnd);
-
-        for (let h = 0; h < holes.length; h++) {
-            newHoles.push(newVertices.length / 2);
-            const holeStart = holes[h];
-            const holeEnd = h + 1 < holes.length ? holes[h + 1] : vertices.length / 2;
-            processRing(holeStart, holeEnd);
-        }
-        return { vertices: newVertices, holes: newHoles };
-    });
-
-    return {
-        ...polygon,
-        geometry: newGeometries,
-    };
-}
-
-// TODO: 
-// divide TrianglesMiddleData edges longer than threshold
-// function _divideTriangleEdges(
-//     key: string,
-//     vertices: number[],
-//     indices: number[],
-//     kmThreshold: number // maybe
-// ): TrianglesMiddleData {
-//     return { key, vertices, indices };
-// }
-
-
-
-// TODO: NEED TEST
-function triangulation(polygon: PolygonPluginInput, kmThreshold: number): TrianglesMiddleData {
-
-    const finalVertices: number[] = [];
-    const finalIndices: number[] = [];
-    let vertexIndexOffset = 0;
-
-    for (const geom of polygon.geometry) {
-        const indices = earcut(geom.vertices, geom.holes, 2);
-        
-        finalVertices.push(...geom.vertices);
-
-        for (const index of indices) {
-            finalIndices.push(index + vertexIndexOffset);
-        }
-
-        vertexIndexOffset += geom.vertices.length / 2;
-    }
-
-    return {
-        key: polygon.key,
-        vertices: finalVertices,
-        indices: finalIndices
-    };
-}
-
-export { triangulation };

package/semiplugins/shape-on-terrain/terrain-polygon/data/readme.md

@@ -1,5 +0,0 @@
-# TODO:
-
-need a glue to manage cache, connect cache to processed data, ready to be consumed by texture-dem-program 
-
-It should be able to work on web worker.

package/semiplugins/shape-on-terrain/terrain-polygon/data/types.ts

@@ -1,37 +0,0 @@
-import { Color } from "../../../../types";
-import { TriangleTessellationMeta } from "../../../../Math/tessellation/triangle-tessellation";
-import { PolygonPluginInput } from "../types";
-
-
-
-type CatchedType = {
-    polygon: PolygonPluginInput,
-    offset: number,
-    tessellationMeta: TriangleTessellationMeta,
-    minX: number,
-    minY: number,
-    maxX: number,
-    maxY: number,
-};
-
-
-type CacheTriangle = {
-    parentKey: string;
-    tessellationMeta: TriangleTessellationMeta;
-}
-
-
-type Cache = Map<string,
-    {
-        triangles: CacheTriangle[],
-        properties: PolygonProperties
-    }>;
-
-
-
-type PolygonProperties = {
-    color: Color,
-    height: number,
-}
-
-export { CacheTriangle, Cache, PolygonProperties, CatchedType };

package/semiplugins/shape-on-terrain/terrain-polygon/data/worker.js

@@ -1,146 +0,0 @@
-/// <reference lib="webworker" />
-
-import { Cache } from "./cache";
-import { partialTessellation, zoomLevelShowThreshold } from "../../../../Math/tessellation/triangle-tessellation";
-import { IndexAttributeEscapeValue } from "../../../../programs/polygon-on-globe/texture-dem-triangles";
-
-const cache = new Cache(100); // 100 km threshold
-let _pickableState = false;
-let _variativeColorsOnState = false;
-
-let showThreshold = 0;
-// eslint-disable-next-line no-restricted-globals
-self.onmessage = (event) => {
-    try {
-        const { bboxes, insertDeleteQueue, pickableState, variativeColorsOn } = event.data;
-        if (variativeColorsOn !== undefined) {
-            _variativeColorsOnState = variativeColorsOn;
-        }
-        if (pickableState !== undefined) {
-            _pickableState = pickableState;
-        }
-
-        // Process insert/delete queue
-        if (insertDeleteQueue[0] === "__CLEAR_ALL_ITEMS__") {
-            insertDeleteQueue.shift();
-            cache.clear();
-        }
-
-        for (const item of insertDeleteQueue) {
-            if (typeof item === 'string') {
-                cache.remove(item);
-            } else {
-                cache.insert(item.key, item);
-            }
-        }
-
-        // Update bboxes if provided
-        if (bboxes) {
-            cache.setBBOXes(bboxes);
-            showThreshold = zoomLevelShowThreshold(bboxes[0].zoom, 0.03);
-        }
-
-        // Search for triangles in view
-        const trianglesInView = cache.search();
-
-        // Prepare arrays for merging
-        const results = [];
-
-        // Convert bbox to BBoxZoom format for partialTessellation
-        const bboxZooms = bboxes ? bboxes.map(b => ({
-            bbox: {
-                min: [b.minX, b.minY],
-                max: [b.maxX, b.maxY]
-            },
-            zoom: b.zoom
-        })) : []; // This will be empty if no bbox, causing issues
-
-        let counter = 0;
-        let indexCounter = 0;
-        // Process each triangle
-        for (const triangle of trianglesInView) {
-            if (triangle.tessellationMeta.showThreshold * 0.075 > showThreshold) {
-                continue;
-            }
-
-            const result = (triangle.tessellationMeta.showThreshold < showThreshold) ? partialTessellation(
-                triangle.tessellationMeta,
-                bboxZooms,
-                5 // innerCuts parameter
-            ) : triangle.tessellationMeta.shortCut;
-
-
-            counter += result.vec3s.length;
-            indexCounter += result.indices.length;
-            if (_pickableState) {
-                // TODO: find a better way to fill indeces to final array
-                result.pickIndex = triangle.polygon.index;
-            }
-            if (_variativeColorsOnState) {
-                const color = triangle.polygon.color || [IndexAttributeEscapeValue, IndexAttributeEscapeValue, IndexAttributeEscapeValue, IndexAttributeEscapeValue];
-                result.variativeColors = color;
-                // Update offset for next triangle
-            }
-            results.push(result);
-        }
-
-        // Send results back
-        const output = {
-            vec3s: new Float32Array(counter),
-            longLats: new Float32Array(counter / 3 * 2),
-            indices: new Uint32Array(indexCounter),
-
-        };
-
-        if (_pickableState) {
-            output.pickIndices = new Float32Array(counter / 3);
-        }
-        if (_variativeColorsOnState) {
-            output.variativeColors = new Float32Array(counter / 3 * 4);
-        }
-
-        let currentVertexOffset = 0;
-        let indexOffset = 0;
-        for (const result of results) {
-            output.vec3s.set(result.vec3s, currentVertexOffset);
-            output.longLats.set(result.longLats, (currentVertexOffset / 3) * 2);
-            output.indices.set(result.indices.map(i => i + currentVertexOffset / 3), indexOffset);
-            currentVertexOffset += result.vec3s.length;
-            indexOffset += result.indices.length;
-            if (_pickableState) {
-                const subArray = output.pickIndices.subarray(currentVertexOffset / 3 - result.vec3s.length / 3, currentVertexOffset / 3);
-                subArray.fill(result.pickIndex);
-            }
-            if (_variativeColorsOnState && result.variativeColors) {
-                const vertexCount = result.vec3s.length / 3;
-                const colorStartIndex = (currentVertexOffset / 3 - vertexCount) * 4;
-                for (let i = 0; i < vertexCount; i++) {
-                    const offset = colorStartIndex + i * 4;
-                    output.variativeColors[offset] = result.variativeColors[0];
-                    output.variativeColors[offset + 1] = result.variativeColors[1];
-                    output.variativeColors[offset + 2] = result.variativeColors[2];
-                    output.variativeColors[offset + 3] = result.variativeColors[3];
-                }
-            }
-        }
-
-        const buffers = [
-            output.vec3s.buffer,
-            output.indices.buffer,
-            output.longLats.buffer,
-        ];
-        if (pickableState && output.pickIndices) {
-            buffers.push(output.pickIndices.buffer);
-        }
-        if (_variativeColorsOnState && output.variativeColors) {
-            buffers.push(output.variativeColors.buffer);
-        }
-        // eslint-disable-next-line no-restricted-globals
-        self.postMessage(output,
-            buffers);
-    } catch (error) {
-        console.error('Error in worker:', error);
-
-        // self.postMessage({ error: error.message || 'Unknown error in worker' });
-    }
-};

package/semiplugins/shape-on-terrain/terrain-polygon/notes.md

@@ -1,90 +0,0 @@
-# Requirements
-
-- webgl program
-- interaction with globe elevation api
-- mesh algorithm
-
-
-# WEBGL PROGRAM
-
-Triangles with Webgl picking. Program can have color hightlighting too for selected item.
-
-# Interation with Globe Elevation API
-
-Elevation resolution is based on camera and focus positions. 
-Instead of blindly ask for elevation of coordinates, what else can be done?
-
-## 1. Server side solution
-A detailed version can be requested from server. Server create mesh. The mesh preferably high resolution.
-Therefore zoom level and camera information is no longer parameters.
-
-On edit mod the change is on fly. Server probably cannot catch the speed of spontanius editting. On this case less detailed mesh can be 
-processed be client side. One edit finished, client asks for detailed final version. 
-
-**Criterias:** Visual compatibility with Globe surface, Performance, Memory, Web Traffic(maybe opening a mesh server at backand)
-
-# Mesh Algorithm & Data Structure
-
-  olygon to elevation mesh
-
-Data structure would be points and indexes. 
-
-Adaptors employed to convert user input to desired ınput.
-
-Flat version of mesh can be build on front end if possible
-
-
-
-***********
-
-
-[-] Mesh algorthm concave
-[-] triangle plugin with gpu picking. input ( key, mesh (Variative size ?) , color,)
-
-
---------
-
-# Loading DEM to texture array
-
-There is 6 Tiles with dem in an instance of time.
-
-These 6 tiles can be loaded to gpu as texture[6].
-And 6 bbox can be loaded as vec4[6] rgba -> ur lr rl ll
-Each vertex finds which tile they are blonged to, and calculate dem from points relative position to their bbox
-If a vertex is not inside of a tile elevation  is Zero. 
-
-****
-
-Taking interseption between points of six tile ( 5 * 5 * 6 ) and polygons will give necessery points. 
-
-In theory, That way we can contract polygon mesh that fits the Elevation model perfectly with minimal count of points.
-
-{
-If 'tiles' are not spontaninus. ve can predefine meshes acounding to current zoom level. If zoom level changes the shapes inside visibility bbox will be updated.
-}
-    
-
-
-Hasana sorular 
-
-Ekrana yüklenen ekrandaki yükseklikler merkez baz alınarak 6 tane
-
-5 * 5 * 6 ?
-
-bir anda sadece 6 tile in yükseikli ile mi çizim yapılmakta ?
-
-
-GLOBA bunları bboxları ile alabileceğim bir method çıkabilir miyiz?
-
-Dönen istekleri alabileceğim
-
---
-
-Hasan ile konuştum. 
-
-
----
-
-mesh 
-
-try mapbox delunay

package/semiplugins/shape-on-terrain/terrain-polygon/types.ts

@@ -1,69 +0,0 @@
-
-/**
- * @module WebGLobePlugins/SemiPlugins/ShapeOnTerrain/TerrainPolygon
- * @description
- * Type definitions for TerrainPolygon plugin
- * /
- * 
- */
-
-import { Color } from "../../../types";
-
-
-/**
- * @type PolygonInput
- * @description
- * Represents the input structure for defining a polygon on terrain.
- * Position starts with the shell vertices followed by hole vertices.
- * @param vertices - A flat array of vertex coordinates (e.g., [x1, y1, x2, y2, ...]).
- * @param holes - An array of indices indicating the start of each hole in the positions array.
- * @param dimensions - The number of dimensions for each vertex (typically 2 for 2D coordinates).
- */
-export type PolygonPluginInput = {
-    key: string;
-    geometry: { vertices: number[]; holes: number[] }[]
-    color?: Color;
-};
-
-export type TerrainPolygonOptions = {
-    pickable: boolean;
-    variativeColorsOn: boolean;
-    defaultColor: Color;
-    pickedColor: Color;
-    opacity: number;
-    showTesselationPoints: boolean;
-    pickedCallback?: (polygon: PolygonPluginInput | null) => void;
-}
-
-export type PolygonInput = PolygonPluginInput & { index: number };
-
-
-
-export type TrianglesMiddleData = {
-    key: string;
-    vertices: number[];
-    indices: number[];
-}
-
-export type BBOXZOOMDATA = {
-    minX: number,
-    minY: number,
-    maxX: number,
-    maxY: number,
-    zoom: number
-}[];
-
-export type WorkerInput = {
-    pickableState: boolean | undefined;
-    variativeColorsOn: boolean | undefined;
-    bboxes: BBOXZOOMDATA | null | undefined;
-    insertDeleteQueue: (PolygonPluginInput | string)[] | null | undefined;
-};
-
-export type WorkerOutput = {
-    vec3s: Float32Array;
-    indices: Uint32Array;
-    longLats: Float32Array;
-    pickIndices: Float32Array | null;
-    variativeColors: Float32Array | null;
-};

package/semiplugins/shell/bbox-renderer/index.ts

@@ -1,2 +0,0 @@
-import { BBOXGlobeShell } from './object'
-export { BBOXGlobeShell };