[opencv] image binarization

Binary image processing

Image binarization , It is to turn the color in the image into black according to the threshold / White two

The process of binarization

The pseudo code of binarization process is described as follows

for (;it != itend;it++, itout++) {
    
			if (get_ColorToTargetDistance(colorx) <= _distance) {
    
				*itout = 0;
			}
			else {
    
				*itout = 255;
			}
		}

among it Is an iterator of the source image ,itout Is the iterator of the binary result container ;

get_ColorToTargetDistance（） Used to get the difference between color and threshold ;
The difference between the colors of two three channels can be calculated by the following formula ：

distance = 
abs(color1[0] - color2[0]) + 
abs(color1[1] - color2[1]) + 
abs(color1[2] - color2[2]);

If the color in the picture is near the threshold , Just change it to 0; Otherwise, it should be changed to 255;
The results are as follows ：

Go straight to the code ：

Binarization processing class ColorDetector

/* ColorDetector @brief:  For binary processing  @member function: > > > > */
#include <vector>
#include <opencv2/core/core.hpp> 
#include <opencv2/highgui/highgui.hpp> 
using std::vector;
using namespace cv;
class ColorDetector {
    
public:
	/*  Constructors  */
	ColorDetector() :
		_distance(0)
	{
    

	};
	/*  Destructor  */
	~ColorDetector() {
    

	};
	/*  binarization  */
	inline cv::Mat process(cv::Mat& image) {
    
		_result.create(image.size(), CV_8U);
		auto it = image.begin<cv::Vec3b>();
		auto itend = image.end<cv::Vec3b>();
		auto itout = _result.begin<uchar>();
		std::vector<int> colorx(5);

		for (;it != itend;it++, itout++) {
    
			colorx[0] = it[0][0];
			colorx[1] = it[0][1];
			colorx[2] = it[0][2];
			if (get_ColorToTargetDistance(colorx) <= _distance) {
    
				*itout = 0;
			}
			else {
    
				*itout = 255;
			}
		}
		return _result;
	};
	/*  Set the threshold of each channel  */
	inline void setTargetColor(const int blue, const int red, const int green) {
    
		_target = std::vector<int>{
     blue,red,green };
	};
	/*  Set tolerances  */
	inline void setColorDistanceThreshold(int distance) {
    
		_distance = (distance > 0) ? distance : 0;
	};
	/*  Obtain tolerance  */
	inline int get_Distance() {
    
		return _distance;
	};
	/*  Get the urban distance from the color to the threshold  */
	inline int get_ColorToTargetDistance(std::vector<int>& color) {
    
		return get_ColorDistance(_target, color);
	}
	/*  Get the urban distance of the color  */
	inline int get_ColorDistance(std::vector<int>& color1, std::vector<int>& color2) {
    
		return abs(color1[0] - color2[0]) + abs(color1[1] - color2[1]) + abs(color1[2] - color2[2]);
	}


private:
	vector<int> _target;/*  threshold  */
	int _distance;/*  tolerance  */
	cv::Mat _result;/*  Binarization results  */
};

Calling procedure

int main()
{
     
	Mat imga = imread("D:\\cat.jpg");

	ColorDetector cdetector;
	/*  Set the threshold  */
	cdetector.setTargetColor(50,50,50);
	/*  Set tolerances  */
	cdetector.setColorDistanceThreshold(150);
	/*  binarization  */
	cv::Mat result = cdetector.process(imga);
	imshow("src", imga);;
	imshow("zhc", result);;

	waitKey(0);
}