feature(FeatureGeometryLayer): introduce FeatureMesh, they are added to layer.object3d.

gchoqueux · gchoqueux · commit 0d777ce9ed10 · 2022-04-11T14:36:12.000+02:00
FeatureMesh could be it can dynamically change its geographic projection system.
diff --git a/src/Converter/Feature2Mesh.js b/src/Converter/Feature2Mesh.js
@@ -3,11 +3,84 @@ import Earcut from 'earcut';
 import { FEATURE_TYPES } from 'Core/Feature';
 import ReferLayerProperties from 'Layer/ReferencingLayerProperties';
 import { deprecatedFeature2MeshOptions } from 'Core/Deprecated/Undeprecator';
+import Extent from 'Core/Geographic/Extent';
+import Crs from 'Core/Geographic/Crs';
+import OrientationUtils from 'Utils/OrientationUtils';
+import Coordinates from 'Core/Geographic/Coordinates';
+
+const coord = new Coordinates('EPSG:4326', 0, 0, 0);
+const dim_ref = new THREE.Vector2();
+const dim = new THREE.Vector2();
+const extent = new Extent('EPSG:4326', 0, 0, 0, 0);
 
 const _color = new THREE.Color();
 const maxValueUint8 = 2 ** 8 - 1;
 const maxValueUint16 = 2 ** 16 - 1;
 const maxValueUint32 = 2 ** 32 - 1;
+const crsWGS84 = 'EPSG:4326';
+
+class FeatureMesh extends THREE.Group {
+    #currentCrs;
+    #originalCrs;
+    constructor(meshes, collection) {
+        super();
+        this.meshesCollection = new THREE.Group().add(...meshes);
+        this.meshesCollection.quaternion.copy(collection.quaternion);
+        this.meshesCollection.position.copy(collection.position);
+        this.meshesCollection.scale.copy(collection.scale);
+        this.meshesCollection.updateMatrix();
+
+        this.#originalCrs = collection.crs;
+        this.#currentCrs = this.#originalCrs;
+        this.extent = collection.extent;
+        this.place = new THREE.Group();
+        this.geoid = new THREE.Group();
+
+        this.add(this.place.add(this.geoid.add(this.meshesCollection)));
+    }
+
+    as(crs) {
+        if (this.#currentCrs !== crs) {
+            this.#currentCrs = crs;
+            if (crs == this.#originalCrs) {
+                // reset transformation
+                this.place.position.set(0, 0, 0);
+                this.position.set(0, 0, 0);
+                this.scale.set(1, 1, 1);
+                this.quaternion.identity();
+            } else {
+                // calculate the scale transformation to transform the feature.extent
+                // to feature.extent.as(crs)
+                coord.crs = Crs.formatToEPSG(this.#originalCrs);
+                extent.copy(this.extent).applyMatrix4(this.meshesCollection.matrix);
+                extent.as(coord.crs, extent);
+                extent.spatialEuclideanDimensions(dim_ref);
+                extent.planarDimensions(dim);
+                if (dim.x && dim.y) {
+                    this.scale.copy(dim_ref).divide(dim).setZ(1);
+                }
+
+                // Position and orientation
+                // remove original position
+                this.place.position.copy(this.meshesCollection.position).negate();
+
+                // get mesh coordinate
+                coord.setFromVector3(this.meshesCollection.position);
+
+                // get method to calculate orientation
+                const crsInput = this.#originalCrs == 'EPSG:3857' ? crsWGS84 : this.#originalCrs;
+                const crs2crs = OrientationUtils.quaternionFromCRSToCRS(crsInput, crs);
+                // calculate orientation to crs
+                crs2crs(coord.as(crsWGS84), this.quaternion);
+
+                // transform position to crs
+                coord.as(crs, coord).toVector3(this.position);
+            }
+        }
+
+        return this;
+    }
+}
 
 function toColor(color) {
     if (color) {
@@ -507,18 +580,12 @@ export default {
 
             if (!features || features.length == 0) { return; }
 
-            const group = new THREE.Group();
             options.GlobalZTrans = collection.center.z;
 
-            group.layer = options.layer;
-
-            features.forEach(feature => group.add(featureToMesh(feature, options)));
-
-            group.quaternion.copy(collection.quaternion);
-            group.position.copy(collection.position);
-            group.scale.copy(collection.scale);
+            const meshes = features.map(feature => featureToMesh(feature, options));
+            const featureNode = new FeatureMesh(meshes, collection);
 
-            return group;
+            return featureNode;
         };
     },
 };
diff --git a/src/Core/Feature.js b/src/Core/Feature.js
@@ -362,7 +362,7 @@ export class FeatureCollection extends THREE.Object3D {
     constructor(options) {
         super();
         this.isFeatureCollection = true;
-        this.crs = CRS.formatToEPSG(options.crs);
+        this.crs = CRS.formatToEPSG(options.accurate || !options.source?.crs ? options.crs : options.source.crs);
         this.features = [];
         this.mergeFeatures = options.mergeFeatures === undefined ? true : options.mergeFeatures;
         this.size = options.structure == '3d' ? 3 : 2;
diff --git a/src/Core/TileMesh.js b/src/Core/TileMesh.js
@@ -45,6 +45,8 @@ class TileMesh extends THREE.Mesh {
         this.domElements = {};
 
         this.geoidHeight = 0;
+
+        this.link = [];
     }
 
     /**
diff --git a/src/Layer/FeatureGeometryLayer.js b/src/Layer/FeatureGeometryLayer.js
@@ -22,22 +22,45 @@ class FeatureGeometryLayer extends GeometryLayer {
      * @param {string} id - The id of the layer, that should be unique. It is
      * not mandatory, but an error will be emitted if this layer is added a
      * {@link View} that already has a layer going by that id.
-     * @param {Object} [config] - Optional configuration, all elements in it
+     * @param {Object} [options] - Optional configuration, all elements in it
      * will be merged as is in the layer.
      * @param {function} [options.batchId] - optional function to create batchId attribute.
      * It is passed the feature property and the feature index.
      * As the batchId is using an unsigned int structure on 32 bits, the batchId could be between 0 and 4,294,967,295.
-     * @param {THREE.Object3D} [config.object3d=new THREE.Group()] root object3d layer.
+     * @param {THREE.Object3D} [options.object3d=new THREE.Group()] root object3d layer.
+     * @param {function} [options.onMeshCreated] this callback is called when the mesh is created. The callback parameters are the
+     * `mesh` and the `context`.
+     * @param {boolean} [options.accurate=TRUE] If `accurate` is `true`, data are re-projected with maximum geographical accuracy.
+     * With `true`, `proj4` is used to transform data source.
      *
+     * If `accurate` is `false`, re-projecting is faster but less accurate.
+     * With `false`, an affine transformation is used to transform data source.
+     * This method is an approximation. The error increases with the extent
+     * dimension of the object or queries.
+     *
+     * For example :
+     * * for a **100** meter dimension, there's a difference of **0.001** meter with the accurate method
+     * * for a **500** meter dimension, there's a difference of **0.05** meter with the accurate method
+     * * for a **20000** meter dimension, there's a difference of **40** meter with the accurate method
+     *
+     * **WARNING** If the source is `VectorTilesSource` then `accurate` is always false.
      */
-    constructor(id, config = {}) {
-        config.update = FeatureProcessing.update;
-        config.convert = Feature2Mesh.convert({
-            batchId: config.batchId,
+    constructor(id, options = {}) {
+        options.update = FeatureProcessing.update;
+        options.convert = Feature2Mesh.convert({
+            batchId: options.batchId,
         },
         );
-        super(id, config.object3d || new Group(), config);
+        super(id, options.object3d || new Group(), options);
         this.isFeatureGeometryLayer = true;
+        this.accurate = options.accurate ?? true;
+        this.buildExtent = !this.accurate;
+    }
+
+    preUpdate(context, sources) {
+        if (sources.has(this.parent)) {
+            this.object3d.clear();
+        }
     }
 }
 
diff --git a/src/Layer/GeometryLayer.js b/src/Layer/GeometryLayer.js
@@ -207,8 +207,7 @@ class GeometryLayer extends Layer {
      * specified coordinates.
      */
     pickObjectsAt(view, coordinates, radius = this.options.defaultPickingRadius, target = []) {
-        const object3d = this.parent ? this.parent.object3d : this.object3d;
-        return Picking.pickObjectsAt(view, coordinates, radius, object3d, target, this.threejsLayer);
+        return Picking.pickObjectsAt(view, coordinates, radius, this.object3d, target, this.threejsLayer);
     }
 }
 
diff --git a/src/Layer/OrientedImageLayer.js b/src/Layer/OrientedImageLayer.js
@@ -128,6 +128,7 @@ class OrientedImageLayer extends GeometryLayer {
 
         this.mergeFeatures = false;
         this.filteringExtent = false;
+        this.accurate = true;
         const options = { out: this };
 
         // panos is an array of feature point, representing many panoramics.
diff --git a/src/Process/FeatureProcessing.js b/src/Process/FeatureProcessing.js
@@ -1,11 +1,14 @@
-import * as THREE from 'three';
 import LayerUpdateState from 'Layer/LayerUpdateState';
 import ObjectRemovalHelper from 'Process/ObjectRemovalHelper';
 import handlingError from 'Process/handlerNodeError';
 import Coordinates from 'Core/Geographic/Coordinates';
 
 const coord = new Coordinates('EPSG:4326', 0, 0, 0);
 
+function geoidLayerIsVisible(layer) {
+    return layer.parent?.attachedLayers.filter(l => l.isGeoidLayer)[0]?.visible;
+}
+
 export default {
     update(context, layer, node) {
         if (!node.parent && node.children.length) {
@@ -20,15 +23,17 @@ export default {
         if (node.layerUpdateState[layer.id] === undefined) {
             node.layerUpdateState[layer.id] = new LayerUpdateState();
         } else if (!node.layerUpdateState[layer.id].canTryUpdate()) {
+            // toggle visibility features
+            node.link.forEach((f) => {
+                if (f.layer?.id == layer.id) {
+                    f.layer.object3d.add(f);
+                    f.geoid.position.z = geoidLayerIsVisible(layer) ? node.geoidHeight : 0;
+                    f.geoid.updateMatrixWorld();
+                }
+            });
             return;
         }
 
-        const features = node.children.filter(n => n.layer == layer);
-
-        if (features.length > 0) {
-            return features;
-        }
-
         const extentsDestination = node.getExtentsByProjection(layer.source.crs) || [node.extent];
 
         const zoomDest = extentsDestination[0].zoom;
@@ -54,31 +59,32 @@ export default {
             requester: node,
         };
 
-        return context.scheduler.execute(command).then((result) => {
-            // if request return empty json, WFSProvider.getFeatures return undefined
-            result = result[0];
-            if (result) {
-                // call onMeshCreated callback if needed
-                if (layer.onMeshCreated) {
-                    layer.onMeshCreated(result);
-                }
-                node.layerUpdateState[layer.id].success();
-                if (!node.parent) {
-                    ObjectRemovalHelper.removeChildrenAndCleanupRecursively(layer, result);
-                    return;
+        return context.scheduler.execute(command).then((featureMeshes) => {
+            node.layerUpdateState[layer.id].noMoreUpdatePossible();
+
+            featureMeshes.forEach((featureMesh) => {
+                if (featureMesh) {
+                    featureMesh.as(context.view.referenceCrs);
+                    featureMesh.geoid.position.z = geoidLayerIsVisible(layer) ? node.geoidHeight : 0;
+                    featureMesh.updateMatrixWorld();
+
+                    if (layer.onMeshCreated) {
+                        layer.onMeshCreated(featureMesh, context);
+                    }
+
+                    if (!node.parent) {
+                        // TODO: Clean cache needs a refactory, because it isn't really efficient and used
+                        ObjectRemovalHelper.removeChildrenAndCleanupRecursively(layer, featureMesh);
+                    } else {
+                        layer.object3d.add(featureMesh);
+                        node.link.push(featureMesh);
+                    }
+                    featureMesh.layer = layer;
+                } else {
+                    // TODO: verify if it's possible the featureMesh is undefined.
+                    node.layerUpdateState[layer.id].failure(1, true);
                 }
-                // remove old group layer
-                node.remove(...node.children.filter(c => c.layer && c.layer.id == layer.id));
-                const group = new THREE.Group();
-                group.layer = layer;
-                group.matrixWorld.copy(node.matrixWorld).invert();
-                group.matrixWorld.decompose(group.position, group.quaternion, group.scale);
-                group.position.z += node.geoidHeight;
-                node.add(group.add(result));
-                group.updateMatrixWorld(true);
-            } else {
-                node.layerUpdateState[layer.id].failure(1, true);
-            }
+            });
         },
         err => handlingError(err, node, layer, node.level, context.view));
     },
diff --git a/src/Process/ObjectRemovalHelper.js b/src/Process/ObjectRemovalHelper.js
@@ -68,7 +68,10 @@ export default {
      * @return {Array} an array of removed Object3D from obj (not including the recursive removals)
      */
     removeChildrenAndCleanupRecursively(layer, obj) {
-        const toRemove = obj.children.filter(c => (c.layer && c.layer.id) === layer.id);
+        let toRemove = obj.children.filter(c => (c.layer && c.layer.id) === layer.id);
+        if (obj.link) {
+            toRemove = toRemove.concat(obj.link);
+        }
         for (const c of toRemove) {
             this.removeChildrenAndCleanupRecursively(layer, c);
         }
diff --git a/src/Source/VectorTilesSource.js b/src/Source/VectorTilesSource.js
@@ -130,6 +130,10 @@ class VectorTilesSource extends TMSSource {
     onLayerAdded(options) {
         super.onLayerAdded(options);
         if (options.out.style) {
+            if (options.out.isFeatureGeometryLayer && options.out.accurate) {
+                console.warn('With VectorTilesSource and FeatureGeometryLayer, the accurate option is always false');
+                options.out.accurate = false;
+            }
             const keys = Object.keys(this.styles);
 
             keys.forEach((k) => { this.styles[k].parent = options.out.style; });
diff --git a/test/unit/dataSourceProvider.js b/test/unit/dataSourceProvider.js
@@ -226,7 +226,7 @@ describe('Provide in Sources', function () {
 
         featureLayer.update(context, featureLayer, tile);
         DataSourceProvider.executeCommand(context.scheduler.commands[0]).then((features) => {
-            assert.equal(features[0].children.length, 4);
+            assert.equal(features[0].meshesCollection.children.length, 4);
             done();
         });
     });
@@ -247,10 +247,10 @@ describe('Provide in Sources', function () {
         featureLayer.source.onLayerAdded({ out: featureLayer });
         featureLayer.update(context, featureLayer, tile);
         DataSourceProvider.executeCommand(context.scheduler.commands[0]).then((features) => {
-            assert.ok(features[0].children[0].isMesh);
-            assert.ok(features[0].children[1].isPoints);
-            assert.equal(features[0].children[0].children.length, 0);
-            assert.equal(features[0].children[1].children.length, 0);
+            assert.ok(features[0].meshesCollection.children[0].isMesh);
+            assert.ok(features[0].meshesCollection.children[1].isPoints);
+            assert.equal(features[0].meshesCollection.children[0].children.length, 0);
+            assert.equal(features[0].meshesCollection.children[1].children.length, 0);
             assert.equal(featureCountByCb, 2);
             done();
         });
diff --git a/test/unit/feature2mesh.js b/test/unit/feature2mesh.js
@@ -32,7 +32,7 @@ describe('Feature2Mesh', function () {
 
     it('rect mesh area should match geometry extent', () =>
         parsed.then((collection) => {
-            const mesh = Feature2Mesh.convert()(collection);
+            const mesh = Feature2Mesh.convert()(collection).meshesCollection;
             const extentSize = collection.extent.planarDimensions();
 
             assert.equal(
@@ -42,7 +42,7 @@ describe('Feature2Mesh', function () {
 
     it('square mesh area should match geometry extent minus holes', () =>
         parsed.then((collection) => {
-            const mesh = Feature2Mesh.convert()(collection);
+            const mesh = Feature2Mesh.convert()(collection).meshesCollection;
 
             const noHoleArea = computeAreaOfMesh(mesh.children[0]);
             const holeArea = computeAreaOfMesh(mesh.children[1]);
@@ -55,7 +55,7 @@ describe('Feature2Mesh', function () {
 
     it('convert points, lines and mesh', () =>
         parsed2.then((collection) => {
-            const mesh = Feature2Mesh.convert()(collection);
+            const mesh = Feature2Mesh.convert()(collection).meshesCollection;
             assert.equal(mesh.children[0].type, 'Points');
             assert.equal(mesh.children[1].type, 'Line');
             assert.equal(mesh.children[2].type, 'Mesh');
diff --git a/test/unit/featuregeometrylayer.js b/test/unit/featuregeometrylayer.js

Original file line number	Diff line number	Diff line change
`@@ -45,6 +45,8 @@ class TileMesh extends THREE.Mesh {`
`45`	`45`	`this.domElements = {};`
`46`	`46`
`47`	`47`	`this.geoidHeight = 0;`
	`48`	`+`
	`49`	`+ this.link = [];`
`48`	`50`	`}`
`49`	`51`
`50`	`52`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -207,8 +207,7 @@ class GeometryLayer extends Layer {`
`207`	`207`	`* specified coordinates.`
`208`	`208`	`*/`
`209`	`209`	`pickObjectsAt(view, coordinates, radius = this.options.defaultPickingRadius, target = []) {`
`210`		`- const object3d = this.parent ? this.parent.object3d : this.object3d;`
`211`		`- return Picking.pickObjectsAt(view, coordinates, radius, object3d, target, this.threejsLayer);`
	`210`	`+ return Picking.pickObjectsAt(view, coordinates, radius, this.object3d, target, this.threejsLayer);`
`212`	`211`	`}`
`213`	`212`	`}`
`214`	`213`