cimg.cxx 3.6.3

package/plugins/matlab.h

@@ -0,0 +1,287 @@
+/*************************************************************************
+ * matlab.h
+ * ---------
+ *
+ * matlab.h is a "plugin" for the CImg library that allows to convert
+ * CImg<T> images from/to MATLAB arrays, so that CImg can be used to write
+ * MATLAB mex files.  It also swaps the "x" and "y" coordinates when going
+ * from / to MATLAB array, i.e. the usual image-processing annoying MATLAB
+ * behaviour of considering images as matrices.
+ *
+ * Added to the CImg<T> class are:
+ *
+ *  - a constructor : CImg(const mxArray *matlabArray, bool vdata = false)
+ *    the vdata  serves  to  decide  whether a 3D matlab array should give
+ *    rise to a 3D CImg object or a "2D vectorial" one.
+ *
+ *  - a assignment operator : CImg & operator=(const mxArray *matlabArray)
+ *    (I use myself extremely seldom and might remove it in the future).
+ *
+ *  - a routine converting a CImg image to a matlab array:
+ *    mxArray *toMatlab(mxClassID classID = mxDOUBLE_CLASS,
+ *                      bool squeeze = false) const
+ *    the squeeze argument serves the opposite purpose than the vdata from
+ *    the constructor.
+ *
+ * For a  bit  more documentation, the manual is this header, see the more
+ * detailed comments in the source code (i.e. RTFM)
+ *
+ *
+ * Its usage should be straightforward:
+ *
+ * - file matlab.h must be in a directory that the compiler can locate.
+ * - prior to include CImg.h, mex.h  must  be  included first, else it will
+ *   result in a compiler error.
+ * - after the inclusion of mex.h, one must define the macro cimg_plugin as
+ *   "matlab.h"  or  <matlab.h> or  <CImg/plugins/matlab.h>  or
+ *   a variation that  matches your  local installation of CImg package and
+ *   plugins probably via the appropriate specification of the include path
+ *   "-Ipath/to/cimg/and/plugins" at mex cmdline.
+ *
+ * You would probably have this kind of declaration:
+ *
+ * // The begining of my fantastic mex file code...
+ * #include <mex.h>
+ * ...
+ * #define cimg_plugin  <matlab.h>
+ * #include <CImg.h>
+ * ...
+ * // and now I can implement my new killer MATLAB function!
+ * ....
+ *
+ *
+ * Copyright (c) 2004-2008 Francois Lauze
+ * Licence: the Gnu Lesser General Public License
+ * http://www.gnu.org/licenses/lgpl.html
+ *
+ * MATLAB is copyright of The MathWorks, Inc, http://www.mathworks.com
+ *
+ * Any comments, improvements and potential bug corrections are welcome, so
+ * write to  me at francois@diku.dk, or use CImg forums, I promise I'll try
+ * to read them once in a while. BTW who modified the cpMatlabData with the
+ * cimg::type<t>::is_float() test (good idea!)
+ *
+ ***************************************************************************/
+
+#ifndef cimg_plugin_matlab
+#define cimg_plugin_matlab
+
+#define CIMGMATLAB_VER 0102
+#ifndef mex_h
+#error the file mex.h must be included prior to inclusion of matlab.h
+#endif
+#ifndef cimg_version
+#error matlab.h requires that CImg.h is included!
+#endif
+
+/**********************************************************
+ * introduction of mwSize and mwIndex types in relatively *
+ * recent versions of matlab, 7.3.0 from what I gathered. *
+ * here is hopefully a needed fix for older versions      *
+ **********************************************************/
+#if !defined(MX_API_VER) ||  MX_API_VER < 0x7030000
+typedef int mwSize;
+#endif
+
+/*********************************************************
+ * begin of included methods                             *
+ * They are just added as member functions / constructor *
+ * for the CImg<T> class.                                *
+ *********************************************************/
+
+private:
+
+/**********************************************************************
+ * internally used to transfer MATLAB array values to CImg<> objects,
+ * check wether the array type is a "numerical" one (including logical)
+ */
+static int isNumericalClassID(mxClassID id) {
+  // all these constants are defined in matrix.h included by mex.h
+  switch (id) {
+  case mxLOGICAL_CLASS:
+  case mxDOUBLE_CLASS:
+  case mxSINGLE_CLASS:
+  case mxINT8_CLASS:
+  case mxUINT8_CLASS:
+  case mxINT16_CLASS:
+  case mxUINT16_CLASS:
+  case mxINT32_CLASS:
+  case mxUINT32_CLASS:
+  case mxINT64_CLASS:
+  case mxUINT64_CLASS: return 1;
+  default: return 0;
+  }
+}
+
+/***************************************************
+ * driving routine that will copy the content of
+ * a MATLAB array to this->_data
+ * The type names used are defined in matlab c/c++
+ * header file tmwtypes.h
+ */
+void makeImageFromMatlabData(const mxArray *matlabArray, mxClassID classID) {
+  if (classID==mxLOGICAL_CLASS) {
+    // logical type works a bit differently than the numerical types
+    mxLogical *mdata = mxGetLogicals(matlabArray);
+    cpMatlabData((const mxLogical *)mdata);
+  } else {
+    void *mdata = (void*)mxGetPr(matlabArray);
+    switch (classID) {
+    case mxDOUBLE_CLASS : cpMatlabData((const real64_T*)mdata); break;
+    case mxSINGLE_CLASS : cpMatlabData((const real32_T*)mdata); break;
+    case mxINT8_CLASS : cpMatlabData((const int8_T*)mdata); break;
+    case mxUINT8_CLASS : cpMatlabData((const uint8_T*)mdata); break;
+    case mxINT16_CLASS : cpMatlabData((const int16_T*)mdata); break;
+    case mxUINT16_CLASS : cpMatlabData((const uint16_T*)mdata); break;
+    case mxINT32_CLASS : cpMatlabData((const int32_T*)mdata); break;
+    case mxUINT32_CLASS : cpMatlabData((const uint32_T*)mdata); break;
+    case mxINT64_CLASS : cpMatlabData((const int64_T*)mdata); break;
+    case mxUINT64_CLASS : cpMatlabData((const uint64_T*)mdata); break;
+    }
+  }
+}
+
+/***********************************************************
+ * the actual memory copy and base type conversion is then
+ * performed by this routine that handles the annoying x-y
+ * problem of MATLAB when dealing with images: we switch
+ * line and column storage: the MATLAB A(x,y) becomes the
+ * CImg img(y,x)
+ */
+template <typename t> void cpMatlabData(const t* mdata) {
+  if (cimg::type<t>::is_float()) {
+    cimg_forXYZC(*this,x,y,z,v) (*this)(x,y,z,v) = (T)(mdata[((v*_depth + z)*_width + x)*_height + y]);
+  } else {
+    cimg_forXYZC(*this,x,y,z,v) (*this)(x,y,z,v) = (T)(int)(mdata[((v*_depth + z)*_width + x)*_height + y]);
+  }
+}
+
+public:
+
+/******************************************************************
+ * Consruct a CImg<T> object from a MATLAB mxArray.
+ * The MATLAB array must be AT MOST 4-dimensional. The boolean
+ * argument vdata is employed in the case the the input mxArray
+ * has dimension 3, say M x N x K. In that case, if vdata is true,
+ * the last dimension is assumed to be "vectorial" and the
+ * resulting CImg<T> object has dimension N x M x 1 x K. Otherwise,
+ * the resulting object has dimension N x M x K x 1.
+ * When MATLAB array has dimension 2 or 4, vdata has no effects.
+ * No shared memory mechanisms are used, it would be the easiest
+ * to crash Matlab (from my own experience...)
+ */
+CImg(const mxArray *matlabArray, const bool vdata = false)
+  : _is_shared(false) {
+  mwSize nbdims = mxGetNumberOfDimensions(matlabArray);
+  mxClassID classID = mxGetClassID(matlabArray);
+  if (nbdims>4 || !isNumericalClassID(classID)) {
+    _data = 0; _width = _height = _depth = _spectrum = 0;
+#if cimg_debug>1
+    cimg::warn("MATLAB array is more than 4D or/and not numerical, returning an empty image.");
+#endif
+  } else {
+    const mwSize *dims = mxGetDimensions(matlabArray);
+    _depth = _spectrum = 1;
+    _width = (unsigned)dims[1];
+    _height = (unsigned)dims[0];
+    if (nbdims==4) { _depth = (unsigned)dims[2]; _spectrum = (unsigned)dims[3]; }
+    else if (nbdims==3) {
+      if (vdata) _spectrum = (unsigned)dims[2]; else _depth = (unsigned)dims[2];
+    }
+    _data = new T[size()];
+    makeImageFromMatlabData(matlabArray,classID);
+  }
+}
+
+/*******************************************************************
+ * operator=(). Copy  mxMarray data mArray into the current image
+ * Works as the previous constructor, but without the vdata stuff.
+ * don't know if it is of any use...
+ */
+CImg & operator=(const mxArray *matlabArray) {
+  int
+    nbdims = (int)mxGetNumberOfDimensions(matlabArray),
+    classID = mxGetClassID(matlabArray);
+  if (nbdims>4 || !isNumericalClassID(classID)) {
+    delete [] _data; _data = 0;
+    _width = _height = _depth = _spectrum = 0;
+#if cimg_debug>1
+    cimg::warn("MATLAB array is more than 4D or/and not numerical, returning an empty image.");
+#endif
+  } else {
+    const mwSize *dims = mxGetDimensions(matlabArray);
+    _depth = _spectrum = 1;
+    _width =  (unsigned)dims[1];
+    _height = (unsigned)dims[0];
+    if (nbdims>2) _depth = (unsigned)dims[2];
+    else if (nbdims>3) _spectrum = (unsigned)dims[3];
+    delete [] _data;
+    _data = new T[size()];
+    makeImageFromMatlabData(matlabArray,classID);
+  }
+}
+
+private:
+
+/*****************************************************************
+ * private routines used for transfering a CImg<T> to a mxArray
+ * here also, we have to exchange the x and y dims so we get the
+ * expected MATLAB array.
+ */
+template <typename c> void populate_maltlab_array(c *const mdata) const {
+  cimg_forXYZC(*this,x,y,z,v) mdata[((v*_depth + z)*_width + x)*_height + y] = (c)(*this)(x,y,z,v);
+}
+
+/*************************************************
+ * the specialized version for "logical" entries
+ */
+void populate_maltlab_array(mxLogical *const mdata) const {
+  cimg_forXYZC(*this,x,y,z,v) mdata[((v*_depth + z)*_width + x)*_height + y] = (mxLogical)((*this)(x,y,z,v)!=0);
+}
+
+public:
+
+/******************************************
+ * export a CImg image to a MATLAB array.
+ **/
+mxArray *toMatlab(mxClassID classID=mxDOUBLE_CLASS, const bool squeeze=false) const {
+  if (!isNumericalClassID(classID)) {
+#if cimg_debug>1
+    cimg::warn("Invalid MATLAB Class Id Specified.");
+#endif
+    return 0;
+  }
+  mwSize dims[4];
+  dims[0] = (mwSize)_height;
+  dims[1] = (mwSize)_width;
+  dims[2] = (mwSize)_depth;
+  dims[3] = (mwSize)_spectrum;
+
+  if (squeeze && _depth == 1) {
+    dims[2] = (mwSize)_spectrum;
+    dims[3] = (mwSize)1;
+  }
+  mxArray *matlabArray = mxCreateNumericArray((mwSize)4,dims,classID,mxREAL);
+  if (classID==mxLOGICAL_CLASS) {
+    mxLogical *mdata = mxGetLogicals(matlabArray);
+    populate_maltlab_array(mdata);
+  } else {
+    void *mdata = mxGetPr(matlabArray);
+    switch (classID) {
+    case mxDOUBLE_CLASS : populate_maltlab_array((real64_T*)mdata); break;
+    case mxSINGLE_CLASS : populate_maltlab_array((real32_T*)mdata); break;
+    case mxINT8_CLASS : populate_maltlab_array((int8_T*)mdata); break;
+    case mxUINT8_CLASS : populate_maltlab_array((uint8_T*)mdata); break;
+    case mxINT16_CLASS : populate_maltlab_array((int16_T*)mdata); break;
+    case mxUINT16_CLASS : populate_maltlab_array((uint16_T*)mdata); break;
+    case mxINT32_CLASS : populate_maltlab_array((int32_T*)mdata); break;
+    case mxUINT32_CLASS : populate_maltlab_array((uint32_T*)mdata); break;
+    case mxINT64_CLASS : populate_maltlab_array((int64_T*)mdata); break;
+    case mxUINT64_CLASS : populate_maltlab_array((uint64_T*)mdata); break;
+    }
+  }
+  return matlabArray;
+}
+
+// end of matlab.h
+#endif /* cimg_plugin_matlab */

package/plugins/nlmeans.h

@@ -0,0 +1,242 @@
+/*
+ #
+ #  File        : nlmeans.h
+ #                ( C++ header file - CImg plug-in )
+ #
+ #  Description : CImg plugin that implements the non-local mean filter.
+ #                This file is a part of the CImg Library project.
+ #                ( http://cimg.eu )
+ #
+ #  [1] Buades, A.; Coll, B.; Morel, J.-M.: A non-local algorithm for image denoising
+ #      IEEE Computer Society Conference on Computer Vision and Pattern Recognition, 2005. CVPR 2005.
+ #      Volume 2,  20-25 June 2005 Page(s):60 - 65 vol. 2
+ #
+ #  [2] Buades, A. Coll, B. and Morel, J.: A review of image denoising algorithms, with a new one.
+ #      Multiscale Modeling and Simulation: A SIAM Interdisciplinary Journal 4 (2004) 490-530
+ #
+ #  [3] Gasser, T. Sroka,L. Jennen Steinmetz,C. Residual variance and residual pattern nonlinear regression.
+ #      Biometrika 73 (1986) 625-659
+ #
+ #  Copyright   : Jerome Boulanger
+ #                ( http://www.irisa.fr/vista/Equipe/People/Jerome.Boulanger.html )
+ #
+ #  License     : CeCILL v2.0
+ #                ( http://www.cecill.info/licences/Licence_CeCILL_V2-en.html )
+ #
+ #  This software is governed by the CeCILL  license under French law and
+ #  abiding by the rules of distribution of free software.  You can  use,
+ #  modify and/ or redistribute the software under the terms of the CeCILL
+ #  license as circulated by CEA, CNRS and INRIA at the following URL
+ #  "http://www.cecill.info".
+ #
+ #  As a counterpart to the access to the source code and  rights to copy,
+ #  modify and redistribute granted by the license, users are provided only
+ #  with a limited warranty  and the software's author,  the holder of the
+ #  economic rights,  and the successive licensors  have only  limited
+ #  liability.
+ #
+ #  In this respect, the user's attention is drawn to the risks associated
+ #  with loading,  using,  modifying and/or developing or reproducing the
+ #  software by the user in light of its specific status of free software,
+ #  that may mean  that it is complicated to manipulate,  and  that  also
+ #  therefore means  that it is reserved for developers  and  experienced
+ #  professionals having in-depth computer knowledge. Users are therefore
+ #  encouraged to load and test the software's suitability as regards their
+ #  requirements in conditions enabling the security of their systems and/or
+ #  data to be ensured and,  more generally, to use and operate it in the
+ #  same conditions as regards security.
+ #
+ #  The fact that you are presently reading this means that you have had
+ #  knowledge of the CeCILL license and that you accept its terms.
+ #
+*/
+
+#ifndef cimg_plugin_nlmeans
+#define cimg_plugin_nlmeans
+
+//! NL-Means denoising algorithm.
+/**
+   This is the in-place version of get_nlmean().
+**/
+CImg<T>& nlmeans(int patch_size=1, double lambda=-1, double alpha=3, double sigma=-1, int sampling=1){
+  if (!is_empty()){
+    if (sigma<0) sigma = std::sqrt(variance_noise()); // noise variance estimation
+    const double np = (2*patch_size + 1)*(2*patch_size + 1)*spectrum()/(double)sampling;
+    if (lambda<0) {// Bandwidth estimation
+      if (np<100)
+        lambda = ((((((1.1785e-12*np - 5.1827e-10)*np + 9.5946e-08)*np -
+                     9.7798e-06)*np + 6.0756e-04)*np - 0.0248)*np + 1.9203)*np + 7.9599;
+      else
+        lambda = (-7.2611e-04*np + 1.3213)*np + 15.2726;
+    }
+#if cimg_debug>=1
+    std::fprintf(stderr,"Size of the patch                              : %dx%d \n",
+                 2*patch_size + 1,2*patch_size + 1);
+    std::fprintf(stderr,"Size of window where similar patch are looked for : %dx%d \n",
+                 (int)(alpha*(2*patch_size + 1)),(int)(alpha*(2*patch_size + 1)));
+    std::fprintf(stderr,"Bandwidth of the kernel                                : %fx%f^2 \n",
+                 lambda,sigma);
+    std::fprintf(stderr,"Noise standard deviation estimated to          : %f \n",
+                 sigma);
+#endif
+
+    CImg<T> dest(width(),height(),depth(),spectrum(),0);
+    double *uhat = new double[spectrum()];
+    const double h2 = -.5/(lambda*sigma*sigma); // [Kervrann] notations
+    if (depth()!=1){ // 3D case
+      const CImg<> P = (*this).get_blur(1); // inspired from Mahmoudi&Sapiro SPletter dec 05
+      const int n_simu = 64;
+      CImg<> tmp(n_simu,n_simu,n_simu);
+      const double sig = std::sqrt(tmp.fill(0.f).noise(sigma).blur(1).pow(2.).sum()/(n_simu*n_simu*n_simu));
+      const int
+        patch_size_z = 0,
+        pxi = (int)(alpha*patch_size),
+        pyi = (int)(alpha*patch_size),
+        pzi = 2; //Define the size of the neighborhood in z
+      for (int zi = 0; zi<depth(); ++zi) {
+#if cimg_debug>=1
+        std::fprintf(stderr,"\rProcessing : %3d %%",(int)((float)zi/(float)depth()*100.));fflush(stdout);
+#endif
+        for (int yi = 0; yi<height(); ++yi)
+          for (int xi = 0; xi<width(); ++xi) {
+            cimg_forC(*this,v) uhat[v] = 0;
+            float sw = 0, wmax = -1;
+            for (int zj = std::max(0,zi - pzi); zj<std::min(depth(),zi + pzi + 1); ++zj)
+              for (int yj = std::max(0,yi - pyi); yj<std::min(height(),yi + pyi + 1); ++yj)
+                for (int xj = std::max(0,xi - pxi); xj<std::min(width(),xi + pxi + 1); ++xj)
+                  if (cimg::abs(P(xi,yi,zi) - P(xj,yj,zj))/sig<3) {
+                    double d = 0;
+                    int n = 0;
+                    if (xi!=xj && yi!=yj && zi!=zj){
+                      for (int kz = -patch_size_z; kz<patch_size_z + 1; kz+=sampling) {
+                        int
+                          zj_ = zj + kz,
+                          zi_ = zi + kz;
+                        if (zj_>=0 && zj_<depth() && zi_>=0 && zi_<depth())
+                          for (int ky = -patch_size; ky<=patch_size; ky+=sampling) {
+                            int
+                              yj_ = yj + ky,
+                              yi_ = yi + ky;
+                            if (yj_>=0 && yj_<height() && yi_>=0 && yi_<height())
+                              for (int kx = -patch_size; kx<=patch_size; kx+=sampling) {
+                                int
+                                  xj_ = xj + kx,
+                                  xi_ = xi + kx;
+                                if (xj_>=0 && xj_<width() && xi_>=0 && xi_<width())
+                                  cimg_forC(*this,v) {
+                                    double d1 = (*this)(xj_,yj_,zj_,v) - (*this)(xi_,yi_,zi_,v);
+                                    d+=d1*d1;
+                                    ++n;
+                                  }
+                              }
+                          }
+                      }
+                      float w = (float)std::exp(d*h2);
+                      wmax = w>wmax?w:wmax;
+                      cimg_forC(*this,v) uhat[v]+=w*(*this)(xj,yj,zj,v);
+                      sw+=w;
+                    }
+                  }
+            // add the central pixel
+            cimg_forC(*this,v) uhat[v]+=wmax*(*this)(xi,yi,zi,v);
+            sw+=wmax;
+            if (sw) cimg_forC(*this,v) dest(xi,yi,zi,v) = (T)(uhat[v]/=sw);
+            else cimg_forC(*this,v) dest(xi,yi,zi,v) = (*this)(xi,yi,zi,v);
+          }
+      }
+    }
+    else { // 2D case
+      const CImg<> P = (*this).get_blur(1); // inspired from Mahmoudi&Sapiro SPletter dec 05
+      const int n_simu = 512;
+      CImg<> tmp(n_simu,n_simu);
+      const double sig = std::sqrt(tmp.fill(0.f).noise(sigma).blur(1).pow(2.).sum()/(n_simu*n_simu));
+      const int
+        pxi = (int)(alpha*patch_size),
+        pyi = (int)(alpha*patch_size); //Define the size of the neighborhood
+      for (int yi = 0; yi<height(); ++yi) {
+#if cimg_debug>=1
+        std::fprintf(stderr,"\rProcessing : %3d %%",(int)((float)yi/(float)height()*100.));fflush(stdout);
+#endif
+        for (int xi = 0; xi<width(); ++xi) {
+          cimg_forC(*this,v) uhat[v] = 0;
+          float sw = 0, wmax = -1;
+          for (int yj = std::max(0,yi - pyi); yj<std::min(height(),yi + pyi + 1); ++yj)
+            for (int xj = std::max(0,xi - pxi); xj<std::min(width(),xi + pxi + 1); ++xj)
+              if (cimg::abs(P(xi,yi) - P(xj,yj))/sig<3.) {
+                double d = 0;
+                int n = 0;
+                if (!(xi==xj && yi==yj)) //{
+                  for (int ky = -patch_size; ky<patch_size + 1; ky+=sampling) {
+                    int
+                      yj_ = yj + ky,
+                      yi_ = yi + ky;
+                    if (yj_>=0 && yj_<height() && yi_>=0 && yi_<height())
+                      for (int kx = -patch_size; kx<patch_size + 1; kx+=sampling) {
+                        int
+                          xj_ = xj + kx,
+                          xi_ = xi + kx;
+                        if (xj_>=0 && xj_<width() && xi_>=0 && xi_<width())
+                          cimg_forC(*this,v) {
+                            double d1 = (*this)(xj_,yj_,v) - (*this)(xi_,yi_,v);
+                            d+=d1*d1;
+                            n++;
+                          }
+                      }
+                    //}
+                float w = (float)std::exp(d*h2);
+                cimg_forC(*this,v) uhat[v]+=w*(*this)(xj,yj,v);
+                wmax = w>wmax?w:wmax; // Store the maximum of the weights
+                sw+=w; // Compute the sum of the weights
+                }
+              }
+          // add the central pixel with the maximum weight
+          cimg_forC(*this,v) uhat[v]+=wmax*(*this)(xi,yi,v);
+          sw+=wmax;
+
+          // Compute the estimate for the current pixel
+          if (sw) cimg_forC(*this,v) dest(xi,yi,v) = (T)(uhat[v]/=sw);
+          else cimg_forC(*this,v) dest(xi,yi,v) = (*this)(xi,yi,v);
+        }
+      } // main loop
+    } // 2d
+    delete [] uhat;
+    dest.move_to(*this);
+#if cimg_debug>=1
+    std::fprintf(stderr,"\n"); // make a new line
+#endif
+  } // is empty
+  return *this;
+}
+
+//! Get the result of the NL-Means denoising algorithm.
+/**
+   \param patch_size = radius of the patch (1=3x3 by default)
+   \param lambda = bandwidth ( -1 by default : automatic selection)
+   \param alpha  = size of the region where similar patch are searched (3 x patch_size = 9x9 by default)
+   \param sigma = noise standard deviation (-1 = estimation)
+   \param sampling = sampling of the patch (1 = uses all point, 2 = uses one point on 4, etc)
+   If the image has three dimensions then the patch is only in  2D and the neighborhood extent in time is only 5.
+   If the image has several channel (color images), the distance between the two patch is computed using
+   all the channels.
+   The greater the patch is the best is the result.
+   Lambda parameter is function of the size of the patch size. The automatic Lambda parameter is taken
+   in the Chi2 table at a significiance level of 0.01. This diffear from the original paper [1].
+   The weighted average becomes then:
+   \f$$ \hat{f}(x,y) = \sum_{x',y'} \frac{1}{Z} exp(\frac{P(x,y)-P(x',y')}{2 \lambda \sigma^2}) f(x',y') $$\f
+   where \f$ P(x,y) $\f denotes the patch in (x,y) location.
+
+   An a priori is also used to increase the speed of the algorithm in the spirit of Sapiro et al. SPletter dec 05
+
+   This very basic version of the Non-Local Means algorithm provides an output image which contains
+   some residual noise with a relatively small variance (\f$\sigma<5$\f).
+
+   [1] A non-local algorithm for image denoising
+   Buades, A.; Coll, B.; Morel, J.-M.;
+   Computer Vision and Pattern Recognition, 2005. CVPR 2005. IEEE Computer Society Conference on
+   Volume 2,  20-25 June 2005 Page(s):60 - 65 vol. 2
+**/
+CImg<T> get_nlmeans( int patch_size=1,  double lambda=-1, double alpha=3 ,double sigma=-1, int sampling=1) const  {
+  return CImg<T>(*this).nlmeans(patch_size,lambda,alpha,sigma,sampling);
+}
+
+#endif /* cimg_plugin_nlmeans */