itowns 2.36.2 → 2.38.1

package/lib/Core/View.js

@@ -23,6 +23,10 @@ var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime
 
 var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
 
+var _classPrivateFieldGet2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldGet"));
+
+var _classPrivateFieldSet2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldSet"));
+
 var THREE = _interopRequireWildcard(require("three"));
 
 var _Camera = _interopRequireDefault(require("../Renderer/Camera"));
@@ -65,6 +69,10 @@ function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflec
 
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+
 var VIEW_EVENTS = {
   /**
    * Fires when all the layers of the view are considered initialized.
@@ -80,7 +88,8 @@ var VIEW_EVENTS = {
   LAYER_REMOVED: 'layer-removed',
   LAYER_ADDED: 'layer-added',
   INITIALIZED: 'initialized',
-  COLOR_LAYERS_ORDER_CHANGED: _ColorLayersOrdering.COLOR_LAYERS_ORDER_CHANGED
+  COLOR_LAYERS_ORDER_CHANGED: _ColorLayersOrdering.COLOR_LAYERS_ORDER_CHANGED,
+  CAMERA_MOVED: 'camera-moved'
 };
 /**
  * Fired on current view's domElement when double right-clicking it. Copies all properties of the second right-click
@@ -191,6 +200,12 @@ var viewers = []; // Size of the camera frustrum, in meters
 
 var screenMeters;
 
+var _layers = /*#__PURE__*/new WeakMap();
+
+var _pixelDepthBuffer = /*#__PURE__*/new WeakMap();
+
+var _fullSizeDepthBuffer = /*#__PURE__*/new WeakMap();
+
 var View = /*#__PURE__*/function (_THREE$EventDispatche) {
   (0, _inherits2["default"])(View, _THREE$EventDispatche);
 
@@ -241,9 +256,24 @@ var View = /*#__PURE__*/function (_THREE$EventDispatche) {
     }
 
     _this = _super.call(this);
+
+    _classPrivateFieldInitSpec((0, _assertThisInitialized2["default"])(_this), _layers, {
+      writable: true,
+      value: []
+    });
+
+    _classPrivateFieldInitSpec((0, _assertThisInitialized2["default"])(_this), _pixelDepthBuffer, {
+      writable: true,
+      value: new Uint8Array(4)
+    });
+
+    _classPrivateFieldInitSpec((0, _assertThisInitialized2["default"])(_this), _fullSizeDepthBuffer, {
+      writable: true,
+      value: void 0
+    });
+
     _this.domElement = viewerDiv;
     _this.referenceCrs = crs;
-    coordinates.crs = crs;
     var engine; // options.renderer can be 2 separate things:
     //   - an actual renderer (in this case we don't use viewerDiv)
     //   - options for the renderer to be created
@@ -263,7 +293,6 @@ var View = /*#__PURE__*/function (_THREE$EventDispatche) {
 
     _this.camera = new _Camera["default"](_this.referenceCrs, _this.mainLoop.gfxEngine.getWindowSize().x, _this.mainLoop.gfxEngine.getWindowSize().y, options.camera);
     _this._frameRequesters = {};
-    _this._layers = [];
     window.addEventListener('resize', function () {
       return _this.resize();
     }, false);
@@ -297,8 +326,7 @@ var View = /*#__PURE__*/function (_THREE$EventDispatche) {
 
     _this.addEventListener(VIEW_EVENTS.LAYERS_INITIALIZED, fn);
 
-    _this._fullSizeDepthBuffer = new Uint8Array(4 * _this.camera.width * _this.camera.height);
-    _this._pixelDepthBuffer = new Uint8Array(4); // Indicates that view's domElement can be focused (the negative value indicates that domElement can't be
+    (0, _classPrivateFieldSet2["default"])((0, _assertThisInitialized2["default"])(_this), _fullSizeDepthBuffer, new Uint8Array(4 * _this.camera.width * _this.camera.height)); // Indicates that view's domElement can be focused (the negative value indicates that domElement can't be
     // focused sequentially using tab key). Focus is needed to capture some key events.
 
     _this.domElement.tabIndex = -1; // Set focus on view's domElement.
@@ -469,7 +497,7 @@ var View = /*#__PURE__*/function (_THREE$EventDispatche) {
           return layer._reject(new Error('Cant add GeometryLayer: missing a preUpdate function'));
         }
 
-        this._layers.push(layer);
+        (0, _classPrivateFieldGet2["default"])(this, _layers).push(layer);
       }
 
       if (layer.object3d && !layer.object3d.parent && layer.object3d !== this.scene) {
@@ -514,7 +542,7 @@ var View = /*#__PURE__*/function (_THREE$EventDispatche) {
           throw new Error("Error to detach ".concat(layerId, " from ").concat(parentLayer.id));
         } else if (parentLayer == undefined) {
           // Remove layer from viewer
-          this._layers.splice(this._layers.findIndex(function (l) {
+          (0, _classPrivateFieldGet2["default"])(this, _layers).splice((0, _classPrivateFieldGet2["default"])(this, _layers).findIndex(function (l) {
             return l.id == layerId;
           }), 1);
         }
@@ -596,7 +624,7 @@ var View = /*#__PURE__*/function (_THREE$EventDispatche) {
         this._changeSources.add(changeSource);
 
         if (changeSource.isTileMesh || changeSource.isCamera) {
-          this._fullSizeDepthBuffer.needsUpdate = true;
+          (0, _classPrivateFieldGet2["default"])(this, _fullSizeDepthBuffer).needsUpdate = true;
         }
       }
 
@@ -627,7 +655,7 @@ var View = /*#__PURE__*/function (_THREE$EventDispatche) {
     value: function getLayers(filter) {
       var result = [];
 
-      var _iterator6 = _createForOfIteratorHelper(this._layers),
+      var _iterator6 = _createForOfIteratorHelper((0, _classPrivateFieldGet2["default"])(this, _layers)),
           _step6;
 
       try {
@@ -1030,6 +1058,11 @@ var View = /*#__PURE__*/function (_THREE$EventDispatche) {
     key: "getScale",
     value: function getScale() {
       var pitch = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0.28;
+
+      if (this.camera.camera3D.isOrthographicCamera) {
+        return pitch * 1E-3 / this.getPixelsToMeters();
+      }
+
       return this.getScaleFromDistance(pitch, this.getDistanceFromCamera());
     }
   }, {
@@ -1192,6 +1225,7 @@ var View = /*#__PURE__*/function (_THREE$EventDispatche) {
       }
 
       this.getPickingPositionFromDepth(mouse, positionVector);
+      coordinates.crs = this.referenceCrs;
       coordinates.setFromVector3(positionVector); // Get the correct precision; the position variable will be set in this
       // function.
 
@@ -1349,15 +1383,15 @@ var View = /*#__PURE__*/function (_THREE$EventDispatche) {
       var buffer;
 
       if (viewPaused) {
-        if (this._fullSizeDepthBuffer.needsUpdate) {
-          this.readDepthBuffer(0, 0, dim.x, dim.y, this._fullSizeDepthBuffer);
-          this._fullSizeDepthBuffer.needsUpdate = false;
+        if ((0, _classPrivateFieldGet2["default"])(this, _fullSizeDepthBuffer).needsUpdate) {
+          this.readDepthBuffer(0, 0, dim.x, dim.y, (0, _classPrivateFieldGet2["default"])(this, _fullSizeDepthBuffer));
+          (0, _classPrivateFieldGet2["default"])(this, _fullSizeDepthBuffer).needsUpdate = false;
         }
 
         var id = ((dim.y - mouse.y - 1) * dim.x + mouse.x) * 4;
-        buffer = this._fullSizeDepthBuffer.slice(id, id + 4);
+        buffer = (0, _classPrivateFieldGet2["default"])(this, _fullSizeDepthBuffer).slice(id, id + 4);
       } else {
-        buffer = this.readDepthBuffer(mouse.x, mouse.y, 1, 1, this._pixelDepthBuffer);
+        buffer = this.readDepthBuffer(mouse.x, mouse.y, 1, 1, (0, _classPrivateFieldGet2["default"])(this, _pixelDepthBuffer));
       }
 
       screen.x = mouse.x / dim.x * 2 - 1;
@@ -1394,6 +1428,38 @@ var View = /*#__PURE__*/function (_THREE$EventDispatche) {
 
       return target;
     }
+    /**
+     * Returns the world {@link Coordinates} at given view coordinates.
+     *
+     * @param   {THREE.Vector2|event}   [mouse]     The view coordinates at which the world coordinates must be
+                                                    * returned. This parameter can also be set to a mouse event from
+                                                    * which the view coordinates will be deducted. If not specified, it
+                                                    * will be defaulted to the view's center coordinates.
+     * @param   {Coordinates}           [target]    The result will be copied into this {@link Coordinates}. If not
+                                                    * specified, a new {@link Coordinates} instance will be created.
+     *
+     * @returns {Coordinates}   The world {@link Coordinates} at the given view coordinates.
+     */
+
+  }, {
+    key: "pickCoordinates",
+    value: function pickCoordinates(mouse) {
+      var target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new _Coordinates["default"](this.tileLayer.extent.crs);
+
+      if (mouse instanceof Event) {
+        this.eventToViewCoords(mouse);
+      } else if (mouse && mouse.x !== undefined && mouse.y !== undefined) {
+        _eventCoords.copy(mouse);
+      } else {
+        _eventCoords.set(this.mainLoop.gfxEngine.width / 2, this.mainLoop.gfxEngine.height / 2);
+      }
+
+      this.getPickingPositionFromDepth(_eventCoords, positionVector);
+      coordinates.crs = this.referenceCrs;
+      coordinates.setFromVector3(positionVector);
+      coordinates.as(target.crs, target);
+      return target;
+    }
     /**
      * Resize the viewer.
      *
@@ -1414,7 +1480,7 @@ var View = /*#__PURE__*/function (_THREE$EventDispatche) {
         height = this.domElement.clientHeight;
       }
 
-      this._fullSizeDepthBuffer = new Uint8Array(4 * width * height);
+      (0, _classPrivateFieldSet2["default"])(this, _fullSizeDepthBuffer, new Uint8Array(4 * width * height));
       this.mainLoop.gfxEngine.onWindowResize(width, height);
       this.camera.resize(width, height);
       this.notifyChange(this.camera.camera3D);

package/lib/Layer/ElevationLayer.js

@@ -71,7 +71,7 @@ var ElevationLayer = /*#__PURE__*/function (_RasterLayer) {
    * // Create an ElevationLayer
    * const elevation = new ElevationLayer('IGN_MNT', {
    *      source: new WMTSSource({
-   *          "url": "https://wxs.ign.fr/3ht7xcw6f7nciopo16etuqp2/geoportail/wmts",
+   *          "url": "https://wxs.ign.fr/altimetrie/geoportail/wmts",
    *           "crs": "EPSG:4326",
    *           "format": "image/x-bil;bits=32",
    *           "name": "ELEVATION.ELEVATIONGRIDCOVERAGE",
@@ -112,7 +112,11 @@ var ElevationLayer = /*#__PURE__*/function (_RasterLayer) {
       node.material.setSequenceElevation(this.id); // bounding box initialisation
 
       var updateBBox = function () {
-        return node.setBBoxZ(rasterElevationNode.min, rasterElevationNode.max, _this2.scale);
+        return node.setBBoxZ({
+          min: rasterElevationNode.min,
+          max: rasterElevationNode.max,
+          scale: _this2.scale
+        });
       };
 
       updateBBox(); // listen elevation updating

package/lib/Layer/FeatureGeometryLayer.js

@@ -9,6 +9,8 @@ exports["default"] = void 0;
 
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
 var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
 
 var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
@@ -49,28 +51,55 @@ var FeatureGeometryLayer = /*#__PURE__*/function (_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.
    */
   function FeatureGeometryLayer(id) {
+    var _options$accurate;
+
     var _this;
 
-    var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     (0, _classCallCheck2["default"])(this, FeatureGeometryLayer);
-    config.update = _FeatureProcessing["default"].update;
-    config.convert = _Feature2Mesh["default"].convert({
-      batchId: config.batchId
+    options.update = _FeatureProcessing["default"].update;
+    options.convert = _Feature2Mesh["default"].convert({
+      batchId: options.batchId
     });
-    _this = _super.call(this, id, config.object3d || new _three.Group(), config);
+    _this = _super.call(this, id, options.object3d || new _three.Group(), options);
     _this.isFeatureGeometryLayer = true;
+    _this.accurate = (_options$accurate = options.accurate) !== null && _options$accurate !== void 0 ? _options$accurate : true;
+    _this.buildExtent = !_this.accurate;
     return _this;
   }
 
+  (0, _createClass2["default"])(FeatureGeometryLayer, [{
+    key: "preUpdate",
+    value: function preUpdate(context, sources) {
+      if (sources.has(this.parent)) {
+        this.object3d.clear();
+      }
+    }
+  }]);
   return FeatureGeometryLayer;
 }(_GeometryLayer2["default"]);
 

package/lib/Layer/GeoidLayer.js

@@ -0,0 +1,142 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+exports.geoidLayerIsVisible = geoidLayerIsVisible;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _Layer2 = _interopRequireDefault(require("./Layer"));
+
+var _LayerUpdateState = _interopRequireDefault(require("./LayerUpdateState"));
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function () { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function geoidLayerIsVisible(tilelayer) {
+  var _tilelayer$attachedLa;
+
+  return tilelayer === null || tilelayer === void 0 ? void 0 : (_tilelayer$attachedLa = tilelayer.attachedLayers.filter(function (l) {
+    return l.isGeoidLayer;
+  })[0]) === null || _tilelayer$attachedLa === void 0 ? void 0 : _tilelayer$attachedLa.visible;
+}
+/**
+ * `GeoidLayer` is a specific `{@link Layer}` which supports geoid height data. When added to a `{@link View}`, it
+ * vertically translates each of the view's tiles by a proper geoid height value. For a given tile, the geoid height
+ * value used for translation is the geoid height computed at the center of the tile.
+ *
+ * @example
+ * // Create a GeoidLayer from a GTX geoid heights file.
+ * const geoidLayer = new GeoidLayer('geoid', {
+ *     source: new FileSource({
+ *         url: 'url-to-some-GTX-geoid-heights-file.gtx',
+ *         crs: 'EPSG:4326',
+ *         format: 'application/gtx',
+ *     }),
+ * });
+ */
+
+
+var GeoidLayer = /*#__PURE__*/function (_Layer) {
+  (0, _inherits2["default"])(GeoidLayer, _Layer);
+
+  var _super = _createSuper(GeoidLayer);
+
+  /**
+   * Creates a new instance of `GeoidLayer`.
+   *
+   * @param   {string}    id              An unique identifier for the layer.
+   * @param   {Object}    config          The layer configuration. All elements in it will be merged as is in the
+                                          * layer. For example, if the configuration contains three elements `name,
+                                          * protocol, extent`, these elements will be available using `layer.name` or
+                                          * something else depending on the property name. Only `config.source`
+                                          * parameter is mandatory.
+   * @param   {Object}    config.source   The source of the geoid data displayed by the `GeoidLayer`. It is mandatory
+                                          * that the source data for a `GeoidLayer` be parsed into a
+                                          * `{@link GeoidGrid}`. You can refer to `{@link GTXParser}`,
+                                          * `{@link GDFParser}` and `{@link ISGParser}` to see how three standard
+                                          * geoid height grid file formats are parsed into `{@link GeoidGrid}`.
+   */
+  function GeoidLayer(id) {
+    var _this;
+
+    var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    (0, _classCallCheck2["default"])(this, GeoidLayer);
+    _this = _super.call(this, id, config);
+    _this.isGeoidLayer = true;
+
+    _this.defineLayerProperty('visible', true);
+
+    return _this;
+  }
+
+  (0, _createClass2["default"])(GeoidLayer, [{
+    key: "updateNodeZ",
+    value: function updateNodeZ(node) {
+      node.material.geoidHeight = this.visible ? node.geoidHeight : 0;
+      node.obb.updateZ({
+        geoidHeight: node.material.geoidHeight
+      });
+    }
+  }, {
+    key: "update",
+    value: function update(context, layer, node, parent) {
+      var _this2 = this;
+
+      if (!parent || !node.material) {
+        return;
+      } // Don't update tile if its zoom is not within the layer's zoom limits
+
+
+      var extentsDestination = node.getExtentsByProjection(layer.crs);
+      var zoom = extentsDestination[0].zoom;
+
+      if (zoom > layer.zoom.max || zoom < layer.zoom.min) {
+        return;
+      }
+
+      if (node.layerUpdateState[layer.id] === undefined) {
+        node.layerUpdateState[layer.id] = new _LayerUpdateState["default"]();
+
+        var updateNodeZ = function () {
+          return _this2.updateNodeZ(node);
+        };
+
+        layer.addEventListener('visible-property-changed', updateNodeZ);
+        node.addEventListener('dispose', function () {
+          layer.removeEventListener('visible-property-changed', updateNodeZ);
+        });
+      }
+
+      if (layer.frozen || !layer.visible || !node.material.visible || !node.layerUpdateState[layer.id].canTryUpdate()) {
+        return;
+      }
+
+      node.layerUpdateState[layer.id].newTry();
+      return this.getData(node.extent, extentsDestination).then(function (result) {
+        node.geoidHeight = result.getHeightAtCoordinates(node.extent.center());
+
+        _this2.updateNodeZ(node);
+
+        node.layerUpdateState[layer.id].noMoreUpdatePossible();
+      });
+    }
+  }]);
+  return GeoidLayer;
+}(_Layer2["default"]);
+
+var _default = GeoidLayer;
+exports["default"] = _default;

package/lib/Layer/GeometryLayer.js

@@ -140,11 +140,13 @@ var GeometryLayer = /*#__PURE__*/function (_Layer) {
    * view.addLayer(geometry);
    */
   function GeometryLayer(id, object3d) {
+    var _config$cacheLifeTime;
+
     var _this;
 
     var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
     (0, _classCallCheck2["default"])(this, GeometryLayer);
-    config.cacheLifeTime = config.cacheLifeTime == undefined ? _Cache.CACHE_POLICIES.GEOMETRY : config.cacheLifeTime;
+    config.cacheLifeTime = (_config$cacheLifeTime = config.cacheLifeTime) !== null && _config$cacheLifeTime !== void 0 ? _config$cacheLifeTime : _Cache.CACHE_POLICIES.GEOMETRY;
     _this = _super.call(this, id, config);
     _this.isGeometryLayer = true;
 
@@ -161,33 +163,8 @@ var GeometryLayer = /*#__PURE__*/function (_Layer) {
       writable: false,
       configurable: true
     });
-
-    _this.defineLayerProperty('opacity', 1.0, function () {
-      var root = _this.parent ? _this.parent.object3d : _this.object3d;
-      root.traverse(function (object) {
-        if (object.layer == (0, _assertThisInitialized2["default"])(_this)) {
-          _this.changeOpacity(object);
-        } else if (object.content && object.content.layer == (0, _assertThisInitialized2["default"])(_this)) {
-          object.content.traverse(_this.changeOpacity);
-        }
-      });
-    });
-
-    _this.defineLayerProperty('wireframe', false, function () {
-      var root = _this.parent ? _this.parent.object3d : _this.object3d;
-      root.traverse(function (object) {
-        if (object.layer == (0, _assertThisInitialized2["default"])(_this) && object.material) {
-          object.material.wireframe = _this.wireframe;
-        } else if (object.content && object.content.layer == (0, _assertThisInitialized2["default"])(_this)) {
-          object.content.traverse(function (o) {
-            if (o.material && o.layer == (0, _assertThisInitialized2["default"])(_this)) {
-              o.material.wireframe = _this.wireframe;
-            }
-          });
-        }
-      });
-    });
-
+    _this.opacity = 1.0;
+    _this.wireframe = false;
     _this.attachedLayers = [];
     _this.visible = config.visible == undefined ? true : config.visible;
     Object.defineProperty(_this.zoom, 'max', {
@@ -311,32 +288,7 @@ var GeometryLayer = /*#__PURE__*/function (_Layer) {
     value: function pickObjectsAt(view, coordinates) {
       var radius = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.options.defaultPickingRadius;
       var target = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
-      var object3d = this.parent ? this.parent.object3d : this.object3d;
-      return _Picking["default"].pickObjectsAt(view, coordinates, radius, object3d, target, this.threejsLayer);
-    }
-    /**
-     * Change the opacity of an object, according to the value of the `opacity`
-     * property of this layer.
-     *
-     * @param {Object} object - The object to change the opacity from. It is
-     * usually a `THREE.Object3d` or an implementation of it.
-     */
-
-  }, {
-    key: "changeOpacity",
-    value: function changeOpacity(object) {
-      if (object.material) {
-        // != undefined: we want the test to pass if opacity is 0
-        if (object.material.opacity != undefined) {
-          object.material.transparent = this.opacity < 1.0;
-          object.material.opacity = this.opacity;
-        }
-
-        if (object.material.uniforms && object.material.uniforms.opacity != undefined) {
-          object.material.transparent = this.opacity < 1.0;
-          object.material.uniforms.opacity.value = this.opacity;
-        }
-      }
+      return _Picking["default"].pickObjectsAt(view, coordinates, radius, this.object3d, target, this.threejsLayer);
     }
   }]);
   return GeometryLayer;

package/lib/Layer/InfoLayer.js

@@ -5,7 +5,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.InfoTiledGeometryLayer = exports["default"] = void 0;
+exports["default"] = exports.InfoTiledGeometryLayer = void 0;
 
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 

package/lib/Layer/Layer.js

@@ -7,7 +7,7 @@ var _typeof = require("@babel/runtime/helpers/typeof");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.ImageryLayers = exports["default"] = void 0;
+exports["default"] = exports.ImageryLayers = void 0;
 
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 

package/lib/Layer/LayerUpdateStrategy.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.STRATEGY_PROGRESSIVE = exports.STRATEGY_MIN_NETWORK_TRAFFIC = exports.STRATEGY_GROUP = exports.STRATEGY_DICHOTOMY = void 0;
 exports.chooseNextLevelToFetch = chooseNextLevelToFetch;
-exports.STRATEGY_DICHOTOMY = exports.STRATEGY_PROGRESSIVE = exports.STRATEGY_GROUP = exports.STRATEGY_MIN_NETWORK_TRAFFIC = void 0;
 
 var _RasterTile = require("../Renderer/RasterTile");
 

package/lib/Layer/OrientedImageLayer.js

@@ -188,6 +188,7 @@ var OrientedImageLayer = /*#__PURE__*/function (_GeometryLayer) {
 
     _this.mergeFeatures = false;
     _this.filteringExtent = false;
+    _this.accurate = true;
     var options = {
       out: (0, _assertThisInitialized2["default"])(_this)
     }; // panos is an array of feature point, representing many panoramics.

package/lib/Layer/PotreeLayer.js

@@ -9,6 +9,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports["default"] = void 0;
 
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
 var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
@@ -114,7 +116,7 @@ var PotreeLayer = /*#__PURE__*/function (_PointCloudLayer) {
     return _this;
   }
 
-  return PotreeLayer;
+  return (0, _createClass2["default"])(PotreeLayer);
 }(_PointCloudLayer2["default"]);
 
 var _default = PotreeLayer;

package/lib/Layer/RasterLayer.js

@@ -41,8 +41,10 @@ var RasterLayer = /*#__PURE__*/function (_Layer) {
   var _super = _createSuper(RasterLayer);
 
   function RasterLayer(id, config) {
+    var _config$cacheLifeTime;
+
     (0, _classCallCheck2["default"])(this, RasterLayer);
-    config.cacheLifeTime = config.cacheLifeTime == undefined ? _Cache.CACHE_POLICIES.TEXTURE : config.cacheLifeTime;
+    config.cacheLifeTime = (_config$cacheLifeTime = config.cacheLifeTime) !== null && _config$cacheLifeTime !== void 0 ? _config$cacheLifeTime : _Cache.CACHE_POLICIES.TEXTURE;
     return _super.call(this, id, config);
   }
 

package/lib/Layer/ReferencingLayerProperties.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+// next step is move these properties to Style class
+// and hide transparent mechanism
+function ReferLayerProperties(material, layer) {
+  if (layer && layer.isGeometryLayer) {
+    var transparent = material.transparent;
+    material.layer = layer;
+
+    if (material.uniforms && material.uniforms.opacity != undefined) {
+      Object.defineProperty(material.uniforms.opacity, 'value', {
+        get: function get() {
+          return material.layer.opacity;
+        }
+      });
+    } else if (material.opacity != undefined) {
+      Object.defineProperty(material, 'opacity', {
+        get: function get() {
+          return material.layer.opacity;
+        }
+      });
+    }
+
+    Object.defineProperty(material, 'wireframe', {
+      get: function get() {
+        return material.layer.wireframe;
+      }
+    });
+    Object.defineProperty(material, 'transparent', {
+      get: function get() {
+        if (transparent != material.layer.opacity < 1.0) {
+          material.needsUpdate = true;
+          transparent = material.layer.opacity < 1.0;
+        }
+
+        return transparent;
+      }
+    });
+  }
+
+  return material;
+}
+
+var _default = ReferLayerProperties;
+exports["default"] = _default;

package/lib/Layer/TiledGeometryLayer.js

@@ -118,7 +118,9 @@ var TiledGeometryLayer = /*#__PURE__*/function (_GeometryLayer) {
     config.cacheLifeTime = _Cache.CACHE_POLICIES.INFINITE;
     config.source = false;
     _this = _super.call(this, id, object3d, config);
-    _this.isTiledGeometryLayer = true;
+    _this.isTiledGeometryLayer = true; // TODO : this should be add in a preprocess method specific to GeoidLayer.
+
+    _this.object3d.geoidHeight = 0;
     _this.protocol = 'tile';
     _this.sseSubdivisionThreshold = _this.sseSubdivisionThreshold || 1.0;
     _this.schemeTile = schemeTile;