testLambdaMST3D.cpp

Go to the documentation of this file.

#include <iostream>
#include <fstream>
#include <vector>
#include <iterator>
#include "DGtal/base/Common.h"
#include "ConfigTest.h"
#include "DGtal/helpers/StdDefs.h"
#include "DGtal/io/readers/PointListReader.h"
#include "DGtal/geometry/curves/Naive3DDSSComputer.h"
#include "DGtal/geometry/curves/estimation/LambdaMST3D.h"
#include "DGtal/geometry/curves/estimation/FunctorsLambdaMST.h"
#include "DGtal/geometry/curves/SaturatedSegmentation.h"


using namespace std;
using namespace DGtal;
using namespace Z3i;
using namespace functors;

// Functions for testing class LambdaMST3D.

class testLambdaMST3D
{
  typedef DGtal::Z3i::Point Point;
  typedef DGtal::Z2i::Point Point2D;
  typedef std::vector < Point > Range;
  typedef std::list < Point2D > Range2D;
  typedef Range::const_iterator ConstIterator;
  typedef Range2D::const_iterator ConstIterator2D;
  typedef Naive3DDSSComputer < ConstIterator, int, 8 > SegmentComputer;
  typedef SaturatedSegmentation<SegmentComputer> Segmentation;
  typedef ArithmeticalDSSComputer < ConstIterator2D, int, 8 > SegmentComputer2D;
  typedef SaturatedSegmentation<SegmentComputer2D> Segmentation2D;
private:
  Range curve;
public:
  testLambdaMST3D ()
  {
    fstream inputStream;
    inputStream.open ( (testPath + "samples/sinus3D.dat").c_str(), std::ios::in );
    try {
      curve = PointListReader<Point>::getPointsFromInputStream ( inputStream );
      if ( curve.size() == 0) throw IOException();
    } catch (DGtal::IOException & ioe) {
      trace.error() << "Size is null." << endl;
    }
  }
  bool lambda64ByPoint ()
  {
    Segmentation segmenter ( curve.begin(), curve.end(), SegmentComputer() );
    LambdaMST3D < Segmentation > lmst64;
    lmst64.attach ( segmenter );
    lmst64.init ( curve.begin(), curve.end() );
    for ( ConstIterator it = curve.begin(); it != curve.end(); ++it )
      lmst64.eval ( *it );
    return true;
  }
  bool lambda64()
  {
    Segmentation segmenter ( curve.begin(), curve.end(), SegmentComputer() );
    LambdaMST3D < Segmentation > lmst64;
    lmst64.attach ( segmenter );
    lmst64.init ( curve.begin(), curve.end() );
    vector < RealVector > tangent;
    lmst64.eval < back_insert_iterator< vector < RealVector > > > ( curve.begin(), curve.end(), back_insert_iterator< vector < RealVector > > ( tangent ) );
    return true;
  }

  bool lambda64Filtered()
  {
      Segmentation segmenter ( curve.begin(), curve.end(), SegmentComputer() );
      LambdaMST3D < Segmentation, Lambda64Function, DSSLengthLessEqualFilter < SegmentComputer > > lmst64;
      lmst64.attach ( segmenter );
      lmst64.getDSSFilter ( ).init ( 1 );
      lmst64.init ( curve.begin(), curve.end() );
      for ( ConstIterator it = curve.begin(); it != curve.end(); ++it )
          lmst64.eval ( *it );
      return true;
  }

  bool lambdaSinByPoint ()
  {
     Segmentation segmenter ( curve.begin(), curve.end(), SegmentComputer() );
     LambdaMST3D < Segmentation, LambdaSinFromPiFunction > lmst;
     lmst.attach ( segmenter );
     lmst.init ( curve.begin(), curve.end() );
     for ( ConstIterator it = curve.begin(); it != curve.end(); ++it )
         lmst.eval ( *it );
     return true;
 }

  bool lambdaSin()
  {
      Segmentation segmenter ( curve.begin(), curve.end(), SegmentComputer() );
      LambdaMST3D < Segmentation, LambdaSinFromPiFunction > lmst;
      lmst.attach ( segmenter );
      lmst.init ( curve.begin(), curve.end() );
      vector < RealVector > tangent;
      lmst.eval < back_insert_iterator< vector < RealVector > > > ( curve.begin(), curve.end(), back_insert_iterator< vector < RealVector > > ( tangent ) );
      return true;
  }

  bool lambdaExpByPoint ()
  {
      Segmentation segmenter ( curve.begin(), curve.end(), SegmentComputer() );
      LambdaMST3D < Segmentation, LambdaExponentialFunction > lmst;
      lmst.attach ( segmenter );
      lmst.init ( curve.begin(), curve.end() );
      for ( ConstIterator it = curve.begin(); it != curve.end(); ++it )
          lmst.eval ( *it );
      return true;
  }

  bool lambdaExp()
  {
      Segmentation segmenter ( curve.begin(), curve.end(), SegmentComputer() );
      LambdaMST3D < Segmentation, LambdaExponentialFunction > lmst;
      lmst.attach ( segmenter );
      lmst.init ( curve.begin(), curve.end() );
      vector < RealVector > tangent;
      lmst.eval < back_insert_iterator< vector < RealVector > > > ( curve.begin(), curve.end(), back_insert_iterator< vector < RealVector > > ( tangent ) );
      return true;
  }
};


// Standard services - public :

int main( int , char**  )
{
    bool res = true;
    testLambdaMST3D testLMST;
    trace.beginBlock ( "Testing LambdaMST3D" );
        trace.beginBlock ( "Testing point only calculation" );
          res &= testLMST.lambda64ByPoint();
          res &= testLMST.lambda64Filtered();
          res &= testLMST.lambdaSinByPoint();
          res &= testLMST.lambdaExpByPoint();
        trace.endBlock();
        trace.beginBlock ( "Testing calculation for whole curve" );
           res &= testLMST.lambda64();
           res &= testLMST.lambdaSin();
           res &= testLMST.lambdaExp();
        trace.endBlock();
    trace.endBlock();
    trace.emphase() << ( res ? "Passed." : "Error." ) << endl;
    return res ? 0 : 1;
}
//                                                                           //