Enum Mode 

#[non_exhaustive]
pub enum Mode {
    Int8 = 0,
    Int16 = 1,
    Float32 = 2,
    Int16Complex = 3,
    Float32Complex = 4,
    Uint16 = 6,
    Float16 = 12,
    Packed4Bit = 101,
}

MRC data mode defining the on-disk representation of voxel values.

Example

use mrc::Mode;

let mode = Mode::Float32;
assert_eq!(mode.byte_size(), 4);
assert!(mode.is_float());
assert!(!mode.is_integer());

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Int8 = 0

Signed 8-bit integer (Mode 0).

Int16 = 1

Signed 16-bit integer (Mode 1).

Float32 = 2

32-bit floating point (Mode 2).

Int16Complex = 3

Complex number with 16-bit integer components (Mode 3)

Byte Order

The layout is [real i16 (2 bytes), imag i16 (2 bytes)] which matches the de facto standard used by CCP4, IMOD, and other MRC implementations. This is not explicitly specified in MRC2014 but is universally adopted.

Float32Complex = 4

Complex number with 32-bit float components (Mode 4)

Byte Order

The layout is [real f32 (4 bytes), imag f32 (4 bytes)] which matches the de facto standard used by CCP4, IMOD, and other MRC implementations. This is not explicitly specified in MRC2014 but is universally adopted.

Uint16 = 6

Unsigned 16-bit integer (Mode 6).

Float16 = 12

16-bit floating point (Mode 12).

Packed4Bit = 101

4-bit data packed two values per byte (Mode 101).

Each byte stores two 4-bit nibbles: low nibble = first pixel, high nibble = second pixel. Read via slices_u8 or convert::<f32>(); write via write_u4_block.

Implementations

impl Mode

pub const fn as_i32(self) -> i32

Return the MRC mode constant as an i32 value.

Example

use mrc::Mode;

assert_eq!(Mode::Int8.as_i32(), 0);
assert_eq!(Mode::Float32.as_i32(), 2);

pub fn from_i32(mode: i32) -> Option<Self>

Convert an MRC mode integer to a Mode enum value.

Returns None for unrecognized mode values.

Example

use mrc::Mode;

assert_eq!(Mode::from_i32(2), Some(Mode::Float32));
assert_eq!(Mode::from_i32(99), None);

pub fn byte_size(&self) -> usize

Number of bytes required to store one voxel in this mode.

For Packed4Bit this returns 1 (two voxels per byte); use byte_size_for_count for per-voxel sizing.

Example

use mrc::Mode;

assert_eq!(Mode::Int16.byte_size(), 2);
assert_eq!(Mode::Float32Complex.byte_size(), 8);

pub fn is_complex(&self) -> bool

Returns true if this mode stores complex numbers (real + imaginary components).

Example

use mrc::Mode;

assert!(Mode::Int16Complex.is_complex());
assert!(!Mode::Float32.is_complex());

pub fn is_integer(&self) -> bool

Returns true if this mode stores integer-valued data (including complex integers).

Example

use mrc::Mode;

assert!(Mode::Uint16.is_integer());
assert!(!Mode::Float32.is_integer());

pub fn is_float(&self) -> bool

Returns true if this mode stores floating-point data (including complex float).

Example

use mrc::Mode;

assert!(Mode::Float16.is_float());
assert!(!Mode::Int8.is_float());

pub fn byte_size_for_count(&self, n: usize) -> usize

Byte size for a given number of voxels.

For most modes this is n * byte_size(), but Packed4Bit stores two voxels per byte so the result is n.div_ceil(2).

Example

use mrc::Mode;

assert_eq!(Mode::Int16.byte_size_for_count(3), 6);
assert_eq!(Mode::Packed4Bit.byte_size_for_count(3), 2);

Trait Implementations

impl Clone for Mode

fn clone(&self) -> Mode

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Mode

impl Debug for Mode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Mode

impl PartialEq for Mode

fn eq(&self, other: &Mode) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Mode