0
0

毕业设计-基于 MATLAB 的图像去雾技术研究

前言

  1.  📅大四是整个大学期间最忙碌的时光,一边要忙着备考或实习为毕业后面临的就业升学做准备,一边要为毕业设计耗费大量精力。近几年各个学校要求的毕设项目越来越难,有不少课题是研究生级别难度的,对本科同学来说是充满挑战。为帮助大家顺利通过和节省时间与精力投入到更重要的就业和考试中去,学长分享优质的选题经验和毕设项目与技术思路。

🚀对毕设有任何疑问都可以问学长哦!

选题指导: https://blog.csdn.net/qq_37340229/article/details/128243277

大家好,这里是海浪学长毕设专题,本次分享的课题是

🎯基于 MATLAB 的图像去雾技术研究

课题背景和意义

工业促进了人类社会的发展，随之而来的是空气污染越来越严重，空气中悬浮的尘粒和水滴在大气光的散射和吸收下形成雾霾。雾霾天气条件下，自然光受空气中悬浮粒子的干扰发生散射，使所获取的户外图像对比度和色彩饱和度降低，图像细节模糊不清，其视觉效果会显著降低，从而限制了景物的识别，造成一些户外图像采集装置无法正常工作。计算机视觉应用领域，如智能交通、遥感探测、安全监控等，其有效性与采集到的图像的可视性息息相关，对图像质量要求较高。因此，对雾霾天气所采集的退化图像做清晰化处理具有重要的现实意义。目前，图像去雾算法主要分为两类：一类是基于图像特征的去雾算法，即图像增强算法，另一类是基于物理模型的去雾算法，即图像复原算法。基于图像特征的去雾算法主要通过增强图像的对比度，突出图像细节，改善整体视觉效果达到去雾目的，不考虑图像降质的原因，实用性强，但可能会造成信息损失或过增强现象。基于物理模型的去雾算法则是根据大气散射原理构建图像退化模型进行计算去除雾气影响，大气散射的物理模型直观表达了雾天图像的退化原因，为图像去雾研究工作奠定了坚实的基础。

实现技术思路

一、常用图像去雾算法

直方图均衡化算法原理

图像直方图表示的是图像中每一灰度级出现的概率情况。假设一幅图像具有 N 个像素，r k 表示第 k 个灰度级对应的灰度，L 表示灰度级个数，nk 表示灰度 r k 的像素个数，则直方图可定义为：

直方图均衡化的基本思想是将原始图像的灰度直方图变换成均匀分布的形式，增加了像素

灰度值的动态范围，提高了图像整体对比度。

** 多尺度 Retinex（MSR）算法原理**

Retinex 理论即视网膜大脑皮层理论，该理论认为物体色彩主要取决于物体表面对红绿蓝 3 种光线的反射能力，不受光线的反射强度和光照非均匀性的影响，成像过程可表示为：

式中，I ( x,y ) 表示原始图像，R ( x,y ) 表示反射图像，L( x,y ) 表示入射光照图像。Retinex 算法的 原理是分离图像中的入射光照分量，保留能反映图像细节信息的反射分量。进行对数 运算，有

采用高斯环绕函数与原始图像的卷积来对入射光照分量进行估计，则第 i 条颜色通道经 SSR 算法处理后得到的反射分量 rSSRi ( x,y )可表示为：

为弥补该算法尺度单一、难以平衡图像动态范围压缩能力和色彩保真性的缺点， 提出了 MSR 算法，该算法的实质是对多个不同尺度的 SSR 算法结果的加权平均，可表示为

**暗通道先验去雾算法原理 **

雾天降质图像可用大气散射模型描述如下：

暗通道先验理论即在绝大多数户外无雾图像非天空区域内，总有大量像素在某个颜色通道上具有很小的亮度值，这个颜色通道即是暗通道。对于非天空区域的清晰无雾图像 *J *( *x *)，其暗通道 *J *dark ( *x *)强度值总是趋近于 0，即

式中，J c ( y )表示图像 J 的 R、G、B 3 个通道中的某个通道，Ω( x )表示以像素 x 为中心的窗口区域。 假设大气光值 A 是已知的，估计初始透射率

引入参数 *ω *使复原后的图像保留一定的雾感避免出现失真，复原无雾图像

二、基于 MATLAB 的图像去雾系统

系统结构

图像去雾系统以 MATLAB R2018b 为平台，对可视化的图形用户界面 GUI 进行设计，通 过用户界面的菜单和控件实现相应功能的调用，便于功能演示，增加了软件交互的易用性。图像 86 2020 年第 6 期 去雾系统集成了全局直方图均衡化、局部直方图均衡化、多尺度 Retinex、暗通道先验 4 种经典去 雾算法。

该系统能够通过菜单关联不同的去雾算法，主窗口加入坐标轴控件用于图像显示，以原 始图像作为输入，经去雾算法处理后的复原图像作为输出，通过显示原始图像和去雾图像演示不 同算法的去雾性能。 系统结构图和主界面设计图分别如图所示。

运用该系统实现图像去雾具体流程如下：

1）打开 MATLAB 软件，选择相应的“.fig”文件，可进入图像去雾系统主界面；

2）通过主界面功能区的“打开文件”菜单，选择任意一幅自然带雾图像，载入待处理图像，并在图像显示区域的坐标轴控件中显示；

3）通过“选择去雾算法”菜单分别调用全局直方图均衡化算法、局部直方图均衡化算法、多尺度Retinex 算法和暗通道先验算法对原始带雾图像进行去雾处理，同时在图像显示区域显示去 雾后的图像，另外针对全局直方图均衡化算法和局部直方图均衡化算法，该系统还能通过显示处

理前后的图像灰度直方图对比去雾效果；

4）通过“保存图像”菜单将处理后的图像保存在相应的文件夹中；

5）通过“退出系统”菜单退出图像去雾系统。

**系统演示 **

针对描述的全局直方图均衡化、局部直方图均衡化、多尺度 Retinex、暗通道先验 4 种常用去雾算法，图像去雾系统运行效果如图所示。

全局直方图均衡化算法：

局部直方图均衡化算法：

全局直方图均衡化算法直方图对比：

局部直方图均衡化算法直方图对比：

多尺度 Retinex 算法：

暗通道先验算法：

三、图像质量评价

图像质量评价方法通常可分为主观评价方法和客观评价方法。

主观评价

主观评价是以观察者对图像的主观视觉感受作为评价标准。该图像去雾系统能够显示原始图像和去雾图像，以原始图像为参考，通过观察不同算法的去雾结果图像对比去雾效果。

客观评价

客观评价则是通过不同的评价指标对图像质量进行客观分析。以图像的标准差、峰值信噪比、信息熵和算法运行时间 4 个方面作为评价指标，统计记录了标准差、峰值信噪比、信息熵和运行时间进一步比较各算法性能。

不同算法性能比较

部分源代码

  1. # Copyright (c) Microsoft Corporation.
  2. # Licensed under the MIT License.
  3.   
  4. import os.path
  5. import io
  6. import zipfile
  7. from data.base_dataset import BaseDataset, get_params, get_transform, normalize
  8. from data.image_folder import make_dataset
  9. import torchvision.transforms as transforms
  10. from data.Load_Bigfile import BigFileMemoryLoader
  11. from data.Load_Bigfilev2 import BigFileMemoryLoaderv2
  12.   
  13. from io import BytesIO
  14. import os
  15. import glob
  16. import cv2, math
  17. import random
  18. import numpy as np
  19. import h5py
  20. import os
  21. from PIL import Image
  22. import scipy.io
  23.   
  24. def pil_to_np(img_PIL):
  25.     '''Converts image in PIL format to np.array.
  26.     From W x H x C [0...255] to C x W x H [0..1]
  27.     '''
  28.     ar = np.array(img_PIL)
  29.   
  30.     if len(ar.shape) == 3:
  31.         ar = ar.transpose(2, 0, 1)
  32.     else:
  33.         ar = ar[None, ...]
  34.   
  35.     return ar.astype(np.float32) / 255.
  36.   
  37.   
  38. def np_to_pil(img_np):
  39.     '''Converts image in np.array format to PIL image.
  40.     From C x W x H [0..1] to  W x H x C [0...255]
  41.     '''
  42.     ar = np.clip(img_np * 255, 0, 255).astype(np.uint8)
  43.   
  44.     if img_np.shape[0] == 1:
  45.         ar = ar[0]
  46.     else:
  47.         ar = ar.transpose(1, 2, 0)
  48.   
  49.     return Image.fromarray(ar)
  50.   
  51. def synthesize_salt_pepper(image,amount,salt_vs_pepper):
  52.   
  53.     ## Give PIL, return the noisy PIL
  54.   
  55.     img_pil=pil_to_np(image)
  56.   
  57.     out = img_pil.copy()
  58.     p = amount
  59.     q = salt_vs_pepper
  60.     flipped = np.random.choice([True, False], size=img_pil.shape,
  61.                                p=[p, 1 - p])
  62.     salted = np.random.choice([True, False], size=img_pil.shape,
  63.                               p=[q, 1 - q])
  64.     peppered = ~salted
  65.     out[flipped & salted] = 1
  66.     out[flipped & peppered] = 0.
  67.     noisy = np.clip(out, 0, 1).astype(np.float32)
  68.   
  69.   
  70.     return np_to_pil(noisy)
  71.   
  72. def synthesize_gaussian(image,std_l,std_r):
  73.   
  74.     ## Give PIL, return the noisy PIL
  75.   
  76.     img_pil=pil_to_np(image)
  77.   
  78.     mean=0
  79.     std=random.uniform(std_l/255.,std_r/255.)
  80.     gauss=np.random.normal(loc=mean,scale=std,size=img_pil.shape)
  81.     noisy=img_pil+gauss
  82.     noisy=np.clip(noisy,0,1).astype(np.float32)
  83.   
  84.     return np_to_pil(noisy)
  85.   
  86. def synthesize_speckle(image,std_l,std_r):
  87.   
  88.     ## Give PIL, return the noisy PIL
  89.   
  90.     img_pil=pil_to_np(image)
  91.   
  92.     mean=0
  93.     std=random.uniform(std_l/255.,std_r/255.)
  94.     gauss=np.random.normal(loc=mean,scale=std,size=img_pil.shape)
  95.     noisy=img_pil+gauss*img_pil
  96.     noisy=np.clip(noisy,0,1).astype(np.float32)
  97.   
  98.     return np_to_pil(noisy)
  99.   
  100.   
  101. def synthesize_low_resolution(img):
  102.     w,h=img.size
  103.   
  104.     new_w=random.randint(int(w/2),w)
  105.     new_h=random.randint(int(h/2),h)
  106.   
  107.     img=img.resize((new_w,new_h),Image.BICUBIC)
  108.   
  109.     if random.uniform(0,1)<0.5:
  110.         img=img.resize((w,h),Image.NEAREST)
  111.     else:
  112.         img = img.resize((w, h), Image.BILINEAR)
  113.   
  114.     return img
  115.   
  116.   
  117.   
  118.   
  119. def convertToJpeg(im,quality):
  120.     with BytesIO() as f:
  121.         im.save(f, format='JPEG',quality=quality)
  122.         f.seek(0)
  123.         return Image.open(f).convert('RGB')
  124.   
  125.   
  126. def blur_image_v2(img):
  127.   
  128.   
  129.     x=np.array(img)
  130.     kernel_size_candidate=[(3,3),(5,5),(7,7)]
  131.     kernel_size=random.sample(kernel_size_candidate,1)[0]
  132.     std=random.uniform(1.,5.)
  133.   
  134.     #print("The gaussian kernel size: (%d,%d) std: %.2f"%(kernel_size[0],kernel_size[1],std))
  135.     blur=cv2.GaussianBlur(x,kernel_size,std)
  136.   
  137.     return Image.fromarray(blur.astype(np.uint8))
  138. def perlin_noise(im,varargin):
  139.     """
  140.         This is the function for adding perlin noise to the depth map. It is a
  141.     simplified implementation of the paper:
  142.     an image sunthesizer
  143.     Ken Perlin, SIGGRAPH, Jul. 1985
  144.     The bicubic interpolation is used, compared to the original version.
  145.     Reference:
  146.     HAZERD: an outdoor scene dataset and benchmark for single image dehazing
  147.     IEEE International Conference on Image Processing, Sep 2017
  148.     The paper and additional information on the project are available at:
  149.     https://labsites.rochester.edu/gsharma/research/computer-vision/hazerd/
  150.     If you use this code, please cite our paper.
  151.     Input:
  152.       im: depth map
  153.       varargin{1}: decay term
  154.     Output:
  155.       im: result of transmission with perlin noise added
  156.     Authors:
  157.       Yanfu Zhang: yzh185@ur.rochester.edu
  158.       Li Ding: l.ding@rochester.edu
  159.       Gaurav Sharma: gaurav.sharma@rochester.edu
  160.     Last update: May 2017
  161.     :return:
  162.     """
  163.     # (h, w, c) = im.shape
  164.     # i = 1
  165.     # if nargin == 1:
  166.     #     decay = 2
  167.     # else:
  168.     #     decay = varargin{1}
  169.     # l_bound = min(h,w)
  170.     # while i <= l_bound:
  171.     #     d = imresize(randn(i, i)*decay, im.shape, 'bicubic')
  172.     #     im = im+d
  173.     #     i = i*2
  174.     # im = c(im);
  175.     # return im
  176.     pass
  177.   
  178. def srgb2lrgb(I0):
  179.     gamma = ((I0 + 0.055) / 1.055)**2.4
  180.     scale = I0 / 12.92
  181.     return np.where (I0 > 0.04045, gamma, scale)
  182.   
  183. def lrgb2srgb(I1):
  184.     gamma =  1.055*I1**(1/2.4)-0.055
  185.     scale = I1 * 12.92
  186.     return np.where (I1 > 0.0031308, gamma, scale)
  187.   
  188. #return : depth matrix
  189. def get_depth(depth_or_trans_name):
  190.     #depth_or_trans_name为mat类型文件或者img类型文件地址
  191.     data = scipy.io.loadmat(depth_or_trans_name)
  192.     depths = data['imDepth'] #深度变量
  193.     #print(data.keys())  #打印mat文件中所有变量
  194.     depths = np.array(depths)
  195.     return depths
  196.   
  197.   
  198.   
  199.   
  200.   
  201. def irregular_hole_synthesize(img,mask):
  202.   
  203.     img_np=np.array(img).astype('uint8')
  204.     mask_np=np.array(mask).astype('uint8')
  205.     mask_np=mask_np/255
  206.     img_new=img_np*(1-mask_np)+mask_np*255
  207.   
  208.     hole_img=Image.fromarray(img_new.astype('uint8')).convert("RGB")
  209.   
  210.     return hole_img,mask.convert("L")
  211.   
  212. def zero_mask(size):
  213.     x=np.zeros((size,size,3)).astype('uint8')
  214.     mask=Image.fromarray(x).convert("RGB")
  215.     return mask
  216.   
  217. def hazy_simu(img_name,depth_or_trans_name,airlight=0.76,is_imdepth=1): ##for outdoor
  218.     """
  219.     This is the function for haze simulation with the parameters given by
  220.     the paper:
  221.     HAZERD: an outdoor scene dataset and benchmark for single image dehazing
  222.     IEEE Internation Conference on Image Processing, Sep 2017
  223.     The paper and additional information on the project are available at:
  224.     https://labsites.rochester.edu/gsharma/research/computer-vision/hazerd/
  225.     If you use this code, please cite our paper.
  226.     IMPORTANT NOTE: The code uses the convention that pixel locations with a
  227.     depth value of 0 correspond to objects that are very far and for the
  228.     simulation of haze these are placed a distance of 2 times the visual
  229.     range.
  230.     Authors:
  231.     Yanfu Zhang: yzh185@ur.rochester.edu
  232.     Li Ding: l.ding@rochester.edu
  233.     Gaurav Sharma: gaurav.sharma@rochester.edu
  234.     Last update: May 2017
  235.     python version update : Aug 2021
  236.     Authors :
  237.     Haoying Sun : 1913434222@qq.com
  238.     parse inputs and set default values
  239.     Set default parameter values. Some of these are used only if they are not
  240.     passed in
  241.     :param img_name: the directory and name of a haze-free RGB image, the name
  242.                      should be in the format of ..._RGB.jpg
  243.     :param depth_name: the corresponding directory and name of the depth map, in
  244.                      .mat file, the name should be in the format of ..._depth.mat
  245.     :param save_dir: the directory to save the simulated images
  246.     :param pert_perlin: 1 for adding perlin noise, default 0
  247.     :param airlight:  3*1 matrix in the range [0,1]
  248.     :param visual_range: a vector of any size
  249.     :return: image name of hazy image
  250.     """
  251.     # if random.uniform(0, 1) < 0.5:
  252.     visual_range = [0.05, 0.1, 0.2, 0.5, 1]  #  visual range in km #可自行调整，或者使用range函数设置区间，此时需要修改beta_param,尚未研究
  253.     beta_param = 3.912     #Default beta parameter corresponding to visual range of 1000m
  254.   
  255.     A = airlight
  256.     #print('Simulating hazy image for:{}'.format(img_name))
  257.     VR = random.choice(visual_range)
  258.   
  259.     #print('Viusal value: {} km'.format(VR) )
  260.     #im1 = cv2.imread(img_name)
  261.     img_pil = pil_to_np(img_name)
  262.   
  263.     #convert sRGB to linear RGB
  264.     I = srgb2lrgb(img_pil)
  265.   
  266.     if is_imdepth:
  267.         depths = depth_or_trans_name
  268.   
  269.         d = depths/1000   # convert meter to kilometer
  270.         if depths.max()==0:
  271.             d = np.where(d == 0,0.01, d) ####
  272.         else:
  273.             d = np.where(d==0,2*VR,d)
  274.         #Set regions where depth value is set to 0 to indicate no valid depth to
  275.         #a distance of two times the visual range. These regions typically
  276.         #correspond to sky areas
  277.   
  278.         #convert depth map to transmission
  279.         beta = beta_param / VR
  280.         beta_return = beta
  281.         beta = np.ones(d.shape) * beta
  282.         transmission = np.exp((-beta*d))
  283.         transmission_3 = np.array([transmission,transmission,transmission])
  284.   
  285.         #Obtain simulated linear RGB hazy image.Eq. 3 in the HazeRD paper
  286.         Ic = transmission_3 * I + (1 - transmission_3) * A
  287.     else:
  288.         Ic = pil_to_np(depth_or_trans_name) * I + (1 - pil_to_np(depth_or_trans_name)) * A
  289.   
  290.     # convert linear RGB to sRGB
  291.     I2 = lrgb2srgb(Ic)
  292.     haze_img = np_to_pil(I2)
  293.     # haze_img = np.asarray(haze_img)
  294.     # haze_img = cv2.cvtColor(haze_img, cv2.COLOR_RGB2BGR)
  295.     # haze_img = Image.fromarray(haze_img)
  296.     return haze_img,airlight,beta_return
  297.   
  298. def hazy_reside_training(img_name,depth_or_trans_name,is_imdepth=1):
  299.     """
  300.     RESIDE的 training中：A ：(0.7, 1.0) ,   beta：(0.6, 1.8)
  301.     :param img_name:
  302.     :param depth_or_trans_name:
  303.     :param pert_perlin:
  304.     :param is_imdepth:
  305.     :return:
  306.     """
  307.     beta = random.uniform(0.6, 1.8)
  308.     beta_return = beta
  309.     airlight = random.uniform(0.7, 1.0)
  310.   
  311.     A = airlight
  312.   
  313.     #print('Viusal value: {} km'.format(VR) )
  314.     #im1 = cv2.imread(img_name)
  315.     img_pil = pil_to_np(img_name)
  316.   
  317.     #convert sRGB to linear RGB
  318.     I = srgb2lrgb(img_pil)
  319.   
  320.     if is_imdepth:
  321.         depths = depth_or_trans_name
  322.   
  323.         #convert depth map to transmission
  324.         if depths.max()==0:
  325.             d = np.where(depths == 0,1, depths)
  326.         else:
  327.             d = depths / depths.max()
  328.             d = np.where(d == 0, 1, d)
  329.   
  330.         beta = np.ones(d.shape) * beta
  331.         transmission = np.exp((-beta*d))
  332.         transmission_3 = np.array([transmission,transmission,transmission])
  333.   
  334.         #Obtain simulated linear RGB hazy image.Eq. 3 in the HazeRD paper
  335.         Ic = transmission_3 * I + (1 - transmission_3) * A
  336.   
  337.     else:
  338.         Ic = pil_to_np(depth_or_trans_name) * I + (1 - pil_to_np(depth_or_trans_name)) * A
  339.   
  340.     # convert linear RGB to sRGB
  341.     I2 = lrgb2srgb(Ic)
  342.     #I2 = cv2.cvtColor(I2, cv2.COLOR_BGR2RGB)
  343.   
  344.     haze_img = np_to_pil(I2)
  345.     # haze_img = np.asarray(haze_img)
  346.     # haze_img = cv2.cvtColor(haze_img, cv2.COLOR_RGB2BGR)
  347.     # haze_img = Image.fromarray(haze_img)
  348.     return haze_img,airlight,beta_return
  349.   
  350. def hazy_reside_OTS(img_name,depth_or_trans_name,is_imdepth=1):
  351.     """
  352.     RESIDE的 OTS中：A [0.8, 0.85, 0.9, 0.95, 1] ,   beta：[0.04, 0.06, 0.08, 0.1, 0.12, 0.16, 0.2]
  353.     :param img_name:
  354.     :param depth_or_trans_name:
  355.     :param pert_perlin:
  356.     :param is_imdepth:
  357.     :return:
  358.     """
  359.     beta = random.choice([0.04, 0.06, 0.08, 0.1, 0.12, 0.16, 0.2])
  360.     beta_return = beta
  361.     airlight = random.choice([0.8, 0.85, 0.9, 0.95, 1])
  362.     #print(beta)
  363.     #print(airlight)
  364.     A = airlight
  365.   
  366.     #print('Viusal value: {} km'.format(VR) )
  367.     #im1 = cv2.imread(img_name)
  368.   
  369.     #img = cv2.cvtColor(np.asarray(img_name), cv2.COLOR_RGB2BGR)
  370.     img_pil = pil_to_np(img_name)
  371.   
  372.     #convert sRGB to linear RGB
  373.     I = srgb2lrgb(img_pil)
  374.   
  375.     if is_imdepth:
  376.         depths = depth_or_trans_name
  377.         #convert depth map to transmission
  378.         if depths.max()==0:
  379.                 d = np.where(depths == 0, 1, depths)
  380.         else:
  381.             d = depths/(depths.max())
  382.             d = np.where(d == 0, 1, d)
  383.   
  384.         beta = np.ones(d.shape) * beta
  385.         transmission = np.exp((-beta*d))
  386.         transmission_3 = np.array([transmission,transmission,transmission])
  387.   
  388.         #Obtain simulated linear RGB hazy image.Eq. 3 in the HazeRD paper
  389.         Ic = transmission_3 * I + (1 - transmission_3) * A
  390.   
  391.     else:
  392.         Ic = pil_to_np(depth_or_trans_name) * I + (1 - pil_to_np(depth_or_trans_name)) * A
  393.   
  394.     # convert linear RGB to sRGB
  395.     I2 = lrgb2srgb(Ic)
  396.     haze_img = np_to_pil(I2)
  397.   
  398.     #haze_img = np.asarray(haze_img)
  399.     #haze_img = cv2.cvtColor(haze_img, cv2.COLOR_RGB2BGR)
  400.     #haze_img = Image.fromarray(haze_img)
  401.     return haze_img,airlight,beta_return
  402. def online_add_degradation_v2(img,depth_or_trans):
  403.     noise = 0
  404.     task_id=np.random.permutation(4)
  405.     if random.uniform(0,1)<0.3:
  406.         noise = 1
  407.         #print('noise')
  408.         for x in task_id:
  409.             #为增加更多变化，随机进行30%的丢弃，即<0.7
  410.             if x==0 and random.uniform(0,1)<0.7:
  411.                 img = blur_image_v2(img)
  412.             if x==1 and random.uniform(0,1)<0.7:
  413.                 flag = random.choice([1, 2, 3])
  414.                 if flag == 1:
  415.                     img = synthesize_gaussian(img, 5, 50) # Gaussian white noise with σ ∈ [5,50]
  416.                 if flag == 2:
  417.                     img = synthesize_speckle(img, 5, 50)
  418.                 if flag == 3:
  419.                     img = synthesize_salt_pepper(img, random.uniform(0, 0.01), random.uniform(0.3, 0.8))
  420.             if x==2 and random.uniform(0,1)<0.7:
  421.                 img=synthesize_low_resolution(img)
  422.   
  423.             if x==3 and random.uniform(0,1)<0.7:
  424.                 img=convertToJpeg(img,random.randint(40,100))
  425.                 #JPEG compression whose level is in the range of [40,100]
  426.     add_haze = random.choice([1,2,3])
  427.     if add_haze == 1:
  428.         img, airlight, beta  = hazy_reside_OTS(img, depth_or_trans)
  429.     elif add_haze  == 2:
  430.         img, airlight, beta  = hazy_simu(img, depth_or_trans)
  431.     else:
  432.         img, airlight, beta  = hazy_reside_training(img, depth_or_trans)
  433.     # else:
  434.     #     if add_haze < 0.1:
  435.     #         img = hazy_reside_OTS(img, depth_or_trans)
  436.     #     elif add_haze > 0.1 and add_haze < 0.2:
  437.     #         img = hazy_simu(img, depth_or_trans)
  438.     #     else:
  439.     #         img = hazy_reside_training(img, depth_or_trans)
  440.     return img#,noise,airlight,beta
  441.   
  442.   
  443. class UnPairOldPhotos_SR(BaseDataset):  ## Synthetic + Real Old
  444.     def initialize(self, opt):
  445.         self.opt = opt
  446.         self.isImage = 'domainA' in opt.name
  447.         self.task = 'old_photo_restoration_training_vae'
  448.         self.dir_AB = opt.dataroot
  449.         if self.isImage:
  450.   
  451.             self.load_npy_dir_depth=os.path.join(self.dir_AB,"VOC_RGB_Depthnpy.bigfile")
  452.             self.load_img_dir_RGB_old=os.path.join(self.dir_AB,"Real_RGB_old.bigfile")
  453.             self.load_img_dir_clean=os.path.join(self.dir_AB,"VOC_RGB_JPEGImages.bigfile")
  454.   
  455.             self.loaded_npys_depth=BigFileMemoryLoaderv2(self.load_npy_dir_depth)
  456.             self.loaded_imgs_RGB_old=BigFileMemoryLoader(self.load_img_dir_RGB_old)
  457.             self.loaded_imgs_clean=BigFileMemoryLoader(self.load_img_dir_clean)
  458.   
  459.         else:
  460.             # self.load_img_dir_clean=os.path.join(self.dir_AB,self.opt.test_dataset)
  461.             self.load_img_dir_clean=os.path.join(self.dir_AB,"VOC_RGB_JPEGImages.bigfile")
  462.             self.loaded_imgs_clean=BigFileMemoryLoader(self.load_img_dir_clean)
  463.   
  464.             self.load_npy_dir_depth=os.path.join(self.dir_AB,"VOC_RGB_Depthnpy.bigfile")
  465.             self.loaded_npys_depth=BigFileMemoryLoaderv2(self.load_npy_dir_depth)
  466.   
  467.         ####
  468.         print("-------------Filter the imgs whose size <256 in VOC-------------")
  469.         self.filtered_imgs_clean=[]
  470.         self.filtered_npys_depth = []
  471.         for i in range(len(self.loaded_imgs_clean)):
  472.             img_name,img=self.loaded_imgs_clean[i]
  473.             npy_name, npy = self.loaded_npys_depth[i]
  474.             h,w=img.size
  475.             if h<256 or w<256:
  476.                 continue
  477.             self.filtered_imgs_clean.append((img_name,img))
  478.             self.filtered_npys_depth.append((npy_name, npy))
  479.         print("--------Origin image num is [%d], filtered result is [%d]--------" % (
  480.         len(self.loaded_imgs_clean), len(self.filtered_imgs_clean)))
  481.         ## Filter these images whose size is less than 256
  482.   
  483.         # self.img_list=os.listdir(load_img_dir)
  484.         self.pid = os.getpid()
  485.   
  486.     def __getitem__(self, index):
  487.   
  488.   
  489.         is_real_old=0
  490.   
  491.         sampled_dataset=None
  492.         sampled_depthdataset = None
  493.         degradation=None
  494.         if self.isImage: ## domain A , contains 2 kinds of data: synthetic + real_old
  495.             P=random.uniform(0,2)
  496.             if P>=0 and P<1:
  497.                 #if random.uniform(0,1)<0.5:
  498.                     #  buyao  huidutu
  499.                     #sampled_dataset=self.loaded_imgs_L_old
  500.                     #self.load_img_dir=self.load_img_dir_L_old
  501.                     sampled_dataset = self.loaded_imgs_RGB_old
  502.                     self.load_img_dir = self.load_img_dir_RGB_old
  503.   
  504.   
  505.                 # else:
  506.                 #     sampled_dataset=self.loaded_imgs_RGB_old
  507.                 #     self.load_img_dir=self.load_img_dir_RGB_old
  508.   
  509.   
  510.                     is_real_old=1
  511.             if P>=1 and P<2:
  512.                 sampled_dataset=self.filtered_imgs_clean
  513.                 self.load_img_dir=self.load_img_dir_clean
  514.   
  515.                 sampled_depthdataset=self.filtered_npys_depth
  516.                 self.load_npy_dir=self.load_npy_dir_depth
  517.   
  518.                 degradation=1
  519.         else:
  520.   
  521.             sampled_dataset=self.filtered_imgs_clean
  522.             self.load_img_dir=self.load_img_dir_clean
  523.   
  524.             sampled_depthdataset = self.filtered_npys_depth
  525.             self.load_npy_dir = self.load_npy_dir_depth
  526.   
  527.         sampled_dataset_len=len(sampled_dataset)
  528.         #print('sampled_dataset_len::::',sampled_dataset_len)
  529.         index=random.randint(0,sampled_dataset_len-1)
  530.   
  531.         img_name,img = sampled_dataset[index]
  532.         # print(img_name)
  533.         # print(img)
  534.         # print(index)
  535.   
  536.         #print(npy_name)
  537.         #print(npy)
  538.         if degradation is not None:
  539.             npy_name, npy = sampled_depthdataset[index]
  540.             img=online_add_degradation_v2(img,npy)
  541.         path=os.path.join(self.load_img_dir,img_name)
  542.   
  543.         # AB = Image.open(path).convert('RGB')
  544.         # split AB image into A and B
  545.   
  546.         # apply the same transform to both A and B
  547.   
  548.         # if random.uniform(0,1) <0.1:
  549.         #     img=img.convert("L")
  550.         #     img=img.convert("RGB")
  551.         #     ## Give a probability P, we convert the RGB image into L
  552.   
  553.   
  554.         A=img
  555.         w,h=A.size
  556.         if w<256 or h<256:
  557.             A=transforms.Scale(256,Image.BICUBIC)(A)
  558.         ## Since we want to only crop the images (256*256), for those old photos whose size is smaller than 256, we first resize them.
  559.   
  560.         transform_params = get_params(self.opt, A.size)
  561.         A_transform = get_transform(self.opt, transform_params)
  562.   
  563.         B_tensor = inst_tensor = feat_tensor = 0
  564.         A_tensor = A_transform(A)
  565.   
  566.   
  567.         input_dict = {'label': A_tensor, 'inst': is_real_old, 'image': A_tensor,
  568.                         'feat': feat_tensor, 'path': path}
  569.         return input_dict
  570.   
  571.     def __len__(self):
  572.         return len(self.loaded_imgs_clean) ## actually, this is useless, since the selected index is just a random number
  573.   
  574.     def name(self):
  575.         return 'UnPairOldPhotos_SR'
  576.   
  577.   
  578. class PairOldPhotos(BaseDataset):
  579.     def initialize(self, opt):
  580.         self.opt = opt
  581.         self.isImage = 'imagegan' in opt.name
  582.         self.task = 'old_photo_restoration_training_mapping'
  583.         self.dir_AB = opt.dataroot
  584.         if opt.isTrain:
  585.             self.load_img_dir_clean= os.path.join(self.dir_AB, "VOC_RGB_JPEGImages.bigfile")
  586.             self.loaded_imgs_clean = BigFileMemoryLoader(self.load_img_dir_clean)
  587.   
  588.             self.load_npy_dir_depth= os.path.join(self.dir_AB, "VOC_RGB_Depthnpy.bigfile")
  589.             self.loaded_npys_depth = BigFileMemoryLoaderv2(self.load_npy_dir_depth)
  590.   
  591.             print("-------------Filter the imgs whose size <256 in VOC-------------")
  592.             self.filtered_imgs_clean = []
  593.             self.filtered_npys_depth = []
  594.             for i in range(len(self.loaded_imgs_clean)):
  595.                 img_name, img = self.loaded_imgs_clean[i]
  596.                 npy_name, npy = self.loaded_npys_depth[i]
  597.                 h, w = img.size
  598.                 if h < 256 or w < 256:
  599.                     continue
  600.                 self.filtered_imgs_clean.append((img_name, img))
  601.                 self.filtered_npys_depth.append((npy_name, npy))
  602.             print("--------Origin image num is [%d], filtered result is [%d]--------" % (
  603.             len(self.loaded_imgs_clean), len(self.filtered_imgs_clean)))
  604.   
  605.         else:
  606.             self.load_img_dir=os.path.join(self.dir_AB,opt.test_dataset)
  607.             self.loaded_imgs=BigFileMemoryLoader(self.load_img_dir)
  608.   
  609.             self.load_depth_dir = os.path.join(self.dir_AB, opt.test_depthdataset)
  610.             self.loaded_npys = BigFileMemoryLoaderv2(self.load_depth_dir)
  611.   
  612.   
  613.         self.pid = os.getpid()
  614.   
  615.     def __getitem__(self, index):
  616.   
  617.   
  618.   
  619.         if self.opt.isTrain:
  620.             img_name_clean,B = self.filtered_imgs_clean[index]
  621.             npy_name_depth,D = self.filtered_npys_depth[index]
  622.             path = os.path.join(self.load_img_dir_clean, img_name_clean)
  623.             if self.opt.use_v2_degradation:
  624.                 A=online_add_degradation_v2(B,D)
  625.             ### Remind: A is the input and B is corresponding GT
  626.         else:
  627.   
  628.             if self.opt.test_on_synthetic:
  629.   
  630.                 img_name_B,B=self.loaded_imgs[index]
  631.                 npy_name_D,D=self.loaded_npys[index]
  632.                 A=online_add_degradation_v2(B,D)
  633.                 A.save('../mybig_data/' + index + '.jpg')
  634.   
  635.                 img_name_A=img_name_B
  636.                 path = os.path.join(self.load_img_dir, img_name_A)
  637.             else:
  638.                 img_name_A,A=self.loaded_imgs[index]
  639.                 img_name_B,B=self.loaded_imgs[index]
  640.                 path = os.path.join(self.load_img_dir, img_name_A)
  641.   
  642.   
  643.         # if random.uniform(0,1)<0.1 and self.opt.isTrain:
  644.         #     A=A.convert("L")
  645.         #     B=B.convert("L")
  646.         #     A=A.convert("RGB")
  647.         #     B=B.convert("RGB")
  648.         # ## In P, we convert the RGB into L
  649.   
  650.   
  651.         ##test on L
  652.   
  653.         # split AB image into A and B
  654.         # w, h = img.size
  655.         # w2 = int(w / 2)
  656.         # A = img.crop((0, 0, w2, h))
  657.         # B = img.crop((w2, 0, w, h))
  658.         w,h=A.size
  659.         if w<256 or h<256:
  660.             A=transforms.Scale(256,Image.BICUBIC)(A)
  661.             B=transforms.Scale(256, Image.BICUBIC)(B)
  662.   
  663.         # apply the same transform to both A and B
  664.         transform_params = get_params(self.opt, A.size)
  665.         A_transform = get_transform(self.opt, transform_params)
  666.         B_transform = get_transform(self.opt, transform_params)
  667.   
  668.         B_tensor = inst_tensor = feat_tensor = 0
  669.         A_tensor = A_transform(A)
  670.         B_tensor = B_transform(B)
  671.   
  672.         input_dict = {'label': A_tensor, 'inst': inst_tensor, 'image': B_tensor,
  673.                     'feat': feat_tensor, 'path': path}
  674.         return input_dict
  675.   
  676.     def __len__(self):
  677.   
  678.         if self.opt.isTrain:
  679.             return len(self.filtered_imgs_clean)
  680.         else:
  681.             return len(self.loaded_imgs)
  682.   
  683.     def name(self):
  684.         return 'PairOldPhotos'
  685.   
  686. #del
  687. class PairOldPhotos_with_hole(BaseDataset):
  688.     def initialize(self, opt):
  689.         self.opt = opt
  690.         self.isImage = 'imagegan' in opt.name
  691.         self.task = 'old_photo_restoration_training_mapping'
  692.         self.dir_AB = opt.dataroot
  693.         if opt.isTrain:
  694.             self.load_img_dir_clean= os.path.join(self.dir_AB, "VOC_RGB_JPEGImages.bigfile")
  695.             self.loaded_imgs_clean = BigFileMemoryLoader(self.load_img_dir_clean)
  696.   
  697.             print("-------------Filter the imgs whose size <256 in VOC-------------")
  698.             self.filtered_imgs_clean = []
  699.             self.filtered_npys_depth = []
  700.             for i in range(len(self.loaded_imgs_clean)):
  701.                 img_name, img = self.loaded_imgs_clean[i]
  702.                 npy_name, npy = self.loaded_npys_depth[i]
  703.                 h, w = img.size
  704.                 if h < 256 or w < 256:
  705.                     continue
  706.                 self.filtered_imgs_clean.append((img_name, img))
  707.                 self.filtered_npys_depth.append((npy_name, npy))
  708.             print("--------Origin image num is [%d], filtered result is [%d]--------" % (
  709.             len(self.loaded_imgs_clean), len(self.filtered_imgs_clean)))
  710.   
  711.         else:
  712.             self.load_img_dir=os.path.join(self.dir_AB,opt.test_dataset)
  713.             self.loaded_imgs=BigFileMemoryLoader(self.load_img_dir)
  714.   
  715.             self.load_depth_dir = os.path.join(self.dir_AB, opt.test_depthdataset)
  716.             self.loaded_npys = BigFileMemoryLoaderv2(self.load_depth_dir)
  717.   
  718.         self.loaded_masks = BigFileMemoryLoader(opt.irregular_mask)
  719.   
  720.         self.pid = os.getpid()
  721.   
  722.     def __getitem__(self, index):
  723.   
  724.   
  725.   
  726.         if self.opt.isTrain:
  727.             img_name_clean,B = self.filtered_imgs_clean[index]
  728.             npy_name_depth, D = self.filtered_npys_depth[index]
  729.   
  730.             path = os.path.join(self.load_img_dir_clean, img_name_clean)
  731.   
  732.             A=online_add_degradation_v2(B,D)
  733.             B=transforms.RandomCrop(256)(B)
  734.   
  735.             ### Remind: A is the input and B is corresponding GT
  736.   
  737.         else:
  738.             img_name_A,A=self.loaded_imgs[index]
  739.             img_name_B,B=self.loaded_imgs[index]
  740.             path = os.path.join(self.load_img_dir, img_name_A)
  741.   
  742.             #A=A.resize((256,256))
  743.             A=transforms.CenterCrop(256)(A)
  744.             B=A
  745.   
  746.         if random.uniform(0,1)<0.1 and self.opt.isTrain:
  747.             A=A.convert("L")
  748.             B=B.convert("L")
  749.             A=A.convert("RGB")
  750.             B=B.convert("RGB")
  751.         ## In P, we convert the RGB into L
  752.   
  753.         if self.opt.isTrain:
  754.             mask_name,mask=self.loaded_masks[random.randint(0,len(self.loaded_masks)-1)]
  755.         else:
  756.             mask_name, mask = self.loaded_masks[index%100]
  757.         mask = mask.resize((self.opt.loadSize, self.opt.loadSize), Image.NEAREST)
  758.   
  759.         if self.opt.random_hole and random.uniform(0,1)>0.5 and self.opt.isTrain:
  760.             mask=zero_mask(256)
  761.   
  762.         if self.opt.no_hole:
  763.             mask=zero_mask(256)
  764.   
  765.   
  766.         A,_=irregular_hole_synthesize(A,mask)
  767.   
  768.         if not self.opt.isTrain and self.opt.hole_image_no_mask:
  769.             mask=zero_mask(256)
  770.   
  771.         transform_params = get_params(self.opt, A.size)
  772.         A_transform = get_transform(self.opt, transform_params)
  773.         B_transform = get_transform(self.opt, transform_params)
  774.   
  775.         if transform_params['flip'] and self.opt.isTrain:
  776.             mask=mask.transpose(Image.FLIP_LEFT_RIGHT)
  777.   
  778.         mask_tensor = transforms.ToTensor()(mask)
  779.   
  780.   
  781.         B_tensor = inst_tensor = feat_tensor = 0
  782.         A_tensor = A_transform(A)
  783.         B_tensor = B_transform(B)
  784.   
  785.         input_dict = {'label': A_tensor, 'inst': mask_tensor[:1], 'image': B_tensor,
  786.                     'feat': feat_tensor, 'path': path}
  787.         return input_dict
  788.   
  789.     def __len__(self):
  790.   
  791.         if self.opt.isTrain:
  792.             return len(self.filtered_imgs_clean)
  793.   
  794.         else:
  795.             return len(self.loaded_imgs)
  796.   
  797.     def name(self):
  798.         return 'PairOldPhotos_with_hole'

实现效果图样例

图像去雾前后对比：

我是海浪学长,创作不易,欢迎点赞、关注、收藏、留言。

毕设帮助，疑难解答，欢迎打扰！

最后

标签： 课程设计 matlab 图像处理
本文转载自: https://blog.csdn.net/qq_37340229/article/details/128672463
版权归原作者 HaiLang_IT 所有， 如有侵权，请联系我们删除。
登录后发布评论

“毕业设计-基于 MATLAB 的图像去雾技术研究”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？