pyxllib 0.3.96__py3-none-any.whl → 0.3.200__py3-none-any.whl

pyxlpr/ppocr/__init__.py

@@ -1,15 +0,0 @@
-# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from pathlib import Path

pyxlpr/ppocr/configs/rec/multi_language/generate_multi_language_configs.py

@@ -1,226 +0,0 @@
-# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import yaml
-from argparse import ArgumentParser, RawDescriptionHelpFormatter
-import os.path
-import logging
-logging.basicConfig(level=logging.INFO)
-
-support_list = {
-    'it': 'italian',
-    'xi': 'spanish',
-    'pu': 'portuguese',
-    'ru': 'russian',
-    'ar': 'arabic',
-    'ta': 'tamil',
-    'ug': 'uyghur',
-    'fa': 'persian',
-    'ur': 'urdu',
-    'rs': 'serbian latin',
-    'oc': 'occitan',
-    'rsc': 'serbian cyrillic',
-    'bg': 'bulgarian',
-    'uk': 'ukranian',
-    'be': 'belarusian',
-    'te': 'telugu',
-    'ka': 'kannada',
-    'chinese_cht': 'chinese tradition',
-    'hi': 'hindi',
-    'mr': 'marathi',
-    'ne': 'nepali',
-}
-
-latin_lang = [
-    'af', 'az', 'bs', 'cs', 'cy', 'da', 'de', 'es', 'et', 'fr', 'ga', 'hr',
-    'hu', 'id', 'is', 'it', 'ku', 'la', 'lt', 'lv', 'mi', 'ms', 'mt', 'nl',
-    'no', 'oc', 'pi', 'pl', 'pt', 'ro', 'rs_latin', 'sk', 'sl', 'sq', 'sv',
-    'sw', 'tl', 'tr', 'uz', 'vi', 'latin'
-]
-arabic_lang = ['ar', 'fa', 'ug', 'ur']
-cyrillic_lang = [
-    'ru', 'rs_cyrillic', 'be', 'bg', 'uk', 'mn', 'abq', 'ady', 'kbd', 'ava',
-    'dar', 'inh', 'che', 'lbe', 'lez', 'tab', 'cyrillic'
-]
-devanagari_lang = [
-    'hi', 'mr', 'ne', 'bh', 'mai', 'ang', 'bho', 'mah', 'sck', 'new', 'gom',
-    'sa', 'bgc', 'devanagari'
-]
-multi_lang = latin_lang + arabic_lang + cyrillic_lang + devanagari_lang
-
-assert (os.path.isfile("./rec_multi_language_lite_train.yml")
-        ), "Loss basic configuration file rec_multi_language_lite_train.yml.\
-You can download it from \
-https://github.com/PaddlePaddle/PaddleOCR/tree/dygraph/configs/rec/multi_language/"
-
-global_config = yaml.load(
-    open("./rec_multi_language_lite_train.yml", 'rb'), Loader=yaml.Loader)
-project_path = os.path.abspath(os.path.join(os.getcwd(), "../../../"))
-
-
-class ArgsParser(ArgumentParser):
-    def __init__(self):
-        super(ArgsParser, self).__init__(
-            formatter_class=RawDescriptionHelpFormatter)
-        self.add_argument(
-            "-o", "--opt", nargs='+', help="set configuration options")
-        self.add_argument(
-            "-l",
-            "--language",
-            nargs='+',
-            help="set language type, support {}".format(support_list))
-        self.add_argument(
-            "--train",
-            type=str,
-            help="you can use this command to change the train dataset default path"
-        )
-        self.add_argument(
-            "--val",
-            type=str,
-            help="you can use this command to change the eval dataset default path"
-        )
-        self.add_argument(
-            "--dict",
-            type=str,
-            help="you can use this command to change the dictionary default path"
-        )
-        self.add_argument(
-            "--data_dir",
-            type=str,
-            help="you can use this command to change the dataset default root path"
-        )
-
-    def parse_args(self, argv=None):
-        args = super(ArgsParser, self).parse_args(argv)
-        args.opt = self._parse_opt(args.opt)
-        args.language = self._set_language(args.language)
-        return args
-
-    def _parse_opt(self, opts):
-        config = {}
-        if not opts:
-            return config
-        for s in opts:
-            s = s.strip()
-            k, v = s.split('=')
-            config[k] = yaml.load(v, Loader=yaml.Loader)
-        return config
-
-    def _set_language(self, type):
-        lang = type[0]
-        assert (type), "please use -l or --language to choose language type"
-        assert(
-                lang in support_list.keys() or lang in multi_lang
-               ),"the sub_keys(-l or --language) can only be one of support list: \n{},\nbut get: {}, " \
-                 "please check your running command".format(multi_lang, type)
-        if lang in latin_lang:
-            lang = "latin"
-        elif lang in arabic_lang:
-            lang = "arabic"
-        elif lang in cyrillic_lang:
-            lang = "cyrillic"
-        elif lang in devanagari_lang:
-            lang = "devanagari"
-        global_config['Global'][
-            'character_dict_path'] = 'ppocr/utils/dict/{}_dict.txt'.format(lang)
-        global_config['Global'][
-            'save_model_dir'] = './output/rec_{}_lite'.format(lang)
-        global_config['Train']['dataset'][
-            'label_file_list'] = ["train_data/{}_train.txt".format(lang)]
-        global_config['Eval']['dataset'][
-            'label_file_list'] = ["train_data/{}_val.txt".format(lang)]
-        global_config['Global']['character_type'] = lang
-        assert (
-            os.path.isfile(
-                os.path.join(project_path, global_config['Global'][
-                    'character_dict_path']))
-        ), "Loss default dictionary file {}_dict.txt.You can download it from \
-https://github.com/PaddlePaddle/PaddleOCR/tree/dygraph/ppocr/utils/dict/".format(
-            lang)
-        return lang
-
-
-def merge_config(config):
-    """
-    Merge config into global config.
-    Args:
-        config (dict): Config to be merged.
-    Returns: global config
-    """
-    for key, value in config.items():
-        if "." not in key:
-            if isinstance(value, dict) and key in global_config:
-                global_config[key].update(value)
-            else:
-                global_config[key] = value
-        else:
-            sub_keys = key.split('.')
-            assert (
-                sub_keys[0] in global_config
-            ), "the sub_keys can only be one of global_config: {}, but get: {}, please check your running command".format(
-                global_config.keys(), sub_keys[0])
-            cur = global_config[sub_keys[0]]
-            for idx, sub_key in enumerate(sub_keys[1:]):
-                if idx == len(sub_keys) - 2:
-                    cur[sub_key] = value
-                else:
-                    cur = cur[sub_key]
-
-
-def loss_file(path):
-    assert (
-        os.path.exists(path)
-    ), "There is no such file:{},Please do not forget to put in the specified file".format(
-        path)
-
-
-if __name__ == '__main__':
-    FLAGS = ArgsParser().parse_args()
-    merge_config(FLAGS.opt)
-    save_file_path = 'rec_{}_lite_train.yml'.format(FLAGS.language)
-    if os.path.isfile(save_file_path):
-        os.remove(save_file_path)
-
-    if FLAGS.train:
-        global_config['Train']['dataset']['label_file_list'] = [FLAGS.train]
-        train_label_path = os.path.join(project_path, FLAGS.train)
-        loss_file(train_label_path)
-    if FLAGS.val:
-        global_config['Eval']['dataset']['label_file_list'] = [FLAGS.val]
-        eval_label_path = os.path.join(project_path, FLAGS.val)
-        loss_file(eval_label_path)
-    if FLAGS.dict:
-        global_config['Global']['character_dict_path'] = FLAGS.dict
-        dict_path = os.path.join(project_path, FLAGS.dict)
-        loss_file(dict_path)
-    if FLAGS.data_dir:
-        global_config['Eval']['dataset']['data_dir'] = FLAGS.data_dir
-        global_config['Train']['dataset']['data_dir'] = FLAGS.data_dir
-        data_dir = os.path.join(project_path, FLAGS.data_dir)
-        loss_file(data_dir)
-
-    with open(save_file_path, 'w') as f:
-        yaml.dump(
-            dict(global_config), f, default_flow_style=False, sort_keys=False)
-    logging.info("Project path is          :{}".format(project_path))
-    logging.info("Train list path set to   :{}".format(global_config['Train'][
-        'dataset']['label_file_list'][0]))
-    logging.info("Eval list path set to    :{}".format(global_config['Eval'][
-        'dataset']['label_file_list'][0]))
-    logging.info("Dataset root path set to :{}".format(global_config['Eval'][
-        'dataset']['data_dir']))
-    logging.info("Dict path set to         :{}".format(global_config['Global'][
-        'character_dict_path']))
-    logging.info("Config file set to       :configs/rec/multi_language/{}".
-                 format(save_file_path))

pyxlpr/ppocr/data/__init__.py

@@ -1,135 +0,0 @@
-# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
-
-import os
-import sys
-import numpy as np
-import paddle
-import signal
-import random
-
-__dir__ = os.path.dirname(os.path.abspath(__file__))
-sys.path.append(os.path.abspath(os.path.join(__dir__, '../..')))
-
-import copy
-from paddle.io import Dataset, DataLoader, BatchSampler, DistributedBatchSampler
-import paddle.distributed as dist
-
-from pyxlpr.ppocr.data.imaug import transform, create_operators
-# 可以在ppocr/data目录下新增脚本，添加自己的数据格式
-# 个人想法，到时候新增的数据格式类，都统一放到一个文件xl_dataset里，方便整理和分享
-from pyxlpr.ppocr.data.simple_dataset import *  # 这里扩展了一些自己的基础数据格式
-from pyxlpr.ppocr.data.lmdb_dataset import LMDBDataSet
-from pyxlpr.ppocr.data.pgnet_dataset import PGDataSet
-from pyxlpr.ppocr.data.pubtab_dataset import PubTabDataSet
-
-# 或者不在ppocr.data这里加也可以，重点是能导入特定接口范式的类，让这里eval能取到即可。
-
-__all__ = ['build_dataloader', 'transform', 'create_operators']
-
-
-def term_mp(sig_num, frame):
-    """ kill all child processes
-    """
-    pid = os.getpid()
-    pgid = os.getpgid(os.getpid())
-    print("main proc {} exit, kill process group " "{}".format(pid, pgid))
-    os.killpg(pgid, signal.SIGKILL)
-
-
-def build_dataloader(config, mode, device, logger, seed=None):
-    config = copy.deepcopy(config)
-
-    support_dict = [
-        'SimpleDataSet', 'LMDBDataSet', 'PGDataSet', 'PubTabDataSet', 'XlSimpleDataSet'
-    ]
-    module_name = config[mode]['dataset']['name']
-    assert module_name in support_dict, Exception(
-        'DataSet only support {}'.format(support_dict))
-    # 这里eval没有安全隐患，因为会提前判断module_name要属于support_dict中的值
-    assert mode in ['Train', 'Eval', 'Test'
-                    ], "Mode should be Train, Eval or Test."
-
-    # 自定义数据格式类，除了初始化，似乎没看到还有其他框架性的约束
-    dataset = eval(module_name)(config, mode, logger, seed)
-    loader_config = config[mode]['loader']
-    # loader的必填参数
-    batch_size = loader_config['batch_size_per_card']
-    drop_last = loader_config['drop_last']
-    shuffle = loader_config['shuffle']
-    num_workers = loader_config['num_workers']
-    # 可选参数
-    # 注意这里实现机制策略与d2的不同，d2习惯是把这个参数加入到初始默认配置字典中，而ppocr是在函数运算中智能判断。
-    if 'use_shared_memory' in loader_config.keys():
-        use_shared_memory = loader_config['use_shared_memory']
-    else:
-        # use_shared_memory (bool) - 是否使用共享内存来提升子进程将数据放入进程间队列的速度，
-        # 该参数尽在多进程模式下有效(即 num_workers > 0 )，
-        # 请确认机器上有足够的共享内存空间(如Linux系统下 /dev/shm/ 目录空间大小)再设置此参数。
-        # 默认为True。
-        use_shared_memory = True
-    if mode == "Train":
-        # Train会用多卡机制分配BatchSampler，当然，如果外部设置了单卡也可以，单卡是特殊的多卡机制。
-        # Distribute data to multiple cards
-        batch_sampler = DistributedBatchSampler(
-            dataset=dataset,
-            batch_size=batch_size,
-            shuffle=shuffle,
-            drop_last=drop_last)
-    else:
-        # 非Train阶段，强制使用单卡处理。
-        # Distribute data to single card
-        batch_sampler = BatchSampler(
-            dataset=dataset,
-            batch_size=batch_size,
-            shuffle=shuffle,
-            drop_last=drop_last)
-
-    data_loader = DataLoader(
-        dataset=dataset,
-        batch_sampler=batch_sampler,
-        places=device,
-        num_workers=num_workers,
-        return_list=True,
-        use_shared_memory=use_shared_memory)
-
-    # 看到用了signal库，好奇~~ https://www.jianshu.com/p/e0a69beb98bb
-    # support exit using ctrl+c
-    signal.signal(signal.SIGINT, term_mp)
-    signal.signal(signal.SIGTERM, term_mp)
-
-    return data_loader
-
-
-def build_dataset(config, mode, logger, seed=None):
-    """ ckz: 有时候不需要获得loader，只要dataset即可 """
-    config = copy.deepcopy(config)
-
-    support_dict = [
-        'SimpleDataSet', 'LMDBDataSet', 'PGDataSet', 'PubTabDataSet', 'XlSimpleDataSet'
-    ]
-    module_name = config[mode]['dataset']['name']
-    assert module_name in support_dict, Exception(
-        'DataSet only support {}'.format(support_dict))
-    assert mode in ['Train', 'Eval', 'Test'
-                    ], "Mode should be Train, Eval or Test."
-
-    dataset = eval(module_name)(config, mode, logger, seed)
-
-    return dataset

pyxlpr/ppocr/data/imaug/ColorJitter.py

@@ -1,26 +0,0 @@
-# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-from paddle.vision.transforms import ColorJitter as pp_ColorJitter
-
-__all__  = ['ColorJitter']
-
-class ColorJitter(object):
-    def __init__(self, brightness=0, contrast=0, saturation=0, hue=0,**kwargs):
-        self.aug = pp_ColorJitter(brightness, contrast, saturation, hue)
-
-    def __call__(self, data):
-        image = data['image']
-        image = self.aug(image)
-        data['image'] = image
-        return data

pyxlpr/ppocr/data/imaug/__init__.py

@@ -1,67 +0,0 @@
-# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
-
-from .iaa_augment import IaaAugment
-from .make_border_map import MakeBorderMap
-from .make_shrink_map import MakeShrinkMap
-from .random_crop_data import EastRandomCropData, RandomCropImgMask
-from .make_pse_gt import MakePseGt
-
-from .rec_img_aug import RecAug, RecResizeImg, ClsResizeImg, SRNRecResizeImg, NRTRRecResizeImg, SARRecResizeImg
-from .randaugment import RandAugment
-from .copy_paste import CopyPaste
-from .ColorJitter import ColorJitter
-from .operators import *  # 操作器的定义方式，可以参考这里的DecodeImage实现
-from .label_ops import *
-
-from .east_process import *
-from .sast_process import *
-from .pg_process import *
-from .gen_table_mask import *
-
-
-def transform(data, ops=None):
-    """ transform """
-    if ops is None:
-        ops = []
-    for op in ops:
-        data = op(data)
-        if data is None:
-            return None
-    return data
-
-
-def create_operators(op_param_list, global_config=None):
-    """
-    create operators based on the config
-
-    Args:
-        params(list): a dict list, used to create some operators
-    """
-    assert isinstance(op_param_list, list), ('operator config should be a list')
-    ops = []
-    for operator in op_param_list:
-        assert isinstance(operator,
-                          dict) and len(operator) == 1, "yaml format error"
-        op_name = list(operator)[0]
-        param = {} if operator[op_name] is None else operator[op_name]
-        if global_config is not None:
-            param.update(global_config)
-        op = eval(op_name)(**param)
-        ops.append(op)
-    return ops

pyxlpr/ppocr/data/imaug/copy_paste.py

@@ -1,170 +0,0 @@
-# copyright (c) 2021 PaddlePaddle Authors. All Rights Reserve.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import copy
-import cv2
-import random
-import numpy as np
-from PIL import Image
-from shapely.geometry import Polygon
-
-from pyxlpr.ppocr.data.imaug.iaa_augment import IaaAugment
-from pyxlpr.ppocr.data.imaug.random_crop_data import is_poly_outside_rect
-from pyxlpr.ppocr.tools.infer.utility import get_rotate_crop_image
-
-
-class CopyPaste(object):
-    def __init__(self, objects_paste_ratio=0.2, limit_paste=True, **kwargs):
-        self.ext_data_num = 1
-        self.objects_paste_ratio = objects_paste_ratio
-        self.limit_paste = limit_paste
-        augmenter_args = [{'type': 'Resize', 'args': {'size': [0.5, 3]}}]
-        self.aug = IaaAugment(augmenter_args)
-
-    def __call__(self, data):
-        point_num = data['polys'].shape[1]
-        src_img = data['image']
-        src_polys = data['polys'].tolist()
-        src_ignores = data['ignore_tags'].tolist()
-        ext_data = data['ext_data'][0]
-        ext_image = ext_data['image']
-        ext_polys = ext_data['polys']
-        ext_ignores = ext_data['ignore_tags']
-
-        indexs = [i for i in range(len(ext_ignores)) if not ext_ignores[i]]
-        select_num = max(
-            1, min(int(self.objects_paste_ratio * len(ext_polys)), 30))
-
-        random.shuffle(indexs)
-        select_idxs = indexs[:select_num]
-        select_polys = ext_polys[select_idxs]
-        select_ignores = ext_ignores[select_idxs]
-
-        src_img = cv2.cvtColor(src_img, cv2.COLOR_BGR2RGB)
-        ext_image = cv2.cvtColor(ext_image, cv2.COLOR_BGR2RGB)
-        src_img = Image.fromarray(src_img).convert('RGBA')
-        for poly, tag in zip(select_polys, select_ignores):
-            box_img = get_rotate_crop_image(ext_image, poly)
-
-            src_img, box = self.paste_img(src_img, box_img, src_polys)
-            if box is not None:
-                box = box.tolist() 
-                for _ in range(len(box), point_num):
-                    box.append(box[-1])
-                src_polys.append(box)
-                src_ignores.append(tag)
-        src_img = cv2.cvtColor(np.array(src_img), cv2.COLOR_RGB2BGR)
-        h, w = src_img.shape[:2]
-        src_polys = np.array(src_polys)
-        src_polys[:, :, 0] = np.clip(src_polys[:, :, 0], 0, w)
-        src_polys[:, :, 1] = np.clip(src_polys[:, :, 1], 0, h)
-        data['image'] = src_img
-        data['polys'] = src_polys
-        data['ignore_tags'] = np.array(src_ignores)
-        return data
-
-    def paste_img(self, src_img, box_img, src_polys):
-        box_img_pil = Image.fromarray(box_img).convert('RGBA')
-        src_w, src_h = src_img.size
-        box_w, box_h = box_img_pil.size
-
-        angle = np.random.randint(0, 360)
-        box = np.array([[[0, 0], [box_w, 0], [box_w, box_h], [0, box_h]]])
-        box = rotate_bbox(box_img, box, angle)[0]
-        box_img_pil = box_img_pil.rotate(angle, expand=1)
-        box_w, box_h = box_img_pil.width, box_img_pil.height
-        if src_w - box_w < 0 or src_h - box_h < 0:
-            return src_img, None
-
-        paste_x, paste_y = self.select_coord(src_polys, box, src_w - box_w,
-                                             src_h - box_h)
-        if paste_x is None:
-            return src_img, None
-        box[:, 0] += paste_x
-        box[:, 1] += paste_y
-        r, g, b, A = box_img_pil.split()
-        src_img.paste(box_img_pil, (paste_x, paste_y), mask=A)
-
-        return src_img, box
-
-    def select_coord(self, src_polys, box, endx, endy):
-        if self.limit_paste:
-            xmin, ymin, xmax, ymax = box[:, 0].min(), box[:, 1].min(
-            ), box[:, 0].max(), box[:, 1].max()
-            for _ in range(50):
-                paste_x = random.randint(0, endx)
-                paste_y = random.randint(0, endy)
-                xmin1 = xmin + paste_x
-                xmax1 = xmax + paste_x
-                ymin1 = ymin + paste_y
-                ymax1 = ymax + paste_y
-
-                num_poly_in_rect = 0
-                for poly in src_polys:
-                    if not is_poly_outside_rect(poly, xmin1, ymin1,
-                                                xmax1 - xmin1, ymax1 - ymin1):
-                        num_poly_in_rect += 1
-                        break
-                if num_poly_in_rect == 0:
-                    return paste_x, paste_y
-            return None, None
-        else:
-            paste_x = random.randint(0, endx)
-            paste_y = random.randint(0, endy)
-            return paste_x, paste_y
-
-
-def get_union(pD, pG):
-    return Polygon(pD).union(Polygon(pG)).area
-
-
-def get_intersection_over_union(pD, pG):
-    return get_intersection(pD, pG) / get_union(pD, pG)
-
-
-def get_intersection(pD, pG):
-    return Polygon(pD).intersection(Polygon(pG)).area
-
-
-def rotate_bbox(img, text_polys, angle, scale=1):
-    """
-    from https://github.com/WenmuZhou/DBNet.pytorch/blob/master/data_loader/modules/augment.py
-    Args:
-        img: np.ndarray
-        text_polys: np.ndarray N*4*2
-        angle: int
-        scale: int
-
-    Returns:
-
-    """
-    w = img.shape[1]
-    h = img.shape[0]
-
-    rangle = np.deg2rad(angle)
-    nw = (abs(np.sin(rangle) * h) + abs(np.cos(rangle) * w))
-    nh = (abs(np.cos(rangle) * h) + abs(np.sin(rangle) * w))
-    rot_mat = cv2.getRotationMatrix2D((nw * 0.5, nh * 0.5), angle, scale)
-    rot_move = np.dot(rot_mat, np.array([(nw - w) * 0.5, (nh - h) * 0.5, 0]))
-    rot_mat[0, 2] += rot_move[0]
-    rot_mat[1, 2] += rot_move[1]
-
-    # ---------------------- rotate box ----------------------
-    rot_text_polys = list()
-    for bbox in text_polys:
-        point1 = np.dot(rot_mat, np.array([bbox[0, 0], bbox[0, 1], 1]))
-        point2 = np.dot(rot_mat, np.array([bbox[1, 0], bbox[1, 1], 1]))
-        point3 = np.dot(rot_mat, np.array([bbox[2, 0], bbox[2, 1], 1]))
-        point4 = np.dot(rot_mat, np.array([bbox[3, 0], bbox[3, 1], 1]))
-        rot_text_polys.append([point1, point2, point3, point4])
-    return np.array(rot_text_polys, dtype=np.float32)