票据预处理（二）

最新推荐文章于 2024-07-26 16:45:27 发布
最新推荐文章于 2024-07-26 16:45:27 发布
阅读量457 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： opencv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_34510308/article/details/81018556 
// DecetorOcr.cpp : Defines the exported functions for the DLL application.
//
#include "stdafx.h"
#include"DecetorOcr.h"
#include<iostream>
#include<string>
#include<opencv.hpp>
using namespace cv;
using namespace std;

//图像细化
void chao_thinimage(Mat &srcimage)//单通道、二值化后的图像
{
    vector<Point> deletelist1;
    int Zhangmude[9];
    int nl = srcimage.rows;
    int nc = srcimage.cols;
    while (true)
    {
        for (int j = 1; j < (nl - 1); j++)
        {
            uchar* data_last = srcimage.ptr<uchar>(j - 1);
            uchar* data = srcimage.ptr<uchar>(j);
            uchar* data_next = srcimage.ptr<uchar>(j + 1);
            for (int i = 1; i < (nc - 1); i++)
            {
                if (data[i] == 255)
                {
                    Zhangmude[0] = 1;
                    if (data_last[i] == 255) Zhangmude[1] = 1;
                    else  Zhangmude[1] = 0;
                    if (data_last[i + 1] == 255) Zhangmude[2] = 1;
                    else  Zhangmude[2] = 0;
                    if (data[i + 1] == 255) Zhangmude[3] = 1;
                    else  Zhangmude[3] = 0;
                    if (data_next[i + 1] == 255) Zhangmude[4] = 1;
                    else  Zhangmude[4] = 0;
                    if (data_next[i] == 255) Zhangmude[5] = 1;
                    else  Zhangmude[5] = 0;
                    if (data_next[i - 1] == 255) Zhangmude[6] = 1;
                    else  Zhangmude[6] = 0;
                    if (data[i - 1] == 255) Zhangmude[7] = 1;
                    else  Zhangmude[7] = 0;
                    if (data_last[i - 1] == 255) Zhangmude[8] = 1;
                    else  Zhangmude[8] = 0;
                    int whitepointtotal = 0;
                    for (int k = 1; k < 9; k++)
                    {
                        whitepointtotal = whitepointtotal + Zhangmude[k];
                    }
                    if ((whitepointtotal >= 2) && (whitepointtotal <= 6))
                    {
                        int ap = 0;
                        if ((Zhangmude[1] == 0) && (Zhangmude[2] == 1)) ap++;
                        if ((Zhangmude[2] == 0) && (Zhangmude[3] == 1)) ap++;
                        if ((Zhangmude[3] == 0) && (Zhangmude[4] == 1)) ap++;
                        if ((Zhangmude[4] == 0) && (Zhangmude[5] == 1)) ap++;
                        if ((Zhangmude[5] == 0) && (Zhangmude[6] == 1)) ap++;
                        if ((Zhangmude[6] == 0) && (Zhangmude[7] == 1)) ap++;
                        if ((Zhangmude[7] == 0) && (Zhangmude[8] == 1)) ap++;
                        if ((Zhangmude[8] == 0) && (Zhangmude[1] == 1)) ap++;
                        if (ap == 1)
                        {
                            if ((Zhangmude[1] * Zhangmude[7] * Zhangmude[5] == 0) && (Zhangmude[3] * Zhangmude[5] * Zhangmude[7] == 0))
                            {
                                deletelist1.push_back(Point(i, j));
                            }
                        }
                    }
                }
            }
        }
        if (deletelist1.size() == 0) break;
        for (size_t i = 0; i < deletelist1.size(); i++)
        {
            Point tem;
            tem = deletelist1[i];
            uchar* data = srcimage.ptr<uchar>(tem.y);
            data[tem.x] = 0;
        }
        deletelist1.clear();

        for (int j = 1; j < (nl - 1); j++)
        {
            uchar* data_last = srcimage.ptr<uchar>(j - 1);
            uchar* data = srcimage.ptr<uchar>(j);
            uchar* data_next = srcimage.ptr<uchar>(j + 1);
            for (int i = 1; i < (nc - 1); i++)
            {
                if (data[i] == 255)
                {
                    Zhangmude[0] = 1;
                    if (data_last[i] == 255) Zhangmude[1] = 1;
                    else  Zhangmude[1] = 0;
                    if (data_last[i + 1] == 255) Zhangmude[2] = 1;
                    else  Zhangmude[2] = 0;
                    if (data[i + 1] == 255) Zhangmude[3] = 1;
                    else  Zhangmude[3] = 0;
                    if (data_next[i + 1] == 255) Zhangmude[4] = 1;
                    else  Zhangmude[4] = 0;
                    if (data_next[i] == 255) Zhangmude[5] = 1;
                    else  Zhangmude[5] = 0;
                    if (data_next[i - 1] == 255) Zhangmude[6] = 1;
                    else  Zhangmude[6] = 0;
                    if (data[i - 1] == 255) Zhangmude[7] = 1;
                    else  Zhangmude[7] = 0;
                    if (data_last[i - 1] == 255) Zhangmude[8] = 1;
                    else  Zhangmude[8] = 0;
                    int whitepointtotal = 0;
                    for (int k = 1; k < 9; k++)
                    {
                        whitepointtotal = whitepointtotal + Zhangmude[k];
                    }
                    if ((whitepointtotal >= 2) && (whitepointtotal <= 6))
                    {
                        int ap = 0;
                        if ((Zhangmude[1] == 0) && (Zhangmude[2] == 1)) ap++;
                        if ((Zhangmude[2] == 0) && (Zhangmude[3] == 1)) ap++;
                        if ((Zhangmude[3] == 0) && (Zhangmude[4] == 1)) ap++;
                        if ((Zhangmude[4] == 0) && (Zhangmude[5] == 1)) ap++;
                        if ((Zhangmude[5] == 0) && (Zhangmude[6] == 1)) ap++;
                        if ((Zhangmude[6] == 0) && (Zhangmude[7] == 1)) ap++;
                        if ((Zhangmude[7] == 0) && (Zhangmude[8] == 1)) ap++;
                        if ((Zhangmude[8] == 0) && (Zhangmude[1] == 1)) ap++;
                        if (ap == 1)
                        {
                            if ((Zhangmude[1] * Zhangmude[3] * Zhangmude[5] == 0) && (Zhangmude[3] * Zhangmude[1] * Zhangmude[7] == 0))
                            {
                                deletelist1.push_back(Point(i, j));
                            }
                        }
                    }
                }
            }
        }
        if (deletelist1.size() == 0) break;
        for (size_t i = 0; i < deletelist1.size(); i++)
        {
            Point tem;
            tem = deletelist1[i];
            uchar* data = srcimage.ptr<uchar>(tem.y);
            data[tem.x] = 0;
        }
        deletelist1.clear();
    }
}

//排序函数
bool cmpy_y(cv::Point const& a, cv::Point const& b)
{
    return a.y < b.y;
}
bool cmpy_x(cv::Point const& a, cv::Point const& b)
{
    return a.x < b.x;
}
//包含带边框的
const char * BoundingBox(Mat &srcImg,char* m_name)
{
    if (srcImg.empty())
    {
        return "failer";
    }
    else
    {
        Mat dstImage;
        Mat tempImage = srcImg.clone();
        //GaussianBlur(srcImg,srcImg,Size(5,5),0,0); //高斯滤波
        medianBlur(srcImg, dstImage, 3);//中值滤波
        cvtColor(dstImage, dstImage, CV_RGB2GRAY);
        threshold(dstImage, dstImage, 100, 255, CV_THRESH_BINARY_INV);
        chao_thinimage(dstImage);
        vector<vector<Point>> contours;
        vector<Vec4i> hierarcy;
        findContours(dstImage, contours, hierarcy, CV_RETR_EXTERNAL, CHAIN_APPROX_SIMPLE); //查找轮廓
        vector<Rect> boundRect(contours.size()); //定义外接矩形集合
        int x0 = 0, y0 = 0, w0 = 0, h0 = 0;
        for (int i = 0; i < contours.size(); i++)
        {
            boundRect[i] = boundingRect((Mat)contours[i]); //查找每个轮廓的外接矩形
            drawContours(srcImg, contours, i, Scalar(0, 0, 255), 2, 8);  //绘制轮廓
            x0 = boundRect[i].x;  //获得第i个外接矩形的左上角的x坐标
            y0 = boundRect[i].y; //获得第i个外接矩形的左上角的y坐标
            w0 = boundRect[i].width; //获得第i个外接矩形的宽度
            h0 = boundRect[i].height; //获得第i个外接矩形的高度
            if (w0*h0 > 10000)
            {
                rectangle(srcImg, Point(x0, y0), Point(x0 + w0, y0 + h0), Scalar(0, 255, 0), 2, 8); //绘制第i个外接矩形
                Mat ImageRoi(tempImage, Rect(x0, y0, w0, h0));
                //imshow("ROI", ImageRoi);
                imwrite(m_name, ImageRoi);
            }
        }
        return "success";
    }
}
//不带边框
const char * NoBox(Mat &srcImg,char *m_name)
{
    if (srcImg.empty())
    {
        return "failer";
    }
    else
    {
        Mat dstImg;
        cvtColor(srcImg, dstImg, CV_BGR2GRAY);
        Mat bw;
        adaptiveThreshold(~dstImg, bw, 255, CV_ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY, 15, -2);
        //chao_thinimage(bw);
        //imshow("bw", bw);
        Mat horizontal = bw.clone();
        Mat vertical = bw.clone();
        int scale = 20; //这个值越大，检测到的直线越多
        int horizontalsize = horizontal.cols / scale;
        // 为了获取横向的表格线，设置腐蚀和膨胀的操作区域为一个比较大的横向直条
        Mat horizontalStructure = getStructuringElement(MORPH_RECT, Size(horizontalsize, 1));
        // 先腐蚀再膨胀
        erode(horizontal, horizontal, horizontalStructure, Point(-1, -1));
        dilate(horizontal, horizontal, horizontalStructure, Point(-1, -1));
        int verticalsize = vertical.rows / scale;
        Mat verticalStructure = getStructuringElement(MORPH_RECT, Size(1, verticalsize));
        erode(vertical, vertical, verticalStructure, Point(-1, -1));
        dilate(vertical, vertical, verticalStructure, Point(-1, -1));
        Mat mask = horizontal + vertical;
        chao_thinimage(horizontal);
        chao_thinimage(vertical);
        Mat joints;
        bitwise_and(horizontal, vertical, joints);
        vector<Point> temp;
        vector<Point> endtemp;
        Point start;
        //寻找左上角点
        for (int i = 0; i < joints.rows; i++)
        {
            uchar *data = joints.ptr<uchar>(i);
            for (int j = 0; j < joints.cols; j++)
            {
                if (data[j] == 255 && data[j - 1] == 0)
                {
                    start.x = j;
                    start.y = i;
                    temp.push_back(start);
                    endtemp.push_back(start);
                }
            }
        }
        sort(temp.begin(), temp.end(), cmpy_x);
        sort(endtemp.begin(), endtemp.end(), cmpy_y);
        int x0 = temp[0].x + 2;
        int y0 = temp[0].y + 2;
        int width = temp[temp.size() - 1].x - temp[0].x - 2;
        int height = endtemp[endtemp.size() - 1].y - endtemp[0].y - 2;
        if (width <= srcImg.cols - x0 && height <= srcImg.rows - y0)
        {
            Mat ROI(srcImg, Rect(x0, y0, width, height));
            //imshow("ROI", ROI);
            imwrite(m_name,ROI);
            return "success";
        }
        else
        {
            return "failer";
        }
    }
}
const char *  _stdcall DetectionBox(char *name,int flag)
{
    Mat temp = imread(name);
    if (flag == 1)
    {
        return BoundingBox(temp,name);
    }
    else if (flag == 2)
    {
        return NoBox(temp,name);
    }
    else
    {
        return "flag is empty";
    }

}
图像处理之Zhang Suen细化算法
weixin_34116110的博客
08-07 2388
在二值图像处理特别是OCR识别与匹配中，都要通过对字符进行细化以便获得图像的骨架，通过zhang-suen细化算法获得图像，作为图像的特征之一，常用来作为识别或者模式匹配。 一：算法介绍 Zhang-Suen细化算法通常是一个迭代算法，整个迭代过程分为两步： Step One：循环所有前景像素点，对符合如下条件的像素点标记为删除： 1.2 &...
票据单据识别OCR
ocr92的博客
08-06 8649
票据单据识别OCR是一款通用的数据批量采集软件，适用于具有表格特征的表单、问卷、单证，通过扫描、图像处理、自动分类、OCR（光学字符识别）技术，将表格图像中的数据信息准确、快速、真实地提取并保存，数据结果可导出为标准的数据格式，如Excel表，与企事业单位的ERP、CRM等系统实现无缝结合。系统支持中英文、数字、符号等多类型字符的手写体、印刷体识别。 票据单据识别OCR表格表单是一种高度精炼，集...
票据OCR前预处理 (附Demo)
weixin_34072159的博客
04-12 533
发一个去年做的一个去除票据干扰项的demo，核心处理是移除红色印章，不破坏红印叠加处的文字。 只是一个小小demo，还没具体进行进一步优化。 也不知道什么时候才有精力继续优化它。 现在放出来给大家试用一下效果。 放上效果图： demo下载 http://files.cnblogs.com/files/tntmonks/GImage.zip (注:可能会被杀毒软件误杀，添加...
OpenCV笔记（5）(定位票据并规范化、调库扫描文本)
dianshu9815的博客
08-16 452
一、定位和变换票据 定位照片中的不规范票据或矩形文本，并将其变换为正规矩形，以供OCR识别。 # -*- coding:utf-8 -*- __author__ = 'Leo.Z' import cv2 as cv import numpy as np def show_img(img, win_name): cv.imshow(win_name, ...
TOCR 4.0 文字识别软件
03-24
由于官网下载比较麻烦，所以上传一下上来了.
图像细化函数
一抹烟霞的博客
10-03 427
在我们进行图像处理的时候，有可能需要对图像进行细化，提取出图像的骨架信息，进行更加有效的分析。 图像细化（Image Thinning），一般指二值图像的骨架化（Image Skeletonization） 的一种操作运算。 所谓的细化就是经过一层层的剥离，从原来的图中去掉一些点，但仍要保持原来的形状，直到得到图像的骨架。骨架，可以理解为...
图像分析－骨架提取
热门推荐
道可盗经常盗
06-26 1万+
转自：https://blog.youkuaiyun.com/xukaiwen_2016/article/details/53135866论文 A fast parallel algorithm for thinning digital patterns所谓细化就是经过一层层的剥离，从原来的图中去掉一些点，但仍要保持原来的形状，直到得到图像的骨架。骨架，可以理解为物体的中轴，例如一个长方形的骨架是它的长方向上...
我是票据图像的预处理任务
02-26
现在用户转向票据预处理，可能需要更具体的步骤和工具推荐。 用户可能的真实需求是什么？他们可能在处理大量票据图像，需要自动化预处理流程，以提高后续处理的准确性。例如，扫描的票据可能有倾斜、阴影、模糊或...
银行票据手写数字串识别的预处理与分割.pdf
11-28
银行票据手写数字串识别的预处理与分割 本论文主要研究银行票据手写数字串识别系统的预处理和分割技术，以提高整个数字串识别率。该系统对银行业有非常大的实用价值。本研究的主要内容包括： 1. 图像灰度化处理：...
基于OpenCV和Python的二维码批量识别与替换系统_支持电子票据二维码处理_包含亮度对比度调整_灰度转换_双边滤波_反二值化等图像预处理算法优化_实现二维码高效检测与替换_可.zip
最新发布
08-13
基于OpenCV和Python的二维码批量识别与替换系统_支持电子票据二维码处理_包含亮度对比度调整_灰度转换_双边滤波_反二值化等图像预处理算法优化_实现二维码高效检测与替换_可.zip
跨境物流清关加速：TensorFlow-多语言票据信息抽取框架.pdf
01-05
该文档【跨境物流清关加速：TensorFlow_多语言票据信息抽取框架】共计 32 页，文档支持目录章节跳转同时还支持阅读器左侧大纲显示和章节快速定位，文档内容完整、条理清晰。文档内所有文字、图表、目录等元素均显示...
收据预处理
03-24
#### 二、去除透明度（Alpha通道） 当收据图片包含透明背景或者复杂的叠加效果时，Tesseract OCR引擎可能会受到干扰。在这种情况下，可以利用leptonica库中的`pixRemoveAlpha()`函数移除alpha分量。该操作会将透明...
YOLO10+OCR识别电子发票的指定文字内容
普通人能赶追天才的方法只有坚持
07-26 4606
实验室里经常有大量的发票需要报销，每次都需要人工一张一张的去手动核对发票上的关键信息是否符合要求，于是我打算使用yolo+ocr的技术去实现自动核对电子发票上的关键信息。ps:因为发票信息可能比较敏感，因此本文中提到的发票数据集和合成逼真发票图片的代码将不被提供YOLO部分一、准备训练所需的数据集。
(OpenCV/Python)实现OCR银行票据
weixin_34226182的博客
08-02 3318
更多深度文章，请关注：https://yq.aliyun.com/cloud 今天我们来介绍一下如何使用（opencv/python）来实现OCR处理银行票据。文末有代码和相关文档下载！ 在第一部分中，我们将讨论两个主题： 1. 首先，我们将了解MICR E-13B字体，美国，英国，加拿大等国家用于支票上都是使用的这种字体。 2. 其次，我...
（附完整python源码）基于tensorflow、opencv的入门案例_发票识别二：字符分割
m0_38097087的博客
05-14 7064
11
opencv 探索之路转载
fanhenghui的专栏
10-28 546
https://www.cnblogs.com/skyfsm/category/1000207.html
人工智能表格票据识别-要素信息自动识别提取
ocr92的博客
05-28 9785
一、产品简介表格票据自动识别开发包（SDK）是一款通用的数据批量采集组件产品，适用于具有表格特征的表单、问卷、单证、发票，通过扫描、图像处理、自动分类、OCR（光学字符识别）技术，将表格图像中的数据信息准确、快速、真实地提取并保存，数据结果可转化为标准的数据格式，如XML、Excel等，与企事业单位的ERP、CRM等系统实现无缝结合。产品支持中英文、数字、符号等多类型字符的手写体、印刷体识别。二、...
OpenCV探索之路（二十八）：Bag of Features(BoF)图像分类实践
weixin_33713503的博客
12-24 525
在深度学习在图像识别任务上大放异彩之前，词袋模型Bag of Features一直是各类比赛的首选方法。首先我们先来回顾一下PASCAL VOC竞赛历年来的最好成绩来介绍物体分类算法的发展。 从上表我们可以发现，在2012年之前，词袋模型是VOC竞赛分类算法的基本框架，几乎所有算法都是基于词袋模型的，可以这么说，词袋模型在图像分类中统治了很多年。虽然现在深度学习在图像识别任务中的效果更胜一筹，但...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值