@windborne/grapher 1.0.0

package/src/state/space_conversions/data_space_to_selected_space.js

@@ -0,0 +1,328 @@
+import binarySearch from '../../helpers/binary_search';
+
+function validateSelectedSpaceConversion({ data, inSelectedSpace, firstIndex, lastIndex, ignoreDiscontinuities }) { // eslint-disable-line no-unused-vars
+    let correct = data.slice(firstIndex + 1, lastIndex);
+    if (ignoreDiscontinuities) {
+        correct = correct.filter(([_x, y]) => (y !== null && y !== undefined));
+    }
+
+    if (correct.length !== inSelectedSpace.length) {
+        console.log({ // eslint-disable-line no-console
+            data,
+            attempt: inSelectedSpace.map(([x, y]) => [undateify(x), y]),
+            correct: correct.map(([x, y]) => [undateify(x), y]),
+            sdl: window.sdl
+        });
+        window.tacomaDataPaused = true;
+        throw new Error('Failed to select via swap');
+    }
+
+    for (let i = 0; i < correct.length; i++) {
+        if (undateify(correct[i][0]) !== undateify(inSelectedSpace[i][0]) || correct[i][1] !== inSelectedSpace[i][1]) {
+            console.log({ // eslint-disable-line no-console
+                i,
+                attempt: inSelectedSpace.map(([x, y]) => [undateify(x), y]),
+                correct: correct.map(([x, y]) => [undateify(x), y]),
+                correctX: undateify(correct[i][0]),
+                correctY: correct[i][1],
+                attemptX: undateify(inSelectedSpace[i][0]),
+                attemptY: inSelectedSpace[i][1]
+            });
+            window.tacomaDataPaused = true;
+            throw new Error('Failed to select via swap');
+        }
+    }
+}
+
+/**
+ * Converts from data space to selected space
+ *
+ * @param {Array<Array<Number>>} data
+ * @param {{data: Array<Array<Number>>}|*} [swap]
+ * @param {Number} minX
+ * @param {Number} maxX
+ * @param {Boolean} ignoreDiscontinuities
+ * @param {Boolean} square
+ * @return {{data: Array<Array<Number>>, lastAdded: boolean, firstAdded: boolean, afterIndex: Number, ignoreDiscontinuities: boolean, minX: Number, maxX: Number, beforeIndex: Number}}
+ */
+export default function dataSpaceToSelectedSpace({ data, swap, minX, maxX, ignoreDiscontinuities, square }) {
+    if (!data.length || data.length && minX > data[data.length - 1][0] || data.length && maxX < data[0][0]) {
+        //let previouslyEmpty = !data.length;
+        return {
+            data: [
+                [minX, null],
+                [maxX, null]
+            ],
+            firstAdded: true,
+            lastAdded: true
+            //previouslyEmpty
+        };
+    }
+
+    let beforeIndex = binarySearch(data, minX, { searchType: 'before', returnIndex: true }) || 0;
+    let afterIndex = binarySearch(data, maxX, { searchType: 'after', returnIndex: true }) || 0;
+    if (afterIndex === -1) {
+        afterIndex = 0;
+    }
+
+    while (beforeIndex >= 0 && data[beforeIndex][0] >= minX) {
+        beforeIndex --;
+    }
+
+    while (afterIndex < data.length && data[afterIndex][0] <= maxX) {
+        afterIndex ++;
+    }
+
+    let inSelectedSpace;
+    let addToEndOnly = false;
+
+    let firstAdded = false;
+    let lastAdded = false;
+
+    let beginningInterpolationIndex = beforeIndex;
+    let endInterpolationIndex = afterIndex;
+    if (ignoreDiscontinuities) {
+        while (beginningInterpolationIndex >= 0 && data[beginningInterpolationIndex][1] === null) {
+            beginningInterpolationIndex --;
+        }
+        while (endInterpolationIndex < data.length && data[endInterpolationIndex][1] === null) {
+            endInterpolationIndex++;
+        }
+    }
+
+    if (swap) {
+        inSelectedSpace = swap.data;
+        if (swap.lastAdded) {
+            inSelectedSpace.pop();
+        }
+        if (minX === swap.minX) {
+            addToEndOnly = true;
+        }
+        if (beforeIndex !== swap.beforeIndex) {
+            addToEndOnly = false;
+            if (swap.firstAdded) {
+                inSelectedSpace.shift();
+            }
+            let index = swap.beforeIndex;
+            while (index >= 0 && inSelectedSpace.length && inSelectedSpace[0][0] >= minX) {
+                if (!ignoreDiscontinuities || data[index][1] || data[index][1] === 0) {
+                    inSelectedSpace.unshift(data[index]);
+                }
+                index --;
+            }
+            while (index < data.length && inSelectedSpace.length && inSelectedSpace[0][0] < minX) {
+                inSelectedSpace.shift();
+                index ++;
+            }
+        }
+
+        if (ignoreDiscontinuities && !swap.ignoreDiscontinuities) {
+            inSelectedSpace = inSelectedSpace.filter(([_x, y]) => (y !== null && y !== undefined));
+        }
+
+        if (beforeIndex === swap.beforeIndex && swap.firstAdded) {
+            firstAdded = true;
+
+            let interpolationIndex = beforeIndex + 1;
+            if (ignoreDiscontinuities) {
+                while (interpolationIndex < data.length && data[interpolationIndex][1] === null) {
+                    interpolationIndex ++;
+                }
+            }
+
+            if (beginningInterpolationIndex === -1 && inSelectedSpace.length) {
+                inSelectedSpace[0] = [minX, null];
+            } else {
+                if (square && inSelectedSpace.length) {
+                    inSelectedSpace[0] = [minX, data[beginningInterpolationIndex][1]];
+                } else {
+                    if (inSelectedSpace.length) {
+                        inSelectedSpace[0] = [minX, interpolate(data, beginningInterpolationIndex, interpolationIndex, minX)];
+                    }
+                }
+            }
+            if (data[beforeIndex + 1][0] === inSelectedSpace[0][0] && data[beforeIndex + 1][1] === inSelectedSpace[0][1]) {
+                firstAdded = false;
+            }
+        }
+        let lastIncluded = swap.afterIndex;
+        if (swap.ignoreDiscontinuities && !ignoreDiscontinuities) {
+            let nullIndex = beforeIndex + 1;
+            let selectedIndex = 0;
+            if (firstAdded) {
+                selectedIndex ++;
+            }
+            while (selectedIndex <= inSelectedSpace.length && nullIndex < data.length && nullIndex < afterIndex) {
+                if (data[nullIndex][0] <= maxX && data[nullIndex][1] === null && (!inSelectedSpace[selectedIndex] || inSelectedSpace[selectedIndex][0] !== data[nullIndex][0] || inSelectedSpace[selectedIndex][1] !== data[nullIndex][1])) {
+                    inSelectedSpace.splice(selectedIndex, 0, data[nullIndex]);
+                    if (nullIndex >= lastIncluded) {
+                        lastIncluded = nullIndex + 1;
+                    }
+                }
+                nullIndex ++;
+                selectedIndex ++;
+            }
+        }
+
+        let dataIndex = lastIncluded || 0;
+        while (dataIndex < data.length && data[dataIndex][0] <= maxX) {
+            if (data[dataIndex][0] >= minX) {
+                if (!ignoreDiscontinuities || data[dataIndex][1] || data[dataIndex][1] === 0) {
+                    inSelectedSpace.push(data[dataIndex]);
+                }
+            }
+            dataIndex ++;
+        }
+        while (inSelectedSpace.length && inSelectedSpace[inSelectedSpace.length - 1][0] > maxX) {
+            inSelectedSpace.pop();
+        }
+
+    } else {
+        inSelectedSpace = data.slice(beforeIndex + 1, afterIndex);
+        if (ignoreDiscontinuities) {
+            inSelectedSpace = inSelectedSpace.filter(([_x, y]) => (y !== null && y !== undefined));
+        }
+    }
+
+    if (!inSelectedSpace.length) {
+        if (square) {
+            if (beginningInterpolationIndex < 0) {
+                inSelectedSpace = [[minX, null], [maxX, null]];
+            } else {
+                inSelectedSpace = [[minX, data[beginningInterpolationIndex][1]], [maxX, data[beginningInterpolationIndex][1]]];
+            }
+        } else {
+            inSelectedSpace = [[minX, interpolate(data, beginningInterpolationIndex, endInterpolationIndex, minX)], [maxX, interpolate(data, beginningInterpolationIndex, endInterpolationIndex, maxX)]];
+        }
+        firstAdded = true;
+        lastAdded = true;
+    }
+
+    if (!addToEndOnly) {
+        let interpolationIndex = beforeIndex + 1;
+        if (ignoreDiscontinuities) {
+            while (interpolationIndex < data.length && data[interpolationIndex][1] === null) {
+                interpolationIndex ++;
+            }
+        }
+
+        if (inSelectedSpace.length && inSelectedSpace[0][0] > minX) {
+            firstAdded = true;
+            if (beginningInterpolationIndex === -1) {
+                inSelectedSpace.unshift([minX, null]);
+            } else {
+                if (square) {
+                    inSelectedSpace.unshift([minX, data[beginningInterpolationIndex][1]]);
+                } else {
+                    inSelectedSpace.unshift([minX, interpolate(data, beginningInterpolationIndex, interpolationIndex, minX)]);
+                }
+            }
+        }
+    }
+
+    if (inSelectedSpace.length && inSelectedSpace[inSelectedSpace.length - 1][0] < maxX) {
+        lastAdded = true;
+
+        let interpolationIndex = afterIndex - 1;
+        if (ignoreDiscontinuities) {
+            while (interpolationIndex >= 0 && data[interpolationIndex][1] === null) {
+                interpolationIndex --;
+            }
+        }
+
+        if (endInterpolationIndex === data.length) {
+            inSelectedSpace.push([maxX, null]);
+        } else {
+            if (square) {
+                inSelectedSpace.push([maxX, inSelectedSpace[inSelectedSpace.length - 1][1]]);
+            } else {
+                inSelectedSpace.push([maxX, interpolate(data, interpolationIndex, endInterpolationIndex, maxX)]);
+            }
+        }
+    }
+
+    if (inSelectedSpace.length === 1) {
+        let begPoint;
+        let endPoint;
+        if (square) {
+            if (beginningInterpolationIndex < 0) {
+                begPoint = [minX, null];
+            } else {
+                begPoint = [minX, data[beginningInterpolationIndex][1]];
+            }
+            endPoint = [maxX, inSelectedSpace[0][1]];
+        } else {
+            begPoint = [minX, interpolate(data, beginningInterpolationIndex, beforeIndex + 1, minX)];
+            endPoint = [maxX, interpolate(data, afterIndex - 1, endInterpolationIndex, maxX)];
+        }
+        inSelectedSpace.unshift(begPoint);
+        inSelectedSpace.push(endPoint);
+        firstAdded = true;
+        lastAdded = true;
+    }
+
+    return {
+        data: inSelectedSpace,
+        minX,
+        maxX,
+        beforeIndex,
+        afterIndex,
+        firstAdded,
+        lastAdded,
+        ignoreDiscontinuities
+        //previouslyEmpty: false
+    };
+}
+
+function undateify(potentialDate) {
+    if (potentialDate instanceof Date) {
+        return potentialDate.valueOf();
+    }
+
+    return potentialDate;
+}
+
+/**
+ * Finds the point at the boundary via interpolation
+ *
+ * @param {Array<Array<Number>>} data
+ * @param {Number} firstIndex
+ * @param {Number} secondIndex
+ * @param {Number} boundary
+ * @return {null|*}
+ */
+function interpolate(data, firstIndex, secondIndex, boundary) {
+    if (firstIndex < 0 || secondIndex < 0) {
+        return null;
+    }
+
+    if (firstIndex >= data.length || secondIndex >= data.length) {
+        return null;
+    }
+
+    if (firstIndex === secondIndex) {
+        return data[firstIndex][1];
+    }
+
+    const [xBefore, yBefore] = data[firstIndex];
+    const [xAfter, yAfter] = data[secondIndex];
+
+    if (boundary === xBefore && yBefore !== null) {
+        return yBefore;
+    }
+
+    if (boundary === xAfter && yAfter !== null) {
+        return yAfter;
+    }
+
+    if (yBefore === null || yAfter === null) {
+        return null;
+    }
+
+    const percent = (boundary - xBefore)/(xAfter - xBefore);
+    if (percent < 0 || percent > 1) {
+        return null;
+    }
+
+    return percent*(yAfter - yBefore) + yBefore;
+}

package/src/state/space_conversions/selected_space_to_background_space.js

@@ -0,0 +1,144 @@
+export function selectedSpaceToBackgroundSpace({ data, background, minX, maxX }) {
+    if (!background) {
+        return null;
+    }
+
+    const conditions = [];
+    for (let [key, color] of Object.entries(background)) {
+        if (typeof color === 'object') {
+            if (typeof color.evaluator !== 'function') {
+                throw new Error('Invalid background declaration: ' + key + ' (evaluator must be a function)');
+            }
+
+            conditions.push(Object.assign({
+                key,
+                comparator: 'custom',
+                comparedAgainst: null
+            }, color));
+            continue;
+        }
+
+        if (key === 'null') {
+            conditions.push({
+                evaluator: (y) => y === null && color,
+                color,
+                key,
+                comparator: '=',
+                comparedAgainst: null
+            });
+            continue;
+        }
+
+        const [comparator, value] = key.split(' ');
+        if (!comparator || !value || isNaN(parseFloat(value))) {
+            throw new Error('Invalid background declaration: ' + key);
+        }
+
+        const parsedValue = parseFloat(value);
+
+        let evaluator;
+        if (comparator === '=') {
+            evaluator = (y) => typeof y === 'number' && y === parsedValue && color;
+        } else if (comparator === '<') {
+            evaluator = (y) => typeof y === 'number' && y < parsedValue && color;
+        } else if (comparator === '>') {
+            evaluator = (y) => typeof y === 'number' && y > parsedValue && color;
+        } else if (comparator === '<=') {
+            evaluator = (y) => typeof y === 'number' && y <= parsedValue && color;
+        } else if (comparator === '>=') {
+            evaluator = (y) => typeof y === 'number' && y >= parsedValue && color;
+        } else {
+            throw new Error('Invalid background declaration: ' + key);
+        }
+
+        conditions.push({
+            evaluator,
+            color,
+            key,
+            comparator,
+            comparedAgainst: parsedValue
+        });
+    }
+
+    const inBackgroundSpace = [];
+    let currentSection = null;
+
+    for (let i = 0; i < data.length; i++) {
+        let [x, y] = data[i];
+        if (x instanceof Date) {
+            x = x.valueOf();
+        }
+
+        for (let condition of currentSection ? [currentSection.condition, ...conditions] : conditions) {
+            const color = condition.evaluator(y);
+
+            if (currentSection) {
+                if (currentSection.color === color) {
+                    break;
+                }
+
+                let interpolatedMaxX = x;
+                if (i > 0) {
+                    let [prevX, prevY] = data[i - 1];
+                    if (prevX instanceof Date) {
+                        prevX = prevX.valueOf();
+                    }
+
+                    if (currentSection.condition.comparedAgainst === null) {
+                        interpolatedMaxX = x;
+                    } else if (y === null) {
+                        interpolatedMaxX = prevX;
+                    } else {
+                        interpolatedMaxX = prevX + (condition.comparedAgainst - prevY)/(y - prevY)*(x - prevX);
+                    }
+                }
+
+                inBackgroundSpace.push({
+                    ...currentSection,
+                    maxX: interpolatedMaxX,
+                    maxXt: (interpolatedMaxX - minX)/(maxX - minX)
+                });
+                currentSection = null;
+            }
+
+            if (color) {
+                let interpolatedMinX = x;
+                if (i > 0) {
+                    let [prevX, prevY] = data[i - 1];
+                    if (prevX instanceof Date) {
+                        prevX = prevX.valueOf();
+                    }
+
+                    if (condition.comparedAgainst === null) {
+                        interpolatedMinX = prevX;
+                    } else if (prevY === null) {
+                        interpolatedMinX = x;
+                    } else {
+                        interpolatedMinX = prevX + (condition.comparedAgainst - prevY)/(y - prevY)*(x - prevX);
+                    }
+                }
+
+                currentSection = {
+                    minX: interpolatedMinX,
+                    minXt: (interpolatedMinX - minX)/(maxX - minX),
+                    color,
+                    condition
+                };
+
+                break;
+            }
+        }
+    }
+
+    if (currentSection) {
+        inBackgroundSpace.push({
+            ...currentSection,
+            maxX: data[data.length - 1][0],
+            maxXt: (data[data.length - 1][0] - minX)/(maxX - minX)
+        });
+    }
+
+    return {
+        data: inBackgroundSpace
+    };
+}

package/src/state/space_conversions/selected_space_to_render_space.js

@@ -0,0 +1,161 @@
+import scaleBounds from '../../renderer/scale_bounds';
+let RustAPI;
+import('../../rust/pkg/index.js').then((module) => {
+    RustAPI = module;
+});
+
+function selectedSpaceToRenderSpaceInPlace({ data, renderWidth, renderHeight, minX, maxX, minY, maxY, scale }, { nullMask, yValues, minYValues, maxYValues }) {
+    let i = 0;
+    let prevI = i - 1;
+
+    for (let pixelX = 0; pixelX < renderWidth; pixelX++) {
+        // find the x value that corresponds to the x pixel
+        const x = (pixelX/(renderWidth - 1))*(maxX - minX) + minX;
+
+        // set i such that data[i][0] < x <= data[i+1][0]
+        let minSeenY = null;
+        let maxSeenY = null;
+
+        if (i > 0 && i <= data.length && data[i - 1][1] === null) {
+            i--;
+        }
+
+        if (i < data.length - 2 && data[i + 1][0] < x) {
+            i++;
+        }
+
+        for (i; i < data.length - 2 && data[i + 1][0] < x; i++) {
+            const curY = data[i][1];
+
+            if (curY === null) {
+                continue;
+            }
+
+            if (minSeenY === null || curY < minSeenY) {
+                minSeenY = curY;
+            }
+
+            if (maxSeenY === null || curY > maxSeenY) {
+                maxSeenY = curY;
+            }
+        }
+
+        minYValues[pixelX] = minSeenY === null ? 0 : renderHeight*(1 - ((scale === 'log' ? Math.log10(minSeenY) : minSeenY) - minY)/(maxY - minY));
+        maxYValues[pixelX] = maxSeenY === null ? 0 : renderHeight*(1 - ((scale === 'log' ? Math.log10(maxSeenY) : maxSeenY) - minY)/(maxY - minY));
+
+        // pass any discontinuities along
+        if (i >= data.length - 1 || data[i][1] === null || data[i + 1][1] === null) {
+            const y = i >= data.length - 1 ? null : data[i][1];
+
+            nullMask[pixelX] = ((y === null) << 0) | ((minSeenY === null) << 1) | ((maxSeenY === null) << 2);
+            yValues[pixelX] = y === null ? 0 : renderHeight*(1 - ((scale === 'log' ? Math.log10(y) : y) - minY)/(maxY - minY));
+
+            i++;
+
+            continue;
+        }
+
+        // interpolate
+        const [xBefore, yBefore] = data[i];
+        const [xAfter, yAfter] = data[i + 1];
+
+        const percent = (x - xBefore) / (xAfter - xBefore);
+        let y = percent * (yAfter - yBefore) + yBefore;
+
+        // we're at the first point after the direction changed. Don't interpolate
+        if (prevI !== i) {
+            y = yBefore;
+        }
+
+        yValues[pixelX] = y === null ? 0 : renderHeight*(1 - ((scale === 'log' ? Math.log10(y) : y) - minY)/(maxY - minY));
+        nullMask[pixelX] = ((y === null) << 0) | ((minSeenY === null) << 1) | ((maxSeenY === null) << 2);
+
+        prevI = i;
+    }
+}
+
+/**
+ * Convert from selected space to value space
+ *
+ * @param data
+ * @param {Object} [swap]
+ * @param {Number} renderWidth  - width, in pixels, of the area in which the graph is rendered
+ * @param {Number} renderHeight - height, in pixels, of the area in which the graph is rendered
+ * @param {Number} minX         - the minimum x value that is rendered
+ * @param {Number} maxX         - the maximum x value that is rendered
+ * @param {Number} minY         - the minimum y value that is rendered
+ * @param {Number} maxY         - the maximum y value that is rendered
+ * @param {'log'|'linear'} scale
+ * @param {Boolean} [dataChanged] - if true, will not rely on the prior data state from swap being accurate
+ * @return {{nullMask: Uint8Array, maxYValues: Float64Array, minYValues: Float64Array, yValues: Float64Array, dataF64: Float64Array, dataNullMask: Uint8Array}}
+ */
+export default function selectedSpaceToRenderSpace({ data, swap, renderWidth, renderHeight, minX, maxX, minY, maxY, scale, dataChanged }) {
+    if (swap && swap.yValues.length !== renderWidth) {
+        swap = null;
+    }
+
+    const nullMask = (swap && swap.nullMask) || new Uint8Array(renderWidth);
+    nullMask.fill(0);
+    const yValues = new Float64Array(renderWidth);
+    const minYValues = new Float64Array(renderWidth);
+    const maxYValues = new Float64Array(renderWidth);
+
+    const scaledBounds = scaleBounds({ minY, maxY, scale});
+    minY = scaledBounds.minY;
+    maxY = scaledBounds.maxY;
+
+    const inParams = { data, renderWidth, renderHeight, minX, maxX, minY, maxY, scale };
+
+    let dataF64, dataNullMask;
+
+    if (RustAPI) {
+        let copyIndexStart = 0;
+
+        const hasSwap = swap && swap.dataNullMask && swap.dataF64;
+        const useSwap = !dataChanged && hasSwap && swap.minX === minX && swap.maxX <= maxX && swap.length <= data.length;
+
+        if (!useSwap || swap.dataNullMask.length < data.length) {
+            const extraSpaceFactor = 1.25;
+            dataF64 = new Float64Array(Math.floor(data.length*2*extraSpaceFactor));
+            dataNullMask = new Uint8Array(Math.floor(data.length*extraSpaceFactor));
+
+            if (useSwap) {
+                dataNullMask.set(swap.dataNullMask);
+                dataF64.set(swap.dataF64);
+            }
+        } else {
+            dataF64 = swap.dataF64;
+            dataNullMask = swap.dataNullMask;
+        }
+
+        if (useSwap) {
+            copyIndexStart = Math.max(swap.length - 1, 0);
+        }
+
+        for (let i = copyIndexStart; i < data.length; i++) {
+            dataF64[2*i] = data[i][0];
+            dataF64[2*i + 1] = data[i][1];
+
+            if (data[i][1] === null) {
+                dataNullMask[i] = 1;
+            } else  {
+                dataNullMask[i] = 0;
+            }
+        }
+        RustAPI.selected_space_to_render_space(data.length, dataF64, dataNullMask, inParams, nullMask, yValues, minYValues, maxYValues);
+    } else {
+        selectedSpaceToRenderSpaceInPlace(inParams, { nullMask, yValues, minYValues, maxYValues });
+    }
+
+    return {
+        nullMask,
+        yValues,
+        minYValues,
+        maxYValues,
+        dataF64,
+        dataNullMask,
+        minX,
+        maxX,
+        length: data.length
+    };
+}