@webviz/subsurface-viewer 0.0.1-alpha.1

package/src/layers/utils/layerTools.ts

@@ -0,0 +1,182 @@
+import { PickingInfo } from "@deck.gl/core/typed";
+import { Color } from "@deck.gl/core/typed";
+import {
+    Layer,
+    LayersList,
+    LayerManager,
+    CompositeLayerProps,
+} from "@deck.gl/core/typed";
+import { Matrix4 } from "math.gl";
+import {
+    ContinuousLegendDataType,
+    DiscreteLegendDataType,
+} from "../../components/ColorLegend";
+import DrawingLayer from "../drawing/drawingLayer";
+
+export type Position3D = [number, number, number];
+
+// Return a color given a number in the [0,1] range.
+export type colorMapFunctionType = (x: number) => [number, number, number];
+
+export interface ExtendedLayerProps<D> extends CompositeLayerProps<D> {
+    "@@type"?: string;
+    name: string;
+}
+
+export interface ExtendedLayer<D> extends Layer<D> {
+    getLegendData?: () => DiscreteLegendDataType | ContinuousLegendDataType;
+}
+
+export interface PropertyDataType {
+    name: string;
+    value: string | number;
+    color?: Color;
+}
+
+// Layer pick info can have multiple properties
+export interface LayerPickInfo extends PickingInfo {
+    propertyValue?: number; // for single property
+    properties?: PropertyDataType[]; // for multiple properties
+}
+
+// Creates property object which will be used to display layer property
+// in the info card.
+export function createPropertyData(
+    name: string,
+    value: string | number,
+    color?: Color
+): PropertyDataType {
+    return {
+        name: name,
+        value: value,
+        color: color,
+    };
+}
+
+// Return a model matrix representing a rotation of "deg" degrees around the point x, y
+export function getModelMatrix(deg: number, x: number, y: number): Matrix4 {
+    const rad = deg * 0.017453;
+    const IDENTITY = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+
+    const m1 = new Matrix4(IDENTITY).translate([-x, -y, 0, 1]); // translate to origin
+    const mRot = new Matrix4(IDENTITY).rotateZ(rad); // rotate
+    const m2 = new Matrix4(IDENTITY).translate([x, y, 0, 1]); // translate back
+
+    // Make  m2*mRot*m1
+    mRot.multiplyRight(m1);
+    const m2mRotm1 = m2.multiplyRight(mRot);
+
+    return m2mRotm1;
+}
+
+// Return a model matrix representing a rotation of "deg" degrees around the point x, y
+export function getModelMatrixScale(scaleZ: number): Matrix4 {
+    const IDENTITY = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+    const mScaleZ = new Matrix4(IDENTITY).scale([1, 1, scaleZ]);
+    return mScaleZ;
+}
+
+export function getLayersInViewport(
+    layers: Record<string, unknown>[] | LayersList,
+    layerIds: string[] | undefined
+): Record<string, unknown>[] | LayersList {
+    if (layerIds && layerIds.length > 0 && layers) {
+        const layers_in_view = (layers as never[]).filter((layer) =>
+            layerIds.includes(layer["id"] as string)
+        );
+        return layers_in_view;
+    } else {
+        return layers;
+    }
+}
+
+export function getLayersByType(layers: LayersList, type: string): LayersList {
+    if (!layers) return [];
+    return layers.filter((l) => l?.constructor.name === type);
+}
+
+export type NewLayersList = LayersList & {
+    id: string;
+    props: prop;
+};
+
+type prop = {
+    data: wellData;
+    visible: boolean;
+};
+
+type wellData = {
+    features: feature[];
+    type: string;
+    unit?: string;
+};
+
+type feature = {
+    properties: {
+        name: string;
+    };
+};
+
+export function getWellLayerByTypeAndSelectedWells(
+    layers: LayersList,
+    type: string,
+    selectedWell: string
+): LayersList {
+    if (!layers) return [];
+    return layers.filter((l) => {
+        return (
+            l?.constructor.name === type &&
+            (l as NewLayersList).props.data.features.find(
+                (item) => item.properties.name === selectedWell
+            )
+        );
+    });
+}
+
+export function getLayersById(layers: LayersList, id: string): LayersList {
+    if (!layers) return [];
+    return layers.filter((l) => (l as Layer).id === id);
+}
+
+export function isDrawingEnabled(layer_manager: LayerManager): boolean {
+    const drawing_layer = layer_manager.getLayers({
+        layerIds: ["drawing-layer"],
+    })?.[0] as DrawingLayer;
+    return (
+        drawing_layer &&
+        drawing_layer.props.visible &&
+        drawing_layer.props.mode != "view"
+    );
+}
+
+export function invertZCoordinate(dataArray: Float32Array): void {
+    for (let i = 2; i < dataArray.length; i += 3) {
+        dataArray[i] *= -1;
+    }
+}
+
+export function defineBoundingBox(
+    dataArray: Float32Array
+): [number, number, number, number, number, number] {
+    const length = dataArray.length;
+    let minX = Number.POSITIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let minZ = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    let maxZ = Number.NEGATIVE_INFINITY;
+
+    for (let i = 0; i < length; i += 3) {
+        const x = dataArray[i];
+        const y = dataArray[i + 1];
+        const z = dataArray[i + 2];
+        minX = x < minX ? x : minX;
+        minY = y < minY ? y : minY;
+        minZ = z < minZ ? z : minZ;
+
+        maxX = x > maxX ? x : maxX;
+        maxY = y > maxY ? y : maxY;
+        maxZ = z > maxZ ? z : maxZ;
+    }
+    return [minX, minY, minZ, maxX, maxY, maxZ];
+}

package/src/layers/utils/propertyMapTools.ts

@@ -0,0 +1,43 @@
+import { Color } from "@deck.gl/core/typed";
+
+// Parameters used to decode a float value from RGB pixels.
+export interface ValueDecoder {
+    // r, g and b multipliers
+    rgbScaler: [number, number, number];
+    // value multiplier
+    floatScaler: number;
+    // translation of the r, g, b sum
+    offset: number;
+    // discretize the value in a number of steps
+    step: number;
+}
+
+// Decode an RGB pixel to a float value. Same operation the one performed in decoder.fs.glsl,
+// but this time performed in the js world.
+// Optionally, this function can also remap an [0, 1] value to a different range, [min, max].
+export function decodeRGB(
+    [r, g, b]: Color,
+    decoder: ValueDecoder,
+    remapToRange?: [number, number]
+): number {
+    const { rgbScaler, floatScaler, offset, step } = decoder;
+    const [rScale, gScale, bScale] = rgbScaler;
+
+    r *= rScale * 256.0 * 256.0;
+    g *= gScale * 256.0;
+    b *= bScale;
+
+    let decodedValue = (r + g + b + offset) * floatScaler;
+
+    if (step > 0) {
+        decodedValue = Math.floor(decodedValue / step + 0.5) * step;
+    }
+
+    if (remapToRange) {
+        const [min, max] = remapToRange;
+        // If we know the min and max values, remap the [0, 1] decoded value to [min, max]
+        decodedValue = decodedValue * (max - min) + min;
+    }
+
+    return decodedValue;
+}

package/src/layers/wells/utils/spline.ts

@@ -0,0 +1,318 @@
+import { FeatureCollection, GeometryCollection, LineString } from "geojson";
+import { cloneDeep } from "lodash";
+import { Position3D } from "../../utils/layerTools";
+
+/**
+ * Given four points P0, P1, P2, P4 and a argument t in the interval [0,1].
+ * returns function value at t. t == 0 corresponds to P1 and t == 1 corrsponds to P2
+ *
+ * See https://qroph.github.io/2018/07/30/smooth-paths-using-catmull-rom-splines.html
+ */
+export function CatmullRom1D(
+    P0: number,
+    P1: number,
+    P2: number,
+    P3: number,
+    t: number
+): number {
+    const alpha = 0.5;
+    const tt = t * t;
+    const ttt = t * t * t;
+
+    const dist_p0_p1 = Math.sqrt(
+        (P1 - P0) * (P1 - P0) + (P1 - P0) * (P1 - P0) + (P1 - P0) * (P1 - P0)
+    );
+    const dist_p1_p2 = Math.sqrt(
+        (P1 - P2) * (P1 - P2) + (P1 - P2) * (P1 - P2) + (P1 - P2) * (P1 - P2)
+    );
+    const dist_p2_p3 = Math.sqrt(
+        (P3 - P2) * (P3 - P2) + (P3 - P2) * (P3 - P2) + (P3 - P2) * (P3 - P2)
+    );
+
+    const t01 = Math.pow(dist_p0_p1, alpha);
+    const t12 = Math.pow(dist_p1_p2, alpha);
+    const t23 = Math.pow(dist_p2_p3, alpha);
+
+    const m1 = P2 - P1 + t12 * ((P1 - P0) / t01 - (P2 - P0) / (t01 + t12));
+    const m2 = P2 - P1 + t12 * ((P3 - P2) / t23 - (P3 - P1) / (t12 + t23));
+
+    const a_x = 2 * (P1 - P2) + m1 + m2;
+    const b_x = -3 * (P1 - P2) - m1 - m1 - m2;
+    const c_x = m1;
+    const d_x = P1;
+
+    const x = a_x * ttt + b_x * tt + c_x * t + d_x;
+
+    return x;
+}
+
+/**
+ * Given four 3D points P0, P1, P2, P4 and a scalar argument t in the interval [0,1].
+ * returns function value (3D) at t. t == 0 corresponds to P1 and t == 1 corrsponds to P2
+ *
+ * See https://qroph.github.io/2018/07/30/smooth-paths-using-catmull-rom-splines.html
+ */
+export function CatmullRom(
+    P0: Position3D,
+    P1: Position3D,
+    P2: Position3D,
+    P3: Position3D,
+    t: number
+): Position3D {
+    const alpha = 0.5;
+    const tt = t * t;
+    const ttt = t * t * t;
+
+    // disable eslint for some lines due to readability.
+    const dist_p0_p1 = Math.sqrt((P1[0]-P0[0])*(P1[0]-P0[0]) + (P1[1]-P0[1])*(P1[1]-P0[1]) + (P1[2]-P0[2])*(P1[2]-P0[2]) ); // eslint-disable-line
+    const dist_p1_p2 = Math.sqrt((P1[0]-P2[0])*(P1[0]-P2[0]) + (P1[1]-P2[1])*(P1[1]-P2[1]) + (P1[2]-P2[2])*(P1[2]-P2[2]) ); // eslint-disable-line
+    const dist_p2_p3 = Math.sqrt((P3[0]-P2[0])*(P3[0]-P2[0]) + (P3[1]-P2[1])*(P3[1]-P2[1]) + (P3[2]-P2[2])*(P3[2]-P2[2]) ); // eslint-disable-line
+
+    const t01 = Math.pow(dist_p0_p1, alpha);
+    const t12 = Math.pow(dist_p1_p2, alpha);
+    const t23 = Math.pow(dist_p2_p3, alpha);
+
+    const m1_x = (P2[0] - P1[0] + t12 * ((P1[0] - P0[0]) / t01 - (P2[0] - P0[0]) / (t01 + t12))); // eslint-disable-line
+    const m1_y = (P2[1] - P1[1] + t12 * ((P1[1] - P0[1]) / t01 - (P2[1] - P0[1]) / (t01 + t12))); // eslint-disable-line
+    const m1_z = (P2[2] - P1[2] + t12 * ((P1[2] - P0[2]) / t01 - (P2[2] - P0[2]) / (t01 + t12))); // eslint-disable-line
+
+    const m2_x = (P2[0] - P1[0] + t12 * ((P3[0] - P2[0]) / t23 - (P3[0] - P1[0]) / (t12 + t23))); // eslint-disable-line
+    const m2_y = (P2[1] - P1[1] + t12 * ((P3[1] - P2[1]) / t23 - (P3[1] - P1[1]) / (t12 + t23))); // eslint-disable-line
+    const m2_z = (P2[2] - P1[2] + t12 * ((P3[2] - P2[2]) / t23 - (P3[2] - P1[2]) / (t12 + t23))); // eslint-disable-line
+
+    const a_x = 2 * (P1[0] - P2[0]) + m1_x + m2_x;
+    const a_y = 2 * (P1[1] - P2[1]) + m1_y + m2_y;
+    const a_z = 2 * (P1[2] - P2[2]) + m1_z + m2_z;
+
+    const b_x = -3 * (P1[0] - P2[0]) - m1_x - m1_x - m2_x;
+    const b_y = -3 * (P1[1] - P2[1]) - m1_y - m1_y - m2_y;
+    const b_z = -3 * (P1[2] - P2[2]) - m1_z - m1_z - m2_z;
+
+    const c_x = m1_x;
+    const c_y = m1_y;
+    const c_z = m1_z;
+
+    const d_x = P1[0];
+    const d_y = P1[1];
+    const d_z = P1[2];
+
+    const x = a_x * ttt + b_x * tt + c_x * t + d_x;
+    const y = a_y * ttt + b_y * tt + c_y * t + d_y;
+    const z = a_z * ttt + b_z * tt + c_z * t + d_z;
+
+    return [x, y, z] as Position3D;
+}
+
+/**
+ * Will interpolate and refine wellpaths using spline interploation resulting
+ * in smoother curves with more points.
+ * Assumes 3D data.
+ */
+export function splineRefine(data_in: FeatureCollection): FeatureCollection {
+    const data = cloneDeep(data_in);
+
+    const no_wells = data.features.length;
+    for (let well_no = 0; well_no < no_wells; well_no++) {
+        const mds = data.features[well_no].properties?.["md"];
+        if (mds === undefined) {
+            continue;
+        }
+        const geometryCollection = data.features[well_no]
+            .geometry as GeometryCollection;
+        const lineString = geometryCollection?.geometries[1] as LineString;
+
+        if (lineString.coordinates?.length === undefined) {
+            continue;
+        }
+
+        const coords = lineString.coordinates as Position3D[];
+
+        const n = coords.length;
+        const ts = n > 3 ? [0.2, 0.4, 0.6, 0.8] : [];
+
+        // Point before first.
+        const x0 = coords[0][0] - coords[1][0] + coords[0][0];
+        const y0 = coords[0][1] - coords[1][1] + coords[0][1];
+        const z0 = coords[0][2] - coords[1][2] + coords[0][2];
+        const P_first: Position3D = [x0, y0, z0];
+
+        const md_first = mds[0][0] - mds[0][1] + mds[0][0];
+
+        // Point after last.
+        const xn = coords[n - 1][0] - coords[n - 2][0] + coords[n - 1][0];
+        const yn = coords[n - 1][1] - coords[n - 2][1] + coords[n - 1][1];
+        const zn = coords[n - 1][2] - coords[n - 2][2] + coords[n - 1][2];
+        const P_n: Position3D = [xn, yn, zn];
+
+        const md_n = mds[0][n - 1] - mds[0][n - 2] + mds[0][n - 1];
+
+        const newCoordinates: Position3D[] = [];
+        const newMds: number[][] = [];
+        newMds.push([]);
+
+        for (let i = 0; i < n - 1; i += 1) {
+            let P0: Position3D, P1: Position3D, P2: Position3D, P3: Position3D;
+            let md0: number, md1: number, md2: number, md3: number;
+
+            if (i === 0) {
+                P0 = P_first;
+                P1 = coords[i + 0];
+                P2 = coords[i + 1];
+                P3 = coords[i + 2];
+
+                md0 = md_first;
+                md1 = mds[0][i + 0];
+                md2 = mds[0][i + 1];
+                md3 = mds[0][i + 2];
+            } else if (i === n - 2) {
+                P0 = coords[n - 3];
+                P1 = coords[n - 2];
+                P2 = coords[n - 1];
+                P3 = P_n;
+
+                md0 = mds[0][n - 3];
+                md1 = mds[0][n - 2];
+                md2 = mds[0][n - 1];
+                md3 = md_n;
+            } else {
+                P0 = coords[i - 1];
+                P1 = coords[i - 0];
+                P2 = coords[i + 1];
+                P3 = coords[i + 2];
+
+                md0 = mds[0][i - 1];
+                md1 = mds[0][i - 0];
+                md2 = mds[0][i + 1];
+                md3 = mds[0][i + 2];
+            }
+
+            newCoordinates.push(P1);
+            newMds[0].push(md1);
+
+            // Skip first leg from platform to first survey point.
+            if (i > 1) {
+                for (let t_i = 0; t_i < ts.length; t_i += 1) {
+                    const t = ts[t_i];
+                    const [x, y, z] = CatmullRom(P0, P1, P2, P3, t);
+                    const md = CatmullRom1D(md0, md1, md2, md3, t);
+
+                    newCoordinates.push([x, y, z] as Position3D);
+                    newMds[0].push(md);
+                }
+            }
+        }
+
+        newCoordinates.push(coords[n - 1]);
+        newMds[0].push(mds[0][n - 1]);
+
+        (
+            (data.features[well_no].geometry as GeometryCollection)
+                .geometries[1] as LineString
+        ).coordinates = newCoordinates;
+
+        if (data.features[well_no].properties) {
+            data.features[well_no].properties!["md"] = newMds; // eslint-disable-line
+        }
+    }
+
+    return data;
+}
+
+export function flattenPath(data_in: FeatureCollection): FeatureCollection {
+    const data = cloneDeep(data_in);
+
+    const no_wells = data.features.length;
+    for (let well_no = 0; well_no < no_wells; well_no++) {
+        const geometryCollection = data.features[well_no]
+            .geometry as GeometryCollection;
+        const lineString = geometryCollection?.geometries[1] as LineString;
+
+        if (lineString.coordinates?.length === undefined) {
+            continue;
+        }
+
+        const coords = lineString.coordinates as Position3D[];
+
+        // flatten by setting z value constant.
+        const coords_flat: Position3D[] = coords.map((e: Position3D) => {
+            return [e[0], e[1], 0.0];
+        });
+
+        (
+            (data.features[well_no].geometry as GeometryCollection)
+                .geometries[1] as LineString
+        ).coordinates = coords_flat;
+    }
+
+    return data;
+}
+
+export function invertPath(data_in: FeatureCollection): FeatureCollection {
+    const data = cloneDeep(data_in);
+
+    const no_wells = data.features.length;
+    for (let well_no = 0; well_no < no_wells; well_no++) {
+        const geometryCollection = data.features[well_no]
+            .geometry as GeometryCollection;
+        const lineString = geometryCollection?.geometries[1] as LineString;
+
+        if (lineString.coordinates?.length === undefined) {
+            continue;
+        }
+
+        const coords = lineString.coordinates as Position3D[];
+
+        // Invert path by multiplying depth with -1.
+        const coords_inverted: Position3D[] = coords.map((e: Position3D) => {
+            return [e[0], e[1], -e[2]];
+        });
+
+        (
+            (data.features[well_no].geometry as GeometryCollection)
+                .geometries[1] as LineString
+        ).coordinates = coords_inverted;
+    }
+
+    return data;
+}
+
+/**
+ * Calculates bounding box of all wells.
+ */
+export function GetBoundingBox(
+    data: FeatureCollection
+): [number, number, number, number, number, number] {
+    let xMin = 9999999999;
+    let yMin = 9999999999;
+    let zMin = 9999999999;
+    let xMax = -9999999999;
+    let yMax = -9999999999;
+    let zMax = -9999999999;
+
+    const no_wells = data.features.length;
+    for (let well_no = 0; well_no < no_wells; well_no++) {
+        const geometryCollection = data.features[well_no]
+            .geometry as GeometryCollection;
+        const lineString = geometryCollection?.geometries[1] as LineString;
+
+        if (lineString.coordinates?.length === undefined) {
+            continue;
+        }
+
+        const coords = lineString.coordinates as Position3D[];
+        const n = coords.length;
+        for (let i = 0; i < n; i++) {
+            const xyz = coords[i];
+
+            xMin = xyz[0] < xMin ? xyz[0] : xMin;
+            yMin = xyz[1] < yMin ? xyz[1] : yMin;
+            zMin = xyz[2] < zMin ? xyz[2] : zMin;
+
+            xMax = xyz[0] > xMax ? xyz[0] : xMax;
+            yMax = xyz[1] > yMax ? xyz[1] : yMax;
+            zMax = xyz[2] > zMax ? xyz[2] : zMax;
+        }
+    }
+
+    return [xMin, yMin, zMin, xMax, yMax, zMax];
+}