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

pyxlpr/ppocr/postprocess/locality_aware_nms.py

@@ -1,200 +0,0 @@
-"""
-Locality aware nms.
-This code is refered from: https://github.com/songdejia/EAST/blob/master/locality_aware_nms.py
-"""
-
-import numpy as np
-from shapely.geometry import Polygon
-
-
-def intersection(g, p):
-    """
-    Intersection.
-    """
-    g = Polygon(g[:8].reshape((4, 2)))
-    p = Polygon(p[:8].reshape((4, 2)))
-    g = g.buffer(0)
-    p = p.buffer(0)
-    if not g.is_valid or not p.is_valid:
-        return 0
-    inter = Polygon(g).intersection(Polygon(p)).area
-    union = g.area + p.area - inter
-    if union == 0:
-        return 0
-    else:
-        return inter / union
-
-
-def intersection_iog(g, p):
-    """
-    Intersection_iog.
-    """
-    g = Polygon(g[:8].reshape((4, 2)))
-    p = Polygon(p[:8].reshape((4, 2)))
-    if not g.is_valid or not p.is_valid:
-        return 0
-    inter = Polygon(g).intersection(Polygon(p)).area
-    #union = g.area + p.area - inter
-    union = p.area
-    if union == 0:
-        print("p_area is very small")
-        return 0
-    else:
-        return inter / union
-
-
-def weighted_merge(g, p):
-    """
-    Weighted merge.
-    """
-    g[:8] = (g[8] * g[:8] + p[8] * p[:8]) / (g[8] + p[8])
-    g[8] = (g[8] + p[8])
-    return g
-
-
-def standard_nms(S, thres):
-    """
-    Standard nms.
-    """
-    order = np.argsort(S[:, 8])[::-1]
-    keep = []
-    while order.size > 0:
-        i = order[0]
-        keep.append(i)
-        ovr = np.array([intersection(S[i], S[t]) for t in order[1:]])
-
-        inds = np.where(ovr <= thres)[0]
-        order = order[inds + 1]
-
-    return S[keep]
-
-
-def standard_nms_inds(S, thres):
-    """
-    Standard nms, retun inds.
-    """
-    order = np.argsort(S[:, 8])[::-1]
-    keep = []
-    while order.size > 0:
-        i = order[0]
-        keep.append(i)
-        ovr = np.array([intersection(S[i], S[t]) for t in order[1:]])
-
-        inds = np.where(ovr <= thres)[0]
-        order = order[inds + 1]
-
-    return keep
-
-
-def nms(S, thres):
-    """
-    nms.
-    """
-    order = np.argsort(S[:, 8])[::-1]
-    keep = []
-    while order.size > 0:
-        i = order[0]
-        keep.append(i)
-        ovr = np.array([intersection(S[i], S[t]) for t in order[1:]])
-
-        inds = np.where(ovr <= thres)[0]
-        order = order[inds + 1]
-
-    return keep
-
-
-def soft_nms(boxes_in, Nt_thres=0.3, threshold=0.8, sigma=0.5, method=2):
-    """
-    soft_nms
-    :para boxes_in, N x 9 (coords + score)
-    :para threshould, eliminate cases min score(0.001)
-    :para Nt_thres, iou_threshi
-    :para sigma, gaussian weght
-    :method, linear or gaussian
-    """
-    boxes = boxes_in.copy()
-    N = boxes.shape[0]
-    if N is None or N < 1:
-        return np.array([])
-    pos, maxpos = 0, 0
-    weight = 0.0
-    inds = np.arange(N)
-    tbox, sbox = boxes[0].copy(), boxes[0].copy()
-    for i in range(N):
-        maxscore = boxes[i, 8]
-        maxpos = i
-        tbox = boxes[i].copy()
-        ti = inds[i]
-        pos = i + 1
-        #get max box
-        while pos < N:
-            if maxscore < boxes[pos, 8]:
-                maxscore = boxes[pos, 8]
-                maxpos = pos
-            pos = pos + 1
-        #add max box as a detection
-        boxes[i, :] = boxes[maxpos, :]
-        inds[i] = inds[maxpos]
-        #swap
-        boxes[maxpos, :] = tbox
-        inds[maxpos] = ti
-        tbox = boxes[i].copy()
-        pos = i + 1
-        #NMS iteration
-        while pos < N:
-            sbox = boxes[pos].copy()
-            ts_iou_val = intersection(tbox, sbox)
-            if ts_iou_val > 0:
-                if method == 1:
-                    if ts_iou_val > Nt_thres:
-                        weight = 1 - ts_iou_val
-                    else:
-                        weight = 1
-                elif method == 2:
-                    weight = np.exp(-1.0 * ts_iou_val**2 / sigma)
-                else:
-                    if ts_iou_val > Nt_thres:
-                        weight = 0
-                    else:
-                        weight = 1
-                boxes[pos, 8] = weight * boxes[pos, 8]
-                #if box score falls below thresold, discard the box by
-                #swaping last box update N
-                if boxes[pos, 8] < threshold:
-                    boxes[pos, :] = boxes[N - 1, :]
-                    inds[pos] = inds[N - 1]
-                    N = N - 1
-                    pos = pos - 1
-            pos = pos + 1
-
-    return boxes[:N]
-
-
-def nms_locality(polys, thres=0.3):
-    """
-    locality aware nms of EAST
-    :param polys: a N*9 numpy array. first 8 coordinates, then prob
-    :return: boxes after nms
-    """
-    S = []
-    p = None
-    for g in polys:
-        if p is not None and intersection(g, p) > thres:
-            p = weighted_merge(g, p)
-        else:
-            if p is not None:
-                S.append(p)
-            p = g
-    if p is not None:
-        S.append(p)
-
-    if len(S) == 0:
-        return np.array([])
-    return standard_nms(np.array(S), thres)
-
-
-if __name__ == '__main__':
-    # 343,350,448,135,474,143,369,359
-    print(
-        Polygon(np.array([[343, 350], [448, 135], [474, 143], [369, 359]]))
-        .area)

pyxlpr/ppocr/postprocess/pg_postprocess.py

@@ -1,52 +0,0 @@
-# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import os
-import sys
-
-__dir__ = os.path.dirname(__file__)
-sys.path.append(__dir__)
-sys.path.append(os.path.join(__dir__, '..'))
-from pyxlpr.ppocr.utils.e2e_utils.pgnet_pp_utils import PGNet_PostProcess
-
-
-class PGPostProcess(object):
-    """
-    The post process for PGNet.
-    """
-
-    def __init__(self, character_dict_path, valid_set, score_thresh, mode,
-                 **kwargs):
-        self.character_dict_path = character_dict_path
-        self.valid_set = valid_set
-        self.score_thresh = score_thresh
-        self.mode = mode
-
-        # c++ la-nms is faster, but only support python 3.5
-        self.is_python35 = False
-        if sys.version_info.major == 3 and sys.version_info.minor == 5:
-            self.is_python35 = True
-
-    def __call__(self, outs_dict, shape_list):
-        post = PGNet_PostProcess(self.character_dict_path, self.valid_set,
-                                 self.score_thresh, outs_dict, shape_list)
-        if self.mode == 'fast':
-            data = post.pg_postprocess_fast()
-        else:
-            data = post.pg_postprocess_slow()
-        return data

pyxlpr/ppocr/postprocess/pse_postprocess/__init__.py

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

pyxlpr/ppocr/postprocess/pse_postprocess/pse/__init__.py

@@ -1,29 +0,0 @@
-# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import sys
-import os
-import subprocess
-
-python_path = sys.executable
-
-ori_path = os.getcwd()
-os.chdir('ppocr/postprocess/pse_postprocess/pse')
-if subprocess.call(
-        '{} setup.py build_ext --inplace'.format(python_path), shell=True) != 0:
-    raise RuntimeError(
-        'Cannot compile pse: {}, if your system is windows, you need to install all the default components of `desktop development using C++` in visual studio 2019+'.
-        format(os.path.dirname(os.path.realpath(__file__))))
-os.chdir(ori_path)
-
-from .pse import pse

pyxlpr/ppocr/postprocess/pse_postprocess/pse/setup.py

@@ -1,14 +0,0 @@
-from distutils.core import setup, Extension
-from Cython.Build import cythonize
-import numpy
-
-setup(ext_modules=cythonize(Extension(
-    'pse',
-    sources=['pse.pyx'],
-    language='c++',
-    include_dirs=[numpy.get_include()],
-    library_dirs=[],
-    libraries=[],
-    extra_compile_args=['-O3'],
-    extra_link_args=[]
-)))

pyxlpr/ppocr/postprocess/pse_postprocess/pse_postprocess.py

@@ -1,118 +0,0 @@
-# copyright (c) 2021 PaddlePaddle Authors. All Rights Reserve.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""
-This code is refer from:
-https://github.com/whai362/PSENet/blob/python3/models/head/psenet_head.py
-"""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import numpy as np
-import cv2
-import paddle
-from paddle.nn import functional as F
-
-from pyxlpr.ppocr.postprocess.pse_postprocess.pse import pse
-
-
-class PSEPostProcess(object):
-    """
-    The post process for PSE.
-    """
-
-    def __init__(self,
-                 thresh=0.5,
-                 box_thresh=0.85,
-                 min_area=16,
-                 box_type='box',
-                 scale=4,
-                 **kwargs):
-        assert box_type in ['box', 'poly'], 'Only box and poly is supported'
-        self.thresh = thresh
-        self.box_thresh = box_thresh
-        self.min_area = min_area
-        self.box_type = box_type
-        self.scale = scale
-
-    def __call__(self, outs_dict, shape_list):
-        pred = outs_dict['maps']
-        if not isinstance(pred, paddle.Tensor):
-            pred = paddle.to_tensor(pred)
-        pred = F.interpolate(
-            pred, scale_factor=4 // self.scale, mode='bilinear')
-
-        score = F.sigmoid(pred[:, 0, :, :])
-
-        kernels = (pred > self.thresh).astype('float32')
-        text_mask = kernels[:, 0, :, :]
-        kernels[:, 0:, :, :] = kernels[:, 0:, :, :] * text_mask
-
-        score = score.numpy()
-        kernels = kernels.numpy().astype(np.uint8)
-
-        boxes_batch = []
-        for batch_index in range(pred.shape[0]):
-            boxes, scores = self.boxes_from_bitmap(score[batch_index],
-                                                   kernels[batch_index],
-                                                   shape_list[batch_index])
-
-            boxes_batch.append({'points': boxes, 'scores': scores})
-        return boxes_batch
-
-    def boxes_from_bitmap(self, score, kernels, shape):
-        label = pse(kernels, self.min_area)
-        return self.generate_box(score, label, shape)
-
-    def generate_box(self, score, label, shape):
-        src_h, src_w, ratio_h, ratio_w = shape
-        label_num = np.max(label) + 1
-
-        boxes = []
-        scores = []
-        for i in range(1, label_num):
-            ind = label == i
-            points = np.array(np.where(ind)).transpose((1, 0))[:, ::-1]
-
-            if points.shape[0] < self.min_area:
-                label[ind] = 0
-                continue
-
-            score_i = np.mean(score[ind])
-            if score_i < self.box_thresh:
-                label[ind] = 0
-                continue
-
-            if self.box_type == 'box':
-                rect = cv2.minAreaRect(points)
-                bbox = cv2.boxPoints(rect)
-            elif self.box_type == 'poly':
-                box_height = np.max(points[:, 1]) + 10
-                box_width = np.max(points[:, 0]) + 10
-
-                mask = np.zeros((box_height, box_width), np.uint8)
-                mask[points[:, 1], points[:, 0]] = 255
-
-                contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL,
-                                               cv2.CHAIN_APPROX_SIMPLE)
-                bbox = np.squeeze(contours[0], 1)
-            else:
-                raise NotImplementedError
-
-            bbox[:, 0] = np.clip(np.round(bbox[:, 0] / ratio_w), 0, src_w)
-            bbox[:, 1] = np.clip(np.round(bbox[:, 1] / ratio_h), 0, src_h)
-            boxes.append(bbox)
-            scores.append(score_i)
-        return boxes, scores