int main( int argc, char** argv )
{
if ( argc < 9 )
{
usage( argc, argv );
return 1;
}
double border_min[ 3 ];
double border_max[ 3 ];
for ( unsigned int i = 0; i < 3; ++i )
{
border_min[ i ] = atof( argv[ 2+i ] );
border_max[ i ] = atof( argv[ 5+i ] );
}
double h = atof( argv[ 8 ] );
typedef Z3i::Space::RealPoint RealPoint;
typedef Z3i::Space::RealPoint::Coordinate Ring;
typedef MPolynomial< 3, Ring > Polynomial3;
typedef MPolynomialReader<3, Ring> Polynomial3Reader;
typedef ImplicitPolynomial3Shape<Z3i::Space> ImplicitShape;
/// Construction of the polynomial shape
Polynomial3 poly;
Polynomial3Reader reader;
std::string poly_str = argv[ 1 ];
std::string::const_iterator iter = reader.read( poly, poly_str.begin(), poly_str.end() );
if ( iter != poly_str.end() )
{
std::cerr << "ERROR: I read only <"
<< poly_str.substr( 0, iter - poly_str.begin() )
<< ">, and I built P=" << poly << std::endl;
return 1;
}
bool export_vol = false;
std::string pathToSavePCLFile = "";
std::string namePCLFile = "";
if( argc >= 10 )
{
export_vol = true;
namePCLFile = argv[ 9 ];
}
ImplicitShape shape( poly );
/// Computation of 3D curvature estimators (mean & Gaussian) on the implicit shape
processShape< Z3i::Space, ImplicitShape >( poly_str,
shape,
border_min, border_max,
h,
namePCLFile
);
}
int main( int argc, char** argv )
{
QApplication application(argc,argv);
// parse command line ----------------------------------------------
using namespace DGtal::functors;
namespace po = boost::program_options;
po::options_description general_opt("Allowed options are: ");
general_opt.add_options()
("help,h", "display this message")
("polynomial,p", po::value<string>(), "the implicit polynomial whose zero-level defines the shape of interest." )
("minAABB,a", po::value<double>()->default_value( -10.0 ), "the min value of the AABB bounding box (domain)" )
("maxAABB,A", po::value<double>()->default_value( 10.0 ), "the max value of the AABB bounding box (domain)" )
("gridstep,g", po::value< double >()->default_value( 1.0 ), "the gridstep that defines the digitization (often called h). " )
("estimator,e", po::value<string>()->default_value( "True" ), "the chosen normal estimator: True | VCM | II | Trivial" )
("R-radius,R", po::value<double>()->default_value( 5 ), "the constant for parameter R in R(h)=R h^alpha (VCM)." )
("r-radius,r", po::value<double>()->default_value( 3 ), "the constant for parameter r in r(h)=r h^alpha (VCM,II,Trivial)." )
("kernel,k", po::value<string>()->default_value( "hat" ), "the function chi_r, either hat or ball." )
("alpha", po::value<double>()->default_value( 0.0 ), "the parameter alpha in r(h)=r h^alpha (VCM)." )
("trivial-radius,t", po::value<double>()->default_value( 3 ), "the parameter t defining the radius for the Trivial estimator. Also used for reorienting the VCM." )
("embedding,E", po::value<int>()->default_value( 0 ), "the surfel -> point embedding for VCM estimator: 0: Pointels, 1: InnerSpel, 2: OuterSpel." )
("maxiter", po::value<int>()->default_value( 20 ), "the maximal number of iterations for True estimator (default is 20).")
("accuracy", po::value<double>()->default_value( 0.1 ), "the maximal accuracy for True estimator (default is 0.1).")
("gamma", po::value<double>()->default_value( 0.01 ), "the maximal gamma step for True estimator (default is 0.01).")
("output,o", po::value<string>()->default_value( "output" ), "the output basename. All generated files will have the form <arg>-*, for instance <arg>-area-<gridstep>.txt." )
;
bool parseOK=true;
po::variables_map vm;
try{
po::store(po::parse_command_line(argc, argv, general_opt), vm);
}catch(const exception& ex){
parseOK=false;
trace.info()<< "Error checking program options: "<< ex.what()<< endl;
}
po::notify(vm);
if( !parseOK || vm.count("help"))
{
cout << "Usage: " << argv[0] << " -p \"90-x^2-y^2-z^2\" -h 1 -R 5 -r 6 -t 2\n"
<< "Computes the area of a digital surface, defined as an implicit polynomial surface, by integration of normal estimation."
<< endl
<< general_opt << "\n";
cout << "Example:\n"
<< "./area-integration -p \"81-x^2-y^2-z^2\" -e VCM -R 3 -r 3 -g 0.5 # aire de la sphere de rayon 9, discrétisé au pas 0.5" << endl
<< " - ellipse : 90-3*x^2-2*y^2-z^2 " << endl
<< " - torus : -1*(x^2+y^2+z^2+6*6-2*2)^2+4*6*6*(x^2+y^2) " << endl
<< " - rcube : 6561-x^4-y^4-z^4" << endl
<< " - goursat : 8-0.03*x^4-0.03*y^4-0.03*z^4+2*x^2+2*y^2+2*z^2" << endl
<< " - distel : 10000-(x^2+y^2+z^2+1000*(x^2+y^2)*(x^2+z^2)*(y^2+z^2))" << endl
<< " - leopold : 100-(x^2*y^2*z^2+4*x^2+4*y^2+3*z^2)" << endl
<< " - diabolo : x^2-(y^2+z^2)^2" << endl
<< " - heart : -1*(x^2+2.25*y^2+z^2-1)^3+x^2*z^3+0.1125*y^2*z^3" << endl
<< " - crixxi : -0.9*(y^2+z^2-1)^2-(x^2+y^2-1)^3" << endl
<< " - goursat_dodecahedron: z^6-5*(x^2+y^2)*z^4+5*(x^2+y^2)^2*z^2-2*(x^4-10*x^2*y^2+5*y^4)*x*z+1*(x^2+y^2+z^2)^3+(-1)*(5)^2*(x^2+y^2+z^2)^2+1*(5)^4*(x^2+y^2+z^2)+(-1)*(5)^6" << endl
<< " - goursat_icosahedron : z^6-5*(x^2+y^2)*z^4+5*(x^2+y^2)^2*z^2-2*(x^4-10*x^2*y^2+5*y^4)*x*z+(-1)*(x^2+y^2+z^2)^3+(0)*(5)^2*(x^2+y^2+z^2)^2+(-1)*(5)^4*(x^2+y^2+z^2)+(1)*(5)^6" << endl
<< " - goursat_60lines : z^6-5*(x^2+y^2)*z^4+5*(x^2+y^2)^2*z^2-2*(x^4-10*x^2*y^2+5*y^4)*x*z+(0)*(x^2+y^2+z^2)^3+(5)*(5)^2*(x^2+y^2+z^2)^2+(-45)*(5)^4*(x^2+y^2+z^2)+(71)*(5)^6" << endl;
return 0;
}
if ( ! vm.count( "polynomial" ) )
{
cerr << "Need parameter --polynomial" << endl;
return 1;
}
trace.beginBlock( "Make implicit shape..." );
typedef Z3i::Space Space;
typedef double Scalar;
typedef MPolynomial< 3, Scalar > Polynomial3;
typedef MPolynomialReader<3, Scalar> Polynomial3Reader;
typedef ImplicitPolynomial3Shape<Space> ImplicitShape;
string poly_str = vm[ "polynomial" ].as<string>();
Polynomial3 poly;
Polynomial3Reader reader;
string::const_iterator iter = reader.read( poly, poly_str.begin(), poly_str.end() );
if ( iter != poly_str.end() )
{
trace.error() << "ERROR reading polynomial: I read only <" << poly_str.substr( 0, iter - poly_str.begin() )
<< ">, and I built P=" << poly << std::endl;
return 2;
}
CountedPtr<ImplicitShape> shape( new ImplicitShape( poly ) ); // smart pointer
trace.endBlock();
trace.beginBlock( "Make implicit digital shape..." );
typedef Z3i::KSpace KSpace;
typedef KSpace::Point Point;
typedef Space::RealPoint RealPoint;
typedef GaussDigitizer< Space, ImplicitShape > ImplicitDigitalShape;
typedef ImplicitDigitalShape::Domain Domain;
Scalar min_x = vm[ "minAABB" ].as<double>();
Scalar max_x = vm[ "maxAABB" ].as<double>();
Scalar h = vm[ "gridstep" ].as<double>();
RealPoint p1( min_x, min_x, min_x );
RealPoint p2( max_x, max_x, max_x );
CountedPtr<ImplicitDigitalShape> dshape( new ImplicitDigitalShape() );
dshape->attach( *shape );
dshape->init( p1, p2, h );
Domain domain = dshape->getDomain();
KSpace K;
K.init( domain.lowerBound(), domain.upperBound(), true );
trace.info() << "- domain is " << domain << std::endl;
trace.endBlock();
trace.beginBlock( "Make digital surface..." );
typedef LightImplicitDigitalSurface<KSpace,ImplicitDigitalShape> SurfaceContainer;
typedef DigitalSurface< SurfaceContainer > Surface;
typedef Surface::ConstIterator ConstIterator;
typedef typename Surface::Surfel Surfel;
SurfelAdjacency< KSpace::dimension > surfAdj( true );
Surfel bel;
try {
bel = Surfaces<KSpace>::findABel( K, *dshape, 10000 );
} catch (DGtal::InputException e) {
trace.error() << "ERROR Unable to find bel." << std::endl;
return 3;
}
SurfaceContainer* surfaceContainer = new SurfaceContainer( K, *dshape, surfAdj, bel );
CountedPtr<Surface> ptrSurface( new Surface( surfaceContainer ) ); // acquired
trace.info() << "- surface component has " << ptrSurface->size() << " surfels." << std::endl;
trace.endBlock();
string kernel = vm[ "kernel" ].as<string>();
double r = vm["r-radius"].as<double>();
double alpha = vm["alpha"].as<double>();
if ( alpha != 0.0 ) r *= pow( h, alpha-1.0 );
if ( kernel == "hat" ) {
typedef typename KSpace::Point Point;
typedef HatPointFunction<Point,double> KernelFunction;
KernelFunction chi_r( 1.0, r );
trace.info() << "- kernel hat r = " << r << std::endl;
chooseEstimator( vm, K, *shape, *ptrSurface, chi_r, *dshape );
} else if ( kernel == "ball" ) {
typedef typename KSpace::Point Point;
typedef BallConstantPointFunction<Point,double> KernelFunction;
KernelFunction chi_r( 1.0, r );
trace.info() << "- kernel ball r = " << r << std::endl;
chooseEstimator( vm, K, *shape, *ptrSurface, chi_r, *dshape );
}
return 0;
}
int main( int argc, char** argv )
{
// parse command line ----------------------------------------------
namespace po = boost::program_options;
po::options_description general_opt("Allowed options are: ");
general_opt.add_options()
("help,h", "display this message")
("polynomial,p", po::value<string>(), "the implicit polynomial whose zero-level defines the shape of interest." )
("noise,N", po::value<double>()->default_value( 0.0 ), "the Kanungo noise level l=arg, with l^d the probability that a point at distance d is flipped inside/outside." )
("minAABB,a", po::value<double>()->default_value( -10.0 ), "the min value of the AABB bounding box (domain)" )
("maxAABB,A", po::value<double>()->default_value( 10.0 ), "the max value of the AABB bounding box (domain)" )
("gridstep,g", po::value< double >()->default_value( 1.0 ), "the gridstep that defines the digitization (often called h). " )
("estimator,e", po::value<string>()->default_value( "True" ), "the chosen normal estimator: True | VCM | II | Trivial" )
("R-radius,R", po::value<double>()->default_value( 5 ), "the constant for parameter R in R(h)=R h^alpha (VCM)." )
("r-radius,r", po::value<double>()->default_value( 3 ), "the constant for parameter r in r(h)=r h^alpha (VCM,II,Trivial)." )
("kernel,k", po::value<string>()->default_value( "hat" ), "the function chi_r, either hat or ball." )
("alpha", po::value<double>()->default_value( 0.0 ), "the parameter alpha in r(h)=r h^alpha (VCM)." )
("trivial-radius,t", po::value<double>()->default_value( 3 ), "the parameter t defining the radius for the Trivial estimator. Also used for reorienting the VCM." )
("embedding,E", po::value<int>()->default_value( 0 ), "the surfel -> point embedding for VCM estimator: 0: Pointels, 1: InnerSpel, 2: OuterSpel." )
("output,o", po::value<string>()->default_value( "output" ), "the output basename. All generated files will have the form <arg>-*, for instance <arg>-angle-deviation-<gridstep>.txt, <arg>-normals-<gridstep>.txt, <arg>-cells-<gridstep>.txt, <arg>-noff-<gridstep>.off." )
("angle-deviation-stats,S", "computes angle deviation error and outputs them in file <basename>-angle-deviation-<gridstep>.txt, as specified by -o <basename>." )
("export,x", po::value<string>()->default_value( "None" ), "exports surfel normals which can be viewed with ImaGene tool 'viewSetOfSurfels' in file <basename>-cells-<gridstep>.txt, as specified by -o <basename>. Parameter <arg> is None|Normals|AngleDeviation. The color depends on the angle deviation in degree: 0 metallic blue, 5 light cyan, 10 light green, 15 light yellow, 20 yellow, 25 orange, 30 red, 35, dark red, 40- grey" )
("normals,n", "outputs every surfel, its estimated normal, and the ground truth normal in file <basename>-normals-<gridstep>.txt, as specified by -o <basename>." )
("noff,O","exports the digital surface with normals as NOFF file <basename>-noff-<gridstep>.off, as specified by -o <basename>.." )
#ifdef WITH_VISU3D_QGLVIEWER
("view,V", po::value<string>()->default_value( "None" ),"view the digital surface with normals. Parameter <arg> is None|Normals|AngleDeviation. The color depends on the angle deviation in degree: 0 metallic blue, 5 light cyan, 10 light green, 15 light yellow, 20 yellow, 25 orange, 30 red, 35, dark red, 40- grey." )
#endif
;
bool parseOK=true;
po::variables_map vm;
try{
po::store(po::parse_command_line(argc, argv, general_opt), vm);
}catch(const exception& ex){
parseOK=false;
cerr << "Error checking program options: "<< ex.what()<< endl;
}
po::notify(vm);
if( ! parseOK || vm.count("help") || ! vm.count( "polynomial" ) )
{
if ( ! vm.count( "polynomial" ) )
cerr << "Need parameter --polynomial / -p" << endl;
cerr << "Usage: " << argv[0] << " -p <polynomial> [options]\n"
<< "Computes a normal vector field over a digitized 3D implicit surface for several estimators (II|VCM|Trivial|True), specified with -e. You may add Kanungo noise with option -N. These estimators are compared with ground truth. You may then: 1) visualize the normals or the angle deviations with -V (if WITH_QGL_VIEWER is enabled), 2) outputs them as a list of cells/estimations with -n, 3) outputs them as a ImaGene file with -O, 4) outputs them as a NOFF file with -O, 5) computes estimation statistics with option -S."
<< endl
<< general_opt << "\n";
cerr << "Example:\n"
<< "./generic3dNormalEstimator -p \"90-3*x^2-2*y^2-z^2\" -o VCM-ellipse -a -10 -A 10 -e VCM -R 3 -r 3 -t 2 -E 0 -x Normals" << endl
<< " - ellipse : 90-3*x^2-2*y^2-z^2 " << endl
<< " - torus : -1*(x^2+y^2+z^2+6*6-2*2)^2+4*6*6*(x^2+y^2) " << endl
<< " - rcube : 6561-x^4-y^4-z^4" << endl
<< " - goursat : 8-0.03*x^4-0.03*y^4-0.03*z^4+2*x^2+2*y^2+2*z^2" << endl
<< " - distel : 10000-(x^2+y^2+z^2+1000*(x^2+y^2)*(x^2+z^2)*(y^2+z^2))" << endl
<< " - leopold : 100-(x^2*y^2*z^2+4*x^2+4*y^2+3*z^2)" << endl
<< " - diabolo : x^2-(y^2+z^2)^2" << endl
<< " - heart : -1*(x^2+2.25*y^2+z^2-1)^3+x^2*z^3+0.1125*y^2*z^3" << endl
<< " - crixxi : -0.9*(y^2+z^2-1)^2-(x^2+y^2-1)^3" << endl << endl;
cerr << "Estimators (specified by -e):" << endl
<< " - True : supposed to be the ground truth for computations. Of course, it is only approximations." << endl
<< " - VCM : normal estimator by digital Voronoi Covariance Matrix. Radii parameters are given by -R, -r." << endl
<< " - II : normal estimator by Integral Invariants. Radius parameter is given by -r." << endl
<< " - Trivial : the normal obtained by average trivial surfel normals in a ball neighborhood. Radius parameter is given by -r." << endl
<< endl;
cerr << "Note:" << endl
<< " - This is a normal *direction* evaluator more than a normal vector evaluator. Orientations of normals are deduced from ground truth. This is due to the fact that II and VCM only estimates normal directions." << endl
<< " - This tool only analyses one surface component, and one that contains at least as many surfels as the width of the digital bounding box. This is required when analysing noisy data, where a lot of the small components are spurious. The drawback is that you cannot analyse the normals on a surface with several components." << endl;
return 0;
}
trace.beginBlock( "Make implicit shape..." );
typedef Z3i::Space Space;
typedef double Scalar;
typedef MPolynomial< 3, Scalar > Polynomial3;
typedef MPolynomialReader<3, Scalar> Polynomial3Reader;
typedef ImplicitPolynomial3Shape<Space> ImplicitShape;
string poly_str = vm[ "polynomial" ].as<string>();
Polynomial3 poly;
Polynomial3Reader reader;
string::const_iterator iter = reader.read( poly, poly_str.begin(), poly_str.end() );
if ( iter != poly_str.end() )
{
trace.error() << "ERROR reading polynomial: I read only <" << poly_str.substr( 0, iter - poly_str.begin() )
<< ">, and I built P=" << poly << std::endl;
return 2;
}
CountedPtr<ImplicitShape> shape( new ImplicitShape( poly ) ); // smart pointer
trace.endBlock();
trace.beginBlock( "Make implicit digital shape..." );
typedef Z3i::KSpace KSpace;
typedef KSpace::Point Point;
typedef Space::RealPoint RealPoint;
typedef GaussDigitizer< Space, ImplicitShape > ImplicitDigitalShape;
typedef ImplicitDigitalShape::Domain Domain;
Scalar min_x = vm[ "minAABB" ].as<double>();
Scalar max_x = vm[ "maxAABB" ].as<double>();
Scalar h = vm[ "gridstep" ].as<double>();
RealPoint p1( min_x, min_x, min_x );
RealPoint p2( max_x, max_x, max_x );
CountedPtr<ImplicitDigitalShape> dshape( new ImplicitDigitalShape() );
dshape->attach( *shape );
dshape->init( p1, p2, h );
Domain domain = dshape->getDomain();
KSpace K;
K.init( domain.lowerBound(), domain.upperBound(), true );
trace.info() << "- domain is " << domain << std::endl;
trace.endBlock();
chooseSurface( vm, K, *shape, *dshape );
return 0;
}
int main( int argc, char** argv )
{
if ( argc < 9 )
{
usage( argc, argv );
return 1;
}
double p1[ 3 ];
double p2[ 3 ];
for ( unsigned int i = 0; i < 3; ++i )
{
p1[ i ] = atof( argv[ 2 + i ] );
p2[ i ] = atof( argv[ 5 + i ] );
}
double step = atof( argv[ 8 ] );
Polynomial3 P;
Polynomial3Reader reader;
std::string poly_str = argv[ 1 ];
std::string::const_iterator iter
= reader.read( P, poly_str.begin(), poly_str.end() );
if ( iter != poly_str.end() )
{
std::cerr << "ERROR: I read only <"
<< poly_str.substr( 0, iter - poly_str.begin() )
<< ">, and I built P=" << P << std::endl;
return 1;
}
ImplicitShape ishape( P );
DigitalShape dshape;
dshape.attach( ishape );
dshape.init( RealPointT( p1 ), RealPointT( p2 ), step );
Domain domain = dshape.getDomain();
KSpace K;
bool space_ok = K.init( domain.lowerBound(),
domain.upperBound(), true
);
if ( !space_ok )
{
trace.error() << "Error in the Khamisky space construction." << std::endl;
return 2;
}
typedef SurfelAdjacency< KSpace::dimension > MySurfelAdjacency;
MySurfelAdjacency surfAdj( true ); // interior in all directions.
typedef KSpace::Surfel Surfel;
typedef KSpace::SurfelSet SurfelSet;
typedef SetOfSurfels< KSpace, SurfelSet > MySetOfSurfels;
MySetOfSurfels theSetOfSurfels( K, surfAdj );
Surfel bel = Surfaces< KSpace >::findABel( K, dshape, 100000 );
Surfaces< KSpace >::trackBoundary( theSetOfSurfels.surfelSet(),
K, surfAdj,
dshape, bel );
QApplication application( argc, argv );
Viewer3D<> viewer;
viewer.show();
viewer << SetMode3D( domain.className(), "BoundingBox" ) << domain;
//-----------------------------------------------------------------------
// Looking for the min and max values
double minCurv = 1;
double maxCurv = 0;
CanonicSCellEmbedder< KSpace > midpoint( K );
for ( std::set< SCell >::iterator it = theSetOfSurfels.begin(), it_end = theSetOfSurfels.end();
it != it_end; ++it)
{
RealPointT A = midpoint( *it ) * step;
A = ishape.nearestPoint (A,0.01,200,0.1*step);
double a = ishape.meanCurvature( A );
// double a=ishape.gaussianCurvature(A);
if ( !boost::math::isnan( a ))
{
if ( a > maxCurv )
{
maxCurv = a;
}
else
if ( a < minCurv )
{
minCurv = a;
}
}
}
trace.info() << " Min = " << minCurv << std::endl;
trace.info() << " Max = " << maxCurv << std::endl;
//-----------------------------------------------------------------------
//Specifing a color map
GradientColorMap< double > cmap_grad( minCurv, maxCurv );
cmap_grad.addColor( Color( 50, 50, 255 ) );
cmap_grad.addColor( Color( 255, 0, 0 ) );
cmap_grad.addColor( Color( 255, 255, 10 ) );
//------------------------------------------------------------------------------------
//drawing
unsigned int nbSurfels = 0;
for ( std::set<SCell>::iterator it = theSetOfSurfels.begin(),
it_end = theSetOfSurfels.end();
it != it_end; ++it, ++nbSurfels )
{
RealPointT A = midpoint( *it ) * step;
A = ishape.nearestPoint (A,0.01,200,0.1*step);
// double a=ishape.gaussianCurvature(A);
double a = ishape.meanCurvature( A );
if ( boost::math::isnan( a ))
{
a = 0;
}
viewer << CustomColors3D( Color::Black, cmap_grad( a ));
viewer << *it;
}
viewer << Viewer3D<>::updateDisplay;
return application.exec();
}
