/** @packageDocumentation
 * @module Polyface
 */
import { Transform } from "../geometry3d/Transform";
import { Range1d, Range3d } from "../geometry3d/Range";
/** The types of data that can be represented by an [[AuxChannelData]]. Each type of data contributes differently to the
 * animation applied by an [AnalysisStyle]($common) and responds differently when the host [[PolyfaceAuxData]] is transformed.
 * @public
 */
export declare enum AuxChannelDataType {
    /** General-purpose scalar values like stress, temperature, etc., used to recolor the [[Polyface]]'s vertices.
     * When the host Polyface is transformed, scalar values remain unmodified.
     */
    Scalar = 0,
    /** Distances in meters used to recolor the [[Polyface]]'s vertices.
     * When the host [[Polyface]] is transformed the [[Transform]]'s scale is applied to the distances.
     */
    Distance = 1,
    /** (X, Y, Z) displacement vectors added to the [[Polyface]]'s vertex positions resulting in deformation of the mesh.
     * When the host Polyface is transformed the displacements are rotated and scaled accordingly.
     */
    Vector = 2,
    /** (X, Y, Z) unit normal vectors that replace the host [[Polyface]]'s own normals.
     * When the Polyface is transformed the normals are rotated and renormalized accordingly.
     */
    Normal = 3
}
/**  Represents the [[AuxChannel]] data at a single input value.
 * @public
*/
export declare class AuxChannelData {
    /** The input value for this data. */
    input: number;
    /** The vertex values for this data. A single value per vertex for scalar and distance types and 3 values (x,y,z) for normal or vector channels. */
    values: number[];
    /** Constructor. If `values` is a number array, it is captured.  */
    constructor(input: number, values: number[] | Float64Array);
    /** Copy blocks of size `blockSize` from (blocked index) `thisIndex` in this AuxChannelData to (blockIndex) `otherIndex` of `other` */
    copyValues(other: AuxChannelData, thisIndex: number, otherIndex: number, blockSize: number): void;
    /** return a deep copy */
    clone(): AuxChannelData;
    /** toleranced comparison of the `input` and `value` fields.
     * * Default tolerance is 1.0e-8
     */
    isAlmostEqual(other: AuxChannelData, tol?: number): boolean;
}
/**  Represents a single [[PolyfaceAuxData]] channel.
 * @public
*/
export declare class AuxChannel {
    /** An array of [[AuxChannelData]] that represents the vertex data at one or more input values. */
    data: AuxChannelData[];
    /** The type of data stored in this channel. */
    dataType: AuxChannelDataType;
    /** The channel name. This is used to present the [[AuxChannel]] to the user and also to select the [[AuxChannel]] for display from AnalysisStyle */
    name?: string;
    /** The input name. */
    inputName?: string;
    /** Constructor with CAPTURED inputs. */
    constructor(data: AuxChannelData[], dataType: AuxChannelDataType, name?: string, inputName?: string);
    /** Return a deep copy. */
    clone(): AuxChannel;
    /** Toleranced comparison of contents. */
    isAlmostEqual(other: AuxChannel, tol?: number): boolean;
    /** True if the data type is 1-dimensional. */
    static isScalar(dataType: AuxChannelDataType): boolean;
    /** True if the data stored in this AuxChannel is 1-dimensional. */
    get isScalar(): boolean;
    /** The dimension (1D or 3D) of each datum of an AuxChannel of the given type. */
    static entriesPerValue(dataType: AuxChannelDataType): number;
    /** The dimension (1D or 3D) of each datum in the data arrays of this AuxChannel. */
    get entriesPerValue(): number;
    /** The number of data stored in each data array of this AuxChannel, equal to the length of the array divided by `entriesPerValue`. */
    get valueCount(): number;
    /** The minimum and maximum values in `data.values`, or `undefined` if [[isScalar]] is false. */
    get scalarRange(): Range1d | undefined;
    /** Compute the range of this channel's displacement values, if [[dataType]] is [[AuxChannelDataType.Vector]].
     * @param scale Scale by which to multiply each displacement.
     * @param result Preallocated object in which to store result.
     * @returns The range encompassing all this channel's displacements scaled by `scale`; or a null range if this channel does not contain displacements.
     */
    computeDisplacementRange(scale?: number, result?: Range3d): Range3d;
}
/**
 * The `PolyfaceAuxData` structure contains one or more analytical data channels for each vertex of a [[Polyface]], allowing the polyface to be styled
 * using an [AnalysisStyle]($common).
 * Typically a polyface will contain only vertex data required for its basic display: vertex position, normal, texture parameter, color.
 * `PolyfaceAuxData` provides supplemental per-vertex data that is generally computed in an analysis program or other external data source.
 * This supplemental data can be either 1D (e.g., height, override color) or 3D (e.g., displacement vector, override normal); see [[AuxChannel.entriesPerValue]], [[AuxChannel.dataType]].
 * All data channels are indexed by the same indices, which must have the same length and structure as the other Polyface indices.
 * This means that if a facet's face loop is found at index range [i0,i1] in the Polyface vertex index array, then the same index range [i0,i1]
 * locates the data for this facet in all the other Polyface index arrays, including the `PolyfaceAuxData` indices.
 * @see [[PolyfaceData.auxData]] to associate auxiliary data with a polyface.
 * @public
 */
export declare class PolyfaceAuxData {
    /** Array with one or more channels of auxiliary data for the associated polyface. */
    channels: AuxChannel[];
    /** The indices (shared by all data in all channels) mapping the data to the mesh facets. */
    indices: number[];
    /** Constructor with CAPTURED inputs. */
    constructor(channels: AuxChannel[], indices: number[]);
    /** Return a deep copy. */
    clone(): PolyfaceAuxData;
    /** Returns true if `this` is equivalent to `other` within `tolerance`.
     * The indices are compared for exact equality. The data in the channels are compared using `tolerance`, which defaults to 1.0e-8.
     */
    isAlmostEqual(other: PolyfaceAuxData, tolerance?: number): boolean;
    /** Returns true if both `left` and `right` are undefined, or both are defined and equivalent within `tolerance` (default: 1.0e-8). */
    static isAlmostEqual(left: PolyfaceAuxData | undefined, right: PolyfaceAuxData | undefined, tol?: number): boolean;
    /** Create a PolyfaceAuxData for use by a [[PolyfaceVisitor]].  */
    createForVisitor(): PolyfaceAuxData;
    /** Apply `transform` to the data in each channel.
     * @see [[AuxChannelDataType]] for details regarding how each data type is affected by the transform.
     * @note This method may fail if a channel of [[AuxChannelDataType.Normal]] exists and `transform.matrix` is non-invertible.
     * @returns true if the channels were all successfully transformed.
     */
    tryTransformInPlace(transform: Transform): boolean;
}
//# sourceMappingURL=AuxData.d.ts.map