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

pyxlpr/ppocr/data/imaug/make_border_map.py

@@ -1,184 +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.
-"""
-This code is refer from:
-https://github.com/WenmuZhou/DBNet.pytorch/blob/master/data_loader/modules/make_border_map.py
-"""
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
-
-import numpy as np
-import cv2
-
-np.seterr(divide='ignore', invalid='ignore')
-import pyclipper
-from shapely.geometry import Polygon
-import sys
-import warnings
-
-warnings.simplefilter("ignore")
-
-__all__ = ['MakeBorderMap']
-
-
-class MakeBorderMap(object):
-    """ 计算文本区域阈值图标签类
-
-    ppocr db模型代码阅读理解_垚1234的博客-CSDN博客:
-    https://blog.csdn.net/weixin_41393000/article/details/118740663
-    """
-    def __init__(self,
-                 shrink_ratio=0.4,
-                 thresh_min=0.3,
-                 thresh_max=0.7,
-                 **kwargs):
-        self.shrink_ratio = shrink_ratio
-        self.thresh_min = thresh_min
-        self.thresh_max = thresh_max
-
-    def __call__(self, data):
-        img = data['image']
-        text_polys = data['polys']
-        ignore_tags = data['ignore_tags']
-
-        # 1. 生成空模版
-        canvas = np.zeros(img.shape[:2], dtype=np.float32)
-        mask = np.zeros(img.shape[:2], dtype=np.float32)
-
-        for i in range(len(text_polys)):
-            if ignore_tags[i]:
-                continue
-
-            # 2. draw_border_map函数根据解码后的box信息计算阈值图标签
-            self.draw_border_map(text_polys[i], canvas, mask=mask)
-        canvas = canvas * (self.thresh_max - self.thresh_min) + self.thresh_min
-
-        data['threshold_map'] = canvas
-        data['threshold_mask'] = mask
-
-        # from pyxllib.ai.paddlelib import show_feature_map
-        # show_feature_map([[data['image'][:,:,0].astype('float32') / 255, canvas, mask]])
-        return data
-
-    def draw_border_map(self, polygon, canvas, mask):
-        polygon = np.array(polygon)
-        assert polygon.ndim == 2
-        assert polygon.shape[1] == 2
-
-        polygon_shape = Polygon(polygon)
-        if polygon_shape.area <= 0:
-            return
-        # 多边形内缩
-        distance = polygon_shape.area * (
-            1 - np.power(self.shrink_ratio, 2)) / polygon_shape.length
-        subject = [tuple(l) for l in polygon]
-        padding = pyclipper.PyclipperOffset()
-        padding.AddPath(subject, pyclipper.JT_ROUND, pyclipper.ET_CLOSEDPOLYGON)
-        # 计算mask
-        padded_polygon = np.array(padding.Execute(distance)[0])
-        cv2.fillPoly(mask, [padded_polygon.astype(np.int32)], 1.0)
-
-        xmin = padded_polygon[:, 0].min()
-        xmax = padded_polygon[:, 0].max()
-        ymin = padded_polygon[:, 1].min()
-        ymax = padded_polygon[:, 1].max()
-        width = xmax - xmin + 1
-        height = ymax - ymin + 1
-
-        polygon[:, 0] = polygon[:, 0] - xmin
-        polygon[:, 1] = polygon[:, 1] - ymin
-
-        xs = np.broadcast_to(
-            np.linspace(
-                0, width - 1, num=width).reshape(1, width), (height, width))
-        ys = np.broadcast_to(
-            np.linspace(
-                0, height - 1, num=height).reshape(height, 1), (height, width))
-
-        distance_map = np.zeros(
-            (polygon.shape[0], height, width), dtype=np.float32)
-        for i in range(polygon.shape[0]):
-            j = (i + 1) % polygon.shape[0]
-            # 计算点到线的距离
-            absolute_distance = self._distance(xs, ys, polygon[i], polygon[j])
-            distance_map[i] = np.clip(absolute_distance / distance, 0, 1)
-        distance_map = distance_map.min(axis=0)
-
-        xmin_valid = min(max(0, xmin), canvas.shape[1] - 1)
-        xmax_valid = min(max(0, xmax), canvas.shape[1] - 1)
-        ymin_valid = min(max(0, ymin), canvas.shape[0] - 1)
-        ymax_valid = min(max(0, ymax), canvas.shape[0] - 1)
-        canvas[ymin_valid:ymax_valid + 1, xmin_valid:xmax_valid + 1] = np.fmax(
-            1 - distance_map[ymin_valid - ymin:ymax_valid - ymax + height,
-                             xmin_valid - xmin:xmax_valid - xmax + width],
-            canvas[ymin_valid:ymax_valid + 1, xmin_valid:xmax_valid + 1])
-
-    def _distance(self, xs, ys, point_1, point_2):
-        '''
-        compute the distance from point to a line
-        ys: coordinates in the first axis
-        xs: coordinates in the second axis
-        point_1, point_2: (x, y), the end of the line
-        '''
-        height, width = xs.shape[:2]
-        square_distance_1 = np.square(xs - point_1[0]) + np.square(ys - point_1[
-            1])
-        square_distance_2 = np.square(xs - point_2[0]) + np.square(ys - point_2[
-            1])
-        square_distance = np.square(point_1[0] - point_2[0]) + np.square(
-            point_1[1] - point_2[1])
-
-        cosin = (square_distance - square_distance_1 - square_distance_2) / (
-            2 * np.sqrt(square_distance_1 * square_distance_2))
-        square_sin = 1 - np.square(cosin)
-        square_sin = np.nan_to_num(square_sin)
-        result = np.sqrt(square_distance_1 * square_distance_2 * square_sin /
-                         square_distance)
-
-        result[cosin <
-               0] = np.sqrt(np.fmin(square_distance_1, square_distance_2))[cosin
-                                                                           < 0]
-        # self.extend_line(point_1, point_2, result)
-        return result
-
-    def extend_line(self, point_1, point_2, result, shrink_ratio):
-        ex_point_1 = (int(
-            round(point_1[0] + (point_1[0] - point_2[0]) * (1 + shrink_ratio))),
-                      int(
-                          round(point_1[1] + (point_1[1] - point_2[1]) * (
-                              1 + shrink_ratio))))
-        cv2.line(
-            result,
-            tuple(ex_point_1),
-            tuple(point_1),
-            4096.0,
-            1,
-            lineType=cv2.LINE_AA,
-            shift=0)
-        ex_point_2 = (int(
-            round(point_2[0] + (point_2[0] - point_1[0]) * (1 + shrink_ratio))),
-                      int(
-                          round(point_2[1] + (point_2[1] - point_1[1]) * (
-                              1 + shrink_ratio))))
-        cv2.line(
-            result,
-            tuple(ex_point_2),
-            tuple(point_2),
-            4096.0,
-            1,
-            lineType=cv2.LINE_AA,
-            shift=0)
-        return ex_point_1, ex_point_2

pyxlpr/ppocr/data/imaug/make_pse_gt.py

@@ -1,106 +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.
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
-
-import cv2
-import numpy as np
-import pyclipper
-from shapely.geometry import Polygon
-
-__all__ = ['MakePseGt']
-
-
-class MakePseGt(object):
-    def __init__(self, kernel_num=7, size=640, min_shrink_ratio=0.4, **kwargs):
-        self.kernel_num = kernel_num
-        self.min_shrink_ratio = min_shrink_ratio
-        self.size = size
-
-    def __call__(self, data):
-
-        image = data['image']
-        text_polys = data['polys']
-        ignore_tags = data['ignore_tags']
-
-        h, w, _ = image.shape
-        short_edge = min(h, w)
-        if short_edge < self.size:
-            # keep short_size >= self.size
-            scale = self.size / short_edge
-            image = cv2.resize(image, dsize=None, fx=scale, fy=scale)
-            text_polys *= scale
-
-        gt_kernels = []
-        for i in range(1, self.kernel_num + 1):
-            # s1->sn, from big to small
-            rate = 1.0 - (1.0 - self.min_shrink_ratio) / (self.kernel_num - 1
-                                                          ) * i
-            text_kernel, ignore_tags = self.generate_kernel(
-                image.shape[0:2], rate, text_polys, ignore_tags)
-            gt_kernels.append(text_kernel)
-
-        training_mask = np.ones(image.shape[0:2], dtype='uint8')
-        for i in range(text_polys.shape[0]):
-            if ignore_tags[i]:
-                cv2.fillPoly(training_mask,
-                             text_polys[i].astype(np.int32)[np.newaxis, :, :],
-                             0)
-
-        gt_kernels = np.array(gt_kernels)
-        gt_kernels[gt_kernels > 0] = 1
-
-        data['image'] = image
-        data['polys'] = text_polys
-        data['gt_kernels'] = gt_kernels[0:]
-        data['gt_text'] = gt_kernels[0]
-        data['mask'] = training_mask.astype('float32')
-        return data
-
-    def generate_kernel(self,
-                        img_size,
-                        shrink_ratio,
-                        text_polys,
-                        ignore_tags=None):
-        """
-        Refer to part of the code:
-        https://github.com/open-mmlab/mmocr/blob/main/mmocr/datasets/pipelines/textdet_targets/base_textdet_targets.py
-        """
-
-        h, w = img_size
-        text_kernel = np.zeros((h, w), dtype=np.float32)
-        for i, poly in enumerate(text_polys):
-            polygon = Polygon(poly)
-            distance = polygon.area * (1 - shrink_ratio * shrink_ratio) / (
-                polygon.length + 1e-6)
-            subject = [tuple(l) for l in poly]
-            pco = pyclipper.PyclipperOffset()
-            pco.AddPath(subject, pyclipper.JT_ROUND, pyclipper.ET_CLOSEDPOLYGON)
-            shrinked = np.array(pco.Execute(-distance))
-
-            if len(shrinked) == 0 or shrinked.size == 0:
-                if ignore_tags is not None:
-                    ignore_tags[i] = True
-                continue
-            try:
-                shrinked = np.array(shrinked[0]).reshape(-1, 2)
-            except:
-                if ignore_tags is not None:
-                    ignore_tags[i] = True
-                continue
-            cv2.fillPoly(text_kernel, [shrinked.astype(np.int32)], i + 1)
-        return text_kernel, ignore_tags

pyxlpr/ppocr/data/imaug/make_shrink_map.py

@@ -1,126 +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.
-"""
-This code is refer from:
-https://github.com/WenmuZhou/DBNet.pytorch/blob/master/data_loader/modules/make_shrink_map.py
-"""
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
-
-import numpy as np
-import cv2
-from shapely.geometry import Polygon
-import pyclipper
-
-__all__ = ['MakeShrinkMap']
-
-
-class MakeShrinkMap(object):
-    r'''
-    Making binary mask from detection data with ICDAR format.
-    Typically following the process of class `MakeICDARData`.
-    '''
-
-    def __init__(self, min_text_size=8, shrink_ratio=0.4, **kwargs):
-        self.min_text_size = min_text_size
-        self.shrink_ratio = shrink_ratio
-
-    def __call__(self, data):
-        image = data['image']
-        text_polys = data['polys']
-        ignore_tags = data['ignore_tags']
-
-        h, w = image.shape[:2]
-        # 1 校验文本检测标签
-        text_polys, ignore_tags = self.validate_polygons(text_polys,
-                                                         ignore_tags, h, w)
-        gt = np.zeros((h, w), dtype=np.float32)
-        mask = np.ones((h, w), dtype=np.float32)
-        # 2 根据文本检测框计算文本区域概率图
-        for i in range(len(text_polys)):
-            polygon = text_polys[i]
-            height = max(polygon[:, 1]) - min(polygon[:, 1])
-            width = max(polygon[:, 0]) - min(polygon[:, 0])
-            if ignore_tags[i] or min(height, width) < self.min_text_size:
-                cv2.fillPoly(mask,
-                             polygon.astype(np.int32)[np.newaxis, :, :], 0)
-                ignore_tags[i] = True
-            else:
-                # 多边形内缩
-                polygon_shape = Polygon(polygon)
-                subject = [tuple(l) for l in polygon]
-                padding = pyclipper.PyclipperOffset()
-                padding.AddPath(subject, pyclipper.JT_ROUND,
-                                pyclipper.ET_CLOSEDPOLYGON)
-                shrinked = []
-
-                # Increase the shrink ratio every time we get multiple polygon returned back
-                possible_ratios = np.arange(self.shrink_ratio, 1,
-                                            self.shrink_ratio)
-                np.append(possible_ratios, 1)
-                # print(possible_ratios)
-                for ratio in possible_ratios:
-                    # print(f"Change shrink ratio to {ratio}")
-                    distance = polygon_shape.area * (
-                        1 - np.power(ratio, 2)) / polygon_shape.length
-                    shrinked = padding.Execute(-distance)
-                    if len(shrinked) == 1:
-                        break
-
-                if shrinked == []:
-                    cv2.fillPoly(mask,
-                                 polygon.astype(np.int32)[np.newaxis, :, :], 0)
-                    ignore_tags[i] = True
-                    continue
-
-                # 填充
-                for each_shirnk in shrinked:
-                    shirnk = np.array(each_shirnk).reshape(-1, 2)
-                    cv2.fillPoly(gt, [shirnk.astype(np.int32)], 1)
-
-        data['shrink_map'] = gt
-        data['shrink_mask'] = mask
-        return data
-
-    def validate_polygons(self, polygons, ignore_tags, h, w):
-        '''
-        polygons (numpy.array, required): of shape (num_instances, num_points, 2)
-        '''
-        if len(polygons) == 0:
-            return polygons, ignore_tags
-        assert len(polygons) == len(ignore_tags)
-        for polygon in polygons:
-            polygon[:, 0] = np.clip(polygon[:, 0], 0, w - 1)
-            polygon[:, 1] = np.clip(polygon[:, 1], 0, h - 1)
-
-        for i in range(len(polygons)):
-            area = self.polygon_area(polygons[i])
-            if abs(area) < 1:
-                ignore_tags[i] = True
-            if area > 0:
-                polygons[i] = polygons[i][::-1, :]
-        return polygons, ignore_tags
-
-    def polygon_area(self, polygon):
-        """
-        compute polygon area
-        """
-        area = 0
-        q = polygon[-1]
-        for p in polygon:
-            area += p[0] * q[1] - p[1] * q[0]
-            q = p
-        return area / 2.0