@pirireis/webglobeplugins 0.17.1 → 1.0.2

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

@@ -0,0 +1,69 @@
+import { Color } from "../../../types";
+import { PolygonPluginInput } from "./types";
+
+
+function geoJSONToTerrainPolygon(geojson: any,
+    keyAdapter: (feature: any) => string,
+    colorAdapter: (feature: any) => Color | undefined
+): PolygonPluginInput[] {
+
+    if (geojson.type !== 'FeatureCollection') {
+        throw new Error('Invalid GeoJSON: Expected FeatureCollection');
+    }
+
+    const features = geojson.features;
+    const polygons: PolygonPluginInput[] = [];
+
+    for (const feature of features) {
+        const geometry = feature.geometry;
+        const key = keyAdapter(feature);
+        const color = colorAdapter(feature);
+        const geometries: { vertices: number[]; holes: number[] }[] = [];
+
+        if (geometry.type === 'Polygon') {
+            const coordinates = geometry.coordinates;
+            const vertices: number[] = [];
+            const holes: number[] = [];
+            let holeIndex = 0;
+            for (let i = 0; i < coordinates.length; i++) {
+                if (i > 0) {
+                    holeIndex += coordinates[i - 1].length;
+                    holes.push(holeIndex);
+                }
+                for (const coord of coordinates[i]) {
+                    vertices.push(coord[0], coord[1]);
+                }
+            }
+            geometries.push({ vertices, holes });
+        } else if (geometry.type === 'MultiPolygon') {
+            const multiCoordinates = geometry.coordinates;
+            for (const coordinates of multiCoordinates) {
+                const vertices: number[] = [];
+                const holes: number[] = [];
+                let holeIndex = 0;
+                for (let i = 0; i < coordinates.length; i++) {
+                    if (i > 0) {
+                        holeIndex += coordinates[i - 1].length;
+                        holes.push(holeIndex);
+                    }
+                    for (const coord of coordinates[i]) {
+                        vertices.push(coord[0], coord[1]);
+                    }
+                }
+                geometries.push({ vertices, holes });
+            }
+        } else {
+            continue; // Skip non-polygon geometries
+        }
+
+        if (geometries.length > 0) {
+            polygons.push({ key, color, geometry: geometries });
+        }
+    }
+
+    return polygons;
+
+}
+
+
+export { geoJSONToTerrainPolygon };

package/semiplugins/shape-on-terrain/terrain-polygon/data/cache-shortcuts.md

@@ -0,0 +1,20 @@
+1) Tüm üçgenlerin özetini bufferlarda tutmak zoom 0 göre partition
+1 problem 1) eğer üçgen çok büyükse, 3d de küre oturmaz, 2d de gerekli alanı kaplamaz
+1 problem 2) Cachelenmiş hızlı yüklenen çıktılar main threaddemi, tüm işlemleri yapan webworkerda mı yoksa yeni bir workerdamı tutulacak?
+
+ Webworker problemi: Şu an webworkera bir aracı ile veri gönderilip alınıyor. Aracı webworker işlemdeyken gelen yazma silme işlemlerini istifliyor, tile işlemlerinin ise üzerine yazıyor. Webworker cevap gönderdiğinde onun boşaldığını anlıyor. Biriktirdiği tüm işlemleri tek seferde yolluyor. 
+
+MessageChannel API (Doğrudan İletişim): Araştıracağım!!!!
+
+
+
+2) Görünmüyorsa, hesaplarken O an ekrandaki en derin zoom seviyesindeki parkenin bile kenarından 100 kat küçükse üçgen atlanabilir. 
+
+Bu hesaplamada üçgenin uzun kenarı ile parkenin kenarı kıyaslanır. polygonlar çok ince ama uzun üçgenler içerebiliyor. 
+Alan hesaplandığında bu kenarlar eleniyor. Ancak kenar uzunluğu kullanıldığında polygon biraz küçültülerek basitleştirilmiş gibi gözüküyor
+
+2 problemi) Küçücük üçgenelere bölünmüş büyük polygonlar düşük zoom seviyelerinde çok fazla budanıyor. 
+
+2 avantajı) gözükmeyen üçgenler gpu bufferda yer tutmuyor ve işlemci zamanı harcamıyor
+
+

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

@@ -0,0 +1,149 @@
+import { TrianglesMiddleData } from "../types";
+import { TriangleTessellationMeta, createTriangleTessellationMeta } from "../../../../Math/tessellation/triangle-tessellation";
+import { triangulation } from "./polygon-to-triangles";
+import { Color, GlobeBBox } from "../../../../types";
+import { LongLat } from "../../../../Math/types";
+import { CatchedType } from "./types";
+
+import { PolygonProperties, CacheTriangle } from "./types";
+import RBush from "rbush";
+import { RADIAN } from "../../../../Math/methods";
+import { PolygonInput } from "../types";
+
+type BBOXES = {
+    zoom: number,
+    minX: number,
+    minY: number,
+    maxX: number,
+    maxY: number
+}
+
+
+// TODO: use type instead of any
+function _entry(polygon: PolygonInput, kmThreshold: number): CatchedType[] {
+    __polygonInputWGS84ToRadian(polygon);
+    const trianglesData: TrianglesMiddleData = triangulation(polygon, kmThreshold);
+    const cacheTriangles: CatchedType[] = [];
+
+
+    for (let i = 0; i < trianglesData.indices.length; i += 3) {
+
+        const idx0 = trianglesData.indices[i] * 2;
+        const idx1 = trianglesData.indices[i + 1] * 2;
+        const idx2 = trianglesData.indices[i + 2] * 2;
+
+        const v0 = [trianglesData.vertices[idx0], trianglesData.vertices[idx0 + 1]] as LongLat;
+        const v1 = [trianglesData.vertices[idx1], trianglesData.vertices[idx1 + 1]] as LongLat;
+        const v2 = [trianglesData.vertices[idx2], trianglesData.vertices[idx2 + 1]] as LongLat;
+
+        const tessellationMeta = createTriangleTessellationMeta(v0, v1, v2);
+
+        cacheTriangles.push({
+            polygon: polygon,
+            offset: i / 3,
+            tessellationMeta: tessellationMeta,
+            minX: tessellationMeta.bbox.min[0],
+            minY: tessellationMeta.bbox.min[1],
+            maxX: tessellationMeta.bbox.max[0],
+            maxY: tessellationMeta.bbox.max[1],
+        });
+    }
+    return cacheTriangles;
+}
+
+
+function __polygonInputWGS84ToRadian(polygon: PolygonInput) {
+    for (const geom of polygon.geometry) {
+        const vertices: number[] = geom.vertices;
+        for (let i = 0; i < vertices.length / 2; i++) {
+            vertices[i * 2] = vertices[i * 2] * RADIAN;
+            vertices[i * 2 + 1] = vertices[i * 2 + 1] * RADIAN;
+        }
+    }
+}
+
+export class Cache {
+    private cache: Map<string,
+        {
+            polygon: PolygonInput,
+            triangles: CatchedType[]
+        }> = new Map();
+    private kmThreshold: number;
+    private rbush: RBush = new RBush();
+    private bboxes: BBOXES[] = [];
+    constructor(kmThreshold: number) {
+        this.kmThreshold = kmThreshold;
+    }
+
+
+    clear(): void {
+        this.cache.clear();
+        this.rbush.clear();
+    }
+
+
+
+    insert(key: string, polygon: PolygonInput): void {
+        if (this.cache.has(key)) {
+            this.remove(key);
+        }
+        const triangles = _entry(polygon as PolygonInput, this.kmThreshold);
+        this.rbush.load(triangles);
+        this.cache.set(key, { polygon: polygon as PolygonInput, triangles });
+    }
+
+
+    remove(key: string): void {
+        const entry = this.cache.get(key);
+        if (entry) {
+            for (const triangle of entry.triangles) {
+                this.rbush.remove(triangle);
+            }
+            this.cache.delete(key);
+        }
+    }
+
+
+    setBBOXes(BBOXES: BBOXES[]): void {
+        this.bboxes = BBOXES;
+    }
+
+    search(): Set<CatchedType> {
+        const results = new Set<CatchedType>();
+        for (const bbox of this.bboxes) {
+            const { minX, minY, maxX, maxY } = bbox;
+            if (minX <= maxX && minY <= maxY) {
+                // Normal case
+                const partialResults = this.rbush.search({ minX, minY, maxX, maxY }) as CatchedType[];
+                for (const res of partialResults) {
+                    results.add(res);
+                }
+            } else {
+                // Handle antimeridian crossing
+                // MinX > MaxX case is the signal.
+                const partialResults1 = this.rbush.search({ minX, minY, maxX: Math.PI, maxY }) as CatchedType[];
+                const partialResults2 = this.rbush.search({ minX: -Math.PI, minY, maxX, maxY }) as CatchedType[];
+                for (const res of partialResults1) {
+                    results.add(res);
+                }
+                for (const res of partialResults2) {
+                    results.add(res);
+                }
+            }
+
+        }
+        return results;
+    }
+
+
+
+    defragment(): void {
+        const allItems = this.rbush.all() as CatchedType[];
+        this.rbush.clear();
+        this.rbush.load(allItems);
+    }
+
+
+
+
+}

package/semiplugins/shape-on-terrain/terrain-polygon/data/index-polygon-map.ts

@@ -0,0 +1,58 @@
+import { PolygonInput, PolygonPluginInput } from "../types";
+
+export class IndexPolygonMap {
+
+    private _indexPolygonMap: Map<number, PolygonInput> = new Map();
+    private _polygonKeyMap: Map<string, number> = new Map();
+    private _thumbstones: number[] = [];
+    private _polygonIndex: number = 1; // 0 index is null
+
+    constructor() { }
+
+    private newIndex(): number {
+        if (this._thumbstones.length > 0) {
+            return this._thumbstones.pop() as number;
+        }
+        return this._polygonIndex++;
+    }
+
+    insertBulk(polygons: PolygonPluginInput[]) {
+
+        for (const poly of polygons) {
+            if (this._polygonKeyMap.has(poly.key)) {
+                this.deleteBulk([poly.key]);
+            }
+            const index = this.newIndex();
+            // @ts-ignore
+            poly.index = index; // Assign the new index to the polygon
+            this._indexPolygonMap.set(index, poly as PolygonInput);
+            this._polygonKeyMap.set(poly.key, index);
+        }
+
+        return polygons as PolygonInput[];
+    }
+
+    deleteBulk(keys: string[]) {
+        for (const key of keys) {
+            const index = this._polygonKeyMap.get(key);
+            if (index === undefined) continue;
+            this._polygonKeyMap.delete(key);
+            this._indexPolygonMap.delete(index);
+            this._thumbstones.push(index);
+        }
+    }
+
+
+    get(index: number): PolygonPluginInput | null {
+        return this._indexPolygonMap.get(index) || null;
+    }
+
+
+    clear() {
+        this._indexPolygonMap.clear();
+        this._polygonKeyMap.clear();
+        this._thumbstones = [];
+        this._polygonIndex = 1;
+    }
+}
+

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

@@ -0,0 +1,4 @@
+// this is the glue binds data to plugin
+// plugin inserts data to this.
+// plugin send bboxes and zoom levels and expects data ready to be looaded on polygon program
+

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

@@ -0,0 +1,196 @@
+/// <reference lib="webworker" />
+
+const _workers = [];
+const _workerMap = new Map();
+let _maxWorkers = 4; // Default, updated in init
+let _nextWorkerIndex = 0;
+
+// Configuration state to pass to new workers or re-broadcast
+let _pickableState;
+let _variativeColorsOn;
+
+// Initialize workers
+function initWorkers() {
+    _maxWorkers = Math.max(1, (navigator.hardwareConcurrency / 2 || 3) - 1);
+    for (let i = 0; i < _maxWorkers; i++) {
+        addWorker();
+    }
+}
+
+function addWorker() {
+    const worker = new Worker(new URL("./worker.js", import.meta.url), { type: 'module' });
+
+    const wrapper = {
+        worker,
+        inProgress: false,
+        insertDeleteQueue: [],
+        lastBBOXData: null,
+        itemCount: 0,
+        lastOutput: null
+    };
+
+    worker.onmessage = (event) => {
+        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 = [];
+
+    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 = {
+        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
+    // eslint-disable-next-line no-restricted-globals
+    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) {
+    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,
+    });
+
+    wrapper.lastBBOXData = null;
+    wrapper.insertDeleteQueue = [];
+}
+
+function triggerAllWorkers() {
+    for (const w of _workers) {
+        sendToSubWorker(w);
+    }
+}
+
+// Handle messages from Main Thread
+// eslint-disable-next-line no-restricted-globals
+self.onmessage = (event) => {
+    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);
+                }
+            }
+        }
+    } triggerAllWorkers();
+};