| import time |
| from typing import Union, List, Dict, Callable |
| import os.path as osp |
|
|
| import numpy as np |
| from qtpy.QtCore import QThread, Signal, QObject, QLocale, QTimer |
| from qtpy.QtWidgets import QFileDialog |
|
|
| from .funcmaps import get_maskseg_method |
| from utils.logger import logger as LOGGER |
| from utils.registry import Registry |
| from utils.imgproc_utils import enlarge_window, get_block_mask |
| from utils.io_utils import imread, text_is_empty |
| from modules.translators import MissingTranslatorParams |
| from modules.base import BaseModule, soft_empty_cache |
| from modules import INPAINTERS, TRANSLATORS, TEXTDETECTORS, OCR, \ |
| GET_VALID_TRANSLATORS, GET_VALID_TEXTDETECTORS, GET_VALID_INPAINTERS, GET_VALID_OCR, \ |
| BaseTranslator, InpainterBase, TextDetectorBase, OCRBase, merge_config_module_params |
| import modules |
| modules.translators.SYSTEM_LANG = QLocale.system().name() |
| from utils.textblock import TextBlock, sort_regions |
| from utils import shared |
| from utils.message import create_error_dialog, create_info_dialog |
| from .custom_widget import ImgtransProgressMessageBox, ParamComboBox |
| from .configpanel import ConfigPanel |
| from utils.proj_imgtrans import ProjImgTrans |
| from utils.config import pcfg |
| cfg_module = pcfg.module |
|
|
|
|
| class ModuleThread(QThread): |
|
|
| finish_set_module = Signal() |
| _failed_set_module_msg = 'Failed to set module.' |
|
|
| def __init__(self, module_key: str, MODULE_REGISTER: Registry, *args, **kwargs) -> None: |
| super().__init__(*args, **kwargs) |
| self.job = None |
| self.module: Union[TextDetectorBase, BaseTranslator, InpainterBase, OCRBase] = None |
| self.module_register = MODULE_REGISTER |
| self.module_key = module_key |
|
|
| self.pipeline_pagekey_queue = [] |
| self.finished_counter = 0 |
| self.imgtrans_proj: ProjImgTrans = None |
|
|
| def _set_module(self, module_name: str): |
| old_module = self.module |
| try: |
| module: Union[TextDetectorBase, BaseTranslator, InpainterBase, OCRBase] \ |
| = self.module_register.module_dict[module_name] |
| params = cfg_module.get_params(self.module_key)[module_name] |
| if params is not None: |
| self.module = module(**params) |
| else: |
| self.module = module() |
| if not pcfg.module.load_model_on_demand: |
| self.module.load_model() |
| if old_module is not None: |
| del old_module |
| except Exception as e: |
| self.module = old_module |
| create_error_dialog(e, self._failed_set_module_msg) |
|
|
| self.finish_set_module.emit() |
|
|
| def pipeline_finished(self): |
| if self.imgtrans_proj is None: |
| return True |
| elif self.finished_counter == len(self.imgtrans_proj.pages): |
| return True |
| return False |
|
|
| def initImgtransPipeline(self, proj: ProjImgTrans): |
| if self.isRunning(): |
| self.terminate() |
| self.imgtrans_proj = proj |
| self.finished_counter = 0 |
| self.pipeline_pagekey_queue.clear() |
|
|
| def run(self): |
| if self.job is not None: |
| self.job() |
| self.job = None |
|
|
|
|
| class InpaintThread(ModuleThread): |
|
|
| finish_inpaint = Signal(dict) |
| inpainting = False |
| inpaint_failed = Signal() |
|
|
| def __init__(self, *args, **kwargs) -> None: |
| super().__init__('inpainter', INPAINTERS, *args, **kwargs) |
|
|
| @property |
| def inpainter(self) -> InpainterBase: |
| return self.module |
|
|
| def setInpainter(self, inpainter: str): |
| self.job = lambda : self._set_module(inpainter) |
| self.start() |
|
|
| def inpaint(self, img: np.ndarray, mask: np.ndarray, img_key: str = None, inpaint_rect=None): |
| self.job = lambda : self._inpaint(img, mask, img_key, inpaint_rect) |
| self.start() |
| |
| def _inpaint(self, img: np.ndarray, mask: np.ndarray, img_key: str = None, inpaint_rect=None): |
| inpaint_dict = {} |
| self.inpainting = True |
| try: |
| inpainted = self.inpainter.inpaint(img, mask) |
| inpaint_dict = { |
| 'inpainted': inpainted, |
| 'img': img, |
| 'mask': mask, |
| 'img_key': img_key, |
| 'inpaint_rect': inpaint_rect |
| } |
| self.finish_inpaint.emit(inpaint_dict) |
| except Exception as e: |
| create_error_dialog(e, self.tr('Inpainting Failed.'), 'InpaintFailed') |
| self.inpainting = False |
| self.inpaint_failed.emit() |
| self.inpainting = False |
|
|
|
|
| class TextDetectThread(ModuleThread): |
| |
| finish_detect_page = Signal(str) |
| def __init__(self, *args, **kwargs) -> None: |
| super().__init__('textdetector', TEXTDETECTORS, *args, **kwargs) |
|
|
| def setTextDetector(self, textdetector: str): |
| self.job = lambda : self._set_module(textdetector) |
| self.start() |
|
|
| @property |
| def textdetector(self) -> TextDetectorBase: |
| return self.module |
|
|
|
|
| class OCRThread(ModuleThread): |
|
|
| finish_ocr_page = Signal(str) |
| def __init__(self, *args, **kwargs) -> None: |
| super().__init__('ocr', OCR, *args, **kwargs) |
|
|
| def setOCR(self, ocr: str): |
| self.job = lambda : self._set_module(ocr) |
| self.start() |
| |
| @property |
| def ocr(self) -> OCRBase: |
| return self.module |
|
|
|
|
| class TranslateThread(ModuleThread): |
|
|
| finish_translate_page = Signal(str) |
| progress_changed = Signal(int) |
|
|
| def __init__(self, *args, **kwargs) -> None: |
| super().__init__('translator', TRANSLATORS, *args, **kwargs) |
| self.translator: BaseTranslator = self.module |
|
|
| def _set_translator(self, translator: str): |
| |
| old_translator = self.translator |
| source, target = cfg_module.translate_source, cfg_module.translate_target |
| if self.translator is not None: |
| if self.translator.name == translator: |
| return |
| |
| try: |
| params = cfg_module.translator_params[translator] |
| translator_module: BaseTranslator = TRANSLATORS.module_dict[translator] |
| if params is not None: |
| self.translator = translator_module(source, target, raise_unsupported_lang=False, **params) |
| else: |
| self.translator = translator_module(source, target, raise_unsupported_lang=False) |
| cfg_module.translate_source = self.translator.lang_source |
| cfg_module.translate_target = self.translator.lang_target |
| cfg_module.translator = self.translator.name |
| except Exception as e: |
| if old_translator is None: |
| old_translator = TRANSLATORS.module_dict['google']('简体中文', 'English', raise_unsupported_lang=False) |
| self.translator = old_translator |
| msg = self.tr('Failed to set translator ') + translator |
| create_error_dialog(e, msg, 'FailedSetTranslator') |
|
|
| self.module = self.translator |
| self.finish_set_module.emit() |
|
|
| def setTranslator(self, translator: str): |
| if translator in ['Sugoi']: |
| self._set_translator(translator) |
| else: |
| self.job = lambda : self._set_translator(translator) |
| self.start() |
|
|
| def _translate_page(self, page_dict, page_key: str, emit_finished=True): |
| page = page_dict[page_key] |
| try: |
| self.translator.translate_textblk_lst(page) |
| except Exception as e: |
| create_error_dialog(e, self.tr('Translation Failed.'), 'TranslationFailed') |
| if emit_finished: |
| self.finish_translate_page.emit(page_key) |
|
|
| def translatePage(self, page_dict, page_key: str): |
| self.job = lambda: self._translate_page(page_dict, page_key) |
| self.start() |
|
|
| def push_pagekey_queue(self, page_key: str): |
| self.pipeline_pagekey_queue.append(page_key) |
|
|
| def runTranslatePipeline(self, imgtrans_proj: ProjImgTrans): |
| self.initImgtransPipeline(imgtrans_proj) |
| self.job = self._run_translate_pipeline |
| self.start() |
|
|
| def _run_translate_pipeline(self): |
| delay = self.translator.delay() |
|
|
| while not self.pipeline_finished(): |
| if len(self.pipeline_pagekey_queue) == 0: |
| time.sleep(0.1) |
| continue |
| |
| page_key = self.pipeline_pagekey_queue.pop(0) |
| self.blockSignals(True) |
| try: |
| self._translate_page(self.imgtrans_proj.pages, page_key, emit_finished=False) |
| except Exception as e: |
| |
| |
|
|
| msg = self.tr('Translation Failed.') |
| if isinstance(e, MissingTranslatorParams): |
| msg = msg + '\n' + str(e) + self.tr(' is required for ' + self.translator.name) |
| |
| self.blockSignals(False) |
| create_error_dialog(e, msg, 'TranslationFailed') |
| |
| |
| |
| |
| self.blockSignals(False) |
| self.finished_counter += 1 |
| self.progress_changed.emit(self.finished_counter) |
|
|
| if not self.pipeline_finished() and delay > 0: |
| time.sleep(delay) |
|
|
|
|
| class ImgtransThread(QThread): |
|
|
| finished = Signal(object) |
| update_detect_progress = Signal(int) |
| update_ocr_progress = Signal(int) |
| update_translate_progress = Signal(int) |
| update_inpaint_progress = Signal(int) |
|
|
| finish_blktrans_stage = Signal(str, int) |
| finish_blktrans = Signal(int, list) |
| unload_modules = Signal(list) |
|
|
| detect_counter = 0 |
| ocr_counter = 0 |
| translate_counter = 0 |
| inpaint_counter = 0 |
|
|
| def __init__(self, |
| textdetect_thread: TextDetectThread, |
| ocr_thread: OCRThread, |
| translate_thread: TranslateThread, |
| inpaint_thread: InpaintThread, |
| *args, **kwargs) -> None: |
| super().__init__(*args, **kwargs) |
| self.textdetect_thread = textdetect_thread |
| self.ocr_thread = ocr_thread |
| self.translate_thread = translate_thread |
| self.inpaint_thread = inpaint_thread |
| self.job = None |
| self.imgtrans_proj: ProjImgTrans = None |
|
|
| @property |
| def textdetector(self) -> TextDetectorBase: |
| return self.textdetect_thread.textdetector |
|
|
| @property |
| def ocr(self) -> OCRBase: |
| return self.ocr_thread.ocr |
| |
| @property |
| def translator(self) -> BaseTranslator: |
| return self.translate_thread.translator |
|
|
| @property |
| def inpainter(self) -> InpainterBase: |
| return self.inpaint_thread.inpainter |
|
|
| def runImgtransPipeline(self, imgtrans_proj: ProjImgTrans): |
| self.imgtrans_proj = imgtrans_proj |
| self.num_pages = len(self.imgtrans_proj.pages) |
| self.job = self._imgtrans_pipeline |
| self.start() |
|
|
| def runBlktransPipeline(self, blk_list: List[TextBlock], tgt_img: np.ndarray, mode: int, blk_ids: List[int], tgt_mask): |
| self.job = lambda : self._blktrans_pipeline(blk_list, tgt_img, mode, blk_ids, tgt_mask) |
| self.start() |
|
|
| def _blktrans_pipeline(self, blk_list: List[TextBlock], tgt_img: np.ndarray, mode: int, blk_ids: List[int], tgt_mask): |
| if mode >= 0 and mode < 3: |
| try: |
| self.ocr_thread.module.run_ocr(tgt_img, blk_list, split_textblk=True) |
| except Exception as e: |
| create_error_dialog(e, self.tr('OCR Failed.'), 'OCRFailed') |
| self.finish_blktrans.emit(mode, blk_ids) |
|
|
| if mode != 0 and mode < 3: |
| self.translate_thread.module.translate_textblk_lst(blk_list) |
| self.finish_blktrans.emit(mode, blk_ids) |
| if mode > 1: |
| im_h, im_w = tgt_img.shape[:2] |
| progress_prod = 100. / len(blk_list) if len(blk_list) > 0 else 0 |
| for ii, blk in enumerate(blk_list): |
| xyxy = enlarge_window(blk.xyxy, im_w, im_h) |
| xyxy = np.array(xyxy) |
| x1, y1, x2, y2 = xyxy.astype(np.int64) |
| blk.region_inpaint_dict = None |
| if y2 - y1 > 2 and x2 - x1 > 2: |
| im = np.copy(tgt_img[y1: y2, x1: x2]) |
| maskseg_method = get_maskseg_method() |
| inpaint_mask_array, ballon_mask, bub_dict = maskseg_method(im, mask=tgt_mask[y1: y2, x1: x2]) |
| mask = self.post_process_mask(inpaint_mask_array) |
| if mask.sum() > 0: |
| inpainted = self.inpaint_thread.inpainter.inpaint(im, mask) |
| blk.region_inpaint_dict = {'img': im, 'mask': mask, 'inpaint_rect': [x1, y1, x2, y2], 'inpainted': inpainted} |
| self.finish_blktrans_stage.emit('inpaint', int((ii+1) * progress_prod)) |
| self.finish_blktrans.emit(mode, blk_ids) |
|
|
| def _imgtrans_pipeline(self): |
| import debugpy; debugpy.breakpoint() |
| self.detect_counter = 0 |
| self.ocr_counter = 0 |
| self.translate_counter = 0 |
| self.inpaint_counter = 0 |
| self.num_pages = num_pages = len(self.imgtrans_proj.pages) |
|
|
| low_vram_trans = False |
| if self.translator is not None: |
| low_vram_trans = self.translator.low_vram_mode |
| self.parallel_trans = not self.translator.is_computational_intensive() and not low_vram_trans |
| else: |
| self.parallel_trans = False |
| |
| self.parallel_trans = False |
| if self.parallel_trans and cfg_module.enable_translate: |
| self.translate_thread.runTranslatePipeline(self.imgtrans_proj) |
|
|
| for imgname in self.imgtrans_proj.pages: |
| img = self.imgtrans_proj.read_img(imgname) |
| mask = blk_list = None |
| need_save_mask = False |
| blk_removed: List[TextBlock] = [] |
| if cfg_module.enable_detect: |
| try: |
| mask, blk_list = self.textdetector.detect(img, self.imgtrans_proj) |
| need_save_mask = True |
| except Exception as e: |
| create_error_dialog(e, self.tr('Text Detection Failed.'), 'TextDetectFailed') |
| blk_list = [] |
| self.detect_counter += 1 |
| if pcfg.module.keep_exist_textlines: |
| blk_list = self.imgtrans_proj.pages[imgname] + blk_list |
| blk_list = sort_regions(blk_list) |
| existed_mask = self.imgtrans_proj.load_mask_by_imgname(imgname) |
| if existed_mask is not None: |
| mask = np.bitwise_or(mask, existed_mask) |
| self.imgtrans_proj.pages[imgname] = blk_list |
|
|
| if mask is not None and not cfg_module.enable_ocr: |
| self.imgtrans_proj.save_mask(imgname, mask) |
| need_save_mask = False |
| |
| self.update_detect_progress.emit(self.detect_counter) |
|
|
| if blk_list is None: |
| blk_list = self.imgtrans_proj.pages[imgname] if imgname in self.imgtrans_proj.pages else [] |
|
|
| if cfg_module.enable_ocr: |
| try: |
| self.ocr.run_ocr(img, blk_list) |
| except Exception as e: |
| create_error_dialog(e, self.tr('OCR Failed.'), 'OCRFailed') |
| self.ocr_counter += 1 |
|
|
| if pcfg.restore_ocr_empty: |
| blk_list_updated = [] |
| for blk in blk_list: |
| text = blk.get_text() |
| if text_is_empty(text): |
| blk_removed.append(blk) |
| else: |
| blk_list_updated.append(blk) |
|
|
| if len(blk_removed) > 0: |
| blk_list.clear() |
| blk_list += blk_list_updated |
| |
| if mask is None: |
| mask = self.imgtrans_proj.load_mask_by_imgname(imgname) |
| if mask is not None: |
| inpainted = None |
| if not cfg_module.enable_inpaint: |
| inpainted = self.imgtrans_proj.load_inpainted_by_imgname(imgname) |
| for blk in blk_removed: |
| xywh = blk.bounding_rect() |
| blk_mask, xyxy = get_block_mask(xywh, mask, blk.angle) |
| x1, y1, x2, y2 = xyxy |
| if blk_mask is not None: |
| mask[y1: y2, x1: x2] = 0 |
| if inpainted is not None: |
| mskpnt = np.where(blk_mask) |
| inpainted[y1: y2, x1: x2][mskpnt] = img[y1: y2, x1: x2][mskpnt] |
| need_save_mask = True |
| if inpainted is not None and need_save_mask: |
| self.imgtrans_proj.save_inpainted(imgname, inpainted) |
| if need_save_mask: |
| self.imgtrans_proj.save_mask(imgname, mask) |
| need_save_mask = False |
|
|
| self.update_ocr_progress.emit(self.ocr_counter) |
|
|
| if need_save_mask and mask is not None: |
| self.imgtrans_proj.save_mask(imgname, mask) |
| need_save_mask = False |
|
|
| if cfg_module.enable_translate: |
| if self.parallel_trans: |
| self.translate_thread.push_pagekey_queue(imgname) |
| elif not low_vram_trans: |
| self.translator.translate_textblk_lst(blk_list) |
| self.translate_counter += 1 |
| self.update_translate_progress.emit(self.translate_counter) |
| |
| if cfg_module.enable_inpaint: |
| if mask is None: |
| mask = self.imgtrans_proj.load_mask_by_imgname(imgname) |
| |
| if mask is not None: |
| try: |
| inpainted = self.inpainter.inpaint(img, mask, blk_list) |
| self.imgtrans_proj.save_inpainted(imgname, inpainted) |
| except Exception as e: |
| create_error_dialog(e, self.tr('Inpainting Failed.'), 'InpaintFailed') |
| |
| self.inpaint_counter += 1 |
| self.update_inpaint_progress.emit(self.inpaint_counter) |
| else: |
| if len(blk_removed) > 0: |
| self.imgtrans_proj.load_mask_by_imgname |
| |
| if cfg_module.enable_translate and low_vram_trans: |
| unload_modules(self, ['textdetector', 'inpainter', 'ocr']) |
| for imgname in self.imgtrans_proj.pages: |
| blk_list = self.imgtrans_proj.pages[imgname] |
| self.translator.translate_textblk_lst(blk_list) |
| self.translate_counter += 1 |
| self.update_translate_progress.emit(self.translate_counter) |
|
|
| def detect_finished(self) -> bool: |
| if self.imgtrans_proj is None: |
| return True |
| return self.detect_counter == self.num_pages or not cfg_module.enable_detect |
|
|
| def ocr_finished(self) -> bool: |
| if self.imgtrans_proj is None: |
| return True |
| return self.ocr_counter == self.num_pages or not cfg_module.enable_ocr |
|
|
| def translate_finished(self) -> bool: |
| if self.imgtrans_proj is None \ |
| or not cfg_module.enable_ocr \ |
| or not cfg_module.enable_translate: |
| return True |
| if self.parallel_trans: |
| return self.translate_thread.pipeline_finished() |
| return self.translate_counter == self.num_pages or not cfg_module.enable_translate |
|
|
| def inpaint_finished(self) -> bool: |
| if self.imgtrans_proj is None or not cfg_module.enable_inpaint: |
| return True |
| return self.inpaint_counter == self.num_pages or not cfg_module.enable_inpaint |
|
|
| def run(self): |
| if self.job is not None: |
| self.job() |
| self.job = None |
|
|
| def recent_finished_index(self, ref_counter: int) -> int: |
| if cfg_module.enable_detect: |
| ref_counter = min(ref_counter, self.detect_counter) |
| if cfg_module.enable_ocr: |
| ref_counter = min(ref_counter, self.ocr_counter) |
| if cfg_module.enable_inpaint: |
| ref_counter = min(ref_counter, self.inpaint_counter) |
| if cfg_module.enable_translate: |
| if self.parallel_trans: |
| ref_counter = min(ref_counter, self.translate_thread.finished_counter) |
| else: |
| ref_counter = min(ref_counter, self.translate_counter) |
|
|
| return ref_counter - 1 |
|
|
|
|
| def unload_modules(self, module_names): |
| model_deleted = False |
| for module in module_names: |
| module: BaseModule = getattr(self, module) |
| model_deleted = model_deleted or module.unload_model() |
| if model_deleted: |
| soft_empty_cache() |
|
|
|
|
| class ModuleManager(QObject): |
| imgtrans_proj: ProjImgTrans = None |
|
|
| finish_translate_page = Signal(str) |
| canvas_inpaint_finished = Signal(dict) |
| inpaint_th_finished = Signal() |
|
|
| imgtrans_pipeline_finished = Signal() |
| blktrans_pipeline_finished = Signal(int, list) |
| page_trans_finished = Signal(int) |
|
|
| run_canvas_inpaint = False |
| is_waiting_th = False |
| block_set_inpainter = False |
|
|
| def __init__(self, |
| imgtrans_proj: ProjImgTrans, |
| *args, **kwargs) -> None: |
| super().__init__(*args, **kwargs) |
| self.imgtrans_proj = imgtrans_proj |
| self.check_inpaint_fin_timer = QTimer(self) |
| self.check_inpaint_fin_timer.timeout.connect(self.check_inpaint_th_finished) |
|
|
| def setupThread(self, config_panel: ConfigPanel, imgtrans_progress_msgbox: ImgtransProgressMessageBox, ocr_postprocess: Callable = None, translate_preprocess: Callable = None, translate_postprocess: Callable = None): |
| self.textdetect_thread = TextDetectThread() |
|
|
| self.ocr_thread = OCRThread() |
| |
| self.translate_thread = TranslateThread() |
| self.translate_thread.progress_changed.connect(self.on_update_translate_progress) |
| self.translate_thread.finish_translate_page.connect(self.on_finish_translate_page) |
|
|
| self.inpaint_thread = InpaintThread() |
| self.inpaint_thread.finish_inpaint.connect(self.on_finish_inpaint) |
|
|
| self.progress_msgbox = imgtrans_progress_msgbox |
|
|
| self.imgtrans_thread = ImgtransThread(self.textdetect_thread, self.ocr_thread, self.translate_thread, self.inpaint_thread) |
| self.imgtrans_thread.update_detect_progress.connect(self.on_update_detect_progress) |
| self.imgtrans_thread.update_ocr_progress.connect(self.on_update_ocr_progress) |
| self.imgtrans_thread.update_translate_progress.connect(self.on_update_translate_progress) |
| self.imgtrans_thread.update_inpaint_progress.connect(self.on_update_inpaint_progress) |
| self.imgtrans_thread.finish_blktrans_stage.connect(self.on_finish_blktrans_stage) |
| self.imgtrans_thread.finish_blktrans.connect(self.on_finish_blktrans) |
|
|
| self.translator_panel = translator_panel = config_panel.trans_config_panel |
| translator_params = merge_config_module_params(cfg_module.translator_params, GET_VALID_TRANSLATORS(), TRANSLATORS.get) |
| translator_panel.addModulesParamWidgets(translator_params) |
| translator_panel.translator_changed.connect(self.setTranslator) |
| translator_panel.paramwidget_edited.connect(self.on_translatorparam_edited) |
| from modules.translators.hooks import chs2cht |
| BaseTranslator.register_preprocess_hooks({'keyword_sub': translate_preprocess}) |
| BaseTranslator.register_postprocess_hooks({'chs2cht': chs2cht, 'keyword_sub': translate_postprocess}) |
|
|
| self.inpaint_panel = inpainter_panel = config_panel.inpaint_config_panel |
| inpainter_params = merge_config_module_params(cfg_module.inpainter_params, GET_VALID_INPAINTERS(), INPAINTERS.get) |
| inpainter_panel.addModulesParamWidgets(inpainter_params) |
| inpainter_panel.paramwidget_edited.connect(self.on_inpainterparam_edited) |
| inpainter_panel.inpainter_changed.connect(self.setInpainter) |
| inpainter_panel.needInpaintChecker.checker_changed.connect(self.on_inpainter_checker_changed) |
| inpainter_panel.needInpaintChecker.checker.setChecked(cfg_module.check_need_inpaint) |
|
|
| self.textdetect_panel = textdetector_panel = config_panel.detect_config_panel |
| textdetector_params = merge_config_module_params(cfg_module.textdetector_params, GET_VALID_TEXTDETECTORS(), TEXTDETECTORS.get) |
| textdetector_panel.addModulesParamWidgets(textdetector_params) |
| textdetector_panel.paramwidget_edited.connect(self.on_textdetectorparam_edited) |
| textdetector_panel.detector_changed.connect(self.setTextDetector) |
|
|
| self.ocr_panel = ocr_panel = config_panel.ocr_config_panel |
| ocr_params = merge_config_module_params(cfg_module.ocr_params, GET_VALID_OCR(), OCR.get) |
| ocr_panel.addModulesParamWidgets(ocr_params) |
| ocr_panel.paramwidget_edited.connect(self.on_ocrparam_edited) |
| ocr_panel.ocr_changed.connect(self.setOCR) |
| OCRBase.register_postprocess_hooks(ocr_postprocess) |
|
|
| config_panel.unload_models.connect(self.unload_all_models) |
|
|
|
|
| def unload_all_models(self): |
| unload_modules(self, {'textdetector', 'inpainter', 'ocr', 'translator'}) |
|
|
| @property |
| def translator(self) -> BaseTranslator: |
| return self.translate_thread.translator |
|
|
| @property |
| def inpainter(self) -> InpainterBase: |
| return self.inpaint_thread.inpainter |
|
|
| @property |
| def textdetector(self) -> TextDetectorBase: |
| return self.textdetect_thread.textdetector |
|
|
| @property |
| def ocr(self) -> OCRBase: |
| return self.ocr_thread.ocr |
|
|
| def translatePage(self, run_target: bool, page_key: str): |
| if not run_target: |
| if self.translate_thread.isRunning(): |
| LOGGER.warning('Terminating a running translation thread.') |
| self.translate_thread.terminate() |
| return |
| self.translate_thread.translatePage(self.imgtrans_proj.pages, page_key) |
|
|
| def inpainterBusy(self): |
| return self.inpaint_thread.isRunning() |
|
|
| def inpaint(self, img: np.ndarray, mask: np.ndarray, img_key: str = None, inpaint_rect = None, **kwargs): |
| if self.inpaint_thread.isRunning(): |
| LOGGER.warning('Waiting for inpainting to finish') |
| return |
| self.inpaint_thread.inpaint(img, mask, img_key, inpaint_rect) |
|
|
| def terminateRunningThread(self): |
| if self.textdetect_thread.isRunning(): |
| self.textdetect_thread.quit() |
| if self.ocr_thread.isRunning(): |
| self.ocr_thread.quit() |
| if self.inpaint_thread.isRunning(): |
| self.inpaint_thread.quit() |
| if self.translate_thread.isRunning(): |
| self.translate_thread.quit() |
|
|
| def check_inpaint_th_finished(self): |
| if self.inpaint_thread.isRunning(): |
| return |
| self.block_set_inpainter = False |
| self.check_inpaint_fin_timer.stop() |
| self.inpaint_th_finished.emit() |
|
|
| def runImgtransPipeline(self): |
| if self.imgtrans_proj.is_empty: |
| LOGGER.info('proj file is empty, nothing to do') |
| self.progress_msgbox.hide() |
| return |
| self.last_finished_index = -1 |
| self.terminateRunningThread() |
| |
| if cfg_module.all_stages_disabled() and self.imgtrans_proj is not None and self.imgtrans_proj.num_pages > 0: |
| for ii in range(self.imgtrans_proj.num_pages): |
| self.page_trans_finished.emit(ii) |
| self.imgtrans_pipeline_finished.emit() |
| return |
| |
| self.progress_msgbox.detect_bar.setVisible(cfg_module.enable_detect) |
| self.progress_msgbox.ocr_bar.setVisible(cfg_module.enable_ocr) |
| self.progress_msgbox.translate_bar.setVisible(cfg_module.enable_translate) |
| self.progress_msgbox.inpaint_bar.setVisible(cfg_module.enable_inpaint) |
| self.progress_msgbox.zero_progress() |
| self.progress_msgbox.show() |
| self.imgtrans_thread.runImgtransPipeline(self.imgtrans_proj) |
|
|
| def runBlktransPipeline(self, blk_list: List[TextBlock], tgt_img: np.ndarray, mode: int, blk_ids: List[int], tgt_mask): |
| self.terminateRunningThread() |
| self.progress_msgbox.hide_all_bars() |
| if mode >= 0 and mode < 3: |
| self.progress_msgbox.ocr_bar.show() |
| if mode >= 2: |
| self.progress_msgbox.inpaint_bar.show() |
| if mode != 0 and mode < 3: |
| self.progress_msgbox.translate_bar.show() |
| self.progress_msgbox.zero_progress() |
| self.progress_msgbox.show() |
| self.imgtrans_thread.runBlktransPipeline(blk_list, tgt_img, mode, blk_ids, tgt_mask) |
|
|
| def on_finish_blktrans_stage(self, stage: str, progress: int): |
| if stage == 'ocr': |
| self.progress_msgbox.updateOCRProgress(progress) |
| elif stage == 'translate': |
| self.progress_msgbox.updateTranslateProgress(progress) |
| elif stage == 'inpaint': |
| self.progress_msgbox.updateInpaintProgress(progress) |
| else: |
| raise NotImplementedError(f'Unknown stage: {stage}') |
| |
| def on_finish_blktrans(self, mode: int, blk_ids: List): |
| self.blktrans_pipeline_finished.emit(mode, blk_ids) |
| self.progress_msgbox.hide() |
|
|
| def on_update_detect_progress(self, progress: int): |
| ri = self.imgtrans_thread.recent_finished_index(progress) |
| if 'detect' in shared.pbar: |
| shared.pbar['detect'].update(1) |
| progress = int(progress / self.imgtrans_thread.num_pages * 100) |
| self.progress_msgbox.updateDetectProgress(progress) |
| if ri != self.last_finished_index: |
| self.last_finished_index = ri |
| self.page_trans_finished.emit(ri) |
| if progress == 100: |
| self.finishImgtransPipeline() |
|
|
| def on_update_ocr_progress(self, progress: int): |
| ri = self.imgtrans_thread.recent_finished_index(progress) |
| if 'ocr' in shared.pbar: |
| shared.pbar['ocr'].update(1) |
| progress = int(progress / self.imgtrans_thread.num_pages * 100) |
| self.progress_msgbox.updateOCRProgress(progress) |
| if ri != self.last_finished_index: |
| self.last_finished_index = ri |
| self.page_trans_finished.emit(ri) |
| if progress == 100: |
| self.finishImgtransPipeline() |
|
|
| def on_update_translate_progress(self, progress: int): |
| ri = self.imgtrans_thread.recent_finished_index(progress) |
| if 'translate' in shared.pbar: |
| shared.pbar['translate'].update(1) |
| progress = int(progress / self.imgtrans_thread.num_pages * 100) |
| self.progress_msgbox.updateTranslateProgress(progress) |
| if ri != self.last_finished_index: |
| self.last_finished_index = ri |
| self.page_trans_finished.emit(ri) |
| if progress == 100: |
| self.finishImgtransPipeline() |
|
|
| def on_update_inpaint_progress(self, progress: int): |
| ri = self.imgtrans_thread.recent_finished_index(progress) |
| if 'inpaint' in shared.pbar: |
| shared.pbar['inpaint'].update(1) |
| progress = int(progress / self.imgtrans_thread.num_pages * 100) |
| self.progress_msgbox.updateInpaintProgress(progress) |
| if ri != self.last_finished_index: |
| self.last_finished_index = ri |
| self.page_trans_finished.emit(ri) |
| if progress == 100: |
| self.finishImgtransPipeline() |
|
|
| def progress(self): |
| progress = {} |
| num_pages = self.imgtrans_thread.num_pages |
| if cfg_module.enable_detect: |
| progress['detect'] = self.imgtrans_thread.detect_counter / num_pages |
| if cfg_module.enable_ocr: |
| progress['ocr'] = self.imgtrans_thread.ocr_counter / num_pages |
| if cfg_module.enable_inpaint: |
| progress['inpaint'] = self.imgtrans_thread.inpaint_counter / num_pages |
| if cfg_module.enable_translate: |
| progress['translate'] = self.imgtrans_thread.translate_counter / num_pages |
| return progress |
|
|
| def proj_finished(self): |
| if self.imgtrans_thread.detect_finished() \ |
| and self.imgtrans_thread.ocr_finished() \ |
| and self.imgtrans_thread.translate_finished() \ |
| and self.imgtrans_thread.inpaint_finished(): |
| return True |
| return False |
|
|
| def finishImgtransPipeline(self): |
| if self.proj_finished(): |
| self.progress_msgbox.hide() |
| self.imgtrans_pipeline_finished.emit() |
|
|
| def setTranslator(self, translator: str = None): |
| if translator is None: |
| translator = cfg_module.translator |
| if self.translate_thread.isRunning(): |
| LOGGER.warning('Terminating a running translation thread.') |
| self.translate_thread.terminate() |
| self.translate_thread.setTranslator(translator) |
|
|
| def setInpainter(self, inpainter: str = None): |
| |
| if self.block_set_inpainter: |
| return |
| |
| if inpainter is None: |
| inpainter =cfg_module.inpainter |
| |
| if self.inpaint_thread.isRunning(): |
| self.block_set_inpainter = True |
| create_info_dialog(self.tr('Set Inpainter...'), modal=True, signal_slot_map_list=[{'signal': self.inpaint_th_finished, 'slot': 'done'}]) |
| self.check_inpaint_fin_timer.start(300) |
| return |
|
|
| self.inpaint_thread.setInpainter(inpainter) |
|
|
| def setTextDetector(self, textdetector: str = None): |
| if textdetector is None: |
| textdetector = cfg_module.textdetector |
| if self.textdetect_thread.isRunning(): |
| LOGGER.warning('Terminating a running text detection thread.') |
| self.textdetect_thread.terminate() |
| self.textdetect_thread.setTextDetector(textdetector) |
|
|
| def setOCR(self, ocr: str = None): |
| if ocr is None: |
| ocr = cfg_module.ocr |
| if self.ocr_thread.isRunning(): |
| LOGGER.warning('Terminating a running OCR thread.') |
| self.ocr_thread.terminate() |
| self.ocr_thread.setOCR(ocr) |
|
|
| def on_finish_translate_page(self, page_key: str): |
| self.finish_translate_page.emit(page_key) |
| |
| def on_finish_inpaint(self, inpaint_dict: dict): |
| if self.run_canvas_inpaint: |
| self.canvas_inpaint_finished.emit(inpaint_dict) |
| self.run_canvas_inpaint = False |
|
|
| def canvas_inpaint(self, inpaint_dict): |
| self.run_canvas_inpaint = True |
| self.inpaint(**inpaint_dict) |
| |
| def on_translatorparam_edited(self, param_key: str, param_content: dict): |
| if self.translator is not None: |
| self.updateModuleSetupParam(self.translator, param_key, param_content) |
| cfg_module.translator_params[self.translator.name] = self.translator.params |
|
|
| def on_inpainterparam_edited(self, param_key: str, param_content: dict): |
| if self.inpainter is not None: |
| self.updateModuleSetupParam(self.inpainter, param_key, param_content) |
| cfg_module.inpainter_params[self.inpainter.name] = self.inpainter.params |
|
|
| def on_textdetectorparam_edited(self, param_key: str, param_content: dict): |
| if self.textdetector is not None: |
| self.updateModuleSetupParam(self.textdetector, param_key, param_content) |
| cfg_module.textdetector_params[self.textdetector.name] = self.textdetector.params |
|
|
| def on_ocrparam_edited(self, param_key: str, param_content: dict): |
| if self.ocr is not None: |
| self.updateModuleSetupParam(self.ocr, param_key, param_content) |
| cfg_module.ocr_params[self.ocr.name] = self.ocr.params |
|
|
| def updateModuleSetupParam(self, |
| module: Union[InpainterBase, BaseTranslator], |
| param_key: str, param_content: dict): |
| |
| if param_content.get('flush', False): |
| param_widget: ParamComboBox = param_content['widget'] |
| param_widget.blockSignals(True) |
| current_item = param_widget.currentText() |
| param_widget.clear() |
| param_widget.addItems(module.flush(param_key)) |
| param_widget.setCurrentText(current_item) |
| param_widget.blockSignals(False) |
| elif param_content.get('select_path', False): |
| dialog = QFileDialog() |
| f = module.params[param_key].get('path_filter', None) |
| p = dialog.getOpenFileUrl(self.parent(), filter=f)[0].toLocalFile() |
| if osp.exists(p): |
| param_widget: ParamComboBox = param_content['widget'] |
| param_widget.setCurrentText(p) |
| else: |
| module.updateParam(param_key, param_content['content']) |
|
|
| def handle_page_changed(self): |
| if not self.imgtrans_thread.isRunning(): |
| if self.inpaint_thread.inpainting: |
| self.run_canvas_inpaint = False |
| self.inpaint_thread.terminate() |
|
|
| def on_inpainter_checker_changed(self, is_checked: bool): |
| cfg_module.check_need_inpaint = is_checked |
| InpainterBase.check_need_inpaint = is_checked |
