python去噪算法

《programming computer vision with python 》中denoise 算法有误，从网上好了可用的代码贴上，以便以后使用。

书中错误的代码：

def denoise(im,U_init,tolerance=0.1,tau=0.125,tv_weight=100):

    m,n = im.shape

    U = U_init

    Px = im

    Py = im

    error = 1

    

    while (error > tolerance):

        Uold = U

        GradUx = roll(U,-1,axis=1)-U

        GradUy = roll(U,-1,axis=0)-U

        

        PxNew = Px + (tau/tv_weight)*GradUx

        PyNew = Py + (tau/tv_weight)*GradUy

        NormNew = maximum(1,sqrt(PxNew**2+PyNew**2))

        

        Px = PxNew/NormNew

        py = PyNew/NormNew



        RxPx = roll(Px,1,axis=1)

        RyPy = roll(Py,1,axis=0)



        DivP = (Px - RxPx) + (Py - RyPy)

        U = im + tv_weight*DivP



        error = linalg.norm(U-Uold)/sqrt(n*m)

    return U,im-U

网上可用的代码：

def denoise(im, U_init, tolerance=0.1, tau=0.125, tv_weight=100):

    """ An implementation of the Rudin-Osher-Fatemi (ROF) denoising model

        using the numerical procedure presented in Eq. (11) of A. Chambolle

        (2005). Implemented using periodic boundary conditions 

        (essentially turning the rectangular image domain into a torus!).

    

        Input:

        im - noisy input image (grayscale)

        U_init - initial guess for U

        tv_weight - weight of the TV-regularizing term

        tau - steplength in the Chambolle algorithm

        tolerance - tolerance for determining the stop criterion

    

        Output:

        U - denoised and detextured image (also the primal variable)

        T - texture residual"""

    

    #---Initialization

    m,n = im.shape #size of noisy image



    U = U_init

    Px = im #x-component to the dual field

    Py = im #y-component of the dual field

    error = 1 

    iteration = 0



    #---Main iteration

    while (error > tolerance):

        Uold = U



        #Gradient of primal variable

        LyU = vstack((U[1:,:],U[0,:])) #Left translation w.r.t. the y-direction

        LxU = hstack((U[:,1:],U.take([0],axis=1))) #Left translation w.r.t. the x-direction



        GradUx = LxU-U #x-component of U's gradient

        GradUy = LyU-U #y-component of U's gradient



        #First we update the dual varible

        PxNew = Px + (tau/tv_weight)*GradUx #Non-normalized update of x-component (dual)

        PyNew = Py + (tau/tv_weight)*GradUy #Non-normalized update of y-component (dual)

        NormNew = maximum(1,sqrt(PxNew**2+PyNew**2))



        Px = PxNew/NormNew #Update of x-component (dual)

        Py = PyNew/NormNew #Update of y-component (dual)



        #Then we update the primal variable

        RxPx =hstack((Px.take([-1],axis=1),Px[:,0:-1])) #Right x-translation of x-component

        RyPy = vstack((Py[-1,:],Py[0:-1,:])) #Right y-translation of y-component

        DivP = (Px-RxPx)+(Py-RyPy) #Divergence of the dual field.

        U = im + tv_weight*DivP #Update of the primal variable



        #Update of error-measure

        error = linalg.norm(U-Uold)/sqrt(n*m);

        iteration += 1;



        print iteration, error



    #The texture residual

    T = im - U

    print 'Number of ROF iterations: ', iteration

    

    return U,T

测试代码：

from numpy import *

from numpy import random

from scipy.ndimage import filters

import rof

from scipy.misc import imsave



im = zeros((500,500))

im[100:400,100:400] = 128

im[200:300,200:300] = 255



im = im + 30*random.standard_normal((500,500))



imsave('synth_ori.pdf',im)



U,T = rof.denoise(im,im,0.07)



G = filters.gaussian_filter(im,10)





imsave('synth_rof.pdf',U)

imsave('synth_gaussian.pdf',G)