OCR-文本检测后的文字纠正

最新推荐文章于 2024-05-14 00:18:11 发布
最新推荐文章于 2024-05-14 00:18:11 发布
阅读量5.1k 收藏 49
点赞数 10
分类专栏： OCR 文章标签： 计算机视觉 opencv python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39056987/article/details/108671180
版权

序言

主要是对规则的文本检测的角度纠正，如果弯曲的很厉害，那也没办法，因为最近一直在做OCR方面的工作，包括文本检测、文本识别等等，关于检测后的文本角度纠正，网上查了很久没发现一个靠谱的，想了很久，决定自己用opencv实现一下，本文记录下实现的过程。主要是对YOLO检测后的倾斜文本做纠正，纠正后的图片送入到识别网络中能够大大的提升模型的识别率，当然不一定对所有场景下的文本都适用，实现仅供参考和学习。

一、关键技术

  1. 霍夫变换预测倾斜角度；
  2. 图像二值化用于分割文本区域；
  3. ROI区域获取；
  4. 得到纠正后的文本区域截图。

二、实现过程

2.1 样本准备

首先获得文本检测后的截图，例如我们这里有几张发票检测下来的倾斜角度比较大的图片：
在这里插入图片描述
在这里插入图片描述
我们希望能够将图中的文字方向正确的纠正过来，具体实现如下。

首先通过霍夫变换找出图片中的直线，并通过这些直线求得近似真实值的旋转角度，再然后使用旋转函数对图片进行角度旋转。在这里要说明的是，其实文本图像中的直线是比较多的，我在反复测试很多检测文本时发现，纠正的角度还是很标准的，不过也有例外，总的来说，文本越清晰，求出的角度越准确。先贴上角度纠正前后的效果对比：

在这里插入图片描述
在这里插入图片描述
这里旋转后为了不缺边，使用了图像的RGB均值对边缘进行填充。

第二步是将图片灰度后进行二值化处理，二值化后用到了闭运算，这样能够保证相连的文字不会被分成几个部分，最后得到的二值图像如下，对比上图，可以看到有文字的区域都被区分的很开，这里尝试了后面接着用开运算，但是效果不理想，所以果断放弃这个操作。
在这里插入图片描述
在这里插入图片描述
得到文字区域的二值图像后，接下来就对这些区域进行ROI提取，提取出面积最大的最小外接矩形区域，其他的剔除，最后得到的纠正效果：

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
前后对比一下，可以说效果非常的奈斯。当然正常情况下的文本倾斜角度不会太大，如果霍夫变换求出的角度太小对识别的影响不是特别大，如果求出角度太大则很可能会出错，这里我们可以在程序里对角度范围进行限制，超过一定范围则忽略直接返回原图，这部分的修改可以在Hough函数中设置。

三、代码实现

最后贴上代码实现：

# -*- coding: utf-8 -*-
import cv2
import numpy as np
import math

def compute(img):
    "求图像每个通道的均值"
    per_image_Rmean = []
    per_image_Gmean = []
    per_image_Bmean = []
    per_image_Bmean.append(np.mean(img[:, :, 0]))
    per_image_Gmean.append(np.mean(img[:, :, 1]))
    per_image_Rmean.append(np.mean(img[:, :, 2]))
    R_mean = np.mean(per_image_Rmean)
    G_mean = np.mean(per_image_Gmean)
    B_mean = np.mean(per_image_Bmean)
    return B_mean, G_mean, R_mean


def rotate_bound(image, angle):
    """
    旋转任意角度不缺边缘
    """
    (h, w) = image.shape[:2]  # 获取图像的尺寸
    (cX, cY) = (w // 2, h // 2)  # 旋转中心

    # 设置旋转矩阵
    M = cv2.getRotationMatrix2D((cX, cY), -angle, 1.0)
    cos = np.abs(M[0, 0])
    sin = np.abs(M[0, 1])

    # 计算图像旋转后的新边界
    nW = int((h * sin) + (w * cos))
    nH = int((h * cos) + (w * sin))

    # 调整旋转矩阵的移动距离（t_{x}, t_{y}）
    M[0, 2] += (nW / 2) - cX
    M[1, 2] += (nH / 2) - cY

    # perform the actual rotation and return the image
    b, g, r = compute(image)
    return cv2.warpAffine(image, M, (nW, nH), borderValue=(b, g, r))


def Hough(img):
    """
    霍夫变换角度检测并纠正
    :param img:
    :return: 矫正后的图片
    """
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    edges = cv2.Canny(gray, 25, 150, apertureSize=3)

    lines = cv2.HoughLines(edges, 1, np.pi / 180, 0)
    for rho, theta in lines[0]:
        a = np.cos(theta)
        b = np.sin(theta)
        x0 = a * rho
        y0 = b * rho
        x1 = int(x0 + 1000 * (-b))
        y1 = int(y0 + 1000 * (a))
        x2 = int(x0 - 1000 * (-b))
        y2 = int(y0 - 1000 * (a))
    if x1 == x2 or y1 == y2:
        return img
    t = float(y2 - y1) / (x2 - x1)
    rotate_angle = math.degrees(math.atan(t))
    print(rotate_angle)
    if 12 > rotate_angle > 2 or -12 < rotate_angle < -2:    # 角度纠正的范围
        rotate_img = rotate_bound(img, -rotate_angle)
        afterimg=find_license(rotate_img)
        cv2.imshow("afterimg",afterimg)
        return afterimg
    else:
        return img


def stretch(img):
    '''
    图像拉伸函数
    '''
    maxi=float(img.max())
    mini=float(img.min())

    for i in range(img.shape[0]):
        for j in range(img.shape[1]):
            img[i,j]=(255/(maxi-mini)*img[i,j]-(255*mini)/(maxi-mini))

    return img

def dobinaryzation(img):
    '''
    二值化处理函数
    '''
    maxi=float(img.max())
    mini=float(img.min())

    x=maxi-((maxi-mini)/2)
    ret,thresh=cv2.threshold(img,x,255,cv2.THRESH_BINARY)
    #返回二值化后的黑白图像
    return thresh

def find_license(img):
    '''
    预处理函数
    '''
    gray_img=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
    #灰度拉伸
    stretchedimg=stretch(gray_img)

    #图像二值化
    binaryimg=dobinaryzation(stretchedimg)

    #canny边缘检测
    canny=cv2.Canny(binaryimg,binaryimg.shape[0],binaryimg.shape[1])

    #进行闭运算
    kernel=np.ones((3,19),np.uint8)
    closingimg=cv2.morphologyEx(canny,cv2.MORPH_CLOSE,kernel)
    # cv2.imshow("closingimg",closingimg)
    # 提取图像区域
    img_crop = ROI_extract(img,closingimg)

    return img_crop

def findVertices(points):
    # 获取最小外接矩阵，中心点坐标，宽高，旋转角度
    rect = cv2.minAreaRect(points)
    # 获取矩形四个顶点，浮点型
    box = cv2.boxPoints(rect)
    # 取整
    box = np.int0(box)
    # 获取四个顶点坐标
    left_point_x = np.min(box[:, 0])
    right_point_x = np.max(box[:, 0])
    top_point_y = np.min(box[:, 1])
    bottom_point_y = np.max(box[:, 1])

    left_point_y = box[:, 1][np.where(box[:, 0] == left_point_x)][0]
    right_point_y = box[:, 1][np.where(box[:, 0] == right_point_x)][0]
    top_point_x = box[:, 0][np.where(box[:, 1] == top_point_y)][0]
    bottom_point_x = box[:, 0][np.where(box[:, 1] == bottom_point_y)][0]
    # 上下左右四个点坐标
    vertices = np.array([[top_point_x, top_point_y], [bottom_point_x, bottom_point_y], [left_point_x, left_point_y],
                      [right_point_x, right_point_y]])
    return vertices, rect

def ROI_extract(image,thresh):
    """
    提取目标区域
    :param image:
    :return:
    """
    contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

    max_area = 0
    img = None
    size = image.shape
    if len(contours) != 0:
        for cnt in range(len(contours)):
            x, y, w, h = cv2.boundingRect(contours[cnt])
            box, _ = findVertices(contours[cnt])
            area = w * h
            if area > max_area:  # 过滤小区域，只保留最大的区域
                y1 = max(0,y-2)
                x1 = max(0,x-2)
                y2 = min(size[0],y + h + 2)
                x2 = min(size[1],x + w + 2)
                newimage = image[y1 :y2, x1 :x2]
                max_area = area
                img = newimage

                # 框出文字区域
                image_copy = image.copy()
                cv2.rectangle(image_copy, (x1, y1), (x2, y2), (0, 255, 0), 2)
                cv2.imshow('image_copy', image_copy)
            else:
                continue
    else:
        return img
    return img


if __name__=='__main__':
    import os

    path = r"G:\CRNN_data\diff_img\test"
    for name in os.listdir(path):
        img=cv2.imread(os.path.join(path,name),cv2.IMREAD_COLOR)
        #预处理图像
        cv2.imshow("img0",img)
        img = Hough(img)
        # cv2.imwrite(r"G:\CRNN_data\diff_img\test_save\{}".format(name),img)
        cv2.imshow("hough_img",img)
        cv2.waitKey()

PS：最后，因为是基于传统方法去做的，鲁棒性有待加强，旋转角度基本上没什么问题，主要是阈值分割不是很稳定，可以尝试在旋转纠正后使用其他的方法分割出字符，如果在自己的数据上不是很适用的话，还可以考虑在识别网络中加入TPS进行纠正，关于TPS这里就不说了，如果要说的话又可以写一篇博文了，感兴趣的可以百度。不过谨慎看好，因为我在加进去后精度反而还还下降了，当然和我本身的数据有关。

update另一种实现，修改了字符分割部分，使用水平投影对字符进行分割，最后对投影的区域进行筛选分割，分割的效果稳定性更好：

在这里插入图片描述
在这里插入图片描述

# -*- coding: utf-8 -*-
import cv2
import numpy as np
import math

def compute(img):
    "求图像每个通道的均值"
    per_image_Rmean = []
    per_image_Gmean = []
    per_image_Bmean = []
    per_image_Bmean.append(np.mean(img[:, :, 0]))
    per_image_Gmean.append(np.mean(img[:, :, 1]))
    per_image_Rmean.append(np.mean(img[:, :, 2]))
    R_mean = np.mean(per_image_Rmean)
    G_mean = np.mean(per_image_Gmean)
    B_mean = np.mean(per_image_Bmean)
    return B_mean, G_mean, R_mean

def rotate_bound(image, angle):
    """
    旋转任意角度不缺边缘
    """
    (h, w) = image.shape[:2]  # 获取图像的尺寸
    (cX, cY) = (w // 2, h // 2)  # 旋转中心

    # 设置旋转矩阵
    M = cv2.getRotationMatrix2D((cX, cY), -angle, 1.0)
    cos = np.abs(M[0, 0])
    sin = np.abs(M[0, 1])

    # 计算图像旋转后的新边界
    nW = int((h * sin) + (w * cos))
    nH = int((h * cos) + (w * sin))

    # 调整旋转矩阵的移动距离（t_{x}, t_{y}）
    M[0, 2] += (nW / 2) - cX
    M[1, 2] += (nH / 2) - cY

    # perform the actual rotation and return the image
    b, g, r = compute(image)
    return cv2.warpAffine(image, M, (nW, nH), borderValue=(b, g, r))

def Hough(img):
    """
    霍夫变换角度检测并纠正
    :param img:
    :return: 矫正后的图片
    """
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    edges = cv2.Canny(gray, 25, 150, apertureSize=3)

    lines = cv2.HoughLines(edges, 1, np.pi / 180, 0)
    for rho, theta in lines[0]:
        a = np.cos(theta)
        b = np.sin(theta)
        x0 = a * rho
        y0 = b * rho
        x1 = int(x0 + 1000 * (-b))
        y1 = int(y0 + 1000 * (a))
        x2 = int(x0 - 1000 * (-b))
        y2 = int(y0 - 1000 * (a))
    if x1 == x2 or y1 == y2:
        return img
    t = float(y2 - y1) / (x2 - x1)
    rotate_angle = math.degrees(math.atan(t))
    print(rotate_angle)
    if 12 > rotate_angle > 3 or -12 < rotate_angle < -3:    # 角度纠正的范围
        rotate_img = rotate_bound(img, -rotate_angle)
        # cv2.imwrite(r"G:\CRNN_data\diff_img\test_save\{}".format(name), rotate_img)
        afterimg=find_license(rotate_img)
        # cv2.imshow("afterimg",afterimg)
        return afterimg
    else:
        return img

def stretch(img):
    '''
    图像拉伸函数
    '''
    maxi=float(img.max())
    mini=float(img.min())

    for i in range(img.shape[0]):
        for j in range(img.shape[1]):
            img[i,j]=(255/(maxi-mini)*img[i,j]-(255*mini)/(maxi-mini))

    return img

def dobinaryzation(img):
    '''
    二值化处理函数
    '''
    maxi=float(img.max())
    mini=float(img.min())

    x=maxi-((maxi-mini)/2)
    ret,thresh=cv2.threshold(img,x,255,cv2.THRESH_BINARY)
    #返回二值化后的黑白图像
    return thresh

def getHProjection(image):
    hProjection = np.zeros(image.shape, np.uint8)

    # 图像高与宽
    (h, w) = image.shape
    # 长度与图像高度一致的数组
    h_ = [0] * h
    # 循环统计每一行白色像素的个数
    for y in range(h):
        for x in range(w):
            if image[y, x] == 255:
                h_[y] += 1
    # 绘制水平投影图像
    for y in range(h):
        for x in range(h_[y]):
            hProjection[y, x] = 255
    cv2.imshow('hProjection2', hProjection)

    return h_

def find_license(img):
    '''
    预处理函数
    '''
    gray_img=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
    #灰度拉伸
    stretchedimg=stretch(gray_img)

    #图像二值化
    binaryimg=dobinaryzation(stretchedimg)

    #canny边缘检测
    canny=cv2.Canny(binaryimg,binaryimg.shape[0],binaryimg.shape[1])

    #进行闭运算
    kernel=np.ones((3,19),np.uint8)
    closingimg=cv2.morphologyEx(canny,cv2.MORPH_CLOSE,kernel)

    H = getHProjection(closingimg)     # 投影字符分割

    start = 0
    H_Start = []
    H_End = []
    # 根据水平投影获取垂直分割位置
    for i in range(len(H)):
        if H[i] > 0 and start == 0:
            H_Start.append(i)
            start = 1
        if H[i] <= 0 and start == 1:
            H_End.append(i)
            start = 0
    if len(H_Start) != len(H_End):
        H_End.append(len(H))
    # 分割行，分割之后再进行列分割并保存分割位置
    sum_list = []
    for i in range(len(H_Start)):
        sum_pix = sum(H[H_Start[i]:H_End[i]])        # 对每个区域内像素相加
        sum_list.append(sum_pix)
    index = sum_list.index(max(sum_list))         # 选出像素分布最大的区域
    cropImg = img[H_Start[index]:H_End[index], 0:img.shape[1]]      # 对该区域进行裁剪


    # 提取图像区域
    # cropImg = ROI_extract(img,closingimg)

    return cropImg

if __name__=='__main__':
    import os

    path = r"E:\PycharmProjects\yolov5_invoice_api\inference\output_crop"
    for name in os.listdir(path):
        img=cv2.imread(os.path.join(path,name),cv2.IMREAD_COLOR)
        #预处理图像
        cv2.imshow("img0",img)
        img = Hough(img)
        cv2.imwrite(r"G:\CRNN_data\diff_img\test_save\{}".format(name),img)
        cv2.imshow("hough_img",img)
        cv2.waitKey()

速度慢了一点，不过还存在很大的优化空间，上面代码涉及了很多for循环，这是非常耗时的，可使用numpy数组运算代替for循环，速度可提升到毫秒级别。

三叔家的猫
关注
  • 10
    点赞
  • 踩
  • 49
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
OpenCV学习笔记（十二）旋转文本矫正
spw_1201的博客
12-13 1万+
旋转文本矫正： 图像文本旋转通常在仿射变换时获取图像的倾斜角度，利用傅里叶变换中的时域与频域的变换关系，实现旋转文本的校正。 旋转文本的特征明显就是存在分行间隔，当文本图像旋转时，其频域中的频谱也会随之旋转。根据这一特征来计算文本图像的DFT变换，DFT变换的结果是低频位于边界四角，高频集中在中心区域，将低频和高频互换，实现中心的移动，进而可以看到文本图像的频谱有明显的倾斜直线，再通过计算倾斜
STN：不规则文本矫正网络的探索
何小义的博客
11-02 811
STN 网络！
2024年最全深度学习在文档矫正中的应用_弯曲文档校正(2)，2024年最新C C++基础入门教程
最新发布
2401_84976585的博客
05-14 394
处理上面和文稿相关的扫描、文字识别等任务外，TextIn还可以进行PS智能检测，检测图像是否PS过。使用PS智能检测可以很好的辨别这些伪造的图像，这里我们对正常图像进行人为的PS处理，然后在。印章的文字通常是弯曲的，一般的文字识别程序不能很好的处理，在TextIn中提供了印章检测识别的功能。另外我们可以做一件有趣的事，可以手动给一个文档添加水印，然后使用TextIn对其去水印，再把去水印的结果交给前面提到的PS智能检测检测是否被篡改过，可以发现一个非常有趣的现象。左侧是处理后的效果，右侧是带有水印的效果。
page_dewarp实现弯曲文本矫正
Frank-Li的博客
07-13 832
朋友们，如果你使用ocr，再识别的时候会遇到文本扭曲的问题，为了解决这个问题，需要进行弯曲文本矫正，这里推荐一个开源项目，可以使用上面的功能进行矫正，不过里面可能需要改动一些代码，原来的应用范围好像python2。矫正效果（代码里面细节需要修正，部分图片丢了）
毕业设计-基于机器自然场景的倾斜文本定位方法-YOLO
Hai_Lang_IT的博客
01-03 447
毕业设计-基于机器自然场景的倾斜文本定位方法-YOLO：随着近几年深度学习技术的发展，神经网络应用到光学字符识别（OCR）中的场景日益增多。文本区域定位是 OCR 中至关重要的一步，利用目标检测算法能够在一定程度上有效且快速地定位到文本区域。 在过去的几年，随着深度学习技术的发展，已经提出了一些可以用于自然场景文本定位的目标检测技术。提出了Faster R-CNN 将特征提取、proposal 提取、Bounding BoxRegression、Clas-sification整合到一个网络中，目标检测速
OCR技术
weixin_74021557的博客
06-20 946
版面元素检测和识别是OCR系统中的一个重要步骤，它可以将文档中的文字、图片等元素分离出来，为后续的字符切割和识别提供依据。物理版面版面分析是OCR系统中的一个重要步骤，它可以将文档中的文字、图片等元素分离出来，为后续的字符切割和识别提供依据。逻辑版面版面分析是OCR系统中的一个重要步骤，它可以将文档中的文字、图片等元素分离出来，为后续的字符切割和识别提供依据。3、版面分析：版面分析是OCR系统中的一个重要步骤，它可以将文档中的文字、图片等元素分离出来，为后续的字符切割和识别提供依据。
深度霍夫变换：语义线检测新方法
爱CV
09-11 880
Deep Hough Transform for Semantic Line Detection 主页：https://mmcheng.net/dhtline/ 论文：http://mftp.mmcheng.net/Papers/21PAMI-DHT-line.pdf 代码：https://github.com/Hanqer/deep-hough-transform 南开大学计算媒体实验室在机器学习顶刊 IEEE TPAMI 发表论文提出”深度霍夫变换“ (deep hough tra...
百度文字识别OCR-通用文字识别
01-08
6. **后处理**：对识别结果进行校正，如纠正识别错误，拼接连续的文字。 ### 百度AI OCR服务特点 1. **高精度**：百度OCR服务采用了先进的深度学习算法，对于不同字体、字号、排版的文字有较高的识别准确率。 2. ...
C++ 基于tesseract-OCR的图片文字识别
12-24
- 在实际应用中，可能需要对识别结果进行后处理，比如去除噪声词汇、纠正拼写错误等。 综上所述，使用C++和Tesseract OCR在Visual Studio 2015中实现图片文字识别是一个涉及图像处理、模式识别和自然语言处理的过程...
开源 tesseract-ocr-文字识别软件
02-17
6. **后处理**：纠正可能的识别错误，如相邻字符的粘连，提高整体识别准确性。 **训练自定义数据** 除了内置的训练数据，Tesseract OCR还允许用户使用`jTessBoxEditor`这样的工具来训练自己的数据集。这在遇到特殊...
tesseract-ocr-setup-3.01-1.rar
03-22
2. **文字定位**：通过图像分析找到可能包含文本的区域，这一步也被称为文字框检测。 3. **字符分割**：将文字区域进一步分割成单独的字符。 4. **特征提取**：每个字符被转化为特征向量，这些特征可以是形状、...
基于图元识别的 OCR文本图像倾斜矫正快速算法 (2004年)
05-30
提出了一种基于文本图元识别以跟踪字符中心线的高精度矫正 OCR图像倾斜的快速算法 ,该算法思想虽然简单 ,却具有高效和高精度的特点 ,同时还具有高可靠性和良好的抗噪特征 。实验表明 ,该方法完全满足实时应用的需要 。
chineseocr-lite-onnx.zip
02-01
OCR（Optical Character Recognition，光学字符识别）技术在数字化时代中扮演着至关重要的角色，它能够自动识别图像中的文字并将其转换为可编辑的文本格式。在中文OCR领域，chineseocr-lite-onnx是一个值得一提的...
弯曲文本检测PSENet论文笔记
zephyr_wang的博客
04-05 940
1.介绍 1.1.介绍 本文基于《Shape Robust Text Detection with Progressive Scale Expansion Network》翻译总结。PSENet（Progressive Scale Expansion Network）称为渐进尺度扩展网络，主要是进行任意形状的文字定位，以及不同的光照条件、不同的颜色、不同的尺度大小。甚至文字区域非常接近，以及有部分...
ocr 图片纠正_OCR 车牌识别
weixin_39850331的博客
12-22 505
OCROCR (Optical Character Recognition，光学字符识别)是指电子设备(例如扫描仪或数码相机)检查纸上打印的字符，通过检测暗、亮的模式确定其形状，然后用字符识别方法将形状翻译成计算机文字的过程；即，针对印刷体字符，采用光学的方式将纸质文档中的文字转换成为黑白点阵的图像文件，并通过识别软件将图像中的文字转换成文本格式，供文字处理软件进一步编辑加工的技术。如何...
ocr 图片纠正_OCR 技术浅析
weixin_40006133的博客
12-04 672
随着人工智能的热度上升，图像识别这一分领域也渐渐被人们所关注。图像识别中最贴近我们生活的可能就是 OCR 技术了。可能很多同学还不知道什么是 OCR。我们先来看下 OCR 的定义：OCR (Optical Character Recognition，光学字符识别)是指电子设备(例如扫描仪或数码相机)检查纸上打印的字符，通过检测暗、亮的模式确定其形状，然后用字符识别方法将形状翻译成计算机文字的过程。...
OpenCV-Python的文本透视矫正与水平矫正
学习容易上瘾
08-22 2万+
已经感觉一个月没有更博了，最近也是在找工作找实习。最近在看的就是如何使用神经网络去做一个OCR识别，网上的资料多种多样，包括分割单字进行识别的，也有不定长文字识别。网络模型目前看到比较多的是CRNN，检测的模型包括CTPN、YOLO等等。 今天整理的是数据预处理上的文本透视矫正与水平矫正。 一、透视矫正 透视矫正是什么？比如发现了一页纸，写的挺好，你想拍下来，但是拍摄时角度的问题，你拍成了下...
【深度学习YOLO V1】深刻解读YOLO V1（图解）
热门推荐
c20081052的专栏
05-08 10万+
参考：http://blog.csdn.net/u011534057/article/details/51244354论文下载：http://arxiv.org/abs/1506.02640 darknet版的代码下载：https://github.com/pjreddie/darknettensorflow版本的代码下载：https://github.com/hizhangp/yolo_tens...
深度解析：OCR中的文字检测与识别技术(CTPN与CRNN)
OCR技术的核心在于精确的文字检测和高效的识别，其中CTPN作为一种强大的文字检测算法，其独特的网络设计和时序性处理能力对于提高文字识别的准确性和鲁棒性至关重要。随着深度学习的发展，未来OCR技术有望在更多复杂...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值