#[repr(transparent)]pub struct Image(_);
Expand description
An image type that can be displayed by the Image element. You can construct
Image objects from a path to an image file on disk, using Self::load_from_path
.
Another typical use-case is to render the image content with Rust code. For this it’s most efficient to create a new SharedPixelBuffer with the known dimensions and pass the mutable slice to your rendering function. Afterwards you can create an Image.
The following example creates a 320x200 RGB pixel buffer and calls an external
low_level_render() function to draw a shape into it. Finally the result is
stored in an Image with Self::from_rgb8()
:
fn low_level_render(width: u32, height: u32, buffer: &mut [u8]) {
// render beautiful circle or other shapes here
}
let mut pixel_buffer = SharedPixelBuffer::<Rgb8Pixel>::new(320, 200);
low_level_render(pixel_buffer.width(), pixel_buffer.height(),
pixel_buffer.make_mut_bytes());
let image = Image::from_rgb8(pixel_buffer);
Another use-case is to import existing image data into Slint, by creating a new Image through cloning of another image type.
The following example uses the popular image crate to
load a .png
file from disk, apply brightening filter on it and then import
it into an Image
:
let mut cat_image = image::open("cat.png").expect("Error loading cat image").into_rgba8();
image::imageops::colorops::brighten_in_place(&mut cat_image, 20);
let buffer = SharedPixelBuffer::<Rgba8Pixel>::clone_from_slice(
cat_image.as_raw(),
cat_image.width(),
cat_image.height(),
);
let image = Image::from_rgba8(buffer);
A popular software (CPU) rendering library in Rust is tiny-skia. The following example shows
how to use tiny-skia to render into a SharedPixelBuffer
:
let mut pixel_buffer = SharedPixelBuffer::<Rgba8Pixel>::new(640, 480);
let width = pixel_buffer.width();
let height = pixel_buffer.height();
let mut pixmap = tiny_skia::PixmapMut::from_bytes(
pixel_buffer.make_mut_bytes(), width, height
).unwrap();
pixmap.fill(tiny_skia::Color::TRANSPARENT);
let circle = tiny_skia::PathBuilder::from_circle(320., 240., 150.).unwrap();
let mut paint = tiny_skia::Paint::default();
paint.shader = tiny_skia::LinearGradient::new(
tiny_skia::Point::from_xy(100.0, 100.0),
tiny_skia::Point::from_xy(400.0, 400.0),
vec![
tiny_skia::GradientStop::new(0.0, tiny_skia::Color::from_rgba8(50, 127, 150, 200)),
tiny_skia::GradientStop::new(1.0, tiny_skia::Color::from_rgba8(220, 140, 75, 180)),
],
tiny_skia::SpreadMode::Pad,
tiny_skia::Transform::identity(),
).unwrap();
pixmap.fill_path(&circle, &paint, tiny_skia::FillRule::Winding, Default::default(), None);
let image = Image::from_rgba8_premultiplied(pixel_buffer);
Implementations
impl Image
impl Image
pub fn load_from_path(path: &Path) -> Result<Image, LoadImageError>
pub fn load_from_path(path: &Path) -> Result<Image, LoadImageError>
Load an Image from a path to a file containing an image
pub fn from_rgb8(buffer: SharedPixelBuffer<RGB<u8>>) -> Image
pub fn from_rgb8(buffer: SharedPixelBuffer<RGB<u8>>) -> Image
Creates a new Image from the specified shared pixel buffer, where each pixel has three color channels (red, green and blue) encoded as u8.
pub fn from_rgba8(buffer: SharedPixelBuffer<RGBA<u8, u8>>) -> Image
pub fn from_rgba8(buffer: SharedPixelBuffer<RGBA<u8, u8>>) -> Image
Creates a new Image from the specified shared pixel buffer, where each pixel has four color channels (red, green, blue and alpha) encoded as u8.
pub fn from_rgba8_premultiplied(
buffer: SharedPixelBuffer<RGBA<u8, u8>>
) -> Image
pub fn from_rgba8_premultiplied(
buffer: SharedPixelBuffer<RGBA<u8, u8>>
) -> Image
Creates a new Image from the specified shared pixel buffer, where each pixel has four color
channels (red, green, blue and alpha) encoded as u8 and, in contrast to Self::from_rgba8
,
the alpha channel is also assumed to be multiplied to the red, green and blue channels.
Only construct an Image with this function if you know that your pixels are encoded this way.
pub fn path(&self) -> Option<&Path>
pub fn path(&self) -> Option<&Path>
Returns the path of the image on disk, if it was constructed via Self::load_from_path
.
For example:
let path_buf = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../examples/printerdemo/ui/images/cat.jpg");
let image = Image::load_from_path(&path_buf).unwrap();
assert_eq!(image.path(), Some(path_buf.as_path()));
Trait Implementations
impl StructuralPartialEq for Image
Auto Trait Implementations
impl RefUnwindSafe for Image
impl Send for Image
impl !Sync for Image
impl Unpin for Image
impl UnwindSafe for Image
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
sourcefn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
impl<T> NoneValue for T where
T: Default,
impl<T> NoneValue for T where
T: Default,
type NoneType = T
fn null_value() -> T
fn null_value() -> T
The none-equivalent value.
impl<T> Pointable for T
impl<T> Pointable for T
sourceimpl<R, P> ReadPrimitive<R> for P where
R: Read + ReadEndian<P>,
P: Default,
impl<R, P> ReadPrimitive<R> for P where
R: Read + ReadEndian<P>,
P: Default,
sourcefn read_from_little_endian(read: &mut R) -> Result<Self, Error>
fn read_from_little_endian(read: &mut R) -> Result<Self, Error>
Read this value from the supplied reader. Same as ReadEndian::read_from_little_endian()
.
sourcefn read_from_big_endian(read: &mut R) -> Result<Self, Error>
fn read_from_big_endian(read: &mut R) -> Result<Self, Error>
Read this value from the supplied reader. Same as ReadEndian::read_from_big_endian()
.
sourcefn read_from_native_endian(read: &mut R) -> Result<Self, Error>
fn read_from_native_endian(read: &mut R) -> Result<Self, Error>
Read this value from the supplied reader. Same as ReadEndian::read_from_native_endian()
.
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
fn vzip(self) -> V
sourceimpl<T> WithSubscriber for T
impl<T> WithSubscriber for T
sourcefn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
sourcefn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more