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

package/lib/Layer/OrientedImageLayer.js

@@ -0,0 +1,227 @@
+import * as THREE from 'three';
+import GeometryLayer from "./GeometryLayer.js";
+import OrientedImageMaterial from "../Renderer/OrientedImageMaterial.js";
+import GeoJsonParser from "../Parser/GeoJsonParser.js";
+import CameraCalibrationParser from "../Parser/CameraCalibrationParser.js";
+import { Coordinates, OrientationUtils } from '@itowns/geographic';
+const coord = new Coordinates('EPSG:4978', 0, 0, 0);
+const commandCancellation = cmd => cmd.requester.id !== cmd.layer.currentPano.id;
+function updatePano(context, camera, layer) {
+  const newPano = layer.mostNearPano(camera.position);
+  // detection of oriented image change
+  const currentId = layer.currentPano ? layer.currentPano.id : undefined;
+  if (newPano && currentId != newPano.id) {
+    layer.currentPano = newPano;
+
+    // callback to indicate current pano has changed
+    layer.onPanoChanged({
+      previousPanoPosition: layer.getPreviousPano() ? layer.getPreviousPano().position : undefined,
+      currentPanoPosition: layer.getCurrentPano().position,
+      nextPanoPosition: layer.getNextPano().position
+    });
+    // prepare informations about the needed textures
+    const panoCameras = newPano.geometries[0].properties.idSensors;
+    const imagesInfo = layer.cameras.map(cam => ({
+      cameraId: cam.name,
+      panoId: newPano.id,
+      as: () => {}
+    })).filter(info => !panoCameras || panoCameras.includes(info.cameraId));
+    const command = {
+      layer,
+      // put informations about image URL as extent to be used by generic DataSourceProvider, OrientedImageSource will use that.
+      extentsSource: imagesInfo,
+      view: context.view,
+      requester: newPano,
+      earlyDropFunction: commandCancellation
+    };
+
+    // async call to scheduler to get textures
+    context.scheduler.execute(command).then(textures => {
+      if (newPano.id === layer.currentPano.id) {
+        layer.material.setTextures(textures, newPano, layer.getCamerasNameFromFeature(newPano));
+        layer.material.updateUniforms(context.camera.camera3D);
+        context.view.notifyChange(layer, true);
+      }
+    }, () => {});
+  }
+}
+function updateBackground(layer) {
+  if (layer.background && layer.currentPano) {
+    layer.background.position.copy(layer.currentPano.position);
+    layer.background.updateMatrixWorld();
+    layer.background.material = layer.material || layer.background.material;
+  }
+}
+function createBackground(radius) {
+  if (!radius || radius <= 0) {
+    return undefined;
+  }
+  const geometry = new THREE.SphereGeometry(radius, 32, 32);
+  const material = new THREE.MeshPhongMaterial({
+    color: 0x7777ff,
+    side: THREE.DoubleSide,
+    transparent: true,
+    opacity: 0.5,
+    wireframe: true
+  });
+  const sphere = new THREE.Mesh(geometry, material);
+  sphere.visible = true;
+  sphere.name = 'OrientedImageBackground';
+  return sphere;
+}
+
+/**
+ * OrientedImageLayer loads oriented images, and project these textures on the scene.
+ * It is design to create an immersive view. </br>
+ * It loads a set of panoramic position and orientation,
+ * a set of camera calibration file (it's the same set of camera for each panoramic),
+ * and a set of texture (each image for each camera for each panoramic), all organised in an {@link OrientedImageSource}. </br>
+ * It creates an {@link OrientedImageMaterial} used to do projective texture mapping on the scene.
+ * @extends GeometryLayer
+ */
+class OrientedImageLayer extends GeometryLayer {
+  /**
+   * @param { string } id - The id of the layer, a unique name.
+   * @param { Object } config - configuration of the layer
+   * @param { number } config.backgroundDistance - Radius in meter of the sphere used as a background
+   * @param { function } config.onPanoChanged - callback fired when current panoramic changes
+   * @param { string } config.crs - crs projection of the view
+   * @param { string } config.orientation - Json object, using GeoJSon format to represent points,
+   * it's a set of panoramic position and orientation.
+   * @param { string } config.calibrations - Json object, representing a set of camera.
+   * see {@link CameraCalibrationParser}
+   * @param { OrientedImageSource } config.source - Source used to build url of texture for each oriented image,
+   * a tecture is need for each camera, for each panoramic.
+   */
+  constructor(id) {
+    let config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    const {
+      backgroundDistance,
+      background = createBackground(backgroundDistance),
+      onPanoChanged = () => {},
+      getCamerasNameFromFeature = () => {},
+      ...geometryOptions
+    } = config;
+    if (config.projection) {
+      console.warn('OrientedImageLayer projection parameter is deprecated, use crs instead.');
+      config.crs = config.crs || config.projection;
+    }
+    super(id, new THREE.Group(), geometryOptions);
+    this.isOrientedImageLayer = true;
+    this.background = background;
+    if (this.background) {
+      // Add layer id to easily identify the objects later on (e.g. to delete the geometries when deleting the layer)
+      this.background.layer = this.background.layer ?? {};
+      this.background.layer.id = this.background.layer.id ?? id;
+      this.object3d.add(this.background);
+    }
+
+    // currentPano is the current point, means it's the closest from the camera
+    this.currentPano = undefined;
+
+    // store a callback to fire event when current panoramic change
+    this.onPanoChanged = onPanoChanged;
+
+    // function to get cameras name from panoramic feature
+    this.getCamerasNameFromFeature = getCamerasNameFromFeature;
+    const resolve = this.addInitializationStep();
+    this.mergeFeatures = false;
+    this.filteringExtent = false;
+    this.accurate = true;
+    const options = {
+      out: this
+    };
+
+    // panos is an array of feature point, representing many panoramics.
+    // for each point, there is a position and a quaternion attribute.
+    this.source.whenReady.then(metadata => GeoJsonParser.parse(config.orientation || metadata.orientation, options).then(orientation => {
+      this.panos = orientation.features;
+
+      // the crs input is parsed in geojson parser
+      // and returned in options.in
+      const crsIn = options.in.crs;
+      const crsOut = config.crs;
+      const crs2crs = OrientationUtils.quaternionFromCRSToCRS(crsIn, crsOut);
+      const quat = new THREE.Quaternion();
+
+      // add position and quaternion attributes from point feature
+      let i = 0;
+      for (const pano of this.panos) {
+        // set position
+        coord.crs = pano.crs;
+        coord.setFromArray(pano.vertices).applyMatrix4(orientation.matrix);
+        pano.position = coord.toVector3();
+
+        // set quaternion
+        crs2crs(coord, quat);
+        pano.quaternion = OrientationUtils.quaternionFromAttitude(pano.geometries[0].properties).premultiply(quat);
+        pano.id = pano.geometries[0].properties.id;
+        pano.index = i++;
+      }
+    }).then(() => {
+      // array of cameras, represent the projective texture configuration for each panoramic.
+      CameraCalibrationParser.parse(config.calibration || metadata.calibration, config).then(cameras => {
+        this.cameras = cameras;
+        // create the material
+        this.material = new OrientedImageMaterial(this.cameras, config);
+        resolve();
+      });
+    }));
+  }
+
+  // eslint-disable-next-line
+  update() {}
+  set boostLight(value) {
+    this.material.uniforms.boostLight.value = value;
+  }
+  get boostLight() {
+    return this.material.uniforms.boostLight.value;
+  }
+  preUpdate(context) {
+    updatePano(context, context.camera.camera3D, this);
+    this.material.updateUniforms(context.camera.camera3D);
+    updateBackground(this);
+  }
+  getNextPano() {
+    const index = (this.currentPano.index + 1) % this.panos.length;
+    return this.panos[index];
+  }
+  getCurrentPano() {
+    return this.currentPano;
+  }
+  getPreviousPano() {
+    const index = (this.currentPano.index - 1) % this.panos.length;
+    return this.panos[index];
+  }
+
+  /**
+   * Delete background, but doesn't delete OrientedImageLayer.material. For the moment, this material visibility is set to false.
+   * You need to replace OrientedImageLayer.material applied on each object, if you want to continue displaying them.
+   * This issue (see #1018 {@link https://github.com/iTowns/itowns/issues/1018}) will be fixed when OrientedImageLayer will be a ColorLayer.
+  * @param {boolean} [clearCache=false] Whether to clear the layer cache or not
+  */
+  delete(clearCache) {
+    if (this.background) {
+      // only delete geometries if it has some
+      super.delete();
+    }
+    if (clearCache) {
+      this.cache.clear();
+    }
+    this.material.visible = false;
+    console.warn('You need to replace OrientedImageLayer.material applied on each object. This issue will be fixed when OrientedImageLayer will be a ColorLayer. the material visibility is set to false. To follow issue see https://github.com/iTowns/itowns/issues/1018');
+  }
+  mostNearPano(position) {
+    let minDistance = Infinity;
+    let nearPano;
+    for (const pano of this.panos) {
+      const distance = position.distanceTo(pano.position);
+      if (distance < minDistance) {
+        minDistance = distance;
+        nearPano = pano;
+      }
+    }
+    return nearPano;
+  }
+}
+export default OrientedImageLayer;

package/lib/Layer/PointCloudLayer.js

@@ -0,0 +1,405 @@
+import * as THREE from 'three';
+import GeometryLayer from "./GeometryLayer.js";
+import PointsMaterial, { PNTS_MODE } from "../Renderer/PointsMaterial.js";
+import Picking from "../Core/Picking.js";
+const point = new THREE.Vector3();
+const bboxMesh = new THREE.Mesh();
+const box3 = new THREE.Box3();
+bboxMesh.geometry.boundingBox = box3;
+function initBoundingBox(elt, layer) {
+  elt.tightbbox.getSize(box3.max);
+  box3.max.multiplyScalar(0.5);
+  box3.min.copy(box3.max).negate();
+  elt.obj.boxHelper = new THREE.BoxHelper(bboxMesh);
+  elt.obj.boxHelper.geometry = elt.obj.boxHelper.geometry.toNonIndexed();
+  elt.obj.boxHelper.computeLineDistances();
+  elt.obj.boxHelper.material = elt.childrenBitField ? new THREE.LineDashedMaterial({
+    dashSize: 0.25,
+    gapSize: 0.25
+  }) : new THREE.LineBasicMaterial();
+  elt.obj.boxHelper.material.color.setHex(0);
+  elt.obj.boxHelper.material.linewidth = 2;
+  elt.obj.boxHelper.frustumCulled = false;
+  elt.obj.boxHelper.position.copy(elt.tightbbox.min).add(box3.max);
+  elt.obj.boxHelper.autoUpdateMatrix = false;
+  layer.bboxes.add(elt.obj.boxHelper);
+  elt.obj.boxHelper.updateMatrix();
+  elt.obj.boxHelper.updateMatrixWorld();
+}
+function computeSSEPerspective(context, pointSize, spacing, elt, distance) {
+  if (distance <= 0) {
+    return Infinity;
+  }
+  const pointSpacing = spacing / 2 ** elt.depth;
+  // Estimate the onscreen distance between 2 points
+  const onScreenSpacing = context.camera.preSSE * pointSpacing / distance;
+  // [  P1  ]--------------[   P2   ]
+  //     <--------------------->      = pointsSpacing (in world coordinates)
+  //                                  ~ onScreenSpacing (in pixels)
+  // <------>                         = pointSize (in pixels)
+  return Math.max(0.0, onScreenSpacing - pointSize);
+}
+function computeSSEOrthographic(context, pointSize, spacing, elt) {
+  const pointSpacing = spacing / 2 ** elt.depth;
+
+  // Given an identity view matrix, project pointSpacing from world space to
+  // clip space. v' = vVP = vP
+  const v = new THREE.Vector4(pointSpacing);
+  v.applyMatrix4(context.camera.camera3D.projectionMatrix);
+
+  // We map v' to the screen space and calculate the distance to the origin.
+  const dx = v.x * 0.5 * context.camera.width;
+  const dy = v.y * 0.5 * context.camera.height;
+  const distance = Math.sqrt(dx * dx + dy * dy);
+  return Math.max(0.0, distance - pointSize);
+}
+function computeScreenSpaceError(context, pointSize, spacing, elt, distance) {
+  if (context.camera.camera3D.isOrthographicCamera) {
+    return computeSSEOrthographic(context, pointSize, spacing, elt);
+  }
+  return computeSSEPerspective(context, pointSize, spacing, elt, distance);
+}
+function markForDeletion(elt) {
+  if (elt.obj) {
+    elt.obj.visible = false;
+  }
+  if (!elt.notVisibleSince) {
+    elt.notVisibleSince = Date.now();
+    // Set .sse to an invalid value
+    elt.sse = -1;
+  }
+  for (const child of elt.children) {
+    markForDeletion(child);
+  }
+}
+function changeIntensityRange(layer) {
+  layer.material.intensityRange?.set(layer.minIntensityRange, layer.maxIntensityRange);
+}
+function changeElevationRange(layer) {
+  layer.material.elevationRange?.set(layer.minElevationRange, layer.maxElevationRange);
+}
+function changeAngleRange(layer) {
+  layer.material.angleRange?.set(layer.minAngleRange, layer.maxAngleRange);
+}
+
+/**
+ * The basis for all point clouds related layers.
+ *
+ * @property {boolean} isPointCloudLayer - Used to checkout whether this layer
+ * is a PointCloudLayer. Default is `true`. You should not change this, as it is
+ * used internally for optimisation.
+ * @property {THREE.Group|THREE.Object3D} group - Contains the created
+ * `THREE.Points` meshes, usually with an instance of a `THREE.Points` per node.
+ * @property {THREE.Group|THREE.Object3D} bboxes - Contains the bounding boxes
+ * (`THREE.Box3`) of the tree, usually one per node.
+ * @property {number} octreeDepthLimit - The depth limit at which to stop
+ * browsing the octree. Can be used to limit the browsing, without having to
+ * edit manually the source of the point cloud. No limit by default (`-1`).
+ * @property {number} [pointBudget=2000000] - Maximum number of points to
+ * display at the same time. This influences the performance of rendering.
+ * Default to two millions points.
+ * @property {number} [sseThreshold=2] - Threshold of the **S**creen **S**pace
+ * **E**rror. Default to `2`.
+ * @property {number} [pointSize=4] - The size (in pixels) of the points.
+ * Default to `4`.
+ * @property {THREE.Material|PointsMaterial} [material=new PointsMaterial] - The
+ * material to use to display the points of the cloud. Be default it is a new
+ * `PointsMaterial`.
+ * @property {number} [mode=PNTS_MODE.COLOR] - The displaying mode of the points.
+ * Values are specified in `PointsMaterial`.
+ * @property {number} [minIntensityRange=0] - The minimal intensity of the
+ * layer. Changing this value will affect the material, if it has the
+ * corresponding uniform. The value is normalized between 0 and 1.
+ * @property {number} [maxIntensityRange=1] - The maximal intensity of the
+ * layer. Changing this value will affect the material, if it has the
+ * corresponding uniform. The value is normalized between 0 and 1.
+ *
+ * @extends GeometryLayer
+ */
+class PointCloudLayer extends GeometryLayer {
+  /**
+   * Constructs a new instance of point cloud layer.
+   * Constructs a new instance of a Point Cloud Layer. This should not be used
+   * directly, but rather implemented using `extends`.
+   *
+   * @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
+   * 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. See the list of properties to know which one can be specified.
+   * @param {Source} config.source - Description and options of the source See @Layer.
+   * @param {number}  [options.minElevationRange] - Min value for the elevation range (default value will be taken from the source.metadata).
+   * @param {number}  [options.maxElevationRange] - Max value for the elevation range (default value will be taken from the source.metadata).
+   */
+  constructor(id) {
+    let config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    const {
+      object3d = new THREE.Group(),
+      group = new THREE.Group(),
+      bboxes = new THREE.Group(),
+      octreeDepthLimit = -1,
+      pointBudget = 2000000,
+      pointSize = 2,
+      sseThreshold = 2,
+      minIntensityRange = 1,
+      maxIntensityRange = 65536,
+      minElevationRange,
+      maxElevationRange,
+      minAngleRange = -90,
+      maxAngleRange = 90,
+      material = {},
+      mode = PNTS_MODE.COLOR,
+      ...geometryLayerConfig
+    } = config;
+    super(id, object3d, geometryLayerConfig);
+
+    /**
+     * @type {boolean}
+     * @readonly
+     */
+    this.isPointCloudLayer = true;
+    this.protocol = 'pointcloud';
+    this.group = group;
+    this.object3d.add(this.group);
+    this.bboxes = bboxes || new THREE.Group();
+    this.bboxes.visible = false;
+    this.object3d.add(this.bboxes);
+    this.group.updateMatrixWorld();
+
+    // default config
+    /**
+     * @type {number}
+     */
+    this.octreeDepthLimit = octreeDepthLimit;
+
+    /**
+     * @type {number}
+     */
+    this.pointBudget = pointBudget;
+
+    /**
+     * @type {number}
+     */
+    this.pointSize = pointSize;
+
+    /**
+     * @type {number}
+     */
+    this.sseThreshold = sseThreshold;
+    this.defineLayerProperty('minIntensityRange', minIntensityRange, changeIntensityRange);
+    this.defineLayerProperty('maxIntensityRange', maxIntensityRange, changeIntensityRange);
+    this.defineLayerProperty('minElevationRange', minElevationRange, changeElevationRange);
+    this.defineLayerProperty('maxElevationRange', maxElevationRange, changeElevationRange);
+    this.defineLayerProperty('minAngleRange', minAngleRange, changeAngleRange);
+    this.defineLayerProperty('maxAngleRange', maxAngleRange, changeAngleRange);
+
+    /**
+     * @type {THREE.Material}
+     */
+    this.material = material;
+    if (!this.material.isMaterial) {
+      this.material.intensityRange = new THREE.Vector2(this.minIntensityRange, this.maxIntensityRange);
+      this.material.elevationRange = new THREE.Vector2(this.minElevationRange, this.maxElevationRange);
+      this.material.angleRange = new THREE.Vector2(this.minAngleRange, this.maxAngleRange);
+      this.material = new PointsMaterial(this.material);
+    }
+    this.mode = mode || PNTS_MODE.COLOR;
+
+    /**
+     * @type {PointCloudNode | undefined}
+     */
+    this.root = undefined;
+  }
+  preUpdate(context, changeSources) {
+    // See https://cesiumjs.org/hosted-apps/massiveworlds/downloads/Ring/WorldScaleTerrainRendering.pptx
+    // slide 17
+    context.camera.preSSE = context.camera.height / (2 * Math.tan(THREE.MathUtils.degToRad(context.camera.camera3D.fov) * 0.5));
+    if (this.material) {
+      this.material.visible = this.visible;
+      this.material.opacity = this.opacity;
+      this.material.transparent = this.opacity < 1 || this.material.userData.needTransparency[this.material.mode];
+      this.material.size = this.pointSize;
+      this.material.scale = context.camera.preSSE;
+      if (this.material.updateUniforms) {
+        this.material.updateUniforms();
+      }
+    }
+
+    // lookup lowest common ancestor of changeSources
+    let commonAncestor;
+    for (const source of changeSources.values()) {
+      if (source.isCamera || source == this) {
+        // if the change is caused by a camera move, no need to bother
+        // to find common ancestor: we need to update the whole tree:
+        // some invisible tiles may now be visible
+        return [this.root];
+      }
+      if (source.obj === undefined) {
+        continue;
+      }
+      // filter sources that belong to our layer
+      if (source.obj.isPoints && source.obj.layer == this) {
+        if (!commonAncestor) {
+          commonAncestor = source;
+        } else {
+          commonAncestor = source.findCommonAncestor(commonAncestor);
+          if (!commonAncestor) {
+            return [this.root];
+          }
+        }
+      }
+    }
+    if (commonAncestor) {
+      return [commonAncestor];
+    }
+
+    // Start updating from hierarchy root
+    return [this.root];
+  }
+  update(context, layer, elt) {
+    elt.visible = false;
+    if (this.octreeDepthLimit >= 0 && this.octreeDepthLimit < elt.depth) {
+      markForDeletion(elt);
+      return;
+    }
+
+    // pick the best bounding box
+    const bbox = elt.tightbbox ? elt.tightbbox : elt.bbox;
+    elt.visible = context.camera.isBox3Visible(bbox, this.object3d.matrixWorld);
+    if (!elt.visible) {
+      markForDeletion(elt);
+      return;
+    }
+    elt.notVisibleSince = undefined;
+    point.copy(context.camera.camera3D.position).sub(this.object3d.getWorldPosition(new THREE.Vector3()));
+    point.applyQuaternion(this.object3d.getWorldQuaternion(new THREE.Quaternion()).invert());
+
+    // only load geometry if this elements has points
+    if (elt.numPoints !== 0) {
+      if (elt.obj) {
+        elt.obj.visible = true;
+      } else if (!elt.promise) {
+        const distance = Math.max(0.001, bbox.distanceToPoint(point));
+        // Increase priority of nearest node
+        const priority = computeScreenSpaceError(context, layer.pointSize, layer.spacing, elt, distance) / distance;
+        elt.promise = context.scheduler.execute({
+          layer,
+          requester: elt,
+          view: context.view,
+          priority,
+          redraw: true,
+          earlyDropFunction: cmd => !cmd.requester.visible || !this.visible
+        }).then(pts => {
+          elt.obj = pts;
+          // store tightbbox to avoid ping-pong (bbox = larger => visible, tight => invisible)
+          elt.tightbbox = pts.tightbbox;
+
+          // make sure to add it here, otherwise it might never
+          // be added nor cleaned
+          this.group.add(elt.obj);
+          elt.obj.updateMatrixWorld(true);
+        }).catch(err => {
+          if (!err.isCancelledCommandException) {
+            return err;
+          }
+        }).finally(() => {
+          elt.promise = null;
+        });
+      }
+    }
+    if (elt.children && elt.children.length) {
+      const distance = bbox.distanceToPoint(point);
+      elt.sse = computeScreenSpaceError(context, layer.pointSize, layer.spacing, elt, distance) / this.sseThreshold;
+      if (elt.sse >= 1) {
+        return elt.children;
+      } else {
+        for (const child of elt.children) {
+          markForDeletion(child);
+        }
+      }
+    }
+  }
+  postUpdate() {
+    this.displayedCount = 0;
+    for (const pts of this.group.children) {
+      if (pts.visible) {
+        const count = pts.geometry.attributes.position.count;
+        pts.geometry.setDrawRange(0, count);
+        this.displayedCount += count;
+      }
+    }
+    if (this.displayedCount > this.pointBudget) {
+      // 2 different point count limit implementation, depending on the potree source
+      if (this.supportsProgressiveDisplay) {
+        // In this format, points are evenly distributed within a node,
+        // so we can draw a percentage of each node and still get a correct
+        // representation
+        const reduction = this.pointBudget / this.displayedCount;
+        for (const pts of this.group.children) {
+          if (pts.visible) {
+            const count = Math.floor(pts.geometry.drawRange.count * reduction);
+            if (count > 0) {
+              pts.geometry.setDrawRange(0, count);
+            } else {
+              pts.visible = false;
+            }
+          }
+        }
+        this.displayedCount *= reduction;
+      } else {
+        // This format doesn't require points to be evenly distributed, so
+        // we're going to sort the nodes by "importance" (= on screen size)
+        // and display only the first N nodes
+        this.group.children.sort((p1, p2) => p2.userData.node.sse - p1.userData.node.sse);
+        let limitHit = false;
+        this.displayedCount = 0;
+        for (const pts of this.group.children) {
+          const count = pts.geometry.attributes.position.count;
+          if (limitHit || this.displayedCount + count > this.pointBudget) {
+            pts.visible = false;
+            limitHit = true;
+          } else {
+            this.displayedCount += count;
+          }
+        }
+      }
+    }
+    const now = Date.now();
+    for (let i = this.group.children.length - 1; i >= 0; i--) {
+      const obj = this.group.children[i];
+      if (!obj.visible && now - obj.userData.node.notVisibleSince > 10000) {
+        // remove from group
+        this.group.children.splice(i, 1);
+
+        // no need to dispose obj.material, as it is shared by all objects of this layer
+        obj.geometry.dispose();
+        obj.material = null;
+        obj.geometry = null;
+        obj.userData.node.obj = null;
+      }
+    }
+  }
+  pickObjectsAt(view, mouse, radius) {
+    let target = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+    return Picking.pickPointsAt(view, mouse, radius, this, target);
+  }
+  getObjectToUpdateForAttachedLayers(meta) {
+    if (meta.obj) {
+      const p = meta.parent;
+      if (p && p.obj) {
+        return {
+          element: meta.obj,
+          parent: p.obj
+        };
+      } else {
+        return {
+          element: meta.obj
+        };
+      }
+    }
+  }
+}
+export default PointCloudLayer;