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

pyxlpr/data/icdar/__init__.py

@@ -1,96 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# @Author : 陈坤泽
-# @Email  : 877362867@qq.com
-# @Date   : 2021/02/22 10:29
-
-""" 对icdar2013的三种测评方法的接口封装
-
-官方原版处理两个 zip 文件，这里扩展支持目录、内存对象
-"""
-
-import re
-
-from pyxllib.xl import XlPath, Dir, shorten
-
-
-class IcdarEval:
-    """
-    >>> gt = {'1.abc': [[158, 128, 411, 181], [443, 128, 450, 169]], '2': [[176, 189, 456, 274]]}
-    >>> dt = {'1.abc': [[158, 128, 411, 185], [443, 120, 450, 169]]}
-    >>> ie = IcdarEval(gt, dt)  # 除了内存格式，也兼容原来的zip文件、目录初始化方法
-    >>> ie.icdar2013()
-    {'precision': 1.0, 'recall': 0.6667, 'hmean': 0.8}
-    >>> ie.deteval()
-    {'precision': 1.0, 'recall': 0.6667, 'hmean': 0.8}
-    >>> ie.iou()
-    {'precision': 1.0, 'recall': 0.6667, 'hmean': 0.8, 'AP': 0}
-    """
-
-    def __init__(self, gt, dt):
-        """ 输入gt和dt文件
-
-        官方原版是支持 【zip文件】，必须要遵循官方原版所有的规则
-            压缩包里的文件名格式为： gt_img_1.txt， res_img_1.txt
-        我这里扩展，也支持输入 【目录】，注意这种操作格式，除了文件名也要完全遵守官方的规则
-            这里文件名降低要求，只匹配出第一个出现的数值
-        还扩展了内存操作方式，这个格式比官方简洁，不需要遵循官方琐碎的规则，只需要
-            gt是一个dict
-                key写图片名或id编号都可以
-                value写若干个定位框，例如 [[xmin1, ymin1, xmax1, ymax1], [xmin2, ymin2, xmax2, ymax2], ...]
-            dt同gt，注意key要对应
-
-        icdar系列指标，原本是用于文本检测效果的评测，也可以扩展应用到一般性的检测任务
-            icdar只考虑单类，不考虑多类别问题，如果要加入类别问题，可以修改key达到更精细的分组效果
-
-        附，官方原版格式说明
-            {'1': b'38,43,...', '2':, b'...', ...}
-            key是图片编号1,2,3...233，其实改成其他各种key也行，就是一个分组概念
-            value是匹配效果，使用bytes格式，用\r\n作为换行符分开每个检测框
-                对gt而言，存储x1,y1,x2,y2,label，最后必须要有个label值
-                对dt而言，存储x1,y1,x2,y2
-        因为我这里底层做了扩展，所以从IcdarEval入口调用的测评，都是转成了我新的字典数据结构来预测的
-        """
-        self.gt = self.init_label(gt)
-        self.dt = self.init_label(dt)
-
-    @classmethod
-    def init_label(cls, label):
-        if isinstance(label, dict):
-            # 如果是字典，信任其是按照官方格式来标注的
-            # {'16000,1': b'566,227,673,261,0\n682,210,945,260,0', '16001,1': ...
-            return label
-        elif isinstance(label, (str, XlPath)) and str(label)[-4:].lower() == '.zip':
-            # 官方原版的 zip 文件初始化方法
-            return label
-        elif Dir.safe_init(label):
-            # 输入是目录，则按照数字编号大小顺序依次读数数据
-            d = Dir(label)
-            res = dict()
-            for f in d.select_files('*.txt'):
-                k = re.search(r'\d+', f.stem).group()
-                res[k] = f.read(mode='b')
-            return res
-        else:
-            raise TypeError(shorten(label))
-
-    def _eval(self, evaluate_method, default_evaluation_params, update_params):
-        eval_params = default_evaluation_params()
-        if update_params:
-            eval_params.update(update_params)
-        eval_data = evaluate_method(self.gt, self.dt, eval_params)
-        # eval_data字典还存有'per_sample'的每张图片详细数据
-        res = {k: round(v, 4) for k, v in eval_data['method'].items()}  # 只保留4位小数，看起来比较舒服
-        return res
-
-    def icdar2013(self, params=None):
-        from pyxlpr.data.icdar.icdar2013 import evaluate_method, default_evaluation_params
-        return self._eval(evaluate_method, default_evaluation_params, params)
-
-    def deteval(self, params=None):
-        from pyxlpr.data.icdar.deteval import evaluate_method, default_evaluation_params
-        return self._eval(evaluate_method, default_evaluation_params, params)
-
-    def iou(self, params=None):
-        from pyxlpr.data.icdar.iou import evaluate_method, default_evaluation_params
-        return self._eval(evaluate_method, default_evaluation_params, params)

pyxlpr/data/icdar/deteval.py

@@ -1,377 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-#File: TL2p_deteval_1_1.py
-#Version: 1.1
-#Version info: changes for Python 3
-#Date: 2019-12-29
-#Description: Evaluation script that computes Text Localization following the Deteval implementation
-
-from collections import namedtuple
-import pyxlpr.data.icdar.rrc_evaluation_funcs_1_1 as rrc_evaluation_funcs
-import importlib
-
-def evaluation_imports():
-    """
-    evaluation_imports: Dictionary ( key = module name , value = alias  )  with python modules used in the evaluation. 
-    """
-    return {
-            'math':'math',
-            'numpy':'np'
-            }
-
-def default_evaluation_params():
-    """
-    default_evaluation_params: Default parameters to use for the validation and evaluation.
-    """
-    return {
-                'AREA_RECALL_CONSTRAINT' : 0.8,
-                'AREA_PRECISION_CONSTRAINT' : 0.4,
-                'EV_PARAM_IND_CENTER_DIFF_THR': 1,
-                'MTYPE_OO_O':1.,
-                'MTYPE_OM_O':0.8,
-                'MTYPE_OM_M':1.,
-                'GT_SAMPLE_NAME_2_ID':'gt_img_([0-9]+).txt',
-                'DET_SAMPLE_NAME_2_ID':'res_img_([0-9]+).txt',
-                'CRLF':False # Lines are delimited by Windows CRLF format
-            }
-
-def validate_data(gtFilePath, submFilePath,evaluationParams):
-    """
-    Method validate_data: validates that all files in the results folder are correct (have the correct name contents).
-                            Validates also that there are no missing files in the folder.
-                            If some error detected, the method raises the error
-    """
-    gt = rrc_evaluation_funcs.load_zip_file(gtFilePath, evaluationParams['GT_SAMPLE_NAME_2_ID'])
-
-    subm = rrc_evaluation_funcs.load_zip_file(submFilePath, evaluationParams['DET_SAMPLE_NAME_2_ID'], True)
-
-    #Validate format of GroundTruth
-    for k in gt:
-        rrc_evaluation_funcs.validate_lines_in_file(k,gt[k],evaluationParams['CRLF'],True,True)
-
-    #Validate format of results
-    for k in subm:
-        if (k in gt) == False :
-            raise Exception("The sample %s not present in GT" %k)
-
-        rrc_evaluation_funcs.validate_lines_in_file(k,subm[k],evaluationParams['CRLF'],True,False)
-
-
-def evaluate_method(gtFilePath, submFilePath, evaluationParams):
-    """
-    Method evaluate_method: evaluate method and returns the results
-        Results. Dictionary with the following values:
-        - method (required)  Global method metrics. Ex: { 'Precision':0.8,'Recall':0.9 }
-        - samples (optional) Per sample metrics. Ex: {'sample1' : { 'Precision':0.8,'Recall':0.9 } , 'sample2' : { 'Precision':0.8,'Recall':0.9 }
-    """
-
-    for module,alias in evaluation_imports().items():
-        globals()[alias] = importlib.import_module(module)
-
-    def one_to_one_match(row, col):
-        cont = 0
-        for j in range(len(recallMat[0])):
-            if recallMat[row,j] >= evaluationParams['AREA_RECALL_CONSTRAINT'] and precisionMat[row,j] >= evaluationParams['AREA_PRECISION_CONSTRAINT'] :
-                cont = cont +1
-        if (cont != 1):
-            return False
-        cont = 0
-        for i in range(len(recallMat)):
-            if recallMat[i,col] >= evaluationParams['AREA_RECALL_CONSTRAINT'] and precisionMat[i,col] >= evaluationParams['AREA_PRECISION_CONSTRAINT'] :
-                cont = cont +1
-        if (cont != 1):
-            return False
-
-        if recallMat[row,col] >= evaluationParams['AREA_RECALL_CONSTRAINT'] and precisionMat[row,col] >= evaluationParams['AREA_PRECISION_CONSTRAINT'] :
-            return True
-        return False
-
-    def num_overlaps_gt(gtNum):
-        cont = 0
-        for detNum in range(len(detRects)):
-            if detNum not in detDontCareRectsNum:
-                if recallMat[gtNum,detNum] > 0 :
-                    cont = cont +1
-        return cont
-
-    def num_overlaps_det(detNum):
-        cont = 0
-        for gtNum in range(len(recallMat)):
-            if gtNum not in gtDontCareRectsNum:
-                if recallMat[gtNum,detNum] > 0 :
-                    cont = cont +1
-        return cont
-
-    def is_single_overlap(row, col):
-        if num_overlaps_gt(row)==1 and num_overlaps_det(col)==1:
-            return True
-        else:
-            return False
-
-    def one_to_many_match(gtNum):
-        many_sum = 0
-        detRects = []
-        for detNum in range(len(recallMat[0])):
-            if gtRectMat[gtNum] == 0 and detRectMat[detNum] == 0 and detNum not in detDontCareRectsNum:
-                if precisionMat[gtNum,detNum] >= evaluationParams['AREA_PRECISION_CONSTRAINT'] :
-                    many_sum += recallMat[gtNum,detNum]
-                    detRects.append(detNum)
-        if round(many_sum,4) >=evaluationParams['AREA_RECALL_CONSTRAINT'] :
-            return True,detRects
-        else:
-            return False,[]
-
-    def many_to_one_match(detNum):
-        many_sum = 0
-        gtRects = []
-        for gtNum in range(len(recallMat)):
-            if gtRectMat[gtNum] == 0 and detRectMat[detNum] == 0 and gtNum not in gtDontCareRectsNum:
-                if recallMat[gtNum,detNum] >= evaluationParams['AREA_RECALL_CONSTRAINT'] :
-                    many_sum += precisionMat[gtNum,detNum]
-                    gtRects.append(gtNum)
-        if round(many_sum,4) >=evaluationParams['AREA_PRECISION_CONSTRAINT'] :
-            return True,gtRects
-        else:
-            return False,[]
-
-    def area(a, b):
-            dx = min(a.xmax, b.xmax) - max(a.xmin, b.xmin) + 1
-            dy = min(a.ymax, b.ymax) - max(a.ymin, b.ymin) + 1
-            if (dx>=0) and (dy>=0):
-                    return dx*dy
-            else:
-                    return 0.
-
-    def center(r):
-        x = float(r.xmin) + float(r.xmax - r.xmin + 1) / 2.;
-        y = float(r.ymin) + float(r.ymax - r.ymin + 1) / 2.;
-        return Point(x,y)
-
-    def point_distance(r1, r2):
-        distx = math.fabs(r1.x - r2.x)
-        disty = math.fabs(r1.y - r2.y)
-        return math.sqrt(distx * distx + disty * disty )
-
-
-    def center_distance(r1, r2):
-        return point_distance(center(r1), center(r2))
-
-    def diag(r):
-        w = (r.xmax - r.xmin + 1)
-        h = (r.ymax - r.ymin + 1)
-        return math.sqrt(h * h + w * w)
-
-    def rectangle_to_points(rect):
-        points = [int(rect.xmin), int(rect.ymax), int(rect.xmax), int(rect.ymax), int(rect.xmax), int(rect.ymin), int(rect.xmin), int(rect.ymin)]
-        return points
-
-    perSampleMetrics = {}
-
-    methodRecallSum = 0
-    methodPrecisionSum = 0
-
-    Rectangle = namedtuple('Rectangle', 'xmin ymin xmax ymax')
-    Point = namedtuple('Point', 'x y')
-
-    if isinstance(gtFilePath, str):
-        gt = rrc_evaluation_funcs.load_zip_file(gtFilePath,evaluationParams['GT_SAMPLE_NAME_2_ID'])
-    else:
-        gt = gtFilePath
-    if isinstance(submFilePath, str):
-        subm = rrc_evaluation_funcs.load_zip_file(submFilePath,evaluationParams['DET_SAMPLE_NAME_2_ID'],True)
-    else:
-        subm = submFilePath
-
-    numGt = 0;
-    numDet = 0;
-
-    for resFile in gt:
-        if isinstance(gt[resFile], bytes):
-            gtFile = rrc_evaluation_funcs.decode_utf8(gt[resFile])
-        else:
-            gtFile = gt[resFile]
-        recall = 0
-        precision = 0
-        hmean = 0
-        recallAccum = 0.
-        precisionAccum = 0.
-        gtRects = []
-        detRects = []
-        gtPolPoints = []
-        detPolPoints = []
-        gtDontCareRectsNum = []#Array of Ground Truth Rectangles' keys marked as don't Care
-        detDontCareRectsNum = []#Array of Detected Rectangles' matched with a don't Care GT
-        pairs = []
-        evaluationLog = ""
-
-        recallMat = np.empty([1,1])
-        precisionMat = np.empty([1,1])
-
-        pointsList,_,transcriptionsList = rrc_evaluation_funcs.get_tl_line_values_from_file_contents(gtFile,evaluationParams['CRLF'],True,True,False)
-        for n in range(len(pointsList)):
-            points = pointsList[n]
-            transcription = transcriptionsList[n]
-            dontCare = transcription == "###"
-            gtRect = Rectangle(*points)
-            gtRects.append(gtRect)
-            gtPolPoints.append(points)
-            if dontCare:
-                gtDontCareRectsNum.append( len(gtRects)-1 )
-
-        evaluationLog += "GT rectangles: " + str(len(gtRects)) + (" (" + str(len(gtDontCareRectsNum)) + " don't care)\n" if len(gtDontCareRectsNum)>0 else "\n")
-
-        if resFile in subm:
-            if isinstance(subm[resFile], bytes):
-                detFile = rrc_evaluation_funcs.decode_utf8(subm[resFile])
-            else:
-                detFile = subm[resFile]
-            pointsList,_,_ = rrc_evaluation_funcs.get_tl_line_values_from_file_contents(detFile,evaluationParams['CRLF'],True,False,False)
-            for n in range(len(pointsList)):
-                points = pointsList[n]
-                detRect = Rectangle(*points)
-                detRects.append(detRect)
-                detPolPoints.append(points)
-                if len(gtDontCareRectsNum)>0 :
-                    for dontCareRectNum in gtDontCareRectsNum:
-                        dontCareRect = gtRects[dontCareRectNum]
-                        intersected_area = area(dontCareRect,detRect)
-                        rdDimensions = ( (detRect.xmax - detRect.xmin+1) * (detRect.ymax - detRect.ymin+1));
-                        if (rdDimensions==0) :
-                            precision = 0
-                        else:
-                            precision= intersected_area / rdDimensions
-                        if (precision > evaluationParams['AREA_PRECISION_CONSTRAINT'] ):
-                            detDontCareRectsNum.append( len(detRects)-1 )
-                            break
-
-            evaluationLog += "DET rectangles: " + str(len(detRects)) + (" (" + str(len(detDontCareRectsNum)) + " don't care)\n" if len(detDontCareRectsNum)>0 else "\n")
-
-            if len(gtRects)==0:
-                recall = 1
-                precision = 0 if len(detRects)>0 else 1
-
-            if len(detRects)>0:
-                #Calculate recall and precision matrixs
-                outputShape=[len(gtRects),len(detRects)]
-                recallMat = np.empty(outputShape)
-                precisionMat = np.empty(outputShape)
-                gtRectMat = np.zeros(len(gtRects),np.int8)
-                detRectMat = np.zeros(len(detRects),np.int8)
-                for gtNum in range(len(gtRects)):
-                    for detNum in range(len(detRects)):
-                        rG = gtRects[gtNum]
-                        rD = detRects[detNum]
-                        intersected_area = area(rG,rD)
-                        rgDimensions = ( (rG.xmax - rG.xmin+1) * (rG.ymax - rG.ymin+1) );
-                        rdDimensions = ( (rD.xmax - rD.xmin+1) * (rD.ymax - rD.ymin+1));
-                        recallMat[gtNum,detNum] = 0 if rgDimensions==0 else  intersected_area / rgDimensions
-                        precisionMat[gtNum,detNum] = 0 if rdDimensions==0 else intersected_area / rdDimensions
-
-                # Find one-to-one matches
-                evaluationLog += "Find one-to-one matches\n"
-                for gtNum in range(len(gtRects)):
-                    for detNum in range(len(detRects)):
-                        if gtRectMat[gtNum] == 0 and detRectMat[detNum] == 0 and gtNum not in gtDontCareRectsNum and detNum not in detDontCareRectsNum :
-                            match = one_to_one_match(gtNum, detNum)
-                            if match is True :
-                                #in deteval we have to make other validation before mark as one-to-one
-                                if is_single_overlap(gtNum, detNum) is True :
-                                    rG = gtRects[gtNum]
-                                    rD = detRects[detNum]
-                                    normDist = center_distance(rG, rD);
-                                    normDist /= diag(rG) + diag(rD);
-                                    normDist *= 2.0;
-                                    if normDist < evaluationParams['EV_PARAM_IND_CENTER_DIFF_THR'] :
-                                        gtRectMat[gtNum] = 1
-                                        detRectMat[detNum] = 1
-                                        recallAccum += evaluationParams['MTYPE_OO_O']
-                                        precisionAccum += evaluationParams['MTYPE_OO_O']
-                                        pairs.append({'gt':gtNum,'det':detNum,'type':'OO'})
-                                        evaluationLog += "Match GT #" + str(gtNum) + " with Det #" + str(detNum) + "\n"
-                                    else:
-                                        evaluationLog += "Match Discarded GT #" + str(gtNum) + " with Det #" + str(detNum) + " normDist: " + str(normDist) + " \n"
-                                else:
-                                    evaluationLog += "Match Discarded GT #" + str(gtNum) + " with Det #" + str(detNum) + " not single overlap\n"
-                # Find one-to-many matches
-                evaluationLog += "Find one-to-many matches\n"
-                for gtNum in range(len(gtRects)):
-                    if gtNum not in gtDontCareRectsNum:
-                        match,matchesDet = one_to_many_match(gtNum)
-                        if match is True :
-                            evaluationLog += "num_overlaps_gt=" + str(num_overlaps_gt(gtNum))
-                            #in deteval we have to make other validation before mark as one-to-one
-                            if num_overlaps_gt(gtNum)>=2 :
-                                gtRectMat[gtNum] = 1
-                                recallAccum += (evaluationParams['MTYPE_OO_O'] if len(matchesDet)==1 else evaluationParams['MTYPE_OM_O'])
-                                precisionAccum += (evaluationParams['MTYPE_OO_O'] if len(matchesDet)==1 else evaluationParams['MTYPE_OM_O']*len(matchesDet))
-                                pairs.append({'gt':gtNum,'det':matchesDet,'type': 'OO' if len(matchesDet)==1 else 'OM'})
-                                for detNum in matchesDet :
-                                    detRectMat[detNum] = 1
-                                evaluationLog += "Match GT #" + str(gtNum) + " with Det #" + str(matchesDet) + "\n"
-                            else:
-                                evaluationLog += "Match Discarded GT #" + str(gtNum) + " with Det #" + str(matchesDet) + " not single overlap\n"
-
-                # Find many-to-one matches
-                evaluationLog += "Find many-to-one matches\n"
-                for detNum in range(len(detRects)):
-                    if detNum not in detDontCareRectsNum:
-                        match,matchesGt = many_to_one_match(detNum)
-                        if match is True :
-                            #in deteval we have to make other validation before mark as one-to-one
-                            if num_overlaps_det(detNum)>=2 :
-                                detRectMat[detNum] = 1
-                                recallAccum += (evaluationParams['MTYPE_OO_O'] if len(matchesGt)==1 else evaluationParams['MTYPE_OM_M']*len(matchesGt))
-                                precisionAccum += (evaluationParams['MTYPE_OO_O'] if len(matchesGt)==1 else evaluationParams['MTYPE_OM_M'])
-                                pairs.append({'gt':matchesGt,'det':detNum,'type': 'OO' if len(matchesGt)==1 else 'MO'})
-                                for gtNum in matchesGt :
-                                    gtRectMat[gtNum] = 1
-                                evaluationLog += "Match GT #" + str(matchesGt) + " with Det #" + str(detNum) + "\n"
-                            else:
-                                evaluationLog += "Match Discarded GT #" + str(matchesGt) + " with Det #" + str(detNum) + " not single overlap\n"
-
-                numGtCare = (len(gtRects) - len(gtDontCareRectsNum))
-                if numGtCare == 0:
-                    recall = float(1)
-                    precision = float(0) if len(detRects)>0 else float(1)
-                else:
-                    recall = float(recallAccum) / numGtCare
-                    precision =  float(0) if (len(detRects) - len(detDontCareRectsNum))==0 else float(precisionAccum) / (len(detRects) - len(detDontCareRectsNum))
-                hmean = 0 if (precision + recall)==0 else 2.0 * precision * recall / (precision + recall)
-
-        methodRecallSum += recallAccum
-        methodPrecisionSum += precisionAccum
-        numGt += len(gtRects) - len(gtDontCareRectsNum)
-        numDet += len(detRects) - len(detDontCareRectsNum)
-
-        perSampleMetrics[resFile] = {
-                                        'precision':precision,
-                                        'recall':recall,
-                                        'hmean':hmean,
-                                        'pairs':pairs,
-                                        'recallMat':[] if len(detRects)>100 else recallMat.tolist(),
-                                        'precisionMat':[] if len(detRects)>100 else precisionMat.tolist(),
-                                        'gtPolPoints':gtPolPoints,
-                                        'detPolPoints':detPolPoints,
-                                        'gtDontCare':gtDontCareRectsNum,
-                                        'detDontCare':detDontCareRectsNum,
-                                        'evaluationParams': evaluationParams,
-                                        'evaluationLog': evaluationLog
-                                    }
-
-    methodRecall = 0 if numGt==0 else methodRecallSum/numGt
-    methodPrecision = 0 if numDet==0 else methodPrecisionSum/numDet
-    methodHmean = 0 if methodRecall + methodPrecision==0 else 2* methodRecall * methodPrecision / (methodRecall + methodPrecision)
-
-    methodMetrics = {'precision':methodPrecision, 'recall':methodRecall,'hmean': methodHmean  }
-
-    resDict = {'calculated':True,'Message':'','method': methodMetrics,'per_sample': perSampleMetrics}
-
-
-    return resDict;
-
-
-
-if __name__=='__main__':
-
-    rrc_evaluation_funcs.main_evaluation(None,default_evaluation_params,validate_data,evaluate_method)