openocr-python 0.0.2__py3-none-any.whl

openocr/openrec/preprocess/cam_label_encode.py

@@ -0,0 +1,141 @@
+import numpy as np
+import cv2
+from .ar_label_encode import ARLabelEncode
+
+
+def crop_safe(arr, rect, bbs=[], pad=0):
+    rect = np.array(rect)
+    rect[:2] -= pad
+    rect[2:] += 2 * pad
+    v0 = [max(0, rect[0]), max(0, rect[1])]
+    v1 = [
+        min(arr.shape[0], rect[0] + rect[2]),
+        min(arr.shape[1], rect[1] + rect[3])
+    ]
+    arr = arr[v0[0]:v1[0], v0[1]:v1[1], ...]
+    if len(bbs) > 0:
+        for i in range(len(bbs)):
+            bbs[i, 0] -= v0[0]
+            bbs[i, 1] -= v0[1]
+        return arr, bbs
+    else:
+        return arr
+
+
+try:
+    # pygame==2.5.2
+    import pygame
+    from pygame import freetype
+except:
+    pass
+
+
+class CAMLabelEncode(ARLabelEncode):
+    """Convert between text-label and text-index."""
+
+    def __init__(self,
+                 max_text_length,
+                 character_dict_path=None,
+                 use_space_char=False,
+                 font_path=None,
+                 font_size=30,
+                 font_strength=0.1,
+                 image_shape=[32, 128],
+                 **kwargs):
+        super(CAMLabelEncode,
+              self).__init__(max_text_length, character_dict_path,
+                             use_space_char)
+        self.image_shape = image_shape
+
+        if font_path is not None:
+            freetype.init()
+            # init font
+            self.font = freetype.Font(font_path)
+            self.font.antialiased = True
+            self.font.origin = True
+
+            # choose font style
+            self.font.size = font_size
+            self.font.underline = False
+
+            self.font.strong = True
+            self.font.strength = font_strength
+            self.font.oblique = False
+
+    def render_normal(self, font, text):
+        # get the number of lines
+        lines = text.split('\n')
+        lengths = [len(l) for l in lines]
+
+        # font parameters:
+        line_spacing = font.get_sized_height() + 1
+
+        # initialize the surface to proper size:
+        line_bounds = font.get_rect(lines[np.argmax(lengths)])
+        fsize = (round(2.0 * line_bounds.width),
+                 round(1.25 * line_spacing * len(lines)))
+        surf = pygame.Surface(fsize, pygame.locals.SRCALPHA, 32)
+
+        bbs = []
+        space = font.get_rect('O')
+        # space = font.get_rect(' ')
+        x, y = 0, 0
+        for l in lines:
+            x = 2  # carriage-return
+            y += line_spacing  # line-feed
+
+            for ch in l:  # render each character
+                if ch.isspace():  # just shift
+                    x += space.width
+                else:
+                    # render the character
+                    ch_bounds = font.render_to(surf, (x, y), ch)
+                    # ch_bounds.x = x + ch_bounds.x
+                    # ch_bounds.y = y - ch_bounds.y
+                    x += ch_bounds.width + 5
+                    bbs.append(np.array(ch_bounds))
+
+        # get the union of characters for cropping:
+        r0 = pygame.Rect(bbs[0])
+        rect_union = r0.unionall(bbs)
+
+        # get the words:
+        # words = ' '.join(text.split())
+
+        # crop the surface to fit the text:
+        bbs = np.array(bbs)
+        surf_arr, bbs = crop_safe(pygame.surfarray.pixels_alpha(surf),
+                                  rect_union,
+                                  bbs,
+                                  pad=5)
+        surf_arr = surf_arr.swapaxes(0, 1)
+
+        # self.visualize_bb(surf_arr,bbs)
+        return surf_arr, bbs
+
+    def __call__(self, data):
+        data = super().__call__(data=data)
+        if data is None:
+            return None
+        word = []
+        for c in data['label'][1:data['length'] + 1]:
+            word.append(self.character[c])
+        word = ''.join(word)
+        # binary mask
+        binary_mask, bbs = self.render_normal(self.font, word)
+        cate_aware_surf = np.zeros((binary_mask.shape[0], binary_mask.shape[1],
+                                    len(self.character) - 3)).astype(np.uint8)
+        for id, bb in zip(data['label'][1:data['length'] + 1], bbs):
+            char_id = id - 1
+            cate_aware_surf[:, :,
+                            char_id][bb[1]:bb[1] + bb[3], bb[0]:bb[0] +
+                                     bb[2]] = binary_mask[bb[1]:bb[1] + bb[3],
+                                                          bb[0]:bb[0] + bb[2]]
+        binary_mask = cate_aware_surf
+        binary_mask = cv2.resize(
+            binary_mask, (self.image_shape[0] // 2, self.image_shape[1] // 2))
+        if np.max(binary_mask) > 0:
+            binary_mask = binary_mask / np.max(binary_mask)  # [0 ~ 1]
+            binary_mask = binary_mask.astype(np.float32)
+        data['binary_mask'] = binary_mask
+        return data

openocr/openrec/preprocess/ce_label_encode.py

@@ -0,0 +1,116 @@
+import re
+
+import numpy as np
+
+from tools.utils.logging import get_logger
+
+
+class BaseRecLabelEncode(object):
+    """Convert between text-label and text-index."""
+
+    def __init__(
+        self,
+        max_text_length,
+        character_dict_path=None,
+        use_space_char=False,
+        lower=False,
+    ):
+        self.max_text_len = max_text_length
+        self.beg_str = 'sos'
+        self.end_str = 'eos'
+        self.lower = lower
+        self.reverse = False
+        if character_dict_path is None:
+            logger = get_logger()
+            logger.warning(
+                'The character_dict_path is None, model can only recognize number and lower letters'
+            )
+            self.character_str = '0123456789abcdefghijklmnopqrstuvwxyz'
+            dict_character = list(self.character_str)
+            self.lower = True
+        else:
+            self.character_str = []
+            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.append(line)
+            if use_space_char:
+                self.character_str.append(' ')
+            dict_character = list(self.character_str)
+            if 'arabic' in character_dict_path:
+                self.reverse = True
+        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 label_reverse(self, text):
+        text_re = []
+        c_current = ''
+        for c in text:
+            if not bool(re.search('[a-zA-Z0-9 :*./%+-١٢٣٤٥٦٧٨٩٠]', c)):
+                if c_current != '':
+                    text_re.append(c_current)
+                text_re.append(c)
+                c_current = ''
+            else:
+                c_current += c
+        if c_current != '':
+            text_re.append(c_current)
+
+        return ''.join(text_re[::-1])
+
+    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) == 0 or len(text) > self.max_text_len:
+            return None
+        if self.lower:
+            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
+
+
+class CELabelEncode(BaseRecLabelEncode):
+    """Convert between text-label and text-index."""
+
+    def __init__(self,
+                 max_text_length,
+                 character_dict_path=None,
+                 use_space_char=False,
+                 **kwargs):
+        super(CELabelEncode,
+              self).__init__(max_text_length, character_dict_path,
+                             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))
+        data['label'] = np.array(text)
+        return data
+
+    def add_special_char(self, dict_character):
+        return dict_character

openocr/openrec/preprocess/char_label_encode.py

@@ -0,0 +1,36 @@
+import numpy as np
+
+from .ctc_label_encode import BaseRecLabelEncode
+
+
+class CharLabelEncode(BaseRecLabelEncode):
+    """Convert between text-label and text-index."""
+
+    def __init__(self,
+                 max_text_length,
+                 character_dict_path=None,
+                 use_space_char=False,
+                 **kwargs):
+        super(CharLabelEncode,
+              self).__init__(max_text_length, character_dict_path,
+                             use_space_char)
+
+    def __call__(self, data):
+        text = data['label']
+        text = self.encode(text)
+        if text is None:
+            return None
+        if len(text) > self.max_text_len:
+            return None
+        data['length'] = np.array(len(text))
+        text_char = text + [104] * (self.max_text_len + 1 - len(text))
+        text.insert(0, 2)
+        text.append(3)
+        text = text + [0] * (self.max_text_len + 2 - len(text))
+        data['label'] = np.array(text)
+        data['label_char'] = np.array(text_char)
+        return data
+
+    def add_special_char(self, dict_character):
+        dict_character = ['blank', '<unk>', '<s>', '</s>'] + dict_character
+        return dict_character

openocr/openrec/preprocess/cppd_label_encode.py

@@ -0,0 +1,173 @@
+import random
+
+import numpy as np
+
+from openrec.preprocess.ctc_label_encode import BaseRecLabelEncode
+
+
+class CPPDLabelEncode(BaseRecLabelEncode):
+    """Convert between text-label and text-index."""
+
+    def __init__(
+            self,
+            max_text_length,
+            character_dict_path=None,
+            use_space_char=False,
+            ch=False,
+            #  ch_7000=7000,
+            ignore_index=100,
+            use_sos=False,
+            pos_len=False,
+            **kwargs):
+        self.use_sos = use_sos
+        super(CPPDLabelEncode,
+              self).__init__(max_text_length, character_dict_path,
+                             use_space_char)
+        self.ch = ch
+        self.ignore_index = ignore_index
+        self.pos_len = pos_len
+
+    def __call__(self, data):
+        text = data['label']
+        if self.ch:
+            text, text_node_index, text_node_num = self.encodech(text)
+            if text is None:
+                return None
+            if len(text) > self.max_text_len:
+                return None
+            data['length'] = np.array(len(text))
+            # text.insert(0, 0)
+            if self.pos_len:
+                text_pos_node = [i_ for i_ in range(len(text), -1, -1)
+                                 ] + [100] * (self.max_text_len - len(text))
+            else:
+                text_pos_node = [1] * (len(text) + 1) + [0] * (
+                    self.max_text_len - len(text))
+
+            text.append(0)
+            text + [0] * (self.max_text_len - len(text))
+
+            text = text + [self.ignore_index
+                           ] * (self.max_text_len + 1 - len(text))
+
+            data['label'] = np.array(text)
+            data['label_node'] = np.array(text_node_num + text_pos_node)
+            data['label_index'] = np.array(text_node_index)
+            # data['label_ctc'] = np.array(ctc_text)
+            return data
+        else:
+            text, text_char_node, ch_order = self.encode(text)
+
+            if text is None:
+                return None
+            if len(text) > self.max_text_len:
+                return None
+            data['length'] = np.array(len(text))
+            # text.insert(0, 0)
+            if self.pos_len:
+                text_pos_node = [i_ for i_ in range(len(text), -1, -1)
+                                 ] + [100] * (self.max_text_len - len(text))
+            else:
+                text_pos_node = [1] * (len(text) + 1) + [0] * (
+                    self.max_text_len - len(text))
+
+            text.append(0)
+
+            text = text + [self.ignore_index
+                           ] * (self.max_text_len + 1 - len(text))
+            data['label'] = np.array(text)
+            data['label_node'] = np.array(text_char_node + text_pos_node)
+            data['label_order'] = np.array(ch_order)
+
+            return data
+
+    def add_special_char(self, dict_character):
+        if self.use_sos:
+            dict_character = ['<s>', '</s>'] + dict_character
+        else:
+            dict_character = ['</s>'] + dict_character
+        self.num_character = len(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) == 0:
+            return None, None, None
+        if self.lower:
+            text = text.lower()
+        text_node = [0 for _ in range(self.num_character)]
+        text_node[0] = 1
+        text_list = []
+        ch_order = []
+        order = 1
+        for char in text:
+            if char not in self.dict:
+                continue
+            text_list.append(self.dict[char])
+            text_node[self.dict[char]] += 1
+            ch_order.append(
+                [self.dict[char], text_node[self.dict[char]], order])
+            order += 1
+
+        no_ch_order = []
+        for char in self.character:
+            if char not in text:
+                no_ch_order.append([self.dict[char], 1, 0])
+        random.shuffle(no_ch_order)
+        ch_order = ch_order + no_ch_order
+        ch_order = ch_order[:self.max_text_len + 1]
+
+        if len(text_list) == 0 or len(text_list) > self.max_text_len:
+            return None, None, None
+        return text_list, text_node, ch_order.sort()
+
+    def encodech(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) == 0:
+            return None, None, None
+        if self.lower:
+            text = text.lower()
+        text_node_dict = {}
+        text_node_dict.update({0: 1})
+        character_index = [_ for _ in range(self.num_character)]
+        text_list = []
+        for char in text:
+            if char not in self.dict:
+                continue
+            i_c = self.dict[char]
+            text_list.append(i_c)
+
+            if i_c in text_node_dict.keys():
+                text_node_dict[i_c] += 1
+            else:
+                text_node_dict.update({i_c: 1})
+        for ic in list(text_node_dict.keys()):
+            character_index.remove(ic)
+        none_char_index = random.sample(character_index,
+                                        37 - len(list(text_node_dict.keys())))
+        for ic in none_char_index:
+            text_node_dict[ic] = 0
+
+        text_node_index = sorted(text_node_dict)
+
+        text_node_num = [text_node_dict[k] for k in text_node_index]
+        if len(text_list) == 0 or len(text_list) > self.max_text_len:
+            return None, None, None
+        return text_list, text_node_index, text_node_num

openocr/openrec/preprocess/ctc_label_encode.py

@@ -0,0 +1,124 @@
+import re
+
+import numpy as np
+
+from tools.utils.logging import get_logger
+
+
+class BaseRecLabelEncode(object):
+    """Convert between text-label and text-index."""
+
+    def __init__(
+        self,
+        max_text_length,
+        character_dict_path=None,
+        use_space_char=False,
+        lower=False,
+    ):
+        self.max_text_len = max_text_length
+        self.beg_str = 'sos'
+        self.end_str = 'eos'
+        self.lower = lower
+        self.reverse = False
+        if character_dict_path is None:
+            logger = get_logger()
+            logger.warning(
+                'The character_dict_path is None, model can only recognize number and lower letters'
+            )
+            self.character_str = '0123456789abcdefghijklmnopqrstuvwxyz'
+            dict_character = list(self.character_str)
+            self.lower = True
+        else:
+            self.character_str = []
+            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.append(line)
+            if use_space_char:
+                self.character_str.append(' ')
+            dict_character = list(self.character_str)
+            if 'arabic' in character_dict_path:
+                self.reverse = True
+        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 label_reverse(self, text):
+        text_re = []
+        c_current = ''
+        for c in text:
+            if not bool(re.search('[a-zA-Z0-9 :*./%+-١٢٣٤٥٦٧٨٩٠]', c)):
+                if c_current != '':
+                    text_re.append(c_current)
+                text_re.append(c)
+                c_current = ''
+            else:
+                c_current += c
+        if c_current != '':
+            text_re.append(c_current)
+
+        return ''.join(text_re[::-1])
+
+    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) == 0:
+            return None
+        if self.lower:
+            text = text.lower()
+        text_list = []
+        for char in text:
+            if char not in self.dict:
+                continue
+            text_list.append(self.dict[char])
+        if len(text_list) == 0 or len(text_list) > self.max_text_len:
+            return None
+        return text_list
+
+
+class CTCLabelEncode(BaseRecLabelEncode):
+    """Convert between text-label and text-index."""
+
+    def __init__(self,
+                 max_text_length,
+                 character_dict_path=None,
+                 use_space_char=False,
+                 **kwargs):
+        super(CTCLabelEncode,
+              self).__init__(max_text_length, character_dict_path,
+                             use_space_char)
+        self.is_reverse = kwargs.get('is_reverse', False)
+
+    def __call__(self, data):
+        text = data['label']
+        if self.reverse and self.is_reverse:  # for arabic rec
+            text = self.label_reverse(text)
+        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)
+
+        label = [0] * len(self.character)
+        for x in text:
+            label[x] += 1
+        data['label_ace'] = np.array(label)
+        return data
+
+    def add_special_char(self, dict_character):
+        dict_character = ['blank'] + dict_character
+        return dict_character

openocr/openrec/preprocess/ep_label_encode.py

@@ -0,0 +1,38 @@
+import numpy as np
+
+from openrec.preprocess.ctc_label_encode import BaseRecLabelEncode
+
+
+class EPLabelEncode(BaseRecLabelEncode):
+    """Convert between text-label and text-index."""
+    EOS = '</s>'
+    PAD = '<pad>'
+
+    def __init__(self,
+                 max_text_length,
+                 character_dict_path=None,
+                 use_space_char=False,
+                 **kwargs):
+
+        super(EPLabelEncode,
+              self).__init__(max_text_length, character_dict_path,
+                             use_space_char)
+
+    def __call__(self, data):
+        text = data['label']
+        text = self.encode(text)
+        if text is None:
+            return None
+        if len(text) > self.max_text_len:
+            return None
+
+        data['length'] = np.array(len(text))
+        text = text + [self.dict[self.EOS]]
+        text = text + [self.dict[self.PAD]
+                       ] * (self.max_text_len + 1 - len(text))
+        data['label'] = np.array(text)
+        return data
+
+    def add_special_char(self, dict_character):
+        dict_character = [self.EOS] + dict_character + [self.PAD]
+        return dict_character