无法在 C++ OpenCV HSV 图像分离中分离对象

Question

我有这张带有 3 个辣椒的图片：

我需要把这张图片转换成HSV形式，然后把每个辣椒分成自己的图片。

到目前为止，我似乎能够很好地将红辣椒与其他辣椒分开。但是，我似乎无法弄清楚如何将其他辣椒分开。

这是我的代码：

#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/imgcodecs.hpp>
#include <opencv2/objdetect/objdetect.hpp>
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <cmath>
#include <string>
#include <vector>

int main(int argc, char *argv[]){
    cv::Mat im_in;
    cv::Mat hsv_in;
    cv::Mat bgr_in;
    cv::Mat orig_in;
    cv::Mat im_o1;
    cv::Mat im_o2;
    cv::Mat im_o3;
    // Read image
    if (argc<2){
    im_in = cv::imread("colorpeppers.jpg");
    }
    if (argc==2){
        im_in=cv::imread((argv[1]));
    }
    if (argc>2){
        std::cout<<"Error! Too many arguments!"<<std::endl;
    }
    if (im_in.empty()){
        std::cout << "error detected. something went wrong with opening the image. is it empty? exiting"<<std::endl;
        return -1;
    }
    cv::Mat orig_image = im_in.clone();
    cv::medianBlur(im_in, im_in, 3);

    cv::cvtColor(im_in, hsv_in, cv::COLOR_BGR2HSV);
    cv::namedWindow("Original Image", cv::WINDOW_AUTOSIZE);
    cv::imshow("Orginal Image", im_in);

    cv::namedWindow("Orginal Image converted to HSV", cv::WINDOW_AUTOSIZE);
    cv::imshow("Original Image converted to HSV", hsv_in);
    cv::Mat lower_red_hue_range;
    cv::Mat upper_red_hue_range;
    cv::Mat lower_green_hue_range;
    cv::Mat upper_green_hue_range;
    cv::Mat lower_yellow_hue_range;
    cv::Mat upper_yellow_hue_range;


    cv::inRange(hsv_in, cv::Scalar(0,100,100), cv::Scalar(10,255,255), lower_red_hue_range);
    cv::inRange(hsv_in, cv::Scalar(160,100,100),cv::Scalar(179, 255, 255), upper_red_hue_range);
    cv::inRange(hsv_in, cv::Scalar(0,100,100), cv::Scalar(10,255,255), lower_green_hue_range);
    cv::inRange(hsv_in, cv::Scalar(50,100,100),cv::Scalar(70,255,255), upper_green_hue_range);
    cv::inRange(hsv_in, cv::Scalar(0,100,100),cv::Scalar(20,0,0),lower_yellow_hue_range);
    cv::inRange(hsv_in,cv::Scalar(10,100,100),cv::Scalar(50,110,110),upper_yellow_hue_range);

    //combining the above
    cv::Mat red_hue_image=im_in.clone();
    cv::Mat green_hue_image=im_in.clone();
    cv::Mat yellow_hue_image=im_in.clone();
    cv::addWeighted(lower_red_hue_range, 1.0, upper_red_hue_range, 1.0, 0.0, red_hue_image);
    cv::addWeighted(lower_green_hue_range, 1.0, upper_green_hue_range, 1.0, 0.0, green_hue_image);
    cv::addWeighted(lower_yellow_hue_range, 1.0, upper_yellow_hue_range, 1.0, 0.0, yellow_hue_image);
    cv::GaussianBlur(red_hue_image, red_hue_image, cv::Size(9,9), 2, 2);
    cv::GaussianBlur(green_hue_image, green_hue_image, cv::Size(9,9),2,2);
    cv::GaussianBlur(yellow_hue_image, yellow_hue_image, cv::Size(9,9),2,2);

    cv::namedWindow("Threshold lower red image", cv::WINDOW_AUTOSIZE);
    cv::imshow("Threshold lower red image", lower_red_hue_range);
    cv::namedWindow("Threshold upper red image", cv::WINDOW_AUTOSIZE);
    cv::imshow("Threshold upper red image", upper_red_hue_range);
    cv::namedWindow("Combined Threshold red Images", cv::WINDOW_AUTOSIZE);
    cv::imshow("Combined Threshold red Images", red_hue_image);

    cv::namedWindow("Threshold lower green image", cv::WINDOW_AUTOSIZE);
    cv::imshow("Threshold lower green image", lower_green_hue_range);
    cv::namedWindow("Threshold upper green image", cv::WINDOW_AUTOSIZE);
    cv::imshow("Threshold upper green image", upper_green_hue_range);
    cv::namedWindow("Combined Threshold green Images", cv::WINDOW_AUTOSIZE);
    cv::imshow("Combined Threshold green Images", green_hue_image);

    cv::namedWindow("Threshold lower yellow image", cv::WINDOW_AUTOSIZE);
    cv::imshow("Threshold lower yellow image", lower_yellow_hue_range);
    cv::namedWindow("Threshold upper yellow image", cv::WINDOW_AUTOSIZE);
    cv::imshow("Threshold upper yellow image", upper_yellow_hue_range);
    cv::namedWindow("Combined Threshold yellow Images", cv::WINDOW_AUTOSIZE);
    cv::imshow("Combined Threshold yellow Images", yellow_hue_image);



    //cv::Mat redpepper;//=red_hue_image.clone();
    //cv::Mat redpepper_hsv;
    //cvtColor(redpepper, redpepper_hsv,CV_BGR2HSV);
//    for(int i = 0; i < redpepper.rows;i++){
  //      for(int j = 0; j <redpepper.cols;j++){




    char k;
    for (int x=1;x<15;x++){
        k=cvWaitKey(0);
    }

}

Answer 1

作为第一步，让我们使用k-means clustering减少图像中的颜色数量。

接下来，让我们将图像转换为 HSV 空间，并将其拆分为单独的色调、饱和度和值组件。

色相：

色调（彩色映射）：

饱和度：

值：

色调分量对于算法的其余部分来说已经足够了。 我们通过选择适合三种颜色范围内的像素来创建三个蒙版。

红色：

黄色：

绿色：

我们使用形态变换（腐蚀、扩张）来清理掩码图像。接下来，我们检测轮廓，只选择面积大于某个阈值的轮廓（我选择了 5000 像素）。我们通过填充满足条件的轮廓来生成新的蒙版。

红色：

黄色：

绿色：

现在我们可以画轮廓了……

红色：

黄色：

绿色：

代码：

#include <opencv2/opencv.hpp>

#include <cstdint>
#include <iostream>
#include <vector>

cv::Mat cluster_image(cv::Mat const& img)
{
    int K = 4;
    int n = img.rows * img.cols;
    cv::Mat data = img.reshape(1, n);
    data.convertTo(data, CV_32F);

    std::vector<int> labels;
    cv::Mat1f colors;
    cv::kmeans(data, K, labels
        , cv::TermCriteria(CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, 10000, 0.0001)
        , 5, cv::KMEANS_PP_CENTERS, colors);

    for (int i = 0; i < n; ++i) {
        data.at<float>(i, 0) = colors(labels[i], 0);
        data.at<float>(i, 1) = colors(labels[i], 1);
        data.at<float>(i, 2) = colors(labels[i], 2);
    }

    cv::Mat reduced = data.reshape(3, img.rows);
    reduced.convertTo(reduced, CV_8U);

    return reduced;
}

cv::Mat filter_mask(cv::Mat& img, cv::Mat& mask)
{
    cv::Mat kernel = cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(5, 5));
    cv::Mat filtered;
    cv::erode(mask, filtered, kernel, cv::Point(-1, -1), 2);
    cv::dilate(filtered, filtered, kernel, cv::Point(-1, -1), 2);

    std::vector<std::vector<cv::Point>> contours;
    std::vector<cv::Vec4i> hierarchy;

    cv::findContours(filtered, contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);

    cv::Mat output_mask = cv::Mat::zeros(mask.size(), CV_8UC1);

    double const MIN_CONTOUR_AREA(5000.0);
    for (int i(0); i < contours.size(); ++i) {
        double area = cv::contourArea(contours[i]);

        if (area >= MIN_CONTOUR_AREA) {
            cv::drawContours(output_mask, contours, i, cv::Scalar(255), CV_FILLED);
        }
    }

    cv::dilate(output_mask, output_mask, kernel, cv::Point(-1, -1), 1);

    return output_mask;
}

void highlight_mask(std::string const& filename, cv::Mat& img, cv::Mat& mask)
{
    cv::Mat output = img.clone();

    std::vector<std::vector<cv::Point>> contours;
    std::vector<cv::Vec4i> hierarchy;
    cv::findContours(mask, contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);
    cv::drawContours(output, contours, 0, cv::Scalar(255, 0, 0), 2);

    cv::imwrite(filename, output);
}


int main(int argc, char *argv[])
{
    cv::Mat orig_image(cv::imread("d:\\code\\shit\\so03\\bin\\runtime\\Debug\\peppers.png"));
    if (orig_image.empty()) {
        std::cerr << "Input image empty." << std::endl;
        return -1;
    }

    cv::Mat im_in;
    cv::medianBlur(orig_image, im_in, 3);

    cv::Mat clustered = cluster_image(im_in);
    cv::imwrite("peppers_clustered.png", clustered);

    cv::Mat hsv_in;
    cv::cvtColor(clustered, hsv_in, cv::COLOR_BGR2HSV);

    uint32_t HUE(0), SAT(1), VAL(2);
    std::vector<cv::Mat> h_s_v(3);
    cv::split(hsv_in, h_s_v);
    cv::imwrite("peppers_hue.png", h_s_v[HUE]);
    cv::imwrite("peppers_sat.png", h_s_v[SAT]);
    cv::imwrite("peppers_val.png", h_s_v[VAL]);



    cv::Mat red_mask_a;
    cv::inRange(h_s_v[HUE], cv::Scalar(2), cv::Scalar(10), red_mask_a);
    cv::Mat red_mask_b = filter_mask(im_in, red_mask_a);
    cv::imwrite("peppers_red_mask_a.png", red_mask_a);
    cv::imwrite("peppers_red_mask_b.png", red_mask_b);

    cv::Mat yellow_mask_a;
    cv::inRange(h_s_v[HUE], cv::Scalar(15), cv::Scalar(25), yellow_mask_a);
    cv::Mat yellow_mask_b = filter_mask(im_in, yellow_mask_a);
    cv::imwrite("peppers_yellow_mask_a.png", yellow_mask_a);
    cv::imwrite("peppers_yellow_mask_b.png", yellow_mask_b);

    cv::Mat green_mask_a;
    cv::inRange(h_s_v[HUE], cv::Scalar(40), cv::Scalar(50), green_mask_a);
    cv::Mat green_mask_b = filter_mask(im_in, green_mask_a);
    cv::imwrite("peppers_green_mask_a.png", green_mask_a);
    cv::imwrite("peppers_green_mask_b.png", green_mask_b);

    highlight_mask("peppers_red_out.png", orig_image, red_mask_b);
    highlight_mask("peppers_yellow_out.png", orig_image, yellow_mask_b);
    highlight_mask("peppers_green_out.png", orig_image, green_mask_b);
}