Histogram equalization and histogram matching for image processing

1 Histogram equalization

  Histogram equalization is an image processing method that converts the gray distribution in the image into a uniform distribution, thereby enhancing the contrast of the image. Histogram equalization can convert the original white or black image into an image whose contrast conforms to human vision.

1.1 Principle

Continuous space image grayscale r ∈ [ 0 , L − 1 ]
  in continuous space , L represents the gray level r\in[0,L-1], L represents the gray level$r\in [0,L-1],Lrepresents\; the\; gray\; level$ , the expected equalization conversion function is
$$s=T(r),0\le r\le L-1$$
  of which$T$ is the grayscale transformation function,$s$ is the transformed gray value, and the change function satisfies two conditions:

• $T\left(r\right)$ in the interval$[0,L-1]$ is a strictly monotonically increasing function. Ensure that the conversion is one-to-one correspondence to avoid ambiguity;
• 当$0\le r\le L-1$时，$0\le s\le L-1$ . Ensure that the grayscale range of the input and output is the same.

  What we expect is to input the gray probability distribution $p\left(r\right)$ is converted into the output gray probability distribution$p(s)=\frac{1}{L-1}$. Here we choose the following transformation function to prove that this function is feasible:
$$s=T(r)=(L-1){\int }_0^r{p}_r\left(w\right)dw,wis\; the\; dummy\; variable\; of\; the\; integral$$
  First,${\int }_0^r{p}_r(w)\; The\; value\; range\; ofdw$ is$[0,1]$ Therefore$The\; value\; range\; of\; s$ is$[0,L-1]$ ; In addition, this function is also strictly monotonically increasing. The basic conditions are met. Below we prove that$p(s)=\frac{1}{L-1}$。因为
$$\begin{array}{c}\begin{array}{rl}p(s)& =p_r(r)|\frac{dr}{ds}|\\ & =p_r(r)\frac{1}{\frac{ds}{dr}}\\ & =p_r\left(r\right)\frac{1}{(L-1)\frac{d}{dr}[{\int }_0^r{p}_r(w\left)dw\right]}\\ & =p_r(r)\frac{1}{(L-1)p_r\left(r\right)}\\ & =\frac{1}{L-1}\end{array}\end{array}$$
  So $s=T(r)=(L-1){\int }_0^r{p}_r\left(w\right)dw$ can be used as an equalization transformation function.
Discrete space
  is always discrete space for image processing, the gray level$r_k,kis\; the\; gray\; level,k\in [0,L-1]$ the probability is approximately
$$p_r(r_k)=\frac{n_k}{MN}$$
  Where $kis\; the\; gray\; level,k\in [0,L-1]$；$M$ and$N$ is the width and height of the image,$n_k$is the number of pixels in the current gray level. Then use the above transformation function to get $s_k$为
$$s_k=T(r_k)=(L-1)\sum _{j=0}^k{p}_r(r_j)=\frac{L-1}{MN}\sum _{j=0}^k{n}_j$$
  In addition, the gray value calculated by the above change function may be a decimal, so it needs to be rounded to the nearest integer. And for the RGB image, if the images of the R, G, and B channels are respectively transformed, there will be a hue problem, so the image needs to be converted into other color spaces such as YUV, and only the grayscale transformation of Y is performed.

1.2 Implementation

  The implementation is relatively simple. First, the number of each gray level is calculated pixel by pixel, and the probability of each gray level is calculated according to the number of changes. Finally, the final color mapping relationship is calculated using the above formula, and the original image will be converted to the original image according to the mapping relationship. Colors are mapped.

static vector<float> countGrayProp(const Mat &img) {
    
    
    assert(img.channels() == 1);
    double pixelProp = 1.0 / (img.rows * img.cols);
    vector<float> ret(GRAPH_GRAY_LAYER_NUM, 0.0);
    for (int i = 0; i < img.rows; i++) {
    
    
        for (int j = 0; j < img.cols; j++) {
    
    
            ret[static_cast<int>(img.at<uchar>(i, j))] += pixelProp;
        }
    }

    return ret;
}
/*
    * @brief 均衡化灰度图
    */
static Mat avgGrayHistogram(const Mat &img) {
    
    
    assert(img.channels() == 1);
    vector<float> props = countGrayProp(img);
    vector<float> propSum(GRAPH_GRAY_LAYER_NUM, 0.0);
    for (int i = 0; i < GRAPH_GRAY_LAYER_NUM;i ++) {
    
    
        if (i == 0) {
    
    
            propSum[i] = props[i];
        }
        else {
    
    
            propSum[i] = (props[i] + propSum[i - 1]);
        }

    }

    Mat ret(img.rows, img.cols, CV_8UC1);
    for (int i = 0; i < img.rows; i++) {
    
    
        for (int j = 0; j < img.cols; j++) {
    
    
            int value = static_cast<int>(img.at<uchar>(i, j));
            ret.at<uchar>(i, j) = int((GRAPH_GRAY_LAYER_NUM - 1) * propSum[value]);
        }
    }

    return ret;
}

Mat avgHistogram(const Mat &img) {
    
    
    if (img.channels() == 1) {
    
    
			return avgGrayHistogram(img);
		}
		else if (img.channels() == 3) {
    
    
			Mat yuvImg;
			cvtColor(img, yuvImg, COLOR_BGR2YUV);
			std::vector<Mat> yuvImgs;
			split(yuvImg, yuvImgs);
			yuvImgs[0] = avgGrayHistogram(yuvImgs[0]);

			Mat proYUV, ret;
			merge(yuvImgs, proYUV);
			cv::cvtColor(proYUV, ret, COLOR_YUV2BGR);
			return ret;
		}

		return img;
}

  The effect of the single-channel grayscale image is as follows, and it can be seen that the grayscale in the equalized grayscale histogram is more uniform:

  If you directly equalize the three channels of rgb, the following situation will appear (1, 2, 3, and 4 in the four pictures 1 and 3 are the pictures before processing, and 34 is the picture after processing)

  First, the image is converted to other color spaces such as YUV, and only the Y component is equalized so that there will be no obvious color difference and singularity.

2 Histogram matching

2.1 Principle

  Using histogram equalization to adjust the gray level of the image can quickly and efficiently adjust the image to meet the perception of the human eye. However, this method is too simple and crude, and the histogram of the target cannot be customized, which is not very effective for some scenarios. Histogram regulation or histogram matching is a method to solve the problem that histogram equalization cannot specify the histogram probability distribution of the output image. This method can map the probability distribution of the input image to the specified output histogram probability distribution.
Continuous space
  task target: the probability density distribution $p_r\left(r\right)$ , the output image probability density distribution is$p_z\left(z\right)$ .
  In the histogram equalization task,$s$ andrrThe mapping relationship of$r$$s=T(r)=(L-1){\int }_0^r{p}_r\left(w\right)dw$ . Similarly, for$p_z\left(z\right)$ for histogram equalization, then$G(z)=(L-1){\int }_0^z{p}_z\left(w\right)dw$，其中$G\left(z\right)=T(r)$，即
$$\begin{array}{c}\begin{array}{r}T(r)=(L-1){\int }_0^r{p}_r\left(w\right)dw=G(z)=(L-1){\int }_0^z{p}_z(t)dt\end{array}\end{array}$$
  则：
$$z=G^{-1}\left(T\right(r))$$
  Therefore, a probability density as$p_{r}The\; image\; of\; (r)$ is specified as$p_z\left(z\right)$ steps are:

1. Calculate the probability distribution pr ( r ) p_r(r) of each gray level of the input image$p_r(r)$；
2. Calculate the histogram equalization mapping function of the input image;
3. According to the specified $p_z\left(z\right)$ Calculate the mapping function$G(z)$；
4. 求 G ( z ) G(z) The inverse transformation function of$G$$($$z$$)$$G^{-1}\left(T\right(r))$, process each pixel in the image to get the target grayscale image.

Discrete space
  In discrete space, $p_r\left(r\right)$ The output after histogram equalization is$s_k=\frac{L-1}{MN}{\sum }_{j=0}^k{n}_j$，而$G(z)=(L-1){\sum }_{i=0}^q{p}_z(z_j)$ . According to the inference of continuous space, the output value is$z_q=G^{-1}(s_k)$ .
  It can be seen from the above inference that we only need to find the inverse transformation$G^{-1}\left(s_k\right)$ is enough, but in fact, since the gray levels we use are limited, such as 256 gray levels, it is often only necessary to exhaustively enumerate.

1. Calculate the probability distribution pr ( r ) p_r(r) of each gray level of the input image$p_r(r)$；
2. Perform histogram equalization on the input image to obtain $r\to s_k$the mapping;
3. Calculate the histogram equalization mapping relationship $q\to s_q$；
4. Find the closest G ( z ) G(z) in the mapping relationship in step 3$G\left(z\right)$ , if there are multiple values, select the smallest one, that is, get$s_k\to map\; of\; q$ .

It is possible to find G ( z ) G(z)   in an implementation$G\left(z\right)$ is not strictly monotonically increasing and does not meet the conditions mentioned in histogram equalization, but this is not a serious problem in discrete spaces.

2.2 Implementation

  The implementation is relatively simple, the main thing is to search for content.

	static Mat matchGrayHistogram(const cv::Mat &img, const std::vector<float>& targetProp) {
    
    
		assert(img.channels() == 1);
		vector<float> props = countGrayProp(img);
		vector<float> propSum(GRAPH_GRAY_LAYER_NUM, 0.0), targPropSum(GRAPH_GRAY_LAYER_NUM, 0.0);
		for (int i = 0; i < GRAPH_GRAY_LAYER_NUM; i++) {
    
    
			if (i == 0) {
    
    
				propSum[i] = props[i];
				targPropSum[i] = targetProp[i];
			}
			else {
    
    
				propSum[i] = (props[i] + propSum[i - 1]);
				targPropSum[i] = (targetProp[i] + targPropSum[i - 1]);
			}
		}

		//将输入和输出的标签映射整数化
		for (int i = 0; i < GRAPH_GRAY_LAYER_NUM; i++) {
    
    
			int layer = GRAPH_GRAY_LAYER_NUM - 1;
			propSum[i] = std::min<float>(GRAPH_GRAY_LAYER_NUM - 1, static_cast<int>(layer * propSum[i] + 0.5));
			targPropSum[i] = std::min<float>(GRAPH_GRAY_LAYER_NUM - 1, static_cast<int>(layer * targPropSum[i] + 0.5));
		}

		//映射关系搜索，propSum中存储r->sk，targPropSum中存储z->sk 目标搜索sk->z
		std::vector<int> skzMap(GRAPH_GRAY_LAYER_NUM, -1);
		for (int i = 0; i < GRAPH_GRAY_LAYER_NUM; i++) {
    
    
			int sk = propSum[i];
			if (skzMap[sk] == -1) {
    
    
				//使用二分查找法在targetPropSum中搜索sk
				int left = 0, right = targPropSum.size() - 1;
				int mid = 0;
				while (left < right) {
    
    
					mid = left + (right - left) / 2.0;
					if (targPropSum[mid] == sk) {
    
    
						while (mid > 1 && targPropSum[mid] == targPropSum[mid - 1]) {
    
     mid--; }
						skzMap[sk] = mid;
						break;
					}
					else if (targPropSum[mid] > sk) {
    
    
						right = mid - 1;
					}
					else {
    
    
						left = mid + 1;
					}
				}

				if (targPropSum[mid] != sk) {
    
    
					if (left != 0 && abs(sk - targPropSum[left - 1]) < abs(sk - targPropSum[left])) {
    
    
						skzMap[sk] = left - 1;
					}
					else {
    
    
						skzMap[sk] = left;
					}
				}
				else {
    
    
					printf("");
				}
			}
		}

		Mat ret(img.rows, img.cols, CV_8UC1);
		for (int i = 0; i < img.rows; i++) {
    
    
			for (int j = 0; j < img.cols; j++) {
    
    
				int value = static_cast<int>(img.at<uchar>(i, j));
				ret.at<uchar>(i, j) = skzMap[propSum[value]];
			}
		}

		return ret;
	}

	Mat GrayTransform::matchHistogram(const cv::Mat &img, const std::vector<float>& targetProp) {
    
    
		assert(targetProp.size() == 256);
		if (img.channels() == 1) {
    
    
			return matchGrayHistogram(img, targetProp);
		}
		else if (img.channels() == 3) {
    
    
			Mat yuvImg;
			cvtColor(img, yuvImg, COLOR_BGR2YUV);
			std::vector<Mat> yuvImgs;
			split(yuvImg, yuvImgs);
			yuvImgs[0] = matchGrayHistogram(yuvImgs[0], targetProp);

			Mat proYUV, ret;
			merge(yuvImgs, proYUV);
			cv::cvtColor(proYUV, ret, COLOR_YUV2BGR);
			return ret;
		}

		return img;
	}