devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

STM32 OV7725摄像头模块识别颜色物体（1）--HSL二值化和腐蚀中心算法，并用串口输出数据_stm32 摄像头

作者：小丑西瓜9 | 2024-05-02 22:31:06

赞

踩

stm32 摄像头

目录

前言

一、摄像头采集数据流程

二、如何将图像显示到电脑上

 三、图像二值化

1、什么是RGB?

2、RGB565转RGB888

I、RGB565和RGB888的区别

II、代码

3、RGB转HSL

I、什么是HSL

 II、转换公式

 III、代码

3、输出一张摄像头二值化图片

I、原理

II、代码 

四、简单的物体识别

1、原理参考

 2、识别代码

3、显示代码

总结

前言

前阵子用STM32弄摄像头，断断续续有段时间，也在网上翻阅了不少资料，写篇博客记录一下学习过程。最后成功识别单个物体，图形和多个物体暂不支。

一、摄像头采集数据流程

(1) 利用 SIO_C、SIO_D 引脚通过 SCCB 协议向 OV7725 的寄存器写入初始化配置；

(2) 初始化完成后，OV7725 传感器会使用 VGA 时序输出图像数据，它的 VSYNC 会

首先输出帧有效信号（低电平跳变），当外部的控制器（如 STM32）检测到该信号

时，把 WEN 引脚设置为高电平，并且使用 WRST 引脚复位 FIFO 的写指针到 0 地

址；

(3) 随着 OV7725 继续按 VGA 时序输出图像数据，它在传输每行有效数据时， HREF

引脚都会持续输出高电平，由于 WEN 和 HREF 同时为高电平输入至与非门，使得

其连接到 FIFO WE 引脚的输出为低电平，允许向 FIFO 写入数据，所以在这期间，

OV7725 通过它的 PCLK 和 D[0:7]信号线把图像数据存储到 FIFO 中，由于前面复

位了写指针，所以图像数据是从 FIFO 的 0 地址开始记录的；

(4) 各行图像数据持续传输至 FIFO，受 HREF 控制的 WE 引脚确保了写入到 FIFO 中

的都是有效的图像数据，OV7725 输出完一帧数据时，VSYNC 会再次输出帧有效

信号，表示一帧图像已输出完成；

(5) 控制器检测到上述 VSYNC 信号后，可知 FIFO 中已存储好一帧图像数据，这时控

制 WEN 引脚为低电平，使得 FIFO 禁止写入，防止 OV7725 持续输出的下一帧数

据覆盖当前 FIFO 数据；

(6) 控制器使用RRST复位读指针到FIFO的0地址，然后通过FIFO的RCLK和DO[0:7]

引脚，从 0 地址开始把 FIFO 缓存的整帧图像数据读取出来。在这期间，OV7725

是持续输出它采集到的图像数据的，但由于禁止写入 FIFO，这些数据被丢弃了；

(7) 控制器使用 WRST 复位写指针到 FIFO 的 0 地址，然后等待新的 VSYNC 有效信号

到来，检测到后把 WEN 引脚设置为高电平，恢复 OV7725 向 FIFO 的写入权限，

OV7725 输出的新一帧图像数据会被写入到 FIFO 的 0 地址中，重复上述过程。

网上也有很多现成的文章，分享几个链接

摄像头原理：

stm32 OV7670摄像头模块的介绍以及应用（SCCB的使用）_闰土小蒋的博客-CSDN博客

正点原子开发板程序：

http://www.openedv.com/docs/modules/camera/ov7725-fifo.html

二、如何将图像显示到电脑上

使用串口发送数据到电脑，用山外调试助手显示，这里的波特率使用256000，因为调试助手的最大也只能是256000，图像配置，宽：320，高：240，RGB565大端(这个是个大坑)

一副图像的通信协议为：[0x01] [0xFE][…数据…][0xFE] [0x01]

[…数据…] 是图像的数据，一帧图像有多少数据，这里的数据长度就有多少。换句话说， […数据…]与图像的格式，图像的宽高有关。此处的图像数据，都是从上往下，从左往右存储 的。 只有下位机发送的数据与上位机配置的格式的长度相同时，才可正确识别图像格式，从 而正确显示图像。 下位机发送图像时，先发送帧头：0x01,0xFE，接着发送图像数据，最后发送帧尾： 0xFE,0x01 完成一副图像发送。

链接：https://pan.baidu.com/s/1eA3rhtNiocKxtH0rxvyGzg?pwd=0722 
提取码：0722

摄像头采集代码如下：

  1.         OV7725_RRST(0);                //开始复位读指针 
  2.         OV7725_RCK_L;
  3.         OV7725_RCK_H;
  4.         OV7725_RCK_L;
  5.         OV7725_RRST(1);                //复位读指针结束 
  6.         OV7725_RCK_H;
  7.    
  8.         while(USART_GetFlagStatus(UART4, USART_FLAG_TC)==RESET);      //判断是否发送完成。
  9.         USART_SendData(UART4, 0x01);
  10.         while(USART_GetFlagStatus(UART4, USART_FLAG_TC)==RESET);      //判断是否发送完成。
  11.         USART_SendData(UART4, 0xfe);
  12.        
  13.         for(x_size=0;x_size<240;x_size++)
  14.         {
  15.             for(y_size=0;y_size<320;y_size++)
  16.             {
  17.                 OV7725_RCK_L;
  18.                 color=GPIOE->IDR;    //读数据
  19.                 OV7725_RCK_H;
  20.                 colorH=(color>>8) &0xff;
  21.                 OV7725_RCK_L;
  22.                 color=GPIOE->IDR ;    //读数据
  23.                 OV7725_RCK_H; 
  24.                 colorL=(color>>8) &0xff;
  25.                 
  26.                 while(USART_GetFlagStatus(UART4, USART_FLAG_TC)==RESET);      //判断是否发送完成。
  27.                 USART_SendData(UART4, colorH);
  28.                 while(USART_GetFlagStatus(UART4, USART_FLAG_TC)==RESET);      //判断是否发送完成。
  29.                 USART_SendData(UART4, colorL);
  30.             }
  31.         }
  32.  
  33.         while(USART_GetFlagStatus(UART4, USART_FLAG_TC)==RESET);      //判断是否发送完成。
  34.         USART_SendData(UART4, 0xfe);
  35.         while(USART_GetFlagStatus(UART4, USART_FLAG_TC)==RESET);      //判断是否发送完成。
  36.         USART_SendData(UART4, 0x01);

 三、图像二值化

1、什么是RGB?

        RGB是从颜色发光的原理来设计定的，通俗点说它的颜色混合方式就好像有红、绿、蓝三盏灯，当它们的光相互叠合的时候，色彩相混，而亮度却等于两者亮度之总和，越混合亮度越高，即加法混合。

        红、绿、蓝三个颜色通道每种色各分为256阶亮度，在0时“灯”最弱——是关掉的，而在255时“灯”最亮。当三色灰度数值相同时，产生不同灰度值的灰色调，即三色灰度都为0时，是最暗的黑色调；三色灰度都为255时，是最亮的白色调。

        在电脑中，RGB的所谓“多少”就是指亮度，并使用整数来表示。通常情况下，RGB各有256级亮度，用数字表示为从0、1、2...直到255。注意虽然数字最高是255，但0也是数值之一，因此共256级。

2、RGB565转RGB888

I、RGB565和RGB888的区别

在计算机中图像基本是以RGB888格式显示的，24位图每个像素保存了32bit的数据，即RGB888+Alpha，Alpha就是半透明填充字节。对于真彩的图像而言，肉眼在16bit的时候已经难以分辨了，有些时候，可以将RGB888转换为RGB565来存储，减少了存储器的容量的同时，降低了数据量；在显示的时候，再次把RGB565转换为RGB888，实现数据宽度的匹配

RGB888->RGB565

只要提取相应单色高位即可(R5 G6 B5)，但会导致低位的缺失，影响精度，而且无法恢复

RGB565->RGB888

填充相应单色低位即可

II、代码

  1. typedef struct 					//RGB888
  2. {
  3. 	unsigned char Red;			//红色，[0,255]
  4. 	unsigned char Green;        //绿色，[0,255]
  5. 	unsigned char Blue;         //蓝色，[0,255]
  6. }COLOR_RGB;
  7.  
  8. void RGB565_To_RGB888(u16 rgb,COLOR_RGB *color_rgb)
  9. {
  10. 	color_rgb->Red 	    = (unsigned char)( ( rgb & 0xF800 ) >> 8 );
  11. 	color_rgb->Green    = (unsigned char)( ( rgb & 0x07E0 ) >> 3 );
  12. 	color_rgb->Blue 	= (unsigned char)( ( rgb & 0x001F ) << 3 );	
  13. }

3、RGB转HSL

I、什么是HSL

 HSL的H(hue)分量，代表的是人眼所能感知的颜色范围，这些颜色分布在一个平面的色相环上，取值范围是0°到360°的圆心角，每个角度可以代表一种颜色。色相值的意义在于，我们可以在不改变光感的情况下，通过旋转色相环来改变颜色。在实际应用中，我们需要记住色相环上的六大主色，用作基本参照：360°/0°红、60°黄、120°绿、180°青、240°蓝、300°洋红，它们在色相环上按照60°圆心角的间隔排列

HSL的S(saturation)分量，指的是色彩的饱和度，它用0%至100%的值描述了相同色相、明度下色彩纯度的变化。数值越大，颜色中的灰色越少，颜色越鲜艳，呈现一种从灰度到纯色的变化。

HSL的L(lightness)分量，指的是色彩的明度，作用是控制色彩的明暗变化。它同样使用了0%至100%的取值范围。数值越小，色彩越暗，越接近于黑色；数值越大，色彩越亮，越接近于白色。

 II、转换公式

 III、代码

  1. typedef struct					//HLS颜色
  2. {
  3. 	unsigned char Hue;			//色度，[0,240]				
  4. 	unsigned char Lightness;	//亮度，[0,240]	     
  5. 	unsigned char Saturation;	//饱和度，[0,240]	     
  6. }COLOR_HLS;
  7.  
  8. #define maxOf3Values( v1, v2, v3 )			( (v1>v2) ? ( (v1>v3) ? (v1) : (v3) ) : ( (v2>v3) ? (v2) : (v3) ) ) //取rgb中的最大值
  9. #define minOf3Values( v1, v2, v3 )			( (v1<v2) ? ( (v1<v3) ? (v1) : (v3) ) : ( (v2<v3) ? (v2) : (v3) ) ) //取rgb中的最小值
  10.  
  11.  
  12. void RGB888_TO_HSL(COLOR_RGB* color_rgb, COLOR_HLS* color_hls)
  13. {
  14. 	unsigned char r, g, b;
  15. 	unsigned char h, l, s;
  16. 	unsigned char max, min, dif;
  17. 	
  18. 	r = color_rgb->Red;
  19. 	g = color_rgb->Green;
  20. 	b = color_rgb->Blue;
  21. 	
  22. 	max = maxOf3Values( r, g, b );  //取rgb中的最大值
  23. 	min = minOf3Values( r, g, b );  //取rgb中的最小值
  24. 	dif = max - min;                //计算最大值和最小值的差值
  25.     
  26. 	//计算l，亮度
  27. 	l = ( max + min ) * 240 / 255 / 2;
  28. 	//计算h，色度
  29. 	if( max == min )//无定义 RGB一样  黑灰白
  30. 	{
  31. 		s = 0;//饱和度0
  32. 		h = 0;//色度0
  33. 	}
  34. 	else
  35. 	{
  36. 		/*计算色度h*/
  37. 		if( max == r )      //如果R值最大
  38. 		{
  39. 			if( g >= b )    //h介于0到40
  40. 			{
  41. 				h = 40 * ( g - b ) / dif;
  42. 			}
  43. 			else if( g < b )//h介于200到240
  44. 			{
  45. 				h = 40 * ( g - b ) / dif + 240;
  46. 			}
  47. 		}
  48. 		else if( max == g )
  49. 		{
  50. 			h = 40 * ( b - r ) / dif + 80;
  51. 		}
  52. 		else if( max == b )
  53. 		{
  54. 			h = 40 * ( r - g ) / dif + 160;
  55. 		}
  56. 		/*计算饱和度s*/
  57. 		if( l == 0 )
  58. 		{
  59. 			s = 0;
  60. 		}
  61. 		else if( l <= 120 )      /* 0<l<=1/2 */
  62. 		{
  63. 			s = dif * 240 / ( max + min );                  
  64. 		}
  65. 		else                    /* l>1/2 */
  66. 		{
  67. 			s = dif * 240 / ( 480 - ( max + min ) );        
  68. 		}		 
  69. 	}   
  70.     color_hls->Hue = h;				//色度
  71. 	color_hls->Lightness = l;		//亮度
  72. 	color_hls->Saturation = s;		//饱和度
  73. }

3、输出一张摄像头二值化图片

I、原理

摄像头采集到的每个像素点，先由RGB格式转换成HSL格式，再与定义阈值进行对比，判断颜色是否和定义颜色匹配

II、代码 

  1. typedef struct					//判定为目标的条件
  2. {
  3. 	unsigned char H_MIN;		//目标最小色度
  4. 	unsigned char H_MAX;		//目标最大色度
  5. 	
  6. 	unsigned char S_MIN;		//目标最小饱和度
  7. 	unsigned char S_MAX;		//目标最大饱和度
  8. 	
  9. 	unsigned char L_MIN;		//目标最小亮度
  10. 	unsigned char L_MAX;		//目标最大亮度
  11. 	
  12. 	unsigned short WIDTH_MIN;	//目标最小宽度
  13. 	unsigned short HEIGHT_MIN;	//目标最小高度
  14. 	
  15. 	unsigned short WIDTH_MAX;   //目标最大宽度
  16. 	unsigned short HEIGHT_MAX;	//目标最大高度
  17. }TARGET_CONDITION;
  18.  
  19. int ColorMatch(const COLOR_HLS* color_hls, const TARGET_CONDITION* condition )
  20. {
  21. 	if(	color_hls->Lightness >= condition->L_MIN && color_hls->Lightness <= condition->L_MAX &&
  22. 		color_hls->Saturation >= condition->S_MIN && color_hls->Saturation <= condition->S_MAX )   //比较饱和度和亮度
  23.     {      
  24.         if( color_hls->Hue >= condition->H_MIN && color_hls->Hue <= condition->H_MAX )   //颜色在范围内
  25.         {   
  26.             return 1;
  27.         }       
  28.         else if( condition->H_MAX < condition->H_MIN )  //设定的最大颜色小于最小颜色 说明有向下溢出 可能需要和高位颜色匹配            
  29.         {
  30.             /*0——有效——最大值——无效——最小值——有效——240*/
  31.             if( color_hls->Hue <= condition->H_MAX )     //小于最大值
  32.                 return 1;
  33.             if( color_hls->Hue >= condition->H_MIN )     //大于最小值
  34.                 return 1;
  35.         } 
  36.     }
  37. 	return 0;
  38. }

判断颜色是否和定义颜色匹配。

输入变量，color_hls：COLOR_HLS结构体，存储HLS格式颜色数据； 

                 condition ：TARGET_CONDITION结构体，存放希望的颜色数据阈值。

返回数据，1：像素点颜色在目标范围内；0：像素点颜色不在目标范围内。

  1. u8 Bmp_Minimize_SDRAM[240][40];  /*用于存放二值化后像素点数据，Bmp_Minimize_SDRAM[X][Y]*/
  2.  
  3. TARGET_CONDITION condition0={
  4. 	40,		  //目标最小色度，H_MIN
  5. 	80,       //目标最大色度，H_MAX
  6. 	           
  7. 	0,        //目标最小饱和度，S_MIN
  8. 	240,       //目标最大饱和度，S_MAX
  9. 	           
  10. 	0,        //目标最小亮度，L_MIN
  11. 	240,       //目标最大亮度，L_MAX
  12. 	           
  13. 	40,        //目标最小宽度，WIDTH_MIN
  14. 	40,        //目标最小高度，HEIGHT_MIN
  15. 	           
  16. 	240,       //目标最大宽度，WIDTH_MAX
  17. 	320        //目标最大高度，HEIGHT_MAX
  18. };
  19.  
  20. for(x_size=0;x_size<240;x_size++)   //此种方式可以兼容任何彩屏,但是速度很慢
  21. {
  22.     for(y_size=0;y_size<320;y_size++)
  23.     {
  24.         OV7725_RCK_L;
  25.         color=GPIOE->IDR;	//读数据
  26.         OV7725_RCK_H;
  27.         colorH=(color>>8) &0xff;
  28.         OV7725_RCK_L;
  29.         color=GPIOE->IDR ;	//读数据
  30.         OV7725_RCK_H; 
  31.         colorL=(color>>8) &0xff;
  32.         
  33.         color=(colorH<<8)|colorL;
  34.  
  35.         RGB565_TO_HSL(color,&hls_value);        /*RGB565转换为HLS*/
  36.         
  37.         if(y_size%8==0)
  38.         {
  39.             Bmp_Minimize_SDRAM[x_size][y_size/8]=color_buffer;      /*二值化后的数据，存入缓存*/
  40.         }
  41.         color_buffer<<=1;
  42.         color_buffer|=ColorMatch(&hls_value,&condition0);
  43.     }
  44. }

摄像头采集数据二值化，由于STM32F1内存有限，存放不了一帧320*240的彩色图像，故将处理好后的数据存入数组

  1. while(USART_GetFlagStatus(UART4, USART_FLAG_TC)==RESET);      //判断是否发送完成。
  2. USART_SendData(UART4, 0x01);
  3. while(USART_GetFlagStatus(UART4, USART_FLAG_TC)==RESET);      //判断是否发送完成。
  4. USART_SendData(UART4, 0xfe);
  5. for(y_size=0;y_size<240;y_size++)     /*数组数据串口打印到电脑*/
  6. {
  7.     for(x_size=0;x_size<40;x_size++)
  8.     {
  9.         color=Bmp_Minimize_SDRAM[y_size][x_size+1];
  10.         for(color_buffer=0;color_buffer<8;color_buffer++)
  11.         {
  12.             if((color<<color_buffer) &0x80)
  13.             {
  14.                 while(USART_GetFlagStatus(UART4, USART_FLAG_TC)==RESET);      //判断是否发送完成。
  15.                 USART_SendData(UART4, 0xff);
  16.                 while(USART_GetFlagStatus(UART4, USART_FLAG_TC)==RESET);      //判断是否发送完成。
  17.                 USART_SendData(UART4, 0xff);
  18.             }
  19.             else
  20.             {
  21.                 while(USART_GetFlagStatus(UART4, USART_FLAG_TC)==RESET);      //判断是否发送完成。
  22.                 USART_SendData(UART4, 0x00);
  23.                 while(USART_GetFlagStatus(UART4, USART_FLAG_TC)==RESET);      //判断是否发送完成。
  24.                 USART_SendData(UART4, 0x00);                        
  25.             }
  26.         }
  27.     }
  28. }
  29. while(USART_GetFlagStatus(UART4, USART_FLAG_TC)==RESET);      //判断是否发送完成。
  30. USART_SendData(UART4, 0xfe);
  31. while(USART_GetFlagStatus(UART4, USART_FLAG_TC)==RESET);      //判断是否发送完成。
  32. USART_SendData(UART4, 0x01);

将存放在缓存中的二值化数据，通过简单位操作输出到调试助手

四、简单的物体识别

1、原理参考

首先遍历寻找腐蚀中心，然后在之前腐蚀中心点处进行迭代向外寻找新的腐蚀中心。腐蚀算法从该点开始分别向上下左右四个方向进行读点，若点的颜色符合条件则往外读，等四个方向都结束后得到四个边缘点的坐标，记左边缘点的x轴坐标为left，右边缘点的x轴坐标为right，上边缘点的y轴坐标为up，下边缘点的y轴坐标为bottom，那么坐标( (right-left)/2 , (up-bottom)/2 ) 即为新的腐蚀中心。当确定4个点通过，泽围绕4个点画框，将色块识别区域框起来。

2、腐蚀中心算法（如下图详解）
一个40/3=13 1313大小的色块为单位进行识别
每次只读取这色块的以y的2/1 为点（也就是这个1313色块y轴为中心点） x轴向右开始查询识别颜色 如识别失败个数大于6次 则认为这一个1313的色块无效 跳出循环 继续查询下一个1313的色块。

如果失败次数少于6次则改变查询方向 查询这色块的以X/2 为点 对y轴进行查询方法同上 ，如果y轴有6次失败则，退出循环不认同这个色块合格（因为太小了，失败次数又多），但如果少于六次失败，则认为这个色块识别成功 并记录下这个色块的中心点，这就是腐蚀中心 /。

 

 

 2、识别代码

  1. extern u8 Bmp_Minimize_SDRAM[240][40];
  2.  
  3. static uint8_t ReadColor( uint16_t usX, uint16_t usY)
  4. {
  5.     uint8_t color_value;
  6.     usY=usY/8;
  7.     color_value=Bmp_Minimize_SDRAM[usX][usY];
  8.     usY=usY%8;
  9.     return (color_value>>usY)&0x01;
  10. }
  11.  
  12. #define IMG_X 0				//图片x坐标
  13. #define IMG_Y 0             //图片y坐标
  14. #define IMG_W 240           //图片宽度
  15. #define IMG_H 320           //图片高度
  16.  
  17. #define ALLOW_FAIL_PER 10    //容错率
  18. #define ITERATER_NUM   8   //迭代次数
  19.  
  20. /**
  21.  * @brief  寻找腐蚀中心
  22.  * @param  x ：腐蚀中心x坐标
  23.  * @param  y ：腐蚀中心y坐标
  24.  * @param  condition ：TARGET_CONDITION结构体，存放希望的颜色数据阈值
  25.  * @param  area ：SEARCH_AREA结构体，查找腐蚀中心的区域
  26.  * @retval 1：找到了腐蚀中心，x、y为腐蚀中心的坐标；0：没有找到腐蚀中心。
  27.  */
  28. static int SearchCenter(unsigned short* x, unsigned short* y, const TARGET_CONDITION* condition, SEARCH_AREA* area )
  29. {
  30. 	unsigned short i, j, k;
  31. 	unsigned short FailCount=0;
  32. 	unsigned short SpaceX, SpaceY;
  33. 	
  34. 	SpaceX = condition->WIDTH_MIN / 3;      //以最小宽度除以3 为 横向查询的步进的一个单位
  35. 	SpaceY = condition->HEIGHT_MIN / 3;     //以最小高度除以3 为 垂直查询的步进的一个单位
  36. 	
  37.     /*横向步进单位+垂直步进单位 组成了一个矩形的色块*/
  38. 	for(i=area->Y_Start; i<area->Y_End; i+=SpaceY)
  39. 	{
  40. 		for(j=area->X_Start; j<area->X_End; j+=SpaceX)
  41. 		{
  42. 			FailCount = 0;      //失败次数初始化
  43. 			for(k=0; k<SpaceX+SpaceY; k++)
  44. 			{
  45. 				if(k<SpaceX)    //查询色块中间一横的颜色
  46.                 {   
  47.                     if(ReadColor(j+k, i+SpaceY/2)==0)
  48.                     {
  49.                        FailCount++;     //颜色不匹配 失败计数+1 
  50.                     }
  51.                 }
  52. 				else            //查询色块中间一竖的颜色     
  53.                 {
  54. 					if(ReadColor( j+SpaceX/2, i+k-SpaceX)==0)
  55.                     {
  56.                         FailCount++;    //颜色不匹配 失败计数+1
  57.                     }
  58. 				}
  59. 					
  60. 				if(FailCount>( (SpaceX+SpaceY) / ALLOW_FAIL_PER ))     //失败计数大于 色块需要查询的总点数/容错率
  61. 					break;  //失败次数太多 退出
  62. 			}
  63. 			
  64. 			if(k == SpaceX+SpaceY)  //k坚持到查询完毕，说明基本匹配
  65. 			{
  66.                 /*记录该色块的中心点为腐蚀中心*/
  67. 				*x = j + SpaceX / 2;
  68. 				*y = i + SpaceY / 2;
  69. 				return 1;   //记录到第一个腐蚀中心后退出函数
  70. 			}
  71. 		}	
  72. 	}
  73. 	return 0;	
  74. }
  75.  
  76.  
  77. /**
  78.  * @brief  从腐蚀中心向外腐蚀，得到新的腐蚀中心
  79.  * @param  oldX ：先前的腐蚀中心x坐标
  80.  * @param  oldX ：先前的腐蚀中心y坐标
  81.  * @param  condition ：TARGET_CONDITION结构体，存放希望的颜色数据阈值
  82.  * @param  result ：RESULT结构体，存放检测结果
  83.  * @retval 1：检测成功；0：检测失败。
  84.  */
  85. static int Corrode(unsigned short oldX, unsigned short oldY, const TARGET_CONDITION* condition, RESULT* result )
  86. {
  87. 	unsigned short Xmin, Xmax, Ymin, Ymax;
  88. 	unsigned short i;
  89. 	unsigned short FailCount=0;
  90. 	for(i=oldX; i>IMG_X; i--)           //从中心点查到x最左侧
  91. 	{
  92. 		if(!ReadColor(i, oldY))
  93. 			FailCount++;    //不匹配计数自加1
  94.         if( FailCount> ((condition->WIDTH_MIN)/ALLOW_FAIL_PER) | i<=0)//当识别失败点大于最小宽度/2是跳出  
  95. 			break;
  96. 	}
  97. 	Xmin=i;     //更新X轴最小坐标值
  98.     
  99. 	FailCount=0;    //清空错误次数
  100. 	for(i=oldX; i<IMG_X+IMG_W; i++)     //从中心点查到x最右侧
  101. 	{
  102. 		if(!ReadColor(i, oldY))
  103. 			FailCount++;    //不匹配计数自加1
  104.  
  105.         if( FailCount> ((condition->WIDTH_MIN)/ALLOW_FAIL_PER) | i>=240)
  106. 			break;
  107. 	}
  108. 	Xmax=i;     //更新X轴最大坐标值
  109.  
  110. 	FailCount=0;    //清空错误次数
  111. 	for(i=oldY; i>IMG_Y; i--)           //从中心点查到y最上侧
  112. 	{
  113. 		if(!ReadColor(oldX, i)) 
  114. 			FailCount++;    //不匹配计数自加1
  115.  
  116.         if( FailCount> ((condition->HEIGHT_MIN)/ALLOW_FAIL_PER) | i<=0)
  117. 			break;
  118. 	}
  119. 	Ymin=i;     //更新Y轴最小坐标值
  120.  
  121. 	FailCount=0;    //清空错误次数
  122. 	for(i=oldY; i<IMG_Y+IMG_H; i++)     //从中心点查到y最下侧
  123. 	{
  124. 		if(!ReadColor(oldX, i))
  125. 			FailCount++;
  126.  
  127.         if( FailCount> ((condition->HEIGHT_MIN)/ALLOW_FAIL_PER)| i>=320)
  128. 			break;
  129. 	}
  130. 	Ymax=i;     //更新Y轴最大坐标值
  131. 	
  132.     FailCount=0;    //清空错误次数
  133.  
  134.     //获得腐蚀区域的中点和xy范围
  135.     result->x = (Xmin + Xmax) / 2;
  136.     result->y = (Ymin + Ymax) / 2;
  137.     result->w = (Xmax - Xmin);
  138.     result->h = (Ymax - Ymin);
  139.     
  140. 	if( (result->w >= condition->WIDTH_MIN)  && (result->w <= condition->WIDTH_MAX) &&
  141.         (result->h >= condition->HEIGHT_MIN) && (result->h <= condition->HEIGHT_MAX) )
  142.         {
  143.                return 1;   //如果腐蚀后的区域没有超过最大限定区域且没有小于最小限定区域 有效！！ 
  144.         }
  145. 	return 0;
  146. }
  147.  
  148. /**
  149.  * @brief  用户将识别条件写入Condition指向的结构体中，该函数将返回目标的x，y坐标和长宽
  150.  * @param  condition ：TARGET_CONDITION结构体，存放希望的颜色数据阈值
  151.  * @param  result ：RESULT结构体，存放检测结果
  152.  * @retval 1：检测成功；0：检测失败。
  153.  */
  154. int Trace(const TARGET_CONDITION* condition, RESULT* result_final)
  155. {
  156. 	unsigned char i;
  157. 	static unsigned short x0, y0;
  158.     static unsigned char Flag=0;
  159. 	static SEARCH_AREA area = {IMG_X, IMG_X+IMG_W, IMG_Y, IMG_Y+IMG_H};//搜索区域
  160. 	RESULT result;      //RESULT识别结果
  161.     
  162.     if(Flag==0)     //如果首次使用或上一次腐蚀失败
  163.     {
  164.         if(SearchCenter(&x0, &y0, condition, &area))    //搜索腐蚀中心并返回给x0，y0，如果成功搜索到，那么flag置1
  165.         {
  166.             Flag = 1;
  167.         }
  168.         else        //如果还没腐蚀成功，那么把腐蚀区域再次扩大到整个图像范围内进行腐蚀
  169.         {
  170.             area.X_Start = IMG_X;
  171.             area.X_End   = IMG_X+IMG_W;
  172.             area.Y_Start = IMG_Y;
  173.             area.Y_End   = IMG_Y+IMG_H;
  174.             
  175.             if(SearchCenter(&x0, &y0, condition, &area))    //如果整个范围腐蚀成功，那么flag置1
  176.             {
  177.                 Flag = 1;
  178.                 return 1;
  179.             }
  180.             else
  181.             {
  182. 				Flag = 0;
  183. 				return 0;               
  184.             }
  185.         }      
  186.     }
  187.     
  188. 	//找到腐蚀中心 得到中点
  189. 	result.x = x0;      //如果flag!=0，说明上一次有腐蚀中心结果，所以直接使用上一次结果腐蚀即可，而不需要再次遍历图像搜索腐蚀中心
  190. 	result.y = y0;      //上一次的腐蚀中心赋值给这次的oldx，oldy
  191.     for(i=0; i<ITERATER_NUM; i++)   //进行腐蚀迭代计算
  192.     {
  193.         Corrode(result.x, result.y, condition, &result);
  194.     }
  195.     
  196.     if(Corrode(result.x, result.y, condition, &result))     //从腐蚀中心向外腐蚀成功
  197.     {
  198.         //更新腐蚀中心，以便下次使用
  199. 		x0 = result.x;      
  200. 		y0 = result.y;
  201.         
  202.         //更新/返回结果值
  203. 		result_final->x = result.x;
  204. 		result_final->y = result.y;
  205. 		result_final->w = result.w;
  206. 		result_final->h = result.h;
  207.         Flag=1;
  208.         
  209.         //缩小下次搜索腐蚀中心图像范围
  210. 		area.X_Start = result.x - ((result.w)>>1);
  211. 		area.X_End   = result.x + ((result.w)>>1);
  212. 		area.Y_Start = result.y - ((result.h)>>1);
  213. 		area.Y_End   = result.y + ((result.h)>>1);
  214.         return 1;
  215. 	}
  216.     else    //如果腐蚀失败，那么标志位flag置0，返回失败值0
  217.     {
  218.         Flag=0;
  219.         return 0;
  220.     }
  221. }

代码有点多，都有写注释哈，就不一一讲解了

3、显示代码

  1. void GUI_DrawPoint(u16 x,u16 y)
  2. {
  3.     u8 color_value=0x80;
  4.     color_value>>=y%8;
  5.     Bmp_Minimize_SDRAM[x][y/8]|=color_value;
  6. }
  7.  
  8. void GUI_DrawLine(u16 x1, u16 y1, u16 x2, u16 y2)
  9. {
  10. 	u16 t; 
  11. 	int xerr=0,yerr=0,delta_x,delta_y,distance; 
  12. 	int incx,incy,uRow,uCol; 
  13.  
  14. 	delta_x=x2-x1; //计算坐标增量 
  15. 	delta_y=y2-y1; 
  16. 	uRow=x1; 
  17. 	uCol=y1; 
  18. 	if(delta_x>0)incx=1; //设置单步方向 
  19. 	else if(delta_x==0)incx=0;//垂直线 
  20. 	else {incx=-1;delta_x=-delta_x;} 
  21. 	if(delta_y>0)incy=1; 
  22. 	else if(delta_y==0)incy=0;//水平线 
  23. 	else{incy=-1;delta_y=-delta_y;} 
  24. 	if( delta_x>delta_y)distance=delta_x; //选取基本增量坐标轴 
  25. 	else distance=delta_y; 
  26. 	for(t=0;t<=distance+1;t++ )//画线输出 
  27. 	{  
  28. 		GUI_DrawPoint(uRow,uCol);//画点 
  29. 		xerr+=delta_x ; 
  30. 		yerr+=delta_y ; 
  31. 		if(xerr>distance) 
  32. 		{ 
  33. 			xerr-=distance; 
  34. 			uRow+=incx; 
  35. 		} 
  36. 		if(yerr>distance) 
  37. 		{ 
  38. 			yerr-=distance; 
  39. 			uCol+=incy; 
  40. 		} 
  41. 	}  
  42. } 
  43.  
  44. void GUI_DrawRectangle(u16 x1, u16 y1, u16 x2, u16 y2)
  45. {
  46. 	GUI_DrawLine(x1,y1,x2,y1);
  47. 	GUI_DrawLine(x1,y1,x1,y2);
  48. 	GUI_DrawLine(x1,y2,x2,y2);
  49. 	GUI_DrawLine(x2,y1,x2,y2);
  50. }

在二值化数据中画矩形

  1. if(Trace(&condition0, &result))
  2. {
  3.     for(y_size=0;y_size<240;y_size++)     /*检测到物体，清空二值化数据*/
  4.     {
  5.         for(x_size=0;x_size<40;x_size++)
  6.         {
  7.             Bmp_Minimize_SDRAM[y_size][x_size]=0;
  8.         }
  9.     }
  10.     /*画矩形，和中心点*/
  11.     GUI_DrawRectangle ( result.x-result.w/2, result.y-result.h/2, result.x+result.w/2, result.y+result.h/2);
  12.     GUI_DrawLine(result.x-10,result.y,result.x+10,result.y);
  13.     GUI_DrawLine(result.x,result.y-10,result.x,result.y+10);
  14. }

识别物体满足颜色和大小的判断条件，更新二值化数组，用矩形框出物体，并标出中心点 

总结

第一次写博客，有诸多不足，望多包涵，后续会更新多物体识别和图形识别。

END...

参考文章

stm32 OV7670/摄像头模块颜色区域定位（腐蚀中心算法）_摄像头模块颜色识别_闰土小蒋的博客-CSDN博客

识别车牌-识别颜色-基于stm32f4 ov7670（无晶振，无fifo，ov7725，ov2640类似可用）_stm32f4 ov7670颜色识别_qq斯国一的博客-CSDN博客

STM32+ov7725图像识别（HSL原理）_stm32图像识别_大桶矿泉水的博客-CSDN博客

《STM32》EasyTrace物体追踪 源代码个人注释+完整例程 - 知乎

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

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

  

闽ICP备14008679号