histo.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_HISTO_HPP
#define SLIP_HISTO_HPP

#include <iterator>
#include <algorithm>
#include <numeric>
#include <cassert>
#include <cmath>
#include <iostream>

namespace slip
{

  template<typename InputIterator, typename RandomAccessIterator>
  inline
  void histogram(InputIterator first,
                                 InputIterator last,
                                 RandomAccessIterator histo_first,
                                 RandomAccessIterator histo_last,
                                 typename std::iterator_traits<InputIterator>::value_type minval,
                                 typename std::iterator_traits<InputIterator>::value_type maxval,
                                 typename std::iterator_traits<InputIterator>::value_type step = 1)              
  {
    typedef typename std::iterator_traits<InputIterator>::value_type T;
    typedef typename std::iterator_traits<RandomAccessIterator>::value_type histo_T;
    
    assert(first != last);
    assert(step > 0);
    assert((histo_last - histo_first) == (int)((maxval - minval + 1)/step));
    
    // Initialize result and check values
    std::fill(histo_first,histo_last,histo_T());
    int maxi = static_cast<int>((histo_last-histo_first) - 1);
    
    InputIterator first2 = first;
    bool error = false;
    for (; !error && first2 != last; ++first2)
      {
                if ( (*first2 < minval) || (*first2 > maxval) )
                  {
                    error = true;
                  }
      }
    if (error)
      {
                std::cerr << "Some values of the input datas are outside the defined interval: ["<<minval<<","<<maxval<<"]"<<std::endl;
      }
    // Store the histogram
    while(first != last)
      {
                int i = (int) trunc((*first - minval) / step);
                if ((i > maxi) || (i < 0)) 
                  {
                    if (*first == maxval)
                      {
                                (*(histo_first + maxi))++;
                      } 
                    // Else not take into account
                  } 
                else 
                  {
                    (*(histo_first + i))++;
                  }
                ++first;
      }
  }

  template<typename InputIterator, 
                   typename RandomAccessIterator, 
                   typename MaskIterator>
  inline
  void histogram_mask(InputIterator first,
                                      InputIterator last, 
                                      MaskIterator mask_first,
                                      RandomAccessIterator histo_first,
                                      RandomAccessIterator histo_last,
                                      typename std::iterator_traits<InputIterator>::value_type minval,
                                      typename std::iterator_traits<InputIterator>::value_type maxval,
                                      typename std::iterator_traits<InputIterator>::value_type step = 1,
                                      typename std::iterator_traits<MaskIterator>::value_type value=typename std::iterator_traits<MaskIterator>::value_type(1))  
  {
    assert(first != last);
    assert(step > 0);
    assert((histo_last - histo_first) == (int)((maxval - minval + 1)/step));

    typedef typename std::iterator_traits<InputIterator>::value_type T;
    typedef typename std::iterator_traits<RandomAccessIterator>::value_type histo_T;
    
    // Initialize result and check values
    std::fill(histo_first,histo_last,histo_T());
    int maxi = static_cast<int>((histo_last-histo_first) - 1);

    InputIterator first2 = first;
    MaskIterator  mask_first2 = mask_first;
    bool error = false;
    for (; !error && first2 != last; ++first2, ++mask_first2)
      {
                if(*mask_first2 == value)
                  {
                    if ( (*first2 < minval) || (*first2 > maxval) )
                      {
                                error = true;
                      }
                  }
      }
    if (error)
      {
                std::cerr << "Some values of the input datas are outside the defined interval: ["<<minval<<","<<maxval<<"]"<<std::endl;
      }
    // Store the histogram
    
    while(first != last)
      {
                if(*mask_first==value)
                  {  
                    int i = (int) trunc((*first - minval) / step);
                    
                    if ((i > maxi) || (i < 0)) 
                      {
                                if (*first == maxval)
                                  {
                                    (*(histo_first + maxi))++;
                                    
                                  } 
                                // Else not take into account
                      } 
                    else 
                      {
                (*(histo_first + i))++;
                      }
                  }
                ++first;
                ++mask_first;
      }
       
  }



  template<typename InputIterator, 
                   typename RandomAccessIterator, 
                   typename Predicate>
  inline
  void histogram_if(InputIterator first,
                                    InputIterator last,
                                    RandomAccessIterator histo_first,
                                    RandomAccessIterator histo_last,
                                    Predicate pred,
                                    typename std::iterator_traits<InputIterator>::value_type minval,
                                    typename std::iterator_traits<InputIterator>::value_type maxval,
                                    typename std::iterator_traits<InputIterator>::value_type step = 1
                                    )
  {
    assert(first != last);
    assert(step > 0);
    assert((histo_last - histo_first) == (int)((maxval - minval + 1)/step));
    typedef typename std::iterator_traits<InputIterator>::value_type T;
    typedef typename std::iterator_traits<RandomAccessIterator>::value_type histo_T;
    
   
   

    // Initialize result and check values
    std::fill(histo_first,histo_last,histo_T());
    int maxi = static_cast<int>((histo_last-histo_first) - 1);
   
    InputIterator first2 = first;
    bool error = false;
    for (; !error && first2 != last; ++first2)
      {
                if(pred(*first2))
                  {
                    if ( (*first2 < minval) || (*first2 > maxval) )
                      {
                                error = true;
                      }
                  }
      }
    if (error)
      {
                std::cerr << "Some values of the input datas are outside the defined interval: ["<<minval<<","<<maxval<<"]"<<std::endl;
      }
    // Store the histogram
    while(first != last)
      {
                if(pred(*first))
           {  
                     int i = (int) trunc((*first - minval) / step);

                    if ((i > maxi) || (i < 0)) 
                      {
                                if (*first == maxval)
                                  {
                                    (*(histo_first + maxi))++;

                                  } 
                                // Else not take into account
                      } 
                    else 
                      {
                (*(histo_first + i))++;
                                
              }
            }
                    ++first;

                  }
  }

  template<typename InputIterator, typename InputIterator2, typename OutputIterator>
  inline
  void real_histogram(InputIterator first,
                                      InputIterator last,
                                      InputIterator2 stepfirst,
                                      InputIterator2 steplast,
                                      OutputIterator result)     
  {
    assert(first != last);
    assert(stepfirst != steplast);

    InputIterator2 runsteps;
    InputIterator first2 = first;
    bool error = false;
    bool end = false;
    int i = 0;
    // Initialize result and check values
                
    for (runsteps=stepfirst+1,i=0;runsteps!=steplast;i++,runsteps++)
      {
        *(result + i) = 0;
      }

    for (; !error && (first2 != last); ++first2){
        if ( (*first2 < *stepfirst) || (*first2 > *(steplast-1)))
                  {
            error=true;
                  }
    }
    if (error)
      {
        std::cerr << "Some values of the input datas are outside the defined interval: ["<<*stepfirst<<","<<*(steplast-1)<<"]"<<std::endl;
      }


     // Store the histogram
                while(first != last)
                  {
                    i = -1;
                    end = false;
                    
                    for (runsteps=stepfirst;!end && runsteps != steplast; runsteps++)
                      {
                                if (*first >= *runsteps)
                                  {
                                    i++;
                                  } 
                                else 
                                  {
                                    end = true;
                                  }
                      }
                    // Over value : do not take into account
                    if (!end && (*first >= *(steplast-1)))
                      {
                                // High Bound case 
                                if (*first == *(steplast-1))
                                  {
                                    i--;
                                  } 
                                else 
                                  {
                                    i = -1;
                                  }
                      } 

                    
                    if (i >= 0)
                      {
                                (*(result+i))++;
                      }
                    ++first;
                  }
  }
 


template<typename RandomAccessIterator1, typename RandomAccessIterator2>
  inline
  void cumulative_histogram(RandomAccessIterator1 histo_first,
                            RandomAccessIterator1 histo_last,
                                                    RandomAccessIterator2 cum_histo_first,
                            RandomAccessIterator2 cum_histo_last)                
  {

     assert(histo_last != histo_first);
     assert((histo_last - histo_first) == (cum_histo_last - cum_histo_first));

     typedef typename std::iterator_traits<RandomAccessIterator2>::value_type value_type;
     //std::copy(histo_first,histo_last,cum_histo_first);
     *cum_histo_first++ = *histo_first++;
     for(; histo_first != histo_last; ++histo_first, ++cum_histo_first)
       {
                 *cum_histo_first = *(cum_histo_first-1) + *histo_first;
       }
  }

}//slip::


#endif //SLIP_HISTO_HPP