Loading [MathJax]/extensions/TeX/AMSsymbols.js
DGtal 2.0.0
ShortcutsGeometry.h
1
16
17#pragma once
18
30
31#if defined(ShortcutsGeometry_RECURSES)
32#error Recursive header files inclusion detected in ShortcutsGeometry.h
33#else // defined(ShortcutsGeometry_RECURSES)
35#define ShortcutsGeometry_RECURSES
36
37#if !defined ShortcutsGeometry_h
39#define ShortcutsGeometry_h
40
42#include "DGtal/helpers/Shortcuts.h"
43#include "DGtal/geometry/volumes/distance/LpMetric.h"
44#include "DGtal/geometry/volumes/distance/ExactPredicateLpSeparableMetric.h"
45#include "DGtal/geometry/surfaces/estimation/TrueDigitalSurfaceLocalEstimator.h"
46#include "DGtal/geometry/surfaces/estimation/VoronoiCovarianceMeasureOnDigitalSurface.h"
47#include "DGtal/geometry/surfaces/estimation/VCMDigitalSurfaceLocalEstimator.h"
48#include "DGtal/geometry/surfaces/estimation/IIGeometricFunctors.h"
49#include "DGtal/geometry/surfaces/estimation/IntegralInvariantVolumeEstimator.h"
50#include "DGtal/geometry/surfaces/estimation/IntegralInvariantCovarianceEstimator.h"
51#include "DGtal/geometry/meshes/CorrectedNormalCurrentComputer.h"
52
53#include "DGtal/dec/DiscreteExteriorCalculusFactory.h"
54#include "DGtal/dec/ATSolver2D.h"
56
57namespace DGtal
58{
59
60 namespace sgf = ::DGtal::functors::ShapeGeometricFunctors;
61
63 // template class ShortcutsGeometry
74 template < typename TKSpace >
75 class ShortcutsGeometry : public Shortcuts< TKSpace >
76 {
78 public:
82 using Base::getKSpace;
84
85 // ----------------------- Usual space types --------------------------------------
86 public:
87
89 typedef TKSpace KSpace;
91 typedef typename KSpace::Space Space;
93 typedef typename Space::Integer Integer;
95 typedef typename Space::Point Point;
97 typedef typename Space::Vector Vector;
99 typedef typename Space::RealVector RealVector;
101 typedef typename Space::RealPoint RealPoint;
107 typedef unsigned char GrayScale;
108
109 // ----------------------- Shortcut types --------------------------------------
110 public:
127 typedef typename KSpace::SurfelSet SurfelSet;
132 typedef ::DGtal::DigitalSurface< LightSurfaceContainer > LightDigitalSurface;
136 typedef ::DGtal::DigitalSurface< ExplicitSurfaceContainer > DigitalSurface;
143 typedef typename LightDigitalSurface::Arc Arc;
144 typedef typename LightDigitalSurface::Face Face;
150 typedef std::set< IdxSurfel > IdxSurfelSet;
151 typedef std::vector< Surfel > SurfelRange;
152 typedef std::vector< Cell > CellRange;
153 typedef std::vector< IdxSurfel > IdxSurfelRange;
154 typedef std::vector< Scalar > Scalars;
155 typedef std::vector< RealVector > RealVectors;
156 typedef std::vector< RealPoint > RealPoints;
157
158 typedef ::DGtal::Statistic<Scalar> ScalarStatistic;
159
160 typedef sgf::ShapePositionFunctor<ImplicitShape3D> PositionFunctor;
161 typedef sgf::ShapeNormalVectorFunctor<ImplicitShape3D> NormalFunctor;
162 typedef sgf::ShapeMeanCurvatureFunctor<ImplicitShape3D> MeanCurvatureFunctor;
163 typedef sgf::ShapeGaussianCurvatureFunctor<ImplicitShape3D> GaussianCurvatureFunctor;
164 typedef sgf::ShapeFirstPrincipalCurvatureFunctor<ImplicitShape3D> FirstPrincipalCurvatureFunctor;
165 typedef sgf::ShapeSecondPrincipalCurvatureFunctor<ImplicitShape3D> SecondPrincipalCurvatureFunctor;
166 typedef sgf::ShapeFirstPrincipalDirectionFunctor<ImplicitShape3D> FirstPrincipalDirectionFunctor;
167 typedef sgf::ShapeSecondPrincipalDirectionFunctor<ImplicitShape3D> SecondPrincipalDirectionFunctor;
168 typedef sgf::ShapePrincipalCurvaturesAndDirectionsFunctor<ImplicitShape3D> PrincipalCurvaturesAndDirectionsFunctor;
169
171 typedef std::vector< CurvatureTensorQuantity > CurvatureTensorQuantities;
172
174
193
194 typedef ::DGtal::Mesh<RealPoint> Mesh;
195 typedef ::DGtal::TriangulatedSurface<RealPoint> TriangulatedSurface;
196 typedef ::DGtal::PolygonalSurface<RealPoint> PolygonalSurface;
197 typedef std::map<Surfel, IdxSurfel> Surfel2Index;
198 typedef std::map<Cell, IdxVertex> Cell2Index;
199
200 // ----------------------- Static services --------------------------------------
201 public:
202
203 // ----------------------- Exact geometry services ------------------------------
206 public:
207
215
223 {
224 return Parameters
225 ( "projectionMaxIter", 20 )
226 ( "projectionAccuracy", 0.0001 )
227 ( "projectionGamma", 0.5 )
228 ( "gridstep", 1.0 );
229 }
230
249 static RealPoints
252 const KSpace& K,
253 const SurfelRange& surfels,
254 const Parameters& params = parametersShapeGeometry() )
255 {
256 RealVectors n_true_estimations;
257 TruePositionEstimator true_estimator;
258 int maxIter = params[ "projectionMaxIter" ].as<int>();
259 double accuracy = params[ "projectionAccuracy" ].as<double>();
260 double gamma = params[ "projectionGamma" ].as<double>();
261 Scalar gridstep = params[ "gridstep" ].as<Scalar>();
262 true_estimator.attach( *shape );
263 true_estimator.setParams( K, PositionFunctor(), maxIter, accuracy, gamma );
264 true_estimator.init( gridstep, surfels.begin(), surfels.end() );
265 true_estimator.eval( surfels.begin(), surfels.end(),
266 std::back_inserter( n_true_estimations ) );
267 return n_true_estimations;
268 }
269
283 static RealPoints
286 const RealPoints& points,
287 const Parameters& params = parametersShapeGeometry() )
288 {
289 RealPoints proj_points( points.size() );
290 int maxIter = params[ "projectionMaxIter" ].as<int>();
291 double accuracy = params[ "projectionAccuracy" ].as<double>();
292 double gamma = params[ "projectionGamma" ].as<double>();
293 for ( unsigned int i = 0; i < points.size(); ++i )
294 proj_points[ i ] = shape->nearestPoint( points[ i ], accuracy,
295 maxIter, gamma );
296 return proj_points;
297 }
298
317 static RealVectors
320 const KSpace& K,
321 const SurfelRange& surfels,
322 const Parameters& params = parametersShapeGeometry() )
323 {
324 RealVectors n_true_estimations;
325 TrueNormalEstimator true_estimator;
326 int maxIter = params[ "projectionMaxIter" ].as<int>();
327 double accuracy = params[ "projectionAccuracy" ].as<double>();
328 double gamma = params[ "projectionGamma" ].as<double>();
329 Scalar gridstep = params[ "gridstep" ].as<Scalar>();
330 true_estimator.attach( *shape );
331 true_estimator.setParams( K, NormalFunctor(), maxIter, accuracy, gamma );
332 true_estimator.init( gridstep, surfels.begin(), surfels.end() );
333 true_estimator.eval( surfels.begin(), surfels.end(),
334 std::back_inserter( n_true_estimations ) );
335 return n_true_estimations;
336 }
337
356 static Scalars
359 const KSpace& K,
360 const SurfelRange& surfels,
361 const Parameters& params = parametersShapeGeometry() )
362 {
363 Scalars n_true_estimations;
364 TrueMeanCurvatureEstimator true_estimator;
365 int maxIter = params[ "projectionMaxIter" ].as<int>();
366 double accuracy = params[ "projectionAccuracy" ].as<double>();
367 double gamma = params[ "projectionGamma" ].as<double>();
368 Scalar gridstep = params[ "gridstep" ].as<Scalar>();
369 true_estimator.attach( *shape );
370 true_estimator.setParams( K, MeanCurvatureFunctor(), maxIter, accuracy, gamma );
371 true_estimator.init( gridstep, surfels.begin(), surfels.end() );
372 true_estimator.eval( surfels.begin(), surfels.end(),
373 std::back_inserter( n_true_estimations ) );
374 return n_true_estimations;
375 }
376
391 static Scalars
394 const typename Base::SurfaceMesh::Faces faces,
395 const Parameters& params = parametersShapeGeometry() )
396 {
397 using Face = typename Base::SurfaceMesh::Face;
398
399 bool unit_u = params["unit_u"].as<int>();
400 double radius = params["r-radius"].as<double>();
401 double alpha = params["alpha"].as<double>();
402 double h = params["gridstep"].as<double>();
403 if ( alpha != 1.0 ) radius *= pow( h, alpha-1.0 );
404
405 CNCComputer computer(*mesh, unit_u);
406
407 const auto& mu0 = computer.computeMu0();
408 const auto& mu1 = computer.computeMu1();
409
410 Scalars curvatures(faces.size());
411 for (size_t i = 0; i < faces.size(); ++i)
412 {
413 const auto center = mesh->faceCentroid(faces[i]);
414 const auto area = mu0.measure(center, radius, faces[i]);
415 const auto lmu1 = mu1.measure(center, radius, faces[i]);
416 curvatures[i] = CNCComputer::meanCurvature(area, lmu1);
417 }
418
419 return curvatures;
420 }
421
443 const Parameters & params = parametersShapeGeometry() )
444 {
445 std::vector<typename Base::SurfaceMesh::Face> allFaces(mesh->nbFaces());
446 std::iota(allFaces.begin(), allFaces.end(), 0);
447
448 return getCNCMeanCurvatures(mesh, allFaces, params);
449 }
450
469 template <typename T>
471 T & digitalObject, const Parameters & params = parametersShapeGeometry() )
472 {
474 return getCNCMeanCurvatures(mesh, params);
475 }
476
496 static Scalars
499 const KSpace& K,
500 const SurfelRange& surfels,
501 const Parameters& params = parametersShapeGeometry() )
502 {
503 Scalars n_true_estimations;
504 TrueGaussianCurvatureEstimator true_estimator;
505 int maxIter = params[ "projectionMaxIter" ].as<int>();
506 double accuracy = params[ "projectionAccuracy" ].as<double>();
507 double gamma = params[ "projectionGamma" ].as<double>();
508 Scalar gridstep = params[ "gridstep" ].as<Scalar>();
509 true_estimator.attach( *shape );
510 true_estimator.setParams( K, GaussianCurvatureFunctor(), maxIter, accuracy, gamma );
511 true_estimator.init( gridstep, surfels.begin(), surfels.end() );
512 true_estimator.eval( surfels.begin(), surfels.end(),
513 std::back_inserter( n_true_estimations ) );
514 return n_true_estimations;
515 }
516
537 const typename Base::SurfaceMesh::Faces & faces,
538 const Parameters & params = parametersShapeGeometry() )
539 {
540 using Face = typename Base::SurfaceMesh::Face;
541
542 bool unit_u = params["unit_u"].as<int>();
543 double radius = params["r-radius"].as<double>();
544 double alpha = params["alpha"].as<double>();
545 double h = params["gridstep"].as<double>();
546 if ( alpha != 1.0 ) radius *= pow( h, alpha-1.0 );
547
548 CNCComputer computer(*mesh, unit_u);
549
550 const auto& mu0 = computer.computeMu0();
551 const auto& mu2 = computer.computeMu2();
552
553 Scalars curvatures(faces.size());
554 for (size_t i = 0; i < faces.size(); ++i)
555 {
556 const auto center = mesh->faceCentroid(faces[i]);
557 const auto area = mu0.measure(center, radius, faces[i]);
558 const auto lmu2 = mu2.measure(center, radius, faces[i]);
559 curvatures[i] = CNCComputer::GaussianCurvature(area, lmu2);
560 }
561
562 return curvatures;
563 }
564
586 const Parameters & params = parametersShapeGeometry() )
587 {
588 std::vector<typename Base::SurfaceMesh::Face> allFaces(mesh->nbFaces());
589 std::iota(allFaces.begin(), allFaces.end(), 0);
590
591 return getCNCGaussianCurvatures(mesh, allFaces, params);
592 }
593
612 template <typename T>
614 T & digitalObject, const Parameters & params = parametersShapeGeometry() )
615 {
617 return getCNCGaussianCurvatures(mesh, params);
618 }
619
638 static Scalars
641 const KSpace& K,
642 const SurfelRange& surfels,
643 const Parameters& params = parametersShapeGeometry() )
644 {
645 Scalars n_true_estimations;
647 int maxIter = params[ "projectionMaxIter" ].as<int>();
648 double accuracy = params[ "projectionAccuracy" ].as<double>();
649 double gamma = params[ "projectionGamma" ].as<double>();
650 Scalar gridstep = params[ "gridstep" ].as<Scalar>();
651 true_estimator.attach( *shape );
652 true_estimator.setParams( K, FirstPrincipalCurvatureFunctor(),
653 maxIter, accuracy, gamma );
654 true_estimator.init( gridstep, surfels.begin(), surfels.end() );
655 true_estimator.eval( surfels.begin(), surfels.end(),
656 std::back_inserter( n_true_estimations ) );
657 return n_true_estimations;
658 }
659
680 static Scalars
683 const KSpace& K,
684 const SurfelRange& surfels,
685 const Parameters& params = parametersShapeGeometry() )
686 {
687 Scalars n_true_estimations;
689 int maxIter = params[ "projectionMaxIter" ].as<int>();
690 double accuracy = params[ "projectionAccuracy" ].as<double>();
691 double gamma = params[ "projectionGamma" ].as<double>();
692 Scalar gridstep = params[ "gridstep" ].as<Scalar>();
693 true_estimator.attach( *shape );
695 maxIter, accuracy, gamma );
696 true_estimator.init( gridstep, surfels.begin(), surfels.end() );
697 true_estimator.eval( surfels.begin(), surfels.end(),
698 std::back_inserter( n_true_estimations ) );
699 return n_true_estimations;
700 }
701
722 static RealVectors
725 const KSpace& K,
726 const SurfelRange& surfels,
727 const Parameters& params = parametersShapeGeometry() )
728 {
729 RealVectors n_true_estimations;
731 int maxIter = params[ "projectionMaxIter" ].as<int>();
732 double accuracy = params[ "projectionAccuracy" ].as<double>();
733 double gamma = params[ "projectionGamma" ].as<double>();
734 Scalar gridstep = params[ "gridstep" ].as<Scalar>();
735 true_estimator.attach( *shape );
736 true_estimator.setParams( K, FirstPrincipalDirectionFunctor(),
737 maxIter, accuracy, gamma );
738 true_estimator.init( gridstep, surfels.begin(), surfels.end() );
739 true_estimator.eval( surfels.begin(), surfels.end(),
740 std::back_inserter( n_true_estimations ) );
741 return n_true_estimations;
742 }
743
764 static RealVectors
767 const KSpace& K,
768 const SurfelRange& surfels,
769 const Parameters& params = parametersShapeGeometry() )
770 {
771 RealVectors n_true_estimations;
773 int maxIter = params[ "projectionMaxIter" ].as<int>();
774 double accuracy = params[ "projectionAccuracy" ].as<double>();
775 double gamma = params[ "projectionGamma" ].as<double>();
776 Scalar gridstep = params[ "gridstep" ].as<Scalar>();
777 true_estimator.attach( *shape );
779 maxIter, accuracy, gamma );
780 true_estimator.init( gridstep, surfels.begin(), surfels.end() );
781 true_estimator.eval( surfels.begin(), surfels.end(),
782 std::back_inserter( n_true_estimations ) );
783 return n_true_estimations;
784 }
785
810 const KSpace& K,
811 const SurfelRange& surfels,
812 const Parameters& params = parametersShapeGeometry() )
813 {
814 CurvatureTensorQuantities n_true_estimations;
816 int maxIter = params[ "projectionMaxIter" ].as<int>();
817 double accuracy = params[ "projectionAccuracy" ].as<double>();
818 double gamma = params[ "projectionGamma" ].as<double>();
819 Scalar gridstep = params[ "gridstep" ].as<Scalar>();
820 true_estimator.attach( *shape );
822 maxIter, accuracy, gamma );
823 true_estimator.init( gridstep, surfels.begin(), surfels.end() );
824 true_estimator.eval( surfels.begin(), surfels.end(),
825 std::back_inserter( n_true_estimations ) );
826 return n_true_estimations;
827 }
828
853 static std::tuple<Scalars, Scalars, RealVectors, RealVectors>
856 const typename Base::SurfaceMesh::Faces& faces,
857 const Parameters& params = parametersShapeGeometry() )
858 {
859 using Face = typename Base::SurfaceMesh::Face;
860
861 bool unit_u = params["unit_u"].as<int>();
862 double radius = params["r-radius"].as<double>();
863 double alpha = params["alpha"].as<double>();
864 double h = params["gridstep"].as<double>();
865 if ( alpha != 1.0 ) radius *= pow( h, alpha-1.0 );
866
867 CNCComputer computer(*mesh, unit_u);
868
869 const auto& mu0 = computer.computeMu0();
870 const auto& muxy = computer.computeMuXY();
871
872 if (mesh->faceNormals().size() == 0)
873 {
874 // Try to use vertex normals if any
875 if (mesh->vertexNormals().size() == 0)
876 mesh->computeFaceNormalsFromPositions();
877 else
878 mesh->computeFaceNormalsFromVertexNormals();
879 }
880
881 const auto& normals = mesh->faceNormals();
882
883 Scalars k1(faces.size()), k2(faces.size());
884 RealVectors d1(faces.size()), d2(faces.size());
885
886 for (size_t i = 0; i < faces.size(); ++i)
887 {
888 const auto center = mesh->faceCentroid(faces[i]);
889 const auto area = mu0 .measure(center, radius, faces[i]);
890 const auto lmuxy = muxy.measure(center, radius, faces[i]);
891 std::tie(k1[i], k2[i], d1[i], d2[i]) =
892 CNCComputer::principalCurvatures(area, lmuxy, normals[faces[i]]);
893 }
894
895 return std::make_tuple(k1, k2, d1, d2);
896 }
897
923 static std::tuple<Scalars, Scalars, RealVectors, RealVectors>
926 const Parameters & params = parametersShapeGeometry() )
927 {
928 std::vector<typename Base::SurfaceMesh::Face> allFaces(mesh->nbFaces());
929 std::iota(allFaces.begin(), allFaces.end(), 0);
930
931 return getCNCPrincipalCurvaturesAndDirections(mesh, allFaces, params);
932 }
933
953 template <typename T>
954 static std::tuple<Scalars, Scalars, RealVectors, RealVectors>
956 T & digitalObject,
957 const Parameters & params = parametersShapeGeometry() )
958 {
960 return getCNCPrincipalCurvaturesAndDirections(mesh, params);
961 }
962
963
964 // --------------------------- geometry estimation ------------------------------
967 public:
968
980 {
981 return Parameters
982 ( "verbose", 1 )
983 ( "t-ring", 3.0 )
984 ( "kernel", "hat" )
985 ( "R-radius", 10.0 )
986 ( "r-radius", 3.0 )
987 ( "alpha", 0.33 )
988 ( "surfelEmbedding", 0 )
989 ( "unit_u" , 0 );
990 }
991
1001 static RealVectors
1003 const SurfelRange& surfels )
1004 {
1005 std::vector< RealVector > result;
1006 for ( auto s : surfels )
1007 {
1008 Dimension k = K.sOrthDir( s );
1009 bool direct = K.sDirect( s, k );
1011 t[ k ] = direct ? -1.0 : 1.0;
1012 result.push_back( t );
1013 }
1014 return result;
1015 }
1016
1032 template <typename TAnyDigitalSurface>
1033 static RealVectors
1036 const SurfelRange& surfels,
1037 const Parameters& params = parametersGeometryEstimation() )
1038 {
1039 int verbose = params[ "verbose" ].as<int>();
1040 Scalar t = params[ "t-ring" ].as<double>();
1041 typedef typename TAnyDigitalSurface::DigitalSurfaceContainer SurfaceContainer;
1042 typedef LpMetric<Space> Metric;
1045 < Surfel, CanonicSCellEmbedder<KSpace> > SurfelFunctor;
1047 < SurfaceContainer, Metric, SurfelFunctor, Functor> NormalEstimator;
1048 if ( verbose > 0 )
1049 trace.info() << "- CTrivial normal t-ring=" << t << " (discrete)" << std::endl;
1050 const Functor fct( 1.0, t );
1051 const KSpace & K = surface->container().space();
1052 Metric aMetric( 2.0 );
1053 CanonicSCellEmbedder<KSpace> canonic_embedder( K );
1054 std::vector< RealVector > n_estimations;
1055 SurfelFunctor surfelFct( canonic_embedder, 1.0 );
1056 NormalEstimator estimator;
1057 estimator.attach( *surface);
1058 estimator.setParams( aMetric, surfelFct, fct, t );
1059 estimator.init( 1.0, surfels.begin(), surfels.end());
1060 estimator.eval( surfels.begin(), surfels.end(),
1061 std::back_inserter( n_estimations ) );
1062 std::transform( n_estimations.cbegin(), n_estimations.cend(), n_estimations.begin(),
1063 [] ( RealVector v ) { return -v; } );
1064 return n_estimations;
1065 }
1066
1088 template <typename TAnyDigitalSurface>
1089 static RealVectors
1092 const SurfelRange& surfels,
1093 const Parameters& params = parametersGeometryEstimation() )
1094 {
1096 typedef typename TAnyDigitalSurface::DigitalSurfaceContainer SurfaceContainer;
1097 RealVectors n_estimations;
1098 int verbose = params[ "verbose" ].as<int>();
1099 std::string kernel = params[ "kernel" ].as<std::string>();
1100 Scalar h = params[ "gridstep" ].as<Scalar>();
1101 Scalar R = params[ "R-radius" ].as<Scalar>();
1102 Scalar r = params[ "r-radius" ].as<Scalar>();
1103 Scalar t = params[ "t-ring" ].as<Scalar>();
1104 Scalar alpha = params[ "alpha" ].as<Scalar>();
1105 int embedding = params[ "embedding" ].as<int>();
1106 // Adjust parameters according to gridstep if specified.
1107 if ( alpha != 1.0 ) R *= pow( h, alpha-1.0 );
1108 if ( alpha != 1.0 ) r *= pow( h, alpha-1.0 );
1109 Surfel2PointEmbedding embType = embedding == 0 ? Pointels :
1110 embedding == 1 ? InnerSpel : OuterSpel;
1111 if ( verbose > 0 )
1112 {
1113 trace.info() << "- VCM normal kernel=" << kernel << " emb=" << embedding
1114 << " alpha=" << alpha << std::endl;
1115 trace.info() << "- VCM normal r=" << (r*h) << " (continuous) "
1116 << r << " (discrete)" << std::endl;
1117 trace.info() << "- VCM normal R=" << (R*h) << " (continuous) "
1118 << R << " (discrete)" << std::endl;
1119 trace.info() << "- VCM normal t=" << t << " (discrete)" << std::endl;
1120 }
1121 if ( kernel == "hat" )
1122 {
1123 typedef functors::HatPointFunction<Point,Scalar> KernelFunction;
1125 < SurfaceContainer, Metric, KernelFunction > VCMOnSurface;
1128 < SurfaceContainer, Metric, KernelFunction, NormalVFunctor> VCMNormalEstimator;
1129 KernelFunction chi_r( 1.0, r );
1130 VCMNormalEstimator estimator;
1131 estimator.attach( *surface );
1132 estimator.setParams( embType, R, r, chi_r, t, Metric(), verbose > 0 );
1133 estimator.init( h, surfels.begin(), surfels.end() );
1134 estimator.eval( surfels.begin(), surfels.end(),
1135 std::back_inserter( n_estimations ) );
1136 }
1137 else if ( kernel == "ball" )
1138 {
1141 < SurfaceContainer, Metric, KernelFunction > VCMOnSurface;
1144 < SurfaceContainer, Metric, KernelFunction, NormalVFunctor> VCMNormalEstimator;
1145 KernelFunction chi_r( 1.0, r );
1146 VCMNormalEstimator estimator;
1147 estimator.attach( *surface );
1148 estimator.setParams( embType, R, r, chi_r, t, Metric(), verbose > 0 );
1149 estimator.init( h, surfels.begin(), surfels.end() );
1150 estimator.eval( surfels.begin(), surfels.end(),
1151 std::back_inserter( n_estimations ) );
1152 }
1153 else
1154 {
1155 trace.warning() << "[ShortcutsGeometry::getVCMNormalVectors] Unknown kernel: "
1156 << kernel << std::endl;
1157 }
1158 return n_estimations;
1159 }
1160
1183 static RealVectors
1185 const SurfelRange& surfels,
1186 const Parameters& params
1188 | parametersKSpace() )
1189 {
1190 auto K = getKSpace( bimage, params );
1191 return getIINormalVectors( *bimage, K, surfels, params );
1192 }
1193
1223 static RealVectors
1225 const SurfelRange& surfels,
1226 const Parameters& params
1230 {
1231 auto K = getKSpace( params );
1232 return getIINormalVectors( *dshape, K, surfels, params );
1233 }
1234
1259 template <typename TPointPredicate>
1260 static RealVectors
1261 getIINormalVectors( const TPointPredicate& shape,
1262 const KSpace& K,
1263 const SurfelRange& surfels,
1264 const Parameters& params
1266 | parametersKSpace() )
1267 {
1268 typedef functors::IINormalDirectionFunctor<Space> IINormalFunctor;
1270 <KSpace, TPointPredicate, IINormalFunctor> IINormalEstimator;
1271
1272 RealVectors n_estimations;
1273 int verbose = params[ "verbose" ].as<int>();
1274 Scalar h = params[ "gridstep" ].as<Scalar>();
1275 Scalar r = params[ "r-radius" ].as<Scalar>();
1276 Scalar alpha = params[ "alpha" ].as<Scalar>();
1277 if ( alpha != 1.0 ) r *= pow( h, alpha-1.0 );
1278 if ( verbose > 0 )
1279 {
1280 trace.info() << "- II normal alpha=" << alpha << std::endl;
1281 trace.info() << "- II normal r=" << (r*h) << " (continuous) "
1282 << r << " (discrete)" << std::endl;
1283 }
1284 IINormalFunctor functor;
1285 functor.init( h, r*h );
1286 IINormalEstimator ii_estimator( functor );
1287 ii_estimator.attach( K, shape );
1288 ii_estimator.setParams( r );
1289 ii_estimator.init( h, surfels.begin(), surfels.end() );
1290 ii_estimator.eval( surfels.begin(), surfels.end(),
1291 std::back_inserter( n_estimations ) );
1292 const RealVectors n_trivial = getTrivialNormalVectors( K, surfels );
1293 orientVectors( n_estimations, n_trivial );
1294 return n_estimations;
1295 }
1296
1297
1316 static Scalars
1318 const SurfelRange& surfels,
1319 const Parameters& params
1321 | parametersKSpace() )
1322 {
1323 auto K = getKSpace( bimage, params );
1324 return getIIMeanCurvatures( *bimage, K, surfels, params );
1325 }
1326
1352 static Scalars
1354 const SurfelRange& surfels,
1355 const Parameters& params
1359 {
1360 auto K = getKSpace( params );
1361 return getIIMeanCurvatures( *dshape, K, surfels, params );
1362 }
1363
1364
1386 template <typename TPointPredicate>
1387 static Scalars
1388 getIIMeanCurvatures( const TPointPredicate& shape,
1389 const KSpace& K,
1390 const SurfelRange& surfels,
1391 const Parameters& params
1393 | parametersKSpace() )
1394 {
1395 typedef functors::IIMeanCurvature3DFunctor<Space> IIMeanCurvFunctor;
1397 <KSpace, TPointPredicate, IIMeanCurvFunctor> IIMeanCurvEstimator;
1398
1399 Scalars mc_estimations;
1400 int verbose = params[ "verbose" ].as<int>();
1401 Scalar h = params[ "gridstep" ].as<Scalar>();
1402 Scalar r = params[ "r-radius" ].as<Scalar>();
1403 Scalar alpha = params[ "alpha" ].as<Scalar>();
1404 if ( alpha != 1.0 ) r *= pow( h, alpha-1.0 );
1405 if ( verbose > 0 )
1406 {
1407 trace.info() << "- II mean curvature alpha=" << alpha << std::endl;
1408 trace.info() << "- II mean curvature r=" << (r*h) << " (continuous) "
1409 << r << " (discrete)" << std::endl;
1410 }
1411 IIMeanCurvFunctor functor;
1412 functor.init( h, r*h );
1413 IIMeanCurvEstimator ii_estimator( functor );
1414 ii_estimator.attach( K, shape );
1415 ii_estimator.setParams( r );
1416 ii_estimator.init( h, surfels.begin(), surfels.end() );
1417 ii_estimator.eval( surfels.begin(), surfels.end(),
1418 std::back_inserter( mc_estimations ) );
1419 return mc_estimations;
1420 }
1421
1440 static Scalars
1442 const SurfelRange& surfels,
1443 const Parameters& params
1445 | parametersKSpace() )
1446 {
1447 auto K = getKSpace( bimage, params );
1448 return getIIGaussianCurvatures( *bimage, K, surfels, params );
1449 }
1450
1476 static Scalars
1478 const SurfelRange& surfels,
1479 const Parameters& params
1483 {
1484 auto K = getKSpace( params );
1485 return getIIGaussianCurvatures( *dshape, K, surfels, params );
1486 }
1487
1488
1510 template <typename TPointPredicate>
1511 static Scalars
1512 getIIGaussianCurvatures( const TPointPredicate& shape,
1513 const KSpace& K,
1514 const SurfelRange& surfels,
1515 const Parameters& params
1517 | parametersKSpace() )
1518 {
1519 typedef functors::IIGaussianCurvature3DFunctor<Space> IIGaussianCurvFunctor;
1521 <KSpace, TPointPredicate, IIGaussianCurvFunctor> IIGaussianCurvEstimator;
1522
1523 Scalars mc_estimations;
1524 int verbose = params[ "verbose" ].as<int>();
1525 Scalar h = params[ "gridstep" ].as<Scalar>();
1526 Scalar r = params[ "r-radius" ].as<Scalar>();
1527 Scalar alpha = params[ "alpha" ].as<Scalar>();
1528 if ( alpha != 1.0 ) r *= pow( h, alpha-1.0 );
1529 if ( verbose > 0 )
1530 {
1531 trace.info() << "- II Gaussian curvature alpha=" << alpha << std::endl;
1532 trace.info() << "- II Gaussian curvature r=" << (r*h) << " (continuous) "
1533 << r << " (discrete)" << std::endl;
1534 }
1535 IIGaussianCurvFunctor functor;
1536 functor.init( h, r*h );
1537 IIGaussianCurvEstimator ii_estimator( functor );
1538 ii_estimator.attach( K, shape );
1539 ii_estimator.setParams( r );
1540 ii_estimator.init( h, surfels.begin(), surfels.end() );
1541 ii_estimator.eval( surfels.begin(), surfels.end(),
1542 std::back_inserter( mc_estimations ) );
1543 return mc_estimations;
1544 }
1545
1567 const SurfelRange& surfels,
1568 const Parameters& params
1570 | parametersKSpace() )
1571 {
1572 auto K = getKSpace( bimage, params );
1573 return getIIPrincipalCurvaturesAndDirections( *bimage, K, surfels, params );
1574 }
1575
1604 const SurfelRange& surfels,
1605 const Parameters& params
1609 {
1610 auto K = getKSpace( params );
1611 return getIIPrincipalCurvaturesAndDirections( *dshape, K, surfels, params );
1612 }
1613
1614
1636 template <typename TPointPredicate>
1638 getIIPrincipalCurvaturesAndDirections( const TPointPredicate& shape,
1639 const KSpace& K,
1640 const SurfelRange& surfels,
1641 const Parameters& params
1643 | parametersKSpace() )
1644 {
1647
1648 CurvatureTensorQuantities mc_estimations;
1649 int verbose = params[ "verbose" ].as<int>();
1650 Scalar h = params[ "gridstep" ].as<Scalar>();
1651 Scalar r = params[ "r-radius" ].as<Scalar>();
1652 Scalar alpha = params[ "alpha" ].as<Scalar>();
1653 if ( alpha != 1.0 ) r *= pow( h, alpha-1.0 );
1654 if ( verbose > 0 )
1655 {
1656 trace.info() << "- II principal curvatures and directions alpha=" << alpha << std::endl;
1657 trace.info() << "- II principal curvatures and directions r=" << (r*h) << " (continuous) "
1658 << r << " (discrete)" << std::endl;
1659 }
1660 IICurvFunctor functor;
1661 functor.init( h, r*h );
1662 IICurvEstimator ii_estimator( functor );
1663 ii_estimator.attach( K, shape );
1664 ii_estimator.setParams( r );
1665 ii_estimator.init( h, surfels.begin(), surfels.end() );
1666 ii_estimator.eval( surfels.begin(), surfels.end(),
1667 std::back_inserter( mc_estimations ) );
1668 return mc_estimations;
1669 }
1670
1672
1673 // --------------------------- AT approximation ------------------------------
1676 public:
1677
1691 {
1692 return Parameters
1693 ( "at-enabled", 1 )
1694 ( "at-alpha", 0.1 )
1695 ( "at-lambda", 0.025 )
1696 ( "at-epsilon", 0.25 )
1697 ( "at-epsilon-start", 2.0 )
1698 ( "at-epsilon-ratio", 2.0 )
1699 ( "at-max-iter", 10 )
1700 ( "at-diff-v-max", 0.0001 )
1701 ( "at-v-policy", "Maximum" );
1702 }
1703
1726 template <typename TAnyDigitalSurface,
1727 typename VectorFieldInput>
1728 static
1729 VectorFieldInput
1731 const SurfelRange& surfels,
1732 const VectorFieldInput& input,
1733 const Parameters& params
1735 {
1736 (void)surface; //param not used. FIXME: JOL
1737
1738 int verbose = params[ "verbose" ].as<int>();
1739 Scalar alpha_at = params[ "at-alpha" ].as<Scalar>();
1740 Scalar lambda_at = params[ "at-lambda" ].as<Scalar>();
1741 Scalar epsilon1 = params[ "at-epsilon-start" ].as<Scalar>();
1742 Scalar epsilon2 = params[ "at-epsilon" ].as<Scalar>();
1743 Scalar epsilonr = params[ "at-epsilon-ratio" ].as<Scalar>();
1744 int max_iter = params[ "at-max-iter" ].as<int>();
1745 Scalar diff_v_max= params[ "at-diff-v-max" ].as<Scalar>();
1747 const auto calculus = CalculusFactory::createFromNSCells<2>( surfels.cbegin(), surfels.cend() );
1748 ATSolver2D< KSpace > at_solver( calculus, verbose );
1749 at_solver.initInputVectorFieldU2( input, surfels.cbegin(), surfels.cend() );
1750 at_solver.setUp( alpha_at, lambda_at );
1751 at_solver.solveGammaConvergence( epsilon1, epsilon2, epsilonr, false, diff_v_max, max_iter );
1752 auto output = input;
1753 at_solver.getOutputVectorFieldU2( output, surfels.cbegin(), surfels.cend() );
1754 return output;
1755 }
1756
1787 template <typename TAnyDigitalSurface,
1788 typename VectorFieldInput,
1789 typename CellRangeConstIterator>
1790 static
1791 VectorFieldInput
1793 CellRangeConstIterator itB,
1794 CellRangeConstIterator itE,
1796 const SurfelRange& surfels,
1797 const VectorFieldInput& input,
1798 const Parameters& params
1800 {
1801 (void)surface; //param not used FIXME: JOL
1802
1803 int verbose = params[ "verbose" ].as<int>();
1804 Scalar alpha_at = params[ "at-alpha" ].as<Scalar>();
1805 Scalar lambda_at = params[ "at-lambda" ].as<Scalar>();
1806 Scalar epsilon1 = params[ "at-epsilon-start" ].as<Scalar>();
1807 Scalar epsilon2 = params[ "at-epsilon" ].as<Scalar>();
1808 Scalar epsilonr = params[ "at-epsilon-ratio" ].as<Scalar>();
1809 int max_iter = params[ "at-max-iter" ].as<int>();
1810 Scalar diff_v_max= params[ "at-diff-v-max" ].as<Scalar>();
1811 std::string policy = params[ "at-v-policy" ].as<std::string>();
1813 const auto calculus = CalculusFactory::createFromNSCells<2>( surfels.cbegin(), surfels.cend() );
1814 ATSolver2D< KSpace > at_solver( calculus, verbose );
1815 at_solver.initInputVectorFieldU2( input, surfels.cbegin(), surfels.cend() );
1816 at_solver.setUp( alpha_at, lambda_at );
1817 at_solver.solveGammaConvergence( epsilon1, epsilon2, epsilonr, false, diff_v_max, max_iter );
1818 auto output = input;
1819 at_solver.getOutputVectorFieldU2( output, surfels.cbegin(), surfels.cend() );
1820 auto p = ( policy == "Average" ) ? at_solver.Average
1821 : ( policy == "Minimum" ) ? at_solver.Minimum
1822 : at_solver.Maximum;
1823 at_solver.getOutputScalarFieldV0( features, itB, itE, p );
1824 return output;
1825 }
1826
1850 template <typename TAnyDigitalSurface>
1851 static
1852 Scalars
1854 const SurfelRange& surfels,
1855 const Scalars& input,
1856 const Parameters& params
1858 {
1859 (void)surface; //param not used FIXME: JOL
1860
1861 int verbose = params[ "verbose" ].as<int>();
1862 Scalar alpha_at = params[ "at-alpha" ].as<Scalar>();
1863 Scalar lambda_at = params[ "at-lambda" ].as<Scalar>();
1864 Scalar epsilon1 = params[ "at-epsilon-start" ].as<Scalar>();
1865 Scalar epsilon2 = params[ "at-epsilon" ].as<Scalar>();
1866 Scalar epsilonr = params[ "at-epsilon-ratio" ].as<Scalar>();
1867 int max_iter = params[ "at-max-iter" ].as<int>();
1868 Scalar diff_v_max= params[ "at-diff-v-max" ].as<Scalar>();
1870 const auto calculus = CalculusFactory::createFromNSCells<2>( surfels.cbegin(), surfels.cend() );
1871 ATSolver2D< KSpace > at_solver( calculus, verbose );
1872 at_solver.initInputScalarFieldU2( input, surfels.cbegin(), surfels.cend() );
1873 at_solver.setUp( alpha_at, lambda_at );
1874 at_solver.solveGammaConvergence( epsilon1, epsilon2, epsilonr, false, diff_v_max, max_iter );
1875 auto output = input;
1876 at_solver.getOutputScalarFieldU2( output, surfels.cbegin(), surfels.cend() );
1877 return output;
1878 }
1879
1914 template <typename TAnyDigitalSurface,
1915 typename CellRangeConstIterator>
1916 static
1917 Scalars
1919 CellRangeConstIterator itB,
1920 CellRangeConstIterator itE,
1922 const SurfelRange& surfels,
1923 const Scalars& input,
1924 const Parameters& params
1926 {
1927 (void)surface; //param not used FIXME: JOL
1928
1929 int verbose = params[ "verbose" ].as<int>();
1930 Scalar alpha_at = params[ "at-alpha" ].as<Scalar>();
1931 Scalar lambda_at = params[ "at-lambda" ].as<Scalar>();
1932 Scalar epsilon1 = params[ "at-epsilon-start" ].as<Scalar>();
1933 Scalar epsilon2 = params[ "at-epsilon" ].as<Scalar>();
1934 Scalar epsilonr = params[ "at-epsilon-ratio" ].as<Scalar>();
1935 int max_iter = params[ "at-max-iter" ].as<int>();
1936 Scalar diff_v_max= params[ "at-diff-v-max" ].as<Scalar>();
1937 std::string policy = params[ "at-v-policy" ].as<std::string>();
1939 const auto calculus = CalculusFactory::createFromNSCells<2>( surfels.cbegin(), surfels.cend() );
1940 ATSolver2D< KSpace > at_solver( calculus, verbose );
1941 at_solver.initInputScalarFieldU2( input, surfels.cbegin(), surfels.cend() );
1942 at_solver.setUp( alpha_at, lambda_at );
1943 at_solver.solveGammaConvergence( epsilon1, epsilon2, epsilonr, false, diff_v_max, max_iter );
1944 auto output = input;
1945 at_solver.getOutputScalarFieldU2( output, surfels.cbegin(), surfels.cend() );
1946 auto p = ( policy == "Average" ) ? at_solver.Average
1947 : ( policy == "Minimum" ) ? at_solver.Minimum
1948 : at_solver.Maximum;
1949 at_solver.getOutputScalarFieldV0( features, itB, itE, p );
1950 return output;
1951 }
1952
1954
1955 // ------------------------- Error measures services -------------------------
1958 public:
1959
1965 static void
1967 const RealVectors& ref_v )
1968 {
1969 std::transform( ref_v.cbegin(), ref_v.cend(), v.cbegin(), v.begin(),
1970 [] ( RealVector rw, RealVector w )
1971 { return rw.dot( w ) >= 0.0 ? w : -w; } );
1972 }
1973
1978 static ScalarStatistic
1980 {
1981 ScalarStatistic stat;
1982 stat.addValues( v.begin(), v.end() );
1983 stat.terminate();
1984 return stat;
1985 }
1986
1993 static Scalars
1995 const RealVectors& v2 )
1996 {
1997 Scalars v( v1.size() );
1998 if ( v1.size() == v2.size() )
1999 {
2000 auto outIt = v.begin();
2001 for ( auto it1 = v1.cbegin(), it2 = v2.cbegin(), itE1 = v1.cend();
2002 it1 != itE1; ++it1, ++it2 )
2003 {
2004 Scalar angle_error = acos( (*it1).dot( *it2 ) );
2005 *outIt++ = angle_error;
2006 }
2007 }
2008 else
2009 {
2010 trace.warning() << "[ShortcutsGeometry::getVectorsAngleDeviation]"
2011 << " v1.size()=" << v1.size() << " should be equal to "
2012 << " v2.size()=" << v2.size() << std::endl;
2013 }
2014 return v;
2015 }
2016
2021 static Scalars
2023 const Scalars & v2 )
2024 {
2025 Scalars result( v1.size() );
2026 std::transform( v2.cbegin(), v2.cend(), v1.cbegin(), result.begin(),
2027 [] ( Scalar val1, Scalar val2 )
2028 { return fabs( val1 - val2 ); } );
2029 return result;
2030 }
2031
2038 static Scalar
2040 const Scalars & v2 )
2041 {
2042 Scalar sum = 0;
2043 for ( unsigned int i = 0; i < v1.size(); i++ )
2044 sum += ( v1[ i ] - v2[ i ] ) * ( v1[ i ] - v2[ i ] );
2045 return sqrt( sum / v1.size() );
2046 }
2047
2054 static Scalar
2056 const Scalars & v2 )
2057 {
2058 Scalar sum = 0;
2059 for ( unsigned int i = 0; i < v1.size(); i++ )
2060 sum += fabs( v1[ i ] - v2[ i ] );
2061 return sum / v1.size();
2062 }
2063
2070 static Scalar
2072 const Scalars & v2 )
2073 {
2074 Scalar loo = 0;
2075 for ( unsigned int i = 0; i < v1.size(); i++ )
2076 loo = std::max( loo, fabs( v1[ i ] - v2[ i ] ) );
2077 return loo;
2078 }
2079
2081
2082 // ----------------------- Standard services ------------------------------
2085 public:
2086
2091
2096
2101 ShortcutsGeometry ( const ShortcutsGeometry & other ) = delete;
2102
2108
2115
2122
2124
2125 // ----------------------- Interface --------------------------------------
2126 public:
2127
2128 // ------------------------- Protected Datas ------------------------------
2129 protected:
2130
2131 // ------------------------- Private Datas --------------------------------
2132 private:
2133
2134 // ------------------------- Hidden services ------------------------------
2135 protected:
2136
2137 // ------------------------- Internals ------------------------------------
2138 private:
2139
2140 }; // end of class ShortcutsGeometry
2141
2142
2143} // namespace DGtal
2144
2145
2147// Includes inline functions.
2148
2149// //
2151
2152#endif // !defined ShortcutsGeometry_h
2153
2154#undef ShortcutsGeometry_RECURSES
2155#endif // else defined(ShortcutsGeometry_RECURSES)
Aim: This class solves Ambrosio-Tortorelli functional on a two-dimensional digital space (a 2D grid o...
Definition ATSolver2D.h:91
void getOutputScalarFieldU2(ScalarFieldOutput &output, SurfelRangeConstIterator itB, SurfelRangeConstIterator itE)
Definition ATSolver2D.h:798
void getOutputScalarFieldV0(ScalarFieldOutput &output, CellRangeConstIterator itB, CellRangeConstIterator itE, CellOutputPolicy policy=CellOutputPolicy::Average)
Definition ATSolver2D.h:824
void initInputScalarFieldU2(const ScalarFieldInput &input, SurfelRangeConstIterator itB, SurfelRangeConstIterator itE)
Definition ATSolver2D.h:330
void setUp(double a, double l)
Definition ATSolver2D.h:444
void initInputVectorFieldU2(const VectorFieldInput &input, SurfelRangeConstIterator itB, SurfelRangeConstIterator itE, bool normalize=false)
Definition ATSolver2D.h:288
bool solveGammaConvergence(double eps1=2.0, double eps2=0.25, double epsr=2.0, bool compute_smallest_epsilon_map=false, double n_oo_max=1e-4, unsigned int iter_max=10)
Definition ATSolver2D.h:657
void getOutputVectorFieldU2(VectorFieldOutput &output, SurfelRangeConstIterator itB, SurfelRangeConstIterator itE)
Definition ATSolver2D.h:772
@ Maximum
compute maximum value at cell vertices
Definition ATSolver2D.h:105
@ Average
compute average values at cell vertices
Definition ATSolver2D.h:103
@ Minimum
compute minimum value at cell vertices,
Definition ATSolver2D.h:104
Aim: Smart pointer based on reference counts.
Definition CountedPtr.h:80
Aim: This class provides static members to create DEC structures from various other DGtal structures.
Aim: implements separable l_p metrics with exact predicates.
Aim: Parallelepidec region of a digital space, model of a 'CDomain'.
Aim: model of CEuclideanOrientedShape concepts to create a shape from a polynomial.
Aim: This class implement an Integral Invariant estimator which computes for each surfel the covarian...
Aim: This class implement an Integral Invariant estimator which computes for each surfel the volume o...
Aim: this class adapts any local functor on digital surface element to define a local estimator....
Aim: implements l_p metrics.
Definition LpMetric.h:75
BOOST_CONCEPT_ASSERT((concepts::CCellularGridSpaceND< TKSpace >))
static Scalars getIIGaussianCurvatures(CountedPtr< BinaryImage > bimage, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace())
static RealVectors getIINormalVectors(CountedPtr< DigitizedImplicitShape3D > dshape, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace()|parametersDigitizedImplicitShape3D())
static Scalar getScalarsNormL1(const Scalars &v1, const Scalars &v2)
static RealVectors getTrivialNormalVectors(const KSpace &K, const SurfelRange &surfels)
LightImplicitDigitalSurface< KSpace, BinaryImage > LightSurfaceContainer
MPolynomial< Space::dimension, Scalar > ScalarPolynomial
static Scalars getIIMeanCurvatures(CountedPtr< DigitizedImplicitShape3D > dshape, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace()|parametersDigitizedImplicitShape3D())
static RealPoints getPositions(CountedPtr< ImplicitShape3D > shape, const RealPoints &points, const Parameters &params=parametersShapeGeometry())
static std::tuple< Scalars, Scalars, RealVectors, RealVectors > getCNCPrincipalCurvaturesAndDirections(CountedPtr< typename Base::SurfaceMesh > mesh, const Parameters &params=parametersShapeGeometry())
::DGtal::Statistic< Scalar > ScalarStatistic
ShortcutsGeometry(const ShortcutsGeometry &other)=delete
static Scalars getATScalarFieldApproximation(Scalars &features, CellRangeConstIterator itB, CellRangeConstIterator itE, CountedPtr< TAnyDigitalSurface > surface, const SurfelRange &surfels, const Scalars &input, const Parameters &params=parametersATApproximation()|parametersGeometryEstimation())
static Parameters parametersGeometryEstimation()
static Scalars getMeanCurvatures(CountedPtr< ImplicitShape3D > shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersShapeGeometry())
static RealPoints getPositions(CountedPtr< ImplicitShape3D > shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersShapeGeometry())
static Parameters parametersKSpace()
Definition Shortcuts.h:312
functors::IIPrincipalCurvaturesAndDirectionsFunctor< Space >::Quantity CurvatureTensorQuantity
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, GaussianCurvatureFunctor > TrueGaussianCurvatureEstimator
static CurvatureTensorQuantities getIIPrincipalCurvaturesAndDirections(const TPointPredicate &shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace())
static KSpace getKSpace(const Point &low, const Point &up, Parameters params=parametersKSpace())
Definition Shortcuts.h:333
ShortcutsGeometry & operator=(const ShortcutsGeometry &other)=delete
LightDigitalSurface::ArcRange ArcRange
sgf::ShapeGaussianCurvatureFunctor< ImplicitShape3D > GaussianCurvatureFunctor
static Parameters parametersShapeGeometry()
CorrectedNormalCurrentComputer< RealPoint, RealVector > CNCComputer
static CurvatureTensorQuantities getIIPrincipalCurvaturesAndDirections(CountedPtr< DigitizedImplicitShape3D > dshape, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace()|parametersDigitizedImplicitShape3D())
static Scalars getCNCGaussianCurvatures(CountedPtr< typename Base::SurfaceMesh > mesh, const typename Base::SurfaceMesh::Faces &faces, const Parameters &params=parametersShapeGeometry())
sgf::ShapeSecondPrincipalDirectionFunctor< ImplicitShape3D > SecondPrincipalDirectionFunctor
static CurvatureTensorQuantities getIIPrincipalCurvaturesAndDirections(CountedPtr< BinaryImage > bimage, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace())
static Scalars getIIGaussianCurvatures(CountedPtr< DigitizedImplicitShape3D > dshape, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace()|parametersDigitizedImplicitShape3D())
sgf::ShapePositionFunctor< ImplicitShape3D > PositionFunctor
sgf::ShapeMeanCurvatureFunctor< ImplicitShape3D > MeanCurvatureFunctor
sgf::ShapeSecondPrincipalCurvatureFunctor< ImplicitShape3D > SecondPrincipalCurvatureFunctor
static void orientVectors(RealVectors &v, const RealVectors &ref_v)
static RealVectors getIINormalVectors(CountedPtr< BinaryImage > bimage, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace())
static Parameters parametersATApproximation()
ShortcutsGeometry(ShortcutsGeometry &&other)=delete
static Scalars getScalarsAbsoluteDifference(const Scalars &v1, const Scalars &v2)
std::vector< CurvatureTensorQuantity > CurvatureTensorQuantities
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, PositionFunctor > TruePositionEstimator
static RealVectors getNormalVectors(CountedPtr< ImplicitShape3D > shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersShapeGeometry())
::DGtal::TriangulatedSurface< RealPoint > TriangulatedSurface
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, SecondPrincipalDirectionFunctor > TrueSecondPrincipalDirectionEstimator
static std::tuple< Scalars, Scalars, RealVectors, RealVectors > getCNCPrincipalCurvaturesAndDirections(CountedPtr< typename Base::SurfaceMesh > mesh, const typename Base::SurfaceMesh::Faces &faces, const Parameters &params=parametersShapeGeometry())
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, NormalFunctor > TrueNormalEstimator
static RealVectors getFirstPrincipalDirections(CountedPtr< ImplicitShape3D > shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersShapeGeometry())
static Scalars getCNCGaussianCurvatures(T &digitalObject, const Parameters &params=parametersShapeGeometry())
ImageContainerBySTLVector< Domain, GrayScale > GrayScaleImage
::DGtal::PolygonalSurface< RealPoint > PolygonalSurface
static Scalars getIIMeanCurvatures(const TPointPredicate &shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace())
static RealVectors getSecondPrincipalDirections(CountedPtr< ImplicitShape3D > shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersShapeGeometry())
ImplicitPolynomial3Shape< Space > ImplicitShape3D
::DGtal::DigitalSurface< ExplicitSurfaceContainer > DigitalSurface
GaussDigitizer< Space, ImplicitShape3D > DigitizedImplicitShape3D
ImageContainerBySTLVector< Domain, float > FloatImage
SetOfSurfels< KSpace, SurfelSet > ExplicitSurfaceContainer
static RealVectors getCTrivialNormalVectors(CountedPtr< TAnyDigitalSurface > surface, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation())
static Scalars getCNCMeanCurvatures(CountedPtr< typename Base::SurfaceMesh > mesh, const typename Base::SurfaceMesh::Faces faces, const Parameters &params=parametersShapeGeometry())
static Scalars getIIMeanCurvatures(CountedPtr< BinaryImage > bimage, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace())
ImageContainerBySTLVector< Domain, double > DoubleImage
static std::tuple< Scalars, Scalars, RealVectors, RealVectors > getCNCPrincipalCurvaturesAndDirections(T &digitalObject, const Parameters &params=parametersShapeGeometry())
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, SecondPrincipalCurvatureFunctor > TrueSecondPrincipalCurvatureEstimator
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, FirstPrincipalCurvatureFunctor > TrueFirstPrincipalCurvatureEstimator
ShortcutsGeometry< Z3i::KSpace > Self
static CurvatureTensorQuantities getPrincipalCurvaturesAndDirections(CountedPtr< ImplicitShape3D > shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersShapeGeometry())
static Parameters defaultParameters()
static Scalars getCNCMeanCurvatures(T &digitalObject, const Parameters &params=parametersShapeGeometry())
::DGtal::DigitalSurface< LightSurfaceContainer > LightDigitalSurface
static Scalars getGaussianCurvatures(CountedPtr< ImplicitShape3D > shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersShapeGeometry())
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, PrincipalCurvaturesAndDirectionsFunctor > TruePrincipalCurvaturesAndDirectionsEstimator
static RealVectors getIINormalVectors(const TPointPredicate &shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace())
static Scalars getVectorsAngleDeviation(const RealVectors &v1, const RealVectors &v2)
static Scalars getCNCGaussianCurvatures(CountedPtr< typename Base::SurfaceMesh > mesh, const Parameters &params=parametersShapeGeometry())
static Scalar getScalarsNormL2(const Scalars &v1, const Scalars &v2)
IndexedDigitalSurface< ExplicitSurfaceContainer > IdxDigitalSurface
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, MeanCurvatureFunctor > TrueMeanCurvatureEstimator
static Scalars getFirstPrincipalCurvatures(CountedPtr< ImplicitShape3D > shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersShapeGeometry())
sgf::ShapeNormalVectorFunctor< ImplicitShape3D > NormalFunctor
sgf::ShapeFirstPrincipalDirectionFunctor< ImplicitShape3D > FirstPrincipalDirectionFunctor
static Scalar getScalarsNormLoo(const Scalars &v1, const Scalars &v2)
static Parameters parametersDigitizedImplicitShape3D()
Definition Shortcuts.h:462
static ScalarStatistic getStatistic(const Scalars &v)
static Scalars getATScalarFieldApproximation(CountedPtr< TAnyDigitalSurface > surface, const SurfelRange &surfels, const Scalars &input, const Parameters &params=parametersATApproximation()|parametersGeometryEstimation())
sgf::ShapeFirstPrincipalCurvatureFunctor< ImplicitShape3D > FirstPrincipalCurvatureFunctor
static Scalars getIIGaussianCurvatures(const TPointPredicate &shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation()|parametersKSpace())
TrueDigitalSurfaceLocalEstimator< KSpace, ImplicitShape3D, FirstPrincipalDirectionFunctor > TrueFirstPrincipalDirectionEstimator
sgf::ShapePrincipalCurvaturesAndDirectionsFunctor< ImplicitShape3D > PrincipalCurvaturesAndDirectionsFunctor
static VectorFieldInput getATVectorFieldApproximation(CountedPtr< TAnyDigitalSurface > surface, const SurfelRange &surfels, const VectorFieldInput &input, const Parameters &params=parametersATApproximation()|parametersGeometryEstimation())
static Scalars getCNCMeanCurvatures(CountedPtr< typename Base::SurfaceMesh > mesh, const Parameters &params=parametersShapeGeometry())
static Scalars getSecondPrincipalCurvatures(CountedPtr< ImplicitShape3D > shape, const KSpace &K, const SurfelRange &surfels, const Parameters &params=parametersShapeGeometry())
static VectorFieldInput getATVectorFieldApproximation(Scalars &features, CellRangeConstIterator itB, CellRangeConstIterator itE, CountedPtr< TAnyDigitalSurface > surface, const SurfelRange &surfels, const VectorFieldInput &input, const Parameters &params=parametersATApproximation()|parametersGeometryEstimation())
static RealVectors getVCMNormalVectors(CountedPtr< TAnyDigitalSurface > surface, const SurfelRange &surfels, const Parameters &params=parametersGeometryEstimation())
std::map< Surfel, IdxSurfel > Surfel2Index
IdxDigitalSurface::ArcRange IdxArcRange
ImageContainerBySTLVector< Domain, bool > BinaryImage
static Parameters parametersKSpace()
Definition Shortcuts.h:312
static KSpace getKSpace(const Point &low, const Point &up, Parameters params=parametersKSpace())
Definition Shortcuts.h:333
Shortcuts()=delete
LightDigitalSurface::Face Face
Definition Shortcuts.h:167
static Parameters parametersDigitizedImplicitShape3D()
Definition Shortcuts.h:462
static CountedPtr< SurfaceMesh > makePrimalSurfaceMesh(Cell2Index &c2i, CountedPtr< ::DGtal::DigitalSurface< TContainer > > aSurface)
Definition Shortcuts.h:2373
PointVector< dim, Integer > Point
Definition SpaceND.h:110
PointVector< dim, double > RealPoint
Definition SpaceND.h:117
PointVector< dim, double > RealVector
Definition SpaceND.h:121
PointVector< dim, Integer > Vector
Definition SpaceND.h:113
void addValues(Iter b, Iter e)
Aim: An estimator on digital surfaces that returns the reference local geometric quantity....
void init(const Scalar _h, SurfelConstIterator itb, SurfelConstIterator ite)
Quantity eval(SurfelConstIterator it) const
void setParams(ConstAlias< KSpace > ks, Clone< GeometricFunctor > fct, const int maxIter=20, const Scalar accuracy=0.0001, const Scalar gamma=0.5)
void attach(ConstAlias< Shape > aShape)
Aim: This class adapts a VoronoiCovarianceMeasureOnDigitalSurface to be a model of CDigitalSurfaceLoc...
Aim: This class specializes the Voronoi covariance measure for digital surfaces. It adds notably the ...
Aim: Estimates normal vector by convolution of elementary normal vector to adjacent surfel.
Aim: A functor Matrix -> RealVector that returns the normal direction by diagonalizing the given cova...
Aim: A functor Matrix -> std::pair<RealVector,RealVector> that returns the first and the second princ...
std::tuple< double, double, RealVector, RealVector > Quantity
PolyCalculus * calculus
CountedPtr< SH3::DigitalSurface > surface
DGtal is the top-level namespace which contains all DGtal functions and types.
DGtal::uint32_t Dimension
Definition Common.h:119
Trace trace
Surfel2PointEmbedding
Possible embeddings for surfel as point(s)
Aim: A trivial embedder for signed cell, which corresponds to the canonic injection of cell centroids...
Aim: Utility class to compute curvature measures induced by (1) a corrected normal current defined by...
static std::tuple< Scalar, Scalar, RealVector, RealVector > principalCurvatures(Scalar mu0, RealTensor muXY, const RealVector &N)
Aim: This concept describes a cellular grid space in nD. In these spaces obtained by cartesian produc...
Aim: A functor Matrix -> Real that returns the Gaussian curvature by diagonalizing the given covarian...
Aim: A functor Real -> Real that returns the 3d mean curvature by transforming the given volume....
Aim: A functor Surfel -> Quantity that returns the outer normal vector at given surfel.
KSpace K