Struct RawImage 

pub struct RawImage<'a> {
    pub shape: Vec<usize>,
    pub bitpix: Bitpix,
    pub scaling: Scaling,
    /* private fields */
}

An image read from an HDU, in whichever form the reader could give cheaply — returned by crate::FitsReader::read_image for both plain and tiled- compressed images, so callers needn’t know which they have. Carries the shape, BITPIX, and Scaling; the pixels are exposed lazily through decode, u8, physical, and unsigned.

A plain image borrows the data unit’s big-endian bytes in place (zero-copy); a compressed one (ZIMAGE) holds the reconstructed host-endian samples it had to decompress. The accessors paper over the difference — e.g. u8 is the zero-copy BITPIX = 8 plane either way — so you only reach for raw_bytes when you specifically want the undecoded on-disk bytes (plain images only).

Fields

shape: Vec<usize>

bitpix: Bitpix

scaling: Scaling

Implementations

impl<'a> RawImage<'a>

pub fn decode(&self) -> ImageData

The host-endian samples. For a plain image this byte-swaps the on-disk bytes into an owned buffer; a compressed image’s pixels are already decoded (cloned out here).

pub fn u8(&self) -> Option<&[u8]>

The samples as a borrowed &[u8] when no byte-swap is needed (BITPIX = 8): a plain image’s borrowed on-disk bytes, or a compressed image’s decoded u8 buffer. None for multi-byte element types — use RawImage::decode.

pub fn raw_bytes(&self) -> Option<&[u8]>

The undecoded big-endian on-disk bytes — Some only for a plain image (zero-copy borrow); None for a compressed one, whose pixels were reconstructed and have no on-disk byte form. Use RawImage::decode for the samples regardless of form.

pub fn physical(&self) -> Vec<f64>

The physical-plane values: BZERO + BSCALE × sample, BLANK → NaN (§3.4).

pub fn physical_f32(&self) -> Vec<f32>

The physical plane narrowed to f32 in a single pass — the compact, lossy counterpart to physical. The scaling is still evaluated in f64 (so each value is the correctly-rounded f32), but only one Vec<f32> is allocated rather than a Vec<f64> the caller then re-walks to narrow. Prefer it when the consumer wants f32 regardless (display, GPU upload, f32 pipelines); use physical when you need double precision — e.g. large BITPIX = 64 integers or fine BSCALE/BZERO past f32’s range.

pub fn unsigned(&self) -> Option<UnsignedView>

Exact typed integers when the scaling is the FITS unsigned (or signed-byte) convention; None otherwise — same rule as Image::unsigned.

pub fn sample_type(&self) -> SampleType

The effective element type these samples represent, resolving the unsigned and signed-byte conventions from BITPIX + Scaling without decoding the pixels.

impl RawImage<'_>

pub fn physical_array(&self) -> ArrayD<f64>

Available on crate feature ndarray only.

The physical plane as an N-d f64 array (BZERO + BSCALE × sample, BLANK → NaN), in FITS axis order — index arr[[x, y]].

pub fn to_ndarray(&self) -> ImageArray

Available on crate feature ndarray only.

The samples as a typed N-d ImageArray, in FITS axis order. Decodes into an owned buffer first (the array then owns it, no further copy).

Trait Implementations

impl<'a> Debug for RawImage<'a>

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

Formats the value using the given formatter.