This example shows how to make a polyhedron surface from a digital object vol file.
#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include "DGtal/base/Common.h"
#include "DGtal/helpers/StdDefs.h"
#include "ConfigExamples.h"
#include "DGtal/io/readers/VolReader.h"
#include "DGtal/images/ImageSelector.h"
#include "DGtal/images/ImageContainerBySTLVector.h"
#include "DGtal/images/SimpleThresholdForegroundPredicate.h"
#include "DGtal/io/Display3D.h"
#include "DGtal/io/viewers/Viewer3D.h"
#include "DGtal/io/DrawWithDisplay3DModifier.h"
#include "DGtal/images/imagesSetsUtils/SetFromImage.h"
#include "DGtal/topology/DigitalSurface.h"
#include "DGtal/topology/helpers/Surfaces.h"
#include "DGtal/topology/ImplicitDigitalSurface.h"
#include "DGtal/graph/BreadthFirstVisitor.h"
#include "DGtal/geometry/surfaces/COBANaivePlaneComputer.h"
#include "DGtal/geometry/surfaces/ChordNaivePlaneComputer.h"
#include "DGtal/geometry/surfaces/ChordGenericNaivePlaneComputer.h"
#include "DGtal/math/linalg/SimpleMatrix.h"
#include "DGtal/math/linalg/EigenDecomposition.h"
using namespace Z3i;
template <typename T1, typename T2>
struct PairSorted2nd
{
typedef PairSorted2nd<T1,T2> Self;
inline PairSorted2nd( const T1& t1, const T2& t2 ) : first( t1 ), second( t2 ) {}
bool operator<( const Self& other ) const
{
return second < other.second;
}
T1 first;
T2 second;
};
template <typename T1, typename T2, typename T3>
struct Triple
{
T1 first;
T2 second;
T3 third;
Triple( T1 t1 = T1(), T2 t2 = T2(), T3 t3 = T3() )
: first( t1 ), second( t2 ), third( t3 )
{}
};
template <typename RealVector,
{
typedef typename RealVector::Component Component;
unsigned int nb = 0;
RealVector G = RealVector::zero;
{
G += RealVector( (*it)[ 0 ], (*it)[ 1 ], (*it)[ 2 ] );
++nb;
}
G /= nb;
{
RealVector p( (*it)[ 0 ], (*it)[ 1 ], (*it)[ 2 ] );
p -= G;
A.setComponent( i, j, A( i, j ) + p[ i ] * p[ j ] );
}
Matrix V;
RealVector values;
N = V.column( 0 );
double mu = 0.0;
mu += N.dot( *it );
return mu/(double)nb;
}
int main(
int argc,
char** argv )
{
QApplication application(argc,argv);
string inputFilename = argc > 1 ? argv[ 1 ] : examplesPath+"/samples/Al.100.vol";
int threshold = argc > 2 ? atoi( argv[ 2 ] ) : 0;
int widthNum = argc > 3 ? atoi( argv[ 3 ] ) : 2;
int widthDen = argc > 4 ? atoi( argv[ 4 ] ) : 1;
DigitalObject digitalObject( image, threshold );
trace.
beginBlock(
"Construct the Khalimsky space from the image domain." );
bool space_ok = ks.init( image.domain().lowerBound(), image.domain().upperBound(), true );
if (!space_ok)
{
trace.
error() <<
"Error in the Khamisky space construction."<<endl;
return 2;
}
MySurfelAdjacency surfAdj( false );
typedef KSpace::Surfel
Surfel;
MyContainer container( ks, digitalObject, surfAdj, start_surfel );
trace.
info() <<
"Digital surface has " << digSurf.size() <<
" surfels."
<< endl;
trace.
beginBlock(
"Decomposition first pass. Computes all planes so as to sort vertices by the plane size." );
map<Surfel,unsigned int> v2size;
for (
ConstIterator it = digSurf.begin(), itE= digSurf.end(); it != itE; ++it )
v2size[ *it ] = 0;
int j = 0;
int nb = digSurf.size();
vector<Point> layer;
vector<Surfel> layer_surfel;
for (
ConstIterator it = digSurf.begin(), itE= digSurf.end(); it != itE; ++it )
{
planeComputer.init( widthNum, widthDen );
layer.clear();
layer_surfel.clear();
Visitor::Size currentSize = visitor.current().second;
while ( ! visitor.finished() )
{
Visitor::Node node = visitor.current();
v = node.first;
int axis = ks.sOrthDir( v );
Point p = ks.sCoords( ks.sDirectIncident( v, axis ) );
if ( node.second != currentSize )
{
bool isExtended = planeComputer.extend( layer.begin(), layer.end() );
if ( isExtended )
{
for ( vector<Surfel>::const_iterator it_layer = layer_surfel.begin(),
it_layer_end = layer_surfel.end(); it_layer != it_layer_end; ++it_layer )
{
++v2size[ *it_layer ];
}
layer_surfel.clear();
layer.clear();
currentSize = node.second;
}
else
break;
}
layer_surfel.push_back( v );
layer.push_back( p );
visitor.expand();
}
}
typedef PairSorted2nd<Surfel,int> SurfelWeight;
priority_queue<SurfelWeight> Q;
for (
ConstIterator it = digSurf.begin(), itE= digSurf.end(); it != itE; ++it )
Q.push( SurfelWeight( *it, v2size[ *it ] ) );
trace.
beginBlock(
"Decomposition second pass. Visits vertices from the one with biggest plane to the one with smallest plane." );
typedef Triple<NaivePlaneComputer, Color, pair<RealVector,double> > RoundPlane;
set<Surfel> processedVertices;
vector<RoundPlane*> roundPlanes;
map<Surfel,RoundPlane*> v2plane;
j = 0;
while ( ! Q.empty() )
{
Q.pop();
if ( processedVertices.find( v ) != processedVertices.end() )
continue;
RoundPlane* ptrRoundPlane = new RoundPlane;
roundPlanes.push_back( ptrRoundPlane );
v2plane[ v ] = ptrRoundPlane;
ptrRoundPlane->first.init( widthNum, widthDen );
ptrRoundPlane->third = make_pair( RealVector::zero, 0.0 );
layer.clear();
layer_surfel.clear();
Visitor::Size currentSize = visitor.current().second;
while ( ! visitor.finished() )
{
Visitor::Node node = visitor.current();
v = node.first;
Point p = ks.sCoords( ks.sDirectIncident( v, axis ) );
if ( node.second != currentSize )
{
bool isExtended = ptrRoundPlane->first.extend( layer.begin(), layer.end() );
if ( isExtended )
{
for ( vector<Surfel>::const_iterator it_layer = layer_surfel.begin(),
it_layer_end = layer_surfel.end(); it_layer != it_layer_end; ++it_layer )
{
processedVertices.insert( s );
if ( v2plane.find( s ) == v2plane.end() )
v2plane[ s ] = ptrRoundPlane;
}
layer.clear();
layer_surfel.clear();
currentSize = node.second;
}
else break;
}
layer_surfel.push_back( v );
layer.push_back( p );
if ( processedVertices.find( v ) != processedVertices.end() )
visitor.ignore();
else
visitor.expand();
}
if ( visitor.finished() )
{
for ( vector<Surfel>::const_iterator it_layer = layer_surfel.begin(),
it_layer_end = layer_surfel.end(); it_layer != it_layer_end; ++it_layer )
{
processedVertices.insert( s );
if ( v2plane.find( s ) == v2plane.end() )
v2plane[ s ] = ptrRoundPlane;
}
}
ptrRoundPlane->second =
Color( rand() % 192 + 64, rand() % 192 + 64, rand() % 192 + 64, 255 );
}
for ( vector<RoundPlane*>::iterator
it = roundPlanes.begin(), itE = roundPlanes.end();
it != itE; ++it )
{
RealVector normal;
double mu =
LSF( normal, computer.begin(), computer.end() );
(*it)->third = make_pair( normal, mu );
}
map<Surfel, RealPoint> coordinates;
for ( map<Surfel,RoundPlane*>::const_iterator
it = v2plane.begin(), itE = v2plane.end();
it != itE; ++it )
{
RoundPlane* rplane = it->second;
Point p = ks.sKCoords( v );
RealPoint rp( (
double)p[ 0 ]/2.0, (
double)p[ 1 ]/2.0, (
double)p[ 2 ]/2.0 );
double mu = rplane->third.second;
RealVector normal = rplane->third.first;
double lambda = mu - rp.dot( normal );
coordinates[ v ] = rp + lambda*normal;
}
typedef vector<Surfel> SurfelRange;
map<Surfel, RealPoint> new_coordinates;
for (
ConstIterator it = digSurf.begin(), itE= digSurf.end(); it != itE; ++it )
{
SurfelRange neighbors;
back_insert_iterator<SurfelRange> writeIt = back_inserter( neighbors );
digSurf.writeNeighbors( writeIt, *it );
for ( SurfelRange::const_iterator its = neighbors.begin(), itsE = neighbors.end();
its != itsE; ++its )
x += coordinates[ *its ];
new_coordinates[ s ] = x / neighbors.size();
}
typedef unsigned int Number;
typedef MyMesh::MeshFace MeshFace;
typedef MyDigitalSurface::FaceSet FaceSet;
map<Surfel, Number> index;
Number nbv = 0;
MyMesh polyhedron( true );
for (
ConstIterator it = digSurf.begin(), itE= digSurf.end(); it != itE; ++it )
{
polyhedron.addVertex( new_coordinates[ *it ] );
index[ *it ] = nbv++;
}
FaceSet faces = digSurf.allClosedFaces();
for ( typename FaceSet::const_iterator itf = faces.begin(), itf_end = faces.end();
itf != itf_end; ++itf )
{
MeshFace mface( itf->nbVertices );
int i = 0;
for ( typename VertexRange::const_iterator itv = vtcs.begin(), itv_end = vtcs.end();
itv != itv_end; ++itv )
{
mface[ i++ ] = index[ *itv ];
}
polyhedron.addFace( mface,
Color( 255, 243, 150, 255 ) );
}
MyViewer3D viewer( ks );
viewer.show();
bool isOK = polyhedron >> "test.off";
bool isOK2 = polyhedron >> "test.obj";
viewer << polyhedron;
viewer << MyViewer3D::updateDisplay;
application.exec();
for ( vector<RoundPlane*>::iterator
it = roundPlanes.begin(), itE = roundPlanes.end();
it != itE; ++it )
delete *it;
if (isOK && isOK2)
return 0;
else
return 1;
}
Aim: This class is useful to perform a breadth-first exploration of a graph given a starting point or...
Aim: A class that recognizes pieces of digital planes of given axis width. When the width is 1,...
Structure representing an RGB triple with alpha component.
Aim: Represents a set of n-1-cells in a nD space, together with adjacency relation between these cell...
Aim: This class provides methods to compute the eigen decomposition of a matrix. Its objective is to ...
Aim: A model of CDigitalSurfaceContainer which defines the digital surface as the boundary of an impl...
Aim: This class is defined to represent a surface mesh through a set of vertices and faces....
Aim: implements basic MxN Matrix services (M,N>=1).
Aim: A utility class for constructing surfaces (i.e. set of (n-1)-cells).
Aim: Represent adjacencies between surfel elements, telling if it follows an interior to exterior ord...
void beginBlock(const std::string &keyword="")
void progressBar(const double currentValue, const double maximalValue)
Aim: Define a simple Foreground predicate thresholding image values given a single thresold....
DigitalSurface< MyDigitalSurfaceContainer > MyDigitalSurface
COBANaivePlaneComputer< Z3, InternalInteger > NaivePlaneComputer
MyDigitalSurface::ConstIterator ConstIterator
BreadthFirstVisitor< MyDigitalSurface > Visitor
DGtal is the top-level namespace which contains all DGtal functions and types.
DGtal::uint32_t Dimension
double LSF(RealVector &N, ConstIterator itB, ConstIterator itE)
Aim: implements methods to read a "Vol" file format.
ImageContainerBySTLVector< Domain, Value > Image
TriMesh::VertexRange VertexRange
PointVector< 3, double > RealPoint