@gisatcz/deckgl-geolib 1.10.1-dev.0 → 1.10.1-dev.1

package/dist/cjs/types/cogtiles/cogtiles.d.ts

@@ -1,6 +1,7 @@
 import { Tiff, TiffImage } from '@cogeotiff/core';
 import LZWDecoder from './lzw';
 import GeoImage, { GeoImageOptions } from '../geoimage/geoimage.ts';
+export type Bounds = [minX: number, minY: number, maxX: number, maxY: number];
 declare class CogTiles {
     cog: Tiff;
     zoomRange: number[];
@@ -21,7 +22,7 @@ declare class CogTiles {
     getResolutionFromZoomLevel(tileSize: number, z: number): number;
     getZoomLevelFromResolution(tileSize: number, resolution: number): number;
     getLatLon(input: number[]): number[];
-    getTile(x: number, y: number, z: number): Promise<string>;
+    getTile(x: number, y: number, z: number, bounds: Bounds): Promise<string>;
     getFormat(sampleFormat: number[] | number, bitsPerSample: number[] | number): any;
     getNoDataValue(tags: any): number;
     testCog(): Promise<void>;

package/dist/cjs/types/geoimage/delatin/index.d.ts

@@ -0,0 +1,23 @@
+export default class Delatin {
+    constructor(data: any, width: any, height?: any);
+    run(maxError?: number): void;
+    refine(): void;
+    getMaxError(): any;
+    getRMSD(): number;
+    heightAt(x: any, y: any): any;
+    _flush(): void;
+    _findCandidate(p0x: any, p0y: any, p1x: any, p1y: any, p2x: any, p2y: any, t: any): void;
+    _step(): void;
+    _addPoint(x: any, y: any): number;
+    _addTriangle(a: any, b: any, c: any, ab: any, bc: any, ca: any, e?: any): any;
+    _legalize(a: any): void;
+    _handleCollinear(pn: any, a: any): void;
+    _queuePush(t: any, error: any, rms: any): void;
+    _queuePop(): any;
+    _queuePopBack(): any;
+    _queueRemove(t: any): void;
+    _queueLess(i: any, j: any): boolean;
+    _queueSwap(i: any, j: any): void;
+    _queueUp(j0: any): void;
+    _queueDown(i0: any, n: any): boolean;
+}

package/dist/cjs/types/geoimage/geoimage.d.ts

@@ -1,5 +1,6 @@
 import { GeoTIFFImage } from 'geotiff';
 import chroma from 'chroma-js';
+export type Bounds = [minX: number, minY: number, maxX: number, maxY: number];
 export type ClampToTerrainOptions = {
     terrainDrawMode?: string;
 };
@@ -42,12 +43,60 @@ export default class GeoImage {
         width: number;
         height: number;
         rasters: any[];
-    }, options: GeoImageOptions): Promise<string>;
+        bounds: Bounds;
+    }, options: GeoImageOptions): Promise<string | {
+        loaderData: {
+            header: {};
+        };
+        header: {
+            vertexCount: any;
+            boundingBox: any;
+        };
+        mode: number;
+        indices: {
+            value: Uint32Array;
+            size: number;
+        };
+        attributes: {
+            POSITION: {
+                value: Float32Array;
+                size: number;
+            };
+            TEXCOORD_0: {
+                value: Float32Array;
+                size: number;
+            };
+        };
+    }>;
     getHeightmap(input: string | {
+        bounds: Bounds;
         width: number;
         height: number;
         rasters: any[];
-    }, options: GeoImageOptions): Promise<string>;
+    }, options: GeoImageOptions): Promise<{
+        loaderData: {
+            header: {};
+        };
+        header: {
+            vertexCount: any;
+            boundingBox: any;
+        };
+        mode: number;
+        indices: {
+            value: Uint32Array;
+            size: number;
+        };
+        attributes: {
+            POSITION: {
+                value: Float32Array;
+                size: number;
+            };
+            TEXCOORD_0: {
+                value: Float32Array;
+                size: number;
+            };
+        };
+    }>;
     getBitmap(input: string | {
         width: number;
         height: number;

package/dist/cjs/types/geoimage/helpers/skirt.d.ts

@@ -0,0 +1,18 @@
+export type EdgeIndices = {
+    westIndices: number[];
+    northIndices: number[];
+    eastIndices: number[];
+    southIndices: number[];
+};
+/**
+ * Add skirt to existing mesh
+ * @param {object} attributes - POSITION and TEXCOOD_0 attributes data
+ * @param {any} triangles - indices array of the mesh geometry
+ * @param skirtHeight - height of the skirt geometry
+ * @param outsideIndices - edge indices from quantized mesh data
+ * @returns - geometry data with added skirt
+ */
+export declare function addSkirt(attributes: any, triangles: any, skirtHeight: number, outsideIndices?: EdgeIndices): {
+    attributes: any;
+    triangles: any;
+};

package/dist/cjs/types/loaders/CogTerrainLoader.d.ts

@@ -0,0 +1,3 @@
+import type { LoaderContext } from '@loaders.gl/loader-utils';
+export declare const CogTerrainLoader: LoaderWithParser<any, never, any>;
+export declare function parseTerrain(arrayBuffer: ArrayBuffer, options?: {}, context?: LoaderContext): Promise<void>;

package/dist/cjs/types/terrain-layer.d.ts

@@ -0,0 +1,83 @@
+import { Color, CompositeLayer, CompositeLayerProps, DefaultProps, Layer, LayersList, Material, TextureSource, UpdateParameters } from '@deck.gl/core';
+import { SimpleMeshLayer } from '@deck.gl/mesh-layers';
+import type { MeshAttributes } from '@loaders.gl/schema';
+import { TileLayerProps, GeoBoundingBox, _TileLoadProps as TileLoadProps, _Tile2DHeader as Tile2DHeader, NonGeoBoundingBox } from '@deck.gl/geo-layers';
+import { GeoImageOptions } from './geoimage/geoimage.ts';
+import CogTiles from './cogtiles/cogtiles.ts';
+export type Bounds = [minX: number, minY: number, maxX: number, maxY: number];
+export type TileBoundingBox = NonGeoBoundingBox | GeoBoundingBox;
+export type ZRange = [minZ: number, maxZ: number];
+export type URLTemplate = string | string[] | null;
+export declare const urlType: {
+    type: "object";
+    value: URLTemplate;
+    validate: (value: any, propType: any) => boolean;
+    equal: (value1: any, value2: any) => boolean;
+};
+type ElevationDecoder = {
+    rScaler: number;
+    gScaler: number;
+    bScaler: number;
+    offset: number;
+};
+type TerrainLoadProps = {
+    bounds: Bounds;
+    elevationData: string | null;
+    elevationDecoder: ElevationDecoder;
+    meshMaxError: number;
+    signal?: AbortSignal;
+};
+type MeshAndTexture = [MeshAttributes | null, TextureSource | null];
+/** All properties supported by TerrainLayer */
+export type TerrainLayerProps = _TerrainLayerProps & TileLayerProps<MeshAndTexture> & CompositeLayerProps;
+/** Props added by the TerrainLayer */
+type _TerrainLayerProps = {
+    /** Image url that encodes height data. * */
+    elevationData: URLTemplate;
+    /** Image url to use as texture. * */
+    texture?: URLTemplate;
+    /** Martini error tolerance in meters, smaller number -> more detailed mesh. * */
+    meshMaxError?: number;
+    /** Bounding box of the terrain image, [minX, minY, maxX, maxY] in world coordinates. * */
+    bounds?: Bounds | null;
+    /** Color to use if texture is unavailable. * */
+    color?: Color;
+    /** Object to decode height data, from (r, g, b) to height in meters. * */
+    elevationDecoder?: ElevationDecoder;
+    /** Whether to render the mesh in wireframe mode. * */
+    wireframe?: boolean;
+    /** Material props for lighting effect. * */
+    material?: Material;
+    /**
+     * @deprecated Use `loadOptions.terrain.workerUrl` instead
+     */
+    workerUrl?: string;
+};
+/** Render mesh surfaces from height map images. */
+export default class TerrainLayer<ExtraPropsT extends {} = {}> extends CompositeLayer<ExtraPropsT & Required<_TerrainLayerProps & Required<TileLayerProps<MeshAndTexture>>>> {
+    static defaultProps: DefaultProps<TerrainLayerProps>;
+    static layerName: string;
+    terrainCogTiles: CogTiles;
+    terrainUrl: string;
+    minZoom: number;
+    maxZoom: number;
+    state: {
+        isTiled?: boolean;
+        terrain?: MeshAttributes;
+        zRange?: ZRange | null;
+    };
+    constructor(props: TerrainLayerProps & ExtraPropsT, terrainOptions: GeoImageOptions);
+    initializeState(context: any): Promise<void>;
+    init(terrainUrl: string): Promise<void>;
+    updateState({ props, oldProps }: UpdateParameters<this>): void;
+    loadTerrain({ elevationData, bounds, elevationDecoder, meshMaxError, signal, }: TerrainLoadProps): Promise<MeshAttributes> | null;
+    getTiledTerrainData(tile: TileLoadProps): Promise<MeshAndTexture>;
+    renderSubLayers(props: TileLayerProps<MeshAndTexture> & {
+        id: string;
+        data: MeshAndTexture;
+        tile: Tile2DHeader<MeshAndTexture>;
+    }): SimpleMeshLayer<any, {}>;
+    onViewportLoad(tiles?: Tile2DHeader<MeshAndTexture>[]): void;
+    renderLayers(): Layer | null | LayersList;
+}
+export {};