@equinor/esv-intersection 4.0.0 → 4.1.1

package/src/datautils/seismicimage.ts

@@ -16,7 +16,9 @@ export type SeismicInfo = {
   };
 };
 
-export const getSeismicOptions = (info: SeismicInfo | null): SeismicCanvasDataOptions => {
+export const getSeismicOptions = (
+  info: SeismicInfo | null,
+): SeismicCanvasDataOptions => {
   if (!info) {
     return {
       x: 0,
@@ -40,20 +42,36 @@ export const getSeismicOptions = (info: SeismicInfo | null): SeismicCanvasDataOp
  * @param trajectory Wellbore or freehand trajectory
  * @return  Key domain and depth information for seismic data
  */
-export function getSeismicInfo(data: { datapoints: number[][]; yAxisValues: number[] }, trajectory: number[][]): SeismicInfo | null {
+export function getSeismicInfo(
+  data: { datapoints: number[][]; yAxisValues: number[] },
+  trajectory: number[][],
+): SeismicInfo | null {
   if (!(data && data.datapoints)) {
     return null;
   }
-  const minX = trajectory.reduce((acc: number, val: number[]) => Math.min(acc, val[0]!), 0);
-  const maxX = trajectory.reduce((acc: number, val: number[]) => Math.max(acc, val[0]!), 0);
+  const minX = trajectory.reduce(
+    (acc: number, val: number[]) => Math.min(acc, val[0]!),
+    0,
+  );
+  const maxX = trajectory.reduce(
+    (acc: number, val: number[]) => Math.max(acc, val[0]!),
+    0,
+  );
 
   const minTvdMsl = data.yAxisValues && data.yAxisValues[0]!;
-  const maxTvdMsl = data.yAxisValues && data.yAxisValues[data.yAxisValues.length - 1]!;
+  const maxTvdMsl =
+    data.yAxisValues && data.yAxisValues[data.yAxisValues.length - 1]!;
 
   // Find value domain
   const dp = data.datapoints || [];
-  const min = -dp.reduce((val: number, array: number[]) => Math.min(...array, val), 0);
-  const max = dp.reduce((val: number, array: number[]) => Math.max(...array, val), 0);
+  const min = -dp.reduce(
+    (val: number, array: number[]) => Math.min(...array, val),
+    0,
+  );
+  const max = dp.reduce(
+    (val: number, array: number[]) => Math.max(...array, val),
+    0,
+  );
 
   const absMax = Math.max(Math.abs(min), Math.abs(max));
 
@@ -103,8 +121,14 @@ export async function generateSeismicSliceImage(
   }
   const { datapoints: dp } = data;
 
-  const min = options?.seismicMin || options?.seismicRange || dp.reduce((val: number, array: number[]) => Math.min(...array, val), 0);
-  const max = options?.seismicMax || options?.seismicRange || dp.reduce((val: number, array: number[]) => Math.max(...array, val), 0);
+  const min =
+    options?.seismicMin ||
+    options?.seismicRange ||
+    dp.reduce((val: number, array: number[]) => Math.min(...array, val), 0);
+  const max =
+    options?.seismicMax ||
+    options?.seismicRange ||
+    dp.reduce((val: number, array: number[]) => Math.max(...array, val), 0);
 
   const absMax = Math.max(Math.abs(min), Math.abs(max));
 
@@ -131,7 +155,9 @@ export async function generateSeismicSliceImage(
   let offset = 0;
   const colorFactor = (colorTableSize - 1) / domain.difference;
 
-  let pos = options?.isLeftToRight ? trajectory[0]?.[0]! : trajectory[trajectory.length - 1]?.[0]!;
+  let pos = options?.isLeftToRight
+    ? trajectory[0]?.[0]!
+    : trajectory[trajectory.length - 1]?.[0]!;
 
   const step = (length / width) * (options?.isLeftToRight ? -1 : 1);
 

package/src/datautils/surfacedata.ts

@@ -1,7 +1,13 @@
 import { interpolateRgb, quantize } from 'd3-interpolate';
 import { scaleOrdinal } from 'd3-scale';
 import { convertColor } from '../utils/color';
-import { StratUnit, SurfaceMetaAndValues, SurfaceLine, SurfaceArea, SurfaceData } from './interfaces';
+import {
+  StratUnit,
+  SurfaceMetaAndValues,
+  SurfaceLine,
+  SurfaceArea,
+  SurfaceData,
+} from './interfaces';
 
 const TRANSLUCENT_RED = 0x80000000;
 const WHITE = 0xffffffff;
@@ -48,16 +54,30 @@ interface SurfaceAreaGrouping {
  * @param surfaceData - Surfaces meta data with surface values in data section
  * @return  Surface areas ready for rendering in geolayer
  */
-export function generateSurfaceData(trajectory: number[][], stratColumn: StratUnit[], surfaceData: SurfaceMetaAndValues[]): SurfaceData {
-  const filteredSurfaces: SurfaceMetaAndValues[] = surfaceData.filter((s) => s.data.values);
+export function generateSurfaceData(
+  trajectory: number[][],
+  stratColumn: StratUnit[],
+  surfaceData: SurfaceMetaAndValues[],
+): SurfaceData {
+  const filteredSurfaces: SurfaceMetaAndValues[] = surfaceData.filter(
+    s => s.data.values,
+  );
   const mappedSurfaces = mapSurfaceData(filteredSurfaces);
 
   const stratGroups = new Map<string, StratGroup>();
-  const stratigraphies = combineSurfacesAndStratColumn(mappedSurfaces, stratColumn, stratGroups);
+  const stratigraphies = combineSurfacesAndStratColumn(
+    mappedSurfaces,
+    stratColumn,
+    stratGroups,
+  );
   sortStratigraphies(stratigraphies);
 
   const lines: SurfaceLine[] = getSurfaceLines(mappedSurfaces, trajectory);
-  const surfaceAreas: SurfaceAreaGrouping = generateSurfaceAreas(trajectory, stratigraphies, stratColumn);
+  const surfaceAreas: SurfaceAreaGrouping = generateSurfaceAreas(
+    trajectory,
+    stratigraphies,
+    stratColumn,
+  );
 
   const groups: MappedGroup[] = mapGroups(stratGroups, surfaceAreas);
   const groupAreas: SurfaceArea[] = generateGroupAreas(groups, trajectory);
@@ -67,7 +87,7 @@ export function generateSurfaceData(trajectory: number[][], stratColumn: StratUn
     ...groupAreas,
     ...Object.values(surfaceAreas)
       .flat()
-      .filter((d) => !d.exclude),
+      .filter(d => !d.exclude),
   ];
 
   const data = {
@@ -83,7 +103,10 @@ export function generateSurfaceData(trajectory: number[][], stratColumn: StratUn
  * @param  mappedSurfaces
  * @param  trajectory
  */
-function getSurfaceLines(mappedSurfaces: MappedSurfaces[], trajectory: number[][]): SurfaceLine[] {
+function getSurfaceLines(
+  mappedSurfaces: MappedSurfaces[],
+  trajectory: number[][],
+): SurfaceLine[] {
   const lines: SurfaceLine[] = mappedSurfaces
     .filter((d: MappedSurfaces) => d.visualization === 'line')
     .map((l: MappedSurfaces) => ({
@@ -97,27 +120,40 @@ function getSurfaceLines(mappedSurfaces: MappedSurfaces[], trajectory: number[][
   return lines;
 }
 
-function generateGroupAreas(groups: MappedGroup[], trajectory: number[][]): SurfaceArea[] {
+function generateGroupAreas(
+  groups: MappedGroup[],
+  trajectory: number[][],
+): SurfaceArea[] {
   const groupAreas = groups.map((g: MappedGroup, i: number) => {
-    const next: MappedGroup | null = i + 1 < groups.length ? groups[i + 1]! : null;
+    const next: MappedGroup | null =
+      i + 1 < groups.length ? groups[i + 1]! : null;
     return {
       id: g.id,
       color: convertColor(g.color),
-      data: trajectory.map((p: number[], j: number) => [p[0]!, g.top[j]!, ...(next ? [next.top[j]!] : [])]),
+      data: trajectory.map((p: number[], j: number) => [
+        p[0]!,
+        g.top[j]!,
+        ...(next ? [next.top[j]!] : []),
+      ]),
     };
   });
 
   return groupAreas;
 }
 
-function mapGroups(stratGroups: Map<string, StratGroup>, surfaceAreas: SurfaceAreaGrouping): MappedGroup[] {
+function mapGroups(
+  stratGroups: Map<string, StratGroup>,
+  surfaceAreas: SurfaceAreaGrouping,
+): MappedGroup[] {
   const groups = Array.from(stratGroups.values())
     .sort((a: StratGroup, b: StratGroup) => a.age - b.age)
     .filter((g: StratGroup) => {
       const surfaces = surfaceAreas[g.name];
       const isValid = surfaces && surfaces.length > 0;
       if (!isValid) {
-        console.warn(`Intersection surface group '${g.name}' has no valid entries and will be discarded.`);
+        console.warn(
+          `Intersection surface group '${g.name}' has no valid entries and will be discarded.`,
+        );
       }
       return isValid;
     })
@@ -139,10 +175,14 @@ function combineSurfacesAndStratColumn(
   stratColumn: StratUnit[],
   stratGroups: Map<string, StratGroup>,
 ): Stratigraphy[] {
-  const firstUnit = stratColumn && stratColumn.find((d: StratUnit) => d.stratUnitLevel === 1);
+  const firstUnit =
+    stratColumn && stratColumn.find((d: StratUnit) => d.stratUnitLevel === 1);
   const defaultGroupName: string = firstUnit ? firstUnit.identifier : 'SEABED';
   const stratigrafies = mappedSurfaces
-    .filter((d: MappedSurfaces) => d.visualization === 'interval' || d.visualization === 'none')
+    .filter(
+      (d: MappedSurfaces) =>
+        d.visualization === 'interval' || d.visualization === 'none',
+    )
     .map((s: MappedSurfaces) => {
       const path: StratUnit[] = [];
       const stratUnit = findStratcolumnUnit(stratColumn, s.name, path);
@@ -201,14 +241,22 @@ function sortStratigraphies(stratigrafies: Stratigraphy[]): void {
  * @param {string} unitname
  * @param {[]} path
  */
-function findStratcolumnUnit(units: StratUnit[], unitname: string, path: StratUnit[] = []): StratUnit | null {
-  const unit = units.find((u: StratUnit) => u.identifier.toLowerCase() === unitname.toLowerCase());
+function findStratcolumnUnit(
+  units: StratUnit[],
+  unitname: string,
+  path: StratUnit[] = [],
+): StratUnit | null {
+  const unit = units.find(
+    (u: StratUnit) => u.identifier.toLowerCase() === unitname.toLowerCase(),
+  );
   if (unit) {
     // Build path
     let temp: StratUnit | undefined = unit;
     do {
       path.unshift(temp);
-      temp = units.find((u: StratUnit) => u.identifier === temp!.stratUnitParent);
+      temp = units.find(
+        (u: StratUnit) => u.identifier === temp!.stratUnitParent,
+      );
     } while (temp);
 
     return unit;
@@ -247,7 +295,12 @@ const unassignedColorScale = scaleOrdinal<number, string>()
 /**
  * Find the best matching base index based on name or by values
  */
-function findBestMatchingBaseIndex(top: Stratigraphy, index: number, surfaces: Stratigraphy[], stratColumn: StratUnit[]): number | undefined {
+function findBestMatchingBaseIndex(
+  top: Stratigraphy,
+  index: number,
+  surfaces: Stratigraphy[],
+  stratColumn: StratUnit[],
+): number | undefined {
   const nextIndex: number = index + 1;
 
   if (!surfaces || nextIndex >= surfaces.length) {
@@ -255,7 +308,10 @@ function findBestMatchingBaseIndex(top: Stratigraphy, index: number, surfaces: S
   }
 
   // If there is a matching base by name, use that. More robust, does not rely on sorting
-  const baseSurfaceIndex = surfaces.findIndex((candidate: Stratigraphy) => candidate.isBase && candidate.name === top.name);
+  const baseSurfaceIndex = surfaces.findIndex(
+    (candidate: Stratigraphy) =>
+      candidate.isBase && candidate.name === top.name,
+  );
   if (baseSurfaceIndex !== -1) {
     return baseSurfaceIndex;
   }
@@ -272,38 +328,61 @@ function findBestMatchingBaseIndex(top: Stratigraphy, index: number, surfaces: S
   return undefined;
 }
 
-function isAnchestor(descendant: Stratigraphy, candidate: Stratigraphy, stratColumn: StratUnit[]): boolean {
+function isAnchestor(
+  descendant: Stratigraphy,
+  candidate: Stratigraphy,
+  stratColumn: StratUnit[],
+): boolean {
   const path: StratUnit[] = [];
   findStratcolumnUnit(stratColumn, descendant.name, path);
   return path.some((p: StratUnit) => candidate.name === p.identifier);
 }
 
-function generateSurfaceAreas(projection: number[][], surfaces: Stratigraphy[], stratColumn: StratUnit[]): SurfaceAreaGrouping {
-  const areas: SurfaceAreaGrouping = surfaces.reduce((acc: SurfaceAreaGrouping, surface: Stratigraphy, i: number) => {
-    if (!surface.isBase) {
-      if (!acc[surface.group]) {
-        acc[surface.group] = [];
+function generateSurfaceAreas(
+  projection: number[][],
+  surfaces: Stratigraphy[],
+  stratColumn: StratUnit[],
+): SurfaceAreaGrouping {
+  const areas: SurfaceAreaGrouping = surfaces.reduce(
+    (acc: SurfaceAreaGrouping, surface: Stratigraphy, i: number) => {
+      if (!surface.isBase) {
+        if (!acc[surface.group]) {
+          acc[surface.group] = [];
+        }
+        const baseIndex = findBestMatchingBaseIndex(
+          surface,
+          i,
+          surfaces,
+          stratColumn,
+        );
+        acc[surface.group]?.push({
+          id: surface.name,
+          label: surface.name,
+          color: (surface.unit && getColorFromUnit(surface.unit)) || WHITE,
+          exclude: surface.visualization === 'none' || !surface.unit,
+          data: projection.map((p, j) => {
+            const baseValue =
+              surface.values[j] != null
+                ? getBaseValue(baseIndex, surfaces, j)
+                : undefined;
+            return [p[0]!, surface.values[j]!, baseValue!];
+          }),
+        });
       }
-      const baseIndex = findBestMatchingBaseIndex(surface, i, surfaces, stratColumn);
-      acc[surface.group]?.push({
-        id: surface.name,
-        label: surface.name,
-        color: (surface.unit && getColorFromUnit(surface.unit)) || WHITE,
-        exclude: surface.visualization === 'none' || !surface.unit,
-        data: projection.map((p, j) => {
-          const baseValue = surface.values[j] != null ? getBaseValue(baseIndex, surfaces, j) : undefined;
-          return [p[0]!, surface.values[j]!, baseValue!];
-        }),
-      });
-    }
-    return acc;
-  }, {});
+      return acc;
+    },
+    {},
+  );
   return areas;
 }
 
 // get the value from the surface with the supplied index,
 // iterate to next surface if value is null
-function getBaseValue(index: number | undefined, surfaces: Stratigraphy[], datapoint: number): number | undefined {
+function getBaseValue(
+  index: number | undefined,
+  surfaces: Stratigraphy[],
+  datapoint: number,
+): number | undefined {
   if (!surfaces || !index || index >= surfaces.length) {
     return undefined;
   }

package/src/datautils/trajectory.ts

@@ -15,12 +15,16 @@ const pathSteps = 10;
  * Code originally developed for REP
  * @param {[]} poslog Position log from SMDA
  */
-export function generateProjectedWellborePath(poslog: SurveySample[]): [number, number][] {
+export function generateProjectedWellborePath(
+  poslog: SurveySample[],
+): [number, number][] {
   if (!poslog || poslog.length === 0) {
     return [];
   }
 
-  const points: [number, number, number, number][] = poslog ? poslog.map((p: SurveySample) => [p.easting, p.northing, p.tvd, p.md]) : [];
+  const points: [number, number, number, number][] = poslog
+    ? poslog.map((p: SurveySample) => [p.easting, p.northing, p.tvd, p.md])
+    : [];
 
   const projection = simplify(projectCurtain(points));
   const offset = projection[projection.length - 1]?.[0];
@@ -40,14 +44,22 @@ export function generateProjectedWellborePath(poslog: SurveySample[]): [number,
  * @param {[]} poslog Position log from SMDA
  * @param {number} defaultIntersectionAngle Default intersection angle for the field
  */
-export function generateProjectedTrajectory(poslog: SurveySample[], defaultIntersectionAngle: number): number[][] {
+export function generateProjectedTrajectory(
+  poslog: SurveySample[],
+  defaultIntersectionAngle: number,
+): number[][] {
   if (!poslog || poslog.length === 0) {
     return [];
   }
 
-  const points: [number, number, number, number][] = poslog ? poslog.map((p) => [p.easting, p.northing, p.tvd, p.md]) : [];
+  const points: [number, number, number, number][] = poslog
+    ? poslog.map(p => [p.easting, p.northing, p.tvd, p.md])
+    : [];
 
-  const interpolator: CurveInterpolator = new CurveInterpolator(points, { tension: 0.75, arcDivisions: 5000 });
+  const interpolator: CurveInterpolator = new CurveInterpolator(points, {
+    tension: 0.75,
+    arcDivisions: 5000,
+  });
   const displacement: number = interpolator.length;
 
   const nPoints: number = Math.round(displacement * pathSteps);
@@ -67,12 +79,19 @@ export function generateProjectedTrajectory(poslog: SurveySample[], defaultInter
 
   if (relativeDist < thresholdRelativeDist) {
     const oneEighty = 180;
-    const radCurtainDirection = (defaultIntersectionAngle / oneEighty) * Math.PI;
-    v = new Vector2(Math.cos(radCurtainDirection), Math.sin(radCurtainDirection)).mutable;
+    const radCurtainDirection =
+      (defaultIntersectionAngle / oneEighty) * Math.PI;
+    v = new Vector2(
+      Math.cos(radCurtainDirection),
+      Math.sin(radCurtainDirection),
+    ).mutable;
   } else {
     v = getDirectionVector(path, thresholdDirectionDist);
   }
-  const extensionLengthStart: number = Math.max(0, extensionLength - displacement);
+  const extensionLengthStart: number = Math.max(
+    0,
+    extensionLength - displacement,
+  );
   const offset: number = extensionLengthStart + displacement;
   const trajectory: [number, number][] = [];
 
@@ -83,7 +102,7 @@ export function generateProjectedTrajectory(poslog: SurveySample[], defaultInter
 
   if (extensionLengthStart > 0) {
     // extend from start
-    firstPoints = seqI(Math.ceil(extensionLengthStart * stepSize)).map((t) =>
+    firstPoints = seqI(Math.ceil(extensionLengthStart * stepSize)).map(t =>
       v
         .set(initial)
         .scale(extensionLengthStart * (1 - t))
@@ -96,7 +115,7 @@ export function generateProjectedTrajectory(poslog: SurveySample[], defaultInter
   trajectory.push(...path);
 
   const endPoints = seqI(Math.ceil(extensionLength * stepSize))
-    .map((t) =>
+    .map(t =>
       v
         .set(initial)
         .scale(extensionLength * t)
@@ -107,7 +126,11 @@ export function generateProjectedTrajectory(poslog: SurveySample[], defaultInter
 
   trajectory.push(...endPoints);
 
-  const projectedTrajectory: number[][] = projectCurtain(trajectory, undefined, offset);
+  const projectedTrajectory: number[][] = projectCurtain(
+    trajectory,
+    undefined,
+    offset,
+  );
 
   return projectedTrajectory;
 }
@@ -154,12 +177,16 @@ function getDirectionVector(path: number[][], threshold: number): Vector2 {
  *
  * @return {Number[]}    Simplified array
  */
-function simplify(inputArr: [number, number][], maxOffset = 0.001, maxDistance = 10): [number, number][] {
+function simplify(
+  inputArr: [number, number][],
+  maxOffset = 0.001,
+  maxDistance = 10,
+): [number, number][] {
   if (inputArr.length <= 4) {
     return inputArr;
   }
   const [o0, o1] = inputArr[0]!;
-  const arr = inputArr.map<[number, number]>((d) => [d[0]! - o0, d[1]! - o1]);
+  const arr = inputArr.map<[number, number]>(d => [d[0]! - o0, d[1]! - o1]);
   let [a0, a1] = arr[0]!;
   const sim = [inputArr[0]!];
 
@@ -168,9 +195,17 @@ function simplify(inputArr: [number, number][], maxOffset = 0.001, maxDistance =
     const [b0, b1] = arr[i + 1] ?? [];
 
     // If t->b vector is NOT [0, 0]
-    if (t0 != null && t1 != null && b0 != null && b1 != null && (b0 - t0 !== 0 || b1 - t1 !== 0)) {
+    if (
+      t0 != null &&
+      t1 != null &&
+      b0 != null &&
+      b1 != null &&
+      (b0 - t0 !== 0 || b1 - t1 !== 0)
+    ) {
       // Proximity check
-      const proximity: number = Math.abs(a0 * b1 - a1 * b0 + b0 * t1 - b1 * t0 + a1 * t0 - a0 * t1) / Math.sqrt((b0 - a0) ** 2 + (b1 - a1) ** 2);
+      const proximity: number =
+        Math.abs(a0 * b1 - a1 * b0 + b0 * t1 - b1 * t0 + a1 * t0 - a0 * t1) /
+        Math.sqrt((b0 - a0) ** 2 + (b1 - a1) ** 2);
 
       const dir: [number, number] = [a0 - t0, a1 - t1];
       const len: number = Math.sqrt(dir[0] ** 2 + dir[1] ** 2);
@@ -194,10 +229,14 @@ function simplify(inputArr: [number, number][], maxOffset = 0.001, maxDistance =
  * @param offset
  * @returns {array}
  */
-function projectCurtain(points: [number, number, ...number[]][], origin?: [number, number, number, number], offset = 0): [number, number][] {
+function projectCurtain(
+  points: [number, number, ...number[]][],
+  origin?: [number, number, number, number],
+  offset = 0,
+): [number, number][] {
   let p0 = origin || points[0]!;
   let l = 0;
-  const projected = points.map<[number, number]>((p1) => {
+  const projected = points.map<[number, number]>(p1 => {
     const dx = p1[0] - p0[0];
     const dy = p1[1] - p0[1];
     l += Math.sqrt(dx ** 2 + dy ** 2);