import copy
import time
import traceback
import numpy as np
import cv2
import matplotlib.pyplot as plt
from format_convert.utils import log, pil_resize


def table_line(img, model, size=(512, 1024), prob=0.2, is_test=0):
    log("into table_line, prob is " + str(prob))

    # resize
    w, h = size
    img_new = pil_resize(img, h, w)
    img_show = copy.deepcopy(img_new)

    # predict
    start_time = time.time()
    pred = model.predict(np.array([img_new]))
    pred = pred[0]
    log("otr model predict time " + str(time.time() - start_time))

    # show
    show(pred, title='pred', prob=prob, mode=1, is_test=is_test)

    # 根据点获取线
    start_time = time.time()
    line_list = points2lines(pred, False, prob=prob)
    log("points2lines " + str(time.time() - start_time))
    if not line_list:
        return []
    show(line_list, title="points2lines", mode=2, is_test=is_test)

    # 清除短线
    start_time = time.time()
    line_list = delete_short_lines(line_list, img_new.shape)
    show(line_list, title="delete_short_lines", mode=2, is_test=is_test)
    log("delete_short_lines " + str(time.time() - start_time))

    # 分成横竖线
    start_time = time.time()
    row_line_list = []
    col_line_list = []
    for line in line_list:
        if line[0] == line[2]:
            col_line_list.append(line)
        elif line[1] == line[3]:
            row_line_list.append(line)
    log("divide rows and cols " + str(time.time() - start_time))

    # 两种线都需要存在，否则跳过
    if not row_line_list or not col_line_list:
        return []

    # 合并错开线
    start_time = time.time()
    row_line_list = merge_line(row_line_list, axis=0)
    col_line_list = merge_line(col_line_list, axis=1)
    show(row_line_list + col_line_list, title="merge_line", mode=2, is_test=is_test)
    log("merge_line " + str(time.time() - start_time))

    # 计算交点
    cross_points = get_points(row_line_list, col_line_list, (img_new.shape[0], img_new.shape[1]))
    if not cross_points:
        return []
    # 删除无交点线 需重复两次才删的干净
    row_line_list, col_line_list = delete_single_lines(row_line_list, col_line_list, cross_points)
    cross_points = get_points(row_line_list, col_line_list, (img_new.shape[0], img_new.shape[1]))
    row_line_list, col_line_list = delete_single_lines(row_line_list, col_line_list, cross_points)
    if not row_line_list or not col_line_list:
        return []

    # 多个表格分割线，获取多个表格区域
    start_time = time.time()
    split_lines, split_y = get_split_line(cross_points, col_line_list, img_new)
    area_row_line_list, area_col_line_list, area_point_list = get_split_area(split_y, row_line_list, col_line_list, cross_points)
    log("get_split_area " + str(time.time() - start_time))

    # 根据区域循环
    need_split_flag = False
    for i in range(len(area_point_list)):
        sub_row_line_list = area_row_line_list[i]
        sub_col_line_list = area_col_line_list[i]
        sub_point_list = area_point_list[i]

        # 修复边框
        start_time = time.time()
        new_rows, new_cols, long_rows, long_cols = fix_outline(img_new,
                                                               sub_row_line_list,
                                                               sub_col_line_list,
                                                               sub_point_list)

        # 如有补线
        if new_rows or new_cols:
            # 连接至补线的延长线
            if long_rows:
                sub_row_line_list = long_rows
            if long_cols:
                sub_col_line_list = long_cols
            # 新的补线
            if new_rows:
                sub_row_line_list += new_rows
            if new_cols:
                sub_col_line_list += new_cols
            need_split_flag = True
            area_row_line_list[i] = sub_row_line_list
            area_col_line_list[i] = sub_col_line_list

    row_line_list = [y for x in area_row_line_list for y in x]
    col_line_list = [y for x in area_col_line_list for y in x]

    if need_split_flag:
        # 修复边框后重新计算交点
        cross_points = get_points(row_line_list, col_line_list, (img_new.shape[0], img_new.shape[1]))
        split_lines, split_y = get_split_line(cross_points, col_line_list, img_new)
        area_row_line_list, area_col_line_list, area_point_list = get_split_area(split_y, row_line_list, col_line_list, cross_points)

    show(cross_points, title="get_points", img=img_show, mode=4, is_test=is_test)
    show(split_lines, title="split_lines", img=img_show, mode=3, is_test=is_test)
    show(row_line_list + col_line_list, title="fix_outline", mode=2, is_test=is_test)
    log("fix_outline " + str(time.time() - start_time))

    # 根据区域循环
    for i in range(len(area_point_list)):
        sub_row_line_list = area_row_line_list[i]
        sub_col_line_list = area_col_line_list[i]
        sub_point_list = area_point_list[i]

        # 验证轮廓的4个交点
        sub_row_line_list, sub_col_line_list = fix_4_points(sub_point_list, sub_row_line_list, sub_col_line_list)

        # 把四个边线在加一次
        sub_point_list = get_points(sub_row_line_list, sub_col_line_list, (img_new.shape[0], img_new.shape[1]))
        sub_row_line_list, sub_col_line_list = add_outline(sub_point_list, sub_row_line_list, sub_col_line_list)

        # 修复内部缺线
        start_time = time.time()
        sub_row_line_list, sub_col_line_list = fix_inner(sub_row_line_list, sub_col_line_list, sub_point_list)
        log("fix_inner " + str(time.time() - start_time))
        show(sub_row_line_list + sub_col_line_list, title="fix_inner1", mode=2, is_test=is_test)

        # 合并错开
        start_time = time.time()
        sub_row_line_list = merge_line(sub_row_line_list, axis=0)
        sub_col_line_list = merge_line(sub_col_line_list, axis=1)
        log("merge_line " + str(time.time() - start_time))
        show(sub_row_line_list + sub_col_line_list, title="merge_line", mode=2, is_test=is_test)

        # 修复内部线后重新计算交点
        start_time = time.time()
        cross_points = get_points(sub_row_line_list, sub_col_line_list, (img_new.shape[0], img_new.shape[1]))
        show(cross_points, title="get_points3", img=img_show, mode=4, is_test=is_test)

        # 消除线突出，获取标准的线
        area_row_line_list[i], area_col_line_list[i] = get_standard_lines(sub_row_line_list, sub_col_line_list)
        show(area_row_line_list[i] + area_col_line_list[i], title="get_standard_lines", mode=2, is_test=is_test)

    row_line_list = [y for x in area_row_line_list for y in x]
    col_line_list = [y for x in area_col_line_list for y in x]

    line_list = row_line_list + col_line_list
    # 打印处理后线
    show(line_list, title="all", img=img_show, mode=5, is_test=is_test)
    log("otr postprocess table_line " + str(time.time() - start_time))
    return line_list


def show(pred_or_lines, title='', prob=0.2, img=None, mode=1, is_test=0):
    if not is_test:
        return

    if mode == 1:
        plt.figure()
        plt.title(title)

        _array = []
        for _h in range(len(pred_or_lines)):
            _line = []
            for _w in range(len(pred_or_lines[_h])):
                _prob = pred_or_lines[_h][_w]
                if _prob[0] > prob:
                    _line.append((0, 0, 255))
                elif _prob[1] > prob:
                    _line.append((255, 0, 0))
                else:
                    _line.append((255, 255, 255))
            _array.append(_line)
        # plt.axis('off')
        plt.imshow(np.array(_array))
        plt.show()

    elif mode == 2:
        plt.figure()
        plt.title(title)
        for _line in pred_or_lines:
            x0, y0, x1, y1 = _line
            plt.plot([x0, x1], [y0, y1])
        plt.show()

    elif mode == 3:
        for _line in pred_or_lines:
            x0, y0 = _line[0]
            x1, y1 = _line[1]
            cv2.line(img, [int(x0), int(y0)], [int(x1), int(y1)], (0, 0, 255), 2)
        cv2.namedWindow(title, cv2.WINDOW_NORMAL)
        cv2.imshow(title, img)
        cv2.waitKey(0)

    elif mode == 4:
        for point in pred_or_lines:
            point = [int(x) for x in point]
            cv2.circle(img, (point[0], point[1]), 1, (0, 255, 0), 2)
        cv2.namedWindow(title, cv2.WINDOW_NORMAL)
        cv2.imshow(title, img)
        cv2.waitKey(0)

    elif mode == 5:
        for _line in pred_or_lines:
            x0, y0, x1, y1 = _line
            cv2.line(img, [int(x0), int(y0)], [int(x1), int(y1)], (0, 255, 0), 2)
        cv2.namedWindow(title, cv2.WINDOW_NORMAL)
        cv2.imshow(title, img)
        cv2.waitKey(0)


def points2lines(pred, sourceP_LB=True, prob=0.2, line_width=8, padding=3, min_len=10,
                 cell_width=13):
    _time = time.time()

    log("starting points2lines")
    height = len(pred)
    width = len(pred[0])

    _sum = list(np.sum(np.array((pred[..., 0] > prob)).astype(int), axis=1))

    h_index = -1
    h_lines = []
    v_lines = []
    _step = line_width
    while 1:
        h_index += 1
        if h_index >= height:
            break
        w_index = -1
        if sourceP_LB:
            h_i = height - 1 - h_index
        else:
            h_i = h_index
        _start = None
        if _sum[h_index] < min_len:
            continue
        last_back = 0
        while 1:
            if w_index >= width:
                if _start is not None:
                    _end = w_index - 1
                    _bbox = [_start, h_i, _end, h_i]
                    _dict = {"bbox": _bbox}
                    h_lines.append(_dict)
                    _start = None
                break
            _h, _v = pred[h_i][w_index]
            if _h > prob:
                if _start is None:
                    _start = w_index
                w_index += _step
            else:
                if _start is not None:
                    _end = w_index - 1
                    _bbox = [_start, h_i, _end, h_i]
                    _dict = {"bbox": _bbox}
                    h_lines.append(_dict)
                    _start = None

                w_index -= _step // 2
                if w_index <= last_back:
                    w_index = last_back + _step // 2
                last_back = w_index

    log("starting points2lines 1")
    w_index = -1

    _sum = list(np.sum(np.array((pred[..., 1] > prob)).astype(int), axis=0))
    _step = line_width
    while 1:
        w_index += 1
        if w_index >= width:
            break
        if _sum[w_index] < min_len:
            continue
        h_index = -1
        _start = None
        last_back = 0
        list_test = []
        list_lineprob = []
        while 1:
            if h_index >= height:
                if _start is not None:
                    _end = last_h
                    _bbox = [w_index, _start, w_index, _end]
                    _dict = {"bbox": _bbox}
                    v_lines.append(_dict)
                    _start = None
                    list_test.append(_dict)
                break
            if sourceP_LB:
                h_i = height - 1 - h_index
            else:
                h_i = h_index

            _h, _v = pred[h_index][w_index]
            list_lineprob.append((h_index, _v))
            if _v > prob:
                if _start is None:
                    _start = h_i
                h_index += _step
            else:
                if _start is not None:
                    _end = last_h
                    _bbox = [w_index, _start, w_index, _end]
                    _dict = {"bbox": _bbox}
                    v_lines.append(_dict)
                    _start = None
                    list_test.append(_dict)

                h_index -= _step // 2
                if h_index <= last_back:
                    h_index = last_back + _step // 2
                last_back = h_index

            last_h = h_i
    log("starting points2lines 2")

    for _line in h_lines:
        _bbox = _line["bbox"]
        _bbox = [max(_bbox[0] - 2, 0), (_bbox[1] + _bbox[3]) / 2, _bbox[2] + 2, (_bbox[1] + _bbox[3]) / 2]
        _line["bbox"] = _bbox

    for _line in v_lines:
        _bbox = _line["bbox"]
        _bbox = [(_bbox[0] + _bbox[2]) / 2, max(_bbox[1] - 2, 0), (_bbox[0] + _bbox[2]) / 2, _bbox[3] + 2]
        _line["bbox"] = _bbox

    h_lines = lines_cluster(h_lines, line_width=line_width)
    v_lines = lines_cluster(v_lines, line_width=line_width)

    list_line = []
    for _line in h_lines:
        _bbox = _line["bbox"]
        _bbox = [max(_bbox[0] - 1, 0), (_bbox[1] + _bbox[3]) / 2, _bbox[2] + 1, (_bbox[1] + _bbox[3]) / 2]
        list_line.append(_bbox)
    for _line in v_lines:
        _bbox = _line["bbox"]
        _bbox = [(_bbox[0] + _bbox[2]) / 2, max(_bbox[1] - 1, 0), (_bbox[0] + _bbox[2]) / 2, _bbox[3] + 1]
        list_line.append(_bbox)

    log("points2lines cost %.2fs" % (time.time() - _time))

    # import matplotlib.pyplot as plt
    # plt.figure()
    # for _line in list_line:
    #     x0,y0,x1,y1 = _line
    #     plt.plot([x0,x1],[y0,y1])
    # for _line in list_line:
    #     x0,y0,x1,y1 = _line.bbox
    #     plt.plot([x0,x1],[y0,y1])
    # for point in list_crosspoints:
    #     plt.scatter(point.get("point")[0],point.get("point")[1])
    # plt.show()

    return list_line


def lines_cluster(list_lines, line_width):
    after_len = 0
    prelength = len(list_lines)
    append_width = line_width // 2
    while 1:
        c_lines = []
        first_len = after_len

        for _line in list_lines:
            bbox = _line["bbox"]
            _find = False
            for c_l_i in range(len(c_lines)):
                c_l = c_lines[len(c_lines) - c_l_i - 1]
                bbox1 = c_l["bbox"]
                bboxa = [max(0, bbox[0] - append_width), max(0, bbox[1] - append_width), bbox[2] + append_width,
                         bbox[3] + append_width]
                bboxb = [max(0, bbox1[0] - append_width), max(0, bbox1[1] - append_width), bbox1[2] + append_width,
                         bbox1[3] + append_width]

                _iou = getIOU(bboxa, bboxb)
                if _iou > 0:
                    new_bbox = [min(bbox[0], bbox[2], bbox1[0], bbox1[2]), min(bbox[1], bbox[3], bbox1[1], bbox1[3]),
                                max(bbox[0], bbox[2], bbox1[0], bbox1[2]), max(bbox[1], bbox[3], bbox1[1], bbox1[3])]
                    _find = True
                    c_l["bbox"] = new_bbox
                    break
            if not _find:
                c_lines.append(_line)
        after_len = len(c_lines)
        if first_len == after_len:
            break
        list_lines = c_lines
    log("cluster lines from %d to %d" % (prelength, len(list_lines)))
    return c_lines


def getIOU(bbox0, bbox1):
    width = abs(max(bbox0[2], bbox1[2]) - min(bbox0[0], bbox1[0])) - (
            abs(bbox0[2] - bbox0[0]) + abs(bbox1[2] - bbox1[0]))
    height = abs(max(bbox0[3], bbox1[3]) - min(bbox0[1], bbox1[1])) - (
            abs(bbox0[3] - bbox0[1]) + abs(bbox1[3] - bbox1[1]))
    if width <= 0 and height <= 0:
        iou = abs(width * height / min(abs((bbox0[2] - bbox0[0]) * (bbox0[3] - bbox0[1])),
                                       abs((bbox1[2] - bbox1[0]) * (bbox1[3] - bbox1[1]))))
        # print("getIOU", iou)
        return iou + 0.1
    return 0


def delete_short_lines(list_lines, image_shape, scale=100):
    # 排除太短的线
    x_min_len = max(5, int(image_shape[0] / scale))
    y_min_len = max(5, int(image_shape[1] / scale))
    new_list_lines = []
    for line in list_lines:
        if line[0] == line[2]:
            if abs(line[3] - line[1]) >= y_min_len:
                # print("y_min_len", abs(line[3] - line[1]), y_min_len)
                new_list_lines.append(line)
        else:
            if abs(line[2] - line[0]) >= x_min_len:
                # print("x_min_len", abs(line[2] - line[0]), x_min_len)
                new_list_lines.append(line)
    return new_list_lines


def delete_single_lines(row_line_list, col_line_list, point_list):
    new_col_line_list = []
    min_point_cnt = 2
    for line in col_line_list:
        p_cnt = 0
        for p in point_list:
            # if line[0] == p[0] and line[1] <= p[1] <= line[3]:
            if line[0] == p[0]:
                p_cnt += 1
            if p_cnt >= min_point_cnt:
                new_col_line_list.append(line)
                break
    new_row_line_list = []
    for line in row_line_list:
        p_cnt = 0
        for p in point_list:
            # if line[1] == p[1] and line[0] <= p[0] <= line[2]:
            if line[1] == p[1]:
                p_cnt += 1
            if p_cnt >= min_point_cnt:
                new_row_line_list.append(line)
                break
    return new_row_line_list, new_col_line_list


def merge_line(lines, axis, threshold=5):
    """
    解决模型预测一条直线错开成多条直线，合并成一条直线

    :param lines: 线条列表
    :param axis: 0:横线 1:竖线
    :param threshold: 两条线间像素差阈值
    :return: 合并后的线条列表
    """
    # 任意一条line获取该合并的line，横线往下找，竖线往右找
    lines.sort(key=lambda x: (x[axis], x[1 - axis]))
    merged_lines = []
    used_lines = []
    for line1 in lines:
        if line1 in used_lines:
            continue

        merged_line = [line1]
        used_lines.append(line1)
        for line2 in lines:
            if line2 in used_lines:
                continue

            if line1[1 - axis] - threshold <= line2[1 - axis] <= line1[1 - axis] + threshold:
                # 计算基准长度
                min_axis = 10000
                max_axis = 0
                for line3 in merged_line:
                    if line3[axis] < min_axis:
                        min_axis = line3[axis]
                    if line3[axis + 2] > max_axis:
                        max_axis = line3[axis + 2]
                # 判断两条线有无交集
                if min_axis <= line2[axis] <= max_axis \
                        or min_axis <= line2[axis + 2] <= max_axis:
                    merged_line.append(line2)
                    used_lines.append(line2)
        if merged_line:
            merged_lines.append(merged_line)

    # 合并line
    result_lines = []
    for merged_line in merged_lines:
        # 获取line宽的平均值
        axis_average = 0
        for line in merged_line:
            axis_average += line[1 - axis]
        axis_average = int(axis_average / len(merged_line))

        # 获取最长line两端
        merged_line.sort(key=lambda x: (x[axis]))
        axis_start = merged_line[0][axis]
        merged_line.sort(key=lambda x: (x[axis + 2]))
        axis_end = merged_line[-1][axis + 2]

        if axis:
            result_lines.append([axis_average, axis_start, axis_average, axis_end])
        else:
            result_lines.append([axis_start, axis_average, axis_end, axis_average])
    return result_lines


def get_points(row_lines, col_lines, image_size):
    # 创建空图
    row_img = np.zeros(image_size, np.uint8)
    col_img = np.zeros(image_size, np.uint8)

    # 画线
    threshold = 5
    for row in row_lines:
        cv2.line(row_img, (int(row[0] - threshold), int(row[1])), (int(row[2] + threshold), int(row[3])), (255, 255, 255), 1)
    for col in col_lines:
        cv2.line(col_img, (int(col[0]), int(col[1] - threshold)), (int(col[2]), int(col[3] + threshold)), (255, 255, 255), 1)

    # 求出交点
    point_img = np.bitwise_and(row_img, col_img)
    # cv2.imwrite("get_points.jpg", row_img+col_img)
    # cv2.imshow("get_points", row_img+col_img)
    # cv2.waitKey(0)

    # 识别黑白图中的白色交叉点，将横纵坐标取出
    ys, xs = np.where(point_img > 0)
    points = []
    for i in range(len(xs)):
        points.append((xs[i], ys[i]))
    points.sort(key=lambda x: (x[0], x[1]))
    return points


def fix_outline(image, row_line_list, col_line_list, point_list, scale=25):
    log("into fix_outline")
    x_min_len = max(10, int(image.shape[0] / scale))
    y_min_len = max(10, int(image.shape[1] / scale))

    if len(row_line_list) <= 1 or len(col_line_list) <= 1:
        return [], [], row_line_list, col_line_list

    # 预测线取上下左右4个边(会有超出表格部分) [(), ()]
    row_line_list.sort(key=lambda x: (x[1], x[0]))
    up_line = row_line_list[0]
    bottom_line = row_line_list[-1]
    col_line_list.sort(key=lambda x: x[0])
    left_line = col_line_list[0]
    right_line = col_line_list[-1]

    # 计算单格高度宽度
    if len(row_line_list) > 1:
        height_dict = {}
        for j in range(len(row_line_list)):
            if j + 1 > len(row_line_list) - 1:
                break
            height = abs(int(row_line_list[j][3] - row_line_list[j + 1][3]))
            if height >= 10:
                if height in height_dict.keys():
                    height_dict[height] = height_dict[height] + 1
                else:
                    height_dict[height] = 1
        height_list = [[x, height_dict[x]] for x in height_dict.keys()]
        if height_list:
            height_list.sort(key=lambda x: (x[1], -x[0]), reverse=True)
            # print("box_height", height_list)
            box_height = height_list[0][0]
        else:
            box_height = y_min_len
    else:
        box_height = y_min_len
    if len(col_line_list) > 1:
        box_width = abs(col_line_list[1][2] - col_line_list[0][2])
    else:
        box_width = x_min_len

    # 设置轮廓线需超出阈值
    if box_height >= 2 * y_min_len:
        fix_h_len = y_min_len
    else:
        fix_h_len = box_height * 2 / 3
    if box_width >= 2 * x_min_len:
        fix_w_len = x_min_len
    else:
        fix_w_len = box_width * 2 / 3

    # 判断超出部分的长度，超出一定长度就补线
    new_row_lines = []
    new_col_lines = []
    all_longer_row_lines = []
    all_longer_col_lines = []

    # print('box_height, box_width, fix_h_len, fix_w_len', box_height, box_width, fix_h_len, fix_w_len)
    # print('bottom_line, left_line, right_line', bottom_line, left_line, right_line)

    # 补左右两条竖线超出来的线的row
    if up_line[1] - left_line[1] >= fix_h_len and up_line[1] - right_line[1] >= fix_h_len:
        if up_line[1] - left_line[1] >= up_line[1] - right_line[1]:
            new_row_lines.append([left_line[0], left_line[1], right_line[0], left_line[1]])
            new_col_y = left_line[1]
            # 补了row，要将其他短的col连到row上
            for j in range(len(col_line_list)):
                col = col_line_list[j]
                if abs(new_col_y - col[1]) <= box_height:
                    col_line_list[j][1] = min([new_col_y, col[1]])
        else:
            new_row_lines.append([left_line[0], right_line[1], right_line[0], right_line[1]])
            new_col_y = right_line[1]
            # 补了row，要将其他短的col连到row上
            for j in range(len(col_line_list)):
                col = col_line_list[j]
                # 且距离不能相差太大
                if abs(new_col_y - col[1]) <= box_height:
                    col_line_list[j][1] = min([new_col_y, col[1]])
    if left_line[3] - bottom_line[3] >= fix_h_len and right_line[3] - bottom_line[3] >= fix_h_len:
        if left_line[3] - bottom_line[3] >= right_line[3] - bottom_line[3]:
            new_row_lines.append([left_line[2], left_line[3], right_line[2], left_line[3]])
            new_col_y = left_line[3]
            # 补了row，要将其他短的col连到row上
            for j in range(len(col_line_list)):
                col = col_line_list[j]
                # 且距离不能相差太大
                if abs(new_col_y - col[3]) <= box_height:
                    col_line_list[j][3] = max([new_col_y, col[3]])
        else:
            new_row_lines.append([left_line[2], right_line[3], right_line[2], right_line[3]])
            new_col_y = right_line[3]
            # 补了row，要将其他短的col连到row上
            for j in range(len(col_line_list)):
                col = col_line_list[j]
                # 且距离不能相差太大
                if abs(new_col_y - col[3]) <= box_height:
                    col_line_list[j][3] = max([new_col_y, col[3]])

    # 补上下两条横线超出来的线的col
    if left_line[0] - up_line[0] >= fix_w_len and left_line[0] - bottom_line[0] >= fix_w_len:
        if left_line[0] - up_line[0] >= left_line[0] - bottom_line[0]:
            new_col_lines.append([up_line[0], up_line[1], up_line[0], bottom_line[1]])
            new_row_x = up_line[0]
            # 补了col，要将其他短的row连到col上
            for j in range(len(row_line_list)):
                row = row_line_list[j]
                # 且距离不能相差太大
                if abs(new_row_x - row[0]) <= box_width:
                    row_line_list[j][0] = min([new_row_x, row[0]])
        else:
            new_col_lines.append([bottom_line[0], up_line[1], bottom_line[0], bottom_line[1]])
            new_row_x = bottom_line[0]
            # 补了col，要将其他短的row连到col上
            for j in range(len(row_line_list)):
                row = row_line_list[j]
                # 且距离不能相差太大
                if abs(new_row_x - row[0]) <= box_width:
                    row_line_list[j][0] = min([new_row_x, row[0]])
    if up_line[2] - right_line[2] >= fix_w_len and bottom_line[2] - right_line[2] >= fix_w_len:
        if up_line[2] - right_line[2] >= bottom_line[2] - right_line[2]:
            new_col_lines.append([up_line[2], up_line[3], up_line[2], bottom_line[3]])
            new_row_x = up_line[2]
            # 补了col，要将其他短的row连到col上
            for j in range(len(row_line_list)):
                row = row_line_list[j]
                # 且距离不能相差太大
                if abs(new_row_x - row[2]) <= box_width:
                    row_line_list[j][2] = max([new_row_x, row[2]])
        else:
            new_col_lines.append([bottom_line[2], up_line[3], bottom_line[2], bottom_line[3]])
            new_row_x = bottom_line[2]
            # 补了col，要将其他短的row连到col上
            for j in range(len(row_line_list)):
                row = row_line_list[j]
                # 且距离不能相差太大
                if abs(new_row_x - row[2]) <= box_width:
                    row_line_list[j][2] = max([new_row_x, row[2]])

    all_longer_row_lines += row_line_list
    all_longer_col_lines += col_line_list

    # print('new_row_lines, new_col_lines', new_row_lines, new_col_lines)
    # print('all_longer_row_lines, all_longer_col_lines', all_longer_row_lines, all_longer_col_lines)
    return new_row_lines, new_col_lines, all_longer_row_lines, all_longer_col_lines


def fix_inner(row_line_list, col_line_list, point_list):
    def fix(fix_lines, assist_lines, split_points, axis):
        new_line_point_list = []
        delete_line_point_list = []
        for line1 in fix_lines:
            min_assist_line = [[], []]
            min_distance = [1000, 1000]
            if_find = [0, 0]

            # 获取fix_line中的所有col point，里面可能不包括两个顶点，col point是交点，顶点可能不是交点
            fix_line_points = []
            for point in split_points:
                if abs(point[1 - axis] - line1[1 - axis]) <= 2:
                    if line1[axis] <= point[axis] <= line1[axis + 2]:
                        fix_line_points.append(point)

            # 找出离两个顶点最近的assist_line, 并且assist_line与fix_line不相交
            line1_point = [line1[:2], line1[2:]]
            for i in range(2):
                point = line1_point[i]
                for line2 in assist_lines:
                    if not if_find[i] and abs(point[axis] - line2[axis]) <= 2:
                        if line1[1 - axis] <= point[1 - axis] <= line2[1 - axis + 2]:
                            # print("line1, match line2", line1, line2)
                            if_find[i] = 1
                            break
                    else:
                        if abs(point[axis] - line2[axis]) < min_distance[i] and line2[1 - axis] <= point[1 - axis] <= \
                                line2[1 - axis + 2]:
                            if line1[axis] <= line2[axis] <= line1[axis + 2]:
                                continue
                            min_distance[i] = abs(line1[axis] - line2[axis])
                            min_assist_line[i] = line2

            if len(min_assist_line[0]) == 0 and len(min_assist_line[1]) == 0:
                continue

            # 找出离assist_line最近的交点
            min_distance = [1000, 1000]
            min_col_point = [[], []]
            for i in range(2):
                # print("顶点", i, line1_point[i])
                if min_assist_line[i]:
                    for point in fix_line_points:
                        if abs(point[axis] - min_assist_line[i][axis]) < min_distance[i]:
                            min_distance[i] = abs(point[axis] - min_assist_line[i][axis])
                            min_col_point[i] = point

            # print("min_col_point", min_col_point)
            # print("min_assist_line", min_assist_line)

            if len(min_col_point[0]) == 0 and len(min_col_point[1]) == 0:
                continue

            # 顶点到交点的距离(多出来的线)需大于assist_line到交点的距离(bbox的边)的1/3
            # print("line1_point", line1_point)
            if min_assist_line[0] and min_assist_line[0] == min_assist_line[1]:
                if min_assist_line[0][axis] < line1_point[0][axis]:
                    bbox_len = abs(min_col_point[0][axis] - min_assist_line[0][axis])
                    line_distance = abs(min_col_point[0][axis] - line1_point[0][axis])
                    if bbox_len / 3 <= line_distance <= bbox_len:
                        if axis == 1:
                            add_point = (line1_point[0][1 - axis], min_assist_line[0][axis])
                        else:
                            add_point = (min_assist_line[0][axis], line1_point[0][1 - axis])
                        new_line_point_list.append([line1, add_point])
                elif min_assist_line[1][axis] > line1_point[1][axis]:
                    bbox_len = abs(min_col_point[1][axis] - min_assist_line[1][axis])
                    line_distance = abs(min_col_point[1][axis] - line1_point[1][axis])
                    if bbox_len / 3 <= line_distance <= bbox_len:
                        if axis == 1:
                            add_point = (line1_point[1][1 - axis], min_assist_line[1][axis])
                        else:
                            add_point = (min_assist_line[1][axis], line1_point[1][1 - axis])
                        new_line_point_list.append([line1, add_point])
            else:
                for i in range(2):
                    if min_col_point[i]:
                        bbox_len = abs(min_col_point[i][axis] - min_assist_line[i][axis])
                        line_distance = abs(min_col_point[i][axis] - line1_point[i][axis])
                        # print("bbox_len, line_distance", bbox_len, line_distance)
                        if bbox_len / 3 <= line_distance <= bbox_len:
                            if axis == 1:
                                add_point = (line1_point[i][1 - axis], min_assist_line[i][axis])
                            else:
                                add_point = (min_assist_line[i][axis], line1_point[i][1 - axis])
                            new_line_point_list.append([line1, add_point])

        return new_line_point_list

    row_line_list_copy = copy.deepcopy(row_line_list)
    col_line_list_copy = copy.deepcopy(col_line_list)
    try:
        new_point_list = fix(col_line_list, row_line_list, point_list, axis=1)
        for line, new_point in new_point_list:
            if line in col_line_list:
                index = col_line_list.index(line)
                point1 = line[:2]
                point2 = line[2:]
                if new_point[1] >= point2[1]:
                    col_line_list[index] = [point1[0], point1[1], new_point[0], new_point[1]]
                elif new_point[1] <= point1[1]:
                    col_line_list[index] = [new_point[0], new_point[1], point2[0], point2[1]]

        new_point_list = fix(row_line_list, col_line_list, point_list, axis=0)
        for line, new_point in new_point_list:
            if line in row_line_list:
                index = row_line_list.index(line)
                point1 = line[:2]
                point2 = line[2:]
                if new_point[0] >= point2[0]:
                    row_line_list[index] = [point1[0], point1[1], new_point[0], new_point[1]]
                elif new_point[0] <= point1[0]:
                    row_line_list[index] = [new_point[0], new_point[1], point2[0], point2[1]]
        return row_line_list, col_line_list
    except:
        traceback.print_exc()
        return row_line_list_copy, col_line_list_copy


def fix_4_points(cross_points, row_line_list, col_line_list):
    if not (len(row_line_list) >= 2 and len(col_line_list) >= 2):
        return row_line_list, col_line_list

    cross_points.sort(key=lambda x: (x[0], x[1]))
    left_up_p = cross_points[0]
    right_down_p = cross_points[-1]
    cross_points.sort(key=lambda x: (-x[0], x[1]))
    right_up_p = cross_points[0]
    left_down_p = cross_points[-1]
    # print('left_up_p', left_up_p, 'left_down_p', left_down_p)
    # print('right_up_p', right_up_p, 'right_down_p', right_down_p)

    min_x = min(left_up_p[0], left_down_p[0], right_down_p[0], right_up_p[0])
    max_x = max(left_up_p[0], left_down_p[0], right_down_p[0], right_up_p[0])
    min_y = min(left_up_p[1], left_down_p[1], right_down_p[1], right_up_p[1])
    max_y = max(left_up_p[1], left_down_p[1], right_down_p[1], right_up_p[1])

    if left_up_p[0] != min_x or left_up_p[1] != min_y:
        log('轮廓左上角交点有问题')
        row_line_list.append([min_x, min_y, max_x, min_y])
        col_line_list.append([min_x, min_y, min_x, max_y])
    if left_down_p[0] != min_x or left_down_p[1] != max_y:
        log('轮廓左下角交点有问题')
        row_line_list.append([min_x, max_y, max_x, max_y])
        col_line_list.append([min_x, min_y, min_x, max_y])
    if right_up_p[0] != max_x or right_up_p[1] != min_y:
        log('轮廓右上角交点有问题')
        row_line_list.append([min_x, max_y, max_x, max_y])
        col_line_list.append([max_x, min_y, max_x, max_y])
    if right_down_p[0] != max_x or right_down_p[1] != max_y:
        log('轮廓右下角交点有问题')
        row_line_list.append([min_x, max_y, max_x, max_y])
        col_line_list.append([max_x, min_y, max_x, max_y])

    return row_line_list, col_line_list


def get_split_line(points, col_lines, image_np, threshold=5):
    # 线贴着边缘无法得到split_y，导致无法分区
    for _col in col_lines:
        if _col[3] >= image_np.shape[0] - 5:
            _col[3] = image_np.shape[0] - 6

        if _col[1] <= 0 + 5:
            _col[1] = 6

    # print("get_split_line", image_np.shape)
    points.sort(key=lambda x: (x[1], x[0]))
    # 遍历y坐标，并判断y坐标与上一个y坐标是否存在连接线
    i = 0
    split_line_y = []
    for point in points:
        # 从已分开的线下面开始判断
        if split_line_y:
            if point[1] <= split_line_y[-1] + threshold:
                last_y = point[1]
                continue
            if last_y <= split_line_y[-1] + threshold:
                last_y = point[1]
                continue

        if i == 0:
            last_y = point[1]
            i += 1
            continue

        current_line = (last_y, point[1])
        split_flag = 1
        for col in col_lines:
            # 只要找到一条col包含就不是分割线
            if current_line[0] >= col[1] - 3 and current_line[1] <= col[3] + 3:
                split_flag = 0
                break

        if split_flag:
            split_line_y.append(current_line[0] + 5)
            split_line_y.append(current_line[1] - 5)

        last_y = point[1]

    # 加上收尾分割线
    points.sort(key=lambda x: (x[1], x[0]))
    y_min = points[0][1]
    y_max = points[-1][1]
    if y_min - threshold < 0:
        split_line_y.append(0)
    else:
        split_line_y.append(y_min - threshold)
    if y_max + threshold > image_np.shape[0]:
        split_line_y.append(image_np.shape[0])
    else:
        split_line_y.append(y_max + threshold)
    split_line_y = list(set(split_line_y))

    # 剔除两条相隔太近分割线
    temp_split_line_y = []
    split_line_y.sort(key=lambda x: x)
    last_y = -20
    for y in split_line_y:
        if y - last_y >= 20:
            temp_split_line_y.append(y)
            last_y = y
    split_line_y = temp_split_line_y

    # 生成分割线
    split_line = []
    for y in split_line_y:
        split_line.append([(0, y), (image_np.shape[1], y)])
    split_line.append([(0, 0), (image_np.shape[1], 0)])
    split_line.append([(0, image_np.shape[0]), (image_np.shape[1], image_np.shape[0])])
    split_line.sort(key=lambda x: x[0][1])
    return split_line, split_line_y


def get_split_area(split_y, row_line_list, col_line_list, cross_points):
    # 分割线纵坐标
    if len(split_y) < 2:
        return [], [], []

    split_y.sort(key=lambda x: x)
    # new_split_y = []
    # for i in range(1, len(split_y), 2):
    #     new_split_y.append(int((split_y[i] + split_y[i - 1]) / 2))

    area_row_line_list = []
    area_col_line_list = []
    area_point_list = []

    for i in range(1, len(split_y)):
        y = split_y[i]
        last_y = split_y[i - 1]

        split_row = []
        for row in row_line_list:
            if last_y <= row[3] <= y:
                split_row.append(row)

        split_col = []
        for col in col_line_list:
            if last_y <= col[1] <= y or last_y <= col[3] <= y or col[1] < last_y < y < col[3]:
                split_col.append(col)

        split_point = []
        for point in cross_points:
            if last_y <= point[1] <= y:
                split_point.append(point)

        # 满足条件才能形成表格区域
        if len(split_row) >= 2 and len(split_col) >= 2 and len(split_point) >= 4:
            # print('len(split_row), len(split_col), len(split_point)', len(split_row), len(split_col), len(split_point))
            area_row_line_list.append(split_row)
            area_col_line_list.append(split_col)
            area_point_list.append(split_point)

    return area_row_line_list, area_col_line_list, area_point_list


def get_standard_lines(row_line_list, col_line_list):
    new_row_line_list = []
    for row in row_line_list:
        w1 = row[0]
        w2 = row[2]
        # 横线的两个顶点分别找到最近的竖线
        min_distance = [10000, 10000]
        min_dis_w = [None, None]
        for col in col_line_list:
            if abs(col[0] - w1) < min_distance[0]:
                min_distance[0] = abs(col[0] - w1)
                min_dis_w[0] = col[0]
            if abs(col[0] - w2) < min_distance[1]:
                min_distance[1] = abs(col[0] - w2)
                min_dis_w[1] = col[0]
        if min_dis_w[0] is not None:
            row[0] = min_dis_w[0]
        if min_dis_w[1] is not None:
            row[2] = min_dis_w[1]
        new_row_line_list.append(row)

    new_col_line_list = []
    for col in col_line_list:
        h1 = col[1]
        h2 = col[3]
        # 横线的两个顶点分别找到最近的竖线
        min_distance = [10000, 10000]
        min_dis_w = [None, None]
        for row in row_line_list:
            if abs(row[1] - h1) < min_distance[0]:
                min_distance[0] = abs(row[1] - h1)
                min_dis_w[0] = row[1]
            if abs(row[1] - h2) < min_distance[1]:
                min_distance[1] = abs(row[1] - h2)
                min_dis_w[1] = row[1]
        if min_dis_w[0] is not None:
            col[1] = min_dis_w[0]
        if min_dis_w[1] is not None:
            col[3] = min_dis_w[1]
        new_col_line_list.append(col)


    # all_line_list = []
    # # 横线竖线两个维度
    # for i in range(2):
    #     axis = i
    #     cross_points.sort(key=lambda x: (x[axis], x[1-axis]))
    #     current_axis = cross_points[0][axis]
    #     points = []
    #     line_list = []
    #     for p in cross_points:
    #         if p[axis] == current_axis:
    #             points.append(p)
    #         else:
    #             if points:
    #                 line_list.append([points[0][0], points[0][1], points[-1][0], points[-1][1]])
    #             points = [p]
    #             current_axis = p[axis]
    #     if points:
    #         line_list.append([points[0][0], points[0][1], points[-1][0], points[-1][1]])
    #     all_line_list.append(line_list)
    # new_col_line_list, new_row_line_list = all_line_list

    return new_col_line_list, new_row_line_list


def add_outline(cross_points, row_line_list, col_line_list):
    cross_points.sort(key=lambda x: (x[0], x[1]))
    left_up_p = cross_points[0]
    right_down_p = cross_points[-1]

    row_line_list.append([left_up_p[0], left_up_p[1], right_down_p[0], left_up_p[1]])
    row_line_list.append([left_up_p[0], right_down_p[1], right_down_p[0], right_down_p[1]])
    col_line_list.append([left_up_p[0], left_up_p[1], left_up_p[0], right_down_p[1]])
    col_line_list.append([right_down_p[0], left_up_p[1], right_down_p[0], right_down_p[1]])
    return row_line_list, col_line_list