Struct rustracer::hdrimage::HdrImage

pub struct HdrImage {
    width: u32,
    height: u32,
    pixels: Vec<Color>,
}

High Dynamic Range Image struct.

Fields

width: u32

Number of columns in the 2D matrix of colors.

height: u32

Number of rows in the 2D matrix of colors.

pixels: Vec<Color>

The 2D matrix, represented as a 1D std::vec::Vec of Color.

Implementations

impl HdrImage

pub fn new(width: u32, height: u32) -> Self

Create a black image with the specified resolution.

pub fn shape(&self) -> (u32, u32)

Get pixels matrix shape (width, heigth).

fn pixel_offset(&self, x: u32, y: u32) -> usize

Return the position in the 1D array of the specified pixel.

fn valid_coordinates(&self, x: u32, y: u32) -> bool

Return true if (x, y) are coordinates within the 2D matrix.

pub fn get_pixel(&self, x: u32, y: u32) -> Result<Color, HdrImageErr>

Return the Color value for a pixel in the image inside a std::result::Result.

For invalid (x, y) coordinates the result is an HdrImageErr error variant.

The pixel at the top-left corner has coordinates (0, 0).

pub fn set_pixel( &mut self, x: u32, y: u32, new_color: Color ) -> Result<(), HdrImageErr>

Set the new Color for a pixel in the image.

For invalid (x, y) coordinates the result is an HdrImageErr error variant.

The pixel at the top-left corner has coordinates (0, 0).

pub fn set_pixels(&mut self, pixels: Vec<Color>) -> Result<(), HdrImageErr>

Set pixels matrix, from underlying Vec structure, of the correct size.

Otherwise return HdrImageErr::InvalidPixelsSize variant.

fn read_pfm_image<R: BufRead>(buf_reader: &mut R) -> Result<Self, HdrImageErr>

Read a pfm image from buf_reader with std::io::BufRead trait implementation.

The expected input buffer must respect pfm format:

PF              # ASCII text, '\n' as line separator
width height    # ASCII text, '\n' as line separator
±1.0            # ASCII text, '\n' as line separator
pixels matrix   # binary content (float RGB x #pixels)

Little description:

• PF - the magic
• width height - image shape (note: space separated)
• ±1.0 - endianness (+1 big endian, -1 little endian) float codification
• pixels matrix - matrix of RGB float pixels encoded as function of endianness

Possible read failures, in precedence order:

1. Lack of first end line (check_eol)
2. Invalid magic (no PF)
3. Lack of second end line (check_eol)
4. Invalid image shape (parse_img_shape)
5. Lack of third end line (check_eol)
6. Invalid endianness (parse_endianness)
7. Invalid pixels matrix (error parsing float RGB)
8. Invalid EOF (unexpected binary content after pixels matrix read)

Parse of f32 from binary stream using byteorder library.
Return a HdrImage object containing the image inside a std::result::Result.
If an error occurs the result contains an HdrImageErr error variant.

pub fn read_pfm_file(path: &Path) -> Result<Self, HdrImageErr>

Read a pfm image from path, wrapper function around read_pfm_image.

Return a HdrImage object containing the image inside a std::result::Result.
If an error occurs the result contains an HdrImageErr error variant.

fn write_pfm_image<W: Write>( &self, stream: &mut W, endianness: ByteOrder ) -> Result<(), HdrImageErr>

Write a pfm image to stream with std::io::Write trait implementation.

The enum endianness specifies the byte endianness to be used in the file.

If an error occurs the result contains an HdrImageErr error variant.

pub fn write_pfm_file( &self, path: &Path, endianness: ByteOrder ) -> Result<(), HdrImageErr>

Write a pfm image to path, wrapper function around write_pfm_image.

If an error occurs the result contains an HdrImageErr error variant.

fn average_luminosity(&self) -> f32

Return the average luminosity of the image.

The DELTA constant is used to prevent numerical problems for under illuminated pixels.

pub fn normalize_image(&mut self, factor: f32, luminosity: Luminosity)

Normalize the image for a given luminosity.

factor is normalization factor.
Different variants of luminosity enum can be chosen.

pub fn clamp_image(&mut self)

Adjust the color levels of the brightest pixels in the image.

pub fn write_ldr_file(&self, path: &Path, gamma: f32) -> Result<(), HdrImageErr>

Save the image in a Low Dynamic Range (LDR) format, using image library.

gamma is transfer function parameter.

Note: the output format is auto-detected from the file name extension,
only two LDR image format are supported .ff (farbfeld) and .png (PNG).

Note: before calling this function, you should apply a tone-mapping algorithm to the image and
be sure that the RGB values of the colors in the image are all in the range [0, 1].
Use normalize_image and clamp_image to do this.

In case of errors, std::result::Result is an HdrImageErr error variant.

Trait Implementations

impl Clone for HdrImage

fn clone(&self) -> HdrImage

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for HdrImage

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

Formats the value using the given formatter.

impl PartialEq for HdrImage

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for HdrImage