基于暗通道优先的单幅图像去雾算法（Matlab/C++）

算法原理：

参见论文：Single Image Haze Removal Using Dark Channel Prior [1]

① 暗通道定义

何恺明 通过对大量在户外拍摄的自然景物图片进行统计分析得出一个结论：在绝大多数非天空的局部区域里，某一些像素总会（至少一个颜色通道）具有很低的值。换言之，该区域光强度的最小值是个很小的数（趋于0）。

基于上述结论，我们定义暗通道，用公式描述，对于一幅图像J有如下式子：

也就是说以像素点x为中心，分别取三个通道内窗口Ω内的最小值，然后再取三个通道的最小值作为像素点x的暗通道的值，如下图所示：

Jc代表J的某一个颜色通道，而Ω(x)是以x为中心的一块方形区域。我们观察得出，除了天空方位，Jdark的强度总是很低并且趋近于0。如果J是户外的无雾图像，我们把Jdark称为J的暗原色,并且把以上观察得出的经验性规律称为暗原色先验。

②大气物理模型

要想从物理模型角度对有雾图像进行清晰化处理，就要了解有雾图像的物理成因，那么就要了解雾天的大气散射模型。

大气散射物理模型包含两部分，第一部分称为直接衰减项(Direct Attenuation)也称直接传播，第二部分称为大气光照(Airlight)

用公式表示如下:

I是观测到的有雾图像，J是景物反射光强度（也就是清晰的无雾图像），A是全局大气光照强度，t用来描述光线通过介质透射到成像设备过程中没有被散射的部分，去雾的目标就是从I中复原J。那么也就是要通过I求A和t。

方程右边的第一项J(x)t(x) 叫做直接衰减项，第二项A(1-t(x))则是大气光照。直接衰减项描述的是景物光线在透射媒介中经衰减后的部分，而大气光则是由前方散射引起的，会导致景物颜色的偏移。因为大气层可看成各向同性的，透射率t可表示为：

β为大气的散射系数，该式表明景物光线是随着景物深度d按指数衰减的。

③求解透射率t

在论文[1]中，作者给出了推导过程，这里就不再重复，其最后得到透射率t的公式如下：

Ic为输入的有雾图像，对其除以全局大气光照Ac后在利用暗通道定义公式进行求解暗通道。w（0<w<1）是雾的保留系数通常取0.95。

这里需要值得注意的是，求得的t是粗透射率图，并不能直接带入大气模型公式求解，所以需要进行细化后再处理。细化过程见⑤，Ac为全局大气光照，其求法见④。

④求解全局大气光照Ac

论文[1]中作者给出求解全局大气光照的过程如下：

1.首先对输入的有雾图像I求解其暗通道图像Jdark。

2.选择暗通道Jdark内图像总像素点个数（N_imagesize）千分之一（N=N_imagesize/1000）个最亮的像素点，并记录这些像素点（x,y）坐标。

3.再根据这些点的坐标分别在原图像I的三个通道（r,g,b）内找到这些像素点并加和得到（sum_r,sum_g,sum_b）.

4.Ac=[Ar,Ag,Ab]. 其中Ar=sum_r/N; Ag=sum_g/N; Ab=sum_b/N.

⑤细化透射率t

作者在论文[1]中使用了软抠图（soft matting）的方法，详见论文如下：

A Closed-Form Solution to Natural Image Matting[2], 作者：Anat Levin

使用软抠图法对得到的粗透射率t~进行细化。由于这个方法时间和内存花费比较大，后来作者又使用指导性滤波器进行细化粗透射图。效果上指导性滤波要稍差于软抠图法，但在时间和内存花费上具有明显优势，因此这里我们使用指导性滤波器进行细化粗透射率t~。（注：Matlab代码中也附带软抠图法细化透射率的代码。内容见文件包）

关与指导性滤波的详细内容见论文：Guided Image Filtering [3] 作者：何恺明

⑥求解最后清晰图像

现在，我们得到了A和t，那么带入大气模型公式：

这里，t0参数用来限定透射率t的下限值，其作用也就是在输入图像的浓雾区域保留一定的雾。

附录：

复制代码

ReadMe.txt：感谢论文Single Image Haze Removal Using Dark Channel Prior作者何凯明。
基于暗通道优先去雾算法的Matlab /C++ 源码为免费开源。只供研究学习使用，如果引用请注明原开发者，及出处。

Matlab版中指导性滤波的源码为原作者何凯明提供。

开发者：赵常凯（不包括Matlab版中 指导性滤波的源码）
时间：2013.8.19

复制代码

Matlab 源代码下载 5.69MB

C++ 源代码下载 1.68MB

说明:C++ 是基于 OpenCV2.2 + Qt 4.8.5 编写的，如果不匹配需要搭建 Qt+OpenCV开发环境。如果只想查看核心源码文件，请查看Dehazor.cpp文件。

复制代码

  1 /*--------------------------------------------------------------------------------*\2 3    This program is free software; permission is hereby granted to use, copy, modify,4    and distribute this source code, or portions thereof, for any purpose, without fee,5    subject to the restriction that the copyright notice may not be removed6    or altered from any source or altered source distribution.7    The software is released on an as-is basis and without any warranties of any kind.8    In particular, the software is not guaranteed to be fault-tolerant or free from9    failure.10 11    The author disclaims all warranties with regard to this software, any use,12    and any consequent failure, is purely the responsibility of the user.13 14    Copyright (C) 2013-2016 Changkai Zhao, www.cnblogs.com/changkaizhao15 \*-------------------------------------------------------------------------------*/16 #include "dehazor.h"17 18 cv::Mat Dehazor::process(const cv::Mat &image)19 {20     int dimr=image.rows;21     int dimc=image.cols;22 23     cv::Mat rawtemp;24     cv::Mat refinedImage_temp;25     cv::Mat output_b_temp(image.rows,image.cols,CV_32F);26     cv::Mat output_g_temp(image.rows,image.cols,CV_32F);27     cv::Mat output_r_temp(image.rows,image.cols,CV_32F);28     cv::Mat output_temp(dimr,dimc,image.type());29     rawImage.create(image.rows,image.cols,CV_8U); 30     refinedImage_temp.create(image.rows,image.cols,CV_32F);31     rawtemp.create(image.rows,image.cols,CV_8U);32 33 34     float sumb=0;float sumg=0;float sumr=0;35     float Air_b;  float Air_g; float Air_r;36     cv::Point2i pt;37 38     int dimone=floor(dimr*dimc*0.001);39     cv::Mat quantile;40     quantile=cv::Mat::zeros(2,dimone,CV_8U);41 42     int dx=floor(windowsize/2);43 //    cv::Mat imagetemp;44 //    imagetemp.create(image.rows,image.cols,CV_32FC3);45 46     for(int j=0;j<dimr;j++){47         for(int i=0;i<dimc;i++){48             int min;49             image.at<cv::Vec3b>(j,i)[0] >= image.at<cv::Vec3b>(j,i)[1]?50                min=image.at<cv::Vec3b>(j,i)[1]:51                min=image.at<cv::Vec3b>(j,i)[0];52             if(min>=image.at<cv::Vec3b>(j,i)[2])53                 min=image.at<cv::Vec3b>(j,i)[2];54             rawImage.at<uchar>(j,i)=min;55         }56     }57 58     for(int j=0;j<dimr;j++){59         for(int i=0;i<dimc;i++){60             int min=255;61 62             int jlow=j-dx;int jhigh=j+dx;63             int ilow=i-dx;int ihigh=i+dx;64 65             if(ilow<=0)66                 ilow=0;67             if(ihigh>=dimc)68                 ihigh=dimc-1;69             if(jlow<=0)70                 jlow=0;71             if(jhigh>=dimr)72                 jhigh=dimr-1;73 74             for(int m=jlow;m<=jhigh;m++){75                 for(int n=ilow;n<=ihigh;n++){76                     if(min>=rawImage.at<uchar>(m,n))77                         min=rawImage.at<uchar>(m,n);78                 }79             }80            rawtemp.at<uchar>(j,i)=min;81         }82     }83 84     for(int i=0;i<dimone;i++){85         cv::minMaxLoc(rawtemp,0,0,0,&pt);86         sumb+= image.at<cv::Vec3b>(pt.y,pt.x)[0];87         sumg+= image.at<cv::Vec3b>(pt.y,pt.x)[1];88         sumr+= image.at<cv::Vec3b>(pt.y,pt.x)[2];89         rawtemp.at<uchar>(pt.y,pt.x)=0;90     }91     Air_b=sumb/dimone;92     Air_g=sumg/dimone;93     Air_r=sumr/dimone;94 95 96     cv::Mat layb;  cv::Mat Im_b;97     cv::Mat layg;  cv::Mat Im_g;98     cv::Mat layr;  cv::Mat Im_r;99 
100     // create vector of 3 images
101     std::vector<cv::Mat> planes;
102     // split 1 3-channel image into 3 1-channel images
103     cv::split(image,planes);
104 
105     layb=planes[0];
106     layg=planes[1];
107     layr=planes[2];
108     Im_b=planes[0];
109     Im_g=planes[1];
110     Im_r=planes[2];
111 
112     layb.convertTo(layb, CV_32F);
113     layg.convertTo(layg, CV_32F);
114     layr.convertTo(layr, CV_32F);
115 
116     Im_b.convertTo(Im_b, CV_32F);
117     Im_g.convertTo(Im_g, CV_32F);
118     Im_r.convertTo(Im_r, CV_32F);
119 
120 
121     for (int j=0; j<dimr; j++) {
122         for (int i=0; i<dimc; i++) {
123         // process each pixel ---------------------
124         layb.at<float>(j,i)=layb.at<float>(j,i)/Air_b;
125 
126         layg.at<float>(j,i)=layg.at<float>(j,i)/Air_g;
127 
128         layr.at<float>(j,i)=layr.at<float>(j,i)/Air_r;
129         // end of pixel processing ----------------
130         } // end of line
131     }
132 
133 
134     rawtemp.convertTo(rawtemp,CV_32F);
135 
136 
137     for(int j=0;j<dimr;j++){
138         for(int i=0;i<dimc;i++){
139             float min;
140             layb.at<float>(j,i) >= layg.at<float>(j,i)?
141                min=layg.at<float>(j,i):
142                min=layb.at<float>(j,i);
143             if(min>=layr.at<float>(j,i))
144                 min=layr.at<float>(j,i);
145             rawtemp.at<float>(j,i)=min;
146         }
147     }
148     for(int j=0;j<dimr;j++){
149         for(int i=0;i<dimc;i++){
150             float min=1;
151 
152             int jlow=j-dx;int jhigh=j+dx;
153             int ilow=i-dx;int ihigh=i+dx;
154 
155             if(ilow<=0)
156                 ilow=0;
157             if(ihigh>=dimc)
158                 ihigh=dimc-1;
159             if(jlow<=0)
160                 jlow=0;
161             if(jhigh>=dimr)
162                 jhigh=dimr-1;
163 
164             for(int m=jlow;m<=jhigh;m++){
165                 for(int n=ilow;n<=ihigh;n++){
166                     if(min>=rawtemp.at<float>(m,n))
167                         min=rawtemp.at<float>(m,n);
168                 }
169             }
170            rawImage.at<uchar>(j,i)=(1-(float)fog_reservation_factor*min)*255;
171         }
172     }
173 
174    refinedImage_temp=guildedfilter_color(image,rawImage,localwindowsize,eps);
175 
176    for(int j=0;j<dimr;j++){
177        for(int i=0;i<dimc;i++){
178            if(refinedImage_temp.at<float>(j,i)<0.1)
179                refinedImage_temp.at<float>(j,i)=0.1;
180        }
181    }
182 
183    cv::Mat onemat(dimr,dimc,CV_32F,cv::Scalar(1));
184 
185    cv::Mat air_bmat(dimr,dimc,CV_32F);
186    cv::Mat air_gmat(dimr,dimc,CV_32F);
187    cv::Mat air_rmat(dimr,dimc,CV_32F);
188 
189    cv::addWeighted(onemat,Air_b,onemat,0,0,air_bmat);
190    cv::addWeighted(onemat,Air_g,onemat,0,0,air_gmat);
191    cv::addWeighted(onemat,Air_r,onemat,0,0,air_rmat);
192 
193 
194    output_b_temp=Im_b-air_bmat;
195    output_g_temp=Im_g-air_gmat;
196    output_r_temp=Im_r-air_rmat;
197 
198    output_b_temp=output_b_temp.mul(1/refinedImage_temp,1)+air_bmat;
199    output_g_temp=output_g_temp.mul(1/refinedImage_temp,1)+air_gmat;
200    output_r_temp=output_r_temp.mul(1/refinedImage_temp,1)+air_rmat;
201 
202 
203    output_b_temp.convertTo(output_b_temp,CV_8U);
204    output_g_temp.convertTo(output_g_temp,CV_8U);
205    output_r_temp.convertTo(output_r_temp,CV_8U);
206 
207    for(int j=0;j<dimr;j++){
208        for(int i=0;i<dimc;i++){
209            output_temp.at<cv::Vec3b>(j,i)[0]=output_b_temp.at<uchar>(j,i);
210            output_temp.at<cv::Vec3b>(j,i)[1]=output_g_temp.at<uchar>(j,i);
211            output_temp.at<cv::Vec3b>(j,i)[2]=output_r_temp.at<uchar>(j,i);
212        }
213    }
214 
215    cv::Mat nom_255(dimr,dimc,CV_32F,cv::Scalar(255));
216 
217    cv::Mat ref_temp(dimr,dimc,CV_32F);
218    ref_temp=refinedImage_temp;
219    ref_temp=ref_temp.mul(nom_255,1);
220    ref_temp.convertTo(refinedImage,CV_8U);
221 
222 
223     return output_temp;
224 }
225 cv::Mat Dehazor::boxfilter(cv::Mat &im, int r)
226 {
227     //im is a CV_32F type mat [0,1] (normalized)
228     //output is the same size to im;
229 
230     int hei=im.rows;
231     int wid=im.cols;
232     cv::Mat imDst;
233     cv::Mat imCum;
234 
235 
236     imDst=cv::Mat::zeros(hei,wid,CV_32F);
237     imCum.create(hei,wid,CV_32F);
238 
239     //cumulative sum over Y axis
240     for(int i=0;i<wid;i++){
241         for(int j=0;j<hei;j++){
242             if(j==0)
243                 imCum.at<float>(j,i)=im.at<float>(j,i);
244             else
245                 imCum.at<float>(j,i)=im.at<float>(j,i)+imCum.at<float>(j-1,i);
246         }
247     }
248 
249 
250     //difference over Y axis
251     for(int j=0;j<=r;j++){
252         for(int i=0;i<wid;i++){
253             imDst.at<float>(j,i)=imCum.at<float>(j+r,i);
254         }
255     }
256     for(int j=r+1;j<=hei-r-1;j++){
257         for(int i=0;i<wid;i++){
258             imDst.at<float>(j,i)=imCum.at<float>(j+r,i)-imCum.at<float>(j-r-1,i);
259         }
260     }
261     for(int j=hei-r;j<hei;j++){
262         for(int i=0;i<wid;i++){
263             imDst.at<float>(j,i)=imCum.at<float>(hei-1,i)-imCum.at<float>(j-r-1,i);
264         }
265     }
266 
267 
268     //cumulative sum over X axis
269       for(int j=0;j<hei;j++){
270           for(int i=0;i<wid;i++){
271               if(i==0)
272                   imCum.at<float>(j,i)=imDst.at<float>(j,i);
273               else
274                   imCum.at<float>(j,i)=imDst.at<float>(j,i)+imCum.at<float>(j,i-1);
275           }
276       }
277       //difference over X axis
278       for(int j=0;j<hei;j++){
279           for(int i=0;i<=r;i++){
280               imDst.at<float>(j,i)=imCum.at<float>(j,i+r);
281           }
282       }
283       for(int j=0;j<hei;j++){
284           for(int i=r+1;i<=wid-r-1;i++){
285               imDst.at<float>(j,i)=imCum.at<float>(j,i+r)-imCum.at<float>(j,i-r-1);
286           }
287       }
288       for(int j=0;j<hei;j++){
289           for(int i=wid-r;i<wid;i++){
290               imDst.at<float>(j,i)=imCum.at<float>(j,wid-1)-imCum.at<float>(j,i-r-1);
291           }
292       }
293 
294     return imDst;
295 }
296 cv::Mat Dehazor::guildedfilter_color(const cv::Mat &Img, cv::Mat &p, int r, float &epsi)
297 {
298 
299     int hei=p.rows;
300     int wid=p.cols;
301 
302     cv::Mat matOne(hei,wid,CV_32F,cv::Scalar(1));
303     cv::Mat N;
304 
305     N=boxfilter(matOne,r);
306 
307 
308 
309     cv::Mat mean_I_b(hei,wid,CV_32F);
310     cv::Mat mean_I_g(hei,wid,CV_32F);
311     cv::Mat mean_I_r(hei,wid,CV_32F);
312     cv::Mat mean_p(hei,wid,CV_32F);
313 
314 
315     cv::Mat Ip_b(hei,wid,CV_32F);
316     cv::Mat Ip_g(hei,wid,CV_32F);
317     cv::Mat Ip_r(hei,wid,CV_32F);
318     cv::Mat mean_Ip_b(hei,wid,CV_32F);
319     cv::Mat mean_Ip_g(hei,wid,CV_32F);
320     cv::Mat mean_Ip_r(hei,wid,CV_32F);
321     cv::Mat cov_Ip_b(hei,wid,CV_32F);
322     cv::Mat cov_Ip_g(hei,wid,CV_32F);
323     cv::Mat cov_Ip_r(hei,wid,CV_32F);
324 
325     cv::Mat II_bb(hei,wid,CV_32F);
326     cv::Mat II_gg(hei,wid,CV_32F);
327     cv::Mat II_rr(hei,wid,CV_32F);
328     cv::Mat II_bg(hei,wid,CV_32F);
329     cv::Mat II_br(hei,wid,CV_32F);
330     cv::Mat II_gr(hei,wid,CV_32F);
331 
332     cv::Mat var_I_bb(hei,wid,CV_32F);
333     cv::Mat var_I_gg(hei,wid,CV_32F);
334     cv::Mat var_I_rr(hei,wid,CV_32F);
335     cv::Mat var_I_bg(hei,wid,CV_32F);
336     cv::Mat var_I_br(hei,wid,CV_32F);
337     cv::Mat var_I_gr(hei,wid,CV_32F);
338 
339     cv::Mat layb;
340     cv::Mat layg;
341     cv::Mat layr;
342     cv::Mat P_32;
343 
344     // create vector of 3 images
345     std::vector<cv::Mat> planes;
346     // split 1 3-channel image into 3 1-channel images
347     cv::split(Img,planes);
348 
349     layb=planes[0];
350     layg=planes[1];
351     layr=planes[2];
352 
353     layb.convertTo(layb, CV_32F);
354     layg.convertTo(layg, CV_32F);
355     layr.convertTo(layr, CV_32F);
356 
357     p.convertTo(P_32,CV_32F);
358     cv::Mat nom_255(hei,wid,CV_32F,cv::Scalar(255));
359 
360 
361 
362     layb=layb.mul(1/nom_255,1);
363     layg=layg.mul(1/nom_255,1);
364     layr=layr.mul(1/nom_255,1);
365     P_32=P_32.mul(1/nom_255,1);
366 
367     cv::Mat mean_I_b_temp=boxfilter(layb,r);
368     cv::Mat mean_I_g_temp=boxfilter(layg,r);
369     cv::Mat mean_I_r_temp=boxfilter(layr,r);
370     cv::Mat mean_p_temp=boxfilter(P_32,r);
371 
372     mean_I_b=mean_I_b_temp.mul(1/N,1);
373     mean_I_g=mean_I_g_temp.mul(1/N,1);
374     mean_I_r=mean_I_r_temp.mul(1/N,1);
375     mean_p=mean_p_temp.mul(1/N,1);
376 
377     Ip_b=layb.mul(P_32,1);
378     Ip_g=layg.mul(P_32,1);
379     Ip_r=layr.mul(P_32,1);
380 
381     cv::Mat mean_Ip_b_temp=boxfilter(Ip_b,r);
382     cv::Mat mean_Ip_g_temp=boxfilter(Ip_g,r);
383     cv::Mat mean_Ip_r_temp=boxfilter(Ip_r,r);
384 
385     mean_Ip_b=mean_Ip_b_temp.mul(1/N,1);
386     mean_Ip_g=mean_Ip_g_temp.mul(1/N,1);
387     mean_Ip_r=mean_Ip_r_temp.mul(1/N,1);
388 
389     cov_Ip_b=mean_Ip_b-mean_I_b.mul(mean_p,1);
390     cov_Ip_g=mean_Ip_g-mean_I_g.mul(mean_p,1);
391     cov_Ip_r=mean_Ip_r-mean_I_r.mul(mean_p,1);
392 
393 
394 //     variance of I in each local patch: the matrix Sigma in Eqn (14).
395 //     Note the variance in each local patch is a 3x3 symmetric matrix:
396 //                   bb, bg, br
397 //           Sigma = bg, gg, gr
398 //                   br, gr, rr
399     II_bb=layb.mul(layb,1);
400     II_gg=layg.mul(layg,1);
401     II_rr=layr.mul(layr,1);
402     II_bg=layb.mul(layg,1);
403     II_br=layb.mul(layr,1);
404     II_gr=layg.mul(layr,1);
405 
406     cv::Mat bb_box=boxfilter(II_bb,r);
407     cv::Mat gg_box=boxfilter(II_gg,r);
408     cv::Mat rr_box=boxfilter(II_rr,r);
409     cv::Mat bg_box=boxfilter(II_bg,r);
410     cv::Mat br_box=boxfilter(II_br,r);
411     cv::Mat gr_box=boxfilter(II_gr,r);
412 
413     var_I_bb=bb_box.mul(1/N,1)-mean_I_b.mul(mean_I_b);
414     var_I_gg=gg_box.mul(1/N,1)-mean_I_g.mul(mean_I_g);
415     var_I_rr=rr_box.mul(1/N,1)-mean_I_r.mul(mean_I_r);
416     var_I_bg=bg_box.mul(1/N,1)-mean_I_b.mul(mean_I_g);
417     var_I_br=br_box.mul(1/N,1)-mean_I_b.mul(mean_I_r);
418     var_I_gr=gr_box.mul(1/N,1)-mean_I_g.mul(mean_I_r);
419 
420     cv::Mat a_b(hei,wid,CV_32F);
421     cv::Mat a_g(hei,wid,CV_32F);
422     cv::Mat a_r(hei,wid,CV_32F);
423 
424     cv::Mat b(hei,wid,CV_32F);
425     cv::Mat sigma(3,3,CV_32F,cv::Scalar(0));
426     cv::Mat inv_sigma(3,3,CV_32F);
427 
428     for(int j=0;j<hei;j++){
429         for(int i=0;i<wid;i++){
430             sigma.at<float>(0,0)=var_I_rr.at<float>(j,i)+epsi;
431             sigma.at<float>(0,1)=var_I_gr.at<float>(j,i);
432             sigma.at<float>(0,2)=var_I_br.at<float>(j,i);
433             sigma.at<float>(1,0)=var_I_gr.at<float>(j,i);
434             sigma.at<float>(2,0)=var_I_br.at<float>(j,i);
435             sigma.at<float>(1,1)=var_I_gg.at<float>(j,i)+epsi;
436             sigma.at<float>(2,2)=var_I_bb.at<float>(j,i)+epsi;
437             sigma.at<float>(1,2)=var_I_bg.at<float>(j,i);
438             sigma.at<float>(2,1)=var_I_bg.at<float>(j,i);
439             inv_sigma=sigma.inv(cv::DECOMP_LU);
440 
441             a_r.at<float>(j,i)=cov_Ip_r.at<float>(j,i)*inv_sigma.at<float>(0,0)+
442                                cov_Ip_g.at<float>(j,i)*inv_sigma.at<float>(1,0)+
443                                cov_Ip_b.at<float>(j,i)*inv_sigma.at<float>(2,0);
444             a_g.at<float>(j,i)=cov_Ip_r.at<float>(j,i)*inv_sigma.at<float>(0,1)+
445                                cov_Ip_g.at<float>(j,i)*inv_sigma.at<float>(1,1)+
446                                cov_Ip_b.at<float>(j,i)*inv_sigma.at<float>(2,1);
447             a_b.at<float>(j,i)=cov_Ip_r.at<float>(j,i)*inv_sigma.at<float>(0,2)+
448                                cov_Ip_g.at<float>(j,i)*inv_sigma.at<float>(1,2)+
449                                cov_Ip_b.at<float>(j,i)*inv_sigma.at<float>(2,2);
450 
451 
452         }
453     }
454     b=mean_p-a_b.mul(mean_I_b,1)-a_g.mul(mean_I_g,1)-a_r.mul(mean_I_r,1);
455 
456     cv::Mat box_ab=boxfilter(a_b,r);
457     cv::Mat box_ag=boxfilter(a_g,r);
458     cv::Mat box_ar=boxfilter(a_r,r);
459     cv::Mat box_b=boxfilter(b,r);
460     cv::Mat q(hei,wid,CV_32F);
461 
462 
463     q=box_ab.mul(layb,1)+box_ag.mul(layg,1)+box_ar.mul(layr,1)+box_b;
464     q=q.mul(1/N,1);
465 
466 
467     return q;
468 
469 }

复制代码

截图：

查看全文
如若内容造成侵权/违法违规/事实不符，请联系编程学习网邮箱：809451989@qq.com进行投诉反馈，一经查实，立即删除！

游标的属性方法以及在实际开发中的应用
把前三个月以及当前的时间设置为默认值获取下拉框的选项 def MySQLdb_BM_connect():return pymysql.connect(host127.0.0.1,port3306,userjibu, passwd密码, db数据库名,charsetutf8)def get_connect_and_cursor_from_bm():conn Nonecursor Nonetry:#获取数据库连接对象co…...
2024/4/21 18:03:00
c++一行代码太长
对于语句，直接回车换行就可以了。如果定义宏，则要用“\”作为“续行符”...
2024/4/21 18:02:59
Java实现矩阵对角线元素之和
一、题目定义一个二维数组用于存储一个矩阵的元素值，并求出这个矩阵的对角线元素之和，然后输出计算结果。二、分析左对角线：行列相等，即i j 右对角线：行列相加等于行数减一，即 ij array.length -1 三…...
2024/4/21 18:02:57
Failed to execute ‘postMessage‘ on ‘DOMWindow‘:
要做的是两个跨域页面传输传大量的数据,由于url有长度限制,所以拼接的方式行不通,后来查到可以用postmessage来做: <iframeid"myIframe"style"display: none":src"ifSrc"frameborder"0"></iframe>在页面中添加一个iframe…...
2024/4/28 1:03:41
打印机出现“你不能访问此共享文件夹，因为你组织的安全策略阻止未经身份验证的来宾访问。
其实这个很简单的，有的人看到这个问题不知道怎么解决，接下来我来教给你怎么解决这个问题，其实一共就三步，看下面： 1.winR 输入gpedit.msc 2.找到计算机配置，点开，找到管理模板，然后…...
2024/4/27 22:29:58
Detours学习之四：拦截二进制函数
拦截二进制函数 Detours库支持拦截函数调用。拦截代码在运行时动态应用。Detours将目标函数的前几个指令替换为无条件跳转到用户提供的detour函数。来自目标函数的指令保存在 trampoline函数中。 trampoline 由从目标函数中删除的指令和无条件地转移到目标函数的其余部分组成。…...
2024/4/28 2:24:13
## 一、单例模式
由普通类和代理类两个部分组成单例模式普通类 CreateDiv，创建div并添加到body中 var CreateDiv function (html) {this.html html;this.init(); }; CreateDiv.prototype.init function () {var div document.createElement(div);div.innerHTML this.html…...
2024/4/21 18:02:53
一个线程池的例子
https://segmentfault.com/a/1190000005876711 主要是ThreadPoolExecutor的参数. 中的queen和池子里超过最大数量后的处理策略...
2024/4/21 18:02:52
C语言入门基础知识，图片来源于图片右下
1.注：const让变量不具有被修改的属性，但是本质上仍是变量。 2.字符串用“”引起来，字符用‘’引起来。“字符串" ‘字符’ 字符串的末尾其实隐藏一个‘\0’。 \0是字符串结束的标志 3. 4. 5.C语言中有两种注释方式，C99之…...
2024/4/21 18:02:51
124. 二叉树中的最大路径和
124. 二叉树中的最大路径和题目描述思路分析代码实现题目描述点这里思路分析二叉树树上dp 所有答案对应树的最高点是确定的，因此我们枚举最高点。我们发现树最高的答案可以通过子树递归求，因此可以树上dp。f[root]root−>valmax(max(0,f[root−…...
2024/4/21 18:02:50
Anaconda如何在创建的环境中打开Jupyter NoteBook
1.创建虚拟环境 > conda create -n 环境名 python版本号2.进入环境 > activate 环境名3.安装ipykernel > pip install ipykernel4.将虚拟环境添加到内核 > python -m ipykernel install --name环境名打开jupyter notebook 创建文件时选择你创建的环境即可。参…...
2024/4/21 18:02:49
端口宏定义-led实例
宏定义： #define LED0_Pin GPIO_PIN_9 #define LED0_GPIO_Port GPIOF #define LED1_Pin GPIO_PIN_10 #define LED1_GPIO_Port GPIOF #define LED0_PIN LED0_GPIO_Port, LED0_Pin #define LED1_PIN LED1_GPIO_Port, LED1_Pin …...
2024/4/21 18:02:49
JS · 工具：vConsole.js移动端调试
在做微信公众号开发的时候，时常要调微信接口。在电脑浏览器上无法模拟，出现问题很难排查。只能通过电脑连接手机去查看log，这儿介绍一个快捷的方法，在手机前端页面直接查看打印信息。 vConsole前端调试面板 vConsole是一款由微信…...
2024/4/20 13:38:28
前端post请求Content-Type和后端对应的接收参数方式
今天遇到一个奇葩问题，废了大半天，原来是没有理解前端发送http请求传参方式，不同的content-type会进行不同传参，后台也要用不同的方式接受，在此记录一下； 我们的程序使用的是前后端分离，前端使用…...
2024/4/28 1:53:30
QT 设计透明窗口(视频上方)
头文件 class MyAutoCloseFrameBase : public QFrame {Q_OBJECTpublic:MyAutoCloseFrameBase(QWidget *parent,int keeptime 2000);//msec~MyAutoCloseFrameBase();void resetAutoClock(bool isable true);void SetLabelText(QString text); protected:bool event(QEvent *e…...
2024/4/20 5:17:36
广度优先算法
伪代码 //广度优先算法，类似于二叉树的层次遍历 /* 利用队列实现搜索首先访问起始顶点v,接着由v出发，依次访问v的各个未访问的邻接结点w1,w2,,, 然后依次访问w1,w2,wi这些所有没有被访问的结点再从这些访问过的顶点出发，访问它们所有未被访…...
2024/4/20 13:38:25
js 三级运算表达式运用
1.动态样式里三级表达式的写法 <li v-for"(item, index) in listData" :key"index"><div class"ww"><div class"ee">//不同字段表示不同颜色<p class"title2" v-text"item.riskgrade" v…...
2024/4/21 18:02:47
如果在 SpringBoot核心配置文件中有中文信息，会出现乱码
1.一般建议在配置文件中，不建议出现中文（注释除外） 2。如果有，请看下面步骤： 点击左上角的file 再点击settings进入设置温馨提醒：大家如果从其他地方拷贝的配置文件，一定要把里面的空格删除干…...
2024/4/21 18:02:46
设计模式之装饰模式：如何在基础组件上扩展新功能？
在前面几讲中，我们已经学习了结构型模式中的适配器模式、桥接模式和组合模式。而今天我们要介绍的装饰模式看上去和适配器模式、桥接模式很相似，都是使用组合方式来扩展原有类的，但其实本质上却相差甚远呢。简单来说，适配器模式侧…...
2024/4/21 18:02:45
Clickhouse(4)---Clickhouse语法
Clickhouse语法DDL基础创建表方式1方式2方式3修改表DML基础插入数据方式1方式2方式3更新删除数据操作数据条件删除数据条件更新数据通过操作分区操作数据创建分区查看分区删除分区复制分区卸载分区装载分区重置分区数据视图普通视图物化视图DDL基础 clickhouse建表必须指定引擎…...
2024/4/21 18:02:45

基于暗通道优先算法的去雾应用(Matlab/C++)

基于暗通道优先的单幅图像去雾算法（Matlab/C++）

相关文章

最新文章