| import os, json, shutil, re, docx, docx2txt, piexif, cv2 |
| from docx.shared import Inches |
| from docx import Document |
| import piexif.helper |
| import numpy as np |
| import os.path as osp |
| from typing import Tuple, Union, List, Dict |
| from PIL import Image |
|
|
| from .logger import logger as LOGGER |
| from .io_utils import find_all_imgs, imread, imwrite, NumpyEncoder |
| from .textblock import TextBlock, FontFormat |
| from .config import pcfg |
| from . import shared |
| from .exceptions import ImgnameNotInProjectException, ProjectLoadFailureException, ProjectDirNotExistException, ProjectNotSupportedException |
|
|
|
|
| def get_last_modified_file(file_prefix, exts, ext_fallback=None): |
| ''' |
| get last modified file from files sharing same prefix |
| ''' |
| latest_time = -1 |
| latest_f = None |
| for ext in exts: |
| tmp_p = file_prefix + ext |
| if osp.exists(tmp_p) and osp.getmtime(tmp_p) > latest_time: |
| latest_time = osp.getmtime(tmp_p) |
| latest_f = tmp_p |
| if latest_f is None: |
| if ext_fallback is not None: |
| latest_f = file_prefix + ext_fallback |
| else: |
| latest_f = file_prefix + exts[0] |
| return latest_f |
|
|
|
|
| def write_jpg_metadata(imgpath: str, metadata="a metadata"): |
| exif_dict = {"Exif":{piexif.ExifIFD.UserComment: piexif.helper.UserComment.dump(metadata, encoding='unicode')}} |
| exif_bytes = piexif.dump(exif_dict) |
| piexif.insert(exif_bytes, imgpath) |
|
|
| def read_jpg_metadata(imgpath: str): |
| exif_dict = piexif.load(imgpath) |
| user_comment = piexif.helper.UserComment.load(exif_dict["Exif"][piexif.ExifIFD.UserComment]) |
| bubdict = json.loads(user_comment) |
| return bubdict |
|
|
| page_start_pattern = re.compile(r'^###\s+', re.MULTILINE) |
| text_blkid_start_pattern = re.compile(r'^\d+\.', re.MULTILINE) |
|
|
| def parse_txt_translation(file_path: str): |
| with open(file_path, 'r', encoding='utf8') as f: |
| content = f.read() |
| page_start = None |
| page_list = [] |
| for matched in page_start_pattern.finditer(content): |
| start, end = matched.span() |
| if page_start is not None: |
| page_list.append({'page_content': content[page_start: start]}) |
| page_start = start |
| if page_start is not None: |
| page_list.append({'page_content': content[page_start:]}) |
|
|
| for page_dict in page_list: |
| page_content = page_dict['page_content'] |
| page_dict['page_name'] = page_start_pattern.sub('', page_content.split('\n')[0]).strip() |
| blkid_start = blkid_end = None |
| blk_list = [] |
| for matched in text_blkid_start_pattern.finditer(page_content): |
| start, end = matched.span() |
| if blkid_start is not None: |
| blk_list.append(page_content[blkid_end: start].strip()) |
| blkid_start = start |
| blkid_end = end |
| if blkid_start is not None: |
| blk_list.append(page_content[blkid_end:].strip()) |
| page_dict['blk_list'] = blk_list |
|
|
| return page_list |
|
|
|
|
| class TextBlkEncoder(NumpyEncoder): |
| def default(self, obj): |
| if isinstance(obj, TextBlock): |
| return obj.to_dict() |
| elif isinstance(obj, FontFormat): |
| return vars(obj) |
| return NumpyEncoder.default(self, obj) |
|
|
|
|
| class ProjImgTrans: |
|
|
| def __init__(self, directory: str = None): |
| self.type = 'imgtrans' |
| self.directory: str = None |
| self.pages: Dict[str, List[TextBlock]] = {} |
| self._pagename2idx = {} |
| self._idx2pagename = {} |
|
|
| self._fuzzy_inpainted_list = None |
|
|
| self.not_found_pages: Dict[str, List[TextBlock]] = {} |
| self.new_pages: List[str] = [] |
| self.proj_path: str = None |
|
|
| self.current_img: str = None |
| self.img_array: np.ndarray = None |
| self.mask_array: np.ndarray = None |
| self.inpainted_array: np.ndarray = None |
| if directory is not None: |
| self.load(directory) |
|
|
| def idx2pagename(self, idx: int) -> str: |
| return self._idx2pagename[idx] |
|
|
| def pagename2idx(self, pagename: str) -> int: |
| if pagename in self.pages: |
| return self._pagename2idx[pagename] |
| return -1 |
|
|
| def proj_name(self) -> str: |
| return self.type+'_'+osp.basename(self.directory) |
|
|
| def load(self, directory: str, json_path: str = None) -> bool: |
| self.directory = directory |
| if json_path is None: |
| self.proj_path = osp.join(self.directory, self.proj_name() + '.json') |
| else: |
| self.proj_path = json_path |
| new_proj = False |
| if not osp.exists(self.proj_path): |
| new_proj = True |
| self.new_project() |
| else: |
| try: |
| with open(self.proj_path, 'r', encoding='utf8') as f: |
| proj_dict = json.loads(f.read()) |
| except Exception as e: |
| raise ProjectLoadFailureException(e) |
| self.load_from_dict(proj_dict) |
| if not osp.exists(self.inpainted_dir()): |
| os.makedirs(self.inpainted_dir()) |
| if not osp.exists(self.mask_dir()): |
| os.makedirs(self.mask_dir()) |
|
|
| return new_proj |
|
|
| def mask_dir(self): |
| return osp.join(self.directory, 'mask') |
|
|
| def inpainted_dir(self): |
| return osp.join(self.directory, 'inpainted') |
|
|
| def result_dir(self): |
| return osp.join(self.directory, 'result') |
|
|
| def load_from_dict(self, proj_dict: dict): |
| self.set_current_img(None) |
| try: |
| self.pages = {} |
| self._pagename2idx = {} |
| self._idx2pagename = {} |
| self.not_found_pages = {} |
| page_dict = proj_dict['pages'] |
| not_found_pages = list(page_dict.keys()) |
| found_pages = find_all_imgs(img_dir=self.directory, abs_path=False, sort=True) |
| for ii, imname in enumerate(found_pages): |
| if imname in page_dict: |
| self.pages[imname] = [TextBlock(**blk_dict) for blk_dict in page_dict[imname]] |
| not_found_pages.remove(imname) |
| else: |
| self.pages[imname] = [] |
| self.new_pages.append(imname) |
| self._pagename2idx[imname] = ii |
| self._idx2pagename[ii] = imname |
| for imname in not_found_pages: |
| self.not_found_pages[imname] = [TextBlock(**blk_dict) for blk_dict in page_dict[imname]] |
| except Exception as e: |
| raise ProjectNotSupportedException(e) |
| set_img_failed = False |
| if 'current_img' in proj_dict: |
| current_img = proj_dict['current_img'] |
| try: |
| self.set_current_img(current_img) |
| except ImgnameNotInProjectException: |
| set_img_failed = True |
| else: |
| set_img_failed = True |
| LOGGER.warning(f'{current_img} not found.') |
| if set_img_failed: |
| if len(self.pages) > 0: |
| self.set_current_img_byidx(0) |
|
|
| def load_translation_from_txt(self, file_path: str): |
| page_list = parse_txt_translation(file_path) |
| missing_pages = [] |
| unmatched_pages = [] |
| unexpected_pages = [] |
| matched_pages = [] |
| for page_dict in page_list: |
| page_name = page_dict['page_name'] |
| if page_name in self.pages: |
| matched_pages.append(page_name) |
| else: |
| unexpected_pages.append(page_name) |
| continue |
| blklist = self.pages[page_name] |
| n_blk = len(blklist) |
| src_blk_list = page_dict['blk_list'] |
| n_src_blk = len(src_blk_list) |
| if n_src_blk != n_blk: |
| LOGGER.warning(f'Unmatched text blocks in {page_name}, number of text blocks in this page vs source file: {n_blk}-{n_src_blk}') |
| unmatched_pages.append(page_name) |
| for blkid in range(min(n_blk, n_src_blk)): |
| blk = blklist[blkid] |
| blk.rich_text = '' |
| blk.translation = src_blk_list[blkid] |
|
|
| matched_pages = set(matched_pages) |
| if len(matched_pages) != self.num_pages: |
| for page_name in self.pages: |
| if page_name not in matched_pages: |
| missing_pages.append(page_name) |
| |
| all_matched = len(missing_pages) == 0 and len(unmatched_pages) == 0 and len(unexpected_pages) == 0 |
| return all_matched, {'missing_pages': missing_pages, 'unmatched_pages': unmatched_pages, 'unexpected_pages': unexpected_pages, 'matched_pages': matched_pages} |
|
|
| def load_from_json(self, json_path: str): |
| old_dir = self.directory |
| directory = osp.dirname(json_path) |
| try: |
| self.load(directory, json_path=json_path) |
| except Exception as e: |
| self.load(old_dir) |
| raise ProjectLoadFailureException(e) |
|
|
| def set_current_img(self, imgname: str): |
| if imgname is not None: |
| if imgname not in self.pages: |
| raise ImgnameNotInProjectException |
| self.current_img = imgname |
| img_path = self.current_img_path() |
| mask_path = self.get_mask_path(get_last_modified=True) |
| self.img_array = imread(img_path) |
| im_h, im_w = self.img_array.shape[:2] |
| if osp.exists(mask_path): |
| self.mask_array = imread(mask_path, cv2.IMREAD_GRAYSCALE) |
| else: |
| self.mask_array = np.zeros((im_h, im_w), dtype=np.uint8) |
| self.inpainted_array = self.load_inpainted_by_imgname(imgname) |
| if self.inpainted_array is None: |
| self.inpainted_array = np.copy(self.img_array) |
| else: |
| self.current_img = None |
| self.img_array = None |
| self.mask_array = None |
| self.inpainted_array = None |
|
|
| def current_has_alpha(self): |
| if self.current_img is None: |
| return False |
| return len(self.img_array.shape) and self.img_array.shape[-1] == 4 |
|
|
| def set_current_img_byidx(self, idx: int): |
| num_pages = self.num_pages |
| if idx < 0: |
| idx = idx + self.num_pages |
| if idx < 0 or idx > num_pages - 1: |
| self.set_current_img(None) |
| else: |
| self.set_current_img(self.idx2pagename(idx)) |
|
|
| def get_blklist_byidx(self, idx: int) -> List[TextBlock]: |
| return self.pages[self.idx2pagename(idx)] |
|
|
| @property |
| def num_pages(self) -> int: |
| return len(self.pages) |
|
|
| @property |
| def current_idx(self) -> int: |
| return self.pagename2idx(self.current_img) |
|
|
| def new_project(self): |
| if not osp.exists(self.directory): |
| raise ProjectDirNotExistException |
| self.set_current_img(None) |
| imglist = find_all_imgs(self.directory, abs_path=False, sort=True) |
| self.pages = {} |
| self._pagename2idx = {} |
| self._idx2pagename = {} |
| for ii, imgname in enumerate(imglist): |
| self.pages[imgname] = [] |
| self._pagename2idx[imgname] = ii |
| self._idx2pagename[ii] = imgname |
| self.set_current_img_byidx(0) |
| self.save() |
| |
| def save(self, keep_exist_as_backup=False): |
| if not osp.exists(self.directory): |
| raise ProjectDirNotExistException |
| tmp_save_tgt = self.proj_path + '.tmp' |
| try: |
| with open(tmp_save_tgt, "w", encoding="utf-8") as f: |
| f.write(json.dumps(self.to_dict(), ensure_ascii=False, cls=TextBlkEncoder)) |
| except: |
| raise Exception(f'Failed to write {self.to_dict()}') |
| if osp.exists(self.proj_path) and keep_exist_as_backup: |
| os.replace(self.proj_path, self.proj_path + '.backup') |
| os.replace(tmp_save_tgt, self.proj_path) |
| else: |
| os.replace(tmp_save_tgt, self.proj_path) |
| LOGGER.debug(f'project saved to {self.proj_path}') |
|
|
| def to_dict(self) -> Dict: |
| pages = self.pages.copy() |
| pages.update(self.not_found_pages) |
| return { |
| 'directory': self.directory, |
| 'pages': pages, |
| 'current_img': self.current_img, |
| } |
|
|
| def read_img(self, imgname: str) -> np.ndarray: |
| if imgname not in self.pages: |
| raise ImgnameNotInProjectException |
| return imread(osp.join(self.directory, imgname)) |
|
|
| def save_mask(self, img_name, mask: np.ndarray): |
| imwrite(self.get_mask_path(img_name), mask, ext=pcfg.intermediate_imgsave_ext) |
|
|
| def save_inpainted(self, img_name, inpainted: np.ndarray): |
| imwrite(self.get_inpainted_path(img_name), inpainted, ext=pcfg.intermediate_imgsave_ext) |
|
|
| def current_img_path(self) -> str: |
| if self.current_img is None: |
| return None |
| return osp.join(self.directory, self.current_img) |
|
|
| def get_mask_path(self, imgname: str = None, get_last_modified=False) -> str: |
| if imgname is None: |
| imgname = self.current_img |
|
|
| fileprefix = osp.join(self.mask_dir(), osp.splitext(imgname)[0]) |
| if get_last_modified: |
| p = get_last_modified_file(fileprefix, ['.jxl', '.png'], ext_fallback=pcfg.intermediate_imgsave_ext) |
| else: |
| p = fileprefix+pcfg.intermediate_imgsave_ext |
|
|
| return p |
| |
| def load_mask_by_imgname(self, imgname: str) -> np.ndarray: |
| mask = None |
| mp = self.get_mask_path(imgname, get_last_modified=True) |
| if osp.exists(mp): |
| mask = imread(mp, cv2.IMREAD_GRAYSCALE) |
| return mask |
|
|
| def get_inpainted_path(self, imgname: str = None, get_last_modified=False) -> str: |
| if imgname is None: |
| imgname = self.current_img |
|
|
| fileprefix = osp.join(self.inpainted_dir(), osp.splitext(imgname)[0]) |
| if get_last_modified: |
| p = get_last_modified_file(fileprefix, ['.jxl', '.png'], ext_fallback=pcfg.intermediate_imgsave_ext) |
| else: |
| p = fileprefix+pcfg.intermediate_imgsave_ext |
|
|
| if not osp.exists(p) and shared.FUZZY_MATCH_IMAGE_NAME: |
| if self._fuzzy_inpainted_list is None: |
| if osp.exists(self.inpainted_dir()): |
| self._fuzzy_inpainted_list = find_all_imgs(self.inpainted_dir(), sort=True) |
| else: |
| self._fuzzy_inpainted_list = [] |
| pidx = self.pagename2idx(imgname) |
| if pidx < len(self._fuzzy_inpainted_list): |
| return osp.join(self.inpainted_dir(), self._fuzzy_inpainted_list[pidx]) |
| return p |
| |
| def load_inpainted_by_imgname(self, imgname: str, scale_to_src: bool = True) -> np.ndarray: |
| inpainted = None |
| mp = self.get_inpainted_path(imgname, get_last_modified=True) |
| if mp is not None and osp.exists(mp): |
| inpainted = imread(mp) |
| if imgname == self.current_img and self.img_array is not None: |
| h, w = self.img_array.shape[:2] |
| else: |
| i = Image.open(osp.join(self.directory, imgname)) |
| h, w = i.height, i.width |
| ih, iw = inpainted.shape[:2] |
| if ih != h or iw != w: |
| inpainted = Image.fromarray(inpainted).resize((w, h), resample=Image.Resampling.LANCZOS) |
| inpainted = np.array(inpainted) |
| return inpainted |
|
|
| def get_result_path(self, imgname: str) -> str: |
| ext = '.png' |
| if pcfg is not None: |
| if pcfg.imgsave_ext not in {'.jpg', '.png', '.webp', '.jxl'}: |
| LOGGER.warning('invalid image saving ext in config.json') |
| else: |
| ext = pcfg.imgsave_ext |
| return osp.join(self.result_dir(), osp.splitext(imgname)[0]+ext) |
| |
| def backup(self): |
| raise NotImplementedError |
|
|
| @property |
| def is_empty(self): |
| return len(self.pages) == 0 |
|
|
| @property |
| def is_all_pages_no_text(self): |
| return all([len(blklist) == 0 for blklist in self.pages.values()]) |
|
|
| @property |
| def img_valid(self): |
| return self.img_array is not None |
| |
| @property |
| def mask_valid(self): |
| return self.mask_array is not None |
|
|
| @property |
| def inpainted_valid(self): |
| return self.inpainted_array is not None |
|
|
| def set_next_img(self): |
| if self.current_img is not None: |
| next_idx = (self.current_idx + 1) % self.num_pages |
| self.set_current_img(self.idx2pagename(next_idx)) |
|
|
| def set_prev_img(self): |
| if self.current_img is not None: |
| next_idx = (self.current_idx - 1 + self.num_pages) % self.num_pages |
| self.set_current_img(self.idx2pagename(next_idx)) |
|
|
| def current_block_list(self) -> List[TextBlock]: |
| if self.current_img is not None: |
| assert self.current_img in self.pages |
| return self.pages[self.current_img] |
| else: |
| return None |
|
|
| def doc_path(self) -> str: |
| return os.path.join(self.directory, self.proj_name() + ".docx") |
|
|
| def doc_exist(self) -> bool: |
| return osp.exists(self.doc_path()) |
|
|
| def dump_doc(self, delete_tmp_folder=True, fin_page_signal=None): |
| |
| cuts_dir = os.path.join(self.directory, "bubcuts") |
| if os.path.exists(cuts_dir): |
| shutil.rmtree(cuts_dir) |
| os.mkdir(cuts_dir) |
| |
| document = Document() |
| style = document.styles['Normal'] |
| font = style.font |
| target_font = 'Arial' |
| font.name = target_font |
| for pagename, blklist in self.pages.items(): |
| imgpath = os.path.join(self.directory, pagename) |
| |
| cuts_path_list, cut_width_list = gen_ballon_cuts(cuts_dir, imgpath, blklist) |
| paragraph = document.add_paragraph(pagename) |
| paragraph.style = document.styles['Normal'] |
| table = document.add_table(rows=len(cuts_path_list), cols=2, style='Table Grid') |
|
|
| for index, (cut_path, width) in enumerate(zip(cuts_path_list, cut_width_list)): |
| run = table.cell(index, 0).paragraphs[0].add_run() |
| run.style.font.name = target_font |
| blk: TextBlock = blklist[index] |
| bubdict = vars(blk).copy() |
| bubdict["imgkey"] = pagename |
| bubdict["rich_text"] = '' |
| bubdict["text"] = blk.get_text() |
| write_jpg_metadata(cut_path, metadata=json.dumps(bubdict, ensure_ascii=False, cls=TextBlkEncoder)) |
| run.add_picture(cut_path, width=Inches(width/96 * 0.85)) |
| table.cell(index, 1).text = bubdict["translation"] |
|
|
| document.add_page_break() |
| |
| if fin_page_signal is not None: |
| fin_page_signal.emit() |
| |
|
|
| doc_path = self.doc_path() |
| document.save(doc_path) |
| if delete_tmp_folder: |
| shutil.rmtree(cuts_dir) |
|
|
| def dump_txt_path(self, dump_target, suffix): |
| save_path = osp.join(self.directory, self.proj_name() + f'_{dump_target}{suffix}') |
| return save_path |
|
|
| def dump_txt(self, dump_target: str, suffix='.txt'): |
| save_path = self.dump_txt_path(dump_target, suffix=suffix) |
| text_all = [] |
| assert dump_target in {'source', 'translation'} |
| assert suffix in {'.txt', '.md'} |
| for page_name, blk_list in self.pages.items(): |
| text_in_page = ['### ' + page_name] |
| for ii, blk in enumerate(blk_list): |
| if dump_target == 'translation': |
| text = blk.translation.strip() |
| elif dump_target == 'source': |
| text = blk.get_text().strip() |
| text_in_page.append(f'{ii + 1}. {text}') |
| text_all.append('\n\n'.join(text_in_page)) |
| with open(save_path, 'w', encoding='utf8') as f: |
| f.write('\n\n\n'.join(text_all)) |
|
|
| def load_doc(self, doc_path, delete_tmp_folder=True, fin_page_signal=None): |
| tmp_bubble_folder = osp.join(self.directory, 'img_folder') |
| os.makedirs(tmp_bubble_folder, exist_ok=True) |
| docx2txt.process(doc_path, tmp_bubble_folder) |
|
|
| doc = docx.Document(doc_path) |
| body_xml_str = doc._body._element.xml |
|
|
| pages = {} |
| bub_index = 0 |
| for tbl in re.findall(r'<w:tbl>(.*?)</w:tbl>', body_xml_str, re.DOTALL): |
| for tr in re.findall(r'<w:tr(.*?)>(.*?)</w:tr>', tbl, re.DOTALL): |
| if re.findall(r'<pic:cNvPr id=\"(.*?)\" name=\"(.*?)\"(.*?)>', tr[1]): |
| bub_index += 1 |
| translation = "" |
| for paragraph in re.findall(r'<w:p(.*?)>(.*?)</w:p>', tr[1], re.DOTALL): |
| for wt in re.findall(r'<w:t>(.*?)</w:t>', paragraph[1], re.DOTALL): |
| translation += wt |
| translation += "\n" |
| translation = translation[:-1] |
| if len(translation) != 0 and translation[0] == "\n": |
| translation = translation[1:] |
|
|
|
|
| bubpath = os.path.join(tmp_bubble_folder, "image"+str(bub_index)) |
| if osp.exists(bubpath+'.jpg'): |
| bubpath = bubpath + '.jpg' |
| else: |
| bubpath = bubpath + '.jpeg' |
|
|
| meta_dict = read_jpg_metadata(bubpath) |
| meta_dict["translation"] = translation |
| imgkey = meta_dict.pop("imgkey") |
| if not imgkey in pages: |
| pages[imgkey] = [] |
| pages[imgkey].append(TextBlock(**meta_dict)) |
| |
| if fin_page_signal is not None: |
| fin_page_signal.emit() |
|
|
| self.merge_from_proj_dict(pages) |
| if delete_tmp_folder: |
| shutil.rmtree(tmp_bubble_folder) |
|
|
| def merge_from_proj_dict(self, tgt_dict: Dict) -> Dict: |
| if self.pages is None: |
| self.pages = {} |
| src_dict = self.pages if self.pages is not None else {} |
| key_lst = list(dict.fromkeys(list(src_dict.keys()) + list(tgt_dict.keys()))) |
| key_lst.sort() |
| rst_dict = {} |
| pagename2idx = {} |
| idx2pagename = {} |
| page_counter = 0 |
| for key in key_lst: |
| if key in src_dict and not key in tgt_dict: |
| rst_dict[key] = src_dict[key] |
| else: |
| rst_dict[key] = tgt_dict[key] |
| pagename2idx[key] = page_counter |
| idx2pagename[page_counter] = key |
| page_counter += 1 |
| self.pages.clear() |
| self.pages.update(rst_dict) |
| self._pagename2idx = pagename2idx |
| self._idx2pagename = idx2pagename |
|
|
|
|
| def gen_ballon_cuts(cuts_dir: str, imgpath: str, blk_list: List[TextBlock], resize=True) -> Tuple[List[str], List[int]]: |
| img = imread(imgpath) |
| imgname = os.path.basename(imgpath) |
| cuts_path_list = [] |
| cut_width_list = [] |
| for ii, blk in enumerate(blk_list): |
| |
| x, y, w, h = blk.bounding_rect() |
| x, y = max(x, 0), max(y, 0) |
| w = max(w, 1) |
| h = max(h, 1) |
| x1, y1, x2, y2 = int(x), int(y), int(x+w), int(y+h) |
|
|
| cut_path = os.path.join(cuts_dir, f'{imgname}-{ii}.jpg') |
| bub = img[y1:y2, x1:x2] |
| max_width = 448 |
|
|
| if bub.shape[0] < 1 or bub.shape[1] < 1: |
| emptyw = 60 |
| resized = np.full((emptyw, emptyw, 3), fill_value=0, dtype=np.uint8) |
| width = emptyw |
| else: |
| |
| scale_percent = min(1920 / img.shape[0], max_width / w) |
| |
| if scale_percent < 1: |
| width = max(1, int(bub.shape[1] * scale_percent)) |
| height = max(1, int(bub.shape[0] * scale_percent)) |
| dim = (width, height) |
| resized = cv2.resize(bub, dim, interpolation = cv2.INTER_AREA) if resize else bub |
| else: |
| width = w |
| resized = bub |
|
|
| imwrite(cut_path, resized, '.jpg') |
| cuts_path_list.append(cut_path) |
| cut_width_list.append(width) |
|
|
| return cuts_path_list, cut_width_list |
|
|
|
|
|
|
|
|
