@pirireis/webglobeplugins 0.8.22 → 0.8.24

package/Math/arc.ts

@@ -115,8 +115,8 @@ export class Arc {
         const _yA = this.pointA.dot(A);
         const _yB = this.pointA.dot(B);
 
-        const _xA = _A_x_otherA.dot(this._AxB);
-        const _xB = _A_x_otherB.dot(this._AxB);
+        const _xA = _A_x_otherA.dot(this._imageinaryPlane.normal); //  this._AxB.normalize() == this._imageinaryPlane.normal
+        const _xB = _A_x_otherB.dot(this._imageinaryPlane.normal);
 
 
         if (_xA < 0 && _xB < 0) {
@@ -124,11 +124,11 @@ export class Arc {
                 throw new Error("A is before B with right hand rule but A is on the left side of the arc. This should not happen.");
             }
             return null; // no intersection
-        }
-        if (_yA < this._dot && _yB < this._dot) {
+        } else if (_xA > 0 && _xB > 0 && _yA < this._dot && _yB < this._dot) {
             return null; // no intersection
         }
 
+
         const resultPoints: [Vector3D, Vector3D] = [
             _xA < 0 ? this.pointA.clone() : A,
             _yB <= this._dot ? this.pointB.clone() : B
@@ -186,6 +186,8 @@ export class Arc {
 
         return points3D;
     }
+
+
     // cutBoundingBoxes(dotStep: number = 0.025): { minX: number, minY: number, maxX: number, maxY: number }[] {
     //     const pointA = this.pointA;
     //     const to = this.pointB;

package/Math/plane.ts

@@ -107,7 +107,7 @@ export class Plane {
     static fromGlobeLookInfo(centerLongitude: Radians, centerLatitude: Radians, distance: Meter, target: Plane): boolean {
         const radiansAngle = Math.PI * distance / WORLD_RADIUS_MERCATOR;
         target.normal.setFromLonLat(centerLongitude, centerLatitude).normalize();
-        target.constant = - Math.cos(radiansAngle);
+        target.constant = Math.cos(radiansAngle);
         return true;
     }
 

package/Math/vector3d.ts

@@ -58,6 +58,15 @@ export class Vector3D implements IVector3D {
 
 
 
+    angle(other: Vector3D): number {
+        const a = this.length();
+        const b = other.length();
+        const c = this.dot(other);
+        const angle = Math.acos(c / (a * b));
+
+        return isNaN(angle) ? 0 : angle;
+    }
+
     lerpVectors(a: Vector3D, b: Vector3D, t: number): Vector3D {
         this.x = a.x + (b.x - a.x) * t;
         this.y = a.y + (b.y - a.y) * t;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@pirireis/webglobeplugins",
-    "version": "0.8.22",
+    "version": "0.8.24",
     "main": "index.js",
     "author": "Toprak Nihat Deniz Ozturk",
     "license": "MIT"

package/tests/Math/arc.test.ts

@@ -48,27 +48,65 @@ test("intersectionMedium 2 - single point arc", () => {
 
 
 describe(`intersectionMedium 3 - return full arc`, () => {
-
-    for (let i = 0; i < 100; i++) {
-        test(`intersectionMedium 3 - return full arc  ${i} `, () => {
-            _medium.set(new Vector3D(0, 0, 1), 0.001);
+    let i = 0;
+    test(`intersectionMedium 3 - return full arc  ${i} `, () => {
+        for (let i = 0; i < 100; i++) {
+            _medium.set(new Vector3D(0, 0, 1), 0);
             _0vector.randomUnit();
-            _0vector.z = Math.abs(_0vector.z);
+            _0vector.z = Math.abs(_0vector.z); // make sure point is above the plane
             _1vector.randomUnit();
-            _1vector.z = Math.abs(_1vector.z);
+            _1vector.z = Math.abs(_1vector.z); // make sure point is above the plane
+            expect(Math.abs(_0vector.length() - 1) < 0.0001).toBeTruthy();
+            expect(Math.abs(_1vector.length() - 1) < 0.0001).toBeTruthy();
             _0arc.setFromUnitVectors(_0vector, _1vector);
 
             const _1arc = _0arc.intersectionMedium(_medium)!;
-            if (_1arc === null) {
-                console.log(_0arc, _medium);
-            }
+            // if (_1arc === null) {
+            //     console.log(_0arc, _medium);
+            // }
             expect(_1arc !== null).toBeTruthy();
             expect(_0arc.equals(_1arc)).toBeTruthy();
-        });
-    }
+        }
+    });
+});
+
+
+describe(`intersectionMedium 4 - return half arc`, () => {
+    let i = 0;
+    test(`intersectionMedium 4 - return half arc  ${i} `, () => {
+        for (let i = 0; i < 100; i++) {
+            _medium.set(new Vector3D(0, 0, 1), 0);
+
+            _0vector.randomUnit();
+            _1vector.copy(_0vector);
+            _1vector.z *= -1;
+
+            expect(Math.abs(_0vector.length() - 1) < 0.0001).toBeTruthy();
+            expect(Math.abs(_1vector.length() - 1) < 0.0001).toBeTruthy();
+            _0arc.setFromUnitVectors(_0vector, _1vector);
+
+            const _1arc = _0arc.intersectionMedium(_medium)!;
+            // if (_1arc === null) {
+            //     console.log(_0arc, _medium);
+            // }
+            expect(_1arc !== null).toBeTruthy();
+
+            expect([_1arc.pointA.z, _1arc.pointB.z].some((v) => v === 0)).toBeTruthy();
+
+            // expect(_0arc.equals(_1arc)).toBeTruthy();
+        }
+    });
 });
 
 
-test(" populatePoints3D", () => {
 
-});
+test("populatePoints3D 1", () => {
+    _0arc.setFromUnitVectors(new Vector3D(0, 1, 0), new Vector3D(0, 1, 0));
+    const result = _0arc.populatePoints3D(10);
+    expect(result.length).toBe(10 * 3);
+    _0vector.set(result[0], result[1], result[2]);
+    expect(_0vector.equals(_0arc.pointA)).toBeTruthy();
+    _0vector.set(result[27 + 0], result[27 + 1], result[27 + 2]);
+    expect(_0vector.equals(_0arc.pointB)).toBeTruthy();
+});
+

package/tests/Math/vector3d.test.ts

@@ -69,3 +69,36 @@ test('cross same and negated', () => {
 });
 
 
+// console.log
+// A Vector3D { x: 0.6389419688270773, y: -0.7692549385420794, z: 0 } B Vector3D { x: -0.6389419688270773, y: 0.7692549385420794, z: 0 } this.A Vector3D {
+//     x: -0.6002207824512262,
+//         y: -0.4133184680372552,
+//             z: 0.6847648182354102
+// }
+
+// at Arc.intersectionMedium(src / webglobeplugins / Math / arc.ts: 111: 17)
+
+// console.log
+// y < this._dot - 0.0655589757420102 0.0655589757420102 0.8489202601389976
+
+
+test('negated dot', () => {
+    const A = _0vector.randomUnit().clone();
+    const B = _0vector.randomUnit();
+
+    const result = A.dot(B);
+    const result2 = A.dot(B.negate());
+    expect(result).toBe(-result2);
+
+});
+
+
+
+
+test('cross', () => {
+    const A = _0vector.randomUnit().clone();
+    const B = _0vector.randomUnit();
+    const result = A.cross(B);
+    expect(result.equals(new Vector3D(0, 0, 0))).toBe(false);
+    expect(result.length()).toBeCloseTo(A.length() * B.length() * Math.sin(A.angle(B)), 1e-6);
+});

package/util/surface-line-data/arc-bboxes.ts

@@ -1,42 +1,42 @@
 
 
-function naiveBBox(a: number[], b: number[]): BBox {
-    return {
-        minX: Math.min(a[0], b[0]),
-        minY: Math.min(a[1], b[1]),
-        maxX: Math.max(a[0], b[0]),
-        maxY: Math.max(a[1], b[1])
-    };
+// function naiveBBox(a: number[], b: number[]): BBox {
+//     return {
+//         minX: Math.min(a[0], b[0]),
+//         minY: Math.min(a[1], b[1]),
+//         maxX: Math.max(a[0], b[0]),
+//         maxY: Math.max(a[1], b[1])
+//     };
 
-}
+// }
 
 
-function slerp(a: Vector, b: Vector, t: number, theta: number, sinTheta: number): Vector {
+// function slerp(a: Vector, b: Vector, t: number, theta: number, sinTheta: number): Vector {
 
-}
+// }
 
 
-function getArcBBoxes(arc: Arc, dotStep: number = 0.025): BBox[] {
-    const start = arc.start;
-    const end = arc.end;
-    const a = [start[0], start[1], start[2]];
-    const b = [end[0], end[1], end[2]];
+// function getArcBBoxes(arc: Arc, dotStep: number = 0.025): BBox[] {
+//     const start = arc.start;
+//     const end = arc.end;
+//     const a = [start[0], start[1], start[2]];
+//     const b = [end[0], end[1], end[2]];
 
 
 
 
-    const theta = Math.acos(a[0] * b[0] + a[1] * b[1] + a[2] * b[2]);
-    const step = dotStep / theta;
+//     const theta = Math.acos(a[0] * b[0] + a[1] * b[1] + a[2] * b[2]);
+//     const step = dotStep / theta;
 
-    if (step >= 1) {
-        return [naiveBBox(start, end)];
-    }
+//     if (step >= 1) {
+//         return [naiveBBox(start, end)];
+//     }
 
 
-    let points = [start] as Vector[];
+//     let points = [start] as Vector[];
 
 
-    let currentStep = 
+//     let currentStep =
 
-    return bbox;
-}
+//     return bbox;
+// }

package/util/surface-line-data/flow.ts

@@ -2,51 +2,51 @@
 
 
 
-class FlowManager {
-    _populateCount: number;
-    _rbush: RBush<any>;
-    _arcToCutsManager: ArcToCutsManager;
-    consturctor({ populateCount = 36, dotDistanceOfArcCuts = 1 / Math.pow(2, 10 - 1) }) {
-        this._populateCount = populateCount;
+// class FlowManager {
+//     _populateCount: number;
+//     _rbush: RBush<any>;
+//     _arcToCutsManager: ArcToCutsManager;
+//     consturctor({ populateCount = 36, dotDistanceOfArcCuts = 1 / Math.pow(2, 10 - 1) }) {
+//         this._populateCount = populateCount;
 
-        // does the cutting and id mapping(one to many)
-        // cuts have their bbox ready for rbush
-        this._rbush = new RBush(1000);
-        this._arcToCutsManager = new ArcToCutsManager({ dotDistanceOfArcCuts, rbush: this._rbush }); // 10km
+//         // does the cutting and id mapping(one to many)
+//         // cuts have their bbox ready for rbush
+//         this._rbush = new RBush(1000);
+//         this._arcToCutsManager = new ArcToCutsManager({ dotDistanceOfArcCuts, rbush: this._rbush }); // 10km
 
-    }
+//     }
 
 
 
 
 
-    /**
-     * adds or updates an arc in the rbush and the cuts manager
-     */
-    insertArc(arc: Arc) {
-        this._arcToCutsManager.insertArc(arc);
+//     /**
+//      * adds or updates an arc in the rbush and the cuts manager
+//      */
+//     insertArc(arc: Arc) {
+//         this._arcToCutsManager.insertArc(arc);
 
-    }
+//     }
 
 
 
-    deleteArc(id: Arc['id']) {
-        this._arcToCutsManager.deleteArc(id);
-    }
+//     deleteArc(id: Arc['id']) {
+//         this._arcToCutsManager.deleteArc(id);
+//     }
 
 
-    queryBBox(bbox: BBox) {
+//     queryBBox(bbox: BBox) {
 
-        const arcIDSet = new Set(this._rbush.query(bbox).map(x => x.id)); // sets Of ids of arcs 
+//         const arcIDSet = new Set(this._rbush.query(bbox).map(x => x.id)); // sets Of ids of arcs
 
-        // arcs U bbox => arcs
+//         // arcs U bbox => arcs
 
 
-        // populate points 
-        // return typed array of points belonging to all the arcs of cuts
-    }
+//         // populate points
+//         // return typed array of points belonging to all the arcs of cuts
+//     }
 
 
 
 
-}
+// }

package/waveparticles/plugin.js

@@ -191,17 +191,21 @@ export default class Plugin {
     }
 
 
-    setVectorFieldData(data, { dataWidth = null, dataHeight = null } = {}) {
+    setVectorFieldData(data, { dataWidth = null, dataHeight = null, flipY } = {}) {
         if (dataWidth !== null && dataHeight !== null) {
             this._dataWidth = dataWidth;
             this._dataHeight = dataHeight;
         }
+        if (flipY !== undefined) {
+            this._flipY = flipY;
+        }
         this.__data = data;
         const { gl, _dataWidth, _dataHeight } = this;
         gl.bindTexture(gl.TEXTURE_2D, this._rgVectorFieldTexture);
         gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, this._flipY);
         gl.texImage2D(gl.TEXTURE_2D, 0, gl.RG32F, _dataWidth, _dataHeight, 0, gl.RG, gl.FLOAT, data);
         gl.bindTexture(gl.TEXTURE_2D, null);
+        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
     }
 
 

package/wind/plugin.js

@@ -605,11 +605,8 @@ export default class WindPlugin {
 
         gl.useProgram(currentProgram);
 
-        if (this.coordinatesDataCalculator) {
-            const magnitude = imageToMagnitude(windData);
-            this.coordinatesDataCalculator.updateData(0, magnitude, magnitude);
 
-        }
+        this._setCoorcinatesDataCalculatorData();
         this.resize();
     }
 
@@ -640,10 +637,15 @@ export default class WindPlugin {
 
 
     _createPointCoordinatesDataCalculator() {
-        if (!this.windData) {
-            throw new Error("wind plugin. _createPointCoordinatesDataCalculator is called before wind data is set.");
-        }
         this.coordinatesDataCalculator = new PointCoordinatesDataCalculator(this.windData.bbox, this.windData.width, this.windData.height);
+        this._setCoorcinatesDataCalculatorData();
+    }
+
+
+    _setCoorcinatesDataCalculatorData() {
+        if (!this.windData || !this.coordinatesDataCalculator) {
+            return;
+        }
         const magnitude = imageToMagnitude(this.windData);
         this.coordinatesDataCalculator.updateData(0, magnitude, magnitude);
     }