[Bug fix]: Several bug fixes in intersection module (#1406)

Author: rubenthoms

frontend/src/modules/ModuleSerializedStateMap.ts

@@ -24,108 +24,137 @@ import type { SerializedSettings as WellCompletionsSettings } from "@modules/Wel
 import type { SerializedSettings as WellLogViewerSettings } from "@modules/WellLogViewer/settings/persistence";
 
 export type ModuleSerializedStateMap = {
-    "2DViewer": {
-        settings?: Partial<M_2DViewerSettings>;
-        view?: Partial<M_2DViewerView>;
-    };
-    "3DViewer": {
-        settings?: Partial<M_3DViewerSettings>;
-        view?: Partial<M_3DViewerView>;
-    };
-    DbgWorkbenchSpy: {
-        settings?: never;
-        view?: never;
-    };
-    DistributionPlot: {
-        settings?: Partial<DistributionPlotSettings>;
-        view?: never;
-    };
-    FlowNetwork: {
-        settings?: Partial<FlowNetworkSettings>;
-        view?: never;
-    };
-    InplaceVolumesPlot: {
-        settings?: Partial<InplaceVolumesPlotSettings>;
-        view?: never;
-    };
-    InplaceVolumesTable: {
-        settings?: Partial<InplaceVolumesTableSettings>;
-        view?: never;
-    };
-    Intersection: {
-        settings?: Partial<IntersectionSettings>;
-        view?: never;
-    };
-    Map: {
-        settings?: never;
-        view?: never;
-    };
-    MyModule: {
-        settings?: never;
-        view?: never;
-    };
-    MyModule2: {
-        settings?: never;
-        view?: never;
-    };
-    ParameterDistributions: {
-        settings?: Partial<ParameterDistributionsSettings>;
-        view?: never;
-    };
-    ParameterResponseCorrelationBarPlot: {
-        settings?: Partial<ParameterResponseCorrelationBarPlotSettings>;
-        view?: never;
-    };
-    ParameterResponseCorrelationMatrixPlot: {
-        settings?: Partial<ParameterResponseCorrelationMatrixPlotSettings>;
-        view?: never;
-    };
-    ParameterResponseCorrelationParallelCoordsPlot: {
-        settings?: Partial<ParameterResponseCorrelationParallelCoordsPlotSettings>;
-        view?: never;
-    };
-    ParameterResponseCrossPlot: {
-        settings?: Partial<ParameterResponseCrossPlotSettings>;
-        view?: never;
-    };
-    Pvt: {
-        settings?: never;
-        view?: never;
-    };
-    Rft: {
-        settings?: never;
-        view?: never;
-    };
-    SensitivityPlot: {
-        settings?: Partial<SensitivityPlotSettings>;
-        view?: never;
-    };
-    SimulationTimeSeries: {
-        settings?: Partial<SimulationTimeSeriesSettings>;
-        view?: Partial<SimulationTimeSeriesView>;
-    };
-    SimulationTimeSeriesSensitivity: {
-        settings?: Partial<SimulationTimeSeriesSensitivitySettings>;
-        view?: Partial<SimulationTimeSeriesSensitivityView>;
-    };
-    SubsurfaceMap: {
-        settings?: never;
-        view?: never;
-    };
-    TopographicMap: {
-        settings?: never;
-        view?: never;
-    };
-    Vfp: {
-        settings?: never;
-        view?: never;
-    };
-    WellCompletions: {
-        settings?: Partial<WellCompletionsSettings>;
-        view?: never;
-    };
-    WellLogViewer: {
-        settings?: Partial<WellLogViewerSettings>;
-        view?: never;
-    };
+  "2DViewer": {
+    settings?: Partial<M_2DViewerSettings>,
+    view?: Partial<M_2DViewerView>,
+  },
+  "3DViewer": {
+    settings?: Partial<M_3DViewerSettings>,
+    view?: Partial<M_3DViewerView>,
+  },
+  "3DViewerNew": {
+    settings?: never,
+    view?: never,
+  },
+  "DbgWorkbenchSpy": {
+    settings?: never,
+    view?: never,
+  },
+  "DistributionPlot": {
+    settings?: Partial<DistributionPlotSettings>,
+    view?: never,
+  },
+  "FlowNetwork": {
+    settings?: Partial<FlowNetworkSettings>,
+    view?: never,
+  },
+  "Grid3D": {
+    settings?: never,
+    view?: never,
+  },
+  "Grid3DIntersection": {
+    settings?: never,
+    view?: never,
+  },
+  "InplaceVolumesPlot": {
+    settings?: Partial<InplaceVolumesPlotSettings>,
+    view?: never,
+  },
+  "InplaceVolumesTable": {
+    settings?: Partial<InplaceVolumesTableSettings>,
+    view?: never,
+  },
+  "InplaceVolumetrics": {
+    settings?: never,
+    view?: never,
+  },
+  "Intersection": {
+    settings?: Partial<IntersectionSettings>,
+    view?: never,
+  },
+  "Map": {
+    settings?: never,
+    view?: never,
+  },
+  "MyModule": {
+    settings?: never,
+    view?: never,
+  },
+  "MyModule2": {
+    settings?: never,
+    view?: never,
+  },
+  "ParameterDistributions": {
+    settings?: Partial<ParameterDistributionsSettings>,
+    view?: never,
+  },
+  "ParameterResponseCorrelationBarPlot": {
+    settings?: Partial<ParameterResponseCorrelationBarPlotSettings>,
+    view?: never,
+  },
+  "ParameterResponseCorrelationMatrixPlot": {
+    settings?: Partial<ParameterResponseCorrelationMatrixPlotSettings>,
+    view?: never,
+  },
+  "ParameterResponseCorrelationParallelCoordsPlot": {
+    settings?: Partial<ParameterResponseCorrelationParallelCoordsPlotSettings>,
+    view?: never,
+  },
+  "ParameterResponseCrossPlot": {
+    settings?: Partial<ParameterResponseCrossPlotSettings>,
+    view?: never,
+  },
+  "Pvt": {
+    settings?: never,
+    view?: never,
+  },
+  "Rft": {
+    settings?: never,
+    view?: never,
+  },
+  "SeismicIntersection": {
+    settings?: never,
+    view?: never,
+  },
+  "SensitivityPlot": {
+    settings?: Partial<SensitivityPlotSettings>,
+    view?: never,
+  },
+  "SimulationTimeSeries": {
+    settings?: Partial<SimulationTimeSeriesSettings>,
+    view?: Partial<SimulationTimeSeriesView>,
+  },
+  "SimulationTimeSeriesMatrix": {
+    settings?: never,
+    view?: never,
+  },
+  "SimulationTimeSeriesSensitivity": {
+    settings?: Partial<SimulationTimeSeriesSensitivitySettings>,
+    view?: Partial<SimulationTimeSeriesSensitivityView>,
+  },
+  "StructuralUncertaintyIntersection": {
+    settings?: never,
+    view?: never,
+  },
+  "SubsurfaceMap": {
+    settings?: never,
+    view?: never,
+  },
+  "TimeSeriesParameterDistribution": {
+    settings?: never,
+    view?: never,
+  },
+  "Vfp": {
+    settings?: never,
+    view?: never,
+  },
+  "WellCompletions": {
+    settings?: Partial<WellCompletionsSettings>,
+    view?: never,
+  },
+  "WellLogViewer": {
+    settings?: Partial<WellLogViewerSettings>,
+    view?: never,
+  },
 };
+

frontend/src/modules/_shared/components/EsvIntersection/interaction/FanchartIntersectionCalculator.ts

@@ -31,6 +31,12 @@ export class FanchartIntersectionCalculator implements IntersectionCalculator {
         const y1 = p1[1];
         const x2 = p2[0];
         const y2 = p2[1];
+
+        // Handle vertical line (x2 === x1) - cannot interpolate
+        if (x2 === x1) {
+            return y1;
+        }
+
         return y1 + ((x - x1) * (y2 - y1)) / (x2 - x1);
     }
 

frontend/src/modules/_shared/components/EsvIntersection/interaction/HighlightOverlay.ts

@@ -135,12 +135,16 @@ export class HighlightOverlay {
             }
             if (item.shape === HighlightItemShape.POINTS) {
                 for (const point of item.points) {
-                    const circle = document.createElementNS("http://www.w3.org/2000/svg", "circle");
-                    circle.setAttribute("cx", xScale(point[0]).toString());
-                    circle.setAttribute("cy", yScale(point[1]).toString());
-                    circle.setAttribute("r", "5");
-                    circle.setAttribute("fill", item.color);
-                    svgLayer.appendChild(circle);
+                    try {
+                        const circle = document.createElementNS("http://www.w3.org/2000/svg", "circle");
+                        circle.setAttribute("cx", xScale(point[0]).toString());
+                        circle.setAttribute("cy", yScale(point[1]).toString());
+                        circle.setAttribute("r", "5");
+                        circle.setAttribute("fill", item.color);
+                        svgLayer.appendChild(circle);
+                    } catch (error) {
+                        console.error("Error drawing highlight items:", error);
+                    }
                 }
             }
         }

frontend/src/modules/_shared/components/EsvIntersection/interaction/LineIntersectionCalculator.ts

@@ -155,7 +155,7 @@ export class LineIntersectionCalculator implements IntersectionCalculator {
     } {
         let nearestPoint = this._points[startIndex];
         let smallestDistance = this.calcPointDistance(nearestPoint, point);
-        let nearestPointIndex = 0;
+        let nearestPointIndex = startIndex;
 
         if (startIndex === endIndex) {
             return {
@@ -164,7 +164,7 @@ export class LineIntersectionCalculator implements IntersectionCalculator {
             };
         }
 
-        for (let i = startIndex + 1; i < endIndex; i++) {
+        for (let i = startIndex + 1; i <= endIndex; i++) {
             const distance = this.calcPointDistance(this._points[i], point);
             if (distance < smallestDistance) {
                 nearestPoint = this._points[i];
@@ -182,7 +182,7 @@ export class LineIntersectionCalculator implements IntersectionCalculator {
 
         if (nearestPointIndex === endIndex) {
             return {
-                p1: nearestPoint,
+                p1: this._points[endIndex - 1],
                 p2: this._points[endIndex],
             };
         }
@@ -238,8 +238,16 @@ export class LineIntersectionCalculator implements IntersectionCalculator {
         const scalarProduct = p1ToPointVector[0] * p1ToP2Vector[0] + p1ToPointVector[1] * p1ToP2Vector[1];
 
         const p1ToP2Length = this.calcPointDistance(lineSegment.p1, lineSegment.p2);
+
+        // Handle degenerate case where p1 and p2 are the same point
+        if (p1ToP2Length === 0) {
+            return [lineSegment.p1[0], lineSegment.p1[1]];
+        }
+
         const scalar = scalarProduct / p1ToP2Length ** 2;
-        const result = [p1ToP2Vector[0] * scalar, p1ToP2Vector[1] * scalar];
+        // Clamp scalar to [0, 1] to keep the result within the line segment
+        const clampedScalar = Math.max(0, Math.min(1, scalar));
+        const result = [p1ToP2Vector[0] * clampedScalar, p1ToP2Vector[1] * clampedScalar];
 
         const resultVector = [lineSegment.p1[0] + result[0], lineSegment.p1[1] + result[1]];
 

frontend/src/modules/_shared/components/EsvIntersection/interaction/LineSetIntersectionCalculator.ts

@@ -1,4 +1,3 @@
-
 import type { IntersectedItem, IntersectionCalculator } from "../types/types";
 import { IntersectionItemShape } from "../types/types";
 import { calcDistance } from "../utils/geometry";
@@ -29,6 +28,12 @@ export class LineSetIntersectionCalculator implements IntersectionCalculator {
         const y1 = p1[1];
         const x2 = p2[0];
         const y2 = p2[1];
+
+        // Handle vertical line (x2 === x1) - cannot interpolate
+        if (x2 === x1) {
+            return y1;
+        }
+
         return y1 + ((x - x1) * (y2 - y1)) / (x2 - x1);
     }
 

frontend/src/modules/_shared/components/EsvIntersection/utils/intersectionConversion.ts

@@ -1,6 +1,5 @@
 import type { Controller, Layer } from "@equinor/esv-intersection";
 
-
 import { FanchartIntersectionCalculator } from "../interaction/FanchartIntersectionCalculator";
 import type { IntersectionHandlerOptions } from "../interaction/IntersectionHandler";
 import { LineIntersectionCalculator } from "../interaction/LineIntersectionCalculator";
@@ -81,7 +80,7 @@ export function getColorFromLayerData(layer: Layer<unknown>, index: number): str
     }
 
     if (isStatisticalFanchartsCanvasLayer(layer) && layer.data) {
-        return layer.data.fancharts[index].color ?? "#000";
+        return layer.data.fancharts[index]?.color ?? "#000";
     }
 
     if (isCalloutCanvasLayer(layer) && layer.data) {

frontend/src/modules/_shared/components/EsvIntersection/utils/readoutItemUtils.tsx

@@ -467,7 +467,7 @@ export function esvReadoutToGenericReadout(
 ): GenericReadoutItem {
     return {
         label: makeLabelFromLayer(readout.layer, layerIdToNameMap) ?? getLabelFromLayerData(readout),
-        color: getColorFromLayerData(readout.layer, index),
+        color: getColorFromLayerData(readout.layer, readout.index),
         info: esvReadoutToInfoItems(readout),
     };
 }