itowns 2.36.2 → 2.38.1

package/lib/ThreeExtended/loaders/GLTFLoader.js

@@ -64,6 +64,10 @@ var GLTFLoader = /*#__PURE__*/function (_Loader) {
       return new GLTFTextureWebPExtension(parser);
     });
 
+    _this.register(function (parser) {
+      return new GLTFMaterialsSheenExtension(parser);
+    });
+
     _this.register(function (parser) {
       return new GLTFMaterialsTransmissionExtension(parser);
     });
@@ -270,6 +274,14 @@ var GLTFLoader = /*#__PURE__*/function (_Loader) {
       parser.setPlugins(plugins);
       parser.parse(onLoad, onError);
     }
+  }, {
+    key: "parseAsync",
+    value: function parseAsync(data, path) {
+      var scope = this;
+      return new Promise(function (resolve, reject) {
+        scope.parse(data, path, resolve, reject);
+      });
+    }
   }]);
   return GLTFLoader;
 }(_three.Loader);
@@ -309,6 +321,7 @@ var EXTENSIONS = {
   KHR_MATERIALS_CLEARCOAT: 'KHR_materials_clearcoat',
   KHR_MATERIALS_IOR: 'KHR_materials_ior',
   KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS: 'KHR_materials_pbrSpecularGlossiness',
+  KHR_MATERIALS_SHEEN: 'KHR_materials_sheen',
   KHR_MATERIALS_SPECULAR: 'KHR_materials_specular',
   KHR_MATERIALS_TRANSMISSION: 'KHR_materials_transmission',
   KHR_MATERIALS_UNLIT: 'KHR_materials_unlit',
@@ -531,6 +544,65 @@ var GLTFMaterialsClearcoatExtension = /*#__PURE__*/function () {
   }]);
   return GLTFMaterialsClearcoatExtension;
 }();
+/**
+ * Sheen Materials Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_sheen
+ */
+
+
+var GLTFMaterialsSheenExtension = /*#__PURE__*/function () {
+  function GLTFMaterialsSheenExtension(parser) {
+    (0, _classCallCheck2["default"])(this, GLTFMaterialsSheenExtension);
+    this.parser = parser;
+    this.name = EXTENSIONS.KHR_MATERIALS_SHEEN;
+  }
+
+  (0, _createClass2["default"])(GLTFMaterialsSheenExtension, [{
+    key: "getMaterialType",
+    value: function getMaterialType(materialIndex) {
+      var parser = this.parser;
+      var materialDef = parser.json.materials[materialIndex];
+      if (!materialDef.extensions || !materialDef.extensions[this.name]) return null;
+      return _three.MeshPhysicalMaterial;
+    }
+  }, {
+    key: "extendMaterialParams",
+    value: function extendMaterialParams(materialIndex, materialParams) {
+      var parser = this.parser;
+      var materialDef = parser.json.materials[materialIndex];
+
+      if (!materialDef.extensions || !materialDef.extensions[this.name]) {
+        return Promise.resolve();
+      }
+
+      var pending = [];
+      materialParams.sheenColor = new _three.Color(0, 0, 0);
+      materialParams.sheenRoughness = 0;
+      materialParams.sheen = 1;
+      var extension = materialDef.extensions[this.name];
+
+      if (extension.sheenColorFactor !== undefined) {
+        materialParams.sheenColor.fromArray(extension.sheenColorFactor);
+      }
+
+      if (extension.sheenRoughnessFactor !== undefined) {
+        materialParams.sheenRoughness = extension.sheenRoughnessFactor;
+      }
+
+      if (extension.sheenColorTexture !== undefined) {
+        pending.push(parser.assignTexture(materialParams, 'sheenColorMap', extension.sheenColorTexture));
+      }
+
+      if (extension.sheenRoughnessTexture !== undefined) {
+        pending.push(parser.assignTexture(materialParams, 'sheenRoughnessMap', extension.sheenRoughnessTexture));
+      }
+
+      return Promise.all(pending);
+    }
+  }]);
+  return GLTFMaterialsSheenExtension;
+}();
 /**
  * Transmission Materials Extension
  *
@@ -622,7 +694,7 @@ var GLTFMaterialsVolumeExtension = /*#__PURE__*/function () {
 
       materialParams.attenuationDistance = extension.attenuationDistance || 0;
       var colorArray = extension.attenuationColor || [1, 1, 1];
-      materialParams.attenuationTint = new _three.Color(colorArray[0], colorArray[1], colorArray[2]);
+      materialParams.attenuationColor = new _three.Color(colorArray[0], colorArray[1], colorArray[2]);
       return Promise.all(pending);
     }
   }]);
@@ -708,10 +780,10 @@ var GLTFMaterialsSpecularExtension = /*#__PURE__*/function () {
       }
 
       var colorArray = extension.specularColorFactor || [1, 1, 1];
-      materialParams.specularTint = new _three.Color(colorArray[0], colorArray[1], colorArray[2]);
+      materialParams.specularColor = new _three.Color(colorArray[0], colorArray[1], colorArray[2]);
 
       if (extension.specularColorTexture !== undefined) {
-        pending.push(parser.assignTexture(materialParams, 'specularTintMap', extension.specularColorTexture).then(function (texture) {
+        pending.push(parser.assignTexture(materialParams, 'specularColorMap', extension.specularColorTexture).then(function (texture) {
           texture.encoding = _three.sRGBEncoding;
         }));
       }
@@ -892,8 +964,7 @@ var BINARY_EXTENSION_CHUNK_TYPES = {
   JSON: 0x4E4F534A,
   BIN: 0x004E4942
 };
-
-var GLTFBinaryExtension = function GLTFBinaryExtension(data) {
+var GLTFBinaryExtension = /*#__PURE__*/(0, _createClass2["default"])(function GLTFBinaryExtension(data) {
   (0, _classCallCheck2["default"])(this, GLTFBinaryExtension);
   this.name = EXTENSIONS.KHR_BINARY_GLTF;
   this.content = null;
@@ -936,14 +1007,13 @@ var GLTFBinaryExtension = function GLTFBinaryExtension(data) {
   if (this.content === null) {
     throw new Error('THREE.GLTFLoader: JSON content not found.');
   }
-};
+});
 /**
  * DRACO Mesh Compression Extension
  *
  * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_draco_mesh_compression
  */
 
-
 var GLTFDracoMeshCompressionExtension = /*#__PURE__*/function () {
   function GLTFDracoMeshCompressionExtension(json, dracoLoader) {
     (0, _classCallCheck2["default"])(this, GLTFDracoMeshCompressionExtension);
@@ -1050,7 +1120,7 @@ var GLTFTextureTransformExtension = /*#__PURE__*/function () {
 /**
  * Specular-Glossiness Extension
  *
- * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness
+ * Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Archived/KHR_materials_pbrSpecularGlossiness
  */
 
 /**
@@ -1074,7 +1144,7 @@ var GLTFMeshStandardSGMaterial = /*#__PURE__*/function (_MeshStandardMaterial) {
 
     var specularMapParsFragmentChunk = ['#ifdef USE_SPECULARMAP', '	uniform sampler2D specularMap;', '#endif'].join('\n');
     var glossinessMapParsFragmentChunk = ['#ifdef USE_GLOSSINESSMAP', '	uniform sampler2D glossinessMap;', '#endif'].join('\n');
-    var specularMapFragmentChunk = ['vec3 specularFactor = specular;', '#ifdef USE_SPECULARMAP', '	vec4 texelSpecular = texture2D( specularMap, vUv );', '	texelSpecular = sRGBToLinear( texelSpecular );', '	// reads channel RGB, compatible with a glTF Specular-Glossiness (RGBA) texture', '	specularFactor *= texelSpecular.rgb;', '#endif'].join('\n');
+    var specularMapFragmentChunk = ['vec3 specularFactor = specular;', '#ifdef USE_SPECULARMAP', '	vec4 texelSpecular = texture2D( specularMap, vUv );', '	// reads channel RGB, compatible with a glTF Specular-Glossiness (RGBA) texture', '	specularFactor *= texelSpecular.rgb;', '#endif'].join('\n');
     var glossinessMapFragmentChunk = ['float glossinessFactor = glossiness;', '#ifdef USE_GLOSSINESSMAP', '	vec4 texelGlossiness = texture2D( glossinessMap, vUv );', '	// reads channel A, compatible with a glTF Specular-Glossiness (RGBA) texture', '	glossinessFactor *= texelGlossiness.a;', '#endif'].join('\n');
     var lightPhysicalFragmentChunk = ['PhysicalMaterial material;', 'material.diffuseColor = diffuseColor.rgb * ( 1. - max( specularFactor.r, max( specularFactor.g, specularFactor.b ) ) );', 'vec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );', 'float geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );', 'material.roughness = max( 1.0 - glossinessFactor, 0.0525 ); // 0.0525 corresponds to the base mip of a 256 cubemap.', 'material.roughness += geometryRoughness;', 'material.roughness = min( material.roughness, 1.0 );', 'material.specularColor = specularFactor;'].join('\n');
     var uniforms = {
@@ -1265,10 +1335,10 @@ var GLTFMaterialsPbrSpecularGlossinessExtension = /*#__PURE__*/function () {
  */
 
 
-var GLTFMeshQuantizationExtension = function GLTFMeshQuantizationExtension() {
+var GLTFMeshQuantizationExtension = /*#__PURE__*/(0, _createClass2["default"])(function GLTFMeshQuantizationExtension() {
   (0, _classCallCheck2["default"])(this, GLTFMeshQuantizationExtension);
   this.name = EXTENSIONS.KHR_MESH_QUANTIZATION;
-};
+});
 /*********************************/
 
 /********** INTERPOLATION ********/
@@ -1277,7 +1347,6 @@ var GLTFMeshQuantizationExtension = function GLTFMeshQuantizationExtension() {
 // Spline Interpolation
 // Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#appendix-c-spline-interpolation
 
-
 var GLTFCubicSplineInterpolant = /*#__PURE__*/function (_Interpolant) {
   (0, _inherits2["default"])(GLTFCubicSplineInterpolant, _Interpolant);
 
@@ -1454,30 +1523,10 @@ var ALPHA_MODES = {
   MASK: 'MASK',
   BLEND: 'BLEND'
 };
-/* UTILITY FUNCTIONS */
-
-function resolveURL(url, path) {
-  // Invalid URL
-  if (typeof url !== 'string' || url === '') return ''; // Host Relative URL
-
-  if (/^https?:\/\//i.test(path) && /^\//.test(url)) {
-    path = path.replace(/(^https?:\/\/[^\/]+).*/i, '$1');
-  } // Absolute URL http://,https://,//
-
-
-  if (/^(https?:)?\/\//i.test(url)) return url; // Data URI
-
-  if (/^data:.*,.*$/i.test(url)) return url; // Blob URL
-
-  if (/^blob:.*$/i.test(url)) return url; // Relative URL
-
-  return path + url;
-}
 /**
  * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#default-material
  */
 
-
 function createDefaultMaterial(cache) {
   if (cache['DefaultMaterial'] === undefined) {
     cache['DefaultMaterial'] = new _three.MeshStandardMaterial({
@@ -1678,7 +1727,7 @@ var GLTFParser = /*#__PURE__*/function () {
     this.nodeNamesUsed = {}; // Use an ImageBitmapLoader if imageBitmaps are supported. Moves much of the
     // expensive work of uploading a texture to the GPU off the main thread.
 
-    if (typeof createImageBitmap !== 'undefined' && /Firefox/.test(navigator.userAgent) === false) {
+    if (typeof createImageBitmap !== 'undefined' && /Firefox|^((?!chrome|android).)*safari/i.test(navigator.userAgent) === false) {
       this.textureLoader = new _three.ImageBitmapLoader(this.options.manager);
     } else {
       this.textureLoader = new _three.TextureLoader(this.options.manager);
@@ -1990,7 +2039,7 @@ var GLTFParser = /*#__PURE__*/function () {
 
       var options = this.options;
       return new Promise(function (resolve, reject) {
-        loader.load(resolveURL(bufferDef.uri, options.path), resolve, undefined, function () {
+        loader.load(_three.LoaderUtils.resolveURL(bufferDef.uri, options.path), resolve, undefined, function () {
           reject(new Error('THREE.GLTFLoader: Failed to load buffer "' + bufferDef.uri + '".'));
         });
       });
@@ -2173,7 +2222,7 @@ var GLTFParser = /*#__PURE__*/function () {
             };
           }
 
-          loader.load(resolveURL(sourceURI, options.path), onLoad, undefined, reject);
+          loader.load(_three.LoaderUtils.resolveURL(sourceURI, options.path), onLoad, undefined, reject);
         });
       }).then(function (texture) {
         // Clean up resources and configure Texture.
@@ -2322,7 +2371,9 @@ var GLTFParser = /*#__PURE__*/function () {
     }
   }, {
     key: "getMaterialType",
-    value: function getMaterialType() {
+    value: function
+      /* materialIndex */
+    getMaterialType() {
       return _three.MeshStandardMaterial;
     }
     /**
@@ -2395,7 +2446,6 @@ var GLTFParser = /*#__PURE__*/function () {
 
         materialParams.depthWrite = false;
       } else {
-        materialParams.format = _three.RGBFormat;
         materialParams.transparent = false;
 
         if (alphaMode === ALPHA_MODES.MASK) {
@@ -2739,9 +2789,8 @@ var GLTFParser = /*#__PURE__*/function () {
           var targetNames = [];
 
           if (PATH_PROPERTIES[target.path] === PATH_PROPERTIES.weights) {
-            // Node may be a Group (glTF mesh with several primitives) or a Mesh.
             node.traverse(function (object) {
-              if (object.isMesh === true && object.morphTargetInfluences) {
+              if (object.morphTargetInfluences) {
                 targetNames.push(object.name ? object.name : object.uuid);
               }
             });

package/lib/Utils/CameraUtils.js

@@ -7,9 +7,9 @@ var _typeof = require("@babel/runtime/helpers/typeof");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports["default"] = void 0;
 exports.getLookAtFromMath = getLookAtFromMath;
 exports.getRig = getRig;
-exports["default"] = void 0;
 
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
@@ -35,6 +35,8 @@ var _Ellipsoid = _interopRequireDefault(require("../Core/Math/Ellipsoid"));
 
 var _OBB = _interopRequireDefault(require("../Renderer/OBB"));
 
+var _View = require("../Core/View");
+
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
@@ -173,6 +175,14 @@ var CameraRig = /*#__PURE__*/function (_THREE$Object3D) {
       } else {
         this.camera.matrixWorld.decompose(camera.position, camera.quaternion, camera.scale);
       }
+
+      view.dispatchEvent({
+        type: _View.VIEW_EVENTS.CAMERA_MOVED,
+        coord: this.coord,
+        range: this.range,
+        heading: this.heading,
+        tilt: this.tilt
+      });
     }
   }, {
     key: "setProxy",

package/lib/Utils/DEMUtils.js

@@ -7,8 +7,8 @@ var _typeof = require("@babel/runtime/helpers/typeof");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.readTextureValueWithBilinearFiltering = readTextureValueWithBilinearFiltering;
 exports["default"] = void 0;
+exports.readTextureValueWithBilinearFiltering = readTextureValueWithBilinearFiltering;
 
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 
@@ -352,10 +352,12 @@ function offsetInExtent(point, extent) {
 }
 
 function _readZ(layer, method, coord, nodes, cache) {
+  var _cache$tile;
+
   var pt = coord.as(layer.extent.crs, temp.coord1);
   var tileWithValidElevationTexture = null; // first check in cache
 
-  if (cache && cache.tile && cache.tile.material) {
+  if (cache !== null && cache !== void 0 && (_cache$tile = cache.tile) !== null && _cache$tile !== void 0 && _cache$tile.material) {
     tileWithValidElevationTexture = tileAt(pt, cache.tile);
   }
 

package/lib/Utils/FeaturesUtils.js

@@ -81,20 +81,24 @@ function getClosestPoint(point, points, epsilon, offset, count, size) {
   return closestPoint;
 }
 
-function pointIsInsidePolygon(point, polygonPoints, offset, count, size) {
+function pointIsInsidePolygon(point, polygonPoints, epsilon, offset, count, size) {
   // ray-casting algorithm based on
   // http://wrf.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html
   var x = point.x;
   var y = point.y;
   var inside = false; // in first j is last point of polygon
   // for each segment of the polygon (j is i -1)
-  // debugger;
 
   for (var i = offset, j = offset + count - size; i < offset + count; j = i, i += size) {
     var xi = polygonPoints[i];
     var yi = polygonPoints[i + 1];
     var xj = polygonPoints[j];
-    var yj = polygonPoints[j + 1]; // isIntersect semi-infinite ray horizontally with polygon's edge
+    var yj = polygonPoints[j + 1];
+
+    if (pointIsOverLine(point, [xi, yi, xj, yj], epsilon, 0, 4, 2)) {
+      return true;
+    } // isIntersect semi-infinite ray horizontally with polygon's edge
+
 
     if (yi > y != yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi) {
       inside = !inside;
@@ -107,7 +111,7 @@ function pointIsInsidePolygon(point, polygonPoints, offset, count, size) {
 function isFeatureSingleGeometryUnderCoordinate(coordinate, type, coordinates, epsilon, offset, count, size) {
   if (type == _Feature.FEATURE_TYPES.LINE && pointIsOverLine(coordinate, coordinates, epsilon, offset, count, size)) {
     return true;
-  } else if (type == _Feature.FEATURE_TYPES.POLYGON && pointIsInsidePolygon(coordinate, coordinates, offset, count, size)) {
+  } else if (type == _Feature.FEATURE_TYPES.POLYGON && pointIsInsidePolygon(coordinate, coordinates, epsilon, offset, count, size)) {
     return true;
   } else if (type == _Feature.FEATURE_TYPES.POINT) {
     var closestPoint = getClosestPoint(coordinate, coordinates, epsilon, offset, count, size);

package/lib/Utils/gui/Main.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Minimap", {
+  enumerable: true,
+  get: function get() {
+    return _Minimap["default"];
+  }
+});
+Object.defineProperty(exports, "Navigation", {
+  enumerable: true,
+  get: function get() {
+    return _Navigation["default"];
+  }
+});
+Object.defineProperty(exports, "Scale", {
+  enumerable: true,
+  get: function get() {
+    return _Scale["default"];
+  }
+});
+Object.defineProperty(exports, "Searchbar", {
+  enumerable: true,
+  get: function get() {
+    return _Searchbar["default"];
+  }
+});
+
+var _Navigation = _interopRequireDefault(require("./Navigation"));
+
+var _Minimap = _interopRequireDefault(require("./Minimap"));
+
+var _Scale = _interopRequireDefault(require("./Scale"));
+
+var _Searchbar = _interopRequireDefault(require("./Searchbar"));

package/lib/Utils/gui/Minimap.js

@@ -0,0 +1,197 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+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 _Coordinates = _interopRequireDefault(require("../../Core/Geographic/Coordinates"));
+
+var _MainLoop = require("../../Core/MainLoop");
+
+var _PlanarView = _interopRequireDefault(require("../../Core/Prefab/PlanarView"));
+
+var _Camera = require("../../Renderer/Camera");
+
+var _Widget2 = _interopRequireDefault(require("./Widget"));
+
+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; } }
+
+var DEFAULT_OPTIONS = {
+  minScale: 1 / 500000,
+  maxScale: 1 / 5E8,
+  zoomRatio: 1 / 30,
+  width: 150,
+  height: 150,
+  position: 'bottom-left'
+};
+/**
+ * A widget for minimap
+ *
+ * To use it, you need to link the widgets' stylesheet to your html webpage. This stylesheet is included in
+ * [itowns bundles](https://github.com/iTowns/itowns/releases) if you downloaded them, or it can be found in
+ * `node_modules/itowns/examples/css` if you installed iTowns with npm. Otherwise, it can be found at
+ * [this link](https://raw.githubusercontent.com/iTowns/itowns/master/examples/css/widgets.css). See
+ * [this example](http://www.itowns-project.org/itowns/examples/#widgets_minimap) for more details.
+ *
+ * @extends Widget
+ *
+ * @property    {HTMLElement}   domElement      An html div containing the minimap.
+ * @property    {HTMLElement}   parentElement   The parent HTML container of `this.domElement`.
+ */
+
+var Minimap = /*#__PURE__*/function (_Widget) {
+  (0, _inherits2["default"])(Minimap, _Widget);
+
+  var _super = _createSuper(Minimap);
+
+  /**
+   * @param   {GlobeView}             view                                    The iTowns view the minimap should be
+                                                                              * linked to. Only {@link GlobeView} is
+                                                                              * supported at the moment.
+   * @param   {ColorLayer}            layer                                   The {@link ColorLayer} that should be
+                                                                              * displayed on the minimap.
+   * @param   {Object}                [options]                               The minimap optional configuration.
+   * @param   {HTMLElement}           [options.parentElement=view.domElement] The parent HTML container of the div
+                                                                              * which contains minimap widgets.
+   * @param   {number}                [options.size]                          The size of the minimap. It is a number
+                                                                              * that describes both width and height
+                                                                              * in pixels of the minimap.
+   * @param   {number}                [options.width=150]                     The width in pixels of the minimap.
+   * @param   {number}                [options.height=150]                    The height in pixels of the minimap.
+   * @param   {string}                [options.position='bottom-left']        Defines which position within the
+                                                                              * `parentElement` the minimap should be
+                                                                              * displayed to. Possible values are
+                                                                              * `top`, `bottom`, `left`, `right`,
+                                                                              * `top-left`, `top-right`, `bottom-left`
+                                                                              * and `bottom-right`. If the input value
+                                                                              * does not match one of these, it will
+                                                                              * be defaulted to `bottom-left`.
+   * @param   {Object}                [options.translate]                     An optional translation of the minimap.
+   * @param   {number}                [options.translate.x=0]                 The minimap translation along the page
+                                                                              * x-axis.
+   * @param   {number}                [options.translate.y=0]                 The minimap translation along the page
+                                                                              * y-axis.
+   * @param   {HTMLElement|string}    [options.cursor]                        An html element or an HTML string
+                                                                              * describing a cursor showing minimap
+                                                                              * view camera target position at the
+                                                                              * center of the minimap.
+   * @param   {number}                [options.minScale=1/2000]               The minimal scale the minimap can reach.
+   * @param   {number}                [options.maxScale=1/1_250_000]          The maximal scale the minimap can reach.
+   * @param   {number}                [options.zoomRatio=1/30]                The ratio between minimap camera zoom
+                                                                              * and view camera zoom.
+   * @param   {number}                [options.pitch=0.28]                    The screen pixel pitch, used to compute
+                                                                              * view and minimap scale.
+   */
+  function Minimap(view, layer) {
+    var _this;
+
+    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    (0, _classCallCheck2["default"])(this, Minimap);
+
+    // ---------- BUILD PROPERTIES ACCORDING TO DEFAULT OPTIONS AND OPTIONS PASSED IN PARAMETERS : ----------
+    if (!view.isGlobeView) {
+      throw new Error('\'Minimap\' plugin only supports \'GlobeView\'. Therefore, the \'view\' parameter must be a ' + '\'GlobeView\'.');
+    }
+
+    if (!layer.isColorLayer) {
+      throw new Error('\'layer\' parameter form \'Minimap\' constructor should be a \'ColorLayer\'.');
+    }
+
+    _this = _super.call(this, view, options, DEFAULT_OPTIONS);
+    _this.minScale = options.minScale || DEFAULT_OPTIONS.minScale;
+    _this.maxScale = options.maxScale || DEFAULT_OPTIONS.maxScale; // TODO : it could be interesting to be able to specify a method as zoomRatio parameter. This method could
+    //  return a zoom ratio from the scale of the minimap.
+
+    _this.zoomRatio = options.zoomRatio || DEFAULT_OPTIONS.zoomRatio; // ---------- this.domElement SETTINGS SPECIFIC TO MINIMAP : ----------
+
+    _this.domElement.id = 'widgets-minimap'; // Display a cursor at the center of the minimap, if requested.
+
+    if (options.cursor) {
+      // Wrap cursor domElement inside a div to center it in minimap.
+      var cursorWrapper = document.createElement('div');
+      cursorWrapper.id = 'cursor-wrapper';
+
+      _this.domElement.appendChild(cursorWrapper); // Add specified cursor to its wrapper.
+
+
+      if (typeof options.cursor === 'string') {
+        cursorWrapper.innerHTML = options.cursor;
+      } else if (options.cursor instanceof HTMLElement) {
+        cursorWrapper.appendChild(options.cursor);
+      }
+    } // ---------- CREATE A MINIMAP View AND DISPLAY DATA PASSED IN Layer PARAMETER : ----------
+
+
+    _this.view = new _PlanarView["default"](_this.domElement, layer.source.extent, {
+      camera: {
+        type: _Camera.CAMERA_TYPE.ORTHOGRAPHIC
+      },
+      placement: layer.source.extent,
+      // TODO : the default placement should be the view extent for ortho camera
+      noControls: true,
+      maxSubdivisionLevel: view.tileLayer.maxSubdivisionLevel
+    });
+
+    _this.view.addLayer(layer); // TODO : should this promise be returned by constructor so that user can use it ?
+    // Give the focus back to the main view. Indeed, `View` constructor takes the focus, and we don't want the focus
+    // on the latest created `View`, which is the minimap view.
+
+
+    view.domElement.focus(); // Prevent the minimap domElement to get focus when clicked, and prevent click event to be propagated to the
+    // main view controls.
+
+    _this.domElement.addEventListener('pointerdown', function (event) {
+      event.preventDefault();
+    }); // Store minimap view camera3D in constant for code convenience.
+
+
+    var camera3D = _this.view.camera.camera3D; // ---------- UPDATE MINIMAP VIEW WHEN UPDATING THE MAIN VIEW : ----------
+    // The minimal and maximal value the minimap camera3D zoom can reach in order to stay in the scale limits.
+
+    var initialScale = _this.view.getScale(options.pitch);
+
+    var minZoom = camera3D.zoom * _this.maxScale / initialScale;
+    var maxZoom = camera3D.zoom * _this.minScale / initialScale; // Coordinates used to transform position vectors from the main view CRS to the minimap view CRS.
+
+    var mainViewCoordinates = new _Coordinates["default"](view.referenceCrs);
+    var viewCoordinates = new _Coordinates["default"](_this.view.referenceCrs);
+    var targetPosition = view.controls.getCameraTargetPosition();
+    view.addFrameRequester(_MainLoop.MAIN_LOOP_EVENTS.AFTER_RENDER, function () {
+      // Update minimap camera zoom
+      var distance = view.camera.camera3D.position.distanceTo(targetPosition);
+      var scale = view.getScaleFromDistance(options.pitch, distance);
+      camera3D.zoom = _this.zoomRatio * maxZoom * scale / _this.minScale;
+      camera3D.zoom = Math.min(Math.max(camera3D.zoom, minZoom), maxZoom);
+      camera3D.updateProjectionMatrix(); // Update minimap camera position.
+
+      mainViewCoordinates.setFromVector3(view.controls.getCameraTargetPosition());
+      mainViewCoordinates.as(_this.view.referenceCrs, viewCoordinates);
+      camera3D.position.x = viewCoordinates.x;
+      camera3D.position.y = viewCoordinates.y;
+      camera3D.updateMatrixWorld(true);
+
+      _this.view.notifyChange(camera3D);
+    });
+    return _this;
+  }
+
+  return (0, _createClass2["default"])(Minimap);
+}(_Widget2["default"]);
+
+var _default = Minimap;
+exports["default"] = _default;