@sjcrh/proteinpaint-rust 2.185.0 → 2.188.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.185.0",
+	"version": "2.188.0",
 	"name": "@sjcrh/proteinpaint-rust",
 	"type": "module",
 	"description": "Rust-based utilities for proteinpaint",

package/src/volcano.rs

@@ -40,10 +40,21 @@ struct Input {
 
 #[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
@@ -145,19 +156,45 @@ fn main() -> Result<(), Box<dyn Error>> {
         y_max_data = y_max_data.max(pt.y);
     }
 
-    // Axis extents — symmetric on x, padded 5%.
-    let x_span = if x_abs_max > 0.0 { x_abs_max * 1.05 } else { 1.0 };
-    let (x_min, x_max, y_min) = (-x_span, x_span, 0f64);
-    let y_max = if y_max_data > 0.0 { y_max_data * 1.05 } else { 1.0 };
+    // 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 };
 
-    // Render — borderless scatter. No axes/labels/margins. The client owns
-    // axes and positions the PNG exactly over its plot rect, so the inner
-    // drawing area fills the whole canvas.
-    let (w, h) = (input.pixel_width, input.pixel_height);
+    // Normalize the dot radius once into the integer pixel count plotters will
+    // actually draw, with a min of 1 so sub-pixel inputs don't collapse to a
+    // zero-radius dot. This single value drives both PNG padding and circle
+    // rendering, keeping the geometry self-consistent (matches manhattan).
+    let radius_px = (input.dot_radius as i32).max(1);
+    // Pad PNG by 2*radius_px so dots near the data edges stay fully visible.
+    let pad_px = (2 * radius_px) as u32;
+    let (w, h) = (input.pixel_width + pad_px, input.pixel_height + pad_px);
     if w == 0 || h == 0 || w > 4000 || h > 4000 {
         return Err(format!("pixel dimensions {}x{} out of range (1–4000)", w, h).into());
     }
+
+    // Convert pixel padding to data units using the unpadded extents and the
+    // unpadded pixel dimensions. Per-axis pad in data space = radius_px * (data
+    // range / pixel range) — keeps the data/pixel ratio identical between
+    // padded and unpadded space.
+    let x_data_per_px = (x_max_unpadded - x_min_unpadded) / input.pixel_width as f64;
+    let y_data_per_px = (y_max_unpadded - y_min_unpadded) / input.pixel_height as f64;
+    let x_pad_data = radius_px as f64 * x_data_per_px;
+    let y_pad_data = radius_px as f64 * y_data_per_px;
+    let x_min = x_min_unpadded - x_pad_data;
+    let x_max = x_max_unpadded + x_pad_data;
+    let y_min = y_min_unpadded - y_pad_data;
+    let y_max = y_max_unpadded + y_pad_data;
     let mut buffer = vec![0u8; (w as usize) * (h as usize) * 3];
+    // Per-point pixel coords as plotters actually rasterizes them. Returned to
+    // the client so the SVG overlay rings sit exactly on top of the PNG dots
+    // instead of being recomputed from data coords (which loses sub-pixel
+    // precision under plotters' integer truncation).
+    let mut all_pixel_coords: Vec<(f64, f64)> = Vec::with_capacity(points.len());
     {
         let backend = BitMapBackend::with_buffer(&mut buffer, (w, h));
         let root = backend.into_drawing_area();
@@ -191,20 +228,26 @@ fn main() -> Result<(), Box<dyn Error>> {
             filled: false,
             stroke_width: 1,
         };
-        let radius = input.dot_radius as i32;
 
         // 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, ring(color_non))),
+                .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, ring(c))
+            Circle::new((p.fc, p.y), radius_px, ring(c))
         }))?;
 
+        // Mirror manhattan_plot.rs: capture the exact pixel coords plotters
+        // used for each point so the client overlay can land on them precisely.
+        for p in points.iter() {
+            let (px, py) = chart.backend_coord(&(p.fc, p.y));
+            all_pixel_coords.push((px as f64, py as f64));
+        }
+
         root.present()?;
     }
 
@@ -216,7 +259,18 @@ fn main() -> Result<(), Box<dyn Error>> {
     if let Some(cap) = input.max_interactive_dots {
         sig_points.truncate(cap);
     }
-    let dots: Vec<Value> = sig_points.iter().map(|p| input.rows[p.idx].clone()).collect();
+    let dots: Vec<Value> = sig_points
+        .iter()
+        .map(|p| {
+            let mut row = input.rows[p.idx].clone();
+            let (px, py) = all_pixel_coords[p.idx];
+            if let Value::Object(ref mut m) = row {
+                m.insert("pixel_x".to_string(), Value::from(px));
+                m.insert("pixel_y".to_string(), Value::from(py));
+            }
+            row
+        })
+        .collect();
 
     let output = Output {
         png: BASE64.encode(&encode_rgb_to_png(&buffer, w, h)?),
@@ -225,6 +279,13 @@ fn main() -> Result<(), Box<dyn Error>> {
             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,

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");
-}