@sjcrh/proteinpaint-rust 2.186.0 → 2.189.0

package/Cargo.toml

@@ -84,10 +84,6 @@ path="src/cluster.rs"
 name="gdcmaf"
 path="src/gdcmaf.rs"
 
-[[bin]]
-name="topGeneByExpressionVariance"
-path="src/topGeneByExpressionVariance.rs"
-
 [[bin]]
 name="wilcoxon"
 path="src/wilcoxon.rs"
@@ -142,4 +138,4 @@ path="src/dmrcate.rs"
 
 [[bin]]
 name="volcano"
-path="src/volcano.rs"
+path="src/volcano.rs"

package/package.json

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

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()?)
-}

package/src/topGeneByExpressionVariance.rs

@@ -1,731 +0,0 @@
-/*
- This script selects the top most variant genes by calculating the variance/interquartile region for each gene.
- Added support for HDF5 input files alongside the existing text file support.
-
-Various JSON parameters:
-   samples: Enter the sample ID(s) separated by comma
-   input_file: Path to input file (either text or HDF5 format)
-   filter_extreme_values: boolean (true/false). When true, this filter according to logic filterbyExpr in edgeR. This basically removes genes that have very low gene counts.
-   num_genes: The top num_genes (for e.g 10) that need to be reported in the output.
-   rank_type: var/iqr . This parameter decides whether to sort genes using variance or interquartile region. There is an article which states that its better to use interquartile region than variance for selecting genes for clustering https://www.frontiersin.org/articles/10.3389/fgene.2021.632620/full
-   newformat?: bool. Used to support new format HDF5
-
- Example syntax: cd .. && cargo build --release && json='{"samples":"sample1,sample2,sample3","min_count":30,"min_total_count":20,"input_file":"/path/to/input/file.h5","filter_extreme_values":true,"num_genes":100, "rank_type":"var"}' && time echo $json | target/release/gene_variance
-
- Usage for new format HDF5
-    echo '{"samples":"sample1,sample2,sample3","newformat":true,"min_count":30,"min_total_count":20,"input_file":"/path/to/input/file.h5","filter_extreme_values":true,"num_genes":100, "rank_type":"var"}' | ./target/release/topGeneByExpressionVariance
-*/
-#![allow(non_snake_case)]
-use bgzip::BGZFReader;
-use json;
-use nalgebra::DMatrix;
-use nalgebra::base::Matrix;
-use nalgebra::base::VecStorage;
-use nalgebra::base::dimension::Dyn;
-use serde::{Deserialize, Serialize};
-use serde_json;
-use statrs::statistics::Data;
-use statrs::statistics::Median;
-use statrs::statistics::OrderStatistics;
-use statrs::statistics::Statistics;
-use std::cmp::Ordering;
-use std::fs;
-use std::io;
-use std::io::Read;
-use std::str::FromStr;
-// use std::time::Instant;
-use hdf5::types::VarLenUnicode;
-use hdf5::{File, Result};
-use ndarray::Dim;
-
-/// Read expression data from a dense HDF5 file for a list of samples
-///
-/// This function extracts expression data from a dense format HDF5 file for
-/// the specified samples and returns it in the format expected by the
-/// gene variance calculation code.
-///
-/// # Arguments
-///
-/// * `filename` - Path to the HDF5 file
-/// * `sample_list` - List of sample IDs to extract data for
-///
-/// # Returns
-///
-/// A Result containing either:
-/// - A tuple with expression matrix and gene symbols list on success, or
-/// - An error with details formatted as JSON
-fn input_data_hdf5(
-    filename: &String,
-    sample_list: &Vec<&str>,
-) -> Result<(Matrix<f64, Dyn, Dyn, VecStorage<f64, Dyn, Dyn>>, Vec<String>)> {
-    // Open the HDF5 file
-    let file = match File::open(filename) {
-        Ok(f) => f,
-        Err(err) => {
-            return Err(hdf5::Error::Internal(format!("Failed to open HDF5 file: {}", err)));
-        }
-    };
-
-    // Read gene symbols dataset
-    let genes_dataset = match file.dataset("item") {
-        Ok(ds) => ds,
-        Err(err) => {
-            return Err(hdf5::Error::Internal(format!(
-                "Failed to open gene_names dataset: {}",
-                err
-            )));
-        }
-    };
-
-    // Read genes as VarLenAscii
-    let genes_varlen = match genes_dataset.read_1d::<VarLenUnicode>() {
-        Ok(g) => g,
-        Err(err) => {
-            return Err(hdf5::Error::Internal(format!("Failed to read gene symbols: {}", err)));
-        }
-    };
-
-    // Convert to Vec<String> for easier handling
-    let gene_names: Vec<String> = genes_varlen.iter().map(|g| g.to_string()).collect();
-    let num_genes = gene_names.len();
-
-    // Read sample names
-    let samples_dataset = match file.dataset("samples") {
-        Ok(ds) => ds,
-        Err(err) => {
-            println!(
-                "{}",
-                serde_json::json!({
-                    "status": "error",
-                    "message": format!("Failed to open samples dataset: {}", err),
-                    "file_path": filename
-                })
-            );
-            return Err(hdf5::Error::Internal(format!(
-                "Failed to open samples dataset: {}",
-                err
-            )));
-        }
-    };
-
-    // Read samples as VarLenAscii
-    let samples_varlen = match samples_dataset.read_1d::<VarLenUnicode>() {
-        Ok(s) => s,
-        Err(err) => {
-            // eprintln!("Failed to read sample names: {}", err);
-            println!(
-                "{}",
-                serde_json::json!({
-                    "status": "error",
-                    "message": format!("Failed to read sample names: {}", err),
-                    "file_path": filename
-                })
-            );
-            return Err(hdf5::Error::Internal(format!("Failed to read sample names: {}", err)));
-        }
-    };
-
-    // Convert to Vec<String> for easier handling
-    let all_samples: Vec<String> = samples_varlen.iter().map(|s| s.to_string()).collect();
-
-    // Find indices of requested samples
-    let mut column_indices: Vec<usize> = Vec::with_capacity(sample_list.len());
-    for sample in sample_list {
-        if let Some(index) = all_samples.iter().position(|s| s == sample) {
-            column_indices.push(index);
-        } else {
-            return Err(hdf5::Error::Internal(format!(
-                "Sample '{}' not found in the dataset",
-                sample
-            )));
-        }
-    }
-
-    // Read the counts dataset
-    let counts_dataset = match file.dataset("matrix") {
-        Ok(ds) => ds,
-        Err(err) => {
-            return Err(hdf5::Error::Internal(format!("Failed to open counts dataset: {}", err)));
-        }
-    };
-
-    // Get dataset dimensions for validation
-    let dataset_shape = counts_dataset.shape();
-    if dataset_shape.len() != 2 {
-        return Err(hdf5::Error::Internal("Expected a 2D dataset for counts".to_string()));
-    };
-
-    // Check dimensions match expected values
-    if dataset_shape[0] != num_genes {
-        return Err(hdf5::Error::Internal(format!(
-            "Counts dataset first dimension ({}) doesn't match number of genes ({})",
-            dataset_shape[0], num_genes
-        )));
-    };
-
-    if dataset_shape[1] != all_samples.len() {
-        return Err(hdf5::Error::Internal(format!(
-            "Counts dataset second dimension ({}) doesn't match number of samples ({})",
-            dataset_shape[1],
-            all_samples.len()
-        )));
-    };
-
-    // Read the counts dataset
-    let all_counts = match counts_dataset.read::<f64, Dim<[usize; 2]>>() {
-        Ok(data) => data,
-        Err(err) => {
-            return Err(hdf5::Error::Internal(format!(
-                "Failed to read expression data: {}",
-                err
-            )));
-        }
-    };
-
-    let mut input_vector: Vec<f64> = Vec::with_capacity(num_genes * sample_list.len());
-
-    for gene_idx in 0..num_genes {
-        for &col_idx in &column_indices {
-            input_vector.push(all_counts[[gene_idx, col_idx]]);
-        }
-    }
-
-    // Create matrix from the extracted data
-    let dm = DMatrix::from_row_slice(num_genes, sample_list.len(), &input_vector);
-
-    Ok((dm, gene_names))
-}
-
-// The original input_data function for text files is kept as is
-fn input_data(
-    filename: &String,
-    sample_list: &Vec<&str>,
-) -> (Matrix<f64, Dyn, Dyn, VecStorage<f64, Dyn, Dyn>>, Vec<String>) {
-    // Build the CSV reader and iterate over each record.
-    let mut reader = BGZFReader::new(fs::File::open(filename).unwrap()).unwrap();
-    let mut num_lines: usize = 0;
-    let mut gene_names: Vec<String> = Vec::with_capacity(500);
-
-    let mut buffer = String::new();
-    reader.read_to_string(&mut buffer).unwrap();
-
-    let lines = buffer.split("\n");
-    let mut first = true;
-    let mut input_vector: Vec<f64> = Vec::with_capacity(1000 * 500);
-    let mut column_numbers: Vec<usize> = Vec::with_capacity(300);
-    for line in lines {
-        if first == true {
-            first = false;
-            let columns: Vec<&str> = line.split("\t").collect();
-            // Finding column numbers corresponding to each sample given in the input list
-            for item in sample_list {
-                if let Some(index) = columns.iter().position(|num| num == item) {
-                    column_numbers.push(index)
-                } else {
-                    panic!("Sample {} not found:", item)
-                }
-            }
-        } else {
-            let line2: Vec<&str> = line.split("\t").collect();
-            if line2.len() == 1 {
-                break; // end of file
-            } else {
-                num_lines += 1;
-                //println!("line2:{:?}", line2);
-                gene_names.push(line2[3].to_string());
-                for i in &column_numbers {
-                    let field = line2[*i];
-                    let num = FromStr::from_str(field);
-                    match num {
-                        Ok(n) => {
-                            //println!("n:{}", n);
-                            input_vector.push(n);
-                        }
-                        Err(_n) => {
-                            panic!(
-                                "Number {} in line {} and column {} is not a decimal number",
-                                field,
-                                num_lines + 1,
-                                i + 1
-                            );
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    //println!("case_indexes:{:?}", case_indexes);
-    //println!("control_indexes:{:?}", control_indexes);
-
-    let dm = DMatrix::from_row_slice(num_lines, sample_list.len(), &input_vector);
-    //println!("dm:{:?}", dm);
-    (dm, gene_names)
-}
-
-#[allow(dead_code)]
-#[derive(Debug, Serialize, Deserialize)]
-struct GeneInfo {
-    gene_symbol: String,
-    rank_type: f64,
-}
-
-fn calculate_variance(
-    input_matrix: Matrix<f64, Dyn, Dyn, VecStorage<f64, Dyn, Dyn>>,
-    gene_names: Vec<String>,
-    mut min_sample_size: f64,
-    filter_extreme_values: bool,
-    rank_type: String,
-    min_count_option: Option<f64>,
-    min_total_count_option: Option<f64>,
-) -> Vec<GeneInfo> {
-    let mut min_count: f64 = 10.0;
-    match min_count_option {
-        Some(x) => min_count = x,
-        None => {}
-    }
-    let mut min_total_count: f64 = 15.0;
-    match min_total_count_option {
-        Some(x) => min_total_count = x,
-        None => {}
-    }
-    //const MIN_COUNT: f64 = 10.0; // Value of constant from R implementation
-    //const MIN_TOTAL_COUNT: f64 = 15.0; // Value of constant from R implementation
-    const LARGE_N: f64 = 10.0; // Value of constant from R implementation
-    const MIN_PROP: f64 = 0.7; // Value of constant from R implementation
-
-    if min_sample_size == 0.0 {
-        panic!("Only one condition present in groups");
-    }
-
-    if min_sample_size > LARGE_N {
-        min_sample_size = LARGE_N + (min_sample_size - LARGE_N) * MIN_PROP;
-    }
-
-    // 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);
-    }
-
-    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, &lib_sizes);
-    const TOL: f64 = 1e-14; // Value of constant from R implementation
-
-    let mut gene_infos = Vec::<GeneInfo>::new();
-    for row in 0..input_matrix.nrows() {
-        let mut trues = 0.0;
-        // CPM filter (NaN-safe)
-        for col in 0..cpm_matrix.ncols() {
-            let v = cpm_matrix[(row, col)];
-            if v.is_finite() && v >= cpm_cutoff {
-                trues += 1.0;
-            }
-        }
-        let mut keep_cpm_bool = false;
-        if trues >= min_sample_size - TOL {
-            keep_cpm_bool = true;
-            //keep_cpm.push(keep_cpm_bool);
-            //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_sum_finite >= min_total_count - TOL {
-            keep_total_bool = true;
-        }
-
-        let mut gene_counts: Vec<f64> = Vec::with_capacity(input_matrix.ncols());
-        for col in 0..input_matrix.ncols() {
-            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 {
-            } else if filter_extreme_values == true && keep_cpm_bool == true && keep_total_bool == true {
-                gene_infos.push(GeneInfo {
-                    rank_type: gene_counts.variance(),
-                    gene_symbol: gene_names[row].clone(),
-                });
-            } else if filter_extreme_values == false {
-                gene_infos.push(GeneInfo {
-                    rank_type: gene_counts.variance(),
-                    gene_symbol: gene_names[row].clone(),
-                });
-            }
-        } else {
-            // Calculating interquartile region
-            let mut gene_counts_data = Data::new(gene_counts);
-            if gene_counts_data.clone().interquartile_range().is_nan() == true {
-            } else if filter_extreme_values == true && keep_cpm_bool == true && keep_total_bool == true {
-                gene_infos.push(GeneInfo {
-                    rank_type: gene_counts_data.interquartile_range(),
-                    gene_symbol: gene_names[row].clone(),
-                });
-            } else if filter_extreme_values == false {
-                gene_infos.push(GeneInfo {
-                    rank_type: gene_counts_data.interquartile_range(),
-                    gene_symbol: gene_names[row].clone(),
-                });
-            }
-        }
-    }
-    gene_infos
-        .as_mut_slice()
-        .sort_by(|a, b| (a.rank_type).partial_cmp(&b.rank_type).unwrap_or(Ordering::Equal));
-    gene_infos
-}
-
-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 output_matrix = DMatrix::from_element(input_matrix.nrows(), input_matrix.ncols(), 0.0);
-
-    for col in 0..input_matrix.ncols() {
-        let norm = col_sums[col];
-        for row in 0..input_matrix.nrows() {
-            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
-            };
-        }
-    }
-    output_matrix
-}
-
-fn main() {
-    // println!("Starting gene variance calculation...");
-    let mut input = String::new();
-    match io::stdin().read_line(&mut input) {
-        // Accepting the piped input from nodejs (or command line from testing)
-        Ok(_bytes_read) => {
-            // eprintln!("Read {} bytes from stdin", bytes_read);
-            // println!("{} bytes read", bytes_read);
-            // println!("{}", input);
-            let input_json = json::parse(&input);
-            match input_json {
-                Ok(json_string) => {
-                    // println!("Successfully parsed JSON input");
-                    // let now = Instant::now();
-                    let samples_string_result = &json_string["samples"].to_owned();
-                    let samples_string;
-                    match samples_string_result.as_str() {
-                        Some(x) => {
-                            samples_string = x.to_string();
-                            // println!("Samples: {}", samples_string);
-                        }
-                        None => {
-                            // eprintln!("ERROR: Samples not provided in JSON");
-                            println!(
-                                "{}",
-                                serde_json::json!({
-                                    "status": "error",
-                                    "message": "Samples not provided"
-                                })
-                            );
-                            return;
-                        }
-                    }
-
-                    let file_name_result = &json_string["input_file"];
-                    let file_name;
-
-                    match file_name_result.as_str() {
-                        Some(x) => {
-                            file_name = x.to_string();
-                            // eprintln!("Input file: {}", file_name);
-                            // Return file name as JSON for debugging
-                            // println!(
-                            //     "{}",
-                            //     serde_json::json!({"status": "success", "file_name": file_name})
-                            // );
-                        }
-                        None => {
-                            // eprintln!("ERROR: File name missing in JSON");
-                            // println!(
-                            //     "{}",
-                            //     serde_json::json!({
-                            //         "status": "error",
-                            //         "message": "File name is missing"
-                            //     })
-                            // );
-                            return;
-                        }
-                    }
-
-                    // Determine file type based on extension
-                    let file_type: String;
-                    if file_name.to_lowercase().ends_with(".h5") {
-                        file_type = "hdf5".to_string();
-                        // eprintln!("Detected HDF5 file format based on .h5 extension");
-                    } else {
-                        file_type = "text".to_string();
-                        // eprintln!("Using default text file format (no .h5 extension found)");
-                    }
-
-                    // Determine if the H5 file is new format
-                    //let new_format: bool = match &json_string {
-                    //    json::JsonValue::Object(ref obj) => {
-                    //        obj.get("newformat").and_then(|v| v.as_bool()).map_or(false, |b| b)
-                    //    }
-                    //    _ => false,
-                    //};
-
-                    let rank_type = &json_string["rank_type"] // Value provide must be either "var" or "iqr"
-                        .to_owned()
-                        .as_str()
-                        .unwrap_or("var")
-                        .to_string();
-                    // eprintln!("Rank type: {}", rank_type);
-                    if rank_type != "var" && rank_type != "iqr" {
-                        // Check if any unknown method has been provided
-                        // eprintln!("ERROR: Unknown rank method: {}", rank_type);
-                        // println!(
-                        //     "{}",
-                        //     serde_json::json!({
-                        //         "status": "error",
-                        //         "message": format!("Unknown rank method: {}. Must be 'var' or 'iqr'", rank_type)
-                        //     })
-                        // );
-                        return;
-                    }
-                    let filter_extreme_values_result = &json_string["filter_extreme_values"];
-
-                    let filter_extreme_values;
-                    match filter_extreme_values_result.as_bool() {
-                        Some(x) => {
-                            filter_extreme_values = x;
-                            // eprintln!("Filter extreme values: {}", filter_extreme_values);
-                        }
-                        None => {
-                            filter_extreme_values = true; // If filter_extreme_values field is missing, set it to true by default
-                            // eprintln!(
-                            //     "Filter extreme values not specified, defaulting to: {}",
-                            //     filter_extreme_values
-                            // );
-                        }
-                    }
-
-                    let num_genes_result = &json_string["num_genes"];
-                    let num_genes;
-                    match num_genes_result.as_usize() {
-                        Some(x) => {
-                            num_genes = x;
-                            // eprintln!("Number of genes requested: {}", num_genes);
-                        }
-                        None => {
-                            // eprintln!("ERROR: Number of genes to be given is missing");
-                            println!(
-                                "{}",
-                                serde_json::json!({
-                                    "status": "error",
-                                    "message": "Number of genes to be given is missing"
-                                })
-                            );
-                            return;
-                        }
-                    }
-
-                    let min_count_result = &json_string["min_count"];
-                    let mut min_count: Option<f64> = None;
-                    match min_count_result.as_f64() {
-                        Some(x) => {
-                            min_count = Some(x);
-                            // eprintln!("Min count: {}", x);
-                        }
-                        None => {
-                            // eprintln!("Min count not specified, will use default");
-                        }
-                    }
-
-                    let min_total_count_result = &json_string["min_total_count"];
-                    let mut min_total_count: Option<f64> = None;
-                    match min_total_count_result.as_f64() {
-                        Some(x) => {
-                            min_total_count = Some(x);
-                            // eprintln!("Min total count: {}", x);
-                        }
-                        None => {
-                            // eprintln!("Min total count not specified, will use default");
-                        }
-                    }
-
-                    let samples_list: Vec<&str> = samples_string.split(",").collect();
-                    // eprintln!("Number of samples in list: {}", samples_list.len());
-
-                    // Choose the appropriate input function based on file type
-                    // eprintln!("Reading data from {} file: {}", file_type, file_name);
-                    let (input_matrix, gene_names) = if file_type == "hdf5" {
-                        // eprintln!("Using HDF5 reader function...");
-                        match input_data_hdf5(&file_name, &samples_list) {
-                            Ok(result) => result,
-                            Err(err) => {
-                                eprintln!("ERROR in HDF5 reader: {:?}", err);
-                                return;
-                            }
-                        }
-                    } else {
-                        // For original text-based implementation, we wrap it in a try-catch block
-                        // to handle panics in a more structured way
-                        // eprintln!("Using text file reader function...");
-                        match std::panic::catch_unwind(|| input_data(&file_name, &samples_list)) {
-                            Ok(result) => {
-                                // eprintln!("Successfully read text file data");
-                                result
-                            }
-                            Err(err) => {
-                                eprintln!("ERROR in text file reader: {:?}", err);
-                                println!(
-                                    "{}",
-                                    serde_json::json!({
-                                        "status": "error",
-                                        "message": "Failed to read text file data",
-                                        "file_path": file_name
-                                    })
-                                );
-                                return;
-                            }
-                        }
-                    };
-
-                    // eprintln!(
-                    //     "Matrix dimensions: {}x{}",
-                    //     input_matrix.nrows(),
-                    //     input_matrix.ncols()
-                    // );
-                    // eprintln!("Number of gene symbols: {}", gene_names.len());
-                    if !gene_names.is_empty() {
-                        // eprintln!(
-                        //     "First few gene symbols: {:?}",
-                        //     &gene_names.iter().take(5).collect::<Vec<_>>()
-                        // );
-                    }
-
-                    // Wrap the variance calculation in a try-catch to capture any panics
-                    // eprintln!(
-                    //     "Calculating variance with {} samples, filter={}, rank_type={}",
-                    //     samples_list.len(),
-                    //     filter_extreme_values,
-                    //     rank_type
-                    // );
-                    let gene_infos = match std::panic::catch_unwind(|| {
-                        calculate_variance(
-                            input_matrix,
-                            gene_names,
-                            samples_list.len() as f64,
-                            filter_extreme_values,
-                            rank_type.to_string(),
-                            min_count,
-                            min_total_count,
-                        )
-                    }) {
-                        Ok(result) => {
-                            // eprintln!(
-                            //     "Successfully calculated variance for {} genes",
-                            //     result.len()
-                            // );
-                            result
-                        }
-                        Err(err) => {
-                            eprintln!("ERROR in variance calculation: {:?}", err);
-                            println!(
-                                "{}",
-                                serde_json::json!({
-                                    "status": "error",
-                                    "message": "Error calculating gene variance",
-                                    "file_path": file_name
-                                })
-                            );
-                            return;
-                        }
-                    };
-
-                    // Check if we have enough genes for the requested output
-                    if gene_infos.len() < num_genes {
-                        // eprintln!(
-                        //     "WARNING: Only {} genes found, but {} were requested",
-                        //     gene_infos.len(),
-                        //     num_genes
-                        // );
-                    }
-
-                    let actual_num_genes = std::cmp::min(num_genes, gene_infos.len());
-                    // eprintln!("Returning top {} genes", actual_num_genes);
-
-                    // Printing the top "num_genes" genes to JSON
-                    let mut output_string = "[".to_string();
-                    for j in 0..actual_num_genes {
-                        let i = gene_infos.len() - j - 1;
-                        output_string += &serde_json::to_string(&gene_infos[i]).unwrap();
-                        if i > gene_infos.len() - actual_num_genes {
-                            output_string += &",".to_string();
-                        }
-                    }
-                    output_string += &"]".to_string();
-
-                    // Debug the first few characters of the output
-                    if output_string.len() > 100 {
-                        // eprintln!("Output JSON starts with: {}", &output_string[0..100]);
-                    } else {
-                        // eprintln!("Output JSON: {}", output_string);
-                    }
-
-                    println!("output_json:{}", output_string);
-                    // let elapsed = now.elapsed();
-                    // eprintln!("Completed in: {:?}", elapsed);
-                    // println!("Time for calculating variances:{:?}", elapsed);
-                }
-                Err(error) => {
-                    eprintln!("ERROR: JSON parsing error: {}", error);
-                    println!(
-                        "{}",
-                        serde_json::json!({
-                            "status": "error",
-                            "message": format!("Incorrect json: {}", error)
-                        })
-                    );
-                }
-            }
-        }
-        Err(error) => {
-            eprintln!("ERROR: Failed to read from stdin: {}", error);
-            println!(
-                "{}",
-                serde_json::json!({
-                "status": "error",
-                "message": format!("Piping error: {}", error)
-                })
-            );
-        }
-    }
-    // println!("Program execution complete");
-}