Struct RgbImage

pub struct RgbImage { /* private fields */ }

Creates a struct holding a raw RGB image

Implementations

impl RgbImage

pub fn new( data: &[u8], w: i32, h: i32, depth: ColorDepth, ) -> Result<RgbImage, FltkError>

Initializes a new raw RgbImage, copies the data and handles its lifetime. If you need to work with RGB data,

Errors

Errors on invalid or unsupported image format

Examples found in repository

examples/rgb.rs (line 18)

fn main() {
    let app = app::App::default();
    let mut wind = window::Window::default().with_size(400, 400);
    let mut frame = frame::Frame::default_fill();
    wind.make_resizable(true);
    wind.end();
    wind.show();
    frame.draw(move |f| {
        let mut fb: Vec<u8> = vec![0u8; (f.w() * f.h() * 4) as usize];
        for (iter, pixel) in fb.chunks_exact_mut(4).enumerate() {
            let x = iter % f.w() as usize;
            let y = iter / f.w() as usize;
            let (red, green, blue) = utils::hex2rgb((x ^ y) as u32);
            pixel.copy_from_slice(&[red, green, blue, 255]);
        }
        let mut image = image::RgbImage::new(&fb, f.w(), f.h(), ColorDepth::Rgba8)
            .unwrap()
            .to_srgb_image()
            .unwrap()
            .blur(50)
            .unwrap()
            .convert(ColorDepth::Rgb8)
            .unwrap();
        image.draw(f.x(), f.y(), f.w(), f.h());
    });

    app.run().unwrap();
}

pub unsafe fn from_data( data: &[u8], w: i32, h: i32, depth: ColorDepth, ) -> Result<RgbImage, FltkError>

Initializes a new raw RgbImage from shared data, doesn’t handle the data’s lifetime

Safety

The data must be valid for the lifetime of the image

Errors

Errors on invalid or unsupported image format

pub unsafe fn new_ext( data: &[u8], w: i32, h: i32, depth: i32, line_data: i32, ) -> Result<RgbImage, FltkError>

Initializes a new raw RgbImage, copies the data and handles its lifetime. If you need to work with RGB data,

Errors

Errors on invalid or unsupported image format

Safety

Passing wrong line data can read to over or underflow

pub unsafe fn from_data_ext( data: &[u8], w: i32, h: i32, depth: i32, line_data: i32, ) -> Result<RgbImage, FltkError>

Initializes a new raw RgbImage from shared data, doesn’t handle the data’s lifetime

Safety

The data must be valid for the lifetime of the image

Errors

Errors on invalid or unsupported image format

Safety

Passing wrong line data can read to over or underflow

pub fn from_pixmap(image: &Pixmap) -> RgbImage

Creates an RgbImage from a pixmap

pub unsafe fn into_parts(self) -> (Vec<u8>, i32, i32)

Deconstructs a raw RgbImage into parts

Safety

Destructures the image into its raw elements

pub fn convert(&self, new_depth: ColorDepth) -> Result<RgbImage, FltkError>

Convert from one ColorDepth to another ColorDepth

Examples found in repository

examples/rounded_images.rs (line 61)

fn main() {
    let app = app::App::default().with_scheme(app::Scheme::Gleam);
    app::background(0, 0, 0);
    let image = image::SharedImage::load("screenshots/calc2.jpg")
        .unwrap()
        .as_rgb_image()
        .unwrap();

    let mut wind = window::Window::new(100, 100, 800, 400, "Hello from rust");
    let row = group::Flex::default()
        .row()
        .with_size(800, 200)
        .center_of_parent();
    for i in 1..=4 {
        let color_depth = enums::ColorDepth::from_u8(i).unwrap();
        let image = image.convert(color_depth).unwrap();
        RoundImageBox::new(100, image);
    }
    row.end();
    wind.end();
    wind.show();

    app.run().unwrap();
}

examples/rgb.rs (line 24)

fn main() {
    let app = app::App::default();
    let mut wind = window::Window::default().with_size(400, 400);
    let mut frame = frame::Frame::default_fill();
    wind.make_resizable(true);
    wind.end();
    wind.show();
    frame.draw(move |f| {
        let mut fb: Vec<u8> = vec![0u8; (f.w() * f.h() * 4) as usize];
        for (iter, pixel) in fb.chunks_exact_mut(4).enumerate() {
            let x = iter % f.w() as usize;
            let y = iter / f.w() as usize;
            let (red, green, blue) = utils::hex2rgb((x ^ y) as u32);
            pixel.copy_from_slice(&[red, green, blue, 255]);
        }
        let mut image = image::RgbImage::new(&fb, f.w(), f.h(), ColorDepth::Rgba8)
            .unwrap()
            .to_srgb_image()
            .unwrap()
            .blur(50)
            .unwrap()
            .convert(ColorDepth::Rgb8)
            .unwrap();
        image.draw(f.x(), f.y(), f.w(), f.h());
    });

    app.run().unwrap();
}

pub fn convert_transparent(&self) -> Result<RgbImage, FltkError>

Convert black pixels to transparent

pub fn blur(&self, radius: u32) -> Result<RgbImage, FltkError>

Blur the image Adapted from https://www.cairographics.org/cookbook/blur.c/

Examples found in repository

examples/rgb.rs (line 22)

fn main() {
    let app = app::App::default();
    let mut wind = window::Window::default().with_size(400, 400);
    let mut frame = frame::Frame::default_fill();
    wind.make_resizable(true);
    wind.end();
    wind.show();
    frame.draw(move |f| {
        let mut fb: Vec<u8> = vec![0u8; (f.w() * f.h() * 4) as usize];
        for (iter, pixel) in fb.chunks_exact_mut(4).enumerate() {
            let x = iter % f.w() as usize;
            let y = iter / f.w() as usize;
            let (red, green, blue) = utils::hex2rgb((x ^ y) as u32);
            pixel.copy_from_slice(&[red, green, blue, 255]);
        }
        let mut image = image::RgbImage::new(&fb, f.w(), f.h(), ColorDepth::Rgba8)
            .unwrap()
            .to_srgb_image()
            .unwrap()
            .blur(50)
            .unwrap()
            .convert(ColorDepth::Rgb8)
            .unwrap();
        image.draw(f.x(), f.y(), f.w(), f.h());
    });

    app.run().unwrap();
}

pub fn to_srgb_image(&self) -> Result<RgbImage, FltkError>

Returns an SRGB image

Examples found in repository

examples/rgb.rs (line 20)

fn main() {
    let app = app::App::default();
    let mut wind = window::Window::default().with_size(400, 400);
    let mut frame = frame::Frame::default_fill();
    wind.make_resizable(true);
    wind.end();
    wind.show();
    frame.draw(move |f| {
        let mut fb: Vec<u8> = vec![0u8; (f.w() * f.h() * 4) as usize];
        for (iter, pixel) in fb.chunks_exact_mut(4).enumerate() {
            let x = iter % f.w() as usize;
            let y = iter / f.w() as usize;
            let (red, green, blue) = utils::hex2rgb((x ^ y) as u32);
            pixel.copy_from_slice(&[red, green, blue, 255]);
        }
        let mut image = image::RgbImage::new(&fb, f.w(), f.h(), ColorDepth::Rgba8)
            .unwrap()
            .to_srgb_image()
            .unwrap()
            .blur(50)
            .unwrap()
            .convert(ColorDepth::Rgb8)
            .unwrap();
        image.draw(f.x(), f.y(), f.w(), f.h());
    });

    app.run().unwrap();
}

pub fn set_scaling_algorithm(algorithm: RgbScaling)

Sets the scaling algorithm

pub fn scaling_algorithm() -> RgbScaling

Gets the scaling algorithm

Trait Implementations

impl Clone for RgbImage

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RgbImage

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

Formats the value using the given formatter.

impl Drop for RgbImage

fn drop(&mut self)

Executes the destructor for this type.

impl ImageExt for RgbImage

fn copy(&self) -> Self

Performs a deep copy of the image

fn copy_sized(&self, w: i32, h: i32) -> Self

Performs a deep copy of the image but to a new size. This will make use of the scaling algorithm when resizing.

fn draw(&mut self, arg2: i32, arg3: i32, arg4: i32, arg5: i32)

Draws the image at the presupplied coordinates and size

fn draw_ext( &mut self, arg2: i32, arg3: i32, arg4: i32, arg5: i32, cx: i32, cy: i32, )

Draws the image at the presupplied coordinates and size and offset cx, cy

fn w(&self) -> i32

Return the width of the image

fn h(&self) -> i32

Return the height of the image

fn as_image_ptr(&self) -> *mut Fl_Image

Returns a pointer of the image

unsafe fn from_image_ptr(ptr: *mut Fl_Image) -> Self

Transforms a raw image pointer to an image

fn as_rgb_data(&self) -> Vec<u8>

Returns the underlying raw rgb image data

fn as_rgb_image(&self) -> Result<RgbImage, FltkError>

Transforms the image into an RgbImage

fn scale( &mut self, width: i32, height: i32, proportional: bool, can_expand: bool, )

Scales the image

fn count(&self) -> i32

Return the count of pointers in an image (Pixmaps have more than 1, bitmaps have 0, Rgb based images have 1)

fn data_w(&self) -> i32

Gets the image’s data width

fn data_h(&self) -> i32

Gets the image’s data height

fn depth(&self) -> ColorDepth

Gets the image’s depth

fn ld(&self) -> i32

Gets the image’s line data size

fn inactive(&mut self)

Greys the image

unsafe fn delete(img: Self)

Deletes the image

fn was_deleted(&self) -> bool

Checks if the image was deleted

unsafe fn into_image<I: ImageExt>(self) -> I

Transforms an Image base into another Image

impl PartialEq for RgbImage

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for RgbImage

impl Send for RgbImage

Available on non-crate feature single-threaded only.

impl Sync for RgbImage

Available on non-crate feature single-threaded only.