potree-core 2.0.10 → 2.0.12

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

@@ -1,14 +1,11 @@
 import { PointCloudOctreeGeometry } from '../point-cloud-octree-geometry';
 import { GetUrlFn, XhrRequest } from './types';
 /**
+ * Loads a Point Cloud Octree (POC) from a given URL.
  *
- * @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.
+ * @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/loading2/OctreeGeometryNode.d.ts

@@ -1,34 +1,60 @@
 import { IPointCloudTreeNode } from './../types';
 import { Box3, Sphere, BufferGeometry } from 'three';
 import { OctreeGeometry } from './OctreeGeometry';
+/**
+ * Represents a node in an octree structure for point cloud geometry.
+ */
 export declare class OctreeGeometryNode implements IPointCloudTreeNode {
     name: string;
     octreeGeometry: OctreeGeometry;
     boundingBox: Box3;
-    constructor(name: string, octreeGeometry: OctreeGeometry, boundingBox: Box3);
+    /** Indicates if the node's geometry has been loaded. */
     loaded: boolean;
+    /** Indicates if the node's geometry is currently loading. */
     loading: boolean;
+    /** Reference to the parent node, or null if this is the root. */
     parent: OctreeGeometryNode | null;
+    /** The geometry data associated with this node, or null if not loaded. */
     geometry: BufferGeometry | null;
+    /** Optional type identifier for the node. */
     nodeType?: number;
+    /** Optional byte offset for the node's data in the source file. */
     byteOffset?: bigint;
+    /** Optional byte size of the node's data in the source file. */
     byteSize?: bigint;
+    /** Optional byte offset for the node's hierarchy data. */
     hierarchyByteOffset?: bigint;
+    /** Optional byte size of the node's hierarchy data. */
     hierarchyByteSize?: bigint;
+    /** Indicates if the node has children. */
     hasChildren: boolean;
+    /** The spacing value for the node's points. */
     spacing: number;
+    /** Optional density value for the node's points. */
     density?: number;
+    /** Indicates if the node is a leaf node (has no children). */
     isLeafNode: boolean;
+    /** Indicates if this node is a tree node (always false for geometry nodes). */
     readonly isTreeNode: boolean;
+    /** Indicates if this node is a geometry node (always true). */
     readonly isGeometryNode: boolean;
+    /** Array of child nodes (up to 8 for an octree), or null if no child at that position. */
     readonly children: ReadonlyArray<OctreeGeometryNode | null>;
+    /** Static counter for generating unique node IDs. */
     static IDCount: number;
+    /** Unique identifier for this node. */
     id: number;
+    /** Index of this node within its parent. */
     index: number;
+    /** Bounding sphere enclosing the node's geometry. */
     boundingSphere: Sphere;
+    /** Number of points contained in this node. */
     numPoints: number;
+    /** Level of the node in the octree hierarchy. */
     level: number;
+    /** Array of handlers to be called once when the node is disposed. */
     oneTimeDisposeHandlers: Function[];
+    constructor(name: string, octreeGeometry: OctreeGeometry, boundingBox: Box3);
     getLevel(): number;
     isLoaded(): boolean;
     getBoundingSphere(): Sphere;

package/dist/loading2/OctreeLoader.d.ts

@@ -1,16 +1,34 @@
-import { XhrRequest } from './../loading/types';
 import { PointAttributes } from './PointAttributes';
 import { WorkerPool } from './WorkerPool';
 import { OctreeGeometryNode } from './OctreeGeometryNode';
 import { OctreeGeometry } from './OctreeGeometry';
+import { RequestManager } from './RequestManager';
+/**
+ * NodeLoader is responsible for loading the geometry of octree nodes.
+ */
 export declare class NodeLoader {
     url: string;
     workerPool: WorkerPool;
     metadata: Metadata;
+    requestManager: RequestManager;
+    /**
+     * Point attributes to be used when loading the geometry.
+     */
     attributes?: PointAttributes;
+    /**
+     * Scale applied to the geometry when loading.
+     */
     scale?: [number, number, number];
+    /**
+     * Offset applied to the geometry when loading.
+     */
     offset?: [number, number, number];
-    constructor(url: string, workerPool: WorkerPool, metadata: Metadata);
+    constructor(url: string, workerPool: WorkerPool, metadata: Metadata, requestManager: RequestManager);
+    /**
+     * Loads the geometry for a given octree node.
+     *
+     * @param node - The octree node to load.
+     */
     load(node: OctreeGeometryNode): Promise<void>;
     parseHierarchy(node: OctreeGeometryNode, buffer: ArrayBuffer): void;
     loadHierarchy(node: OctreeGeometryNode): Promise<void>;
@@ -68,6 +86,9 @@ declare let typenameTypeattributeMap: {
     };
 };
 type AttributeType = keyof typeof typenameTypeattributeMap;
+/**
+ * Attribute interface defines the structure of an attribute in the octree geometry.
+ */
 export interface Attribute {
     name: string;
     description: string;
@@ -77,6 +98,9 @@ export interface Attribute {
     min: number[];
     max: number[];
 }
+/**
+ * Metadata interface defines the structure of the metadata for an octree geometry.
+ */
 export interface Metadata {
     version: string;
     name: string;
@@ -98,11 +122,29 @@ export interface Metadata {
     encoding: string;
     attributes: Attribute[];
 }
+/**
+ * OctreeLoader is responsible for loading octree geometries from a given URL.
+ */
 export declare class OctreeLoader {
+    /**
+     * WorkerPool instance used for managing workers for loading tasks.
+     */
     workerPool: WorkerPool;
-    constructor();
+    /**
+     * Parses the attributes from a JSON array and converts them into PointAttributes.
+     *
+     * @param jsonAttributes Array of attributes in JSON format.
+     * @returns A PointAttributes instance containing the parsed attributes.
+     */
     static parseAttributes(jsonAttributes: Attribute[]): PointAttributes;
-    load(url: string, xhrRequest: XhrRequest): Promise<{
+    /**
+     * Loads an octree geometry from a given URL using the provided RequestManager.
+     *
+     * @param url - The URL from which to load the octree geometry metadata.
+     * @param requestManager - The RequestManager instance used to handle HTTP requests.
+     * @returns Geometry object containing the loaded octree geometry.
+     */
+    load(url: string, requestManager: RequestManager): Promise<{
         geometry: OctreeGeometry;
     }>;
 }

package/dist/loading2/RequestManager.d.ts

@@ -0,0 +1,20 @@
+/**
+ * RequestManager interface for handling HTTP requests.
+ *
+ * This interface defines methods for fetching resources and resolving URLs.
+ */
+export interface RequestManager {
+    /**
+     * Fetches a resource from the network.
+     *
+     * @param input - The resource to fetch, which can be a URL string or a Request object.
+     * @param init - Optional parameters for the request, such as method, headers, body, etc.
+     */
+    fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+    /**
+     * Get the URL for a given resource.
+     *
+     * @param url - The URL of the resource to resolve.
+     */
+    getUrl(url: string): Promise<string>;
+}

package/dist/loading2/WorkerPool.d.ts

@@ -1,9 +1,41 @@
+/**
+ * Enumerates the types of workers available in the worker pool.
+ */
 export declare enum WorkerType {
+    /**
+     * Worker for decoding Brotli-compressed data.
+     */
     DECODER_WORKER_BROTLI = "DECODER_WORKER_BROTLI",
+    /**
+     * Worker for general decoding tasks.
+     */
     DECODER_WORKER = "DECODER_WORKER"
 }
+/**
+ * WorkerPool manages a collection of worker instances, allowing for efficient retrieval and return of workers based on their type.
+ */
 export declare class WorkerPool {
-    private workers;
+    /**
+     * Workers will be an object that has a key for each worker type and the value is an array of Workers that can be empty.
+     */
+    workers: {
+        [key in WorkerType]: Worker[];
+    };
+    /**
+     * Retrieves a Worker instance from the pool associated with the specified worker type.
+     *
+     * If no worker instances are available, a new worker is created and added to the pool before retrieving one.
+     *
+     * @param workerType - The type of the worker to retrieve.
+     * @returns A Worker instance corresponding to the specified worker type.
+     * @throws Error if the worker type is not recognized or if no workers are available in the pool.
+     */
     getWorker(workerType: WorkerType): Worker;
+    /**
+     * Returns a worker instance to the pool for the specified worker type.
+     *
+     * @param workerType - The type of the worker, which determines the corresponding pool.
+     * @param worker - The worker instance to be returned to the pool.
+     */
     returnWorker(workerType: WorkerType, worker: Worker): void;
 }

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

@@ -1,2 +1,9 @@
-import { GetUrlFn, XhrRequest } from '../loading/types';
-export declare function loadOctree(url: string, getUrl: GetUrlFn, xhrRequest: XhrRequest): Promise<import("./OctreeGeometry").OctreeGeometry>;
+import { type RequestManager } from './RequestManager';
+/**
+ * Loads an octree geometry from a specified URL using the provided request manager.
+ *
+ * @param url - The URL of the octree geometry to load.
+ * @param requestManager - The request manager to handle network requests.
+ * @returns A promise that resolves to the loaded octree geometry.
+ */
+export declare function loadOctree(url: string, requestManager: RequestManager): Promise<import("./OctreeGeometry").OctreeGeometry>;

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

@@ -1,11 +1,56 @@
 import { ShaderMaterial, Texture } from 'three';
 import { IUniform } from './types';
+/**
+ * Uniforms interface for blur material shader.
+ *
+ * Defines the uniform variables that control blur rendering parameters.
+ *
+ * Check http://john-chapman-graphics.blogspot.co.at/2013/01/ssao-tutorial.html
+ */
 export interface IBlurMaterialUniforms {
+    /**
+     * Generic uniform property accessor.
+     * @param name - The name of the uniform property
+     */
     [name: string]: IUniform<any>;
+    /**
+     * Screen width in pixels.
+     * Used to calculate blur kernel size and sampling coordinates.
+     */
     screenWidth: IUniform<number>;
+    /**
+     * Screen height in pixels.
+     * Used to calculate blur kernel size and sampling coordinates.
+     */
     screenHeight: IUniform<number>;
+    /**
+     * Input texture to be blurred.
+     * Can be null if no texture is currently bound.
+     */
     map: IUniform<Texture | null>;
 }
+/**
+ * Represents a custom shader material for applying a blur effect.
+ *
+ * Extends the base ShaderMaterial class and sets up the required shaders and uniforms.
+ *
+ * This material uses custom vertex and fragment shaders for blurring.
+ */
 export declare class BlurMaterial extends ShaderMaterial {
+    /**
+     * The GLSL source code for the vertex shader.
+     */
+    vertexShader: any;
+    /**
+     * The GLSL source code for the fragment shader.
+     */
+    fragmentShader: any;
+    /**
+     * The set of uniforms used by the blur shader.
+     *
+     * @property screenWidth - The width of the screen, used for blur calculations.
+     * @property screenHeight - The height of the screen, used for blur calculations.
+     * @property map - The texture to which the blur effect will be applied.
+     */
     uniforms: IBlurMaterialUniforms;
 }

package/dist/materials/eye-dome-lighting-material.d.ts

@@ -0,0 +1,25 @@
+import { Matrix4, RawShaderMaterial, Texture } from 'three';
+import { IUniform } from './types';
+export interface IEyeDomeLightingMaterialUniforms {
+    [name: string]: IUniform<any>;
+    screenWidth: IUniform<number>;
+    screenHeight: IUniform<number>;
+    edlStrength: IUniform<number>;
+    radius: IUniform<number>;
+    opacity: IUniform<number>;
+    neighbours: IUniform<Float32Array>;
+    uProj: IUniform<Float32Array>;
+    colorMap: IUniform<Texture | null>;
+}
+export declare class EyeDomeLightingMaterial extends RawShaderMaterial {
+    uniforms: IEyeDomeLightingMaterialUniforms;
+    private _neighbourCount;
+    private neighboursArray;
+    constructor();
+    get neighbourCount(): number;
+    set neighbourCount(value: number);
+    private initializeNeighboursArray;
+    private getDefines;
+    updateShaderSource(): void;
+    setProjectionMatrix(projectionMatrix: Matrix4): void;
+}

package/dist/materials/index.d.ts

@@ -1,6 +1,7 @@
 export * from './blur-material';
 export * from './clipping';
 export * from './enums';
+export * from './eye-dome-lighting-material';
 export * from './point-cloud-material';
 export * from './texture-generation';
 export * from './types';

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

@@ -5,64 +5,143 @@ import { ClipMode, IClipBox } from './clipping';
 import { PointColorType, PointOpacityType, PointShape, PointSizeType, TreeType } from './enums';
 import { IClassification, IGradient, IUniform } from './types';
 import { ColorEncoding } from './color-encoding';
+/**
+ * Configuration parameters for point cloud material rendering.
+ *
+ * @interface IPointCloudMaterialParameters
+ */
 export interface IPointCloudMaterialParameters {
+    /**
+     * The base size of points in the point cloud.
+     */
     size: number;
+    /**
+     * The minimum allowed size for points when scaling.
+     */
     minSize: number;
+    /**
+     * The maximum allowed size for points when scaling.
+     */
     maxSize: number;
+    /**
+     * The type of tree structure used for organizing the point cloud data.
+     */
     treeType: TreeType;
+    /**
+     * Whether to use the new format for point cloud data processing.
+     */
     newFormat: boolean;
 }
+/**
+ * Interface defining uniforms for point cloud material rendering in WebGL shaders.
+ * These uniforms control various aspects of point cloud visualization including
+ * appearance, filtering, transformations, and rendering parameters.
+ *
+ * @interface IPointCloudMaterialUniforms
+ */
 export interface IPointCloudMaterialUniforms {
+    /** Bounding box size as [width, height, depth] */
     bbSize: IUniform<[number, number, number]>;
+    /** Supplement value for depth blending calculations */
     blendDepthSupplement: IUniform<number>;
+    /** Hardness factor for blending operations */
     blendHardness: IUniform<number>;
+    /** Lookup texture for point classification rendering */
     classificationLUT: IUniform<Texture>;
+    /** Number of active clipping boxes */
     clipBoxCount: IUniform<number>;
+    /** Array containing clipping box parameters */
     clipBoxes: IUniform<Float32Array>;
+    /** Depth map texture for depth-based effects, null if not used */
     depthMap: IUniform<Texture | null>;
+    /** Diffuse color as RGB values [r, g, b] */
     diffuse: IUniform<[number, number, number]>;
+    /** Field of view angle in radians */
     fov: IUniform<number>;
+    /** Gradient texture for color mapping */
     gradient: IUniform<Texture>;
+    /** Maximum height value for elevation-based coloring */
     heightMax: IUniform<number>;
+    /** Minimum height value for elevation-based coloring */
     heightMin: IUniform<number>;
+    /** Brightness adjustment for intensity values */
     intensityBrightness: IUniform<number>;
+    /** Contrast adjustment for intensity values */
     intensityContrast: IUniform<number>;
+    /** Gamma correction for intensity values */
     intensityGamma: IUniform<number>;
+    /** Intensity range as [min, max] values */
     intensityRange: IUniform<[number, number]>;
+    /** Current level of detail */
     level: IUniform<number>;
+    /** Maximum point size in pixels */
     maxSize: IUniform<number>;
+    /** Minimum point size in pixels */
     minSize: IUniform<number>;
+    /** Size of the octree structure */
     octreeSize: IUniform<number>;
+    /** Overall opacity of the point cloud (0.0 to 1.0) */
     opacity: IUniform<number>;
+    /** Point cloud index identifier */
     pcIndex: IUniform<number>;
+    /** Brightness adjustment for RGB color values */
     rgbBrightness: IUniform<number>;
+    /** Contrast adjustment for RGB color values */
     rgbContrast: IUniform<number>;
+    /** Gamma correction for RGB color values */
     rgbGamma: IUniform<number>;
+    /** Screen height in pixels */
     screenHeight: IUniform<number>;
+    /** Screen width in pixels */
     screenWidth: IUniform<number>;
+    /** Orthographic camera height */
     orthoHeight: IUniform<number>;
+    /** Orthographic camera width */
     orthoWidth: IUniform<number>;
+    /** Flag indicating whether orthographic camera is being used */
     useOrthographicCamera: IUniform<boolean>;
+    /** Far clipping plane distance */
     far: IUniform<number>;
+    /** Base point size */
     size: IUniform<number>;
+    /** Spacing between points */
     spacing: IUniform<number>;
+    /** Transformation matrix to model space */
     toModel: IUniform<number[]>;
+    /** Transition factor for animations or interpolations */
     transition: IUniform<number>;
+    /** Color uniform for material */
     uColor: IUniform<Color>;
+    /** Texture containing visible node information */
     visibleNodes: IUniform<Texture>;
+    /** Starting index for visible nodes */
     vnStart: IUniform<number>;
+    /** Weight factor for classification-based coloring */
     wClassification: IUniform<number>;
+    /** Weight factor for elevation-based coloring */
     wElevation: IUniform<number>;
+    /** Weight factor for intensity-based coloring */
     wIntensity: IUniform<number>;
+    /** Weight factor for return number-based coloring */
     wReturnNumber: IUniform<number>;
+    /** Weight factor for RGB color contribution */
     wRGB: IUniform<number>;
+    /** Weight factor for source ID-based coloring */
     wSourceID: IUniform<number>;
+    /** Opacity attenuation factor based on distance or other criteria */
     opacityAttenuation: IUniform<number>;
+    /** Threshold value for normal-based point filtering */
     filterByNormalThreshold: IUniform<number>;
+    /** 3D coordinate of the highlighted point */
     highlightedPointCoordinate: IUniform<Vector3>;
+    /** RGBA color for highlighted point rendering */
     highlightedPointColor: IUniform<Vector4>;
+    /** Flag to enable or disable point highlighting feature */
     enablePointHighlighting: IUniform<boolean>;
+    /** Scale factor for highlighted point size */
     highlightedPointScale: IUniform<number>;
+    /** Scale factor for view-dependent sizing */
+    viewScale: IUniform<number>;
 }
 export declare class PointCloudMaterial extends RawShaderMaterial {
     private static helperVec3;
@@ -115,6 +194,7 @@ export declare class PointCloudMaterial extends RawShaderMaterial {
     highlightedPointColor: Vector4;
     enablePointHighlighting: boolean;
     highlightedPointScale: number;
+    viewScale: number;
     useClipBox: boolean;
     weighted: boolean;
     pointColorType: PointColorType;

package/dist/point-cloud-octree-node.d.ts

@@ -2,17 +2,67 @@ import { Box3, EventDispatcher, Object3D, Points, Sphere } from 'three';
 import { PointCloudOctreeGeometryNode } from './point-cloud-octree-geometry-node';
 import { IPointCloudTreeNode } from './types';
 export declare class PointCloudOctreeNode extends EventDispatcher implements IPointCloudTreeNode {
+    /**
+     * Unique identifier for the node, automatically incremented.
+     */
     geometryNode: PointCloudOctreeGeometryNode;
+    /**
+     * The scene node that represents this octree node in the 3D scene.
+     *
+     * It contains the points of the point cloud.
+     */
     sceneNode: Points;
+    /**
+     * The index of the point cloud in the scene, if applicable.
+     *
+     * This is used to identify which point cloud this node belongs to.
+     */
     pcIndex: number | undefined;
+    /**
+     * The bounding box node for this octree node, if applicable.
+     *
+     * This is used for visualizing the bounding box in the scene.
+     */
     boundingBoxNode: Object3D | null;
+    /**
+     * An array of child nodes, which can be null if there are no children at that position.
+     *
+     * This is used to traverse the octree structure.
+     */
     readonly children: (IPointCloudTreeNode | null)[];
+    /**
+     * Indicates whether the node's geometry has been loaded.
+     */
     readonly loaded = true;
+    /**
+     * Indicates whether the node is currently loading.
+     */
     readonly isTreeNode: boolean;
+    /**
+     * Indicates whether this node is a geometry node.
+     *
+     * This is always false for PointCloudOctreeNode, as it represents a tree node.
+     */
     readonly isGeometryNode: boolean;
     constructor(geometryNode: PointCloudOctreeGeometryNode, sceneNode: Points);
+    /**
+     * Disposes of the resources used by this node.
+     *
+     * This method should be called when the node is no longer needed to free up memory.
+     */
     dispose(): void;
+    /**
+     * Disposes of the scene node associated with this octree node.
+     *
+     * This method removes the geometry and its attributes from the scene node to free up resources.
+     */
     disposeSceneNode(): void;
+    /**
+     * Traverses the octree node and executes a callback function for each node.
+     *
+     * @param cb - The callback function to execute for each node.
+     * @param includeSelf - If true, the callback will also be executed for this node.
+     */
     traverse(cb: (node: IPointCloudTreeNode) => void, includeSelf?: boolean): void;
     get id(): number;
     get name(): string;

package/dist/point-cloud-octree-picker.d.ts

@@ -6,19 +6,16 @@ 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.
+     * 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.
+     * 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.
      *
-     * @param material
-     *    The pick material.
-     * @param renterTarget
-     *    The render target used for picking.
+     * 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;
 }