devbox
盐析白兔
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

STM32+ov7725图像识别（HSL原理）_stm32图像识别

作者：盐析白兔 | 2024-04-10 23:02:41

赞

踩

stm32图像识别

一、前言

嗯，玩一玩ov7725摄像头，看到个帖子有关于图像识别的，就想玩玩

二、环境

stm32驱动ov7670摄像头识别颜色并追踪_木木so的博客-CSDN博客_stm32f103驱动ov7670摄像头参照这位老哥，这位老哥之上还有鼻祖，嗯

三、正文

在寻常的摄像头刷新图像之后，加上鼻祖的第三方文件库，调用其中的api函数，即可实现腐蚀中心绘制，识别出想要识别的物体中心和方框，嗯，但是物体如果是彩色的，估计就GG了，这个原理就是根据物体的HSL颜色，具体参考链接或者自行百度，HSL比起RGB更容易被机器识别一些。

  1. #include "delay.h"
  2.  
  3. #include "sys.h"
  4. #include "lcd.h"
  5. #include "usart.h"	 
  6. #include "string.h"
  7. #include "ov7670.h"
  8. #include "timer.h"
  9. #include "exti.h"
  10. #include "ColorTracer.h"
  11.  
  12.  
  13.  
  14. const u8*LMODE_TBL[5]={"Auto","Sunny","Cloudy","Office","Home"};							//5种光照模式	    
  15. const u8*EFFECTS_TBL[7]={"Normal","Negative","B&W","Redish","Greenish","Bluish","Antique"};	//7种特效 
  16. extern u8 ov_sta;	//在exit.c里 面定义
  17. extern u8 ov_frame;	//在timer.c里面定义	
  18. extern volatile uint8_t Ov7725_Vsync;
  19. //更新LCD显示
  20. u8 R,G,B;
  21. void camera_refresh(void)
  22. {
  23. 	u32 j;
  24.  	u16 color;	 
  25. 	if(ov_sta)//有帧中断更新？
  26. 	{
  27. 		LCD_Scan_Dir(U2D_L2R);		//从上到下,从左到右  
  28. 		if(lcddev.id==0X1963)LCD_Set_Window((lcddev.width-240)/2,(lcddev.height-320)/2,240,320);//将显示区域设置到屏幕中央
  29. 		else if(lcddev.id==0X5510||lcddev.id==0X5310)LCD_Set_Window((lcddev.width-320)/2,(lcddev.height-240)/2,320,240);//将显示区域设置到屏幕中央
  30. 		LCD_WriteRAM_Prepare();     //开始写入GRAM	
  31. 		OV7670_RRST=0;				//开始复位读指针 
  32. 		OV7670_RCK_L;
  33. 		OV7670_RCK_H;
  34. 		OV7670_RCK_L;
  35. 		OV7670_RRST=1;				//复位读指针结束 
  36. 		OV7670_RCK_H;
  37. 		for(j=0;j<76800;j++)
  38. 		{
  39. 			OV7670_RCK_L;
  40. 			color=GPIOC->IDR&0XFF;	//读数据
  41. 			OV7670_RCK_H; 
  42. 			color<<=8;  
  43. 			OV7670_RCK_L;
  44. 			color|=GPIOC->IDR&0XFF;	//读数据
  45. 			OV7670_RCK_H; 
  46. 			LCD->LCD_RAM=color;
  47. 		}   							  
  48.  		ov_sta=0;					//清零帧中断标记
  49. 		LCD_Scan_Dir(DFT_SCAN_DIR);	//恢复默认扫描方向 
  50. 	} 
  51. }	   
  52.  
  53. u8 i=0;	
  54.  int main(void)
  55.  {	 
  56. 	u8 lightmode=0,saturation=2,brightness=2,contrast=2;
  57. 	u8 effect=0;	 
  58. 	delay_init();	    	 //延时函数初始化	  
  59.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置中断优先级分组为组2：2位抢占优先级，2位响应优先级
  60. 	uart_init(921600);	 	//串口初始化为 115200	
  61. 	LCD_Init();			   		//初始化LCD  
  62.  
  63.  
  64.   
  65. 	while(OV7670_Init())//初始化OV7670
  66. 	{
  67. 		LCD_ShowString(30,230,200,16,16,"OV7670 Error!!");
  68. 		delay_ms(200);
  69. 	    LCD_Fill(30,230,239,246,WHITE);
  70. 		delay_ms(200);
  71. 	}
  72. 	POINT_COLOR=RED;
  73.  	LCD_ShowString(30,230,200,16,16,"OV7670 Init OK");
  74. 	delay_ms(1500);	 	   
  75. 	OV7670_Light_Mode(lightmode);
  76. 	OV7670_Color_Saturation(saturation);
  77. 	OV7670_Brightness(brightness);
  78. 	OV7670_Contrast(contrast);
  79.  	OV7670_Special_Effects(effect);	 
  80. 	TIM6_Int_Init(10000,7199);			//10Khz计数频率,1秒钟中断									  
  81. 	EXTI8_Init();						//使能定时器捕获
  82. 	OV7670_Window_Set(12,176,240,320);	//设置窗口	  
  83.   	OV7670_CS=0;					
  84. 	LCD_Clear(BLACK);
  85.  	while(1)
  86. 	{	
  87. 			camera_refresh();//更新显示
  88. 			
  89. 			if(Ov7725_Vsync == 2)
  90. 			{
  91. 				Ov7725_Vsync = 0;
  92. 				
  93. 					switch(i)
  94. 					{
  95. 						case 0:
  96. 							if(Trace(&condition0, &result))
  97. 							{
  98. 								LCD_DrawRectangle ( result.x-result.w/2, result.y-result.h/2, result.x+result.w/2, result.y+result.h/2);
  99. 								printf("绿色");
  100. 							}
  101. 							else
  102. 							{
  103. 								i = 1;
  104. 							}
  105. 								break;
  106. 						case 1:
  107. 							if(Trace(&condition1, &result))
  108. 							{
  109. 								LCD_DrawRectangle ( result.x-result.w/2, result.y-result.h/2, result.x+result.w/2, result.y+result.h/2);
  110. 								printf("蓝色");
  111. 							}
  112. 							else
  113. 							{
  114. 								i = 2;
  115. 							}
  116. 							break;
  117. 						case 2:
  118. 							if(Trace(&condition2, &result))
  119. 							{
  120. 								LCD_DrawRectangle ( result.x-result.w/2, result.y-result.h/2, result.x+result.w/2, result.y+result.h/2);
  121. 								printf("紫色");
  122. 							}
  123. 							else
  124. 							{
  125. 								i = 3;
  126. 							}
  127. 							break;
  128. 						case 3:
  129. 							if(Trace(&condition3, &result))
  130. 							{
  131. 								LCD_DrawRectangle ( result.x-result.w/2, result.y-result.h/2, result.x+result.w/2, result.y+result.h/2);
  132. 								printf("黑色");
  133. 							}
  134. 							else
  135. 							{
  136. 								i = 4;
  137. 							}
  138. 							break;
  139. 						case 4:
  140. 							if(Trace(&condition4, &result))
  141. 							{
  142. 								LCD_DrawRectangle ( result.x-result.w/2, result.y-result.h/2, result.x+result.w/2, result.y+result.h/2);
  143. 								printf("橙色");
  144. 							}
  145. 							else
  146. 							{
  147. 								i = 5;
  148. 							}
  149. 							break;
  150. 						case 5:
  151. 							if(Trace(&condition5, &result))
  152. 							{
  153. 								LCD_DrawRectangle ( result.x-result.w/2, result.y-result.h/2, result.x+result.w/2, result.y+result.h/2);
  154. 						
  155. 								printf("黄色");
  156. 							}
  157. 							else
  158. 							{
  159. 								i = 6;
  160. 							}
  161. 							break;
  162. 						case 6:
  163. 							if(Trace(&condition6, &result))
  164. 							{
  165. 								LCD_DrawRectangle ( result.x-result.w/2, result.y-result.h/2, result.x+result.w/2, result.y+result.h/2);
  166. 								printf("棕色");
  167. 							}
  168. 							else
  169. 							{
  170. 								i = 8;
  171. 							}
  172. 							break;
  173. //						case 7:
  174. //							if(Trace(&condition7, &result))
  175. //							{
  176. //								LCD_DrawRectangle ( result.x-result.w/2, result.y-result.h/2, result.x+result.w/2, result.y+result.h/2);
  177. //								//k = 1;
  178. //							}
  179. //							else
  180. //							{
  181. //								i = 8;
  182. //							}
  183. //							break;
  184. 						case 8:
  185. 							if(Trace(&condition8, &result))
  186. 							{
  187. 								LCD_DrawRectangle ( result.x-result.w/2, result.y-result.h/2, result.x+result.w/2, result.y+result.h/2);
  188. 								//k = 1;
  189. 								printf("红色");
  190. 							}
  191. 							else
  192. 							{
  193. 								i = 0;
  194. 							}
  195. 							break;
  196. 							
  197. 					
  198. 				}
  199. 					
  200. 				
  201. 			}
  202. 			
  203. 	}	   
  204. }
  205.  
  206.  
  207.  
  208.  
  209.  
  210.  
  211.  
  212.  
  213.  
  214.  
  215.  
  216.  
  217.  

  1. #include "ColorTracer.h"
  2. #include "lcd.h"
  3.  
  4. RESULT result;
  5.  
  6. //TARGET_CONDITION condition={50,80,20,250,20,200,40,40,320,240};
  7.  
  8. //识别的是绿色
  9. TARGET_CONDITION condition0={
  10. 	60,				 //目标最小色度，H_MIN
  11. 	110,       //目标最大色度，H_MAX
  12. 	           
  13. 	45,        //目标最小饱和度，S_MIN
  14. 	110,       //目标最大饱和度，S_MAX
  15. 	           
  16. 	90,        //目标最小亮度，L_MIN
  17. 	210,       //目标最大亮度，L_MAX
  18. 	           
  19. 	40,        //目标最小宽度，WIDTH_MIN
  20. 	40,        //目标最小高度，HEIGHT_MIN
  21. 	           
  22. 	240,       //目标最大宽度，WIDTH_MAX
  23. 	320        //目标最大高度，HEIGHT_MAX
  24. };
  25. //蓝色
  26. TARGET_CONDITION condition1={
  27. 	110,				 //目标最小色度，H_MIN
  28. 	150,       //目标最大色度，H_MAX
  29. 	           
  30. 	50,        //目标最小饱和度，S_MIN
  31. 	150,       //目标最大饱和度，S_MAX
  32. 	           
  33. 	100,        //目标最小亮度，L_MIN
  34. 	200,       //目标最大亮度，L_MAX
  35. 	           
  36. 	40,        //目标最小宽度，WIDTH_MIN
  37. 	40,        //目标最小高度，HEIGHT_MIN
  38. 	           
  39. 	240,       //目标最大宽度，WIDTH_MAX
  40. 	320        //目标最大高度，HEIGHT_MAX
  41. };
  42.  
  43. //紫色
  44. TARGET_CONDITION condition2={
  45. 	160,				 //目标最小色度，H_MIN
  46. 	190,       //目标最大色度，H_MAX
  47. 	           
  48. 	15,        //目标最小饱和度，S_MIN
  49. 	100,       //目标最大饱和度，S_MAX
  50. 	           
  51. 	15,        //目标最小亮度，L_MIN
  52. 	190,       //目标最大亮度，L_MAX
  53. 	           
  54. 	40,        //目标最小宽度，WIDTH_MIN
  55. 	40,        //目标最小高度，HEIGHT_MIN
  56. 	           
  57. 	240,       //目标最大宽度，WIDTH_MAX
  58. 	320        //目标最大高度，HEIGHT_MAX
  59. };
  60. //黑色
  61. TARGET_CONDITION condition3={
  62. 	80,				 //目标最小色度，H_MIN
  63. 	160,       //目标最大色度，H_MAX
  64. 	           
  65. 	10,        //目标最小饱和度，S_MIN
  66. 	100,       //目标最大饱和度，S_MAX
  67. 	           
  68. 	10,        //目标最小亮度，L_MIN
  69. 	100,       //目标最大亮度，L_MAX
  70. 	           
  71. 	40,        //目标最小宽度，WIDTH_MIN
  72. 	40,        //目标最小高度，HEIGHT_MIN
  73. 	           
  74. 	240,       //目标最大宽度，WIDTH_MAX
  75. 	320        //目标最大高度，HEIGHT_MAX
  76. };
  77. //橙色
  78. TARGET_CONDITION condition4={
  79. 	1,				 //目标最小色度，H_MIN
  80. 	40,       //目标最大色度，H_MAX
  81. 	           
  82. 	50,        //目标最小饱和度，S_MIN
  83. 	120,       //目标最大饱和度，S_MAX
  84. 	           
  85. 	40,        //目标最小亮度，L_MIN
  86. 	220,       //目标最大亮度，L_MAX
  87. 	           
  88. 	40,        //目标最小宽度，WIDTH_MIN
  89. 	40,        //目标最小高度，HEIGHT_MIN
  90. 	           
  91. 	240,       //目标最大宽度，WIDTH_MAX
  92. 	320        //目标最大高度，HEIGHT_MAX	
  93. };
  94. //黄色
  95. TARGET_CONDITION condition5={
  96. 	20,				 //目标最小色度，H_MIN
  97. 	70,       //目标最大色度，H_MAX
  98. 	           
  99. 	30,        //目标最小饱和度，S_MIN
  100. 	200,       //目标最大饱和度，S_MAX
  101. 	           
  102. 	70,        //目标最小亮度，L_MIN
  103. 	240,       //目标最大亮度，L_MAX
  104. 	           
  105. 	40,        //目标最小宽度，WIDTH_MIN
  106. 	40,        //目标最小高度，HEIGHT_MIN
  107. 	           
  108. 	240,       //目标最大宽度，WIDTH_MAX
  109. 	320        //目标最大高度，HEIGHT_MAX
  110. };
  111.  
  112. //棕色
  113. TARGET_CONDITION condition6={
  114. 	7,				 //目标最小色度，H_MIN
  115. 	22,       //目标最大色度，H_MAX
  116. 	           
  117. 	1,        //目标最小饱和度，S_MIN
  118. 	55,       //目标最大饱和度，S_MAX
  119. 	           
  120. 	1,        //目标最小亮度，L_MIN
  121. 	160,       //目标最大亮度，L_MAX
  122. 	           
  123. 	40,        //目标最小宽度，WIDTH_MIN
  124. 	40,        //目标最小高度，HEIGHT_MIN
  125. 	           
  126. 	240,       //目标最大宽度，WIDTH_MAX
  127. 	320        //目标最大高度，HEIGHT_MAX
  128. };
  129. //灰白
  130. TARGET_CONDITION condition7={
  131. 	60,				 //目标最小色度，H_MIN
  132. 	170,       //目标最大色度，H_MAX
  133. 	           
  134. 	0,        //目标最小饱和度，S_MIN
  135. 	25,       //目标最大饱和度，S_MAX
  136. 	           
  137. 	160,        //目标最小亮度，L_MIN
  138. 	220,       //目标最大亮度，L_MAX
  139. 	           
  140. 	40,        //目标最小宽度，WIDTH_MIN
  141. 	40,        //目标最小高度，HEIGHT_MIN
  142. 	           
  143. 	240,       //目标最大宽度，WIDTH_MAX
  144. 	320        //目标最大高度，HEIGHT_MAX
  145. };
  146. //红色
  147. TARGET_CONDITION condition8={
  148. 	200,				 //目标最小色度，H_MIN
  149. 	240,       //目标最大色度，H_MAX
  150. 	           
  151. 	5,        //目标最小饱和度，S_MIN
  152. 	240,       //目标最大饱和度，S_MAX
  153. 	           
  154. 	5,        //目标最小亮度，L_MIN
  155. 	240,       //目标最大亮度，L_MAX
  156. 	           
  157. 	40,        //目标最小宽度，WIDTH_MIN
  158. 	40,        //目标最小高度，HEIGHT_MIN
  159. 	           
  160. 	240,       //目标最大宽度，WIDTH_MAX
  161. 	320        //目标最大高度，HEIGHT_MAX
  162. };
  163. #define minOf3Values( v1, v2, v3 )			( (v1<v2) ? ( (v1<v3) ? (v1) : (v3) ) : ( (v2<v3) ? (v2) : (v3) ) )//取rgb中的最小值
  164.  
  165. #define maxOf3Values( v1, v2, v3 )			( (v1>v2) ? ( (v1>v3) ? (v1) : (v3) ) : ( (v2>v3) ? (v2) : (v3) ) )//取rgb中的最大值
  166.  
  167. typedef struct 						//RGB
  168. {
  169. 	unsigned char Red;					// [0,255]
  170. 	unsigned char Green;        // [0,255]
  171. 	unsigned char Blue;         // [0,255]
  172. }COLOR_RGB;
  173.  
  174. typedef struct						//HLS颜色
  175. {
  176. 	unsigned char Hue;					//色度	,[0,240]				
  177. 	unsigned char Lightness;		//亮度,[0,240]	     
  178. 	unsigned char Saturation;		//饱和度,[0,240]	     
  179. }COLOR_HLS;
  180.  
  181. COLOR_HLS h;
  182. typedef struct						//搜寻区域
  183. {
  184. 	unsigned int X_Start;
  185. 	unsigned int X_End;
  186. 	unsigned int Y_Start;
  187. 	unsigned int Y_End;
  188. }SEARCH_AREA;
  189.  
  190.  
  191. /**
  192.  * @brief  获取 ILI9341 显示器上某一个坐标点的像素数据
  193.  * @param  usX ：在特定扫描方向下该点的X坐标
  194.  * @param  usY ：在特定扫描方向下该点的Y坐标
  195.  * @retval 像素数据
  196.  */
  197. //uint16_t ILI9341_GetPointPixel( uint16_t usX, uint16_t usY )
  198.  
  199. /**
  200.  * @brief  读取某一点颜色数据
  201.  * @param  usX ：该点的X坐标
  202.  * @param  usY ：该点的Y坐标
  203.  * @param  color_rgb ：COLOR_RGB结构体，存储颜色数据
  204.  * @retval 无
  205.  */
  206. static void ReadColor( uint16_t usX, uint16_t usY, COLOR_RGB* color_rgb )
  207. {
  208. 	unsigned short rgb;
  209. 	
  210. 	rgb = LCD_ReadPoint( usX, usY );					//获取颜色数据
  211. 	
  212. 	//转换成值域为[0,255]的三原色值
  213. 	color_rgb->Red 		= (unsigned char)( ( rgb & 0xF800 ) >> 8 );
  214. 	color_rgb->Green  = (unsigned char)( ( rgb & 0x07E0 ) >> 3 );
  215. 	color_rgb->Blue 	= (unsigned char)( ( rgb & 0x001F ) << 3 );
  216. 	//color_rgb->Blue 	= (unsigned char)( ( rgb & 0x001F )  );
  217. }
  218.  
  219. /**
  220.  * @brief  RGB转HLS
  221.  * @param  color_rgb ：COLOR_RGB结构体，存储RGB格式颜色数据
  222.  * @param  color_hls ：COLOR_HLS结构体，存储HLS格式颜色数据
  223.  * @retval 无
  224.  */
  225. u8 H,S,L;
  226. static void RGB2HSL( const COLOR_RGB* color_rgb, COLOR_HLS* color_hls )
  227. {
  228. 	int r, g, b;
  229. 	int h, l, s;
  230. 	int max, min, dif;
  231. 	
  232. 	r = color_rgb->Red;
  233. 	g = color_rgb->Green;
  234. 	b = color_rgb->Blue;
  235. 	
  236. 	max = maxOf3Values( r, g, b );
  237. 	min = minOf3Values( r, g, b );
  238. 	dif = max - min;
  239. 	
  240. 	//计算l，亮度
  241. 	l = ( max + min ) * 240 / 255 / 2;
  242. 	
  243. 	//计算h，色度
  244. 	if( max == min )//无定义
  245. 	{
  246. 		s = 0;
  247. 		h = 0;
  248. 	}
  249. 	else
  250. 	{
  251. 		//计算色度
  252. 		if( max == r )//最大值为红色
  253. 		{ 
  254. 			if( min == b )//h介于0到40  最小值为蓝色
  255. 			{
  256. 				h = 40 * ( g - b ) / dif;//h = 40 * ( g - n ) / dif;
  257. 			}
  258. 			else if( min == g )//h介于200到240 最小值为绿色
  259. 			{
  260. 				h = 40 * ( g - b ) / dif + 240;
  261. 			}
  262. 			
  263. 		}
  264. 		else if( max == g )//最大值为绿色 40到120
  265. 		{
  266. 			h = 40 * ( b - r ) / dif + 80;
  267. 		}
  268. 		else if( max == b )//最大值为蓝色 120 -200
  269. 		{
  270. 			h = 40 * ( r - g ) / dif + 160;
  271. 		}
  272. 		
  273. 		//计算饱和度
  274. 		if( l == 0 )
  275. 		{
  276. 			s = 0;
  277. 		}
  278. 		else if( l <= 120 )
  279. 		{
  280. 			s = dif * 240 / ( max + min );
  281. 		}
  282. 		else
  283. 		{
  284. 			s = dif * 240 / ( 480 - ( max + min ) );
  285. 		}
  286. 		
  287. 	}
  288. //	H = h;
  289. //	S = s;
  290. //	L = l;
  291. 	color_hls->Hue = h;							//色度
  292. 	color_hls->Lightness = l;				//亮度
  293. 	color_hls->Saturation = s;			//饱和度
  294. 	
  295. }
  296.  
  297. /**
  298.  * @brief  颜色匹配
  299.  * @param  color_hls ：COLOR_HLS结构体，存储HLS格式颜色数据
  300.  * @param  condition ：TARGET_CONDITION结构体，存放希望的颜色数据阈值
  301.  * @retval 1：像素点颜色在目标范围内；0：像素点颜色不在目标范围内。
  302.  */
  303. static int ColorMatch(const COLOR_HLS* color_hls, const TARGET_CONDITION* condition )
  304. {
  305. 	if(
  306. 			color_hls->Hue > condition->H_MIN &&
  307. 			color_hls->Hue < condition->H_MAX &&
  308. 			color_hls->Lightness > condition->L_MIN &&
  309. 			color_hls->Lightness < condition->L_MAX &&
  310. 			color_hls->Saturation > condition->S_MIN &&
  311. 			color_hls->Saturation < condition->S_MAX
  312. 	)
  313. 	{
  314. 		
  315. 		H = color_hls->Hue;
  316. 		S = color_hls->Saturation;
  317. 		L = color_hls->Lightness;return 1;
  318. 	}
  319. 		
  320. 	else
  321. 		return 0;
  322. }
  323.  
  324. /**
  325.  * @brief  寻找腐蚀中心
  326.  * @param  x ：腐蚀中心x坐标
  327.  * @param  y ：腐蚀中心y坐标
  328.  * @param  condition ：TARGET_CONDITION结构体，存放希望的颜色数据阈值
  329.  * @param  area ：SEARCH_AREA结构体，查找腐蚀中心的区域
  330.  * @retval 1：找到了腐蚀中心，x、y为腐蚀中心的坐标；0：没有找到腐蚀中心。
  331.  */
  332. static int SearchCenter(unsigned int* x, unsigned int* y, const TARGET_CONDITION* condition, SEARCH_AREA* area )
  333. {
  334. 	unsigned int i, j, k;
  335. 	unsigned int FailCount=0;
  336. 	unsigned int SpaceX, SpaceY;
  337. 	COLOR_RGB rgb;
  338. 	COLOR_HLS hls;
  339. 	
  340. 	SpaceX = condition->WIDTH_MIN / 3;//最小宽度 40/3
  341. 	SpaceY = condition->HEIGHT_MIN / 3;//最小高度 40/3
  342. 	
  343. 	for(i=area->Y_Start; i<area->Y_End; i+=SpaceY)
  344. 	{
  345. 		for(j=area->X_Start; j<area->X_End; j+=SpaceX)
  346. 		{
  347. 			FailCount = 0;
  348. 			for(k=0; k<SpaceX+SpaceY; k++)
  349. 			{
  350. 				if(k<SpaceX)
  351. 					ReadColor( j+k, i+SpaceY/2, &rgb );
  352. 				else
  353. 					ReadColor( j+SpaceX/2, i+k-SpaceX, &rgb );
  354. 				RGB2HSL( &rgb, &hls );
  355. 				
  356. 				if(!ColorMatch( &hls, condition ))
  357. 					FailCount++;
  358. 				
  359. 				if(FailCount>( (SpaceX+SpaceY) >> ALLOW_FAIL_PER ))
  360. 					break;
  361. 				
  362. 			}
  363. 			
  364. 			if(k == SpaceX+SpaceY)
  365. 			{
  366. 				*x = j + SpaceX / 2;
  367. 				*y = i + SpaceY / 2;
  368. 				return 1;
  369. 			}
  370. 			
  371. 		}
  372. 			
  373. 	}
  374. 	
  375. 	return 0;
  376. 		
  377. }
  378.  
  379. /**
  380.  * @brief  从腐蚀中心向外腐蚀，得到新的腐蚀中心
  381.  * @param  oldX ：先前的腐蚀中心x坐标
  382.  * @param  oldX ：先前的腐蚀中心y坐标
  383.  * @param  condition ：TARGET_CONDITION结构体，存放希望的颜色数据阈值
  384.  * @param  result ：RESULT结构体，存放检测结果
  385.  * @retval 1：检测成功；0：检测失败。
  386.  */
  387. static int Corrode(unsigned int oldX, unsigned int oldY, const TARGET_CONDITION* condition, RESULT* result )
  388. {
  389. 	unsigned int Xmin, Xmax, Ymin, Ymax;
  390. 	unsigned int i;
  391. 	unsigned int FailCount=0;
  392. 	COLOR_RGB rgb;
  393. 	COLOR_HLS hls;
  394. 	//从中心点查到x最左侧
  395. 	for(i=oldX; i>IMG_X; i--)
  396. 	{
  397. 		ReadColor(i, oldY, &rgb);
  398. 		RGB2HSL(&rgb, &hls);
  399. 		if(!ColorMatch(&hls, condition))
  400. 			FailCount++;
  401. 		if(FailCount>(((condition->WIDTH_MIN+condition->WIDTH_MAX)>>2)>>ALLOW_FAIL_PER))
  402. 			break;
  403. 	}
  404. 	Xmin=i;
  405. 	//从中心点查到x最右侧
  406. 	FailCount=0;
  407. 	for(i=oldX; i<IMG_X+IMG_W; i++)
  408. 	{
  409. 		ReadColor(i, oldY, &rgb);
  410. 		RGB2HSL(&rgb, &hls);
  411. 		if(!ColorMatch(&hls, condition))
  412. 			FailCount++;
  413. 		if(FailCount>(((condition->WIDTH_MIN+condition->WIDTH_MAX)>>2)>>ALLOW_FAIL_PER))
  414. 			break;
  415. 	}
  416. 	Xmax=i;
  417. 	//y上
  418. 	FailCount=0;
  419. 	for(i=oldY; i>IMG_Y; i--)
  420. 	{
  421. 		ReadColor(oldX, i, &rgb);
  422. 		RGB2HSL(&rgb, &hls);
  423. 		if(!ColorMatch(&hls, condition))
  424. 			FailCount++;
  425. 		if(FailCount>(((condition->HEIGHT_MIN+condition->HEIGHT_MAX)>>2)>>ALLOW_FAIL_PER))
  426. 			break;
  427. 	}
  428. 	Ymin=i;
  429. 	//y下
  430. 	FailCount=0;
  431. 	for(i=oldY; i<IMG_Y+IMG_H; i++)
  432. 	{
  433. 		ReadColor(oldX, i, &rgb);
  434. 		RGB2HSL(&rgb, &hls);
  435. 		if(!ColorMatch(&hls, condition))
  436. 			FailCount++;
  437. 		if(FailCount>(((condition->HEIGHT_MIN+condition->HEIGHT_MAX)>>2)>>ALLOW_FAIL_PER))
  438. 			break;
  439. 	}
  440. 	Ymax=i;
  441. 	
  442. 	FailCount=0;
  443. 	
  444. 	result->x = (Xmin + Xmax) / 2;
  445. 	result->y = (Ymin + Ymax) / 2;
  446. 	result->w = (Xmax - Xmin);
  447. 	result->h = (Ymax - Ymin);
  448. 	
  449. 	if( (result->w > condition->WIDTH_MIN) && (result->w < condition->WIDTH_MAX) &&
  450. 			(result->h > condition->HEIGHT_MIN) && (result->h < condition->HEIGHT_MAX)  )
  451. 		return 1;
  452. 	else
  453. 		return 0;
  454. }
  455.  
  456.  
  457. int Trace(const TARGET_CONDITION* condition, RESULT* result_final)
  458. {
  459. 	unsigned int i;
  460. 	static unsigned int x0, y0, Flag = 0;
  461. 	static SEARCH_AREA area = {IMG_X, IMG_X+IMG_W, IMG_Y, IMG_Y+IMG_H};//搜索区域
  462. 	RESULT result;
  463. //	for(i = 0;i<2;i++)
  464. //	{
  465. 		if(Flag == 0)
  466. 		{
  467. 			if(SearchCenter(&x0, &y0, condition, &area))
  468. 			{
  469. 				Flag = 1;
  470. 				//break;
  471. 			}
  472. 			else
  473. 			{
  474. 				area.X_Start = IMG_X;
  475. 				area.X_End   = IMG_X+IMG_W;
  476. 				area.Y_Start = IMG_Y;
  477. 				area.Y_End   = IMG_Y+IMG_H;
  478. 				
  479. 				if(SearchCenter(&x0, &y0, condition, &area))
  480. 				{
  481. 					Flag = 0;
  482. 					return 0;
  483. 				}
  484. 			}
  485. 		}
  486. 	//}
  487. 	
  488. 	result.x = x0;
  489. 	result.y = y0;
  490. 	
  491. 	for(i=0; i<ITERATER_NUM; i++)
  492. 	{
  493. 		Corrode(result.x, result.y, condition, &result);	//从腐蚀中心向外腐蚀，得到新的腐蚀中心
  494. 		
  495. 	}
  496. 	
  497. 	if( Corrode(result.x, result.y, condition, &result) )
  498. 	{
  499. 		x0 = result.x;
  500. 		y0 = result.y;
  501. 		result_final->x = result.x;
  502. 		result_final->y = result.y;
  503. 		result_final->w = result.w;
  504. 		result_final->h = result.h;
  505. 		Flag = 1;
  506. 		
  507. 		area.X_Start = result.x - ((result.w)>>1);
  508. 		area.X_End   = result.x + ((result.w)>>1);
  509. 		area.Y_Start = result.y - ((result.h)>>1);
  510. 		area.Y_End   = result.y + ((result.h)>>1);
  511. 		
  512. 		return 1;
  513. 	}
  514. 	else
  515. 	{
  516. 		Flag = 0;
  517. 		return 0;
  518. 	}
  519. 	
  520. }
  521.  
  522.  
  523. //#define min3v(v1, v2, v3)   ((v1)>(v2)? ((v2)>(v3)?(v3):(v2)):((v1)>(v3)?(v3):(v1)))
  524. //#define max3v(v1, v2, v3)   ((v1)<(v2)? ((v2)<(v3)?(v3):(v2)):((v1)<(v3)?(v3):(v1)))
  525.  
  526. //typedef struct{
  527. //    unsigned char  red;             // [0,255]
  528. //    unsigned char  green;           // [0,255]
  529. //    unsigned char  blue;            // [0,255]
  530. //}COLOR_RGB;//RGB格式颜色
  531.  
  532. //typedef struct{
  533. //    unsigned char hue;              // [0,240]
  534. //    unsigned char saturation;       // [0,240]
  535. //    unsigned char luminance;        // [0,240]
  536. //}COLOR_HSL;//HSL格式颜色
  537.  
  538. //typedef struct{
  539. //    unsigned int X_Start;              
  540. //    unsigned int X_End;
  541. //	unsigned int Y_Start;              
  542. //    unsigned int Y_End;
  543. //}SEARCH_AREA;//区域
  544.  
  545. 读取RBG格式颜色，唯一需要移植的函数
  546. //extern unsigned short GUI_ReadBit16Point(unsigned short x,unsigned short y);
  547. //static void ReadColor(unsigned int x,unsigned int y,COLOR_RGB *Rgb)
  548. //{
  549. //	unsigned short C16;
  550.  
  551. //	C16 = LCD_ReadPoint(x,y);
  552.  
  553. //	Rgb->red   =	 (unsigned char)((C16&0xf800)>>8);
  554. //	Rgb->green =	 (unsigned char)((C16&0x07e0)>>3);
  555. //	Rgb->blue  =     (unsigned char)((C16&0x001f)<<3);
  556. //}
  557.  
  558.  
  559.  
  560. RGB转HSL
  561. //static void RGBtoHSL(const COLOR_RGB *Rgb, COLOR_HSL *Hsl)
  562. //{
  563. //    int h,s,l,maxVal,minVal,difVal;
  564. //	int r  = Rgb->red;
  565. //	int g  = Rgb->green;
  566. //    int b  = Rgb->blue;
  567. //	
  568. //	maxVal = max3v(r, g, b);
  569. //	minVal = min3v(r, g, b);
  570. //	
  571. //	difVal = maxVal-minVal;
  572. //	
  573. //	//计算亮度
  574. //    l = (maxVal+minVal)*240/255/2;
  575. //	
  576. //	if(maxVal == minVal)//若r=g=b
  577. //	{
  578. //		h = 0; 
  579. //		s = 0;
  580. //	}
  581. //	else
  582. //	{
  583. //		//计算色调
  584. //		if(maxVal==r)
  585. //		{
  586. //			if(g>=b)
  587. //				h = 40*(g-b)/(difVal);
  588. //			else
  589. //				h = 40*(g-b)/(difVal) + 240;
  590. //		}
  591. //		else if(maxVal==g)
  592. //			h = 40*(b-r)/(difVal) + 80;
  593. //		else if(maxVal==b)
  594. //			h = 40*(r-g)/(difVal) + 160;
  595. //		//计算饱和度
  596. //		if(l == 0)
  597. //			s = 0;
  598. //		else if(l<=120)
  599. //			s = (difVal)*240/(maxVal+minVal);
  600. //		else
  601. //			s = (difVal)*240/(480 - (maxVal+minVal));
  602. //	}
  603. //    Hsl->hue =        (unsigned char)(((h>240)? 240 : ((h<0)?0:h)));
  604. //    Hsl->saturation = (unsigned char)(((s>240)? 240 : ((s<0)?0:s)));
  605. //    Hsl->luminance =  (unsigned char)(((l>240)? 240 : ((l<0)?0:l)));
  606. //}
  607.  
  608. 匹配颜色
  609. //static int ColorMatch(const COLOR_HSL *Hsl,const TARGET_CONDITION *Condition)
  610. //{
  611. //	if( 
  612. //		Hsl->hue		>	Condition->H_MIN &&
  613. //		Hsl->hue		<	Condition->H_MAX &&
  614. //		Hsl->saturation	>	Condition->S_MIN &&
  615. //		Hsl->saturation	<   Condition->S_MAX &&
  616. //		Hsl->luminance	>	Condition->L_MIN &&
  617. //		Hsl->luminance	<   Condition->L_MAX 
  618. //    )
  619. //		return 1;
  620. //	else
  621. //		return 0;
  622. //}
  623.  
  624. 搜索腐蚀中心
  625. //static int SearchCentre(unsigned int *x,unsigned int *y,const TARGET_CONDITION *Condition,const SEARCH_AREA *Area)
  626. //{
  627. //	unsigned int SpaceX,SpaceY,i,j,k,FailCount=0;
  628. //	COLOR_RGB Rgb;
  629. //	COLOR_HSL Hsl;
  630. //	
  631. //	SpaceX = Condition->WIDTH_MIN/3;
  632. //	SpaceY = Condition->HEIGHT_MIN/3;
  633.  
  634. //	for(i=Area->Y_Start;i<Area->Y_End;i+=SpaceY)
  635. //	{
  636. //		for(j=Area->X_Start;j<Area->X_End;j+=SpaceX)
  637. //		{
  638. //			FailCount=0;
  639. //			for(k=0;k<SpaceX+SpaceY;k++)
  640. //			{
  641. //				if(k<SpaceX)
  642. //					ReadColor(j+k,i+SpaceY/2,&Rgb);
  643. //				else
  644. //					ReadColor(j+SpaceX/2,i+(k-SpaceX),&Rgb);
  645. //				RGBtoHSL(&Rgb,&Hsl);
  646. //				
  647. //				if(!ColorMatch(&Hsl,Condition))
  648. //					FailCount++;
  649. //				if(FailCount>((SpaceX+SpaceY)>>ALLOW_FAIL_PER))
  650. //					break;
  651. //			}
  652. //			if(k==SpaceX+SpaceY)
  653. //			{
  654. //				*x = j+SpaceX/2;
  655. //				*y = i+SpaceY/2;
  656. //				return 1;
  657. //			}
  658. //		}
  659. //	}
  660. //	return 0;
  661. //}
  662.  
  663. 从腐蚀中心向外腐蚀，得到新的腐蚀中心
  664. //static int Corrode(unsigned int oldx,unsigned int oldy,const TARGET_CONDITION *Condition,RESULT *Resu)
  665. //{
  666. //	unsigned int Xmin,Xmax,Ymin,Ymax,i,FailCount=0;
  667. //	COLOR_RGB Rgb;
  668. //	COLOR_HSL Hsl;
  669. //	
  670. //	for(i=oldx;i>IMG_X;i--)
  671. //	{
  672. //		ReadColor(i,oldy,&Rgb);
  673. //		RGBtoHSL(&Rgb,&Hsl);
  674. //		if(!ColorMatch(&Hsl,Condition))
  675. //			FailCount++;
  676. //		if(FailCount>(((Condition->WIDTH_MIN+Condition->WIDTH_MAX)>>2)>>ALLOW_FAIL_PER))
  677. //			break;	
  678. //	}
  679. //	Xmin=i;
  680. //	FailCount=0;
  681. //	
  682. //	for(i=oldx;i<IMG_X+IMG_W;i++)
  683. //	{
  684. //		ReadColor(i,oldy,&Rgb);
  685. //		RGBtoHSL(&Rgb,&Hsl);
  686. //		if(!ColorMatch(&Hsl,Condition))
  687. //			FailCount++;
  688. //		if(FailCount>(((Condition->WIDTH_MIN+Condition->WIDTH_MAX)>>2)>>ALLOW_FAIL_PER))
  689. //			break;	
  690. //	}
  691. //	Xmax=i;
  692. //	FailCount=0;
  693. //	
  694. //	for(i=oldy;i>IMG_Y;i--)
  695. //	{
  696. //		ReadColor(oldx,i,&Rgb);
  697. //		RGBtoHSL(&Rgb,&Hsl);
  698. //		if(!ColorMatch(&Hsl,Condition))
  699. //			FailCount++;
  700. //		if(FailCount>(((Condition->HEIGHT_MIN+Condition->HEIGHT_MIN)>>2)>>ALLOW_FAIL_PER))
  701. //			break;	
  702. //	}
  703. //	Ymin=i;
  704. //	FailCount=0;
  705. //	
  706. //	for(i=oldy;i<IMG_Y+IMG_H;i++)
  707. //	{
  708. //		ReadColor(oldx,i,&Rgb);
  709. //		RGBtoHSL(&Rgb,&Hsl);
  710. //		if(!ColorMatch(&Hsl,Condition))
  711. //			FailCount++;
  712. //		if(FailCount>(((Condition->HEIGHT_MIN+Condition->HEIGHT_MIN)>>2)>>ALLOW_FAIL_PER))
  713. //			break;	
  714. //	}
  715. //	Ymax=i;
  716. //	FailCount=0;
  717. //	
  718. //	Resu->x	= (Xmin+Xmax)/2;
  719. //	Resu->y	= (Ymin+Ymax)/2;
  720. //	Resu->w	= Xmax-Xmin;
  721. //	Resu->h	= Ymax-Ymin;
  722.  
  723. //	if(((Xmax-Xmin)>(Condition->WIDTH_MIN)) && ((Ymax-Ymin)>(Condition->HEIGHT_MIN)) &&\
  724. //	   ((Xmax-Xmin)<(Condition->WIDTH_MAX)) && ((Ymax-Ymin)<(Condition->HEIGHT_MIN)) )
  725. //		return 1;	
  726. //	else
  727. //		return 0;	
  728. //}
  729.  
  730. 唯一的API，用户将识别条件写入Condition指向的结构体中，该函数将返回目标的x，y坐标和长宽
  731. 返回1识别成功，返回1识别失败
  732. //int Trace(const TARGET_CONDITION *Condition,RESULT *Resu)
  733. //{
  734. //	unsigned int i;
  735. //	static unsigned int x0,y0,flag=0;
  736. //	static SEARCH_AREA Area={IMG_X,IMG_X+IMG_W,IMG_Y,IMG_Y+IMG_H};
  737. //	RESULT Result;	
  738. //	
  739.  
  740. //	if(flag==0)
  741. //	{
  742. //		if(SearchCentre(&x0,&y0,Condition,&Area))
  743. //			flag=1;
  744. //		else
  745. //		{
  746. //			Area.X_Start= IMG_X	;
  747. //			Area.X_End  = IMG_X+IMG_W  ;
  748. //			Area.Y_Start= IMG_Y		;
  749. //			Area.Y_End  = IMG_Y+IMG_H;
  750.  
  751. //			if(SearchCentre(&x0,&y0,Condition,&Area))	
  752. //			{
  753. //				flag=0;
  754. //				return 0;
  755. //			}	
  756. //		}
  757. //	}
  758. //	Result.x = x0;
  759. //	Result.y = y0;
  760. //	
  761. //	for(i=0;i<ITERATER_NUM;i++)
  762. //		Corrode(Result.x,Result.y,Condition,&Result);
  763. //		
  764. //	if(Corrode(Result.x,Result.y,Condition,&Result))
  765. //	{
  766. //		x0=Result.x;
  767. //		y0=Result.y;
  768. //		Resu->x=Result.x;
  769. //		Resu->y=Result.y;
  770. //		Resu->w=Result.w;
  771. //		Resu->h=Result.h;
  772. //		flag=1;
  773.  
  774. //		Area.X_Start= Result.x - ((Result.w)>>1);
  775. //		Area.X_End  = Result.x + ((Result.w)>>1);
  776. //		Area.Y_Start= Result.y - ((Result.h)>>1);
  777. //		Area.Y_End  = Result.y + ((Result.h)>>1);
  779.  
  780. //		return 1;
  781. //	}
  782. //	else
  783. //	{
  784. //		flag=0;
  785. //		return 0;
  786. //	}
  787.  
  788. //}
  789.  
  790.  
  791.  
  792.  
  793.  
  794.  
  795.  
  796.  
  1. #ifndef __COLORTRACER_H
  2. #define __COLORTRACER_H
  3.  
  4. #include "stm32f10x.h"
  5.  
  6.  
  7. #define IMG_X 0							  //图片x坐标
  8. #define IMG_Y 0               //图片y坐标
  9. #define IMG_W 240             //图片宽度
  10. #define IMG_H 320             //图片高度
  11.  
  12. #define ALLOW_FAIL_PER 3    //容错率
  13. #define ITERATER_NUM   8    //迭代次数
  14.  
  15. typedef struct							//判定为目标的条件
  16. {
  17. 	unsigned char H_MIN;			//目标最小色度
  18. 	unsigned char H_MAX;			//目标最大色度
  19. 	
  20. 	unsigned char S_MIN;			//目标最小饱和度
  21. 	unsigned char S_MAX;			//目标最大饱和度
  22. 	
  23. 	unsigned char L_MIN;			//目标最小亮度
  24. 	unsigned char L_MAX;			//目标最大亮度
  25. 	
  26. 	unsigned int WIDTH_MIN;		//目标最小宽度
  27. 	unsigned int HEIGHT_MIN;	//目标最小高度
  28. 	
  29. 	unsigned int WIDTH_MAX;		//目标最大宽度
  30. 	unsigned int HEIGHT_MAX;	//目标最大高度
  31. }TARGET_CONDITION;
  32.  
  33. typedef struct				//结果
  34. {
  35. 	unsigned int x;			//目标x坐标
  36. 	unsigned int y;			//目标y坐标
  37. 	unsigned int w;			//目标宽度
  38. 	unsigned int h;			//目标高度
  39. }RESULT;
  40.  
  41. extern RESULT result;
  42. extern TARGET_CONDITION condition0;
  43. extern TARGET_CONDITION condition1;
  44. extern TARGET_CONDITION condition2;
  45. extern TARGET_CONDITION condition3;
  46. extern TARGET_CONDITION condition4;
  47. extern TARGET_CONDITION condition5;
  48. extern TARGET_CONDITION condition6;
  49. extern TARGET_CONDITION condition7;
  50. extern TARGET_CONDITION condition8;
  51.  
  52.  
  53. int Trace(const TARGET_CONDITION* condition, RESULT* result_final);
  54.  
  55.  
  56. #endif
  57.  
  58.

四、结语

好用 ,太好用了

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/401501
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号