noise.hpp

Go to the documentation of this file.

/*
 * Copyright(c):
 * Signal Image and Communications (SIC) Department 
 * http://www.sic.sp2mi.univ-poitiers.fr/ 
 *  - University of Poitiers, France http://www.univ-poitiers.fr 
 *  - XLIM  Institute UMR CNRS 7252  http://www.xlim.fr/ 
 * 
 * and 
 * 
 * D2 Fluid, Thermic and Combustion 
 *  - University of Poitiers, France http://www.univ-poitiers.fr 
 *  - PPRIME Institute -  UPR CNRS 3346  http://www.pprime.fr
 *  - ISAE-ENSMA http://www.ensma.fr
 *
 * Contributor(s):
 * The SLIP team,
 * Benoit Tremblais <tremblais_AT_sic.univ-poitiers.fr>,
 * Laurent David <laurent.david_AT_lea.univ-poitiers.fr>, 
 * Ludovic Chatellier <ludovic.chatellier_AT_univ-poitiers.fr>, 
 * Lionel Thomas <lionel.thomas_AT_univ-poitiers.fr>, 
 * Denis Arrivault <arrivault_AT_sic.univ-poitiers.fr>, 
 * Julien Dombre <julien.dombre_AT_univ-poitiers.fr>.
 *
 * Description:
 * The Simple Library of Image Processing (SLIP) is a new image processing 
 * library. It is written in the C++ language following as much as possible 
 * the ISO/ANSI C++ standard. It is consequently compatible with any system  
 * satisfying the ANSI C++ complience. It works on different Unix , Linux ,  
 * Mircrosoft Windows and Mac OS X plateforms. SLIP is a research library that  
 * was created by the Signal, Image and Communications (SIC) departement of  
 * the XLIM, UMR 7252 CNRS Institute in collaboration with the Fluids, Thermic  
 * and Combustion departement of the P', UPR 3346 CNRS Institute of the  
 * University of Poitiers.
 * 
 * The SLIP Library source code has been registered to the APP (French Agency 
 * for the Protection of Programs) by the University of Poitiers and CNRS, 
 * under  registration number IDDN.FR.001.300034.000.S.P.2010.000.21000.

 * http://www.sic.sp2mi.univ-poitiers.fr/slip/
 *
 * This software is governed by the CeCILL-C 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-C 
 * 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-C license and that you accept its terms.
 */



#ifndef SLIP_NOISE_HPP
#define SLIP_NOISE_HPP


#include <ctime>
#include <boost/random.hpp>

namespace slip
{

  /* @{ */
  template<typename InputIterator, typename OutputIterator, typename Real>
  inline
  void add_gaussian_noise(InputIterator first, 
                                                  InputIterator last, 
                                                  OutputIterator result, 
                                                  const Real mean = Real(0.0), const Real var = Real(0.01))
  {
    assert(first != last);
                boost::mt19937 generator(static_cast<unsigned int>(std::time(0)));
                boost::normal_distribution<> distrib(mean,var);
                boost::variate_generator<boost::mt19937&, boost::normal_distribution<> > deg(generator, distrib);               
                for (;first!=last;++first,++result)
                  {
                    *result = *first + deg();
                  }
  }
 template<typename InputIterator, typename OutputIterator, typename Real,typename MaskIterator>
  inline
  void add_gaussian_noise_mask(InputIterator first, 
                                                       InputIterator last, 
                                                       MaskIterator mask_first,
                                                       OutputIterator result,
                                                       const Real mean = Real(0.0), const Real var = Real(0.01), typename std::iterator_traits<MaskIterator>::value_type value=typename                          std::iterator_traits<MaskIterator>::value_type(1))
  {
        assert(first != last);
                boost::mt19937 generator(static_cast<unsigned int>(std::time(0)));
                boost::normal_distribution<> distrib(mean,var);
                boost::variate_generator<boost::mt19937&, boost::normal_distribution<> > deg(generator, distrib);               
                 for (;first!=last;++first,++result,++mask_first)
             {

                 if(*mask_first == value)
                         {
                    *result = *first + deg();
                 }
                                 else
                                   {
                                     *result = *first;
                                   }
                  }
  }

 template<typename InputIterator, typename OutputIterator, typename Real,typename Predicate>
  inline
  void add_gaussian_noise_if(InputIterator first, 
                                                  InputIterator last, 
                                                  OutputIterator result,
                          Predicate pred,
                                                  const Real mean = Real(0.0), const Real var = Real(0.01))
  {
        assert(first != last);
                boost::mt19937 generator(static_cast<unsigned int>(std::time(0)));
                boost::normal_distribution<> distrib(mean,var);
                boost::variate_generator<boost::mt19937&, boost::normal_distribution<> > deg(generator, distrib);               
                 for (;first!=last;++first,++result)
             {

                 if(pred(*first))
                         {
                    *result = *first + deg();
                 }
                                 else
                                   {
                                     *result = *first;
                                   }
                  }
  }

 /* @} */

  /* @{ */
  template<typename InputIterator, typename OutputIterator, typename Real>
  inline
  void add_speckle_noise(InputIterator first, 
                                                 InputIterator last, 
                                                 OutputIterator result, 
                                                 const Real var = 0.04)
  {
    assert(first != last);
    assert (var <= Real(1));
    assert (var >= Real(0));
    boost::mt19937 generator(static_cast<unsigned int>(std::time(0)));
    boost::normal_distribution<> distrib(-1.0,1.0);
    boost::variate_generator<boost::mt19937&, boost::normal_distribution<> > deg(generator, distrib);           
    Real sqrt_value=std::sqrt(var);
    for (;first!=last;++first,++result)
      {
                *result = *first * (1 + deg() * sqrt_value);
      }
  }
template<typename InputIterator, typename OutputIterator, typename Real,typename MaskIterator>
  inline
  void add_speckle_noise_mask(InputIterator first, 
                                                      InputIterator last, 
                                                      MaskIterator mask_first,
                                                      OutputIterator result,
                                                      const Real var = 0.04, 
                                                      typename std::iterator_traits<MaskIterator>::value_type value=typename                          std::iterator_traits<MaskIterator>::value_type(1))
{
    assert(first != last);
    assert (var <= Real(1));
    assert (var >= Real(0));
    boost::mt19937 generator(static_cast<unsigned int>(std::time(0)));
    boost::normal_distribution<> distrib(-1.0,1.0);
    boost::variate_generator<boost::mt19937&, boost::normal_distribution<> > deg(generator, distrib);           
    Real sqrt_value=std::sqrt(var);
    for (;first!=last;++first,++result,++mask_first)
      {
        if(*mask_first == value)
                {
          *result = *first * (1 + deg() * sqrt_value);
        }
                else
                  {
                    *result = *first;
                  }
     }
}

template<typename InputIterator, typename OutputIterator, typename Real, typename Predicate>
  inline
  void add_speckle_noise_if(InputIterator first, 
                                                  InputIterator last, 
                                                  OutputIterator result,
                          Predicate pred,
                                                  const Real var = 0.04)
{
    assert(first != last);
    assert (var <= Real(1));
    assert (var >= Real(0));
    boost::mt19937 generator(static_cast<unsigned int>(std::time(0)));
    boost::normal_distribution<> distrib(-1.0,1.0);
    boost::variate_generator<boost::mt19937&, boost::normal_distribution<> > deg(generator, distrib);           
    Real sqrt_value=std::sqrt(var);
    for (;first!=last;++first,++result)
      {
        if(pred(*first))
                {
          *result = *first * (1 + deg() * sqrt_value);
        }
                else
                  { 
                    *result = *first;
                  }
     }
}

  /* @} */

  /* @{ */
  template<typename InputIterator, typename OutputIterator, typename Real>
  inline
  void add_uniform_noise(InputIterator first, 
                                                 InputIterator last, 
                                                 OutputIterator result, 
                                                 const Real min = Real(0.0), 
                                                 const Real max = Real(1.0))
  {
    assert(first != last);
    boost::mt19937 generator(static_cast<unsigned int>(std::time(0)));
    boost::uniform_real<> distrib(min,max);
    boost::variate_generator<boost::mt19937&, boost::uniform_real<> > deg(generator, distrib);  
    for (;first!=last;++first,++result)
      {
                *result = *first + deg();
      }
  }
template<typename InputIterator, typename OutputIterator, typename Real,typename MaskIterator>
  inline
  void add_uniform_noise_mask(InputIterator first, 
                                                      InputIterator last, 
                                                      MaskIterator mask_first,
                                                      OutputIterator result,
                                                      const Real min = Real(0.0), 
                                                      const Real max = Real(1.0),
                              typename std::iterator_traits<MaskIterator>::value_type value=typename                          std::iterator_traits<MaskIterator>::value_type(1))
{
    assert(first != last);
    boost::mt19937 generator(static_cast<unsigned int>(std::time(0)));
    boost::uniform_real<> distrib(min,max);
    boost::variate_generator<boost::mt19937&, boost::uniform_real<> > deg(generator, distrib);  
    for (;first!=last;++first,++result,++mask_first)
      {
       if(*mask_first == value)
                {
          *result = *first + deg();
        }
       else
                 {
                   *result = *first;
                 }
      }
}
template<typename InputIterator, typename OutputIterator, typename Real,typename Predicate>
  inline
  void add_uniform_noise_if(InputIterator first, 
                                                      InputIterator last, 
                                                      OutputIterator result,
                              Predicate pred,
                                                      const Real min = Real(0.0), 
                                                      const Real max = Real(1.0))
{
    assert(first != last);
    boost::mt19937 generator(static_cast<unsigned int>(std::time(0)));
    boost::uniform_real<> distrib(min,max);
    boost::variate_generator<boost::mt19937&, boost::uniform_real<> > deg(generator, distrib);  
    for (;first!=last;++first,++result)
      {
       if(pred(*first))
                {
          *result = *first + deg();
        }
       else
                 {
                   *result = *first;
                 }
      }
}
  /* @} */

  /* @{ */
template<typename InputIterator, typename OutputIterator, typename Real> 
  inline
  void add_salt_and_pepper_noise(InputIterator first, 
                                                                 InputIterator last, 
                                                                 OutputIterator result, 
                                                                 const Real density = Real(0.05), 
                                                                 const typename std::iterator_traits<OutputIterator>::value_type salt_value = typename std::iterator_traits<OutputIterator>::value_type(1.0), 
                                                                 const typename std::iterator_traits<OutputIterator>::value_type pepper_value = typename std::iterator_traits<OutputIterator>::value_type(0.0))
  {
                assert (density <= Real(1));
                assert (density >= Real(0));

                boost::mt19937 generator(static_cast<unsigned int>(std::time(0)));
                boost::uniform_real<> distrib(0.0,1.0);
                boost::variate_generator<boost::mt19937&, boost::uniform_real<> > deg(generator, distrib);      
                for (;first!=last;++first,++result)
                  {
                    Real rand = deg();
                    // salt or pepper
                    if (rand < density)
                      {
                                // Salt case
                                if ((2 * rand) < density)
                                  {
                                    *result = salt_value;
                                  } 
                                else 
                                  {
                                    // Pepper case
                                    *result = pepper_value;
                                  }
                      } 
                    else 
                      {
                                *result = *first;
                      }
                  }
  }

template<typename InputIterator, typename OutputIterator, typename Real,typename MaskIterator >
  inline
  void add_salt_and_pepper_noise_mask(InputIterator first, 
                                                                      InputIterator last, 
                                                                      MaskIterator mask_first,
                                                                      OutputIterator result, 
                                                                      const Real density = Real(0.05), 
                                                                      const Real salt_value = Real(1.0), 
                                                                      const Real pepper_value = Real(0.0),
                                                                      typename std::iterator_traits<MaskIterator>::value_type value=typename                          std::iterator_traits<MaskIterator>::value_type(1))
  {
                assert (density <= Real(1));
                assert (density >= Real(0));

                boost::mt19937 generator(static_cast<unsigned int>(std::time(0)));
                boost::uniform_real<> distrib(0.0,1.0);
                boost::variate_generator<boost::mt19937&, boost::uniform_real<> > deg(generator, distrib);      
                for (;first!=last;++first,++result,++mask_first)
                  {
                   if(*mask_first==value)
            {
             Real rand = deg();
                    // salt or pepper
                    if (rand < density)
                      {
                                // Salt case
                                if ((2 * rand) < density)
                                  {
                                    *result = salt_value;
                                  } 
                                else 
                                  {
                                    // Pepper case
                                    *result = pepper_value;
                                  }
                      } 
                    else 
                      {
                                *result = *first;
                      }
                    }
                   else
                     {
                       *result = *first;
                     }
       } 
  }

template<typename InputIterator, typename OutputIterator, typename Real,typename Predicate >
  inline
  void add_salt_and_pepper_noise_if(InputIterator first, 
                                                                    InputIterator last, 
                                                                    OutputIterator result, 
                                    Predicate pred,
                                                                 const Real density = Real(0.05), 
                                                                 const Real salt_value = Real(1.0), 
                                                                 const Real pepper_value = Real(0.0))
  {
                assert (density <= Real(1));
                assert (density >= Real(0));

                boost::mt19937 generator(static_cast<unsigned int>(std::time(0)));
                boost::uniform_real<> distrib(0.0,1.0);
                boost::variate_generator<boost::mt19937&, boost::uniform_real<> > deg(generator, distrib);      
                for (;first!=last;++first,++result)
                  {
                   if(pred(*first))
            {
             Real rand = deg();
                    // salt or pepper
                    if (rand < density)
                      {
                                // Salt case
                                if ((2 * rand) < density)
                                  {
                                    *result = salt_value;
                                  } 
                                else 
                                  {
                                    // Pepper case
                                    *result = pepper_value;
                                  }
                      } 
                    else 
                      {
                                *result = *first;
                      }
                  }
                   else
                     {
                       *result = *first;
                     }
       } 
  }
/* @} */
}//slip::



#endif //SLIP_NOISE_HPP