gis-tools-ts/dist/readers/las/laz/v3.d.ts

A collection of geospatial tools primarily designed for WGS84, Web Mercator, and S2.

import { BufferReader } from '../../index.js';
import { ArithmeticDecoder, ArithmeticModel, IntegerCompressor, StreamingMedian5 } from './index.js';
import { U64I64F64 } from '../util.js';
import type { Reader } from '../../index.js';
import type { ItemReader, LAZContext } from './index.js';
/** LAS Point 1.4 context */
export declare class LAScontextPOINT14 {
    unused: boolean;
    lastItem: DataView<ArrayBuffer>;
    lastIntensity: number[];
    lastXDiffMedian5: (StreamingMedian5 | undefined)[];
    lastYDiffMedian5: (StreamingMedian5 | undefined)[];
    lastZ: number[];
    mChangedValues: (ArithmeticModel | undefined)[];
    mScannerChannel?: ArithmeticModel;
    mNumberOfReturns: (ArithmeticModel | undefined)[];
    mReturnNumberGpsSame?: ArithmeticModel;
    mReturnNumber: (ArithmeticModel | undefined)[];
    icdX?: IntegerCompressor;
    icdY?: IntegerCompressor;
    icZ?: IntegerCompressor;
    mClassification: (ArithmeticModel | undefined)[];
    mFlags: (ArithmeticModel | undefined)[];
    mUserData: (ArithmeticModel | undefined)[];
    icIntensity?: IntegerCompressor;
    icScanAngle?: IntegerCompressor;
    icPointSourceID?: IntegerCompressor;
    last: number;
    next: number;
    lastGpstime: U64I64F64[];
    lastGpstimeDiff: number[];
    multiExtremeCounter: number[];
    mGpstimeMulti?: ArithmeticModel;
    mGpstime0diff?: ArithmeticModel;
    icGpstime?: IntegerCompressor;
    /** Setup class */
    constructor();
}
/** LAS RGB 1.4 context */
export declare class LAScontextRGB14 {
    unused: boolean;
    lastItem: DataView<ArrayBuffer>;
    mByteUsed?: ArithmeticModel;
    mRgbDiff0?: ArithmeticModel;
    mRgbDiff1?: ArithmeticModel;
    mRgbDiff2?: ArithmeticModel;
    mRgbDiff3?: ArithmeticModel;
    mRgbDiff4?: ArithmeticModel;
    mRgbDiff5?: ArithmeticModel;
}
/** LAS RGB & NIR 1.4 context */
export declare class LAScontextRGBNIR14 {
    unused: boolean;
    lastItem: DataView<ArrayBuffer>;
    mRgbBytesUsed?: ArithmeticModel;
    mRgbDiff0?: ArithmeticModel;
    mRgbDiff1?: ArithmeticModel;
    mRgbDiff2?: ArithmeticModel;
    mRgbDiff3?: ArithmeticModel;
    mRgbDiff4?: ArithmeticModel;
    mRgbDiff5?: ArithmeticModel;
    mNirBytesUsed?: ArithmeticModel;
    mNirDiff0?: ArithmeticModel;
    mNirDiff1?: ArithmeticModel;
}
/** LAS WAVEPACKET 1.4 context */
export declare class LAScontextWAVEPACKET14 {
    unused: boolean;
    lastItem: DataView<ArrayBuffer>;
    lastDiff32: number;
    symLastOffsetDiff: number;
    mPacketIndex?: ArithmeticModel;
    mOffsetDiff: (ArithmeticModel | undefined)[];
    icOffsetDiff?: IntegerCompressor;
    icPacketSize?: IntegerCompressor;
    icReturnPoint?: IntegerCompressor;
    icXyz?: IntegerCompressor;
}
/** LAS BYTE 1.4 context */
export declare class LAScontextBYTE14 {
    unused: boolean;
    lastItem: DataView<ArrayBuffer>;
    mBytes: (ArithmeticModel | undefined)[];
}
/** Parse LAZ Point 1.4v3 */
export declare class LAZPoint14v3Reader implements ItemReader {
    #private;
    readonly dec: ArithmeticDecoder;
    readonly decompressSelective: number;
    instreamChannelReturnsXY?: BufferReader;
    instreamZ?: BufferReader;
    instreamClassification?: BufferReader;
    instreamFlags?: BufferReader;
    instreamIntensity?: BufferReader;
    instreamScanAngle?: BufferReader;
    instreamUserData?: BufferReader;
    instreamPointSource?: BufferReader;
    instreamGpsTime?: BufferReader;
    decChannelReturnsXY: ArithmeticDecoder;
    decZ: ArithmeticDecoder;
    decClassification: ArithmeticDecoder;
    decFlags: ArithmeticDecoder;
    decIntensity: ArithmeticDecoder;
    decScanAngle: ArithmeticDecoder;
    decUserData: ArithmeticDecoder;
    decPointSource: ArithmeticDecoder;
    decGpsTime: ArithmeticDecoder;
    requestedZ: boolean;
    requestedClassification: boolean;
    requestedFlags: boolean;
    requestedIntensity: boolean;
    requestedScanAngle: boolean;
    requestedUserData: boolean;
    requestedPointSource: boolean;
    requestedGpsTime: boolean;
    numBytesChannelReturnsXY: number;
    numBytesZ: number;
    numBytesClassification: number;
    numBytesFlags: number;
    numBytesIntensity: number;
    numBytesScanAngle: number;
    numBytesUserData: number;
    numBytesPointSource: number;
    numBytesGpsTime: number;
    changedZ: boolean;
    changedClassification: boolean;
    changedFlags: boolean;
    changedIntensity: boolean;
    changedScanAngle: boolean;
    changedUserData: boolean;
    changedPointSource: boolean;
    changedGpsTime: boolean;
    bytes?: DataView;
    numBytesAllocated: number;
    currentContext: number;
    contexts: LAScontextPOINT14[];
    /**
     * @param dec - the arithmetic decoder
     * @param decompressSelective - which fields to decompress
     */
    constructor(dec: ArithmeticDecoder, decompressSelective?: number);
    /**
     * Read in chunk sizes
     * @param reader - the full data store
     */
    chunkSizes(reader: Reader): void;
    /**
     * @param item - the current item to be read into
     * @param context - the current context
     */
    init(item: DataView, context: LAZContext): void;
    /**
     * @param item - the current item to be read into
     * @param context - the current context
     */
    read(item: DataView, context: LAZContext): void;
}
/** Parse LAZ RGB 1.4v3 */
export declare class LAZrgb14v3Reader implements ItemReader {
    #private;
    readonly dec: ArithmeticDecoder;
    readonly decompressSelective: number;
    instreamRGB?: Reader;
    decRGB?: ArithmeticDecoder;
    changedRGB: boolean;
    numBytesRGB: number;
    requestedRGB: boolean;
    bytes?: DataView;
    numBytesAllocated: number;
    currentContext: number;
    contexts: LAScontextRGB14[];
    /**
     * @param dec - the arithmetic decoder
     * @param decompressSelective - which fields to decompress
     */
    constructor(dec: ArithmeticDecoder, decompressSelective?: number);
    /**
     * @param item - the current item
     * @param context - the current context
     */
    init(item: DataView, context: LAZContext): void;
    /**
     * @param item - the current item
     * @param context - the current context
     */
    read(item: DataView, context: LAZContext): void;
    /**
     * Read in the chunk size
     * @param reader - the data block to read from
     */
    chunkSizes(reader: Reader): void;
}
/** Parse LAZ RGB NIR 1.4v3 */
export declare class LAZrgbNir14v3Reader implements ItemReader {
    #private;
    readonly dec: ArithmeticDecoder;
    readonly decompressSelective: number;
    instreamRGB?: Reader;
    instreamNIR?: Reader;
    decRGB?: ArithmeticDecoder;
    decNIR?: ArithmeticDecoder;
    changedRGB: boolean;
    changedNIR: boolean;
    numBytesRGB: number;
    numBytesNIR: number;
    requestedRGB: boolean;
    requestedNIR: boolean;
    bytes?: DataView;
    numBytesAllocated: number;
    currentContext: number;
    contexts: LAScontextRGBNIR14[];
    /**
     * @param dec - the arithmetic decoder
     * @param decompressSelective - the decompress selective
     */
    constructor(dec: ArithmeticDecoder, decompressSelective?: number);
    /** @param reader - the data block to read from */
    chunkSizes(reader: Reader): void;
    /**
     * @param item - the current item
     * @param context - the current context
     */
    init(item: DataView, context: LAZContext): void;
    /**
     * @param item - the current item
     * @param context - the current context
     */
    read(item: DataView, context: LAZContext): void;
}
/** Parse LAZ wavepacket 1.4v3 */
export declare class LAZwavepacket14v3Reader implements ItemReader {
    #private;
    private dec;
    readonly decompressSelective: number;
    instreamWavepacket?: Reader;
    decWavepacket?: ArithmeticDecoder;
    changedWavepacket: boolean;
    numBytesWavepacket: number;
    requestedWavepacket: boolean;
    bytes?: DataView;
    numBytesAllocated: number;
    currentContext: number;
    contexts: LAScontextWAVEPACKET14[];
    /**
     * @param dec - the arithmetic decoder
     * @param decompressSelective - the decompress selective (filter)
     */
    constructor(dec: ArithmeticDecoder, decompressSelective?: number);
    /** @param reader - the data block to read from */
    chunkSizes(reader: Reader): void;
    /**
     * @param item - the current item to read in
     * @param context - the current context
     */
    init(item: DataView, context: LAZContext): void;
    /**
     * @param item - the current item
     * @param context - the current context
     */
    read(item: DataView, context: LAZContext): void;
}
/** Parse LAZ RGB 1.4v3 */
export declare class LAZbyte14v3Reader implements ItemReader {
    #private;
    readonly dec: ArithmeticDecoder;
    readonly number: number;
    readonly decompressSelective: number;
    instreamBytes?: Reader[];
    decBytes: (ArithmeticDecoder | undefined)[];
    numBytesBytes: number[];
    changedBytes: boolean[];
    requestedBytes: boolean[];
    bytes?: DataView;
    numBytesAllocated: number;
    currentContext: number;
    contexts: LAScontextBYTE14[];
    /**
     * @param dec - the arithmetic decoder
     * @param number - the number of bytes to read
     * @param decompressSelective - the selective decompression flags
     */
    constructor(dec: ArithmeticDecoder, number: number, decompressSelective?: number);
    /**
     * Read in the chunk sizes
     * @param reader - the data block to read from
     */
    chunkSizes(reader: Reader): void;
    /**
     * Initialize the byte reader
     * @param item - the first raw item needs to be injected for future reads
     * @param context - the current context
     */
    init(item: DataView, context: LAZContext): void;
    /**
     * Read the next item
     * @param item - the next item
     * @param context - the current context
     */
    read(item: DataView, context: LAZContext): void;
}
//# sourceMappingURL=v3.d.ts.map