@equinor/esv-intersection 3.0.1 → 3.0.4

package/src/datautils/interfaces.ts

@@ -1,68 +0,0 @@
-/**
- * Survey data from SDMA
- */
-export interface SurveySample {
-  md: number;
-  tvd: number;
-  easting: number;
-  northing: number;
-}
-
-/**
- * Strat unit element as retrieved from SDMA
- */
-export interface StratUnit {
-  identifier: string;
-  stratUnitParent: string;
-  colorR: null | number;
-  colorG: null | number;
-  colorB: null | number;
-  topAge: number;
-  baseAge: number;
-  stratUnitLevel: number;
-}
-
-/**
- * Surfaces meta data as received from surface API with surface values injected
- */
-export interface SurfaceMetaAndValues {
-  data: {
-    values: number[];
-  };
-  visualSettings: {
-    displayName: string;
-    crossSection: string;
-    colors: {
-      crossSection: string;
-    };
-  };
-}
-
-/**
- * Surfaces lines ready for drawing by geomodel layer
- */
-export interface SurfaceLine {
-  id?: string;
-  label: string;
-  color: number | string; // Color is passed to pixi.js and accepts both CSS color strings and hex color value
-  data: number[][];
-}
-
-/**
- * Surfaces areas ready for drawing by geomodel layer
- */
-export interface SurfaceArea {
-  id?: string;
-  label: string;
-  color: number | string; // Color is passed to pixi.js and accepts both CSS color strings and hex color value
-  data: number[][];
-  exclude?: boolean;
-}
-
-/**
- * Surfaces lines and areas ready for drawing by geomodel layer
- */
-export interface SurfaceData {
-  lines: SurfaceLine[];
-  areas: SurfaceArea[];
-}

package/src/datautils/picks.ts

@@ -1,328 +0,0 @@
-import { Annotation } from '../interfaces';
-
-type Pick = {
-  pickIdentifier?: string;
-  confidence: string | null;
-  depthReferencePoint: string;
-  md: number;
-  mdUnit: string;
-  tvd: number;
-};
-
-type PickWithId = {
-  identifier: string;
-} & Pick;
-
-type Unit = {
-  identifier: string;
-  top: string;
-  base: string;
-  baseAge: number;
-  topAge: number;
-  colorR: number;
-  colorG: number;
-  colorB: number;
-  stratUnitLevel: number;
-  lithologyType: number;
-  stratUnitParent: number;
-};
-
-type UnitDto = {
-  unitName: string;
-  topSurface: string;
-  baseSurface: string;
-  ageBase: number;
-  ageTop: number;
-  color: {
-    r: number;
-    g: number;
-    b: number;
-  };
-  level: number;
-  lithType: number;
-  parent: number;
-};
-
-type PickAndUnit = PickWithId & UnitDto;
-
-type PairedPickAndUnit = {
-  name: string;
-  mdEntry: number;
-  tvdEntry: number;
-  color: { r: number; g: number; b: number };
-  level: number;
-  entryPick: PickAndUnit;
-  mdExit: number;
-  tvdExit: number;
-  exitPick: PickAndUnit;
-  confidenceEntry: string;
-  confidenceExit: string;
-  from?: number;
-  to?: number;
-};
-
-const mapPick = (p: PickWithId, groupName: string): Annotation => ({
-  title: p.pickIdentifier || p.identifier,
-  group: groupName,
-  label: `${p.md} ${p.mdUnit} ${p.depthReferencePoint}`,
-  color: groupName === 'strat-picks' ? '#227' : 'rgba(0,0,0,0.8)',
-  md: p.md,
-});
-
-function getReferencePicks(picks: PickWithId[]): Annotation[] {
-  if (!picks) {
-    return [];
-  }
-
-  return picks.map((p: PickWithId) => mapPick(p, 'ref-picks'));
-}
-
-function getEntryPicks(formationPicks: PairedPickAndUnit[]): Annotation[] {
-  if (!formationPicks) {
-    return [];
-  }
-
-  return formationPicks
-    .filter((d: PairedPickAndUnit) => d.entryPick.md === d.from)
-    .map((p: PairedPickAndUnit) => mapPick(p.entryPick, 'strat-picks'));
-}
-
-function getFilteredExitPicks(formationPicks: PairedPickAndUnit[]): Annotation[] {
-  if (!formationPicks) {
-    return [];
-  }
-
-  return (
-    formationPicks
-      .filter((d: PairedPickAndUnit) => formationPicks.findIndex((p: PairedPickAndUnit) => Math.abs(p.entryPick.md - d.exitPick.md) < 0.5) === -1)
-      .map((p: PairedPickAndUnit) => mapPick(p.exitPick, 'strat-picks'))
-      // Remove duplicates from unitpicks filling in gaps in formation
-      .filter((obj: Annotation, i: number, array: Annotation[]) => i === array.findIndex((v: Annotation) => v.title === obj.title && v.md === obj.md))
-  );
-}
-
-export const getPicksData = (picksData: { unitPicks: PairedPickAndUnit[]; nonUnitPicks: PickWithId[] }): Annotation[] =>
-  [...getReferencePicks(picksData.nonUnitPicks), ...getEntryPicks(picksData.unitPicks), ...getFilteredExitPicks(picksData.unitPicks)].sort(
-    (a, b) => a.md - b.md,
-  );
-
-/**
- * @param {Unit} u
- */
-const unitDto = (u: Unit): UnitDto => ({
-  unitName: u.identifier,
-  topSurface: u.top,
-  baseSurface: u.base,
-  ageBase: u.baseAge,
-  ageTop: u.topAge,
-  color: {
-    r: u.colorR === null ? 255 : u.colorR,
-    g: u.colorG === null ? 255 : u.colorG,
-    b: u.colorB === null ? 255 : u.colorB,
-  },
-  level: u.stratUnitLevel,
-  lithType: u.lithologyType,
-  parent: u.stratUnitParent,
-});
-
-/**
- *
- * @param {number} from
- * @param {number} to
- * @param {{ from: number; to: number; itm: PairedPickAndUnit }[]} arr
- * @param {number} arr.to
- * @param {number} arr.from
- * @returns {[number, number][]}
- */
-function findGaps(from: number, to: number, arr: { from: number; to: number; itm: PairedPickAndUnit }[]): [number, number][] {
-  if (arr.length === 0) {
-    return [[from, to]];
-  }
-  const gaps: [number, number][] = [];
-  let d = from;
-  let i = 0;
-  while (d < to && i < arr.length) {
-    const itm = arr[i];
-    if (itm.from > d) {
-      gaps.push([d, Math.min(itm.from, to)]);
-    }
-    d = Math.min(to, Math.max(from, itm.to));
-    i += 1;
-  }
-  if (d < to) {
-    gaps.push([d, to]);
-  }
-  return gaps;
-}
-
-/**
- * @param {Unit[]} units
- * @returns {UnitDto[]}
- */
-const transformStratColumn = (units: Unit[]): UnitDto[] => units.map(unitDto);
-
-/**
- * Join picks data with strat column units
- * @param {Pick[]} picks picks
- * @param {Unit[]} stratColumn strat column
- */
-function joinPicksAndStratColumn(picks: Pick[], stratColumn: Unit[]): { joined: PickAndUnit[]; nonUnitPicks: PickWithId[] } {
-  const transformed = transformStratColumn(stratColumn);
-  const nonUnitPicks: PickWithId[] = [];
-  const joined: PickAndUnit[] = [];
-  picks.forEach((p: Pick) => {
-    const matches = transformed.filter((u: UnitDto) => p.pickIdentifier.search(new RegExp(`(${u.topSurface}|${u.baseSurface})`, 'i')) !== -1);
-    if (matches.length > 0) {
-      matches.forEach((u: UnitDto) =>
-        joined.push({
-          md: p.md,
-          tvd: p.tvd,
-          identifier: p.pickIdentifier,
-          confidence: p.confidence,
-          mdUnit: p.mdUnit,
-          depthReferencePoint: p.depthReferencePoint,
-          ...u,
-        }),
-      );
-    } else {
-      nonUnitPicks.push({ identifier: p.pickIdentifier, ...p });
-    }
-  });
-
-  return { joined, nonUnitPicks };
-}
-
-/**
- * Find matching pairs of entry/exit picks
- * @param {PickAndUnit[]} joined picks joined with strat column units
- */
-function pairJoinedPicks(joined: PickAndUnit[]): PairedPickAndUnit[] {
-  // pair picks by unit name
-  const pairs = [];
-  let current = null;
-
-  const sorted = joined
-    .filter((d: PickAndUnit) => d.level)
-    .sort((a: PickAndUnit, b: PickAndUnit) => a.unitName.localeCompare(b.unitName) || a.md - b.md || a.ageTop - b.ageTop);
-
-  while (sorted.length > 0) {
-    current = sorted.shift();
-    const name = current.identifier;
-    let pairWithName: string;
-
-    const isTop = name === current.topSurface;
-    const isBase = name === current.baseSurface;
-
-    if (isTop) {
-      pairWithName = current.baseSurface;
-    } else if (isBase) {
-      pairWithName = current.topSurface;
-    } else {
-      console.warn(`Unable to match ${name} with top or base surface, ignored`);
-      continue;
-    }
-
-    let top: PickAndUnit;
-    let base: PickAndUnit;
-
-    const pairWith = sorted.find((p: PickAndUnit) => p.identifier === pairWithName);
-    if (!pairWith) {
-      console.warn(`Unable to find ${pairWithName} pick for ${name}`);
-      if (isTop) {
-        top = current;
-        base = joined
-          .filter((d: PickAndUnit) => d.level)
-          .sort((a: PickAndUnit, b: PickAndUnit) => a.md - b.md)
-          .find((p: PickAndUnit) => p.md > top.md);
-        if (base) {
-          console.warn(`Using ${base.identifier} as base for ${name}`);
-        } else {
-          console.warn(`Unable to find a base pick for ${name} pick at ${top.md}, ignored`);
-          continue;
-        }
-      } else if (isBase) {
-        base = current;
-        top = joined
-          .filter((d: PickAndUnit) => d.level)
-          .sort((a: PickAndUnit, b: PickAndUnit) => b.md - a.md)
-          .find((p: PickAndUnit) => p.md < base.md);
-        if (top) {
-          console.warn(`Using ${top.identifier} as top for ${name}`);
-        } else {
-          console.warn(`Unable to find a top pick for ${name} pick at ${base.md}, ignored`);
-          continue;
-        }
-      } else {
-        console.warn(`${name} ignored`);
-        continue;
-      }
-    } else {
-      top = isTop ? current : pairWith;
-      base = isTop ? pairWith : current;
-
-      if (top.md > base.md) {
-        [top, base] = [base, top];
-      }
-
-      sorted.splice(sorted.indexOf(pairWith), 1);
-    }
-
-    pairs.push(<PairedPickAndUnit>{
-      name: top.unitName,
-      mdEntry: top.md,
-      tvdEntry: top.tvd,
-      color: top.color,
-      level: top.level,
-      entryPick: top,
-      mdExit: base.md,
-      tvdExit: base.tvd,
-      exitPick: base,
-      confidenceEntry: top.confidence,
-      confidenceExit: base.confidence,
-    });
-  }
-
-  return pairs;
-}
-
-/**
- * Transform data for formation track
- * @param {Pick[]} picks picks
- * @param {Unit[]} stratColumn strat column
- */
-export function transformFormationData(picks: Pick[], stratColumn: Unit[]): { unitPicks: PairedPickAndUnit[]; nonUnitPicks: PickWithId[] } {
-  const { joined, nonUnitPicks } = joinPicksAndStratColumn(picks, stratColumn);
-  const pairs = pairJoinedPicks(joined);
-
-  const itemstack = pairs
-    .filter((d: PairedPickAndUnit) => d.mdEntry < d.mdExit)
-    .sort((a, b) => a.mdEntry - b.mdEntry || a.level - b.level)
-    .reverse();
-
-  // flatten groups of unit picks, so that the highest level is
-  // given presedence over lower levels for overlapping picks.
-  const unitPicks = [];
-  while (itemstack.length > 0) {
-    const first = itemstack.pop();
-    const group: PairedPickAndUnit[] = [];
-    while (itemstack.length > 0 && itemstack[itemstack.length - 1].level > first.level) {
-      group.push(itemstack.pop());
-    }
-    group.reverse();
-    group.push(first);
-    const arr: { from: number; to: number; itm: PairedPickAndUnit }[] = [];
-    group.forEach((itm: PairedPickAndUnit) => {
-      const gaps = findGaps(itm.mdEntry, itm.mdExit, arr);
-      arr.push(...gaps.map((g) => ({ from: g[0], to: g[1], itm })));
-    });
-    arr.sort((a, b) => a.from - b.from);
-    unitPicks.push(
-      ...arr.map((d) => ({
-        from: d.from,
-        to: d.to,
-        ...d.itm,
-      })),
-    );
-  }
-  return { unitPicks, nonUnitPicks };
-}