@webviz/well-log-viewer 2.0.1 → 2.1.0

package/dist/utils/tracks.d.ts

@@ -9,7 +9,7 @@ export interface ExtPlotOptions extends GradientFillPlotOptions {
 }
 import type WellLogView from "../components/WellLogView";
 import type { TemplatePlotType, TemplateTrack, TemplatePlot, TemplateStyle } from "../components/WellLogTemplateTypes";
-import type { WellLog, WellLogMetadataDiscreteObjects } from "../components/WellLogTypes";
+import type { WellLogSet, WellLogMetadataDiscreteObjects } from "../components/WellLogTypes";
 import type { ColorMapFunction } from "../components/ColorMapFunction";
 export declare function indexOfElementByName(array: Named[], name: string): number;
 declare class TracksInfo {
@@ -23,7 +23,7 @@ declare class TracksInfo {
 type Named = {
     name: string;
 };
-export declare function getAvailableAxes(welllog: WellLog | undefined, axisMnemos: Record<string, string[]>): string[];
+export declare function getAvailableAxes(wellLog: WellLogSet[], axisMnemos: Record<string, string[]>): string[];
 import type { Plot } from "@equinor/videx-wellog";
 export declare function getPlotType(plot: Plot): TemplatePlotType;
 export declare function addOrEditGraphTrackPlot(wellLogView: WellLogView, track: GraphTrack, plot: Plot | null, templatePlot: TemplatePlot): void;
@@ -37,7 +37,7 @@ export declare function getDiscreteColorAndName(value: number | string | null, c
     color: number[];
     name: string;
 };
-export declare function getDiscreteMeta(welllog: WellLog, name: string): DiscreteMeta | null;
+export declare function getDiscreteMeta(wellLogSet: WellLogSet, name: string): DiscreteMeta | null;
 export interface TrackOptionsEx extends TrackOptions {
     __template: TemplateTrack;
 }
@@ -51,7 +51,7 @@ export interface AxesInfo {
     titles: Record<string, string>;
     mnemos: Record<string, string[]>;
 }
-export declare function createTracks(welllog: WellLog | undefined, axes: AxesInfo, templateTracks: TemplateTrack[], // Part of JSON
+export declare function createTracks(wellLog: WellLogSet[], axes: AxesInfo, templateTracks: TemplateTrack[], // Part of JSON
 templateStyles: TemplateStyle[] | undefined, // Part of JSON
 colorMapFunctions: ColorMapFunction[]): TracksInfo;
 export declare function addOrEditGraphTrack(wellLogView: WellLogView, track: GraphTrack | null, templateTrack: TemplateTrack, trackCurrent: Track, bAfter: boolean): GraphTrack;

package/dist/utils/tracks.js

@@ -17,6 +17,9 @@ import { createScale } from "./graph/factory";
 import { checkMinMaxValue, checkMinMax, roundMinMax, roundLogMinMax, } from "./minmax";
 import { updateLegendRows } from "./log-viewer";
 import { deepCopy } from "./deepcopy";
+import { createPlotType } from "@equinor/videx-wellog";
+import { defaultPlotFactory } from "@equinor/videx-wellog";
+import { getAxisIndices, getDiscreteMetaDataByName, getAllWellLogCurves, findSetAndCurveIndex, } from "./well-log";
 export function indexOfElementByName(array, name) {
     if (array && name) {
         const nameUpper = name.toUpperCase();
@@ -42,15 +45,6 @@ function indexOfElementByNames(array, names) {
     }
     return -1;
 }
-function elementByKeyName(meta, name) {
-    name = name.toUpperCase();
-    for (const key in meta) {
-        if (key.toUpperCase() === name)
-            // search case insensitive!
-            return meta[key];
-    }
-    return null;
-}
 const __colors = [
     "red",
     "blue",
@@ -113,12 +107,11 @@ function shortDescription(description) {
     }
     return description;
 }
-function makeTrackHeader(welllog, templateTrack) {
+function makeTrackHeader(curves, templateTrack) {
     if (templateTrack.title)
         return templateTrack.title;
     const templatePlots = templateTrack.plots;
     if (templatePlots && templatePlots[0]) {
-        const curves = welllog.curves;
         // get the first curve name
         const templatePlot = templatePlots[0];
         const iCurve = indexOfElementByName(curves, templatePlot.name);
@@ -147,15 +140,13 @@ class TracksInfo {
         this.secondaries = new Float32Array(0);
     }
 }
-export function getAvailableAxes(welllog, axisMnemos) {
+export function getAvailableAxes(wellLog, axisMnemos) {
     const result = [];
-    if (welllog) {
-        const curves = welllog.curves;
-        for (const key in axisMnemos) {
-            const i = indexOfElementByNames(curves, axisMnemos[key]);
-            if (i >= 0)
-                result.push(key);
-        }
+    const curves = getAllWellLogCurves(wellLog);
+    for (const key in axisMnemos) {
+        const i = indexOfElementByNames(curves, axisMnemos[key]);
+        if (i >= 0)
+            result.push(key);
     }
     return result;
 }
@@ -230,6 +221,19 @@ function getTemplatePlotProps(templatePlot, templateStyles) {
     }
     return options;
 }
+function isStackedTrack(templateTrack, templateStyles) {
+    var _a, _b;
+    // Stacked tracks only render the first plot, so we only care about the first
+    const firstTrackPlot = (_a = templateTrack.plots[0]) !== null && _a !== void 0 ? _a : {};
+    if (firstTrackPlot.type === "stacked")
+        return true;
+    if (!firstTrackPlot.style || !templateStyles)
+        return false;
+    const iStyle = indexOfElementByName(templateStyles, firstTrackPlot.style);
+    if (iStyle < 0)
+        return false;
+    return ((_b = templateStyles[iStyle]) === null || _b === void 0 ? void 0 : _b.type) === "stacked";
+}
 class __dataAccessor {
     constructor(iData) {
         this.iData = iData;
@@ -414,9 +418,7 @@ function updateStackedTrackScale(track) {
     //}
     //if (!track.options.scale) throw Error("Invalid track.options.scale!");
     //track.trackScale = createScale(track.options.scale, track.options.domain);
-    // TODO: Fix this the next time the file is edited.
-    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-    track.xscale;
+    // track.xscale;
 }
 function addGraphTrackPlot(wellLogView, track, templatePlot) {
     const templateTrack = getTrackTemplate(track);
@@ -426,53 +428,24 @@ function addGraphTrackPlot(wellLogView, track, templatePlot) {
     ];
     const axes = wellLogView.getAxesInfo();
     const plotFactory = track.options.plotFactory;
-    const welllog = wellLogView.props.welllog;
-    if (plotFactory && welllog) {
-        const data = welllog.data;
-        const curves = welllog.curves;
-        const iPrimaryAxis = !axes.mnemos
-            ? -1
-            : indexOfElementByNames(curves, axes.mnemos[axes.primaryAxis]);
-        const iCurve = indexOfElementByName(curves, templatePlot.name);
-        if (iCurve < 0)
-            console.log("iCurve < 0");
-        const curve = curves[iCurve];
-        const dimensions = curve.dimensions === undefined ? 1 : curve.dimensions;
-        if (dimensions !== 1)
-            console.log("curve.dimensions !== 1");
-        if (curve.valueType === "string")
-            console.log('curve.valueType === "string"');
-        const plotData = preparePlotData(data, iCurve, iPrimaryAxis);
-        checkMinMax(minmaxPrimaryAxis, plotData.minmaxPrimaryAxis);
-        const minmax = [
-            plotData.minmax[0],
-            plotData.minmax[1],
-        ];
-        const plotDatas = track.options.data;
-        const plots = track.plots;
-        const colorMapFunctions = wellLogView.props.colorMapFunctions;
-        let iCurve2 = -1;
-        let curve2 = undefined;
-        let plotData2 = undefined;
-        if (templatePlot.type === "differential") {
-            iCurve2 = templatePlot.name2
-                ? indexOfElementByName(curves, templatePlot.name2)
-                : -1;
-            curve2 = iCurve2 >= 0 ? curves[iCurve2] : undefined;
-            plotData2 = preparePlotData(data, iCurve2, iPrimaryAxis);
-            if (!curve2)
-                console.error("templatePlot.name2 '" + templatePlot.name2 + "' not found");
-            checkMinMax(minmaxPrimaryAxis, plotData2.minmaxPrimaryAxis);
-            checkMinMax(minmax, plotData2.minmax);
-        }
+    const wellLog = wellLogView.wellLogSets;
+    const colorMapFunctions = wellLogView.props.colorMapFunctions;
+    const plotDatas = track.options.data;
+    const plots = track.plots;
+    if (plotFactory && wellLog.length) {
+        const plotSetup = setupPlot(wellLog, templatePlot.name, axes);
+        if (!plotSetup)
+            return minmaxPrimaryAxis;
+        const { plotData, curve, iCurve, minmax, iSet } = plotSetup;
+        const plotSetup2 = maybeSetupPlot2(wellLog, templatePlot, axes);
+        checkSetupMinMax(plotSetup, plotSetup2, minmaxPrimaryAxis);
         // Make full props
         const templatePlotProps = getTemplatePlotProps(templatePlot, 
         /*templateStyles*/ []);
-        const p = getPlotConfig(iCurve, templatePlotProps, templateTrack.scale, minmax, curve, plotDatas.length, curve2, plotDatas.length + 1, colorMapFunctions);
+        const p = getPlotConfig(`${iSet}-${iCurve}`, templatePlotProps, templateTrack.scale, minmax, curve, plotDatas.length, plotSetup2 === null || plotSetup2 === void 0 ? void 0 : plotSetup2.curve, plotDatas.length + 1, colorMapFunctions);
         plotDatas.push(plotData.data);
-        if (plotData2) {
-            plotDatas.push(plotData2.data);
-        }
+        if (plotSetup2)
+            plotDatas.push(plotSetup2.plotData.data);
         // GraphTrack
         const createPlot = plotFactory[p.type];
         if (!createPlot)
@@ -495,53 +468,24 @@ function editGraphTrackPlot(wellLogView, track, plot, templatePlot) {
     ];
     const axes = wellLogView.getAxesInfo();
     const plotFactory = track.options.plotFactory;
-    const welllog = wellLogView.props.welllog;
-    if (plotFactory && welllog) {
-        const data = welllog.data;
-        const curves = welllog.curves;
-        const iPrimaryAxis = !axes.mnemos
-            ? -1
-            : indexOfElementByNames(curves, axes.mnemos[axes.primaryAxis]);
-        const iCurve = indexOfElementByName(curves, templatePlot.name);
-        if (iCurve < 0)
-            console.log("iCurve < 0");
-        const curve = curves[iCurve];
-        const dimensions = curve.dimensions === undefined ? 1 : curve.dimensions;
-        if (dimensions !== 1)
-            console.log("curve.dimensions !== 1");
-        if (curve.valueType === "string")
-            console.log('curve.valueType === "string"');
-        const plotData = preparePlotData(data, iCurve, iPrimaryAxis);
-        checkMinMax(minmaxPrimaryAxis, plotData.minmaxPrimaryAxis);
-        const minmax = [
-            plotData.minmax[0],
-            plotData.minmax[1],
-        ];
-        const plotDatas = track.options.data;
-        const plots = track.plots;
+    const wellLog = wellLogView.wellLogSets;
+    const plotDatas = track.options.data;
+    const plots = track.plots;
+    if (plotFactory && wellLog.length) {
+        const plotSetup = setupPlot(wellLog, templatePlot.name, axes);
+        if (!plotSetup)
+            return minmaxPrimaryAxis;
+        const { plotData, curve, iCurve, iSet, minmax } = plotSetup;
+        const plotSetup2 = maybeSetupPlot2(wellLog, templatePlot, axes);
+        checkSetupMinMax(plotSetup, plotSetup2, minmaxPrimaryAxis);
         const colorMapFunctions = wellLogView.props.colorMapFunctions;
-        let iCurve2 = -1;
-        let curve2 = undefined;
-        let plotData2 = undefined;
-        if (templatePlot.type === "differential") {
-            iCurve2 = templatePlot.name2
-                ? indexOfElementByName(curves, templatePlot.name2)
-                : -1;
-            curve2 = iCurve2 >= 0 ? curves[iCurve2] : undefined;
-            if (!curve2)
-                console.error("templatePlot.name2 '" + templatePlot.name2 + "' not found");
-            plotData2 = preparePlotData(data, iCurve2, iPrimaryAxis);
-            checkMinMax(minmaxPrimaryAxis, plotData2.minmaxPrimaryAxis);
-            checkMinMax(minmax, plotData2.minmax);
-        }
         // Make full props
         const templatePlotProps = getTemplatePlotProps(templatePlot, 
         /*templateStyles*/ []);
-        const p = getPlotConfig(iCurve, templatePlotProps, templateTrack.scale, minmax, curve, plotDatas.length, curve2, plotDatas.length + 1, colorMapFunctions);
+        const p = getPlotConfig(`${iSet}-${iCurve}`, templatePlotProps, templateTrack.scale, minmax, curve, plotDatas.length, plotSetup2 === null || plotSetup2 === void 0 ? void 0 : plotSetup2.curve, plotDatas.length + 1, colorMapFunctions);
         plotDatas.push(plotData.data);
-        if (plotData2) {
-            plotDatas.push(plotData2.data);
-        }
+        if (plotSetup2)
+            plotDatas.push(plotSetup2.plotData.data);
         // GraphTrack
         const createPlot = plotFactory[p.type];
         if (!createPlot)
@@ -765,32 +709,25 @@ function createStackData(data, colorMapFunction, meta) {
 function newStackedTrack(options) {
     return new StackedTrack(undefined, options);
 }
-export function getDiscreteMeta(welllog, name) {
-    const meta = welllog.metadata_discrete;
-    if (meta) {
-        // File has metadata for discrete log
-        //const table=meta[name.toUpperCase()]; // search case insensitive!
-        const table = elementByKeyName(meta, name);
-        if (table) {
-            // there is a metadata for given log name
-            const attributes = table.attributes; // ["color", "code"]
-            if (attributes) {
-                const iCode = attributes.indexOf("code");
-                const iColor = attributes.indexOf("color");
-                if (iColor >= 0 && iCode >= 0)
-                    // all values are OK
-                    return {
-                        iCode: iCode,
-                        iColor: iColor,
-                        objects: table.objects, // [attr1,attr2]                ,
-                    };
-            }
+export function getDiscreteMeta(wellLogSet, name) {
+    const metadataTable = getDiscreteMetaDataByName(wellLogSet, name);
+    if (metadataTable) {
+        // there is a metadata for given log name
+        const attributes = metadataTable.attributes; // ["color", "code"]
+        if (attributes) {
+            const iCode = attributes.indexOf("code");
+            const iColor = attributes.indexOf("color");
+            if (iColor >= 0 && iCode >= 0)
+                // all values are OK
+                return {
+                    iCode: iCode,
+                    iColor: iColor,
+                    objects: metadataTable.objects, // [attr1,attr2]                ,
+                };
         }
     }
     return null; // something went wrong
 }
-import { createPlotType } from "@equinor/videx-wellog";
-import { defaultPlotFactory } from "@equinor/videx-wellog";
 const plotFactory = Object.assign(Object.assign({}, defaultPlotFactory), { gradientfill: createPlotType(GradientFillPlot) });
 const defaultOptions = {
     plotFactory: plotFactory,
@@ -835,92 +772,123 @@ export function getScaleTrackNum(tracks) {
     }
     return n;
 }
-function addScaleTracks(info, axes, curves, data, iPrimaryAxis) {
-    const titlePrimaryAxis = axes.titles
-        ? axes.titles[axes.primaryAxis]
-        : axes.primaryAxis;
-    const curvePrimaryAxis = curves[iPrimaryAxis];
-    const iSecondaryAxis = !axes.mnemos
-        ? -1
-        : indexOfElementByNames(curves, axes.mnemos[axes.secondaryAxis]);
-    if (iSecondaryAxis >= 0) {
-        info.tracks.push(newDualScaleTrack(0, titlePrimaryAxis, curvePrimaryAxis.name, curvePrimaryAxis.unit));
-        const titleSecondaryAxis = axes.titles
-            ? axes.titles[axes.secondaryAxis]
-            : axes.secondaryAxis;
-        const curveSecondaryAxis = curves[iSecondaryAxis];
-        info.tracks.push(newDualScaleTrack(1, titleSecondaryAxis, curveSecondaryAxis.name, curveSecondaryAxis.unit));
-        info.primaries = new Float32Array(data.length); // 32 bits should be enough
-        info.secondaries = new Float32Array(data.length);
-        {
-            let count = 0;
-            for (const row of data) {
-                const secondary = row[iSecondaryAxis];
-                checkMinMaxValue(info.minmaxSecondaryAxis, secondary);
-                if (secondary !== null) {
-                    const primary = row[iPrimaryAxis];
-                    if (primary !== null) {
-                        info.secondaries[count] = secondary;
-                        info.primaries[count] = primary;
-                        count++;
-                    }
+function getAxisTitle(axes, axisName) {
+    return axes.titles ? axes.titles[axisName] : axisName;
+}
+function addScaleTracks(info, axesInfo, wellLog) {
+    // All sets is  assumed to include the main axis curve, so we just look at the first curve well log set here
+    const data = wellLog[0].data;
+    const curves = wellLog[0].curves;
+    const axisIndices = getAxisIndices(curves, axesInfo);
+    if (axisIndices.primary < 0)
+        return; // Axis curves are missing
+    const idxPrimary = axisIndices.primary;
+    const titlePrimary = getAxisTitle(axesInfo, axesInfo.primaryAxis);
+    const curvePrimary = curves[idxPrimary];
+    if (axisIndices.secondary >= 0) {
+        addDualScaleTrack(info, axesInfo, curves, data, axisIndices);
+    }
+    else {
+        info.tracks.push(newScaleTrack(titlePrimary, curvePrimary.name, curvePrimary.unit));
+    }
+}
+function addDualScaleTrack(info, axes, curves, data, axisIndices) {
+    const idxPrimary = axisIndices.primary;
+    const idxSecondary = axisIndices.secondary;
+    const titlePrimary = getAxisTitle(axes, axes.primaryAxis);
+    const titleSecondary = getAxisTitle(axes, axes.secondaryAxis);
+    const curvePrimary = curves[idxPrimary];
+    const curveSecondary = curves[idxSecondary];
+    info.tracks.push(newDualScaleTrack(0, titlePrimary, curvePrimary.name, curvePrimary.unit), newDualScaleTrack(1, titleSecondary, curveSecondary.name, curveSecondary.unit));
+    info.primaries = new Float32Array(data.length); // 32 bits should be enough
+    info.secondaries = new Float32Array(data.length);
+    {
+        let count = 0;
+        for (const row of data) {
+            const secondary = row[idxSecondary];
+            checkMinMaxValue(info.minmaxSecondaryAxis, secondary);
+            if (secondary !== null) {
+                const primary = row[idxPrimary];
+                if (primary !== null) {
+                    info.secondaries[count] = secondary;
+                    info.primaries[count] = primary;
+                    count++;
                 }
             }
-            if (count < info.primaries.length) {
-                // resize arrays to actual size used
-                info.primaries = info.primaries.subarray(0, count);
-                info.secondaries = info.secondaries.subarray(0, count);
-            }
+        }
+        if (count < info.primaries.length) {
+            // resize arrays to actual size used
+            info.primaries = info.primaries.subarray(0, count);
+            info.secondaries = info.secondaries.subarray(0, count);
         }
     }
-    else {
-        info.tracks.push(newScaleTrack(titlePrimaryAxis, curvePrimaryAxis.name, curvePrimaryAxis.unit));
+}
+function setupPlot(wellLog, plotName, axesInfo) {
+    var _a;
+    const { iCurve, iSet } = findSetAndCurveIndex(wellLog, plotName);
+    if (iCurve < 0)
+        return null;
+    const sourceLogSet = wellLog[iSet];
+    const data = sourceLogSet.data;
+    const curves = sourceLogSet.curves;
+    const curve = curves[iCurve];
+    const dimensions = (_a = curve.dimensions) !== null && _a !== void 0 ? _a : 1;
+    if (dimensions !== 1)
+        return null;
+    if (curve.valueType === "string")
+        return null;
+    const axisIndices = getAxisIndices(sourceLogSet.curves, axesInfo);
+    const plotData = preparePlotData(data, iCurve, axisIndices.primary);
+    const minmax = [plotData.minmax[0], plotData.minmax[1]];
+    return {
+        iCurve,
+        iSet,
+        sourceLogSet,
+        curve,
+        plotData,
+        minmax,
+    };
+}
+function maybeSetupPlot2(wellLog, templatePlot, axesInfo) {
+    if (templatePlot.type !== "differential")
+        return null;
+    else
+        return setupPlot(wellLog, templatePlot.name2, axesInfo);
+}
+function checkSetupMinMax(setup1, setup2, primaryAxisMinMax) {
+    checkMinMax(primaryAxisMinMax, setup1.plotData.minmaxPrimaryAxis);
+    if (setup2) {
+        checkMinMax(setup1.minmax, setup2.minmax);
+        checkMinMax(primaryAxisMinMax, setup2.plotData.minmaxPrimaryAxis);
     }
 }
-function addGraphTrack(info, welllog, curves, data, iPrimaryAxis, templateTrack, templateStyles, colorMapFunctions) {
+function addGraphTrack(info, wellLog, axesInfo, templateTrack, templateStyles, colorMapFunctions) {
     const plotDatas = [];
     const plots = [];
+    // Saving the curves so it can be used for title generation
+    const curvesUsed = [];
     if (templateTrack.plots)
         for (const templatePlot of templateTrack.plots) {
-            // see also addGraphTrackPlot(wellLogView, track, templatePlot);
-            const iCurve = indexOfElementByName(curves, templatePlot.name);
-            if (iCurve < 0)
-                continue; // curve not found
-            const curve = curves[iCurve];
-            const dimensions = curve.dimensions === undefined ? 1 : curve.dimensions;
-            if (dimensions !== 1)
-                continue;
-            if (curve.valueType === "string")
-                continue;
-            const plotData = preparePlotData(data, iCurve, iPrimaryAxis);
-            checkMinMax(info.minmaxPrimaryAxis, plotData.minmaxPrimaryAxis);
-            const minmax = [
-                plotData.minmax[0],
-                plotData.minmax[1],
-            ];
-            let iCurve2 = -1;
-            let curve2 = undefined;
-            let plotData2 = undefined;
-            if (templatePlot.type === "differential") {
-                iCurve2 = templatePlot.name2
-                    ? indexOfElementByName(curves, templatePlot.name2)
-                    : -1;
-                curve2 = iCurve2 >= 0 ? curves[iCurve2] : undefined;
-                plotData2 = preparePlotData(data, iCurve2, iPrimaryAxis);
-                checkMinMax(info.minmaxPrimaryAxis, plotData2.minmaxPrimaryAxis);
-                checkMinMax(minmax, plotData2.minmax);
-            }
+            const plotSetup = setupPlot(wellLog, templatePlot.name, axesInfo);
+            if (!plotSetup)
+                continue; // Plot couldnt be set up, skip adding this track
+            const { plotData, curve, minmax, iCurve, iSet } = plotSetup;
+            const plotSetup2 = maybeSetupPlot2(wellLog, templatePlot, axesInfo);
+            // Apply min-max index values to entire track
+            checkSetupMinMax(plotSetup, plotSetup2, info.minmaxPrimaryAxis);
             // make full props
             const templatePlotProps = getTemplatePlotProps(templatePlot, templateStyles);
-            const p = getPlotConfig(iCurve, templatePlotProps, templateTrack.scale, minmax, curve, plotDatas.length, curve2, plotDatas.length + 1, colorMapFunctions);
+            const p = getPlotConfig(`${iSet}-${iCurve}`, templatePlotProps, templateTrack.scale, minmax, curve, plotDatas.length, plotSetup2 === null || plotSetup2 === void 0 ? void 0 : plotSetup2.curve, plotDatas.length + 1, colorMapFunctions);
+            plots.push(p);
+            curvesUsed.push(curve);
             plotDatas.push(plotData.data);
-            if (plotData2) {
-                plotDatas.push(plotData2.data);
+            if (plotSetup2) {
+                curvesUsed.push(plotSetup2.curve);
+                plotDatas.push(plotSetup2.plotData.data);
             }
-            plots.push(p);
         }
     if (plots.length || templateTrack.required) {
-        const label = makeTrackHeader(welllog, templateTrack);
+        const label = makeTrackHeader(curvesUsed, templateTrack);
         const options = {
             data: plotDatas,
             plots: plots,
@@ -932,26 +900,22 @@ function addGraphTrack(info, welllog, curves, data, iPrimaryAxis, templateTrack,
         info.tracks.push(track);
     }
 }
-function addStackedTrack(info, welllog, curves, data, iPrimaryAxis, templateTrack, templateStyles, colorMapFunctions, showLines, showLabels, labelRotation) {
+function addStackedTrack(info, wellLog, axesInfo, templateTrack, templateStyles, colorMapFunctions) {
+    var _a;
     const templatePlot = templateTrack.plots[0];
     const name = templatePlot.name;
-    const iCurve = indexOfElementByName(curves, name);
-    if (iCurve < 0)
-        return; // curve not found
-    const curve = curves[iCurve];
-    const dimensions = curve.dimensions === undefined ? 1 : curve.dimensions;
-    if (dimensions !== 1)
+    const plotSetup = setupPlot(wellLog, name, axesInfo);
+    if (!plotSetup)
         return;
-    const plotData = preparePlotData(data, iCurve, iPrimaryAxis);
-    checkMinMax(info.minmaxPrimaryAxis, plotData.minmaxPrimaryAxis);
+    const { plotData, curve, sourceLogSet } = plotSetup;
     // make full props
     const templatePlotProps = getTemplatePlotProps(templatePlot, templateStyles);
     const templateTrackFullPlot = deepCopy(templateTrack);
-    const label = makeTrackHeader(welllog, templateTrack);
+    const label = makeTrackHeader([curve], templateTrack);
+    const meta = getDiscreteMeta(sourceLogSet, name);
     templateTrackFullPlot.title = label;
     templateTrackFullPlot.plots[0].type = templatePlotProps.type;
     // curve.valueType could be "integer", "string"
-    const meta = getDiscreteMeta(welllog, name);
     if (!meta && curve.valueType === "integer")
         console.log("Discrete meta information for '" +
             name +
@@ -979,9 +943,9 @@ function addStackedTrack(info, welllog, curves, data, iPrimaryAxis, templateTrac
     }
     const plot = templateTrackFullPlot.plots[0];
     if (plot) {
-        plot.showLabels = showLabels;
-        plot.showLines = showLines;
-        plot.labelRotation = labelRotation !== null && labelRotation !== void 0 ? labelRotation : 0;
+        plot.showLabels = templatePlotProps.showLabels;
+        plot.showLines = templatePlotProps.showLines;
+        plot.labelRotation = (_a = templatePlotProps.labelRotation) !== null && _a !== void 0 ? _a : 0;
     }
     const options = {
         abbr: name, // name of the only plot
@@ -991,41 +955,23 @@ function addStackedTrack(info, welllog, curves, data, iPrimaryAxis, templateTrac
     setStackedTrackOptionsFromTemplate(options, templateTrackFullPlot);
     const track = newStackedTrack(options);
     updateStackedTrackScale(track);
+    checkMinMax(info.minmaxPrimaryAxis, plotData.minmaxPrimaryAxis);
     info.tracks.push(track);
 }
-function getTemplateTrackFirstPlotProps(templateTrack, templateStyles) {
-    if (!templateTrack.plots)
-        return undefined;
-    const templatePlot = templateTrack.plots[0];
-    if (!templatePlot)
-        return undefined;
-    const templatePlotProps = getTemplatePlotProps(templatePlot, templateStyles);
-    return templatePlotProps;
-}
-export function createTracks(welllog, axes, templateTracks, // Part of JSON
+export function createTracks(wellLog, axes, templateTracks, // Part of JSON
 templateStyles, // Part of JSON
 colorMapFunctions // JS code or JSON color table
 ) {
+    if (!(wellLog === null || wellLog === void 0 ? void 0 : wellLog.length))
+        return new TracksInfo();
     const info = new TracksInfo();
-    if (welllog) {
-        const data = welllog.data;
-        const curves = welllog.curves;
-        const iPrimaryAxis = !axes.mnemos
-            ? -1
-            : indexOfElementByNames(curves, axes.mnemos[axes.primaryAxis]);
-        if (iPrimaryAxis >= 0)
-            // scale tracks are needed
-            addScaleTracks(info, axes, curves, data, iPrimaryAxis);
-        if (templateTracks) {
-            for (const templateTrack of templateTracks) {
-                const templatePlotProps = getTemplateTrackFirstPlotProps(templateTrack, templateStyles);
-                if (templatePlotProps && templatePlotProps.type === "stacked") {
-                    addStackedTrack(info, welllog, curves, data, iPrimaryAxis, templateTrack, templateStyles, colorMapFunctions, templatePlotProps.showLines, templatePlotProps.showLabels, templatePlotProps.labelRotation);
-                }
-                else {
-                    addGraphTrack(info, welllog, curves, data, iPrimaryAxis, templateTrack, templateStyles, colorMapFunctions);
-                }
-            }
+    addScaleTracks(info, axes, wellLog);
+    for (const templateTrack of templateTracks) {
+        if (isStackedTrack(templateTrack, templateStyles)) {
+            addStackedTrack(info, wellLog, axes, templateTrack, templateStyles, colorMapFunctions);
+        }
+        else {
+            addGraphTrack(info, wellLog, axes, templateTrack, templateStyles, colorMapFunctions);
         }
     }
     return info;
@@ -1099,19 +1045,22 @@ export function addOrEditGraphTrack(wellLogView, track, templateTrack, trackCurr
 export function addOrEditStackedTrack(wellLogView, track, templateTrack, trackCurrent, bAfter) {
     var _a;
     const props = wellLogView.props;
-    const welllog = props.welllog;
+    const wellLog = wellLogView.wellLogSets;
     const templatePlot = templateTrack.plots[0];
-    if (!welllog || !templatePlot)
+    if (!wellLog || !templatePlot)
         return null;
     const name = templatePlot.name;
     const templateStyles = props.template.styles;
     // make full props
     const templatePlotProps = getTemplatePlotProps(templatePlot, templateStyles);
     const colorMapFunctionName = (_a = props.colorMapFunctions) === null || _a === void 0 ? void 0 : _a.find((colorMapFunction) => colorMapFunction.name === templatePlotProps.colorMapFunctionName);
-    const meta = getDiscreteMeta(welllog, name);
-    const data = welllog.data;
-    const curves = welllog.curves;
-    const iCurve = indexOfElementByName(curves, name);
+    const { iCurve, iSet } = findSetAndCurveIndex(wellLog, name);
+    if (iCurve < 0)
+        return null; // curve not found
+    const sourceLogSet = wellLog[iSet];
+    const meta = getDiscreteMeta(sourceLogSet, name);
+    const data = sourceLogSet.data;
+    const curves = sourceLogSet.curves;
     const axes = wellLogView.getAxesInfo();
     const iPrimaryAxis = indexOfElementByNames(curves, axes.mnemos[axes.primaryAxis]);
     const plotData = preparePlotData(data, iCurve, iPrimaryAxis);
@@ -1120,7 +1069,7 @@ export function addOrEditStackedTrack(wellLogView, track, templateTrack, trackCu
         // edit existing track
         {
             // force to clear stacked areas
-            track.data = null; // workarond for videx welllog component to force redraw areas with new options (showLines, ...)
+            track.data = null; // workarond for videx well log component to force redraw areas with new options (showLines, ...)
             if (wellLogView.logController)
                 wellLogView.logController.updateTracks();
         }