katana-document-viewer 0.1.4

KatanA document viewer artifact, render evaluation, and export foundation.
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use crate::export_quality::types::{ExportFormatQualityScore, ExportQualityCheck, check};
use crate::forge::ExportFormat;
use image::GenericImageView;

const DOCUMENT_MIN_WIDTH: u32 = 640;
const DOCUMENT_MIN_HEIGHT: u32 = 480;
const DOCUMENT_MIN_AREA: u32 = DOCUMENT_MIN_WIDTH * DOCUMENT_MIN_HEIGHT;
const NON_EMPTY_SCORE_WEIGHT: u16 = 20;
const SIGNATURE_SCORE_WEIGHT: u16 = 20;
const DECODE_SCORE_WEIGHT: u16 = 25;
const SCALE_SCORE_WEIGHT: u16 = 25;
const AREA_SCORE_WEIGHT: u16 = 10;

pub(crate) struct ImageQualityScore;

impl ImageQualityScore {
    pub(crate) fn score(
        format: ExportFormat,
        bytes: &[u8],
        decoded: Result<(u32, u32), image::ImageError>,
        signature: &[u8],
    ) -> ExportFormatQualityScore {
        let label = format!("{format:?}").to_lowercase();
        ExportFormatQualityScore::new(format, Self::checks(&label, bytes, &decoded, signature))
    }

    pub(crate) fn decode_dimensions(bytes: &[u8]) -> Result<(u32, u32), image::ImageError> {
        image::load_from_memory(bytes).map(|image| image.dimensions())
    }

    fn checks(
        label: &str,
        bytes: &[u8],
        decoded: &Result<(u32, u32), image::ImageError>,
        signature: &[u8],
    ) -> Vec<ExportQualityCheck> {
        vec![
            Self::non_empty_check(label, bytes),
            Self::signature_check(label, bytes, signature),
            Self::decode_check(label, decoded),
            Self::scale_check(label, decoded),
            Self::area_check(label, decoded),
        ]
    }

    fn non_empty_check(label: &str, bytes: &[u8]) -> ExportQualityCheck {
        check(
            &format!("{label} is non-empty"),
            !bytes.is_empty(),
            true,
            NON_EMPTY_SCORE_WEIGHT,
        )
    }

    fn signature_check(label: &str, bytes: &[u8], signature: &[u8]) -> ExportQualityCheck {
        check(
            &format!("{label} has signature"),
            bytes.starts_with(signature),
            true,
            SIGNATURE_SCORE_WEIGHT,
        )
    }

    fn decode_check(
        label: &str,
        decoded: &Result<(u32, u32), image::ImageError>,
    ) -> ExportQualityCheck {
        check(
            &format!("{label} decodes"),
            decoded.is_ok(),
            true,
            DECODE_SCORE_WEIGHT,
        )
    }

    fn scale_check(
        label: &str,
        decoded: &Result<(u32, u32), image::ImageError>,
    ) -> ExportQualityCheck {
        check(
            &format!("{label} dimensions are document scale"),
            document_scale(decoded),
            true,
            SCALE_SCORE_WEIGHT,
        )
    }

    fn area_check(
        label: &str,
        decoded: &Result<(u32, u32), image::ImageError>,
    ) -> ExportQualityCheck {
        check(
            &format!("{label} is not visually blank"),
            has_area(decoded),
            true,
            AREA_SCORE_WEIGHT,
        )
    }
}

fn document_scale(decoded: &Result<(u32, u32), image::ImageError>) -> bool {
    decoded
        .as_ref()
        .is_ok_and(|(width, height)| *width >= DOCUMENT_MIN_WIDTH && *height >= DOCUMENT_MIN_HEIGHT)
}

fn has_area(decoded: &Result<(u32, u32), image::ImageError>) -> bool {
    decoded
        .as_ref()
        .is_ok_and(|(width, height)| width.saturating_mul(*height) > DOCUMENT_MIN_AREA)
}