Summary of "turn" image grayscale method and its VC implementation

Reprinted from: http://blog.csdn.net/likezhaobin/article/details/6915754

Recently, the author began to design the positioning system of moving target recognition, this article and several subsequent articles are from an image processing beginner's point of view to summarize the target detection and positioning process of the various common algorithms used in the In particular, solving the problems caused by carelessness or the lack of solid basic skills of C programming in the process of algorithm implementation. This paper summarizes the method and implementation process of color image grayscale, and finally gives the C Code of implementation.

In the video stream target recognition and tracking, usually the first step is to grayscale the collected color image, this is because of the small black and white photo data, compared to color photo easier to implement real-time algorithm, on the other hand, black and white photos are caused by the processing of the light of the photo, so from the image processing point of view, The information covered by this image without special filtering is more valuable.

At present, in the image processing process, the most commonly used color picture format has RGB,HSV, YUV and HLS three kinds. The following is a grayscale implementation of the color images in these three formats respectively.

1. RGB Space Image

A color map defined in RGB space whose color is determined by a combination of R, G, and b three components per pixel. The number of bits that each component occupies in memory determines the depth of the image, which is the number of bytes per pixel. In a common 24-depth color RGB graph, the three components each account for 1 bytes, so that each component can have a value of 0~255, so that a pixel can have a range of more than 16 million (255*255*255) color variations. For such a color map, the corresponding grayscale image is only 8 bits of the depth of the picture (it is considered to be an RGB three components equal), which also shows that the gray-scale image processing requires less computational. However, it is important to note that although some color grades have been lost, the description of the grayscale image is consistent with the description of the color map in terms of the overall and local color of the whole image and the distribution of luminance levels.
For the RGB image grayscale, the popular point is that the RGB three components of the image weighted average to get the final gray value. The most common weighting methods are as follows:

1) gray=b;gray=g;gray=r

2) Gray=max (B+G+R)

3) gray= (B+G+R)/3

4) gray= 0.072169b+ 0.715160g+ 0.212671R

5) gray= 0.11b+ 0.59g+ 0.3R

Of these three methods, the first is the component method, that is, a component of the RGB three component as the gray value of the point; the second method is the maximum value method, which uses the maximum of three component luminance in the color image as the gray value of the gray scale. In the third method, the three-component luminance of color image is averaged to obtain a gray scale, and the second is the weighted average method, the fourth one is the gray weights used in the open library of OpenCV, and the fifth is a kind of weight from the human physiology angle (the human eye is sensitive to green and the blue is the lowest).

2. Grayscale of other color spaces

About the color map of HSV and HLS color space, you can refer to the Web page "HSL and HSV color space", the method described in this page can convert several different color expressions, convert them to RGB space, and then use the above formula for grayscale.

Regarding the color image of YUV space, the physical meaning of its Y component is the luminance of the pixel, which reflects the luminance level, so the corresponding brightness Y and R, G and b three color components can be established according to the variation relationship between RGB and YUV color space: y=0.3r+0.59g+0.11b, The grayscale value of the image is expressed with this luminance value .

3. Code implementation

The purpose of this paper is to summarize the whole realization principle and idea, so the following basic function based on OPENCV to realize these kinds of changes, as for bitmap and other forms of image, after acquiring the original image data, the processing method is the same, only need to pay attention to the position of the pointer operation. The specific code is as follows:

2. Iplimage *colorimage; //define the corresponding image pointer
4. Iplimage *grayimage1; //The result of different weights represented in 5
6. Iplimage *grayimage2;
8. Iplimage *grayimage3;
10. Iplimage *grayimage4;
12. Iplimage *grayimage5;
14. Iplimage *grayimage6;
16. Iplimage *grayimage7;
20. Colorimage = Cvloadimage ( "49138.jpg",-1); //Read pictures
22. if (colorimage = = NULL)
24. return;
28. GrayImage1 = Cvcreateimage (Cvgetsize (colorimage), 8, 1);
30. GrayImage2 = Cvcreateimage (Cvgetsize (colorimage), 8, 1);
32. GrayImage3 = Cvcreateimage (Cvgetsize (colorimage), 8, 1);
34. GrayImage4 = Cvcreateimage (Cvgetsize (colorimage), 8, 1);
36. GrayImage5 = Cvcreateimage (Cvgetsize (colorimage), 8, 1);
38. GrayImage6 = Cvcreateimage (Cvgetsize (colorimage), 8, 1);
40. GrayImage7 = Cvcreateimage (Cvgetsize (colorimage), 8, 1);
44. cvmat* PGRAYMAT1 = NULL; //define data pointers associated with the image
46. cvmat* pGrayMat2 = NULL;
48. cvmat* PGRAYMAT3 = NULL;
50. cvmat* pGrayMat4 = NULL;
52. cvmat* pGrayMat5 = NULL;
54. cvmat* pGrayMat6 = NULL;
56. cvmat* pGrayMat7 = NULL;
60. PGRAYMAT1 = Cvcreatemat (Colorimage->height, Colorimage->width, CV_32FC1);
62. PGRAYMAT2 = Cvcreatemat (Colorimage->height, Colorimage->width, CV_32FC1);
64. PGRAYMAT3 = Cvcreatemat (Colorimage->height, Colorimage->width, CV_32FC1);
66. PGRAYMAT4 = Cvcreatemat (Colorimage->height, Colorimage->width, CV_32FC1);
68. PGRAYMAT5 = Cvcreatemat (Colorimage->height, Colorimage->width, CV_32FC1);
70. PGrayMat6 = Cvcreatemat (Colorimage->height, Colorimage->width, CV_32FC1);
72. PGRAYMAT7 = Cvcreatemat (Colorimage->height, Colorimage->width, CV_32FC1);
76. BYTE data1; //Intermediate process variables
78. BYTE data2;
80. BYTE data3;
82. BYTE data4;
84. BYTE Data5;
86. BYTE data6;
88. BYTE Data7;
90. for (int j=0; j<colorimage->height; j + +)
92. {
94. For (int i=0; i<colorimage->width; i++)
96. {
98. Data1 = (BYTE) Colorimage->imagedata[j*colorimage->widthstep + i*3]; //b Component
100. Data2 = (BYTE) Colorimage->imagedata[j*colorimage->widthstep + i*3 + 1]; //g Component
102. Data3 = (BYTE) Colorimage->imagedata[j*colorimage->widthstep + i*3 + 2]; //r Component
104. DATA4 = Max (data1, Max (data2, data3)); //Maximum value
106. Data5 = (BYTE) ((data1 + data2 + data3)/3);
108. DATA6 = (BYTE) (0.072169*data1 + 0.715160*data2 + 0.212671*data3);
110. Data7 = (BYTE) (0.11*data1 + 0.59*data2 + 0.30*data3);
112. Cvmset (PGRAYMAT1, J, I, data1);
114. Cvmset (PGrayMat2, J, I, data2);
116. Cvmset (PGRAYMAT3, J, I, data3);
118. Cvmset (PGRAYMAT4, J, I, DATA4);
120. Cvmset (PGRAYMAT5, J, I, DATA5);
122. Cvmset (PGrayMat6, J, I, DATA6);
124. Cvmset (PGRAYMAT7, J, I, DATA6);
126. }
128. }
130. Cvconvert (PGRAYMAT1, GrayImage1);
132. Cvconvert (PGRAYMAT2, GrayImage2);
134. Cvconvert (PGRAYMAT3, GrayImage3);
136. Cvconvert (PGRAYMAT4, GrayImage4);
138. Cvconvert (PGRAYMAT5, GrayImage5);
140. Cvconvert (PGrayMat6, GrayImage6);
142. Cvconvert (PGRAYMAT7, GrayImage7);
146. Cvnamedwindow ( "Colorimage", cv_window_autosize);
148. Cvnamedwindow ( "GrayImage1", cv_window_autosize);
150. Cvnamedwindow ( "GrayImage2", cv_window_autosize);
152. Cvnamedwindow ( "GrayImage3", cv_window_autosize);
154. Cvnamedwindow ( "GrayImage4", cv_window_autosize);
156. Cvnamedwindow ( "GrayImage5", cv_window_autosize);
158. Cvnamedwindow ( "GrayImage6", cv_window_autosize);
160. Cvnamedwindow ( "GrayImage7", cv_window_autosize);
164. Cvshowimage ("Colorimage", colorimage);
166. Cvshowimage ("GrayImage1", GrayImage1);
168. Cvshowimage ("GrayImage2", GrayImage2);
170. Cvshowimage ("GrayImage3", GrayImage3);
172. Cvshowimage ("GrayImage4", GrayImage4);
174. Cvshowimage ("GrayImage5", GrayImage5);
176. Cvshowimage ("GrayImage6", GrayImage6);
178. Cvshowimage ("GrayImage7", GrayImage7);
182. Cvwaitkey (0);
184. Cvdestroywindow ("Colorimage");
186. Cvdestroywindow ("GrayImage1");
188. Cvdestroywindow ("GrayImage2");
190. Cvdestroywindow ("GrayImage3");
192. Cvdestroywindow ("GrayImage4");
194. Cvdestroywindow ("GrayImage5");
196. Cvdestroywindow ("GrayImage6");
198. Cvdestroywindow ("GrayImage7");
202. Cvreleaseimage (&colorimage);
204. Cvreleaseimage (&GRAYIMAGE1);
206. Cvreleaseimage (&grayimage2);
208. Cvreleaseimage (&grayimage3);
210. Cvreleaseimage (&GRAYIMAGE4);
212. Cvreleaseimage (&GRAYIMAGE5);
214. Cvreleaseimage (&grayimage6);
216. Cvreleaseimage (&grayimage7);
220. Cvreleasemat (&PGRAYMAT1);
222. Cvreleasemat (&PGRAYMAT2);
224. Cvreleasemat (&PGRAYMAT3);
226. Cvreleasemat (&PGRAYMAT4);
228. Cvreleasemat (&PGRAYMAT5);
230. Cvreleasemat (&PGRAYMAT6);
232. Cvreleasemat (&PGRAYMAT7);

The comparison of different methods to achieve grayscale is as follows;

Figure 1 Raw images to be processed-out of the vulgar cat

Figure 2 Component Grayscale-B component

Figure 3 Component Grayscale-G component

Figure 4 Component Grayscale-R component

Figure 5 Grayscale of the maximum value

Figure 6 mean Grayscale

Fig. 7 Gray weight coefficient of OpenCV

Fig. 8 Gray value of network common weights

4. Thinking

In the preceding code implementation, the last method, for example, uses the following code:

Gray= (0.11* Blue + 0.59* Green + 0.30* Red);

The actual computer processing, this method is very fast, but in fact there is room to optimize. The above code is based on floating-point arithmetic. In image processing, the speed is life, real-time is often a very important indicator, which requires us to implement the algorithm must take into account the efficiency of the Code. So there is a principle: in the image processing, can not use floating point operation, it is best not used!

Therefore, the above code can be optimized for the equivalent:

Gray = (* Red + *green + one * Blue)/100;

Such a change can effectively avoid floating point arithmetic, so it can improve the efficiency of the Code.

This line of code can also continue to be improved as follows:

Gray= Hibyte (* Red + 151 * Green + * Blue);

of which 77,151, 28 are divided by 256 respectively, which is three coefficients above.

Similarly, it can be implemented as:

gray= (* Red + 151 * Green + * Blue) SHR 8;

This method realizes the shift operation, avoids the division and improves the efficiency.

For specific code efficiency issues, you can refer to the blog post "from the grayscale view of the basic image processing."

Summary of "turn" image grayscale method and its VC implementation