tmp_test.py

# -*- coding:utf-8 -*-
import os
import cv2
import sys
import time
import math
import copy
from functools import reduce
import collections
import torch
import argparse
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
from scipy import misc, ndimage
# from angle import get_rotate_img

from PIL import Image

from torch.autograd import Variable
from torch.utils import data

from dataset import DataLoader
import models
import util
# c++ version pse based on opencv 3+
from pse import pse

# from angle import detect_angle
from apphelper.image import order_point, calc_iou, xy_rotate_box
from crnn import crnnRec

from eval.invoice.eval_invoice import evaluate
# from layout.VGGLocalization import VGGLoc, trans_image

# python pse
# from pypse import pse as pypse
from pse2 import pse2
from angle import *

def get_right_marge(data):
    # 排除备注中的信息，以图片的中间为限
    max_r = 0
    for dd in data:
        tem_r = float(dd['cx']) + float(dd['w']) / 2
        if tem_r > max_r:
            max_r = tem_r
    return max_r + 200


def get_min_distance_index(tem,indexes,near):
    x = float(tem['cx']) + float(tem['w']) / 2
    y = float(tem['cy']) + float(tem['h']) / 2
    distance_min = 100000
    ii = 0
    for i in indexes:
        x_tem = float(near[i]['cx']) - float(near[i]['w']/2)
        y_tem = float(near[i]['cy']) + float(near[i]['h']/2)
        distance_tem = math.sqrt(math.pow((x-x_tem),2) + math.pow((y-y_tem),2))
        if distance_tem < distance_min and len(near[i]['text']):
            ii = i
            distance_min = distance_tem
    return ii


def get_params():
    parser = argparse.ArgumentParser(description='Hyperparams')
    parser.add_argument('--arch', nargs='?', type=str, default='resnet50')
    parser.add_argument('--resume', nargs='?', type=str, default='./checkpoints/ctw1500_res50_pretrain_ic17.pth.tar',
                        help='Path to previous saved model to restart from')
    parser.add_argument('--binary_th', nargs='?', type=float, default=0.5,
                        help='Path to previous saved model to restart from')
    parser.add_argument('--kernel_num', nargs='?', type=int, default=7,
                        help='Path to previous saved model to restart from')
    parser.add_argument('--scale', nargs='?', type=int, default=1,
                        help='Path to previous saved model to restart from')
    parser.add_argument('--long_size', nargs='?', type=int, default=2240,
                        help='Path to previous saved model to restart from')
    parser.add_argument('--min_kernel_area', nargs='?', type=float, default=5.0,
                        help='min kernel area')
    parser.add_argument('--min_area', nargs='?', type=float, default=300.0,
                        help='min area')
    parser.add_argument('--min_score', nargs='?', type=float, default=0.5,
                        help='min score')
    parser.add_argument('--image_fgbg', nargs='?', type=bool, default=False,
                       help='split image into foreground and background')
    parser.add_argument('--evaluate', nargs='?', type=bool, default=True,
                        help='evalution')
    args = parser.parse_args()
    return args

def recognize(im=None, path=None):
    ret = None
    try:
        file = None
        if im:
            pass
        elif path:
            # 提取文件路径
            # dir,base = os.path.split(path)
            # file,suffix = os.path.splitext(base)
            # dir = os.path.dirname(__file__)
            # tmpfile = os.path.join(dir, 'tmp/'+file+'-large'+suffix)
            # 修改图片大小和分辨率
            im = Image.open(path)
            file = os.path.basename(path)

        if im:
            dir = os.path.join(os.path.dirname(__file__), '../data/images/invoice/')
            file = file if file is not None else 'tmp.jpg'
            tmpfile = os.path.join(dir, file)
            im.save(tmpfile)

            data = test(get_params(), tmpfile)
            if data:
                ret = format(data)
    except Exception as e:
        print(e)

    return ret


def format(data):
    return data


def extend_3c(img):
    img = img.reshape(img.shape[0], img.shape[1], 1)
    img = np.concatenate((img, img, img), axis=2)
    return img


def debug(idx, img_paths, imgs, output_root):
    if not os.path.exists(output_root):
        os.makedirs(output_root)

    col = []
    for i in range(len(imgs)):
        row = []
        for j in range(len(imgs[i])):
            # img = cv2.copyMakeBorder(imgs[i][j], 3, 3, 3, 3, cv2.BORDER_CONSTANT, value=[255, 0, 0])
            row.append(imgs[i][j])
        res = np.concatenate(row, axis=1)
        col.append(res)
    res = np.concatenate(col, axis=0)
    img_name = img_paths[idx].split('/')[-1]
    print(idx, '/', len(img_paths), img_name)
    cv2.imwrite(output_root + img_name, res)


def write_result_as_txt(image_name, bboxes, path):
    filename = util.io.join_path(path, 'res_%s.txt' % (image_name))
    lines = []
    for b_idx, bbox in enumerate(bboxes):
        values = [int(v) for v in bbox]
        line = "%d, %d, %d, %d, %d, %d, %d, %d\n" % tuple(values)
        lines.append(line)
    util.io.write_lines(filename, lines)


def polygon_from_points(points):
    """
    Returns a Polygon object to use with the Polygon2 class from a list of 8 points: x1,y1,x2,y2,x3,y3,x4,y4
    """
    resBoxes = np.empty([1, 8], dtype='int32')
    resBoxes[0, 0] = int(points[0])
    resBoxes[0, 4] = int(points[1])
    resBoxes[0, 1] = int(points[2])
    resBoxes[0, 5] = int(points[3])
    resBoxes[0, 2] = int(points[4])
    resBoxes[0, 6] = int(points[5])
    resBoxes[0, 3] = int(points[6])
    resBoxes[0, 7] = int(points[7])
    pointMat = resBoxes[0].reshape([2, 4]).T
    return plg.Polygon(pointMat)

#----
# --
# -----------------------------------------------------------------------------------

import os
import sys
import pathlib
__dir__ = pathlib.Path(os.path.abspath(__file__))
sys.path.append(str(__dir__))
sys.path.append(str(__dir__.parent.parent))

# project = 'DBNet.pytorch'  # 工作项目根目录
# sys.path.append(os.getcwd().split(project)[0] + project)
import time
import cv2
import torch

from dbnet.data_loader import get_transforms
from dbnet.models import build_model
from dbnet.post_processing import get_post_processing

def resize_image(img, short_size):
    height, width, _ = img.shape
    if height < width:
        new_height = short_size
        new_width = new_height / height * width
    else:
        new_width = short_size
        new_height = new_width / width * height
    new_height = int(round(new_height / 32) * 32)
    new_width = int(round(new_width / 32) * 32)
    resized_img = cv2.resize(img, (new_width, new_height))
    return resized_img

class Pytorch_model:
    def __init__(self, model_path, post_p_thre=0.7, gpu_id=None):
        '''
        初始化pytorch模型
        :param model_path: 模型地址(可以是模型的参数或者参数和计算图一起保存的文件) model_path='/home/share/gaoluoluo/dbnet/output/DBNet_resnet18_FPN_DBHead/checkpoint/model_latest.pth'
        :param gpu_id: 在哪一块gpu上运行
        '''
        self.gpu_id = gpu_id

        if self.gpu_id is not None and isinstance(self.gpu_id, int) and torch.cuda.is_available():
            self.device = torch.device("cuda:%s" % self.gpu_id)
        else:
            self.device = torch.device("cpu")
        # print('device:', self.device)
        checkpoint = torch.load(model_path, map_location=self.device)
        # print("checkpoint:",checkpoint)

        config = checkpoint['config']
        # print(checkpoint['config'])
        config['arch']['backbone']['pretrained'] = False
        self.model = build_model(config['arch'])
        self.post_process = get_post_processing(config['post_processing'])
        self.post_process.box_thresh = post_p_thre
        self.img_mode = config['dataset']['train']['dataset']['args']['img_mode']
        self.model.load_state_dict(checkpoint['state_dict'])
        self.model.to(self.device)
        self.model.eval()

        self.transform = []
        for t in config['dataset']['train']['dataset']['args']['transforms']:
            if t['type'] in ['ToTensor', 'Normalize']:
                self.transform.append(t)
        self.transform = get_transforms(self.transform)

    def predict(self, img, is_output_polygon=False, short_size: int = 1024):
        '''
        对传入的图像进行预测，支持图像地址,opecv 读取图片，偏慢
        :param img_path: 图像地址
        :param is_numpy:
        :return:
        '''
        # assert os.path.exists(img_path), 'file is not exists'
        # img = cv2.imread(img_path, 1 if self.img_mode != 'GRAY' else 0)
        if self.img_mode == 'RGB':
            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
        h, w = img.shape[:2] # 2550 3507
        img = resize_image(img, short_size)
        # 将图片由(w,h)变为(1,img_channel,h,w)
        tensor = self.transform(img)
        tensor = tensor.unsqueeze_(0)

        tensor = tensor.to(self.device)
        batch = {'shape': [(h, w)]}
        with torch.no_grad():
            if str(self.device).__contains__('cuda'):
                torch.cuda.synchronize(self.device)
            start = time.time()
            preds = self.model(tensor)
            if str(self.device).__contains__('cuda'):
                torch.cuda.synchronize(self.device)
            box_list, score_list = self.post_process(batch, preds, is_output_polygon=is_output_polygon)
            box_list, score_list = box_list[0], score_list[0]
            if len(box_list) > 0:
                if is_output_polygon:
                    idx = [x.sum() > 0 for x in box_list]
                    box_list = [box_list[i] for i, v in enumerate(idx) if v]
                    score_list = [score_list[i] for i, v in enumerate(idx) if v]
                else:
                    idx = box_list.reshape(box_list.shape[0], -1).sum(axis=1) > 0  # 去掉全为0的框
                    box_list, score_list = box_list[idx], score_list[idx]
            else:
                box_list, score_list = [], []
            t = time.time() - start
        return preds[0, 0, :, :].detach().cpu().numpy(), box_list, score_list, t

def init_args():
    import argparse
    parser = argparse.ArgumentParser(description='DBNet.pytorch')
    # parser.add_argument('--model_path', default=r'/home/share/gaoluoluo/dbnet/output/DBNet_resnet18_FPN_DBHead/checkpoint/model_latest.pth', type=str)
    parser.add_argument('--model_path', default=r'/home/share/gaoluoluo/模型/model_best.pth', type=str)
    # parser.add_argument('--model_path', default=r'/home/share/gaoluoluo/模型/model50_ch_epoch248_latest.pth', type=str)
    # parser.add_argument('--input_folder', default='/home/share/gaoluoluo/complete_ocr/data/img_not_use', type=str, help='img path for predict')
    parser.add_argument('--input_folder', default='/home/share/gaoluoluo/dbnet/test/test_input', type=str, help='img path for predict')
    parser.add_argument('--img_correct',default='/home/share/gaoluoluo/dbnet/test/test_corre_input/',type=str,help='img_correct path for predict')
    # parser.add_argument('--input_folder',default='/home/share/gaoluoluo/dbnet/test/test_corre_input', type=str, help='img path for predict')
    # parser.add_argument('--input_folder', default='/home/share/gaoluoluo/complete_ocr/data/images/tmp', type=str,help='img path for predict')
    # parser.add_argument('--output_folder', default='/home/share/gaoluoluo/dbnet/test/test_output', type=str, help='img path for output')
    parser.add_argument('--output_folder', default='/home/share/gaoluoluo/dbnet/test/test_output', type=str, help='img path for output')
    parser.add_argument('--gt_txt', default='/home/share/gaoluoluo/complete_ocr/data/txt_not_use', type=str, help='img 对应的 txt')
    parser.add_argument('--thre', default=0.1, type=float, help='the thresh of post_processing')
    parser.add_argument('--polygon', action='store_true', help='output polygon or box')
    parser.add_argument('--show', action='store_true', help='show result')
    parser.add_argument('--save_result', action='store_true', help='save box and score to txt file')
    parser.add_argument('--evaluate', nargs='?', type=bool, default=True,
                        help='evalution')
    args = parser.parse_args()
    return args

def test(args, file=None):

    import pathlib
    from tqdm import tqdm
    import matplotlib.pyplot as plt
    from dbnet.utils.util import show_img, draw_bbox, save_result, get_file_list

    args = init_args()
    # print(args)
    os.environ['CUDA_VISIBLE_DEVICES'] = str('0')
    # 初始化网络                                         0.1
    model = Pytorch_model(args.model_path, post_p_thre=args.thre, gpu_id=0)
    img_folder = pathlib.Path(args.input_folder)  # dbnet/test/input/
    # i = 0

    total_frame = 0.0
    total_time = []

    precisions = []

    names = []
    names_tem = []
    # iii = 1
    for img_path in tqdm(get_file_list(args.input_folder, p_postfix=['.jpg','.png'])):  # img_path /home/share/gaoluoluo/dbnet/test/input/2018实验仪器发票.jpg
        # print("img_path:",img_path)  /home/share/gaoluoluo/dbnet/test/input/2018实验仪器发票.jpg
        print("\nimg_path:", img_path)
        start_time = time.time()
        img = angle_corre(img_path)# 调整图片角度
        img_path = args.img_correct + img_path.split('/')[-1] # After correct angle img path
        names.append(img_path.split('/')[-1])
        # names_tem.append(str(iii)+img_path.split('.')[-1])
        # iii += 1
        print("img_path:",img_path)
        preds, boxes_list, score_list, t = model.predict(img, is_output_polygon=args.polygon)
        img_path1 = img_path
        boxes_list_save = boxes_list
        box = []
        for i in range(0,len(boxes_list)):
            for  j in range(0,len(boxes_list[0])):
                b = []
                b.append(np.float32(boxes_list[i][j][0]))
                b.append(np.float32(boxes_list[i][j][1]))
                box.append(b)
        boxes_list = boxes_list.reshape(-1,2)
        boxes_list = box
        #---hekuang  zhineng chuli yige kuang bei fencheng liangge bufen
        i = 4
        points_kuang = []
        min_tmp = 1000
        remove_mark = []
        while(i<=len(boxes_list)):
            points = boxes_list[i-4:i]
            i = i+4
            points = np.array(points)
            points_kuang.append(points)
        for i in range(0,len(points_kuang)):
            point3 = points_kuang[i][2]
            end_point = i + 8
            if end_point > len(points_kuang):
                end_point = len(points_kuang)
            for j in range(i+1,end_point):
                point4 = points_kuang[j][3]
                min_dis = math.sqrt(math.pow((point3[0] - point4[0]),2) + math.pow((point3[1] - point4[1]),2))
                if min_dis <min_tmp:
                    min_tmp = min_dis
                if min_dis < 10:
                    point1_1 = points_kuang[i][0]
                    point1_2 = points_kuang[j][0]
                    x_min = min(point1_1[0],point1_2[0])
                    y_min = min(point1_1[1],point1_2[1])
                    point3_2 = points_kuang[j][2]
                    x_max = max(point3[0],point3_2[0])
                    y_max = max(point3[1],point3_2[1])
                    points_kuang[i][0,0] = x_min
                    points_kuang[i][0,1] = y_min
                    points_kuang[i][1,0] = x_max
                    points_kuang[i][1,1] = y_min
                    points_kuang[i][2,0] = x_max
                    points_kuang[i][2,1] = y_max
                    points_kuang[i][3,0] = x_min
                    points_kuang[i][3,1] = y_max
                    remove_mark.append(j)
                    break
        remove_mark = sorted(remove_mark,reverse=True)
        for _,i in enumerate(remove_mark):
            del points_kuang[i]
        #---
        i = 4;
        rects = []
        while(i<=len(boxes_list)):
            points = boxes_list[i-4:i]
            i = i+4
            points = np.array(points)
            rect = cv2.minAreaRect(points) # 4个点 -> d cx cy w h
            rec = []
            rec.append(rect[-1])
            rec.append(rect[1][1])
            rec.append(rect[1][0])
            rec.append(rect[0][0])
            rec.append(rect[0][1])
            rects.append(rec)
        ori_img = cv2.imread(img_path1)
        result = crnnRec(cv2.cvtColor(ori_img, cv2.COLOR_BGR2RGB), rects)
        result = list(reversed(result))


        dur = time.time() - start_time
        print("dur:",dur)

        #  保存画框图片---------
        # img = draw_bbox(img(img_path)[:, :, ::-1], boxes_list_save)
        img = draw_bbox(cv2.imread(img_path)[:, :, ::-1], boxes_list_save)
        if args.show:
            show_img(preds)
            show_img(img, title=os.path.basename(img_path))
            plt.show()
        # 保存结果到路径
        os.makedirs(args.output_folder, exist_ok=True)
        img_path = pathlib.Path(img_path)
        output_path = os.path.join(args.output_folder, img_path.stem + '_result.jpg')  # /home/share/gaoluoluo/dbnet/test/output/2018实验仪器发票_result.jpg
        pred_path = os.path.join(args.output_folder,img_path.stem + '_pred.jpg')  # /home/share/gaoluoluo/dbnet/test/output/2018实验仪器发票_pred.jpg
        cv2.imwrite(output_path, img[:, :, ::-1])
        cv2.imwrite(pred_path, preds * 255)
        save_result(output_path.replace('_result.jpg', '.txt'), boxes_list_save, score_list, args.polygon)
        #  --------
        total_frame += 1
        total_time.append(dur)

        # print("-------------------11")
        result = formatResult(result)
        #  # 保存画框图片---------
        # img = draw_bbox(cv2.imread(img_path)[:, :, ::-1], boxes_list_save)
        # if args.show:
        #     show_img(preds)
        #     show_img(img, title=os.path.basename(img_path))
        #     plt.show()
        # # 保存结果到路径
        # os.makedirs(args.output_folder, exist_ok=True)
        # img_path = pathlib.Path(img_path)
        # output_path = os.path.join(args.output_folder, img_path.stem + '_result.jpg')  # /home/share/gaoluoluo/dbnet/test/output/2018实验仪器发票_result.jpg
        # pred_path = os.path.join(args.output_folder,img_path.stem + '_pred.jpg')  # /home/share/gaoluoluo/dbnet/test/output/2018实验仪器发票_pred.jpg
        # cv2.imwrite(output_path, img[:, :, ::-1])
        # cv2.imwrite(pred_path, preds * 255)
        # save_result(output_path.replace('_result.jpg', '.txt'), boxes_list_save, score_list, args.polygon)
        #  # --------

        # 计算准确率
        if args.evaluate:
            file = os.path.join(args.gt_txt,img_path.stem + '.txt')
            errfile = os.path.join(args.output_folder, 'error_txt/' + img_path.stem + '-errors.txt')
            canfile = os.path.join(args.output_folder, 'candidate_txt/' + img_path.stem + '-candidate.txt')
            if os.path.exists(file):
                precision = evaluate(file, errfile,canfile,result)
                print('precision:' + str(precision[0]) + '%')
                precisions.append(precision[0])
    for i in range(0,len(precisions)):
        print(names[i],precisions[i])

    if len(precisions):
        mean = np.mean(precisions)
        print("names:",names)
        # print("names:",names_tem)
        print("precisions:",precisions)
        time_mean = np.mean(total_time)
        print('mean precision:' + str(mean) + '%')
        print('mean time:' + str(time_mean) + 's')

    return 0;


    #--------------------------------------------------



def predict_bbox(args, model, org_img, img, slice):
    # angle detection
    # org_img, angle = detect_angle(org_img)
    outputs = model(img)

    score = torch.sigmoid(outputs[:, slice, :, :])
    outputs = (torch.sign(outputs - args.binary_th) + 1) / 2

    text = outputs[:, slice, :, :]
    kernels = outputs
    # kernels = outputs[:, 0:args.kernel_num, :, :] * text

    score = score.data.cpu().numpy()[0].astype(np.float32)
    text = text.data.cpu().numpy()[0].astype(np.uint8)
    kernels = kernels.data.cpu().numpy()[0].astype(np.uint8)

    if args.arch == 'mobilenet':
        pred = pse2(kernels, args.min_kernel_area / (args.scale * args.scale))
    else:
        # c++ version pse
        pred = pse(kernels, args.min_kernel_area / (args.scale * args.scale))
        # python version pse
        # pred = pypse(kernels, args.min_kernel_area / (args.scale * args.scale))

    # scale = (org_img.shape[0] * 1.0 / pred.shape[0], org_img.shape[1] * 1.0 / pred.shape[1])
    scale = (org_img.shape[1] * 1.0 / pred.shape[1], org_img.shape[0] * 1.0 / pred.shape[0])
    label = pred
    label_num = np.max(label) + 1
    bboxes = []
    rects = []
    for i in range(1, label_num):
        points = np.array(np.where(label == i)).transpose((1, 0))[:, ::-1]

        if points.shape[0] < args.min_area / (args.scale * args.scale):
            continue

        score_i = np.mean(score[label == i])
        if score_i < args.min_score:
            continue

        rect = cv2.minAreaRect(points)
        bbox = cv2.boxPoints(rect) * scale
        bbox = bbox.astype('int32')
        bbox = order_point(bbox)
        # bbox = np.array([bbox[1], bbox[2], bbox[3], bbox[0]])
        bboxes.append(bbox.reshape(-1))

        rec = []
        rec.append(rect[-1])
        rec.append(rect[1][1] * scale[1])
        rec.append(rect[1][0] * scale[0])
        rec.append(rect[0][0] * scale[0])
        rec.append(rect[0][1] * scale[1])
        rects.append(rec)

    return bboxes, rects, text

import re
def isTitle(text):
    # return re.search(r'(货物|劳务|服.?名称|规.?型号|^单[位价]|^数|.?额$|^税.$|项目|类型|车牌|通行日期)', text) != None
    # return re.search(r'(货物|劳务|服.?名称|规.?型号|^单[位价]|^数|.?额$|税率|税额|项目|类型|车牌|通行日期)', text) != None
    return re.search(r'(货物|劳务|服.?名称|规.?型号|^单[位价]|^数量|.?额$|税率|税额)', text) != None
    return re.search(r'(货物|劳务|服.?名称|规.?型号|^单[位价]|^数量|.?额$|税率|税额|项目|类型|车牌|通行日期)', text) != None

    # return text.find(r'服务名称') > -1 \
    #        or text.find(r'规格型号') > -1 \
    #        or text.find(r'单位') > -1 \
    #        or text.find(r'数量') > -1 \
    #        or text.find(r'单价') > -1 \
    #        or text.find(r'金额') > -1 \
    #        or text.find(r'税率') > -1 \
    #        or text.find(r'税额') > -1

def isSummary(text):
    # pattern = re.compile(r'[￥|Y|羊]\d+?\.?\d*')
    # pattern = re.compile(r'(￥|Y|羊)[0-9]+(.[0-9]{2})?$')
    pattern = re.compile(r'(￥|Y|羊)[0-9]+(.[0-9]{2})$')
    return text==r'计' or text == r'合' or text == r'合计' or pattern.search(text) != None

def get_content_boundary(data):
    #

    #--- 过滤左边的无用信息
    left = [d for i, d in enumerate(data) if isTitle(d['text'])]
    left = sorted(left,key=lambda x: x['cx'] - x['w'] / 2)
    left = left[0]
    cx_tem = float(left['cx'] - float(left['w']) / 2) # 标题的左
    if re.search(r'(货物|劳务|服.?名称)', left['text']) != None:
        for i in range(len(data)-1,-1,-1):
            cx = float(data[i]['cx']) + float(data[i]['w']) / 2 # 其他的右
            if(0 < cx_tem -cx):
                # print(data[i])
                data.pop(i)
    #----
    #----
    while len(data):
        left_tem = min(data, key = lambda x : x['cx'] - x['w'] / 2)
        if len(left_tem['text']) < 3 :
            data.remove(left_tem)
        else :
            break
    while len(data):
        right_tem = max(data, key = lambda x : x['cx'] + x['w'] / 2)
        if len(right_tem['text']) < 3 :
            data.remove(right_tem)
        else :
            break
    #----
    title = [i for i, d in enumerate(data) if isTitle(d['text'])]
    print(data[31]['text'])
    s = title[0]
    e = title[-1]
    title.extend([i+s-4 for i,d in enumerate(data[s-4:s]) if abs(d['cy'] - data[s]['cy']) < 10])
    title.extend([i+e+1 for i,d in enumerate(data[e+1:e+6]) if abs(d['cy'] - data[e]['cy']) < 10])
    s = min(title)
    e = max(title)
    lf = min(data[s:e+1], key=lambda x:x['cx']-x['w']/2)

    summary = [i for i, d in enumerate(data) if isSummary(d['text'])]
    s = summary[0]
    summary.extend([i+s-4 for i, d in enumerate(data[s-4:s]) if abs(d['cy'] - data[summary[-1]]['cy']) < 10])
    s = min(summary)

    start = e
    # print("start:",start)
    end = s
    # print("end:",end)

    # rt = [d for d in data[start:end] if re.match(r'\d+\.?\d*$', d['text'])]
    rt = max(data[start:end], key=lambda x: x['cx']+x['w']/2)


    left = lf['cx']-lf['w']/2   # 20为经验值
    right = rt['cx']+rt['w']/2   # 80 为经验值

    return (start, end, left, right)

def check(data, placeholder, dir = 0):
    try:
        i = None
        if isinstance(placeholder,list):
            for pld in placeholder:
                f = [x for x,d in enumerate(data) if d == pld]
                if len(f):
                    i = f[-1]
                    break
        else:
            f = [x for x,d in enumerate(data) if d == placeholder]
            if len(f):
                i = f[-1]
        return i
    except:
        return None

LEFT_MARGIN = 70
RIGHT_MARGIN = 20
def parseLine(line, boundary, isvehicle=False):
    xmin, xmax = boundary

    copyed = copy.deepcopy(line)
    copyed = preprocess_line(copyed) # 主要处理的是框框交叉,并对cx排序

    if isvehicle:
        # ratio, price = get_ratio(copyed, xmax)
        ratio, price, tax = get_ratio_price_tax(copyed, xmax)
        # title
        title = get_title(copyed, xmin)
        sdate, edate, price, ratio = get_date(copyed, price, ratio)
        platenum, cartype, sdate, edate = get_platenum_cartype(copyed, sdate, edate)

        return postprocess_line(title, platenum, cartype, sdate, edate, price, ratio, tax)
    else:
        # ratio
        # ratio, price = get_ratio(copyed, xmax)
        ratio, price, tax = get_ratio_price_tax(copyed, xmax)
        # title
        title = get_title(copyed, xmin) # jin
        # tax
        # tax = get_tax(copyed, xmax, ratio)
        # prices
        #
        specs, amount, uprice, price, ratio = get_numbers(copyed, price, ratio,tax)
        #specs
        specs,unit = get_specs_unit(copyed, specs)

        return postprocess_line(title, specs, unit, amount, uprice, price, ratio, tax)

def preprocess_line(line):
    line = sorted(line, key=lambda x: x['cx'] - x['w'] / 2)
    res = []

    i = 0
    j = 1
    while i < len(line) and j < len(line):
        x = line[i]
        y = line[j]
        x1 = x['cx'] + x['w'] / 2 # 左的右边
        y1 = y['cx'] - y['w'] / 2 # 右的左边

        if abs(x1 - y1) < 8: # 说明是同一个框 合并
            x['w'] = y['cx'] + y['w']/2 - x['cx'] + x['w']/2
            x['cx'] = y['cx'] + y['w']/2 - x['w']/2
            x['text'] = x['text'] + y['text']
            j = j + 1
        else: # 不是同一个框，继续向you遍历
            res.append(x)
            i = j
            j = j + 1

    res.append(line[i])
    return res

def is_number(s):
    try:
        float(s)
        return True
    except ValueError:
        pass
    return False

def postprocess_line(title, specs, unit, amount, uprice, price, ratio, tax):
    # print("tax:",tax)
    # print("price:",price)
    # if len(price)==0:
    #     price = 0
    # if len(tax) ==0:
    #     tax = 0
    if tax != '***' and (not tax or not is_number(tax) or float(tax) > float(price) or not '.' in tax) and price and ratio:
        tax = '%.2f' % (float(price) / 100 * float(ratio[:-1]))
    return [title, specs, unit, amount, uprice, price, ratio, tax]

def get_title(line, xmin):
    title = ''
    candidates = [d for d in line if abs(d['cx'] - d['w'] / 2 - xmin) < LEFT_MARGIN]
    if len(candidates):
        candidates = sorted(candidates, key=lambda x:x['cy'])
        for c in candidates:
            title += c['text']
            line.remove(c)

    if title and not title.startswith('*'):
        title = '*' + title

    return title

def get_ratio_price_tax(line, xmax):
    ratio = ''
    price = ''
    tax = ''

    pat = re.compile(r'(\-?[\dBG]+\.?[\dBG]{2})*(([\dBG]+[\%])|([\u4e00-\u9fa5]+税))$')
    pat2 = re.compile(r'(\-?[\dBG]+\.[\dBG]{2})([\dBG]{1,2}[8])')

    ratioitem = None
    for i in range(len(line)-1, -1, -1):
        text = line[i]['text']
        m = pat.match(text)
        if m:
            price, ratio = (m.group(1), m.group(2)) if m.group(1) else ('', m.group(2))
        else:
            if len(line) - i < 3: # reduce
                m = pat2.match(text)
                if m:
                    price, ratio = (m.group(1), m.group(2))
                    ratio = ratio[:-1] + '%'

        if ratio:
            ratioitem = line.pop(i)
            break

    if not ratio:
        numbers = sorted([i for i,d in enumerate(line) if re.match(r'([\dBG]+\.?[\dBG]{2})*', d['text'])], key=lambda x:line[x]['cx']-line[x]['w']/2)
        if len(numbers)>=3:
            i = numbers[-2]
            d = line[i]
            m = re.match(r'(\d{1,2})\D+', d['text']) # 1-2 number and !number char eg 11%
            if m:
                ratio = m.group(1)
                ratioitem = line.pop(i)

    if re.search(r'税$', ratio):
        tax = '***'
    else:
        if ratioitem:
            taxes = [l for l in line if l['cx'] > ratioitem['cx']]
            if len(taxes):
                tax = taxes[0]['text']
                line.remove(taxes[0])

        if not tax:
            x = 1000
            for i,d in enumerate(line):
                if abs(d['cx'] + d['w'] / 2 - xmax) < x:
                    x = abs(d['cx'] + d['w'] / 2 - xmax)
            idx = [i for i, d in enumerate(line) if abs(d['cx'] + d['w'] / 2 - xmax) < RIGHT_MARGIN]
            if len(idx):
                idx = idx[0]
                ln = line[idx]
                tax = ln['text']
                line.pop(idx)

                if len(tax) > 2 and tax.find('.') == -1:
                    tax = tax[:-2] + '.' + tax[-2:]

        if len(price) and not '.' in price:
            if tax and ratio:
                while float(price) > float(tax):
                    prc = price[:-2] + '.' + price[-2:]
                    f_tax = float(tax)
                    f_ratio = float(ratio[:-1])
                    f_price = float(prc)

                    if abs(f_price * f_ratio / 100.0 - f_tax) > 0.1 and f_ratio < 10:
                        ratio = price[-1] + ratio
                        price = price[:-1]
                    else:
                        price = prc
                        break
            else:
                price = price[:-2] + '.' + price[-2:]

    if price and ratio and not tax:
        tax = str(round(float(price) * float(ratio[:-1]) / 100.0, 2))

    return ratio, price, tax

def get_tax(line, xmax, ratio):
    tax = ''

    if re.search(r'税$', ratio):
        tax = '***'

    idx = [i for i, d in enumerate(line) if abs(d['cx'] + d['w'] / 2 - xmax) < RIGHT_MARGIN]
    if len(idx):
        idx = idx[0]
        ln = line[idx]
        tax = ln['text']
        line.pop(idx)

        if len(tax) > 2 and tax.find('.') == -1:
            tax = tax[:-2] + '.' + tax[-2:]

    return tax

def get_ratio(line, xmax):
    ratio = ''
    price = ''
    pat = re.compile(r'(\-?[\dBG]+\.?[\dBG]{2})*(([\dBG]+[\%])|([\u4e00-\u9fa5]+税))$')

    for i in range(len(line)-1, -1, -1):
        text = line[i]['text']
        m = pat.match(text)
        if m:
            price, ratio = (m.group(1), m.group(2)) if m.group(1) else ('', m.group(2))

        if ratio:
            line.pop(i)
            break

    if not ratio:
        numbers = sorted([i for i,d in enumerate(line) if re.match(r'([\dBG]+\.?[\dBG]{2})*', d['text'])], key=lambda x:line[x]['cx']-line[x]['w']/2)
        if len(numbers)>=3:
            i = numbers[-2]
            d = line[i]
            m = re.match(r'(\d{1,2})\D+', d['text'])
            if m:
                ratio = m.group(1) + '%'
                line.pop(i)

    return ratio, price

def get_numbers(line, price, ratio,tax):

    specs = ''
    amount = ''
    uprice = ''

    pattern = re.compile(r'\-?[\dBG:]+\.?[\dBG]*$')
    numbers = []

    for d in line:
        if pattern.match(d['text']):
            d['text'] = d['text'].replace('B','8').replace('G', '6').replace(':','')
            numbers.append(d)

    if len(numbers):
        for n in numbers:
            line.remove(n)

        # preprocess_number(numbers)
        numbers = sorted(numbers, key=lambda x: x['cx'] - x['w'] / 2)
        if not ratio and re.match(r'^\d{2,3}$', numbers[-1]['text']):
            ratio = numbers[-1]['text']
            ratio = ratio[:-1] + '%'
            numbers = numbers[0:-1]
        if not price:
            # print("*price:",price)
            # print("len:",len(numbers[-1]['text']))
            if(len(numbers)):
                price = numbers[-1]['text']
                m = re.match(r'(\d+\.\d{2})\d*(\d{2})$', price)
                if m and not ratio:
                    price = m.group(1)
                    ratio = m.group(2) + '%'

                numbers = numbers[0:-1]

        numlen = len(numbers)
        if numlen == 3:
            specs = numbers[0]['text']
            amount = numbers[1]['text']
            uprice = numbers[2]['text']
        elif numlen == 2:
            num1 = numbers[0]['text']
            num2 = numbers[1]['text']

            if abs(float(num1) * float(num2) - float(price)) < 0.01:
                specs = ''
                amount = num1
                uprice = num2
            elif abs(float(num2) - float(price)) < 0.01:
                specs = num1
                amount = '1'
                uprice = num2
            else:
                specs, amount, uprice = get_amount_uprice(price, num2, num1)

        elif numlen == 1:
            specs = ''
            num = numbers[0]['text']
            if abs(float(num) - float(price)) < 0.01:
                amount = '1'
                uprice = num
            else:
                specs, amount, uprice = get_amount_uprice(price, num)

            if not amount:
                if uprice:
                    amount = str(int(float(price) / float(uprice) + 0.5))
                else:
                    amount = num

    if not ratio and price and tax:
        ratio = str(int(float(tax) * 100 / float(price) + 0.5)) + '%'

    return specs, amount, uprice, price, ratio

def get_date(line, price, ratio):
    sdate = ''
    edate = ''

    pattern = re.compile(r'\-?[\dBG:]+\.?[\dBG]*$')
    numbers = []

    for d in line:
        if pattern.match(d['text']):
            d['text'] = d['text'].replace('B','8').replace('G', '6').replace(':','')
            numbers.append(d)

    if len(numbers):
        for n in numbers:
            line.remove(n)

        # preprocess_number(numbers)
        numbers = sorted(numbers, key=lambda x: x['cx'] - x['w'] / 2)
        if not ratio and re.match(r'^\d{2,3}$', numbers[-1]['text']):
            ratio = numbers[-1]['text']
            ratio = ratio[:-1] + '%'
            numbers = numbers[0:-1]
        if not price:
            price = numbers[-1]['text']
            m = re.match(r'(\d+\.\d{2})\d*(\d{2})$', price)
            if m and not ratio:
                price = m.group(1)
                ratio = m.group(2) + '%'

            numbers = numbers[0:-1]

        numlen = len(numbers)
        if numlen == 2:
            sdate = numbers[0]['text']
            edate = numbers[1]['text']
        elif numlen == 1:
            edate = numbers[0]['text']

    return sdate, edate, price, ratio

def get_platenum_cartype(line, sdate, edate):
    platenum = ''
    cartype = ''

    pattern = re.compile(r'([\u4e00-\u9fa5]+)(\d{8,})$')
    if len(line) == 2:
        platenum = line[0]['text']
        cartype = line[1]['text']
    elif len(line) == 1:
        if not sdate:
            cartype = line[0]['text']
        else:
            platenum = line[0]['text']

    if cartype and not sdate:
        m = pattern.match(cartype)
        if m:
            cartype, sdate = m.group(1), m.group(2)
            if len(sdate) > 8 and not edate:
                edate = sdate[8:]
                sdate = sdate[:8]

    return platenum, cartype, sdate, edate


def preprocess_number(numbers):
    number = [i for i,n in enumerate(numbers) if n['text'].find(':')>-1]
    adds = []
    removes = []
    for i in number:
        d = numbers[i]
        text = d['text']
        splits = text.split(':')
        d1 = dict(d)
        d1['text'] = splits[0]
        d1['w'] = d['w'] * len(d1['text']) / len(text)
        d1['cx'] = d['cx'] - d['w'] / 2 + d1['w'] / 2

        d2 = dict(d)
        d2['text'] = splits[1]
        d2['w'] = d['w'] * len(d2['text']) / len(text)
        d2['cx'] = d['cx'] + d['w'] / 2 - d2['w'] / 2

        removes.append(d)
        adds.extend([d1, d2])

    for d in removes:
        numbers.remove(d)
    numbers.extend(adds)

def get_amount_uprice(price, upricecand, amtcand=None):
    price = float(price)
    specs = ''
    amount = ''
    uprice = ''

    copyprice = upricecand
    dotplace = upricecand.find('.')
    if dotplace > 0:
        upricecand = upricecand[:dotplace] + upricecand[dotplace + 1:]

    if amtcand:
        upr = str(math.trunc(float(price) / float(amtcand) * 100))
        idx = upricecand.find(upr)
        if idx >= 0:
            amount = amtcand
            upricecand = upricecand[idx:]
            dot = len(upr[:-2])
            uprice = upricecand[:dot] + '.' + upricecand[dot:]

    if not uprice:
        end = dotplace - 1 if dotplace else len(upricecand) - 2
        for idx in range(2, end):
            amt = int(upricecand[:idx])
            upr = upricecand[idx:]
            if not amt:
                break

            calcupr = price / amt
            if calcupr < 1:
                break
            dot = str(calcupr).find('.')
            if dot > len(upr):
                break
            upr = float(upr[0:dot] + '.' + upr[dot:])
            if abs(upr - calcupr) < 1:
                amount = str(amt)
                uprice = str(upr)
                break
            # upr = str(math.trunc(price / amt * 100))
            # if len(upr) < 3:
            #     break
            # i = upricecand.find(upr, idx)
            # if i > 0:
            #     amount = upricecand[0:i]
            #     uprice = upricecand[i:]
            #     dotplace = str(price / int(amount)).find('.')
            #     uprice = uprice[:dotplace] + '.' + uprice[dotplace:]
            #     break

        if not uprice:
            m = re.match(r'(\d+0+)([1-9]\d*\.\d+)', copyprice)
            if m:
                amount = m.group(1)
                uprice = m.group(2)
            else:
                uprice = copyprice
                if amtcand:
                    amount = amtcand
        else:
            if amtcand:
                specs = amtcand

    return specs,amount,uprice

def get_specs_unit(line, specs):
    unit = ''
    linelen = len(line)
    if linelen == 2:
        specs = line[0]['text']
        unit = line[1]['text']
    if linelen == 1:
        text = line[0]['text']
        if specs:
            unit = text
        else:
            if len(text) == 1:
                unit = text
            else:
                specs = text

    return specs,unit

def is_wrapped_title(data, line, boundary):
    res = False
    xmin = boundary[0]
    dx = abs(data['cx'] - data['w'] / 2 - xmin) # 该data的左边与最左边的差的绝对值
    text = data['text'] #
    if len(text) == 0: # 自己加的
        return res

    if dx < LEFT_MARGIN and text[0] != '*': # 偏左并且开头不是*
        res = True

    return res

def check_title(line, data, start, end, boundary):
    xmin = boundary[0]

    lf = min(line, key=lambda d:d['cx'] - d['w'] / 2)
    dx = abs(lf['cx'] - lf['w'] / 2 - xmin)
    if dx > LEFT_MARGIN:
        for d in data[start:end]:
            dx = abs(d['cx'] - d['w'] / 2 - xmin)
            if dx < LEFT_MARGIN:
                iou = [calc_axis_iou(d,l,1) for l in line]
                if np.mean(iou) > 0.3:
                    line.append(d)
                    data.remove(d)
                    break

def check_wrap_title(res, wraptitles, line=None):
    title = res[-1][0]
    wraplen = len(wraptitles)
    if wraplen:
        idx = 0
        if not line:
            wrap = wraptitles[:]
        else:
            wrap = []
            ref = min(line, key=lambda x:x['cx']-x['w']/2)
            for i,w in enumerate(wraptitles):
                if w['cy'] < ref['cy']:
                    wrap.append(w)
                else:
                    break

        if len(wrap):
            del wraptitles[0:len(wrap)]
            title = reduce(lambda a,b:a+b, [w['text'] for w in wrap], title)
            res[-1][0] = title


def get_basic_boundary(data):
    indexes = [i for i, d in enumerate(data) if re.search(r'开.?日期|票日期|校.?码|2?年?月', d['text'])]
    # print(data[71])
    if len(indexes):
        end = max(indexes)
    else:
        end = 8
    lt = min(data[:end+1]+data[-10:], key=lambda x:x['cx']-x['w']/2)
    rt = max(data[:end+1]+data[-10:], key=lambda x:x['cx']+x['w']/2)

    left = lt['cx'] - lt['w'] / 2
    right = rt['cx'] + rt['w'] / 2

    return (0, end, left, right)

def get_basic_checkcode(basic):
    checkcode = ''
    candidates = [d for d in basic if re.search(r'^te校.?码*', d['text'])]
    if len(candidates):
        m = re.match(r'^校.?码.*?(\d+)', candidates[0]['text'])
        checkcode = m.group(1) if m else ''

    return checkcode
def get_basic_checkcode2(date):
    checkcode = ''
    candidates = [d for d in date if re.search(r'^校.?码*', d['text'])] # 找到，切只能找到一个
    if len(candidates) <=0:
        return ''
    # indexs = [idx for idx,d in enumerate(date) if re.search(r'^校.?码*', d['text'])]
    indexs = [i for i, d in enumerate(date) if re.search(r'^校.?码*', d['text'])]

    # 整体框的时候
    if candidates[0]['text'].find(':') >= 0:
        checkcode = candidates[0]['text'].split(':')[1]
    if len(checkcode)==20:
        return checkcode

    if len(candidates) == 1: # 不是整体框的时候
        r = indexs[0] + 5
        l = max(indexs[0]-5,0)

        can = date[l:r]
        x = float(candidates[0]['cx']) + float(candidates[0]['w'])/2
        y = float(candidates[0]['cy']) + float(candidates[0]['h'])/2
        distance_min = 10000
        index = 0
        for i in range(0,len(can)): # 先找到一个最小的离验证码框
            x_tem = float(can[i]['cx']) - float(can[i]['w'])/2
            y_tem = float(can[i]['cy']) + float(can[i]['h'])/2
            distance_tem = math.sqrt(math.pow((x - x_tem),2) + math.pow((y-y_tem),2))
            if distance_tem < distance_min:
                distance_min = distance_tem
                index = i
        flags = []
        flags.append(index)
        checkcode = can[index]['text']
        for i in (0,4):
            if(len(checkcode)>=20):
                break
            x = float(can[index]['cx']) + float(can[index]['w']) / 2
            y = float(can[index]['cy']) + float(can[index]['h']) / 2
            distance_min = 10000
            for j in range(0,len(can)):
                if j not in flags:
                    x_tem = float(can[j]['cx']) - float(can[j]['w']) / 2
                    y_tem = float(can[j]['cy']) + float(can[j]['h']) / 2
                    distance_tem = math.sqrt(math.pow((x - x_tem), 2) + math.pow((y - y_tem), 2))
                    if distance_tem < distance_min:
                        distance_min = distance_tem
                        index = j
            if can[index]['text'].isdigit():
                checkcode += can[index]['text']
                flags.append(index)



        # m = re.match(r'^校.?码.*?(\d+)', candidates[0]['text'])
        # checkcode = m.group(1) if m else ''

    return checkcode
PROVINCE = ['河北','山西','辽宁','吉林','黑龙江','江苏','浙江','安徽','福建','江西','山东','河南','湖北','湖南','广东','海南','四川','贵州','云南','陕西']

def get_basic_type(basic):
    type = ''
    title = ''
    elec = '电子' if len([d for d in basic if re.search(r'发票代码', d['text'])])>0 else ''

    candidates = [d for d in basic if re.search(r'.*(专?用?|通)?发票', d['text'])]
    if len(candidates):
        text = candidates[0]['text']

        if text.find('用') >= 0 or text.find('专') >= 0:
            type = elec + '专用发票'
        else:
            type = elec + '普通发票'

        suffix = '增值税' + type
        title = suffix
        # ---新加的
        for p in PROVINCE:
            indexs = [d for d in basic if re.search(p, d['text'])]
            if len(indexs):
                title = p + suffix
                return type,title
        # ----
        if text[:2] in PROVINCE:
            title = text[:2] + suffix
        elif text[:3] in PROVINCE:
            title = text[:3] + suffix
        else:
            titles = [d for d in basic if re.search(r'^.*增值?', d['text'])]
            if len(titles):
                title = titles[0]['text']
                i = title.find('增')
                title = title[:i] + suffix
            else:
                i = basic.index(candidates[0])
                titles = [basic[i-1], basic[i+1]]
                for t in titles:
                    if re.match(r'[\u4e00-\u9fa5]{2,3}', t['text']): # duociyiju
                        # title = t['text'] + suffix
                        break
    else:
        for p in PROVINCE:
            indexs = [d for d in basic if re.search(p, d['text'])]
            if len(indexs):
                title = p + '增值税' + '发票'
                return type, title
    return type,title

def get_basic_title(basic, type):
    title = ''
    elec = '电子' if len([d for d in basic if re.search(r'发票代码', d['text'])]) > 0 else ''

    candidates = [d for d in basic if re.search(r'^.*增值?', d['text'])]
    if len(candidates):
        title = candidates[0]['text']
        i = title.find('增')
        title = title[:i] + '增值税' + elec + type

    return title

def get_basic_date(basic):
    date = ''
    # candidates = [d for d in basic if re.search(r'开?票?日期', d['text'])]
    candidates = [d for d in basic if re.search(r'2?年?月', d['text'])]
    if len(candidates):# 原来的Pse wangluo shi zhengti kuangde
        date = candidates[0]['text']
        date = re.sub(r'开?票?日期:?', '', date)

    return date

def get_basic_code(basic):
    code = ''
    candidates = [d for d in basic if re.search(r'(发票代码:?\d+)|(^\d{10,12}$)', d['text'])]
    if len(candidates):
        code = max(candidates, key=lambda x:x['cx']+x['w']/2)
        m = re.match(r'.*?(\d+)$', code['text'])
        code = m.group(1) if m else ''

    return code

def get_basic_sn(basic):
    sn = ''
    candidates = [d for d in basic if re.search(r'(发票号码:?\d+)|(^\d{8}$)', d['text'])]
    if len(candidates):
        code = max(candidates, key=lambda x: x['cx'] + x['w'] / 2)
        m = re.match('.*?(\d+)$', code['text'])
        sn = m.group(1) if m else ''

    return sn

def get_basic_payee(data):
    payee = ''
    candidates = [d for d in data if re.search(r'收款人', d['text'])]
    if len(candidates):
        payee = max(candidates, key=lambda x: x['cy'])
        payee = re.sub(r'收款人:?', '', payee['text'])

    return payee


def get_basic_reviewer(data):
    reviewer = ''
    candidates = [d for d in data if re.search(r'(复核|发校)', d['text'])]
    if len(candidates):
        reviewer = max(candidates, key=lambda x: x['cy'])
        reviewer = re.sub(r'(复核|发校):?', '', reviewer['text'])

    return reviewer


def get_basic_drawer(data):
    drawer = ''
    candidates = [d for d in data if re.search(r'开票人', d['text'])]
    if len(candidates):
        drawer = max(candidates, key=lambda x: x['cy'])
        drawer = re.sub(r'开票人:?', '', drawer['text'])

    return drawer

def parse_person(text):
    if text.find(':') >= 0:
        text = text.split(':')[1]
    else:
        text = re.sub(r'.*((开?票?人)|(复?核)|(复)|(收?款?人))', '', text)
    return text

def get_basic_person(data, boundary):
    payee = ''
    reviewer = ''
    drawer = ''

    payee_text = ''
    reviewer_text = ''
    drawer_text = ''

    xmin = boundary[0]

    rear = data[-12:] #范围大一点，防止盖章和备注信息的影响
    indexes = [i for i,d in enumerate(rear) if re.search(r'收?款|开票人|复?核|人:|复.:', d['text'])]
    finded = len(indexes)
    if finded < 3:
        s = min(indexes) - 3
        e = min(10, max(indexes)+3)
        for i in range(s,e):
            if i not in indexes:
                text = rear[i]['text']
                l = len(text)
                if (text.find(':') > -1 and l < 8) or (text.find('钠售') < 0 and l < 4 and l > 1):
                    indexes.append(i)

        candidates = [rear[i] for i in indexes]
        if len(candidates):
            candidates = sorted(candidates, key=lambda x:x['cx']-x['w']/2)
            left = candidates[0]['cx'] - candidates[0]['w'] / 2 - xmin
            if left < 25:
                payee = candidates[0]
                candidates.pop(0)

            s = max([i for i, d in enumerate(data) if re.search(r'\(?大写\)?', d['text'])],default=0)
            e = min([i for i, d in enumerate(data) if re.search(r'\(?小写\)?.*(￥|Y|羊)?\d+', d['text'])],default=0)
            ref = data[e]
            s, e = (e-1, s+2) if e < s else (s, e+1)

            refs = sorted([data[i] for i in range(s,e) if calc_axis_iou(ref, data[i], 1)>0.01], key=lambda x: x['cx']-x['w']/2)
            if len(refs) >= 3:
                idx = refs.index(ref)
                ref = refs[idx-1]
                rl = ref['cx'] - ref['w'] / 2
                rr = ref['cx'] + ref['w'] / 2
                for c in candidates:
                    cl = c['cx'] - c['w'] / 2
                    cr = c['cx'] + c['w'] / 2
                    if cr > rr:
                        drawer = c
                        break
                    elif rl < c['cx'] and rr > c['cx']:
                        reviewer = c

    elif finded == 3:
        payee,reviewer,drawer = sorted([rear[i] for i in indexes],key=lambda x:x['cx']-x['w']/2)
        # payee_text = parse_person(payee['text'])
        payee_text = payee['text']
        if len(payee_text)>4:
            payee_text = payee_text[4:]
        else:
            x = float(payee['cx']) + float(payee['w'])/2
            y = float(payee['cy']) + float(payee['h'])/2 # 右下坐标

            index =0
            distance_min = 100000
            for i in range(len(data)-10,len(data)):
                tem_payee = data[i]
                x_tem = float(tem_payee['cx']) - float(tem_payee['w'])/2
                y_tem = float(tem_payee['cy']) + float(tem_payee['h']) / 2  # 左下坐标
                distance_tmp = math.sqrt(math.pow((x - x_tem), 2) + math.pow((y - y_tem), 2))
                if distance_tmp < distance_min and len(tem_payee['text']):
                    index = i
                    distance_min = distance_tmp
            payee = data[index]
            payee_text = payee['text']

#--------------------------------------------
        # reviewer_text = parse_person(reviewer['text'])
        reviewer_text = reviewer['text']
        if len(reviewer_text) > 3:
            reviewer_text = reviewer_text[3:]
        else :
            x = float(reviewer['cx']) + float(reviewer['w'])/2
            y = float(reviewer['cy']) + float(reviewer['h'])/2

            index = 0
            distance_min = 100000
            for i in range(len(data)-10,len(data)):
                tem_reviewer = data[i]
                x_tem = float(tem_reviewer['cx']) - float(tem_reviewer['w'])/2
                y_tem = float(tem_reviewer['cy']) + float(tem_reviewer['w'])/2
                distance_tmp = math.sqrt(math.pow((x - x_tem),2) + math.pow((y - y_tem),2))
                if distance_tmp < distance_min and len(tem_reviewer['text']):
                    distance_min = distance_tmp
                    index  = i

            reviewer = data[index]
            reviewer_text = reviewer['text']

#--------------------------------------------------------
        # drawer_text = parse_person(drawer['text'])
        drawer_text = drawer['text']

        if len(drawer_text) > 4:
            drawer_text = drawer_text[4:]
        else:
            x = float(drawer['cx']) + float(drawer['w'])/2
            y = float(drawer['cy']) + float(drawer['h'])/2

            index = 0
            distance_min = 100000
            for i in range(len(data)-10,len(data)):
                tem_drawer = data[i]
                x_tem = float(tem_drawer['cx']) - float(tem_drawer['w'])/2
                y_tem = float(tem_drawer['cy']) + float(tem_drawer['h'])/2
                distance_tmp = math.sqrt(math.pow((x - x_tem),2) + math.pow((y - y_tem),2))
                if distance_min > distance_tmp and len(tem_drawer['text']):
                    distance_min = distance_tmp
                    index = i
            drawer = data[index]
            drawer_text = drawer['text']
    return payee_text,reviewer_text,drawer_text



    if payee:
        payee = parse_person(payee['text'])
    if reviewer:
        reviewer = parse_person(reviewer['text'])
    if drawer:
        drawer = parse_person(drawer['text'])

    return payee, reviewer, drawer

def getBasics(data):
    s, e, left, right = get_basic_boundary(data)
    basic = data[s:e+1]

    # checkcode = get_basic_checkcode(basic) #
    checkcode = get_basic_checkcode2(data) # 只有电子发票有验证码
    type, title = get_basic_type(basic)
    # title = basic_title(basic, checkcode, type)
    code = get_basic_code(basic)
    sn = get_basic_sn(basic)
    date = get_basic_date(basic)

    # payee = basic_payee(data[-10:])
    # reviewer = basic_reviewer(data[-10:])
    # drawer = basic_drawer(data[-10:])
    payee, reviewer, drawer = get_basic_person(data, [left, right])

    res = [[{'name': r'发票类型','value': type},
            {'name': r'发票名称','value': title},
            {'name': r'发票代码','value': code},
            {'name': r'发票号码','value': sn},
            {'name': r'开票日期','value': date},
            {'name': r'校验码','value': checkcode},
            {'name': r'收款人','value': payee},
            {'name': r'复核','value': reviewer},
            {'name': r'开票人','value': drawer}]]
    del data[:e-1]
    return res
    # return {"type":type, "title":title, "code":code, "sn":sn, "date":date, "checkcode":checkcode, "payee":payee, "reviewer":reviewer, "drawer":drawer}

def get_buyer_boundary(data):
    indexes = [i for i, d in enumerate(data) if isTitle(d['text'])]
    end = min(indexes) # 为什么取最小  因为去tittle之前的

    indexes = [i for i, d in enumerate(data) if i < end and re.search(r'(开票日期)|(校.?码)|(2?年?月)', d['text'])]
    # print("len(indexes):",len(indexes))
    start = max(indexes,default=0) + 1 # 取 上面日期范围中最大的

    indexes = [i for i, d in enumerate(data[start:end]) if calc_axis_iou(data[start-1], d, 1) > 0.3]
    if len(indexes):
        start = start + max(indexes) + 1

    return start, end

def get_buyer_name(buyer):
    indexes = [i for i, d in enumerate(buyer) if re.search(r'[\u4e00-\u9fa5]{6,}', d['text'])]
    # indexes = [i for i, d in enumerate(buyer) if re.search(r'^称:[\u4e00-\u9fa5]{6,}', d['text'])]
    if len(indexes):
        index = indexes[0]
    else:
        indexes = [i for i, d in enumerate(buyer) if re.search(r'[\u4e00-\u9fa5]{6,}', d['text'])]
        index = indexes[0]
    name = buyer[index]
    text = name['text']
    if text.find(':') >= 0:
        name = text.split(':')[-1]
    else:
        name = re.sub(r'^[^\u4e00-\u9fa5]+?', '', text)
        name = re.sub(r'^称', '', name)

    return name, index

def get_buyer_taxnumber(buyer):
    indexes = [i for i, d in enumerate(buyer) if re.search(r'[0-9A-Z]{14,}', d['text'])]
    index = indexes[0]
    taxnumber = buyer[index]
    text = taxnumber['text']
    if text.find(':') >= 0:
        taxnumber = text.split(':')[1]
    else:
        taxnumber = re.sub(r'^[^0-9A-Z]+?', '', text)

    return taxnumber, index

def get_buyer_address(buyer):
    address = ''
    index = 0

    indexes = [i for i, d in enumerate(buyer) if re.search(r'电话:[\u4e00-\u9fa5]{7,}', d['text'])]
    if not len(indexes):
        indexes = [i for i, d in enumerate(buyer) if re.search(r'[\u4e00-\u9fa5]{7,}', d['text'])]

    if len(indexes):
        index = indexes[0]
        address = buyer[index]
        text = address['text']
        if text.find(':') >= 0:
            address_tem = text.split(':')
            address = ''
            for i in range(1,len(address_tem)):
                # print(address_tem[i])
                address += str(address_tem[i])
        else:
            address = text

        if not re.search(r'[0-9\-]{11,}$', address):
            # indexes = [i for i, d in enumerate(buyer) if re.match(r'\d+$', d['text']) and i > index]
            indexes = [i for i, d in enumerate(buyer) if re.match(r'[0-9\-]{6,}$', d['text'])]
            x = float(buyer[index]['cx']) + float(buyer[index]['w']/2)
            y = float(buyer[index]['cy']) + float(buyer[index]['h']/2)
            distance_min = 100000
            for i in indexes:
                x_tem = float(buyer[i]['cx']) - float(buyer[i]['w'] / 2)
                y_tem = float(buyer[i]['cy']) + float(buyer[i]['h'] / 2)
                distance_tem = math.sqrt(math.pow((x-x_tem),2) + math.pow((y-y_tem),2))
                if distance_min > distance_tem:
                    pass
                    index = i
                    distance_min = distance_tem
            address += buyer[index]['text']

             # address += buyer[index]['text']

            # if len(indexes):
            #     index = indexes[0]
            #     address += buyer[index]['text']

        for prov in PROVINCE:
            idx = address.find(prov)
            if idx > 0:
                address = address[idx:]
                break

    return address, index

def get_buyer_account(buyer):
    account = ''

    indexes = [i for i, d in enumerate(buyer) if re.search(r'账号:[\u4e00-\u9fa5]{7,}', d['text'])]
    if not len(indexes):
        indexes = [i for i, d in enumerate(buyer) if re.search(r'[\u4e00-\u9fa5]{7,}', d['text'])]
    if len(indexes):
        index = indexes[0]
        account = buyer[index]
        text = account['text']
        if text.find(':') >= 0:
            account = text.split(':')[1]
        else:
            account = text

        if not re.search(r'\d{12,}$', account):
            # indexes = [i for i, d in enumerate(buyer) if re.match(r'\d{12,}$', d['text']) and i > index]
            indexes = [i for i, d in enumerate(buyer) if re.match(r'\d{12,}$', d['text'])]
            if len(indexes):
                index = indexes[0]
                account += buyer[index]['text']

        idx = account.find(r'账号')
        if idx >= 0:
            account = account[idx+2:]

    return account

def getBuyer(data):
    start, end = get_buyer_boundary(data)
    buyer = data[start:end]

    name, index = get_buyer_name(buyer)
    buyer = buyer[index+1:]

    taxnum, index = get_buyer_taxnumber(buyer)
    buyer = buyer[index+1:]

    address, index = get_buyer_address(buyer)
    buyer = buyer[index+1:]

    account = get_buyer_account(buyer)

    res = [[{'name':r'名称', 'value':name},
            {'name':r'纳税人识别号', 'value':taxnum},
            {'name':r'地址、电话', 'value':address},
            {'name':r'开户行及账号','value':account}]]
    return res
    # return {"name":name, "taxnum":taxnum, "address":address, "account":account}

def isVehicle(data):
    ret = False
    l = len(data)
    for d in data[:int(l/2)]:
        if re.search(r'项目|类型|车牌|通行日期', d['text']):
            ret = True
            break

    return ret

def is_wrapped_title2(data, line, content, next, boundary) :
    """

    :param data: ct
    :param line: one line have
    :param content:
    :param next: save as now data next index
    :param boundary: left and right
    :return:
    """
    ret = False
    xmin = boundary[0]
    dx = abs(data['cx'] - data['w'] / 2 - xmin)
    text = data['text']

    if dx < LEFT_MARGIN :
        if len(text) < 6 and len(line) : # len(tittle)==6 and
            ret = True
        else :
            if not re.search(r'\*[\u4e00-\u9fa5]', text) : # is number
                if next == len(content) : # last one
                    if (not len(line) or calc_axis_iou(data, line) > 0.2) :
                        ret = True
                else : # is not last one
                    end = min([next + 8, len(content)])
                    neighbor = None
                    title = None
                    for c in content[next :end] :
                        if calc_axis_iou(c, data) > 0.2 :
                            title = c
                        else :
                            if neighbor is None :
                                neighbor = c
                            else :
                                dx = c['cx'] - data['cx']
                                #                                               must correct img_angle
                                if (neighbor['cx'] - data['cx'] > dx > 0) and calc_axis_iou(c, neighbor,1) > 0.3 and calc_axis_iou(c, neighbor) < 0.1 :
                                #   now neighbor is more near than before       in Y must be iou                    is not iou in X
                                    neighbor = c

                    if neighbor is None : # have not neighbor
                        ret = True
                    else :
                        y_iou = calc_axis_iou(neighbor, data, 1)
                        if y_iou > 0.3 : # neighbor and data have big iou
                            if len(line) and len(data) and len(neighbor):
                                if calc_axis_iou(neighbor, line, 1) > 0.1 and calc_axis_iou(neighbor,line) < 0.1 and calc_axis_iou(data, line) > 0.1 :
                                #  neighbor and before line have iou in Y        neighbor and before line have not iou in X     data and before line have iou in X
                                    ret = True
                        elif y_iou < 0.1 : # have little iou
                            ret = True
                        else : # have not iou in Y
                            if title is not None :
                                if calc_axis_iou(neighbor, title, 1) > 0.25 :
                                    ret = True
                            else :
                                if calc_axis_iou(data, line) > 0.2 :
                                    ret = True

    # if dx < LEFT_MARGIN and len(line) and calc_axis_iou(data, line) > 0.2 and (len(text) < 5 or not re.search(r'\*[\u4e00-\u9fa5]', text)):
    #     ret = True

    return ret


def getContent(data):
    res = []
    start,end,left,right = get_content_boundary(data)
    content = data[start+1:end]

    while len(content):
        left_tem = min(content, key = lambda x : x['cx'] - x['w'] / 2)
        if len(left_tem['text']) < 3 :
            content.remove(left_tem)
        else :
            break
    while len(content):
        right_tem = max(content, key = lambda x : x['cx'] + x['w'] / 2)
        if len(right_tem['text']) < 3 :
            content.remove(right_tem)
        else :
            break

    isvehicle = isVehicle(data) # 是否是私家车
    # top = min(content, key=lambda x:float(x['cy'])-float(x['h']/2))
    # bottom = max(content, key=lambda x: float(x['cy'])+float(x['h']/2))
    # lh = (bottom['cy'] + bottom['h']/2 - top['cy'] + top['h']/2) / 8

    lt = min(content, key=lambda x:float(x['cx'])-float(x['w']/2)) # 得到最左边的
    rb = max(content, key=lambda x: float(x['cx'])+float(x['w']/2)) # 得到最右边的

    # 下面这两行是根据中间的内容找的，不加就是根据 title 找的
    left = float(lt['cx'])-float(lt['w']/2) # 得到最左边的边
    right = float(rb['cx'])+float(rb['w']/2) # 得到最右边的边

    line = []
    wraptitle = [] #
    for idx,ct in enumerate(content):

        deal = False
        # iswrap = is_wrapped_title(ct, line, [left,right]) # ?? 可能是判断该行是不是之前的换行 True 是 上一行
        iswrap = is_wrapped_title2(ct, line, content, idx + 1, [left, right])
        if not iswrap and ct not in wraptitle:
            linelen = len(line)
            if linelen:
                y_ious = []
                for l in line:
                    x_iou = calc_axis_iou(l, ct) # l 是 dict,ct 是 dict
                    y_iou = calc_axis_iou(l, ct, 1)
                    y_ious.append(y_iou)
                    if x_iou > 0.3: # 交叉部分大就跳出
                        deal = True
                        break
                if not deal and np.mean(y_ious) < 0.05:# y的差距小 说明在一行
                    deal = True

            if deal == False:
                line.append(ct)
            else: # deal 为 true 已经跳出，说明当前的ct与之前的line里面的存在交叉
                #           存前idx  总
                check_title(line, content, idx+1, idx+4, [left,right])
                if len(res): # 如果结果中已经有值，可以把判断为换行的tittle加到上一行
                    check_wrap_title(res, wraptitle, line)
                parsed = parseLine(line, [left, right], isvehicle)
                res.append(parsed)

                line = [ct]
        else: # 是换行
            #--- shihuanhang qie huanhang de neirong bei fencheng duoge bufen
            if ct not in wraptitle:
                wraptitle.append(ct)
                start_idx = idx+1
                end_idx = idx + 3
                if end_idx > len(content):
                    end_idx = len(content)
                for i in range(start_idx,end_idx):
                    y_iou = calc_axis_iou(content[i], ct, 1)
                    if i != idx and calc_axis_iou(content[i], ct, 1) > 0.9:
                        wraptitle.append(content[i])
            #---
            # flag = 0

    if len(line) + len(wraptitle) >= 3:
        if len(res):
            check_wrap_title(res, wraptitle, line)
        if len(wraptitle):
            line.extend(wraptitle)
        parsed = parseLine(line, [left, right], isvehicle)
        res.append(parsed)

    ret = []
    calcprice = 0
    calctax = 0
    for r in res:
        if isvehicle:
            title, platenum, type, sdate, edate, price, ratio, tax = r
            ret.append([{'name': r'项目名称', 'value': title},
                        {'name': r'车牌号', 'value': platenum},
                        {'name': r'类型', 'value': type},
                        {'name': r'通行日期起', 'value': sdate},
                        {'name': r'通行日期止', 'value': edate},
                        {'name': r'金额', 'value': price},
                        {'name': r'税率', 'value': ratio},
                        {'name': r'税额', 'value': tax}])
        else:
            title, specs, unit, amount, uprice, price, ratio, tax = r
            ret.append([{'name': r'名称', 'value': title},
                        {'name': r'规格型号', 'value': specs},
                        {'name': r'单位', 'value': unit},
                        {'name': r'数量', 'value': amount},
                        {'name': r'单价', 'value': uprice},
                        {'name': r'金额', 'value': price},
                        {'name': r'税率', 'value': ratio},
                        {'name': r'税额', 'value': tax}])
        # print("price:",price)
        if len(price):
            calcprice += float(price)
        calctax += float(tax) if is_number(tax) else 0

    calctotal = '%.2f' % (calcprice + calctax)
    calcprice = '%.2f' % calcprice
    if calctax <= 0.001:
        calctax = '***'
    else:
        calctax = '%.2f' % calctax
    return ret, (calctotal, calcprice, calctax)

def get_seller_boundary(data):
    s = max([i for i, d in enumerate(data) if re.search(r'\(?大写\)?|价税合?计?', d['text'])])
    # e = min([i for i, d in enumerate(data[s-4:]) if re.search(r'\(?小写?\)?', d['text'])])
    e = min([i for i, d in enumerate(data) if re.search(r'(￥|Y|羊)[0-9]+(.[0-9]{2})?$|\(?小写\)?', d['text'])])
    # e = min([i for i, d in enumerate(data) if re.search(r'\(?小写\)?.*(￥|Y|羊)?\d+', d['text'])])


    start = max([s,e]) + 1
    # start = max([i for i, d in enumerate(data) if re.search(r'\(?小写\)?|\(?大写\)?|价税合?计?|￥[0-9]+(.[0-9]{2})?$|Y[0-9]+(.[0-9]{2})?$|羊[0-9]+(.[0-9]{2})?$', d['text'])]) + 1
    # if abs(s-e) == 1:
    #     start = start + 1 # 为什么 +1
    end = len(data) - 2

    benchmark = ['仟', '佰', '拾', '亿', '仟', '佰', '拾', '万', '仟', '佰', '拾', '圆', '角', '分','零','壹','贰','叁','肆','伍','陆','柒','捌','玖','拾','整']

    text = data[start]['text']
    i = 0
    for t in text:
        if t in benchmark:
            i += 1

    if i>2:
        return start + 1,end
    else:
        return start, end

def get_seller_name(buyer):
    name = ''
    index = -1
#                                                             匹配中文
    indexes = [i for i, d in enumerate(buyer) if re.search(r'[\u4e00-\u9fa5]{6,}', d['text'])]
    if len(indexes):
        index = indexes[0]
        name = buyer[index]
        text = name['text']
        # -----
        if len(text):
            benchmark = ['仟', '佰', '拾', '亿', '仟', '佰', '拾', '万', '仟', '佰', '拾', '圆', '角', '分','零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖', '拾','整']
            flag = 0
            for i in range(0,len(text)):
                if text[i] in benchmark:
                    flag += 1
            if flag > 3 and len(indexes) > 1:
                index = indexes[1]
                name = buyer[index]
                text = name['text']
        # ---
        if text.find(':') >= 0:
            name = text.split(':')[1]
        else:
            name = re.sub(r'^[^\u4e00-\u9fa5]+?', '', text)
            name = re.sub(r'^称|你', '', name)

    return name, index

def get_seller_taxnumber(buyer,RIGHT_MOST):
    taxnumber = ''
    index = -1

    # 排除备注中的信息，以图片的中间为限
    indexes = [i for i, d in enumerate(buyer) if float(d['cx']) - float(d['w'])/2 <= RIGHT_MOST/2 and re.search(r':[0-9A-Z]{16,}|^[0-9A-Z]{16,}', d['text'])]
    if len(indexes):
        index = indexes[0]
        taxnumber = buyer[index]
        text = taxnumber['text']
        if text.find(':') >= 0:
            taxnumber_tem = text.split(':')
            taxnumber = ''
            for i in range(0,len(taxnumber_tem)):
                if re.search(r'^[0-9A-Z]{1,}',taxnumber_tem[i]):
                    taxnumber += taxnumber_tem[i]
        else:
            taxnumber = re.sub(r'^[^0-9A-Z]+?', '', text)

    return taxnumber, index

def get_seller_address(buyer,RIGHT_MOST):
    address = ''
    index = -1

#                                                              匹配中文
    indexes = [i for i, d in enumerate(buyer) if float(d['cx']) - float(d['w'])/2<= RIGHT_MOST/2 and re.search(r'[\u4e00-\u9fa5]{6,}', d['text']) and not re.search('识别号',d['text'])]
    index_add = sorted([d for i, d in enumerate(buyer) if re.search('地址|电话',d['text'])],key=lambda x: x['cx'] + x['w'] / 2,reverse=True)
    if len(index_add):
        index = buyer.index(index_add[0])
        address = index_add[0]
        text = address['text']
        if text.find(':') >= 0:
            address = text.split(':')[1]
        else:
            address = ''

        address = re.sub(r'^地址、?电话', '', address)
        index_max = int(index)
        bre = 0
        while True:  # forbid seller address three part
            if not re.search(r'[0-9\-]{11,}$', address):
                #---- deal with 8 -> B
                rear_text = address.replace('B','8')
                if re.search(r'[0-9\-]{11,}$', rear_text):
                    for i in range(len(address) - 1,-1,-1):
                        if re.search(r'[\u4e00-\u9fa5]',address[i]):
                            break
                        if address[i] == 'B':
                            address = address[:i] + '8' + address[i+1:]
                    break
                #----
                indexs = [i for i, d in enumerate(buyer)]

                index_tem = get_min_distance_index(buyer[index], indexs, buyer)
                address += buyer[index_tem]['text']
                if index_tem > index_max:
                    index_max = index_tem
                index = index_tem
            else:
                break
            bre += 1
            if bre > 3:
                break
            # buyer.pop(index_tem)
        index = index_max

        for prov in PROVINCE:
            idx = address.find(prov)
            if idx > 0:
                address = address[idx:]
                break
        return address, index

    else:
        if len(indexes):
            index = indexes[0]
            address = buyer[index]
            text = address['text']
            if text.find(':') >= 0:
                address = text.split(':')[1]
            else:
                address = text
            address = re.sub(r'^地址、?电话', '', address)

            index_max = int(index)
            bre = 0
            while True: # forbid seller address three part
                if not re.search(r'[0-9\-]{11,}$',address):
                    indexs = [i for i,d in enumerate(buyer)]
                    index_tem = get_min_distance_index(buyer[index],indexs,buyer)
                    address += buyer[index_tem]['text']
                    if index_tem >index_max:
                        index_max = index_tem
                    index = index_tem
                else:
                    break
                bre += 1
                if bre > 3:
                    break
            index = index_max

            for prov in PROVINCE:
                idx = address.find(prov)
                if idx > 0:
                    address = address[idx:]
                    break

    return address, index

def get_seller_account(buyer):
    account = ''
    indexes = [i for i, d in enumerate(buyer) if re.search(r'[\u4e00-\u9fa5]{7,}', d['text'])]
    if len(indexes):
        index = indexes[0]
        account = buyer[index]
        text = account['text']
        if text.find(':') >= 0:
            splittxt = text.split(':')
            account = ''.join(splittxt[1:])
        else:
            account = text

        if not re.search(r'\d{12,}$', account):
            # indexes = [i for i, d in enumerate(buyer) if re.match(r'[0-9]{13,}$', d['text'])]
            indexes = [i for i, d in enumerate(buyer) if re.search(r'[0-9]{13,}$', d['text'])]
            ii = get_min_distance_index(buyer[index],indexes,buyer)
            # distance_min = 100000
            # ii = 0
            # for i in indexes:
            #     x_tem = float(buyer[i]['cx']) - float(buyer[i]['w']/2)
            #     y_tem = float(buyer[i]['cy']) + float(buyer[i]['h']/2)
            #     distance_tem = math.sqrt(math.pow((x-x_tem),2) + math.pow((y-y_tem),2))
            #     if distance_tem < distance_min:
            #         ii = i
            #         distance_min = distance_tem
            account += buyer[ii]['text']

            # if len(indexes):
            #     index = indexes[0]
            #     account += buyer[index]['text']

        idx = account.find(r'账号')
        if idx >= 0:
            account = account[idx+2:]

    return account

def getSeller(data):
    RIGHT_MOST = get_right_marge(data) # 找最右边的边
    start, end = get_seller_boundary(data) # 从大写/小写开始 到 倒数第二个结束
    seller = data[start:end]

    name, index = get_seller_name(seller)
    seller = seller[index + 1:]

    taxnum, index = get_seller_taxnumber(seller,RIGHT_MOST)
    seller = seller[index + 1:]
    address, index = get_seller_address(seller,RIGHT_MOST)
    seller = seller[index + 1:]

    account = get_seller_account(seller)

    res = [[{'name': r'名称', 'value': name},
            {'name': r'纳税人识别号', 'value': taxnum},
            {'name': r'地址、电话', 'value': address},
            {'name': r'开户行及账号', 'value': account}]]
    return res
    # return {"name": name, "taxnum": taxnum, "address": address, "account": account}

def get_summation_boundary(data):
    summation = [i for i, d in enumerate(data) if re.search(r'\(?大写\)?', d['text'])]
    summation.extend([i for i, d in enumerate(data) if re.search(r'\(?小写\)?.*(￥|Y|羊)?[\d\.]+$', d['text'])])
    summation.extend([i for i, d in enumerate(data) if re.search(r'(￥|Y|羊)[\d+\.]+$', d['text'])])

    start = min(summation) - 1
    end = max(summation) + 1

    return start, end

def check_price(price, calc):
    if price:
        price = re.sub(r'^\D+', '', price['text'])
        if re.search(r'[^\d\.]', price):
            price = calc
        else:
            idx = price.rfind(r'.')
            if idx <= 0:
                if len(price) > 2:
                    price = price[:-2] + '.' + price[-2:]
            else:
                price = price[:idx].replace(r'.', '') + (price[idx:] if len(price[idx:]) <= 3 else price[idx:idx + 3])

            if len(price) <= 2:
                price = calc
    else:
        price = calc

    return price

def getSummation(data, calcsum):
    benchmark = ['仟', '佰', '拾', '亿', '仟', '佰', '拾', '万', '仟', '佰', '拾', '圆', '角', '分']
    chinesedigit = ['零','壹','贰','叁','肆','伍','陆','柒','捌','玖','拾']
    tax = ''
    price = ''
    total = ''
    capital = ''

    calctotal, calcprice, calctax = calcsum
    _,_,_,right = get_content_boundary(data)

    start, end = get_summation_boundary(data)
    summation = data[start:end]

    prices = [d for d in summation if re.search(r'(￥|Y|羊)?[\d\.]+$', d['text'])]
    #--- 处理盖章乱盖 and summation
    if len(prices) > 3:
        prices = sorted(prices, key=lambda x: x['cx'],reverse=True)
        for i in range(len(prices) - 1, -1, -1):
            if not re.search(r'(￥|Y|羊)[\d\.]+$', prices[i]['text']):
                prices.pop(i)
            else: # 如果匹配到就break
                break
            if len(prices)==3:
                break
        if len(prices) > 3:
            Y = [d for i,d in enumerate(prices) if re.search(r'(￥|Y|羊)[\d\.]+$', d['text'])]
            if len(Y): # 处理税额的影响
                Y = sorted(Y,key=lambda x: x['cx'] + x['w'] / 2,reverse=True)
                tax_right = Y[0]

                if math.fabs(float(tax_right['cx']) + float(tax_right['w'])/2 - right) < RIGHT_MARGIN:
                    for j in range(len(prices)-1, -1, -1):
                        if tax_right != prices[j] and float(tax_right['cy'])>float(prices[j]['cy']):
                            cha_rate = calc_axis_iou(tax_right, prices[j], axis=0)
                            if calc_axis_iou(tax_right, prices[j], axis=0) > 0.5:
                                prices.pop(j)
                            if len(prices) == 3 :
                                break
            if len(Y): # 处理金额的影响
                Y = sorted(Y, key=lambda x: x['cx'] - x['w'] / 2)
                price_left = Y[0]
                if len(Y) > 1 and math.fabs(float(Y[-1]['cx']) + float(Y[-1]['w'])/2 - right) < RIGHT_MARGIN:
                    for j in range(len(prices) - 1 ,-1,-1):
                        if price_left != prices[j] and float(price_left['cy']) > float(prices[j]['cy']):
                            if calc_axis_iou(price_left, prices[j]) > 0.5:
                                prices.pop(j)
                            if len(prices) == 3:
                                break
                # 找一个条件说明是金额

    #---

    if len(prices): # 是不是该满足大于1
        prices = sorted(prices, key=lambda x: x['cy'], reverse=True) # big -> small
        p = prices[0]
        ll = calc_axis_iou(p, prices[1:], 1)
        if calc_axis_iou(p, prices[1:], 1) < 0.11:#  p 和 另外的数在y方向上都不存在交叉，说明 p 是 tatal
            total = p
            prices.remove(p)

    if len(prices):
        prices = sorted(prices, key=lambda x: x['cx'], reverse=True)
        p = prices[0]
        if abs(p['cx']+p['w']/2 - right) < RIGHT_MARGIN: # 最靠右的是tax
            tax = p
            prices.remove(p)

    if len(prices):
        price = prices[0]

    total = check_price(total, calctotal)
    price = check_price(price, calcprice)
    tax = check_price(tax, calctax)
    if total == calctotal and tax == calctax and math.fabs(float(calctax)+float(calcprice)-float(calctotal)) < 0.1: # 补丁 防止印章影响总的price
        price = calcprice
    strtotal = re.sub(r'\.', '', total)
    bm = benchmark[-len(strtotal):]

    for (c, b) in zip(strtotal, bm):
        capital += chinesedigit[int(c)] + b

    if int(total[-2:]) == 0:
        capital = capital[:-4] + '整'
    capital = re.sub(r'零[仟佰拾角分]', '零', capital)
    capital = re.sub(r'零{2,}', '零', capital)
    capital = re.sub(r'零$', '', capital)
    capital = re.sub(r'零圆', '圆', capital)

    if capital[-1] != '整' and capital[-1] != '分':
        capital += '整'
    res = [[{'name': r'金额合计', 'value': price},
            {'name': r'税额合计', 'value': tax},
            {'name': r'价税合计(大写)', 'value': capital},
            {'name': r'价税合计(小写)', 'value': total}]]
    return res

def calc_axis_iou(a,b,axis=0):
    if isinstance(b, list): # b 是list类型时
        if axis == 0: # x 方向的交叉率
            #                     左                        右                     左                 右
            ious = [calc_iou([a['cx'] - a['w'] / 2, a['cx'] + a['w'] / 2], [x['cx'] - x['w'] / 2, x['cx'] + x['w'] / 2]) for x in b] #
        else: # y fangxinag de jiaocha lv
            ious = [calc_iou([a['cy'] - a['h'] / 2, a['cy'] + a['h'] / 2], [x['cy'] - x['h'] / 2, x['cy'] + x['h'] / 2]) for x in b]
        iou = max(ious)
    elif isinstance(a, list):
        if axis == 0:
            ious = [calc_iou([x['cx'] - x['w'] / 2, x['cx'] + x['w'] / 2], [b['cx'] - b['w'] / 2, b['cx'] + b['w'] / 2]) for x in a]
        else:
            ious = [calc_iou([x['cy'] - x['h'] / 2, x['cy'] + x['h'] / 2], [b['cy'] - b['h'] / 2, b['cy'] + b['h'] / 2]) for x in a]
        iou = max(ious)
    else: # a b 都不是 list类型
        if axis == 0:#
            iou = calc_iou([a['cx'] - a['w'] / 2, a['cx'] + a['w'] / 2], [b['cx'] - b['w'] / 2, b['cx'] + b['w'] / 2])
        else:
            iou = calc_iou([a['cy'] - a['h'] / 2, a['cy'] + a['h'] / 2], [b['cy'] - b['h'] / 2, b['cy'] + b['h'] / 2])
    return iou

def sort_result(data):
    data = sorted(data, key=lambda d: d['cy'])
    lines = []
    line = []
    for i in range(len(data)):
        d = data[i]
        if not len(line):
            line.append(d)
        else:
            iou_x = calc_axis_iou(d, line, 0)
            iou_y = calc_axis_iou(d, line, 1)
            if iou_y > 0.6 and iou_x < 0.1:
                line.append(d)
            else:
                line = sorted(line, key=lambda l:l['cx']-l['w']/2)
                lines.append(line)
                line = [d]

    if len(line):
        line = sorted(line, key=lambda l: l['cx'] - l['w'] / 2)
        lines.append(line)

    return lines


def formatResult(data):

    basic = getBasics(data)

    buyer = getBuyer(data)

    content,calcsum = getContent(data)
    seller = getSeller(data)
    summation = getSummation(data, calcsum)
    res = [{'title':r'发票基本信息', 'items':basic},
           {'title':r'购买方', 'items':buyer},
           {'title':r'销售方', 'items':seller},
           {'title':r'货物或应税劳务、服务', 'items':content},
           {'title':r'合计', 'items':summation}]
    return res
    # return {"basic":basic, "buyer":buyer, "content":content, "seller":seller}

if __name__ == '__main__':

    parser = argparse.ArgumentParser(description='Hyperparams')
    parser.add_argument('--arch', nargs='?', type=str, default='resnet50')
    parser.add_argument('--resume', nargs='?', type=str, default=None,
                        help='Path to previous saved model to restart from')
    parser.add_argument('--binary_th', nargs='?', type=float, default=1.0,
                        help='Path to previous saved model to restart from')
    parser.add_argument('--kernel_num', nargs='?', type=int, default=7,
                        help='Path to previous saved model to restart from')
    parser.add_argument('--scale', nargs='?', type=int, default=1,
                        help='Path to previous saved model to restart from')
    parser.add_argument('--long_size', nargs='?', type=int, default=960,
                        help='Path to previous saved model to restart from')
    parser.add_argument('--min_kernel_area', nargs='?', type=float, default=5.0,
                        help='min kernel area')
    parser.add_argument('--min_area', nargs='?', type=float, default=300.0,
                        help='min area')
    parser.add_argument('--min_score', nargs='?', type=float, default=0.5,
                        help='min score')

    args = parser.parse_args()
    test(args)