@pirireis/webglobeplugins 0.11.0-alpha → 0.12.0-alpha

package/shape-on-terrain/arc/naive/plugin.js

@@ -1,289 +1,205 @@
-"use strict";
-// import { LineStripProgramCache } from "../../../programs/line-on-globe/linestrip"
-// import "../../../programs/interface";
-// import { createBufferAndReadInfo } from '../../../util/gl-util/buffer/attribute-loader';
+import { LineStripProgramCache } from "../../../programs/line-on-globe/linestrip";
+import { createBufferAndReadInfo } from '../../../util/gl-util/buffer/attribute-loader';
 // import { populateFloat32Array } from "../../../util/jshelpers/data-filler";
-// import { BufferManagementMap, BufferManager, BufferOrchestrator } from "../../../util/account/single-attribute-buffer-management/index";
-// import { globe3Dcoordinates, globe2Dcoordinates, RADIANS } from "../../../Math/methods";
-// import { generateArcPoints } from "../../../Math/arc-generate-points";
-// import { Vec3, Plane, Arc } from "../../../Math/types";
-// import * as vec3 from "../../../Math/vec3";
-// import * as plane from "../../../Math/plane";
-// import * as arc from "../../../Math/arc";
-// // import { arcFrustumPlanesIntersection } from "../../../Math/intersections/arc-frustum-planes";
-// import CameraUniformBlockTotem, { CameraUniformBlockTotemCache } from "../../../programs/totems/camerauniformblock";
-// import { FrustumPlanes } from "../../../Math/frustum/types";
-// const VERTEX_COUNT = 360;
-// const INITAL_CAPACITY = 10;
-// const _0vector = [0, 0, 0] as Vec3;
-// const _attractionPoint = [0, 0, 0] as Vec3;
-// const _start = [0, 0, 0] as Vec3;
-// const _end = [0, 0, 0] as Vec3;
-// const _0arc = arc.create([1, 0, 0] as Vec3, [0, 1, 0] as Vec3); // zero arc for intersection tests
-// // window add properties
-// declare global {
-//     interface Window {
-//         startPoint: Vec3;
-//         endPoint: Vec3;
-//     }
-// }
-// let interval = 1;
-// export class NaiveLineOnTerrainPlugin {
-//     public id: string;
-//     private program: ProgramInterface | null = null;
-//     private _bufferManagersCompMap: BufferManagementMap | null = null;
-//     private _bufferManagersCompMapTest: BufferManagementMap | null = null;
-//     private _bufferOrchestrator: BufferOrchestrator = new BufferOrchestrator({ capacity: INITAL_CAPACITY });
-//     private _testOrchestrator: BufferOrchestrator = new BufferOrchestrator({ capacity: INITAL_CAPACITY });
-//     private _opacity: number = 1;
-//     private _arcUBOHandler: UBOHandler | null = null;
-//     private _vao: WebGLVertexArrayObject | null = null;
-//     private _vaoAllTest: WebGLVertexArrayObject | null = null;
-//     private _ubohandlerAllTest: UBOHandler | null = null;
-//     private globe: any | null = null;
-//     private gl: WebGL2RenderingContext | null = null;
-//     private _arcMap: Map<string, Arc>;
-//     private _arcMapTest: Map<string, Arc>;
-//     private _screenPlane: Plane = { normal: [0, 0, 1] as Vec3, distance: 0 } as Plane;
-//     private _doBuild: boolean = false
-//     private _cameraUniformBlock: CameraUniformBlockTotem | null = null;
-//     private _attractionStrength: number = 50;
-//     public fieldOfView = 50 * RADIANS; // 50 degrees in radians
-//     constructor(id: string) {
-//         this.id = id;
-//         this._arcMap = new Map();
-//         this._arcMapTest = new Map();
-//     }
-//     insertArcFromLongLat(key: string, startPoint: { long: number, lat: number }, endPoint: { long: number, lat: number }) {
-//         if (this._arcMap.has(key)) {
-//             this._arcMap.delete(key);
-//         }
-//         vec3.fromUnitVectorLongLat(_start, [startPoint.long * RADIANS, startPoint.lat * RADIANS]);
-//         vec3.fromUnitVectorLongLat(_end, [endPoint.long * RADIANS, endPoint.lat * RADIANS]);
-//         window.startPoint = _start;
-//         window.endPoint = _end;
-//         const _arc = arc.create(_start, _end);
-//         this._arcMap.set(key, _arc);
-//         this._arcMapTest.set(key, arc.clone(_arc));
-//         // const longLatArr = new Float32Array(2 * VERTEX_COUNT);
-//         // //
-//         // const _3Dpoints = generateArcPoints(_start, _end, VERTEX_COUNT);
-//         // const longLat = {
-//         //     long: 1,
-//         //     lat: 1
-//         // };
-//         // for (let i = 0; i < _3Dpoints.length / 3; i++) {
-//         //     _0vector.set(_3Dpoints[i * 3], _3Dpoints[i * 3 + 1], _3Dpoints[i * 3 + 2]).toLongLat(longLat);
-//         //     longLatArr.set([longLat.long / RADIANS, longLat.lat / RADIANS], i * 2);
-//         // }
-//         // const result = [{
-//         //     key: key,
-//         //     longLatArr: longLatArr,
-//         // }
-//         // ]
-//         // this._testOrchestrator.insertBulk(result, this._bufferManagersCompMapTest);
-//         this._doBuild = true;
-//         this.globe.DrawRender();
-//     }
-//     init(globe: any, gl: WebGL2RenderingContext) {
-//         this.globe = globe;
-//         this.gl = gl;
-//         this.program = LineStripProgramCache.get(globe);
-//         const g3D = globe3Dcoordinates(globe, 30);
-//         const g2D = globe2Dcoordinates(globe);
-//         this._cameraUniformBlock = CameraUniformBlockTotemCache.get(globe);
-//         this._bufferManagersCompMap = new Map(
-//             [
-//                 ["position3d", {
-//                     bufferManager: new BufferManager(gl, 3 * (VERTEX_COUNT + 1), { bufferType: "DYNAMIC_DRAW", initialCapacity: INITAL_CAPACITY }),
-//                     adaptor: (item: any) => {
-//                         const { longLatArr } = item;
-//                         const result = g3D(longLatArr, { paddingCount: 1 });
-//                         // console.log("result", result);
-//                         return result;
-//                     }
-//                 }],
-//                 ["position2d", {
-//                     bufferManager: new BufferManager(gl, 2 * (VERTEX_COUNT + 1), { bufferType: "DYNAMIC_DRAW", initialCapacity: INITAL_CAPACITY }),
-//                     adaptor: (item: any) => {
-//                         const { longLatArr } = item;
-//                         return g2D(longLatArr, { paddingCount: 1 });
-//                     }
-//                 }
-//                 ],
-//             ]
-//         );
-//         this._bufferManagersCompMapTest = new Map([
-//             ["positionTest3d", {
-//                 bufferManager: new BufferManager(gl, 3 * (VERTEX_COUNT + 1), { bufferType: "DYNAMIC_DRAW", initialCapacity: INITAL_CAPACITY }),
-//                 adaptor: (item: any) => {
-//                     const { longLatArr } = item;
-//                     const result = g3D(longLatArr, { paddingCount: 1 });
-//                     return result;
-//                 }
-//             }],
-//             ["positionTest2d", {
-//                 bufferManager: new BufferManager(gl, 2 * (VERTEX_COUNT + 1), { bufferType: "DYNAMIC_DRAW", initialCapacity: INITAL_CAPACITY }),
-//                 adaptor: (item: any) => {
-//                     const { longLatArr } = item;
-//                     return g2D(longLatArr, { paddingCount: 1 });
-//                 }
-//             }
-//             ]
-//         ]
-//         );
-//         this._bufferOrchestrator = new BufferOrchestrator();
-//         this._arcUBOHandler = this.program.createUBO();
-//         this._arcUBOHandler.update(new Map([
-//             ["u_color", new Float32Array([1, 0, 0, 1])],
-//         ]));
-//         this._ubohandlerAllTest = this.program.createUBO();
-//         this._ubohandlerAllTest.update(new Map([
-//             ["u_color", new Float32Array([0, 0, 1, 1])],
-//         ]));
-//         this._vao = this.program.createVAO(
-//             createBufferAndReadInfo(this._bufferManagersCompMap.get("position3d")?.bufferManager.buffer as WebGLBuffer),
-//             createBufferAndReadInfo(this._bufferManagersCompMap.get("position2d")?.bufferManager.buffer as WebGLBuffer),
-//             null,
-//             null,
-//             null,
-//         );
-//         this._vaoAllTest = this.program.createVAO(
-//             createBufferAndReadInfo(this._bufferManagersCompMapTest.get("positionTest3d")?.bufferManager.buffer as WebGLBuffer),
-//             createBufferAndReadInfo(this._bufferManagersCompMapTest.get("positionTest2d")?.bufferManager.buffer as WebGLBuffer),
-//             null,
-//             null,
-//             null,
-//         );
-//     }
-//     setFieldOfView(fieldOfView: number) {
-//         this.fieldOfView = fieldOfView * RADIANS; // convert degrees to radians
-//         this.globe.DrawRender();
-//     }
-//     _buildArcs() {
-//         const { globe, _arcMap, _cameraUniformBlock } = this;
-//         const cameraPositionNormalized = _cameraUniformBlock.getCameraPositionNormalized() as Vec3;
-//         const result = [];
-//         const longLat = [0, 0] as [number, number];
-//         for (const [key, arcInstance] of _arcMap) {
-//             arc.copy(_0arc, arcInstance);
-//             const isOnArc = arc.closestPoint(_attractionPoint, _0arc, cameraPositionNormalized);
-//             if (!isOnArc) {
-//                 vec3.distanceSquared(cameraPositionNormalized, _0arc.p0) < vec3.distanceSquared(cameraPositionNormalized, _0arc.p1) ?
-//                     vec3.copy(_attractionPoint, _0arc.p0) : vec3.copy(_attractionPoint, _0arc.p1);
-//             }
-//             const generatedPoints = generateArcPoints(_0arc.p0, _0arc.p1, _0arc.normal, _attractionPoint, VERTEX_COUNT, this._attractionStrength);
-//             const longLatArr = new Float32Array(2 * VERTEX_COUNT);
-//             for (let i = 0; i < generatedPoints.length; i++) {
-//                 const point = generatedPoints[i];
-//                 vec3.toUnitVectorLongLat(longLat, point);
-//                 longLatArr.set([longLat[0] / RADIANS, longLat[1] / RADIANS], i * 2);
-//             }
-//             result.push({
-//                 key: key,
-//                 longLatArr: longLatArr,
-//             })
-//         }
-//         this._bufferOrchestrator.resetWithCapacity(this._bufferManagersCompMap, result.length);
-//         this._bufferOrchestrator.insertBulk(result, this._bufferManagersCompMap);
-//         this._doBuild = false; // reset build flag
-//         this._checkIfCorrupted(); // check if any arc is corrupted
-//     }
-//     setAttractionStrength(strength: number) {
-//         this._attractionStrength = strength;
-//         this._doBuild = true; // trigger rebuild
-//         this.globe.DrawRender();
-//     }
-//     // _buildArcs() {
-//     //     // updatePlane
-//     //     const { globe, _arcMap } = this;
-//     //     const planes = this._cameraUniformBlock.getFrustumPlanes() as FrustumPlanes;
-//     //     //
-//     //     const cameraPostition = new Vector3D();
-//     //     cameraPostition.copy(globe.Fp as Vector3D).normalize();
-//     //     // calculateHorizonPlane(globe, _screenPlane, this.fieldOfView);
-//     //     const result = [];
-//     //     const longLat = {
-//     //         long: 1,
-//     //         lat: 1
-//     //     }
-//     //     let counter = 0;
-//     //     for (const [key, arc] of _arcMap) {
-//     //         // const isArc = arc.intersectionMedium(_screenPlane, _0arc) as Arc;
-//     //         _0arc.copy(arc);
-//     //         const isArc = arcFrustumPlanesIntersection(_0arc, planes, _0arc);
-//     //         if (!isArc) {
-//     //             continue;
-//     //         }
-//     //         counter++;
-//     //         const longLatArr = new Float32Array(2 * VERTEX_COUNT);
-//     //         // const _3Dpoints = _0arc.populatePoints3DInRespectToCamera(cameraPostition, VERTEX_COUNT);
-//     //         const _3Dpoints = _0arc.populatePoints3D(VERTEX_COUNT);
-//     //         for (let i = 0; i < _3Dpoints.length / 3; i++) {
-//     //             _0vector.set(_3Dpoints[i * 3], _3Dpoints[i * 3 + 1], _3Dpoints[i * 3 + 2]).toLongLat(longLat);
-//     //             longLatArr.set([longLat.long / RADIANS, longLat.lat / RADIANS], i * 2);
-//     //         }
-//     //         result.push({
-//     //             key: key,
-//     //             longLatArr: longLatArr,
-//     //         });
-//     //         // if (!arc.imaginaryPlane.equals(_0arc.imaginaryPlane) || !arc.imaginaryPlane.equalsReverseOriantation(_0arc.imaginaryPlane)) {
-//     //         //     // console.log("Arc with key", key, "has imaginary plane equal to the original arc's imaginary plane.");
-//     //         //     throw new Error("The arc segment is not on the parent arc")
-//     //         // }
-//     //     }
-//     //     interval += 1;
-//     //     if (interval === 100) {
-//     //         interval = 1;
-//     //         console.log("Arc count on screen:", counter);
-//     //     }
-//     //     // update buffer
-//     //     this._bufferOrchestrator.resetWithCapacity(this._bufferManagersCompMap, result.length);
-//     //     this._bufferOrchestrator.insertBulk(result, this._bufferManagersCompMap);
-//     //     this._doBuild = false;
-//     //     this._checkIfCorrupted(); // check if any arc is corrupted
-//     // }
-//     draw3D() {
-//         // Drawing logic here
-//         this._buildArcs() // can be async
-//         const { gl, program, _bufferOrchestrator } = this;
-//         gl.disable(gl.DEPTH_TEST);
-//         const drawOptionTest = {
-//             drawRange: {
-//                 first: 0,
-//                 count: this._testOrchestrator.length * (VERTEX_COUNT + 1)
-//             },
-//             indexes: null
-//         }
-//         program.draw(
-//             this._vaoAllTest,
-//             drawOptionTest,
-//             this._opacity,
-//             this._ubohandlerAllTest
-//         );
-//         const drawOptions = {
-//             drawRange: {
-//                 first: 0,
-//                 count: _bufferOrchestrator.length * (VERTEX_COUNT + 1)
-//             },
-//             indexes: null
-//         }
-//         program.draw(
-//             this._vao,
-//             drawOptions,
-//             this._opacity,
-//             this._arcUBOHandler
-//         );
-//         gl.enable(gl.DEPTH_TEST);
-//     }
-//     _checkIfCorrupted() {
-//         for (const [key, arc] of this._arcMap) {
-//             if (!arc.p0.equals(arc.p1)) {
-//                 continue; // valid arc
-//             }
-//             console.warn(`Arc with key ${key} is corrupted: p0 and p1 are the same point.`);
-//             // this._arcMap.delete(key);
-//             // this._arcMapTest.delete(key);
-//         }
-//     }
-// }
+import { BufferManager, BufferOrchestrator } from "../../../util/account/single-attribute-buffer-management/index";
+import { globe3Dcoordinates, globe2Dcoordinates, RADIANS } from "../../../Math/methods";
+import { generateArcPoints } from "../../../Math/arc-cdf-points";
+import * as vec3 from "../../../Math/vec3";
+import * as arc from "../../../Math/arc";
+import { CameraUniformBlockTotemCache } from "../../../programs/totems/camerauniformblock";
+import { WORLD_RADIUS_3D } from "../../../Math/constants";
+const VERTEX_COUNT = 70;
+const INITAL_CAPACITY = 10;
+const _0vector = [0, 0, 0];
+const _attractionPoint = [0, 0, 0];
+const _start = [0, 0, 0];
+const _end = [0, 0, 0];
+const _0arc = arc.create([1, 0, 0], [0, 1, 0]); // zero arc for intersection tests
+let interval = 1;
+export class NaiveLineOnTerrainPlugin {
+    id;
+    program = null;
+    _bufferManagersCompMap = null;
+    _bufferManagersCompMapTest = null;
+    _bufferOrchestrator = new BufferOrchestrator({ capacity: INITAL_CAPACITY });
+    _testOrchestrator = new BufferOrchestrator({ capacity: INITAL_CAPACITY });
+    _opacity = 1;
+    _arcUBOHandler = null;
+    _vao = null;
+    _vaoAllTest = null;
+    _ubohandlerAllTest = null;
+    globe = null;
+    gl = null;
+    _arcMap;
+    _arcMapTest;
+    _doBuild = false;
+    _cameraUniformBlock = null;
+    _attractionStrength = 8;
+    constructor(id) {
+        this.id = id;
+        this._arcMap = new Map();
+        this._arcMapTest = new Map();
+    }
+    insertArcFromLongLat(key, startPoint, endPoint) {
+        if (this._arcMap.has(key)) {
+            this._arcMap.delete(key);
+        }
+        vec3.fromLongLatToUnitVector(_start, [startPoint.long * RADIANS, startPoint.lat * RADIANS]);
+        vec3.fromLongLatToUnitVector(_end, [endPoint.long * RADIANS, endPoint.lat * RADIANS]);
+        const _arc = arc.create(_start, _end);
+        this._arcMap.set(key, _arc);
+        this._arcMapTest.set(key, arc.clone(_arc));
+        this._doBuild = true;
+        this.globe.DrawRender();
+    }
+    deleteArcs(keys) {
+        for (const key of keys) {
+            if (this._arcMap.has(key)) {
+                this._arcMap.delete(key);
+            }
+        }
+        this._doBuild = true;
+        this.globe.DrawRender();
+    }
+    init(globe, gl) {
+        this.globe = globe;
+        this.gl = gl;
+        this.program = LineStripProgramCache.get(globe);
+        const g3D = globe3Dcoordinates(globe, 30);
+        const g2D = globe2Dcoordinates(globe);
+        this._cameraUniformBlock = CameraUniformBlockTotemCache.get(globe);
+        this._bufferManagersCompMap = new Map([
+            ["position3d", {
+                    bufferManager: new BufferManager(gl, 3 * (VERTEX_COUNT + 1), { bufferType: "DYNAMIC_DRAW", initialCapacity: INITAL_CAPACITY }),
+                    adaptor: (item) => {
+                        const { longLatArr } = item;
+                        const result = g3D(longLatArr, { paddingCount: 1 });
+                        // console.log("result", result);
+                        return result;
+                    }
+                }],
+            ["position2d", {
+                    bufferManager: new BufferManager(gl, 2 * (VERTEX_COUNT + 1), { bufferType: "DYNAMIC_DRAW", initialCapacity: INITAL_CAPACITY }),
+                    adaptor: (item) => {
+                        const { longLatArr } = item;
+                        return g2D(longLatArr, { paddingCount: 1 });
+                    }
+                }
+            ],
+        ]);
+        this._bufferManagersCompMapTest = new Map([
+            ["positionTest3d", {
+                    bufferManager: new BufferManager(gl, 3 * (VERTEX_COUNT + 1), { bufferType: "DYNAMIC_DRAW", initialCapacity: INITAL_CAPACITY }),
+                    adaptor: (item) => {
+                        const { longLatArr } = item;
+                        const result = g3D(longLatArr, { paddingCount: 1 });
+                        return result;
+                    }
+                }],
+            ["positionTest2d", {
+                    bufferManager: new BufferManager(gl, 2 * (VERTEX_COUNT + 1), { bufferType: "DYNAMIC_DRAW", initialCapacity: INITAL_CAPACITY }),
+                    adaptor: (item) => {
+                        const { longLatArr } = item;
+                        return g2D(longLatArr, { paddingCount: 1 });
+                    }
+                }
+            ]
+        ]);
+        this._bufferOrchestrator = new BufferOrchestrator();
+        this._arcUBOHandler = this.program.createUBO();
+        this._arcUBOHandler.update(new Map([
+            ["u_color", new Float32Array([1, 0, 0, 1])],
+        ]));
+        this._ubohandlerAllTest = this.program.createUBO();
+        this._ubohandlerAllTest.update(new Map([
+            ["u_color", new Float32Array([0, 0, 1, 1])],
+        ]));
+        this._vao = this.program.createVAO(createBufferAndReadInfo(this._bufferManagersCompMap.get("position3d")?.bufferManager.buffer), createBufferAndReadInfo(this._bufferManagersCompMap.get("position2d")?.bufferManager.buffer), null, null, null);
+        this._vaoAllTest = this.program.createVAO(createBufferAndReadInfo(this._bufferManagersCompMapTest.get("positionTest3d")?.bufferManager.buffer), createBufferAndReadInfo(this._bufferManagersCompMapTest.get("positionTest2d")?.bufferManager.buffer), null, null, null);
+    }
+    draw3D() {
+        // Drawing logic here
+        this._buildArcs(); // can be async
+        const { gl, program, _bufferOrchestrator, _vao, _arcUBOHandler, _vaoAllTest, _ubohandlerAllTest, _testOrchestrator } = this;
+        if (!gl || !program || !_bufferOrchestrator || !_vao || !_arcUBOHandler
+            || !_vaoAllTest || !_ubohandlerAllTest || !_testOrchestrator) {
+            console.warn("WebGL context, program, or buffer orchestrator is not initialized.");
+            return;
+        }
+        gl.disable(gl.DEPTH_TEST);
+        const drawOptions = {
+            drawRange: {
+                first: 0,
+                count: _bufferOrchestrator.length * (VERTEX_COUNT + 1)
+            },
+            indexes: null
+        };
+        program.draw(_vao, drawOptions, this._opacity, _arcUBOHandler);
+        gl.enable(gl.DEPTH_TEST);
+    }
+    _buildArcs() {
+        if (!this._doBuild)
+            return; // if not needed to build, return early
+        const { globe, _arcMap, _cameraUniformBlock, _bufferManagersCompMap } = this;
+        if (!globe || !_cameraUniformBlock || !_bufferManagersCompMap) {
+            console.warn("Globe or camera uniform block is not initialized.");
+            return;
+        }
+        const lookAtPosition = _cameraUniformBlock.getLookAtVector();
+        const cameraPosition = _cameraUniformBlock.getCameraVector();
+        vec3.divideScalar(cameraPosition, cameraPosition, WORLD_RADIUS_3D);
+        vec3.add(cameraPosition, cameraPosition, lookAtPosition);
+        // vec3.normalize(cameraPosition, cameraPosition);
+        vec3.divideScalar(cameraPosition, cameraPosition, 2);
+        // vec3.multiplyScalar(cameraPosition, cameraPosition, 1.3);
+        const _attractionStrength = (() => {
+            const lod = globe.api_GetCurrentLODWithDecimal();
+            if (lod < 11) {
+                return 1;
+            }
+            return lod * (lod - 8.5);
+        })();
+        console.log("Attraction strength: ", _attractionStrength);
+        const result = [];
+        const longLat = [0, 0];
+        for (const [key, arcInstance] of _arcMap) {
+            arc.copy(_0arc, arcInstance);
+            const isOnArc = arc.closestPoint(_attractionPoint, _0arc, cameraPosition);
+            if (!isOnArc) {
+                if (vec3.distanceSquared(cameraPosition, _0arc.p0) < vec3.distanceSquared(cameraPosition, _0arc.p1)) {
+                    vec3.copy(_attractionPoint, _0arc.p0);
+                }
+                else {
+                    vec3.copy(_attractionPoint, _0arc.p1);
+                }
+            }
+            const generatedPoints = generateArcPoints(_0arc.p0, _0arc.p1, _0arc.normal, _attractionPoint, VERTEX_COUNT, _attractionStrength);
+            const longLatArr = new Float32Array(2 * VERTEX_COUNT);
+            for (let i = 0; i < generatedPoints.length; i++) {
+                const point = generatedPoints[i];
+                vec3.fromUnitVectorToLongLat(longLat, point);
+                longLatArr.set([longLat[0] / RADIANS, longLat[1] / RADIANS], i * 2);
+            }
+            result.push({
+                key: key,
+                longLatArr: longLatArr,
+            });
+        }
+        this._bufferOrchestrator.resetWithCapacity(_bufferManagersCompMap, result.length);
+        this._bufferOrchestrator.insertBulk(result, _bufferManagersCompMap);
+        this._doBuild = false; // reset build flag
+        this._checkIfCorrupted(); // check if any arc is corrupted
+    }
+    _checkIfCorrupted() {
+        for (const [key, arcInstance] of this._arcMap) {
+            const copyarc = this._arcMapTest.get(key);
+            if (!copyarc) {
+                console.warn(`Arc with key ${key} is missing in the test map.`);
+                continue;
+            }
+            if (!arc.equals(arcInstance, copyarc)) {
+                console.warn(`Arc with key ${key} is corrupted: p0 and p1 are the same point.`);
+            }
+        }
+    }
+}