精华内容
下载资源
问答
  • 图像增强python算法

    2018-10-23 21:24:40
    图像增强python算法,使用的时候直接导入jupyternotebook 中即可
  • pythonRetinex图像增强代码,包含MSRCR,MSR,SSR,MSRCP,自动MSR,MSRCR论文。
  • 图像增强pythonStuck behind the paywall? Click here to read the full article with my friend link 卡在收费墙后面? 单击 此处 以阅读完整的文章以及我的朋友链接 Image augmentation is a technique for ...

    图像增强python

    Stuck behind the paywall? Click here to read the full article with my friend link

    卡在收费墙后面? 单击 此处 以阅读完整的文章以及我的朋友链接

    Image augmentation is a technique for artificially adding more images to your image data to expand the data set. It is mostly used to add variety to the data set so that models don’t over-fit.

    图像增强是一种为图像数据人为添加更多图像以扩展数据集的技术。 它主要用于为数据集增加多样性,以免模型过度拟合。

    Some of the most common augmentation methods are flipping, rotating, and tweaking image properties like contrast, brightness, and color.

    一些最常见的增强方法是翻转,旋转和调整图像属性,例如对比度,亮度和颜色。

    We shall apply all these techniques to a sample of image leaves from the Plant-Village Data Set. The data set is available here. Open the link while you are signed in to your Google account so that it's available in the “Shared with me” folder of your Google Drive.

    我们将所有这些技术应用于“植物村数据集”中的图像叶片样本。 数据集可在此处获得 。 登录到Google帐户后,打开链接,以便在Google云端硬盘的“与我共享”文件夹中可用。

    设置工作区 (Setting Up the Workspace)

    To make the setup easy and fast, we’ll be hosting our notebook on Google Colab. For those new to Colab, it is a free development environment offered by Google which lets you use GPUs or TPUs for your modeling needs. It also comes with the Python Imaging Library (PIL) and OpenCV preinstalled, so it saves us the trouble of installing them as they are not shipped with the Anaconda distribution of Python. Using Colab also lets you use Google Drive to host your data, so you don’t have to download 4000+ photos of leaves to your local machine.

    为了使设置变得容易和快捷,我们将在Google Colab上托管笔记本。 对于Colab的新用户来说,这是Google提供的免费开发环境,可让您使用GPU或TPU满足您的建模需求。 它还附带了预安装的Python Imaging Library(PIL)和OpenCV,因此它为我们省去了安装它们的麻烦,因为Python的Anaconda发行版中没有提供它们。 使用Colab还可让您使用Google云端硬盘托管数据,因此您不必将4000多张叶子的照片下载到本地计算机上。

    Once you open Colab, choose “New Notebook” to open a blank Jupyter Notebook. Then click on “Connect” at the top-right. Once you’ve connected, you’ll be able to see a green tick with the RAM and the disk utilization where “Connect” was earlier. Once this is done, go to “Runtime” from the menu bar, select “Change runtime type”, and then choose “GPU” from the Hardware accelerator drop-down. You can also uncheck the “Omit code cell output when saving this notebook” option if you want to save your notebook with outputs. Click on “Save”, and your GPU-hosted Jupyter Notebook is now ready!

    打开Colab后,选择“新笔记本”以打开空白的Jupyter笔记本。 然后点击右上角的“连接”。 连接后,您将可以看到RAM和磁盘利用率在“ Connect”之前的位置上带有绿色的勾号。 完成此操作后,从菜单栏转到“运行时”,选择“更改运行时类型”,然后从硬件加速器下拉列表中选择“ GPU”。 如果要使用输出保存笔记本,还可以取消选中“在保存此笔记本时忽略代码单元输出”选项。 单击“保存”,您的GPU托管Jupyter Notebook现在准备就绪!

    We start by importing the libraries. We will use:

    我们从导入库开始。 我们将使用:

    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt
    import cv2
    import glob
    import datetime
    import random
    from tqdm.notebook import tqdm
    from PIL import Image
    from PIL import ImageEnhance
    np.random.seed(1) #to have reproducible results
    pd.set_option('display.max_colwidth', None)

    Finally, we just have to mount our Google drive to Colab:

    最后,我们只需要将Google驱动器安装到Colab:

    Image for post

    Follow the URL, select the Google account which you used to access the data-set, and grant Colab permissions to your Drive. Paste the authorization code at the text box in the cell output, and you’ll get the message Mounted at /gdrive.

    跟随该URL,选择用于访问数据集的Google帐户,然后向您的云端硬盘授予Colab权限。 将授权代码粘贴到单元格输出中的文本框中,您将收到消息Mounted at /gdrive

    Our notebook is now set up!

    现在我们的笔记本已经设置好了!

    从驱动器读取图像 (Reading Images from Drive)

    Let's have a look at the folder structure in Drive:

    让我们来看看Drive中的文件夹结构:

    Image for post

    Note: In your case, the path will be:

    注意:根据您的情况,路径为:

    /gdrive/Shared with me/color/Grape___Esca_(Black_Measles)/2da24728-7553-4abc-9dc4-385895eebbc1___FAM_B.Msls 4292.JPG

    We will save the paths to a list. We should have 4062 paths in total:

    我们将路径保存到列表中。 我们应该总共有4062条路径:

    Image for post

    Since loading and processing 4000 images will take a while (~30 mins), even on a GPU, I will just pick 20 random images. (If you want to follow this through till the classification part, I’ld suggest you use the entire set).

    由于加载和处理4000张图像需要花费一段时间(约30分钟),即使在GPU上,我也只能选择20张随机图像。 (如果您想一直进行到分类部分,我建议您使用整个集合)。

    Image for post

    Now, we’ll use the Image.open() method to open images from these paths, and save them to a NumPy array:

    现在,我们将使用Image.open()方法从这些路径打开图像,并将其保存到NumPy数组中:

    Image for post

    From orig.shape we can see that we have 20 images of dimension 256x256, with three color channels (R, G, B).

    orig.shape我们可以看到我们有20个尺寸为256x256的图像,并具有三个颜色通道(R,G,B)。

    Let’s see how these images look:

    让我们看看这些图像的外观:

    plt.figure(figsize=(9,9))
    i = 0
    for img in orig[0:16]:
    plt.subplot(4, 4, i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(img)
    i += 1
    plt.suptitle("Original", fontsize=20)
    plt.show()
    Image for post
    Original images
    原始图片

    增强影像 (Augmenting the Images)

    Now we can finally get started with the image augmentation. We will use PIL’s ImageEnhance method for this.

    现在我们终于可以开始图像增强了。 我们将为此使用PIL的ImageEnhance方法。

    ImageEnhance’s Contrast(), Brightness(), Sharpness(), and Color() all load the image; then, we can use their enhance() methods to enhance those properties by any factor we choose. We will use np.linspace to choose factors between 0 and 1.5, and np.random.choice to randomize those factors.

    ImageEnhance的Contrast()Brightness()Sharpness()Color()均加载图像; 然后,我们可以使用它们的enhance()方法通过我们选择的任何因素来增强这些属性。 我们将使用np.linspace在0和1.5之间选择因子,并使用np.random.choice将这些因子随机化。

    The one-liner for doing this for contrast is:

    进行对比的一种方法是:

    contrast = [np.asarray(ImageEnhance.Contrast(Image.fromarray(img, 'RGB')).enhance(np.random.choice(np.linspace(0.5, 1.5, 5)))) for img in orig]

    For each img in orig, we first load the image from the img array (specifying the color channel as “RGB”. Then, enhance the contrast by a random value from [0, 0.5, 1, 1.25, 1.5] (np.linspace(0.5, 1.5, 5) will choose five linearly spaced values between 0 and 1.5). Finally, we save this image as an array within the contrast list.

    对于orig每个img ,我们首先从img数组加载图像(将颜色通道指定为“ RGB”。然后,通过[ np.linspace(0.5, 1.5, 5) ]中的随机值增强对比度( np.linspace(0.5, 1.5, 5)将在0和1.5之间选择五个线性间隔的值。最后,我们将此图像保存为contrast列表中的数组。

    Let us see how the images look with their contrast tweaked:

    让我们看看调整了对比度后的图像外观:

    plt.figure(figsize=(9,9))
    i = 0
    for img in contrast[0:16]:
    plt.subplot(4, 4, i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(img)
    i += 1
    plt.show()
    Image for post
    Contrast tweaked by a factor of 0.5 to 1.5
    对比度调整了0.5到1.5

    Images with an enhancement factor < 1 look greyer, while those with a factor > 1 are more saturated. Those with a factor = 1 won’t be any different from the original.

    增强因子<1的图像看起来更灰白,而因子> 1的图像则更饱和。 因子= 1的那些与原始的没有什么不同。

    To amplify the effect of randomness, we sequentially process the images for brightness, sharpness, and color, i.e., the output of one is the input of the other:

    为了扩大随机性的影响,我们依次处理图像的亮度,清晰度和颜色,即,一个的输出是另一个的输入:

    brightness = [np.asarray(ImageEnhance.Contrast(Image.fromarray(img, 'RGB')).enhance(np.random.choice(np.linspace(0.5, 1.5, 5)))) for img in contrast]sharpness = [np.asarray(ImageEnhance.Contrast(Image.fromarray(img, 'RGB')).enhance(np.random.choice(np.linspace(0.5, 1.5, 5)))) for img in brightness]color = [np.asarray(ImageEnhance.Contrast(Image.fromarray(img, 'RGB')).enhance(np.random.choice(np.linspace(0.5, 1.5, 5)))) for img in sharpness]

    After all these operations, the images look like:

    完成所有这些操作后,图像如下所示:

    Image for post
    After tweaking brightness, sharpness, and color
    调整亮度,清晰度和色彩后

    We are just left with two more operations — flip and rotate.

    我们只剩下两个操作-翻转和旋转。

    For flip, we will use cv2.flip(). It takes the image and a value between 0, 1 and -1. For 0, it flips vertically; for 1, it flips horizontally; and for -1, it flips both horizontally and vertically. We can randomize these values to randomize the flip, and we can also randomize choosing if the image will be flipped or not. The one-liner for this is:

    对于翻转,我们将使用cv2.flip() 。 它获取图像以及介于0、1和-1之间的值。 值为0时,它垂直翻转。 1,它水平翻转; -1时,水平和垂直翻转。 我们可以随机化这些值以随机化翻转,也可以随机化图像是否翻转的选择。 一线的是:

    flip = [cv2.flip(img, np.random.choice([0, 1, -1])) if np.random.choice([0, 1]) else img for img in color]

    If np.random.choice([0, 1]) is 0, we don’t flip and return the input; otherwise, we flip depending on np.random.choice([0, 1, -1]).

    如果np.random.choice([0, 1])为0,则不翻转并返回输入。 否则,我们将根据np.random.choice([0, 1, -1])翻转。

    Rotating is straightforward. We load the image from the image array and rotate it by as many degrees as we want. To avoid having to fill, we’ll be randomly rotating the images by 0 (no rotation), 90, 180, or 270 degrees:

    旋转很简单。 我们从图像数组加载图像并将其旋转所需的角度。 为避免填充,我们将图像随机旋转0(不旋转),90、180或270度:

    rotate = [Image.fromarray(img, 'RGB').rotate(np.random.choice([0, 90, 180, 270])) for img in flip]

    The final output after all these operations (along with the original images) looks like:

    所有这些操作(以及原始图像)之后的最终输出如下所示:

    Image for post

    We can then save these images in a separate “augmented” folder:

    然后,我们可以将这些图像保存在单独的“增强”文件夹中:

    import os
    for i, image in tqdm(enumerate(rotate)):
    directory = paths[i].rsplit('/', 3)[0] + '/augmented/' + paths[i].rsplit('/', 2)[1]+ '/'
    os.makedirs(directory, exist_ok = True)
    image.save(directory + paths[i].rsplit('/', 2)[2])

    In addition to the steps we discussed, you can also add noise and blur to your image as a part of augmentation. These are described in my article on generating text CAPTCHAs in Python:

    除了我们讨论的步骤之外,您还可以在图像中添加噪点和模糊作为增强的一部分。 我在Python中生成文本验证码的文章中对此进行了描述:

    就这样...现在 (That's It… For Now)

    You can find the Colab notebook I used here.

    您可以在这里找到我使用的Colab笔记本。

    This is the first part of a series I’ll write on Image Augmentation, Segmentation, and Classification. Links to the subsequent articles will be added here once published.

    这是我将撰写的有关图像增强,分割和分类的系列文章的第一部分。 一旦发布,将在此处添加指向后续文章的链接。

    Part II is now live:

    第二部分现已上线:

    Thanks for reading, bouquets, and brickbats welcome! 😄

    感谢您的阅读,花束和欢迎。 😄

    翻译自: https://medium.com/better-programming/introduction-to-image-augmentation-in-python-1691cbf8901f

    图像增强python

    展开全文
  • Python实现GIMP色彩增强插件,主要在CMYK,BGR和HSV颜色空间进行处理。
  • python实现图像增强

    2018-06-09 10:37:19
    主要是深度学习模型进行图像增强,实现深度学习训练阶段做图像扩增,增加模型的泛化能力。
  • 此代码可以实现图像的去噪和增强
  • python实现图像数据增强,实现对数据的增强,包括调亮,调暗,裁剪,镜像等等等,操作简单,可批量处理
  • 简单来说就是使得灰度在不同灰度级别出现的概率更加的均匀均衡的意思就是使得每一个灰度级别的像素点个数是一样或者相近的,这时候灰度累积直方图是一条直线...能够增加图像的对比度,均衡化常用于偏暗和偏亮的图像处理

    目录

    一、相关概念

    1、灰度直方图概念(hist)

    2、灰度概率累积函数(cdf)

    3、灰度直方图均衡化(equalizehist)

    4、均衡化适用范围

    二、均衡化的目的以及求解步骤

    1、目的

    2、求解步骤

    (1)原图灰度直方图求解

    (2)计算累积直方图

    直方图.cumsum(),返回累积直方图数据

    (3)取整扩展确定映射关系

    (4)根据映射关系计算均衡化直方图以及图像(这一步是关键)

    3、绘制未均衡和均衡后对应像素点像素值的改变

    三、全局均衡化直方图

    1、系统自带函数

    2、自定义函数

    3、结果展示

    四、限制对比度自适应直方图均衡(Contrast Limited Adaptive histgram equalization/CLAHE)

    1、限制对比度自适应直方图均衡的概念

    2、适用场景与优势

    3、原理及代码


     


    一、相关概念

    1、灰度直方图概念(hist)

    对图像中不同灰度级别出现的次数进行统计,统计后进行绘制直方图,横坐标表示灰度级别0-255,纵坐标表示每个灰度级别在图像中出现的次数,一般会对次数进行归一化,用每个灰度级出现的次数除以图像的像素总个数

    2、灰度概率累积函数(cdf)

    灰度级由0到255出现频率次数不断进行累加得到的直方图

    https://img-blog.csdn.net/20170729134058885?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvd2VpeGluXzM3ODgyMTUz/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center

    3、灰度直方图均衡化(equalizehist)

    简单来说就是使得灰度在不同灰度级别出现的概率更加的均匀均衡的意思就是使得每一个灰度级别的像素点个数是一样或者相近的,这时候灰度累积直方图是一条直线,这时候出现的频率相近则灰度级别类别也就多了,出现的次数也差不多,能够增加图像的对比度,均衡化常用于偏暗和偏亮的图像处理

    4、均衡化适用范围

    当直方图中的数据集中在某一个灰度值范围内时,直方图均衡化很有用。但是如果像素的变化很大,而且占据的灰度范围非常广时,例如:既有很亮的像素点又有很暗的像素点时。请查看更多资源中的 SOF 链接。

    二、均衡化的目的以及求解步骤

    1、目的

    这种方法通常用来增加许多图像的全局对比度,尤其是当图像的有用数据的对比度相当接近的时候。通过这种方法,亮度可以更好地在直方图上分布,这样就可以用于增强局部的对比度而不影响整体的对比度。
           这种方法对于背景和前景都太亮或者太暗的图像非常有用,这种方法尤其是可以带来X光图像中更好的骨骼结构显示以及曝光过度或者曝光不足照片中更好的细节。
           这种方法的一个主要优势是它是一个相当直观的技术并且是可逆操作,如果已知均衡化函数,那么就可以恢复原始的直方图,并且计算量也不大。这种方法的一个缺点是它对处理的数据不加选择,它可能会增加背景噪声的对比度并且降低有用信号的对比度。

    2、求解步骤

    以图像为3位,共2**3-1 = 8个灰度级 ,0-7,求解过程如表中数据

    (1)原图灰度直方图求解

    用自带函数cv2.calcHist()也可以求解,表示每个灰度级的频率,即该灰度级出现的个数占总像素点的比例

        img = cv2.imread(img,0)
    
        #第一步获取图像的直方图
        h,w = img.shape
        hist = cv2.calcHist([img],[0],None,[256],[0,255])#这里返回的是次数
        hist[0:255] = hist[0:255]/(h*w)#将直方图归一化,化为概率的形式

    (2)计算累积直方图

    也就是统计每一个灰度在整个图像中像素个数的占比,总和为1。记第i个灰度的直方图分布概率为p(i)。利用cumsum()函数

    直方图.cumsum(),返回累积直方图数据

    def cdf(img):
        img = cv2.imread(img,0)
        #flatten() 将数组变成一维
        hist,bins = np.histogram(img.flatten(),256,[0,256])#计算直方图
        #bins:每个区间的起始点和终点,(257,1)
        #hist:直方图(256.1)
        # 计算累积分布图
        print(hist)
        cdf = hist.cumsum()
        cdf_normalized = cdf * hist.max()/ cdf.max()#
        plt.plot(cdf_normalized, color = 'b')#绘制累积灰度级别曲线
        plt.hist(img.flatten(),256,[0,256], color = 'r')#绘制原始图像的直方图
        plt.xlim([0,256])
        plt.legend(('cdf','histogram'), loc = 'upper left')
        plt.show()

    自定义

        #第二步得到灰度级概率累积直方图
        sum_hist = np.zeros(hist.shape)#用于存放灰度级别概率的累和
        for i in range(256):
            sum_hist[i] = sum(hist[0:i+1])#将前i+1个灰度级别的出现概率总和赋值给sum_hist[i]

    (3)取整扩展确定映射关系

    每个Pk经过映射后的灰度级值

    L表示图像处理的灰度级个数,因为此表处理的图像为3位,所以灰度级共2的3次方,8个灰度级,所以L=8 ,一般L=256

    L-1 表示最大灰度级

    0 表示最小灰度级

    • 例 S(0) = int[((8-1)-0)*0.02+0.5] = 0
        #第三步通过映射函数获得原图像灰度级与均衡后图像的灰度级的映射关系,这里创建映射后的灰度级别排序
        equal_hist = np.zeros(sum_hist.shape)
        for i in range(256):
            equal_hist[i] = int(((L-1)-0)*sum_hist[i]+0.5)

    (4)根据映射关系计算均衡化直方图以及图像(这一步是关键)

    计算后的灰度级替换掉计算前的灰度级,得到均衡化后的直方图

        #第四步根据第三步的映射关系将灰度图每个像素点的灰度级别替换为映射后的灰度级别,这里是这样换的,equal_hist的索引号相当于原先的灰度级别排序,元素值则是映射后的灰度级别
        equal_img = img.copy()#用于存放均衡化后图像的灰度值
        for i in range(h):
            for j in range(w):
                equal_img[i,j] = equal_hist[img[i,j]]
        #计算得到均衡化后的直方图
        equal_hist = cv2.calcHist([equal_img],[0],None,[256],[0,255])
        equal_hist[0:255] = equal_hist[0:255] / (h * w)  # 将直方图归一化,化为概率的形式

    3、绘制未均衡和均衡后对应像素点像素值的改变

    import cv2
    import numpy as np
    from matplotlib import pyplot as plt
    
    def sys_equalizehist(img):
        '''
        利用系统自带的函数进行直方图均衡化
        :param img: 待处理图像
        :return:  [equ_img,equ_hist],返回一个列表,第一个元素是均衡化后的图像,第二个是均衡了的直方图
        '''
        img = cv2.imread(img,0)
        h,w = img.shape
        equ_img = cv2.equalizeHist(img)#得到直方图均衡化后的图像
        equ_hist = cv2.calcHist([equ_img],[0],None,[256],[0,255])#得到均衡化后的图像的灰度直方图
        equ_hist[0:255] = equ_hist[0:255] / (h * w)  # 将直方图归一化,化为概率的形式
        # res = np.hstack((img,equ)) #stacking images side-by-side#这一行是将两个图像进行了行方向的叠加
        return [img,equ_img,equ_hist]
    
    #创建绘制原图像和均衡化后图像的对应灰度值变化曲线
    def equalWithOrignImg(gray_img,sys_img):
        '''
        :param gray_img: 未均衡图
        :param sys_img: 均衡图
        :return:无返回值
        '''
        #将图像像素变成一维的
        gray_img = gray_img.ravel()
        sys_img = sys_img.ravel()
        #返回gray_img像素值从小到大的索引号,对其进行排序
        argOfGrayImg = np.argsort(gray_img)
        gray_img = sorted(gray_img)
        #根据索引号来取sys_img中的元素
        sys_img_sorted = []
        for i in argOfGrayImg:
            sys_img_sorted.append(sys_img[i])
        plt.plot(gray_img,sys_img_sorted)
        plt.show()
    
    if __name__ == '__main__':
        img = "E:\PYTHON\Image_Processing\colorful_lena.jpg"
        gray_img,sys_img,sys_hist = sys_equalizehist(img)
        equalWithOrignImg(gray_img,sys_img)

     

    三、全局均衡化直方图

    OpenCV 中的直方图均衡化函数为 cv2.equalizeHist()。这个函数的输入图片仅仅是一副灰度图像,输出结果是直方图均衡化之后的图像。对全局进行均衡化

    1、系统自带函数

    import cv2
    import numpy as np
    from matplotlib import pyplot as plt
    
    
    def sys_equalizehist(img):
        '''
        利用系统自带的函数进行直方图均衡化
        :param img: 待处理图像
        :return:  [equ_img,equ_hist],返回一个列表,第一个元素是均衡化后的图像,第二个是均衡了的直方图
        '''
        img = cv2.imread(img,0)
        h,w = img.shape
        equ_img = cv2.equalizeHist(img)#得到直方图均衡化后的图像
        equ_hist = cv2.calcHist([equ_img],[0],None,[256],[0,255])#得到均衡化后的图像的灰度直方图
        equ_hist[0:255] = equ_hist[0:255] / (h * w)  # 将直方图归一化,化为概率的形式
        # res = np.hstack((img,equ)) #stacking images side-by-side#这一行是将两个图像进行了行方向的叠加
        return [equ_img,equ_hist]

    2、自定义函数

    def def_equalizehist(img,L=256):
        '''
        根据均衡化原理自定义函数
        :param img: 待处理图像
        :param L: 灰度级别的个数
        :return: [equal_img,equal_hist]返回一个列表,第一个元素是均衡化后的图像,第二个是均衡了的直方图
        '''
        img = cv2.imread(img,0)
    
        #第一步获取图像的直方图
        h,w = img.shape
        hist = cv2.calcHist([img],[0],None,[256],[0,255])#这里返回的是次数
        hist[0:255] = hist[0:255]/(h*w)#将直方图归一化,化为概率的形式
    
        #第二步得到灰度级概率累积直方图
        sum_hist = np.zeros(hist.shape)#用于存放灰度级别概率的累和
        for i in range(256):
            sum_hist[i] = sum(hist[0:i+1])#将前i+1个灰度级别的出现概率总和赋值给sum_hist[i]
    
        #第三步通过映射函数获得原图像灰度级与均衡后图像的灰度级的映射关系,这里创建映射后的灰度级别排序
        equal_hist = np.zeros(sum_hist.shape)
        for i in range(256):
            equal_hist[i] = int(((L-1)-0)*sum_hist[i]+0.5)
    
        #第四步根据第三步的映射关系将灰度图每个像素点的灰度级别替换为映射后的灰度级别,这里是这样换的,equal_hist的索引号相当于原先的灰度级别排序,元素值则是映射后的灰度级别
        equal_img = img.copy()#用于存放均衡化后图像的灰度值
        for i in range(h):
            for j in range(w):
                equal_img[i,j] = equal_hist[img[i,j]]
        #计算得到均衡化后的直方图
        equal_hist = cv2.calcHist([equal_img],[0],None,[256],[0,255])
        equal_hist[0:255] = equal_hist[0:255] / (h * w)  # 将直方图归一化,化为概率的形式
        return [equal_img,equal_hist]
    
    
    
    if __name__ == '__main__':
        img = "colorful_lena.jpg"
        sys_img,sys_hist = sys_equalizehist(img)
        def_img,def_hist = def_equalizehist(img)
        x = np.linspace(0,255,256)
        plt.subplot(1,2,1),plt.plot(x,sys_hist,'-b')
        plt.subplot(1,2,2),plt.plot(x,def_hist,'-r')
        plt.show()
    

    3、结果展示

    均衡化以前

    均衡化以后

    可见均衡化后的直方图比较密集了,且比较均匀,说明各个灰度级别出现的概率比较相近 ,且均衡化的图像比均衡化前的对比度大,亮的更亮,暗的更暗,色差大

    四、限制对比度自适应直方图均衡(Contrast Limited Adaptive histgram equalization/CLAHE)

    1、限制对比度自适应直方图均衡的概念

     有限对比适应性直方图均衡化我们在上边做的直方图均衡化会改变整个图像的对比度,但是在很多情况下,这样做的效果并不好。如下图:

           的确在进行完直方图均衡化之后,图片背景的对比度被改变了。但是你再对比一下两幅图像中雕像的面图,由于太亮我们丢失了很多信息。造成这种结果的根本原因在于这幅图像的直方图并不是集中在某一个区域(试着画出它的直方图,你就明白了)。


              为了解决这个问题,我们需要使用自适应的直方图均衡化。这种情况下,整幅图像会被分成很多小块,这些小块被称为“tiles”(在 OpenCV 中 tiles 的大小默认是 8x8),然后再对每一个小块分别进行直方图均衡化(跟前面类似)
      所以在每一个的区域中,直方图会集中在某一个小的区域中(除非有噪声干扰)。如果有噪声的话,噪声会被放大。为了避免这种情况的出现要使用对比度限制。对于每个小块来说,如果直方图中的 也就是灰度级别 超过对比度的上限的话,就把其中的像素点均匀分散到其他 bins 中,然后在进行直方图均衡化。最后,为了去除每一个小块之间“人造的”(由于算法造成)边界,再使用双线性差值,对小块进行缝合。

     

    2、适用场景与优势

    自适应直方图均衡化(AHE)用来提升图像的对比度的一种计算机图像处理技术。和普通的直方图均衡算法不同,AHE算法通过计算图像的局部直方图,然后重新分布亮度来来改变图像对比度。因此,该算法更适合于改进图像的局部对比度以及获得更多的图像细节。

    3、原理及代码

    原理比较复杂,可参考:https://blog.csdn.net/huangli19870217/article/details/45534397

    def clahe(img,tileGridSize=8):
        '''
        限制对比度自适应直方图均衡
        :param img: 待测图像
        :param tileGridSize: 划分小区域的大小一般为8
        :return: 返回的是直方图均衡化后的图像
        '''
        img = cv2.imread(img, 0)
        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(tileGridSize, tileGridSize))#先设置区域块tile的大小以及裁剪的限制
        cl1 = clahe.apply(img)#对图片进行自适应均衡化
        return cl1

    这时候的图像对比度高,且不会模糊细节

    展开全文
  • 基于以下论文,通过光照图估计实现两种低光图像增强技术的 Python 实现: 稳健曝光校正的双光照估计 [] LIME:通过照明图估计进行低光图像增强 [] 这两种方法都基于 retinex 建模,旨在通过保留图像的突出结构来...
  • python图像增强总结

    2020-12-20 19:42:32
    图像增强主要解决由于图像的灰度级范围较小造成的对比度较低的问题,目的就是将输出图像的灰度级放大到指定的程度,使得图像中的细节看起来增加清晰。 常用的图像增强方法有以下几种: 1.提高对比度 2.Gamma校正 3....
  • 为克服传统Retinex算法没有解决的噪声问题,提出了一种基于Retinex和BM3D的图像增强算法。该方法将BM3D去噪环节加入到传统Retinex算法中。首先,计算出图像各像素之间的相对明暗关系,进而对待处理图像中的每个像素...
  • 用于机器学习实验的图像增强
  • TensorFlow implementation of the CVPR 2018 spotlight paper, Deep Photo Enhancer: Unpaired Learning for Image Enhancement from Photographs with GANs
  • 此次任务参考了以下大佬的博客,链接: haar小波: https://blog.csdn.net/baidu_27643275/article/details/84826773 【小波变换】小波变换python实现–PyWavelets: ...python代码: import numpy
  • 使用python编写了共六种图像增强算法:1)基于直方图均衡化2)基于拉普拉斯算子3)基于对数变换4)基于伽马变换5)限制对比度自适应直方图均衡化:CLAHE6)retinex-SSR7)retinex-MSR其中,6和7属于同一种下的变化。...

    使用python编写了共六种图像增强算法:

    1)基于直方图均衡化

    2)基于拉普拉斯算子

    3)基于对数变换

    4)基于伽马变换

    5)限制对比度自适应直方图均衡化:CLAHE

    6)retinex-SSR

    7)retinex-MSR其中,6和7属于同一种下的变化。

    将每种方法编写成一个函数,封装,可以直接在主函数中调用。

    采用同一幅图进行效果对比。

    图像增强的效果为:

    直方图均衡化:对比度较低的图像适合使用直方图均衡化方法来增强图像细节

    拉普拉斯算子可以增强局部的图像对比度

    log对数变换对于整体对比度偏低并且灰度值偏低的图像增强效果较好

    伽马变换对于图像对比度偏低,并且整体亮度值偏高(对于相机过曝)情况下的图像增强效果明显

    CLAHE和retinex的效果均较好

    python代码为:

    # 图像增强算法,图像锐化算法

    # 1)基于直方图均衡化 2)基于拉普拉斯算子 3)基于对数变换 4)基于伽马变换 5)CLAHE 6)retinex-SSR 7)retinex-MSR

    # 其中,基于拉普拉斯算子的图像增强为利用空域卷积运算实现滤波

    # 基于同一图像对比增强效果

    # 直方图均衡化:对比度较低的图像适合使用直方图均衡化方法来增强图像细节

    # 拉普拉斯算子可以增强局部的图像对比度

    # log对数变换对于整体对比度偏低并且灰度值偏低的图像增强效果较好

    # 伽马变换对于图像对比度偏低,并且整体亮度值偏高(对于相机过曝)情况下的图像增强效果明显

    import cv2

    import numpy as np

    import matplotlib.pyplot as plt

    # 直方图均衡增强

    def hist(image):

    r, g, b = cv2.split(image)

    r1 = cv2.equalizeHist(r)

    g1 = cv2.equalizeHist(g)

    b1 = cv2.equalizeHist(b)

    image_equal_clo = cv2.merge([r1, g1, b1])

    return image_equal_clo

    # 拉普拉斯算子

    def laplacian(image):

    kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]])

    image_lap = cv2.filter2D(image, cv2.CV_8UC3, kernel)

    return image_lap

    # 对数变换

    def log(image):

    image_log = np.uint8(np.log(np.array(image) + 1))

    cv2.normalize(image_log, image_log, 0, 255, cv2.NORM_MINMAX)

    # 转换成8bit图像显示

    cv2.convertScaleAbs(image_log, image_log)

    return image_log

    # 伽马变换

    def gamma(image):

    fgamma = 2

    image_gamma = np.uint8(np.power((np.array(image) / 255.0), fgamma) * 255.0)

    cv2.normalize(image_gamma, image_gamma, 0, 255, cv2.NORM_MINMAX)

    cv2.convertScaleAbs(image_gamma, image_gamma)

    return image_gamma

    # 限制对比度自适应直方图均衡化CLAHE

    def clahe(image):

    b, g, r = cv2.split(image)

    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))

    b = clahe.apply(b)

    g = clahe.apply(g)

    r = clahe.apply(r)

    image_clahe = cv2.merge([b, g, r])

    return image_clahe

    def replaceZeroes(data):

    min_nonzero = min(data[np.nonzero(data)])

    data[data == 0] = min_nonzero

    return data

    # retinex SSR

    def SSR(src_img, size):

    L_blur = cv2.GaussianBlur(src_img, (size, size), 0)

    img = replaceZeroes(src_img)

    L_blur = replaceZeroes(L_blur)

    dst_Img = cv2.log(img/255.0)

    dst_Lblur = cv2.log(L_blur/255.0)

    dst_IxL = cv2.multiply(dst_Img, dst_Lblur)

    log_R = cv2.subtract(dst_Img, dst_IxL)

    dst_R = cv2.normalize(log_R,None, 0, 255, cv2.NORM_MINMAX)

    log_uint8 = cv2.convertScaleAbs(dst_R)

    return log_uint8

    def SSR_image(image):

    size = 3

    b_gray, g_gray, r_gray = cv2.split(image)

    b_gray = SSR(b_gray, size)

    g_gray = SSR(g_gray, size)

    r_gray = SSR(r_gray, size)

    result = cv2.merge([b_gray, g_gray, r_gray])

    return result

    # retinex MMR

    def MSR(img, scales):

    weight = 1 / 3.0

    scales_size = len(scales)

    h, w = img.shape[:2]

    log_R = np.zeros((h, w), dtype=np.float32)

    for i in range(scales_size):

    img = replaceZeroes(img)

    L_blur = cv2.GaussianBlur(img, (scales[i], scales[i]), 0)

    L_blur = replaceZeroes(L_blur)

    dst_Img = cv2.log(img/255.0)

    dst_Lblur = cv2.log(L_blur/255.0)

    dst_Ixl = cv2.multiply(dst_Img, dst_Lblur)

    log_R += weight * cv2.subtract(dst_Img, dst_Ixl)

    dst_R = cv2.normalize(log_R,None, 0, 255, cv2.NORM_MINMAX)

    log_uint8 = cv2.convertScaleAbs(dst_R)

    return log_uint8

    def MSR_image(image):

    scales = [15, 101, 301] # [3,5,9]

    b_gray, g_gray, r_gray = cv2.split(image)

    b_gray = MSR(b_gray, scales)

    g_gray = MSR(g_gray, scales)

    r_gray = MSR(r_gray, scales)

    result = cv2.merge([b_gray, g_gray, r_gray])

    return result

    if __name__ == "__main__":

    image = cv2.imread("example.jpg")

    image_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    plt.subplot(4, 2, 1)

    plt.imshow(image)

    plt.axis("off")

    plt.title("Offical")

    # 直方图均衡增强

    image_equal_clo = hist(image)

    plt.subplot(4, 2, 2)

    plt.imshow(image_equal_clo)

    plt.axis("off")

    plt.title("equal_enhance")

    # 拉普拉斯算法增强

    image_lap = laplacian(image)

    plt.subplot(4, 2, 3)

    plt.imshow(image_lap)

    plt.axis("off")

    plt.title("laplacian_enhance")

    # LoG对象算法增强

    image_log = log(image)

    plt.subplot(4, 2, 4)

    plt.imshow(image_log)

    plt.axis("off")

    plt.title("log_enhance")

    # 伽马变换

    image_gamma = gamma(image)

    plt.subplot(4, 2, 5)

    plt.imshow(image_gamma)

    plt.axis("off")

    plt.title("gamma_enhance")

    # CLAHE

    image_clahe = clahe(image)

    plt.subplot(4, 2, 6)

    plt.imshow(image_clahe)

    plt.axis("off")

    plt.title("CLAHE")

    # retinex_ssr

    image_ssr = SSR_image(image)

    plt.subplot(4, 2, 7)

    plt.imshow(image_ssr)

    plt.axis("off")

    plt.title("SSR")

    # retinex_msr

    image_msr = MSR_image(image)

    plt.subplot(4, 2, 8)

    plt.imshow(image_msr)

    plt.axis("off")

    plt.title("MSR")

    plt.show()

    增强效果如下图所示:

    305d56c55fc63bf6b6516513a8a98466.png

    到此这篇关于python 图像增强算法实现详解的文章就介绍到这了,更多相关python 图像增强算法内容请搜索云海天教程以前的文章或继续浏览下面的相关文章希望大家以后多多支持云海天教程!

    展开全文
  • python图像数据增强

    2019-03-16 16:47:01
    此代码用于实现图像数据增强,对图片进行批量处理。包括图片旋转、翻转、模糊、增加噪声、亮度几种处理。运行需要安装python、opencv、numpy等。 使用时将图片统一放在img文件夹中,并将img文件夹和下载的py文件放在...
  • OpenCV—Python Retinex图像增强算法

    万次阅读 多人点赞 2019-07-02 15:05:37
    Retinex图像增强算法一、Retinex理论二、Retinex理论的理解三、Retinex理论应用 一、Retinex理论 Retinex理论始于Land和McCann于20世纪60年代作出的一系列贡献,其基本思想是人感知到某点的颜色和亮度并不仅仅取决于...

    一、单尺度SSR(Single Scale Retinex)理论

    Retinex理论始于Land和McCann于20世纪60年代作出的一系列贡献,其基本思想是人感知到某点的颜色和亮度并不仅仅取决于该点进入人眼的绝对光线,还和其周围的颜色和亮度有关。Retinex这个词是由视网膜(Retina)和大脑皮层(Cortex)两个词组合构成的.Land之所以设计这个词,是为了表明他不清楚视觉系统的特性究竟取决于此两个生理结构中的哪一个,抑或是与两者都有关系。

    Land的Retinex模型是建立在以下的基础之上的:

    • 真实世界是无颜色的,我们所感知的颜色是光与物质的相互作用的结果。我们见到的水是无色的,但是水膜—肥皂膜却是显现五彩缤纷,那是薄膜表面光干涉的结果;
    • 每一颜色区域由给定波长的红、绿、蓝三原色构成的;
    • 三原色决定了每个单位区域的颜色。

    Retinex 理论的基本内容

    • 物体的颜色是由物体对长波(红)、中波(绿)和短波(蓝)光线的反射能力决定的,而不是由反射光强度的绝对值决定的;
    • 物体的色彩不受光照非均性的影响,具有一致性,
    • 即Retinex理论是以色感一致性(颜色恒常性)为基础的。

    如下图所示,观察者所看到的物体的图像S是由物体表面对入射光L反射得到的,反射率R由物体本身决定,不受入射光L变化。
    在这里插入图片描述

    基于Retinex的图像增强的目的就是从原始图像S中估计出光照L,从而分解出R,消除光照不均的影响,以改善图像的视觉效果,正如人类视觉系统那样。
    Retinex方法的核心就是估测照度L,从图像S中估测L分量,并去除L分量,得到原始反射分量R,即:
    在这里插入图片描述

    二、Retinex理论的理解

    下面介绍两个经典的Retinex算法:
    基于路径的Retinex以及基于中心/环绕Retinex。

    Retinex理论,与降噪类似,该理论的关键就是合理地假设了图像的构成。如果将观察者看到的图像看成是一幅带有乘性噪声的图像,那么入射光的分量就是一种乘性的,相对均匀,且变换缓慢的噪声。Retinex算法所做的就是合理地估计图像中各个位置的噪声,并除去它。

    在极端情况下,我们大可以认为整幅图像中的分量都是均匀的,那么最简单的估计照度L的方式就是在将图像变换到对数域后对整幅图像求均值。因此,我设计了以下算法来验证自己的猜想,流程如下:
    (1) 将图像变换到对数域 s = log ⁡ S s = \log S s=logS

    (2) 归一化去除加性分量 r ′ = r max ⁡ ( r ) r&#x27; = \frac{r}{\max (r)} r=max(r)r

    (3) 对步骤3得到的结果求指数,反变换到实数域 R = exp ⁡ ( r ⋅ log ⁡ 255 ) R = \exp(r · \log 255) R=exp(rlog255)

    • 计算流程如下:
      L o g ( R ( x , y ) ) = ( L o g ( I ( x , y ) ) − L o g ( I ( x , y ) ∗ G ( x , y ) ) )   ( ∗ 乘 )   ( 1 − 1 ) \rm Log(R(x,y)) =(Log(I(x,y))-Log(I(x,y)* G(x,y)))  (*乘)  (1-1) Log(R(x,y))=(Log(I(x,y))Log(I(x,y)G(x,y)))  (11)
      R ( x , y ) = ( V a l u e − M i n ) / ( M a x − M i n ) ∗ ( 255 − 0 )               ( 1 − 2 ) \rm R(x,y) = ( Value - Min ) / (Max - Min) * (255-0)         (1-2) R(x,y)=(ValueMin)/(MaxMin)(2550)       (12)
    其中:
    I ( x , y ) I(x,y) I(x,y)代表被观察或照相机接收到的图像信号; L ( x , y ) L(x,y) L(x,y)代表环境光的照射分量 ; R ( x , y ) R(x,y) R(x,y)表示携带图像细节信息的目标物体的反射分量 。
    L ( x , y ) L(x,y) L(x,y)是不能够求得的,只能近似求出。我们用 I ( x , y ) I(x,y) I(x,y)和一个高斯核的卷积来近似表示 L ( x , y ) L(x,y) L(x,y)
    import numpy as np
    import cv2
    
    
    def replaceZeroes(data):
        min_nonzero = min(data[np.nonzero(data)])
        data[data == 0] = min_nonzero
        return data
    
    def SSR(src_img, size):
        L_blur = cv2.GaussianBlur(src_img, (size, size), 0)
        img = replaceZeroes(src_img)
        L_blur = replaceZeroes(L_blur)
    
        dst_Img = cv2.log(img/255.0)
        dst_Lblur = cv2.log(L_blur/255.0)
        dst_IxL = cv2.multiply(dst_Img,dst_Lblur)
        log_R = cv2.subtract(dst_Img, dst_IxL)
    
        dst_R = cv2.normalize(log_R,None,0,255,cv2.NORM_MINMAX)
        log_uint8 = cv2.convertScaleAbs(dst_R)
        return log_uint8
    
    
    if __name__ == '__main__':
        img = './gggg/20190701133802.png'
        size = 3
        src_img = cv2.imread(img)
        b_gray, g_gray, r_gray = cv2.split(src_img)
        b_gray = SSR(b_gray, size)
        g_gray = SSR(g_gray, size)
        r_gray = SSR(r_gray, size)
        result = cv2.merge([b_gray, g_gray, r_gray])
    
        cv2.imshow('img',src_img)
        cv2.imshow('result',result)
        cv2.waitKey(0)
    	cv2.destroyAllWindows()
    

    在这里插入图片描述

    三、多尺度MSR(Multi-Scale Retinex)

    MSR是在SSR基础上发展来的,优点是可以同时保持图像高保真度与对图像的动态范围进行压缩的同时,MSR也可实现色彩增强、颜色恒常性、局部动态范围压缩、全局动态范围压缩,也可以用于X光图像增强。最为经典的就是3尺度的,大、中、小,既能实现图像动态范围的压缩,又能保持色感的一致性较好。

    计算流程
    (1) 需要对原始图像进行每个尺度的高斯模糊,得到模糊后的图像 L i ( x , y ) L_i(x,y) Li(x,y),其中小标 i i i表示尺度数。
    (2) 对每个尺度下进行累加计算
    log ⁡ [ R ( x , y ) ] = log ⁡ [ R ( x , y ) ] + W e i g h t ( i ) ∗ ( log ⁡ [ I i ( x , y ) ] − log ⁡ [ L i ( x , y ) ] ) ; \log[R(x,y)] = \log[R(x,y)] + Weight(i)* ( \log[I_i(x,y)]-\log[L_i(x,y)]); log[R(x,y)]=log[R(x,y)]+Weight(i)(log[Ii(x,y)]log[Li(x,y)]);
    其中Weight(i)表示每个尺度对应的权重,要求各尺度权重之和必须为1,经典的取值为等权重。
    import numpy as np
    import cv2
    
    
    def replaceZeroes(data):
        min_nonzero = min(data[np.nonzero(data)])
        data[data == 0] = min_nonzero
        return data
    
    
    def MSR(img, scales):
        weight = 1 / 3.0
        scales_size = len(scales)
        h, w = img.shape[:2]
        log_R = np.zeros((h, w), dtype=np.float32)
    
        for i in range(scales_size):
            img = replaceZeroes(img)
            L_blur = cv2.GaussianBlur(img, (scales[i], scales[i]), 0)
            L_blur = replaceZeroes(L_blur)
            dst_Img = cv2.log(img/255.0)
            dst_Lblur = cv2.log(L_blur/255.0)
            dst_Ixl = cv2.multiply(dst_Img, dst_Lblur)
            log_R += weight * cv2.subtract(dst_Img, dst_Ixl)
    
        dst_R = cv2.normalize(log_R,None, 0, 255, cv2.NORM_MINMAX)
        log_uint8 = cv2.convertScaleAbs(dst_R)
        return log_uint8
    
    
    if __name__ == '__main__':
        img = './gggg/20190701133802.png'
        scales = [15,101,301]  # [3,5,9]  #看不出效果有什么差别
        src_img = cv2.imread(img)
        b_gray, g_gray, r_gray = cv2.split(src_img)
        b_gray = MSR(b_gray, scales)
        g_gray = MSR(g_gray, scales)
        r_gray = MSR(r_gray, scales)
        result = cv2.merge([b_gray, g_gray, r_gray])
    
        cv2.imshow('img',src_img)
        cv2.imshow('MSR_result',result)
        cv2.waitKey(0)
        cv2.destroyAllWindows()
    

    在这里插入图片描述

    四、MSRCR & MSRCP

    由于R是对数域的输出,要转换为数字图像,必须将他们量化为[0,255]的数字图像范畴,关于这个量化的算法,有这极为重要的意义,他的好坏直接决定了最终输出的图像的品质。

    目前,有4种方式进行处理

    • 第一种,直接线性量化,在单尺度SSR中采用的就是这种方法。
      这种方式,由于Retinex数据处理后的高动态特性,数据分布很广,会出现严重的两极化现象,一般难以获得满意的结果。

    • 第二种,就是在经典的MSRCR(Multi-Scale Retinex with Color Restoration)文章《A Multiscale Retinex for Bridging the Gap Between Color Images and the Human Observation of Scenes》中提出的Canonical Gain/set 算法。计算公式如:
      R M S R C R i ( x , y ) = G [ R M S R C R i ( x , y ) − b ] R_{MSRCR_i}(x,y) = G[R_{MSRCR_i}(x,y)-b] RMSRCRi(x,y)=G[RMSRCRi(x,y)b]
      其中G和b为经验参数。

    • 第三种,实在上述文章中提到的Simplest Color Balance(我简写为SCR)方式,这种方式的处理类似于Photoshop中的自动色阶,他把数据按照一定的百分比去除最小和最大的部分,然后中间的部分重新线性量化到0和255之间。

    • 第四种,就是GIMP的Retinex算法,这个可详见 带色彩恢复的多尺度视网膜增强算法(MSRCR)的原理、实现及应用 一文的描述。

    还有一种方式,就是大家知道HDR的过程吧,他也是将高动态的数据量化到图像的可视范围,因此可以直接将这类算法应用与这个问题上。我也做了实验,效果似乎一般。

    在用第二种或第三种方式处理时,最好还需要有个Color Restoration的过程,因为如果直接对MSR处理的结果进行量化,得到的图像往往整体偏灰度,这是由于原始的彩色值经过log处理后的数据范围就比较小了,这样各通道之间的差异也很小,而之后的线性量化比log曲线要平滑很多,因此整体就丧失了彩色。

    论文中提出了修正方式如下: 
    I i ′ ( x , y ) = I i ( x , y ) ∑ j = 1 S I j ( x , y ) I&#x27;_i(x,y) = \frac{I_i(x,y)}{\sum_{j=1}^S I_j(x,y)} Ii(x,y)=j=1SIj(x,y)Ii(x,y)

    C i ( x , y ) = β log ⁡ [ α I i ′ ( x , y ) ] C_i(x,y) = \beta \log[\alpha I&#x27;_i(x,y)] Ci(x,y)=βlog[αIi(x,y)]

    R M S R C R i ( x , y ) = C i ( x , y ) ∗ R M S R i ( x , y ) R_{MSRCR_i}(x,y) = C_i(x,y) *R_{MSR_i}(x,y) RMSRCRi(x,y)=Ci(x,y)RMSRi(x,y)

    其中 β = 46 , α = 125 β=46,α=125 β=46α=125为经验参数,测试取1试验表明效果还不错。
    对于一些原始图像HUE较为合理的图,如果用经典的MSRCR算法,会导致处理后的图容易偏色,上述论文提出了对图像的Intensity数据进行Retinex处理,然后再把数据根据原始的RGB的比例映射到每个通道,这样就能在保留原始颜色分布的基础上增强图像,文章中称其为MSRCP。

    MSRCR 算法步骤

    在这里插入图片描述
    该代码有误待修改

    import numpy as np
    import cv2
    
    
    def replaceZeroes(data):
        min_nonzero = min(data[np.nonzero(data)])
        data[data == 0] = min_nonzero
        return data
    
    
    def simple_color_balance(input_img, s1, s2):
        h, w = input_img.shape[:2]
        temp_img = input_img.copy()
        one_dim_array = temp_img.flatten()
        sort_array = sorted(one_dim_array)
    
        per1 = int((h * w) * s1 / 100)
        minvalue = sort_array[per1]
    
        per2 = int((h * w) * s2 / 100)
        maxvalue = sort_array[(h * w) - 1 - per2]
    
        # 实施简单白平衡算法
        if (maxvalue <= minvalue):
            out_img = np.full(input_img.shape, maxvalue)
        else:
            scale = 255.0 / (maxvalue - minvalue)
            out_img = np.where(temp_img < minvalue, 0)    # 防止像素溢出
            out_img = np.where(out_img > maxvalue, 255)   # 防止像素溢出
            out_img = scale * (out_img - minvalue)        # 映射中间段的图像像素
            out_img = cv2.convertScaleAbs(out_img)
        return out_img
    
    
    def MSRCR(img, scales, s1, s2):
        h, w = img.shape[:2]
        scles_size = len(scales)
        log_R = np.zeros((h, w), dtype=np.float32)
    
        img_sum = np.add(img[:,:,0],img[:,:,1],img[:,:,2])
        img_sum = replaceZeroes(img_sum)
        gray_img = []
    
        for j in range(3):
            img[:, :, j] = replaceZeroes(img[:, :, j])
            for i in range(0, scles_size):
                L_blur = cv2.GaussianBlur(img[:, :, j], (scales[i], scales[i]), 0)
                L_blur = replaceZeroes(L_blur)
    
                dst_img = cv2.log(img[:, :, j]/255.0)
                dst_Lblur = cv2.log(L_blur/255.0)
                dst_ixl = cv2.multiply(dst_img, dst_Lblur)
                log_R += cv2.subtract(dst_img, dst_ixl)
    
            MSR = log_R / 3.0
            MSRCR = MSR * (cv2.log(125.0 * img[:, :, j]) - cv2.log(img_sum))
            gray = simple_color_balance(MSRCR, s1, s2)
            gray_img.append(gray)
        return gray_img
    
    
    if __name__ == '__main__':
        img = './gggg/20190701133802.png'
        scales = [15,101,301]
        s1, s2 = 2,3
        src_img = cv2.imread(img)
        MSRCR_Out = MSRCR(src_img, scales, s1, s2)
    
        result = cv2.merge(MSRCR_Out[0],MSRCR_Out[1],MSRCR_Out[2])
    
        cv2.imshow('img',src_img)
        cv2.imshow('MSR_result',result)
        cv2.waitKey(0)
        cv2.destroyAllWindows()
    
    MSRCR其他实现方法

    MSRCR方法如上,且获得了不错的效果。但在博文《MSRCR》中,作者认为论文里的方法不起任何作用,并且论文里为了这个又引入了太多的可调参数,增加了算法的复杂性,不利于自动化实现。 博文作者认为,GIMP的contrast-retinex.c文件里使用的算法很好,效果也很好。他直接从量化的方式上入手,引入了均值和均方差的概念,再加上一个控制图像动态的参数来实现无色偏的调节过程,简要描述如下:

    计算出 log[R(x,y)]中R/G/B各通道数据的均值Mean和均方差Var(注意是均方差)。
    类似下述公式计算各通道的Min和Max值。

    • Min = Mean - Dynamic * Var;
      Max = Mean + Dynamic * Var;
    • 对Log[R(x,y)]的每一个值Value,进行线性映射:
      R(x,y) = ( Value - Min ) / (Max - Min) * (255 - 0), 同时要注意增加一个溢出判断,即:
      if (R(x, y) > 255) R(x,y) = 255;
      else if (R(x,y) < 0) R(x,y) = 0;
    • 就是经过这么简单的处理,实践证明可以取得非常好的效果,下面贴出一些处理后的效果。
    MSRCP算法实现:(代码有问题,改进待续)

    在这里插入图片描述

    import numpy as np
    import cv2
    
    
    def replaceZeroes(data):
        min_nonzero = min(data[np.nonzero(data)])
        data[data == 0] = min_nonzero
        return data
    
    def simple_color_balance(input_img, s1, s2):
        h, w = input_img.shape[:2]
        temp_img = input_img.copy()
        one_dim_array = temp_img.flatten()
        sort_array = sorted(one_dim_array)
    
        per1 = int((h * w) * s1 / 100)
        minvalue = sort_array[per1]
    
        per2 = int((h * w) * s2 / 100)
        maxvalue = sort_array[(h * w) - 1 - per2]
    
        # 实施简单白平衡算法
        if (maxvalue <= minvalue):
            out_img = np.full(input_img.shape, maxvalue)
        else:
            scale = 255.0 / (maxvalue - minvalue)
            out_img = np.where(temp_img < minvalue, 0,temp_img)   # 防止像素溢出
            out_img = np.where(out_img > maxvalue, 255,out_img)   # 防止像素溢出
            out_img = scale * (out_img - minvalue)                # 映射中间段的图像像素
            out_img = cv2.convertScaleAbs(out_img)
        return out_img
    
    
    def MSRCP(img, scales, s1, s2):
        h, w = img.shape[:2]
        scales_size = len(scales)
        B_chan = img[:, :, 0]
        G_chan = img[:, :, 1]
        R_chan = img[:, :, 2]
        log_R = np.zeros((h, w), dtype=np.float32)
        array_255 = np.full((h, w),255.0,dtype=np.float32)
    
        I_array = (B_chan + G_chan + R_chan) / 3.0
        I_array = replaceZeroes(I_array)
    
        for i in range(0, scales_size):
            L_blur = cv2.GaussianBlur(I_array, (scales[i], scales[i]), 0)
            L_blur = replaceZeroes(L_blur)
            dst_I = cv2.log(I_array/255.0)
            dst_Lblur = cv2.log(L_blur/255.0)
            dst_ixl = cv2.multiply(dst_I, dst_Lblur)
            log_R += cv2.subtract(dst_I, dst_ixl)
        MSR = log_R / 3.0
        Int1 = simple_color_balance(MSR, s1, s2)
    
        B_array = np.maximum(B_chan,G_chan,R_chan)
        A = np.minimum(array_255 / B_array, Int1/I_array)
        R_channel_out = A * R_chan
        G_channel_out = A * G_chan
        B_channel_out = A * B_chan
    
        MSRCP_Out_img = cv2.merge([B_channel_out, G_channel_out, R_channel_out])
        MSRCP_Out = cv2.convertScaleAbs(MSRCP_Out_img)
    
        return MSRCP_Out
    
    if __name__ == '__main__':
        img = './gggg/20190701133802.png'
        scales = [15,101,301]
        s1, s2 = 2,3
        src_img = cv2.imread(img)
        result = MSRCP(src_img, scales, s1, s2)
    
        cv2.imshow('img',src_img)
        cv2.imshow('MSR_result',result)
        cv2.waitKey(0)
        cv2.destroyAllWindows()
    

    特别鸣谢
    https://blog.csdn.net/lz0499/article/details/81840201
    http://www.cnblogs.com/sleepwalker/p/3676600.html?utm_source=tuicool&utm_medium=referral
    https://blog.csdn.net/weixin_38285131/article/details/88097771
    https://blog.csdn.net/ajianyingxiaoqinghan/article/details/71435098
    https://blog.csdn.net/lz0499/article/details/81154937

    展开全文
  • 图像增强Python实现)

    万次阅读 2018-12-02 09:58:37
    题目描述:对于下面这幅图像(图 1),请问可以通过那些图像增强的手段,达到改善视觉效果的目的?请显示处理结果,并附简要处理流程说明。  图 1 原图  常用的图像增强方法有以下几种: 1.提高对比度...
  • python 图像增强算法实现

    千次阅读 2021-01-23 10:46:01
    # 图像增强算法,图像锐化算法 # 1)基于直方图均衡化 2)基于拉普拉斯算子 3)基于对数变换 4)基于伽马变换 5)CLAHE 6)retinex-SSR 7)retinex-MSR # 其中,基于拉普拉斯算子的图像增强为利用空域卷积运算实现滤波 ...
  • python 基于opencv实现图像增强

    千次阅读 2021-01-28 10:03:34
    为了得到更加清晰的图像我们需要通过技术对图像进行处理,比如使用对比度增强的方法来处理图像,对比度增强就是对图像输出的灰度级放大到指定的程度,获得图像质量的提升。本文主要通过代码的方式,通过OpenCV的内置...
  • 数字图像处理python实现-图像增强

    千次阅读 2020-02-08 17:33:54
    冈萨雷斯-图像增强篇内容简介直方图均衡增强空间域算子增强合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右...
  • 图像增强处理:设计一套空间域与频率域结合的图像增强算法,处理以下任一组图片中的带噪声图像,去除噪声,提高图像质量。 (1)已知:噪声为随机噪声和周期噪声混合噪声; (2)要求: a)去噪处理后,计算均方误差...
  • Python中的图像增强

    千次阅读 2020-06-18 12:47:07
    当我们谈论图像增强时 ,这基本上意味着我们想要一个比原始图像更合适的图像新版本。 例如,当您扫描文档时,输出图像的质量可能会比原始输入图像低。 因此,我们需要一种提高输出图像质量的方法,以使输出图像在...
  • 一般我们对图像增强的是亮度,对比度,颜色,图像锐化等量纲。其中亮度是我们比较熟悉的量,也直观。对比度这就体现在灰度值上面提高对比度就会增大灰度值之间的差值!在这里为了大家更容理解亮度和对比度,我跟大家...
  • Matlab基于小波变换的图像增强的一些文献-基于小波变换的图像增强算法.pdf 希望可以对大家有帮助
  • 此代码可以实现图像的去噪和增强
  • opencv实现图像颜色增强算法。。。。 ,vs2013+opencv2.4.13 实现。
  • Retinex是一种常用的建立在科学实验和科学分析基础上的图像增强方法,它是Edwin.H.Land于1963年提出的。就跟Matlab是由Matrix和Laboratory合成的一样,Retinex也是由两个单词合成的一个词语,他们分别是retina 和...
  • 图像处理python

    2020-02-24 10:23:56
    通过python编写的一个图像处理系统,可以实现格式(尺寸、像素、角度)的改变,图像增强,过滤处理、合成处理以及相似度计算等功能,且可以根据不同处理类型的选择得到不同的处理效果。
  • Python 计算机视觉(八)—— OpenCV 进行图像增强

    千次阅读 多人点赞 2021-10-24 20:56:23
    本篇文章主要介绍了一些图像增强中常用的手段,包括直方图均衡化、局部直方图均衡化、图像的去雾处理等,使用到的参考资料我都粘贴在了原文中,如果想深入学习了解可以点进去进行查看

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,868
精华内容 13,547
关键字:

图像增强python

python 订阅