@equinor/videx-map 1.14.3 → 1.14.4

package/dist/utils/ComparableArray.d.ts

@@ -1,60 +1,60 @@
-/**
- * Class for comparing arrays of numbers. Also supports objects with numeric elements.
- */
-export default class ComparableArray<T extends object> {
-    /**
-     * Numbers held by comparable array.
-     */
-    numbers: number[];
-    /**
-     * Function used when selecting key from object.
-     */
-    selector: (val: T) => number;
-    /**
-     * Create a new comparable array.
-     * @param objects Objects used to fill array
-     * @param sort If true, sort objects before storing
-     * @param selector Selector used to get numeric element
-     */
-    constructor(objects: T[], sort: boolean, selector: (val: T) => number);
-    /**
-     * Create a new comparable array.
-     * @param numbers Collection of numbers used to fill array
-     * @param sort If true, sort objects before storing
-     */
-    constructor(numbers: number[], sort: boolean);
-    /**
-     * Create a new comparable array.
-     * @param numbers Collection of numbers used to fill array
-     */
-    constructor(numbers: number[]);
-    /**
-     * Create a new comparable array.
-     * @param number Single number in array
-     */
-    constructor(number: number);
-    /**
-     * Compares the array to a collection of objects.
-     * @param objects Objects to compare with
-     * @param sort If true, sort objects before comparing
-     * @returns True if arrays are equal
-     */
-    compare(objects: T[], sort?: boolean): boolean;
-    /**
-     * Compares the array to a collection of numbers.
-     * @param numbers Collection of numbers to compare with
-     * @param sort If true, sort objects before comparing
-     * @returns True if arrays are equal
-     */
-    compare(numbers: number[], sort?: boolean): boolean;
-    /**
-     * Compares the array to a single number.
-     * @param number Single number to compare with
-     * @returns True if arrays are equal
-     */
-    compare(number: number): boolean;
-    /**
-     * Returns the internal array as a string.
-     */
-    toString(): string;
-}
+/**
+ * Class for comparing arrays of numbers. Also supports objects with numeric elements.
+ */
+export default class ComparableArray<T extends object> {
+    /**
+     * Numbers held by comparable array.
+     */
+    numbers: number[];
+    /**
+     * Function used when selecting key from object.
+     */
+    selector: (val: T) => number;
+    /**
+     * Create a new comparable array.
+     * @param objects Objects used to fill array
+     * @param sort If true, sort objects before storing
+     * @param selector Selector used to get numeric element
+     */
+    constructor(objects: T[], sort: boolean, selector: (val: T) => number);
+    /**
+     * Create a new comparable array.
+     * @param numbers Collection of numbers used to fill array
+     * @param sort If true, sort objects before storing
+     */
+    constructor(numbers: number[], sort: boolean);
+    /**
+     * Create a new comparable array.
+     * @param numbers Collection of numbers used to fill array
+     */
+    constructor(numbers: number[]);
+    /**
+     * Create a new comparable array.
+     * @param number Single number in array
+     */
+    constructor(number: number);
+    /**
+     * Compares the array to a collection of objects.
+     * @param objects Objects to compare with
+     * @param sort If true, sort objects before comparing
+     * @returns True if arrays are equal
+     */
+    compare(objects: T[], sort?: boolean): boolean;
+    /**
+     * Compares the array to a collection of numbers.
+     * @param numbers Collection of numbers to compare with
+     * @param sort If true, sort objects before comparing
+     * @returns True if arrays are equal
+     */
+    compare(numbers: number[], sort?: boolean): boolean;
+    /**
+     * Compares the array to a single number.
+     * @param number Single number to compare with
+     * @returns True if arrays are equal
+     */
+    compare(number: number): boolean;
+    /**
+     * Returns the internal array as a string.
+     */
+    toString(): string;
+}

package/dist/utils/LineDictionary.d.ts

@@ -1,89 +1,89 @@
-import Vector2 from '@equinor/videx-vector2';
-/** Collection of coordinates defining geometry of a line segment. */
-interface Geometry {
-    /** X-component of start position. */
-    x1: number;
-    /** Y-component of start position. */
-    y1: number;
-    /** X-component of end position. */
-    x2: number;
-    /** Y-component of end position. */
-    y2: number;
-}
-/** Definition of a single line segment. */
-interface LineSegment {
-    /** ID of parent line. */
-    lineID: number;
-    /** Geometry of line segment. */
-    geometry: Geometry;
-}
-interface Line<T> {
-    id: number;
-    value: T;
-    segments: LineSegment[];
-}
-/** Dictionary for segmenting lines and finding closest entries. */
-export default class LineDictionary<T> {
-    gridsize: number;
-    /** Map with collection of segment IDs. */
-    tiles: Map<string, LineSegment[]>;
-    /** IDs of lines mapped to values. */
-    lineValues: Map<number, Line<T>>;
-    /** User provided function to test if a line is active or not */
-    testActiveFunction: (value: T) => boolean;
-    /** Used to assign lineID */
-    private lineSeq;
-    /**
-     * Constructs a new line dictionary with segmentation based on given decimal.
-     * @param decimals Defines size of tiles. For example, decimals = 2, would assign
-     * both [12, 23] and [19, 21] to a single tile [10, 20]. Decimals also defines
-     * maximum search distance. For decimals equals 2, only lines within 10 units will
-     * be returned. (Default: 0)
-     */
-    constructor(gridsize?: number, testActive?: (value: T) => boolean);
-    /**
-     * Maps a line up to a given value
-     * @param points Collection of points on line
-     * @param value Value to return for line
-     * @param id Optionally associate an id with this entry
-     */
-    add(points: Vector2[], value: T, id?: number): Line<T>;
-    /**
-     * Add a line segment to the dictionary by start and end position.
-     * @param x1 X-component of start position
-     * @param y1 Y-component of start position
-     * @param x2 X-component of end position
-     * @param y2 Y-component of end position
-     * @param lineID ID of the line which the segment should belong to
-     * @private
-     */
-    addSegment(x1: number, y1: number, x2: number, y2: number, line: Line<T>): void;
-    /**
-     * Find the closest line to the given coordinates and return its value.
-     * @param target Reference position to evaluate
-     * @param maxDist Max distance relative to decimals. Given a decimal value of 2, a maxDist of 1 will return lines within a distance of 0.01 units.
-     * @returns Value assigned the line
-     */
-    getClosest(target: Vector2, maxDist?: number): T;
-    /**
-     * Find the closest lines to the given coordinates and return their value.
-     * @param target Reference position to evaluate
-     * @param epsilon Allowed distance between overlapping segments
-     * @param maxDist Maximum distance in grid cells.
-     * @param filter Function for filtering points based on minimum
-     * @returns Values assigned the lines
-     */
-    getAllClosest(target: Vector2, epsilon?: number, maxDist?: number, filter?: (min: T, d: T) => boolean): T[];
-    isActive(line: Line<T>): boolean;
-    /**
-     * Get unique line segments within a 3 by 3 grid.
-     * @private
-     * @param x X position of point
-     * @param y Y position of point
-     * @returns Collection of segments within boundaries
-     */
-    getSegmentsOn3Grid(target: Vector2): Set<LineSegment>;
-    /** Clear line dictionary to prepare for new data. */
-    clear(filter?: (value: T, id: number) => boolean): void;
-}
-export {};
+import Vector2 from '@equinor/videx-vector2';
+/** Collection of coordinates defining geometry of a line segment. */
+interface Geometry {
+    /** X-component of start position. */
+    x1: number;
+    /** Y-component of start position. */
+    y1: number;
+    /** X-component of end position. */
+    x2: number;
+    /** Y-component of end position. */
+    y2: number;
+}
+/** Definition of a single line segment. */
+interface LineSegment {
+    /** ID of parent line. */
+    lineID: number;
+    /** Geometry of line segment. */
+    geometry: Geometry;
+}
+interface Line<T> {
+    id: number;
+    value: T;
+    segments: LineSegment[];
+}
+/** Dictionary for segmenting lines and finding closest entries. */
+export default class LineDictionary<T> {
+    gridsize: number;
+    /** Map with collection of segment IDs. */
+    tiles: Map<string, LineSegment[]>;
+    /** IDs of lines mapped to values. */
+    lineValues: Map<number, Line<T>>;
+    /** User provided function to test if a line is active or not */
+    testActiveFunction: (value: T) => boolean;
+    /** Used to assign lineID */
+    private lineSeq;
+    /**
+     * Constructs a new line dictionary with segmentation based on given decimal.
+     * @param decimals Defines size of tiles. For example, decimals = 2, would assign
+     * both [12, 23] and [19, 21] to a single tile [10, 20]. Decimals also defines
+     * maximum search distance. For decimals equals 2, only lines within 10 units will
+     * be returned. (Default: 0)
+     */
+    constructor(gridsize?: number, testActive?: (value: T) => boolean);
+    /**
+     * Maps a line up to a given value
+     * @param points Collection of points on line
+     * @param value Value to return for line
+     * @param id Optionally associate an id with this entry
+     */
+    add(points: Vector2[], value: T, id?: number): Line<T>;
+    /**
+     * Add a line segment to the dictionary by start and end position.
+     * @param x1 X-component of start position
+     * @param y1 Y-component of start position
+     * @param x2 X-component of end position
+     * @param y2 Y-component of end position
+     * @param lineID ID of the line which the segment should belong to
+     * @private
+     */
+    addSegment(x1: number, y1: number, x2: number, y2: number, line: Line<T>): void;
+    /**
+     * Find the closest line to the given coordinates and return its value.
+     * @param target Reference position to evaluate
+     * @param maxDist Max distance relative to decimals. Given a decimal value of 2, a maxDist of 1 will return lines within a distance of 0.01 units.
+     * @returns Value assigned the line
+     */
+    getClosest(target: Vector2, maxDist?: number): T;
+    /**
+     * Find the closest lines to the given coordinates and return their value.
+     * @param target Reference position to evaluate
+     * @param epsilon Allowed distance between overlapping segments
+     * @param maxDist Maximum distance in grid cells.
+     * @param filter Function for filtering points based on minimum
+     * @returns Values assigned the lines
+     */
+    getAllClosest(target: Vector2, epsilon?: number, maxDist?: number, filter?: (min: T, d: T) => boolean): T[];
+    isActive(line: Line<T>): boolean;
+    /**
+     * Get unique line segments within a 3 by 3 grid.
+     * @private
+     * @param x X position of point
+     * @param y Y position of point
+     * @returns Collection of segments within boundaries
+     */
+    getSegmentsOn3Grid(target: Vector2): Set<LineSegment>;
+    /** Clear line dictionary to prepare for new data. */
+    clear(filter?: (value: T, id: number) => boolean): void;
+}
+export {};

package/dist/utils/LineInterpolator.d.ts

@@ -1,84 +1,84 @@
-import Vector2 from '@equinor/videx-vector2';
-/** Path used by the interpolator. */
-interface PathPoint {
-    /** Point along the line. */
-    point: Vector2;
-    /** Normalized direction towards next point. */
-    direction: Vector2;
-    /** Distance to point along line. */
-    distance: number;
-    /** Relative distance to point along line. */
-    relative: number;
-}
-/** Point in returned segment. */
-export interface SegmentPoint {
-    /** Point along line. */
-    position: Vector2;
-    /** Normalized direction towards next point. */
-    direction: Vector2;
-    /** Distance to point along line. */
-    distance: number;
-}
-/** Interpolator for finding points and subsegments on a line defined by a collection of Vector2 or 2D vectors. */
-export declare class LineInterpolator {
-    /** Amount of provided points. */
-    amount: number;
-    /** Length of line. */
-    length: number;
-    /** True if line is an approximation of a single point. */
-    singlePoint: boolean;
-    /** Collection of points along line with distances. */
-    path: PathPoint[];
-    /**
-     * Construct line interpolator from a collection of points
-     * @param points Collection of points as Vector2
-     */
-    constructor(points: Vector2[], radius: number);
-    /**
-     * Get point at relative position.
-     * @param relative Relative position along the line between 0 and 1
-     * @returns Point at relative position
-     */
-    GetPoint(relative: number): SegmentPoint;
-    /**
-     * Get section at relative position.
-     * @param relativeStart Relative position along the line between 0 and 1
-     * @param relativeEnd Relative position along the line between 0 and 1
-     * @returns Relative section along the line
-     */
-    GetSection(relativeStart: number, relativeEnd: number): SegmentPoint[];
-    /**
-     * Get closest point below provided relative position along the line.
-     * Utilizes divide-and-conquer algorithm to speed up search.
-     * @param relative Relative position along the line between 0 and 1
-     * @returns Index of closest point below relative
-     */
-    GetClosestPointBelow(relative: number): number;
-    /**
-     * Get point with given distance from the start in world space.
-     * @param distance Real distance from the start
-     * @returns Point at given distance from start
-     */
-    GetPointFromStart(distance: number): SegmentPoint;
-    /**
-     * Get point with given distance from the end in world space.
-     * @param distance Real distance from the end
-     * @returns Point at given distance from end
-     */
-    GetPointFromEnd(distance: number): SegmentPoint;
-    /**
-     * Get collection of equally space points with given width in real distance.
-     * @param relative Start of range
-     * @param width Width of range in real distance
-     * @param resolution Amount of points within range
-     * @returns Collection of equally spaced points within range
-     */
-    GetRangeFromStart(relative: number, width: number, resolution?: number): SegmentPoint[];
-    /**
-     * Get direction towards next point.
-     * @param idx Index of point
-     * @returns Direction as vector
-     */
-    GetDirection(points: Vector2[], idx: number): Vector2;
-}
-export {};
+import Vector2 from '@equinor/videx-vector2';
+/** Path used by the interpolator. */
+interface PathPoint {
+    /** Point along the line. */
+    point: Vector2;
+    /** Normalized direction towards next point. */
+    direction: Vector2;
+    /** Distance to point along line. */
+    distance: number;
+    /** Relative distance to point along line. */
+    relative: number;
+}
+/** Point in returned segment. */
+export interface SegmentPoint {
+    /** Point along line. */
+    position: Vector2;
+    /** Normalized direction towards next point. */
+    direction: Vector2;
+    /** Distance to point along line. */
+    distance: number;
+}
+/** Interpolator for finding points and subsegments on a line defined by a collection of Vector2 or 2D vectors. */
+export declare class LineInterpolator {
+    /** Amount of provided points. */
+    amount: number;
+    /** Length of line. */
+    length: number;
+    /** True if line is an approximation of a single point. */
+    singlePoint: boolean;
+    /** Collection of points along line with distances. */
+    path: PathPoint[];
+    /**
+     * Construct line interpolator from a collection of points
+     * @param points Collection of points as Vector2
+     */
+    constructor(points: Vector2[], radius: number);
+    /**
+     * Get point at relative position.
+     * @param relative Relative position along the line between 0 and 1
+     * @returns Point at relative position
+     */
+    GetPoint(relative: number): SegmentPoint;
+    /**
+     * Get section at relative position.
+     * @param relativeStart Relative position along the line between 0 and 1
+     * @param relativeEnd Relative position along the line between 0 and 1
+     * @returns Relative section along the line
+     */
+    GetSection(relativeStart: number, relativeEnd: number): SegmentPoint[];
+    /**
+     * Get closest point below provided relative position along the line.
+     * Utilizes divide-and-conquer algorithm to speed up search.
+     * @param relative Relative position along the line between 0 and 1
+     * @returns Index of closest point below relative
+     */
+    GetClosestPointBelow(relative: number): number;
+    /**
+     * Get point with given distance from the start in world space.
+     * @param distance Real distance from the start
+     * @returns Point at given distance from start
+     */
+    GetPointFromStart(distance: number): SegmentPoint;
+    /**
+     * Get point with given distance from the end in world space.
+     * @param distance Real distance from the end
+     * @returns Point at given distance from end
+     */
+    GetPointFromEnd(distance: number): SegmentPoint;
+    /**
+     * Get collection of equally space points with given width in real distance.
+     * @param relative Start of range
+     * @param width Width of range in real distance
+     * @param resolution Amount of points within range
+     * @returns Collection of equally spaced points within range
+     */
+    GetRangeFromStart(relative: number, width: number, resolution?: number): SegmentPoint[];
+    /**
+     * Get direction towards next point.
+     * @param idx Index of point
+     * @returns Direction as vector
+     */
+    GetDirection(points: Vector2[], idx: number): Vector2;
+}
+export {};

package/dist/utils/Log.d.ts

@@ -1 +1 @@
-export default function log(text: string): void;
+export default function log(text: string): void;

package/dist/utils/Mesh.d.ts

@@ -1,46 +1,46 @@
-import Vector2 from '@equinor/videx-vector2';
-import * as PIXI from 'pixi.js';
-import { VectorLike } from '@equinor/videx-linear-algebra';
-import { SegmentPoint } from './LineInterpolator';
-export interface WellboreSegmentData {
-    vertices: number[];
-    triangles: number[];
-    vertexData: number[];
-    extraData: number[];
-}
-export interface MeshData {
-    vertices: number[];
-    triangles: number[];
-}
-export interface MeshNormalData extends MeshData {
-    normals: number[];
-}
-export default class Mesh {
-    /**
-     * Create mesh for a line.
-     * @param points Collection of points used to construct mesh
-     * @param thickness Thickness of line
-     * @param type 0: Normal, 1: Interval, 2: Tick
-     * @returns Vertex and triangulation for mesh
-     */
-    static WellboreSegment(points: SegmentPoint[], thickness: number, type: number): WellboreSegmentData;
-    static SimpleLine: (points: VectorLike[], thickness?: number) => MeshNormalData;
-    /**
-     * Create mesh for a polygon.
-     * @param points Collection of points used to construct mesh
-     * @returns Vertex and triangulation for mesh
-     */
-    static Polygon: (points: Vector2[]) => MeshData;
-    static PolygonOutline: (points: VectorLike[], thickness?: number) => MeshNormalData;
-    /**
-     * Create a simple pixi mesh from vertices, triangles and shaders. Vertices are named 'inputVerts' in shader.
-     * @param vertices Vertices belonging to mesh
-     * @param triangles Triangulation of mesh
-     * @param vertexShader Vertex shader as string
-     * @param fragmentShader Fragment shader as string
-     * @param uniforms Collection of uniforms
-     * @param normals UV data
-     * @returns Created pixi mesh
-     */
-    static from(vertices: number[], triangles: number[], vertexShader: string, fragmentShader: string, uniforms?: object, normals?: number[]): PIXI.Mesh;
-}
+import Vector2 from '@equinor/videx-vector2';
+import * as PIXI from 'pixi.js';
+import { VectorLike } from '@equinor/videx-linear-algebra';
+import { SegmentPoint } from './LineInterpolator';
+export interface WellboreSegmentData {
+    vertices: number[];
+    triangles: number[];
+    vertexData: number[];
+    extraData: number[];
+}
+export interface MeshData {
+    vertices: number[];
+    triangles: number[];
+}
+export interface MeshNormalData extends MeshData {
+    normals: number[];
+}
+export default class Mesh {
+    /**
+     * Create mesh for a line.
+     * @param points Collection of points used to construct mesh
+     * @param thickness Thickness of line
+     * @param type 0: Normal, 1: Interval, 2: Tick
+     * @returns Vertex and triangulation for mesh
+     */
+    static WellboreSegment(points: SegmentPoint[], thickness: number, type: number): WellboreSegmentData;
+    static SimpleLine: (points: VectorLike[], thickness?: number) => MeshNormalData;
+    /**
+     * Create mesh for a polygon.
+     * @param points Collection of points used to construct mesh
+     * @returns Vertex and triangulation for mesh
+     */
+    static Polygon: (points: Vector2[]) => MeshData;
+    static PolygonOutline: (points: VectorLike[], thickness?: number) => MeshNormalData;
+    /**
+     * Create a simple pixi mesh from vertices, triangles and shaders. Vertices are named 'inputVerts' in shader.
+     * @param vertices Vertices belonging to mesh
+     * @param triangles Triangulation of mesh
+     * @param vertexShader Vertex shader as string
+     * @param fragmentShader Fragment shader as string
+     * @param uniforms Collection of uniforms
+     * @param normals UV data
+     * @returns Created pixi mesh
+     */
+    static from(vertices: number[], triangles: number[], vertexShader: string, fragmentShader: string, uniforms?: object, normals?: number[]): PIXI.Mesh;
+}