880 Data Provider Framework in Intersection Module

frontend/src/api/autogen/types.gen.ts

@@ -1172,6 +1172,7 @@ export type WellborePick_api = {
     depthReferencePoint: string;
     mdUnit: string;
     interpreter: string | null;
+    obsNo: number;
 };
 
 export type WellboreTrajectory_api = {

frontend/src/lib/components/ToggleButton/toggleButton.tsx

@@ -14,13 +14,19 @@ export type ToggleButtonProps = ButtonUnstyledProps & {
 function ToggleButtonComponent(props: ToggleButtonProps, ref: React.ForwardedRef<HTMLDivElement>) {
     const { active, onToggle, ...other } = props;
     const [isActive, setIsActive] = React.useState<boolean>(active);
+    const [prevIsActive, setPrevIsActive] = React.useState<boolean>(active);
 
     const buttonRef = React.useRef<HTMLButtonElement>(null);
     React.useImperativeHandle<HTMLButtonElement | null, HTMLButtonElement | null>(
         props.buttonRef,
         () => buttonRef.current,
     );
 
+    if (active !== prevIsActive) {
+        setIsActive(active);
+        setPrevIsActive(isActive);
+    }
+
     const handleClick = React.useCallback(() => {
         setIsActive(!isActive);
         onToggle(!active);

frontend/src/lib/utils/assertNonNull.ts

@@ -0,0 +1,7 @@
+export function assertNonNull<T>(value: T | null | undefined, message?: string): T {
+    if (value === null || value === undefined) {
+        message = message || "Value cannot be null or undefined";
+        throw new Error(message);
+    }
+    return value;
+}

frontend/src/modules/Intersection/DataProviderFramework/boundingBoxes/makeGridBoundingBox.ts

@@ -41,7 +41,7 @@ export function makeGridBoundingBox({
     // Ensure consistency between fetched data and requested polyline
     if (polylineIntersectionData.fenceMeshSections.length !== polylineActualSectionLengths.length) {
         throw new Error(
-            `Number of fence mesh sections (${polylineIntersectionData.fenceMeshSections.length}) does not match  number of actual section
+            `Number of fence mesh sections (${polylineIntersectionData.fenceMeshSections.length}) does not match number of actual section
             lengths (${polylineActualSectionLengths.length}) for requested polyline`,
         );
     }

frontend/src/modules/Intersection/DataProviderFramework/boundingBoxes/makeSeismicBoundingBox.ts

@@ -1,4 +1,4 @@
-import type { BBox } from "@lib/utils/bbox";
+import { fromNumArray, type BBox } from "@lib/utils/bbox";
 import type {
     IntersectionRealizationSeismicData,
     IntersectionRealizationSeismicSettings,
@@ -42,16 +42,5 @@ export function makeSeismicBoundingBox({
     const minY = data.min_fence_depth;
     const maxY = data.max_fence_depth;
 
-    return {
-        min: {
-            x: minX,
-            y: minY,
-            z: 0.0,
-        },
-        max: {
-            x: maxX,
-            y: maxY,
-            z: 0.0,
-        },
-    };
+    return fromNumArray([minX, minY, 0, maxX, maxY, 0]);
 }

frontend/src/modules/Intersection/DataProviderFramework/boundingBoxes/makeSurfacesBoundingBox.ts

@@ -40,16 +40,32 @@ export function makeSurfacesBoundingBox({
     const minX = -extensionLength;
     const maxX = polylineActualSectionLengths.reduce((sum, length) => sum + length, -extensionLength);
 
-    // If no surfaces, return a bounding box with only the x-coordinates
+    // If no surfaces are selected
     if (data.length === 0) {
-        return fromNumArray([minX, 0, 0, maxX, 0, 0]);
+        return null;
     }
 
     let minY = Number.MAX_VALUE;
     let maxY = -Number.MAX_VALUE;
     for (const surface of data) {
-        minY = Math.min(minY, ...surface.z_points);
-        maxY = Math.max(maxY, ...surface.z_points);
+        // Find valid min and max values for the surface
+        const { min: surfaceMin, max: surfaceMax } = surface.z_points.reduce(
+            (acc, z) => {
+                if (z === null) {
+                    return acc;
+                }
+
+                return {
+                    min: Math.min(acc.min, z),
+                    max: Math.max(acc.max, z),
+                };
+            },
+            { min: Number.MAX_VALUE, max: -Number.MAX_VALUE },
+        );
+
+        // Update the overall min and max values
+        minY = Math.min(minY, surfaceMin);
+        maxY = Math.max(maxY, surfaceMax);
     }
 
     return fromNumArray([minX, minY, 0, maxX, maxY, 0]);

frontend/src/modules/Intersection/DataProviderFramework/customDataProviderImplementations/EnsembleWellborePicksProvider.ts

@@ -1,4 +1,4 @@
-import { filter, groupBy, isEqual, keys } from "lodash";
+import { groupBy, isEqual, keys } from "lodash";
 
 import { type WellborePick_api, getWellborePicksInStratColumnOptions } from "@api";
 import { IntersectionType } from "@framework/types/intersection";
@@ -101,13 +101,17 @@ export class EnsembleWellborePicksProvider
 
         availableSettingsUpdater(Setting.WELLBORE_PICKS, ({ getLocalSetting, getHelperDependency }) => {
             const wellborePicks = getHelperDependency(wellborePicksDep);
-            const interpreter = getLocalSetting(Setting.WELLBORE_PICK_IDENTIFIER);
+            const selectedInterpreter = getLocalSetting(Setting.WELLBORE_PICK_IDENTIFIER);
 
-            if (!wellborePicks || !interpreter) {
+            if (!wellborePicks || !selectedInterpreter) {
                 return [];
             }
 
-            return filter(wellborePicks, ["interpreter", interpreter]).sort();
+            return wellborePicks
+                .filter((elm) => elm.interpreter === selectedInterpreter)
+                .sort((a, b) => {
+                    return a.pickIdentifier.localeCompare(b.pickIdentifier);
+                });
         });
     }
 

frontend/src/modules/Intersection/DataProviderFramework/customDataProviderImplementations/RealizationSurfacesProvider.ts

@@ -7,6 +7,7 @@ import {
     postGetSurfaceIntersectionOptions,
 } from "@api";
 import { IntersectionType } from "@framework/types/intersection";
+import { assertNonNull } from "@lib/utils/assertNonNull";
 import {
     createIntersectionPolylineWithSectionLengthsForField,
     fetchWellboreHeaders,
@@ -71,7 +72,16 @@ export class RealizationSurfacesProvider
     }
 
     doSettingsChangesRequireDataRefetch(prevSettings: SettingsWithTypes, newSettings: SettingsWithTypes): boolean {
-        return !isEqual(prevSettings, newSettings);
+        return (
+            !prevSettings ||
+            !isEqual(prevSettings.intersection, newSettings.intersection) ||
+            !isEqual(prevSettings.wellboreExtensionLength, newSettings.wellboreExtensionLength) ||
+            !isEqual(prevSettings.ensemble, newSettings.ensemble) ||
+            !isEqual(prevSettings.realization, newSettings.realization) ||
+            !isEqual(prevSettings.attribute, newSettings.attribute) ||
+            !isEqual(prevSettings.surfaceNames, newSettings.surfaceNames) ||
+            !isEqual(prevSettings.sampleResolutionInMeters, newSettings.sampleResolutionInMeters)
+        );
     }
 
     areCurrentSettingsValid({
@@ -233,24 +243,23 @@ export class RealizationSurfacesProvider
         RealizationSurfacesData,
         RealizationSurfacesStoredData
     >): Promise<RealizationSurfacesData> {
-        const ensembleIdent = getSetting(Setting.ENSEMBLE);
-        const realization = getSetting(Setting.REALIZATION);
-        const attribute = getSetting(Setting.ATTRIBUTE);
-        const surfaceNames = getSetting(Setting.SURFACE_NAMES);
-        const sampleResolutionInMeters = getSetting(Setting.SAMPLE_RESOLUTION_IN_METERS) ?? 1;
+        const ensembleIdent = assertNonNull(getSetting(Setting.ENSEMBLE), "No ensemble selected");
+        const realization = assertNonNull(getSetting(Setting.REALIZATION), "No realization number selected");
+        const attribute = assertNonNull(getSetting(Setting.ATTRIBUTE), "No attribute selected");
+        const surfaceNames = assertNonNull(getSetting(Setting.SURFACE_NAMES), "No surface names selected");
+        const sampleResolutionInMeters = assertNonNull(
+            getSetting(Setting.SAMPLE_RESOLUTION_IN_METERS),
+            "No sample resolution selected",
+        );
+        const polylineWithSectionLengths = assertNonNull(
+            getStoredData("polylineWithSectionLengths"),
+            "No polyline and actual section lengths found in stored data",
+        );
         const extensionLength = createValidExtensionLength(
             getSetting(Setting.INTERSECTION),
             getSetting(Setting.WELLBORE_EXTENSION_LENGTH),
         );
 
-        if (sampleResolutionInMeters === null || !surfaceNames || !attribute) {
-            throw new Error("Invalid settings: Sample resolution, surface names or attribute are not set");
-        }
-
-        const polylineWithSectionLengths = getStoredData("polylineWithSectionLengths");
-        if (!polylineWithSectionLengths) {
-            throw new Error("No polyline and actual section lengths found in stored data");
-        }
         if (polylineWithSectionLengths.polylineUtmXy.length < 4) {
             throw new Error("Invalid polyline in stored data. Must contain at least two (x,y)-points");
         }
@@ -267,11 +276,11 @@ export class RealizationSurfacesProvider
             surfaceNames.map((surfaceName) => {
                 const queryOptions = postGetSurfaceIntersectionOptions({
                     query: {
-                        case_uuid: ensembleIdent?.getCaseUuid() ?? "",
-                        ensemble_name: ensembleIdent?.getEnsembleName() ?? "",
-                        realization_num: realization ?? 0,
+                        case_uuid: ensembleIdent.getCaseUuid(),
+                        ensemble_name: ensembleIdent.getEnsembleName(),
+                        realization_num: realization,
                         name: surfaceName,
-                        attribute: attribute ?? "",
+                        attribute: attribute,
                     },
                     body: {
                         cumulative_length_polyline: {

frontend/src/modules/Intersection/DataProviderFramework/customDataProviderImplementations/SurfacesPerRealizationValuesProvider.ts

@@ -7,6 +7,7 @@ import {
     postGetSampleSurfaceInPointsOptions,
 } from "@api";
 import { IntersectionType } from "@framework/types/intersection";
+import { assertNonNull } from "@lib/utils/assertNonNull";
 import {
     createIntersectionPolylineWithSectionLengthsForField,
     fetchWellboreHeaders,
@@ -75,7 +76,16 @@ export class SurfacesPerRealizationValuesProvider
     }
 
     doSettingsChangesRequireDataRefetch(prevSettings: SettingsWithTypes, newSettings: SettingsWithTypes): boolean {
-        return !isEqual(prevSettings, newSettings);
+        return (
+            !prevSettings ||
+            !isEqual(prevSettings.intersection, newSettings.intersection) ||
+            !isEqual(prevSettings.wellboreExtensionLength, newSettings.wellboreExtensionLength) ||
+            !isEqual(prevSettings.ensemble, newSettings.ensemble) ||
+            !isEqual(prevSettings.realizations, newSettings.realizations) ||
+            !isEqual(prevSettings.attribute, newSettings.attribute) ||
+            !isEqual(prevSettings.surfaceNames, newSettings.surfaceNames) ||
+            !isEqual(prevSettings.sampleResolutionInMeters, newSettings.sampleResolutionInMeters)
+        );
     }
 
     areCurrentSettingsValid({
@@ -256,47 +266,29 @@ export class SurfacesPerRealizationValuesProvider
         SurfacesPerRealizationValuesData,
         SurfacesPerRealizationValuesStoredData
     >): Promise<SurfacesPerRealizationValuesData> {
-        const ensembleIdent = getSetting(Setting.ENSEMBLE);
+        const ensembleIdent = assertNonNull(getSetting(Setting.ENSEMBLE), "No ensemble selected");
         const realizations = getSetting(Setting.REALIZATIONS);
-        const attribute = getSetting(Setting.ATTRIBUTE);
-        const surfaceNames = getSetting(Setting.SURFACE_NAMES);
-
-        if (!surfaceNames || !attribute) {
-            throw new Error("Invalid settings: Sample resolution, surface names or attribute are not set");
-        }
+        const attribute = assertNonNull(getSetting(Setting.ATTRIBUTE), "No attribute selected");
+        const surfaceNames = assertNonNull(getSetting(Setting.SURFACE_NAMES), "No surface names selected");
+        const requestedPolylineWithCumulatedLengths = assertNonNull(
+            getStoredData("requestedPolylineWithCumulatedLengths"),
+            "No polyline and cumulated lengths found in stored data",
+        );
 
-        const requestedPolylineWithCumulatedLengths = getStoredData("requestedPolylineWithCumulatedLengths");
-        if (!requestedPolylineWithCumulatedLengths) {
-            throw new Error("No polyline and cumulated lengths found in stored data");
-        }
         if (requestedPolylineWithCumulatedLengths.xUtmPoints.length < 2) {
             throw new Error(
                 "Invalid polyline in stored data. Must contain at least two (x,y)-points, and cumulated length per polyline section",
             );
         }
-        if (
-            requestedPolylineWithCumulatedLengths.xUtmPoints.length !==
-            requestedPolylineWithCumulatedLengths.yUtmPoints.length
-        ) {
-            throw new Error("Invalid polyline points in stored data. Must have same number of X and Y points");
-        }
-        if (
-            requestedPolylineWithCumulatedLengths.xUtmPoints.length !==
-            requestedPolylineWithCumulatedLengths.cumulatedHorizontalPolylineLengthArr.length
-        ) {
-            throw new Error(
-                "Invalid polyline in stored data. Number of cumulated lengths must be equal to number of polyline points",
-            );
-        }
 
         // Create list of surface name and its fetch promise
         const surfaceNameAndFetchList = surfaceNames.map((surfaceName) => {
             const queryOptions = postGetSampleSurfaceInPointsOptions({
                 query: {
-                    case_uuid: ensembleIdent?.getCaseUuid() ?? "",
-                    ensemble_name: ensembleIdent?.getEnsembleName() ?? "",
+                    case_uuid: ensembleIdent.getCaseUuid(),
+                    ensemble_name: ensembleIdent.getEnsembleName(),
                     surface_name: surfaceName,
-                    surface_attribute: attribute ?? "",
+                    surface_attribute: attribute,
                     realization_nums: realizations ?? [],
                 },
                 body: {

frontend/src/modules/Intersection/DataProviderFramework/customDataProviderImplementations/utils.ts

@@ -1,6 +1,22 @@
 import type { Vec2 } from "@lib/utils/vec2";
 import { normalizeVec2, point2Distance } from "@lib/utils/vec2";
 
+/**
+ * Validate that the xPoints, yPoints, and cumulatedHorizontalPolylineLengthArr arrays have the same length.
+ */
+function validatePolylinePointsAndCumulatedLengthArray(
+    xPoints: readonly number[],
+    yPoints: readonly number[],
+    cumulatedHorizontalPolylineLengthArr: readonly number[],
+): void {
+    if (xPoints.length !== yPoints.length) {
+        throw new Error("Invalid polyline: xPoints and yPoints arrays must have the same length");
+    }
+    if (xPoints.length !== cumulatedHorizontalPolylineLengthArr.length) {
+        throw new Error("Number of cumulated lengths must be equal to number of polyline points");
+    }
+}
+
 /**
  * Create resampled polyline and provide the cumulated horizontal length per point in resampled polyline.
  *
@@ -54,6 +70,9 @@ export function createResampledPolylinePointsAndCumulatedLengthArray(
         cumulatedHorizontalPolylineLengthArr.push(cumulatedPolylineLength);
     }
 
+    // Validate output
+    validatePolylinePointsAndCumulatedLengthArray(xPoints, yPoints, cumulatedHorizontalPolylineLengthArr);
+
     return {
         xPoints,
         yPoints,

frontend/src/modules/Intersection/DataProviderFramework/visualization/createGridLayerItemsMaker.ts

@@ -1,5 +1,3 @@
-import type { IntersectionReferenceSystem } from "@equinor/esv-intersection";
-
 import { LayerType } from "@modules/_shared/components/EsvIntersection";
 import type {
     IntersectionRealizationGridData,
@@ -54,7 +52,7 @@ export function createGridLayerItemsMaker({
 
     if (intersectionData.fenceMeshSections.length !== sourcePolylineWithSectionLengths.actualSectionLengths.length) {
         throw new Error(
-            `Number of fence mesh sections (${intersectionData.fenceMeshSections.length}) does not match  number of actual section
+            `Number of fence mesh sections (${intersectionData.fenceMeshSections.length}) does not match number of actual section
             lengths (${sourcePolylineWithSectionLengths.actualSectionLengths.length}) for requested polyline`,
         );
     }
@@ -71,8 +69,7 @@ export function createGridLayerItemsMaker({
     }
 
     const gridIntersectionLayerItemsMaker: EsvLayerItemsMaker = {
-        makeLayerItems: (intersectionReferenceSystem: IntersectionReferenceSystem | null) => {
-            void intersectionReferenceSystem; // Not used for this layer
+        makeLayerItems: () => {
             return [
                 {
                     id: `${id}-grid-layer`,

frontend/src/modules/Intersection/DataProviderFramework/visualization/createSeismicLayerItemsMaker.ts

@@ -1,5 +1,3 @@
-import type { IntersectionReferenceSystem } from "@equinor/esv-intersection";
-
 import { LayerType } from "@modules/_shared/components/EsvIntersection";
 import type {
     IntersectionRealizationSeismicData,
@@ -98,9 +96,7 @@ export function createSeismicLayerItemsMaker({
 
     // The layer has to be created inside EsvIntersection, so we need to return a LayerItem
     const intersectionSeismicLayerItemsMaker: EsvLayerItemsMaker = {
-        makeLayerItems: (intersectionReferenceSystem: IntersectionReferenceSystem | null) => {
-            void intersectionReferenceSystem; // Not used for this layer
-
+        makeLayerItems: () => {
             return [
                 {
                     id: `${id}-seismic-layer`,

frontend/src/modules/Intersection/registerModule.ts

@@ -13,7 +13,7 @@ ModuleRegistry.registerModule<Interfaces>({
     defaultTitle: "Intersection",
     category: ModuleCategory.MAIN,
     devState: ModuleDevState.DEV,
-    description: "Generic intersection viewer for co-visualization of intersection data from various sources.",
+    description: "Generic intersection viewer for co-visualization of data from various sources.",
     preview,
     dataTagIds: [
         ModuleDataTagId.GRID3D,