Struct Image 

pub struct Image { /* private fields */ }

A decoded icon image.

An Image struct consists of a width, a height, a PixelFormat, and a data array encoding the image pixels in that format.

Regardless of format, pixel data for an image is always stored one complete pixel at a time, in row-major order (that is, the top-left pixel comes first, followed by the rest of the top row from left to right; then comes the second row down, again from left to right, and so on until finally the bottom-right pixel comes last).

Implementations

impl Image

pub fn read_png<R: BufRead + Seek>(input: R) -> Result<Image>

Reads an image from a PNG file.

Examples found in repository

examples/png2icns.rs (line 44)

fn main() {
    let num_args = env::args().count();
    if num_args < 2 || num_args > 3 {
        println!("Usage: png2icns <path> [<ostype>]");
        return;
    }
    let png_path = env::args().nth(1).unwrap();
    let png_path = Path::new(&png_path);
    let png_file = BufReader::new(File::open(png_path)
        .expect("failed to open PNG file"));
    let image = Image::read_png(png_file).expect("failed to read PNG file");
    let mut family = IconFamily::new();
    let icns_path = if num_args == 3 {
        let ostype = OSType::from_str(&env::args().nth(2).unwrap()).unwrap();
        let icon_type = IconType::from_ostype(ostype)
            .expect("unsupported ostype");
        family.add_icon_with_type(&image, icon_type)
            .expect("failed to encode image");
        png_path.with_extension(format!("{}.icns", ostype))
    } else {
        family.add_icon(&image).expect("failed to encode image");
        png_path.with_extension("icns")
    };
    let icns_file = BufWriter::new(File::create(icns_path)
        .expect("failed to create ICNS file"));
    family.write(icns_file).expect("failed to write ICNS file");
}

pub fn write_png<W: Write>(&self, output: W) -> Result<()>

Writes the image to a PNG file.

Examples found in repository

examples/icns2png.rs (line 78)

fn main() {
    let num_args = env::args().count();
    if num_args < 2 || num_args > 3 {
        println!("Usage: icns2png <path> [<ostype>|all]");
        return;
    }
    let icns_path = env::args().nth(1).unwrap();
    let icns_path = Path::new(&icns_path);
    let icns_file = BufReader::new(File::open(icns_path)
        .expect("failed to open ICNS file"));
    let family = IconFamily::read(icns_file)
        .expect("failed to read ICNS file");

    let (icon_type, typed_filename) = if num_args == 3 {
        let type_name = &env::args().nth(2).unwrap();
        if type_name == "all" {
            (None, true)
        } else {
            let ostype = OSType::from_str(type_name).unwrap();
            let icon_type = IconType::from_ostype(ostype)
            .expect("unsupported ostype");
            (Some(icon_type), true)
        }
    } else {
        // If no OSType is specified, extract the highest-resolution icon.
        let &icon_type = family.available_icons()
            .iter()
            .max_by_key(|icon_type| {
                icon_type.pixel_width() * icon_type.pixel_height()
            })
            .expect("ICNS file contains no icons");
        (Some(icon_type), true)
    };

    if let Some(icon_type) = icon_type {
        // Extract specific icon
        let image = family.get_icon_with_type(icon_type)
            .expect("ICNS file does not contain that icon type");
        let ext = if typed_filename {
            format!("{}.png", icon_type.ostype())
        } else {
            "png".to_string()
        };
        let png_path = icns_path.with_extension(ext);

        let png_file = BufWriter::new(File::create(png_path)
            .expect("failed to create PNG file"));
        image.write_png(png_file).expect("failed to write PNG file");

    } else {
        // Extract all icons (assuming no duplicates)
        for icon_type in family.available_icons() {
            let image = family.get_icon_with_type(icon_type)
                .expect("ICNS file does not contain that icon type");
            let png_path = icns_path.with_extension(format!("{}.png", icon_type.ostype()));
            let png_file = BufWriter::new(File::create(png_path)
                .expect("failed to create PNG file"));
            image.write_png(png_file).expect("failed to write PNG file");
        }
    }
}

impl Image

pub fn read_jp2(input: &[u8]) -> Result<Image>

Reads an image from a Jpeg 2000 file.

impl Image

pub fn new(format: PixelFormat, width: u32, height: u32) -> Image

Creates a new image with all pixel data set to zero.

Panics if the required memory exceeds isize::MAX, and on allocation failure.

pub fn from_data( format: PixelFormat, width: u32, height: u32, data: Vec<u8>, ) -> Result<Image>

Creates a new image using the given pixel data. Returns an error if the data array is not the correct length.

pub fn pixel_format(&self) -> PixelFormat

Returns the format in which this image’s pixel data is stored.

pub fn width(&self) -> u32

Returns the width of the image, in pixels.

pub fn height(&self) -> u32

Returns the height of the image, in pixels.

pub fn data(&self) -> &[u8]

Returns a reference to the image’s pixel data.

pub fn data_mut(&mut self) -> &mut [u8]

Returns a mutable reference to the image’s pixel data.

pub fn into_data(self) -> Box<[u8]>

Consumes the image, returning the pixel data without cloning it.

pub fn convert_to(&self, format: PixelFormat) -> Image

Creates a copy of this image by converting to the specified pixel format. This operation always succeeds, but may lose information (e.g. converting from RGBA to RGB will silently drop the alpha channel). If the source image is already in the requested format, this is equivalant to simply calling clone().

Trait Implementations

impl Clone for Image

fn clone(&self) -> Image

Returns a duplicate of the value.

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

Performs copy-assignment from source.