testImagesSetsUtilities.cpp

#include <iostream>
#include "DGtal/base/Common.h"

#include "DGtal/images/imagesSetsUtils/ImageFromSet.h"
#include "DGtal/images/imagesSetsUtils/SetFromImage.h"

#include "DGtal/kernel/sets/DigitalSetInserter.h"
#include "DGtal/images/ImageHelper.h"

#include "DGtal/images/ImageContainerBySTLMap.h"
#include "DGtal/images/ImageContainerBySTLVector.h"
#include "DGtal/images/ImageSelector.h"

#include "DGtal/helpers/StdDefs.h"

#include "ConfigTest.h"


using namespace std;
using namespace DGtal;
using namespace Z2i;

// Functions for testing ImageHelper functions.

template <typename P>
struct Norm1
{
  typedef P Point;
  typedef typename P::Coordinate Value;

  Value operator()(const Point& p)
  {
    return p.norm1();
  }
};

bool testImageFromSet()
{

  typedef ImageContainerBySTLVector<Domain,int> Image;

  unsigned int nbok = 0;
  unsigned int nb = 0;

  trace.beginBlock ( "Testing ImageFromSet ..." );

  Point a(0,0);
  Point b(23,435);
  Point c(12,12);

  Domain d(a,b);
  DigitalSet aSet(d);
  aSet.insert(c);

  Image image(d);
  //assign to the points belonging to aSet the value 128
  imageFromRangeAndValue(aSet, image, 128);
  //ie. the value of c is 128 but the value of a remains 0
  nbok += ( (image(c) == 128)&&(image(a) == 0) ) ? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") " << std::endl;

  Image image2(d);
  Norm1<Point> n;
  //fill image2 from n
  imageFromFunctor(image2, n);
  nbok += ( (image2(c) == (int)c.norm1())
            &&(image2(a) == (int)a.norm1())
            &&(image2(b) == (int)b.norm1()) )? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") " << std::endl;

  Image image3 = image;
  //fill image3 from image2
  imageFromImage(image3, image2);
  //image2 and image3 should be equal,
  //but both different from image
  Image::ConstRange rimg = image.constRange();
  Image::ConstRange rimg2 = image2.constRange();
  Image::ConstRange rimg3 = image3.constRange();
  bool flag2 = std::equal(rimg.begin(), rimg.end(), rimg2.begin());
  bool flag3 = std::equal(rimg.begin(), rimg.end(), rimg3.begin());
  bool flag23 = std::equal(rimg2.begin(), rimg2.end(), rimg3.begin());
  nbok += ( (!flag2) && (!flag3) && flag23 )?1:0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") " << std::endl;

  trace.endBlock();

  return nbok == nb;
}

bool testSetFromImage()
{
  unsigned int nbok = 0;
  unsigned int nb = 0;

  trace.beginBlock ( "Testing SetFromImage ..." );

  //some points
  Point a(0,0);
  Point b(3,3);
  Point p(1,1);
  Point q(2,2);
  Point r(1,2);

  //image construction
  typedef ImageContainerBySTLMap<Domain,int> Image;
  Domain d(a,b);
  Image image(d,1);
  image.setValue(p,127);
  image.setValue(q,128);
  image.setValue(r,10);

  //image content
  Image::ConstRange range = image.constRange();
  std::copy(range.begin(), range.end(), ostream_iterator<Image::Value>(cout, " ") );
  cout << endl;

  //set tests

  DigitalSet aSet(d);
  DigitalSetInserter<DigitalSet> inserter(aSet);
  //all points whose value <= 126
  setFromImage( image, inserter, 126 );
  //ie, all points except p and q
  nbok += ( (aSet.find(p) == aSet.end())
            &&(aSet.find(q) == aSet.end())
            &&(aSet.size()==(d.size()-2)) ) ? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") " << std::endl;

  DigitalSet aSet2(d);
  DigitalSetInserter<DigitalSet> inserter2(aSet2);
  //all points whose value <= 127
  setFromImage( image, inserter2, 127 );
  //ie, all points except q
  nbok += ( (aSet2.find(q) == aSet2.end())
            &&(aSet2.size()==(d.size()-1)) ) ? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") " << std::endl;

  DigitalSet aSet3(d);
  DigitalSetInserter<DigitalSet> inserter3(aSet3);
  //all points whose value <= 128
  setFromImage( image, inserter3, 128 );
  //ie, all points
  nbok += ( aSet3.size()==d.size() ) ? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") " << std::endl;

  DigitalSet aSet4(d);
  DigitalSetInserter<DigitalSet> inserter4(aSet4);
  //all points whose value is between 2 and 100
  setFromImage( image, inserter4, 2, 100 );
  //ie, only point r
  nbok += ( (aSet4.find(r)!=aSet4.end())&&(aSet4.size()==1) ) ? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") " << std::endl;

  DigitalSet aSet5(d);
  DigitalSetInserter<DigitalSet> inserter5(aSet5);
  //predicate construction
  typedef std::equal_to<Image::Value> EqualBinaryFunctor;
  typedef std::binder2nd<EqualBinaryFunctor> ValuePredicate;
  ValuePredicate equalTo1 (EqualBinaryFunctor(),1);
  PointFunctorPredicate<Image, ValuePredicate> pred(image, equalTo1);
  //all points whose value is 1
  setFromPointsRangeAndPredicate( d.begin(), d.end(), inserter5, pred );
  //ie all points except p, q, and r
  nbok += ( (aSet5.find(p) == aSet5.end())
            &&(aSet5.find(q) == aSet5.end())
            &&(aSet5.find(r) == aSet5.end())
            &&(aSet5.size()==(d.size()-3)) ) ? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") " << std::endl;


  return nbok == nb;
}

// Standard services - public :

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

  bool res = testImageFromSet() && testSetFromImage();
  trace.emphase() << ( res ? "Passed." : "Error." ) << endl;
  trace.endBlock();
  return res ? 0 : 1;
}
//                                                                           //