@pirireis/webglobeplugins 1.0.2 → 1.0.3

package/semiplugins/shape-on-terrain/terrain-polygon/data/{random.ts → random.js}

@@ -1,165 +1,121 @@
-/**
- * Generates random polygon data for testing PolygonPluginInput
- */
-
-import { GlobeBBox } from "../../../../types";
-
-/**
- * Generates a random polygon with optional holes
- * @param {Object} options - Configuration options
- * @param {number} options.minVertices - Minimum number of vertices for the shell (default: 3)
- * @param {number} options.maxVertices - Maximum number of vertices for the shell (default: 8)
- * @param {number} options.holeCount - Number of holes to generate (default: 0)
- * @param {number} options.minLat - Minimum latitude (default: -85)
- * @param {number} options.maxLat - Maximum latitude (default: 85)
- * @param {number} options.minLng - Minimum longitude (default: -180)
- * @param {number} options.maxLng - Maximum longitude (default: 180)
- * @param {number} options.dimensions - Number of dimensions per vertex (default: 2)
- * @returns {Object} PolygonPluginInput object
- */
-function generateRandomPolygon(options: {
-    minVertices?: number;
-    maxVertices?: number;
-    holeCount?: number;
-    minLat?: number;
-    maxLat?: number;
-    minLng?: number;
-    maxLng?: number;
-    radius?: number;
-    dimensions?: number;
-} = {}) {
-    const {
-        minVertices = 3,
-        maxVertices = 8,
-        holeCount = 0,
-        minLat = -85,
-        maxLat = 85,
-        minLng = -180,
-        maxLng = 180,
-        dimensions = 2,
-        radius = 4,
-    } = options;
-
-    const key = `polygon_${Date.now()}_${Math.floor(Math.random() * 1000)}_${Math.random()}`;
-    const vertices = [];
-    const holes = [];
-
-    // Generate shell vertices
-    const shellVertexCount = Math.floor(Math.random() * (maxVertices - minVertices + 1)) + minVertices;
-    const centerLng = Math.random() * (maxLng - minLng) + minLng;
-    const centerLat = Math.random() * (maxLat - minLat) + minLat;
-
-    // Generate shell as a rough circle with random variations
-    for (let i = 0; i < shellVertexCount; i++) {
-        const angle = (i / shellVertexCount) * 2 * Math.PI;
-        const radiusVariation = radius * (0.7 + Math.random() * 0.6); // Add variation to radius
-        const lng = centerLng + Math.cos(angle) * radiusVariation;
-        const lat = centerLat + Math.sin(angle) * radiusVariation;
-
-        vertices.push(lng, lat);
-        if (dimensions > 2) {
-            for (let d = 2; d < dimensions; d++) {
-                vertices.push(Math.random() * 1000); // Random additional dimensions
-            }
-        }
-    }
-
-    // Generate holes
-    for (let h = 0; h < holeCount; h++) {
-        const holeStartIndex = vertices.length / dimensions;
-        holes.push(holeStartIndex);
-
-        const holeVertexCount = Math.floor(Math.random() * 4) + 3; // 3-6 vertices for holes
-        const holeRadius = radius * (0.2 + Math.random() * 0.3); // Smaller radius for holes
-        const holeCenterLng = centerLng + (Math.random() - 0.5) * radius * 0.8;
-        const holeCenterLat = centerLat + (Math.random() - 0.5) * radius * 0.8;
-
-        for (let i = 0; i < holeVertexCount; i++) {
-            const angle = (i / holeVertexCount) * 2 * Math.PI;
-            const lng = holeCenterLng + Math.cos(angle) * holeRadius;
-            const lat = holeCenterLat + Math.sin(angle) * holeRadius;
-
-            vertices.push(lng, lat);
-            if (dimensions > 2) {
-                for (let d = 2; d < dimensions; d++) {
-                    vertices.push(Math.random() * 1000);
-                }
-            }
-        }
-    }
-
-    return {
-        key,
-        geometry: [{ vertices, holes }],
-        color: [Math.random(), Math.random(), Math.random(), 1.0],
-    };
-}
-
-/**
- * Generates multiple random polygons
- * @param {number} count - Number of polygons to generate
- * @param {Object} options - Options to pass to generateRandomPolygon
- * @returns {Array} Array of PolygonPluginInput objects
- */
-function generateRandomPolygons(count: number, options = {}) {
-    const polygons = [];
-    for (let i = 0; i < count; i++) {
-        polygons.push(generateRandomPolygon(options));
-    }
-    return polygons;
-}
-
-/**
- * Generates a simple rectangular polygon for basic testing
- * @param {number} lng - Center longitude
- * @param {number} lat - Center latitude
- * @param {number} width - Width in degrees
- * @param {number} height - Height in degrees
- * @returns {Object} PolygonPluginInput object
- */
-function generateRectanglePolygon(lng = 0, lat = 0, width = 2, height = 1) {
-    const halfWidth = width / 2;
-    const halfHeight = height / 2;
-
-    return {
-        key: `rectangle_${Date.now()}`,
-        geometry: [{
-            vertices: [
-                lng - halfWidth, lat - halfHeight,  // Bottom-left
-                lng + halfWidth, lat - halfHeight,  // Bottom-right
-                lng + halfWidth, lat + halfHeight,  // Top-right
-                lng - halfWidth, lat + halfHeight   // Top-left
-            ],
-            holes: []
-        }]
-    };
-}
-
-function generateRectangleFromBBOX(bbox: GlobeBBox, key: string | null = null) {
-    const { ll, ur } = bbox;
-    return {
-        key: key || `rectangle_${Date.now()}`,
-        geometry: [{
-            vertices: [
-                ll.x, ll.y,  // Bottom-left
-                ur.x, ll.y,  // Bottom-right
-                ur.x, ur.y,  // Top-right
-                ll.x, ur.y   // Top-left
-            ],
-            holes: []
-        }]
-    };
-}
-
-// // Example usage:
-// console.log('Polygon with holes:', generateRandomPolygon({ holeCount: 2 }));
-// console.log('Multiple polygons:', generateRandomPolygons(3));
-// console.log('Rectangle polygon:', generateRectanglePolygon(-74, 40.7, 0.1, 0.05));
-
-export {
-    generateRandomPolygon,
-    generateRandomPolygons,
-    generateRectanglePolygon,
-    generateRectangleFromBBOX
-};
-
+/**
+ * Generates random polygon data for testing PolygonPluginInput
+ */
+/**
+ * Generates a random polygon with optional holes
+ * @param {Object} options - Configuration options
+ * @param {number} options.minVertices - Minimum number of vertices for the shell (default: 3)
+ * @param {number} options.maxVertices - Maximum number of vertices for the shell (default: 8)
+ * @param {number} options.holeCount - Number of holes to generate (default: 0)
+ * @param {number} options.minLat - Minimum latitude (default: -85)
+ * @param {number} options.maxLat - Maximum latitude (default: 85)
+ * @param {number} options.minLng - Minimum longitude (default: -180)
+ * @param {number} options.maxLng - Maximum longitude (default: 180)
+ * @param {number} options.dimensions - Number of dimensions per vertex (default: 2)
+ * @returns {Object} PolygonPluginInput object
+ */
+function generateRandomPolygon(options = {}) {
+    const { minVertices = 3, maxVertices = 8, holeCount = 0, minLat = -85, maxLat = 85, minLng = -180, maxLng = 180, dimensions = 2, radius = 4, } = options;
+    const key = `polygon_${Date.now()}_${Math.floor(Math.random() * 1000)}_${Math.random()}`;
+    const vertices = [];
+    const holes = [];
+    // Generate shell vertices
+    const shellVertexCount = Math.floor(Math.random() * (maxVertices - minVertices + 1)) + minVertices;
+    const centerLng = Math.random() * (maxLng - minLng) + minLng;
+    const centerLat = Math.random() * (maxLat - minLat) + minLat;
+    // Generate shell as a rough circle with random variations
+    for (let i = 0; i < shellVertexCount; i++) {
+        const angle = (i / shellVertexCount) * 2 * Math.PI;
+        const radiusVariation = radius * (0.7 + Math.random() * 0.6); // Add variation to radius
+        const lng = centerLng + Math.cos(angle) * radiusVariation;
+        const lat = centerLat + Math.sin(angle) * radiusVariation;
+        vertices.push(lng, lat);
+        if (dimensions > 2) {
+            for (let d = 2; d < dimensions; d++) {
+                vertices.push(Math.random() * 1000); // Random additional dimensions
+            }
+        }
+    }
+    // Generate holes
+    for (let h = 0; h < holeCount; h++) {
+        const holeStartIndex = vertices.length / dimensions;
+        holes.push(holeStartIndex);
+        const holeVertexCount = Math.floor(Math.random() * 4) + 3; // 3-6 vertices for holes
+        const holeRadius = radius * (0.2 + Math.random() * 0.3); // Smaller radius for holes
+        const holeCenterLng = centerLng + (Math.random() - 0.5) * radius * 0.8;
+        const holeCenterLat = centerLat + (Math.random() - 0.5) * radius * 0.8;
+        for (let i = 0; i < holeVertexCount; i++) {
+            const angle = (i / holeVertexCount) * 2 * Math.PI;
+            const lng = holeCenterLng + Math.cos(angle) * holeRadius;
+            const lat = holeCenterLat + Math.sin(angle) * holeRadius;
+            vertices.push(lng, lat);
+            if (dimensions > 2) {
+                for (let d = 2; d < dimensions; d++) {
+                    vertices.push(Math.random() * 1000);
+                }
+            }
+        }
+    }
+    return {
+        key,
+        geometry: [{ vertices, holes }],
+        color: [Math.random(), Math.random(), Math.random(), 1.0],
+    };
+}
+/**
+ * Generates multiple random polygons
+ * @param {number} count - Number of polygons to generate
+ * @param {Object} options - Options to pass to generateRandomPolygon
+ * @returns {Array} Array of PolygonPluginInput objects
+ */
+function generateRandomPolygons(count, options = {}) {
+    const polygons = [];
+    for (let i = 0; i < count; i++) {
+        polygons.push(generateRandomPolygon(options));
+    }
+    return polygons;
+}
+/**
+ * Generates a simple rectangular polygon for basic testing
+ * @param {number} lng - Center longitude
+ * @param {number} lat - Center latitude
+ * @param {number} width - Width in degrees
+ * @param {number} height - Height in degrees
+ * @returns {Object} PolygonPluginInput object
+ */
+function generateRectanglePolygon(lng = 0, lat = 0, width = 2, height = 1) {
+    const halfWidth = width / 2;
+    const halfHeight = height / 2;
+    return {
+        key: `rectangle_${Date.now()}`,
+        geometry: [{
+                vertices: [
+                    lng - halfWidth, lat - halfHeight, // Bottom-left
+                    lng + halfWidth, lat - halfHeight, // Bottom-right
+                    lng + halfWidth, lat + halfHeight, // Top-right
+                    lng - halfWidth, lat + halfHeight // Top-left
+                ],
+                holes: []
+            }]
+    };
+}
+function generateRectangleFromBBOX(bbox, key = null) {
+    const { ll, ur } = bbox;
+    return {
+        key: key || `rectangle_${Date.now()}`,
+        geometry: [{
+                vertices: [
+                    ll.x, ll.y, // Bottom-left
+                    ur.x, ll.y, // Bottom-right
+                    ur.x, ur.y, // Top-right
+                    ll.x, ur.y // Top-left
+                ],
+                holes: []
+            }]
+    };
+}
+// // Example usage:
+// console.log('Polygon with holes:', generateRandomPolygon({ holeCount: 2 }));
+// console.log('Multiple polygons:', generateRandomPolygons(3));
+// console.log('Rectangle polygon:', generateRectanglePolygon(-74, 40.7, 0.1, 0.05));
+export { generateRandomPolygon, generateRandomPolygons, generateRectanglePolygon, generateRectangleFromBBOX };

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

@@ -0,0 +1 @@
+export {};

package/semiplugins/shape-on-terrain/terrain-polygon/data/{worker-contact.ts → worker-contact.js}

@@ -1,81 +1,63 @@
-import { PolygonInput, TerrainPolygonOptions } from "../types";
-import { WorkerInput, WorkerOutput, BBOXZOOMDATA } from "../types";
-import { Globe } from "../../../../types";
-import { MergedTilesInfo } from "../../../../Math/tessellation/tile-merger";
-import { DemTextureManager, DemTextureManagerCache } from "../../../../programs/totems/dem-textures-manager";
-import { RADIAN } from "../../../../Math/methods";
-
-export class WorkerContact {
-    private _masterWorker: Worker;
-    private _options: Pick<TerrainPolygonOptions, "pickable" | "variativeColorsOn">;
-    private onResult: (result: WorkerOutput) => void;
-    private demTextureManager: DemTextureManager = null as any;
-
-    constructor(globe: Globe, options: Pick<TerrainPolygonOptions, "pickable" | "variativeColorsOn">, onResult: (result: WorkerOutput) => void) {
-        this._options = options;
-        this.onResult = onResult;
-
-        // Initialize the Master Worker
-        // @ts-ignore
-        this._masterWorker = new Worker(new URL("./master-worker.js", import.meta.url), { type: 'module' });
-
-        this._masterWorker.onmessage = (event: MessageEvent<WorkerOutput>) => {
-            this.onResult(event.data);
-        }
-
-        // Initialize Master Worker state
-        this._masterWorker.postMessage({
-            pickableState: this._options.pickable,
-            variativeColorsOn: this._options.variativeColorsOn,
-            insertDeleteQueue: [],
-            bboxes: null,
-        } as WorkerInput);
-
-        this.demTextureManager = DemTextureManagerCache.get(globe);
-        this.demTextureManager.register(this);
-    }
-
-    setMergedTiles(mergedTilesInfo: MergedTilesInfo[]) {
-        const bboxesData: BBOXZOOMDATA = new Array(mergedTilesInfo.length);
-        for (let i = 0; i < mergedTilesInfo.length; i++) {
-            const { bbox, zoom } = mergedTilesInfo[i];
-            bboxesData[i] = {
-                zoom: zoom,
-                minX: bbox.ll.x * RADIAN,
-                minY: bbox.ll.y * RADIAN,
-                maxX: bbox.ur.x * RADIAN,
-                maxY: bbox.ur.y * RADIAN,
-            };
-        }
-
-        // Send BBOX updates to Master Worker
-        this._masterWorker.postMessage({
-            bboxes: bboxesData
-        } as Partial<WorkerInput>);
-    }
-
-    free() {
-        this.demTextureManager.unregister(this);
-        this._masterWorker.terminate();
-    }
-
-    insertBulk(polygons: PolygonInput[]) {
-        this._masterWorker.postMessage({
-            insertDeleteQueue: polygons
-        } as Partial<WorkerInput>);
-    }
-
-    deleteBulk(keys: string[]) {
-        this._masterWorker.postMessage({
-            insertDeleteQueue: keys
-        } as Partial<WorkerInput>);
-    }
-
-    clear() {
-        this._masterWorker.postMessage({
-            insertDeleteQueue: ["__CLEAR_ALL_ITEMS__"]
-        } as Partial<WorkerInput>);
-    }
-}
-
-
+import { DemTextureManagerCache } from "../../../../programs/totems/dem-textures-manager";
+import { RADIAN } from "../../../../Math/methods";
+export class WorkerContact {
+    _masterWorker;
+    _options;
+    onResult;
+    demTextureManager = null;
+    constructor(globe, options, onResult) {
+        this._options = options;
+        this.onResult = onResult;
+        // Initialize the Master Worker
+        // @ts-ignore
+        this._masterWorker = new Worker(new URL("./master-worker.js", import.meta.url), { type: 'module' });
+        this._masterWorker.onmessage = (event) => {
+            this.onResult(event.data);
+        };
+        // Initialize Master Worker state
+        this._masterWorker.postMessage({
+            pickableState: this._options.pickable,
+            variativeColorsOn: this._options.variativeColorsOn,
+            insertDeleteQueue: [],
+            bboxes: null,
+        });
+        this.demTextureManager = DemTextureManagerCache.get(globe);
+        this.demTextureManager.register(this);
+    }
+    setMergedTiles(mergedTilesInfo) {
+        const bboxesData = new Array(mergedTilesInfo.length);
+        for (let i = 0; i < mergedTilesInfo.length; i++) {
+            const { bbox, zoom } = mergedTilesInfo[i];
+            bboxesData[i] = {
+                zoom: zoom,
+                minX: bbox.ll.x * RADIAN,
+                minY: bbox.ll.y * RADIAN,
+                maxX: bbox.ur.x * RADIAN,
+                maxY: bbox.ur.y * RADIAN,
+            };
+        }
+        // Send BBOX updates to Master Worker
+        this._masterWorker.postMessage({
+            bboxes: bboxesData
+        });
+    }
+    free() {
+        this.demTextureManager.unregister(this);
+        this._masterWorker.terminate();
+    }
+    insertBulk(polygons) {
+        this._masterWorker.postMessage({
+            insertDeleteQueue: polygons
+        });
+    }
+    deleteBulk(keys) {
+        this._masterWorker.postMessage({
+            insertDeleteQueue: keys
+        });
+    }
+    clear() {
+        this._masterWorker.postMessage({
+            insertDeleteQueue: ["__CLEAR_ALL_ITEMS__"]
+        });
+    }
+}