@windborne/grapher 1.0.0

package/src/rust/pkg/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "grapher-rs",
+  "collaborators": [
+    "Kai Marshland <kaimarshland@gmail.com>"
+  ],
+  "version": "0.1.0",
+  "files": [
+    "index_bg.wasm",
+    "index.js",
+    "index_bg.js"
+  ],
+  "module": "index.js",
+  "sideEffects": false
+}

package/src/rust/src/extract_vertices.rs

@@ -0,0 +1,83 @@
+use wasm_bindgen::prelude::*;
+
+fn add_point(x : f32, y : f32, prev_x : f32, prev_y : f32, point_i : usize, positions: &mut [f32], prev_positions: &mut [f32], vertices: &mut [f32], indices: &mut [u32]) {
+    for j in 0..4 {
+        positions[point_i * 8 + 2 * j] = x;
+        positions[point_i * 8 + 2 * j + 1] = y;
+        prev_positions[point_i * 8 + 2 * j] = prev_x;
+        prev_positions[point_i * 8 + 2 * j + 1] = prev_y;
+        vertices[point_i*4 + j] = j as f32;
+    }
+
+    indices[point_i * 6] = (point_i * 4) as u32;
+    indices[point_i * 6 + 1] = (point_i * 4 + 1) as u32;
+    indices[point_i * 6 + 2] = (point_i * 4 + 3) as u32;
+
+    indices[point_i * 6 + 3] = (point_i * 4) as u32;
+    indices[point_i * 6 + 4] = (point_i * 4 + 2) as u32;
+    indices[point_i * 6 + 5] = (point_i * 4 + 3) as u32;
+}
+
+#[wasm_bindgen]
+pub fn extract_vertices(dpi_increase: f64, null_mask: &[u8], y_values: &[f64], min_y_values: &[f64], max_y_values: &[f64], positions: &mut [f32], prev_positions: &mut [f32], vertices: &mut [f32], indices: &mut [u32], dashed : bool, dash0 : usize, dash1 : usize) {
+    let mut previously_discontinuous = true;
+
+    let mut point_i = 0;
+    let mut path_i = 0;
+
+    let mut prev_x : f32;
+    let mut prev_y : f32;
+
+    for i in 0..y_values.len() {
+        if dashed && path_i % (dash0 + dash1) >= dash0 {
+            path_i += 1;
+            continue;
+        }
+
+        let x : f32 = (i as f32)*(dpi_increase as f32);
+        let y = y_values[i] as f32;
+
+        if (null_mask[i] & 0b001) > 0 { // y null
+            previously_discontinuous = true;
+            continue;
+        }
+
+        if previously_discontinuous {
+            path_i = 0;
+            prev_x = x - 1.0;
+            prev_y = y;
+        } else  {
+            prev_x = ((i - 1) as f32)*(dpi_increase as f32);
+            prev_y = y_values[i - 1] as f32;
+        }
+
+        add_point(x, y, prev_x, prev_y, point_i, positions, prev_positions, vertices, indices);
+        point_i += 1;
+        path_i += 1;
+
+        let min_y = min_y_values[i];
+        let max_y = max_y_values[i];
+
+        if min_y != max_y {
+            if (null_mask[i] & 0b010) == 0 {
+                add_point(x, min_y as f32, prev_x, prev_y, point_i, positions, prev_positions, vertices, indices);
+                prev_y = min_y as f32;
+                point_i += 1;
+                path_i += 1;
+            }
+
+            if (null_mask[i] & 0b100) == 0 {
+                add_point(x, max_y as f32, prev_x, prev_y, point_i, positions, prev_positions, vertices, indices);
+                prev_y = max_y as f32;
+                point_i += 1;
+                path_i += 1;
+            }
+
+            add_point(x, y, prev_x, prev_y, point_i, positions, prev_positions, vertices, indices);
+            point_i += 1;
+            path_i += 1;
+        }
+
+        previously_discontinuous = false;
+    }
+}

package/src/rust/src/get_point_number.rs

@@ -0,0 +1,50 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+pub fn get_point_number(null_mask: &[u8], y_values: &[f64], min_y_values: &[f64], max_y_values: &[f64], dashed : bool, dash0 : usize, dash1 : usize) -> f64 {
+    let mut previously_discontinuous = true;
+
+    let mut point_i = 0;
+    let mut path_i = 0;
+
+    for i in 0..y_values.len() {
+        if dashed && path_i % (dash0 + dash1) >= dash0 {
+            path_i += 1;
+            continue;
+        }
+
+        if (null_mask[i] & 0b001) > 0 { // y null
+            previously_discontinuous = true;
+            continue;
+        }
+
+        if previously_discontinuous {
+            path_i = 0;
+        }
+
+        point_i += 1;
+        path_i += 1;
+
+        let min_y = min_y_values[i];
+        let max_y = max_y_values[i];
+
+        if min_y != max_y {
+            if (null_mask[i] & 0b010) == 0 {
+                point_i += 1;
+                path_i += 1;
+            }
+
+            if (null_mask[i] & 0b110) == 0 {
+                point_i += 1;
+                path_i += 1;
+            }
+
+            point_i += 1;
+            path_i += 1;
+        }
+
+        previously_discontinuous = false;
+    }
+
+    point_i as f64
+}

package/src/rust/src/lib.rs

@@ -0,0 +1,15 @@
+use wasm_bindgen::prelude::*;
+mod selected_space_to_render_space;
+mod extract_vertices;
+mod get_point_number;
+
+// This is like the `main` function, except for JavaScript.
+#[wasm_bindgen(start)]
+pub fn main_js() -> Result<(), JsValue> {
+    // This provides better error messages in debug mode.
+    // It's disabled in release mode so it doesn't bloat up the file size.
+    #[cfg(debug_assertions)]
+        console_error_panic_hook::set_once();
+
+    Ok(())
+}

package/src/rust/src/selected_space_to_render_space.rs

@@ -0,0 +1,131 @@
+use wasm_bindgen::prelude::*;
+use js_sys::JsString;
+
+#[wasm_bindgen]
+extern "C" {
+    pub type SelectedToRenderParams;
+
+    #[wasm_bindgen(method, getter = renderWidth)]
+    fn render_width(this: &SelectedToRenderParams) -> f64;
+    #[wasm_bindgen(method, getter = renderHeight)]
+    fn render_height(this: &SelectedToRenderParams) -> f64;
+    #[wasm_bindgen(method, getter = minX)]
+    fn min_x(this: &SelectedToRenderParams) -> f64;
+    #[wasm_bindgen(method, getter = maxX)]
+    fn max_x(this: &SelectedToRenderParams) -> f64;
+    #[wasm_bindgen(method, getter = minY)]
+    fn min_y(this: &SelectedToRenderParams) -> f64;
+    #[wasm_bindgen(method, getter = maxY)]
+    fn max_y(this: &SelectedToRenderParams) -> f64;
+    #[wasm_bindgen(method, getter = scale)]
+    fn scale(this: &SelectedToRenderParams) -> JsString;
+}
+
+#[inline]
+fn value_space_to_render_space(y: f64, min_y : f64, max_y : f64, log_scale : bool, render_height : f64) -> f64 {
+    let mut scaled_y = y;
+    if log_scale {
+        scaled_y = y.log10();
+    }
+
+    let percent = (scaled_y - min_y)/(max_y - min_y);
+
+    return render_height * (1.0 - percent);
+}
+
+#[wasm_bindgen]
+pub fn selected_space_to_render_space(length : usize, data : &[f64], data_null_mask : &[u8], params : &SelectedToRenderParams, null_mask: &mut [u8], y_values: &mut [f64], min_y_values: &mut [f64], max_y_values: &mut [f64]) {
+    let min_x = params.min_x();
+    let max_x = params.max_x();
+    let min_y = params.min_y();
+    let max_y = params.max_y();
+    let render_width = params.render_width();
+    let render_height = params.render_height();
+    let log_scale = params.scale() == "log";
+
+    let mut i : usize = 0;
+    let mut prev_i : i32 = (i as i32) - 1;
+
+    for pixel_x in 0..(render_width.ceil() as usize) {
+        // find the x value that corresponds to the x pixel
+        let x = ((pixel_x as f64)/((render_width as f64) - 1.0))*(max_x - min_x) + min_x;
+
+        // set i such that data[i][0] < x <= data[i+1][0]
+        let mut min_seen_y : Option<f64> = None;
+        let mut max_seen_y : Option<f64> = None;
+
+        if i > 0 && i <= length && data_null_mask[i - 1] > 0 {
+            i -= 1;
+        }
+
+        if (i + 2) < length && data[2*(i + 1)] < x {
+            i += 1;
+        }
+
+        while (i + 2) < length && data[2*(i + 1)] < x {
+            if data_null_mask[i] > 0 {
+                i += 1;
+                continue;
+            }
+
+            let cur_y = data[2*i + 1];
+
+            if min_seen_y == None || cur_y < min_seen_y.unwrap() {
+                min_seen_y = Some(cur_y);
+            }
+
+            if max_seen_y == None || cur_y > max_seen_y.unwrap() {
+                max_seen_y = Some(cur_y);
+            }
+
+            i += 1;
+        }
+
+        let mut cur_null_mask : u8 = 0;
+
+        match min_seen_y {
+            Some(value) => min_y_values[pixel_x] = value_space_to_render_space(value, min_y, max_y, log_scale, render_height),
+            None => cur_null_mask |= 0b010
+        }
+
+        match max_seen_y {
+            Some(value) => max_y_values[pixel_x] = value_space_to_render_space(value, min_y, max_y, log_scale, render_height),
+            None => cur_null_mask |= 0b100
+        }
+
+        // pass any discontinuities along
+        if (i + 1) >= length || (data_null_mask[i] > 0) || (data_null_mask[i + 1] > 0) {
+            if (i + 1) >= length || data_null_mask[i] > 0 {
+                cur_null_mask |= 0b001; // mark y as null
+            } else {
+                let y = data[2*i + 1];
+                y_values[pixel_x] = value_space_to_render_space(y, min_y, max_y, log_scale, render_height);
+            }
+
+            i += 1;
+
+            null_mask[pixel_x] = cur_null_mask;
+            continue;
+        }
+
+        // interpolate
+        let x_before = data[2*i];
+        let y_before = data[2*i + 1];
+
+        let x_after = data[2*(i + 1)];
+        let y_after = data[2*(i + 1) + 1];
+
+        let percent = (x - x_before) / (x_after - x_before);
+        let mut y = percent * (y_after - y_before) + y_before;
+
+        // we're at the first point after the direction changed. Don't interpolate
+        if prev_i != (i as i32) {
+            y = y_before;
+        }
+
+        y_values[pixel_x] = value_space_to_render_space(y, min_y, max_y, log_scale, render_height);
+        null_mask[pixel_x] = cur_null_mask;
+
+        prev_i = i as i32;
+    }
+}

package/src/state/average_loop_times.js

@@ -0,0 +1,15 @@
+export function averageLoopTimes(loopTimes) {
+    const result = {};
+
+    for (let loopTime of loopTimes) {
+        for (let [key, value] of Object.entries(loopTime)) {
+            result[key] = (result[key] || 0) + value;
+        }
+    }
+
+    for (let [key, value] of Object.entries(result)) {
+        result[key] = value/loopTimes.length;
+    }
+
+    return result;
+}

package/src/state/bound_calculator_from_selection.js

@@ -0,0 +1,36 @@
+import scaleBounds from '../renderer/scale_bounds';
+
+export default function boundCalculatorFromSelection({ minPixelX, maxPixelX, minPixelY, maxPixelY}, { elementWidth, elementHeight, selection, axes }) {
+    if (Math.abs(maxPixelX - minPixelX) < 1 || Math.abs(maxPixelY - minPixelY) < 1) {
+        return;
+    }
+
+    const minX = (minPixelX/elementWidth)*(selection.maxX - selection.minX) + selection.minX;
+    const maxX = (maxPixelX/elementWidth)*(selection.maxX - selection.minX) + selection.minX;
+
+    const byAxis = [];
+    for (let { currentBounds, scale } of axes) {
+        const scaledBounds = scaleBounds({ ...currentBounds, scale });
+        let maxY = (1 - minPixelY/elementHeight)*(scaledBounds.maxY - scaledBounds.minY) + scaledBounds.minY;
+        let minY = (1 - maxPixelY/elementHeight)*(scaledBounds.maxY - scaledBounds.minY) + scaledBounds.minY;
+
+        if (scale === 'log') {
+            minY = Math.pow(10, minY);
+            maxY = Math.pow(10, maxY);
+        }
+        byAxis.push({
+            minX,
+            maxX,
+            minY,
+            maxY
+        });
+    }
+
+    return () => {
+        return {
+            minX,
+            maxX,
+            byAxis
+        };
+    };
+}

package/src/state/bound_calculators.js

@@ -0,0 +1,41 @@
+const BOUND_CALCULATORS = {
+    all: () => {},
+    lastMinute: (globalBounds) => {
+        if (!globalBounds.dates) {
+            return;
+        }
+
+        return {
+            minX: Math.max(new Date(globalBounds.maxX).valueOf() - 60*1000, globalBounds.minX)
+        };
+    },
+    last10Minutes: (globalBounds) => {
+        if (!globalBounds.dates) {
+            return;
+        }
+
+        return {
+            minX: Math.max(new Date(globalBounds.maxX).valueOf() - 10*60*1000, globalBounds.minX)
+        };
+    },
+    lastHour: (globalBounds) => {
+        if (!globalBounds.dates) {
+            return;
+        }
+
+        return {
+            minX: Math.max(new Date(globalBounds.maxX).valueOf() - 60*60*1000, globalBounds.minX)
+        };
+    },
+    lastDay: (globalBounds) => {
+        if (!globalBounds.dates) {
+            return;
+        }
+
+        return {
+            minX: Math.max(new Date(globalBounds.maxX).valueOf() - 24*60*60*1000, globalBounds.minX)
+        };
+    }
+};
+
+export default BOUND_CALCULATORS;

package/src/state/calculate_annotations_state.js

@@ -0,0 +1,59 @@
+import nameForSeries from '../helpers/name_for_series.js';
+
+export default function calculateAnnotationsState({ annotations, series, sizing, selection }) {
+    const shownSeries = new Set(series.map((singleSeries, i) => {
+        return {
+            name: nameForSeries(singleSeries, i),
+            hidden: singleSeries.hidden
+        };
+    }).filter(({ hidden }) => !hidden).map(({ name }) => name));
+
+    const { elementWidth } = sizing;
+    const { minX, maxX } = selection;
+
+    const renderableAnnotations = annotations.filter((annotation) => {
+        if (!annotation.series) {
+            return true;
+        }
+
+        for (let seriesName of annotation.series) {
+            if (shownSeries.has(seriesName)) {
+                return true;
+            }
+        }
+
+        return false;
+    }).map((annotation) => {
+        let xAsNumber = annotation.x;
+        if (typeof xAsNumber === 'string') {
+            xAsNumber = new Date(xAsNumber).valueOf();
+        } else if (xAsNumber instanceof Date) {
+            xAsNumber = xAsNumber.valueOf();
+        }
+
+        let xEndAsNumber = annotation.xEnd || xAsNumber;
+        if (typeof xEndAsNumber === 'string') {
+            xEndAsNumber = new Date(xEndAsNumber).valueOf();
+        } else if (xEndAsNumber instanceof Date) {
+            xEndAsNumber = xEndAsNumber.valueOf();
+        }
+
+        const xStart = Math.min(xAsNumber, xEndAsNumber);
+        const xEnd = Math.max(xAsNumber, xEndAsNumber);
+
+        const pixelX = (xStart - minX)/(maxX - minX) * elementWidth;
+        const pixelEnd = (xEnd - minX)/(maxX - minX) * elementWidth;
+        const width = Math.max(pixelEnd - pixelX, 1);
+
+        return {
+            ...annotation,
+            pixelX,
+            width
+        };
+    });
+
+    return {
+        annotations: renderableAnnotations,
+        elementWidth
+    };
+}

package/src/state/calculate_data_bounds.js

@@ -0,0 +1,104 @@
+function finalizeBounds(bounds, { dates }) {
+    const initial = (bounds.minX === null && bounds.maxX === null) || bounds.minY === null || bounds.maxY === null;
+
+    for (let key of Object.keys(bounds)) {
+        if (typeof bounds[key] !== 'number') {
+            bounds[key] = 0;
+        }
+    }
+
+    bounds.initial = initial;
+    bounds.dates = dates;
+
+    return bounds;
+}
+
+function percentileBounds(inDataSpace, bounds, {percentile=100, percentileAsymmetry=0}={}) {
+    let dates = false;
+
+    bounds.minX = inDataSpace[0][0];
+    if (bounds.minX instanceof Date) {
+        bounds.minX = bounds.minX.valueOf();
+        dates = true;
+    }
+
+    bounds.maxX = inDataSpace[inDataSpace.length - 1][0];
+    if (bounds.maxX instanceof Date) {
+        bounds.maxX = bounds.maxX.valueOf();
+        dates = true;
+    }
+
+    const sortedByY = inDataSpace
+        .filter(([_x, y]) => typeof y === 'number')
+        .sort(([_x1, y1], [_x2, y2]) => y1 - y2);
+
+    if (!sortedByY.length) {
+        return finalizeBounds(bounds, {dates});
+    }
+
+    const asymmetry = Math.min(Math.abs(percentileAsymmetry), (100-percentile)/2) * (percentileAsymmetry < 0 ? -1 : 1);
+    const inBottomPercentile = (100-percentile)/2 + asymmetry;
+    const inTopPercentile = (100-percentile)/2 - asymmetry;
+
+    const startIndex = Math.floor((sortedByY.length-1)*inBottomPercentile/100);
+    const endIndex = Math.floor((sortedByY.length-1)*(100-inTopPercentile)/100);
+
+    bounds.minY = sortedByY[startIndex][1];
+    bounds.maxY = sortedByY[endIndex][1];
+
+    return finalizeBounds(bounds, {dates});
+}
+
+export default function calculateDataBounds(inDataSpace, {percentile=100, percentileAsymmetry=0}={}) {
+    let bounds = {
+        minX: null,
+        maxX: null,
+        minY: null,
+        maxY: null,
+        closestSpacing: null
+    };
+
+    if (percentile !== 100 && inDataSpace.length) {
+        return percentileBounds(inDataSpace, bounds, {percentile, percentileAsymmetry});
+    }
+
+    let dates = false;
+    let prevX = null;
+
+    for (let [x, y] of inDataSpace) {
+        if (x instanceof Date) {
+            x = x.valueOf();
+            dates = true;
+        }
+
+        if (typeof bounds.minX !== 'number' || x < bounds.minX) {
+            bounds.minX = x;
+        }
+
+        if (typeof bounds.maxX !== 'number' || x > bounds.maxX) {
+            bounds.maxX = x;
+        }
+
+        if (typeof prevX === 'number' && typeof x === 'number') {
+            const spacing = x - prevX;
+            if (typeof bounds.closestSpacing !== 'number' || spacing < bounds.closestSpacing) {
+                bounds.closestSpacing = spacing;
+            }
+        }
+        prevX = x;
+
+        if (typeof y !== 'number') {
+            continue;
+        }
+
+        if (typeof bounds.minY !== 'number' || y < bounds.minY) {
+            bounds.minY = y;
+        }
+
+        if (typeof bounds.maxY !== 'number' || y > bounds.maxY) {
+            bounds.maxY = y;
+        }
+    }
+
+    return finalizeBounds(bounds, {dates});
+}