@sjcrh/proteinpaint-rust 2.190.0 → 2.191.1

package/Cargo.toml

@@ -119,14 +119,6 @@ path="src/cerno.rs"
 name="readH5"
 path="src/readH5.rs"
 
-[[bin]]
-name="manhattan_plot"
-path="src/manhattan_plot.rs"
-
 [[bin]]
 name="dmrcate"
 path="src/dmrcate.rs"
-
-[[bin]]
-name="volcano"
-path="src/volcano.rs"

package/index.js

@@ -86,7 +86,7 @@ export function run_rust(binfile, input_data, args = [], { signal } = {}) {
 // May need to add an abort signal as argument like in run_rust above.
 // Or it's likely not needed since a closed stream connection from a web browser
 // will already trigger an error. `stream_rust()` was heavily tested manually
-// while troubleshooting and fixing the idle rust processes the led to memory leacks
+// while troubleshooting and fixing the idle rust processes the led to memory leaks
 // as part of `/gdc/mafBuild` handler code, leave this code as-is for now.
 export function stream_rust(binfile, input_data, emitJson) {
 	const binpath = path.join(__dirname, '/target/release/', binfile)

package/package.json

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

package/src/manhattan_plot.rs

@@ -1,687 +0,0 @@
-use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64};
-use plotters::prelude::*;
-use plotters::style::ShapeStyle;
-use serde::{Deserialize, Serialize};
-use serde_json;
-use std::collections::{HashMap, HashSet};
-use std::convert::TryInto;
-use std::error::Error;
-use std::fs::File;
-use std::io::{self, BufReader};
-use tiny_skia::{FillRule, PathBuilder, Pixmap, Transform};
-
-// Define the JSON input structure
-#[derive(Deserialize, Debug)]
-struct Input {
-    file: String,
-    #[serde(rename = "type")]
-    plot_type: String,
-    #[serde(rename = "chrSizes")]
-    chromosomelist: HashMap<String, u64>,
-    plot_width: u64,
-    plot_height: u64,
-    device_pixel_ratio: f64,
-    png_dot_radius: u64,
-    max_capped_points: u64,
-    hard_cap: f64,
-    bin_size: f64,
-    q_value_threshold: f64,
-}
-
-// chromosome info
-#[derive(Serialize)]
-struct ChromInfo {
-    start: u64,
-    size: u64,
-    center: u64,
-}
-
-#[derive(Serialize)]
-struct PointDetail {
-    x: u64,
-    y: f64,
-    color: String,
-    r#type: String,
-    gene: String,
-    chrom: String,
-    start: u64,
-    end: u64,
-    pos: u64,
-    q_value: f64,
-    nsubj: Option<i64>,
-    pixel_x: f64,
-    pixel_y: f64,
-}
-
-#[derive(Serialize)]
-struct InteractiveData {
-    points: Vec<PointDetail>,
-    chrom_data: HashMap<String, ChromInfo>,
-    total_genome_length: i64,
-    x_buffer: i64,
-    y_min: f64,
-    y_max: f64,
-    device_pixel_ratio: f64,
-    default_log_cutoff: f64,
-    has_capped_points: bool,
-}
-
-#[derive(Serialize)]
-struct Output {
-    png: String,
-    plot_data: InteractiveData,
-}
-
-// Helper function to convert hex color to RGB
-fn hex_to_rgb(hex: &str) -> Option<(u8, u8, u8)> {
-    let hex = hex.trim_start_matches('#');
-    if hex.len() != 6 {
-        return None;
-    }
-    let r = u8::from_str_radix(&hex[0..2], 16).ok()?;
-    let g = u8::from_str_radix(&hex[2..4], 16).ok()?;
-    let b = u8::from_str_radix(&hex[4..6], 16).ok()?;
-    Some((r, g, b))
-}
-
-// Helper function to calculate default log cutoff value from the data coming from GRIN2 file
-// We just find the mean of the -log10 q-values that are below the hard cap and
-// set it as the default log cutoff. If the mean is less than 40, we set it to 40.
-// If it is too low it can cause an error in the setting up of the histogram bins in the dynamic y-cap calculation.
-// The exclude_indices parameter allows us to skip placeholder values (e.g., 0.0 placeholders for zero q-values)
-// that would otherwise contaminate the mean calculation.
-fn get_log_cutoff(ys: &[f64], hard_cap: f64, exclude_indices: &HashSet<usize>) -> f64 {
-    let filtered: Vec<f64> = ys
-        .iter()
-        .enumerate()
-        .filter(|(i, &y)| y < hard_cap && !exclude_indices.contains(i))
-        .map(|(_, &y)| y)
-        .collect();
-    let count = filtered.len();
-    let sum: f64 = filtered.iter().sum();
-
-    // If all values are greater than or equal to hard_cap (or excluded), default to hard_cap
-    if filtered.is_empty() {
-        return hard_cap;
-    }
-    let mean = sum / count as f64;
-
-    mean.max(40.0)
-}
-
-/// Calculates a dynamic y-axis cap for Manhattan plots to handle outliers gracefully.
-///
-/// # Problem
-/// Manhattan plots often have a few extreme outliers (very significant p-values) that
-/// compress the visual range for the majority of points. This function finds an optimal
-/// y-axis cap that:
-/// - Shows most data at true scale
-/// - Caps only a small number of extreme outliers
-/// - Ensures visible outliers (below hard cap) render at their true positions
-///
-/// # Algorithm
-/// 1. **No outliers**: If `max_y <= default_cap`, return `max_y` (no capping needed)
-/// 2. **Histogram binning**: Partition the range `(default_cap, hard_cap]` into fixed-size bins
-/// 3. **Walk up**: Starting from the lowest bin, find the first cap where at most
-///    `max_capped_points` would be clamped
-/// 4. **Preserve visible outliers**: Ensure the chosen cap is above the highest y-value
-///    that falls below `hard_cap`, so those points render at their true positions
-///
-/// # Parameters
-/// - `ys`: All y-values (-log10 q-values) in the plot
-/// - `max_capped_points`: Maximum points allowed to be clamped to the cap (e.g., 5)
-/// - `default_cap`: Starting threshold; points below this are never capped (e.g., whatever log_cutoff is calculated to be from get_log_cutoff)
-/// - `hard_cap`: Absolute maximum y-axis value; points above are always clamped (e.g., 200)
-/// - `bin_size`: Histogram bin width on -log10 scale (e.g., 10)
-///
-/// # Returns
-/// The optimal y-axis cap, guaranteed to be in the range `[max_y.min(default_cap), hard_cap]`
-///
-/// # Example
-/// With `default_cap=40`, `hard_cap=200`, `bin_size=10`, `max_capped_points=5`:
-/// - If 7 points are above 40, with two at 83 and 183 and five at/above 200:
-///   Returns 200, so the points at 83 and 183 display at their true positions while
-///   the 5 extreme outliers are clamped to 200
-fn calculate_dynamic_y_cap(
-    ys: &[f64],
-    max_capped_points: usize,
-    default_cap: f64,
-    hard_cap: f64,
-    bin_size: f64,
-) -> f64 {
-    let mut num_bins = ((hard_cap - default_cap) / bin_size) as usize;
-    if num_bins == 0 {
-        // Have to make sure num_bins is positive to avoid issues with histogram later
-        num_bins = 1;
-    }
-    let mut histogram = vec![0usize; num_bins];
-    let mut max_y = f64::NEG_INFINITY;
-    let mut max_y_below_hard_cap = f64::NEG_INFINITY; // Track highest value that's not hard-capped
-    let mut points_above_default = 0usize;
-
-    // Single pass: find max and build histogram simultaneously
-    for &y in ys {
-        if y > max_y {
-            max_y = y;
-        }
-        if y > default_cap {
-            points_above_default += 1;
-            if y > hard_cap {
-                histogram[num_bins - 1] += 1;
-            } else {
-                // Track the max y that's at or below the hard cap
-                if y > max_y_below_hard_cap {
-                    max_y_below_hard_cap = y;
-                }
-                let bin_idx = ((y - default_cap) / bin_size) as usize;
-                histogram[bin_idx] += 1;
-            }
-        }
-    }
-
-    // Case 1: No points exceed default cap - use actual max
-    if max_y <= default_cap {
-        return max_y;
-    }
-
-    // Walk up from default_cap to hard_cap
-    let mut points_above = points_above_default;
-
-    for (i, &count) in histogram.iter().enumerate() {
-        if points_above <= max_capped_points {
-            // Found acceptable number of capped points
-            let bin_upper_bound = default_cap + ((i + 1) as f64) * bin_size;
-
-            // The cap should be:
-            // 1. At least above max_y_below_hard_cap (so those points render at true position)
-            // 2. At most hard_cap
-            // 3. But if all outliers are at/above hard_cap, use the bin boundary
-            let cap = if max_y_below_hard_cap > bin_upper_bound {
-                // There's a visible outlier above this bin - extend cap to show it
-                (max_y_below_hard_cap + bin_size).min(hard_cap)
-            } else {
-                bin_upper_bound.min(hard_cap)
-            };
-
-            return cap;
-        }
-        points_above -= count;
-    }
-
-    // All points are hard-capped outliers
-    hard_cap
-}
-
-// Function to Build cumulative chromosome map
-fn cumulative_chrom(
-    chrom_size: &HashMap<String, u64>,
-) -> Result<(HashMap<String, ChromInfo>, u64, Vec<String>), Box<dyn Error>> {
-    let mut chrom_data: HashMap<String, ChromInfo> = HashMap::new();
-    let mut cumulative_pos: u64 = 0;
-
-    // Sort chromosomes
-    let mut sorted_chroms: Vec<String> = chrom_size.keys().cloned().collect();
-    sorted_chroms.sort_by_key(|chr| {
-        let s = chr.trim_start_matches("chr");
-        match s.parse::<u32>() {
-            Ok(n) => (0, n),
-            Err(_) => match s {
-                "X" => (1, 23),
-                "Y" => (1, 24),
-                "M" | "MT" => (1, 100),
-                _ => (2, u32::MAX),
-            },
-        }
-    });
-
-    for chrom in &sorted_chroms {
-        if let Some(&size) = chrom_size.get(chrom) {
-            chrom_data.insert(
-                chrom.clone(),
-                ChromInfo {
-                    start: cumulative_pos,
-                    size: size,
-                    center: cumulative_pos + size / 2,
-                },
-            );
-            cumulative_pos += size;
-        }
-    }
-    Ok((chrom_data, cumulative_pos, sorted_chroms))
-}
-
-// Envelope JSON written by the server (Grin2Envelope). Rust only needs
-// the geneHits rows from resultData; serde ignores other fields.
-#[derive(Deserialize)]
-struct Grin2Envelope {
-    #[serde(rename = "resultData")]
-    result_data: Grin2ResultData,
-}
-
-#[derive(Deserialize)]
-struct Grin2ResultData {
-    #[serde(rename = "geneHits")]
-    gene_hits: Vec<HashMap<String, serde_json::Value>>,
-}
-
-// Function to read the GRIN2 envelope JSON (grin2/{cacheid}.json) and
-// extract per-gene-per-mutation-type points for the Manhattan plot.
-fn grin2_file_read(
-    grin2_file: &str,
-    chrom_data: &HashMap<String, ChromInfo>,
-    q_value_threshold: f64,
-) -> Result<
-    (
-        Vec<u64>,
-        Vec<f64>,
-        Vec<String>,
-        Vec<PointDetail>,
-        Vec<usize>,
-        Vec<usize>,
-    ),
-    Box<dyn Error>,
-> {
-    // Default colours
-    let mut colors: HashMap<String, String> = HashMap::new();
-    colors.insert("gain".into(), "#FF4444".into());
-    colors.insert("loss".into(), "#4444FF".into());
-    colors.insert("mutation".into(), "#44AA44".into());
-    colors.insert("fusion".into(), "#FFA500".into());
-    colors.insert("sv".into(), "#9932CC".into());
-
-    let mut xs = Vec::new();
-    let mut ys = Vec::new();
-    let mut colors_vec = Vec::new();
-    let mut point_details = Vec::new();
-    let mut sig_indices: Vec<usize> = Vec::new();
-    let mut zero_q_indices: Vec<usize> = Vec::new();
-
-    let f = File::open(grin2_file).expect("Failed to open grin2 envelope file");
-    let envelope: Grin2Envelope =
-        serde_json::from_reader(BufReader::new(f)).expect("Failed to parse grin2 envelope JSON");
-    let gene_hits = envelope.result_data.gene_hits;
-
-    let mutation_types = ["gain", "loss", "mutation", "fusion", "sv"];
-
-    let mut mut_num: usize = 0;
-    for row in &gene_hits {
-        let chrom = match row.get("chrom").and_then(|v| v.as_str()) {
-            Some(s) if !s.is_empty() => s,
-            _ => continue,
-        };
-        let chrom_info = match chrom_data.get(chrom) {
-            Some(info) => info,
-            None => continue,
-        };
-        let gene_name = row.get("gene").and_then(|v| v.as_str()).unwrap_or("").to_string();
-        let gene_start: u64 = match row.get("loc.start").and_then(|v| v.as_u64()) {
-            Some(n) => n,
-            None => continue,
-        };
-        let gene_end: u64 = match row.get("loc.end").and_then(|v| v.as_u64()) {
-            Some(n) => n,
-            None => continue,
-        };
-        let x_pos = chrom_info.start + gene_start;
-
-        for mtype in &mutation_types {
-            let q_key = format!("q.nsubj.{mtype}");
-            let original_q_val: f64 = match row.get(&q_key).and_then(|v| v.as_f64()) {
-                Some(v) if v >= 0.0 => v,
-                _ => continue,
-            };
-
-            // Use a placeholder for zero q-values - these will be updated later
-            // after we calculate the dynamic y_cap from the full dataset
-            let neg_log10_q = if original_q_val == 0.0 {
-                zero_q_indices.push(mut_num);
-                0.0 // Placeholder - will be set to y_cap later in plot_grin2_manhattan
-            } else {
-                -original_q_val.log10()
-            };
-
-            let n_key = format!("nsubj.{mtype}");
-            let n_subj_count: Option<i64> = row.get(&n_key).and_then(|v| v.as_i64());
-            let color = colors.get(*mtype).unwrap_or(&"#888888".to_string()).clone();
-            // Add to plotting vectors
-            xs.push(x_pos);
-            ys.push(neg_log10_q);
-            colors_vec.push(color.clone());
-
-            // only add significant points for interactivity
-            // We check against the original q-value here so we send back the correct values instead of the 1e-300 used for log transform
-            if original_q_val <= q_value_threshold {
-                point_details.push(PointDetail {
-                    x: x_pos,
-                    y: neg_log10_q,
-                    color,
-                    r#type: mtype.to_string(),
-                    gene: gene_name.clone(),
-                    chrom: chrom.to_string(),
-                    start: gene_start,
-                    end: gene_end,
-                    pos: gene_start,
-                    q_value: original_q_val,
-                    nsubj: n_subj_count,
-                    pixel_x: 0.0,
-                    pixel_y: 0.0,
-                });
-                sig_indices.push(mut_num);
-            };
-            mut_num += 1;
-        }
-    }
-
-    Ok((xs, ys, colors_vec, point_details, sig_indices, zero_q_indices))
-}
-
-// Function to create the GRIN2 Manhattan plot
-fn plot_grin2_manhattan(
-    grin2_result_file: String,
-    chrom_size: HashMap<String, u64>,
-    plot_width: u64,
-    plot_height: u64,
-    device_pixel_ratio: f64,
-    png_dot_radius: u64,
-    bin_size: f64,
-    max_capped_points: u64,
-    hard_cap: f64,
-    q_value_threshold: f64,
-) -> Result<(String, InteractiveData), Box<dyn Error>> {
-    // ------------------------------------------------
-    // 1. Build cumulative chromosome map
-    // ------------------------------------------------
-
-    let mut chrom_data: HashMap<String, ChromInfo> = HashMap::new();
-    let mut cumulative_pos: u64 = 0;
-    let mut sorted_chroms: Vec<String> = Vec::new();
-
-    if let Ok((chr_data, cum_pos, chrom_sort)) = cumulative_chrom(&chrom_size) {
-        chrom_data = chr_data;
-        cumulative_pos = cum_pos;
-        sorted_chroms = chrom_sort;
-    };
-    let total_genome_length: i64 = cumulative_pos.try_into().unwrap();
-    let x_buffer = (total_genome_length as f64 * 0.005) as i64; // 0.5 % buffer
-
-    // ------------------------------------------------
-    // 2. Read file & collect points
-    // ------------------------------------------------
-
-    // Declare all data
-    let mut xs = Vec::new();
-    let mut ys = Vec::new();
-    let mut colors_vec = Vec::new();
-    let mut point_details = Vec::new();
-    let mut sig_indices = Vec::new();
-    let mut zero_q_indices: Vec<usize> = Vec::new();
-
-    if let Ok((x, y, c, pd, si, zq)) = grin2_file_read(&grin2_result_file, &chrom_data, q_value_threshold) {
-        xs = x;
-        ys = y;
-        colors_vec = c;
-        point_details = pd;
-        sig_indices = si;
-        zero_q_indices = zq;
-    }
-
-    // ------------------------------------------------
-    // 3. Calculate log_cutoff from data and update zero q-values
-    // ------------------------------------------------
-    // Convert zero_q_indices to HashSet for O(1) lookup when excluding placeholders
-    let zero_q_set: HashSet<usize> = zero_q_indices.iter().cloned().collect();
-    let log_cutoff = get_log_cutoff(&ys, hard_cap, &zero_q_set);
-
-    // ------------------------------------------------
-    // 4. Y-axis capping with dynamic cap
-    // ------------------------------------------------
-    let y_padding = png_dot_radius as f64;
-    let y_min = 0.0 - y_padding;
-
-    // Dynamic y-cap calculation:
-    // - log_cutoff: the baseline cap (calculated from data mean)
-    // - max_capped_points: maximum number of points allowed above cap before raising it
-    // - hard_cap: absolute maximum cap regardless of data distribution
-    // - bin_size: size of bins for histogram approach
-    let max_capped_points = max_capped_points as usize;
-
-    let y_cap = calculate_dynamic_y_cap(&ys, max_capped_points, log_cutoff, hard_cap, bin_size);
-
-    let (y_max, has_capped_points) = if !ys.is_empty() {
-        let max_y = ys.iter().cloned().fold(f64::MIN, f64::max);
-
-        // has_capped_points is true if any points exceed the default cap (log_cutoff)
-        let has_capped = max_y > log_cutoff;
-
-        // Set q=0 points (currently placeholders at 0.0) to y_cap so they appear at the top
-        for &idx in &zero_q_indices {
-            ys[idx] = y_cap;
-        }
-        for p in point_details.iter_mut() {
-            if p.q_value == 0.0 {
-                p.y = y_cap;
-            }
-        }
-
-        if max_y > y_cap {
-            // Clamp values above the cap
-            for y in ys.iter_mut() {
-                if *y > y_cap {
-                    *y = y_cap;
-                }
-            }
-            for p in point_details.iter_mut() {
-                if p.y > y_cap {
-                    p.y = y_cap;
-                }
-            }
-            (y_cap + 0.35 + y_padding, has_capped)
-        } else {
-            (max_y + 0.35 + y_padding, has_capped)
-        }
-    } else {
-        (1.0 + y_padding, false)
-    };
-
-    // ------------------------------------------------
-    // 4. Setup high-DPR bitmap dimensions
-    // ------------------------------------------------
-
-    let dpr = device_pixel_ratio.max(1.0);
-
-    let png_width = plot_width + 2 * png_dot_radius;
-    let png_height = plot_height + 2 * png_dot_radius;
-
-    let w: u32 = ((png_width as f64) * dpr) as u32;
-    let h: u32 = ((png_height as f64) * dpr) as u32;
-
-    // Create RGB buffer for Plotters
-    let mut buffer = vec![0u8; w as usize * h as usize * 3];
-
-    // Make Plotters backend that draws into the RGB buffer (scale-aware)
-
-    let mut pixel_positions: Vec<(f64, f64)> = Vec::with_capacity(xs.len());
-    {
-        let backend = BitMapBackend::with_buffer(&mut buffer, (w, h));
-        let root = backend.into_drawing_area();
-        root.fill(&WHITE)?;
-
-        // ------------------------------------------------
-        // 5. Build the chart (no axes, no margins)
-        // ------------------------------------------------
-        let mut chart = ChartBuilder::on(&root)
-            .margin(0)
-            .set_all_label_area_size(0)
-            .build_cartesian_2d((-x_buffer)..(total_genome_length + x_buffer), y_min..y_max)?;
-
-        chart
-            .configure_mesh()
-            .disable_x_mesh()
-            .disable_y_mesh()
-            .disable_axes()
-            .draw()?;
-
-        // ------------------------------------------------
-        // 6. Alternating chromosome backgrounds
-        // ------------------------------------------------
-        for (i, chrom) in sorted_chroms.iter().enumerate() {
-            if let Some(info) = chrom_data.get(chrom) {
-                let bg = if i % 2 == 0 { WHITE } else { RGBColor(211, 211, 211) };
-                let fill_style: ShapeStyle = bg.mix(0.5).filled();
-                let rect = Rectangle::new(
-                    [
-                        (info.start as i64, (y_min + y_padding)),
-                        ((info.start + info.size) as i64, (y_max - y_padding)),
-                    ],
-                    fill_style,
-                );
-                chart.draw_series(vec![rect])?;
-            }
-        }
-
-        // ------------------------------------------------
-        // 7. Capture high-DPR pixel mapping for the points
-        //    we do not draw the points with plotters (will use tiny-skia for AA)
-        //    but use charts.backend_coord to map data->pixel in the high-DPR backend
-        // ------------------------------------------------
-
-        if !xs.is_empty() {
-            for (x, y) in xs.iter().zip(ys.iter()) {
-                // convert data coords -> high-DPR pixel coords
-                let (px, py) = chart.backend_coord(&(*x as i64, *y));
-                pixel_positions.push((px as f64, py as f64));
-            }
-        };
-
-        for (i, p) in point_details.iter_mut().enumerate() {
-            let (px, py) = pixel_positions[*&sig_indices[i]];
-            p.pixel_x = px / dpr;
-            p.pixel_y = py / dpr;
-        }
-
-        // flush root drawing area
-        root.present()?;
-    }
-
-    // Convert Plotters RGB buffer into tiny-skia RGBA pixmap
-    let mut pixmap = Pixmap::new(w, h).ok_or("Failed to create pixmap")?;
-    {
-        let data = pixmap.data_mut();
-        let mut src_i = 0usize;
-        let mut dst_i = 0usize;
-        for _ in 0..(w as usize * h as usize) {
-            let r = buffer[src_i];
-            let g = buffer[src_i + 1];
-            let b = buffer[src_i + 2];
-            data[dst_i] = r;
-            data[dst_i + 1] = g;
-            data[dst_i + 2] = b;
-            data[dst_i + 3] = 255u8; // opaque alpha
-            src_i += 3;
-            dst_i += 4;
-        }
-    }
-
-    // Draw anti-aliased circles using tiny-skia into the pixmap
-    // radius in HIGH-DPR pixels:
-    let radius_high_dpr = (png_dot_radius as f32) * (dpr as f32);
-
-    // Paint template
-    let mut paint = tiny_skia::Paint::default();
-
-    // for perfomance: reuse a PathBuilder to create circles
-    // will create a small path per point
-    for i in 0..xs.len() {
-        let (px, py) = pixel_positions[i]; // pixel coordinates for this point
-        let color_hex = &colors_vec[i];
-
-        let (r_u8, g_u8, b_u8) = match hex_to_rgb(color_hex) {
-            Some(rgb) => rgb,
-            None => (136u8, 136u8, 136u8),
-        };
-        paint.set_color_rgba8(r_u8, g_u8, b_u8, 255u8);
-        let mut pb = PathBuilder::new();
-        pb.push_circle(px as f32, py as f32, radius_high_dpr);
-
-        if let Some(path) = pb.finish() {
-            pixmap.fill_path(&path, &paint, FillRule::Winding, Transform::identity(), None);
-        };
-    }
-
-    // encode pixmap to PNG bytes
-    let png_bytes = pixmap.encode_png()?;
-    let png_data = BASE64.encode(&png_bytes);
-
-    // ------------------------------------------------
-    // 8. Generate interactive data
-    // ------------------------------------------------
-    let interactive_data = InteractiveData {
-        points: point_details,
-        chrom_data,
-        total_genome_length,
-        x_buffer,
-        y_min,
-        y_max,
-        device_pixel_ratio: dpr,
-        default_log_cutoff: log_cutoff,
-        has_capped_points,
-    };
-    Ok((png_data, interactive_data))
-}
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut input = String::new();
-    match io::stdin().read_line(&mut input) {
-        Ok(_bytes_read) => {
-            let input_json: Input = match serde_json::from_str(&input) {
-                Ok(json) => json,
-                Err(_err) => {
-                    panic!("Invalid JSON input");
-                }
-            };
-
-            // input data type
-            // *** might need to change the key later
-            let input_data = &input_json.plot_type;
-
-            if input_data == "grin2" {
-                let grin2_file = &input_json.file;
-                let chrom_size = &input_json.chromosomelist;
-                let plot_width = &input_json.plot_width;
-                let plot_height = &input_json.plot_height;
-                let device_pixel_ratio = &input_json.device_pixel_ratio;
-                let png_dot_radius = &input_json.png_dot_radius;
-                let max_capped_points = &input_json.max_capped_points;
-                let hard_cap = &input_json.hard_cap;
-                let bin_size = &input_json.bin_size;
-                let q_value_threshold = &input_json.q_value_threshold;
-                if let Ok((base64_string, plot_data)) = plot_grin2_manhattan(
-                    grin2_file.clone(),
-                    chrom_size.clone(),
-                    plot_width.clone(),
-                    plot_height.clone(),
-                    device_pixel_ratio.clone(),
-                    png_dot_radius.clone(),
-                    bin_size.clone(),
-                    max_capped_points.clone(),
-                    hard_cap.clone(),
-                    q_value_threshold.clone(),
-                ) {
-                    let output = Output {
-                        png: base64_string,
-                        plot_data,
-                    };
-                    if let Ok(json) = serde_json::to_string(&output) {
-                        println!("{}", json);
-                    }
-                } else {
-                    eprintln!("Failed to generate Manhattan plot");
-                };
-            }
-        }
-        Err(_err) => {
-            panic!("Error reading input JSON!");
-        }
-    }
-    Ok(())
-}

package/src/volcano.rs

@@ -1,354 +0,0 @@
-// 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 serde::{Deserialize, Serialize};
-use serde_json::Value;
-use std::error::Error;
-use std::io::{self, Read};
-use tiny_skia::{Paint, PathBuilder, Pixmap, Stroke, Transform};
-
-#[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>,
-    /// Hi-DPI scale factor (e.g. 2.0 on retina). Defaults to 1.0 when absent
-    /// so existing callers don't change behavior. The PNG is rasterized at
-    /// `(pixel_* + pad) * dpr` device pixels and is rendered at the CSS-space
-    /// dimensions reported in `plot_extent.pixel_*` — the browser uses the
-    /// extra resolution for sharpness on hi-DPI displays. Mirror of
-    /// manhattan_plot.rs's `device_pixel_ratio` handling.
-    #[serde(default)]
-    device_pixel_ratio: Option<f64>,
-}
-
-#[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;
-
-    // Hi-DPR scaling. The buffer/chart are sized in device pixels (CSS * dpr)
-    // and the drawn radius/stroke are scaled the same way, so the PNG is
-    // sharper on retina. backend_coord returns device-pixel coords; we divide
-    // by dpr below to keep `pixel_x/pixel_y` in CSS-space (which is what the
-    // SVG overlay coordinate system uses). Mirror of manhattan_plot.rs.
-    let dpr = input.device_pixel_ratio.unwrap_or(1.0).max(1.0);
-    let w_hd = ((w as f64) * dpr) as u32;
-    let h_hd = ((h as f64) * dpr) as u32;
-
-    let mut buffer = vec![0u8; (w_hd as usize) * (h_hd as usize) * 3];
-    // Per-point pixel coords as plotters' chart maps them. Captured in device
-    // pixels so tiny-skia can draw the AA rings exactly at those positions;
-    // we keep a CSS-space copy below for the SVG overlay.
-    let mut pixel_coords_hd: Vec<(f64, f64)> = Vec::with_capacity(points.len());
-    {
-        let backend = BitMapBackend::with_buffer(&mut buffer, (w_hd, h_hd));
-        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.
-        // The dots themselves are drawn below with tiny-skia for true AA; here
-        // plotters just gives us a white-background buffer and the data-to-pixel
-        // mapping. Mirror of manhattan_plot.rs.
-
-        for p in points.iter() {
-            let (px, py) = chart.backend_coord(&(p.fc, p.y));
-            pixel_coords_hd.push((px as f64, py as f64));
-        }
-
-        root.present()?;
-    }
-
-    // Convert plotters' RGB buffer to a tiny-skia RGBA pixmap, then stroke the
-    // dots on top with anti-aliasing — gives crisp rings even when the user
-    // zooms in past native DPR. Plotters' BitMapBackend has no AA on shapes,
-    // which is why ring edges looked chunky before this rewrite.
-    let mut pixmap = Pixmap::new(w_hd, h_hd).ok_or("failed to create pixmap")?;
-    {
-        let data = pixmap.data_mut();
-        for (src, dst) in buffer.chunks_exact(3).zip(data.chunks_exact_mut(4)) {
-            dst[..3].copy_from_slice(src);
-            dst[3] = 255;
-        }
-    }
-
-    // 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);
-
-    let radius_hd_f = radius_px as f32 * dpr as f32;
-    // 1 CSS-pixel-wide stroke at hi-DPR. The stroke straddles the path, so the
-    // visible ring thickness is `stroke_width` device px ≈ 1 CSS px.
-    let mut stroke = Stroke::default();
-    stroke.width = dpr as f32;
-    let mut paint = Paint::default();
-    paint.anti_alias = true;
-
-    let stroke_ring = |pixmap: &mut Pixmap, paint: &mut Paint, color: RGBColor, px: f32, py: f32| {
-        paint.set_color_rgba8(color.0, color.1, color.2, 255);
-        let mut pb = PathBuilder::new();
-        pb.push_circle(px, py, radius_hd_f);
-        if let Some(path) = pb.finish() {
-            pixmap.stroke_path(&path, paint, &stroke, Transform::identity(), None);
-        }
-    };
-
-    // Draw non-significant first so significant rings overlay on top.
-    for (i, p) in points.iter().enumerate() {
-        if p.significant {
-            continue;
-        }
-        let (px, py) = pixel_coords_hd[i];
-        stroke_ring(&mut pixmap, &mut paint, color_non, px as f32, py as f32);
-    }
-    for (i, p) in points.iter().enumerate() {
-        if !p.significant {
-            continue;
-        }
-        let (px, py) = pixel_coords_hd[i];
-        let c = if p.fc > 0.0 { color_up } else { color_down };
-        stroke_ring(&mut pixmap, &mut paint, c, px as f32, py as f32);
-    }
-
-    // CSS-space coords for the SVG overlay — divide the device-pixel positions
-    // by dpr. The overlay does not know about hi-DPR; the PNG sizing handles
-    // sharpness for us.
-    let all_pixel_coords: Vec<(f64, f64)> = pixel_coords_hd.iter().map(|(x, y)| (x / dpr, y / dpr)).collect();
-
-    // 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(&pixmap.encode_png()?),
-        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(())
-}