mangatrans 1.0.2

Manga transcription data format and ways to render them into readable formats, statistics and more.
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

use crate::structure::*;
use crate::japanese::*;
use crate::report::*;

use std::fmt::Write;
use std::collections::HashMap;

#[derive(Debug, Clone, Default)]
pub struct LangStats{
    rp: ReportHeader,
    kanji: HashMap<String, usize>,
    other: HashMap<String, usize>,
}

pub fn lang_stats_report(mut s: LangStats, doc: &mut String){
    write_header(&mut s.rp, doc);

    write_list(&s.other, "Hiragana/Katakana frequencies:", "", doc);
    write_list(&s.kanji, "Kanji frequencies:", "", doc);
}

pub fn accumulate_lang_stats(chapter: Chapter, stats: &mut LangStats, log: &mut String){
    set_current_manga(&mut stats.rp.manga, chapter.manga.clone(), log);
    stats.rp.volumes.push(chapter.volume);
    stats.rp.chapters.push(chapter.chapter);

    if chapter.pic.is_empty() { return; }
    chapter_header_log(&chapter, log);

    for picture in chapter.pic{
        stats.rp.pictures += 1;

        if let Some(texts) = picture.text{
            for text in texts{
                log_todo(&text, log);
                let lines = text.lines.vectorize();
                let replacements = if let Some(kmap) = text.kmap{
                    let kmap = kmap.vectorize();
                    for [kanji, mapping] in &kmap{
                        let key = format!("{}: {}", kanji, mapping);
                        update(&mut stats.kanji, &key, |x| x + 1);
                    }
                    map_kanjis(&lines, kmap.as_slice())
                } else {
                    lines.clone()
                };
                if could_contain_kanji(&replacements){
                    let _ = writeln!(
                        log,
                        concat!("Warning: lines {:#?} contain kanji or untranslateable characters.",
                        "\nEvery kanji is counted as one (1) mora."),
                        replacements
                    );
                }
                let morae = replacements.iter().flat_map(|line| line.chars())
                    .fold(0, |acc, c| acc + to_mora(c));
                for line in lines{
                    let split = split_hirakata(&line);
                    for c in split{
                        update(&mut stats.other, &c.to_string(), |x| x + 1);
                    }
                }
                stats.rp.morae += morae;
            }
        };
    }
}