@equinor/videx-map 1.14.2 → 1.14.4

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;
+}

package/dist/utils/PointDictionary.d.ts

@@ -1,58 +1,58 @@
-import Vector2 from '@equinor/videx-vector2';
-/** Interface of a single point. */
-interface Point<T> {
-    /** Value stored in point. */
-    val: T;
-    /** Position of points. */
-    pos: Vector2;
-    /** ID of point. */
-    id: number;
-}
-/** Dictionary for points. Also manages overlapping. */
-export default class PointDictionary<T> {
-    /** Threshold to define overlapping. */
-    distThreshold: number;
-    /** gridSize of data segmentation. */
-    gridSize: number;
-    /** Radius of points. */
-    radius: number;
-    /** Mapping tile coordinates, on format 'x.y', to submap of points. */
-    tiles: Map<string, Map<number, Point<T>>>;
-    /** Mapping point IDs to values. */
-    pointValues: Map<number, Point<T>>;
-    /** User provided function to test if a line is active or not */
-    testActiveFunction: (value: T) => boolean;
-    /** Used to assign PointID */
-    private pointSeq;
-    /**
-     * Constructs a new point dictionary.
-     * @param distThreshold Threshold for what is considered overlapping
-     * @param gridSize grid cell size used for segmentation
-     */
-    constructor(distThreshold: number, gridSize: number, radius: number, testActive?: (value: T) => boolean);
-    /**
-     * Add a single point to the dictionary.
-     * @param pos Position of point
-     * @param val Value stored within points
-     * @returns ID of newly added point
-     */
-    add(pos: Vector2, val: T): number;
-    private getKeys;
-    isActive(point: Point<T>): boolean;
-    getKey(position: Vector2): string;
-    /**
-     * Get overlapping points, if any.
-     * @param pos Target position
-     * @returns Overlapping point
-     */
-    getOverlapping(pos: Vector2): Point<T>;
-    /**
-     * Get closest point under coordinates defined by radius.
-     * @param pos Target position
-     * @returns Closest point
-     */
-    getClosestUnder(pos: Vector2, radius?: number): Point<T>;
-    /** Clear point dictionary to prepare for new data. */
-    clear(filter?: (value: T, id: number) => boolean): void;
-}
-export {};
+import Vector2 from '@equinor/videx-vector2';
+/** Interface of a single point. */
+interface Point<T> {
+    /** Value stored in point. */
+    val: T;
+    /** Position of points. */
+    pos: Vector2;
+    /** ID of point. */
+    id: number;
+}
+/** Dictionary for points. Also manages overlapping. */
+export default class PointDictionary<T> {
+    /** Threshold to define overlapping. */
+    distThreshold: number;
+    /** gridSize of data segmentation. */
+    gridSize: number;
+    /** Radius of points. */
+    radius: number;
+    /** Mapping tile coordinates, on format 'x.y', to submap of points. */
+    tiles: Map<string, Map<number, Point<T>>>;
+    /** Mapping point IDs to values. */
+    pointValues: Map<number, Point<T>>;
+    /** User provided function to test if a line is active or not */
+    testActiveFunction: (value: T) => boolean;
+    /** Used to assign PointID */
+    private pointSeq;
+    /**
+     * Constructs a new point dictionary.
+     * @param distThreshold Threshold for what is considered overlapping
+     * @param gridSize grid cell size used for segmentation
+     */
+    constructor(distThreshold: number, gridSize: number, radius: number, testActive?: (value: T) => boolean);
+    /**
+     * Add a single point to the dictionary.
+     * @param pos Position of point
+     * @param val Value stored within points
+     * @returns ID of newly added point
+     */
+    add(pos: Vector2, val: T): number;
+    private getKeys;
+    isActive(point: Point<T>): boolean;
+    getKey(position: Vector2): string;
+    /**
+     * Get overlapping points, if any.
+     * @param pos Target position
+     * @returns Overlapping point
+     */
+    getOverlapping(pos: Vector2): Point<T>;
+    /**
+     * Get closest point under coordinates defined by radius.
+     * @param pos Target position
+     * @returns Closest point
+     */
+    getClosestUnder(pos: Vector2, radius?: number): Point<T>;
+    /** Clear point dictionary to prepare for new data. */
+    clear(filter?: (value: T, id: number) => boolean): void;
+}
+export {};

package/dist/utils/Radius.d.ts

@@ -1,2 +1,2 @@
-import { ResizeConfig } from '../ResizeConfigInterface';
-export declare function getRadius(zoom: number, { min, max }: ResizeConfig): number;
+import { ResizeConfig } from '../ResizeConfigInterface';
+export declare function getRadius(zoom: number, { min, max }: ResizeConfig): number;

package/dist/utils/Rect.d.ts

@@ -1,27 +1,27 @@
-import Vector2 from '@equinor/videx-vector2';
-import { VectorLike } from '@equinor/videx-linear-algebra';
-export default class Rect {
-    lowerLeft: Vector2;
-    width: number;
-    height: number;
-    rotation: number;
-    constructor(lowerLeft: Vector2, width: number, height: number, rotation: number);
-    /**
-     * Check if a point is inside.
-     * @param vector Vector to evaluate
-     * @returns True if point is inside rectangle
-     */
-    isInside(vector: VectorLike): boolean;
-    /**
-     * Check if a point is inside.
-     * @param x X position to evaluate
-     * @param y Y position to evaluate
-     * @returns True if point is inside rectangle
-     */
-    isInside(x: number, y: number): boolean;
-    /**
-     * Transforms position from world space to local space.
-     * @param position
-     */
-    inverseTransformPoint(x: number, y: number): Vector2;
-}
+import Vector2 from '@equinor/videx-vector2';
+import { VectorLike } from '@equinor/videx-linear-algebra';
+export default class Rect {
+    lowerLeft: Vector2;
+    width: number;
+    height: number;
+    rotation: number;
+    constructor(lowerLeft: Vector2, width: number, height: number, rotation: number);
+    /**
+     * Check if a point is inside.
+     * @param vector Vector to evaluate
+     * @returns True if point is inside rectangle
+     */
+    isInside(vector: VectorLike): boolean;
+    /**
+     * Check if a point is inside.
+     * @param x X position to evaluate
+     * @param y Y position to evaluate
+     * @returns True if point is inside rectangle
+     */
+    isInside(x: number, y: number): boolean;
+    /**
+     * Transforms position from world space to local space.
+     * @param position
+     */
+    inverseTransformPoint(x: number, y: number): Vector2;
+}