use mrc::MrcView;

// Read from memory
let data = std::fs::read("protein.mrc")?;
let view = MrcView::new(data)?;

// Get dimensions
let (nx, ny, nz) = view.dimensions();
println!("Volume: {}×{}×{} voxels", nx, ny, nz);

// Access data based on type
match view.mode() {
    Some(Mode::Float32) => {
        let floats = view.view::<f32>()?;
        println!("First pixel: {}", floats[0]);
    }
    Some(Mode::Int16) => {
        let ints = view.view::<i16>()?;
        println!("First pixel: {}", ints[0]);
    }
    _ => println!("Unsupported data type"),
}

use mrc::{Header, Mode, MrcFile};

// Create header for 3D volume
let mut header = Header::new();
header.nx = 512;
header.ny = 512;
header.nz = 256;
header.mode = Mode::Float32 as i32;

// Set physical dimensions (Ångströms)
header.xlen = 256.0;
header.ylen = 256.0;
header.zlen = 128.0;

// Write to file
let mut file = MrcFile::create("output.mrc", header)?;
file.write_data(&your_data)?;

use mrc::Header;

let mut header = Header::new();

// Basic dimensions
header.nx = 2048;        // X dimension
header.ny = 2048;        // Y dimension  
header.nz = 512;         // Z dimension

// Data type (see Mode enum)
header.mode = Mode::Float32 as i32;

// Physical dimensions in Ångströms
header.xlen = 204.8;     // Physical X length
header.ylen = 204.8;     // Physical Y length
header.zlen = 102.4;     // Physical Z length

// Cell angles for crystallography
header.alpha = 90.0;
header.beta = 90.0;
header.gamma = 90.0;

// Axis mapping (1=X, 2=Y, 3=Z)
header.mapc = 1;         // Fastest changing axis
header.mapr = 2;         // Second fastest axis
header.maps = 3;         // Slowest changing axis

// Data statistics
header.dmin = 0.0;       // Minimum data value
header.dmax = 1.0;       // Maximum data value
header.dmean = 0.5;      // Mean data value
header.rms = 0.1;        // RMS deviation

use mrc::{MrcView, Error, Mode};

// From byte slice
let view = MrcView::new(header, data)?;

// Type-safe access
match view.mode() {
    Some(Mode::Float32) => {
        let floats = view.view::<f32>()?;
        // floats: &[f32] - zero-copy slice
        let sum: f32 = floats.iter().sum();
        println!("Total intensity: {}", sum);
    }
    Some(Mode::Int16) => {
        let ints = view.view::<i16>()?;
        // Process 16-bit integer data
        let max = ints.iter().max().unwrap_or(&0);
    }
    _ => return Err(Error::TypeMismatch),
}

// Raw byte access
let raw_bytes = view.data();           // &[u8]
let slice = view.slice_bytes(0..1024)?; // &[u8]

use mrc::{MrcViewMut, Header};

// Create mutable view
let mut view = MrcViewMut::new(header, &mut data)?;

// Modify data
{
    let mut floats = view.view_mut::<f32>()?;
    for val in floats.iter_mut() {
        *val = val.max(0.0);  // Remove negative values
    }
}

// Update header statistics
view.update_statistics()?;

// Modify header
let mut new_header = view.header().clone();
new_header.dmin = 0.0;
new_header.dmax = 1.0;
view.set_header(new_header)?;

use mrc::{MrcFile, MrcMmap, Mode};

// Standard file I/O
let file = MrcFile::open("data.mrc")?;
let view = file.view()?;

// Memory-mapped for large files (requires mmap feature)
#[cfg(feature = "mmap")]
let mmap = MrcMmap::open("large_volume.mrc")?;
#[cfg(feature = "mmap")]
let view = mmap.view()?;

// Write new file
let header = Header {
    nx: 512, ny: 512, nz: 256,
    mode: Mode::Float32 as i32,
    ..Header::new()
};

let mut file = MrcFile::create("output.mrc", header)?;
file.write_data(&your_float_data)?;

use mrc::MrcView;

struct Volume3D<'a> {
    view: MrcView<'a>,
    nx: usize,
    ny: usize,
    nz: usize,
}

impl<'a> Volume3D<'a> {
    fn new(view: MrcView<'a>) -> Result<Self, mrc::Error> {
        let (nx, ny, nz) = view.dimensions();
        Ok(Self { view, nx, ny, nz })
    }
    
    fn get_slice(&self, z: usize) -> Result<&[f32], mrc::Error> {
        if z >= self.nz {
            return Err(mrc::Error::InvalidDimensions);
        }
        
        let slice_size = self.nx * self.ny;
        let start = z * slice_size;
        let floats = self.view.view::<f32>()?;
        
        floats.get(start..start + slice_size)
            .ok_or(mrc::Error::InvalidDimensions)
    }
    
    fn get_voxel(&self, x: usize, y: usize, z: usize) -> Result<f32, mrc::Error> {
        let index = z * self.nx * self.ny + y * self.nx + x;
        let floats = self.view.view::<f32>()?;
        
        floats.get(index).copied()
            .ok_or(mrc::Error::InvalidDimensions)
    }
}

use mrc::{MrcFile, Mode};
use rayon::prelude::*;

fn process_directory(dir: &str) -> Result<(), Box<dyn std::error::Error>> {
    use std::fs;
    
    let entries = fs::read_dir(dir)?
        .filter_map(|e| e.ok())
        .filter(|e| e.path().extension().map_or(false, |ext| ext == "mrc"));
    
    entries.par_bridge().try_for_each(|entry| {
        let path = entry.path();
        let file = MrcFile::open(&path)?;
        let view = file.view()?;
        
        if let Some(Mode::Float32) = view.mode() {
            let data = view.view::<f32>()?;
            let stats = calculate_statistics(data);
            println!("{:?}: RMS={:.3}", path.file_name(), stats.rms);
        }
        
        Ok::<_, Box<dyn std::error::Error>>(())
    })?;
    
    Ok(())
}

#[derive(Debug)]
struct Statistics {
    min: f32,
    max: f32,
    mean: f32,
    rms: f32,
}

fn calculate_statistics(data: &[f32]) -> Statistics {
    let min = data.iter().fold(f32::INFINITY, |a, &b| a.min(b));
    let max = data.iter().fold(f32::NEG_INFINITY, |a, &b| a.max(b));
    let mean = data.iter().sum::<f32>() / data.len() as f32;
    let rms = (data.iter().map(|&x| x * x).sum::<f32>() / data.len() as f32).sqrt();
    
    Statistics { min, max, mean, rms }
}

use mrc::{Header, MrcView, Mode};

// Works without std library
let view = MrcView::new(header, data)?;
let floats = view.view::<f32>()?;
// Process data in embedded/RTOS environments

// Use memory mapping for large files
#[cfg(feature = "mmap")]
let view = MrcMmap::open("large.mrc")?.view()?;

// Cache data size calculations
let data_size = view.header().data_size();

// Use aligned access for SIMD
let aligned = view.data_aligned::<f32>()?;