subtile 0.4.1

A crate of utils to operate traitements on subtitles
Documentation 
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

use crate::SubtileError;
use image::{EncodableLayout, Pixel, PixelWithColorType};
use std::{
    borrow::Borrow,
    fs::create_dir_all,
    io,
    ops::Deref,
    path::{Path, PathBuf},
};
use thiserror::Error;

/// Handle Error for image dump.
#[derive(Error, Debug)]
#[non_exhaustive]
pub enum DumpError {
    /// Error with path creation
    #[error("could not create path for dump images '{}'", path.display())]
    Folder {
        /// Path of the folder
        path: PathBuf,
        /// Error source
        source: io::Error,
    },

    /// Error during file dump
    #[error("could not write image dump file '{}'", filename.display())]
    DumpImage {
        /// Path of the file write failed
        filename: PathBuf,
        /// Error source
        source: image::ImageError,
    },
}

/// Dump some images in a folder specified by the path.
///
/// # Errors
/// Will return `DumpError::Folder` if the output folder creation failed.
/// Will return `DumpError::DumpImage` if the dump of one image failed.
#[profiling::function]
pub fn dump_images<'a, Iter, Img, P, Container>(
    path: &str,
    images: Iter,
) -> Result<(), SubtileError>
where
    P: Pixel + PixelWithColorType + 'a,
    [P::Subpixel]: EncodableLayout,
    Container: Deref<Target = [P::Subpixel]> + 'a,
    Img: Borrow<image::ImageBuffer<P, Container>>,
    Iter: IntoIterator<Item = Img>,
{
    let folder_path = PathBuf::from(path);

    // create path if not exist
    if !folder_path.is_dir() {
        create_dir_all(folder_path.as_path()).map_err(|source| DumpError::Folder {
            path: folder_path.clone(),
            source,
        })?;
    }

    images
        .into_iter()
        .enumerate()
        .try_for_each(move |(i, img)| {
            let filepath = folder_path.clone().join(format!("{i:06}.png"));
            dump_image(&filepath, img.borrow()).map_err(|source| DumpError::DumpImage {
                filename: filepath,
                source,
            })
        })?;

    Ok(())
}

/// Dump one image
#[profiling::function]
fn dump_image<P, Pix, Container>(
    filename: P,
    image: &image::ImageBuffer<Pix, Container>, // image::Luma<u8>, Vec<u8>
) -> Result<(), image::ImageError>
where
    P: AsRef<Path>,
    Pix: Pixel + PixelWithColorType,
    [Pix::Subpixel]: EncodableLayout,
    Container: Deref<Target = [Pix::Subpixel]>,
{
    image.save(filename)
}