@sjcrh/proteinpaint-rust 2.183.0 → 2.186.0

package/Cargo.toml

@@ -138,4 +138,8 @@ path="src/summary_agent.rs"
 
 [[bin]]
 name="dmrcate"
-path="src/dmrcate.rs"
+path="src/dmrcate.rs"
+
+[[bin]]
+name="volcano"
+path="src/volcano.rs"

package/package.json

@@ -1,5 +1,5 @@
 {
-	"version": "2.183.0",
+	"version": "2.186.0",
 	"name": "@sjcrh/proteinpaint-rust",
 	"type": "module",
 	"description": "Rust-based utilities for proteinpaint",

package/src/topGeneByExpressionVariance.rs

@@ -302,26 +302,33 @@ fn calculate_variance(
         min_sample_size = LARGE_N + (min_sample_size - LARGE_N) * MIN_PROP;
     }
 
-    let mut lib_sizes = Vec::<f64>::new();
-    let lib_sizes_vector = input_matrix.row_sum();
-    //println!("lib_sizes_vector:{:?}", lib_sizes_vector);
-    for i in 0..lib_sizes_vector.ncols() {
-        lib_sizes.push(lib_sizes_vector[(0, i)].into());
+    // Per-sample library sizes as nansum — a single NaN gene doesn't
+    // poison the whole sample's total.
+    let mut lib_sizes = Vec::<f64>::with_capacity(input_matrix.ncols());
+    for col in 0..input_matrix.ncols() {
+        let mut s = 0.0_f64;
+        for row in 0..input_matrix.nrows() {
+            let v = input_matrix[(row, col)];
+            if v.is_finite() {
+                s += v;
+            }
+        }
+        lib_sizes.push(s);
     }
-    //println!("lib_sizes:{:?}", lib_sizes);
-    //println!("min_sample_size:{}", min_sample_size);
+
     let median_lib_size = Data::new(lib_sizes.clone()).median();
     let cpm_cutoff = (min_count / median_lib_size) * 1000000.0;
     //println!("cpm_cutoff:{}", cpm_cutoff);
-    let cpm_matrix = cpm(&input_matrix);
+    let cpm_matrix = cpm(&input_matrix, &lib_sizes);
     const TOL: f64 = 1e-14; // Value of constant from R implementation
 
     let mut gene_infos = Vec::<GeneInfo>::new();
-    let row_sums = input_matrix.column_sum();
     for row in 0..input_matrix.nrows() {
         let mut trues = 0.0;
+        // CPM filter (NaN-safe)
         for col in 0..cpm_matrix.ncols() {
-            if cpm_matrix[(row, col)] >= cpm_cutoff {
+            let v = cpm_matrix[(row, col)];
+            if v.is_finite() && v >= cpm_cutoff {
                 trues += 1.0;
             }
         }
@@ -332,17 +339,32 @@ fn calculate_variance(
             //positive_cpm += 1;
         }
 
+        let mut row_sum_finite = 0.0_f64;
+        for col in 0..input_matrix.ncols() {
+            let v = input_matrix[(row, col)];
+            if v.is_finite() {
+                row_sum_finite += v;
+            }
+        }
         let mut keep_total_bool = false;
-        if row_sums[(row, 0)] as f64 >= min_total_count - TOL {
+        if row_sum_finite >= min_total_count - TOL {
             keep_total_bool = true;
-            //keep_total.push(keep_total_bool);
-            //positive_total += 1;
         }
 
         let mut gene_counts: Vec<f64> = Vec::with_capacity(input_matrix.ncols());
         for col in 0..input_matrix.ncols() {
-            gene_counts.push(input_matrix[(row, col)]);
+            let v = input_matrix[(row, col)];
+            if v.is_finite() {
+                gene_counts.push(v);
+            }
+        }
+
+        // Skip genes with too few observations to produce a stable statistic
+        let min_required = if rank_type == "var" { 2 } else { 4 };
+        if gene_counts.len() < min_required {
+            continue;
         }
+
         if rank_type == "var" {
             // Calculating variance
             if gene_counts.clone().variance().is_nan() == true {
@@ -382,21 +404,21 @@ fn calculate_variance(
 
 fn cpm(
     input_matrix: &Matrix<f64, Dyn, Dyn, VecStorage<f64, Dyn, Dyn>>,
+    col_sums: &[f64],
 ) -> Matrix<f64, Dyn, Dyn, VecStorage<f64, Dyn, Dyn>> {
-    //let mut blank = Vec::<f64>::new();
-    let mut blank = Vec::with_capacity(input_matrix.nrows() * input_matrix.ncols());
-    for _i in 0..input_matrix.nrows() * input_matrix.ncols() {
-        blank.push(0.0);
-    }
-    let mut output_matrix = DMatrix::from_vec(input_matrix.nrows(), input_matrix.ncols(), blank);
-    let column_sums = input_matrix.row_sum();
+    let mut output_matrix = DMatrix::from_element(input_matrix.nrows(), input_matrix.ncols(), 0.0);
+
     for col in 0..input_matrix.ncols() {
-        let norm_factor = column_sums[(0, col)];
+        let norm = col_sums[col];
         for row in 0..input_matrix.nrows() {
-            output_matrix[(row, col)] = (input_matrix[(row, col)] as f64 * 1000000.0) / norm_factor as f64;
+            let v = input_matrix[(row, col)];
+            output_matrix[(row, col)] = if v.is_finite() && norm > 0.0 {
+                v * 1_000_000.0 / norm
+            } else {
+                f64::NAN
+            };
         }
     }
-    //println!("output_matrix:{:?}", output_matrix);
     output_matrix
 }
 

package/src/volcano.rs

@@ -0,0 +1,314 @@
+// Server-side volcano plot renderer.
+//
+// Reads all DA rows + significance thresholds + render params on stdin (JSON),
+// rasterizes the full scatter to a base64 PNG, and in the same pass emits the
+// threshold-passing rows back sorted ascending by the chosen p-value column.
+// This makes the Rust pass the single source of truth for both the colored
+// dots in the PNG and the interactive top-significant overlay on the client.
+
+use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64};
+use plotters::prelude::*;
+use plotters::style::ShapeStyle;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use std::error::Error;
+use std::io::{self, Read};
+
+#[derive(Deserialize)]
+struct Input {
+    /// DA rows; each must carry fold_change + original_p_value + adjusted_p_value.
+    /// Route-specific extras (gene_name, promoter_id, etc.) are preserved via Value.
+    rows: Vec<Value>,
+    /// "adjusted" or "original" — which p-value column to threshold and sort by.
+    p_value_type: String,
+    /// Cutoff on the -log10 scale.
+    p_value_cutoff: f64,
+    /// Log2 fold-change magnitude cutoff.
+    fold_change_cutoff: f64,
+    pixel_width: u32,
+    pixel_height: u32,
+    color_significant: String,
+    color_significant_up: Option<String>,
+    color_significant_down: Option<String>,
+    color_nonsignificant: String,
+    dot_radius: f64,
+    /// Optional cap on the returned `dots`. The PNG still shows every row;
+    /// only the overlay list is truncated to the most-significant N.
+    #[serde(default)]
+    max_interactive_dots: Option<usize>,
+}
+
+#[derive(Serialize)]
+struct PlotExtent {
+    /// Padded data extents — used to position overlay dots so points near the
+    /// real-data edge stay fully visible (mirror of manhattan's yPlot domain).
+    x_min: f64,
+    x_max: f64,
+    y_min: f64,
+    y_max: f64,
+    /// Unpadded data extents — used for the visible axis labels/ticks so the
+    /// axis only spans the real data region (mirror of manhattan's yAxisScale).
+    x_min_unpadded: f64,
+    x_max_unpadded: f64,
+    y_min_unpadded: f64,
+    y_max_unpadded: f64,
+    /// Dot radius in pixels (echoed back so the client can size overlay rings
+    /// to match the PNG without recomputing the heuristic).
+    dot_radius_px: f64,
+    pixel_width: u32,
+    pixel_height: u32,
+    /// Inner drawing rect inside the PNG. Client overlay circles are
+    /// positioned against this rect, not the full canvas.
+    plot_left: i32,
+    plot_top: i32,
+    plot_right: i32,
+    plot_bottom: i32,
+    /// Smallest non-zero p observed; rows with p==0 were positioned at
+    /// -log10(min_nonzero_p) so the client must reuse this cap to align.
+    min_nonzero_p: f64,
+}
+
+#[derive(Serialize)]
+struct Output {
+    png: String,
+    plot_extent: PlotExtent,
+    /// Threshold-passing rows, sorted asc by the chosen p-value column. These
+    /// are the only rows sent back — the PNG carries every row.
+    dots: Vec<Value>,
+    /// Total rows rendered into the PNG; used client-side for stats.
+    total_rows: usize,
+    /// Total rows that passed the significance thresholds, before any
+    /// `max_interactive_dots` truncation. Use this for "% significant" stats.
+    total_significant_rows: usize,
+}
+
+fn rgb(hex: &str, fallback: (u8, u8, u8)) -> RGBColor {
+    let h = hex.trim_start_matches('#');
+    let parse = |i: usize| u8::from_str_radix(&h.get(i..i + 2).unwrap_or(""), 16).ok();
+    match (h.len(), parse(0), parse(2), parse(4)) {
+        (6, Some(r), Some(g), Some(b)) => RGBColor(r, g, b),
+        _ => RGBColor(fallback.0, fallback.1, fallback.2),
+    }
+}
+
+struct Point {
+    idx: usize,
+    fc: f64,
+    /// raw p-value (used for sorting)
+    p: f64,
+    /// -log10(p) with p==0 capped to min_nonzero_p
+    y: f64,
+    significant: bool,
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+    io::stdin().read_to_string(&mut buf)?;
+    let input: Input = serde_json::from_str(&buf)?;
+
+    let p_field = match input.p_value_type.as_str() {
+        "adjusted" => "adjusted_p_value",
+        "original" => "original_p_value",
+        other => return Err(format!("invalid p_value_type: {other}").into()),
+    };
+
+    // One pass: pull numeric summaries and find the smallest non-zero p so we
+    // can cap y for rows with p == 0 (matching the client behavior).
+    let mut points: Vec<Point> = Vec::with_capacity(input.rows.len());
+    let mut min_nonzero_p = f64::INFINITY;
+    for (idx, row) in input.rows.iter().enumerate() {
+        let fc = row
+            .get("fold_change")
+            .and_then(|v| v.as_f64())
+            .ok_or_else(|| format!("row {idx} missing numeric fold_change"))?;
+        if !fc.is_finite() {
+            return Err(format!("row {idx} fold_change is not finite ({fc})").into());
+        }
+        let p = row
+            .get(p_field)
+            .and_then(|v| v.as_f64())
+            .ok_or_else(|| format!("row {idx} missing numeric {p_field}"))?;
+        if !p.is_finite() || p < 0.0 {
+            return Err(format!("row {idx} {p_field} must be a finite value >= 0 (got {p})").into());
+        }
+        if p > 0.0 && p < min_nonzero_p {
+            min_nonzero_p = p;
+        }
+        points.push(Point {
+            idx,
+            fc,
+            p,
+            y: 0.0,
+            significant: false,
+        });
+    }
+    if !min_nonzero_p.is_finite() {
+        min_nonzero_p = 1e-300;
+    }
+
+    // Classify + compute y; track axis extents in the same pass.
+    let (mut x_abs_max, mut y_max_data) = (0f64, 0f64);
+    for pt in points.iter_mut() {
+        let p_for_y = if pt.p <= 0.0 { min_nonzero_p } else { pt.p };
+        pt.y = -p_for_y.log10();
+        pt.significant = pt.y > input.p_value_cutoff && pt.fc.abs() > input.fold_change_cutoff;
+        x_abs_max = x_abs_max.max(pt.fc.abs());
+        y_max_data = y_max_data.max(pt.y);
+    }
+
+    // Unpadded axis extents — symmetric on x, raw data bounds. The dot-radius
+    // pad below provides pixel-level headroom so we don't need extra data-range
+    // breathing room (mirrors manhattan_plot.rs's tighter feel). Fallback to 1.0
+    // when the data has zero spread to keep the chart range valid.
+    let x_span = if x_abs_max > 0.0 { x_abs_max } else { 1.0 };
+    let (x_min_unpadded, x_max_unpadded) = (-x_span, x_span);
+    let y_min_unpadded = 0f64;
+    let y_max_unpadded = if y_max_data > 0.0 { y_max_data } else { 1.0 };
+
+    // Normalize the dot radius once into the integer pixel count plotters will
+    // actually draw, with a min of 1 so sub-pixel inputs don't collapse to a
+    // zero-radius dot. This single value drives both PNG padding and circle
+    // rendering, keeping the geometry self-consistent (matches manhattan).
+    let radius_px = (input.dot_radius as i32).max(1);
+    // Pad PNG by 2*radius_px so dots near the data edges stay fully visible.
+    let pad_px = (2 * radius_px) as u32;
+    let (w, h) = (input.pixel_width + pad_px, input.pixel_height + pad_px);
+    if w == 0 || h == 0 || w > 4000 || h > 4000 {
+        return Err(format!("pixel dimensions {}x{} out of range (1–4000)", w, h).into());
+    }
+
+    // Convert pixel padding to data units using the unpadded extents and the
+    // unpadded pixel dimensions. Per-axis pad in data space = radius_px * (data
+    // range / pixel range) — keeps the data/pixel ratio identical between
+    // padded and unpadded space.
+    let x_data_per_px = (x_max_unpadded - x_min_unpadded) / input.pixel_width as f64;
+    let y_data_per_px = (y_max_unpadded - y_min_unpadded) / input.pixel_height as f64;
+    let x_pad_data = radius_px as f64 * x_data_per_px;
+    let y_pad_data = radius_px as f64 * y_data_per_px;
+    let x_min = x_min_unpadded - x_pad_data;
+    let x_max = x_max_unpadded + x_pad_data;
+    let y_min = y_min_unpadded - y_pad_data;
+    let y_max = y_max_unpadded + y_pad_data;
+    let mut buffer = vec![0u8; (w as usize) * (h as usize) * 3];
+    // Per-point pixel coords as plotters actually rasterizes them. Returned to
+    // the client so the SVG overlay rings sit exactly on top of the PNG dots
+    // instead of being recomputed from data coords (which loses sub-pixel
+    // precision under plotters' integer truncation).
+    let mut all_pixel_coords: Vec<(f64, f64)> = Vec::with_capacity(points.len());
+    {
+        let backend = BitMapBackend::with_buffer(&mut buffer, (w, h));
+        let root = backend.into_drawing_area();
+        root.fill(&WHITE)?;
+
+        let mut chart = ChartBuilder::on(&root)
+            .margin(0)
+            .set_all_label_area_size(0)
+            .build_cartesian_2d(x_min..x_max, y_min..y_max)?;
+        chart
+            .configure_mesh()
+            .disable_x_mesh()
+            .disable_y_mesh()
+            .disable_axes()
+            .draw()?;
+
+        // Threshold guide lines are drawn by the SVG overlay on the client, not
+        // here — double-drawing them would add stray lines offset by axis padding.
+
+        // Resolve colors once. Up/down fall back to `color_sig` when absent.
+        let color_sig = rgb(&input.color_significant, (214, 39, 40));
+        let color_non = rgb(&input.color_nonsignificant, (0, 0, 0));
+        let resolve = |o: &Option<String>| o.as_deref().map(|s| rgb(s, (214, 39, 40))).unwrap_or(color_sig);
+        let color_up = resolve(&input.color_significant_up);
+        let color_down = resolve(&input.color_significant_down);
+
+        // Stroke-only rings at full opacity so each ring is the exact configured
+        // group color — matching the hue the SVG overlay uses.
+        let ring = |c: RGBColor| ShapeStyle {
+            color: c.into(),
+            filled: false,
+            stroke_width: 1,
+        };
+
+        // Draw non-significant first so significant rings overlay on top.
+        chart.draw_series(
+            points
+                .iter()
+                .filter(|p| !p.significant)
+                .map(|p| Circle::new((p.fc, p.y), radius_px, ring(color_non))),
+        )?;
+        chart.draw_series(points.iter().filter(|p| p.significant).map(|p| {
+            let c = if p.fc > 0.0 { color_up } else { color_down };
+            Circle::new((p.fc, p.y), radius_px, ring(c))
+        }))?;
+
+        // Mirror manhattan_plot.rs: capture the exact pixel coords plotters
+        // used for each point so the client overlay can land on them precisely.
+        for p in points.iter() {
+            let (px, py) = chart.backend_coord(&(p.fc, p.y));
+            all_pixel_coords.push((px as f64, py as f64));
+        }
+
+        root.present()?;
+    }
+
+    // Build the interactive `dots` list: threshold-passers sorted asc by the
+    // chosen p-value column, optionally capped at `max_interactive_dots`.
+    let mut sig_points: Vec<&Point> = points.iter().filter(|p| p.significant).collect();
+    sig_points.sort_by(|a, b| a.p.partial_cmp(&b.p).unwrap_or(std::cmp::Ordering::Equal));
+    let total_significant_rows = sig_points.len();
+    if let Some(cap) = input.max_interactive_dots {
+        sig_points.truncate(cap);
+    }
+    let dots: Vec<Value> = sig_points
+        .iter()
+        .map(|p| {
+            let mut row = input.rows[p.idx].clone();
+            let (px, py) = all_pixel_coords[p.idx];
+            if let Value::Object(ref mut m) = row {
+                m.insert("pixel_x".to_string(), Value::from(px));
+                m.insert("pixel_y".to_string(), Value::from(py));
+            }
+            row
+        })
+        .collect();
+
+    let output = Output {
+        png: BASE64.encode(&encode_rgb_to_png(&buffer, w, h)?),
+        plot_extent: PlotExtent {
+            x_min,
+            x_max,
+            y_min,
+            y_max,
+            x_min_unpadded,
+            x_max_unpadded,
+            y_min_unpadded,
+            y_max_unpadded,
+            // Echo the normalized integer radius plotters actually drew so the
+            // SVG overlay sizes its rings to match the rasterized PNG dots.
+            dot_radius_px: radius_px as f64,
+            pixel_width: w,
+            pixel_height: h,
+            plot_left: 0,
+            plot_top: 0,
+            plot_right: w as i32,
+            plot_bottom: h as i32,
+            min_nonzero_p,
+        },
+        dots,
+        total_rows: input.rows.len(),
+        total_significant_rows,
+    };
+
+    println!("{}", serde_json::to_string(&output)?);
+    Ok(())
+}
+
+/// Convert a plotters RGB buffer (3 bytes/px) to a PNG via tiny-skia (4 bytes/px).
+fn encode_rgb_to_png(rgb: &[u8], w: u32, h: u32) -> Result<Vec<u8>, Box<dyn Error>> {
+    let mut pixmap = tiny_skia::Pixmap::new(w, h).ok_or("failed to create pixmap")?;
+    for (src, dst) in rgb.chunks_exact(3).zip(pixmap.data_mut().chunks_exact_mut(4)) {
+        dst[..3].copy_from_slice(src);
+        dst[3] = 255;
+    }
+    Ok(pixmap.encode_png()?)
+}