Struct Normalizer 

pub struct Normalizer { /* private fields */ }

Maps raw FITS array values onto the 0.0..=1.0 range.

A FITS data array stores raw values that have to be shifted and scaled into physical units before they mean anything:

physical = BZERO + BSCALE * raw

Normalising additionally needs to know which physical values correspond to black and white. Those come from the DATAMIN and DATAMAX cards when the file carries them, and otherwise from the full representable range of BITPIX — for example BITPIX = 16 with BZERO = 32768 describes unsigned 16-bit samples, so physical 0 maps to 0.0 and physical 65535 maps to 1.0.

Floating point images have no representable range to fall back on, so they require DATAMIN and DATAMAX; see Normalizer::from_header.

An integer image may also mark pixels as carrying no value at all, with a BLANK card naming the raw value that means “undefined”. Such pixels have no physical value and no place on the 0.0..=1.0 scale, so both physical and normalize answer NaN for them — the same way FITS itself spells an undefined floating point sample.

Implementations

impl Normalizer

pub fn new(zero_offset: f64, scale: f64, minimum: f64, maximum: f64) -> Self

Builds a normaliser from explicit black and white points, given in physical units.

pub fn with_blank(self, blank: Option<i64>) -> Self

Marks blank as the raw value that means “this pixel is undefined”.

This is the BLANK card, which the standard defines only for the integer BITPIX types; a floating point image says the same thing with a NaN and needs no card for it.

pub fn blank(&self) -> Option<f64>

The raw value this normaliser treats as undefined, if any.

pub fn is_blank(&self, raw: f64) -> bool

Whether raw is the BLANK value, and so carries no data.

pub fn for_bitpix(bitpix: Bitpix, zero_offset: f64, scale: f64) -> Option<Self>

Builds a normaliser spanning the full representable range of bitpix.

Returns None for the floating point types, which have no such range; use Normalizer::from_samples or Normalizer::new for those.

pub fn from_samples( zero_offset: f64, scale: f64, samples: impl IntoIterator<Item = f64>, ) -> Self

Builds a normaliser whose black and white points are the smallest and largest values actually present in samples.

This is the honest choice for floating point images, which carry no representable range — but it needs every sample up front, so it is only available once the whole array has been read.

pub fn from_header( header: &Header, ) -> Result<Self, Box<dyn Error + Send + Sync>>

Builds a normaliser from a header’s BITPIX, BZERO, BSCALE, DATAMIN and DATAMAX cards.

Errors

Returns an error for a floating point image (BITPIX -32 or -64) that carries neither DATAMIN nor DATAMAX. Such an image has no black and white point that can be known without reading every pixel, so a single-pass normalisation is not possible — read the image with ImageHDU::read_image instead, which has the whole array available.

pub fn physical(&self, raw: f64) -> f64

Converts a raw array value into physical units.

A BLANK pixel has no physical value, and reads as NaN.

pub fn normalize(&self, raw: f64) -> f64

Converts a raw array value into the 0.0..=1.0 range.

Values outside the black and white points are clamped, which matters when DATAMIN and DATAMAX do not actually bound the data. A BLANK pixel is not clamped into range but reads as NaN, so that “undefined” stays distinguishable from “black”.

Trait Implementations

impl Clone for Normalizer

fn clone(&self) -> Normalizer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Normalizer

impl Debug for Normalizer

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

Formats the value using the given formatter.

impl PartialEq for Normalizer

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Normalizer