@equinor/esv-intersection 3.0.0-beta.5 → 3.0.0-beta.6

package/src/layers/SchematicLayer.ts

@@ -38,12 +38,13 @@ import {
   defaultTubingOptions,
   defaultInternalLayerOptions,
   Perforation,
-  getPerforationsThatStartAtHoleDiameter,
-  getPerforationsThatSTartAtCasingDiameter,
   PerforationOptions,
   defaultPerforationOptions,
   Completion,
   OutlineClosure,
+  hasPacking,
+  hasFracLines,
+  hasSpikes,
 } from './schematicInterfaces';
 import {
   CasingRenderObject,
@@ -59,9 +60,11 @@ import {
   prepareCasingRenderObject,
   createCementPlugTexture,
   createComplexRopeSegmentsForPerforation,
-  createPerforationTexture,
+  createPerforationPackingTexture,
   PerforationShape,
   createCementSqueezeTexture,
+  createPerforationFracLineTexture,
+  createPerforationSpikeTexture,
 } from '../datautils/schematicShapeGenerator';
 import { OnUpdateEvent, OnRescaleEvent, OnUnmountEvent } from '../interfaces';
 import { convertColor } from '../utils/color';
@@ -357,6 +360,8 @@ export class SchematicLayer<T extends SchematicData> extends PixiLayer<T> {
     this.addChild(graphics);
   }
 
+  private perforationRopeAndTextureReferences: { rope: ComplexRope; texture: Texture }[] = [];
+
   public preRender(): void {
     if (!this.data || !this.referenceSystem) {
       return;
@@ -365,19 +370,6 @@ export class SchematicLayer<T extends SchematicData> extends PixiLayer<T> {
     const { exaggerationFactor } = this.options as SchematicLayerOptions<T>;
     const { holeSizes, casings, cements, completion, symbols, pAndA, perforations } = this.data;
 
-    const shouldStartAtHoleDiameter = getPerforationsThatStartAtHoleDiameter(perforations);
-
-    const shouldStartAtCasingDiameter = getPerforationsThatSTartAtCasingDiameter(perforations);
-
-    if (this.internalLayerVisibility.perforationLayerId) {
-      shouldStartAtHoleDiameter.forEach((perforation) => {
-        const perfShapes = this.createPerforationShape(perforation, casings, holeSizes);
-        const otherPerforations = perforations.filter((p) => p.id !== perforation.id);
-        const widestPerfShapeDiameter = perfShapes.reduce((widest, perfShape) => (perfShape.diameter > widest ? perfShape.diameter : widest), 0);
-        this.drawComplexRope(perfShapes, this.createPerforationTexture(perforation, widestPerfShapeDiameter, otherPerforations));
-      });
-    }
-
     this.updateSymbolCache(symbols);
 
     holeSizes.sort((a: HoleSize, b: HoleSize) => b.diameter - a.diameter);
@@ -433,6 +425,84 @@ export class SchematicLayer<T extends SchematicData> extends PixiLayer<T> {
       ),
     );
 
+    this.perforationRopeAndTextureReferences.forEach(({ rope, texture }) => {
+      rope.destroy({
+        children: true,
+        texture: true,
+        baseTexture: true,
+      });
+      texture.destroy(true);
+    });
+    this.perforationRopeAndTextureReferences = [];
+
+    if (this.internalLayerVisibility.perforationLayerId) {
+      const { perforationOptions } = this.options as SchematicLayerOptions<T>;
+      const packings = perforations.filter(hasPacking);
+      const fracLines = perforations.filter(hasFracLines);
+      const spikes = perforations.filter(hasSpikes);
+      packings.forEach((perforation) => {
+        const perfShapes = this.createPerforationShape(perforation, casings, holeSizes);
+        const perfShapesByDiameter: { [key: number]: ComplexRopeSegment[] } = perfShapes.reduce(
+          (dict: { [key: number]: ComplexRopeSegment[] }, ps) => {
+            if (!dict[ps.diameter]) {
+              dict[ps.diameter] = [];
+            }
+            dict[ps.diameter] = [...dict[ps.diameter], ps];
+            return dict;
+          },
+          {},
+        );
+        Object.values(perfShapesByDiameter).forEach((perfShapesWithSameDiameter) => {
+          const texture = createPerforationPackingTexture(perforation, perfShapesWithSameDiameter[0], perforationOptions);
+          const rope = this.drawComplexRope(perfShapesWithSameDiameter, texture);
+          this.perforationRopeAndTextureReferences.push({ rope, texture });
+        });
+      });
+
+      fracLines.forEach((perforation) => {
+        const perfShapes = this.createPerforationShape(perforation, casings, holeSizes);
+        const thiccPerfShapes = perfShapes.map((ps) => ({ ...ps, diameter: ps.diameter * 3 }));
+        const perfShapesByDiameter: { [key: number]: ComplexRopeSegment[] } = thiccPerfShapes.reduce(
+          (dict: { [key: number]: ComplexRopeSegment[] }, ps) => {
+            if (!dict[ps.diameter]) {
+              dict[ps.diameter] = [];
+            }
+            dict[ps.diameter] = [...dict[ps.diameter], ps];
+            return dict;
+          },
+          {},
+        );
+        Object.values(perfShapesByDiameter).forEach((perfShapesWithSameDiameter) => {
+          perfShapesWithSameDiameter.forEach((perfShape) => {
+            const texture = createPerforationFracLineTexture(perforation, perfShape, perforationOptions);
+            const rope = this.drawComplexRope([perfShape], texture);
+            this.perforationRopeAndTextureReferences.push({ rope, texture });
+          });
+        });
+      });
+      spikes.forEach((perforation) => {
+        const perfShapes = this.createPerforationShape(perforation, casings, holeSizes);
+        const thiccPerfShapes = perfShapes.map((ps) => ({ ...ps, diameter: ps.diameter * 3 }));
+        const perfShapesByDiameter: { [key: number]: ComplexRopeSegment[] } = thiccPerfShapes.reduce(
+          (dict: { [key: number]: ComplexRopeSegment[] }, ps) => {
+            if (!dict[ps.diameter]) {
+              dict[ps.diameter] = [];
+            }
+            dict[ps.diameter] = [...dict[ps.diameter], ps];
+            return dict;
+          },
+          {},
+        );
+        Object.values(perfShapesByDiameter).forEach((perfShapesWithSameDiameter) => {
+          perfShapesWithSameDiameter.forEach((perfShape) => {
+            const texture = createPerforationSpikeTexture(perforation, perforations, perfShape, perforationOptions);
+            const rope = this.drawComplexRope([perfShape], texture);
+            this.perforationRopeAndTextureReferences.push({ rope, texture });
+          });
+        });
+      });
+    }
+
     if (this.internalLayerVisibility.completionLayerId) {
       completion.forEach(
         foldCompletion(
@@ -457,15 +527,6 @@ export class SchematicLayer<T extends SchematicData> extends PixiLayer<T> {
         }
       });
     }
-
-    if (this.internalLayerVisibility.perforationLayerId) {
-      shouldStartAtCasingDiameter.forEach((perforation) => {
-        const perfShapes = this.createPerforationShape(perforation, casings, holeSizes);
-        const otherPerforations = perforations.filter((p) => p.id !== perforation.id);
-        const widestPerfShapeDiameter = perfShapes.reduce((widest, perfShape) => (perfShape.diameter > widest ? perfShape.diameter : widest), 0);
-        this.drawComplexRope(perfShapes, this.createPerforationTexture(perforation, widestPerfShapeDiameter, otherPerforations));
-      });
-    }
   }
 
   private updateSymbolCache(symbols: { [key: string]: string }) {
@@ -524,11 +585,6 @@ export class SchematicLayer<T extends SchematicData> extends PixiLayer<T> {
     return this.cementPlugTextureCache;
   }
 
-  private createPerforationTexture(perforation: Perforation, widestPerfShapeDiameter: number, otherPerforations: Perforation[]): Texture {
-    const { perforationOptions } = this.options as SchematicLayerOptions<T>;
-    return createPerforationTexture(perforation, widestPerfShapeDiameter, otherPerforations, perforationOptions);
-  }
-
   private prepareSymbolRenderObject = (component: CompletionSymbol | PAndASymbol): SymbolRenderObject => {
     const { exaggerationFactor } = this.options as SchematicLayerOptions<T>;
 
@@ -660,7 +716,16 @@ export class SchematicLayer<T extends SchematicData> extends PixiLayer<T> {
     return result.filter((item) => item !== undefined).sort((a, b) => a.zIndex - b.zIndex);
   }
 
-  private drawComplexRope(intervals: ComplexRopeSegment[], texture: Texture): void {
+  /**
+   *
+   * @param intervals
+   * @param texture
+   * optionally fetch the exaggerationFactor from a different options prop
+   * options.perforationOptions for example
+   * @param getExaggerationFactor
+   * @returns
+   */
+  private drawComplexRope(intervals: ComplexRopeSegment[], texture: Texture): ComplexRope {
     if (intervals.length === 0) {
       return null;
     }
@@ -669,6 +734,8 @@ export class SchematicLayer<T extends SchematicData> extends PixiLayer<T> {
     const rope = new ComplexRope(texture, intervals, exaggerationFactor);
 
     this.addChild(rope);
+
+    return rope;
   }
 
   private static getOutlineClosureType = (index: number, maxIndex: number): OutlineClosure => {

package/src/layers/schematicInterfaces.ts

@@ -143,10 +143,6 @@ export interface Perforation {
    * is the perforation open or sealed?
    */
   isOpen: boolean;
-  /**
-   * Referenced Casing ids
-   */
-  referenceIds: string[];
 }
 
 export const foldPerforationSubKind = <T>(
@@ -184,41 +180,78 @@ export const foldPerforationSubKind = <T>(
   }
 };
 
-export const getPerforationsThatStartAtHoleDiameter = (perforations: Perforation[]) =>
-  perforations.filter((perf) =>
-    foldPerforationSubKind(
-      {
-        Perforation: () => true,
-        OpenHoleGravelPack: () => true,
-        OpenHoleFracPack: () => false,
-        CasedHoleFracturation: () => false,
-        CasedHoleGravelPack: () => false,
-        CasedHoleFracPack: () => false,
-      },
-      perf.subKind,
-    ),
+export const shouldPerforationStartAtHoleDiameter = (perf: Perforation) =>
+  foldPerforationSubKind(
+    {
+      Perforation: () => true,
+      OpenHoleGravelPack: () => true,
+      OpenHoleFracPack: () => false,
+      CasedHoleFracturation: () => false,
+      CasedHoleGravelPack: () => false,
+      CasedHoleFracPack: () => false,
+    },
+    perf.subKind,
   );
 
-export const getPerforationsThatSTartAtCasingDiameter = (perforations: Perforation[]) =>
-  perforations.filter((perf) =>
-    foldPerforationSubKind(
-      {
-        Perforation: () => false,
-        OpenHoleGravelPack: () => false,
-        OpenHoleFracPack: () => true,
-        CasedHoleFracturation: () => true,
-        CasedHoleGravelPack: () => true,
-        CasedHoleFracPack: () => true,
-      },
-      perf.subKind,
-    ),
+export const shouldPerforationStartAtCasingDiameter = (perf: Perforation) =>
+  foldPerforationSubKind(
+    {
+      Perforation: () => false,
+      OpenHoleGravelPack: () => false,
+      OpenHoleFracPack: () => true,
+      CasedHoleFracturation: () => true,
+      CasedHoleGravelPack: () => true,
+      CasedHoleFracPack: () => true,
+    },
+    perf.subKind,
   );
 
-export function hasGravelPack(perf: Perforation): boolean {
-  return foldPerforationSubKind(
+export const hasPacking = (perf: Perforation): boolean =>
+  foldPerforationSubKind(
     {
       Perforation: () => false,
       OpenHoleGravelPack: () => true,
+      OpenHoleFracPack: () => true,
+      CasedHoleFracturation: () => false,
+      CasedHoleGravelPack: () => true,
+      CasedHoleFracPack: () => true,
+    },
+    perf.subKind,
+  );
+
+export function hasFracLines(perf: Perforation): boolean {
+  return foldPerforationSubKind(
+    {
+      Perforation: () => false,
+      OpenHoleGravelPack: () => false,
+      OpenHoleFracPack: () => true,
+      CasedHoleFracturation: () => true,
+      CasedHoleGravelPack: () => false,
+      CasedHoleFracPack: () => true,
+    },
+    perf.subKind,
+  );
+}
+
+export function hasSpikes(perf: Perforation): boolean {
+  return foldPerforationSubKind(
+    {
+      Perforation: () => true,
+      OpenHoleGravelPack: () => false,
+      OpenHoleFracPack: () => false,
+      CasedHoleFracturation: () => false,
+      CasedHoleGravelPack: () => false,
+      CasedHoleFracPack: () => false,
+    },
+    perf.subKind,
+  );
+}
+
+export function isSubkindCasedHoleGravelPack(perf: Perforation): boolean {
+  return foldPerforationSubKind(
+    {
+      Perforation: () => false,
+      OpenHoleGravelPack: () => false,
       OpenHoleFracPack: () => false,
       CasedHoleFracturation: () => false,
       CasedHoleGravelPack: () => true,
@@ -353,11 +386,13 @@ export interface PerforationOptions {
   yellow: string;
   grey: string;
   red: string;
+  outline: string;
   transparent: string;
   spikeWidth: number;
+  spikeLength: number;
   packingOpacity: number;
   fracLineLength: number;
-  fracLineHalfWidth: number;
+  fracLineCurve: number;
   scalingFactor: number;
 }
 
@@ -366,12 +401,14 @@ export const defaultPerforationOptions: PerforationOptions = {
   yellow: '#FFFC00',
   grey: 'gray',
   red: '#FF5050',
+  outline: 'black',
   transparent: 'rgba(255, 255, 255, 0)',
-  spikeWidth: 25,
+  spikeWidth: 50,
+  spikeLength: 50,
   packingOpacity: 0.5,
-  fracLineHalfWidth: 10,
+  fracLineCurve: 10,
   fracLineLength: 25,
-  scalingFactor: 4,
+  scalingFactor: 25,
 };
 
 export interface CementOptions {