OpenCV的svm手写字检测

最新推荐文章于 2024-01-28 11:17:20 发布
最新推荐文章于 2024-01-28 11:17:20 发布
阅读量4.8k 收藏 10
点赞数 2
分类专栏： OpenCV
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/augusdi/article/details/8865285
版权

转自http://blog.csdn.net/firefight/article/details/6452188

是MNIST手写数字图片库：http://code.google.com/p/supplement-of-the-mnist-database-of-handwritten-digits/downloads/list

其他方法：http://blog.csdn.net/onezeros/article/details/5672192

 

使用OPENCV训练手写数字识别分类器 

1，下载训练数据和测试数据文件，这里用的是MNIST手写数字图片库，其中训练数据库中为60000个，测试数据库中为10000个
2，创建训练数据和测试数据文件读取函数，注意字节顺序为大端
3，确定字符特征方式为最简单的8×8网格内的字符点数


4，创建SVM，训练并读取，结果如下
 1000个训练样本，测试数据正确率80.21%（并没有体现SVM小样本高准确率的特性啊）
  10000个训练样本，测试数据正确率95.45%
  60000个训练样本，测试数据正确率97.67%

5，编写手写输入的GUI程序，并进行验证，效果还可以接受。

 

以下为主要代码，以供参考

（类似的也实现了随机树分类器，比较发现在相同的样本数情况下，SVM准确率略高）

#include "stdafx.h"    
   
#include <fstream>    
#include "opencv2/opencv.hpp"    
#include <vector>    
   
using namespace std;   
using namespace cv;   
   
#define SHOW_PROCESS 0    
#define ON_STUDY 0    
   
class NumTrainData   
{   
public:   
    NumTrainData()   
    {   
        memset(data, 0, sizeof(data));   
        result = -1;   
    }   
public:   
    float data[64];   
    int result;   
};   
   
vector<NumTrainData> buffer;   
int featureLen = 64;   
   
void swapBuffer(char* buf)   
{   
    char temp;   
    temp = *(buf);   
    *buf = *(buf+3);   
    *(buf+3) = temp;   
   
    temp = *(buf+1);   
    *(buf+1) = *(buf+2);   
    *(buf+2) = temp;   
}   
   
void GetROI(Mat& src, Mat& dst)   
{   
    int left, right, top, bottom;   
    left = src.cols;   
    right = 0;   
    top = src.rows;   
    bottom = 0;   
   
    //Get valid area    
    for(int i=0; i<src.rows; i++)   
    {   
        for(int j=0; j<src.cols; j++)   
        {   
            if(src.at<uchar>(i, j) > 0)   
            {   
                if(j<left) left = j;   
                if(j>right) right = j;   
                if(i<top) top = i;   
                if(i>bottom) bottom = i;   
            }   
        }   
    }   
   
    //Point center;    
    //center.x = (left + right) / 2;    
    //center.y = (top + bottom) / 2;    
   
    int width = right - left;   
    int height = bottom - top;   
    int len = (width < height) ? height : width;   
   
    //Create a squre    
    dst = Mat::zeros(len, len, CV_8UC1);   
   
    //Copy valid data to squre center    
    Rect dstRect((len - width)/2, (len - height)/2, width, height);   
    Rect srcRect(left, top, width, height);   
    Mat dstROI = dst(dstRect);   
    Mat srcROI = src(srcRect);   
    srcROI.copyTo(dstROI);   
}   
   
int ReadTrainData(int maxCount)   
{   
    //Open image and label file    
    const char fileName[] = "../res/train-images.idx3-ubyte";   
    const char labelFileName[] = "../res/train-labels.idx1-ubyte";   
   
    ifstream lab_ifs(labelFileName, ios_base::binary);   
    ifstream ifs(fileName, ios_base::binary);   
   
    if( ifs.fail() == true )   
        return -1;   
   
    if( lab_ifs.fail() == true )   
        return -1;   
   
    //Read train data number and image rows / cols    
    char magicNum[4], ccount[4], crows[4], ccols[4];   
    ifs.read(magicNum, sizeof(magicNum));   
    ifs.read(ccount, sizeof(ccount));   
    ifs.read(crows, sizeof(crows));   
    ifs.read(ccols, sizeof(ccols));   
   
    int count, rows, cols;   
    swapBuffer(ccount);   
    swapBuffer(crows);   
    swapBuffer(ccols);   
   
    memcpy(&count, ccount, sizeof(count));   
    memcpy(&rows, crows, sizeof(rows));   
    memcpy(&cols, ccols, sizeof(cols));   
   
    //Just skip label header    
    lab_ifs.read(magicNum, sizeof(magicNum));   
    lab_ifs.read(ccount, sizeof(ccount));   
   
    //Create source and show image matrix    
    Mat src = Mat::zeros(rows, cols, CV_8UC1);   
    Mat temp = Mat::zeros(8, 8, CV_8UC1);   
    Mat img, dst;   
   
    char label = 0;   
    Scalar templateColor(255, 0, 255 );   
   
    NumTrainData rtd;   
   
    //int loop = 1000;    
    int total = 0;   
   
    while(!ifs.eof())   
    {   
        if(total >= count)   
            break;   
           
        total++;   
        cout << total << endl;   
           
        //Read label    
        lab_ifs.read(&label, 1);   
        label = label + '0';   
   
        //Read source data    
        ifs.read((char*)src.data, rows * cols);   
        GetROI(src, dst);   
   
#if(SHOW_PROCESS)    
        //Too small to watch    
        img = Mat::zeros(dst.rows*10, dst.cols*10, CV_8UC1);   
        resize(dst, img, img.size());   
   
        stringstream ss;   
        ss << "Number " << label;   
        string text = ss.str();   
        putText(img, text, Point(10, 50), FONT_HERSHEY_SIMPLEX, 1.0, templateColor);   
   
        //imshow("img", img);    
#endif    
   
        rtd.result = label;   
        resize(dst, temp, temp.size());   
        //threshold(temp, temp, 10, 1, CV_THRESH_BINARY);    
   
        for(int i = 0; i<8; i++)   
        {   
            for(int j = 0; j<8; j++)   
            {   
                    rtd.data[ i*8 + j] = temp.at<uchar>(i, j);   
            }   
        }   
   
        buffer.push_back(rtd);   
   
        //if(waitKey(0)==27) //ESC to quit    
        //  break;    
   
        maxCount--;   
           
        if(maxCount == 0)   
            break;   
    }   
   
    ifs.close();   
    lab_ifs.close();   
   
    return 0;   
}   
   
void newRtStudy(vector<NumTrainData>& trainData)   
{   
    int testCount = trainData.size();   
   
    Mat data = Mat::zeros(testCount, featureLen, CV_32FC1);   
    Mat res = Mat::zeros(testCount, 1, CV_32SC1);   
   
    for (int i= 0; i< testCount; i++)    
    {    
   
        NumTrainData td = trainData.at(i);   
        memcpy(data.data + i*featureLen*sizeof(float), td.data, featureLen*sizeof(float));   
   
        res.at<unsigned int>(i, 0) = td.result;   
    }   
   
    /START RT TRAINNING//    
    CvRTrees forest;   
    CvMat* var_importance = 0;   
   
    forest.train( data, CV_ROW_SAMPLE, res, Mat(), Mat(), Mat(), Mat(),   
            CvRTParams(10,10,0,false,15,0,true,4,100,0.01f,CV_TERMCRIT_ITER));   
    forest.save( "new_rtrees.xml" );   
}   
   
   
int newRtPredict()   
{   
    CvRTrees forest;   
    forest.load( "new_rtrees.xml" );   
   
    const char fileName[] = "../res/t10k-images.idx3-ubyte";   
    const char labelFileName[] = "../res/t10k-labels.idx1-ubyte";   
   
    ifstream lab_ifs(labelFileName, ios_base::binary);   
    ifstream ifs(fileName, ios_base::binary);   
   
    if( ifs.fail() == true )   
        return -1;   
   
    if( lab_ifs.fail() == true )   
        return -1;   
   
    char magicNum[4], ccount[4], crows[4], ccols[4];   
    ifs.read(magicNum, sizeof(magicNum));   
    ifs.read(ccount, sizeof(ccount));   
    ifs.read(crows, sizeof(crows));   
    ifs.read(ccols, sizeof(ccols));   
   
    int count, rows, cols;   
    swapBuffer(ccount);   
    swapBuffer(crows);   
    swapBuffer(ccols);   
   
    memcpy(&count, ccount, sizeof(count));   
    memcpy(&rows, crows, sizeof(rows));   
    memcpy(&cols, ccols, sizeof(cols));   
   
    Mat src = Mat::zeros(rows, cols, CV_8UC1);   
    Mat temp = Mat::zeros(8, 8, CV_8UC1);   
    Mat m = Mat::zeros(1, featureLen, CV_32FC1);   
    Mat img, dst;   
   
    //Just skip label header    
    lab_ifs.read(magicNum, sizeof(magicNum));   
    lab_ifs.read(ccount, sizeof(ccount));   
   
    char label = 0;   
    Scalar templateColor(255, 0, 0);   
   
    NumTrainData rtd;   
   
    int right = 0, error = 0, total = 0;   
    int right_1 = 0, error_1 = 0, right_2 = 0, error_2 = 0;   
    while(ifs.good())   
    {   
        //Read label    
        lab_ifs.read(&label, 1);   
        label = label + '0';   
   
        //Read data    
        ifs.read((char*)src.data, rows * cols);   
        GetROI(src, dst);   
   
        //Too small to watch    
        img = Mat::zeros(dst.rows*30, dst.cols*30, CV_8UC3);   
        resize(dst, img, img.size());   
   
        rtd.result = label;   
        resize(dst, temp, temp.size());   
        //threshold(temp, temp, 10, 1, CV_THRESH_BINARY);    
        for(int i = 0; i<8; i++)   
        {   
            for(int j = 0; j<8; j++)   
            {   
                    m.at<float>(0,j + i*8) = temp.at<uchar>(i, j);   
            }   
        }   
   
        if(total >= count)   
            break;   
   
        char ret = (char)forest.predict(m);    
   
        if(ret == label)   
        {   
            right++;   
            if(total <= 5000)   
                right_1++;   
            else   
                right_2++;   
        }   
        else   
        {   
            error++;   
            if(total <= 5000)   
                error_1++;   
            else   
                error_2++;   
        }   
   
        total++;   
   
#if(SHOW_PROCESS)    
        stringstream ss;   
        ss << "Number " << label << ", predict " << ret;   
        string text = ss.str();   
        putText(img, text, Point(10, 50), FONT_HERSHEY_SIMPLEX, 1.0, templateColor);   
   
        imshow("img", img);   
        if(waitKey(0)==27) //ESC to quit    
            break;   
#endif    
   
    }   
   
    ifs.close();   
    lab_ifs.close();   
   
    stringstream ss;   
    ss << "Total " << total << ", right " << right <<", error " << error;   
    string text = ss.str();   
    putText(img, text, Point(50, 50), FONT_HERSHEY_SIMPLEX, 1.0, templateColor);   
    imshow("img", img);   
    waitKey(0);   
   
    return 0;   
}   
   
void newSvmStudy(vector<NumTrainData>& trainData)   
{   
    int testCount = trainData.size();   
   
    Mat m = Mat::zeros(1, featureLen, CV_32FC1);   
    Mat data = Mat::zeros(testCount, featureLen, CV_32FC1);   
    Mat res = Mat::zeros(testCount, 1, CV_32SC1);   
   
    for (int i= 0; i< testCount; i++)    
    {    
   
        NumTrainData td = trainData.at(i);   
        memcpy(m.data, td.data, featureLen*sizeof(float));   
        normalize(m, m);   
        memcpy(data.data + i*featureLen*sizeof(float), m.data, featureLen*sizeof(float));   
   
        res.at<unsigned int>(i, 0) = td.result;   
    }   
   
    /START SVM TRAINNING//    
    CvSVM svm = CvSVM();    
    CvSVMParams param;    
    CvTermCriteria criteria;   
   
    criteria= cvTermCriteria(CV_TERMCRIT_EPS, 1000, FLT_EPSILON);    
    param= CvSVMParams(CvSVM::C_SVC, CvSVM::RBF, 10.0, 8.0, 1.0, 10.0, 0.5, 0.1, NULL, criteria);    
   
    svm.train(data, res, Mat(), Mat(), param);   
    svm.save( "SVM_DATA.xml" );   
}   
   
   
int newSvmPredict()   
{   
    CvSVM svm = CvSVM();    
    svm.load( "SVM_DATA.xml" );   
   
    const char fileName[] = "../res/t10k-images.idx3-ubyte";   
    const char labelFileName[] = "../res/t10k-labels.idx1-ubyte";   
   
    ifstream lab_ifs(labelFileName, ios_base::binary);   
    ifstream ifs(fileName, ios_base::binary);   
   
    if( ifs.fail() == true )   
        return -1;   
   
    if( lab_ifs.fail() == true )   
        return -1;   
   
    char magicNum[4], ccount[4], crows[4], ccols[4];   
    ifs.read(magicNum, sizeof(magicNum));   
    ifs.read(ccount, sizeof(ccount));   
    ifs.read(crows, sizeof(crows));   
    ifs.read(ccols, sizeof(ccols));   
   
    int count, rows, cols;   
    swapBuffer(ccount);   
    swapBuffer(crows);   
    swapBuffer(ccols);   
   
    memcpy(&count, ccount, sizeof(count));   
    memcpy(&rows, crows, sizeof(rows));   
    memcpy(&cols, ccols, sizeof(cols));   
   
    Mat src = Mat::zeros(rows, cols, CV_8UC1);   
    Mat temp = Mat::zeros(8, 8, CV_8UC1);   
    Mat m = Mat::zeros(1, featureLen, CV_32FC1);   
    Mat img, dst;   
   
    //Just skip label header    
    lab_ifs.read(magicNum, sizeof(magicNum));   
    lab_ifs.read(ccount, sizeof(ccount));   
   
    char label = 0;   
    Scalar templateColor(255, 0, 0);   
   
    NumTrainData rtd;   
   
    int right = 0, error = 0, total = 0;   
    int right_1 = 0, error_1 = 0, right_2 = 0, error_2 = 0;   
    while(ifs.good())   
    {   
        //Read label    
        lab_ifs.read(&label, 1);   
        label = label + '0';   
   
        //Read data    
        ifs.read((char*)src.data, rows * cols);   
        GetROI(src, dst);   
   
        //Too small to watch    
        img = Mat::zeros(dst.rows*30, dst.cols*30, CV_8UC3);   
        resize(dst, img, img.size());   
   
        rtd.result = label;   
        resize(dst, temp, temp.size());   
        //threshold(temp, temp, 10, 1, CV_THRESH_BINARY);    
        for(int i = 0; i<8; i++)   
        {   
            for(int j = 0; j<8; j++)   
            {   
                    m.at<float>(0,j + i*8) = temp.at<uchar>(i, j);   
            }   
        }   
   
        if(total >= count)   
            break;   
   
        normalize(m, m);   
        char ret = (char)svm.predict(m);    
   
        if(ret == label)   
        {   
            right++;   
            if(total <= 5000)   
                right_1++;   
            else   
                right_2++;   
        }   
        else   
        {   
            error++;   
            if(total <= 5000)   
                error_1++;   
            else   
                error_2++;   
        }   
   
        total++;   
   
#if(SHOW_PROCESS)    
        stringstream ss;   
        ss << "Number " << label << ", predict " << ret;   
        string text = ss.str();   
        putText(img, text, Point(10, 50), FONT_HERSHEY_SIMPLEX, 1.0, templateColor);   
   
        imshow("img", img);   
        if(waitKey(0)==27) //ESC to quit    
            break;   
#endif    
   
    }   
   
    ifs.close();   
    lab_ifs.close();   
   
    stringstream ss;   
    ss << "Total " << total << ", right " << right <<", error " << error;   
    string text = ss.str();   
    putText(img, text, Point(50, 50), FONT_HERSHEY_SIMPLEX, 1.0, templateColor);   
    imshow("img", img);   
    waitKey(0);   
   
    return 0;   
}   
   
int main( int argc, char *argv[] )   
{   
#if(ON_STUDY)    
    int maxCount = 60000;   
    ReadTrainData(maxCount);   
   
    //newRtStudy(buffer);    
    newSvmStudy(buffer);   
#else    
    //newRtPredict();    
    newSvmPredict();   
#endif    
    return 0;   
}


 

Augusdi
关注
  • 2
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
图像车牌识别-SVM分类器的构建（字符识别部分）
紫电青霜
03-09 1万+
车牌识别系统识别部分采用了SVM分类器，训练一定数量的样本，构建了一个SVM分类器，实现车牌汉字和字母，以及数字的识别。<1> SVMSVM是支持向量机（Support Vector Machine）的简称，对于解决小样本、非线性、高维的模式识别问题有很多特有的优势。 简单地讲呢，SVM分类算法的实质就是在样本的特征空间中找到一个最优的超平面，使这个超平面离所有的类的样本的距离最小者最大化。 如
基于SVM的手写数字识别（Opencv+图像集）
04-01
自己写的手写数字识别源码，识别效果还可以，基于Opencv3.1+VS2013，带有数字0-5的数据集，还有自己训练的特征文件，包含训练程序以及测试程序。
OpencvSharp SVM实现汉字识别
CtrlNew的博客
10-27 398
OpencvSharp SVM实现汉字识别
【OpenCV】利用OpenCV中的KNN算法实现手写数字和手写字母的识别
只须一笑不须愁X的博客
05-07 6118
【OpenCV】利用OpenCV中的KNN算法实现手写数字和手写字母的识别 一、KNN算法（K近邻） KNN（K Near Neighbor）：k个最近的邻居，即每个样本都可以用它最接近的k个邻居来代表。 距离度量：一般采用欧式距离度量，常用的距离度量方式还有：曼哈顿距离、切比雪夫距离 K值是可以设置的变量： K值过小：k值小，特征空间被划分为更多子空间，整体模型变复杂，容易发生过拟合，k值越小，选择的范围就比较小，训练的时候命中率较高，近似误差小，而用测试集的时候就容易出错，估计误差大，容易
基于SVM的手写字体识别
人工智能算法学习matlab
01-28 408
随着人工智能技术的发展，手写字体识别已成为计算机视觉领域的一个重要研究方向。SVM（支持向量机）是一种常用的算法，可以用于手写字体识别。
【OpenCV-Python】教程：7-6 SVM识别手写字符
12-24 873
训练模型，由于SVM有很多参数，并且需要寻找最好的参数，可以使用。在kNN中，直接用的是像素亮度值，这次，我们将使用。(HOG) 作为特征向量。自动训练使用最好的参数。创建一个空的模型
学习OpenCV——SVM 手写数字检测
小熊不去实验室
04-13 9855
转自http://blog.csdn.net/firefight/article/details/6452188 是MNIST手写数字图片库：http://code.google.com/p/supplement-of-the-mnist-database-of-handwritten-digits/downloads/list 其他方法：http://blog.csdn.net/onezer
使用OPENCV训练手写数字识别分类器
热门推荐
firefight的专栏
05-28 3万+
使用OPENCV训练手写数字识别分类器 1，下载训练数据和测试数据文件，这里用的是MNIST手写数字图片库，其中训练数据库中为60000个，测试数据库中为10000个2，创建训练数据和测试数据文件读取函数，注意字节顺序为大端3，确定字符特征方式为最简单的8×8网格内的字符点数4，创建SVM，训练并读取，结果如下  1000个训练样本，测试数据正确率80.21%（并没有体现SVM小样本高准确率的特性啊）  10000个训练样本，测试数据正确率95.45%5，编写手写输入的GUI程序，并进行验证，效果还可以接受
使用开源工具OpencvsharpHelper测试Hog + svm机器学习效果
tfarcraw的博客
06-11 1104
关于OpencvsharpHelper
OpenCvSharp-机器学习-支持向量机（SVM）附例程源码
m0_55074196的博客
07-14 324
有空再继续补充知识点了。。。
Opencv3.0 手写数字识别（Hog特征+SVM分类器）
06-01
基于Hog特征+SVM分类器，利用Opencv3.0进行手写数字识别的源代码及所需资源文件（训练图片、测试图片）
Opencv2.4.12 SVM手写数字识别示例
02-24
程序测试环境 VS2013+Opencv2.4.12 遍历文件夹下所有手写数字图片 处理后压如堆栈 最后用SVM进行分类识别
基于matlab和opencv的手写数字及字母识别系统.rar
01-19
基于matlab和opencv的手写数字及字母识别系统
126邮箱页 html源码 单页源码 网站后台登陆界面HTML源码.zip
04-23
126邮箱页 html源码 单页源码 网站后台登陆界面HTML源码
武汉开放数据创新大赛——烽火杯文件.zip
04-23
武汉开放数据创新大赛——烽火杯文件
mmexport1713881481676.png
04-23
mmexport1713881481676.png
Digital currency trading platformAdobeXD源码下载设计素材UI设计.xd
最新发布
04-23
Digital currency trading platform landing pageAdobeXD源码下载设计素材UI设计
了解Java及环境搭建
04-23
了解Java及环境搭建
专业实习-三创赛.zip
04-23
专业实习-三创赛
opencv svm 数字识别 单张jpg
12-22
在使用OpenCV进行数字识别时，我们可以利用支持向量机（SVM）这一强大的机器学习算法来训练模型。 首先，我们需要准备一些用于训练模型的数字图片数据集。这些图片可以是手写数字，也可以是印刷数字，我们要确保...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值