roya (50) - Imagen (3)

DynamicImage

DynamicImage son compatibles ImageBuffer

Tipo de enumeración. Es exactamente el tipo de imagen que se determina en tiempo de ejecución. Se devuelve cuando la imagen de tipo abierto. Para mayor comodidad, la imagen dinámica re-implementar todas las funciones de procesamiento de imágenes.
Por lo general, DynamicImage lograr RGBA función de imágenes de píxeles.

Subimagen
vista de otra imagen en una coordenada rectangular está acotado. Es para la realización de funciones de procesamiento de imagen de la sub-área de la imagen.

extern crate image;

use image::{GenericImageView, ImageBuffer, RgbImage, imageops};

let mut img: RgbImage = ImageBuffer::new(512, 512);
let subimg = imageops::crop(&mut img, 0, 0, 100, 100);

assert!(subimg.dimensions() == (100, 100));

Estas son las funciones definidas en el módulo imageops. Todas las funciones de los instrumentos de tipo GenericImage rasgo. Operar.
desenfoque: Falta de definición: realizado en una imagen de una oferta de desenfoque gaussiano.
Iluminar: más brillante: el brillo de la imagen suministrada
huerotate: tonalidad de la imagen para proporcionar un grado de rotación por
contraste Contraste: ajustar el contraste de una imagen proporcionada
Recortar le permite: Cultivo: un retorno variable para ver la imagen a una
filter3x3: una imagen proporcionada realiza un filtro de caja de 3x3.
flip_horizontal: flip horizontal: gira la imagen en sentido horizontal
flip_vertical: una imagen vertical flip
Escala de grises: Escala de grises: convertir la imagen a escala de grises suministra
Historial de la conversión: reversión de imagen proporcionada para cada píxel: inversa.
un cambio de tamaño: Cambiar el tamaño de: proporcionar imagen se ajusta al tamaño especificado
rotate180: girar la imagen en 180 grados en sentido horario.
girar el giratorio 270: 270 grados imagen rotación en sentido horario.
rotate90: girar la imagen 90 grados hacia la derecha.
unsharpen: sin punta: imagen proporcionada por la aplicación de la máscara sin punta

Abrir y guardar imágenes
imagen proporcionada por la ruta de la imagen abierta para la función abierta. Nombrar la decisión extensión de formato de imagen por la ruta del archivo. módulo io proporciona un lector más controlada.

extern crate image;

use image::GenericImageView;

fn main() {
    // Use the open function to load an image from a Path.
    // `open` returns a `DynamicImage` on success.
    let img = image::open("tests/images/jpg/progressive/cat.jpg").unwrap();

    // The dimensions method returns the images width and height.
    println!("dimensions {:?}", img.dimensions());

    // The color method returns the image's `ColorType`.
    println!("{:?}", img.color());

    // Write the contents of this image to the Writer in PNG format.
    img.save("test.png").unwrap();
}

fractal generado

//! An example of generating julia fractals.
extern crate image;
extern crate num_complex;

fn main() {
    let imgx = 800;
    let imgy = 800;

    let scalex = 3.0 / imgx as f32;
    let scaley = 3.0 / imgy as f32;

    // Create a new ImgBuf with width: imgx and height: imgy
    let mut imgbuf = image::ImageBuffer::new(imgx, imgy);

    // Iterate over the coordinates and pixels of the image
    for (x, y, pixel) in imgbuf.enumerate_pixels_mut() {
        let r = (0.3 * x as f32) as u8;
        let b = (0.3 * y as f32) as u8;
        *pixel = image::Rgb([r, 0, b]);
    }

    // A redundant loop to demonstrate reading image data
    for x in 0..imgx {
        for y in 0..imgy {
            let cx = y as f32 * scalex - 1.5;
            let cy = x as f32 * scaley - 1.5;

            let c = num_complex::Complex::new(-0.4, 0.6);
            let mut z = num_complex::Complex::new(cx, cy);

            let mut i = 0;
            while i < 255 && z.norm() <= 2.0 {
                z = z * z + c;
                i += 1;
            }

            let pixel = imgbuf.get_pixel_mut(x, y);
            let image::Rgb(data) = *pixel;
            *pixel = image::Rgb([data[0], i as u8, data[2]]);
        }
    }

    // Save the image as “fractal.png”, the format is deduced from the path
    imgbuf.save("fractal.png").unwrap();
}

Escribe búfer original
si es debido a que la imagen se obtiene por otros medios, y por lo tanto no requiere interfaz avanzada, la imagen proporcionada save_buffer función para guardar la memoria intermedia en un archivo.

extern crate image;

fn main() {

    let buffer: &[u8] = unimplemented!(); // Generate the image data

    // Save the buffer as "image.png"
    image::save_buffer("image.png", buffer, 800, 600, image::ColorType::Rgb8).unwrap()
}