area-estimation-with-indexed-digital-surface.cpp

Go to the documentation of this file.

#include <cstdlib>
#include <iostream>
#include <map>
#include "DGtal/base/Common.h"
#include "DGtal/base/CountedPtr.h"
#include "DGtal/helpers/StdDefs.h"
#include "DGtal/kernel/PointVector.h"
#include "DGtal/graph/CUndirectedSimpleGraph.h"
#include "DGtal/graph/BreadthFirstVisitor.h"
#include "DGtal/topology/DigitalSetBoundary.h"
#include "DGtal/topology/IndexedDigitalSurface.h"
#include "DGtal/shapes/Shapes.h"


using namespace std;
using namespace DGtal;
using namespace DGtal::Z3i;

int main( int argc, char** argv )
{
  const double        R = argc >= 2 ? atof( argv[ 1 ] ) : 13.0; // radius of ball
  const unsigned int KN = argc >= 3 ? atoi( argv[ 2 ] ) : 6;    // size of neighborhood
  const int           M = (int) ceil( R + 2.0 );
  trace.beginBlock( "Creating surface" );
  trace.info() << "Sphere of radius " << R
               << ", " << KN << "-ring neighborhood" << std::endl;
  typedef DigitalSetBoundary   < KSpace, DigitalSet >      DigitalSurfaceContainer;
  typedef IndexedDigitalSurface< DigitalSurfaceContainer > DigSurface;
  typedef BreadthFirstVisitor  < DigSurface >              BFSVisitor;
  Point p1( -M, -M, -M );
  Point p2(  M,  M,  M );
  KSpace K;
  K.init( p1, p2, true );
  DigitalSet aSet( Domain( p1, p2 ) );
  Shapes<Domain>::addNorm2Ball( aSet, Point( 0, 0, 0 ), R );
  auto dsc = CountedPtr< DigitalSurfaceContainer >( new DigitalSurfaceContainer( K, aSet ) );
  DigSurface dsurf( dsc );
  trace.info() << "[OK]"
               << " Sphere has " << dsurf.size() << " vertices/surfels"
               << " with euler " << dsurf.Euler() << std::endl;
  trace.endBlock();

  trace.beginBlock( "Estimating normals" );
  auto v2n = dsurf.makeVertexMap( RealPoint() );
  for ( auto v : dsurf )
    {
      int          nbv = 0;
      RealPoint normal = RealPoint::zero;
      BFSVisitor bfv( dsurf, v );
      while( ! bfv.finished() )
        { // Vertex are colored according to the distance to initial seed.
          auto node    = bfv.current();
          if ( KN < node.second ) break;
          auto surfel  = dsurf.surfel( node.first );
          RealPoint nv = RealPoint::zero;
          Dimension  k = K.sOrthDir( surfel );
          nv[ k ]      = K.sDirect( surfel, k ) ? 1.0 : -1.0;
          normal      += nv;
          nbv         += 1;
          bfv.expand();
        }
      normal  /= nbv;
      v2n[ v ] = normal.getNormalized();
    }
  trace.endBlock();
  
  trace.beginBlock( "Estimating area" );
  const double area_true = 4.0 * M_PI * R * R;
  double   area_averaged = 0.0;
  double  area_corrected = 0.0;
  for ( auto v : dsurf )
    {
      auto     surfel = dsurf.surfel( v );
      Dimension     k = K.sOrthDir( surfel );
      area_corrected += fabs( v2n[ v ][ k ] );
      area_averaged  += 1.0 / v2n[ v ].norm( RealPoint::L_1 );
    }
  trace.info() << "- true area      = " << area_true << std::endl;
  trace.info() << "- corrected area = " << area_corrected << std::endl;
  trace.info() << "- averaged area  = " << area_averaged << std::endl;
  trace.endBlock();

  return 0;
}