@equinor/videx-map 1.14.7 → 1.14.9

package/dist/utils/LineInterpolator.d.ts

@@ -1,84 +0,0 @@
-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 +0,0 @@
-export default function log(text: string): void;

package/dist/utils/Mesh.d.ts

@@ -1,46 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-import { ResizeConfig } from '../ResizeConfigInterface';
-export declare function getRadius(zoom: number, { min, max }: ResizeConfig): number;

package/dist/utils/Rect.d.ts

@@ -1,27 +0,0 @@
-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;
-}

package/dist/utils/TriangleDictionary.d.ts

@@ -1,21 +0,0 @@
-type vec2 = [number, number];
-interface Triangle {
-    v1: vec2;
-    v2: vec2;
-    v3: vec2;
-    polygonID: number;
-}
-export default class TriangleDictionary<T> {
-    /** Resolution of data segmentation. */
-    resolution: number;
-    /** Map with collection of triangle IDs. */
-    tiles: Map<string, number[]>;
-    /** Triangle IDs to polygon. */
-    triangles: Triangle[];
-    /** Mapping polygon IDs to values. */
-    polygonValues: T[];
-    constructor(decimals?: number);
-    add(vertices: vec2[], triangles: number[], value: T): void;
-    getPolygonAt(target: vec2): T;
-}
-export {};

package/dist/utils/WellboreMesh.d.ts

@@ -1,51 +0,0 @@
-import { SegmentPoint, LineInterpolator } from './LineInterpolator';
-import { TickConfig } from './wellbores/Config';
-interface meshData {
-    vertices: number[];
-    triangles: number[];
-    vertexData: number[];
-    extraData: number[];
-}
-export declare class WellboreMesh {
-    /** Line interpolator used to construct mesh. */
-    interp: LineInterpolator;
-    /** Thickness of line. */
-    thickness: number;
-    /** Index of latest vertex, i.e. base for triangulation of new geometry. */
-    baseTris: number;
-    /** Width and height of tick. */
-    tick: TickConfig;
-    /**
-     * Constructor for creating a new line interpolator.
-     * @param interp Interpolator used to generate line
-     */
-    constructor(interp: LineInterpolator, thickness: number, tick: TickConfig);
-    /**
-     * Generate mesh. Interval positioning should be relative.
-     * @param intervals Collection of intervals on the format: [ [Start0, End0], ..., [StartN, EndN] ]
-     */
-    generate(intervals?: [number, number][]): meshData;
-    /**
-     * Append line segment from a section of points.
-     * @param section Collection of segment points
-     * @param type Type of segment, applied as vertex color
-     * @param vertices 1-dimensional array with vertices
-     * @param triangles 1-dimensional array with triangulation
-     * @param vertexData 1-dimensional array with vertex data
-     * @param extraData 1-dimensional array with type-data
-     * @private
-     */
-    appendSegment(section: SegmentPoint[], type: number, vertices: number[], triangles: number[], vertexData: number[], extraData: number[]): void;
-    /**
-     * Creates a tick at the given position.
-     * @param p Position of tick
-     * @param baseTris Base triangle index
-     * @param vertices 1-dimensional array with vertices
-     * @param triangles 1-dimensional array with triangulation
-     * @param vertexData 1-dimensional array with vertex data
-     * @param extraData 1-dimensional array with type-data
-     * @private
-     */
-    private generateCrossline;
-}
-export {};

package/dist/utils/centerOfMass.d.ts

@@ -1,8 +0,0 @@
-import Vector2 from '@equinor/videx-vector2';
-/**
- * Get the center of mass of a polygon.
- * @param vertices Vertices of polygon
- * @param triangles Triangles of polygon
- * @returns Center of mass and mass of polygon
- */
-export default function centerOfMass(vertices: Vector2[], triangles: number[]): [Vector2, number];

package/dist/utils/fields/Highlighter.d.ts

@@ -1,33 +0,0 @@
-import { FieldMesh } from '../../FieldModule';
-type vec3 = [number, number, number];
-interface Cache {
-    fillCol1: vec3;
-    fillCol2: vec3;
-    outlineCol: vec3;
-    baseZIndex: number;
-    field: FieldMesh;
-}
-/**
- * Highlighter class for field layer.
- */
-export default class Hightlighter {
-    fields: FieldMesh[][];
-    cached: Cache[];
-    fillColor1: vec3;
-    fillColor2: vec3;
-    outlineColor: vec3;
-    constructor(fillColor1: vec3, fillColor2: vec3, outlineColor: vec3);
-    /**
-     * Add a new group to highlighter.
-     * @param group Group of field meshes
-     */
-    add(group: FieldMesh[]): void;
-    /**
-     * Highlight a group by given index.
-     * @param index Index of group to highlight
-     */
-    highlight(index: number): void;
-    /** Revert any highlighting. */
-    revert(): boolean;
-}
-export {};

package/dist/utils/fields/LabelManager.d.ts

@@ -1,62 +0,0 @@
-import * as PIXI from 'pixi.js';
-import Vector2 from '@equinor/videx-vector2';
-/** Data for label. */
-export type LabelData = {
-    position: Vector2;
-    mass: number;
-};
-/** Field with connected labels. */
-interface Field {
-    name: string;
-    position: Vector2;
-    instance?: PIXI.Text;
-}
-/** Instance of a multi-label entry. */
-export type Label = {
-    position: Vector2;
-    mass: number;
-    instance: PIXI.Text;
-    active: boolean;
-};
-export interface MultiField {
-    name: string;
-    labels: Label[];
-    width: number;
-    height: number;
-}
-/** Class used to manage field labels. Handles scaling and grouping of labels. */
-export default class LabelManager {
-    /** The textstyle used for labels. */
-    textStyle: PIXI.TextStyle;
-    /** Scale of labels when size is set to 1. */
-    baseScale: number;
-    /** Collection of single-polygon fields. */
-    fields: Field[];
-    /** Collectionh of multi-polygon fields. Labels are grouped when scaling. */
-    multiFields: MultiField[];
-    /** Value of previous scale */
-    prevScale: number;
-    /** Visibility of labels */
-    visible: boolean;
-    /** construct a new label manager. */
-    constructor(textStyle: PIXI.TextStyle, baseScale: number);
-    /**
-     * Add a new field to manage.
-     * @param name Name of field
-     * @param entries Data for each label
-     */
-    addField(name: string, entries: LabelData[]): void;
-    /**
-     * Draw all labels assigned to manager.
-     * @param root Target root for labels
-     */
-    draw(root: PIXI.Container): void;
-    /**
-     * Resize all labels.
-     * @param scale New scale for labels
-     */
-    resize(scale: number): void;
-    hideLabels(): void;
-    showLabels(): void;
-}
-export {};

package/dist/utils/fields/groupLabels.d.ts

@@ -1,5 +0,0 @@
-import { MultiField } from './LabelManager';
-/**
- * Function for grouping labels.
- */
-export default function groupLabels(field: MultiField, scale: number): [number, number][];

package/dist/utils/fields/preprocessFields.d.ts

@@ -1,29 +0,0 @@
-import { Field } from '../../FieldModule';
-/** Interface for data within a processed field. */
-export interface PreprocessedField {
-    type: string;
-    geometry: [
-        {
-            coordinates: [number, number][];
-            properties: {
-                discname: string;
-                hctype: string;
-                polygonId: number;
-                status: string;
-            };
-        }
-    ];
-    properties: {
-        group: number;
-        guid?: number;
-        label: string;
-        lat: number;
-        long: number;
-    };
-}
-/**
- * Preprocess field data to a more managable format.
- * @param data Data to process
- * @returns Processed data
- */
-export default function preprocessFields(data: Field[]): PreprocessedField[];

package/dist/utils/generateCircle.d.ts

@@ -1,10 +0,0 @@
-import Vector2 from '@equinor/videx-vector2';
-import * as PIXI from 'pixi.js';
-/**
- *
- * @param center
- * @param radius
- * @param uniformRadius Fraction of full radius used by uniform initially
- * @return New circle mesh with shader uniforms attached
- */
-export default function generateCircle(center: Vector2, radius: number, shader: any): PIXI.Mesh;

package/dist/utils/linePoint.d.ts

@@ -1,27 +0,0 @@
-import Vector2 from '@equinor/videx-vector2';
-import { VectorLike } from '@equinor/videx-linear-algebra';
-/**
- * Find the position along a line segment closest to a given point.
- * @param point Reference point
- * @param lineStart Start of line segment
- * @param lineEnd End of line segment
- * @returns Closest point on line
- */
-export declare function closestPointOnLine(point: Vector2, lineStart: Vector2, lineEnd: Vector2): Vector2;
-/**
- * Find the shortest distance from a point to a line segment.
- * @param point Reference point
- * @param lineStart Start of line segment
- * @param lineEnd End of line segment
- * @returns Distance to line
- */
-export declare function distanceToLine(point: Vector2, lineStart: Vector2, lineEnd: Vector2): number;
-/**
- * Get the relative displacement of the point in respect to lineStart.
- * X-component contains displacement along line.
- * Y component contains displacement perpendicular to line.
- * @param point Reference point
- * @param lineStart Start of line segment
- * @param lineEnd End of line segment
- */
-export declare function displacementToLineOrigin(point: VectorLike, lineStart: VectorLike, lineEnd: VectorLike): Vector2;

package/dist/utils/lineReducer.d.ts

@@ -1,9 +0,0 @@
-import { VectorLike } from '@equinor/videx-linear-algebra';
-/**
- * Reduce complexity of a line by removing points with little information.
- * @param points Collection of points to reduce
- * @param maxDeviation Max deviation of a single point
- * @param distanceWeight Scale allowed deviatin by distance from last point
- * @returns Reduced line
- */
-export declare function reduce<T extends VectorLike>(points: T[], maxDeviation: number, distanceWeight: number): T[];

package/dist/utils/wellbores/AsyncLoop.d.ts

@@ -1,35 +0,0 @@
-/// <reference types="node" />
-interface Config {
-    /** Total number of iterations. */
-    iterations: number;
-    /** Size of each individual batch. */
-    batchSize: number;
-    /** Function to call for each iteration. */
-    func: (i: number) => void;
-    /** Function to call after each batch. */
-    postFunc?: () => void;
-    /** Function to call after finishing loop. */
-    endFunc?: () => void;
-}
-/** Class for running non-blocking for loops. */
-export default class AsyncLoop {
-    /** Dictionary with intervals */
-    timers: {
-        [key: string]: NodeJS.Timeout;
-    };
-    /**
-     * Start a new asynchronous loop.
-     * @param key Key of loop
-     * @param config Configurations for asynchronous loop.
-     * @param interval Configurations interval between batches
-     */
-    Start(key: string, config: Config, interval?: number): void;
-    /**
-     * Stop a single loop
-     * @param key Key of loop
-     */
-    Stop(key: string): void;
-    /** Stop all ongoing loops */
-    StopAll(): void;
-}
-export {};

package/dist/utils/wellbores/Colors.d.ts

@@ -1,40 +0,0 @@
-type vec3 = [number, number, number];
-export interface Color {
-    col1: vec3;
-    col2: vec3;
-    labelBg: number;
-}
-export interface Colors {
-    fontColor: number;
-    interactFontColor: number;
-    default: Color;
-    highlight: Color;
-    multiHighlight: Color;
-    selected: Color;
-}
-/** Enum for selecting color. [ Default, Highlight, MultiHighlight, Selected ] */
-export declare enum ColorType {
-    Default = 0,
-    Highlight = 1,
-    MultiHighlight = 2,
-    Selected = 3
-}
-export interface InputColors {
-    fontColor?: number;
-    interactFontColor?: number;
-    defaultColor1?: vec3;
-    defaultColor2?: vec3;
-    defaultLabelBg?: number;
-    highlightColor1?: vec3;
-    highlightColor2?: vec3;
-    highlightLabelBg?: number;
-    multiHighlightColor1?: vec3;
-    multiHighlightColor2?: vec3;
-    multiHighlightLabelBg?: number;
-    selectedColor1?: vec3;
-    selectedColor2?: vec3;
-    selectedLabelBg?: number;
-}
-/** Get default configuration for wellbores. */
-export declare function getDefaultColors(input?: InputColors): Colors;
-export {};

package/dist/utils/wellbores/Config.d.ts

@@ -1,80 +0,0 @@
-import { WellboreEventData } from './data';
-import { HighlightEvent } from './data/WellboreEventData';
-import { EventHandler } from '../../EventHandler';
-import { ResizeConfig } from '../../ResizeConfigInterface';
-export interface TickConfig {
-    width: number;
-    height: number;
-}
-/** Interface for wellbore config. */
-export interface Config {
-    /** Relative scale of all components (Default: 1.0). */
-    scale: number;
-    /** Amount of wellbores per batch. (Default: 20) */
-    batchSize: number;
-    /** Origin zoom level, i.e. where input for scaling function is 0. (Default: 0) */
-    zoomOrigin: number;
-    /** Grid size to control resolution of spacial indexing. */
-    gridSize: number;
-    /** Resize configurations of wellbores. */
-    wellboreResize: ResizeConfig;
-    /** Resize configurations of roots. */
-    rootResize: ResizeConfig;
-    /** Settings for ticks along wellbore lines, these do not scale. */
-    tick: TickConfig;
-    /** Function to be called when a wellbore is selected. */
-    onWellboreClick?: (wellbore: WellboreEventData) => void;
-    /** Function to be called when wellbores are highlighted. */
-    onHighlightOn?: (event: HighlightEvent) => void;
-    /** Function to be called when highlight is removed. */
-    onHighlightOff?: () => void;
-}
-/** Data from 'InputConfig' not included in 'Config'. */
-export interface ExtraConfig {
-    /** Opacity of label background. (Default: 0.5) */
-    labelBgOpacity: number;
-    /** Scale of labels. (Default: 0.011) */
-    labelScale: number;
-    /** Size of font. (Default: 24) */
-    fontSize: number;
-    /** Zoom event handler. */
-    scaling: (zoom: number) => number;
-    /** Size of wellbore dash. (Default: 0.01) */
-    wellboreDash: number;
-}
-export interface InputConfig {
-    /** Relative scale of all components. (Default: 1.0) */
-    scale?: number;
-    /** Scale of labels. (Default: 0.011) */
-    labelScale?: number;
-    /** Opacity of label background. (Default: 0.5) */
-    labelBgOpacity?: number;
-    /** Size of font. (Default: 24) */
-    fontSize?: number;
-    /** Amount of wellbores per batch. (Default: 25) */
-    batchSize?: number;
-    /** Origin zoom level, i.e. where input for scaling function is 0. (Default: 0) */
-    zoomOrigin?: number;
-    /** Size of wellbore dash. (Default: 0.01) */
-    wellboreDash?: number;
-    /** Provide your custom event handler. */
-    customEventHandler?: EventHandler;
-    /** Zoom event handler. */
-    scaling?: (zoom: number) => number;
-    /** Grid size to control resolution of spatial indexing. */
-    gridSize?: number;
-    /** Resize configurations of wellbores. */
-    wellboreResize: ResizeConfig;
-    /** Resize configurations of roots. */
-    rootResize?: ResizeConfig;
-    /** Settings for ticks along wellbore lines, these do not scale. */
-    tick?: TickConfig;
-    /** Function to be called when a wellbore is selected. */
-    onWellboreClick?: (selected: WellboreEventData) => void;
-    /** Function to be called when wellbores are highlighted. */
-    onHighlightOn?: (event: HighlightEvent) => void;
-    /** Function to be called when highlight is removed. */
-    onHighlightOff?: () => void;
-}
-/** Get default configuration for wellbores. */
-export declare function getDefaultConfig(input?: InputConfig): [Config, ExtraConfig];

package/dist/utils/wellbores/DataManager.d.ts

@@ -1,15 +0,0 @@
-import { SourceData, WellboreData, RootData, Group } from './data';
-export default abstract class DataManager {
-    wellbores: {
-        [key: number]: WellboreData;
-    };
-    roots: {
-        [key: number]: RootData;
-    };
-    /** Map group keys ('Drilled', 'Planned', etc.) to keys in wellbores dictionary. */
-    groups: {
-        [key: string]: Group;
-    };
-    addWellbore(_key: number, _data: SourceData): void;
-    removeWellbore(_key: number): void;
-}