模糊算法 订阅
模糊算法属于智能算法,当我们对于系统的模型认识不是很深刻,或者说客观的原因导致我们无法对系统的控制模型进行深入研究的时候,智能算法常常能够起到的作用很小。这个时候就需要用到模糊算法,常见的模糊算法有均值模糊、高斯模糊等。 展开全文
模糊算法属于智能算法,当我们对于系统的模型认识不是很深刻,或者说客观的原因导致我们无法对系统的控制模型进行深入研究的时候,智能算法常常能够起到的作用很小。这个时候就需要用到模糊算法,常见的模糊算法有均值模糊、高斯模糊等。
信息
应    用
图像处理、信号处理
外文名
Fuzzy algorithm
中文名
模糊算法
学    科
数学
模糊算法简介
实际上模糊算法属于智能算法,智能算法也可以叫非模型算法,也就是说,当我们对于系统的模型认识不是很深刻,或者说客观的原因导致我们无法对系统的控制模型进行深入研究的时候,智能算法常常能够起到不小的作用。这点是方便理解的,如果一个系统的模型可以轻易的获得,那么就可以根据系统的模型进行模型分析,设计出适合系统模型的控制器。但是现实世界中,可以说所有的系统都是非线性的,是不可预测的。但这并不是说我们就无从建立控制器,因为,大部分的系统在一定的条件和范围内是可以抽象成为线性系统的。问题的关键是,当我们系统设计的范围超出了线性的范围,我们又该如何处理。显然,智能算法是一条很不错的途径。智能算法包含了专家系统、模糊算法、遗传算法、神经网络算法等。其实这其中的任何一种算法都可以跟PID去做结合,而选择的关键在于,处理的实时性能不能得到满足。当我们处理器的速度足够快速时,我们可以选择更为复杂的、精度更加高的算法。但是,控制器的处理速度限制了我们算法的选择。当然,成本是限制处理器速度最根本的原因。这个道理很简单,51单片机和DSP的成本肯定大不相同。专家PID和模糊PID是常用的两种PID选择方式。其实,模糊PID适应一般的控制系统是没有问题 [1]  。
收起全文
精华内容
下载资源
问答
  • 模糊算法

    2019-07-08 08:55:05
    项目实例下载:https://gitee.com/Keith404/fuzzy_algorithm/tree/master/ 2018/11/7 16:55 修改 import java.util.ArrayList; import java.util.List; public class FuzzyMatching { ... private int subst...

    项目实例下载:https://gitee.com/Keith404/fuzzy_algorithm/tree/master/

    2018/11/7    16:55 修改

    import java.util.ArrayList;
    import java.util.List;
    
    public class FuzzyMatching {
    
        //参数
        private int substrCrossDomain = 2; //子串允许的跨界下标值
        private int substrElimination = 2; //子串允许的消除个数值
        private int mainstrCrossDomain = 100; //主串允许的跨界下标值
        private boolean reportOpen = true; //是否显示汇报结果
    
        //变量
        private String mainString = ""; //主串字符串
        private String subString = ""; //子串字符串
        private int substrSubscript = 0; //子串下标
        private int subscriptMovementCount = 0; //子串移动下标次数
        private int currentEliminationNumber = 0; //存储消除子串字符的数值
        private int mainstrPreviousSubscript = 0; //主串的前一次下标值
        private boolean effectiveness; //返回值
        private List matchingItem; //符合条件的子串字符集
        private List report; //汇报内容
        private List result; //主串出现位置结果集
    
        //首字符出现的位置
        private int fistCharShow = -1;
    
        //是否执行过getResult
        private boolean readGetResult = false;
    
        //构造方法
        public FuzzyMatching() {
            report = new ArrayList();
            matchingItem = new ArrayList();
            result = new ArrayList();
        }
    
        public FuzzyMatching(String mainString, String subString) {
            report = new ArrayList();
            matchingItem = new ArrayList();
            result = new ArrayList();
            this.mainString = mainString;
            this.subString = subString;
    
        }
    
        //
    
        //设置主串和子串方法
        public void setMainString(String mainString) {
            this.mainString = mainString;
        }
    
        public void setSubString(String subString) {
            this.subString = subString;
        }
    
        //获取主串和子串
        public String getMainString() {
            return this.mainString;
        }
    
        public String getSubString() {
            return this.subString;
        }
    
        //设置参数值
        public void setSubstrCrossDomain(int value) {
            this.substrCrossDomain = value;
        }
    
        public void setSubstrElimination(int value) {
            this.substrElimination = value;
        }
    
        public void setMainstrCrossDomain(int value) {
            this.mainstrCrossDomain = value;
        }
    
        public void setReportOpen(boolean value) {
            this.reportOpen = value;
        }
    
        //返回主串分别出现的数据结果
        public List getResult() {
            if (readGetResult) {
                return this.result;
            } else {
                System.out.println("还没执行getEffectiveness方法");
                return this.result; //有待完善
            }
    
        }
    
        //返回匹配到的子串字符
        public List getMatchingItem() {
            if (readGetResult) {
                return this.matchingItem;
            } else {
                System.out.println("还没执行getEffectiveness方法");
                return this.matchingItem; //有待完善
            }
        }
    
    
        public Boolean getEffectiveness() {
    
            for (int i = 0; i < mainString.length(); i++) { if (mainString.charAt(i) == subString.charAt(0)) { if ((mainString.length()-i) > substrElimination){
                        fistCharShow = i;
                        break;
                    }
                }
            }
    
            if (fistCharShow != -1){
    
            }else {
                substrSubscript++;
                fistCharShow = 0;
            }
    
            int mainStringSubscript = 0;
            mainStringSubscript = fistCharShow;
            while(mainStringSubscript<mainString.length()){
    
                subscriptMovementCount = 0;
                for (int j = substrSubscript; j < subString.length(); j++) {
                    if (subscriptMovementCount < substrCrossDomain) {
                        if (mainString.charAt(mainStringSubscript) == subString.charAt(j)) {
                            if (mainStringSubscript - mainstrPreviousSubscript < mainstrCrossDomain) { //判断主串下标移动的范围值,如果是第一次匹配,则无穷
                                substrSubscript = j + 1;//将子串下标设置为当前匹配到的下标,并将子串下标移一位
                                matchingItem.add(subString.charAt(j));
                                result.add(mainStringSubscript);
                            } else {
                                report.add("超出主串允许的跨界幅度:" + mainString.charAt(mainStringSubscript));
    
                            }
                            mainstrPreviousSubscript = mainStringSubscript;
                            break;
                        }
    
                    } else {
                        break;
                    }
                    subscriptMovementCount++;
                    if (j==subString.length()){
                        mainStringSubscript = fistCharShow;
                    }
    
    
                }
    
                mainStringSubscript ++;
            }
    
            for (int i = fistCharShow; i < mainString.length(); i++) { } currentEliminationNumber = subString.length() - matchingItem.size(); //汇报信息处理 String strs = "子串符合主串匹配的字符集为:"; if (currentEliminationNumber > substrElimination) {
                report.add("消除的子串个数超过预设值,所以结果无效");
                effectiveness = false;
            } else {
                report.add("消除的子串个数在预设值内,所以结果有效");
                effectiveness = true;
            }
    
    
            for (int i = 0; i < matchingItem.size(); i++) {
                strs += matchingItem.get(i).toString();
            }
            report.add(strs);
            strs = "在主串分别出现的位置为(以0作为起始值):";
            for (int i = 0; i < result.size(); i++) {
                strs += result.get(i).toString() + ",";
            }
            report.add(strs);
    
            //汇报
            if (reportOpen) {
                for (int i = 0; i < report.size(); i++) {
                    System.out.println(report.get(i));
                }
            }
            this.readGetResult = true;
            return effectiveness;
        }
    
    
    }
    

     

    展开全文
  • 模糊算法简介

    2017-01-24 22:07:31
    模糊算法简介
  • 模糊神经网络,结合模糊算法与神经网络算法进行预 模糊神经网络,结合模糊算法与神经网络算法进行预
  • 模糊神经网络,结合模糊算法与神经网络算法进行预模糊神经网络,结合模糊算法与神经网络算法进行预
  • 深入Matlab模糊算法15讲
  • 模糊算法

    2018-07-10 16:13:01
    针对文字的去运动模糊算法 Title: Matlab code for "Deblurring Text Images via L0-Regularized Intensity and Gradient Prior" Author: Jinshan Pan (sdluran@gmail.com), Zhe Hu (zhu@ucmerced.edu), Zhixun Su ...
  • 模糊神经网络,结合模糊算法与神经网络算法进行预matlab
  • 模糊算法代码

    2011-12-02 17:54:41
    模糊算法,自适应算法,适用于电机以及其他温控等的调节……
  • 模糊神经网络,结合模糊算法与神经网络算法进行预测,MATLAB哈
  • 高斯模糊算法

    千次阅读 2019-02-27 14:52:33
    1.高斯模糊算法效果(左边是原始图像,右边是处理后的图像) 2.算法原理 2.1"模糊"的算法有很多种,其中有一种叫做"高斯模糊"(Gaussian Blur)。它将正态分布(又名"高斯分布"...

    1.高斯模糊算法效果(左边是原始图像,右边是处理后的图像)

    2.算法原理

    2.1"模糊"的算法有很多种,其中有一种叫做"高斯模糊"(Gaussian Blur)。它将正态分布(又名"高斯分布")用于图像处理。
    2.2“高斯模糊“二维正态分布为权重,以K((2xK+1)*2)为半径,进行卷积,K越大模糊程度越大
    2.3距离中心点越远的像素所获得权重越小
    2.4权值计算:二维正态分布函数

    2.5x,y坐标选取,其中б是方差,可以自己选取,方差越大,模糊效果越好,注意算得权值要进行归一化,因为算得权值之和不一定为1,所以要使得他们的值之和为1

    2.6将算得的权值与图像中的每个像素进行卷积,算得新的图像,就是你需要的图像
    2.7边缘处理:对边缘像素进行对称处理来代替没有像素的值,这里以3*3(半径K=1)模板为例,首先判断模板的X坐标在图像坐标中的位置,如果不在图像中,将其X坐标关于模板中心的X坐标对称,如果此时该点还在图像外面,再将其Y坐标关于模板中心的Y坐标对称,此时该点一定在图像上,以此点的坐标的像素值来代替模板在图像外面的像素值。

    2.8.计算权重的函数

    //获取核函数
    float *getWeight(int k, float sigma) {
    	int radius = 2 * k + 1;
    	float *filter = new float[radius*radius];
    	float sum = 0;
    	float e = 2.71828;
    	int i, j;
    	for (i = 1; i<radius + 1; i++)
    		for (j = 1; j<radius + 1; j++)
    		{
    			float cifang = -((i - k - 1)*(i - k - 1) + (j - k - 1)*(j - k - 1)) / (2 * sigma*sigma);
    			filter[(i - 1)*radius + j - 1] = pow(e, cifang) / (2 * 3.14159*sigma*sigma);
    			sum = sum + filter[(i - 1)*radius + j - 1];
    		}
    		//将权值归一化
    		for (i = 0; i<radius; i++)
    		{			
    			for (int j = 0; j<radius; j++)
    			{
    				filter[i*radius + j] = filter[i*radius + j] / sum;
    			}
    		}
    		return filter;
    }

    这里我读图片是用了opencv的函数,在VS中配置OpenCV(https://blog.csdn.net/yuanheng19930119/article/details/87972536)的步骤,见链接

    #include "highgui.h"
    #include "time.h"
    #include "math.h"
    #include "omp.h"
     
    //获取核函数
    float *getWeight(int k, float sigma) {
    	int radius = 2 * k + 1;
    	float *filter = new float[radius*radius];
    	float sum = 0;
    	float e = 2.71828;
    	int i, j;
    	for (i = 1; i<radius + 1; i++)
    		for (j = 1; j<radius + 1; j++)
    		{
    			float cifang = -((i - k - 1)*(i - k - 1) + (j - k - 1)*(j - k - 1)) / (2 * sigma*sigma);
    			filter[(i - 1)*radius + j - 1] = pow(e, cifang) / (2 * 3.14159*sigma*sigma);
    			sum = sum + filter[(i - 1)*radius + j - 1];
    		}
    		//将权值归一化
    		for (i = 0; i<radius; i++)
    		{			
    			for (int j = 0; j<radius; j++)
    			{
    				filter[i*radius + j] = filter[i*radius + j] / sum;
    			}
    		}
    		return filter;
    }
    float *mgaussian(int height, int width, int k, float *weight, float *imagedata, int type) {
    float *newimage = new float[height*width*type];
    //omp_get_num_threads();
    //omp_set_num_threads(3);
    //#pragma omp parallel for
    	for (int i = 0; i<height; i++)
    	{
    		for (int j = 0; j<width; j++) {
    			//对边缘像素的处理
    			if(i<k||j<k||i>=height-k||j>=width-k)
    			{
    				//for(int m=0;m<type;m++)
    				//newimage[3*width*i+3*j+m]=imagedata[3*width*i+3*j+m];
    				for(int mtype=0;mtype<type;mtype++)
    				{
    					float valuep=0;
    					for(int nh=0;nh<2*k+1;nh++)
    						for(int nw=0;nw<2*k+1;nw++)
    						{
    							//纵向是否超出范围
    							int mx=i+nh-k;
    							if(mx<0||mx>height-1)
    								mx=2*i-mx;
    							//判断横向是否超出范围
    							int my=j+nw-k;
    							if(my<0||my>width-1)
    								my=2*j-my;
    							valuep=valuep+weight[nh*(2*k+1)+nw]*imagedata[type*mx*width+type*my+mtype];
    						}
    						newimage[type*i*width+type*j+mtype]=valuep;
    				}
    				continue;
    			}
     
    			//高斯核函数计算
    			for (int mtype2 = 0; mtype2<type; mtype2++)
    			{
    				float pixelval = 0;
    				for (int nh2 = 0; nh2<2 * k + 1; nh2++)
    					for (int nw2 = 0; nw2<2 * k + 1; nw2++)
    					{
    						pixelval = pixelval + weight[nh2*(2 * k + 1) + nw2] * imagedata[type*(i + nh2 - k)*width + type*(j + nw2 - k) + mtype2];
    					}
    					newimage[type*i*width + type*j + mtype2] = pixelval;
    			}
    		}
    	}
    	return newimage;
    }
    int main(int argc, char** argv)
    {
     
    	
    	IplImage* img = cvLoadImage("C:\\Users\\heng\\Desktop\\test.jpg");
    	int mwidth, mheight, mtype;
    	int i, j, k = 1;
    	float sigma = 10;
    	printf("请输入高斯核函数的半径:");
    	scanf("%d",&k);
    	printf("请输入高斯核函数的方差sigma:");
    	scanf("%f",&sigma);
    	
    	//double start = clock();
     
    	mwidth = img->width;
    	mheight = img->height;
    	mtype = img->nChannels;
    	//CvMat *imageMat=cvCreateMat(mheight,mheight*mtype,CV_32FC1);
    	float *imageMat = new float[mwidth*mheight*mtype];
    	float *Gweight = getWeight(k, sigma);
    	//去除像素点放到imageMat中
    	for (i = 0; i<mheight; i++)
    		for (j = 0; j<mwidth; j++) {
    			CvScalar s;
    			s = cvGet2D(img, i, j);// get the (i,j) pixel value
    			for (int index = 0; index<mtype; index++) {
    				imageMat[3 * mwidth*i + 3 * j + index] = s.val[index];
    			}
    		}
    		float *imageMat2 = mgaussian(mheight, mwidth, k, Gweight, imageMat, mtype);
    		IplImage* img2 = cvCreateImage(cvSize(mwidth, mheight), IPL_DEPTH_8U, mtype);
    		//将处理后的图像值放入图像中显示
    		for (i = 0; i<mheight; i++)
    			for (j = 0; j<mwidth; j++) {
    				CvScalar s;
    				for (int mmtype = 0; mmtype<mtype; mmtype++) {
    					int p = int(imageMat2[mtype*mwidth*i + mtype*j + mmtype] + 0.5);
    					if (p>255)
    						p = 255;
    					s.val[mmtype] = p;
    				}
    				cvSet2D(img2, i, j, s);
    			}
    			cvNamedWindow("显示原图像", CV_WINDOW_AUTOSIZE);
    			cvShowImage("显示原图像", img);
    			cvNamedWindow("显示高斯滤波处理后的图像", CV_WINDOW_AUTOSIZE);
    			cvShowImage("显示高斯滤波处理后的图像", img2);
    			//double end = clock();
    			//printf("time=%f", end - start);
    			cvWaitKey(0);
    			cvReleaseImage(&img);
    			cvReleaseImage(&img2);
    			cvDestroyWindow("显示原图像");
    			cvDestroyWindow("显示高斯滤波处理后的图像");
    			delete[] imageMat;
    			delete[] imageMat2;
    		
    }

    到此,高斯模糊处理完毕
     

    展开全文
  • Pid控制算法-模糊算法简介

    万次阅读 多人点赞 2017-04-19 16:15:29
    模糊算法简介 在PID控制算法的C++语言实现中,文章已经对模糊PID的实质做了一个简要说明。基本概念和思路进行一下说明,相信有C++语言基础的朋友可以通过这些介绍性的文字自行实现。这篇文章主要说明一下模糊...

    PID控制算法的C++实现

    九 模糊算法简介

      在PID控制算法的C++语言实现中,文章已经对模糊PID的实质做了一个简要说明。基本概念和思路进行一下说明,相信有C++语言基础的朋友可以通过这些介绍性的文字自行实现。这篇文章主要说明一下模糊算法的含义和原理。

      实际上模糊算法属于智能算法,智能算法也可以叫非模型算法,也就是说,当我们对于系统的模型认识不是很深刻,或者说客观的原因导致我们无法对系统的控制模型进行深入研究的时候,智能算法常常能够起到不小的作用。这点是方便理解的,如果一个系统的模型可以轻易的获得,那么就可以根据系统的模型进行模型分析,设计出适合系统模型的控制器。但是现实世界中,可以说所有的系统都是非线性的,是不可预测的。但这并不是说我们就无从建立控制器,因为,大部分的系统在一定的条件和范围内是可以抽象成为线性系统的。问题的关键是,当我们系统设计的范围超出了线性的范围,我们又该如何处理。显然,智能算法是一条很不错的途径。智能算法包含了专家系统、模糊算法、遗传算法、神经网络算法等。其实这其中的任何一种算法都可以跟PID去做结合,而选择的关键在于,处理的实时性能不能得到满足。当我们处理器的速度足够快速时,我们可以选择更为复杂的、精度更加高的算法。但是,控制器的处理速度限制了我们算法的选择。当然,成本是限制处理器速度最根本的原因。这个道理很简单,51单片机和DSP的成本肯定大不相同。专家PID和模糊PID是常用的两种PID选择方式。其实,模糊PID适应一般的控制系统是没有问题。文章接下来将说明模糊算法的一些基本常识。

      模糊算法其实并不模糊。模糊算法其实也是逐次求精的过程。这里举个例子说明。我们设计一个倒立摆系统,假如摆针偏差<5°,我们说它的偏差比较“小”;摆针偏差在5°和10°之间,我们说它的偏差处于“中”的状态;当摆针偏差>10°的时候,我们说它的偏差有点儿“大”了。对于“小”、“中”、“大”这样的词汇来讲,他们是精确的表述,可问题是如果摆针偏差是3°呢,那么这是一种什么样的状态呢。我们可以用“很小”来表述它。如果是7°呢,可以说它是“中”偏“小”。那么如果到了80°呢,它的偏差可以说“非常大”。而我们调节的过程实际上就是让系统的偏差由非常“大”逐渐向非常“小”过度的过程。当然,我们系统这个调节过程是快速稳定的。通过上面的说明,可以认识到,其实对于每一种状态都可以划分到大、中、小三个状态当中去,只不过他们隶属的程度不太一样,比如6°隶属于小的程度可能是0.3,隶属于中的程度是0.7,隶属于大的程度是0。这里实际上是有一个问题的,就是这个隶属的程度怎么确定?这就要求我们去设计一个隶属函数。详细内容可以查阅相关的资料,这里没有办法那么详细的说明了。http://baike.baidu.com/view/150383.htm这里面有些说明。那么,知道了隶属度的问题,就可以根据目前隶属的程度来控制电机以多大的速度和方向转动了,当然,最终的控制量肯定要落实在控制电压上。这点可以很容易的想想,我们控制的目的就是让倒立摆从隶属“大”的程度为1的状态,调节到隶属“小”的程度为1的状态。当隶属大多一些的时候,我们就加快调节的速度,当隶属小多一些的时候,我们就减慢调节的速度,进行微调。可问题是,大、中、小的状态是汉字,怎么用数字表示,进而用程序代码表示呢?其实我们可以给大、中、小三个状态设定三个数字来表示,比如大表示用3表示,中用2表示,小用1表示。那么我们完全可以用1*0.3+2*0.7+3*0.0=1.7来表示它,当然这个公式也不一定是这样的,这个公式的设计是系统模糊化和精确化的一个过程,读者也可参见相关文献理解。但就1.7这个数字而言,可以说明,目前6°的角度偏差处于小和中之间,但是更偏向于中。我们就可以根据这个数字来调节电机的转动速度和时间了。当然,这个数字与电机转速的对应关系,也需要根据实际情况进行设计和调节。

        前面一个例子已经基本上说明了模糊算法的基本原理了。可是实际上,一个系统的限制因素常常不是一个。上面的例子中,只有偏差角度成为了系统调节的参考因素。而实际系统中,比如PID系统,我们需要调节的是比例、积分、微分三个环节,那么这三个环节的作用就需要我们认清,也就是说,我们需要根据超调量、调节时间、震荡情况等信息来考虑对这三个环节调节的比重,输入量和输出量都不是单一的,可是其中必然有某种内在的逻辑联系。所以这种逻辑联系就成为我们设计工作的重点了。下一篇文章将详细分析PID三个变量和系统性能参数之间的联系。

     

    展开全文
  • 人工智能(模糊算法)

    2018-04-05 09:49:46
    本文件详细介绍了模糊算法的原理及其在人工智能领域的应用
  • 模糊算法简单实例

    2013-12-08 19:40:28
    比较简单的模糊算法实例,刚开始学习的时候编的,新手可以学习下
  • PID算法及原理详解,包含增量式PID,位置型PID,梯度PID,专家PID,模糊算法等,从普通PID原型到专家PID逐步优化原理及代码,包含初级到高阶算法
  • 基于quartus II9.1的模糊算法的交通信号灯系统的车流量检测、统计、自动配时仿真
  • 主要介绍了JavaScript实现的图像模糊算法代码分享,需要的朋友可以参考下
  • T-S型模糊算法在FPGA上的实现。TB文件已经写好。详细见我的博客《T-S型模糊算法简述及FPGA的实现》
  • 图像去模糊算法 deblur

    千次阅读 2020-07-07 17:16:35
    图像去模糊算法 循序渐进 附完整代码 https://www.cnblogs.com/cpuimage/p/9735150.html (后面要对比smartdeblur,deblur-gan) 关于图像模糊算法的实现, 我相信大多数学习图像算法的朋友都很熟悉。 例如常见...

    图像去模糊算法 循序渐进 附完整代码

    https://www.cnblogs.com/cpuimage/p/9735150.html

    (后面要对比smartdeblur,deblur-gan)

    关于图像模糊算法的实现,

    我相信大多数学习图像算法的朋友都很熟悉。

    例如常见的毛玻璃效果,高斯模糊等等。

    而图像模糊最简单的实现就是 在一定区域 对像素做平均值计算。

    术语描述,卷积。

    1.认识卷积

    而平均值计算可以,看做是一种常见的卷积计算,卷积核权重都为1。

    OpenCV中与之对应的算法是BoxBlur。

    图像方面深度学习中最重要的两个层,一个池化层,一个卷积层,

    其中池化层可以认为是一种特例的卷积层,与求平均值类似。

    从网上找了一张卷积操作的示例图片。

     

    这样看,虽然知道是在做一个点面计算的操作,但是要具体描述卷积的用途或者原理,是有点困难的。

    在两年前一次公司的内部技术分享会上,我是这么定义卷积的。

    卷积计算从形象上来描述,在图像领域,一般是2维,

    所以可以这么说 “计算两个物体在n维空间的相似度(叠加度)的操作,就称之为(n维)卷积。”

    所以图像是计算两个物体在2维空间的相似度(叠加度)的操作,就称之为卷积。

    如果两个物体完全一致,卷积完全重合,重合度为1,这时可以认为它就是同一个物体。

    以上描述的两个物体,在算法中一般 指的是 卷积核 和被卷积图片,卷积结果就是其两者的重合度。

     

    看下深度学习中的池化层。

    根据上面的描述,重新理解一下,这个层的作用。

    这里就不展开细讲了,大概大家能理解一下卷积这个操作即可。

    而一般情况下,卷积操作,是一种信息外散或内聚的计算,

    当然也有卷积,反卷积,转置卷积的说法。

    举个例子,例如均值池化或者说均值卷积,均值模糊。

    从计算来看,是取目标像素临近区域像素的平均值,而所有临近像素的权重都为1.

    最终目标像素的值为n分之1. 

    那么这个计算就好像是把一个物品在2维空间直接摊平,还不能理解的再看下上面对卷积的描述。

    就像你有9只蚂蚁,你希望他们长得一样大,你一巴掌下去,身体全部压平。

    而在图像领域,绝大多数的模糊,就是受到一个“物体”或者说“卷积核”的干扰,

    致使采集到的信息丢失,或者说不准确。

    例如在按下快门的一瞬间,你手抖了,或者说失去焦点,

    就会很容易造成呈像模糊。

    2.图像修复

    假设我们能找到导致成像模糊的原因,是不是就能实现修复模糊图像呢?

    答案是肯定的。

    不过取决于最终采集到的信息的完整度。

    如果最后成像一片漆黑,那这个时候是无能为力的。

    因为已经没有足够的信息了。

    而一般图像是由色光三原色组成,红绿蓝。

    理论上只要其中一种颜色信息完整,就可以用于辅助修复其他色光。

    只要能计算到当时的色光分布情况即可实现。

    这里我们就需要稍微提及一下摄像领域3大算法,自动白平衡,自动对焦,自动曝光。

    简单讲下 这三个算法的区别。

    白平衡是为了解决色光分布不均,信息缺失或失真问题的。

    自动对焦是为了成像清晰,人为干扰辅助最终成像。

    自动曝光当然是为了解决采光问题,弥补感光元件的不足。

    大概的先后顺序,理论上应该是 对焦->曝光->白平衡

    一般而言,从这逻辑来看,白平衡是最难解决的,因为它受到前面两个因素的干扰。

    但是实际上,白平衡和曝光目前都解决得很好。

    HDR严格意义上来说,能兼顾白平衡和曝光。

    但是对焦或者说失焦,抖动的问题,一直以来都是老大难。

    原因也很简单,导致成像模糊的因素有很多,通过什么样的方法来有效评估修复,就显得比较困难。

     假设能知道计算到当时受到什么“物体”的干扰,通过卷积的方式,移除这干扰,是不是就能修复模糊,恢复图片呈像。

    假设造成模糊的因素为:   清晰的图片 + 干扰因素 = 最终成像

    那么反之恢复图像即为:   最终成像 - 干扰因素 = 清晰图片

    而这里把干扰因素和清晰的图片都认为是一种卷积“物体”。

    3.去模糊

    有了前面的基础知识,我们可以做一个假设,进行验证。

    例如,我先对一张图片做卷积操作,模拟模糊成像。

    这个时候: 你同时有了  清晰的图片 + 干扰因素 = 最终成像

    验证一下:  最终成像 - 干扰因素 = 清晰图片

    这里不展开算法实现,

    但是结果我可以告诉大家,这思路没错,但是有一个干扰因素错了。

    它就是卷积核的大小。

    卷积核大小直接决定它的作用范围。

    而我们第一步拿到的 清晰的图片 + 干扰因素 = 最终成像

    这里 最终成像-干扰因素 却绝对不等于清晰的图片。

    因为 这里的干扰因素和最终成像 两者之间并不是简单的线性关系,相加或者相减,

    他们的关系是卷积关系,也就是说他们都受到卷积核的影响。

    如果想要达到 最终成像 - 干扰因素 = 清晰图片

    必须 在最终成像的时候用类似卷积的方式,消除卷积核的内容以及范围的影响。

    换句话说,这个操作必须控制好变量。

    这个问题说真的,我思考了很久很久。

    最后终于知道问题在哪里,就是图像的明度,也就是最终成像。

    也就是最终成像中是含有卷积核权重信息的,如果要消除这个信息,

    必须将成像也作为权重参与计算。

     也就是说,造成模糊的情况应该是:

    1

    2

    3

    4

    5

    6

    7

    ifsqrt(nx-x) + sqrt(ny-y) <  sqrt(radius) )

    {

        w = luminance(rgb)

        sum += w*rgb;

        wsum += w;

    }

     sum /= wsum;

     伪代码,简洁形象地表达这个现象。

    知道这个前因后果,现在恢复模糊,该如何计算。

    这个留个作业给大家。

    上面伪代码我称之为  散焦 算法,反之为 聚焦 也就是去模糊 。

    聚焦算法最终可以实现耗时模糊半径无关,它是去模糊的一种特例。

    目前,此算法暂无开源计划。

    好几年前就有去模糊的商业软件,当然早期版本作者也开源了。

    项目地址:https://github.com/Y-Vladimir/SmartDeblur

    但是这个项目并没有很好准确计算到去模糊卷积核。

    前几天ipol.im公布了一个比较优秀的评估去模糊卷积核的算法。

    Estimating an Image's Blur Kernel Using Natural Image Statistics, and Deblurring it: An Analysis of the Goldstein-Fattal Method

    从官网demo演示来看,效果特别不错。

     

    但是,它和SmartDeblur 都有着一样的问题,就是用到傅里叶变换去做卷积操作,

    十分耗时。

    都采用了fftw,计算量还是居高不下。

    我对它提供的代码,做了一些简单的裁剪,cmake编译通过,仅依赖fftw。

    而代码的算法调优等等,还没做,算法优化空间比较大,最近精力有限,

    在音频算法上花的时间比较多,图像暂时没有精力做起来。

    感兴趣的朋友,可以移步项目:

    https://github.com/cpuimage/Deblurring

    而近些年,深度学习大兴,各种各样的模型以及训练集,五花八门。

    当然也有去模糊的实现。

    效果非常惊艳!

     

    网络结构如下:

     

    对于采用深度学习的方法进行去模糊实现,可以参阅文章:

    https://blog.sicara.com/keras-generative-adversarial-networks-image-deblurring-45e3ab6977b5

    项目地址:

    https://github.com/RaphaelMeudec/deblur-gan

    相关论文:

    DeblurGAN: Blind Motion Deblurring Using Conditional Adversarial Networks

    https://arxiv.org/pdf/1711.07064.pdf

     

    最后做一个简单的总结,在图像领域,使用卷积就能非常好解决 图像的空间问题,

    而深度学习训练得到的权重,可以简单的类比上面提到的干扰因素。

    通过大量的数据,训练提取 可能性的干扰因素(物体),若是当前图像也有符合这个特征的因素(物体),

    则进行相应的操作计算。

    定位特征,确认特征,发现并处理特征。

    分别 对应物体检测,物体识别,风格化或其他增强修复处理。

    采用深度学习最大的好处就是能预先训练得到已知的信息,然后进行对应的处理。

    而传统算法,则需要采用先验条件,

    然后在一张图片中去发现可能性因素,由于参数较少,鲁棒性一般不佳。

    相比而言,传统算法困难重重,因为你要通过科学方式找到一种适配数据自然规律的先验,真的太不容易。

    而深度学习是另一个问题,数据依赖,数据干扰,数据处理,这些预处理也着实够人头大的了,

    然后还要设计一个比较有效且优良的神经网络。

    就目前来看,经典传统算法稳定性比较高,但是泛化能力一般较差。

    深度学习目前还需要不少传统算法配合进行训练处理,以求达到更好的效果。

    就目前来看,工业化落地也有不少问题,不过相信很快就能做得很好了。

    因为有大公司和大量资金资本的助推,应该不是难事。

    展开全文
  • 图像去模糊算法研究调研

    千次阅读 2020-03-27 16:40:47
    传统的图像去模糊算法研究 针对图像去模糊处理的研究,可以追溯到上世纪五六十年代,在传统上来说,一般都是采用数字图像处理领域中的方法。而根据模糊核是否已知,图像去模糊算法可以分为两类:非盲去模糊算法(Non-...
  • C# 高斯模糊算法

    千次阅读 2016-11-07 16:41:27
    C# 高斯模糊算法
  • 具有鲁棒噪声抑制的实时运动去模糊算法
  • 在医学图像三维显示技术中,需要得到单...它基于Mallat小波模极大值边缘检测方法,同时应用模糊算法构造相应的隶属函数,再对得到的极大值进行进一步筛选,最终可以得到单像素级的边缘.实验结果证明了该算法的可行性.
  • 本科毕业设计(论文) 题 目: 图像去模糊算法对比分析研究 学 院: 专 业: 班 级: 学 号: 学生姓名 指导老师: 职称: 二一五年六月一日 图像去模糊算法分析和研究 摘 要 在数字时代图像去模糊作为图像复原技术一个分支...
  • BMP图像模糊算法

    2012-01-19 17:27:00
    图像模糊算法,把边缘模糊化,暂时只支持16bit bmp。主要学习怎么完整做一个类似的程 序。包含文件读写等。
  • 采煤机作为目前我国煤矿主要开采设备,其安全性及稳定性使工作人员具有良好的工作环境及高效的开采效率,因此,采煤机的...结合模糊算法对采煤机的故障诊断预测系统进行模型建立,拓展模糊算法在我国煤炭产业中的应用范围。
  • 模糊算法在智能车控制中的应用
  • 图像算法---表面模糊算法

    万次阅读 2015-11-16 13:00:04
    本文介绍了PS中的表面模糊算法原理,跟大家分享一下!
  • 超高速指数模糊算法

    2020-07-28 09:45:12
    网上有一篇非常快的模糊算法实现:SSE图像算法优化系列五:超高速指数模糊算法的实现和优化(10000*10000在100ms左右实现)。 名字叫 Exponential blur(指数模糊)。 在搜材料时搜到只搜到了代码:blur.cpp 两个...
  • 多普勒天气雷达全自动速度退模糊算法描述

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,025
精华内容 4,810
关键字:

模糊算法