票据预处理（二）

最新推荐文章于 2018-10-28 15:49:04 发布
最新推荐文章于 2018-10-28 15:49:04 发布
阅读量428 收藏
点赞数
分类专栏： opencv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/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";
    }

}
cool_策
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
票据OCR前预处理 (附Demo)
weixin_34072159的博客
04-12 484
发一个去年做的一个去除票据干扰项的demo，核心处理是移除红色印章，不破坏红印叠加处的文字。 只是一个小小demo，还没具体进行进一步优化。 也不知道什么时候才有精力继续优化它。 现在放出来给大家试用一下效果。 放上效果图： demo下载 http://files.cnblogs.com/files/tntmonks/GImage.zip (注:可能会被杀毒软件误杀，添加...
OpenCV笔记（5）(定位票据并规范化、调库扫描文本)
dianshu9815的博客
08-16 401
一、定位和变换票据 定位照片中的不规范票据或矩形文本，并将其变换为正规矩形，以供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 363
在我们进行图像处理的时候，有可能需要对图像进行细化，提取出图像的骨架信息，进行更加有效的分析。 图像细化（Image Thinning），一般指二值图像的骨架化（Image Skeletonization） 的一种操作运算。 所谓的细化就是经过一层层的剥离，从原来的图中去掉一些点，但仍要保持原来的形状，直到得到图像的骨架。骨架，可以理解为...
图像分析－骨架提取
热门推荐
道可盗经常盗
06-26 1万+
转自：https://blog.csdn.net/xukaiwen_2016/article/details/53135866论文 A fast parallel algorithm for thinning digital patterns所谓细化就是经过一层层的剥离，从原来的图中去掉一些点，但仍要保持原来的形状，直到得到图像的骨架。骨架，可以理解为物体的中轴，例如一个长方形的骨架是它的长方向上...
银行票据手写数字串识别的预处理与分割.pdf
11-28
银行票据手写数字串识别的预处理与分割 本论文主要研究银行票据手写数字串识别系统的预处理和分割技术，以提高整个数字串识别率。该系统对银行业有非常大的实用价值。本研究的主要内容包括： 1. 图像灰度化处理：...
论文研究-一种基于结构的票据定位新方法 .pdf
08-16
票据的预处理是票据定位的前提工作，包括票据摆正和初步二值化的确定。票据摆正的目的是为了降低因图像倾斜而造成特征点提取失败或识别区域提取不准确的风险。在进行摆正时，会计算出票据的倾斜角度，如果角度过大，...
案例八 python银行票据认证分类
08-11
【案例八】Python银行票据认证分类是一个典型的计算机视觉与机器学习的应用，主要目的是通过自动化的算法来识别和分类银行票据中的关键信息，如金额、日期、账号等，从而提高金融机构的工作效率，减少人为错误。...
web 票据打印 ie web 票据打印
08-24
二、IE Web票据打印的特殊性 IE浏览器相对于其他现代浏览器，其打印机制略有不同。IE支持ActiveX控件，这为开发者提供了一种直接控制打印机的手段。通过创建并嵌入ActiveX控件，可以实现更精确的打印控制，例如...
应用tensorflow实现票据识别系统.zip
最新发布
05-03
可能的操作包括灰度化、二值化、直方图均衡化、噪声去除、图像增强等。这些预处理技术有助于突出图像中的关键信息，减少对模型训练的干扰。 2. **特征提取**：在图像预处理后，我们需要提取能代表图像内容的特征。...
图像处理之Zhang Suen细化算法
weixin_34116110的博客
08-07 2048
在二值图像处理特别是OCR识别与匹配中，都要通过对字符进行细化以便获得图像的骨架，通过zhang-suen细化算法获得图像，作为图像的特征之一，常用来作为识别或者模式匹配。 一：算法介绍 Zhang-Suen细化算法通常是一个迭代算法，整个迭代过程分为两步： Step One：循环所有前景像素点，对符合如下条件的像素点标记为删除： 1.2 &...
票据单据识别OCR
ocr92的博客
08-06 8366
票据单据识别OCR是一款通用的数据批量采集软件，适用于具有表格特征的表单、问卷、单证，通过扫描、图像处理、自动分类、OCR（光学字符识别）技术，将表格图像中的数据信息准确、快速、真实地提取并保存，数据结果可导出为标准的数据格式，如Excel表，与企事业单位的ERP、CRM等系统实现无缝结合。系统支持中英文、数字、符号等多类型字符的手写体、印刷体识别。 票据单据识别OCR表格表单是一种高度精炼，集...
(OpenCV/Python)实现OCR银行票据
weixin_34226182的博客
08-02 3207
更多深度文章，请关注：https://yq.aliyun.com/cloud 今天我们来介绍一下如何使用（opencv/python）来实现OCR处理银行票据。文末有代码和相关文档下载！ 在第一部分中，我们将讨论两个主题： 1. 首先，我们将了解MICR E-13B字体，美国，英国，加拿大等国家用于支票上都是使用的这种字体。 2. 其次，我...
（附完整python源码）基于tensorflow、opencv的入门案例_发票识别二：字符分割
m0_38097087的博客
05-14 6972
11
opencv 探索之路转载
fanhenghui的专栏
10-28 499
https://www.cnblogs.com/skyfsm/category/1000207.html
人工智能表格票据识别-要素信息自动识别提取
ocr92的博客
05-28 9523
一、产品简介表格票据自动识别开发包（SDK）是一款通用的数据批量采集组件产品，适用于具有表格特征的表单、问卷、单证、发票，通过扫描、图像处理、自动分类、OCR（光学字符识别）技术，将表格图像中的数据信息准确、快速、真实地提取并保存，数据结果可转化为标准的数据格式，如XML、Excel等，与企事业单位的ERP、CRM等系统实现无缝结合。产品支持中英文、数字、符号等多类型字符的手写体、印刷体识别。二、...
OpenCV探索之路（二十八）：Bag of Features(BoF)图像分类实践
weixin_33713503的博客
12-24 457
在深度学习在图像识别任务上大放异彩之前，词袋模型Bag of Features一直是各类比赛的首选方法。首先我们先来回顾一下PASCAL VOC竞赛历年来的最好成绩来介绍物体分类算法的发展。 从上表我们可以发现，在2012年之前，词袋模型是VOC竞赛分类算法的基本框架，几乎所有算法都是基于词袋模型的，可以这么说，词袋模型在图像分类中统治了很多年。虽然现在深度学习在图像识别任务中的效果更胜一筹，但...
OCR 预处理与检测
dongfang1984的博客
03-22 6928
前言： 通用OCR领域的最难的是预处理与检测，目标检测领域我们常看到的是横平竖直， 也就是说：检测到的边框平行或垂直于图像边界。 但是，在OCR中，文字的方向可以是各种方向；而且长宽比不确定，各种场景，各种尺寸、各种语言、各种艺术字体。而且，目前多角度检测fatal 弱点：文本行比较长，检测框容易断裂； 阵列字极容易找错方向。 当然手写OCR也很难，本文主要对 preprocess 与...
票据OCR系统：图像预处理与小波变换技术的应用
作者赵莉和于承新来自山东建筑大学商学院，他们在2007年提出了一个结合灰度分段线性拉伸、二值化、滤波去噪等图像预处理技术以及字符投影特征和小波变换特征提取方法的OCR系统。此外，他们还利用小波变换的高频和...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值