@equinor/videx-3d 5.1.0-beta

package/dist/types/layers/layers.d.ts

@@ -0,0 +1,6 @@
+import { Layers } from 'three';
+export declare const LAYERS: {
+    NOT_EMITTER: number;
+    EMITTER: number;
+};
+export declare function createLayers(...values: number[]): Layers;

package/dist/types/main.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @module main
+ */
+export * from './components/Annotations';
+export * from './components/CameraTargetMarker/CameraTargetMarker';
+export * from './components/Distance';
+export * from './components/EventEmitter';
+export * from './components/Grids';
+export * from './components/Highlighter';
+export * from './components/Html';
+export * from './components/ObservableGroup/ObservableGroup';
+export * from './components/SDFTest/SDFTest';
+export * from './components/Surfaces';
+export * from './components/Symbol';
+export * from './components/UtmArea';
+export * from './components/Wellbores/BasicTrajectory';
+export * from './components/Wellbores/Casings';
+export * from './components/Wellbores/CompletionTools';
+export * from './components/Wellbores/DepthMarkers';
+export * from './components/Wellbores/FormationMarkers';
+export * from './components/Wellbores/Perforations';
+export * from './components/Wellbores/Perimeter';
+export * from './components/Wellbores/Shoes';
+export * from './components/Wellbores/TubeTrajectory';
+export * from './components/Wellbores/Wellbore';
+export * from './components/Wellbores/WellboreBounds';
+export * from './components/Wellbores/WellboreFormationColumn';
+export * from './components/Wellbores/WellboreLabel';
+export * from './components/Wellbores/WellboreRibbon';
+export * from './components/Wellbores/WellboreSeismicSection';
+export * from './components/Wellbores/Wells';
+export * from './contexts/DataContext';
+export * from './contexts/DataContextProvider';
+export * from './contexts/GeneratorsContext';
+export * from './contexts/GeneratorsContextProvider';
+export * from './contexts/GlyphsContext';
+export * from './contexts/GlyphsContextProvider';
+export * from './events/camera-events';
+export * from './events/depth-events';
+export * from './events/interaction-events';
+export * from './events/wellbore-events';
+export * from './hooks/useData';
+export * from './hooks/useGenerator';
+export * from './hooks/useWellboreContext';
+export * from './layers/layers';
+export * from './rendering';
+export * from './common/color-ramps';
+export * from './common/types';

package/dist/types/rendering/fullscreen-renderer.d.ts

@@ -0,0 +1,9 @@
+import { Camera, Material, Mesh, RawShaderMaterial, Texture, WebGLRenderer, WebGLRenderTarget } from 'three';
+export declare class FullscreenRenderer {
+    camera: Camera;
+    mesh: Mesh;
+    copyMaterial: RawShaderMaterial;
+    constructor();
+    renderMaterial(renderer: WebGLRenderer, buffer: WebGLRenderTarget | null, material: Material): void;
+    renderTexture(renderer: WebGLRenderer, buffer: WebGLRenderTarget | null, texture: Texture, opacity?: number): void;
+}

package/dist/types/rendering/index.d.ts

@@ -0,0 +1,2 @@
+export * from './fullscreen-renderer';
+export * from './render-passes';

package/dist/types/rendering/render-passes.d.ts

@@ -0,0 +1,16 @@
+import { Camera, MeshBasicMaterial, Scene, WebGLRenderer, WebGLRenderTarget } from 'three';
+export declare abstract class Pass {
+    writeToScreen: boolean;
+    abstract render(renderer: WebGLRenderer, buffer: WebGLRenderbuffer): void;
+}
+export declare class RenderPass extends Pass {
+    private scene;
+    private camera;
+    constructor(scene: Scene, camera: Camera);
+    render(renderer: WebGLRenderer, buffer: WebGLRenderTarget): void;
+}
+export declare class OutputPass extends Pass {
+    material: MeshBasicMaterial;
+    constructor();
+    render(renderer: WebGLRenderer, buffer: WebGLRenderTarget): void;
+}

package/dist/types/sdk/data/DataLoader.d.ts

@@ -0,0 +1,54 @@
+import { KeyType, Store } from './Store';
+/**
+ * Used internally by DataLoader class
+ */
+export type BatchQueueEntry = {
+    key: KeyType;
+    promise: Promise<any>;
+    _resolve: ((value?: any) => void) | null;
+};
+/**
+ * Loader Config
+ */
+export type LoaderConfig = {
+    preloaded?: boolean;
+    batched?: boolean;
+    batchSize?: number;
+    batchMaxDelay?: number;
+    noCache?: boolean;
+    transform?: (record: any) => any;
+    init?: <T>(...args: any[]) => Promise<[KeyType, T][]>;
+    load?: <T>(id: KeyType, args?: any) => Promise<T | null>;
+    batchLoad?: <T>(...args: any[]) => Promise<[KeyType, T][]>;
+};
+/**
+ * This is a helper class that may be used to simplify implementation
+ * of the Store interface. The Store may be implemented as you wish, as
+ * long as it adapts to the interface, but this class can be useful for
+ * managing loading on demand, caching, preloading and more.
+ *
+ * You would typically build your store to hold a loader instance per
+ * data type. See the implementation of the MockStore for example usage.
+ *
+ * The DataLoader has the following features:
+ * - optional caching of data
+ * - preload complete data set or on-demand loading of data (single record or batched)
+ * - promise sharing of multiple requests for the same data record
+ */
+export declare class DataLoader {
+    store: Store;
+    config: LoaderConfig;
+    cached: Map<KeyType, unknown>;
+    private _activeLoaders;
+    private _batchqueue;
+    private _flushScheduled;
+    constructor(store: Store, config?: LoaderConfig);
+    init(...args: any[]): Promise<boolean>;
+    all<T>(): Promise<T[] | null>;
+    _enqueueRequest(key: KeyType): Promise<any>;
+    _processBatch(batch: BatchQueueEntry[]): Promise<null | undefined>;
+    _processBatchQueue(): Promise<void>;
+    get<T>(key: KeyType, args?: any): Promise<T | null>;
+    set<T>(key: KeyType, value: T): void;
+    clear(): void;
+}

package/dist/types/sdk/data/GeneratorRegistry.d.ts

@@ -0,0 +1,15 @@
+import { ReadonlyStore } from '../data/Store';
+export type RegistryConfig = {
+    concurrentStoreCalls?: number;
+};
+export type GeneratorFunction = (this: ReadonlyStore, ...args: any[]) => Promise<any>;
+export declare class GeneratorRegistry {
+    protected store: ReadonlyStore | null;
+    protected config: RegistryConfig;
+    protected generators: Map<string, GeneratorFunction>;
+    constructor(config?: RegistryConfig, store?: ReadonlyStore);
+    add(key: string, generator: GeneratorFunction): void;
+    setStore(store: ReadonlyStore): void;
+    connectRemoteStore(port: MessagePort): Promise<void>;
+    invoke<T>(key: string, ...args: any[]): Promise<T>;
+}

package/dist/types/sdk/data/Store.d.ts

@@ -0,0 +1,29 @@
+export type KeyType = string | number;
+/**
+ * This interface includes the methods which are required in a data store
+ * implementation.
+ *
+ * It expects data to be organized as dictionaries of
+ * data sets and data records, where data set refers to a specific data type
+ * (i.e. 'wellbore-headers') and records to a specific item in the set
+ * indexed by a key (i.e. wellbore id)
+ *
+ * get: retrieve a single record from the specified data set with the specified key
+ * all: retrieve all records from the specified data set
+ * query: retrieve all records from the specified data set matching the query partial values
+ * set: set a single record into the specified data set with the specified key
+ *
+ * Example of using query to retrieve all wellbore headers for a specific well:
+ * @example
+ * const wellbores = await mystore.query<WellboreHeader>('wellbore-headers', { well: 'NO 16/2' })
+ */
+export interface Store {
+    get: <T>(dataType: string, key: KeyType, args?: any) => Promise<T | null>;
+    set: <T>(dataType: string, key: KeyType, value: T) => Promise<boolean>;
+    all: <T>(dataType: string) => Promise<T[] | null>;
+    query: <T>(dataType: string, query: Partial<T>) => Promise<T[]>;
+}
+/**
+ * Read-only version of the Store interface. Omitting the set method.
+ */
+export type ReadonlyStore = Pick<Store, 'get' | 'all' | 'query'>;

package/dist/types/sdk/data/helpers/formations-helpers.d.ts

@@ -0,0 +1,24 @@
+import { ReadonlyStore } from '../Store';
+import { Formation, FormationMarker, MergedFormationInterval } from '../types';
+/**
+ * Get the formations for a wellbore filtered by strat column and optionally truncated by fromMsl
+ */
+export declare function getWellboreFormations(wellboreId: string, stratColumnId: string, store: ReadonlyStore, fromMsl?: number): Promise<Formation[]>;
+/**
+ * Merges stratigraphy formations from multiple stratigraphy unit levels into a single column,
+ * where the highest level takes presidence over lower levels.
+ *
+ * The intervals will be processed in-order; in other words, how the intervals are sorted.
+ * We sort first by descending level (higher levels take presidence over lower levels), then by
+ * entry depth (processing top-down) and finally by descending update date.
+ *
+ * The last sorting criteria is used to ensure consistant behaviour for the edge-cases where formation intervals
+ * overlaps within the same strat unit level.
+ */
+export declare function mergeFormationIntervals(formationIntervals: Formation[]): MergedFormationInterval[];
+/**
+ * Identify surface entry points, where the highest level strat unit has precedence:
+ * - Sort intervals by ascending entry depth and descending stratigraphy unit level
+ * - Pick only the first formation of a depth, ignoring any following formations with the same depth as the previous formation
+ */
+export declare function getFormationMarkers(intervals: Formation[]): FormationMarker[];

package/dist/types/sdk/data/helpers/well-helpers.d.ts

@@ -0,0 +1,9 @@
+import { WellboreHeader } from '../types/WellboreHeader';
+/**
+ * Caluclate the segments top for a single well
+ * @param dictionary dictionary of wellbore headers indexed by wellbore name
+ * @param included array of wellbore headers that should be included
+ * @param selected id of selected wellbore if applicable (will be processed first => sequence = 0)
+ * @returns dictionary of segment tops in MD Msl indexed by wellbore id
+ */
+export declare function calculateWellSegments(dictionary: Record<string, WellboreHeader>, included: WellboreHeader[], selected?: string): Record<string, [number, number]>;

package/dist/types/sdk/data/types/Casing.d.ts

@@ -0,0 +1,8 @@
+export type CasingItem = {
+    mdTopMsl: number;
+    mdBottomMsl: number;
+    outerDiameter: number;
+    innerDiameter: number;
+    type: string;
+    properties: Record<string, string>;
+};

package/dist/types/sdk/data/types/CompletionTool.d.ts

@@ -0,0 +1,11 @@
+export type CompletionTool = {
+    name: string;
+    mdTopMsl: number;
+    mdBottomMsl: number;
+    length: number;
+    diameterTop: number;
+    diameterBottom: number;
+    diameterMax: number;
+    diameterDrift: number;
+    category: string;
+};

package/dist/types/sdk/data/types/DepthReferencePoint.d.ts

@@ -0,0 +1 @@
+export type DepthReferencePoint = 'RT' | 'MSL';

package/dist/types/sdk/data/types/Formation.d.ts

@@ -0,0 +1,32 @@
+export type FormationBoundary = {
+    mdMsl: number;
+    tvdMsl?: number;
+    properties?: Record<string, any>;
+};
+export type Formation = {
+    wellboreId: string;
+    stratColumnId: string;
+    entry: FormationBoundary;
+    exit: FormationBoundary;
+    name: string;
+    type?: string;
+    level: number;
+    color: string;
+    properties?: Record<string, any>;
+};
+export type MergedFormationInterval = {
+    mdMslFrom: number;
+    mdMslTo: number;
+    name: string;
+    level: number;
+    color: string;
+    properties?: Record<string, any>;
+};
+export type FormationMarker = {
+    name: string;
+    color: string;
+    mdMsl: number;
+    tvdMsl?: number;
+    type: 'top' | 'base';
+    level: number;
+};

package/dist/types/sdk/data/types/PerforationInterval.d.ts

@@ -0,0 +1,9 @@
+export type PerforationInterval = {
+    type: string;
+    status: 'Open' | 'Closed';
+    density?: number;
+    phase?: number;
+    comment: string;
+    mdTopMsl: number;
+    mdBottomMsl: number;
+};

package/dist/types/sdk/data/types/Pick.d.ts

@@ -0,0 +1,8 @@
+export type Pick = {
+    id: string;
+    wellboreId: string;
+    pickIdentifier: string;
+    mdMsl: number;
+    tvdMsl?: number;
+    properties?: Record<string, any>;
+};

package/dist/types/sdk/data/types/PositionLog.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Position log are expected to be a strided array of values including:
+ * - dx: UTM easting offset relative to the head position
+ * - dy: The TVD depth relative to mean sea level (Msl)
+ * - dz: UTM northing offset relative to the head position
+ * - md: Measured depth relative to mean sea level (Msl)
+ *
+ * The stride is then 4 values per log entry:
+ * [dx0, dy0, dz0, md0, dx1, dy1, dz1, md1, ..., dx(n - 1), dy(n-1), dz(n-1), md(n-1)]
+ *
+ * The measured top is then positionlog[3]
+ * The measured bottom is then positionlog[positionlog.length - 1]
+ *
+ * The position log is represented in this way for optimimalization reasons.
+ *
+ */
+export type PositionLog = Float32Array;

package/dist/types/sdk/data/types/StratColumn.d.ts

@@ -0,0 +1,18 @@
+export type StratColumnUnit = {
+    id: string;
+    name: string;
+    unitType: string;
+    level: number;
+    top: string;
+    base: string;
+    topAge: number;
+    baseAge: number;
+    color: string;
+    parent: string | null;
+};
+export type StratColumn = {
+    id: string;
+    name: string;
+    type: string;
+    units: StratColumnUnit[];
+};

package/dist/types/sdk/data/types/SurfaceMeta.d.ts

@@ -0,0 +1,23 @@
+export type SurfaceMeta = {
+    id: string;
+    name: string;
+    description?: string;
+    projection: string;
+    min: number;
+    max: number;
+    displayMin: number;
+    displayMax: number;
+    color: string;
+    visualization: string;
+    header: {
+        ny: number;
+        xori: number;
+        xmax: number;
+        yori: number;
+        ymax: number;
+        xinc: number;
+        yinc: number;
+        nx: number;
+        rot: number;
+    };
+};

package/dist/types/sdk/data/types/SurfaceValues.d.ts

@@ -0,0 +1 @@
+export type SurfaceValues = Float32Array;

package/dist/types/sdk/data/types/Symbol.d.ts

@@ -0,0 +1,6 @@
+export type SymbolData = Record<string, any>;
+export type SymbolsType = {
+    data?: SymbolData[];
+    transformations: Float32Array;
+    colors?: Float32Array;
+};

package/dist/types/sdk/data/types/VerticalSlice.d.ts

@@ -0,0 +1,9 @@
+import { Vec2 } from '../../types/common';
+import { ProjectedTrajectory } from '../../utils/trajectory';
+export type VerticalSlice = {
+    trajectory: ProjectedTrajectory;
+    depthRange: Vec2;
+    samples: Vec2;
+    values: Float32Array;
+    valueRange: Vec2;
+};

package/dist/types/sdk/data/types/WellboreHeader.d.ts

@@ -0,0 +1,15 @@
+export type WellboreHeader = {
+    id: string;
+    name: string;
+    well: string;
+    depthReferenceElevation: number;
+    kickoffDepthMsl: number | null;
+    parent: string | null;
+    drilled: Date | null;
+    easting: number;
+    northing: number;
+    depthMdMsl: number;
+    waterDepth: number | null;
+    status: string;
+    properties?: Record<string, any>;
+};

package/dist/types/sdk/data/types/index.d.ts

@@ -0,0 +1,11 @@
+export * from './Casing';
+export * from './CompletionTool';
+export * from './DepthReferencePoint';
+export * from './Formation';
+export * from './PerforationInterval';
+export * from './Pick';
+export * from './PositionLog';
+export * from './StratColumn';
+export * from './SurfaceMeta';
+export * from './Symbol';
+export * from './WellboreHeader';

package/dist/types/sdk/geometries/curve/curve-3d.d.ts

@@ -0,0 +1,46 @@
+import { Vec3 } from '../../types/common';
+/**
+ * Interface for interpolating points on a 3d curve
+ */
+export interface Curve3D {
+    getPointAt: (pos: number) => Vec3;
+    getPoints: (nSamples: number, from?: number, to?: number) => Vec3[];
+    getTangentAt: (pos: number) => Vec3;
+    getNormalAt: (pos: number) => Vec3;
+    getBoundingBox: (from?: number, to?: number) => {
+        min: Vec3;
+        max: Vec3;
+    };
+    nearest: (point: Vec3) => {
+        position: number;
+        point: Vec3;
+        distance: number;
+    };
+    length: number;
+    closed: boolean;
+}
+/**
+ * Returns an implementation of `SplineCurve` using `CurveInterpolator`
+ **/
+export declare function getSplineCurve(points: Vec3[], closed?: boolean): Curve3D | null;
+export type FrenetFrame = {
+    curvePosition: number;
+    position: Vec3;
+    tangent: Vec3;
+    normal: Vec3;
+    binormal: Vec3;
+};
+/**
+ * Calculate a stable and balanced set of Frenet Frames for a curve at the
+ * specified positions.
+ */
+export declare function calculateFrenetFrames(curve: Curve3D, curvePositions: number[]): FrenetFrame[];
+/**
+ * Get a set of positions along a curve according to a number of segments per meter,
+ * optionally simplified/optimized by specifying a simplification threshold.
+ *
+ * To get a sub section, use the from and/or to parameters.
+ *
+ * @remarks segments per meter is always calculated from the start of the curve to ensure alingment when optimizing the number of vertices
+ */
+export declare function getCurvePositions(curve: Curve3D, from?: number, to?: number, segmentsPerMeter?: number, simplificationThreshold?: number): number[];

package/dist/types/sdk/geometries/curve/tube-geometry.d.ts

@@ -0,0 +1,34 @@
+import { BufferGeometry } from 'three';
+import { Tuplet } from '../../types/common';
+import { Curve3D } from './curve-3d';
+export type RadiusModifier = {
+    type: 'linear' | 'stepped';
+    steps: Tuplet<number>[];
+};
+export type AttributeOptions = {
+    computeNormals?: boolean;
+    computeUvs?: boolean;
+};
+export type TubeGeometryOptions = AttributeOptions & {
+    radialSegments?: number;
+    from?: number;
+    to?: number;
+    startCap?: boolean;
+    endCap?: boolean;
+    radius?: number;
+    segmentsPerMeter?: number;
+    radiusModifier?: RadiusModifier;
+    simplificationThreshold?: number;
+    computeLengths?: boolean;
+    computeRelativeLengths?: boolean;
+    computeCurveNormals?: boolean;
+    computeCurveTangents?: boolean;
+    computeCurveBinormals?: boolean;
+    innerRadius?: number;
+    thickness?: number;
+    addGroups?: boolean;
+};
+/**
+ * Generates a fully customized tube geometry extruded from a curve.
+ */
+export declare function createTubeGeometry(curve: Curve3D, options?: TubeGeometryOptions): BufferGeometry<import('three').NormalBufferAttributes, import('three').BufferGeometryEventMap>;

package/dist/types/sdk/geometries/delatin.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Modified version of Mapbox Delatin library: https://github.com/mapbox/delatin
+ * Copyright (c) 2019, Michael Fogleman, Vladimir Agafonkin
+ */
+export declare class Delatin {
+    data: Float32Array;
+    width: number;
+    height: number;
+    coords: number[];
+    triangles: number[];
+    nullValue: number;
+    private _queue;
+    private _queueIndices;
+    private _errors;
+    private _halfedges;
+    private _candidates;
+    private _invalidPoints;
+    private _rms;
+    private _pending;
+    private _pendingLen;
+    private _rmsSum;
+    constructor(data: Float32Array, width: number, nullValue?: number);
+    run(maxError?: number): void;
+    removeInvalidTriangles(): void;
+    refine(): void;
+    getMaxError(): number;
+    getRMSD(): number;
+    heightAt(x: number, y: number): number;
+    private _findCandidate;
+    private _step;
+    private _addPoint;
+    private _addTriangle;
+    private _flush;
+    private _legalize;
+    private _handleCollinear;
+    private _queuePush;
+    private _queuePop;
+    private _queuePopBack;
+    private _queueRemove;
+    private _queueLess;
+    private _queueSwap;
+    private _queueUp;
+    private _queueDown;
+}

package/dist/types/sdk/geometries/fence.d.ts

@@ -0,0 +1,3 @@
+import { BufferGeometry } from 'three';
+import { Vec2 } from '../types/common';
+export declare function createFenceGeometry(positions: Vec2[], y0: number, y1: number): BufferGeometry<import('three').NormalBufferAttributes, import('three').BufferGeometryEventMap>;

package/dist/types/sdk/geometries/packing.d.ts

@@ -0,0 +1,46 @@
+import { BufferGeometry, TypedArray } from 'three';
+export type BufferAttributeDrawRange = {
+    start: number;
+    count: number;
+};
+export type BufferAttributeGroups = (BufferAttributeDrawRange & {
+    materialIndex?: number | undefined;
+})[];
+export type BufferAttributeLike = {
+    array: TypedArray;
+    itemSize: number;
+};
+export type BufferGeometryLike = {
+    [index: string]: any;
+    drawRange?: BufferAttributeDrawRange | undefined;
+    groups?: BufferAttributeGroups | undefined;
+    attributes: Record<string, BufferAttributeLike>;
+    index?: ArrayBufferLike | undefined;
+    userData?: any;
+};
+export type PackedBufferAttribute = {
+    buffer: ArrayBufferLike;
+    attributeType: string;
+    itemSize: number;
+};
+export type PackedAttributes = Record<string, PackedBufferAttribute>;
+export type PackedBufferGeometry = {
+    drawRange: BufferAttributeDrawRange;
+    groups: BufferAttributeGroups;
+    attributes: PackedAttributes;
+    index: ArrayBufferLike | undefined;
+    indexType: string | undefined;
+    userData?: any;
+};
+export type PackedBufferGeometryCollection = Record<string, PackedBufferGeometry>;
+export declare function getTypedArrayType(array: ArrayBufferLike | TypedArray): "Int8Array" | "Float32Array" | "Uint8Array" | "Int16Array" | "Uint16Array" | "Int32Array" | "Uint32Array" | "Float64Array";
+export declare function getTypedArrayFromBuffer(buffer: ArrayBufferLike, type: string): Float32Array<ArrayBufferLike> | Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike>;
+export declare function packAttribute(typedArray: TypedArray, itemSize?: number): PackedBufferAttribute;
+export declare function packBufferGeometryLike(geometry: BufferGeometryLike): [PackedBufferGeometry, ArrayBufferLike[]];
+export declare function packBufferGeometry(bufferGeometry: BufferGeometry): [PackedBufferGeometry, ArrayBufferLike[]];
+export declare function packBufferGeometries(bufferGeometries: BufferGeometry[]): {
+    data: PackedBufferGeometryCollection;
+    transferrables: ArrayBufferLike[];
+};
+export declare function unpackBufferGeometry(packed: PackedBufferGeometry): BufferGeometry<import('three').NormalBufferAttributes, import('three').BufferGeometryEventMap>;
+export declare function unpackBufferGeometries(data: PackedBufferGeometryCollection): Record<string, BufferGeometry<import('three').NormalBufferAttributes, import('three').BufferGeometryEventMap>>;

package/dist/types/sdk/geometries/triangulate-grid-delaunay.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Triangulate an elevation grid using Delaunay triangulation
+ */
+export declare function triangulateGridDelaunay(grid: Float32Array, columns: number, scaleX?: number, scaleY?: number, nullValue?: number, maxError?: number): {
+    positions: Float32Array<ArrayBuffer>;
+    uvs: Float32Array<ArrayBuffer>;
+    indices: Uint32Array<ArrayBuffer>;
+};

package/dist/types/sdk/geometries/triangulate-grid.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Triangulates a heightmap using marching-squares algorithm.
+ * This creates a dense polygon count so it's recommended to use
+ * {@link triangulateGridDelaunay} instead!
+ */
+export type TriangleVertex = {
+    x: number;
+    y: number;
+    z: number;
+    edge: TriangleEdge | null;
+};
+export type TriangleEdge = {
+    index: number;
+    tail: number;
+    head: number;
+    twin: TriangleEdge | null;
+    prev: TriangleEdge | null;
+    next: TriangleEdge | null;
+};
+export interface GridValueTransformFunc {
+    (v: number): number | null;
+}
+export declare function triangulateGrid(grid: Float32Array, columns: number, scaleX?: number, scaleY?: number, transformValue?: GridValueTransformFunc): {
+    vertices: TriangleVertex[];
+    indices: number[];
+    uvs: number[];
+    edges: TriangleEdge[];
+};