dygraph first commit

configs/rec/rec_mv3_tps_bilstm_ctc.yml

-Global:
-  algorithm: STARNet
-  use_gpu: true
-  epoch_num: 72
-  log_smooth_window: 20
-  print_batch_step: 10
-  save_model_dir: output/rec_STARNet
-  save_epoch_step: 3
-  eval_batch_step: 2000
-  train_batch_size_per_card: 256
-  test_batch_size_per_card: 256
-  image_shape: [3, 32, 100]
-  max_text_length: 25
-  character_type: en
-  loss_type: ctc
-  tps: true
-  reader_yml: ./configs/rec/rec_benchmark_reader.yml
-  pretrain_weights:
-  checkpoints:
-  save_inference_dir:
-  infer_img:
-
-  
-Architecture:
-  function: ppocr.modeling.architectures.rec_model,RecModel
-
-TPS:
-  function: ppocr.modeling.stns.tps,TPS
-  num_fiducial: 20
-  loc_lr: 0.1
-  model_name: small
-  
-Backbone:
-  function: ppocr.modeling.backbones.rec_mobilenet_v3,MobileNetV3
-  scale: 0.5
-  model_name: large
- 
-Head:
-  function: ppocr.modeling.heads.rec_ctc_head,CTCPredict
-  encoder_type: rnn
-  SeqRNN:
-    hidden_size: 96
-    
-Loss:
-  function: ppocr.modeling.losses.rec_ctc_loss,CTCLoss
-
-Optimizer:
-  function: ppocr.optimizer,AdamDecay
-  base_lr: 0.001
-  beta1: 0.9
-  beta2: 0.999

configs/rec/rec_r34_vd_none_bilstm_ctc.yml

 Global:
-  algorithm: CRNN
-  use_gpu: true
-  epoch_num: 72
+  use_gpu: false
+  epoch_num: 500
   log_smooth_window: 20
   print_batch_step: 10
-  save_model_dir: output/rec_CRNN
-  save_epoch_step: 3
-  eval_batch_step: 2000
-  train_batch_size_per_card: 256
-  test_batch_size_per_card: 256
-  image_shape: [3, 32, 100]
-  max_text_length: 25
-  character_type: en
-  loss_type: ctc
-  reader_yml: ./configs/rec/rec_benchmark_reader.yml
-  pretrain_weights:
-  checkpoints:
+  save_model_dir: ./output/rec/test/
+  save_epoch_step: 500
+  # evaluation is run every 5000 iterations after the 4000th iteration
+  eval_batch_step: 127
+  # if pretrained_model is saved in static mode, load_static_weights must set to True
+  load_static_weights: True
+  cal_metric_during_train: True
+  pretrained_model:
+  checkpoints: #output/rec/rec_crnn/best_accuracy
   save_inference_dir:
-  infer_img:
-
+  use_visualdl: False
+  infer_img: doc/imgs_words/ch/word_1.jpg
+  # for data or label process
+  max_text_length: 80
+  character_dict_path: ppocr/utils/ppocr_keys_v1.txt
+  character_type: 'ch'
+  use_space_char: False
+  infer_mode: False
+  use_tps: False
 
-Architecture:
-  function: ppocr.modeling.architectures.rec_model,RecModel
-
-Backbone:
-  function: ppocr.modeling.backbones.rec_resnet_vd,ResNet
-  layers: 34
- 
-Head:
-  function: ppocr.modeling.heads.rec_ctc_head,CTCPredict
-  encoder_type: rnn
-  SeqRNN:
-    hidden_size: 256
-    
-Loss:
-  function: ppocr.modeling.losses.rec_ctc_loss,CTCLoss
 
 Optimizer:
-  function: ppocr.optimizer,AdamDecay
-  base_lr: 0.001
+  name: Adam
   beta1: 0.9
   beta2: 0.999
+  learning_rate:
+    name: Cosine
+    lr: 0.001
+    warmup_epoch: 4
+  regularizer:
+    name: 'L2'
+    factor: 0.00001
+
+Architecture:
+  type: rec
+  algorithm: CRNN
+  Transform:
+  Backbone:
+    name: ResNet
+    layers: 200
+  Neck:
+    name: SequenceEncoder
+    encoder_type: fc
+    hidden_size: 96
+  Head:
+    name: CTC
+    fc_decay: 0.00001
+
+Loss:
+  name: CTCLoss
+
+PostProcess:
+  name: CTCLabelDecode
+
+Metric:
+  name: RecMetric
+  main_indicator: acc
+
+TRAIN:
+  dataset:
+    name: SimpleDataSet
+    data_dir: /home/zhoujun20/rec
+    file_list:
+      - /home/zhoujun20/rec/real_data.txt # dataset1
+    ratio_list: [ 0.4,0.6 ]
+    transforms:
+      - DecodeImage: # load image
+          img_mode: BGR
+          channel_first: False
+      - CTCLabelEncode: # Class handling label
+      - RecAug:
+      - RecResizeImg:
+          image_shape: [ 3,32,320 ]
+      - keepKeys:
+          keep_keys: [ 'image','label','length' ] # dataloader将按照此顺序返回list
+  loader:
+    batch_size: 256
+    shuffle: True
+    drop_last: True
+    num_workers: 6
+
+EVAL:
+  dataset:
+    name: SimpleDataSet
+    data_dir: /home/zhoujun20/rec
+    file_list:
+      - /home/zhoujun20/rec/label_val_all.txt
+    transforms:
+      - DecodeImage: # load image
+          img_mode: BGR
+          channel_first: False
+      - CTCLabelEncode: # Class handling label
+      - RecResizeImg:
+          image_shape: [ 3,32,320 ]
+      - keepKeys:
+          keep_keys: [ 'image','label','length' ] # dataloader将按照此顺序返回list
+  loader:
+    shuffle: False
+    drop_last: False
+    batch_size: 256
+    num_workers: 6

configs/rec/rec_r34_vd_none_none_ctc.yml

-Global:
-  algorithm: Rosetta
-  use_gpu: true
-  epoch_num: 72
-  log_smooth_window: 20
-  print_batch_step: 10
-  save_model_dir: output/rec_Rosetta
-  save_epoch_step: 3
-  eval_batch_step: 2000
-  train_batch_size_per_card: 256
-  test_batch_size_per_card: 256
-  image_shape: [3, 32, 100]
-  max_text_length: 25
-  character_type: en
-  loss_type: ctc
-  reader_yml: ./configs/rec/rec_benchmark_reader.yml
-  pretrain_weights:
-  checkpoints:
-  save_inference_dir:
-  infer_img:
-  
-Architecture:
-  function: ppocr.modeling.architectures.rec_model,RecModel
-
-Backbone:
-  function: ppocr.modeling.backbones.rec_resnet_vd,ResNet
-  layers: 34
-
-Head:
-  function: ppocr.modeling.heads.rec_ctc_head,CTCPredict
-  encoder_type: reshape
-  
-Loss:
-  function: ppocr.modeling.losses.rec_ctc_loss,CTCLoss
-
-Optimizer:
-  function: ppocr.optimizer,AdamDecay
-  base_lr: 0.001
-  beta1: 0.9
-  beta2: 0.999

configs/rec/rec_r34_vd_tps_bilstm_attn.yml

-Global:
-  algorithm: RARE
-  use_gpu: true
-  epoch_num: 72
-  log_smooth_window: 20
-  print_batch_step: 10
-  save_model_dir: output/rec_RARE
-  save_epoch_step: 3
-  eval_batch_step: 2000
-  train_batch_size_per_card: 256
-  test_batch_size_per_card: 256
-  image_shape: [3, 32, 100]
-  max_text_length: 25
-  character_type: en
-  loss_type: attention
-  tps: true
-  reader_yml: ./configs/rec/rec_benchmark_reader.yml
-  pretrain_weights:
-  checkpoints:
-  save_inference_dir:
-  infer_img:
-
-
-Architecture:
-  function: ppocr.modeling.architectures.rec_model,RecModel
-
-TPS:
-  function: ppocr.modeling.stns.tps,TPS
-  num_fiducial: 20
-  loc_lr: 0.1
-  model_name: large
-
-Backbone:
-  function: ppocr.modeling.backbones.rec_resnet_vd,ResNet
-  layers: 34
- 
-Head:
-  function: ppocr.modeling.heads.rec_attention_head,AttentionPredict
-  encoder_type: rnn
-  SeqRNN:
-    hidden_size: 256
-  Attention:
-    decoder_size: 128
-    word_vector_dim: 128
-  
-Loss:
-  function: ppocr.modeling.losses.rec_attention_loss,AttentionLoss
-  
-Optimizer:
-  function: ppocr.optimizer,AdamDecay
-  base_lr: 0.001
-  beta1: 0.9
-  beta2: 0.999

configs/rec/rec_r34_vd_tps_bilstm_ctc.yml

-Global:
-  algorithm: STARNet
-  use_gpu: true
-  epoch_num: 72
-  log_smooth_window: 20
-  print_batch_step: 10
-  save_model_dir: output/rec_STARNet
-  save_epoch_step: 3
-  eval_batch_step: 2000
-  train_batch_size_per_card: 256
-  test_batch_size_per_card: 256
-  image_shape: [3, 32, 100]
-  max_text_length: 25
-  character_type: en
-  loss_type: ctc
-  tps: true
-  reader_yml: ./configs/rec/rec_benchmark_reader.yml
-  pretrain_weights:
-  checkpoints:
-  save_inference_dir:
-  infer_img:
-
-
-Architecture:
-  function: ppocr.modeling.architectures.rec_model,RecModel
-
-TPS:
-  function: ppocr.modeling.stns.tps,TPS
-  num_fiducial: 20
-  loc_lr: 0.1
-  model_name: large
-
-Backbone:
-  function: ppocr.modeling.backbones.rec_resnet_vd,ResNet
-  layers: 34
- 
-Head:
-  function: ppocr.modeling.heads.rec_ctc_head,CTCPredict
-  encoder_type: rnn
-  SeqRNN:
-    hidden_size: 256
-    
-Loss:
-  function: ppocr.modeling.losses.rec_ctc_loss,CTCLoss
-
-Optimizer:
-  function: ppocr.optimizer,AdamDecay
-  base_lr: 0.001
-  beta1: 0.9
-  beta2: 0.999

configs/rec/rec_r50fpn_vd_none_srn.yml

-Global:
-  algorithm: SRN
-  use_gpu: true
-  epoch_num: 72
-  log_smooth_window: 20
-  print_batch_step: 10
-  save_model_dir: output/rec_pvam_withrotate
-  save_epoch_step: 1
-  eval_batch_step: 8000
-  train_batch_size_per_card: 64
-  test_batch_size_per_card: 1
-  image_shape: [1, 64, 256]
-  max_text_length: 25
-  character_type: en
-  loss_type: srn
-  num_heads: 8
-  average_window: 0.15
-  max_average_window: 15625
-  min_average_window: 10000
-  reader_yml: ./configs/rec/rec_benchmark_reader.yml
-  pretrain_weights: 
-  checkpoints:
-  save_inference_dir:
-  infer_img:
-
-Architecture:
-  function: ppocr.modeling.architectures.rec_model,RecModel
-
-Backbone:
-  function: ppocr.modeling.backbones.rec_resnet_fpn,ResNet
-  layers: 50
- 
-Head:
-  function: ppocr.modeling.heads.rec_srn_all_head,SRNPredict
-  encoder_type: rnn
-  num_encoder_TUs: 2
-  num_decoder_TUs: 4
-  hidden_dims: 512
-  SeqRNN:
-    hidden_size: 256
-    
-Loss:
-  function: ppocr.modeling.losses.rec_srn_loss,SRNLoss
-
-Optimizer:
-  function: ppocr.optimizer,AdamDecay
-  base_lr: 0.0001
-  beta1: 0.9
-  beta2: 0.999

ppocr/data/__init__.py

@@ -11,3 +11,114 @@
 # 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
+
+__dir__ = os.path.dirname(os.path.abspath(__file__))
+sys.path.append(os.path.abspath(os.path.join(__dir__, '../..')))
+
+import copy
+from paddle.io import DataLoader, DistributedBatchSampler, BatchSampler
+import paddle.distributed as dist
+
+from ppocr.data.imaug import transform, create_operators
+
+__all__ = ['build_dataloader', 'transform', 'create_operators']
+
+
+def build_dataset(config, global_config):
+    from ppocr.data.dataset import SimpleDataSet, LMDBDateSet
+    support_dict = ['SimpleDataSet', 'LMDBDateSet']
+
+    module_name = config.pop('name')
+    assert module_name in support_dict, Exception(
+        'DataSet only support {}'.format(support_dict))
+
+    dataset = eval(module_name)(config, global_config)
+    return dataset
+
+
+def build_dataloader(config, device, distributed=False, global_config=None):
+    from ppocr.data.dataset import BatchBalancedDataLoader
+
+    config = copy.deepcopy(config)
+    dataset_config = config['dataset']
+
+    _dataset_list = []
+    file_list = dataset_config.pop('file_list')
+    if len(file_list) == 1:
+        ratio_list = [1.0]
+    else:
+        ratio_list = dataset_config.pop('ratio_list')
+    for file in file_list:
+        dataset_config['file_list'] = file
+        _dataset = build_dataset(dataset_config, global_config)
+        _dataset_list.append(_dataset)
+    data_loader = BatchBalancedDataLoader(_dataset_list, ratio_list,
+                                          distributed, device, config['loader'])
+    return data_loader, _dataset.info_dict
+
+
+def test_loader():
+    import time
+    from tools.program import load_config, ArgsParser
+
+    FLAGS = ArgsParser().parse_args()
+    config = load_config(FLAGS.config)
+
+    place = paddle.CPUPlace()
+    paddle.disable_static(place)
+    import time
+
+    data_loader, _ = build_dataloader(
+        config['TRAIN'], place, global_config=config['Global'])
+    start = time.time()
+    print(len(data_loader))
+    for epoch in range(1):
+        print('epoch {} ****************'.format(epoch))
+        for i, batch in enumerate(data_loader):
+            if i > len(data_loader):
+                break
+            t = time.time() - start
+            start = time.time()
+            print('{}, batch : {} ,time {}'.format(i, len(batch[0]), t))
+
+            continue
+            import matplotlib.pyplot as plt
+
+            from matplotlib import pyplot as plt
+            import cv2
+            fig = plt.figure()
+            # # cv2.imwrite('img.jpg',batch[0].numpy()[0].transpose((1,2,0)))
+            # # cv2.imwrite('bmap.jpg',batch[1].numpy()[0])
+            # # cv2.imwrite('bmask.jpg',batch[2].numpy()[0])
+            # # cv2.imwrite('smap.jpg',batch[3].numpy()[0])
+            # # cv2.imwrite('smask.jpg',batch[4].numpy()[0])
+            plt.title('img')
+            plt.imshow(batch[0].numpy()[0].transpose((1, 2, 0)))
+            # plt.figure()
+            # plt.title('bmap')
+            # plt.imshow(batch[1].numpy()[0],cmap='Greys')
+            # plt.figure()
+            # plt.title('bmask')
+            # plt.imshow(batch[2].numpy()[0],cmap='Greys')
+            # plt.figure()
+            # plt.title('smap')
+            # plt.imshow(batch[3].numpy()[0],cmap='Greys')
+            # plt.figure()
+            # plt.title('smask')
+            # plt.imshow(batch[4].numpy()[0],cmap='Greys')
+            # plt.show()
+            # break
+
+
+if __name__ == '__main__':
+    test_loader()

ppocr/data/dataset.py

+# 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.
+import copy
+import numpy as np
+import os
+import lmdb
+import random
+import signal
+import paddle
+from paddle.io import Dataset, DataLoader, DistributedBatchSampler, BatchSampler
+
+from .imaug import transform, create_operators
+from ppocr.utils.logging import get_logger
+
+
+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)
+
+
+signal.signal(signal.SIGINT, term_mp)
+signal.signal(signal.SIGTERM, term_mp)
+
+
+class ModeException(Exception):
+    """
+    ModeException
+    """
+
+    def __init__(self, message='', mode=''):
+        message += "\nOnly the following 3 modes are supported: " \
+                   "train, valid, test. Given mode is {}".format(mode)
+        super(ModeException, self).__init__(message)
+
+
+class SampleNumException(Exception):
+    """
+    SampleNumException
+    """
+
+    def __init__(self, message='', sample_num=0, batch_size=1):
+        message += "\nError: The number of the whole data ({}) " \
+                   "is smaller than the batch_size ({}), and drop_last " \
+                   "is turnning on, so nothing  will feed in program, " \
+                   "Terminated now. Please reset batch_size to a smaller " \
+                   "number or feed more data!".format(sample_num, batch_size)
+        super(SampleNumException, self).__init__(message)
+
+
+def get_file_list(file_list, data_dir, delimiter='\t'):
+    """
+    read label list from file and shuffle the list
+
+    Args:
+        params(dict):
+    """
+    if isinstance(file_list, str):
+        file_list = [file_list]
+    data_source_list = []
+    for file in file_list:
+        with open(file) as f:
+            full_lines = [line.strip() for line in f]
+            for line in full_lines:
+                try:
+                    img_path, label = line.split(delimiter)
+                except:
+                    logger = get_logger()
+                    logger.warning('label error in {}'.format(line))
+                img_path = os.path.join(data_dir, img_path)
+                data = {'img_path': img_path, 'label': label}
+                data_source_list.append(data)
+    return data_source_list
+
+
+class LMDBDateSet(Dataset):
+    def __init__(self, config, global_config):
+        super(LMDBDateSet, self).__init__()
+        self.data_list = self.load_lmdb_dataset(
+            config['file_list'], global_config['max_text_length'])
+        random.shuffle(self.data_list)
+
+        self.ops = create_operators(config['transforms'], global_config)
+
+        # for rec
+        character = ''
+        for op in self.ops:
+            if hasattr(op, 'character'):
+                character = getattr(op, 'character')
+
+        self.info_dict = {'character': character}
+
+    def load_lmdb_dataset(self, data_dir, max_text_length):
+        self.env = lmdb.open(
+            data_dir,
+            max_readers=32,
+            readonly=True,
+            lock=False,
+            readahead=False,
+            meminit=False)
+        if not self.env:
+            print('cannot create lmdb from %s' % (data_dir))
+            exit(0)
+
+        filtered_index_list = []
+        with self.env.begin(write=False) as txn:
+            nSamples = int(txn.get('num-samples'.encode()))
+            self.nSamples = nSamples
+            for index in range(self.nSamples):
+                index += 1  # lmdb starts with 1
+                label_key = 'label-%09d'.encode() % index
+                label = txn.get(label_key).decode('utf-8')
+                if len(label) > max_text_length:
+                    # print(f'The length of the label is longer than max_length: length
+                    # {len(label)}, {label} in dataset {self.root}')
+                    continue
+
+                # By default, images containing characters which are not in opt.character are filtered.
+                # You can add [UNK] token to `opt.character` in utils.py instead of this filtering.
+                filtered_index_list.append(index)
+        return filtered_index_list
+
+    def print_lmdb_sets_info(self, lmdb_sets):
+        lmdb_info_strs = []
+        for dataset_idx in range(len(lmdb_sets)):
+            tmp_str = " %s:%d," % (lmdb_sets[dataset_idx]['dirpath'],
+                                   lmdb_sets[dataset_idx]['num_samples'])
+            lmdb_info_strs.append(tmp_str)
+        lmdb_info_strs = ''.join(lmdb_info_strs)
+        logger = get_logger()
+        logger.info("DataSummary:" + lmdb_info_strs)
+        return
+
+    def __getitem__(self, idx):
+        idx = self.data_list[idx]
+        with self.env.begin(write=False) as txn:
+            label_key = 'label-%09d'.encode() % idx
+            label = txn.get(label_key)
+            if label is not None:
+                label = label.decode('utf-8')
+                img_key = 'image-%09d'.encode() % idx
+                imgbuf = txn.get(img_key)
+                data = {'image': imgbuf, 'label': label}
+                outs = transform(data, self.ops)
+            else:
+                outs = None
+            if outs is None:
+                return self.__getitem__(np.random.randint(self.__len__()))
+            return outs
+
+    def __len__(self):
+        return len(self.data_list)
+
+
+class SimpleDataSet(Dataset):
+    def __init__(self, config, global_config):
+        super(SimpleDataSet, self).__init__()
+        delimiter = config.get('delimiter', '\t')
+        self.data_list = get_file_list(config['file_list'], config['data_dir'],
+                                       delimiter)
+        random.shuffle(self.data_list)
+
+        self.ops = create_operators(config['transforms'], global_config)
+
+        # for rec
+        character = ''
+        for op in self.ops:
+            if hasattr(op, 'character'):
+                character = getattr(op, 'character')
+
+        self.info_dict = {'character': character}
+
+    def __getitem__(self, idx):
+        data = copy.deepcopy(self.data_list[idx])
+        with open(data['img_path'], 'rb') as f:
+            img = f.read()
+            data['image'] = img
+        outs = transform(data, self.ops)
+        if outs is None:
+            return self.__getitem__(np.random.randint(self.__len__()))
+        return outs
+
+    def __len__(self):
+        return len(self.data_list)
+
+
+class BatchBalancedDataLoader(object):
+    def __init__(self,
+                 dataset_list: list,
+                 ratio_list: list,
+                 distributed,
+                 device,
+                 loader_args: dict):
+        """
+        对datasetlist里的dataset按照ratio_list里对应的比例组合，似的每个batch里的数据按按照比例采样的
+        :param dataset_list: 数据集列表
+        :param ratio_list: 比例列表
+        :param loader_args: dataloader的配置
+        """
+        assert sum(ratio_list) == 1 and len(dataset_list) == len(ratio_list)
+
+        self.dataset_len = 0
+        self.data_loader_list = []
+        self.dataloader_iter_list = []
+        all_batch_size = loader_args.pop('batch_size')
+        batch_size_list = list(
+            map(int, [max(1.0, all_batch_size * x) for x in ratio_list]))
+        remain_num = all_batch_size - sum(batch_size_list)
+        batch_size_list[np.argmax(ratio_list)] += remain_num
+
+        for _dataset, _batch_size in zip(dataset_list, batch_size_list):
+            if distributed:
+                batch_sampler_class = DistributedBatchSampler
+            else:
+                batch_sampler_class = BatchSampler
+            batch_sampler = batch_sampler_class(
+                dataset=_dataset,
+                batch_size=_batch_size,
+                shuffle=loader_args['shuffle'],
+                drop_last=loader_args['drop_last'], )
+            _data_loader = DataLoader(
+                dataset=_dataset,
+                batch_sampler=batch_sampler,
+                places=device,
+                num_workers=loader_args['num_workers'],
+                return_list=True, )
+            self.data_loader_list.append(_data_loader)
+            self.dataloader_iter_list.append(iter(_data_loader))
+            self.dataset_len += len(_dataset)
+
+    def __iter__(self):
+        return self
+
+    def __len__(self):
+        return min([len(x) for x in self.data_loader_list])
+
+    def __next__(self):
+        batch = []
+        for i, data_loader_iter in enumerate(self.dataloader_iter_list):
+            try:
+                _batch_i = next(data_loader_iter)
+                batch.append(_batch_i)
+            except StopIteration:
+                self.dataloader_iter_list[i] = iter(self.data_loader_list[i])
+                _batch_i = next(self.dataloader_iter_list[i])
+                batch.append(_batch_i)
+            except ValueError:
+                pass
+        if len(batch) > 0:
+            batch_list = []
+            batch_item_size = len(batch[0])
+            for i in range(batch_item_size):
+                cur_item_list = [batch_i[i] for batch_i in batch]
+                batch_list.append(paddle.concat(cur_item_list, axis=0))
+        else:
+            batch_list = batch[0]
+        return batch_list
+
+
+def fill_batch(batch):
+    """
+    2020.09.08： The current paddle version only supports returning data with the same length.
+                Therefore, fill in the batches with inconsistent lengths.
+                this method is currently only useful for text detection
+    """
+    keys = list(range(len(batch[0])))
+    v_max_len_dict = {}
+    for k in keys:
+        v_max_len_dict[k] = max([len(item[k]) for item in batch])
+    for item in batch:
+        length = []
+        for k in keys:
+            v = item[k]
+            length.append(len(v))
+            assert isinstance(v, np.ndarray)
+            if len(v) == v_max_len_dict[k]:
+                continue
+            try:
+                tmp_shape = [v_max_len_dict[k] - len(v)] + list(v[0].shape)
+            except:
+                a = 1
+            tmp_array = np.zeros(tmp_shape, dtype=v[0].dtype)
+            new_array = np.concatenate([v, tmp_array])
+            item[k] = new_array
+        item.append(length)
+    return batch

ppocr/data/det/data_augment.py

-# -*- coding:utf-8 -*- 
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
-
-import numpy as np
-import random
-import cv2
-import math
-
-import imgaug
-import imgaug.augmenters as iaa
-
-
-def AugmentData(data):
-    img = data['image']
-    shape = img.shape
-
-    aug = iaa.Sequential(
-        [iaa.Fliplr(0.5), iaa.Affine(rotate=(-10, 10)), iaa.Resize(
-            (0.5, 3))]).to_deterministic()
-
-    def may_augment_annotation(aug, data, shape):
-        if aug is None:
-            return data
-
-        line_polys = []
-        for poly in data['polys']:
-            new_poly = may_augment_poly(aug, shape, poly)
-            line_polys.append(new_poly)
-        data['polys'] = np.array(line_polys)
-        return data
-
-    def may_augment_poly(aug, img_shape, poly):
-        keypoints = [imgaug.Keypoint(p[0], p[1]) for p in poly]
-        keypoints = aug.augment_keypoints(
-            [imgaug.KeypointsOnImage(
-                keypoints, shape=img_shape)])[0].keypoints
-        poly = [(p.x, p.y) for p in keypoints]
-        return poly
-
-    img_aug = aug.augment_image(img)
-    data['image'] = img_aug
-    data = may_augment_annotation(aug, data, shape)
-    return data

ppocr/data/det/dataset_traversal.py

-#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.
-
-import os
-import sys
-import math
-import random
-import functools
-import numpy as np
-import cv2
-import string
-from ppocr.utils.utility import initial_logger
-logger = initial_logger()
-from ppocr.utils.utility import create_module
-from ppocr.utils.utility import get_image_file_list
-import time
-
-
-class TrainReader(object):
-    def __init__(self, params):
-        self.num_workers = params['num_workers']
-        self.label_file_path = params['label_file_path']
-        print(self.label_file_path)
-        self.use_mul_data = False
-        if isinstance(self.label_file_path, list):
-            self.use_mul_data = True
-            self.data_ratio_list = params['data_ratio_list']
-        self.batch_size = params['train_batch_size_per_card']
-        assert 'process_function' in params,\
-            "absence process_function in Reader"
-        self.process = create_module(params['process_function'])(params)
-
-    def __call__(self, process_id):     
-        def sample_iter_reader():
-            with open(self.label_file_path, "rb") as fin:
-                label_infor_list = fin.readlines()
-            img_num = len(label_infor_list)
-            img_id_list = list(range(img_num))
-            random.shuffle(img_id_list)
-            if sys.platform == "win32" and self.num_workers != 1:
-                print("multiprocess is not fully compatible with Windows."
-                      "num_workers will be 1.")
-                self.num_workers = 1
-            for img_id in range(process_id, img_num, self.num_workers):
-                label_infor = label_infor_list[img_id_list[img_id]]
-                outs = self.process(label_infor)
-                if outs is None:
-                    continue
-                yield outs
-
-        def sample_iter_reader_mul():
-            batch_size = 1000
-            data_source_list = self.label_file_path
-            batch_size_list = list(map(int, [max(1.0, batch_size * x) for x in self.data_ratio_list]))
-            print(self.data_ratio_list, batch_size_list)
-
-            data_filename_list, data_size_list, fetch_record_list = [], [], []
-            for data_source in data_source_list:
-                image_files = open(data_source, "rb").readlines()
-                random.shuffle(image_files)
-                data_filename_list.append(image_files)
-                data_size_list.append(len(image_files))
-                fetch_record_list.append(0)
-
-            image_batch = []
-            # get a batch of img_fns and poly_fns
-            for i in range(0, len(batch_size_list)):
-                bs = batch_size_list[i]
-                ds = data_size_list[i]
-                image_names = data_filename_list[i]
-                fetch_record = fetch_record_list[i]
-                data_path = data_source_list[i]
-                for j in range(fetch_record, fetch_record + bs):
-                    index = j % ds
-                    image_batch.append(image_names[index])
-
-                if (fetch_record + bs) > ds:
-                    fetch_record_list[i] = 0
-                    random.shuffle(data_filename_list[i])
-                else:
-                    fetch_record_list[i] = fetch_record + bs
-
-            if sys.platform == "win32":
-                print("multiprocess is not fully compatible with Windows."
-                      "num_workers will be 1.")
-                self.num_workers = 1
-
-            for label_infor in image_batch:
-                outs = self.process(label_infor)
-                if outs is None:
-                    continue
-                yield outs
-
-        def batch_iter_reader():
-            batch_outs = []
-            if self.use_mul_data:
-                print("Sample date from multiple datasets!")
-                for outs in sample_iter_reader_mul():
-                    batch_outs.append(outs)
-                    if len(batch_outs) == self.batch_size:
-                        yield batch_outs
-                        batch_outs = []                
-            else:
-                for outs in sample_iter_reader():
-                    batch_outs.append(outs)
-                    if len(batch_outs) == self.batch_size:
-                        yield batch_outs
-                        batch_outs = []
-
-        return batch_iter_reader
-
-
-class EvalTestReader(object):
-    def __init__(self, params):
-        self.params = params
-        assert 'process_function' in params,\
-            "absence process_function in EvalTestReader"
-
-    def __call__(self, mode):
-        process_function = create_module(self.params['process_function'])(
-            self.params)
-        batch_size = self.params['test_batch_size_per_card']
-
-        img_list = []
-        if mode != "test":
-            img_set_dir = self.params['img_set_dir']
-            img_name_list_path = self.params['label_file_path']
-            with open(img_name_list_path, "rb") as fin:
-                lines = fin.readlines()
-                for line in lines:
-                    img_name = line.decode().strip("\n").split("\t")[0]
-                    img_path = os.path.join(img_set_dir, img_name)
-                    img_list.append(img_path)
-        else:
-            img_path = self.params['infer_img']
-            img_list = get_image_file_list(img_path)
-
-        def batch_iter_reader():
-            batch_outs = []
-            for img_path in img_list:
-                img = cv2.imread(img_path)
-                if img is None:
-                    logger.info("{} does not exist!".format(img_path))
-                    continue
-                elif len(list(img.shape)) == 2 or img.shape[2] == 1:
-                    img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
-                outs = process_function(img)
-                outs.append(img_path)
-                batch_outs.append(outs)
-                if len(batch_outs) == batch_size:
-                    yield batch_outs
-                    batch_outs = []
-            if len(batch_outs) != 0:
-                yield batch_outs
-
-        return batch_iter_reader

ppocr/data/det/db_process.py

-#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.
-
-import math
-import cv2
-import numpy as np
-import json
-import sys
-from ppocr.utils.utility import initial_logger, check_and_read_gif
-logger = initial_logger()
-
-from .data_augment import AugmentData
-from .random_crop_data import RandomCropData
-from .make_shrink_map import MakeShrinkMap
-from .make_border_map import MakeBorderMap
-
-
-class DBProcessTrain(object):
-    """
-    DB pre-process for Train mode
-    """
-
-    def __init__(self, params):
-        self.img_set_dir = params['img_set_dir']
-        self.image_shape = params['image_shape']
-
-    def order_points_clockwise(self, pts):
-        rect = np.zeros((4, 2), dtype="float32")
-        s = pts.sum(axis=1)
-        rect[0] = pts[np.argmin(s)]
-        rect[2] = pts[np.argmax(s)]
-        diff = np.diff(pts, axis=1)
-        rect[1] = pts[np.argmin(diff)]
-        rect[3] = pts[np.argmax(diff)]
-        return rect
-
-    def make_data_dict(self, imgvalue, entry):
-        boxes = []
-        texts = []
-        ignores = []
-        for rect in entry:
-            points = rect['points']
-            transcription = rect['transcription']
-            try:
-                box = self.order_points_clockwise(
-                    np.array(points).reshape(-1, 2))
-                if cv2.contourArea(box) > 0:
-                    boxes.append(box)
-                    texts.append(transcription)
-                    ignores.append(transcription in ['*', '###'])
-            except:
-                print('load label failed!')
-        data = {
-            'image': imgvalue,
-            'shape': [imgvalue.shape[0], imgvalue.shape[1]],
-            'polys': np.array(boxes),
-            'texts': texts,
-            'ignore_tags': ignores,
-        }
-        return data
-
-    def NormalizeImage(self, data):
-        im = data['image']
-        img_mean = [0.485, 0.456, 0.406]
-        img_std = [0.229, 0.224, 0.225]
-        im = im.astype(np.float32, copy=False)
-        im = im / 255
-        im -= img_mean
-        im /= img_std
-        channel_swap = (2, 0, 1)
-        im = im.transpose(channel_swap)
-        data['image'] = im
-        return data
-
-    def FilterKeys(self, data):
-        filter_keys = ['polys', 'texts', 'ignore_tags', 'shape']
-        for key in filter_keys:
-            if key in data:
-                del data[key]
-        return data
-
-    def convert_label_infor(self, label_infor):
-        label_infor = label_infor.decode()
-        label_infor = label_infor.encode('utf-8').decode('utf-8-sig')
-        substr = label_infor.strip("\n").split("\t")
-        img_path = self.img_set_dir + substr[0]
-        label = json.loads(substr[1])
-        return img_path, label
-
-    def __call__(self, label_infor):
-        img_path, gt_label = self.convert_label_infor(label_infor)
-        imgvalue, flag = check_and_read_gif(img_path)
-        if not flag:
-            imgvalue = cv2.imread(img_path)
-        if imgvalue is None:
-            logger.info("{} does not exist!".format(img_path))
-            return None
-        if len(list(imgvalue.shape)) == 2 or imgvalue.shape[2] == 1:
-            imgvalue = cv2.cvtColor(imgvalue, cv2.COLOR_GRAY2BGR)
-        data = self.make_data_dict(imgvalue, gt_label)
-        data = AugmentData(data)
-        data = RandomCropData(data, self.image_shape[1:])
-        data = MakeShrinkMap(data)
-        data = MakeBorderMap(data)
-        data = self.NormalizeImage(data)
-        data = self.FilterKeys(data)
-        return data['image'], data['shrink_map'], data['shrink_mask'], data[
-            'threshold_map'], data['threshold_mask']
-
-
-class DBProcessTest(object):
-    """
-    DB pre-process for Test mode
-    """
-
-    def __init__(self, params):
-        super(DBProcessTest, self).__init__()
-        self.resize_type = 0
-        if 'test_image_shape' in params:
-            self.image_shape = params['test_image_shape']
-            # print(self.image_shape)
-            self.resize_type = 1
-        if 'max_side_len' in params:
-            self.max_side_len = params['max_side_len']
-        else:
-            self.max_side_len = 2400
-
-    def resize_image_type0(self, im):
-        """
-        resize image to a size multiple of 32 which is required by the network
-        args:
-            img(array): array with shape [h, w, c]
-        return(tuple):
-            img, (ratio_h, ratio_w)
-        """
-        max_side_len = self.max_side_len
-        h, w, _ = im.shape
-
-        resize_w = w
-        resize_h = h
-
-        # limit the max side
-        if max(resize_h, resize_w) > max_side_len:
-            if resize_h > resize_w:
-                ratio = float(max_side_len) / resize_h
-            else:
-                ratio = float(max_side_len) / resize_w
-        else:
-            ratio = 1.
-        resize_h = int(resize_h * ratio)
-        resize_w = int(resize_w * ratio)
-        if resize_h % 32 == 0:
-            resize_h = resize_h
-        elif resize_h // 32 <= 1:
-            resize_h = 32
-        else:
-            resize_h = (resize_h // 32 - 1) * 32
-        if resize_w % 32 == 0:
-            resize_w = resize_w
-        elif resize_w // 32 <= 1:
-            resize_w = 32
-        else:
-            resize_w = (resize_w // 32 - 1) * 32
-        try:
-            if int(resize_w) <= 0 or int(resize_h) <= 0:
-                return None, (None, None)
-            im = cv2.resize(im, (int(resize_w), int(resize_h)))
-        except:
-            print(im.shape, resize_w, resize_h)
-            sys.exit(0)
-        ratio_h = resize_h / float(h)
-        ratio_w = resize_w / float(w)
-        return im, (ratio_h, ratio_w)
-
-    def resize_image_type1(self, im):
-        resize_h, resize_w = self.image_shape
-        ori_h, ori_w = im.shape[:2]  # (h, w, c)
-        im = cv2.resize(im, (int(resize_w), int(resize_h)))
-        ratio_h = float(resize_h) / ori_h
-        ratio_w = float(resize_w) / ori_w
-        return im, (ratio_h, ratio_w)
-
-    def normalize(self, im):
-        img_mean = [0.485, 0.456, 0.406]
-        img_std = [0.229, 0.224, 0.225]
-        im = im.astype(np.float32, copy=False)
-        im = im / 255
-        im[:, :, 0] -= img_mean[0]
-        im[:, :, 1] -= img_mean[1]
-        im[:, :, 2] -= img_mean[2]
-        im[:, :, 0] /= img_std[0]
-        im[:, :, 1] /= img_std[1]
-        im[:, :, 2] /= img_std[2]
-        channel_swap = (2, 0, 1)
-        im = im.transpose(channel_swap)
-        return im
-
-    def __call__(self, im):
-        if self.resize_type == 0:
-            im, (ratio_h, ratio_w) = self.resize_image_type0(im)
-        else:
-            im, (ratio_h, ratio_w) = self.resize_image_type1(im)
-        im = self.normalize(im)
-        im = im[np.newaxis, :]
-        return [im, (ratio_h, ratio_w)]

ppocr/data/det/east_process.py

-#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.
-
-import math
-import cv2
-import numpy as np
-import json
-import sys
-import os
-
-class EASTProcessTrain(object):
-    def __init__(self, params):
-        self.img_set_dir = params['img_set_dir']
-        self.random_scale = np.array([0.5, 1, 2.0, 3.0])
-        self.background_ratio = params['background_ratio']
-        self.min_crop_side_ratio = params['min_crop_side_ratio']
-        image_shape = params['image_shape']
-        self.input_size = image_shape[1]
-        self.min_text_size = params['min_text_size']
-
-    def preprocess(self, im):
-        input_size = self.input_size
-        im_shape = im.shape
-        im_size_min = np.min(im_shape[0:2])
-        im_size_max = np.max(im_shape[0:2])
-        im_scale = float(input_size) / float(im_size_max)
-        im = cv2.resize(im, None, None, fx=im_scale, fy=im_scale)
-        img_mean = [0.485, 0.456, 0.406]
-        img_std = [0.229, 0.224, 0.225]
-        im = im[:, :, ::-1].astype(np.float32)
-        im = im / 255
-        im -= img_mean
-        im /= img_std
-        new_h, new_w, _ = im.shape
-        im_padded = np.zeros((input_size, input_size, 3), dtype=np.float32)
-        im_padded[:new_h, :new_w, :] = im
-        im_padded = im_padded.transpose((2, 0, 1))
-        im_padded = im_padded[np.newaxis, :]
-        return im_padded, im_scale
-
-    def convert_label_infor(self, label_infor):
-        label_infor = label_infor.decode()
-        label_infor = label_infor.encode('utf-8').decode('utf-8-sig')
-        substr = label_infor.strip("\n").split("\t")
-        img_path = os.path.join(self.img_set_dir, substr[0])
-        label = json.loads(substr[1])
-        nBox = len(label)
-        wordBBs, txts, txt_tags = [], [], []
-        for bno in range(0, nBox):
-            wordBB = label[bno]['points']
-            txt = label[bno]['transcription']
-            wordBBs.append(wordBB)
-            txts.append(txt)
-            if txt == '###':
-                txt_tags.append(True)
-            else:
-                txt_tags.append(False)
-        wordBBs = np.array(wordBBs, dtype=np.float32)
-        txt_tags = np.array(txt_tags, dtype=np.bool)
-        return img_path, wordBBs, txt_tags, txts
-
-    def rotate_im_poly(self, im, text_polys):
-        """
-        rotate image with 90 / 180 / 270 degre
-        """
-        im_w, im_h = im.shape[1], im.shape[0]
-        dst_im = im.copy()
-        dst_polys = []
-        rand_degree_ratio = np.random.rand()
-        rand_degree_cnt = 1
-        if 0.333 < rand_degree_ratio < 0.666:
-            rand_degree_cnt = 2
-        elif rand_degree_ratio > 0.666:
-            rand_degree_cnt = 3
-        for i in range(rand_degree_cnt):
-            dst_im = np.rot90(dst_im)
-        rot_degree = -90 * rand_degree_cnt
-        rot_angle = rot_degree * math.pi / 180.0
-        n_poly = text_polys.shape[0]
-        cx, cy = 0.5 * im_w, 0.5 * im_h
-        ncx, ncy = 0.5 * dst_im.shape[1], 0.5 * dst_im.shape[0]
-        for i in range(n_poly):
-            wordBB = text_polys[i]
-            poly = []
-            for j in range(4):
-                sx, sy = wordBB[j][0], wordBB[j][1]
-                dx = math.cos(rot_angle) * (sx - cx)\
-                    - math.sin(rot_angle) * (sy - cy) + ncx
-                dy = math.sin(rot_angle) * (sx - cx)\
-                    + math.cos(rot_angle) * (sy - cy) + ncy
-                poly.append([dx, dy])
-            dst_polys.append(poly)
-        dst_polys = np.array(dst_polys, dtype=np.float32)
-        return dst_im, dst_polys
-
-    def polygon_area(self, poly):
-        """
-        compute area of a polygon
-        :param poly:
-        :return:
-        """
-        edge = [(poly[1][0] - poly[0][0]) * (poly[1][1] + poly[0][1]),
-                (poly[2][0] - poly[1][0]) * (poly[2][1] + poly[1][1]),
-                (poly[3][0] - poly[2][0]) * (poly[3][1] + poly[2][1]),
-                (poly[0][0] - poly[3][0]) * (poly[0][1] + poly[3][1])]
-        return np.sum(edge) / 2.
-
-    def check_and_validate_polys(self, polys, tags, img_height, img_width):
-        """
-        check so that the text poly is in the same direction,
-        and also filter some invalid polygons
-        :param polys:
-        :param tags:
-        :return:
-        """
-        h, w = img_height, img_width
-        if polys.shape[0] == 0:
-            return polys
-        polys[:, :, 0] = np.clip(polys[:, :, 0], 0, w - 1)
-        polys[:, :, 1] = np.clip(polys[:, :, 1], 0, h - 1)
-
-        validated_polys = []
-        validated_tags = []
-        for poly, tag in zip(polys, tags):
-            p_area = self.polygon_area(poly)
-            #invalid poly
-            if abs(p_area) < 1:
-                continue
-            if p_area > 0:
-                #'poly in wrong direction'
-                if not tag:
-                    tag = True  #reversed cases should be ignore
-                poly = poly[(0, 3, 2, 1), :]
-            validated_polys.append(poly)
-            validated_tags.append(tag)
-        return np.array(validated_polys), np.array(validated_tags)
-
-    def draw_img_polys(self, img, polys):
-        if len(img.shape) == 4:
-            img = np.squeeze(img, axis=0)
-        if img.shape[0] == 3:
-            img = img.transpose((1, 2, 0))
-            img[:, :, 2] += 123.68
-            img[:, :, 1] += 116.78
-            img[:, :, 0] += 103.94
-        cv2.imwrite("tmp.jpg", img)
-        img = cv2.imread("tmp.jpg")
-        for box in polys:
-            box = box.astype(np.int32).reshape((-1, 1, 2))
-            cv2.polylines(img, [box], True, color=(255, 255, 0), thickness=2)
-        import random
-        ino = random.randint(0, 100)
-        cv2.imwrite("tmp_%d.jpg" % ino, img)
-        return
-
-    def shrink_poly(self, poly, r):
-        """
-        fit a poly inside the origin poly, maybe bugs here...
-        used for generate the score map
-        :param poly: the text poly
-        :param r: r in the paper
-        :return: the shrinked poly
-        """
-        # shrink ratio
-        R = 0.3
-        # find the longer pair
-        dist0 = np.linalg.norm(poly[0] - poly[1])
-        dist1 = np.linalg.norm(poly[2] - poly[3])
-        dist2 = np.linalg.norm(poly[0] - poly[3])
-        dist3 = np.linalg.norm(poly[1] - poly[2])
-        if dist0 + dist1 > dist2 + dist3:
-            # first move (p0, p1), (p2, p3), then (p0, p3), (p1, p2)
-            ## p0, p1
-            theta = np.arctan2((poly[1][1] - poly[0][1]),
-                               (poly[1][0] - poly[0][0]))
-            poly[0][0] += R * r[0] * np.cos(theta)
-            poly[0][1] += R * r[0] * np.sin(theta)
-            poly[1][0] -= R * r[1] * np.cos(theta)
-            poly[1][1] -= R * r[1] * np.sin(theta)
-            ## p2, p3
-            theta = np.arctan2((poly[2][1] - poly[3][1]),
-                               (poly[2][0] - poly[3][0]))
-            poly[3][0] += R * r[3] * np.cos(theta)
-            poly[3][1] += R * r[3] * np.sin(theta)
-            poly[2][0] -= R * r[2] * np.cos(theta)
-            poly[2][1] -= R * r[2] * np.sin(theta)
-            ## p0, p3
-            theta = np.arctan2((poly[3][0] - poly[0][0]),
-                               (poly[3][1] - poly[0][1]))
-            poly[0][0] += R * r[0] * np.sin(theta)
-            poly[0][1] += R * r[0] * np.cos(theta)
-            poly[3][0] -= R * r[3] * np.sin(theta)
-            poly[3][1] -= R * r[3] * np.cos(theta)
-            ## p1, p2
-            theta = np.arctan2((poly[2][0] - poly[1][0]),
-                               (poly[2][1] - poly[1][1]))
-            poly[1][0] += R * r[1] * np.sin(theta)
-            poly[1][1] += R * r[1] * np.cos(theta)
-            poly[2][0] -= R * r[2] * np.sin(theta)
-            poly[2][1] -= R * r[2] * np.cos(theta)
-        else:
-            ## p0, p3
-            # print poly
-            theta = np.arctan2((poly[3][0] - poly[0][0]),
-                               (poly[3][1] - poly[0][1]))
-            poly[0][0] += R * r[0] * np.sin(theta)
-            poly[0][1] += R * r[0] * np.cos(theta)
-            poly[3][0] -= R * r[3] * np.sin(theta)
-            poly[3][1] -= R * r[3] * np.cos(theta)
-            ## p1, p2
-            theta = np.arctan2((poly[2][0] - poly[1][0]),
-                               (poly[2][1] - poly[1][1]))
-            poly[1][0] += R * r[1] * np.sin(theta)
-            poly[1][1] += R * r[1] * np.cos(theta)
-            poly[2][0] -= R * r[2] * np.sin(theta)
-            poly[2][1] -= R * r[2] * np.cos(theta)
-            ## p0, p1
-            theta = np.arctan2((poly[1][1] - poly[0][1]),
-                               (poly[1][0] - poly[0][0]))
-            poly[0][0] += R * r[0] * np.cos(theta)
-            poly[0][1] += R * r[0] * np.sin(theta)
-            poly[1][0] -= R * r[1] * np.cos(theta)
-            poly[1][1] -= R * r[1] * np.sin(theta)
-            ## p2, p3
-            theta = np.arctan2((poly[2][1] - poly[3][1]),
-                               (poly[2][0] - poly[3][0]))
-            poly[3][0] += R * r[3] * np.cos(theta)
-            poly[3][1] += R * r[3] * np.sin(theta)
-            poly[2][0] -= R * r[2] * np.cos(theta)
-            poly[2][1] -= R * r[2] * np.sin(theta)
-        return poly
-
-    def generate_quad(self, im_size, polys, tags):
-        """
-        Generate quadrangle.
-        """
-        h, w = im_size
-        poly_mask = np.zeros((h, w), dtype=np.uint8)
-        score_map = np.zeros((h, w), dtype=np.uint8)
-        # (x1, y1, ..., x4, y4, short_edge_norm)
-        geo_map = np.zeros((h, w, 9), dtype=np.float32)
-        # mask used during traning, to ignore some hard areas
-        training_mask = np.ones((h, w), dtype=np.uint8)
-        for poly_idx, poly_tag in enumerate(zip(polys, tags)):
-            poly = poly_tag[0]
-            tag = poly_tag[1]
-
-            r = [None, None, None, None]
-            for i in range(4):
-                dist1 = np.linalg.norm(poly[i] - poly[(i + 1) % 4])
-                dist2 = np.linalg.norm(poly[i] - poly[(i - 1) % 4])
-                r[i] = min(dist1, dist2)
-            # score map
-            shrinked_poly = self.shrink_poly(
-                poly.copy(), r).astype(np.int32)[np.newaxis, :, :]
-            cv2.fillPoly(score_map, shrinked_poly, 1)
-            cv2.fillPoly(poly_mask, shrinked_poly, poly_idx + 1)
-            # if the poly is too small, then ignore it during training
-            poly_h = min(
-                np.linalg.norm(poly[0] - poly[3]),
-                np.linalg.norm(poly[1] - poly[2]))
-            poly_w = min(
-                np.linalg.norm(poly[0] - poly[1]),
-                np.linalg.norm(poly[2] - poly[3]))
-            if min(poly_h, poly_w) < self.min_text_size:
-                cv2.fillPoly(training_mask,
-                             poly.astype(np.int32)[np.newaxis, :, :], 0)
-
-            if tag:
-                cv2.fillPoly(training_mask,
-                             poly.astype(np.int32)[np.newaxis, :, :], 0)
-
-            xy_in_poly = np.argwhere(poly_mask == (poly_idx + 1))
-            # geo map.
-            y_in_poly = xy_in_poly[:, 0]
-            x_in_poly = xy_in_poly[:, 1]
-            poly[:, 0] = np.minimum(np.maximum(poly[:, 0], 0), w)
-            poly[:, 1] = np.minimum(np.maximum(poly[:, 1], 0), h)
-            for pno in range(4):
-                geo_channel_beg = pno * 2
-                geo_map[y_in_poly, x_in_poly, geo_channel_beg] =\
-                    x_in_poly - poly[pno, 0]
-                geo_map[y_in_poly, x_in_poly, geo_channel_beg+1] =\
-                    y_in_poly - poly[pno, 1]
-            geo_map[y_in_poly, x_in_poly, 8] = \
-                1.0 / max(min(poly_h, poly_w), 1.0)
-        return score_map, geo_map, training_mask
-
-    def crop_area(self,
-                  im,
-                  polys,
-                  tags,
-                  txts,
-                  crop_background=False,
-                  max_tries=50):
-        """
-        make random crop from the input image
-        :param im:
-        :param polys:
-        :param tags:
-        :param crop_background:
-        :param max_tries:
-        :return:
-        """
-        h, w, _ = im.shape
-        pad_h = h // 10
-        pad_w = w // 10
-        h_array = np.zeros((h + pad_h * 2), dtype=np.int32)
-        w_array = np.zeros((w + pad_w * 2), dtype=np.int32)
-        for poly in polys:
-            poly = np.round(poly, decimals=0).astype(np.int32)
-            minx = np.min(poly[:, 0])
-            maxx = np.max(poly[:, 0])
-            w_array[minx + pad_w:maxx + pad_w] = 1
-            miny = np.min(poly[:, 1])
-            maxy = np.max(poly[:, 1])
-            h_array[miny + pad_h:maxy + pad_h] = 1
-        # ensure the cropped area not across a text
-        h_axis = np.where(h_array == 0)[0]
-        w_axis = np.where(w_array == 0)[0]
-        if len(h_axis) == 0 or len(w_axis) == 0:
-            return im, polys, tags, txts
-
-        for i in range(max_tries):
-            xx = np.random.choice(w_axis, size=2)
-            xmin = np.min(xx) - pad_w
-            xmax = np.max(xx) - pad_w
-            xmin = np.clip(xmin, 0, w - 1)
-            xmax = np.clip(xmax, 0, w - 1)
-            yy = np.random.choice(h_axis, size=2)
-            ymin = np.min(yy) - pad_h
-            ymax = np.max(yy) - pad_h
-            ymin = np.clip(ymin, 0, h - 1)
-            ymax = np.clip(ymax, 0, h - 1)
-            if xmax - xmin < self.min_crop_side_ratio * w or \
-               ymax - ymin < self.min_crop_side_ratio * h:
-                # area too small
-                continue
-            if polys.shape[0] != 0:
-                poly_axis_in_area = (polys[:, :, 0] >= xmin)\
-                    & (polys[:, :, 0] <= xmax)\
-                    & (polys[:, :, 1] >= ymin)\
-                    & (polys[:, :, 1] <= ymax)
-                selected_polys = np.where(
-                    np.sum(poly_axis_in_area, axis=1) == 4)[0]
-            else:
-                selected_polys = []
-
-            if len(selected_polys) == 0:
-                # no text in this area
-                if crop_background:
-                    im = im[ymin:ymax + 1, xmin:xmax + 1, :]
-                    polys = []
-                    tags = []
-                    txts = []
-                    return im, polys, tags, txts
-                else:
-                    continue
-
-            im = im[ymin:ymax + 1, xmin:xmax + 1, :]
-            polys = polys[selected_polys]
-            tags = tags[selected_polys]
-            txts_tmp = []
-            for selected_poly in selected_polys:
-                txts_tmp.append(txts[selected_poly])
-            txts = txts_tmp
-            polys[:, :, 0] -= xmin
-            polys[:, :, 1] -= ymin
-            return im, polys, tags, txts
-        return im, polys, tags, txts
-
-    def crop_background_infor(self, im, text_polys, text_tags, text_strs):
-        im, text_polys, text_tags, text_strs = self.crop_area(
-            im, text_polys, text_tags, text_strs, crop_background=True)
-        if len(text_polys) > 0:
-            return None
-        # pad and resize image
-        input_size = self.input_size
-        im, ratio = self.preprocess(im)
-        score_map = np.zeros((input_size, input_size), dtype=np.float32)
-        geo_map = np.zeros((input_size, input_size, 9), dtype=np.float32)
-        training_mask = np.ones((input_size, input_size), dtype=np.float32)
-        return im, score_map, geo_map, training_mask
-
-    def crop_foreground_infor(self, im, text_polys, text_tags, text_strs):
-        im, text_polys, text_tags, text_strs = self.crop_area(
-            im, text_polys, text_tags, text_strs, crop_background=False)
-        if text_polys.shape[0] == 0:
-            return None
-        #continue for all ignore case
-        if np.sum((text_tags * 1.0)) >= text_tags.size:
-            return None
-        # pad and resize image
-        input_size = self.input_size
-        im, ratio = self.preprocess(im)
-        text_polys[:, :, 0] *= ratio
-        text_polys[:, :, 1] *= ratio
-        _, _, new_h, new_w = im.shape
-        #         print(im.shape)
-        #         self.draw_img_polys(im, text_polys)
-        score_map, geo_map, training_mask = self.generate_quad(
-            (new_h, new_w), text_polys, text_tags)
-        return im, score_map, geo_map, training_mask
-
-    def __call__(self, label_infor):
-        infor = self.convert_label_infor(label_infor)
-        im_path, text_polys, text_tags, text_strs = infor
-        im = cv2.imread(im_path)
-        if im is None:
-            return None
-        if text_polys.shape[0] == 0:
-            return None
-        #add rotate cases
-        if np.random.rand() < 0.5:
-            im, text_polys = self.rotate_im_poly(im, text_polys)
-        h, w, _ = im.shape
-        text_polys, text_tags = self.check_and_validate_polys(text_polys,
-                                                              text_tags, h, w)
-        if text_polys.shape[0] == 0:
-            return None
-
-        # random scale this image
-        rd_scale = np.random.choice(self.random_scale)
-        im = cv2.resize(im, dsize=None, fx=rd_scale, fy=rd_scale)
-        text_polys *= rd_scale
-        if np.random.rand() < self.background_ratio:
-            outs = self.crop_background_infor(im, text_polys, text_tags,
-                                              text_strs)
-        else:
-            outs = self.crop_foreground_infor(im, text_polys, text_tags,
-                                              text_strs)
-
-        if outs is None:
-            return None
-        im, score_map, geo_map, training_mask = outs
-        score_map = score_map[np.newaxis, ::4, ::4].astype(np.float32)
-        geo_map = np.swapaxes(geo_map, 1, 2)
-        geo_map = np.swapaxes(geo_map, 1, 0)
-        geo_map = geo_map[:, ::4, ::4].astype(np.float32)
-        training_mask = training_mask[np.newaxis, ::4, ::4]
-        training_mask = training_mask.astype(np.float32)
-        return im, score_map, geo_map, training_mask
-
-
-class EASTProcessTest(object):
-    def __init__(self, params):
-        super(EASTProcessTest, self).__init__()
-        self.resize_type = 0
-        if 'test_image_shape' in params:
-            self.image_shape = params['test_image_shape']
-            # print(self.image_shape)
-            self.resize_type = 1
-        if 'max_side_len' in params:
-            self.max_side_len = params['max_side_len']
-        else:
-            self.max_side_len = 2400
-
-    def resize_image_type0(self, im):
-        """
-        resize image to a size multiple of 32 which is required by the network
-        args:
-            img(array): array with shape [h, w, c]
-        return(tuple):
-            img, (ratio_h, ratio_w)
-        """
-        max_side_len = self.max_side_len
-        h, w, _ = im.shape
-
-        resize_w = w
-        resize_h = h
-
-        # limit the max side
-        if max(resize_h, resize_w) > max_side_len:
-            if resize_h > resize_w:
-                ratio = float(max_side_len) / resize_h
-            else:
-                ratio = float(max_side_len) / resize_w
-        else:
-            ratio = 1.
-        resize_h = int(resize_h * ratio)
-        resize_w = int(resize_w * ratio)
-        if resize_h % 32 == 0:
-            resize_h = resize_h
-        elif resize_h // 32 <= 1:
-            resize_h = 32
-        else:
-            resize_h = (resize_h // 32 - 1) * 32
-        if resize_w % 32 == 0:
-            resize_w = resize_w
-        elif resize_w // 32 <= 1:
-            resize_w = 32
-        else:
-            resize_w = (resize_w // 32 - 1) * 32
-        try:
-            if int(resize_w) <= 0 or int(resize_h) <= 0:
-                return None, (None, None)
-            im = cv2.resize(im, (int(resize_w), int(resize_h)))
-        except:
-            print(im.shape, resize_w, resize_h)
-            sys.exit(0)
-        ratio_h = resize_h / float(h)
-        ratio_w = resize_w / float(w)
-        return im, (ratio_h, ratio_w)
-
-    def resize_image_type1(self, im):
-        resize_h, resize_w = self.image_shape
-        ori_h, ori_w = im.shape[:2]  # (h, w, c)
-        im = cv2.resize(im, (int(resize_w), int(resize_h)))
-        ratio_h = float(resize_h) / ori_h
-        ratio_w = float(resize_w) / ori_w
-        return im, (ratio_h, ratio_w)
-
-    def __call__(self, im):
-        if self.resize_type == 0:
-            im, (ratio_h, ratio_w) = self.resize_image_type0(im)
-        else:
-            im, (ratio_h, ratio_w) = self.resize_image_type1(im)
-        img_mean = [0.485, 0.456, 0.406]
-        img_std = [0.229, 0.224, 0.225]
-        im = im[:, :, ::-1].astype(np.float32)
-        im = im / 255
-        im -= img_mean
-        im /= img_std
-        im = im.transpose((2, 0, 1))
-        im = im[np.newaxis, :]
-        return [im, (ratio_h, ratio_w)]

ppocr/data/det/make_border_map.py

-# -*- coding:utf-8 -*- 
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
-
-import numpy as np
-import cv2
-np.seterr(divide='ignore', invalid='ignore')
-import pyclipper
-from shapely.geometry import Polygon
-import sys
-import warnings
-warnings.simplefilter("ignore")
-
-
-def draw_border_map(polygon, canvas, mask, shrink_ratio):
-    polygon = np.array(polygon)
-    assert polygon.ndim == 2
-    assert polygon.shape[1] == 2
-
-    polygon_shape = Polygon(polygon)
-    if polygon_shape.area <= 0:
-        return
-    distance = polygon_shape.area * (
-        1 - np.power(shrink_ratio, 2)) / polygon_shape.length
-    subject = [tuple(l) for l in polygon]
-    padding = pyclipper.PyclipperOffset()
-    padding.AddPath(subject, pyclipper.JT_ROUND, pyclipper.ET_CLOSEDPOLYGON)
-
-    padded_polygon = np.array(padding.Execute(distance)[0])
-    cv2.fillPoly(mask, [padded_polygon.astype(np.int32)], 1.0)
-
-    xmin = padded_polygon[:, 0].min()
-    xmax = padded_polygon[:, 0].max()
-    ymin = padded_polygon[:, 1].min()
-    ymax = padded_polygon[:, 1].max()
-    width = xmax - xmin + 1
-    height = ymax - ymin + 1
-
-    polygon[:, 0] = polygon[:, 0] - xmin
-    polygon[:, 1] = polygon[:, 1] - ymin
-
-    xs = np.broadcast_to(
-        np.linspace(
-            0, width - 1, num=width).reshape(1, width), (height, width))
-    ys = np.broadcast_to(
-        np.linspace(
-            0, height - 1, num=height).reshape(height, 1), (height, width))
-
-    distance_map = np.zeros((polygon.shape[0], height, width), dtype=np.float32)
-    for i in range(polygon.shape[0]):
-        j = (i + 1) % polygon.shape[0]
-        absolute_distance = _distance(xs, ys, polygon[i], polygon[j])
-        distance_map[i] = np.clip(absolute_distance / distance, 0, 1)
-    distance_map = distance_map.min(axis=0)
-
-    xmin_valid = min(max(0, xmin), canvas.shape[1] - 1)
-    xmax_valid = min(max(0, xmax), canvas.shape[1] - 1)
-    ymin_valid = min(max(0, ymin), canvas.shape[0] - 1)
-    ymax_valid = min(max(0, ymax), canvas.shape[0] - 1)
-    canvas[ymin_valid:ymax_valid + 1, xmin_valid:xmax_valid + 1] = np.fmax(
-        1 - distance_map[ymin_valid - ymin:ymax_valid - ymax + height,
-                         xmin_valid - xmin:xmax_valid - xmax + width],
-        canvas[ymin_valid:ymax_valid + 1, xmin_valid:xmax_valid + 1])
-
-
-def _distance(xs, ys, point_1, point_2):
-    '''
-    compute the distance from point to a line
-    ys: coordinates in the first axis
-    xs: coordinates in the second axis
-    point_1, point_2: (x, y), the end of the line
-    '''
-    height, width = xs.shape[:2]
-    square_distance_1 = np.square(xs - point_1[0]) + np.square(ys - point_1[1])
-    square_distance_2 = np.square(xs - point_2[0]) + np.square(ys - point_2[1])
-    square_distance = np.square(point_1[0] - point_2[0]) + np.square(point_1[
-        1] - point_2[1])
-
-    cosin = (square_distance - square_distance_1 - square_distance_2) / (
-        2 * np.sqrt(square_distance_1 * square_distance_2))
-    square_sin = 1 - np.square(cosin)
-    square_sin = np.nan_to_num(square_sin)
-    result = np.sqrt(square_distance_1 * square_distance_2 * square_sin /
-                     square_distance)
-
-    result[cosin <
-           0] = np.sqrt(np.fmin(square_distance_1, square_distance_2))[cosin <
-                                                                       0]
-    # self.extend_line(point_1, point_2, result)
-    return result
-
-
-def extend_line(point_1, point_2, result, shrink_ratio):
-    ex_point_1 = (
-        int(
-            round(point_1[0] + (point_1[0] - point_2[0]) * (1 + shrink_ratio))),
-        int(
-            round(point_1[1] + (point_1[1] - point_2[1]) * (1 + shrink_ratio))))
-    cv2.line(
-        result,
-        tuple(ex_point_1),
-        tuple(point_1),
-        4096.0,
-        1,
-        lineType=cv2.LINE_AA,
-        shift=0)
-    ex_point_2 = (
-        int(
-            round(point_2[0] + (point_2[0] - point_1[0]) * (1 + shrink_ratio))),
-        int(
-            round(point_2[1] + (point_2[1] - point_1[1]) * (1 + shrink_ratio))))
-    cv2.line(
-        result,
-        tuple(ex_point_2),
-        tuple(point_2),
-        4096.0,
-        1,
-        lineType=cv2.LINE_AA,
-        shift=0)
-    return ex_point_1, ex_point_2
-
-
-def MakeBorderMap(data):
-    shrink_ratio = 0.4
-    thresh_min = 0.3
-    thresh_max = 0.7
-
-    im = data['image']
-    text_polys = data['polys']
-    ignore_tags = data['ignore_tags']
-
-    canvas = np.zeros(im.shape[:2], dtype=np.float32)
-    mask = np.zeros(im.shape[:2], dtype=np.float32)
-
-    for i in range(len(text_polys)):
-        if ignore_tags[i]:
-            continue
-        draw_border_map(
-            text_polys[i], canvas, mask=mask, shrink_ratio=shrink_ratio)
-    canvas = canvas * (thresh_max - thresh_min) + thresh_min
-
-    data['threshold_map'] = canvas
-    data['threshold_mask'] = mask
-    return data

ppocr/data/det/make_shrink_map.py

-# -*- coding:utf-8 -*- 
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
-
-import numpy as np
-import cv2
-from shapely.geometry import Polygon
-import pyclipper
-
-
-def validate_polygons(polygons, ignore_tags, h, w):
-    '''
-    polygons (numpy.array, required): of shape (num_instances, num_points, 2)
-    '''
-    if len(polygons) == 0:
-        return polygons, ignore_tags
-    assert len(polygons) == len(ignore_tags)
-    for polygon in polygons:
-        polygon[:, 0] = np.clip(polygon[:, 0], 0, w - 1)
-        polygon[:, 1] = np.clip(polygon[:, 1], 0, h - 1)
-
-    for i in range(len(polygons)):
-        area = polygon_area(polygons[i])
-        if abs(area) < 1:
-            ignore_tags[i] = True
-        if area > 0:
-            polygons[i] = polygons[i][::-1, :]
-    return polygons, ignore_tags
-
-
-def polygon_area(polygon):
-    edge = 0
-    for i in range(polygon.shape[0]):
-        next_index = (i + 1) % polygon.shape[0]
-        edge += (polygon[next_index, 0] - polygon[i, 0]) * (
-            polygon[next_index, 1] - polygon[i, 1])
-
-    return edge / 2.
-
-
-def MakeShrinkMap(data):
-    min_text_size = 8
-    shrink_ratio = 0.4
-
-    image = data['image']
-    text_polys = data['polys']
-    ignore_tags = data['ignore_tags']
-
-    h, w = image.shape[:2]
-    text_polys, ignore_tags = validate_polygons(text_polys, ignore_tags, h, w)
-    gt = np.zeros((h, w), dtype=np.float32)
-    # gt = np.zeros((1, h, w), dtype=np.float32)
-    mask = np.ones((h, w), dtype=np.float32)
-    for i in range(len(text_polys)):
-        polygon = text_polys[i]
-        height = max(polygon[:, 1]) - min(polygon[:, 1])
-        width = max(polygon[:, 0]) - min(polygon[:, 0])
-        # height = min(np.linalg.norm(polygon[0] - polygon[3]),
-        #             np.linalg.norm(polygon[1] - polygon[2]))
-        # width = min(np.linalg.norm(polygon[0] - polygon[1]),
-        #             np.linalg.norm(polygon[2] - polygon[3]))
-        if ignore_tags[i] or min(height, width) < min_text_size:
-            cv2.fillPoly(mask, polygon.astype(np.int32)[np.newaxis, :, :], 0)
-            ignore_tags[i] = True
-        else:
-            polygon_shape = Polygon(polygon)
-            distance = polygon_shape.area * (
-                1 - np.power(shrink_ratio, 2)) / polygon_shape.length
-            subject = [tuple(l) for l in text_polys[i]]
-            padding = pyclipper.PyclipperOffset()
-            padding.AddPath(subject, pyclipper.JT_ROUND,
-                            pyclipper.ET_CLOSEDPOLYGON)
-            shrinked = padding.Execute(-distance)
-            if shrinked == []:
-                cv2.fillPoly(mask,
-                             polygon.astype(np.int32)[np.newaxis, :, :], 0)
-                ignore_tags[i] = True
-                continue
-            shrinked = np.array(shrinked[0]).reshape(-1, 2)
-            cv2.fillPoly(gt, [shrinked.astype(np.int32)], 1)
-            # cv2.fillPoly(gt[0], [shrinked.astype(np.int32)], 1)
-
-    data['shrink_map'] = gt
-    data['shrink_mask'] = mask
-    return data

ppocr/data/det/sast_process.py

-#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.
-
-import math
-import cv2
-import numpy as np
-import json
-
-
-class SASTProcessTrain(object):
-    """
-    SAST process function for training
-    """
-    def __init__(self, params):
-        self.img_set_dir = params['img_set_dir']
-        self.min_crop_side_ratio = params['min_crop_side_ratio']
-        self.min_crop_size = params['min_crop_size']
-        image_shape = params['image_shape']
-        self.input_size = image_shape[1]
-        self.min_text_size = params['min_text_size']
-        self.max_text_size = params['max_text_size']
-
-    def convert_label_infor(self, label_infor):
-        label_infor = label_infor.decode()
-        label_infor = label_infor.encode('utf-8').decode('utf-8-sig')
-        substr = label_infor.strip("\n").split("\t")
-        img_path = self.img_set_dir + substr[0]
-        label = json.loads(substr[1])
-        nBox = len(label)
-        wordBBs, txts, txt_tags = [], [], []
-        for bno in range(0, nBox):
-            wordBB = label[bno]['points']
-            txt = label[bno]['transcription']
-            wordBBs.append(wordBB)
-            txts.append(txt)
-            if txt == '###':
-                txt_tags.append(True)
-            else:
-                txt_tags.append(False)
-        wordBBs = np.array(wordBBs, dtype=np.float32)
-        txt_tags = np.array(txt_tags, dtype=np.bool)
-        return img_path, wordBBs, txt_tags, txts
-
-    def quad_area(self, poly):
-        """
-        compute area of a polygon
-        :param poly:
-        :return:
-        """
-        edge = [
-            (poly[1][0] - poly[0][0]) * (poly[1][1] + poly[0][1]),
-            (poly[2][0] - poly[1][0]) * (poly[2][1] + poly[1][1]),
-            (poly[3][0] - poly[2][0]) * (poly[3][1] + poly[2][1]),
-            (poly[0][0] - poly[3][0]) * (poly[0][1] + poly[3][1])
-        ]
-        return np.sum(edge) / 2.
-
-    def gen_quad_from_poly(self, poly):
-        """
-        Generate min area quad from poly.
-        """
-        point_num = poly.shape[0]
-        min_area_quad = np.zeros((4, 2), dtype=np.float32)
-        if True:
-            rect = cv2.minAreaRect(poly.astype(np.int32))  # (center (x,y), (width, height), angle of rotation)
-            center_point = rect[0]
-            box = np.array(cv2.boxPoints(rect))
-
-            first_point_idx = 0
-            min_dist = 1e4
-            for i in range(4):
-                dist = np.linalg.norm(box[(i + 0) % 4] - poly[0]) + \
-                    np.linalg.norm(box[(i + 1) % 4] - poly[point_num // 2 - 1]) + \
-                    np.linalg.norm(box[(i + 2) % 4] - poly[point_num // 2]) + \
-                    np.linalg.norm(box[(i + 3) % 4] - poly[-1])
-                if dist < min_dist:
-                    min_dist = dist
-                    first_point_idx = i
-            for i in range(4):
-                min_area_quad[i] = box[(first_point_idx + i) % 4]
-
-        return min_area_quad
-
-    def check_and_validate_polys(self, polys, tags, xxx_todo_changeme):
-        """
-        check so that the text poly is in the same direction,
-        and also filter some invalid polygons
-        :param polys:
-        :param tags:
-        :return:
-        """
-        (h, w) = xxx_todo_changeme
-        if polys.shape[0] == 0:
-            return polys, np.array([]), np.array([])
-        polys[:, :, 0] = np.clip(polys[:, :, 0], 0, w - 1)
-        polys[:, :, 1] = np.clip(polys[:, :, 1], 0, h - 1)
-
-        validated_polys = []
-        validated_tags = []
-        hv_tags = []
-        for poly, tag in zip(polys, tags):
-            quad = self.gen_quad_from_poly(poly)
-            p_area = self.quad_area(quad)
-            if abs(p_area) < 1:
-                print('invalid poly')
-                continue
-            if p_area > 0:
-                if tag == False:
-                    print('poly in wrong direction')
-                    tag = True # reversed cases should be ignore
-                poly = poly[(0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1), :]
-                quad = quad[(0, 3, 2, 1), :]
-
-            len_w = np.linalg.norm(quad[0] - quad[1]) + np.linalg.norm(quad[3] - quad[2])
-            len_h = np.linalg.norm(quad[0] - quad[3]) + np.linalg.norm(quad[1] - quad[2])
-            hv_tag = 1
-        
-            if len_w * 2.0 <  len_h:
-                hv_tag = 0
-
-            validated_polys.append(poly)
-            validated_tags.append(tag)
-            hv_tags.append(hv_tag)
-        return np.array(validated_polys), np.array(validated_tags), np.array(hv_tags)
-
-    def crop_area(self, im, polys, tags, hv_tags, txts, crop_background=False, max_tries=25):
-        """
-        make random crop from the input image
-        :param im:
-        :param polys:
-        :param tags:
-        :param crop_background:
-        :param max_tries: 50 -> 25
-        :return:
-        """
-        h, w, _ = im.shape
-        pad_h = h // 10
-        pad_w = w // 10
-        h_array = np.zeros((h + pad_h * 2), dtype=np.int32)
-        w_array = np.zeros((w + pad_w * 2), dtype=np.int32)
-        for poly in polys:
-            poly = np.round(poly, decimals=0).astype(np.int32)
-            minx = np.min(poly[:, 0])
-            maxx = np.max(poly[:, 0])
-            w_array[minx + pad_w: maxx + pad_w] = 1
-            miny = np.min(poly[:, 1])
-            maxy = np.max(poly[:, 1])
-            h_array[miny + pad_h: maxy + pad_h] = 1
-        # ensure the cropped area not across a text
-        h_axis = np.where(h_array == 0)[0]
-        w_axis = np.where(w_array == 0)[0]
-        if len(h_axis) == 0 or len(w_axis) == 0:
-            return im, polys, tags, hv_tags, txts
-        for i in range(max_tries):
-            xx = np.random.choice(w_axis, size=2)
-            xmin = np.min(xx) - pad_w
-            xmax = np.max(xx) - pad_w
-            xmin = np.clip(xmin, 0, w - 1)
-            xmax = np.clip(xmax, 0, w - 1)
-            yy = np.random.choice(h_axis, size=2)
-            ymin = np.min(yy) - pad_h
-            ymax = np.max(yy) - pad_h
-            ymin = np.clip(ymin, 0, h - 1)
-            ymax = np.clip(ymax, 0, h - 1)
-            # if xmax - xmin < ARGS.min_crop_side_ratio * w or \
-            #   ymax - ymin < ARGS.min_crop_side_ratio * h:
-            if xmax - xmin < self.min_crop_size or \
-            ymax - ymin < self.min_crop_size:
-                # area too small
-                continue
-            if polys.shape[0] != 0:
-                poly_axis_in_area = (polys[:, :, 0] >= xmin) & (polys[:, :, 0] <= xmax) \
-                                    & (polys[:, :, 1] >= ymin) & (polys[:, :, 1] <= ymax)
-                selected_polys = np.where(np.sum(poly_axis_in_area, axis=1) == 4)[0]
-            else:
-                selected_polys = []
-            if len(selected_polys) == 0:
-                # no text in this area
-                if crop_background:
-                    txts_tmp = []
-                    for selected_poly in selected_polys:
-                        txts_tmp.append(txts[selected_poly])
-                    txts = txts_tmp 
-                    return im[ymin : ymax + 1, xmin : xmax + 1, :], \
-                        polys[selected_polys], tags[selected_polys], hv_tags[selected_polys], txts
-                else:
-                    continue
-            im = im[ymin: ymax + 1, xmin: xmax + 1, :]
-            polys = polys[selected_polys]
-            tags = tags[selected_polys]
-            hv_tags = hv_tags[selected_polys]
-            txts_tmp = []
-            for selected_poly in selected_polys:
-                txts_tmp.append(txts[selected_poly])
-            txts = txts_tmp 
-            polys[:, :, 0] -= xmin
-            polys[:, :, 1] -= ymin
-            return im, polys, tags, hv_tags, txts
-
-        return im, polys, tags, hv_tags, txts
-
-    def generate_direction_map(self, poly_quads, direction_map):
-        """
-        """
-        width_list = []
-        height_list = []
-        for quad in poly_quads:
-            quad_w = (np.linalg.norm(quad[0] - quad[1]) + np.linalg.norm(quad[2] - quad[3])) / 2.0
-            quad_h = (np.linalg.norm(quad[0] - quad[3]) + np.linalg.norm(quad[2] - quad[1])) / 2.0
-            width_list.append(quad_w)
-            height_list.append(quad_h)
-        norm_width = max(sum(width_list) / (len(width_list) +  1e-6), 1.0)
-        average_height = max(sum(height_list) / (len(height_list) + 1e-6), 1.0)
-
-        for quad in poly_quads:
-            direct_vector_full = ((quad[1] + quad[2]) - (quad[0] + quad[3])) / 2.0
-            direct_vector = direct_vector_full / (np.linalg.norm(direct_vector_full) + 1e-6) * norm_width
-            direction_label = tuple(map(float, [direct_vector[0], direct_vector[1], 1.0 / (average_height + 1e-6)]))
-            cv2.fillPoly(direction_map, quad.round().astype(np.int32)[np.newaxis, :, :], direction_label)
-        return direction_map
-
-    def calculate_average_height(self, poly_quads):
-        """
-        """
-        height_list = []
-        for quad in poly_quads:
-            quad_h = (np.linalg.norm(quad[0] - quad[3]) + np.linalg.norm(quad[2] - quad[1])) / 2.0
-            height_list.append(quad_h)
-        average_height = max(sum(height_list) / len(height_list), 1.0)
-        return average_height
-
-    def generate_tcl_label(self, hw, polys, tags, ds_ratio,
-                            tcl_ratio=0.3, shrink_ratio_of_width=0.15):
-        """
-        Generate polygon.
-        """
-        h, w = hw
-        h, w = int(h * ds_ratio), int(w * ds_ratio)
-        polys = polys * ds_ratio
-
-        score_map = np.zeros((h, w,), dtype=np.float32)
-        tbo_map = np.zeros((h, w, 5), dtype=np.float32)
-        training_mask = np.ones((h, w,), dtype=np.float32)
-        direction_map = np.ones((h, w, 3)) * np.array([0, 0, 1]).reshape([1, 1, 3]).astype(np.float32)
-
-        for poly_idx, poly_tag in enumerate(zip(polys, tags)):
-            poly = poly_tag[0] 
-            tag = poly_tag[1]
-
-            # generate min_area_quad
-            min_area_quad, center_point = self.gen_min_area_quad_from_poly(poly)
-            min_area_quad_h = 0.5 * (np.linalg.norm(min_area_quad[0] - min_area_quad[3]) +
-                                    np.linalg.norm(min_area_quad[1] - min_area_quad[2]))
-            min_area_quad_w = 0.5 * (np.linalg.norm(min_area_quad[0] - min_area_quad[1]) +
-                                    np.linalg.norm(min_area_quad[2] - min_area_quad[3]))
-
-            if min(min_area_quad_h, min_area_quad_w) < self.min_text_size * ds_ratio \
-                or min(min_area_quad_h, min_area_quad_w) > self.max_text_size * ds_ratio:
-                continue
-
-            if tag:
-                # continue
-                cv2.fillPoly(training_mask, poly.astype(np.int32)[np.newaxis, :, :], 0.15)
-            else:
-                tcl_poly = self.poly2tcl(poly, tcl_ratio)
-                tcl_quads = self.poly2quads(tcl_poly)
-                poly_quads = self.poly2quads(poly)
-                # stcl map
-                stcl_quads, quad_index = self.shrink_poly_along_width(tcl_quads, shrink_ratio_of_width=shrink_ratio_of_width,
-                                                                expand_height_ratio=1.0 / tcl_ratio)
-                # generate tcl map
-                cv2.fillPoly(score_map, np.round(stcl_quads).astype(np.int32), 1.0)
-
-                # generate tbo map
-                for idx, quad in enumerate(stcl_quads):
-                    quad_mask = np.zeros((h, w), dtype=np.float32)
-                    quad_mask = cv2.fillPoly(quad_mask, np.round(quad[np.newaxis, :, :]).astype(np.int32), 1.0)
-                    tbo_map = self.gen_quad_tbo(poly_quads[quad_index[idx]], quad_mask, tbo_map)
-        return score_map, tbo_map, training_mask
-
-    def generate_tvo_and_tco(self, hw, polys, tags, tcl_ratio=0.3, ds_ratio=0.25):
-        """
-        Generate tcl map, tvo map and tbo map.
-        """
-        h, w = hw
-        h, w = int(h * ds_ratio), int(w * ds_ratio)
-        polys = polys * ds_ratio
-        poly_mask = np.zeros((h, w), dtype=np.float32)
-
-        tvo_map = np.ones((9, h, w), dtype=np.float32)
-        tvo_map[0:-1:2] = np.tile(np.arange(0, w), (h, 1))
-        tvo_map[1:-1:2] = np.tile(np.arange(0, w), (h, 1)).T
-        poly_tv_xy_map = np.zeros((8, h, w), dtype=np.float32)
-
-        # tco map
-        tco_map = np.ones((3, h, w), dtype=np.float32)
-        tco_map[0] = np.tile(np.arange(0, w), (h, 1))
-        tco_map[1] = np.tile(np.arange(0, w), (h, 1)).T
-        poly_tc_xy_map = np.zeros((2, h, w), dtype=np.float32)
-
-        poly_short_edge_map = np.ones((h, w), dtype=np.float32)
-
-        for poly, poly_tag in zip(polys, tags):
-
-            if poly_tag == True:
-                continue
-
-            # adjust point order for vertical poly
-            poly = self.adjust_point(poly)
-
-            # generate min_area_quad
-            min_area_quad, center_point = self.gen_min_area_quad_from_poly(poly)
-            min_area_quad_h = 0.5 * (np.linalg.norm(min_area_quad[0] - min_area_quad[3]) +
-                                    np.linalg.norm(min_area_quad[1] - min_area_quad[2]))
-            min_area_quad_w = 0.5 * (np.linalg.norm(min_area_quad[0] - min_area_quad[1]) +
-                                    np.linalg.norm(min_area_quad[2] - min_area_quad[3]))
-
-            # generate tcl map and text, 128 * 128
-            tcl_poly = self.poly2tcl(poly, tcl_ratio)
-
-            # generate poly_tv_xy_map
-            for idx in range(4):
-                cv2.fillPoly(poly_tv_xy_map[2 * idx],
-                            np.round(tcl_poly[np.newaxis, :, :]).astype(np.int32),
-                            float(min(max(min_area_quad[idx, 0], 0), w)))
-                cv2.fillPoly(poly_tv_xy_map[2 * idx + 1],
-                            np.round(tcl_poly[np.newaxis, :, :]).astype(np.int32),
-                            float(min(max(min_area_quad[idx, 1], 0), h)))
-
-            # generate poly_tc_xy_map
-            for idx in range(2):
-                cv2.fillPoly(poly_tc_xy_map[idx],
-                            np.round(tcl_poly[np.newaxis, :, :]).astype(np.int32), float(center_point[idx]))
-
-            # generate poly_short_edge_map
-            cv2.fillPoly(poly_short_edge_map,
-                        np.round(tcl_poly[np.newaxis, :, :]).astype(np.int32),
-                        float(max(min(min_area_quad_h, min_area_quad_w), 1.0)))
-
-            # generate poly_mask and training_mask
-            cv2.fillPoly(poly_mask, np.round(tcl_poly[np.newaxis, :, :]).astype(np.int32), 1)
-
-        tvo_map *= poly_mask
-        tvo_map[:8] -= poly_tv_xy_map
-        tvo_map[-1] /= poly_short_edge_map
-        tvo_map = tvo_map.transpose((1, 2, 0))
-
-        tco_map *= poly_mask
-        tco_map[:2] -= poly_tc_xy_map
-        tco_map[-1] /= poly_short_edge_map
-        tco_map = tco_map.transpose((1, 2, 0))
-
-        return tvo_map, tco_map
-
-    def adjust_point(self, poly):
-        """
-        adjust point order.
-        """
-        point_num = poly.shape[0]
-        if point_num == 4:
-            len_1 = np.linalg.norm(poly[0] - poly[1])
-            len_2 = np.linalg.norm(poly[1] - poly[2])
-            len_3 = np.linalg.norm(poly[2] - poly[3])
-            len_4 = np.linalg.norm(poly[3] - poly[0])
-
-            if (len_1 + len_3) * 1.5 < (len_2 + len_4):
-                poly = poly[[1, 2, 3, 0], :]
-
-        elif point_num > 4:
-            vector_1 = poly[0] - poly[1]
-            vector_2 = poly[1] - poly[2]
-            cos_theta = np.dot(vector_1, vector_2) / (np.linalg.norm(vector_1) * np.linalg.norm(vector_2) + 1e-6)
-            theta = np.arccos(np.round(cos_theta, decimals=4))
-
-            if abs(theta) > (70 / 180 * math.pi):
-                index = list(range(1, point_num)) + [0]
-                poly = poly[np.array(index), :]
-        return poly
-
-    def gen_min_area_quad_from_poly(self, poly):
-        """
-        Generate min area quad from poly.
-        """
-        point_num = poly.shape[0]
-        min_area_quad = np.zeros((4, 2), dtype=np.float32)
-        if point_num == 4:
-            min_area_quad = poly
-            center_point = np.sum(poly, axis=0) / 4
-        else:
-            rect = cv2.minAreaRect(poly.astype(np.int32))  # (center (x,y), (width, height), angle of rotation)
-            center_point = rect[0]
-            box = np.array(cv2.boxPoints(rect))
-
-            first_point_idx = 0
-            min_dist = 1e4
-            for i in range(4):
-                dist = np.linalg.norm(box[(i + 0) % 4] - poly[0]) + \
-                    np.linalg.norm(box[(i + 1) % 4] - poly[point_num // 2 - 1]) + \
-                    np.linalg.norm(box[(i + 2) % 4] - poly[point_num // 2]) + \
-                    np.linalg.norm(box[(i + 3) % 4] - poly[-1])
-                if dist < min_dist:
-                    min_dist = dist
-                    first_point_idx = i
-
-            for i in range(4):
-                min_area_quad[i] = box[(first_point_idx + i) % 4]
-
-        return min_area_quad, center_point
-
-    def shrink_quad_along_width(self, quad, begin_width_ratio=0., end_width_ratio=1.):
-        """
-        Generate shrink_quad_along_width.
-        """
-        ratio_pair = np.array([[begin_width_ratio], [end_width_ratio]], dtype=np.float32)
-        p0_1 = quad[0] + (quad[1] - quad[0]) * ratio_pair
-        p3_2 = quad[3] + (quad[2] - quad[3]) * ratio_pair
-        return np.array([p0_1[0], p0_1[1], p3_2[1], p3_2[0]])
-
-    def shrink_poly_along_width(self, quads, shrink_ratio_of_width, expand_height_ratio=1.0):
-        """
-        shrink poly with given length.
-        """
-        upper_edge_list = []
-
-        def get_cut_info(edge_len_list, cut_len):
-            for idx, edge_len in enumerate(edge_len_list):
-                cut_len -= edge_len
-                if cut_len <= 0.000001:
-                    ratio = (cut_len + edge_len_list[idx]) / edge_len_list[idx]
-                    return idx, ratio
-
-        for quad in quads:
-            upper_edge_len = np.linalg.norm(quad[0] - quad[1])
-            upper_edge_list.append(upper_edge_len)
-
-        # length of left edge and right edge.
-        left_length = np.linalg.norm(quads[0][0] - quads[0][3]) * expand_height_ratio
-        right_length = np.linalg.norm(quads[-1][1] - quads[-1][2]) * expand_height_ratio
-
-        shrink_length = min(left_length, right_length, sum(upper_edge_list)) * shrink_ratio_of_width
-        # shrinking length
-        upper_len_left = shrink_length
-        upper_len_right = sum(upper_edge_list) - shrink_length
-
-        left_idx, left_ratio = get_cut_info(upper_edge_list, upper_len_left)
-        left_quad = self.shrink_quad_along_width(quads[left_idx], begin_width_ratio=left_ratio, end_width_ratio=1)
-        right_idx, right_ratio = get_cut_info(upper_edge_list, upper_len_right)
-        right_quad = self.shrink_quad_along_width(quads[right_idx], begin_width_ratio=0, end_width_ratio=right_ratio)
-        
-        out_quad_list = []
-        if left_idx == right_idx:
-            out_quad_list.append([left_quad[0], right_quad[1], right_quad[2], left_quad[3]])
-        else:
-            out_quad_list.append(left_quad)
-            for idx in range(left_idx + 1, right_idx):
-                out_quad_list.append(quads[idx])
-            out_quad_list.append(right_quad)
-
-        return np.array(out_quad_list), list(range(left_idx, right_idx + 1))
-
-    def vector_angle(self, A, B):
-        """
-        Calculate the angle between vector AB and x-axis positive direction.
-        """
-        AB = np.array([B[1] - A[1], B[0] - A[0]])
-        return np.arctan2(*AB)
-
-    def theta_line_cross_point(self, theta, point):
-        """
-        Calculate the line through given point and angle in ax + by + c =0 form.
-        """
-        x, y = point
-        cos = np.cos(theta)
-        sin = np.sin(theta)
-        return [sin, -cos, cos * y - sin * x]
-
-    def line_cross_two_point(self, A, B):
-        """
-        Calculate the line through given point A and B in ax + by + c =0 form.
-        """
-        angle = self.vector_angle(A, B)
-        return self.theta_line_cross_point(angle, A)
-
-    def average_angle(self, poly):
-        """
-        Calculate the average angle between left and right edge in given poly.
-        """
-        p0, p1, p2, p3 = poly
-        angle30 = self.vector_angle(p3, p0)
-        angle21 = self.vector_angle(p2, p1)
-        return (angle30 + angle21) / 2
-
-    def line_cross_point(self, line1, line2):
-        """
-        line1 and line2 in  0=ax+by+c form, compute the cross point of line1 and line2
-        """
-        a1, b1, c1 = line1
-        a2, b2, c2 = line2
-        d = a1 * b2 - a2 * b1
-
-        if d == 0:
-            #print("line1", line1)
-            #print("line2", line2)
-            print('Cross point does not exist')
-            return np.array([0, 0], dtype=np.float32)
-        else:
-            x = (b1 * c2 - b2 * c1) / d
-            y = (a2 * c1 - a1 * c2) / d
-
-        return np.array([x, y], dtype=np.float32)
-
-    def quad2tcl(self, poly, ratio):
-        """
-        Generate center line by poly clock-wise point. (4, 2)
-        """
-        ratio_pair = np.array([[0.5 - ratio / 2], [0.5 + ratio / 2]], dtype=np.float32)
-        p0_3 = poly[0] + (poly[3] - poly[0]) * ratio_pair
-        p1_2 = poly[1] + (poly[2] - poly[1]) * ratio_pair
-        return np.array([p0_3[0], p1_2[0], p1_2[1], p0_3[1]])
-
-    def poly2tcl(self, poly, ratio):
-        """
-        Generate center line by poly clock-wise point.
-        """
-        ratio_pair = np.array([[0.5 - ratio / 2], [0.5 + ratio / 2]], dtype=np.float32)
-        tcl_poly = np.zeros_like(poly)
-        point_num = poly.shape[0]
-
-        for idx in range(point_num // 2):
-            point_pair = poly[idx] + (poly[point_num - 1 - idx] - poly[idx]) * ratio_pair
-            tcl_poly[idx] = point_pair[0]
-            tcl_poly[point_num - 1 - idx] = point_pair[1]
-        return tcl_poly
-
-    def gen_quad_tbo(self, quad, tcl_mask, tbo_map):
-        """
-        Generate tbo_map for give quad.
-        """
-        # upper and lower line function: ax + by + c = 0;
-        up_line = self.line_cross_two_point(quad[0], quad[1])
-        lower_line = self.line_cross_two_point(quad[3], quad[2])
-
-        quad_h = 0.5 * (np.linalg.norm(quad[0] - quad[3]) + np.linalg.norm(quad[1] - quad[2]))
-        quad_w = 0.5 * (np.linalg.norm(quad[0] - quad[1]) + np.linalg.norm(quad[2] - quad[3]))
-
-        # average angle of left and right line.
-        angle = self.average_angle(quad)
-
-        xy_in_poly = np.argwhere(tcl_mask == 1)
-        for y, x in xy_in_poly:
-            point = (x, y)
-            line = self.theta_line_cross_point(angle, point)
-            cross_point_upper = self.line_cross_point(up_line, line)
-            cross_point_lower = self.line_cross_point(lower_line, line)
-            ##FIX, offset reverse
-            upper_offset_x, upper_offset_y = cross_point_upper - point
-            lower_offset_x, lower_offset_y = cross_point_lower - point
-            tbo_map[y, x, 0] = upper_offset_y
-            tbo_map[y, x, 1] = upper_offset_x
-            tbo_map[y, x, 2] = lower_offset_y
-            tbo_map[y, x, 3] = lower_offset_x
-            tbo_map[y, x, 4] = 1.0 / max(min(quad_h, quad_w), 1.0) * 2
-        return tbo_map
-
-    def poly2quads(self, poly):
-        """
-        Split poly into quads.
-        """
-        quad_list = []
-        point_num = poly.shape[0]
-
-        # point pair
-        point_pair_list = []
-        for idx in range(point_num // 2):
-            point_pair = [poly[idx], poly[point_num - 1 - idx]]
-            point_pair_list.append(point_pair)
-
-        quad_num = point_num // 2 - 1
-        for idx in range(quad_num):
-            # reshape and adjust to clock-wise
-            quad_list.append((np.array(point_pair_list)[[idx, idx + 1]]).reshape(4, 2)[[0, 2, 3, 1]])
-
-        return np.array(quad_list)
-
-    def extract_polys(self, poly_txt_path):
-        """
-        Read text_polys, txt_tags, txts from give txt file.
-        """
-        text_polys, txt_tags, txts = [], [], []
-
-        with open(poly_txt_path) as f:
-            for line in f.readlines():
-                poly_str, txt = line.strip().split('\t')
-                poly = map(float, poly_str.split(','))
-                text_polys.append(np.array(poly, dtype=np.float32).reshape(-1, 2))
-                txts.append(txt)
-                if txt == '###':
-                    txt_tags.append(True)
-                else:
-                    txt_tags.append(False)
-
-        return np.array(map(np.array, text_polys)), \
-            np.array(txt_tags, dtype=np.bool), txts
-
-    def __call__(self, label_infor):
-        infor = self.convert_label_infor(label_infor)
-        im_path, text_polys, text_tags, text_strs = infor
-        im = cv2.imread(im_path)
-        if im is None:
-            return None
-        if text_polys.shape[0] == 0:
-            return None
-
-        h, w, _ = im.shape
-        text_polys, text_tags, hv_tags = self.check_and_validate_polys(text_polys, text_tags, (h, w))
-
-        if text_polys.shape[0] == 0:
-            return None
-
-        #set aspect ratio and keep area fix
-        asp_scales = np.arange(1.0, 1.55, 0.1)
-        asp_scale = np.random.choice(asp_scales)
-
-        if np.random.rand() < 0.5:
-            asp_scale = 1.0 / asp_scale
-        asp_scale = math.sqrt(asp_scale)
-        
-        asp_wx = asp_scale
-        asp_hy = 1.0 / asp_scale
-        im = cv2.resize(im, dsize=None, fx=asp_wx, fy=asp_hy)
-        text_polys[:, :, 0] *= asp_wx
-        text_polys[:, :, 1] *= asp_hy
-
-        h, w, _ = im.shape
-        if max(h, w) > 2048:
-            rd_scale = 2048.0 / max(h, w)
-            im = cv2.resize(im, dsize=None, fx=rd_scale, fy=rd_scale)
-            text_polys *= rd_scale
-        h, w, _ = im.shape
-        if min(h, w) < 16:
-            return None
-
-        #no background
-        im, text_polys, text_tags, hv_tags, text_strs = self.crop_area(im, \
-            text_polys, text_tags, hv_tags, text_strs, crop_background=False)
-        if text_polys.shape[0] == 0:
-            return None
-        #continue for all ignore case
-        if np.sum((text_tags * 1.0)) >= text_tags.size:
-            return None
-        new_h, new_w, _ = im.shape
-        if (new_h is None) or (new_w is None):
-            return None
-        #resize image
-        std_ratio = float(self.input_size) / max(new_w, new_h)
-        rand_scales = np.array([0.25, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0, 1.0, 1.0, 1.0, 1.0])
-        rz_scale = std_ratio * np.random.choice(rand_scales)
-        im = cv2.resize(im, dsize=None, fx=rz_scale, fy=rz_scale)
-        text_polys[:, :, 0] *= rz_scale
-        text_polys[:, :, 1] *= rz_scale
-        
-        #add gaussian blur
-        if np.random.rand() < 0.1 * 0.5:
-            ks = np.random.permutation(5)[0] + 1
-            ks = int(ks/2)*2 + 1
-            im =  cv2.GaussianBlur(im, ksize=(ks, ks), sigmaX=0, sigmaY=0)
-        #add brighter
-        if np.random.rand() < 0.1 * 0.5:
-            im = im * (1.0 + np.random.rand() * 0.5)
-            im = np.clip(im, 0.0, 255.0)
-        #add darker
-        if np.random.rand() < 0.1 * 0.5:
-            im = im * (1.0 - np.random.rand() * 0.5)
-            im = np.clip(im, 0.0, 255.0)
-        
-        # Padding the im to [input_size, input_size]
-        new_h, new_w, _ = im.shape
-        if min(new_w, new_h) < self.input_size * 0.5:
-            return None
-
-        im_padded = np.ones((self.input_size, self.input_size, 3), dtype=np.float32)
-        im_padded[:, :, 2] = 0.485 * 255
-        im_padded[:, :, 1] = 0.456 * 255
-        im_padded[:, :, 0] = 0.406 * 255
-
-        # Random the start position
-        del_h = self.input_size - new_h
-        del_w = self.input_size - new_w
-        sh, sw = 0, 0
-        if del_h > 1:
-            sh = int(np.random.rand() * del_h)
-        if del_w > 1:
-            sw = int(np.random.rand() * del_w)
-
-        # Padding
-        im_padded[sh: sh + new_h, sw: sw + new_w, :] = im.copy()
-        text_polys[:, :, 0] += sw
-        text_polys[:, :, 1] += sh
-
-        score_map, border_map, training_mask = self.generate_tcl_label((self.input_size, self.input_size), 
-                            text_polys, text_tags, 0.25)
-        
-        # SAST head
-        tvo_map, tco_map = self.generate_tvo_and_tco((self.input_size, self.input_size), text_polys, text_tags,  tcl_ratio=0.3, ds_ratio=0.25)
-        # print("test--------tvo_map shape:", tvo_map.shape)
-
-        im_padded[:, :, 2] -= 0.485 * 255
-        im_padded[:, :, 1] -= 0.456 * 255
-        im_padded[:, :, 0] -= 0.406 * 255
-        im_padded[:, :, 2] /= (255.0 * 0.229) 
-        im_padded[:, :, 1] /= (255.0 * 0.224) 
-        im_padded[:, :, 0] /= (255.0 * 0.225) 
-        im_padded = im_padded.transpose((2, 0, 1))
-
-        return im_padded[::-1, :, :], score_map[np.newaxis, :, :], border_map.transpose((2, 0, 1)), training_mask[np.newaxis, :, :], tvo_map.transpose((2, 0, 1)), tco_map.transpose((2, 0, 1))
-
-    
-class SASTProcessTest(object):
-    """
-    SAST process function for test
-    """
-    def __init__(self, params):
-        super(SASTProcessTest, self).__init__()
-        if 'max_side_len' in params:
-            self.max_side_len = params['max_side_len']
-        else:
-            self.max_side_len = 2400
-
-    def resize_image(self, im):
-        """
-        resize image to a size multiple of max_stride which is required by the network
-        :param im: the resized image
-        :param max_side_len: limit of max image size to avoid out of memory in gpu
-        :return: the resized image and the resize ratio
-        """
-        h, w, _ = im.shape
-
-        resize_w = w
-        resize_h = h
-
-        # Fix the longer side
-        if resize_h > resize_w:
-            ratio = float(self.max_side_len) / resize_h
-        else:
-            ratio = float(self.max_side_len) / resize_w
-
-        resize_h = int(resize_h * ratio)
-        resize_w = int(resize_w * ratio)
-
-        max_stride = 128
-        resize_h = (resize_h + max_stride - 1) // max_stride * max_stride
-        resize_w = (resize_w + max_stride - 1) // max_stride * max_stride
-        im = cv2.resize(im, (int(resize_w), int(resize_h)))
-        ratio_h = resize_h / float(h)
-        ratio_w = resize_w / float(w)
-
-        return im, (ratio_h, ratio_w)
-
-    def __call__(self, im):
-        src_h, src_w, _ = im.shape
-        im, (ratio_h, ratio_w) = self.resize_image(im)
-        img_mean = [0.485, 0.456, 0.406]
-        img_std = [0.229, 0.224, 0.225]
-        im = im[:, :, ::-1].astype(np.float32)
-        im = im / 255
-        im -= img_mean
-        im /= img_std
-        im = im.transpose((2, 0, 1))
-        im = im[np.newaxis, :]
-        return [im, (ratio_h, ratio_w, src_h, src_w)]

ppocr/data/imaug/__init__.py

+# 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, PSERandomCrop
+
+from .rec_img_aug import RecAug, RecResizeImg
+
+from .operators import *
+from .label_ops 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

ppocr/data/imaug/iaa_augment.py

+# 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
+
+import numpy as np
+import imgaug
+import imgaug.augmenters as iaa
+
+
+class AugmenterBuilder(object):
+    def __init__(self):
+        pass
+
+    def build(self, args, root=True):
+        if args is None or len(args) == 0:
+            return None
+        elif isinstance(args, list):
+            if root:
+                sequence = [self.build(value, root=False) for value in args]
+                return iaa.Sequential(sequence)
+            else:
+                return getattr(iaa, args[0])(
+                    *[self.to_tuple_if_list(a) for a in args[1:]])
+        elif isinstance(args, dict):
+            cls = getattr(iaa, args['type'])
+            return cls(**{
+                k: self.to_tuple_if_list(v)
+                for k, v in args['args'].items()
+            })
+        else:
+            raise RuntimeError('unknown augmenter arg: ' + str(args))
+
+    def to_tuple_if_list(self, obj):
+        if isinstance(obj, list):
+            return tuple(obj)
+        return obj
+
+
+class IaaAugment():
+    def __init__(self, augmenter_args=None, **kwargs):
+        if augmenter_args is None:
+            augmenter_args = [{
+                'type': 'Fliplr',
+                'args': {
+                    'p': 0.5
+                }
+            }, {
+                'type': 'Affine',
+                'args': {
+                    'rotate': [-10, 10]
+                }
+            }, {
+                'type': 'Resize',
+                'args': {
+                    'size': [0.5, 3]
+                }
+            }]
+        self.augmenter = AugmenterBuilder().build(augmenter_args)
+
+    def __call__(self, data):
+        image = data['image']
+        shape = image.shape
+
+        if self.augmenter:
+            aug = self.augmenter.to_deterministic()
+            data['image'] = aug.augment_image(image)
+            data = self.may_augment_annotation(aug, data, shape)
+        return data
+
+    def may_augment_annotation(self, aug, data, shape):
+        if aug is None:
+            return data
+
+        line_polys = []
+        for poly in data['polys']:
+            new_poly = self.may_augment_poly(aug, shape, poly)
+            line_polys.append(new_poly)
+        data['polys'] = np.array(line_polys)
+        return data
+
+    def may_augment_poly(self, aug, img_shape, poly):
+        keypoints = [imgaug.Keypoint(p[0], p[1]) for p in poly]
+        keypoints = aug.augment_keypoints(
+            [imgaug.KeypointsOnImage(
+                keypoints, shape=img_shape)])[0].keypoints
+        poly = [(p.x, p.y) for p in keypoints]
+        return poly

ppocr/data/imaug/label_ops.py

+# 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
+
+import numpy as np
+from ppocr.utils.logging import get_logger
+
+
+class DetLabelEncode(object):
+    def __init__(self, **kwargs):
+        pass
+
+    def __call__(self, data):
+        import json
+        label = data['label']
+        label = json.loads(label)
+        nBox = len(label)
+        boxes, txts, txt_tags = [], [], []
+        for bno in range(0, nBox):
+            box = label[bno]['points']
+            txt = label[bno]['transcription']
+            boxes.append(box)
+            txts.append(txt)
+            if txt in ['*', '###']:
+                txt_tags.append(True)
+            else:
+                txt_tags.append(False)
+        boxes = np.array(boxes, dtype=np.float32)
+        txt_tags = np.array(txt_tags, dtype=np.bool)
+
+        data['polys'] = boxes
+        data['texts'] = txts
+        data['ignore_tags'] = txt_tags
+        return data
+
+    def order_points_clockwise(self, pts):
+        rect = np.zeros((4, 2), dtype="float32")
+        s = pts.sum(axis=1)
+        rect[0] = pts[np.argmin(s)]
+        rect[2] = pts[np.argmax(s)]
+        diff = np.diff(pts, axis=1)
+        rect[1] = pts[np.argmin(diff)]
+        rect[3] = pts[np.argmax(diff)]
+        return rect
+
+
+class BaseRecLabelEncode(object):
+    """ Convert between text-label and text-index """
+
+    def __init__(self,
+                 max_text_length,
+                 character_dict_path=None,
+                 character_type='ch',
+                 use_space_char=False):
+        support_character_type = ['ch', 'en', 'en_sensitive']
+        assert character_type in support_character_type, "Only {} are supported now but get {}".format(
+            support_character_type, self.character_str)
+
+        self.max_text_len = max_text_length
+        if character_type == "en":
+            self.character_str = "0123456789abcdefghijklmnopqrstuvwxyz"
+            dict_character = list(self.character_str)
+        elif character_type == "ch":
+            self.character_str = ""
+            assert character_dict_path is not None, "character_dict_path should not be None when character_type is ch"
+            with open(character_dict_path, "rb") as fin:
+                lines = fin.readlines()
+                for line in lines:
+                    line = line.decode('utf-8').strip("\n").strip("\r\n")
+                    self.character_str += line
+            if use_space_char:
+                self.character_str += " "
+            dict_character = list(self.character_str)
+        elif character_type == "en_sensitive":
+            # same with ASTER setting (use 94 char).
+            import string
+            self.character_str = string.printable[:-6]
+            dict_character = list(self.character_str)
+        self.character_type = character_type
+        dict_character = self.add_special_char(dict_character)
+        self.dict = {}
+        for i, char in enumerate(dict_character):
+            self.dict[char] = i
+        self.character = dict_character
+
+    def add_special_char(self, dict_character):
+        return dict_character
+
+    def encode(self, text):
+        """convert text-label into text-index.
+        input:
+            text: text labels of each image. [batch_size]
+
+        output:
+            text: concatenated text index for CTCLoss.
+                    [sum(text_lengths)] = [text_index_0 + text_index_1 + ... + text_index_(n - 1)]
+            length: length of each text. [batch_size]
+        """
+        if len(text) > self.max_text_len:
+            return None
+        if self.character_type == "en":
+            text = text.lower()
+        text_list = []
+        for char in text:
+            if char not in self.dict:
+                # logger = get_logger()
+                # logger.warning('{} is not in dict'.format(char))
+                continue
+            text_list.append(self.dict[char])
+        if len(text_list) == 0:
+            return None
+        return text_list
+
+    def get_ignored_tokens(self):
+        return [0]  # for ctc blank
+
+
+class CTCLabelEncode(BaseRecLabelEncode):
+    """ Convert between text-label and text-index """
+
+    def __init__(self,
+                 max_text_length,
+                 character_dict_path=None,
+                 character_type='ch',
+                 use_space_char=False,
+                 **kwargs):
+        super(CTCLabelEncode,
+              self).__init__(max_text_length, character_dict_path,
+                             character_type, use_space_char)
+
+    def __call__(self, data):
+        text = data['label']
+        text = self.encode(text)
+        if text is None:
+            return None
+        data['length'] = np.array(len(text))
+        text = text + [0] * (self.max_text_len - len(text))
+        data['label'] = np.array(text)
+        return data
+
+    def add_special_char(self, dict_character):
+        dict_character = ['blank'] + dict_character
+        return dict_character
+
+
+class AttnLabelEncode(BaseRecLabelEncode):
+    """ Convert between text-label and text-index """
+
+    def __init__(self,
+                 max_text_length,
+                 character_dict_path=None,
+                 character_type='ch',
+                 use_space_char=False,
+                 **kwargs):
+        super(AttnLabelEncode,
+              self).__init__(max_text_length, character_dict_path,
+                             character_type, use_space_char)
+        self.beg_str = "sos"
+        self.end_str = "eos"
+
+    def add_special_char(self, dict_character):
+        dict_character = [self.beg_str, self.end_str] + dict_character
+        return dict_character
+
+    def __call__(self, text):
+        text = self.encode(text)
+        return text
+
+    def get_ignored_tokens(self):
+        beg_idx = self.get_beg_end_flag_idx("beg")
+        end_idx = self.get_beg_end_flag_idx("end")
+        return [beg_idx, end_idx]
+
+    def get_beg_end_flag_idx(self, beg_or_end):
+        if beg_or_end == "beg":
+            idx = np.array(self.dict[self.beg_str])
+        elif beg_or_end == "end":
+            idx = np.array(self.dict[self.end_str])
+        else:
+            assert False, "Unsupport type %s in get_beg_end_flag_idx" \
+                          % beg_or_end
+        return idx

ppocr/data/imaug/make_border_map.py

+# -*- coding:utf-8 -*- 
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
+import numpy as np
+import cv2
+
+np.seterr(divide='ignore', invalid='ignore')
+import pyclipper
+from shapely.geometry import Polygon
+import sys
+import warnings
+
+warnings.simplefilter("ignore")
+
+__all__ = ['MakeBorderMap']
+
+
+class MakeBorderMap(object):
+    def __init__(self,
+                 shrink_ratio=0.4,
+                 thresh_min=0.3,
+                 thresh_max=0.7,
+                 **kwargs):
+        self.shrink_ratio = shrink_ratio
+        self.thresh_min = thresh_min
+        self.thresh_max = thresh_max
+
+    def __call__(self, data: dict) -> dict:
+
+        img = data['image']
+        text_polys = data['polys']
+        ignore_tags = data['ignore_tags']
+
+        canvas = np.zeros(img.shape[:2], dtype=np.float32)
+        mask = np.zeros(img.shape[:2], dtype=np.float32)
+
+        for i in range(len(text_polys)):
+            if ignore_tags[i]:
+                continue
+            self.draw_border_map(text_polys[i], canvas, mask=mask)
+        canvas = canvas * (self.thresh_max - self.thresh_min) + self.thresh_min
+
+        data['threshold_map'] = canvas
+        data['threshold_mask'] = mask
+        return data
+
+    def draw_border_map(self, polygon, canvas, mask):
+        polygon = np.array(polygon)
+        assert polygon.ndim == 2
+        assert polygon.shape[1] == 2
+
+        polygon_shape = Polygon(polygon)
+        if polygon_shape.area <= 0:
+            return
+        distance = polygon_shape.area * (
+            1 - np.power(self.shrink_ratio, 2)) / polygon_shape.length
+        subject = [tuple(l) for l in polygon]
+        padding = pyclipper.PyclipperOffset()
+        padding.AddPath(subject, pyclipper.JT_ROUND, pyclipper.ET_CLOSEDPOLYGON)
+
+        padded_polygon = np.array(padding.Execute(distance)[0])
+        cv2.fillPoly(mask, [padded_polygon.astype(np.int32)], 1.0)
+
+        xmin = padded_polygon[:, 0].min()
+        xmax = padded_polygon[:, 0].max()
+        ymin = padded_polygon[:, 1].min()
+        ymax = padded_polygon[:, 1].max()
+        width = xmax - xmin + 1
+        height = ymax - ymin + 1
+
+        polygon[:, 0] = polygon[:, 0] - xmin
+        polygon[:, 1] = polygon[:, 1] - ymin
+
+        xs = np.broadcast_to(
+            np.linspace(
+                0, width - 1, num=width).reshape(1, width), (height, width))
+        ys = np.broadcast_to(
+            np.linspace(
+                0, height - 1, num=height).reshape(height, 1), (height, width))
+
+        distance_map = np.zeros(
+            (polygon.shape[0], height, width), dtype=np.float32)
+        for i in range(polygon.shape[0]):
+            j = (i + 1) % polygon.shape[0]
+            absolute_distance = self._distance(xs, ys, polygon[i], polygon[j])
+            distance_map[i] = np.clip(absolute_distance / distance, 0, 1)
+        distance_map = distance_map.min(axis=0)
+
+        xmin_valid = min(max(0, xmin), canvas.shape[1] - 1)
+        xmax_valid = min(max(0, xmax), canvas.shape[1] - 1)
+        ymin_valid = min(max(0, ymin), canvas.shape[0] - 1)
+        ymax_valid = min(max(0, ymax), canvas.shape[0] - 1)
+        canvas[ymin_valid:ymax_valid + 1, xmin_valid:xmax_valid + 1] = np.fmax(
+            1 - distance_map[ymin_valid - ymin:ymax_valid - ymax + height,
+                             xmin_valid - xmin:xmax_valid - xmax + width],
+            canvas[ymin_valid:ymax_valid + 1, xmin_valid:xmax_valid + 1])
+
+    def _distance(self, xs, ys, point_1, point_2):
+        '''
+        compute the distance from point to a line
+        ys: coordinates in the first axis
+        xs: coordinates in the second axis
+        point_1, point_2: (x, y), the end of the line
+        '''
+        height, width = xs.shape[:2]
+        square_distance_1 = np.square(xs - point_1[0]) + np.square(ys - point_1[
+            1])
+        square_distance_2 = np.square(xs - point_2[0]) + np.square(ys - point_2[
+            1])
+        square_distance = np.square(point_1[0] - point_2[0]) + np.square(
+            point_1[1] - point_2[1])
+
+        cosin = (square_distance - square_distance_1 - square_distance_2) / (
+            2 * np.sqrt(square_distance_1 * square_distance_2))
+        square_sin = 1 - np.square(cosin)
+        square_sin = np.nan_to_num(square_sin)
+        result = np.sqrt(square_distance_1 * square_distance_2 * square_sin /
+                         square_distance)
+
+        result[cosin <
+               0] = np.sqrt(np.fmin(square_distance_1, square_distance_2))[cosin
+                                                                           < 0]
+        # self.extend_line(point_1, point_2, result)
+        return result
+
+    def extend_line(self, point_1, point_2, result, shrink_ratio):
+        ex_point_1 = (int(
+            round(point_1[0] + (point_1[0] - point_2[0]) * (1 + shrink_ratio))),
+                      int(
+                          round(point_1[1] + (point_1[1] - point_2[1]) * (
+                              1 + shrink_ratio))))
+        cv2.line(
+            result,
+            tuple(ex_point_1),
+            tuple(point_1),
+            4096.0,
+            1,
+            lineType=cv2.LINE_AA,
+            shift=0)
+        ex_point_2 = (int(
+            round(point_2[0] + (point_2[0] - point_1[0]) * (1 + shrink_ratio))),
+                      int(
+                          round(point_2[1] + (point_2[1] - point_1[1]) * (
+                              1 + shrink_ratio))))
+        cv2.line(
+            result,
+            tuple(ex_point_2),
+            tuple(point_2),
+            4096.0,
+            1,
+            lineType=cv2.LINE_AA,
+            shift=0)
+        return ex_point_1, ex_point_2

ppocr/data/imaug/make_shrink_map.py

+# -*- coding:utf-8 -*- 
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
+import numpy as np
+import cv2
+from shapely.geometry import Polygon
+import pyclipper
+
+__all__ = ['MakeShrinkMap']
+
+
+class MakeShrinkMap(object):
+    r'''
+    Making binary mask from detection data with ICDAR format.
+    Typically following the process of class `MakeICDARData`.
+    '''
+
+    def __init__(self, min_text_size=8, shrink_ratio=0.4, **kwargs):
+        self.min_text_size = min_text_size
+        self.shrink_ratio = shrink_ratio
+
+    def __call__(self, data):
+        image = data['image']
+        text_polys = data['polys']
+        ignore_tags = data['ignore_tags']
+
+        h, w = image.shape[:2]
+        text_polys, ignore_tags = self.validate_polygons(text_polys,
+                                                         ignore_tags, h, w)
+        gt = np.zeros((h, w), dtype=np.float32)
+        # gt = np.zeros((1, h, w), dtype=np.float32)
+        mask = np.ones((h, w), dtype=np.float32)
+        for i in range(len(text_polys)):
+            polygon = text_polys[i]
+            height = max(polygon[:, 1]) - min(polygon[:, 1])
+            width = max(polygon[:, 0]) - min(polygon[:, 0])
+            if ignore_tags[i] or min(height, width) < self.min_text_size:
+                cv2.fillPoly(mask,
+                             polygon.astype(np.int32)[np.newaxis, :, :], 0)
+                ignore_tags[i] = True
+            else:
+                polygon_shape = Polygon(polygon)
+                distance = polygon_shape.area * (
+                    1 - np.power(self.shrink_ratio, 2)) / polygon_shape.length
+                subject = [tuple(l) for l in text_polys[i]]
+                padding = pyclipper.PyclipperOffset()
+                padding.AddPath(subject, pyclipper.JT_ROUND,
+                                pyclipper.ET_CLOSEDPOLYGON)
+                shrinked = padding.Execute(-distance)
+                if shrinked == []:
+                    cv2.fillPoly(mask,
+                                 polygon.astype(np.int32)[np.newaxis, :, :], 0)
+                    ignore_tags[i] = True
+                    continue
+                shrinked = np.array(shrinked[0]).reshape(-1, 2)
+                cv2.fillPoly(gt, [shrinked.astype(np.int32)], 1)
+                # cv2.fillPoly(gt[0], [shrinked.astype(np.int32)], 1)
+
+        data['shrink_map'] = gt
+        data['shrink_mask'] = mask
+        return data
+
+    def validate_polygons(self, polygons, ignore_tags, h, w):
+        '''
+        polygons (numpy.array, required): of shape (num_instances, num_points, 2)
+        '''
+        if len(polygons) == 0:
+            return polygons, ignore_tags
+        assert len(polygons) == len(ignore_tags)
+        for polygon in polygons:
+            polygon[:, 0] = np.clip(polygon[:, 0], 0, w - 1)
+            polygon[:, 1] = np.clip(polygon[:, 1], 0, h - 1)
+
+        for i in range(len(polygons)):
+            area = self.polygon_area(polygons[i])
+            if abs(area) < 1:
+                ignore_tags[i] = True
+            if area > 0:
+                polygons[i] = polygons[i][::-1, :]
+        return polygons, ignore_tags
+
+    def polygon_area(self, polygon):
+        # return cv2.contourArea(polygon.astype(np.float32))
+        edge = 0
+        for i in range(polygon.shape[0]):
+            next_index = (i + 1) % polygon.shape[0]
+            edge += (polygon[next_index, 0] - polygon[i, 0]) * (
+                polygon[next_index, 1] - polygon[i, 1])
+
+        return edge / 2.