@equinor/esv-intersection 3.1.9 → 4.1.0

package/src/datautils/schematicShapeGenerator.ts

@@ -1,4 +1,4 @@
-import { groupD8, IPoint, Point, Rectangle, Texture, WRAP_MODES } from 'pixi.js';
+import { CanvasSource, groupD8, Point, Rectangle, Texture } from 'pixi.js';
 import { DEFAULT_TEXTURE_SIZE } from '../constants';
 import {
   Casing,
@@ -51,21 +51,34 @@ export interface CasingRenderObject {
 }
 
 export const getEndLines = (
-  rightPath: [IPoint, IPoint, ...IPoint[]],
-  leftPath: [IPoint, IPoint, ...IPoint[]],
+  rightPath: [Point, Point, ...Point[]],
+  leftPath: [Point, Point, ...Point[]],
 ): {
-  top: [IPoint, IPoint];
-  bottom: [IPoint, IPoint];
+  top: [Point, Point];
+  bottom: [Point, Point];
 } => {
   return {
     top: [rightPath[0], leftPath[0]],
-    bottom: [rightPath[rightPath.length - 1] as IPoint, leftPath[leftPath.length - 1] as IPoint],
+    bottom: [
+      rightPath[rightPath.length - 1] as Point,
+      leftPath[leftPath.length - 1] as Point,
+    ],
   };
 };
 
-export const overlaps = (top1: number, bottom1: number, top2: number, bottom2: number): boolean => top1 <= bottom2 && top2 <= bottom1;
+export const overlaps = (
+  top1: number,
+  bottom1: number,
+  top2: number,
+  bottom2: number,
+): boolean => top1 <= bottom2 && top2 <= bottom1;
 
-export const strictlyOverlaps = (top1: number, bottom1: number, top2: number, bottom2: number): boolean => top1 < bottom2 && top2 < bottom1;
+export const strictlyOverlaps = (
+  top1: number,
+  bottom1: number,
+  top2: number,
+  bottom2: number,
+): boolean => top1 < bottom2 && top2 < bottom1;
 
 export const uniq = <T>(arr: T[]): T[] => Array.from<T>(new Set(arr));
 
@@ -74,10 +87,18 @@ const findIntersectingItems = (
   end: number,
   otherStrings: (Casing | Completion)[],
   holes: HoleSize[],
-): { overlappingHoles: HoleSize[]; overlappingOuterStrings: (Casing | Completion)[] } => {
-  const overlappingHoles = holes.filter((hole: HoleSize) => overlaps(start, end, hole.start, hole.end));
+): {
+  overlappingHoles: HoleSize[];
+  overlappingOuterStrings: (Casing | Completion)[];
+} => {
+  const overlappingHoles = holes.filter((hole: HoleSize) =>
+    overlaps(start, end, hole.start, hole.end),
+  );
 
-  const overlappingOuterStrings = otherStrings.filter((casing: Casing | Completion) => overlaps(start, end, casing.start, casing.end));
+  const overlappingOuterStrings = otherStrings.filter(
+    (casing: Casing | Completion) =>
+      overlaps(start, end, casing.start, casing.end),
+  );
 
   return {
     overlappingHoles,
@@ -95,7 +116,9 @@ export const getUniqueDiameterChangeDepths = (
       d, // to find diameter right before/after object
     ) => [d.start - epsilon, d.start, d.end, d.end + epsilon],
   );
-  const trimmedChangedDepths = diameterChangeDepths.filter((d) => d >= intervalStart && d <= intervalEnd); // trim
+  const trimmedChangedDepths = diameterChangeDepths.filter(
+    d => d >= intervalStart && d <= intervalEnd,
+  ); // trim
 
   trimmedChangedDepths.push(intervalStart);
   trimmedChangedDepths.push(intervalEnd);
@@ -116,16 +139,30 @@ export const findCementOuterDiameterAtDepth = (
   const defaultCementWidth = 100; // Default to flow cement outside to show error in data
 
   const attachedStringAtDepth = attachedStrings.find(
-    (casingOrCompletion: Casing | Completion) => casingOrCompletion.start <= depth && casingOrCompletion.end >= depth,
+    (casingOrCompletion: Casing | Completion) =>
+      casingOrCompletion.start <= depth && casingOrCompletion.end >= depth,
   );
-  const attachedOuterDiameter = attachedStringAtDepth ? attachedStringAtDepth.diameter : 0;
+  const attachedOuterDiameter = attachedStringAtDepth
+    ? attachedStringAtDepth.diameter
+    : 0;
 
   const outerCasingAtDepth = nonAttachedStrings
-    .filter((casingOrCompletion: Casing | Completion) => getInnerStringDiameter(casingOrCompletion) > attachedOuterDiameter)
-    .sort((a: Casing | Completion, b: Casing | Completion) => getInnerStringDiameter(a) - getInnerStringDiameter(b)) // ascending
-    .find((casing) => casing.start <= depth && casing.end >= depth);
-
-  const holeAtDepth = holes.find((hole: HoleSize) => hole.start <= depth && hole.end >= depth && hole.diameter > attachedOuterDiameter);
+    .filter(
+      (casingOrCompletion: Casing | Completion) =>
+        getInnerStringDiameter(casingOrCompletion) > attachedOuterDiameter,
+    )
+    .sort(
+      (a: Casing | Completion, b: Casing | Completion) =>
+        getInnerStringDiameter(a) - getInnerStringDiameter(b),
+    ) // ascending
+    .find(casing => casing.start <= depth && casing.end >= depth);
+
+  const holeAtDepth = holes.find(
+    (hole: HoleSize) =>
+      hole.start <= depth &&
+      hole.end >= depth &&
+      hole.diameter > attachedOuterDiameter,
+  );
 
   if (outerCasingAtDepth) {
     return getInnerStringDiameter(outerCasingAtDepth);
@@ -147,12 +184,21 @@ export const findPerforationOuterDiameterAtDepth = (
   const defaultPerforationWidth = 100; // Default to flow perforation outside to show error in data
 
   const outerCasingAtDepth = nonAttachedStrings
-    .sort((a: Casing | Completion, b: Casing | Completion) => b.diameter - a.diameter) // descending
-    .find((casing) => casing.start <= depth && casing.end >= depth);
-
-  const holeAtDepth = holes.find((hole: HoleSize) => hole.start <= depth && hole.end >= depth);
+    .sort(
+      (a: Casing | Completion, b: Casing | Completion) =>
+        b.diameter - a.diameter,
+    ) // descending
+    .find(casing => casing.start <= depth && casing.end >= depth);
+
+  const holeAtDepth = holes.find(
+    (hole: HoleSize) => hole.start <= depth && hole.end >= depth,
+  );
 
-  if (outerCasingAtDepth && perforationSubKind !== 'Open hole frac pack' && perforationSubKind !== 'Open hole gravel pack') {
+  if (
+    outerCasingAtDepth &&
+    perforationSubKind !== 'Open hole frac pack' &&
+    perforationSubKind !== 'Open hole gravel pack'
+  ) {
     return getInnerStringDiameter(outerCasingAtDepth);
   }
 
@@ -172,27 +218,42 @@ export const findCementPlugInnerDiameterAtDepth = (
   // Default to flow cement outside to show error in data
   const defaultCementWidth = 100;
   const attachedStringAtDepth = attachedStrings
-    .sort((a: Casing | Completion, b: Casing | Completion) => getInnerStringDiameter(a) - getInnerStringDiameter(b)) // ascending
-    .find((casingOrCompletion) => casingOrCompletion.start <= depth && casingOrCompletion.end >= depth);
+    .sort(
+      (a: Casing | Completion, b: Casing | Completion) =>
+        getInnerStringDiameter(a) - getInnerStringDiameter(b),
+    ) // ascending
+    .find(
+      casingOrCompletion =>
+        casingOrCompletion.start <= depth && casingOrCompletion.end >= depth,
+    );
 
   if (attachedStringAtDepth) {
     return getInnerStringDiameter(attachedStringAtDepth);
   }
 
   // Start from an attached diameter
-  const minimumDiameter = attachedStrings.length ? Math.min(...attachedStrings.map((c) => getInnerStringDiameter(c))) : 0;
+  const minimumDiameter = attachedStrings.length
+    ? Math.min(...attachedStrings.map(c => getInnerStringDiameter(c)))
+    : 0;
   const nonAttachedStringAtDepth = nonAttachedStrings
-    .sort((a: Casing | Completion, b: Casing | Completion) => getInnerStringDiameter(a) - getInnerStringDiameter(b)) // ascending
+    .sort(
+      (a: Casing | Completion, b: Casing | Completion) =>
+        getInnerStringDiameter(a) - getInnerStringDiameter(b),
+    ) // ascending
     .find(
       (casingOrCompletion: Casing | Completion) =>
-        casingOrCompletion.start <= depth && casingOrCompletion.end >= depth && minimumDiameter <= getInnerStringDiameter(casingOrCompletion),
+        casingOrCompletion.start <= depth &&
+        casingOrCompletion.end >= depth &&
+        minimumDiameter <= getInnerStringDiameter(casingOrCompletion),
     );
 
   if (nonAttachedStringAtDepth) {
     return getInnerStringDiameter(nonAttachedStringAtDepth);
   }
 
-  const holeAtDepth = holes.find((hole) => hole.start <= depth && hole.end >= depth && hole.diameter);
+  const holeAtDepth = holes.find(
+    hole => hole.start <= depth && hole.end >= depth && hole.diameter,
+  );
 
   if (holeAtDepth) {
     return holeAtDepth.diameter;
@@ -209,36 +270,66 @@ export const createComplexRopeSegmentsForCement = (
   exaggerationFactor: number,
   getPoints: (start: number, end: number) => Point[],
 ): ComplexRopeSegment[] => {
-  const { attachedStrings, nonAttachedStrings } = splitByReferencedStrings(cement.referenceIds, casings, completion);
+  const { attachedStrings, nonAttachedStrings } = splitByReferencedStrings(
+    cement.referenceIds,
+    casings,
+    completion,
+  );
 
   if (attachedStrings.length === 0) {
-    throw new Error(`Invalid cement data, can't find referenced casing/completion string for cement with id '${cement.id}'`);
+    throw new Error(
+      `Invalid cement data, can't find referenced casing/completion string for cement with id '${cement.id}'`,
+    );
   }
 
   attachedStrings.sort((a, b) => a.end - b.end); // ascending
   const bottomOfCement = attachedStrings[attachedStrings.length - 1]!.end;
 
-  const { overlappingOuterStrings, overlappingHoles } = findIntersectingItems(cement.toc, bottomOfCement, nonAttachedStrings, holes);
+  const { overlappingOuterStrings, overlappingHoles } = findIntersectingItems(
+    cement.toc,
+    bottomOfCement,
+    nonAttachedStrings,
+    holes,
+  );
 
-  const outerDiameterIntervals = [...overlappingOuterStrings, ...overlappingHoles].map((d) => ({
+  const outerDiameterIntervals = [
+    ...overlappingOuterStrings,
+    ...overlappingHoles,
+  ].map(d => ({
     start: d.start,
     end: d.end,
   }));
 
-  const changeDepths = getUniqueDiameterChangeDepths([cement.toc, bottomOfCement], outerDiameterIntervals);
-
-  const diameterIntervals = changeDepths.flatMap((depth: number, index: number, list: number[]) => {
-    if (index === list.length - 1) {
-      return [];
-    }
+  const changeDepths = getUniqueDiameterChangeDepths(
+    [cement.toc, bottomOfCement],
+    outerDiameterIntervals,
+  );
 
-    const nextDepth = list[index + 1]!;
-    const diameterAtChangeDepth = findCementOuterDiameterAtDepth(attachedStrings, overlappingOuterStrings, overlappingHoles, depth);
+  const diameterIntervals = changeDepths.flatMap(
+    (depth: number, index: number, list: number[]) => {
+      if (index === list.length - 1) {
+        return [];
+      }
 
-    return [{ top: depth, bottom: nextDepth, diameter: diameterAtChangeDepth * exaggerationFactor }];
-  });
+      const nextDepth = list[index + 1]!;
+      const diameterAtChangeDepth = findCementOuterDiameterAtDepth(
+        attachedStrings,
+        overlappingOuterStrings,
+        overlappingHoles,
+        depth,
+      );
+
+      return [
+        {
+          top: depth,
+          bottom: nextDepth,
+          diameter: diameterAtChangeDepth * exaggerationFactor,
+        },
+      ];
+    },
+  );
 
-  const ropeSegments = diameterIntervals.map((interval) => ({
+  const ropeSegments = diameterIntervals.map(interval => ({
     diameter: interval.diameter,
     points: getPoints(interval.top, interval.bottom),
   }));
@@ -250,15 +341,24 @@ const splitByReferencedStrings = (
   referenceIds: string[],
   casings: Casing[],
   completion: Completion[],
-): { attachedStrings: (Casing | Completion)[]; nonAttachedStrings: (Casing | Completion)[] } =>
+): {
+  attachedStrings: (Casing | Completion)[];
+  nonAttachedStrings: (Casing | Completion)[];
+} =>
   [...casings, ...completion].reduce(
     (acc, current) => {
       if (referenceIds.includes(current.id)) {
         return { ...acc, attachedStrings: [...acc.attachedStrings, current] };
       }
-      return { ...acc, nonAttachedStrings: [...acc.nonAttachedStrings, current] };
+      return {
+        ...acc,
+        nonAttachedStrings: [...acc.nonAttachedStrings, current],
+      };
+    },
+    {
+      attachedStrings: [] as (Casing | Completion)[],
+      nonAttachedStrings: [] as (Casing | Completion)[],
     },
-    { attachedStrings: [] as (Casing | Completion)[], nonAttachedStrings: [] as (Casing | Completion)[] },
   );
 
 export const createComplexRopeSegmentsForCementSqueeze = (
@@ -269,20 +369,37 @@ export const createComplexRopeSegmentsForCementSqueeze = (
   exaggerationFactor: number,
   getPoints: (start: number, end: number) => Point[],
 ): ComplexRopeSegment[] => {
-  const { attachedStrings, nonAttachedStrings } = splitByReferencedStrings(squeeze.referenceIds, casings, completion);
+  const { attachedStrings, nonAttachedStrings } = splitByReferencedStrings(
+    squeeze.referenceIds,
+    casings,
+    completion,
+  );
 
   if (attachedStrings.length === 0) {
-    throw new Error(`Invalid cement squeeze data, can't find referenced casing/completion for squeeze with id '${squeeze.id}'`);
+    throw new Error(
+      `Invalid cement squeeze data, can't find referenced casing/completion for squeeze with id '${squeeze.id}'`,
+    );
   }
 
-  const { overlappingOuterStrings, overlappingHoles } = findIntersectingItems(squeeze.start, squeeze.end, nonAttachedStrings, holes);
+  const { overlappingOuterStrings, overlappingHoles } = findIntersectingItems(
+    squeeze.start,
+    squeeze.end,
+    nonAttachedStrings,
+    holes,
+  );
 
-  const outerDiameterIntervals = [...overlappingOuterStrings, ...overlappingHoles].map((d) => ({
+  const outerDiameterIntervals = [
+    ...overlappingOuterStrings,
+    ...overlappingHoles,
+  ].map(d => ({
     start: d.start,
     end: d.end,
   }));
 
-  const changeDepths = getUniqueDiameterChangeDepths([squeeze.start, squeeze.end], outerDiameterIntervals);
+  const changeDepths = getUniqueDiameterChangeDepths(
+    [squeeze.start, squeeze.end],
+    outerDiameterIntervals,
+  );
 
   const diameterIntervals = changeDepths.flatMap((depth, index, list) => {
     if (index === list.length - 1) {
@@ -291,12 +408,23 @@ export const createComplexRopeSegmentsForCementSqueeze = (
 
     const nextDepth = list[index + 1]!;
 
-    const diameterAtDepth = findCementOuterDiameterAtDepth(attachedStrings, overlappingOuterStrings, overlappingHoles, depth);
+    const diameterAtDepth = findCementOuterDiameterAtDepth(
+      attachedStrings,
+      overlappingOuterStrings,
+      overlappingHoles,
+      depth,
+    );
 
-    return [{ top: depth, bottom: nextDepth, diameter: diameterAtDepth * exaggerationFactor }];
+    return [
+      {
+        top: depth,
+        bottom: nextDepth,
+        diameter: diameterAtDepth * exaggerationFactor,
+      },
+    ];
   });
 
-  const ropeSegments = diameterIntervals.map((interval) => ({
+  const ropeSegments = diameterIntervals.map(interval => ({
     diameter: interval.diameter,
     points: getPoints(interval.top, interval.bottom),
   }));
@@ -312,15 +440,31 @@ export const createComplexRopeSegmentsForCementPlug = (
   exaggerationFactor: number,
   getPoints: (start: number, end: number) => Point[],
 ): ComplexRopeSegment[] => {
-  const { attachedStrings, nonAttachedStrings } = splitByReferencedStrings(plug.referenceIds, casings, completion);
+  const { attachedStrings, nonAttachedStrings } = splitByReferencedStrings(
+    plug.referenceIds,
+    casings,
+    completion,
+  );
 
-  const { overlappingHoles, overlappingOuterStrings } = findIntersectingItems(plug.start, plug.end, nonAttachedStrings, holes);
-  const innerDiameterIntervals = [...attachedStrings, ...overlappingHoles, ...overlappingOuterStrings].map((d) => ({
+  const { overlappingHoles, overlappingOuterStrings } = findIntersectingItems(
+    plug.start,
+    plug.end,
+    nonAttachedStrings,
+    holes,
+  );
+  const innerDiameterIntervals = [
+    ...attachedStrings,
+    ...overlappingHoles,
+    ...overlappingOuterStrings,
+  ].map(d => ({
     start: d.start,
     end: d.end,
   }));
 
-  const changeDepths = getUniqueDiameterChangeDepths([plug.start, plug.end], innerDiameterIntervals);
+  const changeDepths = getUniqueDiameterChangeDepths(
+    [plug.start, plug.end],
+    innerDiameterIntervals,
+  );
 
   const diameterIntervals = changeDepths.flatMap((depth, index, list) => {
     if (index === list.length - 1) {
@@ -328,12 +472,23 @@ export const createComplexRopeSegmentsForCementPlug = (
     }
 
     const nextDepth = list[index + 1]!;
-    const diameterAtDepth = findCementPlugInnerDiameterAtDepth(attachedStrings, overlappingOuterStrings, overlappingHoles, depth);
+    const diameterAtDepth = findCementPlugInnerDiameterAtDepth(
+      attachedStrings,
+      overlappingOuterStrings,
+      overlappingHoles,
+      depth,
+    );
 
-    return [{ top: depth, bottom: nextDepth, diameter: diameterAtDepth * exaggerationFactor }];
+    return [
+      {
+        top: depth,
+        bottom: nextDepth,
+        diameter: diameterAtDepth * exaggerationFactor,
+      },
+    ];
   });
 
-  const ropeSegments = diameterIntervals.map((interval) => ({
+  const ropeSegments = diameterIntervals.map(interval => ({
     diameter: interval.diameter,
     points: getPoints(interval.top, interval.bottom),
   }));
@@ -358,7 +513,11 @@ const createGradientFill = (
   return gradient;
 };
 
-export const createHoleBaseTexture = ({ firstColor, secondColor }: HoleOptions, width: number, height: number): Texture => {
+export const createHoleBaseTexture = (
+  { firstColor, secondColor }: HoleOptions,
+  width: number,
+  height: number,
+): Texture => {
   const canvas = document.createElement('canvas');
   canvas.width = width;
   canvas.height = height;
@@ -368,13 +527,21 @@ export const createHoleBaseTexture = ({ firstColor, secondColor }: HoleOptions,
     throw Error('Could not get canvas context!');
   }
 
-  canvasCtx.fillStyle = createGradientFill(canvas, canvasCtx, firstColor, secondColor, 0);
+  canvasCtx.fillStyle = createGradientFill(
+    canvas,
+    canvasCtx,
+    firstColor,
+    secondColor,
+    0,
+  );
   canvasCtx.fillRect(0, 0, canvas.width, canvas.height);
 
   return Texture.from(canvas);
 };
 
-export const createScreenTexture = ({ scalingFactor }: ScreenOptions): Texture => {
+export const createScreenTexture = ({
+  scalingFactor,
+}: ScreenOptions): Texture => {
   const canvas = document.createElement('canvas');
   const size = DEFAULT_TEXTURE_SIZE * scalingFactor;
   canvas.width = size;
@@ -395,13 +562,20 @@ export const createScreenTexture = ({ scalingFactor }: ScreenOptions): Texture =
   const distanceBetweenLines = size / 3;
   for (let i = -canvas.width; i < canvas.width; i++) {
     canvasCtx.moveTo(-canvas.width + distanceBetweenLines * i, -canvas.height);
-    canvasCtx.lineTo(canvas.width + distanceBetweenLines * i, canvas.height * 2);
+    canvasCtx.lineTo(
+      canvas.width + distanceBetweenLines * i,
+      canvas.height * 2,
+    );
   }
   canvasCtx.stroke();
   return Texture.from(canvas);
 };
 
-export const createTubingTexture = ({ innerColor, outerColor, scalingFactor }: TubingOptions): Texture => {
+export const createTubingTexture = ({
+  innerColor,
+  outerColor,
+  scalingFactor,
+}: TubingOptions): Texture => {
   const size = DEFAULT_TEXTURE_SIZE * scalingFactor;
 
   const canvas = document.createElement('canvas');
@@ -427,7 +601,11 @@ export const createTubingTexture = ({ innerColor, outerColor, scalingFactor }: T
   return Texture.from(canvas);
 };
 
-export const createCementTexture = ({ firstColor, secondColor, scalingFactor }: CementOptions): Texture => {
+export const createCementTexture = ({
+  firstColor,
+  secondColor,
+  scalingFactor,
+}: CementOptions): Texture => {
   const canvas = document.createElement('canvas');
 
   const size = DEFAULT_TEXTURE_SIZE * scalingFactor;
@@ -456,7 +634,11 @@ export const createCementTexture = ({ firstColor, secondColor, scalingFactor }:
   return Texture.from(canvas);
 };
 
-export const createCementPlugTexture = ({ firstColor, secondColor, scalingFactor }: CementPlugOptions): Texture => {
+export const createCementPlugTexture = ({
+  firstColor,
+  secondColor,
+  scalingFactor,
+}: CementPlugOptions): Texture => {
   const canvas = document.createElement('canvas');
 
   const size = DEFAULT_TEXTURE_SIZE * scalingFactor;
@@ -478,14 +660,21 @@ export const createCementPlugTexture = ({ firstColor, secondColor, scalingFactor
   const distanceBetweenLines = size / 12;
   for (let i = -canvas.width; i < canvas.width; i++) {
     canvasCtx.moveTo(-canvas.width + distanceBetweenLines * i, -canvas.height);
-    canvasCtx.lineTo(canvas.width + distanceBetweenLines * i, canvas.height * 2);
+    canvasCtx.lineTo(
+      canvas.width + distanceBetweenLines * i,
+      canvas.height * 2,
+    );
   }
   canvasCtx.stroke();
 
   return Texture.from(canvas);
 };
 
-export const createCementSqueezeTexture = ({ firstColor, secondColor, scalingFactor }: CementSqueezeOptions): Texture => {
+export const createCementSqueezeTexture = ({
+  firstColor,
+  secondColor,
+  scalingFactor,
+}: CementSqueezeOptions): Texture => {
   const canvas = document.createElement('canvas');
 
   const size = DEFAULT_TEXTURE_SIZE * scalingFactor;
@@ -509,14 +698,20 @@ export const createCementSqueezeTexture = ({ firstColor, secondColor, scalingFac
   const distanceBetweenLines = size / 12;
   for (let i = -canvas.width; i < canvas.width; i++) {
     canvasCtx.moveTo(-canvas.width + distanceBetweenLines * i, -canvas.height);
-    canvasCtx.lineTo(canvas.width + distanceBetweenLines * i, canvas.height * 2);
+    canvasCtx.lineTo(
+      canvas.width + distanceBetweenLines * i,
+      canvas.height * 2,
+    );
   }
   canvasCtx.stroke();
 
   return Texture.from(canvas);
 };
 
-export const createTubularRenderingObject = (radius: number, pathPoints: IPoint[]): TubularRenderingObject => {
+export const createTubularRenderingObject = (
+  radius: number,
+  pathPoints: Point[],
+): TubularRenderingObject => {
   const normals = createNormals(pathPoints);
   const rightPath = offsetPoints(pathPoints, normals, radius);
   const leftPath = offsetPoints(pathPoints, normals, -radius);
@@ -530,23 +725,46 @@ export type CasingInterval = {
   end: number;
 };
 
-const createCasingInterval = (start: number, end: number): CasingInterval => ({ kind: 'casing', start, end });
-const createCasingWindowInterval = (start: number, end: number): CasingInterval => ({ kind: 'casing-window', start, end });
+const createCasingInterval = (start: number, end: number): CasingInterval => ({
+  kind: 'casing',
+  start,
+  end,
+});
+const createCasingWindowInterval = (
+  start: number,
+  end: number,
+): CasingInterval => ({ kind: 'casing-window', start, end });
 
-export const getCasingIntervalsWithWindows = (casing: Casing): CasingInterval[] => {
+export const getCasingIntervalsWithWindows = (
+  casing: Casing,
+): CasingInterval[] => {
   const result = (casing.windows || [])
-    .filter((cw: CasingWindow) => strictlyOverlaps(casing.start, casing.end, cw.start, cw.end))
+    .filter((cw: CasingWindow) =>
+      strictlyOverlaps(casing.start, casing.end, cw.start, cw.end),
+    )
     .reduce<{ intervals: CasingInterval[]; lastBottom: number }>(
-      ({ intervals, lastBottom }, currentWindow: CasingWindow, index: number, list: CasingWindow[]) => {
+      (
+        { intervals, lastBottom },
+        currentWindow: CasingWindow,
+        index: number,
+        list: CasingWindow[],
+      ) => {
         const startCasingInterval: CasingInterval | null =
           // last bottom before current start?
-          lastBottom < currentWindow.start ? createCasingInterval(lastBottom, currentWindow.start) : null;
+          lastBottom < currentWindow.start
+            ? createCasingInterval(lastBottom, currentWindow.start)
+            : null;
 
-        const updatedLastBottom = startCasingInterval ? startCasingInterval.end : lastBottom;
+        const updatedLastBottom = startCasingInterval
+          ? startCasingInterval.end
+          : lastBottom;
 
         const windowStart = Math.max(updatedLastBottom, currentWindow.start);
         const windowEnd = Math.min(casing.end, currentWindow.end);
-        const windowInterval: CasingInterval = createCasingWindowInterval(windowStart, windowEnd);
+        const windowInterval: CasingInterval = createCasingWindowInterval(
+          windowStart,
+          windowEnd,
+        );
 
         const nextLastBottom = windowEnd;
 
@@ -558,9 +776,16 @@ export const getCasingIntervalsWithWindows = (casing: Casing): CasingInterval[]
             ? createCasingInterval(nextLastBottom, casing.end)
             : null;
 
-        const newIntervals: CasingInterval[] = [startCasingInterval, windowInterval, endCasingInterval].filter((i): i is CasingInterval => i != null);
+        const newIntervals: CasingInterval[] = [
+          startCasingInterval,
+          windowInterval,
+          endCasingInterval,
+        ].filter((i): i is CasingInterval => i != null);
 
-        return { intervals: [...intervals, ...newIntervals], lastBottom: nextLastBottom };
+        return {
+          intervals: [...intervals, ...newIntervals],
+          lastBottom: nextLastBottom,
+        };
       },
       { intervals: [], lastBottom: casing.start },
     );
@@ -583,11 +808,19 @@ export const prepareCasingRenderObject = (
   const exaggeratedInnerRadius = exaggeratedInnerDiameter / 2;
   const casingWallWidth = exaggeratedRadius - exaggeratedInnerRadius;
 
-  const sections = getCasingIntervalsWithWindows(casing).map((casingInterval: CasingInterval) => {
-    const pathPoints = getPathPoints(casingInterval.start, casingInterval.end);
-    const { leftPath, rightPath } = createTubularRenderingObject(exaggeratedRadius, pathPoints);
-    return { kind: casingInterval.kind, leftPath, rightPath, pathPoints };
-  });
+  const sections = getCasingIntervalsWithWindows(casing).map(
+    (casingInterval: CasingInterval) => {
+      const pathPoints = getPathPoints(
+        casingInterval.start,
+        casingInterval.end,
+      );
+      const { leftPath, rightPath } = createTubularRenderingObject(
+        exaggeratedRadius,
+        pathPoints,
+      );
+      return { kind: casingInterval.kind, leftPath, rightPath, pathPoints };
+    },
+  );
 
   return {
     kind: 'casing',
@@ -608,14 +841,25 @@ export const createComplexRopeSegmentsForPerforation = (
   exaggerationFactor: number,
   getPoints: (start: number, end: number) => Point[],
 ): ComplexRopeSegment[] => {
-  const { overlappingOuterStrings, overlappingHoles } = findIntersectingItems(perforation.start, perforation.end, casings, holes);
+  const { overlappingOuterStrings, overlappingHoles } = findIntersectingItems(
+    perforation.start,
+    perforation.end,
+    casings,
+    holes,
+  );
 
-  const outerDiameterIntervals = [...overlappingOuterStrings, ...overlappingHoles].map((d) => ({
+  const outerDiameterIntervals = [
+    ...overlappingOuterStrings,
+    ...overlappingHoles,
+  ].map(d => ({
     start: d.start,
     end: d.end,
   }));
 
-  const changeDepths = getUniqueDiameterChangeDepths([perforation.start, perforation.end], outerDiameterIntervals);
+  const changeDepths = getUniqueDiameterChangeDepths(
+    [perforation.start, perforation.end],
+    outerDiameterIntervals,
+  );
 
   const diameterIntervals = changeDepths.flatMap((depth, index, list) => {
     if (index === list.length - 1) {
@@ -624,12 +868,23 @@ export const createComplexRopeSegmentsForPerforation = (
 
     const nextDepth = list[index + 1]!;
 
-    const diameterAtDepth = findPerforationOuterDiameterAtDepth(overlappingOuterStrings, overlappingHoles, depth, perforation.subKind);
+    const diameterAtDepth = findPerforationOuterDiameterAtDepth(
+      overlappingOuterStrings,
+      overlappingHoles,
+      depth,
+      perforation.subKind,
+    );
 
-    return [{ top: depth, bottom: nextDepth, diameter: diameterAtDepth * exaggerationFactor }];
+    return [
+      {
+        top: depth,
+        bottom: nextDepth,
+        diameter: diameterAtDepth * exaggerationFactor,
+      },
+    ];
   });
 
-  const ropeSegments = diameterIntervals.map((interval) => {
+  const ropeSegments = diameterIntervals.map(interval => {
     const points = getPoints(interval.top, interval.bottom);
 
     const diameter = interval.diameter;
@@ -643,7 +898,11 @@ export const createComplexRopeSegmentsForPerforation = (
   return ropeSegments;
 };
 
-const drawPacking = (canvas: HTMLCanvasElement, ctx: CanvasRenderingContext2D, perforationOptions: PerforationOptions) => {
+const drawPacking = (
+  canvas: HTMLCanvasElement,
+  ctx: CanvasRenderingContext2D,
+  perforationOptions: PerforationOptions,
+) => {
   const { packingOpacity, yellow } = perforationOptions;
 
   ctx.fillStyle = yellow;
@@ -669,7 +928,8 @@ const drawFracLines = (
   const amountOfSpikes = 10;
   const spikeWidth = canvas.width / amountOfSpikes;
 
-  const diameter = (extendedPerfShapeDiameter / 3) * perforationOptions.scalingFactor;
+  const diameter =
+    (extendedPerfShapeDiameter / 3) * perforationOptions.scalingFactor;
 
   const fracLineLength = diameter / 4;
   const spikeLength = diameter / 2;
@@ -680,15 +940,27 @@ const drawFracLines = (
 
   const fracLines = () => {
     for (let i = -1; i < amountOfSpikes; i++) {
-      const bottom: [number, number] = [i * spikeWidth + offsetX + spikeWidth / 2, canvas.height / 2 - fracLineLength - offsetY - fracLineLength];
+      const bottom: [number, number] = [
+        i * spikeWidth + offsetX + spikeWidth / 2,
+        canvas.height / 2 - fracLineLength - offsetY - fracLineLength,
+      ];
 
       ctx.beginPath();
 
       const start: [number, number] = [...bottom];
-      const controlPoint1: [number, number] = [bottom[0] - fracLineCurve * 2, bottom[1] - fracLineLength / 4];
-      const middle: [number, number] = [bottom[0], bottom[1] - fracLineLength / 2];
-
-      const controlPoint2: [number, number] = [bottom[0] + fracLineCurve * 2, bottom[1] - fracLineLength / 2 - fracLineLength / 4];
+      const controlPoint1: [number, number] = [
+        bottom[0] - fracLineCurve * 2,
+        bottom[1] - fracLineLength / 4,
+      ];
+      const middle: [number, number] = [
+        bottom[0],
+        bottom[1] - fracLineLength / 2,
+      ];
+
+      const controlPoint2: [number, number] = [
+        bottom[0] + fracLineCurve * 2,
+        bottom[1] - fracLineLength / 2 - fracLineLength / 4,
+      ];
       const end: [number, number] = [bottom[0], bottom[1] - fracLineLength];
 
       ctx.bezierCurveTo(...start, ...controlPoint1, ...middle);
@@ -698,15 +970,27 @@ const drawFracLines = (
     }
 
     for (let i = -1; i < amountOfSpikes; i++) {
-      const bottom: [number, number] = [i * spikeWidth + spikeWidth + offsetX + spikeWidth / 2, canvas.height / 2 + diameter / 2 + offsetY];
+      const bottom: [number, number] = [
+        i * spikeWidth + spikeWidth + offsetX + spikeWidth / 2,
+        canvas.height / 2 + diameter / 2 + offsetY,
+      ];
 
       ctx.beginPath();
 
       const start: [number, number] = [...bottom];
-      const controlPoint1: [number, number] = [bottom[0] - fracLineCurve * 2, bottom[1] + fracLineLength / 4];
-      const middle: [number, number] = [bottom[0], bottom[1] + fracLineLength / 2];
-
-      const controlPoint2: [number, number] = [bottom[0] + fracLineCurve * 2, bottom[1] + fracLineLength / 2 + fracLineLength / 4];
+      const controlPoint1: [number, number] = [
+        bottom[0] - fracLineCurve * 2,
+        bottom[1] + fracLineLength / 4,
+      ];
+      const middle: [number, number] = [
+        bottom[0],
+        bottom[1] + fracLineLength / 2,
+      ];
+
+      const controlPoint2: [number, number] = [
+        bottom[0] + fracLineCurve * 2,
+        bottom[1] + fracLineLength / 2 + fracLineLength / 4,
+      ];
       const end: [number, number] = [bottom[0], bottom[1] + fracLineLength];
 
       ctx.bezierCurveTo(...start, ...controlPoint1, ...middle);
@@ -738,15 +1022,22 @@ const drawSpikes = (
   const spikeWidth = canvas.width / amountOfSpikes;
   ctx.strokeStyle = perforationOptions.outline;
 
-  const diameter = (extendedPerfShapeDiameter / 3) * perforationOptions.scalingFactor;
+  const diameter =
+    (extendedPerfShapeDiameter / 3) * perforationOptions.scalingFactor;
 
   ctx.lineWidth = 1;
   const spikeLength = diameter / 2;
 
   // left spikes
   for (let i = 0; i <= amountOfSpikes; i++) {
-    const left: [number, number] = [i * spikeWidth, canvas.height / 2 - diameter / 2];
-    const bottom: [number, number] = [left[0] - spikeWidth / 2, left[1] - spikeLength];
+    const left: [number, number] = [
+      i * spikeWidth,
+      canvas.height / 2 - diameter / 2,
+    ];
+    const bottom: [number, number] = [
+      left[0] - spikeWidth / 2,
+      left[1] - spikeLength,
+    ];
     const right: [number, number] = [left[0] - spikeWidth, left[1]];
 
     ctx.beginPath();
@@ -761,8 +1052,14 @@ const drawSpikes = (
 
   // right spikes
   for (let i = 0; i <= amountOfSpikes; i++) {
-    const left: [number, number] = [i * spikeWidth, canvas.height / 2 + diameter / 2];
-    const bottom: [number, number] = [left[0] - spikeWidth / 2, left[1] + spikeLength];
+    const left: [number, number] = [
+      i * spikeWidth,
+      canvas.height / 2 + diameter / 2,
+    ];
+    const bottom: [number, number] = [
+      left[0] - spikeWidth / 2,
+      left[1] + spikeLength,
+    ];
     const right: [number, number] = [left[0] - spikeWidth, left[1]];
 
     ctx.beginPath();
@@ -780,7 +1077,13 @@ const drawSpikes = (
 
 // for visual debugging
 // if this shoes up, something is wrong
-const errorTexture = (errorMessage = 'Error!', existingContext?: { canvas: HTMLCanvasElement; canvasCtx: CanvasRenderingContext2D }) => {
+const errorTexture = (
+  errorMessage = 'Error!',
+  existingContext?: {
+    canvas: HTMLCanvasElement;
+    canvasCtx: CanvasRenderingContext2D;
+  },
+) => {
   console.error(`${errorMessage}`);
   const canvas = existingContext?.canvas || document.createElement('canvas');
 
@@ -798,13 +1101,15 @@ const errorTexture = (errorMessage = 'Error!', existingContext?: { canvas: HTMLC
   canvasCtx.fillStyle = '#ff00ff';
   canvasCtx.fillRect(...xy, ...wh);
 
-  const texture = new Texture(
-    Texture.from(canvas, { wrapMode: WRAP_MODES.CLAMP }).baseTexture,
-    undefined,
-    new Rectangle(0, 0, canvas.width, canvas.height),
-    undefined,
-    groupD8.MIRROR_HORIZONTAL,
-  );
+  const texture = new Texture({
+    source: new CanvasSource({
+      resource: canvas,
+      wrapMode: 'clamp-to-edge',
+    }),
+    orig: new Rectangle(0, 0, canvas.width, canvas.height),
+    rotate: groupD8.MIRROR_HORIZONTAL,
+  });
+
   return texture;
 };
 
@@ -827,19 +1132,22 @@ const createPerforationCanvas = (
 };
 
 const createPerforationTexture = (canvas: HTMLCanvasElement) => {
-  const texture = new Texture(
-    Texture.from(canvas, { wrapMode: WRAP_MODES.CLAMP }).baseTexture,
-    undefined,
-    new Rectangle(0, 0, canvas.width, canvas.height),
-    undefined,
-    groupD8.MIRROR_HORIZONTAL,
-  );
+  const texture = new Texture({
+    source: new CanvasSource({
+      resource: canvas,
+    }),
+    orig: new Rectangle(0, 0, canvas.width, canvas.height),
+    rotate: groupD8.MIRROR_HORIZONTAL,
+  });
   return texture;
 };
 
 const compareIntersectingPerforationsBy =
-  (targetPerf: Perforation, comparedPerforations: Perforation[]) => (compareFunc: (comparedPerf: Perforation) => boolean) =>
-    comparedPerforations.some((perf) => compareFunc(perf) && intersect(targetPerf, perf));
+  (targetPerf: Perforation, comparedPerforations: Perforation[]) =>
+  (compareFunc: (comparedPerf: Perforation) => boolean) =>
+    comparedPerforations.some(
+      perf => compareFunc(perf) && intersect(targetPerf, perf),
+    );
 
 /**
  * @Perforation
@@ -869,19 +1177,36 @@ const createSubkindPerforationTexture = {
     otherPerforations: Perforation[],
     perforationOptions: PerforationOptions,
   ): Texture => {
-    const { canvas, ctx } = createPerforationCanvas(perfShape, perforationOptions);
+    const { canvas, ctx } = createPerforationCanvas(
+      perfShape,
+      perforationOptions,
+    );
 
-    const compareBy = compareIntersectingPerforationsBy(perforation, otherPerforations);
+    const compareBy = compareIntersectingPerforationsBy(
+      perforation,
+      otherPerforations,
+    );
 
-    const intersectionsWithCasedHoleGravel: boolean = compareBy(isSubkindCasedHoleGravelPack);
+    const intersectionsWithCasedHoleGravel: boolean = compareBy(
+      isSubkindCasedHoleGravelPack,
+    );
 
-    const intersectsWithCasedHoleFracturation: boolean = compareBy(isSubKindCasedHoleFracturation);
+    const intersectsWithCasedHoleFracturation: boolean = compareBy(
+      isSubKindCasedHoleFracturation,
+    );
 
-    const intersectionsWithCasedHoleFracPack: boolean = compareBy(isSubKindCasedHoleFracPack);
+    const intersectionsWithCasedHoleFracPack: boolean = compareBy(
+      isSubKindCasedHoleFracPack,
+    );
 
-    const intersectsWithPerforation = intersectionsWithCasedHoleGravel || intersectsWithCasedHoleFracturation || intersectionsWithCasedHoleFracPack;
+    const intersectsWithPerforation =
+      intersectionsWithCasedHoleGravel ||
+      intersectsWithCasedHoleFracturation ||
+      intersectionsWithCasedHoleFracPack;
 
-    const openPerforationSpikeColor = intersectsWithPerforation ? perforationOptions.yellow : perforationOptions.red;
+    const openPerforationSpikeColor = intersectsWithPerforation
+      ? perforationOptions.yellow
+      : perforationOptions.red;
 
     ctx.globalAlpha = perforationOptions.packingOpacity;
     if (perforation.isOpen) {
@@ -895,7 +1220,13 @@ const createSubkindPerforationTexture = {
     drawSpikes(canvas, ctx, perfShape.diameter, perforationOptions);
 
     if (intersectionsWithCasedHoleFracPack) {
-      drawFracLines(canvas, ctx, perfShape.diameter, perforationOptions, 'spike');
+      drawFracLines(
+        canvas,
+        ctx,
+        perfShape.diameter,
+        perforationOptions,
+        'spike',
+      );
     }
 
     return createPerforationTexture(canvas);
@@ -908,9 +1239,21 @@ const createSubkindPerforationTexture = {
  */
 const createSubkindCasedHoleFracturationTexture = {
   packing: () => errorTexture(),
-  fracLines: (perfShape: ComplexRopeSegment, perforationOptions: PerforationOptions): Texture => {
-    const { canvas, ctx } = createPerforationCanvas(perfShape, perforationOptions);
-    drawFracLines(canvas, ctx, perfShape.diameter, perforationOptions, 'diameter');
+  fracLines: (
+    perfShape: ComplexRopeSegment,
+    perforationOptions: PerforationOptions,
+  ): Texture => {
+    const { canvas, ctx } = createPerforationCanvas(
+      perfShape,
+      perforationOptions,
+    );
+    drawFracLines(
+      canvas,
+      ctx,
+      perfShape.diameter,
+      perforationOptions,
+      'diameter',
+    );
     return createPerforationTexture(canvas);
   },
   spikes: () => errorTexture(),
@@ -924,12 +1267,21 @@ const createSubkindCasedHoleFracturationTexture = {
  * If a perforation of type "perforation" is overlapping, the fracturation lines extends from the tip of the perforation spikes into formation.
  */
 const createSubkindCasedHoleFracPackTexture = {
-  packing: (perfShape: ComplexRopeSegment, perforationOptions: PerforationOptions): Texture => {
-    const { canvas, ctx } = createPerforationCanvas(perfShape, perforationOptions);
+  packing: (
+    perfShape: ComplexRopeSegment,
+    perforationOptions: PerforationOptions,
+  ): Texture => {
+    const { canvas, ctx } = createPerforationCanvas(
+      perfShape,
+      perforationOptions,
+    );
     drawPacking(canvas, ctx, perforationOptions);
     return createPerforationTexture(canvas);
   },
-  fracLines: (perfShape: ComplexRopeSegment, perforationOptions: PerforationOptions) => {
+  fracLines: (
+    perfShape: ComplexRopeSegment,
+    perforationOptions: PerforationOptions,
+  ) => {
     const { canvas } = createPerforationCanvas(perfShape, perforationOptions);
     return createPerforationTexture(canvas);
   },
@@ -941,8 +1293,14 @@ const createSubkindCasedHoleFracPackTexture = {
  * Yellow gravel. Makes perforations of type "Perforation" yellow if overlapping and perforation are open.
  */
 const createSubkindCasedHoleGravelPackTexture = {
-  packing: (perfShape: ComplexRopeSegment, perforationOptions: PerforationOptions): Texture => {
-    const { canvas, ctx } = createPerforationCanvas(perfShape, perforationOptions);
+  packing: (
+    perfShape: ComplexRopeSegment,
+    perforationOptions: PerforationOptions,
+  ): Texture => {
+    const { canvas, ctx } = createPerforationCanvas(
+      perfShape,
+      perforationOptions,
+    );
     drawPacking(canvas, ctx, perforationOptions);
     return createPerforationTexture(canvas);
   },
@@ -955,8 +1313,14 @@ const createSubkindCasedHoleGravelPackTexture = {
  * Yellow gravel
  */
 const createSubkindOpenHoleGravelPackTexture = {
-  packing: (perfShape: ComplexRopeSegment, perforationOptions: PerforationOptions) => {
-    const { canvas, ctx } = createPerforationCanvas(perfShape, perforationOptions);
+  packing: (
+    perfShape: ComplexRopeSegment,
+    perforationOptions: PerforationOptions,
+  ) => {
+    const { canvas, ctx } = createPerforationCanvas(
+      perfShape,
+      perforationOptions,
+    );
     drawPacking(canvas, ctx, perforationOptions);
     return createPerforationTexture(canvas);
   },
@@ -969,14 +1333,33 @@ const createSubkindOpenHoleGravelPackTexture = {
  * Yellow gravel. Yellow frac lines from hole OD into formation
  */
 const createSubkindOpenHoleFracPackTexture = {
-  packing: (_perforation: Perforation, perfShape: ComplexRopeSegment, perforationOptions: PerforationOptions) => {
-    const { canvas, ctx } = createPerforationCanvas(perfShape, perforationOptions);
+  packing: (
+    _perforation: Perforation,
+    perfShape: ComplexRopeSegment,
+    perforationOptions: PerforationOptions,
+  ) => {
+    const { canvas, ctx } = createPerforationCanvas(
+      perfShape,
+      perforationOptions,
+    );
     drawPacking(canvas, ctx, perforationOptions);
     return createPerforationTexture(canvas);
   },
-  fracLines: (perfShape: ComplexRopeSegment, perforationOptions: PerforationOptions): Texture => {
-    const { canvas, ctx } = createPerforationCanvas(perfShape, perforationOptions);
-    drawFracLines(canvas, ctx, perfShape.diameter, perforationOptions, 'diameter');
+  fracLines: (
+    perfShape: ComplexRopeSegment,
+    perforationOptions: PerforationOptions,
+  ): Texture => {
+    const { canvas, ctx } = createPerforationCanvas(
+      perfShape,
+      perforationOptions,
+    );
+    drawFracLines(
+      canvas,
+      ctx,
+      perfShape.diameter,
+      perforationOptions,
+      'diameter',
+    );
     return createPerforationTexture(canvas);
   },
   spikes: () => errorTexture(),
@@ -990,11 +1373,32 @@ export const createPerforationPackingTexture = (
   return foldPerforationSubKind(
     {
       Perforation: () => createSubkindPerforationTexture.packing(),
-      CasedHoleFracturation: () => createSubkindCasedHoleFracPackTexture.packing(perfShape, perforationOptions),
-      CasedHoleFracPack: () => createSubkindCasedHoleFracPackTexture.packing(perfShape, perforationOptions),
-      OpenHoleGravelPack: () => createSubkindOpenHoleGravelPackTexture.packing(perfShape, perforationOptions),
-      OpenHoleFracPack: () => createSubkindOpenHoleFracPackTexture.packing(perforation, perfShape, perforationOptions),
-      CasedHoleGravelPack: () => createSubkindCasedHoleGravelPackTexture.packing(perfShape, perforationOptions),
+      CasedHoleFracturation: () =>
+        createSubkindCasedHoleFracPackTexture.packing(
+          perfShape,
+          perforationOptions,
+        ),
+      CasedHoleFracPack: () =>
+        createSubkindCasedHoleFracPackTexture.packing(
+          perfShape,
+          perforationOptions,
+        ),
+      OpenHoleGravelPack: () =>
+        createSubkindOpenHoleGravelPackTexture.packing(
+          perfShape,
+          perforationOptions,
+        ),
+      OpenHoleFracPack: () =>
+        createSubkindOpenHoleFracPackTexture.packing(
+          perforation,
+          perfShape,
+          perforationOptions,
+        ),
+      CasedHoleGravelPack: () =>
+        createSubkindCasedHoleGravelPackTexture.packing(
+          perfShape,
+          perforationOptions,
+        ),
     },
     perforation.subKind,
   );
@@ -1008,11 +1412,25 @@ export const createPerforationFracLineTexture = (
   return foldPerforationSubKind(
     {
       Perforation: () => createSubkindPerforationTexture.fracLines(),
-      OpenHoleGravelPack: () => createSubkindOpenHoleGravelPackTexture.fracLines(),
-      OpenHoleFracPack: () => createSubkindOpenHoleFracPackTexture.fracLines(perfShape, perforationOptions),
-      CasedHoleFracturation: () => createSubkindCasedHoleFracturationTexture.fracLines(perfShape, perforationOptions),
-      CasedHoleGravelPack: () => createSubkindCasedHoleGravelPackTexture.fracLines(),
-      CasedHoleFracPack: () => createSubkindCasedHoleFracPackTexture.fracLines(perfShape, perforationOptions),
+      OpenHoleGravelPack: () =>
+        createSubkindOpenHoleGravelPackTexture.fracLines(),
+      OpenHoleFracPack: () =>
+        createSubkindOpenHoleFracPackTexture.fracLines(
+          perfShape,
+          perforationOptions,
+        ),
+      CasedHoleFracturation: () =>
+        createSubkindCasedHoleFracturationTexture.fracLines(
+          perfShape,
+          perforationOptions,
+        ),
+      CasedHoleGravelPack: () =>
+        createSubkindCasedHoleGravelPackTexture.fracLines(),
+      CasedHoleFracPack: () =>
+        createSubkindCasedHoleFracPackTexture.fracLines(
+          perfShape,
+          perforationOptions,
+        ),
     },
     perforation.subKind,
   );
@@ -1026,11 +1444,19 @@ export const createPerforationSpikeTexture = (
 ): Texture => {
   return foldPerforationSubKind(
     {
-      Perforation: () => createSubkindPerforationTexture.spikes(perforation, perfShape, otherPerforations, perforationOptions),
+      Perforation: () =>
+        createSubkindPerforationTexture.spikes(
+          perforation,
+          perfShape,
+          otherPerforations,
+          perforationOptions,
+        ),
       OpenHoleGravelPack: () => createSubkindOpenHoleGravelPackTexture.spikes(),
       OpenHoleFracPack: () => createSubkindOpenHoleFracPackTexture.spikes(),
-      CasedHoleFracturation: () => createSubkindCasedHoleFracturationTexture.spikes(),
-      CasedHoleGravelPack: () => createSubkindCasedHoleGravelPackTexture.spikes(),
+      CasedHoleFracturation: () =>
+        createSubkindCasedHoleFracturationTexture.spikes(),
+      CasedHoleGravelPack: () =>
+        createSubkindCasedHoleGravelPackTexture.spikes(),
       CasedHoleFracPack: () => createSubkindCasedHoleFracPackTexture.spikes(),
     },
     perforation.subKind,