Struct RawImage 

pub struct RawImage {

    pub camera: Camera,
    pub make: String,
    pub model: String,
    pub clean_make: String,
    pub clean_model: String,
    pub width: usize,
    pub height: usize,
    pub cpp: usize,
    pub bps: usize,
    pub wb_coeffs: [f32; 4],
    pub whitelevel: WhiteLevel,
    pub blacklevel: BlackLevel,
    pub xyz_to_cam: [[f32; 3]; 4],
    pub photometric: RawPhotometricInterpretation,
    pub active_area: Option<Rect>,
    pub crop_area: Option<Rect>,
    pub blackareas: Vec<Rect>,
    pub orientation: Orientation,
    pub data: RawImageData,
    pub color_matrix: HashMap<Illuminant, FlatColorMatrix>,
    pub dng_tags: HashMap<u16, Value>,
}

All the data needed to process this raw image, including the image data itself as well as all the needed metadata

Fields

camera: Camera

Camera definition

make: String

camera make as encoded in the file

model: String

camera model as encoded in the file

clean_make: String

make cleaned up to be consistent and short

clean_model: String

model cleaned up to be consistent and short

width: usize

width of the full image

height: usize

height of the full image

cpp: usize

number of components per pixel (1 for bayer, 3 for RGB images)

bps: usize

Bits per pixel

wb_coeffs: [f32; 4]

whitebalance coefficients encoded in the file in RGBE order

whitelevel: WhiteLevel

image whitelevels in RGBE order

blacklevel: BlackLevel

image blacklevels in RGBE order

xyz_to_cam: [[f32; 3]; 4]

matrix to convert XYZ to camera RGBE

photometric: RawPhotometricInterpretation

Photometric interpretation

active_area: Option<Rect>

how much to crop the image to get all the usable (non-black) area

crop_area: Option<Rect>

how much to crop the image to get all the recommended area

blackareas: Vec<Rect>

Areas of the sensor that is masked to prevent it from receiving light. Used to calculate black levels and noise.

orientation: Orientation

orientation of the image as indicated by the image metadata

data: RawImageData

image data itself, has width*height*cpp elements

color_matrix: HashMap<Illuminant, FlatColorMatrix>

dng_tags: HashMap<u16, Value>

Implementations

impl RawImage

pub fn calc_black_levels<T>( cfa: &CFA, blackareas: &[Rect], width: usize, _height: usize, image: &[T], ) -> Option<BlackLevel>

where T: SubPixel,

pub fn dim(&self) -> Dim2

pub fn pixels_u16(&self) -> &[u16]

pub fn pixels_u16_mut(&mut self) -> &mut [u16]

pub fn apply_scaling(&mut self) -> Result<()>

Apply blacklevel and whitelevel scaling, replacing raw image data with floating point values in range 0.0 .. 1.0. Internal blacklevel and whitelevel is reset to 0.0 and 1.0 to match image data.

pub fn develop_params(&self) -> Result<DevelopParams>

pub fn add_dng_tag<T: TiffTag, V: Into<Value>>(&mut self, tag: T, value: V)

Add a DNG tag override

pub fn linearize(&self) -> Result<Self>

pub fn cam_to_xyz(&self) -> [[f32; 4]; 3]

Outputs the inverted matrix that converts pixels in the camera colorspace into XYZ components.

pub fn cam_to_xyz_normalized(&self) -> [[f32; 4]; 3]

Outputs the inverted matrix that converts pixels in the camera colorspace into XYZ components normalized to be easily used to convert to Lab or a RGB output space

pub fn neutralwb(&self) -> [f32; 4]

Not all cameras encode a whitebalance so in those cases just using a 6500K neutral one is a good compromise

pub fn cropped_cfa(&self) -> CFA

Returns the CFA pattern after the crop has been applied (and thus the pattern potentially shifted)

pub fn is_monochrome(&self) -> bool

Checks if the image is monochrome

Trait Implementations

impl Clone for RawImage

fn clone(&self) -> RawImage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RawImage

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

Formats the value using the given formatter.

impl From<&RawImage> for RawParams

fn from(rawimage: &RawImage) -> Self

Converts to this type from the input type.