@webviz/well-log-viewer 0.0.1-alpha.1 → 0.0.1-alpha.3

package/src/utils/gradientfill-plot.ts

@@ -1,203 +0,0 @@
-import { area } from "d3";
-import { Scale } from "@equinor/videx-wellog/dist/common/interfaces";
-import { Plot } from "@equinor/videx-wellog";
-
-import { DefinedFunction } from "@equinor/videx-wellog/dist/plots/interfaces";
-
-import renderGradientFillPlotLegend from "./gradientfill-plot-legend";
-import { getInterpolatedColorString } from "./color-table";
-
-import { ColorTable } from "../components/ColorTableTypes";
-
-import { AreaPlotOptions } from "@equinor/videx-wellog/dist/plots/interfaces";
-
-export interface GradientFillPlotOptions extends AreaPlotOptions {
-    colorTable?: ColorTable;
-    inverseColorTable?: ColorTable;
-    colorScale?: "linear" | "log";
-    inverseColorScale?: "linear" | "log";
-}
-
-/*
- * Create gradient based on colorTable
- */
-function createGradient(
-    ctx: CanvasRenderingContext2D,
-    yscale: Scale,
-    horizontal: boolean | undefined,
-    plotdata: number[][],
-    xscale: Scale,
-    colorTable: ColorTable,
-    scale: undefined | string // "linear" | "log"
-): CanvasGradient {
-    const dataFrom = plotdata[0];
-    const dataTo = plotdata[plotdata.length - 1];
-    const sFrom = yscale(dataFrom[0]);
-    const sTo = yscale(dataTo[0]);
-
-    const gradient: CanvasGradient = horizontal
-        ? ctx.createLinearGradient(sFrom, 0, sTo, 0)
-        : ctx.createLinearGradient(0, sFrom, 0, sTo);
-
-    if (scale === "log") {
-        const [min, max] = xscale.domain();
-        const xFrom = dataFrom[0];
-        const xDelta = dataTo[0] - xFrom;
-        const yFrom = Math.log(min);
-        const yDelta = Math.log(max) - yFrom;
-        for (const data of plotdata) {
-            const stop = (data[0] - xFrom) / xDelta;
-            if (0 <= stop && stop <= 1.0) {
-                const v = (Math.log(data[1]) - yFrom) / yDelta;
-                const c = getInterpolatedColorString(colorTable, v);
-                gradient.addColorStop(stop, c);
-            }
-        }
-    } else {
-        // "linear"
-        const xFrom = dataFrom[0];
-        const xDelta = dataTo[0] - xFrom;
-        const yFrom = xscale.domain()[0];
-        const yDelta = xscale.domain()[1] - yFrom;
-        for (const data of plotdata) {
-            // TODO: add some additional intermediate stop positions when y changes significantly
-            // and color-table stops exists between consequent y values
-            const stop = (data[0] - xFrom) / xDelta;
-            if (0 <= stop && stop <= 1.0) {
-                const v = (data[1] - yFrom) / yDelta;
-                const c = getInterpolatedColorString(colorTable, v);
-                gradient.addColorStop(stop, c);
-            }
-        }
-    }
-
-    return gradient;
-}
-
-/**
- * GradientFill plot
- */
-export default class GradientFillPlot extends Plot {
-    constructor(id: string | number, options: GradientFillPlotOptions = {}) {
-        super(id, options);
-        // subclass render function.
-        // eslint-disable-next-line
-        (this.options as any).renderLegend = renderGradientFillPlotLegend; // see updateLegendRows() in videx-wellog\src\tracks\graph\graph-legend.ts 
-    }
-
-    /**
-     * Renders area plot to canvas context
-     * @param ctx canvas context instance
-     * @param scale y-scale
-     */
-    plot(ctx: CanvasRenderingContext2D, scale: Scale): void {
-        const { scale: xscale, data: plotdata } = this;
-        if (!xscale) return;
-
-        const options = this.options as GradientFillPlotOptions;
-        if (options.hidden) return;
-
-        const useMinAsBase =
-            options.useMinAsBase === undefined ? true : options.useMinAsBase;
-
-        const [d0, d1] = xscale.domain();
-        const dmin = Math.min(d0, d1);
-        const dmax = Math.max(d0, d1);
-
-        const rmin = xscale(dmin);
-        const rmax = xscale(dmax);
-
-        const zeroValue = useMinAsBase ? rmin : rmax;
-
-        ctx.save();
-
-        const areaFunction = area()
-            // this.options.defined is always initialized by some function
-            .defined((d) => (options.defined as DefinedFunction)(d[1], d[0]))
-            .context(ctx);
-
-        if (options.horizontal) {
-            areaFunction
-                .y1((d) => xscale(d[1]))
-                .y0(zeroValue)
-                .x((d) => scale(d[0]));
-        } else {
-            areaFunction
-                .x1((d) => xscale(d[1]))
-                .x0(zeroValue)
-                .y((d) => scale(d[0]));
-        }
-
-        ctx.globalAlpha = options.fillOpacity || 1;
-
-        if (options.inverseColor || options.inverseColorTable) {
-            const inverseValue = useMinAsBase ? rmax : rmin;
-
-            const inverseAreaFunction = area()
-                // this.options.defined is always initialized by some function
-                .defined((d) =>
-                    (options.defined as DefinedFunction)(d[1], d[0])
-                )
-                .context(ctx);
-
-            if (options.horizontal) {
-                inverseAreaFunction
-                    .y1((d) => xscale(d[1]))
-                    .y0(inverseValue)
-                    .x((d) => scale(d[0]));
-            } else {
-                inverseAreaFunction
-                    .x1((d) => xscale(d[1]))
-                    .x0(inverseValue)
-                    .y((d) => scale(d[0]));
-            }
-            ctx.beginPath();
-            inverseAreaFunction(plotdata);
-            ctx.fillStyle = options.inverseColor || "";
-            /* Start GradientFill code */
-            const colorTable = options.inverseColorTable;
-            if (colorTable)
-                ctx.fillStyle = createGradient(
-                    ctx,
-                    scale,
-                    options.horizontal,
-                    plotdata,
-                    xscale,
-                    colorTable,
-                    options.inverseColorScale ||
-                        options.colorScale ||
-                        options.scale
-                );
-            /* End GradientFill code */
-
-            ctx.fill();
-        }
-
-        ctx.beginPath();
-        areaFunction(plotdata);
-        ctx.lineWidth = options.width || 0.0;
-
-        ctx.fillStyle = options.fill || options.color || "";
-        /* Start GradientFill code */
-        const colorTable = options.colorTable;
-        if (colorTable)
-            ctx.fillStyle = createGradient(
-                ctx,
-                scale,
-                options.horizontal,
-                plotdata,
-                xscale,
-                colorTable,
-                options.colorScale || options.scale
-            );
-        /* End GradientFill code */
-
-        ctx.fill();
-
-        ctx.globalAlpha = 1;
-        ctx.strokeStyle = options.color || "";
-        ctx.stroke();
-
-        ctx.restore();
-    }
-}

package/src/utils/graph/factory.ts

@@ -1,15 +0,0 @@
-import { scaleLinear, scaleLog } from "d3";
-import { Scale, Domain } from "@equinor/videx-wellog/dist/common/interfaces";
-
-/**
- * Creates a d3 scale from config
- */
-export function createScale(type: string, domain: Domain): Scale {
-    if (type === "linear") {
-        return scaleLinear().domain(domain) as Scale;
-    }
-    if (type === "log") {
-        return scaleLog().domain(domain) as Scale;
-    }
-    throw Error("Invalid input!");
-}

package/src/utils/legend/common.ts

@@ -1,153 +0,0 @@
-/* This file contains functions wich are missed on exports from "@equinor/videx-wellog" see \src\plots\legend\common.ts */
-
-import { setProps, setAttrs } from "@equinor/videx-wellog";
-import { LegendBounds } from "@equinor/videx-wellog/dist/utils/legend-helper";
-// eslint-disable-next-line
-declare type D3Selection = any; // not exported from videx-wellog! import { D3Selection } from "@equinor/videx-wellog/dist/common/interfaces';
-
-/**
- * Renders label, min/max values for domain and unit
- */
-export function renderTextLabels(
-    g: D3Selection,
-    bounds: LegendBounds,
-    label: string,
-    unit: string,
-    domain: number[],
-    color: string,
-    addLabelBg = false
-): void {
-    const { height: h, width: w, top, left } = bounds;
-    const lineY = top + h * 0.5;
-    const textSize = h * 0.35;
-    const subTextSize = textSize * 0.85;
-    const subY = lineY + subTextSize;
-    const centerX = left + w / 2;
-    const [min, max] = domain;
-
-    // label
-    const labelX = centerX;
-    const labelY = top + textSize;
-    const labelTransform = `translate(${labelX},${labelY})`;
-
-    let labelBg;
-    if (addLabelBg) {
-        labelBg = g
-            .append("rect")
-            .classed("label-bg", true)
-            .attr("fill", "white");
-    }
-
-    const labelText = g.append("text").text(label);
-    setProps(labelText, {
-        styles: {
-            "text-anchor": "middle",
-            fill: color,
-        },
-        attrs: {
-            class: "legend-label",
-            "font-size": `${textSize}px`,
-            transform: labelTransform,
-        },
-    });
-
-    if (addLabelBg) {
-        const bbox = labelText.node().getBBox();
-        setAttrs(labelBg, {
-            x: centerX + bbox.x - 1,
-            y: top + 1,
-            width: bbox.width + 2,
-            height: h * 0.5 - 2,
-        });
-    }
-
-    // unit
-    if (unit) {
-        const unitX = centerX;
-        const unitTransform = `translate(${unitX},${subY})`;
-        const unitText = g.append("text").text(unit);
-        setProps(unitText, {
-            styles: {
-                "text-anchor": "middle",
-                fill: color,
-            },
-            attrs: {
-                class: "legend-unit",
-                "font-size": `${subTextSize}px`,
-                transform: unitTransform,
-            },
-        });
-    }
-
-    const minText =
-        Math.abs(min) > 1000 && min % 1000 === 0
-            ? `${Math.round(min / 1000)}k`
-            : `${min}`;
-    const maxText =
-        Math.abs(max) > 1000 && max % 1000 === 0
-            ? `${Math.round(max / 1000)}k`
-            : `${max}`;
-    // domain
-    const minDomain = g.append("text").text(minText);
-    setProps(minDomain, {
-        styles: {
-            "text-anchor": "start",
-            fill: color,
-        },
-        attrs: {
-            class: "legend-domain",
-            "font-size": `${subTextSize}px`,
-            x: left + 2,
-            y: subY,
-        },
-    });
-    const maxDomain = g.append("text").text(maxText);
-    setProps(maxDomain, {
-        styles: {
-            "text-anchor": "end",
-            fill: color,
-        },
-        attrs: {
-            class: "legend-domain",
-            "font-size": `${subTextSize}px`,
-            x: left + w - 2,
-            y: subY,
-        },
-    });
-}
-
-/**
- * Renders a basic/standard set of layout that are common for most plot-type legends
- */
-export function renderBasicPlotLegend(
-    g: D3Selection,
-    bounds: LegendBounds,
-    label: string,
-    unit: string,
-    domain: number[],
-    color: string,
-    addLabelBg = false
-): void {
-    const x1 = bounds.left + 2;
-    const x2 = Math.max(x1, bounds.left + bounds.width - 2);
-
-    const lineY = bounds.top + bounds.height * 0.5;
-    const lineWidth = bounds.height * 0.1;
-
-    const line = g.append("line");
-    setProps(line, {
-        attrs: {
-            x1,
-            x2,
-            y1: lineY,
-            y2: lineY,
-        },
-        styles: {
-            "stroke-width": lineWidth,
-            stroke: color,
-            fill: color,
-        },
-    });
-
-    renderTextLabels(g, bounds, label, unit, domain, color, addLabelBg);
-}

package/src/utils/log-viewer.ts

@@ -1,209 +0,0 @@
-import { LogViewer, Track } from "@equinor/videx-wellog";
-
-import { isScaleTrack } from "../utils/tracks";
-
-export function removeOverlay(logViewer: LogViewer): void {
-    logViewer.container.select(".overlay").remove();
-    //logViewer.overlay = null;
-}
-
-export function isTrackVisible(track: Track): boolean {
-    if (track.elm) {
-        const elm = track.elm.parentElement;
-        if (elm) {
-            return elm.style.display !== "none";
-        }
-    }
-    return false;
-}
-
-export function showTrack(track: Track, visible: boolean): boolean {
-    if (track.elm) {
-        const elm = track.elm.parentElement;
-        if (elm) {
-            const display = visible ? "flex" : "none";
-            if (elm.style.display !== display) {
-                elm.style.display = display;
-                return true; // visibility is changed
-            }
-        }
-    }
-    return false; // visibility is not changed
-}
-
-export function isTrackSelected(_logViewer: LogViewer, track: Track): boolean {
-    if (track.elm) {
-        const elm = track.elm.parentElement;
-        if (elm) {
-            return elm.classList.contains("selected");
-        }
-    }
-    return false;
-}
-
-export function selectTrack(
-    logViewer: LogViewer,
-    track: Track,
-    selected: boolean
-): boolean {
-    if (track.elm) {
-        const elm = track.elm.parentElement;
-        if (elm) {
-            if (isTrackSelected(logViewer, track) !== selected) {
-                elm.classList.toggle("selected");
-                return true; // selection is changed
-            }
-        }
-    }
-    return false; // selection is not changed
-}
-
-export function getSelectedTrackIndices(logViewer?: LogViewer): number[] {
-    const selectedTrackIndices: number[] = [];
-    if (logViewer) {
-        let iTrack = 0;
-        for (const track of logViewer.tracks) {
-            if (isTrackSelected(logViewer, track))
-                selectedTrackIndices.push(iTrack);
-            iTrack++;
-        }
-    }
-    return selectedTrackIndices;
-}
-
-///////////////////////
-
-export function zoomContent(logViewer: LogViewer, zoom: number): boolean {
-    if (!zoom) zoom = 1.0;
-
-    const [b1, b2] = logViewer.scaleHandler.baseDomain();
-    const [d1, d2] = logViewer.domain;
-    const currentZoom = Math.abs(b2 - b1) / Math.abs(d2 - d1);
-    // see also: getContentZoom(logViewer);
-
-    const f = Math.abs(Math.log(currentZoom / zoom));
-    if (f > 0.01) {
-        /*currentZoom !~= zoom*/
-        let d = (d2 - d1) * 0.5;
-        let c = d1 + d; // the center of the visible part
-        d = d * (currentZoom / zoom);
-        // check if new domain is in the base domain
-        if (c + d > b2) c = b2 - d;
-        if (c - d < b1) c = b1 + d;
-        logViewer.zoomTo([c - d, c + d]);
-        return true;
-    }
-    return false;
-}
-
-export function scrollContentTo(
-    logViewer: LogViewer,
-    f: /*fraction*/ number
-): boolean {
-    const [b1, b2] = logViewer.scaleHandler.baseDomain();
-    const [d1, d2] = logViewer.domain;
-    const d = d2 - d1;
-    const w = b2 - b1 - d; // width of not visible part of content
-
-    const c = b1 + f * w;
-    if (c !== d1) {
-        logViewer.zoomTo([c, c + d]);
-        return true;
-    }
-    return false;
-}
-
-export function zoomContentTo(
-    logViewer: LogViewer,
-    domain: [number, number]
-): boolean {
-    const [d1, d2] = logViewer.domain;
-    if (domain[0] !== d1 || domain[1] !== d2) {
-        logViewer.zoomTo(domain);
-        return true;
-    }
-    return false;
-}
-
-export function setContentBaseDomain(
-    logViewer: LogViewer,
-    domain: [number, number]
-): void {
-    const [b1, b2] = logViewer.scaleHandler.baseDomain();
-    if (b1 !== domain[0] || b2 !== domain[1]) {
-        logViewer.domain = domain;
-        //logViewer.scaleHandler.baseDomain(domain);
-        //logViewer.rescale();
-    }
-}
-
-////////// utilities
-
-export function getContentBaseDomain(logViewer: LogViewer): [number, number] {
-    const [b1, b2] = logViewer.scaleHandler.baseDomain();
-    return [b1, b2];
-}
-
-export function getContentDomain(logViewer: LogViewer): [number, number] {
-    const [d1, d2] = logViewer.domain;
-    return [d1, d2];
-}
-
-export function getContentZoom(logViewer: LogViewer): number /*fraction*/ {
-    // see also zoomContent(logViewer)
-    const [b1, b2] = logViewer.scaleHandler.baseDomain();
-    const [d1, d2] = logViewer.domain;
-    return Math.abs(b2 - b1) / Math.abs(d2 - d1);
-}
-
-export function scrollTracksTo(
-    logViewer: LogViewer,
-    iFrom: number,
-    iTo: number
-): boolean {
-    let visibilityIsChanged = false;
-    let iTrack = 0; // non-scale (graph) tracks counter
-    for (const track of logViewer.tracks) {
-        if (isScaleTrack(track)) continue; // skip scales
-
-        const visible = iFrom <= iTrack && iTrack < iTo;
-        if (showTrack(track, visible)) visibilityIsChanged = true;
-
-        iTrack++;
-    }
-    if (visibilityIsChanged) logViewer.updateTracks();
-    return visibilityIsChanged;
-}
-
-export function getFirstVisibleTrack(logViewer: LogViewer): number {
-    let iTrack = 0; // non-scale (graph) tracks counter
-    for (const track of logViewer.tracks) {
-        if (isScaleTrack(track)) continue; // skip scales
-
-        if (isTrackVisible(track)) return iTrack;
-        iTrack++;
-    }
-    return -1;
-}
-
-export function setSelectedTrackIndices(
-    logViewer: LogViewer | undefined,
-    selectedTrackIndices: number[]
-): boolean {
-    let changed = false;
-    if (logViewer && selectedTrackIndices) {
-        let iTrack = 0;
-        for (const track of logViewer.tracks) {
-            const selected = selectedTrackIndices.indexOf(iTrack) >= 0;
-            if (selectTrack(logViewer, track, selected)) changed = true;
-            iTrack++;
-        }
-    }
-    return changed;
-}
-
-export function updateLegendRows(logViewer: LogViewer): void {
-    // access protected member function
-    // eslint-disable-next-line
-    (logViewer as any).updateLegendRows();
-}

package/src/utils/minmax.ts

@@ -1,126 +0,0 @@
-export function checkMinMaxValue(
-    minmax: [number, number],
-    value: number
-): void {
-    if (value !== null) {
-        if (minmax[0] === Number.POSITIVE_INFINITY)
-            minmax[0] = minmax[1] = value;
-        else if (minmax[0] > value) minmax[0] = value;
-        else if (minmax[1] < value) minmax[1] = value;
-    }
-}
-
-export function checkMinMax(
-    minmax: [number, number],
-    minmaxSrc: [number, number]
-): void {
-    if (minmax[0] === Number.POSITIVE_INFINITY) {
-        minmax[0] = minmaxSrc[0];
-        minmax[1] = minmaxSrc[1];
-    } else {
-        if (minmax[0] > minmaxSrc[0]) minmax[0] = minmaxSrc[0];
-        if (minmax[1] < minmaxSrc[1]) minmax[1] = minmaxSrc[1];
-    }
-}
-
-export function roundMinMax(minmax: [number, number]): [number, number] {
-    const kmin = 6; // a minimal number of intervals
-    const kmax = 9; // a maximal number of intervals
-
-    let mi = minmax[0];
-    let ma = minmax[1];
-
-    if (!isFinite(mi) || !isFinite(ma)) return [mi, ma];
-
-    if (!mi && !ma)
-        // some special case of absolutly round values (zeroes)
-        return [mi, ma];
-
-    let d = ma - mi;
-    if (d < 0) return [mi, ma];
-    if (!d) d = 1;
-    else {
-        // avoid rounding of already near round values (some round decimals do not have exact the binary representation)
-        ma = ma - d * 0.0000001;
-        mi = mi + d * 0.0000001;
-        d = ma - mi;
-    }
-    const l0 = Math.floor(Math.log10(d));
-    let p = Math.pow(10, l0 + 1);
-    let c = (mi + d * 0.5) / p;
-    if (Math.abs(c) > 1e9) c *= p;
-    else c = Math.floor(c) * p;
-    let q = 0.5;
-    let l = l0;
-
-    let k1 = 0,
-        k2 = 0;
-    let k = k2 - k1;
-    for (; l > -20 /*-30*/; l--) {
-        p = p * 0.1;
-        while (q >= 0.5) {
-            d = p * q;
-            k2 = Math.floor((ma - c) / d);
-            if (ma >= c) k2++;
-            k1 = Math.floor((mi - c) / d);
-            if (mi < c) k1--;
-            k = k2 - k1;
-            if (k >= kmax) break;
-            q = q * 0.5;
-        }
-        if (k >= kmax) break;
-        q = 2.0;
-    }
-    if (k >= kmax) {
-        for (; l < l0; l++) {
-            while (q <= 2.0) {
-                d = p * q;
-                k2 = Math.floor((ma - c) / d);
-                if (ma >= c) k2++;
-                k1 = Math.floor((mi - c) / d);
-                if (mi < c) k1--;
-                k = k2 - k1;
-                if (k <= kmax) break;
-                q = q * 2.0;
-            }
-            if (k <= kmax) break;
-            q = 0.5;
-            p = p * 10;
-        }
-    }
-    if (k < kmin) {
-        const j = q == 2.0 ? 5 : 2;
-        if (k1 >= 0) k = (k1 / j) * j;
-        else k = ((k1 - j + 1) / j) * j;
-        if (k2 - k > kmin) {
-            if (k2 < 0) k = (k2 / j) * j;
-            else k = ((k2 + j - 1) / j) * j;
-            if (k - k1 > kmin) k2 = (k2 + k1 + kmin) / 2;
-            else k2 = k;
-        } else {
-            k1 = k2 - kmin;
-            k2 = k1 + kmin;
-        }
-        k1 = k;
-    }
-    const a = k1 * d + c;
-    const b = k2 * d + c;
-    return [parseFloat(a.toPrecision(5)), parseFloat(b.toPrecision(5))];
-}
-
-export function roundLogMinMax(minmax: [number, number]): [number, number] {
-    const r = roundMinMax(minmax);
-    /* TODO: make Log version
-      const ret = roundMinMax([Math.log10(minmax[0]), Math.log10(minmax[1])]);
-      //const a=Math.pow(10, ret[0]), b=Math.pow(10, ret[1]);
-      */
-    if (r[0] <= 0) {
-        // avoid non-positive values
-        r[0] = minmax[0];
-        if (r[0] <= 0) {
-            // could not show negative data!
-            console.error("Wrong data range for logarithm scale " + minmax);
-        }
-    }
-    return [parseFloat(r[0].toPrecision(5)), parseFloat(r[1].toPrecision(5))];
-}