Jerome Piovano

Research in Medical Imaging and Computer Vision

• Home
• Research
• Publications
• Teaching
• Biography
• Shared code and data

/home/jpiovano/src/Odyssee++/trunk/Libs/LevelSet/src/SegmentationModule/SparseHistogram.h

+
#ifndef HISTOGRAM_H
#define HISTOGRAM_H

namespace segmentation {

        template <unsigned DIM, typename ElementType = float>
        class Histogram
        {
        public:

                typedef          BaseImage<DIM, int>               base;
                typedef typename base::Shape                       Shape;
                typedef typename base::Index                       Index;

                typedef          Index<DIM,ElementType>            Element;


                Histogram();

                Histogram(const Element &  _br,               
                          const Element &  _tl,               
                          bool             _adaptive = true,  
                          const Element &  _quant_step=1      
                          );

                template <typename ElementType2>
                Histogram(const Histogram<DIM, ElementType2>& hist):base(hist), m_adaptive(hist.m_adaptive), m_nb_elt(0), m_quant_step(hist.m_quant_step)
                {
                        for (typename base::template iterator<domain> i=this->begin() ; i!=this->end() ; ++i )
                                m_nb_elt += base::operator()(i)
                }

                using base::operator=;

                void resize(const Shape & s);



                Element & quantification_step();
                bool& adaptative();
                int  nb_elements();
                void add_element(const Element &  _elt);
                void remove_element(const Element & _elt);
                void clear();



                void compute_statistics(float& mean, float& var, bool compute_variance=false);



                bool      m_adaptive;      
                int       m_nb_elt;        
                Element   m_quant_step;    
        };


        // Constructors - Destructor


        template <unsigned DIM, typename ElementType>
                Histogram<DIM, ElementType>::Histogram()
        : base(), m_adaptive(true), m_nb_elt(0), m_quant_step(1)
        { }

        template <unsigned DIM, typename ElementType>
                Histogram<DIM, ElementType>::Histogram(const Shape &  _shape, bool _adaptive )
        : base(_shape), m_adaptive(_adaptive), m_nb_elt(0), m_quant_step(1)
        {
                base::operator=(0);
        }

        template<unsigned DIM, typename ElementType>
                void Histogram<DIM, ElementType>::resize(const Shape& s)
        {
                base::resize(s);
                m_mask.resize(s);
                base::operator=(0);
                m_nb_elt = 0;
        }


        //Modify the Histogram


        template <unsigned DIM, typename ElementType>
                Element & Histogram<DIM, ElementType>::quantification_step()
        {
                return m_quant_step;
        }

         template <unsigned DIM, typename ElementType>
                bool& Histogram<DIM, ElementType>::adaptative()
        {
                 return m_adaptive;
        }
        
        template <unsigned DIM, typename ElementType>
                void Histogram<DIM, ElementType>::clear()
        {
                if  (m_adaptive){
                        m_nb_elt = 0;
                        base::operator=(0);
                }
        }

        template <unsigned DIM, typename ElementType>
                int Histogram<DIM, ElementType>::nb_elements()
        {
                return m_nb_elt;
        }
        
        template <unsigned DIM, typename ElementType>
                void Histogram<DIM, ElementType>::add_element(const Element & _elt)
        {
                if (m_adaptive){

                        Index ind;
                        for (i=0; i<DIM; i++)
                                ind(i) = floor(_elt(i) / m_quant_step(i));

                        base::operator()(ind)++;
                        m_nb_elt++;
                }
        }

         template <unsigned DIM, typename ElementType>
                void Histogram<DIM, ElementType>::remove_element(const Element & _elt)
        {
                if (m_adaptive){

                        Index ind;
                        for (i=0; i<DIM; i++)
                                ind(i) = floor(_elt(i) / m_quant_step(i));
                
                        if (base::operator()(ind) > 0){
                                base::operator()(ind)--;
                                m_nb_elt--;
                        }
                }
        }

        template <unsigned DIM, typename ElementType>
                void Histogram<DIM, ElementType>::clear()
        {
                if  (m_adaptive){
                        m_nb_elt = 0;
                        base::operator=(0);
                }
        }


        //Statistics computation


        template <unsigned DIM, typename ElementType>
                void Histogram<DIM, ElementType>::compute_statistics(Element& mean, Element& var, bool compute_variance)
        {
                mean = 0;

                for (typename base::template iterator<domain> i=this->begin() ; i!=this->end() ; ++i )
                        mean += i.position() * base::operator()(i)

                mean /= static_cast<float>(m_nb_elt);

                if (compute_variance){
                        var = 0;
                        for (typename base::template iterator<domain> i=this->begin() ; i!=this->end() ; ++i )
                                  var += base::operator()(i)*Maths::sqr(i.position() - mean);
                        
                        var /= static_cast<float>(m_nb_elt);
                }
        }
}

#endif // HISTOGRAM_H

For further information, please contact Jerome Piovano - Last update 2008-02-08