OpenCV学习(7)--

阈值操作：

class ThresholdDemoExamlpe {
    // 阈值操作
public:
    //static int thresholdValue = 0;
    //static int thresholdType = 3;
    //static int const maxValue = 255;
    static int thresholdValue;
    static int thresholdType;
    static int const maxValue;
    static int const maxType = 4;
    static int const maxBINARYvalue = 255;
    static cv::Mat src; 
    static cv::Mat src_gray;
    static cv::Mat dst;

    static void ThresholdDemo(int, void*) {
        // 0: Binary
        // 1: Binary Inverted
        // 2: Threshold Truncated
        // 3: Threshold to Zero
        // 4: Threshold to Zero Inverted
        // 图像二值化
        // https://blog.csdn.net/u012566751/article/details/77046445
        cv::threshold(src_gray, dst, thresholdValue, maxBINARYvalue, thresholdType);
        cv::imshow("Threshold Demo", dst);
    }

    int show(void) {    
        src = cv::imread("dog.jpg", cv::IMREAD_COLOR);
        if (src.empty())
            return -1;

        cv::cvtColor(src, src_gray, cv::COLOR_BGR2GRAY);  // 转化为灰度图像
        cv::namedWindow("Threshold Demo", cv::WINDOW_AUTOSIZE);
        cv::createTrackbar("Type: 
 0: Binary 
 1: Binary Inverted 
 2: Truncate 
 3: To Zero 
 4: To Zero Inverted", "Threshold Demo", &thresholdType, maxType, ThresholdDemo);
        cv::createTrackbar("Value", "Threshold Demo", &thresholdValue, maxValue, ThresholdDemo);
        ThresholdDemo(0, 0);

        cv::waitKey(0);
        return 0;
    }

};

Object detection：

class ObjectDetection {
public:
    static int low_r;
    static int low_g;
    static int low_b;
    static int high_r;
    static int high_g;
    static int high_b;

    static void on_low_r_thresh_trackbar(int, void*) {
        low_r = min(high_r - 1, low_r);
        // openCV提供createTrackbar指定图像窗口创建一个指定名称和范围的滑动条，使用户能够滑动调整输入,然后根据输入值执行程序。
        // 还提供了getTrackbarPos和setTrackbarPos以获取和修改bar的当前值。
        // https://blog.csdn.net/u010963435/article/details/78682725
        cv::setTrackbarPos("Low R", "Object Detection", low_r);
    }

    static void on_high_r_thresh_trackbar(int, void*) {
        high_r = min(high_r, low_r + 1);
        cv::setTrackbarPos("High R", "Object Detection", high_r);
    }

    static void on_low_g_thresh_trackbar(int, void*) {
        low_g = min(high_g - 1, low_g);
        cv::setTrackbarPos("Low G", "Object Detection", low_g);
    }

    static void on_high_g_thresh_trackbar(int, void*) {
        high_g = min(high_g, low_g + 1);
        cv::setTrackbarPos("High G", "Object Detection", high_g);
    }

    static void on_low_b_thresh_trackbar(int, void*) {
        low_b = min(high_b - 1, low_b);
        cv::setTrackbarPos("Low B", "Object Detection", low_b);
    }

    static void on_high_b_thresh_trackbar(int, void*) {
        high_b = min(high_b, low_b + 1);
        cv::setTrackbarPos("High B", "Object Detection", high_b);
    }

    static int show() {
        cv::Mat frame, frame_threshold;
        //cv::VideoCapture cap(0);  // //视频捕捉设备 id ---笔记本电脑的用0表示
        frame = cv::imread("angel.jpg", cv::IMREAD_COLOR);
        cv::namedWindow("Video Capture", cv::WINDOW_NORMAL);
        cv::namedWindow("Object Detection", cv::WINDOW_NORMAL);

        // 创建滑动条 设定阈值
        cv::createTrackbar("Low R", "Object Detection", &low_r, 255, on_low_r_thresh_trackbar);
        cv::createTrackbar("HIgh R", "Object Detection", &high_r, 255, on_high_r_thresh_trackbar);
        cv::createTrackbar("Low G", "Object Detection", &low_g, 255, on_low_g_thresh_trackbar);
        cv::createTrackbar("HIgh G", "Object Detection", &high_g, 255, on_high_g_thresh_trackbar);
        cv::createTrackbar("Low B", "Object Detection", &low_b, 255, on_low_b_thresh_trackbar);
        cv::createTrackbar("HIgh B", "Object Detection", &high_b, 255, on_high_b_thresh_trackbar);

        //while (true) {
            //cap >> frame;
            //if (frame.empty())
                //break;

            //cv::inRange(frame, cv::Scalar(low_b, low_g, low_r), cv::Scalar(high_b, high_g, high_r), frame_threshold);
            //cv::imshow("Video Capture", frame);
            //cv::imshow("Object Detection", frame_threshold);
        //}
        cv::inRange(frame, cv::Scalar(low_b, low_g, low_r), cv::Scalar(high_b, high_g, high_r), frame_threshold);
        cv::imshow("Video Capture", frame);
        cv::imshow("Object Detection", frame_threshold);

        return 0;
    }
};
/*
int ObjectDetection::low_b = 30;
int ObjectDetection::low_g = 30;
int ObjectDetection::low_r = 30;
int ObjectDetection::high_b = 100;
int ObjectDetection::high_g = 100;
int ObjectDetection::high_r = 100;
*/

使用cv::filter2D创建线性过滤器:

int createFilterExample(void) {
    // 使用cv::filter2D创建线性过滤器
    cv::Mat src, dst, kernel;
    cv::Point anchor = cv::Point(-1, -1);   // 中心点;
    double delta = 0;
    int ddepth = -1;
    int kernelSize;
    int ind = 0;

    src = cv::imread("small.jpg", cv::IMREAD_COLOR);
    if (src.empty())
        return -1;

    cv::imshow("Src", src);

    kernelSize = 3;
    kernel = cv::Mat::ones(kernelSize, kernelSize, CV_32F);
    cv::filter2D(src, dst, ddepth, kernel, anchor, delta, cv::BORDER_DEFAULT);
    cv::imshow("kernel size 3", dst);
    /*
        kernelSize = 5;
        kernel = cv::Mat::ones(kernelSize, kernelSize, CV_32F);
        cv::filter2D(src, dst, ddepth, kernel, anchor, delta, cv::BORDER_DEFAULT);
        cv::imshow("kernel size 5", dst);

        kernelSize = 7;
        kernel = cv::Mat::ones(kernelSize, kernelSize, CV_32F);
        cv::filter2D(src, dst, ddepth, kernel, anchor, delta, cv::BORDER_DEFAULT);
        cv::imshow("kernel size 7", dst);

        kernelSize = 9;
        kernel = cv::Mat::ones(kernelSize, kernelSize, CV_32F);
        cv::filter2D(src, dst, ddepth, kernel, anchor, delta, cv::BORDER_DEFAULT);
        cv::imshow("kernel size 9", dst);

        kernelSize = 11;
        kernel = cv::Mat::ones(kernelSize, kernelSize, CV_32F);
        cv::filter2D(src, dst, ddepth, kernel, anchor, delta, cv::BORDER_DEFAULT);
        cv::imshow("kernel size 11", dst);
    */

    cv::waitKey(0);
    return 0;
}

扩充图像边缘：

int makeBorder(void) {
    // 扩充图像边缘
    cv::Mat src, dst;
    src = cv::imread("Lisa.png", cv::IMREAD_COLOR);
    if (src.empty())
        return -1;

    cv::namedWindow("Make Border", cv::WINDOW_AUTOSIZE);
    int top = (int)(0.05 * src.rows);
    int bottom = (int)(0.05 * src.rows);
    int left = (int)(0.05 * src.cols);
    int right = (int)(0.05 * src.cols);
    dst = src;
    cv::imshow("Make Border", dst);
    cv::RNG rng(12345);
    cv::Scalar value(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255));
    // 扩充图像边缘
    // https://blog.csdn.net/qq_22764813/article/details/52787553
    //cv::copyMakeBorder(src, dst, top, bottom, left, right, cv::BORDER_CONSTANT, value);
    cv::copyMakeBorder(src, dst, top, bottom, left, right, cv::BORDER_REPLICATE, value);
    cv::imshow("Make Border", dst);

    cv::waitKey(0);
    return 0;
}

sobel算子的使用：

int sobelExample(void) {
    cv::Mat image, src, src_gray, grad;
    int ddepth = CV_16S;

    image = cv::imread("Lisa.png", cv::IMREAD_COLOR);
    if (image.empty())
        return -1;

    // 高斯滤波 减少图像中的噪音
    cv::GaussianBlur(image, src, cv::Size(3, 3), 0, 0, cv::BORDER_DEFAULT);
    // 转换为灰度图片
    cv::cvtColor(src, src_gray, cv::COLOR_BGR2GRAY);
    cv::Mat grad_x, grad_y, abs_grad_x, abs_grad_y;
    // Gradient X
    // sobel算子是一种常用的边缘检测算子，是一阶的梯度算法。
    // https://blog.csdn.net/streamchuanxi/article/details/51542141
    cv::Sobel(src_gray, grad_x, ddepth, 1, 0, 3, 1, 0, cv::BORDER_DEFAULT);
    // Gradient Y
    cv::Sobel(src_gray, grad_y, ddepth, 0, 1, 3, 1, 0, cv::BORDER_DEFAULT);

    cv::convertScaleAbs(grad_x, abs_grad_x);
    cv::convertScaleAbs(grad_y, abs_grad_y);

    cv::addWeighted(abs_grad_x, 0.5, abs_grad_y, 0.5, 0, grad);

    cv::imshow("Sobel Demo", grad);


    cv::waitKey(0);
    return 0;
}

拉普拉斯变换示例：

int LaplaceOperatorExample(void) {
    // 拉普拉斯变换
    cv::Mat src, src_gray, dst;
    int kernel_size = 3;
    int scale = 1;
    int delta = 0;
    int ddepth = CV_16S;
    string window_name = "Laplace Demo";
    src = cv::imread("Lisa.png", cv::IMREAD_COLOR);
    if (src.empty())
        return -1;

    cv::GaussianBlur(src, src, cv::Size(3, 3), 0, 0, cv::BORDER_DEFAULT);
    cv::cvtColor(src, src_gray, cv::COLOR_BGR2GRAY);
    cv::Mat abs_dst;
    // 拉普拉斯变换
    cv::Laplacian(src_gray, dst, ddepth, kernel_size, scale, delta, cv::BORDER_DEFAULT);
    cv::convertScaleAbs(dst, abs_dst);
    cv::imshow(window_name, abs_dst);

    cv::waitKey(0);
    return 0;
}

Canny边缘检测器使用：

int showCanny(void) {
    // Canny边缘检测器
    cv::Mat src, src_gray, dst, detected_edges;
    int lowThreshold = 25;
    int ratio = 3;
    int kernel_size = 3;
    src = cv::imread("small.jpg", cv::IMREAD_COLOR);
    if (src.empty())
        return -1;

    dst.create(src.size(), src.type());
    cv::cvtColor(src, src_gray, cv::COLOR_BGR2GRAY);
    cv::namedWindow("Edge Map", cv::WINDOW_AUTOSIZE);
    cv::blur(src_gray, detected_edges, cv::Size(3, 3));
    // https://blog.csdn.net/u013488563/article/details/18889557
    cv::Canny(detected_edges, detected_edges, lowThreshold, lowThreshold * ratio, kernel_size);
    dst = cv::Scalar::all(0);
    src.copyTo(dst, detected_edges);
    cv::imshow("Edge Map", dst);


    cv::waitKey(0);
    return 0;
}

检测直线和圆：

int HoughLineExample(void) {   // 运行有点问题
    // Hough Line变换 用于检测直线
    cv::Mat src = cv::imread("LineCircle.jpg", cv::IMREAD_COLOR);
    if (src.empty())
        return -1;

    cv::imshow("Src", src);
    cv::Mat dst, cdst;
    cv::cvtColor(src, dst, cv::COLOR_BGR2GRAY);
    cv::imshow("Gray", dst);
    cv::Canny(dst, cdst, 50, 200, 3);
    cv::imshow("Canny src", cdst);
    //cv::cvtColor(dst, cdst, cv::COLOR_GRAY2BGR);
    //cv::imshow("BGR", cdst);

    vector<cv::Vec2f> lines;
    cv::HoughLines(cdst, lines, 1, CV_PI / 180, 100, 0, 0);
    for (int i = 0; i < lines.size(); i++) {
        float rho = lines[i][0], theta = lines[i][1];
        cv::Point pt1, pt2;
        double a = cos(theta), b = sin(theta);
        double x0 = a * rho, y0 = b * rho;
        pt1.x = cvRound(x0 + 1000 * (-b));
        pt1.y = cvRound(y0 + 1000 * (a));
        pt2.x = cvRound(x0 - 1000 * (-b));
        pt2.y = cvRound(y0 - 1000 * (a));
        cv::line(cdst, pt1, pt2, cv::Scalar(255, 0, 0), 3, 8);
    }
    cv::imshow("detected lines", cdst);

    cv::waitKey(0);
    return 0;
}



int DetectCircle(void) {
    // Hough Circle 检测图像中的圆
    //cv::Mat image = cv::imread("bowl.jpg", cv::IMREAD_COLOR);
    cv::Mat image = cv::imread("LineCircle.jpg", cv::IMREAD_COLOR);
    if (image.empty())
        return -1;
    cv::imshow("Src", image);

    cv::Mat res;
    res.create(image.size(), image.type());
    cv::Mat gray;
    cv::cvtColor(image, gray, cv::COLOR_BGR2GRAY);
    cv::imshow("Gray", gray);
    // 中值滤波
    cv::medianBlur(gray, gray, 5);
    vector<cv::Vec3f> circles;
    // http://www.manongjc.com/article/42132.html
    cv::HoughCircles(gray, circles, cv::HOUGH_GRADIENT, 1, gray.rows / 16, 100, 30, 50, 300);
    // 单独一个圆可以检测出来 当圆和其他直线相交 就测出来多个圆


    for (int i = 0; i < circles.size(); i++) {
        cv::Vec3i c = circles[i];
        cv::circle(res, cv::Point(c[0], c[1]), c[2], cv::Scalar(0, 0, 255), 3, cv::LINE_AA);
        cv::circle(res, cv::Point(c[0], c[1]), 2, cv::Scalar(0, 255, 0), 3, cv::LINE_AA);
    }

    cv::imshow("Detected Circles", res);

    cv::waitKey(0);
    return 0;
}

简单重映射：

int RemapExample(void) {
    // 简单重映射
    cv::Mat src = cv::imread("dog.jpg", cv::IMREAD_COLOR);
    cv::Mat dst;
    dst.create(src.size(), src.type());
    cv::Mat map_x, map_y;
    map_x.create(src.size(), CV_32FC1);
    map_y.create(src.size(), CV_32FC1);
    cv::namedWindow("Remap demo", cv::WINDOW_AUTOSIZE);

    for (int j = 0; j < src.rows; j++) {
        for (int i = 0; i < src.cols; i++) {
            // 上下翻转
            //map_x.at<float>(j, i) = (float)i;
            //map_y.at<float>(j, i) = (float)(src.rows - j);

            // 左右翻转
            //map_x.at<float>(j, i) = (float)(src.cols - i);
            //map_y.at<float>(j, i) = (float)j;

            // 上下左右都翻转
            //map_x.at<float>(j, i) = (float)(src.cols - i);
            //map_y.at<float>(j, i) = (float)(src.rows - j);

            // 缩小 
            if (i > src.cols * 0.25 && i < src.cols * 0.75 && j > src.rows * 0.25 && j < src.rows * 0.75) {
                map_x.at<float>(j, i) = 2 * (i - src.cols * 0.25f) + 0.5f;
                map_y.at<float>(j, i) = 2 * (j - src.rows * 0.25f) + 0.5f;
            }
            else {
                map_x.at<float>(j, i) = 0;
                map_y.at<float>(j, i) = 0;
            }
        }
    }

    // https://blog.csdn.net/sss_369/article/details/52983123
    // cv::remap()就是对原图像各个像素点改变位置 
    cv::remap(src, dst, map_x, map_y, cv::INTER_LINEAR, cv::BORDER_CONSTANT, cv::Scalar(0, 0, 0));
    cv::imshow("Remap demo", dst);


    cv::waitKey(0);
    return 0;
}