在早先的章节里，我们看到很多图像平滑技术如高斯模糊，Median模糊等，它们在移除数量小的噪音时在某种程度上比较好用。在这些技术里，我们取像素周围的一小部分邻居，做一些类似于高斯平均权重，中值等替换掉中间的元素。简单说，移除一个像素的噪音是基于本地邻居的。
噪音有一个属性，噪音一般被认为是具有零平均值的随机变量。假设一个像素噪音，p = p0 + n, 其中p0是像素的真实值，n是那个像素的噪音。你可以从不同图像取大量的同一个像素(N)并计算他们的平均值，理想情况下，你应该得到p=p0，因为均值是0.
你可以自己通过一个简单例子验证一下。保持一个静止的摄像机对准一个位置多呆几秒，这会给你很多帧，或者是对一个场景的很多图像。然后写一些代码来找到视频里所有帧的平均值。比较最终的结果和第一帧。你可以看到噪点被去掉了。不幸的是这个简单的方法对于摄像机和场景的运动来说就不健壮了。而且经常你也只有一个噪音图像可用。
Image Denoising
OpenCV提供了这种技术的四种变体。
cv2.fastNlMeansDenoising() - 使用单个灰度图像
cv2.fastNlMeansDenoisingColored() - 使用彩色图像。
cv2.fastNlMeansDenoisingMulti() - 用于在短时间内捕获的图像序列(灰度图像)
cv2.fastNlMeansDenoisingColoredMulti() - 与上面相同，但用于彩色图像。
Common arguments:
h：参数决定滤波器强度。较高的h值可以更好地消除噪声，但也会删除图像的细节 (10 is ok)
hForColorComponents：与h相同，但仅适用于彩色图像。 (通常与h相同)
templateWindowSize：应该是奇数。 (recommended 7)
searchWindowSize：应该是奇数。 (recommended 21)
cv2.fastNlMeansDenoisingColored()
如上所述，它用于从彩色图像中去除噪声。 (噪音预计是高斯噪音)
import numpy as np
import cv2
import matplotlib.pyplot as plt
img = cv2.imread('img.jpg')
dst = cv2.fastNlMeansDenoisingColored(img,None,10,10,7,21)
plt.subplot(121),plt.imshow(img)
plt.subplot(122),plt.imshow(dst)
plt.show()
cv2.fastNlMeansDenoisingMulti()
现在我们将相同的方法应用于视频。 第一个参数是嘈杂帧的列表。 第二个参数imgToDenoiseIndex指定我们需要去噪的帧，因为我们在输入列表中传递了frame的索引。 第三个是temporalWindowSize，它指定了用于去噪的附近帧的数量。 在这种情况下，使用总共temporalWindowSize帧，其中中心帧是要去噪的帧。 例如，传递了5个帧的列表作为输入。 设imgToDenoiseIndex = 2和temporalWindowSize = 3.然后使用frame-1，frame-2和frame-3对帧-2进行去噪
import numpy as np
import cv2
import matplotlib.pyplot as plt
cap = cv2.VideoCapture('test.mp4')
# create a list of first 5 frames
img = [cap.read()[1] for i in range(5)]
# convert all to grayscale
gray = [cv2.cvtColor(i, cv2.COLOR_BGR2GRAY) for i in img]
# convert all to float64
gray = [np.float64(i) for i in gray]
# create a noise of variance 25
noise = np.random.randn(*gray[1].shape)*10
# Add this noise to images
noisy = [i+noise for i in gray]
# Convert back to uint8
noisy = [np.uint8(np.clip(i,0,255)) for i in noisy]
# Denoise 3rd frame considering all the 5 frames
dst = cv2.fastNlMeansDenoisingMulti(noisy, 2, 5, None, 4, 7, 35)
plt.subplot(131),plt.imshow(gray[2],'gray')
plt.subplot(132),plt.imshow(noisy[2],'gray')
plt.subplot(133),plt.imshow(dst,'gray')
plt.show()
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我们。
本文标题: opencv python 图像去噪的实现方法
本文地址: http://www.cppcns.com/jiaoben/python/238703.html

作者|OpenCV-Python Tutorials 
编译|Vincent
来源|OpenCV-Python Tutorials 
目标
在本章中，

你将学习用于去除图像中噪声的非局部均值去噪算法。
你将看到不同的函数，例如cv.fastNlMeansDenoising()，cv.fastNlMeansDenoisingColored()等。

理论
在前面的章节中，我们已经看到了许多图像平滑技术，例如高斯模糊，中值模糊等，它们在某种程度上可以消除少量噪声。在这些技术中，我们在像素周围采取了一个较小的邻域，并进行了一些操作，例如高斯加权平均值，值的中位数等来替换中心元素。简而言之，在像素处去除噪声是其周围的局部现象。
有噪声的性质。
通常认为噪声是零均值的随机变量。考虑一个有噪声的像素，$p=p_0+n$，其中$p_0$是像素的真实值，$n$是该像素中的噪声。你可以从不同的图像中获取大量相同的像素（例如N）并计算其平均值。理想情况下，由于噪声的平均值为零，因此应该得到$p = p_0$。
你可以通过简单的设置自己进行验证。将静态相机固定在某个位置几秒钟。这将为你提供很多帧或同一场景的很多图像。然后编写一段代码，找到视频中所有帧的平均值（这对你现在应该太简单了）。
比较最终结果和第一帧。你会看到噪声减少。不幸的是，这种简单的方法对摄像机和场景的运动并不稳健。通常，只有一张嘈杂的图像可用。
因此想法很简单，我们需要一组相似的图像来平均噪声。考虑图像中的一个小窗口（例如5x5窗口）。
很有可能同一修补程序可能位于图像中的其他位置。有时在它周围的一个小社区中。一起使用这些相似的补丁并找到它们的平均值怎么办？对于那个特定的窗口，这很好。请参阅下面的示例图片：

图像中的蓝色补丁看起来很相似。绿色补丁看起来很相似。因此，我们获取一个像素，在其周围获取一个小窗口，在图像中搜索相似的窗口，对所有窗口求平均，然后用得到的结果替换该像素。此方法是“非本地均值消噪”。与我们之前看到的模糊技术相比，它花费了更多时间，但是效果非常好。更多信息和在线演示可在其他资源的第一个链接中找到。
对于彩色图像，图像将转换为CIELAB色彩空间，然后分别对L和AB分量进行降噪。
OpenCV中的图像去噪
OpenCV提供了此方法的四个变体。

cv.fastNlMeansDenoising()-处理单个灰度图像
cv.fastNlMeansDenoisingColored()-处理彩色图像。
cv.fastNlMeansDenoisingMulti()-处理在短时间内捕获的图像序列（灰度图像）
cv.fastNlMeansDenoisingColoredMulti()-与上面相同，但用于彩色图像。

常用参数为：

h：决定滤波器强度的参数。较高的h值可以更好地消除噪点，但同时也可以消除图像细节。（可以设为10）
hForColorComponents：与h相同，但仅用于彩色图像。（通常与h相同）
templateWindowSize：应为奇数。（建议设为7）
searchWindowSize：应为奇数。（建议设为21）

请访问其他资源中的第一个链接，以获取有关这些参数的更多详细信息。
我们将在此处演示2和3。剩下的留给你。

cv.fastNlMeansDenoisingColored()
如上所述，它用于消除彩色图像中的噪点。（噪声可能是高斯的）。请参阅以下示例：

import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt
img = cv.imread('die.png')
dst = cv.fastNlMeansDenoisingColored(img,None,10,10,7,21)
plt.subplot(121),plt.imshow(img)
plt.subplot(122),plt.imshow(dst)
plt.show()
以下是结果的放大版本。我的输入图像的高斯噪声为$σ= 25$。查看结果：


cv.fastNlMeansDenoisingMulti()
现在，我们将对视频应用相同的方法。第一个参数是噪声帧列表。第二个参数imgToDenoiseIndex指定我们需要去噪的帧，为此，我们在输入列表中传递帧的索引。第三是temporalWindowSize，它指定要用于降噪的附近帧的数量。应该很奇怪。在那种情况下，总共使用temporalWindowSize帧，其中中心帧是要被去噪的帧。例如，你传递了一个5帧的列表作为输入。令imgToDenoiseIndex = 2,temporalWindowSize =3。然后使用frame-1，frame-2和frame-3去噪frame-2。让我们来看一个例子。
import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt
cap = cv.VideoCapture('vtest.avi')
# 创建5个帧的列表
img = [cap.read()[1] for i in xrange(5)]
# 将所有转化为灰度
gray = [cv.cvtColor(i, cv.COLOR_BGR2GRAY) for i in img]
# 将所有转化为float64
gray = [np.float64(i) for i in gray]
# 创建方差为25的噪声
noise = np.random.randn(*gray[1].shape)*10
# 在图像上添加噪声
noisy = [i+noise for i in gray]
# 转化为unit8
noisy = [np.uint8(np.clip(i,0,255)) for i in noisy]
# 对第三帧进行降噪
dst = cv.fastNlMeansDenoisingMulti(noisy, 2, 5, None, 4, 7, 35)
plt.subplot(131),plt.imshow(gray[2],'gray')
plt.subplot(132),plt.imshow(noisy[2],'gray')
plt.subplot(133),plt.imshow(dst,'gray')
plt.show()



计算需要花费大量时间。结果，第一个图像是原始帧，第二个是噪声帧，第三个是去噪图像。
附加资源

http://www.ipol.im/pub/art/2011/bcm_nlm/ (它包含详细信息，在线演示等。强烈建议访问。我们的测试图像是从此链接生成的)
Online course at coursera (这里拍摄的第一张图片)

练习
欢迎关注磐创AI博客站：
http://panchuang.net/
OpenCV中文官方文档：
http://woshicver.com/
欢迎关注磐创博客资源汇总站：
http://docs.panchuang.net/

Non-local Mean 图像去噪算法的基本实现(Python)

最近开始做视频去噪方面的工作，无一例外就会看到NLM这种经典的基于块匹配图像去噪算法。 

那么最最基本的NLM算法所涉及的公式如下所示： 

 

为加深对公式的理解，写了个python版本的NLM，内含6个循环，没有做任何算法上的优化，没有矩阵运算，什么都没有，效率极低。



def imnlmeans_naive(img, sigma, s1, s2, p1,p2, h):

    # backup
    img_out = np.zeros((img.shape[0],img.shape[1]))

    # padding
    pad = int((s1+s2)/2 + (p1+p2)/2)
    img_pad = np.lib.pad(img, pad, 'symmetric')
    # plt.imshow(img_pad, cmap=plt.cm.gray)
    # plt.show()
    hight = img.shape[0]
    width = img.shape[1]
    P = (2*p1+1)*(2*p2+1)
    patch = 0
    patch2 = 0
    Z = 0
    for i in range(s1+p1,hight+s1+p1+1):
        for j in range(s2+p2,width+s2+p2+1):
            for i1 in range(i-s1,i+s1+1):
                for j1 in range(j-s2,j+s2+1):
                    for i2 in range(i1-p1,i1+p1+1):
                        for j2 in range(j1-p2,j1+p2+1):
                            patch = patch + (img_pad[i2,j2] - img_pad[i2+p1+s1,j1+p2+s2])**2
                    patch = patch / P
                    f = fai(patch, sigma, h, P)
                    patch2 = patch2 + f*img_pad[i1,j1]
                    Z = Z + f
            img_out[i-s1-p1,j-s2-p2] = 1.0/Z*patch2
    return img_out

接下来会放出NLM优化后的python代码，以及NLM的改进算法，即基于块(Block-wise NL-means)的NLM。 

图像去噪的东西才刚刚接触，所以有些词语、说法会不准确，还请大家指出不足、不准确之处，谢谢。

#coding:utf-8
import sys,os
from PIL import Image,ImageDraw

#二值数组
t2val = {}
def twoValue(image,G):
    for y in xrange(0,image.size[1]):
        for x in xrange(0,image.size[0]):
            g = image.getpixel((x,y))
            if g > G:
                t2val[(x,y)] = 1
            else:
                t2val[(x,y)] = 0

# 降噪 
# 根据一个点A的RGB值，与周围的8个点的RBG值比较，设定一个值N（0 <N <8），当A的RGB值与周围8个点的RGB相等数小于N时，此点为噪点 
# G: Integer 图像二值化阀值 
# N: Integer 降噪率 0 <N <8 
# Z: Integer 降噪次数 
# 输出 
#  0：降噪成功 
#  1：降噪失败 
def clearNoise(image,N,Z):

    for i in xrange(0,Z):
        t2val[(0,0)] = 1
        t2val[(image.size[0] - 1,image.size[1] - 1)] = 1

        for x in xrange(1,image.size[0] - 1):
            for y in xrange(1,image.size[1] - 1):
                nearDots = 0
                L = t2val[(x,y)]
                if L == t2val[(x - 1,y - 1)]:
                    nearDots += 1
                if L == t2val[(x - 1,y)]:
                    nearDots += 1
                if L == t2val[(x- 1,y + 1)]:
                    nearDots += 1
                if L == t2val[(x,y - 1)]:
                    nearDots += 1
                if L == t2val[(x,y + 1)]:
                    nearDots += 1
                if L == t2val[(x + 1,y - 1)]:
                    nearDots += 1
                if L == t2val[(x + 1,y)]:
                    nearDots += 1
                if L == t2val[(x + 1,y + 1)]:
                    nearDots += 1

                if nearDots < N:
                    t2val[(x,y)] = 1

def saveImage(filename,size):
    image = Image.new("1",size)
    draw = ImageDraw.Draw(image)

    for x in xrange(0,size[0]):
        for y in xrange(0,size[1]):
            draw.point((x,y),t2val[(x,y)])

    image.save(filename)

image = Image.open("d:/1.jpg").convert("L")
twoValue(image,100)
clearNoise(image,4,1)
saveImage("d:/5.jpg",image.size)