Jerome Piovano

Research in Medical Imaging and Computer Vision

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

2D_MinimalPath.C

Minimal path between 2 points in an image + back tracking

#include <Image.H>
#include <FastMarching.h>
#include <DericheFilter.h>
#include <Globals.h>
#include <Schemes.h>

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

        Image2D<float>      image;                      // Image to segment
        //std::ifstream f("image/tiger.inr");
        std::ifstream f("image/imageTest.inr");
        f >> format("inrimage") >> image;
        
        Image2D<float>      metric(image.shape());      // Metric of the image
        Image2D<float>      data(image.shape());        // Data structure of the fast marching
        Eikonal<2, float>   march(&data);               // Fast Marching
        Image2D<float>      backtrack = image.copy();   // Result of the minimal path

        #ifdef PRINT_TIME
        timeval _time;
        Globals::initChrono(_time);
        #endif

        // Initialization of the metric 
        //------------------------------

        std::cout << " Metric Computation ... " << std::endl;

        DericheFilter<2, float>  deriche(2.0f);
        deriche.filter(image);

        // metric = 1/1+|grad(I)|
        for (Image2D<float>::iterator<domain> ind=metric.begin() ; ind!=metric.end() ; ++ind )
                metric(ind) = 1/(1+Schemes<2, float>::norm_gradient(image, ind.position()));

        Globals::normalize<2,float>(metric, 0.1, 1);

        std::ofstream f1("metric.inr"); 
        f1 << format("inrimage") << metric;
        f1.close();

        #ifdef PRINT_TIME
        Globals::printChrono("  => metric computation : ", _time);
        Globals::initChrono(_time);
        #endif

        // Fast Marching
        //---------------

        std::cout << " Fast-Marching ... " << std::endl;

        march.set_metric(&metric);

        // seed (first point)
        Image2D<float>::Index ind1(933, 15);
        march.add_trial_point(ind1);

        march.run();

        std::ofstream f2("fastmarching.inr"); 
        f2 << format("inrimage") << data;
        f2.close();

        #ifdef PRINT_TIME
        Globals::printChrono("  => Fast Marching : ", _time);
        Globals::initChrono(_time);
        #endif
        
        // Back Tracking
        //----------------
        
        data += metric;

        std::cout << " BackTracking ... " << std::endl;

        // second point 
        Image2D<float>::Index ind2(520, 1040);
        Image2D<float>::Index min;

        int inf_coords[2];
        int sup_coords[2];
        while (ind2 != ind1){
                backtrack(ind2) = 255;

                Schemes<2,float>::find_neighbours(data, ind2, inf_coords, sup_coords);

                min = ind2;
                for (int i=0 ; i<2 ; i++){
                        Image2D<float>::Index inf = ind2;
                        Image2D<float>::Index sup = ind2;
                        inf(i+1) = inf_coords[i];
                        sup(i+1) = sup_coords[i];

                        if (data(inf)<data(min)) min = inf;
                        if (data(sup)<data(min)) min = sup;
                }
                ind2 = min;
        }

        std::ofstream f3("backtrack.inr"); 
        f3 << format("inrimage") << backtrack;
        f3.close();

        #ifdef PRINT_TIME
        Globals::printChrono("  => BackTracking : ", _time);
        Globals::initChrono(_time);
        #endif
}

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