      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121

    //! This crate provides native rust implementations of
    //! image encoders and decoders and basic image manipulation
    //! functions.

    #![warn(missing_docs)]
    #![warn(unused_qualifications)]
    #![deny(missing_copy_implementations)]
    #![cfg_attr(all(test, feature = "benchmarks"), feature(test))]
    // it's a bit of a pain otherwise
    #![cfg_attr(feature = "cargo-clippy", allow(many_single_char_names))]

    extern crate byteorder;
    extern crate lzw;
    extern crate num_iter;
    extern crate num_rational;
    extern crate num_traits;
    #[cfg(feature = "hdr")]
    extern crate scoped_threadpool;
    #[cfg(all(test, feature = "benchmarks"))]
    extern crate test;

    #[cfg(test)]
    #[macro_use]
    extern crate quickcheck;

    use std::io::Write;

    pub use color::ColorType::{self, Gray, GrayA, Palette, RGB, RGBA, BGR, BGRA};

    pub use color::{Luma, LumaA, Rgb, Rgba, Bgr, Bgra};

    pub use image::{AnimationDecoder,
                    GenericImage,
                    GenericImageView,
                    ImageDecoder,
                    ImageDecoderExt,
                    ImageError,
                    ImageResult,
                    MutPixels,
                    // Iterators
                    Pixels,
                    SubImage};

    pub use imageops::FilterType::{self, CatmullRom, Gaussian, Lanczos3, Nearest, Triangle};

    pub use image::ImageFormat::{self, BMP, GIF, ICO, JPEG, PNG, PNM, WEBP};

    pub use image::ImageOutputFormat;

    pub use buffer::{ConvertBuffer,
                     GrayAlphaImage,
                     GrayImage,
                     // Image types
                     ImageBuffer,
                     Pixel,
                     RgbImage,
                     RgbaImage};

    pub use flat::{FlatSamples};

    // Traits
    pub use traits::Primitive;

    // Opening and loading images
    pub use dynimage::{guess_format, load, load_from_memory, load_from_memory_with_format, open,
                       save_buffer};

    pub use dynimage::DynamicImage::{self, ImageLuma8, ImageLumaA8, ImageRgb8, ImageRgba8, ImageBgr8, ImageBgra8};

    pub use animation::{Frame, Frames};

    // Math utils
    pub mod math;

    // Image processing functions
    pub mod imageops;

    // Buffer representations for ffi.
    pub mod flat;

    // Image codecs
    #[cfg(feature = "bmp")]
    pub mod bmp;
    #[cfg(feature = "dxt")]
    pub mod dxt;
    #[cfg(feature = "gif_codec")]
    pub mod gif;
    #[cfg(feature = "hdr")]
    pub mod hdr;
    #[cfg(feature = "ico")]
    pub mod ico;
    #[cfg(feature = "jpeg")]
    pub mod jpeg;
    #[cfg(feature = "png_codec")]
    pub mod png;
    #[cfg(feature = "pnm")]
    pub mod pnm;
    #[cfg(feature = "tga")]
    pub mod tga;
    #[cfg(feature = "tiff")]
    pub mod tiff;
    #[cfg(feature = "webp")]
    pub mod webp;

    mod animation;
    mod buffer;
    mod color;
    mod dynimage;
    mod image;
    mod traits;
    mod utils;

    // Copies data from `src` to `dst`
    //
    // Panics if the length of `dst` is less than the length of `src`.
    #[inline]
    fn copy_memory(src: &[u8], mut dst: &mut [u8]) {
        let len_src = src.len();
        assert!(dst.len() >= len_src);
        dst.write_all(src).unwrap();
    }

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)