精华内容
下载资源
问答
  • openCV+python实现图像去雾 万次阅读 多人点赞
    2018-11-09 15:41:55

    Kaiming早在09年以MSRA实习生的身份获得CVPR best paper,其成果就是给图像去雾。当时并没有用深度学习,却能实现让人震惊的效果。先看下效果:

    左边是原图,右边是去雾霾之后的图。效果还是很惊人的吧。代码也非常简短,如下:

    requirements:

    opencv3

    python3

    用法:

    python dehaze.py xxx.jpg
    import cv2
    import math
    import numpy as np
    
    def DarkChannel(im,sz):
        b,g,r = cv2.split(im)
        dc = cv2.min(cv2.min(r,g),b);
        kernel = cv2.getStructuringElement(cv2.MORPH_RECT,(sz,sz))
        dark = cv2.erode(dc,kernel)
        return dark
    
    def AtmLight(im,dark):
        [h,w] = im.shape[:2]
        imsz = h*w
        numpx = int(max(math.floor(imsz/1000),1))
        darkvec = dark.reshape(imsz,1);
        imvec = im.reshape(imsz,3);
    
        indices = darkvec.argsort();
        indices = indices[imsz-numpx::]
    
        atmsum = np.zeros([1,3])
        for ind in range(1,numpx):
           atmsum = atmsum + imvec[indices[ind]]
    
        A = atmsum / numpx;
        return A
    
    def TransmissionEstimate(im,A,sz):
        omega = 0.95;
        im3 = np.empty(im.shape,im.dtype);
    
        for ind in range(0,3):
            im3[:,:,ind] = im[:,:,ind]/A[0,ind]
    
        transmission = 1 - omega*DarkChannel(im3,sz);
        return transmission
    
    def Guidedfilter(im,p,r,eps):
        mean_I = cv2.boxFilter(im,cv2.CV_64F,(r,r));
        mean_p = cv2.boxFilter(p, cv2.CV_64F,(r,r));
        mean_Ip = cv2.boxFilter(im*p,cv2.CV_64F,(r,r));
        cov_Ip = mean_Ip - mean_I*mean_p;
    
        mean_II = cv2.boxFilter(im*im,cv2.CV_64F,(r,r));
        var_I   = mean_II - mean_I*mean_I;
    
        a = cov_Ip/(var_I + eps);
        b = mean_p - a*mean_I;
    
        mean_a = cv2.boxFilter(a,cv2.CV_64F,(r,r));
        mean_b = cv2.boxFilter(b,cv2.CV_64F,(r,r));
    
        q = mean_a*im + mean_b;
        return q;
    
    def TransmissionRefine(im,et):
        gray = cv2.cvtColor(im,cv2.COLOR_BGR2GRAY);
        gray = np.float64(gray)/255;
        r = 60;
        eps = 0.0001;
        t = Guidedfilter(gray,et,r,eps);
    
        return t;
    
    def Recover(im,t,A,tx = 0.1):
        res = np.empty(im.shape,im.dtype);
        t = cv2.max(t,tx);
    
        for ind in range(0,3):
            res[:,:,ind] = (im[:,:,ind]-A[0,ind])/t + A[0,ind]
    
        return res
    
    if __name__ == '__main__':
        import sys
        try:
            fn = sys.argv[1]
        except:
            fn = 'demo.jpg'
        def nothing(*argv):
            pass
        src = cv2.imread(fn);
        I = src.astype('float64')/255;
        dark = DarkChannel(I,15);
        A = AtmLight(I,dark);
        te = TransmissionEstimate(I,A,15);
        t = TransmissionRefine(src,te);
        J = Recover(I,t,A,0.1);
        arr = np.hstack((I, J))
        cv2.imshow("contrast", arr)
        cv2.imwrite("dehaze.png", J*255 )
        cv2.imwrite("contrast.png", arr*255);
        cv2.waitKey();
        
    

     

     

    更多相关内容
  • 先我们使用的python版本是3.6.5所用到的模块如下: Pytorch模块用来模型训练和网络层建立;其底层和Torch框架一样,但是使用Python重新写了很多内容,不仅更加灵活,支持动态图,而且...OpenCV用来读取图片和图像处理;
  • haze:Python实现经典图像去雾算法
  • 该程序是Retinex去雾算法的仿真实现,亲测有效
  • 有代码,有图。此代码是基于暗通道的图像去雾,在原有的基础上有所改进,相互借鉴哈!
  • 【opencv-python图像去雾

    千次阅读 2022-03-26 14:23:47
    暗通道去雾算法中暗通道的计算过程 给出图像数据、计算暗通道 图像特征 import math import time import cv2 import numpy as np def Dark_img(image): # 此处返回的是灰度图 """ 求暗通道图像 :param...
    • 暗通道去雾算法中暗通道的计算过程

      • 给出图像数据、计算暗通道
        在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    图像特征

    import math
    import time
    
    import cv2
    import numpy as np
    
    
    def Dark_img(image):    # 此处返回的是灰度图
        """
        求暗通道图像
        :param image: 读取到的原图
        :return: 经过三通道最小值处理以及最小值滤波的暗通道灰度图
        """
        '''rgb三通道中取最小值'''
        min_img = np.copy(image)
        for h in range(0, min_img.shape[0]):
            for w in range(0, min_img.shape[1]):
                for c in range(min_img.shape[2]):
                    min_img[h, w, c] = np.min(min_img[h, w, c:c + 3])
        '''再进行一个最小值滤波 方盒大小为15'''
        dark_img = np.copy(min_img)
        dark_img = cv2.cvtColor(dark_img, cv2.COLOR_BGR2GRAY)
        r = 15
        for h in range(0, dark_img.shape[0]):
            for w in range(0, dark_img.shape[1]):
                if (h+r) >= dark_img.shape[0]:
                    dark_img[h, w] = np.min(dark_img[h:dark_img.shape[0], w:w + r])
                if (w+r) >= dark_img.shape[1]:
                    dark_img[h, w] = np.min(dark_img[h:h+r, w:dark_img.shape[1]])
                if (h+r) < dark_img.shape[0] and (w+r) < dark_img.shape[1]:
                    dark_img[h, w] = np.min(dark_img[h:h + r, w:w + r])
        # cv2.imshow('dark_img', dark_img)
        return dark_img
    
    
    def Guided_img(I, p, winSize, eps):
        """
        导向滤波
        :param I: 原图的灰度图/255.0,以此为导向
        :param p: 最小值处理后的按通道图/255.0
        :param winSize: 做均值滤波box的大小
        :param eps: 0.001
        :return: 一个灰度图,对暗通道做导向滤波
        """
        mean_I = cv2.blur(I, winSize)       # I的均值平滑
        mean_p = cv2.blur(p, winSize)       # p的均值平滑
    
        mean_II = cv2.blur(I * I, winSize)  # I*I的均值平滑
        mean_Ip = cv2.blur(I * p, winSize)  # I*p的均值平滑
    
        var_I = mean_II - mean_I * mean_I   # 方差
        cov_Ip = mean_Ip - mean_I * mean_p  # 协方差
    
        a = cov_Ip / (var_I + eps)          # 相关因子a
        b = mean_p - a * mean_I             # 相关因子b
    
        mean_a = cv2.blur(a, winSize)       # 对a进行均值平滑
        mean_b = cv2.blur(b, winSize)       # 对b进行均值平滑
    
        q = mean_a * I + mean_b
        guided_img = np.uint8(np.clip(255 * q, 0, 255))
        # cv2.imshow('guided_img', guided_img)
        return guided_img
    
    
    def A(image, dark_img):
        """
        求对应三通道大气光A的值 取值最小0.1%的像素点计算平均值
        :param image: 原图
        :param dark_img: 暗通道(rgb)
        :return: 大气光的rgb值
        """
        height = image.shape[0]
        width = image.shape[1]
        size = width * height    # 计算图像的总像素点数
        min_part_size = int(max(math.floor(size/1000), 1))      # 取总个数的0.1%
        arr = []
        for row in dark_img:    # 变为一维数组
            arr.extend(row)
        indexes = np.argsort(arr)[::-1]       # 寻找最大像素的下标
        a_sum = np.zeros(3)
        for i in range(0, 3):
            for j in range(0, min_part_size):
                # 根据一维数组下标计算对应二维数组下标
                a_sum[i] += image[indexes[j]//width][indexes[j]-width*(indexes[j]//width)][i]
        # 计算平均值
        A = a_sum / min_part_size
        for i in range(0, 3):
            A[i] = int(A[i])
        return A
    
    
    def tx(guided_img):
        """
        求tx
        :param guided_img: 暗通道导向图(rgb)/255.0
        :return: tx
        """
        tx = np.clip(1.0 - guided_img*0.95, 0.30, 1.00)
        return tx
    
    
    """
    图像去雾——暗通道算法
    :param path: 图像路径
    :return: none
    """
    
    
    def Dehaze(image):
        '''读取图像'''
        initial_img = np.copy(image)
        dark_img = Dark_img(image)      # 得到暗通道图像
        guided_img = Guided_img(cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)/255.0,
                                dark_img/255.0, (81, 81), 0.001)   # 进行引导滤波
        guided_img = cv2.cvtColor(guided_img, cv2.COLOR_GRAY2BGR)
    
        A_ = A(guided_img, dark_img)      # 求大气光照A
        tx_ = tx(guided_img/255.0)   # 求tx
        dehaze_img = (initial_img - A_)/tx_ + A_
    
        cv2.imwrite('dehaze_img.png', dehaze_img)
        time.sleep(1.0)
        return initial_img, cv2.imread('dehaze_img.png', 1)
    
    
    path = "imgs/img_5.png"
    image = cv2.imread(path, 1)
    height = 500
    width = int(height * image.shape[0] / image.shape[1])
    image = cv2.resize(image, (height, width))
    initial, dehaze = Dehaze(image)     # 去雾
    cv2.imshow('Dehaze', np.hstack((initial, dehaze)))
    cv2.waitKey(0)
    
    
    展开全文
  • 这是我整理的基于Retinex的图像去雾算法,不是很完美,仅供参考。
  • I: 已有的图像(待去雾图像) J: 要恢复的无雾图像 A: 全球大气光成分,分r、g、b三个通道,三维向量 te: 透射率矩阵 t: 滤波平滑后的透射率矩阵 求出每个像素RGB分量 中的最小值,存入一幅和原始图像大小...
  • 但现有的图像去雾算法在自然真实情形下大多表现不佳,为了进一步提升图像去雾水平,文中采用了一种基于pix2pix模型的单幅图像去雾方法,通过利用编码器和解码器网络结构来解决图像去雾问题,并利用了马尔可夫判别器...
  • Python图像去雾

    千次阅读 2020-10-09 15:49:26
    Python图像去雾 ** 引言: 在过去的几十年中,单图像去雾作为基本的低级视觉任务已引起了计算机视觉社区和人工智能公司的越来越多的关注。其中最为典型的便是北大&北航提出FFA-Net去雾新网络和何凯明博士提出的...

    **

    Python图像去雾

    **
    引言: 在过去的几十年中,单图像去雾作为基本的低级视觉任务已引起了计算机视觉社区和人工智能公司的越来越多的关注。其中最为典型的便是北大&北航提出FFA-Net去雾新网络和何凯明博士提出的暗通道去雾算法,现所有源码已开源。其论文链接:https://arxiv.org/abs/1911.07559。
    而今天我们就将针对这两个项目进行实践。其中得到的去雾效果如下:
    在这里插入图片描述
    在这里插入图片描述

    一、实验前的准备:
    首先我们使用的python版本是3.6.5所用到的模块如下:
    Pytorch模块用来模型训练和网络层建立;其底层和Torch框架一样,但是使用Python重新写了很多内容,不仅更加灵活,支持动态图,而且提供了Python接口。不仅能够实现强大的GPU加速,同时还支持动态神经网络。
    numpy模块用来进行数值运算处理矩阵运算;
    OpenCV用来读取图片和图像处理;
    os模块用来读取数据集等本地文件操作。
    二、FFA去雾算法
    其代码结构如下图可见:
    在这里插入图片描述

    FFA-Net体系结构包含三个关键组件:
    1.考虑到不同的通道特征包含完全不同的加权信息并且不同图像像素上的雾度分布不均匀,一种新颖的特征注意(FA)模块将通道注意与像素注意机制结合在一起。FA不平等地对待不同的特征和像素,这在处理不同类型的信息时提供了额外的灵活性,从而扩展了CNN的表示能力。
    2.基本的块结构包括本地残差学习和功能注意,本地残差学习允许较不重要的信息(例如薄雾区域或低频)通过多个本地残差连接被绕开,让主网络体系结构专注于更有效的信息。
    3.基于注意力的不同级别特征融合(FFA)结构,可从特征注意(FA)模块中自适应学习特征权重,从而为重要特征赋予更多权重。这种结构还可以保留浅层信息,并将其传递到深层。
    实验结果表明,提出的FFANet在数量和质量上都大大超过了现有的单图像去雾方法,从而将SOTS室内测试数据集上最佳的PSNR度量从30.23db提高到35.77db。
    在这里插入图片描述

    其中训练FFA模型的部分代码如下:

    def default_conv(in_channels, out_channels, kernel_size, bias=True):
        return nn.Conv2d(in_channels, out_channels, kernel_size,padding=(kernel_size//2), bias=bias)
    class PALayer(nn.Module):
        def __init__(self, channel):
            super(PALayer, self).__init__()
            self.pa = nn.Sequential(
                    nn.Conv2d(channel, channel // 8, 1, padding=0, bias=True),
                    nn.ReLU(inplace=True),
                    nn.Conv2d(channel // 8, 1, 1, padding=0, bias=True),
                    nn.Sigmoid()
            )
        def forward(self, x):
            y = self.pa(x)
            return x * y
    class CALayer(nn.Module):
        def __init__(self, channel):
            super(CALayer, self).__init__()
            self.avg_pool = nn.AdaptiveAvgPool2d(1)
            self.ca = nn.Sequential(
                    nn.Conv2d(channel, channel // 8, 1, padding=0, bias=True),
                    nn.ReLU(inplace=True),
                    nn.Conv2d(channel // 8, channel, 1, padding=0, bias=True),
                    nn.Sigmoid()
            )
        def forward(self, x):
            y = self.avg_pool(x)
            y = self.ca(y)
            return x * y
    class Block(nn.Module):
        def __init__(self, conv, dim, kernel_size,):
            super(Block, self).__init__()
            self.conv1=conv(dim, dim, kernel_size, bias=True)
            self.act1=nn.ReLU(inplace=True)
            self.conv2=conv(dim,dim,kernel_size,bias=True)
            self.calayer=CALayer(dim)
            self.palayer=PALayer(dim)
        def forward(self, x):
            res=self.act1(self.conv1(x))
            res=res+x 
            res=self.conv2(res)
            res=self.calayer(res)
            res=self.palayer(res)
            res += x 
            return res
    class Group(nn.Module):
        def __init__(self, conv, dim, kernel_size, blocks):
            super(Group, self).__init__()
            modules = [ Block(conv, dim, kernel_size)  for _ in range(blocks)]
            modules.append(conv(dim, dim, kernel_size))
            self.gp = nn.Sequential(*modules)
        def forward(self, x):
            res = self.gp(x)
            res += x
            return res
    class FFA(nn.Module):
        def __init__(self,gps,blocks,conv=default_conv):
            super(FFA, self).__init__()
            self.gps=gps
            self.dim=64
            kernel_size=3
            pre_process = [conv(3, self.dim, kernel_size)]
            assert self.gps==3
            self.g1= Group(conv, self.dim, kernel_size,blocks=blocks)
            self.g2= Group(conv, self.dim, kernel_size,blocks=blocks)
            self.g3= Group(conv, self.dim, kernel_size,blocks=blocks)
            self.ca=nn.Sequential(*[
                nn.AdaptiveAvgPool2d(1),
                nn.Conv2d(self.dim*self.gps,self.dim//16,1,padding=0),
                nn.ReLU(inplace=True),
                nn.Conv2d(self.dim//16, self.dim*self.gps, 1, padding=0, bias=True),
                nn.Sigmoid()
                ])
            self.palayer=PALayer(self.dim)
            post_precess = [
                conv(self.dim, self.dim, kernel_size),
                conv(self.dim, 3, kernel_size)]
            self.pre = nn.Sequential(*pre_process)
            self.post = nn.Sequential(*post_precess)
        def forward(self, x1):
            x = self.pre(x1)
            res1=self.g1(x)
            res2=self.g2(res1)
            res3=self.g3(res2)
            w=self.ca(torch.cat([res1,res2,res3],dim=1))
            w=w.view(-1,self.gps,self.dim)[:,:,:,None,None]
            out=w[:,0,::]*res1+w[:,1,::]*res2+w[:,2,::]*res3
            out=self.palayer(out)
            x=self.post(out)
            return x + x1
    

    使用“python main.py --net=‘ffa’ --crop --crop_size=240 --blocks=19 --gps=3 --bs=2 --lr=0.0001 --trainset=‘its_train’ --testset=‘its_test’ --steps=500000 --eval_step=5000”命令实现模型的训练功能。
    使用“python test.py --task=‘its or ots’ --test_imgs=‘test_imgs’”来测试模型效果:
    最终得到效果如下:
    在这里插入图片描述

    三、暗通道去雾算法搭建
    何恺明的暗通道先验(dark channel prior)去雾算法是CV界去雾领域很有名的算法,关于该算法的论文"Single Image Haze Removal Using Dark Channel Prior"一举获得2009年CVPR最佳论文。作者统计了大量的无雾图像,发现一条规律:每一幅图像的每一个像素的RGB三个颜色通道中,总有一个通道的灰度值很低。基于这个几乎可以视作是定理的先验知识,作者提出暗通道先验的去雾算法。
    对于任意一幅输入图像,定义其暗通道的数学表达式为:
    在这里插入图片描述

    文章中介绍的方法是软抠图的方法,此方法过程复杂,速度缓慢,因此采用导向滤波对传输函数进行滤波。导向滤波的原理此处不再赘述,其伪代码为:
    在这里插入图片描述

    1、滤波函数:
    定义最小值滤波函数:

    def zmMinFilterGray(src, r=7):
        '''if r <= 0:
            return src
        h, w = src.shape[:2]
        I = src
        res = np.minimum(I  , I[[0]+range(h-1)  , :])
        res = np.minimum(res, I[range(1,h)+[h-1], :])
        I = res
        res = np.minimum(I  , I[:, [0]+range(w-1)])
        res = np.minimum(res, I[:, range(1,w)+[w-1]])
        return zmMinFilterGray(res, r-1)'''
        return cv2.erode(src, np.ones((2*r+1, 2*r+1)))  
    

    引导滤波函数的实现:

    def guidedfilter(I, p, r, eps):
        '''引导滤波,直接参考网上的matlab代码'''
        height, width = I.shape
        m_I = cv2.boxFilter(I, -1, (r,r))
        m_p = cv2.boxFilter(p, -1, (r,r))
        m_Ip = cv2.boxFilter(I*p, -1, (r,r))
        cov_Ip = m_Ip-m_I*m_p
        m_II = cv2.boxFilter(I*I, -1, (r,r))
        var_I = m_II-m_I*m_I
        a = cov_Ip/(var_I+eps)
        b = m_p-a*m_I
        m_a = cv2.boxFilter(a, -1, (r,r))
        m_b = cv2.boxFilter(b, -1, (r,r))
        return m_a*I+m_b
    

    计算大气遮罩图像V1和光照值A, V1 = 1-t/A

    def getV1(m, r, eps, w, maxV1):  #输入rgb图像,值范围[0,1]
        '''计算大气遮罩图像V1和光照值A, V1 = 1-t/A'''
        V1 = np.min(m,2)                                         #得到暗通道图像
        V1 = guidedfilter(V1, zmMinFilterGray(V1,7), r, eps)     #使用引导滤波优化
        bins = 2000
        ht = np.histogram(V1, bins)                              #计算大气光照A
        d = np.cumsum(ht[0])/float(V1.size)
        for lmax in range(bins-1, 0, -1):
            if d[lmax]<=0.999:
                break
        A  = np.mean(m,2)[V1>=ht[1][lmax]].max()
              
        V1 = np.minimum(V1*w, maxV1)                   #对值范围进行限制
        return V1,A
    

    得到的运行程序结果如下:
    在这里插入图片描述

    通过调整代码,将视频分帧,可以达到视频去雾的效果:
    其完整代码如下:

    import cv2
    import numpy as np
    def zmMinFilterGray(src, r=7):
        '''最小值滤波,r是滤波器半径'''
        '''if r <= 0:
            return src
        h, w = src.shape[:2]
        I = src
        res = np.minimum(I  , I[[0]+range(h-1)  , :])
        res = np.minimum(res, I[range(1,h)+[h-1], :])
        I = res
        res = np.minimum(I  , I[:, [0]+range(w-1)])
        res = np.minimum(res, I[:, range(1,w)+[w-1]])
        return zmMinFilterGray(res, r-1)'''
        return cv2.erode(src, np.ones((2 * r + 1, 2 * r + 1)))  # 使用opencv的erode函数更高效
    def guidedfilter(I, p, r, eps):
        '''引导滤波'''
        height, width = I.shape
        m_I = cv2.boxFilter(I, -1, (r, r))
        m_p = cv2.boxFilter(p, -1, (r, r))
        m_Ip = cv2.boxFilter(I * p, -1, (r, r))
        cov_Ip = m_Ip - m_I * m_p
        m_II = cv2.boxFilter(I * I, -1, (r, r))
        var_I = m_II - m_I * m_I
        a = cov_Ip / (var_I + eps)
        b = m_p - a * m_I
        m_a = cv2.boxFilter(a, -1, (r, r))
        m_b = cv2.boxFilter(b, -1, (r, r))
        return m_a * I + m_b
    def getV1(m, r, eps, w, maxV1):  # 输入rgb图像,值范围[0,1]
        '''计算大气遮罩图像V1和光照值A, V1 = 1-t/A'''
        V1 = np.min(m, 2)  # 得到暗通道图像
        V1 = guidedfilter(V1, zmMinFilterGray(V1, 7), r, eps)  # 使用引导滤波优化
        bins = 2000
        ht = np.histogram(V1, bins)  # 计算大气光照A
        d = np.cumsum(ht[0]) / float(V1.size)
        for lmax in range(bins - 1, 0, -1):
            if d[lmax] <= 0.999:
                break
        A = np.mean(m, 2)[V1 >= ht[1][lmax]].max()
        V1 = np.minimum(V1 * w, maxV1)  # 对值范围进行限制
        return V1, A
    def deHaze(m, r=81, eps=0.001, w=0.95, maxV1=0.80, bGamma=False):
        Y = np.zeros(m.shape)
        V1, A = getV1(m, r, eps, w, maxV1)  # 得到遮罩图像和大气光照
        for k in range(3):
            Y[:, :, k] = (m[:, :, k] - V1) / (1 - V1 / A)  # 颜色校正
        Y = np.clip(Y, 0, 1)
        if bGamma:
            Y = Y ** (np.log(0.5) / np.log(Y.mean()))  # gamma校正,默认不进行该操作
        return Y
    video = "1.mp4"
    cap = cv2.VideoCapture(video)
    while cap.isOpened():
        _,frame = cap.read()
        frame = cv2.flip(frame, -180)
        cv2.imwrite("temp.jpg",frame)
        m = deHaze(frame / 255.0) * 255
        height, width = m.shape[:2]
        # 缩小图像
        size = (int(width * 0.5), int(height * 0.5))
        shrink = cv2.resize(m, size, interpolation=cv2.INTER_AREA)
        cv2.imwrite('defog.jpg', shrink)
        img = cv2.imread("defog.jpg")
        cv2.imshow("frame",img)
        key = cv2.waitKey(1) & 0xFF
        if key == ord("q"):
            break
    cap.release()
    cv2.destroyAllWindows()
    

    ****源码GitHub地址:https://github.com/zhilin007/FFA-Net
    欢迎大家关注公众号:
    在这里插入图片描述

    展开全文
  • 基于Python图像去雾算法系统

    千次阅读 2020-01-13 15:39:19
    前些时间博主写了一个Python图像去雾算法系统,准备发出来,结果因为许多事情耽误了,今天补上。 (本人才疏学浅,多有不正之处,欢迎各位大牛批评改正。) 系统分析 本系统主要是结合了Python的GUI,基于暗通道的...

    前些时间博主写了一个Python的图像去雾算法系统,准备发出来,结果因为许多事情耽误了,今天补上。

    (本人才疏学浅,多有不正之处,欢迎各位大牛批评改正。)

    系统分析

    本系统主要是结合了Python的GUI,基于暗通道的图像去雾,基于色阶调整的图像去雾,图像增强算法,同时含有一些保存功能、图像查看等等,话不多说,给大家看看成果。

    系统界面

    1.图像主界面
    主界面
    2.文件功能
    在这里插入图片描述
    3.图像处理功能
    在这里插入图片描述
    4.图像查看功能
    在这里插入图片描述
    5.帮助功能
    在这里插入图片描述

    系统测试

    1.打开图像
    在这里插入图片描述
    2.图像增强
    在这里插入图片描述
    3.色阶调整去雾
    在这里插入图片描述
    4.图像增强后暗通道去雾
    在这里插入图片描述
    5.查看增强图像
    在这里插入图片描述
    6.查看增强后暗通道去雾
    在这里插入图片描述
    7.查看未经过去雾处理的去雾图像
    在这里插入图片描述
    (这里的提示框应该改成“未处理”)

    大概就这些了,大家有建议希望评论区留下来,或者加本人qq:2268323760


    展开全文
  • 基于GAN的图像去雾 该项目旨在实现基于GAN的图像去雾方法 图1.生成器。 发生器可以直接输出无雾图像,而无需估计中间参数。 图2.鉴别器。 鉴别器可以引导发生器生成更真实的除雾结果。 要运行此项目,您需要设置...
  • 之后,我训练了 AOD 卷积网络来进行图像去雾,并对数据集图片做一定的处理,增加了网络的鲁棒性,去雾效果也很不错。暗原色先验的去雾算法使用 MATLAB 实现,使用 MATLAB 的 GUI 设计了用户界面;AOD 卷积网络使用 ...
  • python图像去雾总结

    2020-12-05 09:13:33
    本人qq号:226607573,欢迎互相讨论的伙伴们毕设期间对python图像去雾的学习与总结近年来,雾霾越来越严重,导致户外获取的图像严重退化,何如将户外获取的有雾图像复原成高质量的清晰图像,已成为众多研究者的共同...
  • import cv2 import math import numpy as np def DarkChannel(im, sz): b, g, r = cv2.split(im) dc = cv2.min(cv2.min(r, g), b) kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (sz, sz)) ...
  • 1.暗通道图像去雾算法:何恺明的暗通道先验(dark channel prior)去雾算法是计算机视觉界去雾领域很有名的算法。2.光照不均匀校正:本实验使用动态阈值算法进行光照不均匀校正,该方法属于自动白平衡算法,参考论文...
  • 同态滤波算法实现图像去雾。有注释,可直接运行。。。
  • 训练了 AOD 卷积网络来进行图像去雾,并对数据集图片做一定的处理,增加了网络的鲁棒性,去雾效果也很不错。暗原色先验的去雾算法使用 MATLAB 实现,使用 MATLAB 的 GUI 设计了用户界面;AOD 卷积网络使用 Python ...
  • 这篇文章将详细介绍图像去雾算法,经过图像增强后的图像也能应用于目标检测或图像分类领域,并且效果更好。本文主要讲解ACE去雾算法、暗通道先验去雾算法以及雾化生成算法,并且参考了两位计算机视觉大佬(Rizzi 何...
  • Retinex快速图像去雾

    2013-09-21 15:47:12
    通过对汪荣贵基于暗原色先验的Retinex去雾的学习而编写的对应的matlab去雾程序,对于雾不是特别浓的时候去雾效果还是不错的,这里共享matlab源码,里卖弄注释很全,都是自己注释的。
  • 图像去雾软件v1.2.0

    2021-06-13 12:08:58
    采用pyqt5+python实现,已经打包成软件,可以进行批量图像去雾处理!!!
  • 图像去雾软件v1.0.rar

    2020-08-19 14:49:17
    采用pyqt5+python实现,已经打包成软件,可以进行批量图像去雾处理!!!内置有软件操作说明书,该软件仅供学习交流使用!!!如有问题,请联系我,说明书内有我的联系方式。
  • 门控上下文聚合网络,用于图像去雾和排水 这是我们WACV 2019纸“门控上下文聚合网络进行图像除雾和Deraining”通过实施,,等。 在本文中,我们提出了一种用于图像去雾的新的端到端门控上下文聚合网络GCANet,其中...
  • 图像去雾概述

    千次阅读 2021-11-23 11:03:00
    其中在雾天拍摄的图像容易受雾或霾的影响,导致图片细节模糊、对比度低以至于丢失图像重要信息,为解决此类问题图像去雾算法应运而生。图像去雾算法是以满足特定场景需求、突出图片细节并增强图片质量为目的的一种...
  • 1 图像增强图像增强是对图像的某些特征,如边缘、轮廓、对比度等进行强调或锐化,以便于显示、观察或进一步分析与处理。通过对图像的特定加工,将被处理的图像转化为对具体应用来说视觉质量和效果更“好”或更“有用...
  • 可实现对图片的去雾处理
  • 图像去雾学习总结

    千次阅读 2022-01-10 21:46:08
    本来题目想作为如何学习图像去雾,去雾字如其名,而学习是学会去雾方面相关的知识。但是后来一想,每个研究方向均是一片海洋,而自己是半瓶不满的杯水,如何教别人呢,因此本文只能算作学习该领域的一个阶段性总结吧...
  • 基于暗通道先验的图像去雾(附Python代码)

    千次阅读 热门讨论 2019-07-08 20:44:31
    一、实验结果 二、暗通道先验理论 发现有一个博主写得比较详细了,参考...三、Python代码 #!/usr/bin/env python # -*- coding:utf-8 -*- import cv2 import numpy as np def zmMinFilterGray(src, r=7):...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 925
精华内容 370
关键字:

图像去雾python