Jerome Piovano

Research in Medical Imaging and Computer Vision

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

2D_Gaussian.C

Gaussian Region Segmentation of a 2D Image

#include <Segmentation.h>
#include <SegmentationModule/RegularizationModule.h>
#include <SegmentationModule/GaussianRegionModule.h>
#include <SegmentationModule/BalloonModule.h>

int main(int argc, char* argv[])
{       
        using namespace Images;
        using namespace levelset;
        using namespace segmentation;

#if 1 // 2D

        // image to segment 

        BaseImage<2, float> image;
        std::ifstream f("image/head3.inr");
        f >> format("inrimage") >> image;
        Globals::normalize(image, 0.0f, 250.0f);

/*
        // binary circle
        const Dimension nx = 300; 
        const Dimension ny = 300;
        const Dimension dims[] = {nx, ny};
        Shape<2> shape(dims);
        BaseImage<2,float> image(shape);    // image of size nx*ny

        image = 0.0;

        int radius = 100;
        int cx = 150;
        int cy = 150;

        for (BaseImage<2, float>::iterator<domain> ind=image.begin() ; ind!=image.end() ; ++ind){
                if(sqrt( (double) Maths::sqr(ind(1) - cx) +  Maths::sqr( ind(2) - cy)) < radius)
                        image(ind) = 0;
                else image(ind) =  255 ;
        }
*/

        // initialization of the segmentations objects
        FastMarchingInitializer<2,float> init;                               // Fast Marching Initializer
        LevelSet<2,float>                phi(image.shape(), (double) 20.0);  // Level Set of band thickness = 2
        Segmentation<2,float>            segm(&phi, &init, &image);          // Segmentation

        // initalization of the level set
        BaseImage<2,float> im_init;
        std::ifstream f1("multi_variance/head3/var/phi_000498.inr");
        f1 >> format("inrimage") >> im_init;
        phi.init_image(im_init, init, true);
        // phi.init_small_spheres(10, 25, init);    // parameters : radius, windows

        // initialization of the modules
        RegularizationModule<2,float>        regul(1.f);           // parameters : weight
        GaussianRegionModule<2,float,float>  gauss(&image, 1.f);   // parameters : image, weight

        //note : the variance is useful for the normalization of the gaussian module (speed bounded between -1 and 1)
        //       if no variance, one has to reduce the weight of the gaussian module.
        gauss.use_variance(true);
        gauss.set_data_term(image);

        segm.add_module(regul);
        segm.add_module(gauss); 
 
        // launch the segmentation
        Segmentation<2,float>::RGBPixel neg(215,152,0); 
        Segmentation<2,float>::RGBPixel pos(255,252,0); 

        timeval _time;
        Globals::initChrono(_time);

        std::ostringstream name;
        name.str("");  
        name << "mkdir CVPR/";
        system (name.str().c_str()); 
        name.str("");  
        name << "mkdir CVPR/gaussian_cortex";
        system (name.str().c_str());
        name.str("");  
        name << "CVPR/gaussian_cortex/multivar";

        segm.segment(1000, name.str().c_str(), neg, pos);

        Globals::printChrono("\n        => Gaussian : ", _time);
        Globals::initChrono(_time); 

        std::cout << "OK" << std::endl;

        return 0;

#endif

#if 0 //3D

        // image to segment
        BaseImage<3, unsigned char> image;
        std::ifstream f("image/brain.inr");
        f >> format("inrimage") >> image;

        std::cout << image.shape() << std::endl;

        // initialization of the segmentations objects
        FastMarchingInitializer<3,float> init;                               // Fast Marching Initializer
        LevelSet<3,float>                phi(image.shape(), (double) 2.0);   // Level Set 
        Segmentation<3,unsigned char>    segm(&phi, &init, &image);          // Segmentation object

        phi.init_small_spheres(10, 25, init);    // parameters : radius, windows

        RegularizationModule<3,float>                regul(0.75f);                     // parameters : weight
        GaussianRegionModule<3,float,unsigned char>  gaussian( &image, 0.75f, true);   // parameters : image, weight, smooth

        segm.add_module(regul);
        segm.add_module(gaussian);
 
        // launch the segmentation
        Segmentation<3,float>::RGBPixel neg(215,152,0);
        Segmentation<3,float>::RGBPixel pos(255,252,0);

        timeval _time;
        Globals::initChrono(_time); 

         segm.segment(1000, "result_3D/brain_gaussian/gaussian_", neg, pos); 

        Globals::printChrono("\n        => Gaussian : ", _time); 
        Globals::initChrono(_time); 

        std::cout << "OK" << std::endl;

        return 0;
#endif

}

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