ogp-createrを形態要素解析を使用するようにupdateした

use lindera_core::{mode::Mode, LinderaResult};
use lindera_dictionary::{DictionaryConfig, DictionaryKind};
use lindera_tokenizer::tokenizer::{Tokenizer, TokenizerConfig};

fn main() -> LinderaResult<()> {
    let dictionary = DictionaryConfig {
        kind: Some(DictionaryKind::IPADIC),
        path: None,
    };

    let config = TokenizerConfig {
        dictionary,
        user_dictionary: None,
        mode: Mode::Normal,
    };

    // create tokenizer
    let tokenizer = Tokenizer::from_config(config)?;

    // tokenize the text
    let tokens = tokenizer.tokenize("関西国際空港限定トートバッグ")?;

    // output the tokens
    for token in tokens {
        println!("{}", token.text);
    }

    Ok(())
}

fn split_string(
    text: &str,
    target_width: f32,
    font: &Font,
    default_scale: Scale,
) -> LinderaResult<Vec<String>> {
    let dictionary: DictionaryConfig = DictionaryConfig {
        kind: Some(DictionaryKind::IPADIC),
        path: None,
    };

    let config: TokenizerConfig = TokenizerConfig {
        dictionary,
        user_dictionary: None,
        mode: Mode::Normal,
    };

    let tokenizer: Tokenizer = Tokenizer::from_config(config)?;

    let tokens: Vec<lindera_tokenizer::token::Token> = tokenizer.tokenize(text)?; //ここで形態素解析
    let mut lines = Vec::new();
    let mut current_line = String::new();
    let mut current_width = 0.0;

    //単語ごとに幅を計算しながら行を構成する
    for token in tokens {
        let word = token.text;
        let word_width: f32 = word
            .chars()
            .map(|c| {
                font.glyph(c)
                    .scaled(default_scale)
                    .h_metrics()
                    .advance_width
            })
            .sum::<f32>();

        if current_width + word_width <= target_width {
            current_line.push_str(word);
            current_width += word_width;
        } else {
            lines.push(current_line);
            current_line = word.to_string();
            current_width = word_width;
        }
    }

    lines.push(current_line); // Add the last line
    Ok(lines)
}

fn draw_centered_lines(
    image: &mut ImageBuffer<Rgba<u8>, Vec<u8>>,
    font: &Font,
    lines: &[String],
    color: Rgba<u8>,
    scale: Scale,
) {
    let v_metrics: rusttype::VMetrics = font.v_metrics(scale);
    let line_height: f32 = v_metrics.ascent - v_metrics.descent + v_metrics.line_gap;
    let text_height: f32 = line_height * lines.len() as f32;
    let start_y: f32 = (image.height() as f32 - text_height) / 2.0;

    for (i, line) in lines.iter().enumerate() {
        let text_width: f32 = line
            .chars()
            .map(|c| font.glyph(c).scaled(scale).h_metrics().advance_width)
            .sum::<f32>();

        let start_x: f32 = (image.width() as f32 - text_width) / 2.0;
        let y_position: f32 = start_y + line_height * i as f32;

        draw_text_mut(
            image,
            color,
            start_x as i32,
            y_position as i32,
            scale,
            &font,
            line,
        );
    }
}