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
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

pub mod settings;

use crate::settings::{GenerateDensityImageSettings, ImageDensitySource};
use density_mesh_core::{
    map::{DensityMap, DensityMapError},
    Scalar,
};
use image::{imageops::FilterType, DynamicImage, GenericImageView, GrayImage};

/// Generate density map image.
///
/// # Arguments
/// * `image` - Input image to process.
/// * `settings` - Image processing settings.
/// * `steepness` - If true produce steepness image, if false produce density image.
///
/// # Returns
/// Processed image or error.
pub fn generate_densitymap_image(
    image: DynamicImage,
    settings: &GenerateDensityImageSettings,
    steepness: bool,
) -> Result<DynamicImage, DensityMapError> {
    let map = generate_densitymap_from_image(image, settings)?;
    let data = if steepness {
        map.steepness()
            .iter()
            .map(|v| (v * 255.0) as u8)
            .collect::<Vec<_>>()
    } else {
        map.values()
            .iter()
            .map(|v| (v * 255.0) as u8)
            .collect::<Vec<_>>()
    };
    Ok(DynamicImage::ImageLuma8(
        GrayImage::from_raw(map.unscaled_width() as _, map.unscaled_height() as _, data).unwrap(),
    ))
}

/// Generate density map from image.
///
/// # Arguments
/// * `image` - Input image to process.
/// * `settings` - Image processing settings.
///
/// # Returns
/// Density map or error.
pub fn generate_densitymap_from_image(
    image: DynamicImage,
    settings: &GenerateDensityImageSettings,
) -> Result<DensityMap, DensityMapError> {
    let scale = settings.scale.max(1);
    let image = if scale > 1 {
        image.resize_exact(
            image.width() / scale as u32,
            image.height() / scale as u32,
            FilterType::Lanczos3,
        )
    } else {
        image
    };
    match settings.density_source {
        ImageDensitySource::Luma => {
            let img = image.to_luma();
            DensityMap::new(img.width() as _, img.height() as _, scale, img.into_raw())
        }
        ImageDensitySource::LumaAlpha => {
            let w = image.width();
            let h = image.height();
            let img = image.to_luma_alpha();
            let data = img
                .into_raw()
                .chunks(2)
                .map(|c| ((c[0] as Scalar / 255.0) * (c[1] as Scalar / 255.0) * 255.0) as u8)
                .collect::<Vec<_>>();
            DensityMap::new(w as _, h as _, scale, data)
        }
        ImageDensitySource::Red => {
            let w = image.width();
            let h = image.height();
            let data = image
                .to_rgba()
                .into_raw()
                .chunks(4)
                .map(|c| c[0])
                .collect::<Vec<_>>();
            DensityMap::new(w as _, h as _, scale, data)
        }
        ImageDensitySource::Green => {
            let w = image.width();
            let h = image.height();
            let data = image
                .to_rgba()
                .into_raw()
                .chunks(4)
                .map(|c| c[1])
                .collect::<Vec<_>>();
            DensityMap::new(w as _, h as _, scale, data)
        }
        ImageDensitySource::Blue => {
            let w = image.width();
            let h = image.height();
            let data = image
                .to_rgba()
                .into_raw()
                .chunks(4)
                .map(|c| c[2])
                .collect::<Vec<_>>();
            DensityMap::new(w as _, h as _, scale, data)
        }
        ImageDensitySource::Alpha => {
            let w = image.width();
            let h = image.height();
            let data = image
                .to_rgba()
                .into_raw()
                .chunks(4)
                .map(|c| c[3])
                .collect::<Vec<_>>();
            DensityMap::new(w as _, h as _, scale, data)
        }
    }
}

/// Generate image from density map.
///
/// # Arguments
/// * `map` - Input density map.
/// * `steepness` - If true produce steepness image, if false produce density image.
///
/// # Returns
/// Grayscale image.
pub fn generate_image_from_densitymap(map: &DensityMap, steepness: bool) -> DynamicImage {
    DynamicImage::ImageLuma8(
        GrayImage::from_raw(
            map.unscaled_width() as _,
            map.unscaled_height() as _,
            if steepness {
                map.steepness()
                    .iter()
                    .map(|v| (v * 255.0) as u8)
                    .collect::<Vec<_>>()
            } else {
                map.values()
                    .iter()
                    .map(|v| (v * 255.0) as u8)
                    .collect::<Vec<_>>()
            },
        )
        .unwrap(),
    )
}

pub mod prelude {
    pub use crate::{
        generate_densitymap_from_image, generate_densitymap_image, generate_image_from_densitymap,
        settings::*,
    };
}