potree-core 1.0.6 → 2.0.0

package/dist/loading/binary-loader.d.ts

@@ -0,0 +1,35 @@
+import { Box3 } from 'three';
+import { PointCloudOctreeGeometryNode } from '../point-cloud-octree-geometry-node';
+import { Version } from '../version';
+import { GetUrlFn, XhrRequest } from './types';
+interface BinaryLoaderOptions {
+    getUrl?: GetUrlFn;
+    version: string;
+    boundingBox: Box3;
+    scale: number;
+    xhrRequest: XhrRequest;
+}
+type Callback = (node: PointCloudOctreeGeometryNode) => void;
+export declare class BinaryLoader {
+    version: Version;
+    boundingBox: Box3;
+    scale: number;
+    getUrl: GetUrlFn;
+    disposed: boolean;
+    xhrRequest: XhrRequest;
+    callbacks: Callback[];
+    private workers;
+    constructor({ getUrl, version, boundingBox, scale, xhrRequest }: BinaryLoaderOptions);
+    dispose(): void;
+    load(node: PointCloudOctreeGeometryNode): Promise<void>;
+    private getNodeUrl;
+    private parse;
+    private getWorker;
+    private releaseWorker;
+    private getTightBoundingBox;
+    private addBufferAttributes;
+    private addIndices;
+    private addNormalAttribute;
+    private isAttribute;
+}
+export {};

package/dist/loading/index.d.ts

@@ -0,0 +1,3 @@
+export * from './binary-loader';
+export * from './load-poc';
+export * from './types';

package/dist/loading/load-poc.d.ts

@@ -0,0 +1,14 @@
+import { PointCloudOctreeGeometry } from '../point-cloud-octree-geometry';
+import { GetUrlFn, XhrRequest } from './types';
+/**
+ *
+ * @param url
+ *    The url of the point cloud file (usually cloud.js).
+ * @param getUrl
+ *    Function which receives the relative URL of a point cloud chunk file which is to be loaded
+ *    and shoud return a new url (e.g. signed) in the form of a string or a promise.
+ * @param xhrRequest An arrow function for a fetch request
+ * @returns
+ *    An observable which emits once when the first LOD of the point cloud is loaded.
+ */
+export declare function loadPOC(url: string, getUrl: GetUrlFn, xhrRequest: XhrRequest): Promise<PointCloudOctreeGeometry>;

package/dist/loading/types.d.ts

@@ -0,0 +1,2 @@
+export type GetUrlFn = (url: string) => string | Promise<string>;
+export type XhrRequest = (input: RequestInfo, init?: RequestInit) => Promise<Response>;

package/dist/loading2/OctreeGeometry.d.ts

@@ -0,0 +1,23 @@
+import { NodeLoader, Metadata } from './OctreeLoader';
+import { Box3, Sphere, Vector3 } from 'three';
+import { PointAttributes } from './PointAttributes';
+import { OctreeGeometryNode } from './OctreeGeometryNode';
+export declare class OctreeGeometry {
+    loader: NodeLoader;
+    boundingBox: Box3;
+    root: OctreeGeometryNode;
+    url: string | null;
+    pointAttributes: PointAttributes | null;
+    spacing: number;
+    tightBoundingBox: Box3;
+    numNodesLoading: number;
+    maxNumNodesLoading: number;
+    boundingSphere: Sphere;
+    tightBoundingSphere: Sphere;
+    offset: Vector3;
+    scale: [number, number, number];
+    disposed: boolean;
+    projection?: Metadata['projection'];
+    constructor(loader: NodeLoader, boundingBox: Box3);
+    dispose(): void;
+}

package/dist/loading2/OctreeGeometryNode.d.ts

@@ -0,0 +1,40 @@
+import { IPointCloudTreeNode } from './../types';
+import { Box3, Sphere, BufferGeometry } from 'three';
+import { OctreeGeometry } from './OctreeGeometry';
+export declare class OctreeGeometryNode implements IPointCloudTreeNode {
+    name: string;
+    octreeGeometry: OctreeGeometry;
+    boundingBox: Box3;
+    constructor(name: string, octreeGeometry: OctreeGeometry, boundingBox: Box3);
+    loaded: boolean;
+    loading: boolean;
+    parent: OctreeGeometryNode | null;
+    geometry: BufferGeometry | null;
+    nodeType?: number;
+    byteOffset?: bigint;
+    byteSize?: bigint;
+    hierarchyByteOffset?: bigint;
+    hierarchyByteSize?: bigint;
+    hasChildren: boolean;
+    spacing: number;
+    density?: number;
+    isLeafNode: boolean;
+    readonly isTreeNode: boolean;
+    readonly isGeometryNode: boolean;
+    readonly children: ReadonlyArray<OctreeGeometryNode | null>;
+    static IDCount: number;
+    id: number;
+    index: number;
+    boundingSphere: Sphere;
+    numPoints: number;
+    level: number;
+    oneTimeDisposeHandlers: Function[];
+    getLevel(): number;
+    isLoaded(): boolean;
+    getBoundingSphere(): Sphere;
+    getBoundingBox(): Box3;
+    load(): void;
+    getNumPoints(): number;
+    dispose(): void;
+    traverse(cb: (node: OctreeGeometryNode) => void, includeSelf?: boolean): void;
+}

package/dist/loading2/OctreeLoader.d.ts

@@ -0,0 +1,109 @@
+import { XhrRequest } from './../loading/types';
+import { PointAttributes } from './PointAttributes';
+import { WorkerPool } from './WorkerPool';
+import { OctreeGeometryNode } from './OctreeGeometryNode';
+import { OctreeGeometry } from './OctreeGeometry';
+export declare class NodeLoader {
+    url: string;
+    workerPool: WorkerPool;
+    metadata: Metadata;
+    attributes?: PointAttributes;
+    scale?: [number, number, number];
+    offset?: [number, number, number];
+    constructor(url: string, workerPool: WorkerPool, metadata: Metadata);
+    load(node: OctreeGeometryNode): Promise<void>;
+    parseHierarchy(node: OctreeGeometryNode, buffer: ArrayBuffer): void;
+    loadHierarchy(node: OctreeGeometryNode): Promise<void>;
+}
+declare let typenameTypeattributeMap: {
+    double: {
+        ordinal: number;
+        name: string;
+        size: number;
+    };
+    float: {
+        ordinal: number;
+        name: string;
+        size: number;
+    };
+    int8: {
+        ordinal: number;
+        name: string;
+        size: number;
+    };
+    uint8: {
+        ordinal: number;
+        name: string;
+        size: number;
+    };
+    int16: {
+        ordinal: number;
+        name: string;
+        size: number;
+    };
+    uint16: {
+        ordinal: number;
+        name: string;
+        size: number;
+    };
+    int32: {
+        ordinal: number;
+        name: string;
+        size: number;
+    };
+    uint32: {
+        ordinal: number;
+        name: string;
+        size: number;
+    };
+    int64: {
+        ordinal: number;
+        name: string;
+        size: number;
+    };
+    uint64: {
+        ordinal: number;
+        name: string;
+        size: number;
+    };
+};
+type AttributeType = keyof typeof typenameTypeattributeMap;
+export interface Attribute {
+    name: string;
+    description: string;
+    size: number;
+    numElements: number;
+    type: AttributeType;
+    min: number[];
+    max: number[];
+}
+export interface Metadata {
+    version: string;
+    name: string;
+    description: string;
+    points: number;
+    projection: string;
+    hierarchy: {
+        firstChunkSize: number;
+        stepSize: number;
+        depth: number;
+    };
+    offset: [number, number, number];
+    scale: [number, number, number];
+    spacing: number;
+    boundingBox: {
+        min: [number, number, number];
+        max: [number, number, number];
+    };
+    encoding: string;
+    attributes: Attribute[];
+}
+export declare class OctreeLoader {
+    workerPool: WorkerPool;
+    constructor();
+    static parseAttributes(jsonAttributes: Attribute[]): PointAttributes;
+    load(url: string, xhrRequest: XhrRequest): Promise<{
+        geometry: OctreeGeometry;
+    }>;
+}
+export {};

package/dist/loading2/PointAttributes.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Some types of possible point attribute data formats
+ *
+ * @class
+ */
+declare const PointAttributeTypes: PointAttributeTypesType;
+type PointAttributeTypesType = {
+    [key: string]: PointAttributeTypeType;
+};
+type PointAttributeTypeType = {
+    ordinal: number;
+    name: string;
+    size: number;
+};
+export { PointAttributeTypes };
+type RangeType = number[] | [number[], number[]];
+declare class PointAttribute {
+    name: string;
+    type: PointAttributeTypeType;
+    numElements: number;
+    range: RangeType;
+    byteSize: number;
+    description: string;
+    initialRange?: RangeType;
+    constructor(name: string, type: PointAttributeTypeType, numElements: number, range?: RangeType);
+}
+export { PointAttribute };
+export declare const POINT_ATTRIBUTES: {
+    [key: string]: PointAttribute;
+};
+type PAVectorType = {
+    name: string;
+    attributes: string[];
+};
+export declare class PointAttributes {
+    attributes: PointAttribute[];
+    byteSize: number;
+    size: number;
+    vectors: PAVectorType[];
+    constructor(pointAttributes?: string[], attributes?: PointAttribute[], byteSize?: number, size?: number, vectors?: PAVectorType[]);
+    add(pointAttribute: PointAttribute): void;
+    addVector(vector: PAVectorType): void;
+    hasNormals(): boolean;
+}

package/dist/loading2/WorkerPool.d.ts

@@ -0,0 +1,9 @@
+export declare enum WorkerType {
+    DECODER_WORKER_BROTLI = "DECODER_WORKER_BROTLI",
+    DECODER_WORKER = "DECODER_WORKER"
+}
+export declare class WorkerPool {
+    private workers;
+    getWorker(workerType: WorkerType): Worker;
+    returnWorker(workerType: WorkerType, worker: Worker): void;
+}

package/dist/loading2/load-octree.d.ts

@@ -0,0 +1,2 @@
+import { GetUrlFn, XhrRequest } from '../loading/types';
+export declare function loadOctree(url: string, getUrl: GetUrlFn, xhrRequest: XhrRequest): Promise<import("./OctreeGeometry").OctreeGeometry>;

package/dist/materials/blur-material.d.ts

@@ -0,0 +1,11 @@
+import { ShaderMaterial, Texture } from 'three';
+import { IUniform } from './types';
+export interface IBlurMaterialUniforms {
+    [name: string]: IUniform<any>;
+    screenWidth: IUniform<number>;
+    screenHeight: IUniform<number>;
+    map: IUniform<Texture | null>;
+}
+export declare class BlurMaterial extends ShaderMaterial {
+    uniforms: IBlurMaterialUniforms;
+}

package/dist/materials/classification.d.ts

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

package/dist/materials/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/dist/materials/color-encoding.d.ts

@@ -0,0 +1,4 @@
+export declare enum ColorEncoding {
+    LINEAR = 0,
+    SRGB = 1
+}

package/dist/materials/enums.d.ts

@@ -0,0 +1,37 @@
+export declare enum PointSizeType {
+    FIXED = 0,
+    ATTENUATED = 1,
+    ADAPTIVE = 2
+}
+export declare enum PointShape {
+    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 PointColorType {
+    RGB = 0,
+    COLOR = 1,
+    DEPTH = 2,
+    HEIGHT = 3,
+    ELEVATION = 3,
+    INTENSITY = 4,
+    INTENSITY_GRADIENT = 5,
+    LOD = 6,
+    LEVEL_OF_DETAIL = 6,
+    POINT_INDEX = 7,
+    CLASSIFICATION = 8,
+    RETURN_NUMBER = 9,
+    SOURCE = 10,
+    NORMAL = 11,
+    PHONG = 12,
+    RGB_HEIGHT = 13,
+    COMPOSITE = 50
+}

package/dist/materials/gradients/grayscale.d.ts

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

package/dist/materials/gradients/index.d.ts

@@ -0,0 +1,7 @@
+export * from './grayscale';
+export * from './inferno';
+export * from './plasma';
+export * from './rainbow';
+export * from './spectral';
+export * from './vidris';
+export * from './yellow-green';

package/dist/materials/gradients/inferno.d.ts

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

package/dist/materials/gradients/plasma.d.ts

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

package/dist/materials/gradients/rainbow.d.ts

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

package/dist/materials/gradients/spectral.d.ts

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

package/dist/materials/gradients/vidris.d.ts

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

package/dist/materials/gradients/yellow-green.d.ts

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

package/dist/materials/index.d.ts

@@ -0,0 +1,7 @@
+export * from './blur-material';
+export * from './clipping';
+export * from './enums';
+export * from './point-cloud-material';
+export * from './texture-generation';
+export * from './types';
+export * from './gradients';

package/dist/materials/point-cloud-material.d.ts

@@ -0,0 +1,180 @@
+import { BufferGeometry, Camera, Color, Material, RawShaderMaterial, Scene, Texture, Vector3, Vector4, WebGLRenderer } from 'three';
+import { PointCloudOctree } from '../point-cloud-octree';
+import { PointCloudOctreeNode } from '../point-cloud-octree-node';
+import { ClipMode, IClipBox } from './clipping';
+import { PointColorType, PointOpacityType, PointShape, PointSizeType, TreeType } from './enums';
+import { IClassification, IGradient, IUniform } from './types';
+import { ColorEncoding } from './color-encoding';
+export interface IPointCloudMaterialParameters {
+    size: number;
+    minSize: number;
+    maxSize: number;
+    treeType: TreeType;
+    newFormat: boolean;
+}
+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]>;
+    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>;
+}
+export declare class PointCloudMaterial extends RawShaderMaterial {
+    private static helperVec3;
+    lights: boolean;
+    fog: boolean;
+    numClipBoxes: number;
+    clipBoxes: IClipBox[];
+    visibleNodesTexture: Texture | undefined;
+    private visibleNodeTextureOffsets;
+    private _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;
+    useClipBox: boolean;
+    weighted: boolean;
+    pointColorType: PointColorType;
+    pointSizeType: PointSizeType;
+    clipMode: ClipMode;
+    useEDL: boolean;
+    shape: PointShape;
+    treeType: TreeType;
+    pointOpacityType: PointOpacityType;
+    useFilterByNormal: boolean;
+    highlightPoint: boolean;
+    inputColorEncoding: ColorEncoding;
+    outputColorEncoding: ColorEncoding;
+    attributes: {
+        position: {
+            type: string;
+            value: any[];
+        };
+        color: {
+            type: string;
+            value: any[];
+        };
+        normal: {
+            type: string;
+            value: any[];
+        };
+        intensity: {
+            type: string;
+            value: any[];
+        };
+        classification: {
+            type: string;
+            value: any[];
+        };
+        returnNumber: {
+            type: string;
+            value: any[];
+        };
+        numberOfReturns: {
+            type: string;
+            value: any[];
+        };
+        pointSourceID: {
+            type: string;
+            value: any[];
+        };
+        indices: {
+            type: string;
+            value: any[];
+        };
+    };
+    newFormat: boolean;
+    constructor(parameters?: Partial<IPointCloudMaterialParameters>);
+    dispose(): void;
+    clearVisibleNodeTextureOffsets(): void;
+    updateShaderSource(): void;
+    applyDefines(shaderSrc: string): string;
+    setClipBoxes(clipBoxes: IClipBox[]): void;
+    get gradient(): IGradient;
+    set gradient(value: IGradient);
+    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: PointCloudOctreeNode[], camera: Camera, renderer: WebGLRenderer): void;
+    private updateVisibilityTextureData;
+    static makeOnBeforeRender(octree: PointCloudOctree, node: PointCloudOctreeNode, pcIndex?: number): (_renderer: WebGLRenderer, _scene: Scene, _camera: Camera, _geometry: BufferGeometry, material: Material) => void;
+}

package/dist/materials/texture-generation.d.ts

@@ -0,0 +1,5 @@
+import { Color, Texture } from 'three';
+import { IClassification, IGradient } from '../materials/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/dist/materials/types.d.ts

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

package/dist/point-attributes.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 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;
+}