@equinor/esv-intersection 2.2.0 → 3.0.0-beta.1

package/dist/components/axis.d.ts

@@ -19,7 +19,7 @@ export declare class Axis {
     private _flipX;
     private _flipY;
     private visible;
-    constructor(mainGroup: Selection<SVGElement, any, null, undefined>, showLabels: boolean, labelXDesc: string, labelYDesc: string, unitOfMeasure: string, options?: Options);
+    constructor(mainGroup: Selection<SVGElement, unknown, null, undefined>, showLabels: boolean, labelXDesc: string, labelYDesc: string, unitOfMeasure: string, options?: Options);
     private renderLabelx;
     private renderLabely;
     private renderGy;

package/dist/constants.d.ts

@@ -2,7 +2,10 @@ export declare const DEFAULT_LAYER_WIDTH = 200;
 export declare const DEFAULT_LAYER_HEIGHT = 300;
 export declare const HORIZONTAL_AXIS_MARGIN = 40;
 export declare const VERTICAL_AXIS_MARGIN = 30;
-export declare const HOLE_OUTLINE = 1;
-export declare const SHOE_WIDTH = 25;
-export declare const SHOE_LENGTH = 12;
+export declare const EXAGGERATED_DIAMETER = 100;
+export declare const HOLE_OUTLINE = 0.6;
+export declare const SCREEN_OUTLINE = 0.3;
+export declare const SHOE_WIDTH = 8;
+export declare const SHOE_LENGTH = 16;
+export declare const DEFAULT_TEXTURE_SIZE = 64;
 export declare const SURFACE_LINE_WIDTH = 1;

package/dist/control/IntersectionReferenceSystem.d.ts

@@ -1,4 +1,18 @@
-import { Interpolators, Trajectory, ReferenceSystemOptions, MDPoint } from '../interfaces';
+import { CurveInterpolator } from 'curve-interpolator';
+import { Interpolators, Trajectory, MDPoint } from '../interfaces';
+import { ExtendedCurveInterpolator } from './ExtendedCurveInterpolator';
+export interface ReferenceSystemOptions {
+    normalizedLength?: number;
+    arcDivisions?: number;
+    tension?: number;
+    trajectoryAngle?: number;
+    calculateDisplacementFromBottom?: boolean;
+    curveInterpolator?: ExtendedCurveInterpolator;
+    trajectoryInterpolator?: ExtendedCurveInterpolator;
+    curtainInterpolator?: ExtendedCurveInterpolator;
+    approxT?: boolean;
+    quickT?: boolean;
+}
 export declare class IntersectionReferenceSystem {
     options: ReferenceSystemOptions;
     path: number[][];
@@ -35,10 +49,11 @@ export declare class IntersectionReferenceSystem {
      * a sample in between is discarded.
      *
      * The start and the end are not guaranteed to be part of the returned set of points
-     * @param start in MD
-     * @param end in MD
+     * @param startMd in MD
+     * @param endMd in MD
+     * @param includeStartEnd guarantee to include the starting and end points
      */
-    getCurtainPath(start: number, end: number): MDPoint[];
+    getCurtainPath(startMd: number, endMd: number, includeStartEnd?: boolean): MDPoint[];
     /**
      * Map a displacement back to length along the curve
      */
@@ -74,7 +89,7 @@ export declare class IntersectionReferenceSystem {
      * @param from number between 0 and 1
      * @param to number between 0 and 1
      */
-    static getDirectionVector(interpolator: any, from: number, to: number): number[];
+    static getDirectionVector(interpolator: CurveInterpolator, from: number, to: number): number[];
     get length(): number;
     get offset(): number;
     set offset(offset: number);

package/dist/control/LayerManager.d.ts

@@ -1,5 +1,5 @@
 import { ZoomPanHandler } from './ZoomPanHandler';
-import { Layer } from '../layers';
+import { Layer, LayerOptions } from '../layers';
 import { ScaleOptions } from '../interfaces';
 import { Axis } from '../components';
 import { IntersectionReferenceSystem } from './IntersectionReferenceSystem';
@@ -22,11 +22,11 @@ export declare class LayerManager {
      * Adds and mounts an array of layers
      * @param layers array of layers
      */
-    addLayers(layers: Layer[]): LayerManager;
+    addLayers(layers: Layer<unknown>[]): LayerManager;
     /**
      * Gets all layers currently mounted
      */
-    getLayers(): Layer[];
+    getLayers(): Layer<unknown>[];
     /**
      * Clears data from all mounted layers
      * @param includeReferenceSystem - (optional) if true also removes reference system, default is true
@@ -37,7 +37,7 @@ export declare class LayerManager {
      * @param layer Layer
      * @param params extra params to pass to the onUpdate method
      */
-    addLayer(layer: Layer, params?: any): LayerManager;
+    addLayer(layer: Layer<unknown>, params?: LayerOptions<unknown>): LayerManager;
     /**
      * Remove and unmount layer from manager
      * @param layerId name of layer
@@ -47,8 +47,8 @@ export declare class LayerManager {
      * Remove and unmount all layers from manager
      */
     removeAllLayers(): LayerManager;
-    getLayer(layerId: string): Layer;
-    initLayer(layer: Layer, params?: any): LayerManager;
+    getLayer(layerId: string): Layer<unknown>;
+    initLayer(layer: Layer<unknown>, params?: LayerOptions<unknown>): LayerManager;
     showLayer(layerId: string): LayerManager;
     hideLayer(layerId: string): LayerManager;
     /**

package/dist/control/MainController.d.ts

@@ -2,7 +2,7 @@ import { IntersectionReferenceSystem } from './IntersectionReferenceSystem';
 import { Layer } from '../layers';
 import { ControllerOptions } from './interfaces';
 import { ZoomPanHandler } from './ZoomPanHandler';
-import { ReferenceSystemOptions } from '..';
+import { LayerOptions, OnRescaleEvent, ReferenceSystemOptions } from '..';
 import { Axis } from '../components';
 import { Overlay } from './overlay';
 /**
@@ -47,7 +47,7 @@ export declare class Controller {
      * @param layer layer object
      * @param params (optional) adds additional parameters to the onUpdateEvent
      */
-    addLayer(layer: Layer, params?: any): Controller;
+    addLayer(layer: Layer<unknown>, params?: LayerOptions<unknown>): Controller;
     /**
      * Remove and unmount layer from list
      * @param layerId string id
@@ -61,7 +61,7 @@ export declare class Controller {
      * Find first layer with given id, returns undefined if none are found
      * @param layerId string id
      */
-    getLayer(layerId: string): Layer;
+    getLayer(layerId: string): Layer<unknown>;
     /**
      * Sets visibility to true and rescales the layer
      * @param layerId string id
@@ -146,9 +146,9 @@ export declare class Controller {
     destroy(): Controller;
     private getHighestZIndex;
     private setOverlayZIndex;
-    get overlay(): Overlay;
+    get overlay(): Overlay<Controller>;
     get referenceSystem(): IntersectionReferenceSystem;
     get zoomPanHandler(): ZoomPanHandler;
     get axis(): Axis;
-    get currentStateAsEvent(): any;
+    get currentStateAsEvent(): OnRescaleEvent;
 }

package/dist/control/ZoomPanHandler.d.ts

@@ -9,7 +9,7 @@ export declare type RescaleFunction = (event: OnRescaleEvent) => void;
 export declare class ZoomPanHandler {
     zoom: ZoomBehavior<Element, unknown>;
     elm: HTMLElement;
-    container: Selection<any, unknown, null, undefined>;
+    container: Selection<HTMLElement, unknown, null, undefined>;
     onRescale: RescaleFunction;
     options: ZoomAndPanOptions;
     xBounds: [number, number];
@@ -111,7 +111,9 @@ export declare class ZoomPanHandler {
     /**
      * Handle zoom
      */
-    onZoom(event: any): void;
+    onZoom(event: {
+        transform: ZoomTransform;
+    }): void;
     /**
      * Update scale
      */

package/dist/control/index.d.ts

@@ -1,5 +1,5 @@
-export * from './ZoomPanHandler';
-export * from './LayerManager';
+export * from './interfaces';
 export * from './IntersectionReferenceSystem';
+export * from './LayerManager';
 export * from './MainController';
-export * from './interfaces';
+export * from './ZoomPanHandler';

package/dist/control/interfaces.d.ts

@@ -11,27 +11,27 @@ export interface ControllerOptions {
     axisOptions?: AxisOptions;
     scaleOptions?: ScaleOptions;
     referenceSystem?: IntersectionReferenceSystem;
-    layers?: Layer[];
+    layers?: Layer<unknown>[];
     path?: number[][];
 }
-interface OverlayEvent {
+interface OverlayEvent<T> {
     target?: Element;
     source: Element;
-    caller: any;
+    caller: T;
 }
-export interface OverlayResizeEvent extends OverlayEvent {
+export interface OverlayResizeEvent<T> extends OverlayEvent<T> {
     width: number;
     height: number;
 }
-export interface OverlayMouseMoveEvent extends OverlayEvent {
+export interface OverlayMouseMoveEvent<T> extends OverlayEvent<T> {
     x: number;
     y: number;
 }
-export interface OverlayMouseExitEvent extends OverlayEvent {
+export interface OverlayMouseExitEvent<T> extends OverlayEvent<T> {
 }
-export interface OverlayCallbacks {
-    onMouseMove?(event: OverlayMouseMoveEvent): void;
-    onMouseExit?(event: OverlayMouseExitEvent): void;
-    onResize?(event: OverlayResizeEvent): void;
+export interface OverlayCallbacks<T> {
+    onMouseMove?(event: OverlayMouseMoveEvent<T>): void;
+    onMouseExit?(event: OverlayMouseExitEvent<T>): void;
+    onResize?(event: OverlayResizeEvent<T>): void;
 }
 export {};

package/dist/control/overlay.d.ts

@@ -1,20 +1,20 @@
 import { Selection } from 'd3-selection';
 import { OverlayCallbacks } from './interfaces';
-export declare class Overlay {
+export declare class Overlay<T> {
     elm: Selection<Element, unknown, null, undefined>;
     source: Element;
     elements: {
         [propName: string]: Element;
     };
     listeners: {
-        [propName: string]: OverlayCallbacks;
+        [propName: string]: OverlayCallbacks<T>;
     };
     enabled: boolean;
-    constructor(caller: any, container: HTMLElement);
-    create(key: string, callbacks?: OverlayCallbacks): HTMLElement;
-    register(key: string, callbacks: OverlayCallbacks): void;
+    constructor(caller: T, container: HTMLElement);
+    create(key: string, callbacks?: OverlayCallbacks<T>): HTMLElement;
+    register(key: string, callbacks: OverlayCallbacks<T>): void;
     remove(key: string): void;
     setZIndex(zIndex: number): void;
     destroy(): void;
 }
-export declare const overlay: (caller: any, container: HTMLElement) => Overlay;
+export declare const overlay: <T>(caller: T, container: HTMLElement) => Overlay<T>;

package/dist/datautils/index.d.ts

@@ -1,6 +1,6 @@
+export * from './findsample';
 export * from './interfaces';
+export * from './picks';
+export * from './seismicimage';
 export * from './surfacedata';
 export * from './trajectory';
-export * from './findsample';
-export * from './seismicimage';
-export * from './picks';

package/dist/datautils/interfaces.d.ts

@@ -11,13 +11,19 @@ export interface SurveySample {
  * Strat unit element as retrieved from SDMA
  */
 export interface StratUnit {
-    [propType: string]: any;
+    identifier: string;
+    stratUnitParent: string;
+    colorR: null | number;
+    colorG: null | number;
+    colorB: null | number;
+    topAge: number;
+    baseAge: number;
+    stratUnitLevel: number;
 }
 /**
  * Surfaces meta data as received from surface API with surface values injected
  */
 export interface SurfaceMetaAndValues {
-    [propType: string]: any;
     data: {
         values: number[];
     };

package/dist/datautils/picks.d.ts

@@ -1,10 +1,74 @@
-export declare function getPicksData(picksData: any): any[];
+import { Annotation } from '../interfaces';
+declare type Pick = {
+    pickIdentifier?: string;
+    confidence: string | null;
+    depthReferencePoint: string;
+    md: number;
+    mdUnit: string;
+    tvd: number;
+};
+declare type PickWithId = {
+    identifier: string;
+} & Pick;
+declare type Unit = {
+    identifier: string;
+    top: string;
+    base: string;
+    baseAge: number;
+    topAge: number;
+    colorR: number;
+    colorG: number;
+    colorB: number;
+    stratUnitLevel: number;
+    lithologyType: number;
+    stratUnitParent: number;
+};
+declare type UnitDto = {
+    unitName: string;
+    topSurface: string;
+    baseSurface: string;
+    ageBase: number;
+    ageTop: number;
+    color: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    level: number;
+    lithType: number;
+    parent: number;
+};
+declare type PickAndUnit = PickWithId & UnitDto;
+declare type PairedPickAndUnit = {
+    name: string;
+    mdEntry: number;
+    tvdEntry: number;
+    color: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    level: number;
+    entryPick: PickAndUnit;
+    mdExit: number;
+    tvdExit: number;
+    exitPick: PickAndUnit;
+    confidenceEntry: string;
+    confidenceExit: string;
+    from?: number;
+    to?: number;
+};
+export declare const getPicksData: (picksData: {
+    unitPicks: PairedPickAndUnit[];
+    nonUnitPicks: PickWithId[];
+}) => Annotation[];
 /**
  * Transform data for formation track
- * @param {object[]} picks picks
- * @param {object[]} stratColumn strat column
+ * @param {Pick[]} picks picks
+ * @param {Unit[]} stratColumn strat column
  */
-export declare function transformFormationData(picks: any, stratColumn: any): {
-    unitPicks: any[];
-    nonUnitPicks: any[];
+export declare function transformFormationData(picks: Pick[], stratColumn: Unit[]): {
+    unitPicks: PairedPickAndUnit[];
+    nonUnitPicks: PickWithId[];
 };
+export {};

package/dist/datautils/schematicShapeGenerator.d.ts

@@ -0,0 +1,54 @@
+import { IPoint, Point, Texture } from 'pixi.js';
+import { Casing, Cement, CementOptions, CementPlug, CementPlugOptions, CementSqueeze, HoleOptions, HoleSize, ScreenOptions, TubingOptions } from '../layers/schematicInterfaces';
+import { ComplexRopeSegment } from '../layers/CustomDisplayObjects/ComplexRope';
+export interface TubularRenderingObject {
+    leftPath: Point[];
+    rightPath: Point[];
+    referenceDiameter: number;
+    referenceRadius: number;
+}
+export interface CasingRenderObject extends TubularRenderingObject {
+    kind: 'casing';
+    pathPoints: number[][];
+    polygon: Point[];
+    casingId: string;
+    casingWallWidth: number;
+    hasShoe: boolean;
+    bottom: number;
+    zIndex?: number;
+}
+export declare const getEndLines: (rightPath: IPoint[], leftPath: IPoint[]) => {
+    top: IPoint[];
+    bottom: IPoint[];
+};
+export declare const makeTubularPolygon: (rightPath: Point[], leftPath: Point[]) => Point[];
+export declare const overlaps: (top1: number, bottom1: number, top2: number, bottom2: number) => boolean;
+export declare const uniq: <T>(arr: T[]) => T[];
+export declare const findIntersectingItems: (topOfCement: number, bottomOfCement: number, parentCasings: Casing[], casings: Casing[], holes: HoleSize[]) => {
+    overlappingHoles: HoleSize[];
+    outerCasings: Casing[];
+};
+export declare const cementDiameterChangeDepths: (cement: Cement, bottomOfCement: number, diameterIntervals: {
+    start: number;
+    end: number;
+}[]) => number[];
+export declare const findCementOuterDiameterAtDepth: (innerCasing: Casing[], nonAttachedCasings: Casing[], holes: HoleSize[], depth: number) => number;
+export declare const findCementInnerDiameterAtDepth: (innerCasing: Casing[], _nonAttachedCasings: Casing[], holes: HoleSize[], depth: number) => number;
+export declare const createComplexRopeSegmentsForCement: (cement: Cement, casings: Casing[], holes: HoleSize[], exaggerationFactor: number, getPoints: (start: number, end: number) => [number, number][]) => ComplexRopeSegment[];
+export declare const cementSqueezeDiameterChangeDepths: (squeeze: CementSqueeze, diameterIntervals: {
+    start: number;
+    end: number;
+}[]) => number[];
+export declare const cementPlugDiameterChangeDepths: (plug: CementPlug, diameterIntervals: {
+    start: number;
+    end: number;
+}[]) => number[];
+export declare const createComplexRopeSegmentsForCementSqueeze: (squeeze: CementSqueeze, casings: Casing[], holes: HoleSize[], exaggerationFactor: number, getPoints: (start: number, end: number) => [number, number][]) => ComplexRopeSegment[];
+export declare const createComplexRopeSegmentsForCementPlug: (plug: CementPlug, casings: Casing[], holes: HoleSize[], exaggerationFactor: number, getPoints: (start: number, end: number) => [number, number][]) => ComplexRopeSegment[];
+export declare const createHoleBaseTexture: ({ firstColor, secondColor }: HoleOptions, width: number, height: number) => Texture;
+export declare const createScreenTexture: ({ scalingFactor }: ScreenOptions) => Texture;
+export declare const createTubingTexture: ({ innerColor, outerColor, scalingFactor }: TubingOptions) => Texture;
+export declare const createCementTexture: ({ firstColor, secondColor, scalingFactor }: CementOptions) => Texture<import("pixi.js").Resource>;
+export declare const createCementPlugTexture: ({ firstColor, secondColor, scalingFactor }: CementPlugOptions) => Texture<import("pixi.js").Resource>;
+export declare const createTubularRenderingObject: (diameter: number, pathPoints: [number, number][]) => TubularRenderingObject;
+export declare const prepareCasingRenderObject: (exaggerationFactor: number, casing: Casing, pathPoints: [number, number][]) => CasingRenderObject;

package/dist/datautils/seismicimage.d.ts

@@ -1,3 +1,16 @@
+import { SeismicCanvasDataOptions } from '../layers/SeismicCanvasLayer';
+export declare type SeismicInfo = {
+    minX: number;
+    maxX: number;
+    minTvdMsl: number;
+    maxTvdMsl: number;
+    domain: {
+        min: number;
+        max: number;
+        difference: number;
+    };
+};
+export declare const getSeismicOptions: (info: SeismicInfo | null) => SeismicCanvasDataOptions;
 /**
  * Get key information about the seismic data
  * Code originally developed for the REP project
@@ -8,7 +21,7 @@
 export declare function getSeismicInfo(data: {
     datapoints: number[][];
     yAxisValues: number[];
-}, trajectory: number[][]): any;
+}, trajectory: number[][]): SeismicInfo | null;
 /**
  * Generate seismic
  * Code originally developed for the REP project

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-export * from './layers';
-export * from './control';
 export * from './components';
-export * from './interfaces';
+export * from './control';
 export * from './datautils';
+export * from './interfaces';
+export * from './layers';
 export * from './utils';