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/RegionModule.h

Go to the documentation of this file.

#ifndef REGIONMODULE_H
#define REGIONMODULE_H

#include <SegmentationModule/SegmentationModule.h>
#include <SegmentationModule/Histogram.h>

namespace segmentation {


        template <unsigned DIM, typename Pixel = float, typename PixelImage = float> 
        class RegionModule : public SegmentationModule<DIM, Pixel>
        {
        public: 

                typedef          SegmentationModule<DIM, Pixel>  base;
                typedef typename base::LevelSet                  LevelSet;
                typedef typename base::Index                     Index;
                typedef typename base::Schemes                   Scheme;
                typedef          Histogram<PixelImage>           Histogram;
                typedef          BaseImage<DIM, PixelImage>      ImageType;


                RegionModule(ImageType *  _data,              
                             float        _weight = 1.f,      
                             bool         _adaptive = true    
                             );

                virtual ~RegionModule();



                void set_data_term(ImageType & _data);

                Histogram * hist_pos();
                Histogram * hist_neg();



                virtual float value(const LevelSet & phi, const Index & ind){ return 0.0f; }
                virtual float energy(const LevelSet & phi, const Index & ind){ return 0.0f; }
                virtual void init(const LevelSet & phi);
                virtual void update(const LevelSet & phi){ }
                virtual void save_result(const LevelSet & phi, std::string evodir, int iter){ }

                void init_histograms(const LevelSet & phi);
                void update_histograms(const LevelSet & phi);
                void save_histograms(std::string evodir, int iter);



        protected:      

                ImageType * m_data;       
                Histogram * m_hist_pos;   
                Histogram * m_hist_neg;   


        };


        // Constructors - Destructor


        template <unsigned DIM, typename Pixel, typename PixelImage>
                RegionModule<DIM, Pixel, PixelImage>::RegionModule(ImageType * _data, float _weight, bool _adaptive)
                :SegmentationModule<DIM, Pixel>(_weight, _adaptive), m_data(_data), m_hist_pos(NULL), m_hist_neg(NULL)
        { }

        template <unsigned DIM, typename Pixel, typename PixelImage>
                RegionModule<DIM, Pixel, PixelImage>::~RegionModule() 
        {
                if (m_hist_pos != NULL){
                        delete m_hist_pos;
                        delete m_hist_neg;
                }
        }


        //  Member functions


        template <unsigned DIM, typename Pixel, typename PixelImage>
                void RegionModule<DIM, Pixel, PixelImage>::set_data_term(ImageType & _data)
        {
                m_data = &_data;
        }

        template <unsigned DIM, typename Pixel, typename PixelImage>
                typename RegionModule<DIM, Pixel, PixelImage>::Histogram* RegionModule<DIM, Pixel, PixelImage>::hist_pos()
        {
                return m_hist_pos;
        }

        template <unsigned DIM, typename Pixel, typename PixelImage>
                typename RegionModule<DIM, Pixel, PixelImage>::Histogram* RegionModule<DIM, Pixel, PixelImage>::hist_neg()
        {
                return m_hist_neg;
        }


        // Update of the module  


        template <unsigned DIM, typename Pixel, typename PixelImage>
                void RegionModule<DIM, Pixel, PixelImage>::init(const LevelSet & phi)
        {
                base::init(phi);

                if (m_data->shape() != phi.shape()) {
                        std::cerr << "Error : Shape of the data term and shape of the LevelSet don't match"  << std::endl;
                        exit(1);
                }
        }

        template <unsigned DIM, typename Pixel, typename PixelImage>
                void RegionModule<DIM, Pixel, PixelImage>::init_histograms(const LevelSet & phi)
        {
                if (m_hist_pos == NULL){

                        PixelImage min;
                        PixelImage max;
                        float mean;
                        
                        Globals::stats<DIM,PixelImage>(*m_data, min, max, mean);

                        m_hist_pos = new Histogram(min, max, true);
                        m_hist_neg = new Histogram(min, max, true);
                }

                //computation of the first histograms

                m_hist_pos->clear();
                m_hist_neg->clear();

                for (typename ImageType::template iterator<domain> ind=m_data->begin() ; ind!=m_data->end() ; ++ind ){
                        const Pixel      _phi = phi(ind);
                        const PixelImage _val = (*m_data)(ind);

                        if (_phi>=0) m_hist_pos->add_pixel(_val);
                        else         m_hist_neg->add_pixel(_val);
                }
        }

        template <unsigned DIM, typename Pixel, typename PixelImage>
                void RegionModule<DIM, Pixel, PixelImage>::update_histograms(const LevelSet & phi) 
        {       
                if (m_hist_pos == NULL){
                        std::cerr << "Error : Histograms not initialized"  << std::endl;
                        exit(1);
                }

                //computation of the histograms using previous ones

                if (!m_hist_pos->adaptative() && !m_hist_neg->adaptative()) return;

                for (unsigned int i = 0 ; i < phi.pos_to_neg_index() ; i++){
                        const Index& ind = phi.get_point(i);    
                        const PixelImage _val = (*m_data)(ind);

                        m_hist_neg->add_pixel(_val);
                        m_hist_pos->remove_pixel(_val);
                }

                for (unsigned int i = phi.neg_to_pos_index() ; i < phi.nb_points() ; i++){
                        const Index& ind = phi.get_point(i);
                        const PixelImage _val = (*m_data)(ind);

                        m_hist_neg->remove_pixel(_val);
                        m_hist_pos->add_pixel(_val);
                }
        }

        template <unsigned DIM, typename Pixel, typename PixelImage>
                void RegionModule<DIM, Pixel, PixelImage>::save_histograms(std::string evodir, int iter) 
        {
                if (m_hist_pos == NULL){
                        std::cerr << "Error : Histograms not initialized"  << std::endl;
                        exit(1);
                }

                std::ostringstream name;
                std::ofstream file;

                name.str("");
                name << evodir << "Hist_pos_" << std::setw(6) << std::setfill('0') << iter << ".txt";
                file.open(name.str().c_str());
                for(PixelImage i=m_hist_pos->min(); i < m_hist_pos->max() ; i++) 
                        file << i << " " << (*m_hist_pos)[i]  << std::endl;
                file.close();
                std::cout <<  " - Saved " << name.str() << " ..."  << std::endl;

                name.str("");
                name << evodir << "Hist_neg_" << std::setw(6) << std::setfill('0') << iter << ".txt";
                file.open(name.str().c_str());
                for(PixelImage i=m_hist_pos->min(); i < m_hist_pos->max() ; i++) 
                        file << i << " " << (*m_hist_neg)[i] << std::endl;
                file.close();
                std::cout <<  " - Saved " << name.str() << " ..."  << std::endl;
        }
}

#endif // REGIONMODULE_H

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