@equinor/videx-map 1.14.14 → 2.0.0

package/dist/ExplorationLayer.d.ts

@@ -1,4 +1,4 @@
-import * as PIXI from 'pixi.js';
+import { Mesh, Geometry, Shader } from 'pixi.js';
 import { ModuleInterface } from './ModuleInterface';
 import { RootUniforms } from './utils/wellbores/Shader';
 import PointDictionary from './utils/PointDictionary';
@@ -6,7 +6,7 @@ import PointDictionary from './utils/PointDictionary';
  * Data assigned each point in point dictionary.
  */
 interface PointData {
-    mesh: PIXI.Mesh;
+    mesh: Mesh<Geometry, Shader>;
     uniforms: RootUniforms;
 }
 interface selection {

package/dist/FaultlineModule.d.ts

@@ -1,4 +1,4 @@
-import * as PIXI from 'pixi.js';
+import { Graphics } from 'pixi.js';
 import { ModuleInterface } from './ModuleInterface';
 /** Data format on incoming faultlines */
 interface FaultlineData {
@@ -32,9 +32,9 @@ interface Config {
 /** Module for displaying faultlines. */
 export default class FaultlineModule extends ModuleInterface {
     /** Graphic elements currently existing in world space. */
-    spawned: PIXI.Graphics[];
+    spawned: Graphics[];
     /** Pool of initialized graphic elements. */
-    pool: PIXI.Graphics[];
+    pool: Graphics[];
     /** Default config. */
     config: Config;
     constructor(config?: InputConfig);

package/dist/FieldModule.d.ts

@@ -1,22 +1,46 @@
-import * as PIXI from 'pixi.js';
+import { Geometry, Mesh, Shader } from 'pixi.js';
 import Vector2 from '@equinor/videx-vector2';
 import { ModuleInterface } from './ModuleInterface';
-import { MeshData, MeshNormalData } from './utils/Mesh';
+import { MeshData, MeshNormalData } from './utils/LineMesh';
 import Highlighter from './utils/fields/Highlighter';
 import LabelManager from './utils/fields/LabelManager';
 import TriangleDictionary from './utils/TriangleDictionary';
 type vec3 = [number, number, number];
 interface FillUniform {
-    col1: vec3;
-    col2: vec3;
-    opacity: number;
-    hashed: boolean;
-    hashDisp: number;
-    hashWidth: number;
+    col1: {
+        value: vec3;
+        type: string;
+    };
+    col2: {
+        value: vec3;
+        type: string;
+    };
+    opacity: {
+        value: number;
+        type: string;
+    };
+    hashed: {
+        value: number;
+        type: string;
+    };
+    hashDisp: {
+        value: number;
+        type: string;
+    };
+    hashWidth: {
+        value: number;
+        type: string;
+    };
 }
 interface OutlineUniform {
-    color: vec3;
-    width: number;
+    color: {
+        value: vec3;
+        type: string;
+    };
+    outlineWidth: {
+        value: number;
+        type: string;
+    };
 }
 /** Collection of data describing colors used for fill. */
 interface FieldStyle {
@@ -24,7 +48,7 @@ interface FieldStyle {
     fillColor2: vec3;
     fillOpacity: number;
     outlineColor: vec3;
-    hashed: boolean;
+    hashed: number;
 }
 export interface Field {
     type: string;
@@ -51,11 +75,11 @@ export interface Field {
 }
 export interface FieldMesh {
     fill: {
-        mesh: PIXI.Mesh;
+        mesh: Mesh<Geometry, Shader>;
         uniform: FillUniform;
     };
     outline: {
-        mesh: PIXI.Mesh;
+        mesh: Mesh<Geometry, Shader>;
         uniform: OutlineUniform;
     };
 }

package/dist/GeoJSONModule/GeoJSONModule.d.ts

@@ -1,4 +1,5 @@
-import * as PIXI from 'pixi.js';
+import { Container } from 'pixi.js';
+import * as L from 'leaflet';
 import Vector2 from '@equinor/videx-vector2';
 import { ModuleInterface } from '../ModuleInterface';
 import { EventHandler } from '../EventHandler';
@@ -24,7 +25,7 @@ export default class GeoJSONModule extends ModuleInterface {
     multipolygons: GeoJSONMultiPolygon;
     _eventHandler: EventHandler;
     mapmoving: boolean;
-    labelRoot: PIXI.Container;
+    labelRoot: Container;
     config?: Config;
     constructor(config?: Config);
     set(data: GeoJSON.FeatureCollection, props?: (feature: any) => FeatureProps): void;
@@ -35,8 +36,8 @@ export default class GeoJSONModule extends ModuleInterface {
    * @returns List of features at the given position
    */
     testPosition(pos: Vector2): any;
-    onAdd(map: import('leaflet').Map): void;
-    onRemove(_map: import('leaflet').Map): void;
+    onAdd(map: L.Map): void;
+    onRemove(_map: L.Map): void;
     resize(zoom: number): void;
     private handleMouseMove;
     private handleMouseOut;

package/dist/GeoJSONModule/labels.d.ts

@@ -1,4 +1,4 @@
-import * as PIXI from 'pixi.js';
+import { Container, BitmapFont, BitmapText, TextStyle } from 'pixi.js';
 import Vector2 from '@equinor/videx-vector2';
 /** Data for label. */
 export type GeoJSONLabelData = {
@@ -8,16 +8,16 @@ export type GeoJSONLabelData = {
 interface Label {
     name: string;
     position: Vector2;
-    instance?: PIXI.BitmapText;
+    instance?: BitmapText;
 }
 /** Class used to manage field labels. Handles scaling and grouping of labels. */
 export default class GeoJSONLabels {
     /**PIXI container  to hold all labels*/
-    container: PIXI.Container;
+    container: Container;
     /** The textstyle used for labels. */
-    textStyle: PIXI.TextStyle;
+    textStyle: TextStyle;
     /** The font used for labels. */
-    font: PIXI.BitmapFont;
+    font: BitmapFont;
     /** font name */
     fontName: string;
     /** Scale of labels when size is set to 1. */
@@ -27,7 +27,7 @@ export default class GeoJSONLabels {
     /** Visibility */
     visible: boolean;
     /** construct a new label container. */
-    constructor(root: PIXI.Container, textStyle: PIXI.TextStyle, baseScale: number, fontName?: string);
+    constructor(root: Container, textStyle: TextStyle, baseScale: number, fontName?: string);
     /**
      * Add a new label.
      * @param name label name

package/dist/GeoJSONModule/linestring.d.ts

@@ -1,18 +1,24 @@
-import * as PIXI from 'pixi.js';
+import { Container, Geometry, Mesh, Shader, TextStyle } from 'pixi.js';
 import Vector2 from '@equinor/videx-vector2';
 import { pixiOverlayBase } from '../pixiOverlayInterfaces';
-import { MeshNormalData } from '../utils/Mesh';
+import { MeshNormalData } from '../utils/LineMesh';
 import LineDictionary from '../utils/LineDictionary';
 import { FeatureProps, FeatureStyle } from '.';
 import { ResizeConfig } from '../ResizeConfigInterface';
 type vec3 = [number, number, number];
 interface OutlineUniform {
-    color: vec3;
-    width: number;
+    color: {
+        value: vec3;
+        type: string;
+    };
+    width: {
+        value: number;
+        type: string;
+    };
 }
 export interface FeatureMesh {
     outline: {
-        mesh: PIXI.Mesh;
+        mesh: Mesh<Geometry, Shader>;
         uniform: OutlineUniform;
     };
 }
@@ -30,18 +36,18 @@ export default class GeoJSONLineString {
     features: FeatureMesh[];
     /** Settings for how to render fields. */
     config: Config;
-    container: PIXI.Container;
+    container: Container;
     pixiOverlay: pixiOverlayBase;
     dict: LineDictionary<any>;
-    textStyle: PIXI.TextStyle;
+    textStyle: TextStyle;
     currentZoom: number;
-    constructor(root: PIXI.Container, pixiOverlay: pixiOverlayBase, config?: Config);
+    constructor(root: Container, pixiOverlay: pixiOverlayBase, config?: Config);
     add(feature: GeoJSON.Feature, props: (feature: object) => FeatureProps): void;
     /**
      * Draw each polygon in a polygon collection.
      * @param polygons
      */
-    drawPolygons(container: PIXI.Container, outlineData: MeshNormalData, featureStyle: FeatureStyle, zIndex: number): FeatureMesh;
+    drawPolygons(container: Container, outlineData: MeshNormalData, featureStyle: FeatureStyle, zIndex: number): FeatureMesh;
     /**
      * Project a collection of polygons.
      * @param points Points within polygons

package/dist/GeoJSONModule/multipolygon.d.ts

@@ -1,31 +1,55 @@
-import * as PIXI from 'pixi.js';
+import { Container, Geometry, Mesh, Shader, TextStyle } from 'pixi.js';
 import Vector2 from '@equinor/videx-vector2';
 import { pixiOverlayBase } from '../pixiOverlayInterfaces';
-import { MeshData, MeshNormalData } from '../utils/Mesh';
+import { MeshData, MeshNormalData } from '../utils/LineMesh';
 import GeoJSONLabels from './labels';
 import TriangleDictionary from '../utils/TriangleDictionary';
 import { FeatureProps, FeatureStyle } from '.';
 import { ResizeConfig, LabelResizeConfig } from '../ResizeConfigInterface';
 type vec3 = [number, number, number];
 interface FillUniform {
-    col1: vec3;
-    col2: vec3;
-    opacity: number;
-    hashed: boolean;
-    hashDisp: number;
-    hashWidth: number;
+    col1: {
+        value: vec3;
+        type: string;
+    };
+    col2: {
+        value: vec3;
+        type: string;
+    };
+    opacity: {
+        value: number;
+        type: string;
+    };
+    hashed: {
+        value: boolean;
+        type: string;
+    };
+    hashDisp: {
+        value: number;
+        type: string;
+    };
+    hashWidth: {
+        value: number;
+        type: string;
+    };
 }
 interface OutlineUniform {
-    color: vec3;
-    outlineWidth: number;
+    color: {
+        value: vec3;
+        type: string;
+    };
+    outlineWidth: {
+        value: number;
+        type: string;
+    };
 }
 export interface FeatureMesh {
     fill: {
-        mesh: PIXI.Mesh;
+        mesh: Mesh<Geometry, Shader>;
         uniform: FillUniform;
     };
     outline: {
-        mesh: PIXI.Mesh;
+        mesh: Mesh<Geometry, Shader>;
         uniform: OutlineUniform;
     };
 }
@@ -66,19 +90,19 @@ export default class GeoJSONMultiPolygon {
     features: FeatureMesh[];
     /** Settings for how to render data. */
     config: Config;
-    container: PIXI.Container;
+    container: Container;
     pixiOverlay: pixiOverlayBase;
     dict: TriangleDictionary<any>;
-    textStyle: PIXI.TextStyle;
+    textStyle: TextStyle;
     labels: GeoJSONLabels;
     currentZoom: number;
-    constructor(root: PIXI.Container, labelRoot: PIXI.Container, pixiOverlay: pixiOverlayBase, config?: Config);
+    constructor(root: Container, labelRoot: Container, pixiOverlay: pixiOverlayBase, config?: Config);
     add(feature: GeoJSON.Feature, props: (feature: object) => FeatureProps): void;
     /**
      * Draw each polygon in a polygon collection.
      * @param polygons
      */
-    drawPolygons(container: PIXI.Container, meshData: MeshData, outlineData: MeshNormalData, featureStyle: FeatureStyle, zIndex: number): FeatureMesh;
+    drawPolygons(container: Container, meshData: MeshData, outlineData: MeshNormalData, featureStyle: FeatureStyle, zIndex: number): FeatureMesh;
     drawLabels(): void;
     /**
      * Project a collection of polygons.

package/dist/GeoJSONModule/point.d.ts

@@ -1,4 +1,4 @@
-import * as PIXI from 'pixi.js';
+import { Container, Graphics, TextStyle } from 'pixi.js';
 import Vector2 from '@equinor/videx-vector2';
 import { pixiOverlayBase } from '../pixiOverlayInterfaces';
 import PointDictionary from '../utils/PointDictionary';
@@ -6,14 +6,14 @@ import { FeatureProps } from '.';
 /** Module for displaying fields. */
 export default class GeoJSONPoint {
     /** Graphic elements currently existing in world space. */
-    spawned: PIXI.Graphics[];
+    spawned: Graphics[];
     /** Pool of initialized graphic elements. */
-    pool: PIXI.Graphics[];
-    container: PIXI.Container;
+    pool: Graphics[];
+    container: Container;
     pixiOverlay: pixiOverlayBase;
     dict: PointDictionary<any>;
-    textStyle: PIXI.TextStyle;
-    constructor(root: PIXI.Container, pixiOverlay: pixiOverlayBase);
+    textStyle: TextStyle;
+    constructor(root: Container, pixiOverlay: pixiOverlayBase);
     add(feature: GeoJSON.Feature, props: (feature: object) => FeatureProps): void;
     /**
       * Project a point coordinate.

package/dist/GeoJSONModule/polygon.d.ts

@@ -1,31 +1,55 @@
-import * as PIXI from 'pixi.js';
+import { Container, Mesh, Geometry, Shader, TextStyle } from 'pixi.js';
 import Vector2 from '@equinor/videx-vector2';
 import { pixiOverlayBase } from '../pixiOverlayInterfaces';
-import { MeshData, MeshNormalData } from '../utils/Mesh';
+import { MeshData, MeshNormalData } from '../utils/LineMesh';
 import GeoJSONLabels from './labels';
 import TriangleDictionary from '../utils/TriangleDictionary';
 import { FeatureProps, FeatureStyle } from '.';
 import { ResizeConfig, LabelResizeConfig } from '../ResizeConfigInterface';
 type vec3 = [number, number, number];
 interface FillUniform {
-    col1: vec3;
-    col2: vec3;
-    opacity: number;
-    hashed: boolean;
-    hashDisp: number;
-    hashWidth: number;
+    col1: {
+        value: vec3;
+        type: string;
+    };
+    col2: {
+        value: vec3;
+        type: string;
+    };
+    opacity: {
+        value: number;
+        type: string;
+    };
+    hashed: {
+        value: number;
+        type: string;
+    };
+    hashDisp: {
+        value: number;
+        type: string;
+    };
+    hashWidth: {
+        value: number;
+        type: string;
+    };
 }
 interface OutlineUniform {
-    color: vec3;
-    outlineWidth: number;
+    color: {
+        value: vec3;
+        type: string;
+    };
+    outlineWidth: {
+        value: number;
+        type: string;
+    };
 }
 export interface FeatureMesh {
     fill: {
-        mesh: PIXI.Mesh;
+        mesh: Mesh<Geometry, Shader>;
         uniform: FillUniform;
     };
     outline: {
-        mesh: PIXI.Mesh;
+        mesh: Mesh<Geometry, Shader>;
         uniform: OutlineUniform;
     };
 }
@@ -66,21 +90,21 @@ export default class GeoJSONPolygon {
     features: FeatureMesh[];
     /** Settings for how to render data. */
     config: Config;
-    container: PIXI.Container;
+    container: Container;
     pixiOverlay: pixiOverlayBase;
     dict: TriangleDictionary<any>;
-    textStyle: PIXI.TextStyle;
+    textStyle: TextStyle;
     labels: GeoJSONLabels;
     currentZoom: number;
     outlineThickness: number;
     zIndex: number;
-    constructor(root: PIXI.Container, labelRoot: PIXI.Container, pixiOverlay: pixiOverlayBase, config?: Config);
+    constructor(root: Container, labelRoot: Container, pixiOverlay: pixiOverlayBase, config?: Config);
     add(feature: GeoJSON.Feature, props: (feature: object) => FeatureProps): void;
     /**
      * Draw each polygon in a polygon collection.
      * @param polygons
      */
-    drawPolygons(container: PIXI.Container, meshData: MeshData, outlineData: MeshNormalData, featureStyle: FeatureStyle, zIndex: number): FeatureMesh;
+    drawPolygons(container: Container, meshData: MeshData, outlineData: MeshNormalData, featureStyle: FeatureStyle, zIndex: number): FeatureMesh;
     drawLabels(): void;
     /**
      * Project a collection of polygons.

package/dist/GeoJSONModule/shader.d.ts

@@ -1,10 +1,10 @@
 /**
  * Shared shaders for polygon and multipolygon
  */
-export declare const GeoJSONVertexShaderFill = "\n  attribute vec2 inputVerts;\n\n  uniform mat3 translationMatrix;\n  uniform mat3 projectionMatrix;\n\n  varying vec2 verts;\n\n  void main() {\n    verts = inputVerts;\n    gl_Position = vec4((projectionMatrix * translationMatrix * vec3(inputVerts, 1.0)).xy, 0.0, 1.0);\n  }\n  ";
-export declare const GeoJSONFragmentShaderFill = "\n  precision mediump float;\n\n  varying vec2 verts;\n\n  uniform vec3 col1;\n  uniform vec3 col2;\n  uniform float opacity;\n\n  uniform bool hashed;\n  uniform float hashDisp;\n  uniform float hashWidth;\n\n  void main() {\n    if(hashed && mod(verts.y + hashDisp, hashWidth * 2.0) > hashWidth) {\n      gl_FragColor = vec4(col2 / 255., 1.0) * opacity;\n    }\n    else {\n      gl_FragColor = vec4(col1 / 255., 1.0) * opacity;\n    }\n  }\n  ";
+export declare const GeoJSONVertexShaderFill = "\n  in vec2 inputVerts;\n\n  uniform mat3 uWorldTransformMatrix;\n  uniform mat3 uProjectionMatrix;\n\n  out vec2 verts;\n\n  void main() {\n    verts = inputVerts;\n    gl_Position = vec4((uProjectionMatrix * uWorldTransformMatrix * vec3(inputVerts, 1.0)).xy, 0.0, 1.0);\n  }\n  ";
+export declare const GeoJSONFragmentShaderFill = "\n  precision mediump float;\n\n  in vec2 verts;\n\n  uniform vec3 col1;\n  uniform vec3 col2;\n  uniform float opacity;\n  uniform float hashDisp;\n  uniform float hashWidth;\n\n  void main() {\n    if(mod(verts.y + hashDisp, hashWidth * 2.0) > hashWidth) {\n      gl_FragColor = vec4(col2 / 255., 1.0) * opacity;\n    }\n    else {\n      gl_FragColor = vec4(col1 / 255., 1.0) * opacity;\n    }\n  }\n  ";
 /**
  * Shared shaders for polygon, multipolygon and linestring
  */
-export declare const GeoJSONVertexShaderOutline = "\n  attribute vec2 inputVerts;\n  attribute vec2 inputNormals;\n\n  uniform mat3 translationMatrix;\n  uniform mat3 projectionMatrix;\n\n  uniform float outlineWidth;\n\n  void main() {\n    vec2 pos = inputVerts + inputNormals * outlineWidth;\n    gl_Position = vec4((projectionMatrix * translationMatrix * vec3(pos, 1.0)).xy, 0.0, 1.0);\n  }\n  ";
+export declare const GeoJSONVertexShaderOutline = "\n  in vec2 inputVerts;\n  in vec2 inputNormals;\n\n  uniform mat3 uWorldTransformMatrix;\n  uniform mat3 uProjectionMatrix;\n\n  uniform float outlineWidth;\n\n  void main() {\n    vec2 pos = inputVerts + inputNormals * outlineWidth;\n    gl_Position = vec4((uProjectionMatrix * uWorldTransformMatrix * vec3(pos, 1.0)).xy, 0.0, 1.0);\n  }\n  ";
 export declare const GeoJSONFragmentShaderOutline = "\n  precision mediump float;\n\n  uniform vec3 color;\n\n  void main() {\n    gl_FragColor = vec4(color / 255., 1.0);\n  }\n  ";

package/dist/ModuleInterface.d.ts

@@ -1,11 +1,11 @@
 import { pixiOverlayBase } from './pixiOverlayInterfaces';
-import * as PIXI from 'pixi.js';
+import { Container } from 'pixi.js';
 /** Class with common functions shared by all layers. */
 export declare abstract class ModuleInterface {
     /** Function for pixi overlay. */
     pixiOverlay: pixiOverlayBase;
     /** Root container for layer. */
-    root: PIXI.Container;
+    root: Container;
     /** True if layer is currently visible. */
     visibility: boolean;
     /** Common constructor for all map layers. */

package/dist/OutlineModule.d.ts

@@ -1,4 +1,4 @@
-import * as PIXI from 'pixi.js';
+import { Geometry, Shader, Mesh } from 'pixi.js';
 import { ModuleInterface } from './ModuleInterface';
 export interface OutlineData {
     coordinates: [number, number][][];
@@ -51,7 +51,7 @@ export default class OutlineModule extends ModuleInterface {
         [key: string]: Uniforms;
     };
     /** Graphic elements currently existing in world space. */
-    spawned: PIXI.Mesh[];
+    spawned: Mesh<Geometry, Shader>[];
     /** Vertex shader for the outlines. */
     static vertexShader: string;
     /** Fragment shader for the outlines. */

package/dist/WellboreModule.d.ts

@@ -1,4 +1,5 @@
-import * as PIXI from 'pixi.js';
+import { Container, Graphics } from 'pixi.js';
+import * as L from 'leaflet';
 import { ModuleInterface } from './ModuleInterface';
 import { Config, InputConfig } from './utils/wellbores/Config';
 import { SourceData, Group, GroupOptions, DetailOptions, WellboreData, RootData } from './utils/wellbores/data';
@@ -25,13 +26,13 @@ export default class WellboreModule extends ModuleInterface {
     private _eventHandler;
     private _redrawAnimFrame;
     containers: {
-        wellbores: PIXI.Container;
-        roots: PIXI.Container;
-        labels: PIXI.Container;
+        wellbores: Container;
+        roots: Container;
+        labels: Container;
     };
     /** Zoom event handler. */
     scaling: (zoom: number) => number;
-    marker: PIXI.Graphics;
+    marker: Graphics;
     constructor(inputConfig?: InputConfig);
     destroy(): void;
     registerGroup(key: string, options?: GroupOptions): void;
@@ -108,8 +109,8 @@ export default class WellboreModule extends ModuleInterface {
      */
     clear(...keys: string[]): void;
     resize(zoom: number): void;
-    onAdd(map: import('leaflet').Map): void;
-    onRemove(_map: import('leaflet').Map): void;
+    onAdd(map: L.Map): void;
+    onRemove(_map: L.Map): void;
     get projector(): Projector;
     /**
      * Calculate root radius based on formula used in Shader.ts!