@sjcrh/proteinpaint-rust 2.188.0 → 2.190.0

package/Cargo.toml

@@ -41,7 +41,6 @@ num_cpus = "1.16.0"
 memchr = "2"
 r2d2_sqlite = "0.29.0"
 r2d2 = "0.8.10"
-rig-core = "0.22.0"
 url = "2.5.7"
 async-stream = "0.3.6"
 base64 = "0.22.1"
@@ -124,14 +123,6 @@ path="src/readH5.rs"
 name="manhattan_plot"
 path="src/manhattan_plot.rs"
 
-[[bin]]
-name="query_classification"
-path="src/query_classification.rs"
-
-[[bin]]
-name="summary_agent"
-path="src/summary_agent.rs"
-
 [[bin]]
 name="dmrcate"
 path="src/dmrcate.rs"

package/package.json

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

package/src/manhattan_plot.rs

@@ -7,7 +7,7 @@ use std::collections::{HashMap, HashSet};
 use std::convert::TryInto;
 use std::error::Error;
 use std::fs::File;
-use std::io::{self, BufRead, BufReader};
+use std::io::{self, BufReader};
 use tiny_skia::{FillRule, PathBuilder, Pixmap, Transform};
 
 // Define the JSON input structure
@@ -250,7 +250,22 @@ fn cumulative_chrom(
     Ok((chrom_data, cumulative_pos, sorted_chroms))
 }
 
-// Function to read the GRIN2 file
+// 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>,
@@ -281,59 +296,16 @@ fn grin2_file_read(
     let mut sig_indices: Vec<usize> = Vec::new();
     let mut zero_q_indices: Vec<usize> = Vec::new();
 
-    let grin2_file = File::open(grin2_file).expect("Failed to open grin2_result_file");
-    let mut reader = BufReader::new(grin2_file);
-    // get the first line (header line)
-    let mut header_line = String::new();
-    reader
-        .read_line(&mut header_line)
-        .expect("Failed to read the first line of grin2_result_file");
-    let header: Vec<String> = header_line
-        .trim_end()
-        .split('\t')
-        .map(|s| s.trim().to_string())
-        .collect();
+    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;
 
-    // define the mutation types from the header of grin2 result file
     let mutation_types = ["gain", "loss", "mutation", "fusion", "sv"];
-    let mut mutation_indices: HashMap<&str, (usize, Option<usize>)> = HashMap::new();
-    for name in &mutation_types {
-        let q_col = format!("q.nsubj.{name}");
-        let n_col = format!("nsubj.{name}");
-        if let Some(q_idx) = header.iter().position(|h| h == &q_col) {
-            let n_idx = header.iter().position(|h| h == &n_col);
-            mutation_indices.insert(*name, (q_idx, n_idx));
-        }
-    }
-
-    // extract the index for each required info
-    let chrom_idx = header
-        .iter()
-        .position(|h| h == "chrom")
-        .expect("Missing 'chrom' column");
-    let gene_idx = header.iter().position(|h| h == "gene").expect("Missing 'gene' column");
-    let loc_start_idx = header
-        .iter()
-        .position(|h| h == "loc.start")
-        .expect("Missing 'loc.start' column");
-    let loc_end_idx = header
-        .iter()
-        .position(|h| h == "loc.end")
-        .expect("Missing 'loc.end' column");
 
-    // loop all lines
     let mut mut_num: usize = 0;
-    for line_result in reader.lines() {
-        let line = match line_result {
-            Ok(l) => l,
-            Err(e) => {
-                eprintln!("Error reading line: {}", e);
-                continue;
-            }
-        };
-
-        let fields: Vec<&str> = line.trim_end().split('\t').collect();
-        let chrom = match fields.get(chrom_idx).map(|s| s.trim()) {
+    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,
         };
@@ -341,30 +313,21 @@ fn grin2_file_read(
             Some(info) => info,
             None => continue,
         };
-        let gene_name = fields.get(gene_idx).unwrap_or(&"").to_string();
-        let loc_start_str = match fields.get(loc_start_idx).map(|s| s.trim()) {
-            Some(s) if !s.is_empty() => s,
-            _ => 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_start: u64 = loc_start_str
-            .parse()
-            .unwrap_or_else(|_| panic!("Invalid integer for loc.start: '{}' in line: {}", loc_start_str, line));
-        let loc_end_str = match fields.get(loc_end_idx).map(|s| s.trim()) {
-            Some(s) if !s.is_empty() => s,
-            _ => continue,
+        let gene_end: u64 = match row.get("loc.end").and_then(|v| v.as_u64()) {
+            Some(n) => n,
+            None => continue,
         };
-        let gene_end: u64 = loc_end_str
-            .parse()
-            .unwrap_or_else(|_| panic!("Invalid integer for loc.end: '{}' in line: {}", loc_end_str, line));
-        let x_pos = chrom_info.start + gene_start as u64;
-
-        for (mtype, (q_idx, n_idx_opt)) in &mutation_indices {
-            let q_val_str = match fields.get(*q_idx) {
-                Some(q) => q,
-                None => continue,
-            };
-            let original_q_val: f64 = match q_val_str.parse() {
-                Ok(v) if v >= 0.0 => v,
+        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,
             };
 
@@ -377,9 +340,8 @@ fn grin2_file_read(
                 -original_q_val.log10()
             };
 
-            let n_subj_count: Option<i64> = n_idx_opt
-                .and_then(|i| fields.get(i))
-                .and_then(|s| s.parse::<i64>().ok());
+            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);

package/src/volcano.rs

@@ -8,11 +8,11 @@
 
 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};
+use tiny_skia::{Paint, PathBuilder, Pixmap, Stroke, Transform};
 
 #[derive(Deserialize)]
 struct Input {
@@ -36,6 +36,14 @@ struct Input {
     /// 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)]
@@ -189,14 +197,23 @@ fn main() -> Result<(), Box<dyn Error>> {
     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());
+
+    // 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, h));
+        let backend = BitMapBackend::with_buffer(&mut buffer, (w_hd, h_hd));
         let root = backend.into_drawing_area();
         root.fill(&WHITE)?;
 
@@ -213,44 +230,77 @@ fn main() -> Result<(), Box<dyn Error>> {
 
         // 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.
 
-        // 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));
+            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();
@@ -273,7 +323,7 @@ fn main() -> Result<(), Box<dyn Error>> {
         .collect();
 
     let output = Output {
-        png: BASE64.encode(&encode_rgb_to_png(&buffer, w, h)?),
+        png: BASE64.encode(&pixmap.encode_png()?),
         plot_extent: PlotExtent {
             x_min,
             x_max,
@@ -302,13 +352,3 @@ fn main() -> Result<(), Box<dyn Error>> {
     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()?)
-}