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

pyxlpr/ppocr/optimizer/regularizer.py

@@ -1,52 +0,0 @@
-# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
-
-import paddle
-
-
-class L1Decay(object):
-    """
-    L1 Weight Decay Regularization, which encourages the weights to be sparse.
-    Args:
-        factor(float): regularization coeff. Default:0.0.
-    """
-
-    def __init__(self, factor=0.0):
-        super(L1Decay, self).__init__()
-        self.regularization_coeff = factor
-
-    def __call__(self):
-        reg = paddle.regularizer.L1Decay(self.regularization_coeff)
-        return reg
-
-
-class L2Decay(object):
-    """
-    L2 Weight Decay Regularization, which encourages the weights to be sparse.
-    Args:
-        factor(float): regularization coeff. Default:0.0.
-    """
-
-    def __init__(self, factor=0.0):
-        super(L2Decay, self).__init__()
-        self.regularization_coeff = factor
-
-    def __call__(self):
-        reg = paddle.regularizer.L2Decay(self.regularization_coeff)
-        return reg

pyxlpr/ppocr/postprocess/__init__.py

@@ -1,55 +0,0 @@
-# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
-
-import copy
-
-__all__ = ['build_post_process']
-
-from .db_postprocess import DBPostProcess, DistillationDBPostProcess
-from .east_postprocess import EASTPostProcess
-from .sast_postprocess import SASTPostProcess
-from .rec_postprocess import CTCLabelDecode, AttnLabelDecode, SRNLabelDecode, DistillationCTCLabelDecode, \
-    TableLabelDecode, NRTRLabelDecode, SARLabelDecode, SEEDLabelDecode
-from .cls_postprocess import ClsPostProcess
-from .pg_postprocess import PGPostProcess
-
-
-def build_post_process(config, global_config=None):
-    support_dict = [
-        'DBPostProcess', 'EASTPostProcess', 'SASTPostProcess', 'CTCLabelDecode',
-        'AttnLabelDecode', 'ClsPostProcess', 'SRNLabelDecode', 'PGPostProcess',
-        'DistillationCTCLabelDecode', 'TableLabelDecode',
-        'DistillationDBPostProcess', 'NRTRLabelDecode', 'SARLabelDecode',
-        'SEEDLabelDecode'
-    ]
-
-    if config['name'] == 'PSEPostProcess':
-        from .pse_postprocess import PSEPostProcess
-        support_dict.append('PSEPostProcess')
-
-    config = copy.deepcopy(config)
-    module_name = config.pop('name')
-    if module_name == "None":
-        return
-    if global_config is not None:
-        config.update(global_config)
-    assert module_name in support_dict, Exception(
-        'post process only support {}'.format(support_dict))
-    module_class = eval(module_name)(**config)
-    return module_class

pyxlpr/ppocr/postprocess/cls_postprocess.py

@@ -1,33 +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 paddle
-
-
-class ClsPostProcess(object):
-    """ Convert between text-label and text-index """
-
-    def __init__(self, label_list, **kwargs):
-        super(ClsPostProcess, self).__init__()
-        self.label_list = label_list
-
-    def __call__(self, preds, label=None, *args, **kwargs):
-        if isinstance(preds, paddle.Tensor):
-            preds = preds.numpy()
-        pred_idxs = preds.argmax(axis=1)
-        decode_out = [(self.label_list[idx], preds[i, idx])
-                      for i, idx in enumerate(pred_idxs)]
-        if label is None:
-            return decode_out
-        label = [(self.label_list[idx], 1.0) for idx in label]
-        return decode_out, label

pyxlpr/ppocr/postprocess/db_postprocess.py

@@ -1,234 +0,0 @@
-# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""
-This code is refered from:
-https://github.com/WenmuZhou/DBNet.pytorch/blob/master/post_processing/seg_detector_representer.py
-"""
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import numpy as np
-import cv2
-import paddle
-from shapely.geometry import Polygon
-import pyclipper
-
-
-class DBPostProcess(object):
-    """
-    The post process for Differentiable Binarization (DB).
-    """
-
-    def __init__(self,
-                 thresh=0.3,
-                 box_thresh=0.7,
-                 max_candidates=1000,
-                 unclip_ratio=2.0,
-                 use_dilation=False,
-                 score_mode="fast",
-                 **kwargs):
-        """
-        :param thresh: 分割图进行二值化的阈值
-        :param box_thresh: 对输出框进行过滤的阈值，低于此阈值的框不会输出
-        :param max_candidates: 输出的最大文本框数量
-        :param unclip_ratio: 对文本框进行放大的比例
-        :param use_dilation:
-        :param score_mode:
-        :param kwargs:
-        """
-        # 1. 获取后处理超参数
-        self.thresh = thresh
-        self.box_thresh = box_thresh
-        self.max_candidates = max_candidates
-        self.unclip_ratio = unclip_ratio
-        self.min_size = 3
-        self.score_mode = score_mode
-        assert score_mode in [
-            "slow", "fast"
-        ], "Score mode must be in [slow, fast] but got: {}".format(score_mode)
-
-        self.dilation_kernel = None if not use_dilation else np.array(
-            [[1, 1], [1, 1]])
-
-    def boxes_from_bitmap(self, pred, _bitmap, dest_width, dest_height):
-        '''
-        _bitmap: single map with shape (1, H, W),
-                whose values are binarized as {0, 1}
-        '''
-
-        bitmap = _bitmap
-        height, width = bitmap.shape
-
-        outs = cv2.findContours((bitmap * 255).astype(np.uint8), cv2.RETR_LIST,
-                                cv2.CHAIN_APPROX_SIMPLE)
-        if len(outs) == 3:
-            img, contours, _ = outs[0], outs[1], outs[2]
-        elif len(outs) == 2:
-            contours, _ = outs[0], outs[1]
-
-        num_contours = min(len(contours), self.max_candidates)
-
-        boxes = []
-        scores = []
-        for index in range(num_contours):
-            contour = contours[index]
-            points, sside = self.get_mini_boxes(contour)
-            if sside < self.min_size:
-                continue
-            points = np.array(points)
-            if self.score_mode == "fast":
-                score = self.box_score_fast(pred, points.reshape(-1, 2))
-            else:
-                score = self.box_score_slow(pred, contour)
-            if self.box_thresh > score:
-                continue
-
-            box = self.unclip(points).reshape(-1, 1, 2)
-            box, sside = self.get_mini_boxes(box)
-            if sside < self.min_size + 2:
-                continue
-            box = np.array(box)
-
-            box[:, 0] = np.clip(
-                np.round(box[:, 0] / width * dest_width), 0, dest_width)
-            box[:, 1] = np.clip(
-                np.round(box[:, 1] / height * dest_height), 0, dest_height)
-            boxes.append(box.astype(np.int16))
-            scores.append(score)
-        return np.array(boxes, dtype=np.int16), scores
-
-    def unclip(self, box):
-        unclip_ratio = self.unclip_ratio
-        poly = Polygon(box)
-        distance = poly.area * unclip_ratio / poly.length
-        offset = pyclipper.PyclipperOffset()
-        offset.AddPath(box, pyclipper.JT_ROUND, pyclipper.ET_CLOSEDPOLYGON)
-        expanded = np.array(offset.Execute(distance))
-        return expanded
-
-    def get_mini_boxes(self, contour):
-        bounding_box = cv2.minAreaRect(contour)
-        points = sorted(list(cv2.boxPoints(bounding_box)), key=lambda x: x[0])
-
-        index_1, index_2, index_3, index_4 = 0, 1, 2, 3
-        if points[1][1] > points[0][1]:
-            index_1 = 0
-            index_4 = 1
-        else:
-            index_1 = 1
-            index_4 = 0
-        if points[3][1] > points[2][1]:
-            index_2 = 2
-            index_3 = 3
-        else:
-            index_2 = 3
-            index_3 = 2
-
-        box = [
-            points[index_1], points[index_2], points[index_3], points[index_4]
-        ]
-        return box, min(bounding_box[1])
-
-    def box_score_fast(self, bitmap, _box):
-        '''
-        box_score_fast: use bbox mean score as the mean score
-        '''
-        h, w = bitmap.shape[:2]
-        box = _box.copy()
-        xmin = np.clip(np.floor(box[:, 0].min()).astype(np.int), 0, w - 1)
-        xmax = np.clip(np.ceil(box[:, 0].max()).astype(np.int), 0, w - 1)
-        ymin = np.clip(np.floor(box[:, 1].min()).astype(np.int), 0, h - 1)
-        ymax = np.clip(np.ceil(box[:, 1].max()).astype(np.int), 0, h - 1)
-
-        mask = np.zeros((ymax - ymin + 1, xmax - xmin + 1), dtype=np.uint8)
-        box[:, 0] = box[:, 0] - xmin
-        box[:, 1] = box[:, 1] - ymin
-        cv2.fillPoly(mask, box.reshape(1, -1, 2).astype(np.int32), 1)
-        return cv2.mean(bitmap[ymin:ymax + 1, xmin:xmax + 1], mask)[0]
-
-    def box_score_slow(self, bitmap, contour):
-        '''
-        box_score_slow: use polyon mean score as the mean score
-        '''
-        h, w = bitmap.shape[:2]
-        contour = contour.copy()
-        contour = np.reshape(contour, (-1, 2))
-
-        xmin = np.clip(np.min(contour[:, 0]), 0, w - 1)
-        xmax = np.clip(np.max(contour[:, 0]), 0, w - 1)
-        ymin = np.clip(np.min(contour[:, 1]), 0, h - 1)
-        ymax = np.clip(np.max(contour[:, 1]), 0, h - 1)
-
-        mask = np.zeros((ymax - ymin + 1, xmax - xmin + 1), dtype=np.uint8)
-
-        contour[:, 0] = contour[:, 0] - xmin
-        contour[:, 1] = contour[:, 1] - ymin
-
-        cv2.fillPoly(mask, contour.reshape(1, -1, 2).astype(np.int32), 1)
-        return cv2.mean(bitmap[ymin:ymax + 1, xmin:xmax + 1], mask)[0]
-
-    def __call__(self, outs_dict, shape_list):
-        # 1. 从字典中获取网络预测结果
-        pred = outs_dict['maps']
-        if isinstance(pred, paddle.Tensor):
-            pred = pred.numpy()
-        pred = pred[:, 0, :, :]
-        # 2. 大于后处理参数阈值self.thresh的
-        segmentation = pred > self.thresh
-
-        boxes_batch = []
-        for batch_index in range(pred.shape[0]):
-            # 3. 获取原图的形状和resize比例
-            src_h, src_w, ratio_h, ratio_w = shape_list[batch_index]
-            if self.dilation_kernel is not None:
-                mask = cv2.dilate(
-                    np.array(segmentation[batch_index]).astype(np.uint8),
-                    self.dilation_kernel)
-            else:
-                mask = segmentation[batch_index]
-            # 4. 使用boxes_from_bitmap函数 完成 从预测的文本概率图中计算得到文本框
-            boxes, scores = self.boxes_from_bitmap(pred[batch_index], mask,
-                                                   src_w, src_h)
-
-            boxes_batch.append({'points': boxes})
-        return boxes_batch
-
-
-class DistillationDBPostProcess(object):
-    def __init__(self,
-                 model_name=["student"],
-                 key=None,
-                 thresh=0.3,
-                 box_thresh=0.6,
-                 max_candidates=1000,
-                 unclip_ratio=1.5,
-                 use_dilation=False,
-                 score_mode="fast",
-                 **kwargs):
-        self.model_name = model_name
-        self.key = key
-        self.post_process = DBPostProcess(
-            thresh=thresh,
-            box_thresh=box_thresh,
-            max_candidates=max_candidates,
-            unclip_ratio=unclip_ratio,
-            use_dilation=use_dilation,
-            score_mode=score_mode)
-
-    def __call__(self, predicts, shape_list):
-        results = {}
-        for k in self.model_name:
-            results[k] = self.post_process(predicts[k], shape_list=shape_list)
-        return results

pyxlpr/ppocr/postprocess/east_postprocess.py

@@ -1,143 +0,0 @@
-# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import numpy as np
-from .locality_aware_nms import nms_locality
-import cv2
-import paddle
-
-import os
-import sys
-
-
-class EASTPostProcess(object):
-    """
-    The post process for EAST.
-    """
-
-    def __init__(self,
-                 score_thresh=0.8,
-                 cover_thresh=0.1,
-                 nms_thresh=0.2,
-                 **kwargs):
-
-        self.score_thresh = score_thresh
-        self.cover_thresh = cover_thresh
-        self.nms_thresh = nms_thresh
-
-    def restore_rectangle_quad(self, origin, geometry):
-        """
-        Restore rectangle from quadrangle.
-        """
-        # quad
-        origin_concat = np.concatenate(
-            (origin, origin, origin, origin), axis=1)  # (n, 8)
-        pred_quads = origin_concat - geometry
-        pred_quads = pred_quads.reshape((-1, 4, 2))  # (n, 4, 2)
-        return pred_quads
-
-    def detect(self,
-               score_map,
-               geo_map,
-               score_thresh=0.8,
-               cover_thresh=0.1,
-               nms_thresh=0.2):
-        """
-        restore text boxes from score map and geo map
-        """
-
-        score_map = score_map[0]
-        geo_map = np.swapaxes(geo_map, 1, 0)
-        geo_map = np.swapaxes(geo_map, 1, 2)
-        # filter the score map
-        xy_text = np.argwhere(score_map > score_thresh)
-        if len(xy_text) == 0:
-            return []
-        # sort the text boxes via the y axis
-        xy_text = xy_text[np.argsort(xy_text[:, 0])]
-        #restore quad proposals
-        text_box_restored = self.restore_rectangle_quad(
-            xy_text[:, ::-1] * 4, geo_map[xy_text[:, 0], xy_text[:, 1], :])
-        boxes = np.zeros((text_box_restored.shape[0], 9), dtype=np.float32)
-        boxes[:, :8] = text_box_restored.reshape((-1, 8))
-        boxes[:, 8] = score_map[xy_text[:, 0], xy_text[:, 1]]
-
-        try:
-            import lanms
-            boxes = lanms.merge_quadrangle_n9(boxes, nms_thresh)
-        except:
-            print(
-                'you should install lanms by pip3 install lanms-nova to speed up nms_locality'
-            )
-            boxes = nms_locality(boxes.astype(np.float64), nms_thresh)
-        if boxes.shape[0] == 0:
-            return []
-        # Here we filter some low score boxes by the average score map, 
-        #   this is different from the orginal paper.
-        for i, box in enumerate(boxes):
-            mask = np.zeros_like(score_map, dtype=np.uint8)
-            cv2.fillPoly(mask, box[:8].reshape(
-                (-1, 4, 2)).astype(np.int32) // 4, 1)
-            boxes[i, 8] = cv2.mean(score_map, mask)[0]
-        boxes = boxes[boxes[:, 8] > cover_thresh]
-        return boxes
-
-    def sort_poly(self, p):
-        """
-        Sort polygons.
-        """
-        min_axis = np.argmin(np.sum(p, axis=1))
-        p = p[[min_axis, (min_axis + 1) % 4,\
-            (min_axis + 2) % 4, (min_axis + 3) % 4]]
-        if abs(p[0, 0] - p[1, 0]) > abs(p[0, 1] - p[1, 1]):
-            return p
-        else:
-            return p[[0, 3, 2, 1]]
-
-    def __call__(self, outs_dict, shape_list):
-        score_list = outs_dict['f_score']
-        geo_list = outs_dict['f_geo']
-        if isinstance(score_list, paddle.Tensor):
-            score_list = score_list.numpy()
-            geo_list = geo_list.numpy()
-        img_num = len(shape_list)
-        dt_boxes_list = []
-        for ino in range(img_num):
-            score = score_list[ino]
-            geo = geo_list[ino]
-            boxes = self.detect(
-                score_map=score,
-                geo_map=geo,
-                score_thresh=self.score_thresh,
-                cover_thresh=self.cover_thresh,
-                nms_thresh=self.nms_thresh)
-            boxes_norm = []
-            if len(boxes) > 0:
-                h, w = score.shape[1:]
-                src_h, src_w, ratio_h, ratio_w = shape_list[ino]
-                boxes = boxes[:, :8].reshape((-1, 4, 2))
-                boxes[:, :, 0] /= ratio_w
-                boxes[:, :, 1] /= ratio_h
-                for i_box, box in enumerate(boxes):
-                    box = self.sort_poly(box.astype(np.int32))
-                    if np.linalg.norm(box[0] - box[1]) < 5 \
-                        or np.linalg.norm(box[3] - box[0]) < 5:
-                        continue
-                    boxes_norm.append(box)
-            dt_boxes_list.append({'points': np.array(boxes_norm)})
-        return dt_boxes_list