根据论文试试自动对焦-----草稿

已于 2022-09-09 09:44:12 修改
阅读量785 收藏 6
点赞数 3
分类专栏： Image Deblur 文章标签： 图像预处理
于 2018-07-30 19:05:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wd1603926823/article/details/81290381
版权

要从一个视野的不同高度拍的一组图片中选出最清晰的一张，看了论文《基于边缘特征的光学图像清晰度判定》，试了下，好像比之前的效果好。

int AutoFocus::gradientdimg(Mat &grayimg)
{
	if(!grayimg.data)
	{
		cout<<"error:invalid image..."<<endl;
		return -1;
	}

	for(int r=0;r!=mysize_.height-2;r++)
	{
		for(int c=0;c!=mysize_.width-2;c++)
		{
			gradient_dimg.ptr<float>(r)[c]=sqrt(
					( (int(grayimg.ptr<uchar>(r)[c])-int(grayimg.ptr<uchar>(r)[c+2])) * (int(grayimg.ptr<uchar>(r)[c])-int(grayimg.ptr<uchar>(r)[c+2])) )
					+ ( (int(grayimg.ptr<uchar>(r)[c])-int(grayimg.ptr<uchar>(r+2)[c])) * (int(grayimg.ptr<uchar>(r)[c])-int(grayimg.ptr<uchar>(r+2)[c])))
					);
		}
	}

	return 0;
}
int AutoFocus::directiongradient()
{
	float direction_s[4]={0};
	float d1=0,d2=0,d3=0,d4=0,m1=0,m3=0;
	int gray_divide=0;
	int edges=0;
	int clears=0;

	float m1sum=0,m3sum=0,gray_dividesum=0;
	for(int r=3;r<mysize_.height-3;r+=10)
	{
		for(int c=3;c<mysize_.width-3;c+=10)
		{

			//angle :0
			direction_s[0]=gradient_dimg.ptr<float>(r)[c]+gradient_dimg.ptr<float>(r)[c-1]+gradient_dimg.ptr<float>(r)[c-2]+
					gradient_dimg.ptr<float>(r)[c+1]+gradient_dimg.ptr<float>(r)[c+2];
			//angle:45
			direction_s[1]=gradient_dimg.ptr<float>(r)[c]+gradient_dimg.ptr<float>(r-1)[c+1]+gradient_dimg.ptr<float>(r-2)[c+2]+
								gradient_dimg.ptr<float>(r+1)[c-1]+gradient_dimg.ptr<float>(r+2)[c-2];
			//angle:90
			direction_s[2]=gradient_dimg.ptr<float>(r)[c]+gradient_dimg.ptr<float>(r-1)[c]+gradient_dimg.ptr<float>(r-2)[c]+
								gradient_dimg.ptr<float>(r+1)[c]+gradient_dimg.ptr<float>(r+2)[c];
			//angle:135
			direction_s[3]=gradient_dimg.ptr<float>(r)[c]+gradient_dimg.ptr<float>(r-1)[c-1]+gradient_dimg.ptr<float>(r-2)[c-2]+
								gradient_dimg.ptr<float>(r+1)[c+1]+gradient_dimg.ptr<float>(r+2)[c+2];


			//最大梯度边缘　以及法向量方向
			//angle 0
			if(direction_s[0]>direction_s[1] && direction_s[0]>direction_s[2] && direction_s[0]>direction_s[3])
			{
				uchar gray_max=srcimg_gray_.ptr<uchar>(r-3)[c];
				uchar gray_min=srcimg_gray_.ptr<uchar>(r-3)[c];
				for(short num=1;num<7;num++)
				{
					uchar gray_current=srcimg_gray_.ptr<uchar>(r-3+num)[c];
					if(gray_max<gray_current)
					{
						gray_max=gray_current;
					}
					if(gray_min>gray_current)
					{
						gray_min=gray_current;
					}
				}
				gray_divide=int(gray_max-gray_min);

				//if this is the true edge
				if(gray_divide>gray_thresh)
				{
					++edges;

					//judge if the true edge is clear or not...
					d1=abs(srcimg_gray_.ptr<uchar>(r-1)[c]-srcimg_gray_.ptr<uchar>(r-2)[c]);
					d2=abs(srcimg_gray_.ptr<uchar>(r)[c]-srcimg_gray_.ptr<uchar>(r-1)[c]);
					d3=abs(srcimg_gray_.ptr<uchar>(r+1)[c]-srcimg_gray_.ptr<uchar>(r)[c]);
					d4=abs(srcimg_gray_.ptr<uchar>(r+2)[c]-srcimg_gray_.ptr<uchar>(r+1)[c]);
					m1=std::max(std::max(d1,d2),std::max(d3,d4))/2/gray_divide;
					m3=std::max(d1+d2+d3,d2+d3+d4)/2/gray_divide;

					if(m1>m1_thresh && m3>m3_thresh)
					{
						//it is clear
						++clears;
					}
				}
			}

			//angle 90
			if(direction_s[2]>direction_s[0] && direction_s[2]>direction_s[1] && direction_s[2]>direction_s[3])
			{
				uchar gray_max=srcimg_gray_.ptr<uchar>(r)[c-3];
				uchar gray_min=srcimg_gray_.ptr<uchar>(r)[c-3];
				for(short num=1;num<7;num++)
				{
					uchar gray_current=srcimg_gray_.ptr<uchar>(r)[c-3+num];
					if(gray_max<gray_current)
					{
						gray_max=gray_current;
					}
					if(gray_min>gray_current)
					{
						gray_min=gray_current;
					}
				}
				gray_divide=int(gray_max-gray_min);

				//if this is the true edge
				if(gray_divide>gray_thresh)
				{
					++edges;

					//judge if the true edge is clear or not...
					d1=abs(srcimg_gray_.ptr<uchar>(r)[c-1]-srcimg_gray_.ptr<uchar>(r)[c-2]);
					d2=abs(srcimg_gray_.ptr<uchar>(r)[c]-srcimg_gray_.ptr<uchar>(r)[c-1]);
					d3=abs(srcimg_gray_.ptr<uchar>(r)[c+1]-srcimg_gray_.ptr<uchar>(r)[c]);
					d4=abs(srcimg_gray_.ptr<uchar>(r)[c+2]-srcimg_gray_.ptr<uchar>(r)[c+1]);
					m1=std::max(std::max(d1,d2),std::max(d3,d4))/2/gray_divide;
					m3=std::max(d1+d2+d3,d2+d3+d4)/2/gray_divide;

					if(m1>m1_thresh && m3>m3_thresh)
					{
						//it is clear
						++clears;
					}
				}
			}

			//angle 45
			if(direction_s[1]>direction_s[0] && direction_s[1]>direction_s[2] && direction_s[1]>direction_s[3])
			{
				uchar gray_max=srcimg_gray_.ptr<uchar>(r-3)[c-3];
				uchar gray_min=srcimg_gray_.ptr<uchar>(r-3)[c-3];
				for(short num=1;num<7;num++)
				{
					uchar gray_current=srcimg_gray_.ptr<uchar>(r-3+num)[c-3+num];
					if(gray_max<gray_current)
					{
						gray_max=gray_current;
					}
					if(gray_min>gray_current)
					{
						gray_min=gray_current;
					}
				}
				gray_divide=int(gray_max-gray_min);

				//if this is the true edge
				if(gray_divide>gray_thresh)
				{
					++edges;

					//judge if the true edge is clear or not...
					d1=abs(srcimg_gray_.ptr<uchar>(r-1)[c-1]-srcimg_gray_.ptr<uchar>(r-2)[c-2]);
					d2=abs(srcimg_gray_.ptr<uchar>(r)[c]-srcimg_gray_.ptr<uchar>(r-1)[c-1]);
					d3=abs(srcimg_gray_.ptr<uchar>(r+1)[c+1]-srcimg_gray_.ptr<uchar>(r)[c]);
					d4=abs(srcimg_gray_.ptr<uchar>(r+2)[c+2]-srcimg_gray_.ptr<uchar>(r+1)[c+1]);
					m1=std::max(std::max(d1,d2),std::max(d3,d4))/2/gray_divide;
					m3=std::max(d1+d2+d3,d2+d3+d4)/2/gray_divide;

					if(m1>m1_thresh && m3>m3_thresh)
					{
						//it is clear
						++clears;
					}
				}
			}

			//angle 135
			if(direction_s[3]>direction_s[0] && direction_s[3]>direction_s[2] && direction_s[3]>direction_s[1])
			{
				uchar gray_max=srcimg_gray_.ptr<uchar>(r+3)[c-3];
				uchar gray_min=srcimg_gray_.ptr<uchar>(r+3)[c-3];
				for(short num=1;num<7;num++)
				{
					uchar gray_current=srcimg_gray_.ptr<uchar>(r+3-num)[c-3+num];
					if(gray_max<gray_current)
					{
						gray_max=gray_current;
					}
					if(gray_min>gray_current)
					{
						gray_min=gray_current;
					}
				}
				gray_divide=int(gray_max-gray_min);

				//if this is the true edge
				if(gray_divide>gray_thresh)
				{
					++edges;

					//judge if the true edge is clear or not...
					d1=abs(srcimg_gray_.ptr<uchar>(r+1)[c-1]-srcimg_gray_.ptr<uchar>(r+2)[c-2]);
					d2=abs(srcimg_gray_.ptr<uchar>(r)[c]-srcimg_gray_.ptr<uchar>(r+1)[c-1]);
					d3=abs(srcimg_gray_.ptr<uchar>(r-1)[c+1]-srcimg_gray_.ptr<uchar>(r)[c]);
					d4=abs(srcimg_gray_.ptr<uchar>(r-2)[c+2]-srcimg_gray_.ptr<uchar>(r-1)[c+1]);
					m1=std::max(std::max(d1,d2),std::max(d3,d4))/2/gray_divide;
					m3=std::max(d1+d2+d3,d2+d3+d4)/2/gray_divide;

					if(m1>m1_thresh && m3>m3_thresh)
					{
						//it is clear
						++clears;
					}
				}
			}


			m1sum+=m1;

		}
	}

	float average_m1=m1sum/edges;
	float clear_ratio=float(clears)/edges;
	standard_value[0]=clear_ratio;
	standard_value[1]=average_m1;

	return 0;
}

int AutoFocus::judgeMaxLaplace(bool down_up)
{
	float maxLaplace,sec_max;
	int max_ind,sec_ind;

	if(imgs_clear_one_view_[0]>=imgs_clear_one_view_[1])
	{
		maxLaplace=imgs_clear_one_view_[0];
		max_ind=0;
		sec_max=imgs_clear_one_view_[1];
		sec_ind=1;
	}
	else
	{
		maxLaplace=imgs_clear_one_view_[1];
		max_ind=1;
		sec_max=imgs_clear_one_view_[0];
		sec_ind=0;
	}

	bool useless_max=false;
	for (int j = 2; j != cImgsNumber1View_; j++)
	{
		if (imgs_clear_one_view_[j] > maxLaplace)
		{
			if(useless_max==true)
			{
				sec_max=maxLaplace;
				sec_ind=max_ind;
			}
			maxLaplace = imgs_clear_one_view_[j];
			max_ind = j;
			useless_max=true;
		}
		if (imgs_clear_one_view_[j] > sec_max && imgs_clear_one_view_[j]<maxLaplace)
		{
			sec_max = imgs_clear_one_view_[j];
			sec_ind = j;
		}
	}

	if(imgs_m1_one_view_[max_ind]<imgs_m1_one_view_[sec_ind])
	{
		return sec_ind;
	}
	else
	{
		return max_ind;
	}

}

目前测了大概一千多组图，效果还行。像这种复杂的也还行。

但随着测试复杂程度增加，估计会出现找不准的情况，还要改善，让其更具有鲁棒性。或者要换一种更加好的算法？！

元气少女缘结神
关注
专栏目录
镜头自动聚焦算法
07-31
基于利用清晰度的快速自动聚焦算法, 计算速度快, 实现简单
自动对焦核心方法
xiaochuideai的博客
05-09 1018
核心1：常用的自动对焦方法是基于图像质量评估方法进行的。基本思路是结合运动装置或电控镜头移动拍摄物体对象的同时，对拍摄的图像进行清晰度度量。核心2：需要使用生产者消费者模式。
vivado HLS 实验步骤记录
最新发布
a1915067127的博客
07-27 390
①定义top函数②定义tb文件（包含测试向量）③设置器件型号④定义端口输入时钟⑤定义输出配置（默认：导出IP、语言verilog）
自动对焦算法AF(auto AF)
11-17
自动对焦算法AF，此为相机里的快速对焦算法，供软件 人中学习
自动对焦搜索算法(未完)
thisiszdy的博客
10-12 4198
自动对焦搜索算法 先黄金搜索再爬山搜索 1、爬山搜索法 2、黄金搜索法 3、代码 // AutoFocus.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include <iostream> #include <vector> #include <math.h> #include <halconcpp.h> using namespace HalconCpp; using namespace std;
基于图像的被动式相机自动对焦小结(附搜索合焦位置的c++代码）
u014230360的博客
08-11 3949
自动对焦功能在当下已经成为了相机的必备功能。实现自动对焦可以通过主动或被动感知的方法。在主动式感知中，摄像机发出的单束/多束红外光或超声波信号被成像物体反射，物体到摄像机的距离是通过三角测量或者信号返回到摄像机所需要的时间来确定的。然后，根据物体到相机的距离，从一个查找表中设置焦距。主动传感的优势在于它能够在不同的光照条件下聚焦，特别是在暗光条件下。然而，在通过窗户或玻璃进行聚焦时，由于较高的红外或超声反射率，这种感知机制会遇到一定的困难。此外，聚焦区域仅限于相机上的光源或声源所指向的位置也是其另一短板。
Camera光学、成像和 3A 算法
有趣的人生 一半是山川湖海 一半是初心情怀
03-18 4082
成像与光学。计算机视觉，图像处理，数字成像。自动驾驶与视觉。 镜头设计；人成像（相机），机器视觉 计算机视觉 -- 光学与 camera，书籍 《应用光学》，《几何光学》 Camera（摄像头）算法的书，FPGA或DSP实现的。如ISP功能实现、3A、3D降噪、边缘增强、色彩还原、图像增强、防抖、去雾、隐私遮挡等的， 张芙蓉，《基于DM642的H.264编码器研究》 李方慧，王飞，何佩...
自动对焦算法
Douhaoyu的博客
06-28 647
Halcon自动对焦
Auto-Focus 自动对焦介绍
11-02
Navitar自动对焦系统支持从2倍至100倍的显微镜物镜的交换，使得系统可以根据不同的应用需求进行相应的配置和调整。广泛应用于多个领域，包括晶圆检测、纳米和微设备检测、CMM机器装配、印刷电路板检测、光刻掩膜的...
vue-autofocus-directive:指令自动对焦视图
04-28
Vue自动对焦指令 Vue的自动对焦指令 关于 摘自Vue官方教程： ： 页面加载后，带有指令的元素将获得焦点（注意：自动聚焦在移动Safari上不起作用）。 安装 npm install --save vue-autofocus-directive 用法 import...
V430-F系列自动对焦多功能读码器
03-18
V430-F系列自动对焦多功能读码器是一款先进的自动对焦技术设备，它集成了多种读码功能，特别适用于低压电器领域。由于是技术说明性质的内容，我们可以从中提炼出几个相关的知识点。 知识点一：多功能读码器技术 多...
基恩士SR-1000系列自动对焦1D2D条码读取器产品目录.pdf
06-28
基恩士SR-1000系列自动对焦1D/2D条码读取器是基恩士公司推出的一款高科技产品，具备自动对焦功能和读取1D/2D条码的能力。这款设备具备优秀的性能，能够在不同的场合中应用，对于微型条码和刻印在镜面上的条码，可以...
Avago新推超薄型自动对焦LED产品ASMT-FJ30
01-19
Avago Technologies(安华高科技)近日宣布，推出一款新小型化自动对焦发光二极管(LED)产品，适合超薄型数码相机和照相手机设计。尺寸只有铅笔头橡皮擦大小，安华高的ASMT-FJ30是目前业内薄的自动对焦LED之一。可以在...
相机自动对焦_Laplace算法理论详解_以及与运动控制的结合
家里蹲大学摸鱼学专业优秀毕业生的博客
03-19 3063
本文会详细介绍相机自动对焦的算法，即判别图像清晰度的图像处理算法_Laplace算法理论解析，以及阐述如何与运动控制结合进行实时确认相机焦距。 开发不易，因此本文并未给出源代码，有需要的请单独私聊。 首先，我们需要明确的是，为了确认相机的最佳焦距，相机的视野范围内必须是有足够的灰度差。 如果灰度差基本没有，比如说一张白纸放在视野内，相机是对不了焦距的。 所以基于灰度差，我们知道连续变化的黑白过度期间其一阶微分变化很小，并且一阶微分并不具有很高的灵敏度，所以对黑白过度期间的求二阶微分是一种更好的选择。但是图像
Baumer工业相机堡盟工业相机如何通过BGAPISDK使用AutoFocusHelper自动对焦补充功能（C++）
xianzuzhicai的博客
06-17 1819
Baumer工业相机堡盟工业相机如何通过BGAPISDK使用AutoFocusHelper自动对焦补充功能（C++）
MFC 获取摄像头 实时显示并图像处理（光斑自动对焦）
weixin_41949988的博客
04-23 7829
第一次写CSDN论文，给自己的毕设做个总结。对于我这个常年用C语言的渣渣，突然接触需要C++的MFC和Opencv，就变成毕设困难户了，好在有CSDN上大神们的帮助和同班同学热心的指导，总算是上手了mfc和Opencv。废话不多说，直接进入正题。PART 1  ：   MFC界面的组件认识在VS2013中新建好mfc项目，给这个项目取个动人的 名字“HuaQ_mfc”,然后在dialog中找到了对...
自动对焦方法学习
沧海一升的博客
11-17 4757
自动对焦的各类方法学习介绍
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

元气少女缘结神

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值