Remove image abstractions in iced_graphics
This commit is contained in:
Héctor Ramón Jiménez
parent
9b4bcd287a
commit
3a26baa564
11 changed files with 352 additions and 436 deletions
|
|
@ -11,22 +11,9 @@ keywords = ["gui", "ui", "graphics", "interface", "widgets"]
|
|||
categories = ["gui"]
|
||||
|
||||
[features]
|
||||
svg = ["resvg"]
|
||||
image = ["png", "jpeg", "jpeg_rayon", "gif", "webp", "bmp"]
|
||||
png = ["image_rs/png"]
|
||||
jpeg = ["image_rs/jpeg"]
|
||||
jpeg_rayon = ["image_rs/jpeg_rayon"]
|
||||
gif = ["image_rs/gif"]
|
||||
webp = ["image_rs/webp"]
|
||||
pnm = ["image_rs/pnm"]
|
||||
ico = ["image_rs/ico"]
|
||||
bmp = ["image_rs/bmp"]
|
||||
hdr = ["image_rs/hdr"]
|
||||
dds = ["image_rs/dds"]
|
||||
farbfeld = ["image_rs/farbfeld"]
|
||||
geometry = ["lyon_path"]
|
||||
opengl = []
|
||||
image_rs = ["kamadak-exif"]
|
||||
image = ["dep:image", "kamadak-exif"]
|
||||
|
||||
[dependencies]
|
||||
glam = "0.21.3"
|
||||
|
|
@ -47,14 +34,8 @@ path = "../core"
|
|||
version = "0.8"
|
||||
optional = true
|
||||
|
||||
[dependencies.image_rs]
|
||||
[dependencies.image]
|
||||
version = "0.24"
|
||||
package = "image"
|
||||
default-features = false
|
||||
optional = true
|
||||
|
||||
[dependencies.resvg]
|
||||
version = "0.29"
|
||||
optional = true
|
||||
|
||||
[dependencies.kamadak-exif]
|
||||
|
|
|
|||
|
|
@ -1,10 +1,94 @@
|
|||
//! Render images.
|
||||
#[cfg(feature = "image_rs")]
|
||||
pub mod raster;
|
||||
//! Load and operate on images.
|
||||
use crate::core::image::{Data, Handle};
|
||||
|
||||
#[cfg(feature = "svg")]
|
||||
pub mod vector;
|
||||
use bitflags::bitflags;
|
||||
|
||||
pub mod storage;
|
||||
pub use ::image as image_rs;
|
||||
|
||||
pub use storage::Storage;
|
||||
pub fn load(handle: &Handle) -> image_rs::ImageResult<image_rs::DynamicImage> {
|
||||
match handle.data() {
|
||||
Data::Path(path) => {
|
||||
let image = ::image::open(path)?;
|
||||
|
||||
let operation = std::fs::File::open(path)
|
||||
.ok()
|
||||
.map(std::io::BufReader::new)
|
||||
.and_then(|mut reader| Operation::from_exif(&mut reader).ok())
|
||||
.unwrap_or_else(Operation::empty);
|
||||
|
||||
Ok(operation.perform(image))
|
||||
}
|
||||
Data::Bytes(bytes) => {
|
||||
let image = ::image::load_from_memory(bytes)?;
|
||||
let operation =
|
||||
Operation::from_exif(&mut std::io::Cursor::new(bytes))
|
||||
.ok()
|
||||
.unwrap_or_else(Operation::empty);
|
||||
|
||||
Ok(operation.perform(image))
|
||||
}
|
||||
Data::Rgba {
|
||||
width,
|
||||
height,
|
||||
pixels,
|
||||
} => {
|
||||
if let Some(image) = image_rs::ImageBuffer::from_vec(
|
||||
*width,
|
||||
*height,
|
||||
pixels.to_vec(),
|
||||
) {
|
||||
Ok(image_rs::DynamicImage::ImageRgba8(image))
|
||||
} else {
|
||||
Err(image_rs::error::ImageError::Limits(
|
||||
image_rs::error::LimitError::from_kind(
|
||||
image_rs::error::LimitErrorKind::DimensionError,
|
||||
),
|
||||
))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bitflags! {
|
||||
struct Operation: u8 {
|
||||
const FLIP_HORIZONTALLY = 0b001;
|
||||
const ROTATE_180 = 0b010;
|
||||
const FLIP_DIAGONALLY = 0b100;
|
||||
}
|
||||
}
|
||||
|
||||
impl Operation {
|
||||
// Meaning of the returned value is described e.g. at:
|
||||
// https://magnushoff.com/articles/jpeg-orientation/
|
||||
fn from_exif<R>(reader: &mut R) -> Result<Self, exif::Error>
|
||||
where
|
||||
R: std::io::BufRead + std::io::Seek,
|
||||
{
|
||||
let exif = exif::Reader::new().read_from_container(reader)?;
|
||||
|
||||
Ok(exif
|
||||
.get_field(exif::Tag::Orientation, exif::In::PRIMARY)
|
||||
.and_then(|field| field.value.get_uint(0))
|
||||
.and_then(|value| u8::try_from(value).ok())
|
||||
.and_then(|value| Self::from_bits(value.saturating_sub(1)))
|
||||
.unwrap_or_else(Self::empty))
|
||||
}
|
||||
|
||||
fn perform(self, mut image: image::DynamicImage) -> image::DynamicImage {
|
||||
use image::imageops;
|
||||
|
||||
if self.contains(Self::FLIP_DIAGONALLY) {
|
||||
imageops::flip_vertical_in_place(&mut image)
|
||||
}
|
||||
|
||||
if self.contains(Self::ROTATE_180) {
|
||||
imageops::rotate180_in_place(&mut image);
|
||||
}
|
||||
|
||||
if self.contains(Self::FLIP_HORIZONTALLY) {
|
||||
imageops::flip_horizontal_in_place(&mut image);
|
||||
}
|
||||
|
||||
image
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,242 +0,0 @@
|
|||
//! Raster image loading and caching.
|
||||
use crate::image::Storage;
|
||||
|
||||
use iced_core::image;
|
||||
use iced_core::Size;
|
||||
|
||||
use bitflags::bitflags;
|
||||
use std::collections::{HashMap, HashSet};
|
||||
|
||||
/// Entry in cache corresponding to an image handle
|
||||
#[derive(Debug)]
|
||||
pub enum Memory<T: Storage> {
|
||||
/// Image data on host
|
||||
Host(::image_rs::ImageBuffer<::image_rs::Rgba<u8>, Vec<u8>>),
|
||||
/// Storage entry
|
||||
Device(T::Entry),
|
||||
/// Image not found
|
||||
NotFound,
|
||||
/// Invalid image data
|
||||
Invalid,
|
||||
}
|
||||
|
||||
impl<T: Storage> Memory<T> {
|
||||
/// Width and height of image
|
||||
pub fn dimensions(&self) -> Size<u32> {
|
||||
use crate::image::storage::Entry;
|
||||
|
||||
match self {
|
||||
Memory::Host(image) => {
|
||||
let (width, height) = image.dimensions();
|
||||
|
||||
Size::new(width, height)
|
||||
}
|
||||
Memory::Device(entry) => entry.size(),
|
||||
Memory::NotFound => Size::new(1, 1),
|
||||
Memory::Invalid => Size::new(1, 1),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Caches image raster data
|
||||
#[derive(Debug)]
|
||||
pub struct Cache<T: Storage> {
|
||||
map: HashMap<u64, Memory<T>>,
|
||||
hits: HashSet<u64>,
|
||||
}
|
||||
|
||||
impl<T: Storage> Cache<T> {
|
||||
/// Load image
|
||||
pub fn load(&mut self, handle: &image::Handle) -> &mut Memory<T> {
|
||||
if self.contains(handle) {
|
||||
return self.get(handle).unwrap();
|
||||
}
|
||||
|
||||
let memory = match handle.data() {
|
||||
image::Data::Path(path) => {
|
||||
if let Ok(image) = image_rs::open(path) {
|
||||
let operation = std::fs::File::open(path)
|
||||
.ok()
|
||||
.map(std::io::BufReader::new)
|
||||
.and_then(|mut reader| {
|
||||
Operation::from_exif(&mut reader).ok()
|
||||
})
|
||||
.unwrap_or_else(Operation::empty);
|
||||
|
||||
Memory::Host(operation.perform(image.to_rgba8()))
|
||||
} else {
|
||||
Memory::NotFound
|
||||
}
|
||||
}
|
||||
image::Data::Bytes(bytes) => {
|
||||
if let Ok(image) = image_rs::load_from_memory(bytes) {
|
||||
let operation =
|
||||
Operation::from_exif(&mut std::io::Cursor::new(bytes))
|
||||
.ok()
|
||||
.unwrap_or_else(Operation::empty);
|
||||
|
||||
Memory::Host(operation.perform(image.to_rgba8()))
|
||||
} else {
|
||||
Memory::Invalid
|
||||
}
|
||||
}
|
||||
image::Data::Rgba {
|
||||
width,
|
||||
height,
|
||||
pixels,
|
||||
} => {
|
||||
if let Some(image) = image_rs::ImageBuffer::from_vec(
|
||||
*width,
|
||||
*height,
|
||||
pixels.to_vec(),
|
||||
) {
|
||||
Memory::Host(image)
|
||||
} else {
|
||||
Memory::Invalid
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
self.insert(handle, memory);
|
||||
self.get(handle).unwrap()
|
||||
}
|
||||
|
||||
/// Load image and upload raster data
|
||||
pub fn upload(
|
||||
&mut self,
|
||||
handle: &image::Handle,
|
||||
state: &mut T::State<'_>,
|
||||
storage: &mut T,
|
||||
) -> Option<&T::Entry> {
|
||||
let memory = self.load(handle);
|
||||
|
||||
if let Memory::Host(image) = memory {
|
||||
let (width, height) = image.dimensions();
|
||||
|
||||
let entry = storage.upload(width, height, image, state)?;
|
||||
|
||||
*memory = Memory::Device(entry);
|
||||
}
|
||||
|
||||
if let Memory::Device(allocation) = memory {
|
||||
Some(allocation)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// Trim cache misses from cache
|
||||
pub fn trim(&mut self, storage: &mut T, state: &mut T::State<'_>) {
|
||||
let hits = &self.hits;
|
||||
|
||||
self.map.retain(|k, memory| {
|
||||
let retain = hits.contains(k);
|
||||
|
||||
if !retain {
|
||||
if let Memory::Device(entry) = memory {
|
||||
storage.remove(entry, state);
|
||||
}
|
||||
}
|
||||
|
||||
retain
|
||||
});
|
||||
|
||||
self.hits.clear();
|
||||
}
|
||||
|
||||
fn get(&mut self, handle: &image::Handle) -> Option<&mut Memory<T>> {
|
||||
let _ = self.hits.insert(handle.id());
|
||||
|
||||
self.map.get_mut(&handle.id())
|
||||
}
|
||||
|
||||
fn insert(&mut self, handle: &image::Handle, memory: Memory<T>) {
|
||||
let _ = self.map.insert(handle.id(), memory);
|
||||
}
|
||||
|
||||
fn contains(&self, handle: &image::Handle) -> bool {
|
||||
self.map.contains_key(&handle.id())
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Storage> Default for Cache<T> {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
map: HashMap::new(),
|
||||
hits: HashSet::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bitflags! {
|
||||
struct Operation: u8 {
|
||||
const FLIP_HORIZONTALLY = 0b001;
|
||||
const ROTATE_180 = 0b010;
|
||||
const FLIP_DIAGONALLY = 0b100;
|
||||
}
|
||||
}
|
||||
|
||||
impl Operation {
|
||||
// Meaning of the returned value is described e.g. at:
|
||||
// https://magnushoff.com/articles/jpeg-orientation/
|
||||
fn from_exif<R>(reader: &mut R) -> Result<Self, exif::Error>
|
||||
where
|
||||
R: std::io::BufRead + std::io::Seek,
|
||||
{
|
||||
let exif = exif::Reader::new().read_from_container(reader)?;
|
||||
|
||||
Ok(exif
|
||||
.get_field(exif::Tag::Orientation, exif::In::PRIMARY)
|
||||
.and_then(|field| field.value.get_uint(0))
|
||||
.and_then(|value| u8::try_from(value).ok())
|
||||
.and_then(|value| Self::from_bits(value.saturating_sub(1)))
|
||||
.unwrap_or_else(Self::empty))
|
||||
}
|
||||
|
||||
fn perform<P>(
|
||||
self,
|
||||
image: image_rs::ImageBuffer<P, Vec<P::Subpixel>>,
|
||||
) -> image_rs::ImageBuffer<P, Vec<P::Subpixel>>
|
||||
where
|
||||
P: image_rs::Pixel + 'static,
|
||||
{
|
||||
use image_rs::imageops;
|
||||
|
||||
let mut image = if self.contains(Self::FLIP_DIAGONALLY) {
|
||||
flip_diagonally(image)
|
||||
} else {
|
||||
image
|
||||
};
|
||||
|
||||
if self.contains(Self::ROTATE_180) {
|
||||
imageops::rotate180_in_place(&mut image);
|
||||
}
|
||||
|
||||
if self.contains(Self::FLIP_HORIZONTALLY) {
|
||||
imageops::flip_horizontal_in_place(&mut image);
|
||||
}
|
||||
|
||||
image
|
||||
}
|
||||
}
|
||||
|
||||
fn flip_diagonally<I>(
|
||||
image: I,
|
||||
) -> image_rs::ImageBuffer<I::Pixel, Vec<<I::Pixel as image_rs::Pixel>::Subpixel>>
|
||||
where
|
||||
I: image_rs::GenericImage,
|
||||
I::Pixel: 'static,
|
||||
{
|
||||
let (width, height) = image.dimensions();
|
||||
let mut out = image_rs::ImageBuffer::new(height, width);
|
||||
|
||||
for x in 0..width {
|
||||
for y in 0..height {
|
||||
let p = image.get_pixel(x, y);
|
||||
|
||||
out.put_pixel(y, x, p);
|
||||
}
|
||||
}
|
||||
|
||||
out
|
||||
}
|
||||
|
|
@ -1,190 +0,0 @@
|
|||
//! Vector image loading and caching
|
||||
use crate::image::Storage;
|
||||
|
||||
use iced_core::svg;
|
||||
use iced_core::{Color, Size};
|
||||
|
||||
use resvg::tiny_skia;
|
||||
use resvg::usvg;
|
||||
use std::collections::{HashMap, HashSet};
|
||||
use std::fs;
|
||||
|
||||
/// Entry in cache corresponding to an svg handle
|
||||
pub enum Svg {
|
||||
/// Parsed svg
|
||||
Loaded(usvg::Tree),
|
||||
/// Svg not found or failed to parse
|
||||
NotFound,
|
||||
}
|
||||
|
||||
impl Svg {
|
||||
/// Viewport width and height
|
||||
pub fn viewport_dimensions(&self) -> Size<u32> {
|
||||
match self {
|
||||
Svg::Loaded(tree) => {
|
||||
let size = tree.size;
|
||||
|
||||
Size::new(size.width() as u32, size.height() as u32)
|
||||
}
|
||||
Svg::NotFound => Size::new(1, 1),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Caches svg vector and raster data
|
||||
#[derive(Debug)]
|
||||
pub struct Cache<T: Storage> {
|
||||
svgs: HashMap<u64, Svg>,
|
||||
rasterized: HashMap<(u64, u32, u32, ColorFilter), T::Entry>,
|
||||
svg_hits: HashSet<u64>,
|
||||
rasterized_hits: HashSet<(u64, u32, u32, ColorFilter)>,
|
||||
}
|
||||
|
||||
type ColorFilter = Option<[u8; 4]>;
|
||||
|
||||
impl<T: Storage> Cache<T> {
|
||||
/// Load svg
|
||||
pub fn load(&mut self, handle: &svg::Handle) -> &Svg {
|
||||
if self.svgs.contains_key(&handle.id()) {
|
||||
return self.svgs.get(&handle.id()).unwrap();
|
||||
}
|
||||
|
||||
let svg = match handle.data() {
|
||||
svg::Data::Path(path) => {
|
||||
let tree = fs::read_to_string(path).ok().and_then(|contents| {
|
||||
usvg::Tree::from_str(&contents, &usvg::Options::default())
|
||||
.ok()
|
||||
});
|
||||
|
||||
tree.map(Svg::Loaded).unwrap_or(Svg::NotFound)
|
||||
}
|
||||
svg::Data::Bytes(bytes) => {
|
||||
match usvg::Tree::from_data(bytes, &usvg::Options::default()) {
|
||||
Ok(tree) => Svg::Loaded(tree),
|
||||
Err(_) => Svg::NotFound,
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
let _ = self.svgs.insert(handle.id(), svg);
|
||||
self.svgs.get(&handle.id()).unwrap()
|
||||
}
|
||||
|
||||
/// Load svg and upload raster data
|
||||
pub fn upload(
|
||||
&mut self,
|
||||
handle: &svg::Handle,
|
||||
color: Option<Color>,
|
||||
[width, height]: [f32; 2],
|
||||
scale: f32,
|
||||
state: &mut T::State<'_>,
|
||||
storage: &mut T,
|
||||
) -> Option<&T::Entry> {
|
||||
let id = handle.id();
|
||||
|
||||
let (width, height) = (
|
||||
(scale * width).ceil() as u32,
|
||||
(scale * height).ceil() as u32,
|
||||
);
|
||||
|
||||
let color = color.map(Color::into_rgba8);
|
||||
let key = (id, width, height, color);
|
||||
|
||||
// TODO: Optimize!
|
||||
// We currently rerasterize the SVG when its size changes. This is slow
|
||||
// as heck. A GPU rasterizer like `pathfinder` may perform better.
|
||||
// It would be cool to be able to smooth resize the `svg` example.
|
||||
if self.rasterized.contains_key(&key) {
|
||||
let _ = self.svg_hits.insert(id);
|
||||
let _ = self.rasterized_hits.insert(key);
|
||||
|
||||
return self.rasterized.get(&key);
|
||||
}
|
||||
|
||||
match self.load(handle) {
|
||||
Svg::Loaded(tree) => {
|
||||
if width == 0 || height == 0 {
|
||||
return None;
|
||||
}
|
||||
|
||||
// TODO: Optimize!
|
||||
// We currently rerasterize the SVG when its size changes. This is slow
|
||||
// as heck. A GPU rasterizer like `pathfinder` may perform better.
|
||||
// It would be cool to be able to smooth resize the `svg` example.
|
||||
let mut img = tiny_skia::Pixmap::new(width, height)?;
|
||||
|
||||
resvg::render(
|
||||
tree,
|
||||
if width > height {
|
||||
usvg::FitTo::Width(width)
|
||||
} else {
|
||||
usvg::FitTo::Height(height)
|
||||
},
|
||||
tiny_skia::Transform::default(),
|
||||
img.as_mut(),
|
||||
)?;
|
||||
|
||||
let mut rgba = img.take();
|
||||
|
||||
if let Some(color) = color {
|
||||
rgba.chunks_exact_mut(4).for_each(|rgba| {
|
||||
if rgba[3] > 0 {
|
||||
rgba[0] = color[0];
|
||||
rgba[1] = color[1];
|
||||
rgba[2] = color[2];
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
let allocation = storage.upload(width, height, &rgba, state)?;
|
||||
log::debug!("allocating {} {}x{}", id, width, height);
|
||||
|
||||
let _ = self.svg_hits.insert(id);
|
||||
let _ = self.rasterized_hits.insert(key);
|
||||
let _ = self.rasterized.insert(key, allocation);
|
||||
|
||||
self.rasterized.get(&key)
|
||||
}
|
||||
Svg::NotFound => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Load svg and upload raster data
|
||||
pub fn trim(&mut self, storage: &mut T, state: &mut T::State<'_>) {
|
||||
let svg_hits = &self.svg_hits;
|
||||
let rasterized_hits = &self.rasterized_hits;
|
||||
|
||||
self.svgs.retain(|k, _| svg_hits.contains(k));
|
||||
self.rasterized.retain(|k, entry| {
|
||||
let retain = rasterized_hits.contains(k);
|
||||
|
||||
if !retain {
|
||||
storage.remove(entry, state);
|
||||
}
|
||||
|
||||
retain
|
||||
});
|
||||
self.svg_hits.clear();
|
||||
self.rasterized_hits.clear();
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Storage> Default for Cache<T> {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
svgs: HashMap::new(),
|
||||
rasterized: HashMap::new(),
|
||||
svg_hits: HashSet::new(),
|
||||
rasterized_hits: HashSet::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::fmt::Debug for Svg {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
Svg::Loaded(_) => write!(f, "Svg::Loaded"),
|
||||
Svg::NotFound => write!(f, "Svg::NotFound"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -28,13 +28,15 @@ mod viewport;
|
|||
|
||||
pub mod backend;
|
||||
pub mod compositor;
|
||||
pub mod image;
|
||||
pub mod primitive;
|
||||
pub mod renderer;
|
||||
|
||||
#[cfg(feature = "geometry")]
|
||||
pub mod geometry;
|
||||
|
||||
#[cfg(feature = "image")]
|
||||
pub mod image;
|
||||
|
||||
pub use antialiasing::Antialiasing;
|
||||
pub use backend::Backend;
|
||||
pub use compositor::Compositor;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue