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

package/dist/interfaces.d.ts

@@ -1,14 +1,16 @@
 import { ZoomTransform } from 'd3-zoom';
-import { Graphics, IApplicationOptions } from 'pixi.js';
-import { Layer } from './layers/base/Layer';
-import { IntersectionReferenceSystem } from './control/IntersectionReferenceSystem';
+import { Graphics } from 'pixi.js';
 import Vector2 from '@equinor/videx-vector2';
+import { ScaleLinear } from 'd3-scale';
+import { ExtendedCurveInterpolator } from './control/ExtendedCurveInterpolator';
+import { CurveInterpolator } from 'curve-interpolator';
 interface LayerEvent {
-    [propType: string]: any;
     elm?: HTMLElement;
 }
 export interface OnMountEvent extends LayerEvent {
     elm: HTMLElement;
+    width?: number;
+    height?: number;
 }
 export interface OnUnmountEvent extends LayerEvent {
 }
@@ -17,76 +19,20 @@ export interface OnResizeEvent extends LayerEvent {
     height: number;
 }
 export interface OnRescaleEvent extends LayerEvent {
-    xBounds?: [number, number];
-    yBounds?: [number, number];
-    zFactor?: number;
-    viewportRatio?: number;
-    width?: number;
-    height?: number;
-    xRatio?: number;
-    yRatio?: number;
-    transform?: ZoomTransform;
-}
-export interface OnUpdateEvent extends LayerEvent {
-}
-export interface LayerOptions {
-    order?: number;
-    layerOpacity?: number;
-    referenceSystem?: IntersectionReferenceSystem;
-    data?: any;
-    interactive?: boolean;
-    onMount?(event: OnMountEvent, layer: Layer): void;
-    onUnmount?(event: OnUnmountEvent, layer: Layer): void;
-    onUpdate?(event: OnUpdateEvent, layer: Layer): void;
-    onRescale?(event: OnRescaleEvent, layer: Layer): void;
-    onResize?(event: OnResizeEvent, layer: Layer): void;
-}
-export interface GridLayerOptions extends LayerOptions {
-    majorWidth?: number;
-    majorColor?: string;
-    minorWidth?: number;
-    minorColor?: string;
-}
-export interface WellborepathLayerOptions extends LayerOptions {
-    stroke: string;
-    strokeWidth: string;
-    curveType?: string;
-    tension?: number;
-}
-export interface GeomodelLayerOptions extends LayerOptions {
-}
-export interface CompletionLayerOptions extends PixiLayerOptions {
-}
-export interface GeomodelLayerLabelsOptions extends LayerOptions {
-    margins?: number;
-    minFontSize?: number;
-    maxFontSize?: number;
-    textColor?: string;
-    font?: string;
-}
-export interface HoleSizeLayerOptions extends WellComponentBaseOptions {
-    firstColor?: string;
-    secondColor?: string;
-    lineColor?: number;
-}
-export interface CasingShoeSize {
+    xScale: ScaleLinear<number, number, never>;
+    yScale: ScaleLinear<number, number, never>;
+    xBounds: [number, number];
+    yBounds: [number, number];
+    zFactor: number;
+    viewportRatio: number;
+    xRatio: number;
+    yRatio: number;
     width: number;
-    length: number;
-}
-export interface CasingLayerOptions extends WellComponentBaseOptions {
-    solidColor?: number;
-    lineColor?: number;
-    casingShoeSize?: CasingShoeSize;
-}
-export interface CementLayerOptions extends WellComponentBaseOptions {
-    firstColor?: string;
-    secondColor?: string;
-}
-export interface PixiLayerOptions extends LayerOptions {
-    pixiApplicationOptions?: IApplicationOptions;
+    height: number;
+    transform: ZoomTransform;
 }
-export interface WellComponentBaseOptions extends PixiLayerOptions {
-    exaggerationFactor?: number;
+export interface OnUpdateEvent<T> extends LayerEvent {
+    data?: T;
 }
 export interface ZoomAndPanOptions {
     maxZoomLevel: number;
@@ -104,29 +50,6 @@ export interface Annotation {
     md?: number;
     pos?: [number, number];
 }
-export interface HoleSize {
-    diameter: number;
-    start: number;
-    end: number;
-    innerDiameter?: number;
-}
-export interface Casing {
-    diameter: number;
-    start: number;
-    end: number;
-    hasShoe: boolean;
-    innerDiameter: number;
-    casingId: string;
-}
-export interface Cement {
-    toc: number;
-    casingIds?: string[];
-    /**
-     * Should remove optional on casingIds when casingId is removed in next major release
-     * @‌deprecated use casingIds
-     */
-    casingId?: string;
-}
 export interface MDPoint {
     point: number[];
     normal?: Vector2;
@@ -144,29 +67,14 @@ export interface ScaleOptions {
     yBounds?: [number, number];
 }
 export interface Interpolators {
-    trajectory: any;
-    curtain: any;
-    position?: any;
-    curve?: any;
-}
-export interface Interpolator {
+    trajectory: CurveInterpolator;
+    curtain: ExtendedCurveInterpolator;
+    curve?: ExtendedCurveInterpolator;
 }
 export interface Trajectory {
     points: number[][];
     offset: number;
 }
-export interface ReferenceSystemOptions {
-    normalizedLength?: number;
-    arcDivisions?: number;
-    tension?: number;
-    trajectoryAngle?: number;
-    calculateDisplacementFromBottom?: boolean;
-    curveInterpolator?: Interpolator;
-    trajectoryInterpolator?: Interpolator;
-    curtainInterpolator?: Interpolator;
-    approxT?: boolean;
-    quickT?: boolean;
-}
 export declare type BoundingBox = {
     x: number;
     y: number;
@@ -175,12 +83,4 @@ export declare type BoundingBox = {
     offsetX?: number;
     offsetY?: number;
 };
-export interface CalloutOptions extends LayerOptions {
-    minFontSize?: number;
-    maxFontSize?: number;
-    fontSizeFactor?: number;
-    offsetMin?: number;
-    offsetMax?: number;
-    offsetFactor?: number;
-}
 export {};

package/dist/layers/CalloutCanvasLayer.d.ts

@@ -1,6 +1,7 @@
 import { ScaleLinear } from 'd3-scale';
 import { CanvasLayer } from './base/CanvasLayer';
-import { OnUpdateEvent, Annotation, OnRescaleEvent, BoundingBox, CalloutOptions } from '../interfaces';
+import { OnUpdateEvent, Annotation, OnRescaleEvent, BoundingBox } from '../interfaces';
+import { LayerOptions } from './base/Layer';
 export declare type Point = {
     x: number;
     y: number;
@@ -16,7 +17,15 @@ export declare type Callout = {
     dx: number;
     dy: number;
 };
-export declare class CalloutCanvasLayer extends CanvasLayer {
+export interface CalloutOptions<T extends Annotation[]> extends LayerOptions<T> {
+    minFontSize?: number;
+    maxFontSize?: number;
+    fontSizeFactor?: number;
+    offsetMin?: number;
+    offsetMax?: number;
+    offsetFactor?: number;
+}
+export declare class CalloutCanvasLayer<T extends Annotation[]> extends CanvasLayer<T> {
     rescaleEvent: OnRescaleEvent;
     xRatio: number;
     callouts: Callout[];
@@ -27,9 +36,9 @@ export declare class CalloutCanvasLayer extends CanvasLayer {
     offsetMin: number;
     offsetMax: number;
     offsetFactor: number;
-    constructor(id?: string, options?: CalloutOptions);
+    constructor(id?: string, options?: CalloutOptions<T>);
     setGroupFilter(filter: string[]): void;
-    onUpdate(event: OnUpdateEvent): void;
+    onUpdate(event: OnUpdateEvent<T>): void;
     onRescale(event: OnRescaleEvent): void;
     render(isPanning?: boolean): void;
     private renderAnnotation;
@@ -38,7 +47,7 @@ export declare class CalloutCanvasLayer extends CanvasLayer {
     private renderCallout;
     private renderLine;
     private getPosition;
-    positionCallouts(annotations: Annotation[], isLeftToRight: boolean, xScale: ScaleLinear<number, number>, yScale: ScaleLinear<number, number>, scale: number, fontSize: number, offset?: number): Callout[];
+    positionCallouts(annotations: Annotation[], isLeftToRight: boolean, xScale: ScaleLinear<number, number>, yScale: ScaleLinear<number, number>, _scale: number, fontSize: number, offset?: number): Callout[];
     getAnnotationBoundingBox(title: string, label: string, pos: number[], xScale: ScaleLinear<number, number>, yScale: ScaleLinear<number, number>, height: number): {
         x: number;
         y: number;

package/dist/layers/CustomDisplayObjects/ComplexRope.d.ts

@@ -0,0 +1,22 @@
+import { IPoint, Mesh, Renderer, Texture } from 'pixi.js';
+export declare type ComplexRopeSegment = {
+    points: IPoint[];
+    diameter: number;
+};
+/**
+ * The ComplexRope allows you to draw a texture across several segments of points and then manipulate these points
+ */
+export declare class ComplexRope extends Mesh {
+    /**
+     * re-calculate vertices by rope segment-points each frame
+     * @member {boolean}
+     */
+    autoUpdate: boolean;
+    /**
+     * @param texture - The texture to use on the rope.
+     * @param segments - An array of segments with points and diaeter to construct this rope.
+     * @param {number} textureScale - Optional. Adjust interval of repeated texture
+     */
+    constructor(texture: Texture, segments: ComplexRopeSegment[], textureScale?: number);
+    _render(renderer: Renderer): void;
+}

package/dist/layers/CustomDisplayObjects/ComplexRopeGeometry.d.ts

@@ -0,0 +1,27 @@
+import { MeshGeometry } from 'pixi.js';
+import { ComplexRopeSegment } from './ComplexRope';
+/**
+ * RopeGeometry allows you to draw a geometry across several several segments of points and then manipulate these points.
+ */
+export declare class ComplexRopeGeometry extends MeshGeometry {
+    /** An array of segments with points and diameter that determine the rope. */
+    private segments;
+    /** Rope texture scale. */
+    private readonly textureScale;
+    /**
+     * @param segments - An array of segments with points and diameter to construct this rope.
+     * @param textureScale - scaling factor for repeated texture. To create a tiling rope
+     *     set baseTexture.wrapMode to PIXI.WRAP_MODES.REPEAT and use a power of two texture.
+     */
+    constructor(segments: ComplexRopeSegment[], textureScale?: number);
+    /**
+     * The max width (i.e., thickness) of the rope.
+     * @readonly
+     */
+    get width(): number;
+    /** Refreshes Rope indices and uvs */
+    private build;
+    /** refreshes vertices of Rope mesh */
+    updateVertices(): void;
+    update(): void;
+}

package/dist/layers/CustomDisplayObjects/FixedWidthSimpleRope.d.ts

@@ -0,0 +1,20 @@
+import { IPoint, Mesh, Renderer, Texture } from 'pixi.js';
+/**
+ * The rope allows you to draw a texture across several points and then manipulate these points
+ * Width of rope is given in constructor
+ */
+export declare class FixedWidthSimpleRope extends Mesh {
+    /**
+     * re-calculate vertices by rope points each frame
+     * @member {boolean}
+     */
+    autoUpdate: boolean;
+    /**
+     * Note: The wrap mode of the texture is set to REPEAT if `textureScale` is positive.
+     * @param texture - The texture to use on the rope. (attempt to set UV wrapping, will fail on non-power of two textures)
+     * @param points - An array of {@link PIXI.Point} objects to construct this rope.
+     * @param width - Width of rope
+     */
+    constructor(texture: Texture, points: IPoint[], width: number);
+    _render(renderer: Renderer): void;
+}

package/dist/layers/CustomDisplayObjects/FixedWidthSimpleRopeGeometry.d.ts

@@ -0,0 +1,26 @@
+import { IPoint, MeshGeometry } from 'pixi.js';
+export declare class FixedWidthSimpleRopeGeometry extends MeshGeometry {
+    points: IPoint[];
+    _width: number;
+    /**
+     * @param {number} [width=200] - The width (i.e., thickness) of the rope.
+     * @param {PIXI.Point[]} [points] - An array of PIXI.Point objects to construct this rope.
+     */
+    constructor(points: IPoint[], width?: number);
+    /**
+     * The width (i.e., thickness) of the rope.
+     * @member {number}
+     * @readOnly
+     */
+    get width(): number;
+    /**
+     * Refreshes Rope indices and uvs
+     * @private
+     */
+    private build;
+    /**
+     * refreshes vertices of Rope mesh
+     */
+    updateVertices(): void;
+    update(): void;
+}

package/dist/layers/CustomDisplayObjects/UniformTextureStretchRope.d.ts

@@ -0,0 +1,17 @@
+import { IPoint, Mesh, Renderer, Texture } from 'pixi.js';
+/**
+ * The UniformTextureStretchRope allows you to draw a texture across several points and then manipulate these points
+ */
+export declare class UniformTextureStretchRope extends Mesh {
+    /**
+     * re-calculate vertices by rope points each frame
+     * @member {boolean}
+     */
+    autoUpdate: boolean;
+    /**
+     * @param texture - The texture to use on the rope.
+     * @param points - An array of {@link PIXI.Point} objects to construct this rope.
+     */
+    constructor(texture: Texture, points: IPoint[]);
+    _render(renderer: Renderer): void;
+}

package/dist/layers/CustomDisplayObjects/UniformTextureStretchRopeGeometry.d.ts

@@ -0,0 +1,24 @@
+import { MeshGeometry } from 'pixi.js';
+import type { IPoint } from 'pixi.js';
+/**
+ * UniformTextureStretchRopeGeometry allows you to draw a geometry across several points and then manipulate these points.
+ */
+export declare class UniformTextureStretchRopeGeometry extends MeshGeometry {
+    /** An array of points that determine the rope. */
+    points: IPoint[];
+    /**
+     * The width (i.e., thickness) of the rope.
+     * @readonly
+     */
+    _width: number;
+    /**
+     * @param width - The width (i.e., thickness) of the rope.
+     * @param points - An array of PIXI.Point objects to construct this rope.
+     */
+    constructor(points: IPoint[], width?: number);
+    /** Refreshes Rope indices and uvs */
+    private build;
+    /** refreshes vertices of Rope mesh */
+    updateVertices(): void;
+    update(): void;
+}

package/dist/layers/GeomodelCanvasLayer.d.ts

@@ -1,18 +1,18 @@
-import { SurfaceData } from '../datautils';
-import { GeomodelLayerOptions, OnUpdateEvent, OnRescaleEvent, OnMountEvent } from '../interfaces';
+import { SurfaceData, SurfaceLine } from '../datautils';
+import { OnUpdateEvent, OnRescaleEvent } from '../interfaces';
+import { LayerOptions } from './base';
 import { CanvasLayer } from './base/CanvasLayer';
-export declare class GeomodelCanvasLayer extends CanvasLayer {
+declare type SurfacePaths = {
+    color: string;
+    path: Path2D;
+};
+export declare class GeomodelCanvasLayer<T extends SurfaceData> extends CanvasLayer<T> {
     rescaleEvent: OnRescaleEvent;
-    surfaceAreasPaths: any[];
-    surfaceLinesPaths: any[];
+    surfaceAreasPaths: SurfacePaths[];
+    surfaceLinesPaths: SurfacePaths[];
     maxDepth: number;
-    constructor(id?: string, options?: GeomodelLayerOptions);
-    get data(): SurfaceData;
-    set data(data: SurfaceData);
-    getData(): SurfaceData;
-    setData(data: SurfaceData): void;
-    onMount(event: OnMountEvent): void;
-    onUpdate(event: OnUpdateEvent): void;
+    constructor(id?: string, options?: LayerOptions<T>);
+    onUpdate(event: OnUpdateEvent<T>): void;
     onRescale(event: OnRescaleEvent): void;
     updatePaths(): void;
     render(): void;
@@ -21,7 +21,8 @@ export declare class GeomodelCanvasLayer extends CanvasLayer {
     generateSurfaceLinesPaths(): void;
     drawPolygonPath: (color: string, path: Path2D) => void;
     drawLinePath: (color: string, path: Path2D) => void;
-    createPolygons: (data: any) => number[][];
+    createPolygons: (data: number[][]) => number[][];
     generatePolygonPath: (polygon: number[]) => Path2D;
-    generateLinePaths: (s: any) => Path2D[];
+    generateLinePaths: (s: SurfaceLine) => Path2D[];
 }
+export {};

package/dist/layers/GeomodelLabelsLayer.d.ts

@@ -1,8 +1,19 @@
 import Vector2 from '@equinor/videx-vector2';
 import { CanvasLayer } from './base/CanvasLayer';
-import { GeomodelLayerLabelsOptions, OnUpdateEvent, OnRescaleEvent, OnMountEvent } from '../interfaces';
+import { OnUpdateEvent, OnRescaleEvent, OnMountEvent } from '../interfaces';
 import { SurfaceArea, SurfaceLine, SurfaceData } from '../datautils';
-export declare class GeomodelLabelsLayer extends CanvasLayer {
+import { LayerOptions } from './base/Layer';
+export interface GeomodelLayerLabelsOptions<T extends SurfaceData> extends LayerOptions<T> {
+    margins?: number;
+    minFontSize?: number;
+    maxFontSize?: number;
+    textColor?: string;
+    font?: string;
+}
+interface SurfaceAreaWithAvgTopDepth extends SurfaceArea {
+    avgTopDepth: number;
+}
+export declare class GeomodelLabelsLayer<T extends SurfaceData> extends CanvasLayer<T> {
     defaultMargins: number;
     defaultMinFontSize: number;
     defaultMaxFontSize: number;
@@ -12,26 +23,27 @@ export declare class GeomodelLabelsLayer extends CanvasLayer {
     isLabelsOnLeftSide: boolean;
     maxFontSizeInWorldCoordinates: number;
     isXFlipped: boolean;
-    areasWithAvgTopDepth: any[];
-    constructor(id?: string, options?: GeomodelLayerLabelsOptions);
-    get options(): GeomodelLayerLabelsOptions;
-    setData(data: SurfaceData): void;
-    generateSurfacesWithAvgDepth(): any;
+    areasWithAvgTopDepth: SurfaceAreaWithAvgTopDepth[];
+    constructor(id?: string, options?: GeomodelLayerLabelsOptions<T>);
+    get options(): GeomodelLayerLabelsOptions<T>;
+    setData(data: T): void;
+    generateSurfacesWithAvgDepth(): void;
     onMount(event: OnMountEvent): void;
-    onUpdate(event: OnUpdateEvent): void;
+    onUpdate(event: OnUpdateEvent<T>): void;
     onRescale(event: OnRescaleEvent): void;
     render(): void;
     drawAreaLabels(): void;
     drawLineLabels(): void;
-    drawAreaLabel: (surfaceArea: SurfaceArea, nextSurfaceArea: SurfaceArea, surfaces: any[], i: number) => void;
+    drawAreaLabel: (surfaceArea: SurfaceArea, nextSurfaceArea: SurfaceArea, surfaces: SurfaceArea[], i: number) => void;
     drawLineLabel: (s: SurfaceLine) => void;
     colorToCSSColor(color: number | string): string;
-    calcPos(data: number[][], offset: number, count: number, step: number, topLimit?: number, bottomLimit?: number, alternativeSurfaceData?: number[][], surfaces?: any[], currentSurfaceIndex?: number): Vector2;
-    getAlternativeYValueIfAvailable(x: number, topLimit: number, bottomLimit: number, alternativeSurfaceData: number[][], surfaces: any[], currentSurfaceIndex: number): number;
+    calcPos(data: number[][], offset: number, count: number, step: number, topLimit?: number, bottomLimit?: number, alternativeSurfaceData?: number[][], surfaces?: SurfaceArea[] | null, currentSurfaceIndex?: number): Vector2;
+    getAlternativeYValueIfAvailable(x: number, topLimit: number, bottomLimit: number, alternativeSurfaceData: number[][], surfaces: SurfaceArea[] | null, currentSurfaceIndex: number): number;
     calcLineDir(data: number[][], offset: number, count: number, step: number, zFactor: number, initalVector?: Vector2, topLimit?: number, bottomLimit?: number): Vector2;
-    calcAreaDir(top: number[][], bottom: number[][], offset: number, count: number, step: number, initalVector?: Vector2, topLimit?: number, bottomLimit?: number, minReductionAngle?: number, maxReductionAngle?: number, angleReductionExponent?: number, alternativeSurfaceBottomData?: number[][], surfaces?: any[], currentSurfaceIndex?: number): number;
+    calcAreaDir(top: number[][], bottom: number[][], offset: number, count: number, step: number, initalVector?: Vector2, topLimit?: number, bottomLimit?: number, minReductionAngle?: number, maxReductionAngle?: number, angleReductionExponent?: number, alternativeSurfaceBottomData?: number[][], surfaces?: SurfaceArea[] | null, currentSurfaceIndex?: number): number;
     updateXFlipped(): void;
     getMarginsInWorldCoordinates(): number;
     getSurfacesAreaEdges(): number[];
     checkDrawLabelsOnLeftSide(): boolean;
 }
+export {};

package/dist/layers/GeomodelLayerV2.d.ts

@@ -1,13 +1,12 @@
 import { PixiLayer } from './base/PixiLayer';
-import { OnRescaleEvent, OnUpdateEvent } from '../interfaces';
-import { SurfaceArea, SurfaceLine } from '../datautils';
-export declare class GeomodelLayerV2 extends PixiLayer {
+import { OnUpdateEvent, OnRescaleEvent } from '../interfaces';
+import { SurfaceArea, SurfaceData, SurfaceLine } from '../datautils';
+export declare class GeomodelLayerV2<T extends SurfaceData> extends PixiLayer<T> {
     private isPreRendered;
     onRescale(event: OnRescaleEvent): void;
-    onUpdate(event: OnUpdateEvent): void;
-    clearStage(): void;
+    onUpdate(event: OnUpdateEvent<T>): void;
     preRender(): void;
-    createPolygons: (data: any) => number[][];
+    createPolygons: (data: number[][]) => number[][];
     generateAreaPolygon: (s: SurfaceArea) => void;
     generateSurfaceLine: (s: SurfaceLine) => void;
 }

package/dist/layers/GridLayer.d.ts

@@ -1,12 +1,24 @@
 import { CanvasLayer } from './base/CanvasLayer';
-import { GridLayerOptions, OnUpdateEvent, OnRescaleEvent } from '../interfaces';
-export declare class GridLayer extends CanvasLayer {
+import { OnUpdateEvent, OnRescaleEvent } from '../interfaces';
+import { ScaleLinear } from 'd3-scale';
+import { LayerOptions } from './base/Layer';
+export interface GridLayerOptions<T> extends LayerOptions<T> {
+    majorWidth?: number;
+    majorColor?: string;
+    minorWidth?: number;
+    minorColor?: string;
+}
+export interface OnGridLayerUpdateEvent<T> extends OnUpdateEvent<T> {
+    xScale?: ScaleLinear<number, number, never>;
+    yScale?: ScaleLinear<number, number, never>;
+}
+export declare class GridLayer<T> extends CanvasLayer<T> {
     private _offsetX;
     private _offsetY;
-    constructor(id?: string, options?: GridLayerOptions);
-    onUpdate(event: OnUpdateEvent): void;
+    constructor(id?: string, options?: GridLayerOptions<T>);
+    onUpdate(event: OnGridLayerUpdateEvent<T>): void;
     onRescale(event: OnRescaleEvent): void;
-    render(event: OnRescaleEvent | OnUpdateEvent): void;
+    render(event: OnRescaleEvent | OnGridLayerUpdateEvent<T>): void;
     private renderTicksX;
     private renderTicksY;
     private mapMinorTicks;

package/dist/layers/ImageCanvasLayer.d.ts

@@ -1,9 +1,20 @@
 import { CanvasLayer } from './base/CanvasLayer';
 import { OnUpdateEvent, OnMountEvent, OnRescaleEvent } from '../interfaces';
-export declare class ImageLayer extends CanvasLayer {
+import { ScaleLinear } from 'd3-scale';
+export interface OnImageLayerUpdateEvent<T> extends OnUpdateEvent<T> {
+    url: string;
+    xScale: ScaleLinear<number, number, never>;
+    yScale: ScaleLinear<number, number, never>;
+    xRatio?: number;
+    yRatio?: number;
+    x?: number;
+    y?: number;
+}
+export declare type OnImageLayerRescaleEvent<T> = OnImageLayerUpdateEvent<T> & OnRescaleEvent;
+export declare class ImageLayer<T> extends CanvasLayer<T> {
     img: HTMLImageElement;
     onMount(event: OnMountEvent): void;
-    onUpdate(event: OnUpdateEvent): void;
-    onRescale(event: OnRescaleEvent): void;
-    render(event: OnUpdateEvent): void;
+    onUpdate(event: OnImageLayerUpdateEvent<T>): void;
+    onRescale(event: OnImageLayerRescaleEvent<T>): void;
+    render(event: OnImageLayerUpdateEvent<T>): void;
 }

package/dist/layers/SchematicLayer.d.ts

@@ -0,0 +1,91 @@
+import { ScaleLinear } from 'd3-scale';
+import { Graphics, Point, Texture } from 'pixi.js';
+import { LayerOptions, PixiLayer, PixiRenderApplication } from '.';
+import { CasingOptions, CementOptions, CementPlugOptions, CementSqueezeOptions, HoleOptions, SchematicData, ScreenOptions, TubingOptions, InternalLayerOptions } from './schematicInterfaces';
+import { OnUpdateEvent, OnRescaleEvent, OnUnmountEvent } from '../interfaces';
+interface ScalingFactors {
+    height: number;
+    zFactor: number;
+    yScale: ScaleLinear<number, number, never>;
+}
+export interface SchematicLayerOptions<T extends SchematicData> extends LayerOptions<T> {
+    exaggerationFactor?: number;
+    internalLayerOptions?: InternalLayerOptions;
+    holeOptions?: HoleOptions;
+    casingOptions?: CasingOptions;
+    cementOptions?: CementOptions;
+    cementSqueezeOptions?: CementSqueezeOptions;
+    screenOptions?: ScreenOptions;
+    tubingOptions?: TubingOptions;
+    cementPlugOptions?: CementPlugOptions;
+}
+export declare class SchematicLayer<T extends SchematicData> extends PixiLayer<T> {
+    private internalLayerVisibility;
+    private cementTextureCache;
+    private cementSqueezeTextureCache;
+    private cementPlugTextureCache;
+    private holeTextureCache;
+    private screenTextureCache;
+    private tubingTextureCache;
+    private textureSymbolCacheArray;
+    private maxHoleDiameter;
+    protected scalingFactors: ScalingFactors;
+    constructor(ctx: PixiRenderApplication, id?: string, options?: SchematicLayerOptions<T>);
+    onUnmount(event?: OnUnmountEvent): void;
+    onUpdate(event: OnUpdateEvent<T>): void;
+    onRescale(event: OnRescaleEvent): void;
+    setVisibility(isVisible: boolean, layerId: string): void;
+    getInternalLayerIds(): string[];
+    /**
+     * Calculate yRatio without zFactor
+     * TODO consider to move this into ZoomPanHandler
+     */
+    protected yRatio(): number;
+    protected getZFactorScaledPathForPoints: (start: number, end: number) => [number, number][];
+    protected drawBigPolygon: (coords: Point[], color?: number) => void;
+    protected drawBigTexturedPolygon: (coords: Point[], t: Texture) => Graphics;
+    protected drawRope(path: Point[], texture: Texture, tint?: number): void;
+    /**
+     *
+     * @param leftPath Points for line on left side
+     * @param rightPath Points for line on right side
+     * @param lineColor Color of line
+     * @param lineWidth Width of line
+     * @param close If line should close in top and bottom to form a loop
+     * @param lineAlignment alignment of the line to draw, (0 = inner, 0.5 = middle, 1 = outer).
+     */
+    protected drawOutline(leftPath: Point[], rightPath: Point[], lineColor: number, lineWidth?: number, close?: boolean, lineAlignment?: number): void;
+    preRender(): void;
+    private updateSymbolCache;
+    private drawCementPlug;
+    private getCementPlugTexture;
+    private prepareSymbolRenderObject;
+    private drawSymbolComponent;
+    private drawSVGRope;
+    private getSymbolTexture;
+    private drawHoleSize;
+    private drawHoleRope;
+    private getHoleTexture;
+    /**
+     * The rendering order of these components needs to be aligned
+     * @param casingRenderObjects
+     * @param cementRenderObject
+     * @param cementSqueezes
+     * @returns ordered rendering list
+     */
+    private sortCementAndCasingRenderObjects;
+    private drawComplexRope;
+    private drawCasing;
+    private createCasingTexture;
+    private drawShoe;
+    private generateShoe;
+    private createCementSqueezeShape;
+    private getCementTexture;
+    private createCementSqueezeTexture;
+    private drawScreen;
+    private drawTubing;
+    private getTubingTexture;
+    private getScreenTexture;
+    private drawCompletionRope;
+}
+export {};

package/dist/layers/SeismicCanvasLayer.d.ts

@@ -1,8 +1,19 @@
+/// <reference types="offscreencanvas" />
 import { CanvasLayer } from './base/CanvasLayer';
 import { OnUpdateEvent, OnMountEvent, OnRescaleEvent } from '../interfaces';
-export declare class SeismicCanvasLayer extends CanvasLayer {
+export declare type SeismicCanvasDataOptions = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export declare type SeismicCanvasData = {
+    image: CanvasImageSource | OffscreenCanvas;
+    options: SeismicCanvasDataOptions;
+};
+export declare class SeismicCanvasLayer extends CanvasLayer<SeismicCanvasData> {
     onMount(event: OnMountEvent): void;
-    onUpdate(event: OnUpdateEvent): void;
+    onUpdate(event: OnUpdateEvent<SeismicCanvasData>): void;
     onRescale(event: OnRescaleEvent): void;
     render(): void;
 }