@loaders.gl/tiles 5.0.0-alpha.12 → 5.0.0-alpha.13

package/src/point-cloud/types.ts

@@ -1,99 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import type {DataSource, DataSourceOptions} from '@loaders.gl/loader-utils';
-import type {MeshArrowTable} from '@loaders.gl/schema';
-import type {TilesetSpatialReference} from '../spatial/spatial-types';
-
-/**
- * An accessor-like description for point cloud attributes.
- */
-export type PointCloudAttribute = {
-  value: ArrayBufferView;
-  size: number;
-  normalized?: boolean;
-};
-
-/**
- * deck.gl coordinate system string values accepted by point cloud tile content.
- */
-export type PointCloudCoordinateSystem =
-  | 'default'
-  | 'lnglat'
-  | 'meter-offsets'
-  | 'lnglat-offsets'
-  | 'cartesian';
-
-/**
- * A normalized point cloud tile content payload.
- */
-export type PointCloudTileContent = {
-  data: MeshArrowTable;
-  pointCount: number;
-  cartographicOrigin: number[];
-  coordinateSystem: PointCloudCoordinateSystem;
-  constantRGBA?: number[];
-  modelMatrix?: number[] | Float32Array;
-  /** Spatial descriptor for returned points, origins, and bounds. */
-  spatialReference?: TilesetSpatialReference;
-  /** Content bound expressed in the selected spatial output frame. */
-  spatialBoundingVolume?: PointCloudBoundingVolume;
-};
-
-/**
- * A cartographic bounding volume for a point cloud tile.
- */
-export type PointCloudBoundingVolume = {
-  cartographicBounds: [min: number[], max: number[]];
-  /** True when the longitude interval crosses the antimeridian. */
-  wrapsDateline?: boolean;
-  /** True when the longitude interval covers the full globe. */
-  coversFullLongitude?: boolean;
-  center: number[];
-  radius: number;
-  /** Broad coordinate frame of `center` and `cartographicBounds`. */
-  coordinateFrame?: 'geographic' | 'cartesian';
-};
-
-/**
- * A source-owned tile header used by the point cloud tileset.
- */
-export type PointCloudTileHeader = {
-  id: string;
-  level: number;
-  pointCount: number;
-  geometricError: number;
-  boundingVolume: PointCloudBoundingVolume;
-  /** Bound expressed in the selected content/output frame; traversal retains geographic bounds. */
-  spatialBoundingVolume?: PointCloudBoundingVolume;
-  /** I3S LOD metric used to decide whether this node refines. */
-  lodSelectionMetricType?: 'maxScreenThresholdSQ' | 'density-threshold';
-  /** Source-provided LOD threshold for density or screen metrics. */
-  lodThreshold?: number;
-};
-
-/**
- * Optional tileset view metadata.
- */
-export type PointCloudTilesetViewState = {
-  cartographicCenter?: number[];
-  zoom?: number;
-  boundingVolume?: PointCloudBoundingVolume;
-};
-
-/**
- * Structural contract for point cloud sources that can back a PointCloudTileset.
- */
-export type PointCloudTilesetSource<
-  DataT = unknown,
-  OptionsT extends DataSourceOptions = DataSourceOptions
-> = DataSource<DataT, OptionsT> & {
-  isReady: boolean;
-  initialize(): Promise<void>;
-  getMetadata?(): Promise<unknown>;
-  getRootTile(): Promise<PointCloudTileHeader>;
-  getChildren(tile: PointCloudTileHeader): Promise<PointCloudTileHeader[]>;
-  loadTileContent(tile: PointCloudTileHeader): Promise<PointCloudTileContent | null>;
-  getViewState?(): Promise<PointCloudTilesetViewState> | PointCloudTilesetViewState;
-};

package/src/point-cloud-tile-source-loader-types.ts

@@ -1,53 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import type {CoreAPI, SourceLoader} from '@loaders.gl/loader-utils';
-import type {PointCloudTileSource} from './point-cloud-tile-source';
-import type {
-  PointCloudTileSourceInput,
-  PointCloudTileSourceOptions
-} from './point-cloud-tile-source-types';
-
-// __VERSION__ is injected by babel-plugin-version-inline
-// @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
-
-/** Loads the optional authoring runtime through an explicit package subpath. */
-async function preloadPointCloudTileSource(): Promise<
-  typeof import('./point-cloud-tile-source-loader').PointCloudTileSourceLoaderWithParser
-> {
-  const {PointCloudTileSourceLoaderWithParser} = await import(
-    '@loaders.gl/tiles/point-cloud-tile-source-loader'
-  );
-  return PointCloudTileSourceLoaderWithParser;
-}
-
-/** Metadata-only loader for creating an additive point source from decoded Mesh/Arrow input. */
-export const PointCloudTileSourceLoader = {
-  dataType: null as unknown as PointCloudTileSource,
-  batchType: null as never,
-  name: 'PointCloudTiler',
-  id: 'point-cloud-tiler',
-  module: 'tiles',
-  version: VERSION,
-  extensions: [],
-  mimeTypes: [],
-  type: 'point-cloud',
-  fromUrl: false,
-  fromBlob: false,
-  testURL: () => false,
-  options: {pointCloudTiler: {}},
-  defaultOptions: {pointCloudTiler: {}},
-  preload: preloadPointCloudTileSource,
-  /** Direct construction requires the runtime rather than this metadata export. */
-  createDataSource(
-    _input: PointCloudTileSourceInput | string | Blob,
-    _options: PointCloudTileSourceOptions = {},
-    _coreApi?: CoreAPI
-  ): PointCloudTileSource {
-    throw new Error(
-      'PointCloudTileSourceLoader requires preload() or @loaders.gl/tiles/point-cloud-tile-source-loader'
-    );
-  }
-} as const satisfies SourceLoader<PointCloudTileSource>;

package/src/point-cloud-tile-source-loader.ts

@@ -1,32 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import type {CoreAPI, SourceLoader} from '@loaders.gl/loader-utils';
-import {PointCloudTileSource} from '@loaders.gl/tiles/point-cloud-tile-source';
-import {PointCloudTileSourceLoader} from './point-cloud-tile-source-loader-types';
-import type {
-  PointCloudTileSourceInput,
-  PointCloudTileSourceOptions
-} from './point-cloud-tile-source-types';
-
-const {
-  preload: _preload,
-  createDataSource: _createDataSource,
-  ...metadata
-} = PointCloudTileSourceLoader;
-
-/** Parser-bearing source factory for decoded point Mesh/Arrow data. */
-export const PointCloudTileSourceLoaderWithParser = {
-  ...metadata,
-  /** Creates a native-coordinate source with deferred child indexing. */
-  createDataSource(
-    input: PointCloudTileSourceInput | string | Blob,
-    options: PointCloudTileSourceOptions = {},
-    coreApi?: CoreAPI
-  ): PointCloudTileSource {
-    if (typeof input === 'string' || input instanceof Blob)
-      throw new Error('PointCloudTileSourceLoader requires decoded Mesh/Arrow input');
-    return new PointCloudTileSource(input, options, coreApi);
-  }
-} as const satisfies SourceLoader<PointCloudTileSource>;

package/src/point-cloud-tile-source-types.ts

@@ -1,20 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import type {DataSourceOptions} from '@loaders.gl/loader-utils';
-import type {Mesh, MeshArrowTable} from '@loaders.gl/schema';
-import type {PointCloudTilerOptions} from '@loaders.gl/schema-utils';
-import type {TilesetSpatialReference} from './spatial/spatial-types';
-
-/** Decoded points supplied to the dynamic point-cloud source. */
-export type PointCloudTileSourceInput = Mesh | MeshArrowTable;
-
-/** Options for native-coordinate, additive dynamic point tiling. */
-export type PointCloudTileSourceOptions = DataSourceOptions & {
-  /** Point indexing, output and lifetime controls. No CRS is inferred. */
-  pointCloudTiler?: PointCloudTilerOptions & {
-    /** Spatial metadata for the input coordinates; retained without reprojection. */
-    readonly spatialReference?: TilesetSpatialReference;
-  };
-};

package/src/point-cloud-tile-source.ts

@@ -1,112 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import {DataSource, type CoreAPI} from '@loaders.gl/loader-utils';
-import {
-  PointCloudTiler,
-  convertMeshToTable,
-  type PointCloudTilerNode
-} from '@loaders.gl/schema-utils';
-import type {
-  PointCloudTileContent,
-  PointCloudTileHeader,
-  PointCloudTilesetSource
-} from './point-cloud/types';
-import type {
-  PointCloudTileSourceInput,
-  PointCloudTileSourceOptions
-} from './point-cloud-tile-source-types';
-
-/**
- * Dynamic counterpart to vector table tiling, usable by PointCloudTileset and converter traversal.
- * Each point belongs to one additive node. It retains native coordinates and explicit CRS metadata.
- * Geometry stays in memory; output tiles are gathered on request and are not cached by this source.
- */
-export class PointCloudTileSource
-  extends DataSource<null, PointCloudTileSourceOptions>
-  implements PointCloudTilesetSource<null, PointCloudTileSourceOptions>
-{
-  /** Resolves after the root is indexed. */
-  readonly ready: Promise<void>;
-  /** Whether root indexing has completed successfully. */
-  isReady = false;
-  /** Shared portable index and ownership implementation. */
-  private readonly tiler: PointCloudTiler;
-
-  /** Creates a source from decoded points, without fetching or reprojecting input. */
-  constructor(
-    input: PointCloudTileSourceInput,
-    options: PointCloudTileSourceOptions = {},
-    coreApi?: CoreAPI
-  ) {
-    super(null, options, {pointCloudTiler: {}}, coreApi);
-    this.tiler = new PointCloudTiler(input, options.pointCloudTiler);
-    this.ready = this.tiler.getRootNode().then(() => {
-      this.isReady = true;
-    });
-    this.ready.catch(() => {});
-  }
-
-  /** Waits for one shared indexing operation. */
-  async initialize(): Promise<void> {
-    await this.ready;
-    await this.tiler.getRootNode();
-  }
-
-  /** Reports exact source count and the additive ownership contract. */
-  async getMetadata(): Promise<{pointCount: number; refinement: 'ADD'}> {
-    await this.initialize();
-    return {pointCount: this.tiler.pointCount, refinement: 'ADD'};
-  }
-
-  /** Returns the sampled root and its native bounds. */
-  async getRootTile(): Promise<PointCloudTileHeader> {
-    return this.createHeader(await this.tiler.getRootNode());
-  }
-
-  /** Discovers only the requested node's immediate children. */
-  async getChildren(tile: PointCloudTileHeader): Promise<PointCloudTileHeader[]> {
-    return (await this.tiler.getChildNodes(tile.id)).map(node => this.createHeader(node));
-  }
-
-  /** Gathers the requested point rows into a fresh Arrow tile, preserving attribute types. */
-  async loadTileContent(tile: PointCloudTileHeader): Promise<PointCloudTileContent | null> {
-    const mesh = await this.tiler.getTileMesh(tile.id);
-    if (!mesh.header!.vertexCount) return null;
-    return {
-      data: convertMeshToTable(mesh, 'arrow-table'),
-      pointCount: mesh.header!.vertexCount,
-      cartographicOrigin: [0, 0, 0],
-      coordinateSystem: 'cartesian',
-      spatialReference: this.options.pointCloudTiler.spatialReference,
-      spatialBoundingVolume: this.createHeader(await this.tiler.getNodeMetadata(tile.id))
-        .boundingVolume
-    };
-  }
-
-  /** Releases the input table, attributes and index; safe to repeat. */
-  close(): void {
-    this.tiler.close();
-    this.isReady = false;
-  }
-
-  /** Creates a conservative native-coordinate header without renderer projection math. */
-  private createHeader(node: PointCloudTilerNode): PointCloudTileHeader {
-    const center = node.bounds[0].map((value, axis) => value + (node.bounds[1][axis] - value) / 2);
-    const boundingVolume = {
-      cartographicBounds: node.bounds.map(corner => [...corner]) as [number[], number[]],
-      center,
-      radius: Math.hypot(...center.map((value, axis) => node.bounds[1][axis] - value)),
-      coordinateFrame: 'cartesian' as const
-    };
-    return {
-      id: node.id,
-      level: node.level,
-      pointCount: node.pointCount,
-      geometricError: node.geometricError,
-      boundingVolume,
-      spatialBoundingVolume: boundingVolume
-    };
-  }
-}