mrc 0.5.1

MRC-2014 file format reader/writer for cryo-EM — SIMD-accelerated, mmap-enabled
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! Invert voxel contrast in an MRC file.
//!
//! Negates every voxel value (v → −v), flipping black-on-white to
//! white-on-black and vice versa.  The output is written as Float32
//! regardless of the input mode.
//!
//! Usage:
//! ```text
//! mrc-invert <input.mrc> <output.mrc>
//! ```
//!
//! For each slice, the tool reads via `reader.convert::<f32>().slices()`, negates
//! all values, and writes the result as an equivalent Float32 slice.

use mrc::{VoxelBlock, create, open};
use std::env;
use std::process;

fn usage() {
    eprintln!(
        "mrc-invert v{} — MRC contrast inverter",
        env!("CARGO_PKG_VERSION")
    );
    eprintln!();
    eprintln!("Negates every voxel value (v → −v) to flip black-on-white to");
    eprintln!("white-on-black and vice versa.  Reads any mode, writes Float32.");
    eprintln!("Auto-detects gzip/bzip2 compression on input.");
    eprintln!();
    eprintln!("USAGE:");
    eprintln!("  mrc-invert <input> <output>");
    eprintln!();
    eprintln!("ARGS:");
    eprintln!("  <input>        Path to input MRC file");
    eprintln!("  <output>       Path for the inverted output (uncompressed Float32)");
    eprintln!();
    eprintln!("OPTIONS:");
    eprintln!("  -h, --help     Print this help message");
    eprintln!();
    eprintln!("EXAMPLES:");
    eprintln!("  mrc-invert protein.mrc protein_inverted.mrc");
    eprintln!("  mrc-invert density.mrc.gz inverted.mrc");
}

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() != 3 || args[1] == "--help" || args[1] == "-h" {
        usage();
        process::exit(0);
    }

    let input = &args[1];
    let output = &args[2];

    // Open input (auto-detects gzip/bzip2)
    let reader = match open(input) {
        Ok(r) => r,
        Err(e) => {
            eprintln!("Error opening '{}': {}", input, e);
            process::exit(2);
        }
    };

    let shape = reader.shape();
    let mode = reader.mode();

    eprintln!(
        "Input:  {} × {} × {}, mode={:?}",
        shape.nx, shape.ny, shape.nz, mode
    );
    eprintln!(
        "Output: {} × {} × {}, mode=Float32 (inverted)",
        shape.nx, shape.ny, shape.nz
    );

    // Create output writer
    let mut writer = match create(output)
        .shape([shape.nx, shape.ny, shape.nz])
        .mode::<f32>()
        .finish()
    {
        Ok(w) => w,
        Err(e) => {
            eprintln!("Error creating '{}': {}", output, e);
            process::exit(2);
        }
    };

    // Process slice by slice
    let total_slices = shape.nz;
    for (z, result) in reader.convert::<f32>().slices().enumerate() {
        let block = match result {
            Ok(b) => b,
            Err(e) => {
                eprintln!("Error reading slice {}: {}", z, e);
                process::exit(2);
            }
        };

        // Negate every voxel to invert contrast
        let inverted: Vec<f32> = block.data.iter().map(|&v| -v).collect();

        let out_block = match VoxelBlock::new(block.offset, block.shape, inverted) {
            Ok(b) => b,
            Err(e) => {
                eprintln!("Error creating output block: {}", e);
                process::exit(2);
            }
        };

        if let Err(e) = writer.write_block(&out_block) {
            eprintln!("Error writing slice {}: {}", z, e);
            process::exit(2);
        }

        if (z + 1) % 100 == 0 || z + 1 == total_slices {
            eprintln!("  Progress: {}/{} slices", z + 1, total_slices);
        }
    }

    // Update header statistics and finalize
    if let Err(e) = writer.update_header_stats() {
        eprintln!("Warning: could not update header stats: {}", e);
    }
    if let Err(e) = writer.finalize() {
        eprintln!("Error finalizing '{}': {}", output, e);
        process::exit(2);
    }

    eprintln!("Done: inverted {}", output);
}