@equinor/esv-intersection 3.0.3 → 3.0.4

package/src/datautils/seismicimage.ts

@@ -1,180 +0,0 @@
-import { clamp } from '@equinor/videx-math';
-import { SeismicCanvasDataOptions } from '../layers/SeismicCanvasLayer';
-
-import { createColorTable } from './colortable';
-import { findIndexOfSample } from './findsample';
-
-export type SeismicInfo = {
-  minX: number;
-  maxX: number;
-  minTvdMsl: number;
-  maxTvdMsl: number;
-  domain: {
-    min: number;
-    max: number;
-    difference: number;
-  };
-};
-
-export const getSeismicOptions = (info: SeismicInfo | null): SeismicCanvasDataOptions => {
-  if (!info) {
-    return {
-      x: 0,
-      y: 0,
-      width: 0,
-      height: 0,
-    };
-  }
-  return {
-    x: info.minX,
-    y: info.minTvdMsl,
-    width: info.maxX - info.minX,
-    height: info.maxTvdMsl - info.minTvdMsl,
-  };
-};
-
-/**
- * Get key information about the seismic data
- * Code originally developed for the REP project
- * @param data Seismic data
- * @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 {
-  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 minTvdMsl = data.yAxisValues && data.yAxisValues[0];
-  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 absMax = Math.max(Math.abs(min), Math.abs(max));
-
-  const dmin = -absMax;
-  const dmax = absMax;
-
-  const info = {
-    minX,
-    maxX,
-    minTvdMsl,
-    maxTvdMsl,
-    domain: {
-      min: dmin,
-      max: dmax,
-      difference: dmax - dmin,
-    },
-  };
-
-  return info;
-}
-
-/**
- * Generate seismic
- * Code originally developed for the REP project
- * @param data Seismic data
- * @param trajectory Wellbore or freehand trajectory
- * @param colormap Color map for rendering
- * @param options.isLeftToRight (optional) draw left to right
- * @param options.seismicRange (optional) Range for mapping seimic values to color map
- * @param options.seismicMin (optional) Min seismic value for mapping seimic values to color map
- * @param options.seismicMax (optional) Max seismic value for mapping seimic values to color map
- * @return  Key domain and depth information for seismic data
- */
-export async function generateSeismicSliceImage(
-  data: { datapoints: number[][]; yAxisValues: number[] },
-  trajectory: number[][],
-  colormap: string[],
-  options?: {
-    isLeftToRight: true;
-    seismicRange?: number;
-    seismicMin?: number;
-    seismicMax?: number;
-  },
-): Promise<ImageBitmap> {
-  if (!(data && data.datapoints && data.datapoints.length > 0)) {
-    return;
-  }
-  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 absMax = Math.max(Math.abs(min), Math.abs(max));
-
-  const dmin = -absMax;
-  const dmax = absMax;
-
-  const domain = {
-    min: dmin,
-    max: dmax,
-    difference: dmax - dmin,
-  };
-
-  const length = trajectory[0][0] - trajectory[trajectory.length - 1][0];
-  // eslint-disable-next-line no-magic-numbers
-  const width = Math.abs(Math.floor(length / 5));
-  const height = data.yAxisValues.length;
-
-  // Generate color table
-  const colorTableSize = 1000;
-  const colorTable = createColorTable(colormap, colorTableSize);
-
-  // Generate image
-  const d = new Uint8ClampedArray(width * height * 4);
-
-  let offset = 0;
-  const colorFactor = (colorTableSize - 1) / domain.difference;
-
-  let pos = options?.isLeftToRight ? trajectory[0][0] : trajectory[trajectory.length - 1][0];
-
-  const step = (length / width) * (options?.isLeftToRight ? -1 : 1);
-
-  let val1;
-  let val2;
-  let val;
-  let i;
-  let col: number[];
-  const black = [0, 0, 0];
-  let opacity;
-
-  for (let x = 0; x < width; x++) {
-    offset = x * 4;
-    const index = findIndexOfSample(trajectory, pos);
-    const x1 = trajectory[index][0];
-    const x2 = trajectory[index + 1][0];
-    const span = x2 - x1;
-    const dx = pos - x1;
-    const ratio = dx / span;
-
-    for (let y = 0; y < height; y++) {
-      val1 = dp[y][index];
-      val2 = dp[y][index + 1];
-      if (val1 == null || val2 == null) {
-        col = black;
-        opacity = 0;
-      } else {
-        val = val1 * (1 - ratio) + val2 * ratio;
-        i = (val - domain.min) * colorFactor;
-        i = clamp(~~i, 0, colorTableSize - 1);
-        col = colorTable[i];
-        opacity = 255;
-      }
-
-      d.set([col[0], col[1], col[2], opacity], offset);
-
-      offset += width * 4;
-    }
-    pos += step;
-  }
-  const imageData = new ImageData(d, width, height);
-  const image = await createImageBitmap(imageData, 0, 0, width, height);
-
-  return image;
-}

package/src/datautils/surfacedata.ts

@@ -1,318 +0,0 @@
-import { interpolateRgb, quantize } from 'd3-interpolate';
-import { scaleOrdinal } from 'd3-scale';
-import { convertColor } from '../utils/color';
-import { StratUnit, SurfaceMetaAndValues, SurfaceLine, SurfaceArea, SurfaceData } from './interfaces';
-
-const TRANSLUCENT_RED = 0x80000000;
-const WHITE = 0xffffffff;
-
-type MappedSurfaces = {
-  name: string;
-  isBase: boolean;
-  values: number[];
-  color: string;
-  visualization: string;
-};
-
-type StratGroup = {
-  age: number;
-  name: string;
-};
-
-type Stratigraphy = {
-  unit: StratUnit;
-  group: string;
-  name: string;
-  isBase: boolean;
-  values: number[];
-  color: string;
-  visualization: string;
-};
-
-type MappedGroup = {
-  id: string;
-  label: string;
-  color: string;
-  top: number[];
-};
-
-interface SurfaceAreaGrouping {
-  [propType: string]: SurfaceArea[];
-}
-
-/**
- * Generate surface data from trajectory, stratcolum and surface data
- * Code originally developed for the REP project
- * @param trajectory Projected trajectory generated from the poslog used when retrieving surface data from surface API
- * @param stratColumn Strat columnd from SMDA
- * @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);
-  const mappedSurfaces = mapSurfaceData(filteredSurfaces);
-
-  const stratGroups = new Map<string, StratGroup>();
-  const stratigraphies = combineSurfacesAndStratColumn(mappedSurfaces, stratColumn, stratGroups);
-  sortStratigraphies(stratigraphies);
-
-  const lines: SurfaceLine[] = getSurfaceLines(mappedSurfaces, trajectory);
-  const surfaceAreas: SurfaceAreaGrouping = generateSurfaceAreas(trajectory, stratigraphies, stratColumn);
-
-  const groups: MappedGroup[] = mapGroups(stratGroups, surfaceAreas);
-  const groupAreas: SurfaceArea[] = generateGroupAreas(groups, trajectory);
-
-  //Combine group areas with surface areas
-  const areas: SurfaceArea[] = [
-    ...groupAreas,
-    ...Object.values(surfaceAreas)
-      .flat()
-      .filter((d) => !d.exclude),
-  ];
-
-  const data = {
-    lines,
-    areas,
-  };
-
-  return data;
-}
-
-/**
- * Get surfaces which should be rendered as lines
- * @param  mappedSurfaces
- * @param  trajectory
- */
-function getSurfaceLines(mappedSurfaces: MappedSurfaces[], trajectory: number[][]): SurfaceLine[] {
-  const lines: SurfaceLine[] = mappedSurfaces
-    .filter((d: MappedSurfaces) => d.visualization === 'line')
-    .map((l: MappedSurfaces) => ({
-      id: l.name,
-      label: l.name,
-      width: 2,
-      color: convertColor(l.color || 'black'),
-      data: trajectory.map((p, j) => [p[0], l.values[j]]),
-    }));
-
-  return lines;
-}
-
-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;
-    return {
-      id: g.id,
-      label: g.label,
-      color: convertColor(g.color),
-      data: trajectory.map((p: number[], j: number) => [p[0], g.top[j], next ? next.top[j] : null]),
-    };
-  });
-  return groupAreas;
-}
-
-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: SurfaceArea[] = 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.`);
-      }
-      return isValid;
-    })
-    .map((g: StratGroup, i: number) => {
-      const surface: SurfaceArea[] = surfaceAreas[g.name];
-      const top = surface[0];
-      return {
-        id: g.name,
-        label: g.name,
-        color: unassignedColorScale(i),
-        top: top.data.map((d: number[]) => d[1]),
-      };
-    });
-  return groups;
-}
-
-function combineSurfacesAndStratColumn(
-  mappedSurfaces: MappedSurfaces[],
-  stratColumn: StratUnit[],
-  stratGroups: Map<string, StratGroup>,
-): Stratigraphy[] {
-  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')
-    .map((s: MappedSurfaces) => {
-      const path: StratUnit[] = [];
-      const stratUnit: StratUnit = findStratcolumnUnit(stratColumn, s.name, path);
-      if (!stratUnit) {
-        console.warn(`No match for ${s.name} in strat column`);
-      }
-      const group: StratUnit = path[0] || stratUnit;
-      const groupName: string = (group && group.identifier) || defaultGroupName;
-      if (group && !stratGroups.has(groupName)) {
-        stratGroups.set(groupName, {
-          age: group.topAge,
-          name: group.identifier,
-        });
-      }
-      return {
-        ...s,
-        unit: stratUnit,
-        group: groupName,
-      };
-    });
-  return stratigrafies;
-}
-
-/**
- * Sort stratigrafies on unit and age, base after top and higher level after lower
- * @param  stratigrafies
- */
-function sortStratigraphies(stratigrafies: Stratigraphy[]): void {
-  stratigrafies.sort((a: Stratigraphy, b: Stratigraphy) => {
-    if (!a.unit && !b.unit) {
-      return 0;
-    }
-    if (!a.unit) {
-      return -1;
-    }
-    if (!b.unit) {
-      return 1;
-    }
-    const aAge = a.isBase ? a.unit.baseAge : a.unit.topAge;
-    const bAge = b.isBase ? b.unit.baseAge : b.unit.topAge;
-    if (aAge !== bAge) {
-      return aAge - bAge;
-    }
-    if (a.isBase && !b.isBase) {
-      return 1;
-    }
-    if (!a.isBase && b.isBase) {
-      return -1;
-    }
-    return a.unit.stratUnitLevel - b.unit.stratUnitLevel;
-  });
-}
-
-/**
- * @param {[]} units
- * @param {string} unitname
- * @param {[]} path
- */
-function findStratcolumnUnit(units: StratUnit[], unitname: string, path: StratUnit[] = []): StratUnit | null {
-  const unit: StratUnit = units.find((u: StratUnit) => u.identifier.toLowerCase() === unitname.toLowerCase());
-  if (unit) {
-    // Build path
-    let temp: StratUnit = unit;
-    do {
-      path.unshift(temp);
-      temp = units.find((u: StratUnit) => u.identifier === temp.stratUnitParent);
-    } while (temp);
-
-    return unit;
-  }
-  return null;
-}
-
-function mapSurfaceData(surfaces: SurfaceMetaAndValues[]): MappedSurfaces[] {
-  return surfaces.map((s: SurfaceMetaAndValues) => {
-    const displayName: string = s.visualSettings.displayName;
-    const name: string = displayName.replace(/\s(Base|Top)/gi, '');
-    const isBase: boolean = displayName.toLowerCase().endsWith('base');
-
-    return {
-      name,
-      isBase,
-      values: s.data.values,
-      color: s.visualSettings.colors.crossSection,
-      visualization: s.visualSettings.crossSection.toLowerCase(),
-    };
-  });
-}
-
-function getColorFromUnit(unit: StratUnit): number {
-  if (unit.colorR === null || unit.colorG === null || unit.colorB === null) {
-    return TRANSLUCENT_RED;
-  }
-  const res: number = (unit.colorR << 16) | (unit.colorG << 8) | unit.colorB;
-  return res;
-}
-
-const unassignedColorScale = scaleOrdinal<number, string>()
-  .domain([0, 100])
-  // eslint-disable-next-line no-magic-numbers
-  .range(quantize(interpolateRgb('#e6f1cf', '#85906d'), 10));
-
-/**
- * Find the best matching base index based on name or by values
- */
-function findBestMatchingBaseIndex(top: Stratigraphy, index: number, surfaces: Stratigraphy[], stratColumn: StratUnit[]): number {
-  const nextIndex: number = index + 1;
-
-  if (!surfaces || nextIndex >= surfaces.length) {
-    return null;
-  }
-
-  // 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);
-  if (baseSurfaceIndex !== -1) {
-    return baseSurfaceIndex;
-  }
-
-  for (let i = nextIndex; i < surfaces.length; i++) {
-    const candidate = surfaces[i];
-    if (!candidate.isBase) {
-      return i;
-    }
-    if (isAnchestor(top, candidate, stratColumn)) {
-      return i;
-    }
-  }
-  return null;
-}
-
-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] = [];
-      }
-      const baseIndex: number = 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: number = surface.values[j] !== null ? getBaseValue(baseIndex, surfaces, j) : null;
-          return [p[0], surface.values[j], baseValue];
-        }),
-      });
-    }
-    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, surfaces: Stratigraphy[], datapoint: number): number {
-  if (!surfaces || !index || index >= surfaces.length) {
-    return null;
-  }
-
-  for (let i: number = index; i < surfaces.length; i++) {
-    if (surfaces[i].values[datapoint] !== null) {
-      return surfaces[i].values[datapoint];
-    }
-  }
-  return null;
-}

package/src/datautils/trajectory.ts

@@ -1,206 +0,0 @@
-import Vector2 from '@equinor/videx-vector2';
-import { seqI } from '@equinor/videx-math';
-import { CurveInterpolator } from 'curve-interpolator';
-import { SurveySample } from './interfaces';
-
-const stepSize = 0.1;
-const extensionLength = 1000;
-const thresholdRelativeDist = 150;
-const thresholdDirectionDist = 30;
-
-const pathSteps = 10;
-
-/**
- * Generate projected wellbore path for drawing using wellbore path layer
- * Code originally developed for REP
- * @param {[]} poslog Position log from SMDA
- */
-export function generateProjectedWellborePath(poslog: SurveySample[]): number[][] {
-  if (!poslog || poslog.length === 0) {
-    return [];
-  }
-
-  const points: number[][] = poslog ? poslog.map((p: SurveySample) => [p.easting, p.northing, p.tvd, p.md]) : [];
-
-  const projection: number[][] = simplify(projectCurtain(points));
-  const offset: number = projection[projection.length - 1][0];
-
-  projection.forEach((p, i) => {
-    projection[i][0] = offset - p[0];
-  });
-
-  return projection;
-}
-
-/**
- * Generate Trajectory
- * Code originally developed for REP
- * @param {[]} poslog Position log from SMDA
- * @param {number} defaultIntersectionAngle Default intersection angle for the field
- */
-export function generateProjectedTrajectory(poslog: SurveySample[], defaultIntersectionAngle: number): number[][] {
-  if (!poslog || poslog.length === 0) {
-    return [];
-  }
-
-  const points: 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 displacement: number = interpolator.length;
-
-  const nPoints: number = Math.round(displacement * pathSteps);
-  let path: number[][] = null;
-  if (nPoints > 0) {
-    const maxOffset = 0.0005;
-    const maxDistance = 10;
-    path = simplify(interpolator.getPoints(nPoints), maxOffset, maxDistance);
-  } else {
-    path = [[points[0][0], points[0][1]]];
-  }
-
-  const first: number[] = path[0];
-  const last: number[] = path[path.length - 1];
-  const relativeDist: number = Vector2.distance(first, last);
-  let v: Vector2 = null;
-
-  if (relativeDist < thresholdRelativeDist) {
-    const oneEighty = 180;
-    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 offset: number = extensionLengthStart + displacement;
-  const trajectory: number[][] = [];
-
-  let firstPoints: number[][] = [];
-
-  // Reference to initial vector
-  const initial: number[] = v.toArray();
-
-  if (extensionLengthStart > 0) {
-    // extend from start
-    firstPoints = seqI(Math.ceil(extensionLengthStart * stepSize)).map((t) =>
-      v
-        .set(initial)
-        .scale(extensionLengthStart * (1 - t))
-        .subFrom(first)
-        .toArray(),
-    );
-    firstPoints.pop();
-    trajectory.push(...firstPoints);
-  }
-  trajectory.push(...path);
-
-  const endPoints: number[][] = seqI(Math.ceil(extensionLength * stepSize))
-    .map((t) =>
-      v
-        .set(initial)
-        .scale(extensionLength * t)
-        .add(last)
-        .toArray(),
-    )
-    .splice(1);
-
-  trajectory.push(...endPoints);
-
-  const projectedTrajectory: number[][] = projectCurtain(trajectory, null, offset);
-
-  return projectedTrajectory;
-}
-
-/**
- * Get direction vector
- * Code originally developed for REP
- * @param {[]} path
- * @param {number} threshold
- * @returns {Vector2}
- */
-function getDirectionVector(path: number[][], threshold: number): Vector2 {
-  const res: Vector2 = Vector2.zero.mutable;
-  let len = 0;
-  const temp: Vector2 = Vector2.zero.mutable;
-
-  for (let i = 0; i < path.length - 1; i++) {
-    const index = path.length - 1 - i;
-    temp.set(path[index]).sub(path[index - 1]);
-    res.add(temp);
-
-    len = res.magnitude;
-    if (len > threshold) {
-      break;
-    }
-  }
-
-  if (len === 0) {
-    return new Vector2([0, 0]);
-  }
-  return res.scale(1 / len);
-}
-
-/**
- * Simplify array
- *
- * Simplifies an array using given parameters.
- * Code originally developed for REP
- * @access public
- *
- * @param {Number[]}      inputArr           Array to simplify
- * @param {Number}        [maxOffset=0.001]  Max offset (Default = 0.001)
- * @param {Number}        [maxDistance=10]   Max distance (Default = 10)
- *
- * @return {Number[]}    Simplified array
- */
-function simplify(inputArr: number[][], maxOffset = 0.001, maxDistance = 10): number[][] {
-  if (inputArr.length <= 4) {
-    return inputArr;
-  }
-  const [o0, o1] = inputArr[0];
-  const arr = inputArr.map((d) => [d[0] - o0, d[1] - o1]);
-  let [a0, a1] = arr[0];
-  const sim: number[][] = [inputArr[0]];
-
-  for (let i = 1; i + 1 < arr.length; i++) {
-    const [t0, t1] = arr[i];
-    const [b0, b1] = arr[i + 1];
-
-    // If t->b vector is NOT [0, 0]
-    if (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 dir: number[] = [a0 - t0, a1 - t1];
-      const len: number = Math.sqrt(dir[0] ** 2 + dir[1] ** 2);
-
-      if (proximity > maxOffset || len >= maxDistance) {
-        sim.push([t0 + o0, t1 + o1]);
-        [a0, a1] = [t0, t1];
-      }
-    }
-  }
-  const last: number[] = arr[arr.length - 1];
-  sim.push([last[0] + o0, last[1] + o1]);
-
-  return sim;
-}
-
-/**
- * Perform a curtain projection on a set of points in 3D
- * @param points
- * @param origin
- * @param offset
- * @returns {array}
- */
-function projectCurtain(points: number[][], origin: number[] = null, offset = 0): number[][] {
-  let p0: number[] = origin || points[0];
-  let l = 0;
-  const projected = points.map((p1: number[]) => {
-    const dx = p1[0] - p0[0];
-    const dy = p1[1] - p0[1];
-    l += Math.sqrt(dx ** 2 + dy ** 2);
-    p0 = p1;
-    return [offset > 0 ? offset - l : l, p1[2] || 0];
-  });
-  return projected;
-}