itowns 2.45.1-next.0 → 2.45.1-next.1

package/lib/Renderer/OBB.js

@@ -0,0 +1,150 @@
+import * as THREE from 'three';
+import { TileGeometry } from "../Core/TileGeometry.js";
+import { GlobeTileBuilder } from "../Core/Prefab/Globe/GlobeTileBuilder.js";
+import { CRS, Coordinates } from '@itowns/geographic';
+
+// get oriented bounding box of tile
+const builder = new GlobeTileBuilder({
+  uvCount: 1
+});
+const size = new THREE.Vector3();
+const dimension = new THREE.Vector2();
+const center = new THREE.Vector3();
+const coord = new Coordinates('EPSG:4326', 0, 0, 0);
+let obb;
+
+// it could be considered to remove THREE.Object3D extend.
+/**
+ * Oriented bounding box
+ * @extends THREE.Object3D
+ */
+class OBB extends THREE.Object3D {
+  /**
+   * @param {THREE.Vector3}  min representing the lower (x, y, z) boundary of the box. Default is ( + Infinity, + Infinity, + Infinity ).
+   * @param {THREE.Vector3}  max representing the lower upper (x, y, z) boundary of the box. Default is ( - Infinity, - Infinity, - Infinity ).
+   */
+  constructor() {
+    let min = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new THREE.Vector3(+Infinity, +Infinity, +Infinity);
+    let max = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new THREE.Vector3(-Infinity, -Infinity, -Infinity);
+    super();
+    this.box3D = new THREE.Box3(min.clone(), max.clone());
+    this.natBox = this.box3D.clone();
+    this.z = {
+      min: 0,
+      max: 0,
+      scale: 1.0
+    };
+  }
+
+  /**
+   * Creates a new instance of the object with same properties than original.
+   *
+   * @return     {OBB}  Copy of this object.
+   */
+  clone() {
+    return new OBB().copy(this);
+  }
+
+  /**
+   * Copy the property of OBB
+   *
+   * @param      {OBB}  cOBB OBB to copy
+   * @return     {OBB}  the copy
+   */
+  copy(cOBB) {
+    super.copy(cOBB);
+    this.box3D.copy(cOBB.box3D);
+    this.natBox.copy(cOBB.natBox);
+    this.z.min = cOBB.z.min;
+    this.z.max = cOBB.z.max;
+    this.z.scale = cOBB.z.scale;
+    return this;
+  }
+
+  /**
+   * Update z min, z max and z scale of oriented bounding box
+   *
+   * @param {Object}  [elevation={}]
+   * @param {number}  [elevation.min]             The minimum of oriented bounding box
+   * @param {number}  [elevation.max]             The maximum of oriented bounding box
+   * @param {number}  [elevation.scale]           The scale of oriented bounding box Z axis
+   * @param {number}  [elevation.geoidHeight]     The geoid height added to ellipsoid.
+   */
+  updateZ() {
+    let elevation = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    this.z.min = elevation.min ?? this.z.min;
+    this.z.max = elevation.max ?? this.z.max;
+    this.z.scale = elevation.scale > 0 ? elevation.scale : this.z.scale;
+    this.z.delta = Math.abs(this.z.max - this.z.min) * this.z.scale;
+    const geoidHeight = elevation.geoidHeight || 0;
+    this.box3D.min.z = this.natBox.min.z + this.z.min * this.z.scale + geoidHeight;
+    this.box3D.max.z = this.natBox.max.z + this.z.max * this.z.scale + geoidHeight;
+  }
+
+  /**
+   * Determines if the sphere is above the XY space of the box
+   *
+   * @param      {Sphere}   sphere  The sphere
+   * @return     {boolean}  True if sphere is above the XY space of the box, False otherwise.
+   */
+  isSphereAboveXYBox(sphere) {
+    const localSpherePosition = this.worldToLocal(sphere.center);
+    // get obb closest point to sphere center by clamping
+    const x = Math.max(this.box3D.min.x, Math.min(localSpherePosition.x, this.box3D.max.x));
+    const y = Math.max(this.box3D.min.y, Math.min(localSpherePosition.y, this.box3D.max.y));
+
+    // this is the same as isPointInsideSphere.position
+    const distance = Math.sqrt((x - localSpherePosition.x) * (x - localSpherePosition.x) + (y - localSpherePosition.y) * (y - localSpherePosition.y));
+    return distance < sphere.radius;
+  }
+
+  /**
+   * Compute OBB from extent.
+   * The OBB resulted can be only in the system 'EPSG:3946'.
+   *
+   * @param      {Extent}        extent     The extent (with crs 'EPSG:4326') to compute oriented bounding box
+   * @param      {number}        minHeight  The minimum height of OBB
+   * @param      {number}        maxHeight  The maximum height of OBB
+   * @return     {OBB}           return this object
+   */
+  setFromExtent(extent) {
+    let minHeight = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : extent.min || 0;
+    let maxHeight = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : extent.max || 0;
+    if (extent.crs == 'EPSG:4326') {
+      const {
+        shareableExtent,
+        quaternion,
+        position
+      } = builder.computeShareableExtent(extent);
+      // Compute the minimum count of segment to build tile
+      const segments = Math.max(Math.floor(shareableExtent.planarDimensions(dimension).x / 90 + 1), 2);
+      const geometry = new TileGeometry(builder, {
+        extent: shareableExtent,
+        level: 0,
+        segments,
+        disableSkirt: true
+      });
+      obb.box3D.copy(geometry.boundingBox);
+      obb.natBox.copy(geometry.boundingBox);
+      this.copy(obb);
+      this.updateZ({
+        min: minHeight,
+        max: maxHeight
+      });
+      this.position.copy(position);
+      this.quaternion.copy(quaternion);
+      this.updateMatrixWorld(true);
+    } else if (CRS.isMetricUnit(extent.crs)) {
+      extent.center(coord).toVector3(this.position);
+      extent.planarDimensions(dimension);
+      size.set(dimension.x, dimension.y, Math.abs(maxHeight - minHeight));
+      this.box3D.setFromCenterAndSize(center, size);
+      this.updateMatrixWorld(true);
+    } else {
+      throw new Error('Unsupported extent crs');
+    }
+    return this;
+  }
+}
+obb = new OBB();
+export default OBB;

package/lib/Renderer/OrientedImageCamera.js

@@ -0,0 +1,118 @@
+import * as THREE from 'three';
+class Distortion {
+  constructor(size) {
+    this.size = size;
+    this.pps = null;
+    this.polynom = null;
+    this.l1l2 = null;
+  }
+  setFromMicmacCalibration(distortion) {
+    let imageYDown = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    this.pps = new THREE.Vector2().fromArray(distortion.pps);
+    this.polynom = new THREE.Vector4().fromArray(distortion.poly357);
+    this.l1l2 = new THREE.Vector3();
+    // inverse Y pps convention image micmac
+    this.pps.y = imageYDown ? this.size.y - this.pps.y : this.pps.y;
+    this.polynom.w = distortion.limit ** 2;
+    if (distortion.l1l2) {
+      this.l1l2.fromArray(distortion.l1l2);
+      this.l1l2.z = distortion.etats;
+    }
+  }
+  clone() {
+    const dest = new Distortion(this.size.clone());
+    dest.pps = this.pps.clone();
+    dest.polynom = this.polynom.clone();
+    dest.l1l2 = this.l1l2.clone();
+    return dest;
+  }
+}
+const zoom = new THREE.Vector3();
+
+/**
+ * OrientedImageCamera is a ThreeJs camera adapted to photogrammetric description.
+ * So we can build a ThreeJs perspective camera from size and focal information.
+ */
+class OrientedImageCamera extends THREE.PerspectiveCamera {
+  /**
+   * @param {number|Vector2} size - image size in pixels (default: x=1024, y=x)
+   * @param {number|Vector2} focal - focal length in pixels (default: x=1024, y=x)
+   * @param {Vector2} center - principal point in pixels (default: size/2)
+   * @param {number} near - Camera frustum near plane (default: see THREE.PerspectiveCamera).
+   * @param {number} far - Camera frustum far plane (default: see THREE.PerspectiveCamera).
+   * @param {number} skew - shear transform parameter (default: 0)
+   * @param {number} aspect - aspect ratio of the camera (default: size.x/size.y).
+   */
+  constructor() {
+    let size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1024;
+    let focal = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1024;
+    let center = arguments.length > 2 ? arguments[2] : undefined;
+    let near = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0.1;
+    let far = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 10000;
+    let skew = arguments.length > 5 ? arguments[5] : undefined;
+    let aspect = arguments.length > 6 ? arguments[6] : undefined;
+    size = size.isVector2 ? size : new THREE.Vector2(size, size);
+    aspect = aspect || size.x / size.y;
+    super(undefined, aspect, near, far);
+    this.size = size;
+    this.focal = focal.isVector2 ? focal : new THREE.Vector2(focal, focal);
+    this.center = center || size.clone().multiplyScalar(0.5);
+    this.skew = skew || 0;
+    this.textureMatrixWorldInverse = new THREE.Matrix4();
+    Object.defineProperty(this, 'fov', {
+      get: () => 2 * THREE.MathUtils.radToDeg(Math.atan2(this.size.y, 2 * this.focal.y)),
+      // setting the fov overwrites focal.x and focal.y
+      set: fov => {
+        const focal = 0.5 * this.size.y / Math.tan(THREE.MathUtils.degToRad(fov * 0.5));
+        this.focal.x = focal;
+        this.focal.y = focal;
+      }
+    });
+    this.distortion = new Distortion(this.size);
+    this.maskPath = undefined;
+    this.mask = undefined;
+    this.updateProjectionMatrix();
+  }
+
+  // we override PerspectiveCamera.updateProjectionMatrix to
+  // update the projection matrix depending on other variables
+  // focal, center and size...
+  updateProjectionMatrix() {
+    if (!this.focal) {
+      return;
+    }
+    const near = this.near;
+    const sx = near / this.focal.x;
+    const sy = near / this.focal.y;
+    const left = -sx * this.center.x;
+    const bottom = -sy * this.center.y;
+    const right = left + sx * this.size.x;
+    const top = bottom + sy * this.size.y;
+    this.projectionMatrix.makePerspective(left, right, top, bottom, near, this.far);
+    this.projectionMatrix.elements[4] = 2 * this.skew / this.size.x;
+
+    // take zoom and aspect into account
+    const textureAspect = this.size.x / this.size.y;
+    const aspectRatio = this.aspect / textureAspect;
+    zoom.set(this.zoom, this.zoom, 1);
+    if (aspectRatio > 1) {
+      zoom.x /= aspectRatio;
+    } else {
+      zoom.y *= aspectRatio;
+    }
+    this.projectionMatrix.scale(zoom);
+  }
+  copy(source, recursive) {
+    super.copy(source, recursive);
+    this.size = source.size.clone();
+    this.focal = source.focal.clone();
+    this.center = source.center.clone();
+    this.distortion = source.distortion.clone();
+    this.textureMatrixWorldInverse = source.textureMatrixWorldInverse.clone();
+    this.skew = source.skew;
+    this.maskPath = source.maskPath;
+    this.mask = source.mask;
+    return this;
+  }
+}
+export default OrientedImageCamera;

package/lib/Renderer/OrientedImageMaterial.js

@@ -0,0 +1,167 @@
+import * as THREE from 'three';
+import Capabilities from "../Core/System/Capabilities.js";
+import ShaderUtils from "./Shader/ShaderUtils.js";
+/* babel-plugin-inline-import './Shader/ProjectiveTextureVS.glsl' */
+const textureVS = "#include <itowns/precision_qualifier>\n#include <itowns/projective_texturing_pars_vertex>\n#include <common>\n#include <logdepthbuf_pars_vertex>\n\nvarying vec3 vNormal;\n\nvoid main() {\n    #include <begin_vertex>\n    #include <project_vertex>\n    vNormal = normal;\n    #include <itowns/projective_texturing_vertex>\n    #include <logdepthbuf_vertex>\n}\n";
+/* babel-plugin-inline-import './Shader/ProjectiveTextureFS.glsl' */
+const textureFS = "#include <itowns/precision_qualifier>\n#include <logdepthbuf_pars_fragment>\n#include <itowns/projective_texturing_pars_fragment>\nvarying vec3 vNormal;\n\n#ifdef USE_BASE_MATERIAL\nstruct noPT {\n    vec3 lightDirection;\n    vec3 ambient;\n    float opacity;\n};\n\nuniform noPT noProjectiveMaterial;\n#endif\n\nvoid main(void)\n{\n    #include <logdepthbuf_fragment>\n    #ifdef USE_BASE_MATERIAL\n    float nDotVP = (max(0.1, dot(vNormal, normalize(noProjectiveMaterial.lightDirection))));\n    vec4 color = vec4(noProjectiveMaterial.ambient + nDotVP, 0.0);\n    #else\n    vec4 color = vec4(0.0);\n    #endif\n\n    #pragma unroll_loop\n    for (int i = 0; i < ORIENTED_IMAGES_COUNT; i++) {\n        color = projectiveTextureColor(projectiveTextureCoords[ ORIENTED_IMAGES_COUNT - 1 - i ], projectiveTextureDistortion[ ORIENTED_IMAGES_COUNT - 1 - i ], projectiveTexture[ ORIENTED_IMAGES_COUNT - 1 - i ], mask[ORIENTED_IMAGES_COUNT - 1 - i], color);\n    }\n\n    #ifdef USE_BASE_MATERIAL\n    color.a = color.a < 1.0 ? max(noProjectiveMaterial.opacity, color.a) : 1.0 ;\n    gl_FragColor = vec4(color.rgb, color.a * opacity);\n    #else\n    gl_FragColor = vec4(color.rgb / color.a, opacity);\n    #endif\n\n}\n";
+const ndcToTextureMatrix = new THREE.Matrix4(1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 2, 0, 0, 0, 0, 2);
+const noMask = new THREE.DataTexture(new Uint8Array([255, 255, 255, 255]), 1, 1, THREE.RGBAFormat, THREE.UnsignedByteType);
+noMask.needsUpdate = true;
+const noTexture = new THREE.Texture();
+const shaderMaterial = new THREE.ShaderMaterial();
+/**
+ * OrientedImageMaterial is a custom shader material used to do projective texture mapping.<br/>
+ *
+ * This Material is designed to project many textures simultaneously.
+ * Each projected texture setting is stored as an {@link OrientedImageCamera}.<br/>
+ * <br/>
+ * All cameras settings, like distorsion, can be specified in a configuration file.
+ * See [CameraCalibrationParser]{@link module:CameraCalibrationParser.parse}
+ * used to parse a configuration file and create an array of camera.<br/>
+ * <br/>
+ * The current implementation supports the following distortion models : <br/>
+ *  - no distortion (polynom==vec3(0),l1l2==vec2(0))<br/>
+ *  - radial distortion (polynom!=vec3(0),l1l2==vec2(0)) (see <b>15.2.2 Radial Model</b> in [MicMac doc](https://github.com/micmacIGN/Documentation/blob/master/DocMicMac.pdf)) </br>
+ *  - equilinear fish eye distortion (polynom!=vec3(0),l1l2 != vec2(0)) (see <b>15.3.4 Fish eye models</b> in [MicMac doc](https://github.com/micmacIGN/Documentation/blob/master/DocMicMac.pdf)) </br>
+ * (Note: radial decentric parameters P1 are P2 not supported and assumed to be 0).<br/>
+ * <br/>
+ * To get a more comprehensive support of camera Micmac models, you can consider using [three-photogrammetric-camera]{@link https://github.com/mbredif/three-photogrammetric-camera} instead.
+ */
+class OrientedImageMaterial extends THREE.ShaderMaterial {
+  /**
+   * @param { OrientedImageCamera[]} cameras - Array of {@link OrientedImageCamera}. Each camera will project a texture.
+   * [CameraCalibrationParser]{@link module:CameraCalibrationParser.parse} can used to create this array of camera from a configuration file.
+   * @param {Object} [options={}] - Object with one or more properties defining the material's appearance.
+   * Any property of the material (including any property inherited from
+   * [THREE.Material]{@link https://threejs.org/docs/#api/en/materials/Material} and
+   * [THREE.ShaderMaterial]{@link https://threejs.org/docs/#api/en/materials/ShaderMaterial}) can be passed in here.
+   * @param {Number} [options.side=THREE.DoubleSide] - We override default
+   * [THREE.Material.side]{@link https://threejs.org/docs/#api/en/materials/Material.side} from FrontSide to DoubleSide.
+   * @param {Boolean} [options.transparent=true] - We override default
+   * [THREE.Material.transparent]{@link https://threejs.org/docs/#api/en/materials/Material.transparent} from false to true.
+   * @param {Number} [options.opacity=0.1] - We override default
+   * [THREE.Material.opacity]{@link https://threejs.org/docs/#api/en/materials/Material.opacity} from 1 to 0.1.
+   * @param {Number} [options.alphaBorder=20] - Part of the texture that is blended, when texture crosses each other.
+   * For example, 10 means a border as large as 1 / 10 of the size of the texture is used to blend colors.
+   * @param {Number} [options.debugAlphaBorder=0] - Set this option to 1 to see influence of alphaBorder option.
+   */
+  constructor(cameras) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    options.side = options.side ?? THREE.DoubleSide;
+    options.transparent = options.transparent ?? true;
+    options.opacity = options.opacity ?? 1;
+
+    // Filter out non-ShaderMaterial options
+    const shaderMaterialOptions = {};
+    for (const key in options) {
+      if (Object.prototype.hasOwnProperty.call(options, key)) {
+        const currentValue = shaderMaterial[key];
+        if (currentValue !== undefined) {
+          shaderMaterialOptions[key] = options[key];
+        }
+      }
+    }
+    super(shaderMaterialOptions);
+    this.defines.ORIENTED_IMAGES_COUNT = options.OrientedImagesCount ?? cameras.length;
+
+    // verify that number of textures doesn't exceed GPU capabilities
+    const maxTexturesUnits = Capabilities.getMaxTextureUnitsCount();
+    if (this.defines.ORIENTED_IMAGES_COUNT > maxTexturesUnits) {
+      console.warn(`OrientedImageMaterial: Can't project ${cameras.length} textures, because it's more than GPU capabilities maximum texture units (${maxTexturesUnits})`);
+
+      // Clamp number of textures used
+      this.defines.ORIENTED_IMAGES_COUNT = maxTexturesUnits - 1;
+      console.warn(`OrientedImageMaterial: We'll use only the first ${this.defines.ORIENTED_IMAGES_COUNT} cameras.`);
+    }
+    if (options.useBaseMaterial) {
+      this.defines.USE_BASE_MATERIAL = true;
+    }
+    this.defines.USE_DISTORTION = Number(cameras.some(camera => camera.distortion.pps !== null));
+    this.alphaBorder = options.alphaBorder | 20;
+    this.defines.DEBUG_ALPHA_BORDER = options.debugAlphaBorder | 0;
+    this.cameras = cameras;
+    const textureMatrix = [];
+    const texture = [];
+    const mask = [];
+    const distortion = [];
+    this.group = new THREE.Group();
+    for (let i = 0; i < this.defines.ORIENTED_IMAGES_COUNT; ++i) {
+      texture[i] = noTexture;
+      mask[i] = noMask;
+      textureMatrix[i] = new THREE.Matrix4();
+      cameras[i].needsUpdate = true;
+      distortion[i] = cameras[i].distortion;
+      this.group.add(cameras[i]);
+    }
+    this.uniforms.opacity = new THREE.Uniform(this.opacity);
+    this.uniforms.projectiveTextureAlphaBorder = new THREE.Uniform(this.alphaBorder);
+    this.uniforms.projectiveTextureDistortion = new THREE.Uniform(distortion);
+    this.uniforms.projectiveTextureMatrix = new THREE.Uniform(textureMatrix);
+    this.uniforms.projectiveTexture = new THREE.Uniform(texture);
+    this.uniforms.mask = new THREE.Uniform(mask);
+    this.uniforms.boostLight = new THREE.Uniform(false);
+    this.uniforms.noProjectiveMaterial = new THREE.Uniform({
+      lightDirection: new THREE.Vector3(0.5, 0.5, -0.5),
+      ambient: new THREE.Color(0.1, 0.1, 0.1),
+      opacity: 0.75
+    });
+    this.vertexShader = textureVS;
+    // three loop unrolling of ShaderMaterial only supports integer bounds,
+    // see https://github.com/mrdoob/three.js/issues/28020
+    this.fragmentShader = ShaderUtils.unrollLoops(textureFS, this.defines);
+  }
+
+  /**
+   * Set new textures and new position/orientation of the camera set.
+   * @param {THREE.Texture} textures - Array of [THREE.Texture]{@link https://threejs.org/docs/#api/en/textures/Texture}.
+   * @param {Object} feature - New position / orientation of the set of cameras
+   * @param {THREE.Vector3} feature.position - New position.
+   * @param {THREE.Quaternion} feature.quaternion - New orientation.
+   * @param {Array} camerasNames - camera names of panoramic feature
+   */
+  setTextures(textures, feature, camerasNames) {
+    if (!textures) {
+      return;
+    }
+    this.group.position.copy(feature.position);
+    this.group.quaternion.copy(feature.quaternion);
+    for (let i = 0; i < textures.length && i < this.defines.ORIENTED_IMAGES_COUNT; ++i) {
+      this.uniforms.projectiveTexture.value[i].dispose();
+      this.uniforms.projectiveTexture.value[i] = textures[i];
+
+      // check camera changes
+      if (camerasNames) {
+        const currentCamera = this.group.children[i];
+        if (camerasNames[i] != currentCamera.name) {
+          const camera = this.cameras.find(cam => cam.name === camerasNames[i]);
+          this.uniforms.mask.value[i] = camera.maskTexture || noMask;
+          this.uniforms.mask.value[i].needsUpdate = true;
+          this.uniforms.projectiveTextureDistortion.value[i] = camera.distortion;
+          this.group.children[i] = camera;
+          camera.parent = this.group;
+        }
+      }
+      this.group.children[i].needsUpdate = true;
+    }
+    this.group.updateMatrixWorld(true); // update the matrixWorldInverse of the cameras
+  }
+
+  /**
+   * Udate the uniforms using the current value of camera.matrixWorld.
+   * Need to be called when the camera of the scene has changed.
+   * @param {THREE.Camera} viewCamera - Camera of the scene.
+   */
+  updateUniforms(viewCamera) {
+    for (let i = 0; i < this.group.children.length; ++i) {
+      const camera = this.group.children[i];
+      if (camera.needsUpdate) {
+        camera.textureMatrixWorldInverse.multiplyMatrices(ndcToTextureMatrix, camera.projectionMatrix);
+        camera.textureMatrixWorldInverse.multiply(camera.matrixWorldInverse);
+        camera.needsUpdate = false;
+      }
+      this.uniforms.projectiveTextureMatrix.value[i].multiplyMatrices(camera.textureMatrixWorldInverse, viewCamera.matrixWorld);
+    }
+  }
+}
+export default OrientedImageMaterial;