opencv小项目练习之数独求解

    srcImg.copyTo(Img);
    cvtColor(Img, Img_gray,COLOR_BGR2GRAY);
    
    Mat kernel = (Mat_<float>(3, 3) << 0, -1, 0, -1, 5, -1, 0, -1, 0);
    filter2D(Img_gray, Img_g, -1, kernel);
    threshold(Img_g, Img_g, 150, 255, THRESH_BINARY_INV);         //二值阈值化，这个阈值自己选,这里是反着的，因为一般是白纸黑字

void erode( InputArray src, OutputArray dst, InputArray kernel,
                         Point anchor = Point(-1,-1), int iterations = 1,
                         int borderType = BORDER_CONSTANT,
                         const Scalar& borderValue = morphologyDefaultBorderValue() );

void dilate( InputArray src, OutputArray dst, InputArray kernel,
                          Point anchor = Point(-1,-1), int iterations = 1,
                          int borderType = BORDER_CONSTANT,
                          const Scalar& borderValue = morphologyDefaultBorderValue() );

@param src input image; the number of channels can be arbitrary, but the depth should be one of
CV_8U, CV_16U, CV_16S, CV_32F or CV_64F.(输入图像)
@param dst output image of the same size and type as src\`.（输出图像，和原图大小相同）
@param kernel structuring element used for dilation; if elemenat=Mat(), a 3 x 3 rectangular
structuring element is used. Kernel can be created using getStructuringElement（膨胀核，可由getStructuringElement()这个函数得来）
@param anchor position of the anchor within the element; default value (-1, -1) means that the
anchor is at the element center.  （锚点位置，默认最中心）
@param iterations number of times dilation is applied.（迭代的次数，调用函数可以进行多次迭代膨胀或腐蚀，默认是一次）
@param borderType pixel extrapolation method, see cv::BorderTypes
@param borderValue border value in case of a constant border
@sa  erode, morphologyEx, getStructuringElement
（后面两个参数都是和边缘处理相关的，一般使用时不用管）

Mat getStructuringElement(int shape, Size ksize, Point anchor = Point(-1,-1));
第一个参数是形状，可选三种，分辨是下面的标志位：
矩形：MORPH_RECT;
交叉形：MORPH_CORSS;
椭圆形：MORPH_ELLIPSE;
第二个是尺寸，必须是奇数，第三个是锚点位置，默认中心点。

void findContours( InputOutputArray image, OutputArrayOfArrays contours,
                              OutputArray hierarchy, int mode,
                              int method, Point offset = Point());

       取值一：CV_RETR_EXTERNAL只检测最外围轮廓，包含在外围轮廓内的内围轮廓被忽略
       取值二：CV_RETR_LIST   检测所有的轮廓，包括内围、外围轮廓，但是检测到的轮廓不建立等级关
              系，彼此之间独立，没有等级关系，这就意味着这个检索模式下不存在父轮廓或内嵌轮廓，
              所以hierarchy向量内所有元素的第3、第4个分量都会被置为-1，具体下文会讲到
       取值三：CV_RETR_CCOMP  检测所有的轮廓，但所有轮廓只建立两个等级关系，外围为顶层，若外
              内的内围轮廓还包含了其他的轮廓信息，则内围内的所有轮廓均归属于顶层
       取值四：CV_RETR_TREE， 检测所有轮廓，所有轮廓建立一个等级树结构。外层轮廓包含内层轮廓，内        
               层轮廓还可以继续包含内嵌轮廓。

    寻找轮廓的算法,具体有下面几种可选：
    取值一：CV_CHAIN_APPROX_NONE 保存物体边界上所有连续的轮廓点到contours向量内
    取值二：CV_CHAIN_APPROX_SIMPLE 仅保存轮廓的拐点信息，把所有轮廓拐点处的点保存入contours
            向量内，拐点与拐点之间直线段上的信息点不予保留
    取值三和四：CV_CHAIN_APPROX_TC89_L1，CV_CHAIN_APPROX_TC89_KCOS使用teh-Chinl chain近
             似算法
    没有什么特殊要求的话用这几种算法得到的结果都是可以接受的，我们这里选用的是SIMPLE这种。

    Point偏移量，所有的轮廓信息相对于原始图像对应点的偏移量，相当于在每一个检测出的轮廓点上加
    上该偏移量，并且Point还可以是负值！
    这个偏移量可能是为了画出一种类似于投影那样的效果用的，一般情况用默认值0就可以了。

设原图宽度和高度分别是W和H，第i个矩形的质心为(x,y).
则其索引应该是： 
[i,j]=[x/W*9,y/H*9];
要注意的是，做乘除之前把int型的数据转换为double，然后最后再转为int，去掉小数部分（去尾，不四舍五入）

void getTrainImg(vector<vector<Mat>>  &TrainImgMat)
{
    Mat tmp_srcImg;
    Mat tmp_Img_thresh;
    vector<vector<Point>> cons;
    vector<Vec4i>  hies;

    vector<Rect>  img0_9;
    for (int i = 0; i < 10; i++)
    {
        //读入，阈值化
        tmp_srcImg = imread(".\\TrainImg\\" + to_string(i) + ".jpg",0);     
        tmp_srcImg.copyTo(tmp_Img_thresh);        //拷贝一份，阈值化是在原图上做的
        
        
        threshold(tmp_Img_thresh, tmp_Img_thresh, 150, 255, CV_THRESH_BINARY_INV);
        //3*3十字膨胀
        auto kernel=getStructuringElement(CV_SHAPE_CROSS, Size(3, 3));
        dilate(tmp_Img_thresh, tmp_Img_thresh, kernel);
        //查找轮廓
        findContours(tmp_Img_thresh, cons, hies, RETR_TREE, CHAIN_APPROX_SIMPLE);
        
        //筛选没有父轮廓的轮廓为数字，并求其最小包围矩形
        for (int j = 0; j < hies.size(); j++)
        {
            if (hies[j][3] == -1)
            {
                img0_9.push_back(boundingRect(cons[j]));
            }
        }
        //排序，按照矩形包围圈的x坐标排序
        sort(img0_9.begin(), img0_9.end(), [](Rect &a, Rect &b)->bool {return a.x < b.x; });     
        
        
        for (int k = 0; k < img0_9.size(); k++)
        {
            Mat img20;
            
            resize(tmp_srcImg(img0_9[k]), img20, Size(20, 20));
            TrainImgMat[i].push_back(img20);    
        }
        //清除内存空间，下次用
        cons.clear();
        hies.clear();
        img0_9.clear(); 
    }
}

Mat trainData;
    Mat Label;

    for (int i = 0; i < 10; i++)
    {
        for (int j = 0; j < 10; j++)
        {
            trainData.push_back(TrainImgMat[j][i].reshape(0,1));
            //imshow(" s", TrainImgMat[j][i]);
            Label.push_back(i);
        }
    }

    imshow("das",trainData);

//转换成浮点备用
trainData.convertTo(trainData, CV_32F);           //格式转化必不可少
Ptr<TrainData> tData = TrainData::create(trainData, ROW_SAMPLE, Label); 

//Numbers是vector<Mat>类型，是检测出来的数字图片
    Mat TestData;
    for (auto nums:Numbers)
    {
        TestData.push_back(nums.reshape(0, 1));
    }
    
    TestData.convertTo(TestData, CV_32F);

//---------【knn分类器设置，k=3,分类打开】-----------------
    Ptr<TrainData> tData = TrainData::create(trainData, ROW_SAMPLE, Label);          //

    Ptr<ml::KNearest> knn = ml::KNearest::create();
    knn->setDefaultK(4);        
    knn->setIsClassifier(true);
    knn->train(tData);



    //---【检测方法1】--------
    /*Mat predictRes;
    knn->findNearest(TestData, 4, predictRes);
    cout << predictRes;*/
    

    //----【检测方法2】-----------------
    vector<int>  PredicrRes;
    for (int i = 0; i < TestData.rows; i++)
    {
        Mat tmp = TestData.row(i);
        int response = knn->predict(tmp);
        PredicrRes.push_back(response);
        //cout << response <<"\t"<<i<< endl;

    }

vector<vector<int>> ShuDuMat(9,vector<int>());
    //全零矩阵
    for (int i = 0; i < 9; i++)
    {
        for (int j = 0; j < 9; j++)
        {
            ShuDuMat[i].push_back(0);

        }
    }
      //对应位置赋值
    for (int i = 0; i < PredicrRes.size(); i++)
    {
        ShuDuMat[PosOfNum[i].y][PosOfNum[i].x] = PredicrRes[i];
    }

//---------【获得81个矩形对应的位置，矩阵的位置和原图位置对应】----------
    vector<Rect>  Pos;
    for (int i = 0; i < hierarchy.size(); i++)
    {
        Rect tmp;
        if (hierarchy[i][3] == 0)
        {
            Pos.push_back(boundingRect(contours[i]));
        }
    }
    //按照y来排序，一排一排都链在一起
    sort(Pos.begin(), Pos.end(), [](Rect &a, Rect &b)->bool{return a.y < b.y; });
    cout << "小矩形的个数是" << Pos.size() << endl;

    vector<vector<Rect>> PosMat(9,vector<Rect>());
    int index = 0;
    for (int i = 0; i < 81; i+=9)
    {
        PosMat[index++].assign(Pos.begin() + i, Pos.begin() + i + 9);    //赋值每一行
    }
    
    for (int i=0;i<9;i++)
    {
        sort(PosMat[i].begin(), PosMat[i].end(), [](Rect &a, Rect &b)->bool {return a.x < b.x; });  //每一行按照x排列
        cout << PosMat[i].size() << endl;
    }


   //把数字写到图上
    Mat ResultImg;
    cvtColor(srcImg, ResultImg, CV_GRAY2BGR);
    for (int i = 0; i < 9; i++)
    {
        for (int j = 0; j < 9; j++)
        {
            string text = to_string(res[i][j]);
            putText(ResultImg, text, Point(PosMat[i][j].x, PosMat[i][j].y+15), FONT_ITALIC, 1, Scalar(0, 0, 255), 2);   
        }
        
    }

    imshow("最终求解结果", ResultImg);