@equinor/videx-map 1.14.3 → 1.14.4

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

package/dist/utils/TriangleDictionary.d.ts

@@ -1,21 +1,21 @@
-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 {};
+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 +1,51 @@
-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 {};
+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 +1,8 @@
-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];
+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 +1,33 @@
-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 {};
+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 +1,62 @@
-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 {};
+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 +1,5 @@
-import { MultiField } from './LabelManager';
-/**
- * Function for grouping labels.
- */
-export default function groupLabels(field: MultiField, scale: number): [number, number][];
+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 +1,29 @@
-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[];
+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 +1,10 @@
-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;
+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;