testSegmentation.cpp

//LICENSE-END
#include <cstdio>
#include <cmath>
#include <fstream>
#include <vector>
#include <iostream>
#include <iterator>




#include "DGtal/base/Common.h"
#include "DGtal/base/Exceptions.h"

#include "DGtal/io/boards/Board2D.h"
#include "DGtal/io/Color.h"

#include "DGtal/base/Circulator.h"

#include "DGtal/geometry/curves/ArithmeticalDSS.h"
#include "DGtal/geometry/curves/FreemanChain.h"
#include "DGtal/geometry/curves/GreedySegmentation.h"
#include "DGtal/geometry/curves/SaturatedSegmentation.h"


#include "ConfigTest.h"


using namespace DGtal;
using namespace std;
using namespace LibBoard;

// Functions for testing class GreedySegmentation



template <typename Iterator, typename Board>
void draw(const Iterator& itb, const Iterator& ite, Board& aBoard)
{

  for (Iterator i(itb); i != ite; ++i) {
     
    typename Iterator::SegmentComputer segment(*i); 

    aBoard << SetMode(segment.className(), "BoundingBox" )
           << segment; // draw bounding box
  
  } 

}

template <typename Iterator, typename Board>
void drawCCP(const Iterator& itb, const Iterator& ite, Board& aBoard)
{

  typedef typename Iterator::SegmentComputer::ConstIterator PointIterator; 

  aBoard << SetMode( "ArithmeticalDSS", "BoundingBox" );
  string aStyleName = "ArithmeticalDSS/BoundingBox";

  for (Iterator i(itb); i != ite; ++i) {
     
    //choose pen color
    CustomPenColor* aPenColor;

    if ( !(i.intersectNext() && i.intersectPrevious()) ) {

      aPenColor = new CustomPenColor( Color::Black );

    } else {

      //end points

      PointIterator begin = i->begin();  --begin; 
      PointIterator end = i->end();

      //parameters
      int mu = i->getMu();
      int omega = i->getOmega();

      //configurations
      if ( (i->getRemainder(begin)<=mu-1)&&
           (i->getRemainder(end)<=mu-1) ) {                //concave
        aPenColor = new CustomPenColor( Color::Green);
      } else if ( (i->getRemainder(begin)>=mu+omega)&&
            (i->getRemainder(end)>=mu+omega) ) {           //convex
        aPenColor = new CustomPenColor( Color::Blue );
      } else if ( (i->getRemainder(begin)>=mu+omega)&&
            (i->getRemainder(end)<=mu-1) ) {               //convex to concave
        aPenColor = new CustomPenColor( Color::Yellow );
      } else if ( (i->getRemainder(begin)<=mu-1)&&
            (i->getRemainder(end)>=mu+omega) ) {           //concave to convex
        aPenColor = new CustomPenColor( Color::Yellow );
      } else {                                                    //pb
        aPenColor = new CustomPenColor( Color::Red );
      }

    }

    // draw each segment
    aBoard << CustomStyle( aStyleName, aPenColor )
           << *i; 
  
  } 

}

template <typename Iterator, typename Board>
void segmentationIntoDSSs(const Iterator& itb, const Iterator& ite, 
                          const Iterator& sitb, const Iterator& site,
                          const string& aMode, Board& aBoard)
{
  typedef typename IteratorCirculatorTraits<Iterator>::Value::Coordinate Coordinate; 
  typedef ArithmeticalDSS<Iterator,Coordinate,4> RecognitionAlgorithm;
  typedef GreedySegmentation<RecognitionAlgorithm> Segmentation;

  RecognitionAlgorithm algo;
  Segmentation s(itb,ite,algo);
  s.setSubRange(sitb,site);
  s.setMode(aMode);
  
  typename Segmentation::SegmentComputerIterator i = s.begin();
  typename Segmentation::SegmentComputerIterator end = s.end();

  draw<typename Segmentation::SegmentComputerIterator, Board>
  (i,end,aBoard); 

}

template <typename Iterator, typename Board>
void segmentationIntoMaximalDSSs(const Iterator& itb, const Iterator& ite, 
                                 const Iterator& sitb, const Iterator& site,
                                 const string& aMode, Board& aBoard)
{
  typedef typename IteratorCirculatorTraits<Iterator>::Value::Coordinate Coordinate; 
  typedef ArithmeticalDSS<Iterator,Coordinate,4> RecognitionAlgorithm;
  typedef SaturatedSegmentation<RecognitionAlgorithm> Segmentation;

  RecognitionAlgorithm algo;
  Segmentation s(itb,ite,algo);
  s.setSubRange(sitb,site);
  s.setMode(aMode);
  
  typename Segmentation::SegmentComputerIterator i = s.begin();
  typename Segmentation::SegmentComputerIterator end = s.end();

  drawCCP<typename Segmentation::SegmentComputerIterator, Board>
  (i,end,aBoard); 

}


bool greedySegmentationVisualTest()
{

  typedef int Coordinate;
  typedef FreemanChain<Coordinate> FC; 
  typedef FreemanChain<Coordinate>::ConstIterator ConstIterator; 



  std::string filename = testPath + "samples/manche.fc";

  std::fstream fst;
  fst.open (filename.c_str(), std::ios::in);
  FC fc(fst);

// open digital curve

  trace.beginBlock("Segmentation of a whole range (mode1)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc; 

  segmentationIntoDSSs<ConstIterator,Board2D>
    (fc.begin(),fc.end(),
     fc.begin(),fc.end(),
     "Truncate",aBoard);   

  aBoard.saveEPS("WholeOpenCurveWithItMode1.eps");
}
  trace.endBlock();


  trace.beginBlock("Segmentation of a whole range (mode3)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc; 

  segmentationIntoDSSs<ConstIterator,Board2D>
    (fc.begin(),fc.end(),
     fc.begin(),fc.end(),
     "DoNotTruncate",aBoard);   

  aBoard.saveEPS("WholeOpenCurveWithItMode3.eps");
}
  trace.endBlock();

  trace.beginBlock("Segmentation of a whole range (mode2)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc; 

  segmentationIntoDSSs<ConstIterator,Board2D>
    (fc.begin(),fc.end(),
     fc.begin(),fc.end(),
     "Truncate+1",aBoard);   

  aBoard.saveEPS("WholeOpenCurveWithItMode2.eps");
}
  trace.endBlock();


// subrange

  typedef vector<PointVector<2,Coordinate> > Curve;  
  typedef Curve::const_iterator RAConstIterator;  

  Curve vPts; 
  vPts.assign ( fc.begin(), fc.end() ); 

  RAConstIterator start = vPts.begin()+15;
  RAConstIterator stop = vPts.begin()+200;

trace.info() << *start << " " << *stop << endl;

  trace.beginBlock("Segmentation of a subrange (mode1)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc; 
  aBoard << SetMode("PointVector", "Paving") << *start << *stop; 

  segmentationIntoDSSs<RAConstIterator,Board2D>
    (vPts.begin(),vPts.end(),
     start,stop,
     "Truncate",aBoard);   

  aBoard.saveEPS("PartOpenCurveWithItMode1.eps");
}
  trace.endBlock();

  trace.beginBlock("Segmentation of a subrange (mode2)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc; 
  aBoard << SetMode("PointVector", "Paving") << *start << *stop; 

  segmentationIntoDSSs<RAConstIterator,Board2D>
    (vPts.begin(),vPts.end(),
     start,stop,
     "Truncate+1",aBoard);   

  aBoard.saveEPS("PartOpenCurveWithItMode2.eps");
}
  trace.endBlock();


  trace.beginBlock("Segmentation of a subrange (mode3)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc; 
  aBoard << SetMode("PointVector", "Paving") << *start << *stop; 

  segmentationIntoDSSs<RAConstIterator,Board2D>
    (vPts.begin(),vPts.end(),
     start,stop,
     "DoNotTruncate",aBoard);   

  aBoard.saveEPS("PartOpenCurveWithItMode3.eps");
}
  trace.endBlock();


// using circulators

  typedef Circulator<RAConstIterator> ConstCirculator;
  ConstCirculator c(vPts.begin(),vPts.begin(),vPts.end()); 

  trace.beginBlock("Segmentation of a whole range (mode1) with circulators");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc; 

  segmentationIntoDSSs<ConstCirculator,Board2D>
    (c,c,c,c,
     "Truncate",aBoard);   

  aBoard.saveEPS("WholeOpenCurveWithCircMode1.eps");
}
  trace.endBlock();

  trace.beginBlock("Segmentation of a whole range (mode2) with circulators");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc; 

  segmentationIntoDSSs<ConstCirculator,Board2D>
    (c,c,c,c,
     "Truncate+1",aBoard);   

  aBoard.saveEPS("WholeOpenCurveWithCircMode2.eps");
}
  trace.endBlock();


  trace.beginBlock("Segmentation of a whole range (mode3) with circulators");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc; 

  segmentationIntoDSSs<ConstCirculator,Board2D>
    (c,c,c,c,
     "DoNotTruncate",aBoard);   

  aBoard.saveEPS("WholeOpenCurveWithCircMode3.eps");
}
  trace.endBlock();

// subrange with circulators

  ConstCirculator cstart(start,vPts.begin(),vPts.end()); 
  ConstCirculator cstop(stop,vPts.begin(),vPts.end()); 

  trace.beginBlock("Segmentation of a subrange (mode1) with circulators");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc; 
  aBoard << SetMode("PointVector", "Paving") << *start << *stop; 

  segmentationIntoDSSs<ConstCirculator,Board2D>
    (c,c,
     cstart,cstop,
     "Truncate",aBoard);   

  aBoard.saveEPS("PartOpenCurveWithCircMode1.eps");
}
  trace.endBlock();

  trace.beginBlock("Segmentation of a subrange (mode2) with circulators");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc; 
  aBoard << SetMode("PointVector", "Paving") << *start << *stop; 

  segmentationIntoDSSs<ConstCirculator,Board2D>
    (c,c,
     cstart,cstop,
     "Truncate+1",aBoard);   

  aBoard.saveEPS("PartOpenCurveWithCircMode2.eps");
}
  trace.endBlock();


  trace.beginBlock("Segmentation of a subrange (mode3) with circulators");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc; 
  aBoard << SetMode("PointVector", "Paving") << *start << *stop; 

  segmentationIntoDSSs<ConstCirculator,Board2D>
    (c,c,
     cstart,cstop,
     "DoNotTruncate",aBoard);   

  aBoard.saveEPS("PartOpenCurveWithCircMode3.eps");
}
  trace.endBlock();

// closed digital curve 

  std::stringstream ss(stringstream::in | stringstream::out);
  ss << "31 16 1112121212121221212121221212212222232232323332333333332333332330333033003030000010001001001000100010101010111" << endl;
  
  // Construct the Freeman chain
  FC fc2(ss);

  Curve vPts2; 
  vPts2.assign( fc2.begin(), fc2.end() ); 
  vPts2.insert( vPts2.end(), fc2.begin(), fc2.end() );
  vPts2.insert( vPts2.end(), fc2.begin(), fc2.end() );

//copy ( vPts2.begin(), vPts2.end(), ostream_iterator<PointVector<2,Coordinate> >(cout,"\n") ) ;

  RAConstIterator start2 = vPts2.begin() + fc2.size()+1; 
  RAConstIterator stop2 = start2 + fc2.size()+1; 

trace.info() << *start2 << " " << *stop2 << endl;

  trace.beginBlock("Segmentation of a subrange of a duplicated range (mode1)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc2; 
  aBoard << SetMode("PointVector", "Paving") << *start2 << *stop2; 

  segmentationIntoDSSs<RAConstIterator,Board2D>
    (vPts2.begin(),vPts2.end(),
     start2,stop2,
     "Truncate",aBoard);   

  aBoard.saveEPS("DuplicatedCurveWithItMode1.eps");
}
  trace.endBlock();

  trace.beginBlock("Segmentation of a subrange of a duplicated range (mode2)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc2; 
  aBoard << SetMode("PointVector", "Paving") << *start2 << *stop2; 

  segmentationIntoDSSs<RAConstIterator,Board2D>
    (vPts2.begin(),vPts2.end(),
     start2,stop2,
     "Truncate+1",aBoard);   

  aBoard.saveEPS("DuplicatedCurveWithItMode2.eps");
}
  trace.endBlock();


  trace.beginBlock("Segmentation of a subrange of a duplicated range (mode3)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc2; 
  aBoard << SetMode("PointVector", "Paving") << *start2 << *stop2; 

  segmentationIntoDSSs<RAConstIterator,Board2D>
    (vPts2.begin(),vPts2.end(),
     start2,stop2,
     "DoNotTruncate",aBoard);   

  aBoard.saveEPS("DuplicatedCurveWithItMode3.eps");
}
  trace.endBlock();


// closed digital curve with circulators

  ConstCirculator c2(start2,start2,stop2); 

  trace.beginBlock("Segmentation of a whole range (mode1) with circulators");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc2; 

  segmentationIntoDSSs<ConstCirculator,Board2D>
    (c2,c2,c2,c2,
     "Truncate",aBoard);   

  aBoard.saveEPS("ClosedCurveWithCircMode1.eps");
}
  trace.endBlock();

  trace.beginBlock("Segmentation of a whole range (mode2) with circulators");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc2; 

  segmentationIntoDSSs<ConstCirculator,Board2D>
    (c2,c2,c2,c2,
     "Truncate+1",aBoard);   

  aBoard.saveEPS("ClosedCurveWithCircMode2.eps");
}
  trace.endBlock();


  trace.beginBlock("Segmentation of a whole range (mode3) with circulators");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc2; 

  segmentationIntoDSSs<ConstCirculator,Board2D>
    (c2,c2,c2,c2,
     "DoNotTruncate",aBoard);   

  aBoard.saveEPS("ClosedCurveWithCircMode3.eps");
}
  trace.endBlock();


  return true;
}


// Functions for testing class SaturatedSegmentation



bool SaturatedSegmentationVisualTest()
{

  typedef int Coordinate;
  typedef FreemanChain<Coordinate> FC; 
  typedef FreemanChain<Coordinate>::ConstIterator ConstIterator; 

  std::string filename = testPath + "samples/manche.fc";

  std::fstream fst;
  fst.open (filename.c_str(), std::ios::in);
  FC fc(fst);

// whole open curve

  trace.beginBlock("Simple saturated Segmentation (mode=First)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc; 

  segmentationIntoMaximalDSSs<ConstIterator,Board2D>
    (fc.begin(),fc.end(),
     fc.begin(),fc.end(),
     "First",aBoard);   

  aBoard.saveEPS("MSOpenCurve2.eps");
}
  trace.endBlock();

  trace.beginBlock("Simple saturated Segmentation (mode=MostCentered)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc; 

  segmentationIntoMaximalDSSs<ConstIterator,Board2D>
    (fc.begin(),fc.end(),
     fc.begin(),fc.end(),
     "MostCentered",aBoard);   

  aBoard.saveEPS("MSOpenCurve3.eps");
}
  trace.endBlock();

  trace.beginBlock("Simple saturated Segmentation (mode=Last)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc; 

  segmentationIntoMaximalDSSs<ConstIterator,Board2D>
    (fc.begin(),fc.end(),
     fc.begin(),fc.end(),
     "Last",aBoard);   

  aBoard.saveEPS("MSOpenCurve4.eps");
}
  trace.endBlock();

// subrange

  typedef vector<PointVector<2,Coordinate> > Curve;  
  typedef Curve::const_iterator RAConstIterator;  

  Curve vPts; 
  vPts.assign ( fc.begin(), fc.end() ); 

  RAConstIterator start = vPts.begin()+190;
  RAConstIterator stop = vPts.begin()+400;

trace.info() << *start << " " << *stop << endl;


  trace.beginBlock("saturated Segmentation of a subrange (mode=First)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc; 
  aBoard << SetMode("PointVector", "Paving") << *start << *stop; 

  segmentationIntoMaximalDSSs<RAConstIterator,Board2D>
    (vPts.begin(),vPts.end(),
     start,stop,
     "First",aBoard);   

  aBoard.saveEPS("MSOpenCurvePart2.eps");
}
  trace.endBlock();

  trace.beginBlock("saturated Segmentation of a subrange (mode=MostCentered)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc; 
  aBoard << SetMode("PointVector", "Paving") << *start << *stop; 

  segmentationIntoMaximalDSSs<RAConstIterator,Board2D>
    (vPts.begin(),vPts.end(),
     start,stop,
     "MostCentered",aBoard);   

  aBoard.saveEPS("MSOpenCurvePart3.eps");
}
  trace.endBlock();

  trace.beginBlock("saturated Segmentation of a subrange (mode=Last)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc; 
  aBoard << SetMode("PointVector", "Paving") << *start << *stop; 

  segmentationIntoMaximalDSSs<RAConstIterator,Board2D>
    (vPts.begin(),vPts.end(),
     start,stop,
     "Last",aBoard);   

  aBoard.saveEPS("MSOpenCurvePart4.eps");
}
  trace.endBlock();


// using circulators

  typedef Circulator<RAConstIterator> ConstCirculator;
  ConstCirculator c(vPts.begin(),vPts.begin(),vPts.end()); 


  trace.beginBlock("Segmentation of a range bounded by circulators (mode=First)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc; 

  segmentationIntoMaximalDSSs<ConstCirculator,Board2D>
    (c,c,c,c,
     "First",aBoard);   

  aBoard.saveEPS("MSOpenCurveWithCirc2.eps");
}
  trace.endBlock();

  trace.beginBlock("Segmentation of a range bounded by circulators (mode=MostCentered)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc; 

  segmentationIntoMaximalDSSs<ConstCirculator,Board2D>
    (c,c,c,c,
     "MostCentered",aBoard);   

  aBoard.saveEPS("MSOpenCurveWithCirc3.eps");
}
  trace.endBlock();

  trace.beginBlock("Segmentation of a range bounded by circulators (mode=Last)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc; 

  segmentationIntoMaximalDSSs<ConstCirculator,Board2D>
    (c,c,c,c,
     "Last",aBoard);   

  aBoard.saveEPS("MSOpenCurveWithCirc4.eps");
}
  trace.endBlock();


// subrange with circulators

  ConstCirculator cstart(start,vPts.begin(),vPts.end()); 
  ConstCirculator cstop(stop,vPts.begin(),vPts.end()); 


  trace.beginBlock("Segmentation of a subrange with circulators (mode=First)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc; 
  aBoard << SetMode("PointVector", "Paving") << *cstart << *cstop; 

  segmentationIntoMaximalDSSs<ConstCirculator,Board2D>
    (c,c,cstart,cstop,
     "First",aBoard);   

  aBoard.saveEPS("MSOpenCurvePartWithCirc2.eps");
}
  trace.endBlock();

  trace.beginBlock("Segmentation of a subrange with circulators (mode=MostCentered)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc; 
  aBoard << SetMode("PointVector", "Paving") << *cstart << *cstop; 

  segmentationIntoMaximalDSSs<ConstCirculator,Board2D>
    (c,c,cstart,cstop,
     "MostCentered",aBoard);   

  aBoard.saveEPS("MSOpenCurvePartWithCirc3.eps");
}
  trace.endBlock();

  trace.beginBlock("Segmentation of a subrange with circulators (mode=Last)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc; 
  aBoard << SetMode("PointVector", "Paving") << *cstart << *cstop; 

  segmentationIntoMaximalDSSs<ConstCirculator,Board2D>
    (c,c,cstart,cstop,
     "Last",aBoard);   

  aBoard.saveEPS("MSOpenCurvePartWithCirc4.eps");
}
  trace.endBlock();

// closed digital curve with circulators

  std::stringstream ss(stringstream::in | stringstream::out);
  ss << "31 16 1112121212121221212121221212212222232232323332333333332333332330333033003030000010001001001000100010101010111" << endl;
  
  // Construct the Freeman chain
  FC fc2(ss);

  Curve vPts2; 
  vPts2.assign( fc2.begin(), fc2.end() ); 
  vPts2.insert( vPts2.end(), fc2.begin(), fc2.end() );
  vPts2.insert( vPts2.end(), fc2.begin(), fc2.end() );

  RAConstIterator start2 = vPts2.begin() + fc2.size()+1; 
  RAConstIterator stop2 = start2 + fc2.size()+1; 

  trace.info() << *start2 << " " << *stop2 << endl;

  trace.beginBlock("Satured Segmentation of a duplicated range (mode2)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc2; 
  aBoard << SetMode("PointVector", "Paving") << *start2 << *stop2; 

  segmentationIntoMaximalDSSs<RAConstIterator,Board2D>
    (vPts2.begin(),vPts2.end(),
     start2,stop2,
     "First",aBoard);   

  aBoard.saveEPS("MSClosedCurveWithIt2.eps");
}
  trace.endBlock();

  trace.beginBlock("Satured Segmentation of a duplicated range (mode3)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc2; 
  aBoard << SetMode("PointVector", "Paving") << *start2 << *stop2; 

  segmentationIntoMaximalDSSs<RAConstIterator,Board2D>
    (vPts2.begin(),vPts2.end(),
     start2,stop2,
     "MostCentered",aBoard);   

  aBoard.saveEPS("MSClosedCurveWithIt3.eps");
}
  trace.endBlock();


  trace.beginBlock("Satured Segmentation of a duplicated range (mode4)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc2; 
  aBoard << SetMode("PointVector", "Paving") << *start2 << *stop2; 

  segmentationIntoMaximalDSSs<RAConstIterator,Board2D>
    (vPts2.begin(),vPts2.end(),
     start2,stop2,
     "Last",aBoard);   

  aBoard.saveEPS("MSClosedCurveWithIt4.eps");
}
  trace.endBlock();



  Curve vPts3; 
  vPts3.assign( fc2.begin(), fc2.end() ); 

  ConstCirculator c2(vPts3.begin(),vPts3.begin(),vPts3.end()); 

  trace.beginBlock("saturated Segmentation of a closed digital curve (mode=First)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc2; 
  aBoard << SetMode("PointVector", "Paving") << *c2; 

  segmentationIntoMaximalDSSs<ConstCirculator,Board2D>
    (c2,c2,c2,c2,
     "First",aBoard);   

  aBoard.saveEPS("MSClosedCurveWithCirc2.eps");
}
  trace.endBlock();

  trace.beginBlock("saturated Segmentation of a closed digital curve (mode=MostCentered)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc2; 
  aBoard << SetMode("PointVector", "Paving") << *c2; 

  segmentationIntoMaximalDSSs<ConstCirculator,Board2D>
    (c2,c2,c2,c2,
     "MostCentered",aBoard);   

  aBoard.saveEPS("MSClosedCurveWithCirc3.eps");
}
  trace.endBlock();

  trace.beginBlock("saturated Segmentation of a closed digital curve (mode=Last)");
{
  Board2D aBoard;
  aBoard << SetMode("PointVector", "Grid") << fc2; 
  aBoard << SetMode("PointVector", "Paving") << *c2; 

  segmentationIntoMaximalDSSs<ConstCirculator,Board2D>
    (c2,c2,c2,c2,
     "Last",aBoard);   

  aBoard.saveEPS("MSClosedCurveWithCirc4.eps");
}
  trace.endBlock();


  return true; 

}


bool SaturatedSegmentationTest()
{

  typedef int Coordinate;
  typedef FreemanChain<Coordinate> FC; 

  std::string filename = testPath + "samples/BigBall2.fc";

  std::fstream fst;
  fst.open (filename.c_str(), std::ios::in);
  FC fc(fst);

  typedef PointVector<2,Coordinate> Point; 

  vector<Point> vPts; 
  vPts.assign(fc.begin(),fc.end()); 
 
  typedef vector<Point>::const_iterator ConstIterator; 
  typedef Circulator<ConstIterator> ConstCirculator; 

  Circulator<ConstIterator> c(vPts.begin(), vPts.begin(), vPts.end() ); 

  typedef ArithmeticalDSS<ConstCirculator,Coordinate,4> RecognitionAlgorithm;
  typedef SaturatedSegmentation<RecognitionAlgorithm> Segmentation;

  trace.beginBlock("saturated Segmentation");
  trace.info() << filename << endl;

  RecognitionAlgorithm algo;
  Segmentation s(c,c,algo);
  s.setMode("First"); 
  
  Segmentation::SegmentComputerIterator begin = s.begin();
  Segmentation::SegmentComputerIterator end = s.end();

  unsigned int compteur = 0; 
  for (Segmentation::SegmentComputerIterator i(begin); i != end; ++i) {
    ++compteur; 
  } 

  trace.info() << "# nbpts nbsegments " << endl;
  trace.info() << fc.size()+1 << " " << compteur << endl;

  trace.endBlock();

  return (compteur == 4295);
}


int main(int argc, char **argv)
{
  
  trace.beginBlock ( "Testing class GreedyDecomposition and SaturatedSegmentation" );
  trace.info() << "Args:";
  for ( int i = 0; i < argc; ++i )
    trace.info() << " " << argv[ i ];
  trace.info() << endl;

  bool res = greedySegmentationVisualTest()
&& SaturatedSegmentationVisualTest()
&& SaturatedSegmentationTest()
;

  trace.emphase() << ( res ? "Passed." : "Error." ) << endl;
  trace.endBlock();

  return res ? 0 : 1;

}