1、银行卡识别项目

参考文章

操作流程：
1、提取模板的每个数字
读取图片->转换为灰度图像->二值化图像(大于10取0，小于取255)->轮廓检测->绘制轮廓->对所有轮廓进行排序->提取模板所有轮廓每个数字
2、读取信用卡->转换为灰度图像->(顶帽操作、sobel算子操作、闭操作、二值化、二次膨胀+腐蚀轮廓检测、绘制轮廓)
提取银行卡《四个数字一组》轮廓，然后每个轮廓与模板的每一个数字进行匹配，得到最大匹配结果，在所有轮廓中，识别出《四个数字一组》的轮廓（共有四个），并进行阈值化、轮廓检测和轮廓排序，在《四个数字一组》中，提取每个数字的轮廓以及坐标，并进行模板匹配得到最大匹配结果

1.1、threshold函数

// 对灰度图像进行阈值处理，将图像中的像素值分为两类（例如，白色和黑色）。
void threshold(InputArray src, OutputArray dst, double thresh, double maxval, int type);

InputArray src: 输入图像，通常为单通道的灰度图像。
OutputArray dst: 输出图像，与输入图像相同的尺寸和通道数，用于存储处理后的图像。
double thresh: 阈值，用于将像素值分为两个类别。根据具体的阈值类型，此值可能有不同的含义。
double maxval: 当像素值超过阈值时，赋予的新值（通常为白色）。
int type: 阈值处理的类型，指定了如何处理像素值超过阈值的情况。常见的类型有：
cv::THRESH_BINARY: 如果像素值大于阈值，则设置为 maxval，否则为 0。
cv::THRESH_BINARY_INV: 如果像素值大于阈值，则设置为 0，否则为 maxval。
cv::THRESH_TRUNC: 如果像素值大于阈值，则设置为阈值，否则保持不变。
cv::THRESH_TOZERO: 如果像素值大于阈值，则保持不变，否则设置为 0。
cv::THRESH_TOZERO_INV: 如果像素值大于阈值，则设置为 0，否则保持不变。

1.2、findContours函数

// 轮廓是图像中具有相同颜色或强度的连续点的曲线。该函数返回图像中所有轮廓的点集
void findContours(InputArray image, OutputArrayOfArrays contours, OutputArray hierarchy, int mode, int method, Point offset = Point());

InputArray image: 输入图像，通常为单通道的灰度图像。图像必须是二值图像（只包含两种像素值，通常是黑和白）。
OutputArrayOfArrays contours: 输出参数，用于存储检测到的轮廓。每个轮廓都表示为一个 std::vectorcv::Point。
OutputArray hierarchy: 输出参数，用于存储轮廓的层次结构信息。它是一个可选参数，如果不需要轮廓的层次结构信息，可以传递 cv::noArray()。
int mode: 轮廓检索模式，指定了轮廓的提取方式。常见的模式有：
cv::RETR_EXTERNAL: 只提取最外层的轮廓。
cv::RETR_LIST: 提取所有轮廓并存储在列表中。
cv::RETR_CCOMP: 提取所有轮廓，并将其组织为两层的层次结构。外层为边界，内层为洞的边界。
cv::RETR_TREE: 提取所有轮廓，并将其组织为树状结构。
int method: 轮廓的逼近方法。常见的方法有：
cv::CHAIN_APPROX_NONE: 存储所有的轮廓点。
cv::CHAIN_APPROX_SIMPLE: 压缩水平、垂直和对角方向的元素，只保留其端点。
cv::CHAIN_APPROX_TC89_L1, cv::CHAIN_APPROX_TC89_KCOS: 应用 Teh-Chin 链逼近算法。
Point offset: 可选参数，轮廓点的偏移量。

1.3、getStructuringElement函数

// 用于创建用于形态学操作（如腐蚀和膨胀）
cv::Mat getStructuringElement(int shape, Size ksize, Point anchor = Point(-1,-1));

shape: 结构元素的形状，可以是以下常量之一：
cv::MORPH_RECT: 矩形结构元素。
cv::MORPH_CROSS: 十字形结构元素。
cv::MORPH_ELLIPSE: 椭圆形结构元素。
ksize: 结构元素的大小，指定为 Size(width, height)。大小决定了结构元素的形状和尺寸。
anchor: 结构元素的锚点。锚点是结构元素中心的位置，通常设置为 -1, -1，表示在结构元素的中心。

1.4、morphologyEx函数

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

src: 输入图像，通常为单通道的灰度图像。可以是8位或浮点图像。
dst: 输出图像，用于存储形态学操作的结果。它可以与输入图像相同，也可以是一个新的图像。
op: 形态学操作的类型，可以是以下之一：
MORPH_ERODE：腐蚀操作。
MORPH_DILATE：膨胀操作。
MORPH_OPEN：开运算（腐蚀后膨胀，可以用来消除小黑点）。
MORPH_CLOSE：闭运算（膨胀后腐蚀，可以用来突出边缘特征）。
MORPH_GRADIENT：形态学梯度(膨胀后图像(减去)腐蚀图像,可以突出团块(blob)的边缘,保留物体的边缘轮廓）。
MORPH_TOPHAT：顶帽操作(原始输入（减去）开运算结果 将突出比原轮廓亮的部分)
MORPH_BLACKHAT：黑帽操作。闭运算结果（减去）原始输入将突出比原轮廓暗的部分。
kernel: 结构元素，用于定义形态学操作的形状和大小。可以通过 getStructuringElement 函数创建。
anchor: 结构元素的锚点。通常设置为 -1, -1，表示在结构元素的中心。
iterations: 形态学操作的迭代次数。默认值为1，表示执行一次形态学操作。增加迭代次数可以增强形态学操作的效果。
borderType: 边界扩充的类型，默认为 BORDER_CONSTANT。
borderValue: 当 borderType 设置为 BORDER_CONSTANT 时，用于定义边界的常数值，默认为黑色。

1.5、Sobel函数

Sobel算子是一种常用的边缘检测算子。对噪声具有平滑作用，提供较为精确的边缘方向信息，但是边缘定位精度不够高。边缘就是像素对应的灰度值快速变化的地方。如：黑到白的边界
图像是二维的。Sobel算子在x,y两个方向求导，故有不同的两个卷积核（Gx, Gy），且Gx的转置等于Gy。分别反映了每一点像素在水平方向和在垂直方向上的亮度变换情况.

void Sobel(InputArray src, OutputArray dst, int ddepth, int dx, int dy, int ksize = 3, double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT);

src: 输入图像，通常为单通道的灰度图像。支持的深度为 CV_8U, CV_16U, CV_16S, CV_32F, CV_64F。
dst: 输出图像，用于存储 Sobel 操作的结果。
ddepth: 输出图像的深度，通常选择 CV_16S 或 CV_64F。
dx 和 dy: 表示求导的阶数，通常为 0(表示该方向不求倒)1 或 2分别表示在 x 方向和 y 方向上的导数。
ksize: Sobel 核的大小，必须是 1、3、5 或 7。默认为 3。
scale: 缩放因子，用于缩放计算出的梯度值，默认为 1。
delta: 加法常数，用于调整最终的输出图像，默认为 0。
borderType: 边界处理方式，默认为 BORDER_DEFAULT。

1.6、matchTemplate函数

void matchTemplate(InputArray image, InputArray templ, OutputArray result, int method, InputArray mask = noArray());

image: 输入图像，是需要在其中查找模板的图像。
templ: 输入模板，是待匹配的模板图像。
result: 输出结果图像，用于存储匹配程度。结果图像的大小为 (image.cols - templ.cols + 1, image.rows - templ.rows + 1)。
method: 匹配方法，可以是以下之一：
TM_SQDIFF: 平方差匹配，匹配程度越低越好。
TM_SQDIFF_NORMED: 归一化平方差匹配。
TM_CCORR: 相关性匹配，匹配程度越高越好。
TM_CCORR_NORMED: 归一化相关性匹配。
TM_CCOEFF: 系数匹配，匹配程度越高越好。
TM_CCOEFF_NORMED: 归一化系数匹配。
mask: 用于指定感兴趣区域的可选掩码图像。

2、源码展示

//
// Created by  on 2024/3/4.
//

#include "project.h"

void printf_show(vector<vector<Point>> contours_)
{
    for (size_t i = 0; i < contours_.size(); ++i) {
        std::cout << "Contour:" << std::endl;

        const std::vector<cv::Point>& contour = contours_[i];

        for (size_t j = 0; j < contour.size(); ++j) {
            const cv::Point& point = contour[j];
            std::cout << "Point " << j << ": x = " << point.x << ", y = " << point.y << std::endl;
        }

        // 打印轮廓的总点数
        std::cout << "Total points: " << contour.size() << std::endl;

        // 打印轮廓的边界框坐标

        cv::Rect bounding_box = cv::boundingRect(contour);
        std::cout << "Bounding box - x: " << bounding_box.x << ", y: " << bounding_box.y << ", w: " << bounding_box.width << ", h: " << bounding_box.height << std::endl;

        std::cout << std::endl;
    }
}

vector<vector<Point>> sortContours(vector<vector<Point>>& cnt_s, string method)
{
    int reverse = 0;
    if (method == "left-sort") {
        reverse = 1;
    }

    vector<Rect> bounding_boxs;
    for (auto& cnn : cnt_s) {
        // 计算轮廓的外接矩形
        bounding_boxs.push_back(cv::boundingRect(cnn));
    }
    std::sort(bounding_boxs.begin(), bounding_boxs.end(), [&](const cv::Rect& a, const cv::Rect& b) {
        return a.tl().y < b.tl().y;
        });

    std::vector<std::vector<cv::Point>> sorted_cnt_s;
    for (const auto& bb : bounding_boxs) {
        sorted_cnt_s.push_back(cnt_s[&bb - &bounding_boxs[0]]);
    }

    if (reverse) {
        std::reverse(sorted_cnt_s.begin(), sorted_cnt_s.end());
    }
    return sorted_cnt_s;
}

/*
cv::THRESH_BINARY：
这是最常用的二值化方法。对于每个像素，如果其值大于阈值，则将其设置为最大二值化值；否则，将其设置为0。

cv::THRESH_BINARY_INV：
这是cv::THRESH_BINARY方法的反向版本。对于每个像素，如果其值大于阈值，则将其设置为0；否则，将其设置为最大二值化值。

cv::THRESH_TRUNC：
这种方法将大于阈值的像素值截断为阈值，而保留小于等于阈值的像素值。

cv::THRESH_TOZERO：
这种方法将小于等于阈值的像素值设置为0，而保留大于阈值的像素值。

cv::THRESH_TOZERO_INV：
这是cv::THRESH_TOZERO方法的反向版本。对于每个像素，如果其值大于阈值，则保持像素值不变；否则，将其设置为0。
*/
void cv_project1()
{
    Mat src = imread("/Users/zhulei/CLionProjects/opencv_test/ocr_a_reference.png");
    Mat ref_gray, binimg;
    cvtColor(src, ref_gray, cv::COLOR_BGR2GRAY);

    // 二值化操作
    // 大于10的都为0，小于10,设置为255
    threshold(ref_gray, binimg, 10, 255, cv::THRESH_BINARY_INV);

    vector<vector<Point>> contours_;
    findContours(binimg.clone(), contours_, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);

    Mat img_contours = src.clone();
    // -1表示绘制所有，2表示线宽度
    drawContours(img_contours, contours_, -1, Scalar(0, 255, 0), 2);
    printf_show(contours_);
    cv::imshow("Binary Image", img_contours);

    // 对轮廓点从左到右进行排序
    vector<vector<Point>> sort_res = sortContours(contours_, "left-sort");

    //vector<Mat> digits(sort_res.size());
    // 计算轮廓的外接矩形，取出矩形对应图像中的区域，存储到map中
    // 索引为当前图像对应的数字
    std::map<std::string, cv::Mat> digits;
    for (int i = 0; i < sort_res.size(); i++) {
        Rect boundingRect = cv::boundingRect(sort_res[i]);
        int x = boundingRect.x;
        int y = boundingRect.y;
        int w = boundingRect.width;
        int h = boundingRect.height;
        cout << "x:" << x << " y:" << y << " w:" << w << " h:" << h << endl;
        Mat roi = binimg(Rect(x, y, w, h));
        resize(roi, roi, Size(57, 88));

        digits.insert(std::make_pair(to_string(i), roi.clone()));
        imshow("1", roi);
        waitKey(100);
    }

    Mat rect_Kernel = getStructuringElement(MORPH_RECT, Size(9, 3));
    Mat square_Kernel = getStructuringElement(MORPH_RECT, Size(5, 5));

    // 读取信用卡图片
    Mat img_car = imread("/Users/zhulei/CLionProjects/opencv_test/credit_card_01.png");
    Mat img_resize, img_gray;
    float img_ratio = (300 / (float)img_car.cols);
    cout << "img_ratio:" << img_ratio << endl;
    resize(img_car, img_resize, Size(300, (img_ratio * img_car.rows)));
    cvtColor(img_resize, img_gray, cv::COLOR_BGR2GRAY);
    imshow("new", img_gray);
    waitKey(1000);

    // 礼貌计算突明亮区域
    Mat morpho, image_gradx;
    morphologyEx(img_gray, morpho, MORPH_TOPHAT, rect_Kernel);

    Sobel(morpho, image_gradx, CV_32F, 1, 0, -1);
    image_gradx = cv::abs(image_gradx);

    double minv, maxv;
    minMaxLoc(image_gradx, &minv, &maxv);
    cout << "minv:" << minv << " " << maxv << endl;
    image_gradx = (255 * ((image_gradx - minv) / (maxv - minv)));
    image_gradx.convertTo(image_gradx, CV_8UC1);

    // 闭操作
    Mat image_CLOSE, image_thresh;
    morphologyEx(image_gradx, image_CLOSE, MORPH_CLOSE, square_Kernel);
    imshow("闭操作", image_CLOSE);
    waitKey(2000);
    cout << "image_CLOSE:" << image_CLOSE.type() << "image_gradx:" << image_gradx.type() << endl;
    // 自动寻找阈值
    // THRESH_OTSU 会自动寻找合适的阈值，适合双峰，需把阈值参数设置为0。
    threshold(image_CLOSE, image_thresh, 10, 255, THRESH_BINARY | THRESH_OTSU);

    // (二次)闭操作，将四个连在一起的数字进行填充形成一个整体。
    Mat image_2_dilate, image_1_erode, image_2_CLOSE;
    dilate(image_thresh, image_2_dilate, square_Kernel, Point(-1, -1), 2);			// 膨胀(迭代次数2次)
    erode(image_2_dilate, image_1_erode, square_Kernel, Point(-1, -1), 1); // 腐蚀(迭代次数1次)
    image_2_CLOSE = image_1_erode;

    // 轮廓检测
    vector<vector<Point>> threshCnts;
    findContours(image_2_CLOSE.clone(), threshCnts, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);
    Mat image_Contours = img_resize.clone();
    drawContours(image_Contours, threshCnts, -1, (0, 0, 255), 3);

    imshow("nn", image_Contours);
    waitKey(2000);

    vector<Rect> locs;
    cout << "threshCnts:" << threshCnts.size();
    for (int i = 0; i < threshCnts.size(); i++) {
        auto& c = threshCnts[i];
        Rect rect = cv::boundingRect(c);
        int x = rect.x;
        int y = rect.y;
        int w = rect.width;
        int h = rect.height;
        float ar = static_cast<float>(w) / h;
        if (2.0 < ar && ar < 4.0) {
            if (35 < w && w < 60 && 10 < h && h < 20) {
                cout << "rect:" << rect << endl;
                locs.push_back(rect);
            }
        }
    }

    sort(locs.begin(), locs.end(), [](const Rect& r1, const Rect& r2) {
        return r1.x < r2.x;
        });
    cout << "locs:" << locs.size() << endl;
    for (int i = 0; i < locs.size(); i++) {
        std::vector<std::string> groupOutput;
        int gx = locs[i].x;
        int gy = locs[i].y;
        int gw = locs[i].width;
        int gh = locs[i].height;
        vector<string> grououtput;
        // 根据坐标提取每一个组（将每个轮廓的结果放大一些，避免信息丢失）
        Mat group_digit = img_gray(Rect(gx - 5, gy - 5, gw + 10, gh + 10));
        Mat group_digit_th;
        threshold(group_digit, group_digit_th, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);

        vector<vector<Point>> digitCnts;
        findContours(group_digit_th.clone(), digitCnts, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);

        // 对轮廓进行排序
        std::sort(digitCnts.begin(), digitCnts.end(), [](const std::vector<cv::Point>& c1, const std::vector<cv::Point>& c2) {
            cv::Rect rect1 = cv::boundingRect(c1);
            cv::Rect rect2 = cv::boundingRect(c2);
            return rect1.x < rect2.x;
            });

        // 计算每一组中的每一个数值
        for (const auto& jj : digitCnts) {
            cv::Rect rect = cv::boundingRect(jj);
            cv::Mat roi = group_digit(rect);
            cv::resize(roi, roi, cv::Size(57, 88));
            cv::imshow("Image", roi);
            cv::waitKey(200);

            std::vector<double> scores;

            // 遍历，模板map
            for (const auto& digit : digits) {
                cv::Mat result;
                cv::matchTemplate(roi, digit.second, result, cv::TM_CCOEFF);
                double max_score;
                cv::minMaxLoc(result, nullptr, &max_score);
                scores.push_back(max_score);
            }
            cout << "数字：" << std::to_string(std::distance(scores.begin(), std::max_element(scores.begin(), scores.end())));
            groupOutput.push_back(std::to_string(std::distance(scores.begin(), std::max_element(scores.begin(), scores.end()))));
        }

        cv::rectangle(img_resize, cv::Point(gx - 5, gy - 5), cv::Point(gx + gw + 5, gy + gh + 5), cv::Scalar(0, 0, 255), 1);
        //        cv::putText(img_resize, std::accumulate(groupOutput.begin(), groupOutput.end(), std::string("")), cv::Point(gx, gy - 15), cv::FONT_HERSHEY_SIMPLEX, 0.65, cv::Scalar(0, 0, 255), 2);
    }
    cout << "end!!!" << endl;
    cv::waitKey(0);
}