add source

README.md

@@ -14,7 +14,13 @@ license: mit
 ## Font Image Generation
 
 ```bash
-python -m kana.write.image generate-images --font-path /path/to/font.ttf
+python image.py generate
 ```
 
-- [Model Source](https://storage.openvinotoolkit.org/repositories/open_model_zoo/2023.0/models_bin/1/handwritten-japanese-recognition-0001/FP16-INT8)
+## Font Source
+
+- [Google Font - Kiwi Maru](https://fonts.google.com/specimen/Kiwi+Maru)
+
+## Model Source
+
+- [OpenVINO Open Model Zoo - Handwritten Japanese Recognition FP16-INT8](https://storage.openvinotoolkit.org/repositories/open_model_zoo/2023.0/models_bin/1/handwritten-japanese-recognition-0001/FP16-INT8)

app.py

@@ -0,0 +1,199 @@
+import random
+from copy import deepcopy
+from pathlib import Path
+
+import gradio as gr
+import numpy as np
+
+from utils import KanaData, Recognizer
+
+
+class App:
+    def __init__(
+        self,
+        kana_data_path="data/kana-data.json",
+        kana_char_dir="data/images/kana-chars",
+        bg_image_path="data/images/bg.png",
+        model_xml_path="model/model.xml",
+        model_char_path="model/chars.txt",
+        default_kana="あ",
+        font_name="Kiwi Maru",
+        brush_color="#111",
+        brush_size=15,
+    ):
+        self.brush_color = brush_color
+        self.brush_size = brush_size
+        self.bg_image_path = bg_image_path
+        self.recognizer = Recognizer(model_xml_path, model_char_path)
+
+        self.kana_data = KanaData.load(kana_data_path)
+        self.kana_set = {kana for kana in self.kana_data.spell if len(kana) == 1}
+
+        self.kana_char_dir = Path(kana_char_dir)
+        self.kana_images = [str(p) for p in self.kana_char_dir.rglob("*")]
+
+        self.font_name = font_name
+
+        self.default_kana = default_kana
+        self.default_kana_image = str(self.kana_char_dir / f"{self.default_kana}.png")
+        roma = self.conv_kana_to_roma(self.default_kana)
+        self.default_roma = f"{self.default_kana} ({roma})"
+
+        self.init_app()
+
+    def init_app(self):
+        with self.init_blocks() as self.app:
+            self.init_states()
+            self.init_layout()
+            self.init_events()
+            self.init_storage()
+
+    def init_blocks(self):
+        return gr.Blocks(title="假名手寫練習")
+
+    def init_layout(self):
+        with gr.Sidebar("練習設定"):
+            self.init_setting_tab()
+        with gr.Tab("寫字練習"):
+            self.init_practice_tab()
+
+    def init_states(self):
+        self.curr_kana = gr.State(self.default_kana)
+        self.curr_kana_list = gr.State(list())
+        self.curr_kana_image = gr.State(self.default_kana_image)
+
+    def init_practice_tab(self):
+        self.sketchpad = gr.Sketchpad(
+            self.default_kana_image,
+            type="numpy",
+            image_mode="RGB",
+            brush=gr.Brush(self.brush_size, self.brush_color),
+            eraser=False,
+            layers=False,
+            label="寫字板",
+        )
+
+        with gr.Row():
+            self.target_txt = gr.Textbox(self.default_roma, label="練習目標")
+            self.result_txt = gr.Textbox(label="辨識結果")
+
+        with gr.Row():
+            self.next_btn = gr.Button("下一個字")
+            self.recog_btn = gr.Button("手寫辨識")
+
+    def init_setting_tab(self):
+        with gr.Row():
+            self.use_assist_chk = gr.Checkbox(True, label="顯示輔助字")
+            self.use_kana_hint_chk = gr.Checkbox(True, label="提示假名")
+
+    def init_events(self):
+        recog_kwargs = gr_kwargs(self.do_recog, self.sketchpad, self.result_txt)
+
+        next_inputs = [self.use_assist_chk, self.use_kana_hint_chk, self.curr_kana_list]
+        next_outputs = [self.curr_kana, self.sketchpad, self.curr_kana_image]
+        next_outputs += [self.target_txt, self.result_txt, self.curr_kana_list]
+        next_kwargs = gr_kwargs(self.get_rand_kana, next_inputs, next_outputs)
+
+        clear_kwargs = gr_kwargs(self.clear, self.curr_kana_image, self.sketchpad)
+
+        update_inputs = [self.curr_kana, self.use_assist_chk]
+        update_inputs += [self.use_kana_hint_chk, self.curr_kana_list]
+        update_outputs = [self.curr_kana, self.sketchpad, self.curr_kana_image]
+        update_outputs += [self.target_txt, self.curr_kana_list]
+        update_kwargs = gr_kwargs(self.update, update_inputs, update_outputs)
+
+        self.recog_btn.click(**recog_kwargs)
+        self.next_btn.click(**next_kwargs)
+        self.sketchpad.clear(**clear_kwargs)
+        self.use_assist_chk.change(**update_kwargs)
+        self.use_kana_hint_chk.change(**update_kwargs)
+
+    def init_storage(self):
+        components = [self.use_assist_chk, self.use_kana_hint_chk]
+        triggers = [component.change for component in components]
+
+        default_value = [component.value for component in components]
+        browser_state = gr.BrowserState(
+            default_value,
+            storage_key="storage-key",
+            secret="secret",
+        )
+
+        self.app.load(inputs=browser_state, outputs=components)(lambda data: data)
+        gr.on(triggers, inputs=components, outputs=browser_state)(lambda *data: data)
+
+    def launch_app(self):
+        font = gr.themes.GoogleFont(self.font_name)
+        text_size = gr.themes.sizes.text_lg
+        theme = gr.themes.Ocean(font=font, text_size=text_size)
+        self.app.launch(theme=theme)
+
+    def conv_kana_to_roma(self, kana):
+        return self.kana_data.spell[kana][0]
+
+    def init_kana_list(self):
+        curr_kana_list = deepcopy(self.kana_images)
+        random.shuffle(curr_kana_list)
+        return curr_kana_list
+
+    def get_kana(self, kana: str, use_assist: bool, use_kana_hint: bool, kana_list: list):
+        kana_list = kana_list if kana_list else self.init_kana_list()
+        kana_image = self.kana_char_dir / f"{kana}.png" if kana else kana_list.pop()
+        kana = Path(kana_image).stem
+
+        kana_image = kana_image if use_assist else self.bg_image_path
+
+        roma = self.conv_kana_to_roma(kana)
+        roma = f"{kana} ({roma})" if use_kana_hint else f"{roma}"
+
+        return kana, str(kana_image), roma, kana_list
+
+    def parse_item(self, item):
+        prob = item["prob"]
+        char = item["char"]
+        return f"{char} ({self.conv_kana_to_roma(char)}): {prob:.2%}"
+
+    def is_valid_item(self, item):
+        if item["prob"] < 1e-2:
+            return False
+        if item["char"] not in self.kana_set:
+            return False
+        return True
+
+    def do_recog(self, image: dict[str, np.ndarray]):
+        image = image["layers"][0]
+        image[image == 0] = 255
+        image[image != 255] = 0
+        _, nbest = self.recognizer(image)
+        return ", ".join(
+            self.parse_item(item)
+            for items in nbest
+            for item in items
+            if self.is_valid_item(item)
+        )
+
+    def get_rand_kana(self, assist, kana, chars):
+        char, img, roma, chars = self.get_kana(None, assist, kana, chars)
+        return char, img, img, roma, None, chars
+
+    def clear(self, curr_kana_image):
+        return curr_kana_image
+
+    def update(self, kana, use_assist, use_hint, kana_list):
+        kana_info = self.get_kana(kana, use_assist, use_hint, kana_list)
+        kana, image, roma, kana_list = kana_info
+        return kana, image, image, roma, kana_list
+
+
+def gr_kwargs(fn, inputs=None, outputs=None, show_progress="hidden", **kwargs):
+    return dict(
+        fn=fn,
+        inputs=inputs,
+        outputs=outputs,
+        show_progress=show_progress,
+        **kwargs,
+    )
+
+
+if __name__ == "__main__":
+    App().launch_app()

data/KiwiMaru-Regular.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b7f221e14182abb1d624ffd4c91bfb63cadee13c29d7d03d2e430897d3779111
+size 5037676