convex-and-concave-parts.cpp

Go to the documentation of this file.

#include <cmath>
#include <iostream>
#include <sstream>
#include <fstream>
#include "DGtal/base/Common.h"
#include "DGtal/io/boards/Board2D.h"
#include "DGtal/io/Color.h"
#include "DGtal/shapes/Shapes.h"
#include "DGtal/helpers/StdDefs.h"
#include "DGtal/geometry/curves/ArithmeticalDSSComputer.h"
#include "DGtal/geometry/curves/FreemanChain.h"
#include "DGtal/geometry/curves/SaturatedSegmentation.h"
#include "ConfigExamples.h"

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




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

  //choose the drawing mode
  aBoard << SetMode( "ArithmeticalDSS", "BoundingBox" );
  //prepare the drawing style and the pen color
  string aStyleName = "ArithmeticalDSS/BoundingBox";
  CustomPenColor* aPenColor;

  //for each maximal segment
  for (Iterator i(itb); i != ite; ++i) {

    //get the current maximal segment
    typedef typename Iterator::SegmentComputer::Primitive DSS;
    DSS maximalDSS = i->primitive();

    //if located at the end of a connected part
    if ( !(i.intersectNext() && i.intersectPrevious()) ) {

      aPenColor = new CustomPenColor( Color::Black );

      //otherwise
    } else {

      //get the points located before and after the maximal segment
      typedef typename DSS::Point Point;
      Point beforeFirst = *(--(i->begin()));
      Point afterLast = *(i->end());

      //remainders and bounds
      typedef typename DSS::Integer Integer;
      Integer r1 = maximalDSS.remainder(beforeFirst);
      Integer r2 = maximalDSS.remainder(afterLast);
      Integer mu = maximalDSS.mu();
      Integer omega = maximalDSS.omega();

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

    }

    // draw the maximal segment on the board
    aBoard << CustomStyle( aStyleName, aPenColor )
           << maximalDSS;

  }

}

template <typename Iterator, typename Board>
void segmentationIntoMaximalDSSs(const Iterator& itb, const Iterator& ite,
                                 Board& aBoard)
{
  typedef typename IteratorCirculatorTraits<Iterator>::Value::Coordinate Coordinate;

  //choose the primitive computer and the segmentation
  typedef ArithmeticalDSSComputer<Iterator,Coordinate,4> RecognitionAlgorithm;
  typedef SaturatedSegmentation<RecognitionAlgorithm> Segmentation;

  //create the segmentation
  RecognitionAlgorithm algo;
  Segmentation s(itb,ite,algo);

  //draw the result
  drawCCP(s.begin(), s.end(), aBoard);
}


int main( int argc, char** argv )
{

  trace.beginBlock ( "Example convex-and-concave-parts" );

  Board2D aBoard; //create a board

  //create a chain code
  string codes;
  if (argc >= 2) codes = argv[1];
  else codes = "030030330303303030300001010101101011010000030330303303030300001010110101011010000033";

  stringstream ss(stringstream::in | stringstream::out);
  ss << "0 0 " << codes << endl;
  FreemanChain<int> theContour( ss );

  trace.info() << "Processing of " << ss.str() << endl;

  //draw the digital contour
  aBoard
   << SetMode( "PointVector", "Grid" )
   << theContour;

  //draw the maximal segments
  segmentationIntoMaximalDSSs(theContour.begin(), theContour.end(), aBoard);

  //save the drawing
  aBoard.saveSVG("convex-and-concave-parts.svg");
  #ifdef WITH_CAIRO
    aBoard.saveCairo("convex-and-concave-parts.png"); 
  #endif

  trace.endBlock();

  return 0;
}
//                                                                           //