@cognite/reveal 3.0.2 → 3.2.0

package/packages/pointclouds/src/potree-three-loader/geometry/PointCloudEptGeometryNode.d.ts

@@ -0,0 +1,63 @@
+import { IPointCloudTreeGeometryNode } from './IPointCloudTreeGeometryNode';
+import { IPointCloudTreeNodeBase } from '../tree/IPointCloudTreeNodeBase';
+import * as THREE from 'three';
+import { PointCloudEptGeometry, EptKey } from './PointCloudEptGeometry';
+import { ModelDataProvider } from '../../../../modeldata-api';
+export declare class PointCloudEptGeometryNode implements IPointCloudTreeGeometryNode {
+    private readonly _id;
+    private readonly _ept;
+    private readonly _key;
+    private readonly _dataLoader;
+    private readonly _boundingBox;
+    private readonly _boundingSphere;
+    private readonly _spacing;
+    private _level;
+    private _numPoints;
+    private readonly _name;
+    private readonly _index;
+    private readonly _children;
+    private _loading;
+    private _loaded;
+    private _parent;
+    private _isLeafNode;
+    private _geometry;
+    private _oneTimeDisposeHandlers;
+    static IDCount: number;
+    get id(): number;
+    get name(): string;
+    get level(): number;
+    get spacing(): number;
+    get boundingBox(): THREE.Box3;
+    get boundingSphere(): THREE.Sphere;
+    get loaded(): boolean;
+    get key(): EptKey;
+    get failed(): boolean;
+    get numPoints(): number;
+    get children(): IPointCloudTreeNodeBase[];
+    get oneTimeDisposeHandlers(): (() => void)[];
+    get isLeafNode(): boolean;
+    get geometry(): THREE.BufferGeometry | undefined;
+    get ept(): PointCloudEptGeometry;
+    get index(): number;
+    set parent(_p: PointCloudEptGeometryNode | undefined);
+    get parent(): PointCloudEptGeometryNode | undefined;
+    constructor(ept: PointCloudEptGeometry, modelDataProvider: ModelDataProvider, b?: THREE.Box3, d?: number, x?: number, y?: number, z?: number);
+    get isGeometryNode(): boolean;
+    getLevel(): number;
+    get isTreeNode(): boolean;
+    isLoaded(): boolean;
+    getBoundingSphere(): THREE.Sphere;
+    getBoundingBox(): THREE.Box3;
+    baseUrl(): string;
+    getNumPoints(): number;
+    fileName(): string;
+    getChildren(): IPointCloudTreeGeometryNode[];
+    traverse(callback: (node: IPointCloudTreeNodeBase) => void, includeSelf?: boolean): void;
+    addChild(child: PointCloudEptGeometryNode): void;
+    load(): Promise<void>;
+    loadPoints(): Promise<void>;
+    loadHierarchy(): Promise<void>;
+    doneLoading(bufferGeometry: THREE.BufferGeometry, _tightBoundingBox: THREE.Box3, np: number, _mean: THREE.Vector3): void;
+    toPotreeName(d: number, x: number, y: number, z: number): string;
+    dispose(): void;
+}

package/packages/pointclouds/src/potree-three-loader/geometry/translationUtils.d.ts

@@ -0,0 +1,7 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import * as THREE from 'three';
+export declare function toVector3(v: number[], offset?: number): THREE.Vector3;
+export declare function toBox3(b: number[]): THREE.Box3;
+export declare function sphereFrom(b: THREE.Box3): THREE.Sphere;

package/packages/pointclouds/src/potree-three-loader/index.d.ts

@@ -0,0 +1,10 @@
+export * from './rendering';
+export * from './tree/PointAttributes';
+export * from './tree/PointCloudOctreeNode';
+export * from './tree/PointCloudOctreePicker';
+export * from './tree/PointCloudOctree';
+export * from './tree/PointCloudTree';
+export * from './Potree';
+export * from './types/types';
+export * from './version';
+export { globalNumNodesLoading as numPointCloudNodesLoading } from './loading/globalLoadingCounter';

package/packages/pointclouds/src/potree-three-loader/loading/EptBinaryLoader.d.ts

@@ -0,0 +1,12 @@
+import { WorkerPool } from '../utils/WorkerPool';
+import { ILoader } from './ILoader';
+import { ModelDataProvider } from '../../../../modeldata-api';
+import { PointCloudEptGeometryNode } from '../geometry/PointCloudEptGeometryNode';
+export declare class EptBinaryLoader implements ILoader {
+    private readonly _dataLoader;
+    static readonly WORKER_POOL: WorkerPool<Worker>;
+    extension(): string;
+    constructor(dataLoader: ModelDataProvider);
+    load(node: PointCloudEptGeometryNode): Promise<void>;
+    parse(node: PointCloudEptGeometryNode, buffer: ArrayBuffer): Promise<void>;
+}

package/packages/pointclouds/src/potree-three-loader/loading/EptLoader.d.ts

@@ -0,0 +1,5 @@
+import { ModelDataProvider } from '../../../../modeldata-api';
+import { PointCloudEptGeometry } from '../geometry/PointCloudEptGeometry';
+export declare class EptLoader {
+    static load(baseUrl: string, fileName: string, modelDataProvider: ModelDataProvider): Promise<PointCloudEptGeometry>;
+}

package/packages/pointclouds/src/potree-three-loader/loading/ILoader.d.ts

@@ -0,0 +1,4 @@
+export interface ILoader {
+    load(node: any): Promise<void>;
+    parse(node: any, buffer: ArrayBuffer): void;
+}

package/packages/pointclouds/src/potree-three-loader/loading/globalLoadingCounter.d.ts

@@ -0,0 +1,5 @@
+declare let globalNumNodesLoading: number;
+declare const globalMaxNumNodesLoading: number;
+export { globalNumNodesLoading, globalMaxNumNodesLoading };
+export declare function incrementGlobalNumNodesLoading(): void;
+export declare function decrementGlobalNumNodesLoading(): void;

package/packages/pointclouds/src/potree-three-loader/rendering/PointCloudMaterial.d.ts

@@ -0,0 +1,204 @@
+import { BufferGeometry, Camera, Color, Material, RawShaderMaterial, Scene, Texture, Vector3, Vector4, WebGLRenderer } from 'three';
+import { PointCloudOctree } from '../tree/PointCloudOctree';
+import { IPointCloudTreeNodeBase } from '../tree/IPointCloudTreeNodeBase';
+import { IPointCloudTreeNode } from '../tree/IPointCloudTreeNode';
+import { ClipMode, IClipBox } from './clipping';
+import { PointCloudMixingMode, PotreePointColorType, PointOpacityType, PotreePointShape, PotreePointSizeType, TreeType } from './enums';
+import { IClassification, IUniform } from './types';
+export interface IPointCloudMaterialParameters {
+    size: number;
+    minSize: number;
+    maxSize: number;
+    treeType: TreeType;
+}
+export interface IPointCloudMaterialUniforms {
+    bbSize: IUniform<[number, number, number]>;
+    blendDepthSupplement: IUniform<number>;
+    blendHardness: IUniform<number>;
+    classificationLUT: IUniform<Texture>;
+    clipBoxCount: IUniform<number>;
+    clipBoxes: IUniform<Float32Array>;
+    depthMap: IUniform<Texture | null>;
+    diffuse: IUniform<[number, number, number]>;
+    fov: IUniform<number>;
+    gradient: IUniform<Texture>;
+    heightMax: IUniform<number>;
+    heightMin: IUniform<number>;
+    intensityBrightness: IUniform<number>;
+    intensityContrast: IUniform<number>;
+    intensityGamma: IUniform<number>;
+    intensityRange: IUniform<[number, number]>;
+    isLeafNode: IUniform<boolean>;
+    level: IUniform<number>;
+    maxSize: IUniform<number>;
+    minSize: IUniform<number>;
+    octreeSize: IUniform<number>;
+    opacity: IUniform<number>;
+    pcIndex: IUniform<number>;
+    rgbBrightness: IUniform<number>;
+    rgbContrast: IUniform<number>;
+    rgbGamma: IUniform<number>;
+    screenHeight: IUniform<number>;
+    screenWidth: IUniform<number>;
+    size: IUniform<number>;
+    spacing: IUniform<number>;
+    toModel: IUniform<number[]>;
+    transition: IUniform<number>;
+    uColor: IUniform<Color>;
+    visibleNodes: IUniform<Texture>;
+    vnStart: IUniform<number>;
+    wClassification: IUniform<number>;
+    wElevation: IUniform<number>;
+    wIntensity: IUniform<number>;
+    wReturnNumber: IUniform<number>;
+    wRGB: IUniform<number>;
+    wSourceID: IUniform<number>;
+    opacityAttenuation: IUniform<number>;
+    filterByNormalThreshold: IUniform<number>;
+    highlightedPointCoordinate: IUniform<Vector3>;
+    highlightedPointColor: IUniform<Vector4>;
+    enablePointHighlighting: IUniform<boolean>;
+    highlightedPointScale: IUniform<number>;
+    normalFilteringMode: IUniform<number>;
+    backgroundMap: IUniform<Texture | null>;
+    pointCloudID: IUniform<number>;
+    pointCloudMixAngle: IUniform<number>;
+    stripeDistanceX: IUniform<number>;
+    stripeDistanceY: IUniform<number>;
+    stripeDivisorX: IUniform<number>;
+    stripeDivisorY: IUniform<number>;
+    pointCloudMixingMode: IUniform<number>;
+}
+export declare class PointCloudMaterial extends RawShaderMaterial {
+    private static readonly helperVec3;
+    private static readonly helperVec2;
+    /**
+     * Use the drawing buffer size instead of the dom client width and height when passing the screen height and screen width uniforms to the
+     * shader. This is useful if you have offscreen canvases (which in some browsers return 0 as client width and client height).
+     */
+    useDrawingBufferSize: boolean;
+    lights: boolean;
+    fog: boolean;
+    numClipBoxes: number;
+    clipBoxes: IClipBox[];
+    visibleNodesTexture: Texture | undefined;
+    private readonly visibleNodeTextureOffsets;
+    private readonly _gradient;
+    private gradientTexture;
+    private _classification;
+    private classificationTexture;
+    uniforms: IPointCloudMaterialUniforms & Record<string, IUniform<any>>;
+    bbSize: [number, number, number];
+    depthMap: Texture | undefined;
+    fov: number;
+    heightMax: number;
+    heightMin: number;
+    intensityBrightness: number;
+    intensityContrast: number;
+    intensityGamma: number;
+    intensityRange: [number, number];
+    maxSize: number;
+    minSize: number;
+    octreeSize: number;
+    opacity: number;
+    rgbBrightness: number;
+    rgbContrast: number;
+    rgbGamma: number;
+    screenHeight: number;
+    screenWidth: number;
+    size: number;
+    spacing: number;
+    transition: number;
+    color: Color;
+    weightClassification: number;
+    weightElevation: number;
+    weightIntensity: number;
+    weightReturnNumber: number;
+    weightRGB: number;
+    weightSourceID: number;
+    opacityAttenuation: number;
+    filterByNormalThreshold: number;
+    highlightedPointCoordinate: Vector3;
+    highlightedPointColor: Vector4;
+    enablePointHighlighting: boolean;
+    highlightedPointScale: number;
+    normalFilteringMode: number;
+    backgroundMap: Texture | undefined;
+    pointCloudID: number;
+    pointCloudMixingMode: number;
+    stripeDistanceX: number;
+    stripeDistanceY: number;
+    stripeDivisorX: number;
+    stripeDivisorY: number;
+    pointCloudMixAngle: number;
+    useClipBox: boolean;
+    weighted: boolean;
+    hqDepthPass: boolean;
+    pointColorType: PotreePointColorType;
+    pointSizeType: PotreePointSizeType;
+    clipMode: ClipMode;
+    useEDL: boolean;
+    shape: PotreePointShape;
+    treeType: TreeType;
+    pointOpacityType: PointOpacityType;
+    useFilterByNormal: boolean;
+    useTextureBlending: boolean;
+    usePointCloudMixing: boolean;
+    highlightPoint: boolean;
+    attributes: {
+        position: {
+            type: string;
+            value: never[];
+        };
+        color: {
+            type: string;
+            value: never[];
+        };
+        normal: {
+            type: string;
+            value: never[];
+        };
+        intensity: {
+            type: string;
+            value: never[];
+        };
+        classification: {
+            type: string;
+            value: never[];
+        };
+        returnNumber: {
+            type: string;
+            value: never[];
+        };
+        numberOfReturns: {
+            type: string;
+            value: never[];
+        };
+        pointSourceID: {
+            type: string;
+            value: never[];
+        };
+        indices: {
+            type: string;
+            value: never[];
+        };
+    };
+    constructor(parameters?: Partial<IPointCloudMaterialParameters>);
+    dispose(): void;
+    clearVisibleNodeTextureOffsets(): void;
+    updateShaderSource(): void;
+    applyDefines(shaderSrc: string): string;
+    setPointCloudMixingMode(mode: PointCloudMixingMode): void;
+    getPointCloudMixingMode(): PointCloudMixingMode;
+    setClipBoxes(clipBoxes: IClipBox[]): void;
+    get classification(): IClassification;
+    set classification(value: IClassification);
+    private recomputeClassification;
+    get elevationRange(): [number, number];
+    set elevationRange(value: [number, number]);
+    getUniform<K extends keyof IPointCloudMaterialUniforms>(name: K): IPointCloudMaterialUniforms[K]['value'];
+    setUniform<K extends keyof IPointCloudMaterialUniforms>(name: K, value: IPointCloudMaterialUniforms[K]['value']): void;
+    updateMaterial(octree: PointCloudOctree, visibleNodes: IPointCloudTreeNodeBase[], camera: Camera, renderer: WebGLRenderer): void;
+    private updateVisibilityTextureData;
+    static makeOnBeforeRender(octree: PointCloudOctree, node: IPointCloudTreeNode, pcIndex?: number): (renderer: WebGLRenderer, scene: Scene, camera: Camera, bufferGeometry: BufferGeometry, material: Material) => void;
+}

package/packages/pointclouds/src/potree-three-loader/rendering/classification.d.ts

@@ -0,0 +1,2 @@
+import { IClassification } from './types';
+export declare const DEFAULT_CLASSIFICATION: IClassification;

package/packages/pointclouds/src/potree-three-loader/rendering/clipping.d.ts

@@ -0,0 +1,12 @@
+import { Box3, Matrix4, Vector3 } from 'three';
+export declare enum ClipMode {
+    DISABLED = 0,
+    CLIP_OUTSIDE = 1,
+    HIGHLIGHT_INSIDE = 2
+}
+export interface IClipBox {
+    box: Box3;
+    inverse: Matrix4;
+    matrix: Matrix4;
+    position: Vector3;
+}

package/packages/pointclouds/src/potree-three-loader/rendering/constants.d.ts

@@ -0,0 +1,15 @@
+import { Color, Vector4 } from 'three';
+export declare const DEFAULT_RGB_BRIGHTNESS = 0;
+export declare const DEFAULT_RGB_CONTRAST = 0;
+export declare const DEFAULT_RGB_GAMMA = 1;
+export declare const DEFAULT_MAX_POINT_SIZE = 50;
+export declare const DEFAULT_MIN_NODE_PIXEL_SIZE = 50;
+export declare const DEFAULT_MIN_POINT_SIZE = 1;
+export declare const DEFAULT_PICK_WINDOW_SIZE = 15;
+export declare const DEFAULT_POINT_BUDGET = 3000000;
+export declare const MAX_LOADS_TO_GPU = 2;
+export declare const MAX_NUM_NODES_LOADING = 8;
+export declare const UPDATE_THROTTLE_TIME_MS = 100;
+export declare const PERSPECTIVE_CAMERA = "PerspectiveCamera";
+export declare const COLOR_BLACK: Color;
+export declare const DEFAULT_HIGHLIGHT_COLOR: Vector4;

package/packages/pointclouds/src/potree-three-loader/rendering/enums.d.ts

@@ -0,0 +1,46 @@
+export declare enum PotreePointSizeType {
+    Fixed = 0,
+    Attenuated = 1,
+    Adaptive = 2
+}
+export declare enum PotreePointShape {
+    Square = 0,
+    Circle = 1,
+    Paraboloid = 2
+}
+export declare enum TreeType {
+    Octree = 0,
+    KdTree = 1
+}
+export declare enum PointOpacityType {
+    Fixed = 0,
+    Attenuated = 1
+}
+export declare enum PotreePointColorType {
+    Rgb = 0,
+    Color = 1,
+    Depth = 2,
+    Height = 3,
+    Elevation = 3,
+    Intensity = 4,
+    IntensityGradient = 5,
+    Lod = 6,
+    LevelOfDetail = 6,
+    PointIndex = 7,
+    Classification = 8,
+    ReturnNumber = 9,
+    Source = 10,
+    Normal = 11,
+    Phong = 12,
+    RgbHeight = 13,
+    Composite = 50
+}
+export declare enum NormalFilteringMode {
+    ABSOLUTE_NORMAL_FILTERING_MODE = 1,
+    LESS_EQUAL_NORMAL_FILTERING_MODE = 2,
+    GREATER_NORMAL_FILTERING_MODE = 3
+}
+export declare enum PointCloudMixingMode {
+    CHECKBOARD = 1,
+    STRIPES = 2
+}

package/packages/pointclouds/src/potree-three-loader/rendering/features.d.ts

@@ -0,0 +1,6 @@
+export declare const FEATURES: {
+    SHADER_INTERPOLATION: boolean;
+    SHADER_SPLATS: boolean;
+    SHADER_EDL: boolean;
+    precision: string;
+};

package/packages/pointclouds/src/potree-three-loader/rendering/gradients/SpectralGradient.d.ts

@@ -0,0 +1,2 @@
+import { IGradient } from '../types';
+export declare const SpectralGradient: IGradient;

package/packages/pointclouds/src/potree-three-loader/rendering/index.d.ts

@@ -0,0 +1,5 @@
+export * from './clipping';
+export * from './enums';
+export * from './PointCloudMaterial';
+export * from './texture-generation';
+export * from './types';

package/packages/pointclouds/src/potree-three-loader/rendering/texture-generation.d.ts

@@ -0,0 +1,5 @@
+import { Color, Texture } from 'three';
+import { IClassification, IGradient } from './types';
+export declare function generateDataTexture(width: number, height: number, color: Color): Texture;
+export declare function generateGradientTexture(gradient: IGradient): Texture;
+export declare function generateClassificationTexture(classification: IClassification): Texture;

package/packages/pointclouds/src/potree-three-loader/rendering/types.d.ts

@@ -0,0 +1,10 @@
+import { Color, IUniform as IThreeUniform, Vector4 } from 'three';
+export declare type IGradient = [number, Color][];
+export interface IClassification {
+    [value: string]: Vector4;
+    DEFAULT: Vector4;
+}
+export interface IUniform<T> extends IThreeUniform {
+    type: string;
+    value: T;
+}

package/packages/pointclouds/src/potree-three-loader/tree/IPointCloudTreeNode.d.ts

@@ -0,0 +1,7 @@
+import { IPointCloudTreeNodeBase } from './IPointCloudTreeNodeBase';
+import { IPointCloudTreeGeometryNode } from '../geometry/IPointCloudTreeGeometryNode';
+import * as THREE from 'three';
+export interface IPointCloudTreeNode extends IPointCloudTreeNodeBase {
+    sceneNode: THREE.Points;
+    geometryNode: IPointCloudTreeGeometryNode;
+}

package/packages/pointclouds/src/potree-three-loader/tree/IPointCloudTreeNodeBase.d.ts

@@ -0,0 +1,18 @@
+import * as THREE from 'three';
+export interface IPointCloudTreeNodeBase {
+    id: number;
+    name: string;
+    level: number;
+    index: number;
+    spacing: number;
+    boundingBox: THREE.Box3;
+    boundingSphere: THREE.Sphere;
+    loaded: boolean;
+    numPoints: number;
+    isTreeNode: boolean;
+    boundingBoxNode?: THREE.Object3D;
+    readonly children: Array<IPointCloudTreeNodeBase | null>;
+    readonly isLeafNode: boolean;
+    dispose(): void;
+    traverse(cb: (node: IPointCloudTreeNodeBase) => void, includeSelf?: boolean): void;
+}

package/packages/pointclouds/src/potree-three-loader/tree/PointAttributes.d.ts

@@ -0,0 +1,52 @@
+export declare enum PointAttributeName {
+    POSITION_CARTESIAN = 0,
+    COLOR_PACKED = 1,
+    COLOR_FLOATS_1 = 2,
+    COLOR_FLOATS_255 = 3,
+    NORMAL_FLOATS = 4,
+    FILLER = 5,
+    INTENSITY = 6,
+    CLASSIFICATION = 7,
+    NORMAL_SPHEREMAPPED = 8,
+    NORMAL_OCT16 = 9,
+    NORMAL = 10
+}
+export interface PointAttributeType {
+    ordinal: number;
+    size: number;
+}
+export declare const POINT_ATTRIBUTE_TYPES: Record<string, PointAttributeType>;
+export interface IPointAttribute {
+    name: PointAttributeName;
+    type: PointAttributeType;
+    numElements: number;
+    byteSize: number;
+}
+export interface IPointAttributes {
+    attributes: IPointAttribute[];
+    byteSize: number;
+    size: number;
+}
+export declare const POINT_ATTRIBUTES: {
+    POSITION_CARTESIAN: IPointAttribute;
+    RGBA_PACKED: IPointAttribute;
+    COLOR_PACKED: IPointAttribute;
+    RGB_PACKED: IPointAttribute;
+    NORMAL_FLOATS: IPointAttribute;
+    FILLER_1B: IPointAttribute;
+    INTENSITY: IPointAttribute;
+    CLASSIFICATION: IPointAttribute;
+    NORMAL_SPHEREMAPPED: IPointAttribute;
+    NORMAL_OCT16: IPointAttribute;
+    NORMAL: IPointAttribute;
+};
+export declare type PointAttributeStringName = keyof typeof POINT_ATTRIBUTES;
+export declare class PointAttributes implements IPointAttributes {
+    attributes: IPointAttribute[];
+    byteSize: number;
+    size: number;
+    constructor(pointAttributeNames?: PointAttributeStringName[]);
+    add(pointAttribute: IPointAttribute): void;
+    hasColors(): boolean;
+    hasNormals(): boolean;
+}

package/packages/pointclouds/src/potree-three-loader/tree/PointCloudOctree.d.ts

@@ -0,0 +1,48 @@
+import { Box3, Camera, Object3D, Ray, Sphere, WebGLRenderer } from 'three';
+import { PointCloudMaterial, PotreePointSizeType } from '../rendering';
+import { IPointCloudTreeGeometry } from '../geometry/IPointCloudTreeGeometry';
+import { IPointCloudTreeGeometryNode } from '../geometry/IPointCloudTreeGeometryNode';
+import { PickParams } from './PointCloudOctreePicker';
+import { PointCloudTree } from './PointCloudTree';
+import { PickPoint } from '../types/types';
+import { IPotree } from '../types/IPotree';
+import { IPointCloudTreeNodeBase } from './IPointCloudTreeNodeBase';
+import { IPointCloudTreeNode } from './IPointCloudTreeNode';
+export declare class PointCloudOctree extends PointCloudTree {
+    potree: IPotree;
+    disposed: boolean;
+    pcoGeometry: IPointCloudTreeGeometry;
+    boundingBox: Box3;
+    boundingSphere: Sphere;
+    material: PointCloudMaterial;
+    level: number;
+    maxLevel: number;
+    /**
+     * The minimum radius of a node's bounding sphere on the screen in order to be displayed.
+     */
+    minNodePixelSize: number;
+    root: IPointCloudTreeNodeBase | undefined;
+    boundingBoxNodes: Object3D[];
+    visibleNodes: IPointCloudTreeNode[];
+    visibleGeometry: IPointCloudTreeGeometryNode[];
+    numVisiblePoints: number;
+    showBoundingBox: boolean;
+    private readonly visibleBounds;
+    private picker;
+    constructor(potree: IPotree, pcoGeometry: IPointCloudTreeGeometry, material?: PointCloudMaterial);
+    private updateMaterial;
+    dispose(): void;
+    get pointSizeType(): PotreePointSizeType;
+    set pointSizeType(value: PotreePointSizeType);
+    toTreeNode(geometryNode: IPointCloudTreeGeometryNode, parent?: IPointCloudTreeNode | null): IPointCloudTreeNode;
+    updateVisibleBounds(): void;
+    updateBoundingBoxes(): void;
+    updateMatrixWorld(force: boolean): void;
+    hideDescendants(object: Object3D): void;
+    moveToOrigin(): void;
+    moveToGroundPlane(): void;
+    getBoundingBoxWorld(): Box3;
+    getVisibleExtent(): Box3;
+    pick(renderer: WebGLRenderer, camera: Camera, ray: Ray, params?: Partial<PickParams>): PickPoint | null;
+    get progress(): number;
+}

package/packages/pointclouds/src/potree-three-loader/tree/PointCloudOctreeNode.d.ts

@@ -0,0 +1,27 @@
+import { Box3, EventDispatcher, Object3D, Points, Sphere } from 'three';
+import { IPointCloudTreeGeometryNode } from '../geometry/IPointCloudTreeGeometryNode';
+import { IPointCloudTreeNode } from './IPointCloudTreeNode';
+import { IPointCloudTreeNodeBase } from './IPointCloudTreeNodeBase';
+export declare class PointCloudOctreeNode extends EventDispatcher implements IPointCloudTreeNode {
+    geometryNode: IPointCloudTreeGeometryNode;
+    sceneNode: Points;
+    pcIndex: number | undefined;
+    boundingBoxNode?: Object3D | undefined;
+    readonly children: (IPointCloudTreeNodeBase | null)[];
+    readonly loaded = true;
+    readonly isTreeNode: boolean;
+    readonly isGeometryNode: boolean;
+    constructor(geometryNode: IPointCloudTreeGeometryNode, sceneNode: Points);
+    dispose(): void;
+    disposeSceneNode(): void;
+    traverse(cb: (node: IPointCloudTreeNodeBase) => void, includeSelf?: boolean): void;
+    get id(): number;
+    get name(): string;
+    get level(): number;
+    get isLeafNode(): boolean;
+    get numPoints(): number;
+    get index(): number;
+    get boundingSphere(): Sphere;
+    get boundingBox(): Box3;
+    get spacing(): number;
+}

package/packages/pointclouds/src/potree-three-loader/tree/PointCloudOctreePicker.d.ts

@@ -0,0 +1,14 @@
+import { Camera, Ray, WebGLRenderer } from 'three';
+import { PointCloudOctree } from './PointCloudOctree';
+import { PickPoint } from '../types/types';
+import { PickParams } from './PointCloudOctreePickerHelper';
+export { PickParams };
+export declare class PointCloudOctreePicker {
+    private static readonly helperVec3;
+    private pickState;
+    private readonly _renderer;
+    private readonly _pickerHelper;
+    constructor(renderer: WebGLRenderer);
+    dispose(): void;
+    pick(camera: Camera, ray: Ray, octrees: PointCloudOctree[], params?: Partial<PickParams>): PickPoint | null;
+}

package/packages/pointclouds/src/potree-three-loader/tree/PointCloudOctreePickerHelper.d.ts

@@ -0,0 +1,57 @@
+import { Camera, Ray, Scene, Vector3, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { PointCloudMaterial } from '../rendering';
+import { PointCloudOctree } from './PointCloudOctree';
+import { IPointCloudTreeNode } from './IPointCloudTreeNode';
+import { PickPoint, PointCloudHit } from '../types/types';
+export interface RenderedNode {
+    node: IPointCloudTreeNode;
+    octree: PointCloudOctree;
+}
+export interface IPickState {
+    renderTarget: WebGLRenderTarget;
+    material: PointCloudMaterial;
+    scene: Scene;
+}
+export interface PickParams {
+    pickWindowSize: number;
+    pickOutsideClipRegion: boolean;
+    /**
+     * If provided, the picking will use this pixel position instead of the `Ray` passed to the `pick`
+     * method.
+     */
+    pixelPosition: Vector3;
+    /**
+     * Function which gets called after a picking material has been created and setup and before the
+     * point cloud is rendered into the picking render target. This gives applications a chance to
+     * customize the renderTarget and the material.
+     *
+     * @param material The pick material.
+     * @param renterTarget The render target used for picking.
+     */
+    onBeforePickRender: (material: PointCloudMaterial, renterTarget: WebGLRenderTarget) => void;
+}
+/**
+ * Helper class for PointCloudOctreePicker.
+ */
+export declare class PointCloudOctreePickerHelper {
+    private static readonly helperVec3;
+    private static readonly helperSphere;
+    private readonly _renderer;
+    private readonly _rendererStateHelper;
+    constructor(renderer: WebGLRenderer);
+    resetState(): void;
+    prepareRender(x: number, y: number, pickWndSize: number, pickMaterial: PointCloudMaterial, pickState: IPickState): void;
+    render(camera: Camera, pickMaterial: PointCloudMaterial, octrees: PointCloudOctree[], ray: Ray, pickState: IPickState, params: Partial<PickParams>): RenderedNode[];
+    private static nodesOnRay;
+    readPixels(x: number, y: number, pickWndSize: number): Uint8Array;
+    private static createTempNodes;
+    private static updatePickMaterial;
+    static updatePickRenderTarget(pickState: IPickState, width: number, height: number): void;
+    private static makePickRenderTarget;
+    static findHit(pixels: Uint8Array, pickWndSize: number, nodes: RenderedNode[], camera: THREE.Camera): PointCloudHit | null;
+    static getPickPoint(hit: PointCloudHit | null, nodes: RenderedNode[]): PickPoint | null;
+    static getPointPosition(nodes: RenderedNode[], pcIndex: number, pIndex: number): Vector3;
+    private static addPositionToPickPoint;
+    private static addNormalToPickPoint;
+    static getPickState(): IPickState;
+}