add easyocr

ezocr/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

ezocr/README.md

@@ -0,0 +1,49 @@
+# EasyOCR Lite
+
+从EasyOCR提取文本定位有关代码，进一步适配中文，修正缺陷
+
+## 安装
+
+Python版本至少为3.8。
+
+
+首先按照PyTorch官方说明安装PyTorch。
+
+```
+pip install -e .
+```
+
+## 使用
+
+``` python3
+from easyocrlite import ReaderLite
+
+reader = ReaderLite()
+results = reader.process('my_awesome_handwriting.png')
+```
+
+返回的内容为边界框和对应的图像区域的列表。
+其它说明见[demo](./demo.ipynb)。
+
+
+## 致谢
+
+基于[EasyOCR](https://github.com/JaidedAI/EasyOCR)修改实现。以下为EasyOCR致谢：
+
+This project is based on research and code from several papers and open-source repositories.
+
+All deep learning execution is based on [Pytorch](https://pytorch.org). :heart:
+
+Detection execution uses the CRAFT algorithm from this [official repository](https://github.com/clovaai/CRAFT-pytorch) and their [paper](https://arxiv.org/abs/1904.01941) (Thanks @YoungminBaek from [@clovaai](https://github.com/clovaai)). We also use their pretrained model. Training script is provided by [@gmuffiness](https://github.com/gmuffiness).
+
+The recognition model is a CRNN ([paper](https://arxiv.org/abs/1507.05717)). It is composed of 3 main components: feature extraction (we are currently using [Resnet](https://arxiv.org/abs/1512.03385)) and VGG, sequence labeling ([LSTM](https://www.bioinf.jku.at/publications/older/2604.pdf)) and decoding ([CTC](https://www.cs.toronto.edu/~graves/icml_2006.pdf)). The training pipeline for recognition execution is a modified version of the [deep-text-recognition-benchmark](https://github.com/clovaai/deep-text-recognition-benchmark) framework. (Thanks [@ku21fan](https://github.com/ku21fan) from [@clovaai](https://github.com/clovaai)) This repository is a gem that deserves more recognition.
+
+Beam search code is based on this [repository](https://github.com/githubharald/CTCDecoder) and his [blog](https://towardsdatascience.com/beam-search-decoding-in-ctc-trained-neural-networks-5a889a3d85a7). (Thanks [@githubharald](https://github.com/githubharald))
+
+Data synthesis is based on [TextRecognitionDataGenerator](https://github.com/Belval/TextRecognitionDataGenerator). (Thanks [@Belval](https://github.com/Belval))
+
+And a good read about CTC from distill.pub [here](https://distill.pub/2017/ctc/).
+
+
+## 许可证 (注意！)
+Apache 2.0

ezocr/easyocrlite.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.1
+Name: easyocrlite
+Version: 0.0.1
+License: Apache License 2.0
+Keywords: ocr optical character recognition deep learning neural network
+Classifier: Development Status :: 5 - Production/Stable
+Requires-Python: >=3.7
+License-File: LICENSE

ezocr/easyocrlite.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+setup.py
+easyocrlite/__init__.py
+easyocrlite/reader.py
+easyocrlite/types.py
+easyocrlite.egg-info/PKG-INFO
+easyocrlite.egg-info/SOURCES.txt
+easyocrlite.egg-info/dependency_links.txt
+easyocrlite.egg-info/requires.txt
+easyocrlite.egg-info/top_level.txt

ezocr/easyocrlite.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ezocr/easyocrlite.egg-info/requires.txt

@@ -0,0 +1,5 @@
+torch
+torchvision>=0.5
+opencv-python-headless<=4.5.4.60
+numpy
+Pillow

ezocr/easyocrlite.egg-info/top_level.txt

@@ -0,0 +1 @@
+easyocrlite

ezocr/easyocrlite/__init__.py

@@ -0,0 +1 @@
+from easyocrlite.reader import ReaderLite

ezocr/easyocrlite/model/__init__.py

@@ -0,0 +1 @@
+from .craft import CRAFT

ezocr/easyocrlite/model/craft.py

@@ -0,0 +1,174 @@
+"""
+Copyright (c) 2019-present NAVER Corp.
+MIT License
+"""
+from __future__ import annotations
+
+from collections import namedtuple
+from typing import Iterable, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torchvision
+from packaging import version
+from torchvision import models
+
+VGGOutputs = namedtuple(
+    "VggOutputs", ["fc7", "relu5_3", "relu4_3", "relu3_2", "relu2_2"]
+)
+
+def init_weights(modules: Iterable[nn.Module]):
+    for m in modules:
+        if isinstance(m, nn.Conv2d):
+            nn.init.xavier_uniform_(m.weight)
+            if m.bias is not None:
+                nn.init.zeros_(m.bias)
+        elif isinstance(m, nn.BatchNorm2d):
+            nn.init.constant_(m.weight, 1.0)
+            nn.init.zeros_(m.bias)
+        elif isinstance(m, nn.Linear):
+            nn.init.normal_(m.weight, 0, 0.01)
+            nn.init.zeros_(m.bias)
+
+
+class VGG16_BN(nn.Module):
+    def __init__(self, pretrained: bool=True, freeze: bool=True):
+        super().__init__()
+        if version.parse(torchvision.__version__) >= version.parse("0.13"):
+            vgg_pretrained_features = models.vgg16_bn(
+                weights=models.VGG16_BN_Weights.DEFAULT if pretrained else None
+            ).features
+        else:  # torchvision.__version__ < 0.13
+            models.vgg.model_urls["vgg16_bn"] = models.vgg.model_urls[
+                "vgg16_bn"
+            ].replace("https://", "http://")
+            vgg_pretrained_features = models.vgg16_bn(pretrained=pretrained).features
+
+        self.slice1 = torch.nn.Sequential()
+        self.slice2 = torch.nn.Sequential()
+        self.slice3 = torch.nn.Sequential()
+        self.slice4 = torch.nn.Sequential()
+        self.slice5 = torch.nn.Sequential()
+        for x in range(12):  # conv2_2
+            self.slice1.add_module(str(x), vgg_pretrained_features[x])
+        for x in range(12, 19):  # conv3_3
+            self.slice2.add_module(str(x), vgg_pretrained_features[x])
+        for x in range(19, 29):  # conv4_3
+            self.slice3.add_module(str(x), vgg_pretrained_features[x])
+        for x in range(29, 39):  # conv5_3
+            self.slice4.add_module(str(x), vgg_pretrained_features[x])
+
+        # fc6, fc7 without atrous conv
+        self.slice5 = torch.nn.Sequential(
+            nn.MaxPool2d(kernel_size=3, stride=1, padding=1),
+            nn.Conv2d(512, 1024, kernel_size=3, padding=6, dilation=6),
+            nn.Conv2d(1024, 1024, kernel_size=1),
+        )
+
+        if not pretrained:
+            init_weights(self.slice1.modules())
+            init_weights(self.slice2.modules())
+            init_weights(self.slice3.modules())
+            init_weights(self.slice4.modules())
+
+        init_weights(self.slice5.modules())  # no pretrained model for fc6 and fc7
+
+        if freeze:
+            for param in self.slice1.parameters():  # only first conv
+                param.requires_grad = False
+
+    def forward(self, x: torch.Tensor) -> VGGOutputs:
+        h = self.slice1(x)
+        h_relu2_2 = h
+        h = self.slice2(h)
+        h_relu3_2 = h
+        h = self.slice3(h)
+        h_relu4_3 = h
+        h = self.slice4(h)
+        h_relu5_3 = h
+        h = self.slice5(h)
+        h_fc7 = h
+        
+        out = VGGOutputs(h_fc7, h_relu5_3, h_relu4_3, h_relu3_2, h_relu2_2)
+        return out
+
+
+class DoubleConv(nn.Module):
+    def __init__(self, in_ch: int, mid_ch: int, out_ch: int):
+        super().__init__()
+        self.conv = nn.Sequential(
+            nn.Conv2d(in_ch + mid_ch, mid_ch, kernel_size=1),
+            nn.BatchNorm2d(mid_ch),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(mid_ch, out_ch, kernel_size=3, padding=1),
+            nn.BatchNorm2d(out_ch),
+            nn.ReLU(inplace=True),
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.conv(x)
+        return x
+
+
+class CRAFT(nn.Module):
+    def __init__(self, pretrained: bool=False, freeze: bool=False):
+        super(CRAFT, self).__init__()
+
+        """ Base network """
+        self.basenet = VGG16_BN(pretrained, freeze)
+
+        """ U network """
+        self.upconv1 = DoubleConv(1024, 512, 256)
+        self.upconv2 = DoubleConv(512, 256, 128)
+        self.upconv3 = DoubleConv(256, 128, 64)
+        self.upconv4 = DoubleConv(128, 64, 32)
+
+        num_class = 2
+        self.conv_cls = nn.Sequential(
+            nn.Conv2d(32, 32, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(32, 32, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(32, 16, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(16, 16, kernel_size=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(16, num_class, kernel_size=1),
+        )
+
+        init_weights(self.upconv1.modules())
+        init_weights(self.upconv2.modules())
+        init_weights(self.upconv3.modules())
+        init_weights(self.upconv4.modules())
+        init_weights(self.conv_cls.modules())
+
+    def forward(self, x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+        """Base network"""
+        sources = self.basenet(x)
+
+        """ U network """
+        y = torch.cat([sources[0], sources[1]], dim=1)
+        y = self.upconv1(y)
+
+        y = F.interpolate(
+            y, size=sources[2].size()[2:], mode="bilinear", align_corners=False
+        )
+        y = torch.cat([y, sources[2]], dim=1)
+        y = self.upconv2(y)
+
+        y = F.interpolate(
+            y, size=sources[3].size()[2:], mode="bilinear", align_corners=False
+        )
+        y = torch.cat([y, sources[3]], dim=1)
+        y = self.upconv3(y)
+
+        y = F.interpolate(
+            y, size=sources[4].size()[2:], mode="bilinear", align_corners=False
+        )
+        y = torch.cat([y, sources[4]], dim=1)
+        feature = self.upconv4(y)
+
+        y = self.conv_cls(feature)
+
+        return y.permute(0, 2, 3, 1), feature

ezocr/easyocrlite/reader.py

@@ -0,0 +1,272 @@
+from __future__ import annotations
+
+import logging
+import os
+from pathlib import Path
+from typing import Tuple
+
+import cv2
+import numpy as np
+import torch
+from PIL import Image, ImageEnhance
+
+from easyocrlite.model import CRAFT
+
+from easyocrlite.utils.download_utils import prepare_model
+from easyocrlite.utils.image_utils import (
+    adjust_result_coordinates,
+    boxed_transform,
+    normalize_mean_variance,
+    resize_aspect_ratio,
+)
+from easyocrlite.utils.detect_utils import (
+    extract_boxes,
+    extract_regions_from_boxes,
+    box_expand,
+    greedy_merge,
+)
+from easyocrlite.types import BoxTuple, RegionTuple
+import easyocrlite.utils.utils as utils
+
+logger = logging.getLogger(__name__)
+
+MODULE_PATH = (
+    os.environ.get("EASYOCR_MODULE_PATH")
+    or os.environ.get("MODULE_PATH")
+    or os.path.expanduser("~/.EasyOCR/")
+)
+
+
+class ReaderLite(object):
+    def __init__(
+        self,
+        gpu=True,
+        model_storage_directory=None,
+        download_enabled=True,
+        verbose=True,
+        quantize=True,
+        cudnn_benchmark=False,
+    ):
+
+        self.verbose = verbose
+
+        model_storage_directory = Path(
+            model_storage_directory
+            if model_storage_directory
+            else MODULE_PATH + "/model"
+        )
+        self.detector_path = prepare_model(
+            model_storage_directory, download_enabled, verbose
+        )
+
+        self.quantize = quantize
+        self.cudnn_benchmark = cudnn_benchmark
+        if gpu is False:
+            self.device = "cpu"
+            if verbose:
+                logger.warning(
+                    "Using CPU. Note: This module is much faster with a GPU."
+                )
+        elif not torch.cuda.is_available():
+            self.device = "cpu"
+            if verbose:
+                logger.warning(
+                    "CUDA not available - defaulting to CPU. Note: This module is much faster with a GPU."
+                )
+        elif gpu is True:
+            self.device = "cuda"
+        else:
+            self.device = gpu
+
+        self.detector = CRAFT()
+
+        state_dict = torch.load(self.detector_path, map_location=self.device)
+        if list(state_dict.keys())[0].startswith("module"):
+            state_dict = {k[7:]: v for k, v in state_dict.items()}
+
+        self.detector.load_state_dict(state_dict)
+
+        if self.device == "cpu":
+            if self.quantize:
+                try:
+                    torch.quantization.quantize_dynamic(
+                        self.detector, dtype=torch.qint8, inplace=True
+                    )
+                except:
+                    pass
+        else:
+            self.detector = torch.nn.DataParallel(self.detector).to(self.device)
+            import torch.backends.cudnn as cudnn
+
+            cudnn.benchmark = self.cudnn_benchmark
+
+        self.detector.eval()
+
+    def process(
+        self,
+        image_path: str,
+        max_size: int = 960,
+        expand_ratio: float = 1.0,
+        sharp: float = 1.0,
+        contrast: float = 1.0,
+        text_confidence: float = 0.7,
+        text_threshold: float = 0.4,
+        link_threshold: float = 0.4,
+        slope_ths: float = 0.1,
+        ratio_ths: float = 0.5,
+        center_ths: float = 0.5,
+        dim_ths: float = 0.5,
+        space_ths: float = 1.0,
+        add_margin: float = 0.1,
+        min_size: float = 0.01,
+    ) -> Tuple[BoxTuple, list[np.ndarray]]:
+
+        image = Image.open(image_path).convert('RGB')
+
+        tensor, inverse_ratio = self.preprocess(
+            image, max_size, expand_ratio, sharp, contrast
+        )
+
+        scores = self.forward_net(tensor)
+
+        boxes = self.detect(scores, text_confidence, text_threshold, link_threshold)
+
+        image = np.array(image)
+        region_list, box_list = self.postprocess(
+            image,
+            boxes,
+            inverse_ratio,
+            slope_ths,
+            ratio_ths,
+            center_ths,
+            dim_ths,
+            space_ths,
+            add_margin,
+            min_size,
+        )
+
+        # get cropped image
+        image_list = []
+        for region in region_list:
+            x_min, x_max, y_min, y_max = region
+            crop_img = image[y_min:y_max, x_min:x_max, :]
+            image_list.append(
+                (
+                    ((x_min, y_min), (x_max, y_min), (x_max, y_max), (x_min, y_max)),
+                    crop_img,
+                )
+            )
+
+        for box in box_list:
+            transformed_img = boxed_transform(image, np.array(box, dtype="float32"))
+            image_list.append((box, transformed_img))
+
+        # sort by top left point
+        image_list = sorted(image_list, key=lambda x: (x[0][0][1], x[0][0][0]))
+
+        return image_list
+
+    def preprocess(
+        self,
+        image: Image.Image,
+        max_size: int,
+        expand_ratio: float = 1.0,
+        sharp: float = 1.0,
+        contrast: float = 1.0,
+    ) -> torch.Tensor:
+        if sharp != 1:
+            enhancer = ImageEnhance.Sharpness(image)
+            image = enhancer.enhance(sharp)
+        if contrast != 1:
+            enhancer = ImageEnhance.Contrast(image)
+            image = enhancer.enhance(contrast)
+
+        image = np.array(image)
+
+        image, target_ratio = resize_aspect_ratio(
+            image, max_size, interpolation=cv2.INTER_LINEAR, expand_ratio=expand_ratio
+        )
+        inverse_ratio = 1 / target_ratio
+
+        x = np.transpose(normalize_mean_variance(image), (2, 0, 1))
+
+        x = torch.tensor(np.array([x]), device=self.device)
+
+        return x, inverse_ratio
+
+    @torch.no_grad()
+    def forward_net(self, tensor: torch.Tensor) -> torch.Tensor:
+        scores, feature = self.detector(tensor)
+        return scores[0]
+
+    def detect(
+        self,
+        scores: torch.Tensor,
+        text_confidence: float = 0.7,
+        text_threshold: float = 0.4,
+        link_threshold: float = 0.4,
+    ) -> list[BoxTuple]:
+        # make score and link map
+        score_text = scores[:, :, 0].cpu().data.numpy()
+        score_link = scores[:, :, 1].cpu().data.numpy()
+        # extract box
+        boxes, _ = extract_boxes(
+            score_text, score_link, text_confidence, text_threshold, link_threshold
+        )
+        return boxes
+
+    def postprocess(
+        self,
+        image: np.ndarray,
+        boxes: list[BoxTuple],
+        inverse_ratio: float,
+        slope_ths: float = 0.1,
+        ratio_ths: float = 0.5,
+        center_ths: float = 0.5,
+        dim_ths: float = 0.5,
+        space_ths: float = 1.0,
+        add_margin: float = 0.1,
+        min_size: int = 0,
+    ) -> Tuple[list[RegionTuple], list[BoxTuple]]:
+
+        # coordinate adjustment
+        boxes = adjust_result_coordinates(boxes, inverse_ratio)
+
+        max_y, max_x, _ = image.shape
+
+        # extract region and merge
+        region_list, box_list = extract_regions_from_boxes(boxes, slope_ths)
+
+        region_list = greedy_merge(
+            region_list,
+            ratio_ths=ratio_ths,
+            center_ths=center_ths,
+            dim_ths=dim_ths,
+            space_ths=space_ths,
+            verbose=0
+        )
+
+        # add margin
+        region_list = [
+            region.expand(add_margin, (max_x, max_y)).as_tuple()
+            for region in region_list
+        ]
+
+        box_list = [box_expand(box, add_margin, (max_x, max_y)) for box in box_list]
+
+        # filter by size
+        if min_size:
+            if min_size < 1:
+                min_size = int(min(max_y, max_x) * min_size)
+
+            region_list = [
+                i for i in region_list if max(i[1] - i[0], i[3] - i[2]) > min_size
+            ]
+            box_list = [
+                i
+                for i in box_list
+                if max(utils.diff([c[0] for c in i]), utils.diff([c[1] for c in i]))
+                > min_size
+            ]
+
+        return region_list, box_list

ezocr/easyocrlite/types.py

@@ -0,0 +1,5 @@
+from typing import Tuple
+
+Point = Tuple[int, int]
+BoxTuple = Tuple[Point, Point, Point, Point]
+RegionTuple = Tuple[int, int, int, int]

ezocr/easyocrlite/utils/detect_utils.py

@@ -0,0 +1,327 @@
+from __future__ import annotations
+
+import itertools
+import logging
+import math
+import operator
+from collections import namedtuple
+from functools import cached_property
+from typing import Iterable, Optional, Tuple
+
+import cv2
+import numpy as np
+from easyocrlite.types import BoxTuple, RegionTuple
+from easyocrlite.utils.utils import grouped_by
+
+logger = logging.getLogger(__name__)
+
+class Region(namedtuple("Region", ["x_min", "x_max", "y_min", "y_max"])):
+    @cached_property
+    def ycenter(self):
+        return 0.5 * (self.y_min + self.y_max)
+
+    @cached_property
+    def xcenter(self):
+        return 0.5 * (self.x_min + self.x_max)
+
+    @cached_property
+    def height(self):
+        return self.y_max - self.y_min
+
+    @cached_property
+    def width(self):
+        return self.x_max - self.x_min
+
+    @classmethod
+    def from_box(cls, box: BoxTuple) -> Region:
+        (xtl, ytl), (xtr, ytr), (xbr, ybr), (xbl, ybl) = box
+
+        x_max = max(xtl, xtr, xbr, xbl)
+        x_min = min(xtl, xtr, xbr, xbl)
+        y_max = max(ytl, ytr, ybr, ybl)
+        y_min = min(ytl, ytr, ybr, ybl)
+
+        return cls(x_min, x_max, y_min, y_max)
+
+    def as_tuple(self) -> RegionTuple:
+        return self.x_min, self.x_max, self.y_min, self.y_max
+
+    def expand(
+        self, add_margin: float, size: Optional[Tuple[int, int] | int] = None
+    ) -> Region:
+
+        margin = int(add_margin * min(self.width, self.height))
+        if isinstance(size, Iterable):
+            max_x, max_y = size
+        elif size is None:
+            max_x = self.width * 2
+            max_y = self.height * 2
+        else:
+            max_x = max_y = size
+
+        return Region(
+            max(0, self.x_min - margin),
+            min(max_x, self.x_max + margin),
+            max(0, self.y_min - margin),
+            min(max_y, self.y_max + margin),
+        )
+
+    def __add__(self, region: Region) -> Region:
+        return Region(
+            min(self.x_min, region.x_min),
+            max(self.x_max, region.x_max),
+            min(self.y_min, region.y_min),
+            max(self.y_max, region.y_max),
+        )
+
+def extract_boxes(
+    textmap: np.ndarray,
+    linkmap: np.ndarray,
+    text_threshold: float,
+    link_threshold: float,
+    low_text: float,
+) -> Tuple[list[BoxTuple], list[int]]:
+    # prepare data
+    linkmap = linkmap.copy()
+    textmap = textmap.copy()
+    img_h, img_w = textmap.shape
+
+    """ labeling method """
+    ret, text_score = cv2.threshold(textmap, low_text, 1, 0)
+    ret, link_score = cv2.threshold(linkmap, link_threshold, 1, 0)
+
+    text_score_comb = np.clip(text_score + link_score, 0, 1)
+    nLabels, labels, stats, centroids = cv2.connectedComponentsWithStats(
+        text_score_comb.astype(np.uint8), connectivity=4
+    )
+
+    boxes = []
+    mapper = []
+    for k in range(1, nLabels):
+        # size filtering
+        size = stats[k, cv2.CC_STAT_AREA]
+        if size < 10:
+            continue
+
+        # thresholding
+        if np.max(textmap[labels == k]) < text_threshold:
+            continue
+
+        # make segmentation map
+        segmap = np.zeros(textmap.shape, dtype=np.uint8)
+        segmap[labels == k] = 255
+
+        mapper.append(k)
+        segmap[np.logical_and(link_score == 1, text_score == 0)] = 0  # remove link area
+        x, y = stats[k, cv2.CC_STAT_LEFT], stats[k, cv2.CC_STAT_TOP]
+        w, h = stats[k, cv2.CC_STAT_WIDTH], stats[k, cv2.CC_STAT_HEIGHT]
+        niter = int(math.sqrt(size * min(w, h) / (w * h)) * 2)
+        sx, ex, sy, ey = x - niter, x + w + niter + 1, y - niter, y + h + niter + 1
+        # boundary check
+        if sx < 0:
+            sx = 0
+        if sy < 0:
+            sy = 0
+        if ex >= img_w:
+            ex = img_w
+        if ey >= img_h:
+            ey = img_h
+        kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (1 + niter, 1 + niter))
+        segmap[sy:ey, sx:ex] = cv2.dilate(segmap[sy:ey, sx:ex], kernel)
+
+        # make box
+        np_contours = (
+            np.roll(np.array(np.where(segmap != 0)), 1, axis=0)
+            .transpose()
+            .reshape(-1, 2)
+        )
+        rectangle = cv2.minAreaRect(np_contours)
+        box = cv2.boxPoints(rectangle)
+
+        # align diamond-shape
+        w, h = np.linalg.norm(box[0] - box[1]), np.linalg.norm(box[1] - box[2])
+        box_ratio = max(w, h) / (min(w, h) + 1e-5)
+        if abs(1 - box_ratio) <= 0.1:
+            l, r = min(np_contours[:, 0]), max(np_contours[:, 0])
+            t, b = min(np_contours[:, 1]), max(np_contours[:, 1])
+            box = np.array([[l, t], [r, t], [r, b], [l, b]], dtype=np.float32)
+
+        # make clock-wise order
+        startidx = box.sum(axis=1).argmin()
+        box = np.roll(box, 4 - startidx, 0)
+        box = np.array(box)
+        boxes.append(box)
+
+    return boxes, mapper
+
+
+def extract_regions_from_boxes(
+    boxes: list[BoxTuple], slope_ths: float
+) -> Tuple[list[Region], list[BoxTuple]]:
+
+    region_list: list[Region] = []
+    box_list = []
+
+    for box in boxes:
+        box = np.array(box).astype(np.int32)
+        (xtl, ytl), (xtr, ytr), (xbr, ybr), (xbl, ybl) = box
+
+        # get the tan of top and bottom edge
+        # why 10?
+        slope_top = (ytr - ytl) / max(10, xtr - xtl)
+        slope_bottom = (ybr - ybl) / max(10, xbr - xbl)
+        if max(abs(slope_top), abs(slope_bottom)) < slope_ths:
+            # not very tilted, rectangle box
+            region_list.append(Region.from_box(box))
+        else:
+            # tilted
+            box_list.append(box)
+    return region_list, box_list
+
+
+def box_expand(
+    box: BoxTuple, add_margin: float, size: Optional[Tuple[int, int] | int] = None
+) -> BoxTuple:
+
+    (xtl, ytl), (xtr, ytr), (xbr, ybr), (xbl, ybl) = box
+    height = np.linalg.norm([xbl - xtl, ybl - ytl])  # from top left to bottom left
+    width = np.linalg.norm([xtr - xtl, ytr - ytl])  # from top left to top right
+
+    # margin is added based on the diagonal
+    margin = int(1.44 * add_margin * min(width, height))
+
+    theta13 = abs(np.arctan((ytl - ybr) / max(10, (xtl - xbr))))
+    theta24 = abs(np.arctan((ytr - ybl) / max(10, (xtr - xbl))))
+
+    if isinstance(size, Iterable):
+        max_x, max_y = size
+    elif size is None:
+        max_x = width * 2
+        max_y = height * 2
+    else:
+        max_x = max_y = size
+
+    new_box = (
+        (
+            max(0, int(xtl - np.cos(theta13) * margin)),
+            max(0, int(ytl - np.sin(theta13) * margin)),
+        ),
+        (
+            min(max_x, math.ceil(xtr + np.cos(theta24) * margin)),
+            max(0, int(ytr - np.sin(theta24) * margin)),
+        ),
+        (
+            min(max_x, math.ceil(xbr + np.cos(theta13) * margin)),
+            min(max_y, math.ceil(ybr + np.sin(theta13) * margin)),
+        ),
+        (
+            max(0, int(xbl - np.cos(theta24) * margin)),
+            min(max_y, math.ceil(ybl + np.sin(theta24) * margin)),
+        ),
+    )
+    return new_box
+
+
+def greedy_merge(
+    regions: list[Region],
+    ratio_ths: float = 0.5,
+    center_ths: float = 0.5,
+    dim_ths: float = 0.5,
+    space_ths: float = 1.0,
+    verbose: int = 4,
+) -> list[Region]:
+
+    regions = sorted(regions, key=operator.attrgetter("ycenter"))
+
+    # grouped by ycenter
+    groups = grouped_by(
+        regions,
+        operator.attrgetter("ycenter"),
+        center_ths,
+        operator.attrgetter("height"),
+    )
+    for group in groups:
+        group.sort(key=operator.attrgetter("x_min"))
+        idx = 0
+        while idx < len(group) - 1:
+            region1, region2 = group[idx], group[idx + 1]
+            # both are horizontal regions
+            cond = (region1.width / region1.height) > ratio_ths and (
+                region2.width / region2.height
+            ) > ratio_ths
+            # similar heights
+            cond = cond and abs(region1.height - region2.height) < dim_ths * np.mean(
+                [region1.height, region2.height]
+            )
+            # similar ycenters
+            # cond = cond and abs(region1.ycenter - region2.ycenter) < center_ths * np.mean(
+            #     [region1.height, region2.height]
+            # )
+            # horizontal space is small
+            cond = cond and (region2.x_min - region1.x_max) < space_ths * np.mean(
+                [region1.height, region2.height]
+            )
+            if cond:
+                # merge regiona
+                region = region1 + region2
+
+                if verbose > 2:
+                    logger.debug(f"horizontal merging {region1} {region2}")
+                group.pop(idx)
+                group.pop(idx)
+                group.insert(idx, region)
+
+            else:
+                if verbose > 0:
+                    logger.debug(f"not horizontal merging {region1} {region2}")
+                idx += 1
+
+    # flatten groups
+    regions = list(itertools.chain.from_iterable(groups))
+
+    # grouped by xcenter
+    groups = grouped_by(
+        regions,
+        operator.attrgetter("xcenter"),
+        center_ths,
+        operator.attrgetter("width"),
+    )
+
+    for group in groups:
+        group.sort(key=operator.attrgetter("y_min"))
+        idx = 0
+        while idx < len(group) - 1:
+            region1, region2 = group[idx], group[idx + 1]
+            # both are vertical regions
+            cond = (region1.height / region1.width) > ratio_ths and (
+                region2.height / region2.width
+            ) > ratio_ths
+            # similar widths
+            cond = cond and abs(region1.width - region2.width) < dim_ths * np.mean(
+                [region1.width, region2.width]
+            )
+            # # similar xcenters
+            # cond = cond and abs(region1.xcenter - region2.xcenter) < center_ths * np.mean(
+            #     [region1.width, region2.width]
+            # )
+            # vertical space is small
+            cond = cond and (region2.y_min - region1.y_max) < space_ths * np.mean(
+                [region1.width, region2.width]
+            )
+            if cond:
+                # merge region
+                region = region1 + region2
+                if verbose > 2:
+                    logger.debug(f"vertical merging {region1} {region2}")
+                group.pop(idx)
+                group.pop(idx)
+                group.insert(idx, region)
+            else:
+                if verbose > 1:
+                    logger.debug(f"not vertical merging {region1} {region2}")
+                idx += 1
+
+    # flatten groups
+    regions = list(itertools.chain.from_iterable(groups))
+
+    return regions

ezocr/easyocrlite/utils/download_utils.py

@@ -0,0 +1,92 @@
+import hashlib
+import logging
+from pathlib import Path
+from typing import Callable, Optional
+from urllib.request import urlretrieve
+from zipfile import ZipFile
+
+from tqdm.auto import tqdm
+
+FILENAME = "craft_mlt_25k.pth"
+URL = (
+    "https://github.com/JaidedAI/EasyOCR/releases/download/pre-v1.1.6/craft_mlt_25k.zip"
+)
+MD5SUM = "2f8227d2def4037cdb3b34389dcf9ec1"
+MD5MSG = "MD5 hash mismatch, possible file corruption"
+
+
+logger = logging.getLogger(__name__)
+
+
+def calculate_md5(path: Path) -> str:
+    hash_md5 = hashlib.md5()
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(4096), b""):
+            hash_md5.update(chunk)
+    return hash_md5.hexdigest()
+
+
+def print_progress_bar(t: tqdm) -> Callable[[int, int, Optional[int]], None]:
+    last = 0
+
+    def update_to(
+        count: int = 1, block_size: int = 1, total_size: Optional[int] = None
+    ):
+        nonlocal last
+        if total_size is not None:
+            t.total = total_size
+        t.update((count - last) * block_size)
+        last = count
+
+    return update_to
+
+
+def download_and_unzip(
+    url: str, filename: str, model_storage_directory: Path, verbose: bool = True
+):
+    zip_path = model_storage_directory / "temp.zip"
+    with tqdm(
+        unit="B", unit_scale=True, unit_divisor=1024, miniters=1, disable=not verbose
+    ) as t:
+        reporthook = print_progress_bar(t)
+        urlretrieve(url, str(zip_path), reporthook=reporthook)
+    with ZipFile(zip_path, "r") as zipObj:
+        zipObj.extract(filename, str(model_storage_directory))
+    zip_path.unlink()
+
+
+def prepare_model(model_storage_directory: Path, download=True, verbose: bool = True) -> bool:
+    model_storage_directory.mkdir(parents=True, exist_ok=True)
+
+    detector_path = model_storage_directory / FILENAME
+
+    # try get model path
+    model_available = False
+    if not detector_path.is_file():
+        if not download:
+            raise FileNotFoundError(f"Missing {detector_path} and downloads disabled")
+        logger.info(
+            "Downloading detection model, please wait. "
+            "This may take several minutes depending upon your network connection."
+        )
+    elif calculate_md5(detector_path) != MD5SUM:
+        logger.warning(MD5MSG)
+        if not download:
+            raise FileNotFoundError(
+                f"MD5 mismatch for {detector_path} and downloads disabled"
+            )
+        detector_path.unlink()
+        logger.info(
+            "Re-downloading the detection model, please wait. "
+            "This may take several minutes depending upon your network connection."
+        )
+    else:
+        model_available = True
+
+    if not model_available:
+        download_and_unzip(URL, FILENAME, model_storage_directory, verbose)
+        if calculate_md5(detector_path) != MD5SUM:
+            raise ValueError(MD5MSG)
+        logger.info("Download complete")
+
+    return detector_path

ezocr/easyocrlite/utils/image_utils.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from typing import Tuple
+
+import cv2
+import numpy as np
+from easyocrlite.types import BoxTuple
+
+
+def resize_aspect_ratio(
+    img: np.ndarray, max_size: int, interpolation: int, expand_ratio: float = 1.0
+) -> Tuple[np.ndarray, float]:
+    height, width, channel = img.shape
+
+    # magnify image size
+    target_size = expand_ratio * max(height, width)
+
+    # set original image size
+    if max_size and max_size > 0 and target_size > max_size:
+        target_size = max_size
+
+    ratio = target_size / max(height, width)
+
+    target_h, target_w = int(height * ratio), int(width * ratio)
+
+    if target_h != height or target_w != width:
+        proc = cv2.resize(img, (target_w, target_h), interpolation=interpolation)
+        # make canvas and paste image
+        target_h32, target_w32 = target_h, target_w
+        if target_h % 32 != 0:
+            target_h32 = target_h + (32 - target_h % 32)
+        if target_w % 32 != 0:
+            target_w32 = target_w + (32 - target_w % 32)
+        resized = np.zeros((target_h32, target_w32, channel), dtype=np.float32)
+        resized[0:target_h, 0:target_w, :] = proc
+        target_h, target_w = target_h32, target_w32
+    else:
+        resized = img
+    return resized, ratio
+
+
+def adjust_result_coordinates(
+    box: BoxTuple, inverse_ratio: int = 1, ratio_net: int = 2
+) -> np.ndarray:
+    if len(box) > 0:
+        box = np.array(box)
+        for k in range(len(box)):
+            if box[k] is not None:
+                box[k] *= (inverse_ratio * ratio_net, inverse_ratio * ratio_net)
+    return box
+
+
+def normalize_mean_variance(
+    in_img: np.ndarray,
+    mean: Tuple[float, float, float] = (0.485, 0.456, 0.406),
+    variance: Tuple[float, float, float] = (0.229, 0.224, 0.225),
+) -> np.ndarray:
+    # should be RGB order
+    img = in_img.copy().astype(np.float32)
+
+    img -= np.array(
+        [mean[0] * 255.0, mean[1] * 255.0, mean[2] * 255.0], dtype=np.float32
+    )
+    img /= np.array(
+        [variance[0] * 255.0, variance[1] * 255.0, variance[2] * 255.0],
+        dtype=np.float32,
+    )
+    return img
+
+def boxed_transform(image: np.ndarray, box: BoxTuple) -> np.ndarray:
+    (tl, tr, br, bl) = box
+
+    widthA = np.sqrt(((br[0] - bl[0]) ** 2) + ((br[1] - bl[1]) ** 2))
+    widthB = np.sqrt(((tr[0] - tl[0]) ** 2) + ((tr[1] - tl[1]) ** 2))
+    maxWidth = max(int(widthA), int(widthB))
+
+    # compute the height of the new image, which will be the
+    # maximum distance between the top-right and bottom-right
+    # y-coordinates or the top-left and bottom-left y-coordinates
+    heightA = np.sqrt(((tr[0] - br[0]) ** 2) + ((tr[1] - br[1]) ** 2))
+    heightB = np.sqrt(((tl[0] - bl[0]) ** 2) + ((tl[1] - bl[1]) ** 2))
+    maxHeight = max(int(heightA), int(heightB))
+
+    dst = np.array(
+        [[0, 0], [maxWidth - 1, 0], [maxWidth - 1, maxHeight - 1], [0, maxHeight - 1]],
+        dtype="float32",
+    )
+
+    # compute the perspective transform matrix and then apply it
+    M = cv2.getPerspectiveTransform(box, dst)
+    warped = cv2.warpPerspective(image, M, (maxWidth, maxHeight))
+
+    return warped

ezocr/easyocrlite/utils/utils.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import numpy as np
+
+from typing import Iterable, TypeVar, Callable
+
+T = TypeVar("T")
+V = TypeVar("V")
+
+
+def diff(input_list: Iterable[T]) -> T:
+    return max(input_list) - min(input_list)
+
+
+def grouped_by(
+    items: list[T],
+    group_key: Callable[[T], V],
+    eps: float,
+    eps_key: Callable[[T], float],
+) -> list[list[T]]:
+    items = sorted(items, key=group_key)
+
+    groups = []
+    group = []
+
+    for item in items:
+        if not group:
+            group.append(item)
+            continue
+
+        if group:
+            cond = abs(
+                group_key(item) - np.mean([group_key(item) for item in group])
+            ) < eps * np.mean([eps_key(item) for item in group])
+            if cond:
+                group.append(item)
+            else:
+                groups.append(group)
+                group = [item]
+    else:
+        if group:
+            groups.append(group)
+    return groups

ezocr/requirements.txt

@@ -0,0 +1,5 @@
+torch
+torchvision>=0.5
+opencv-python-headless<=4.5.4.60
+numpy
+Pillow

ezocr/setup.py

@@ -0,0 +1,21 @@
+from io import open
+from setuptools import setup
+
+with open('requirements.txt', encoding="utf-8-sig") as f:
+    requirements = f.readlines()
+
+setup(
+    name='easyocrlite',
+    packages=['easyocrlite'],
+    python_requires='>=3.7',
+    include_package_data=True,
+    version='0.0.1',
+    install_requires=requirements,
+    license='Apache License 2.0',
+    description='',
+    long_description="",
+    keywords=['ocr optical character recognition deep learning neural network'],
+    classifiers=[
+        'Development Status :: 5 - Production/Stable'
+    ],
+)