DGtal  1.3.beta
BasicPointFunctors.h
1 
17 #pragma once
18 
32 #if defined(BasicPointFunctors_RECURSES)
33 #error Recursive header files inclusion detected in BasicPointFunctors.h
34 #else // defined(BasicPointFunctors_RECURSES)
35 
36 #define BasicPointFunctors_RECURSES
37 
38 #if !defined BasicPointFunctors_h
39 
40 #define BasicPointFunctors_h
41 
43 // Inclusions
44 #include <iostream>
45 #include <iterator>
46 #include <array>
47 #include <cmath>
48 
49 #include "DGtal/base/Common.h"
50 #include "DGtal/helpers/StdDefs.h"
51 #include "DGtal/kernel/SpaceND.h"
52 #include "DGtal/kernel/NumberTraits.h"
53 #include "DGtal/base/BasicBoolFunctors.h"
54 #include "DGtal/kernel/CPointPredicate.h"
55 #include "DGtal/base/CQuantity.h"
56 #include "DGtal/kernel/domains/CDomain.h"
57 #include "DGtal/base/ConstAlias.h"
59 
60 namespace DGtal
61 {
62 namespace functors
63  {
65  // template class Projector
105  template <typename S = SpaceND< 2, DGtal::Z2i::Integer > >
106  struct Projector
107  {
108  typedef S Space;
109  typedef typename Space::Dimension Dimension;
111  typedef typename Space::Integer Integer;
112  typedef typename Space::Point Point;
113 
117  Projector(const Integer& aDefaultInteger = NumberTraits<Integer>::zero());
118 
119 
125  template<typename TIterator>
126  void init ( const TIterator& itb, const TIterator& ite );
127 
128 
133  void initRemoveOneDim ( const Dimension &dimRemoved );
134 
139  void initAddOneDim ( const Dimension & newDim );
140 
141 
147  template<typename TInputPoint>
148  Point operator()( const TInputPoint& aPoint ) const;
149 
150  private:
155  std::array<Dimension, dimension> myDims;
156 
162 
163  }; // end of class ConstantPointFunctors
164 
165 
166 
167 
168 
199  template <typename TDomain3D, typename TInteger = DGtal::Z3i::Integer >
201  {
202  public:
203 
205  typedef typename Space::Dimension Dimension;
206  typedef typename Space::Point Point;
207  typedef typename Space::Integer Integer;
218  SliceRotator2D( const Dimension &dimAdded, const TDomain3D &aDomain3DImg,
219  const Integer &sliceIndex, const Dimension &dimRotated,
220  double rotationAngle):
221  myPosDimAdded(dimAdded), mySliceIndex(sliceIndex), myDomain(aDomain3DImg),
222  myDimRotated(dimRotated), myRotationAngle(rotationAngle), myDefaultPoint (aDomain3DImg.lowerBound())
223  {
224  myCenter[0] = aDomain3DImg.lowerBound()[0]+((aDomain3DImg.upperBound())[0]-(aDomain3DImg.lowerBound())[0])/2.0;
225  myCenter[1] = aDomain3DImg.lowerBound()[1]+((aDomain3DImg.upperBound())[1]-(aDomain3DImg.lowerBound())[1])/2.0;
226  myCenter[2] = aDomain3DImg.lowerBound()[2]+((aDomain3DImg.upperBound())[2]-(aDomain3DImg.lowerBound())[2])/2.0;
227  myCenter[dimAdded]=sliceIndex;
228  };
229 
240  SliceRotator2D( const Dimension &dimAdded, const TDomain3D &aDomain3DImg,
241  const Integer &sliceIndex, const Dimension &dimRotated,
242  double rotationAngle, const Point &defaultPoint):
243  myPosDimAdded(dimAdded), mySliceIndex(sliceIndex), myDomain(aDomain3DImg),
244  myDimRotated(dimRotated), myRotationAngle(rotationAngle), myDefaultPoint (defaultPoint)
245  {
246  myCenter[0] = aDomain3DImg.lowerBound()[0]+((aDomain3DImg.upperBound())[0]-(aDomain3DImg.lowerBound())[0])/2.0;
247  myCenter[1] = aDomain3DImg.lowerBound()[1]+((aDomain3DImg.upperBound())[1]-(aDomain3DImg.lowerBound())[1])/2.0;
248  myCenter[2] = aDomain3DImg.lowerBound()[2]+((aDomain3DImg.upperBound())[2]-(aDomain3DImg.lowerBound())[2])/2.0;
249  myCenter[dimAdded]=sliceIndex;
250  };
251 
263  SliceRotator2D( const Dimension &dimAdded, const TDomain3D &aDomain3DImg, const Integer &sliceIndex,
264  const Dimension &dimRotated, const Point &ptCenter, double rotationAngle, const Point &defaultPoint):
265  myPosDimAdded(dimAdded), mySliceIndex(sliceIndex), myDomain(aDomain3DImg),
266  myDimRotated(dimRotated), myRotationAngle(rotationAngle), myCenter(ptCenter), myDefaultPoint (defaultPoint)
267  {
268  };
269 
281  SliceRotator2D( const Dimension &dimAdded, const TDomain3D &aDomain3DImg, const Integer &sliceIndex,
282  const Dimension &dimRotated, const Point &ptCenter, double rotationAngle):
283  myPosDimAdded(dimAdded), mySliceIndex(sliceIndex), myDomain(aDomain3DImg),
284  myDimRotated(dimRotated), myRotationAngle(rotationAngle), myCenter(ptCenter), myDefaultPoint (aDomain3DImg.lowerBound())
285  {
286  };
287 
294  template <typename TPointDimMinus>
295  inline
296  Point operator()(const TPointDimMinus& aPoint) const
297  {
298  Point pt;
299  Dimension pos=0;
300  std::vector<Dimension> indexesRotate;
301  for( Dimension i=0; i<pt.size(); i++)
302  {
303  if(i!=myPosDimAdded)
304  {
305  pt[i]= aPoint[pos];
306  pos++;
307  }else
308  {
309  pt[i]=mySliceIndex;
310  }
311  }
312  for( Dimension i=0; i<pt.size(); i++)
313  {
314  if(i!=myDimRotated)
315  indexesRotate.push_back(i);
316  }
317  double d1 = pt[indexesRotate[0]] - myCenter[indexesRotate[0]];
318  double d2 = pt[indexesRotate[1]] - myCenter[indexesRotate[1]];
319 
320  pt[indexesRotate[0]] = myCenter[indexesRotate[0]] + static_cast<Integer>(round(d1*cos(myRotationAngle)-d2*sin(myRotationAngle) ));
321  pt[indexesRotate[1]] = myCenter[indexesRotate[1]] + static_cast<Integer>(round(d1*sin(myRotationAngle)+d2*cos(myRotationAngle) ));
322 
323  if(myDomain.isInside(pt))
324  return pt;
325  else
326  return myDefaultPoint;
327  }
328  private:
329  // position of insertion of the new dimension
331  // the index of the slice associated to the new domain.
333  TDomain3D myDomain;
338  };
339 
340 
371  template <typename TDomain3D, typename TInteger = DGtal::Z3i::Integer >
373  {
374  public:
375 
377  typedef typename Space::Point Point;
378  typedef typename Space::Integer Integer;
379 
390  Point2DEmbedderIn3D( const TDomain3D &aDomain3DImg,
391  const Point &anOriginPoint, const Point &anUpperPointOnAxis1,
392  const Point &anUpperPointOnAxis2,
393  const Point &aDefautPoint = Point(0,0,0)): myDomain(aDomain3DImg),
394  myOriginPointEmbeddedIn3D(anOriginPoint),
395  myDefaultPoint (aDefautPoint),
396  myFirstAxisEmbeddedDirection(Point(anUpperPointOnAxis1[0]-anOriginPoint[0],
397  anUpperPointOnAxis1[1]-anOriginPoint[1],
398  anUpperPointOnAxis1[2]-anOriginPoint[2])),
399  mySecondAxisEmbeddedDirection(Point(anUpperPointOnAxis2[0]-anOriginPoint[0],
400  anUpperPointOnAxis2[1]-anOriginPoint[1],
401  anUpperPointOnAxis2[2]-anOriginPoint[2]))
402 
403 
404  {
407  }
408 
409 
422  Point2DEmbedderIn3D( const TDomain3D &aDomain3DImg,
423  const Point &anOriginPoint, const typename Space::RealPoint & anNormalVector,
424  const typename Point::Component &anWidth,
425  const Point &aDefautPoint = Point(0,0,0)): myDomain(aDomain3DImg),
426  myDefaultPoint (aDefautPoint)
427  {
428  double d = -anNormalVector[0]*anOriginPoint[0] - anNormalVector[1]*anOriginPoint[1] - anNormalVector[2]*anOriginPoint[2];
429  typename Space::RealPoint pRefOrigin;
430  if(anNormalVector[0]!=0){
431  pRefOrigin [0]= -d/anNormalVector[0];
432  pRefOrigin [1]= 0.0;
433  pRefOrigin [2]= 0.0;
434  if(pRefOrigin==anOriginPoint){
435  pRefOrigin[1]=-1.0;
436  }
437  }else if (anNormalVector[1]!=0){
438  pRefOrigin [0]= 0.0;
439  pRefOrigin [1]= -d/anNormalVector[1];
440  pRefOrigin [2]= 0.0;
441  if(pRefOrigin==anOriginPoint){
442  pRefOrigin[0]=-1.0;
443  }
444  }else if (anNormalVector[2]!=0){
445  pRefOrigin [0]= 0.0;
446  pRefOrigin [1]= 0.0;
447  pRefOrigin [2]= -d/anNormalVector[2];
448  if(pRefOrigin==anOriginPoint){
449  pRefOrigin[0]=-1.0;
450  }
451  }
452  typename Space::RealPoint uDir1;
453  uDir1=(pRefOrigin-anOriginPoint)/((pRefOrigin-anOriginPoint).norm());
454  typename Space::RealPoint uDir2;
455  uDir2[0] = uDir1[1]*anNormalVector[2]-uDir1[2]*anNormalVector[1];
456  uDir2[1] = uDir1[2]*anNormalVector[0]-uDir1[0]*anNormalVector[2];
457  uDir2[2] = uDir1[0]*anNormalVector[1]-uDir1[1]*anNormalVector[0];
458 
459  uDir2/=uDir2.norm();
460 
461  myOriginPointEmbeddedIn3D = anOriginPoint + Point(uDir1*anWidth/2) + Point(uDir2*anWidth/2);
464  }
465 
466 
467 
468 
476  template <typename TPoint2D>
477  inline
478  Point operator()(const TPoint2D& aPoint, bool checkInsideDomain=true) const
479  {
481  for( Dimension i=0; i<pt.size(); i++){
482 
483  pt[i] = pt[i]+static_cast<Integer>(floor(NumberTraits<Integer>::castToDouble(aPoint[0])
485  pt[i] = pt[i]+static_cast<Integer>(floor(NumberTraits<Integer>::castToDouble(aPoint[1])
487  }
488 
489  if(myDomain.isInside(pt)|| !checkInsideDomain)
490  {
491  return pt;
492  }
493  else
494  {
495 #ifdef DEBUG_VERBOSE
496  trace.warning() << "Warning pt outside the 3D domain " << pt << std::endl;
497 #endif
498  return myDefaultPoint;
499  }
500  }
501 
502  private:
503  TDomain3D myDomain;
504 
505  // Origin (or lower point) of the 2D image embedded in the 3D domain
507 
509 
510  // Point giving the direction of the embedded first axis of the 2D image.
512 
513  // Point giving the direction of the embedded second axis of the 2D image.
515 
516  };
517 
518 
522  template< typename TPointPredicate, typename TDomain, typename TValue=typename TDomain::Integer >
524  {
525  typedef TPointPredicate PointPredicate;
526  typedef TDomain Domain;
527  typedef TValue Value;
528  typedef typename Domain::Point Point;
529 
533 
542  const Value aTrueValue, const Value aFalseValue );
543 
545 
551  Value operator()( const Point& aPoint ) const;
552 
560 
561  private:
563  const Domain * myDomain;
566 
567  };
568 
569 
589  template <typename TDomain, typename TInteger = DGtal::int32_t, typename TValue = DGtal::uint32_t >
591  {
592  public:
593  typedef typename TDomain::Space Space;
594  typedef typename TDomain::Size Size;
595  typedef typename TDomain::Integer IntergerDom;
596  typedef typename Space::Dimension Dimension;
597  typedef typename Space::Point Point;
598 
610  BasicDomainSubSampler(const TDomain &aSourceDomain, const std::vector<TValue> &aGridSize,
611  const Point &aGridShift): mySourceDomain(aSourceDomain),
612  myGridShift(aGridShift),
613  myGridSize(aGridSize)
614  {
615  Point domainUpperBound=aSourceDomain.upperBound();
616  Point domainLowerBound=aSourceDomain.lowerBound();
617 
618  for (Dimension dim=0; dim< Space::dimension; dim++){
619  domainLowerBound[dim] = static_cast<IntergerDom>(floor(NumberTraits<IntergerDom>::castToDouble(domainLowerBound[dim]) /
620  NumberTraits<TValue>::castToDouble( aGridSize[dim] )));
621  domainUpperBound[dim] = static_cast<IntergerDom>(floor(NumberTraits<IntergerDom>::castToDouble(domainUpperBound[dim]) /
622  NumberTraits<TValue>::castToDouble( aGridSize[dim] )));
623  }
624  myNewDomain = TDomain(domainLowerBound,
625  domainUpperBound);
626  Point upperGrid;
627  for (Dimension dim=0; dim < Space::dimension; dim++)
628  upperGrid[dim] = myGridSize[dim];
629  myGridSampleDomain = TDomain(Point::diagonal(0), upperGrid);
630  };
631 
632 
646  inline
647  Point operator()(const Point& aPoint) const
648  {
649  Point ptRes = Point::diagonal(0);
650  if(!myNewDomain.isInside(aPoint)){
651  trace.error() << " The point is not in the source domain: "<< aPoint << std::endl;
652  return ptRes;
653  }
654 
655  for (Dimension dim=0; dim< Space::dimension; dim++){
656  ptRes[dim] = static_cast<TInteger>(floor(NumberTraits<TInteger>::castToDouble(aPoint[dim])*
658  }
659  ptRes +=myGridShift;
660 
661  if(!mySourceDomain.isInside(ptRes)){
662  // we are looking for a point inside the domain
663  for(typename TDomain::ConstIterator it = myGridSampleDomain.begin();
664  it!= myGridSampleDomain.end(); it++){
665  if (mySourceDomain.isInside(ptRes+(*it)))
666  return ptRes+(*it);
667  }
668  }
669  return ptRes;
670  }
671 
678  inline
679  const TDomain & getSubSampledDomain(){
680  return myNewDomain;
681  }
682 
683  private:
684  TDomain mySourceDomain;
685  TDomain myNewDomain;
686  // used to search a point when the resulting point is outside the source domain.
689  std::vector<TValue> myGridSize;
690  };
691 
692 
710  template <typename TDomain>
712  {
713  public:
714  typedef typename TDomain::Space Space;
715  typedef typename TDomain::Size Size;
716  typedef typename Space::Dimension Dimension;
717  typedef typename Space::Point Point;
718 
731  FlipDomainAxis(const TDomain &aSourceDomain, const std::vector<Size> & axisFlipped): mySourceDomain(aSourceDomain),
732  myAxisFlipped(axisFlipped){
733  };
734 
735 
745  inline
746  Point operator()(const Point& aPoint) const
747  {
748  Point ptRes;
749  for (Dimension dim=0; dim< Space::dimension; dim++){
750  ptRes[dim] = aPoint[dim];
751  }
752  for(Dimension i = 0; i< myAxisFlipped.size(); i++){
753  ptRes[myAxisFlipped[i]] = mySourceDomain.upperBound()[myAxisFlipped[i]]-aPoint[myAxisFlipped[i]];
754  }
755  return ptRes;
756  }
757 
758  private:
759  TDomain mySourceDomain;
760  std::vector<Size> myAxisFlipped;
761  };
762 
763 
764  template <typename TRealVector, typename TVector>
766  {
767  BOOST_STATIC_ASSERT(( TRealVector::dimension == TVector::dimension ));
768  inline
769  TVector operator () ( const TRealVector & point ) const
770  {
771  TVector out;
772  for ( unsigned int i = 0; i < TVector::dimension; i++ )
773  out[i] = std::round ( point[i] );
774  return out;
775  }
776  };
777 
778  }//namespace functors
779 } // namespace dgtal
780 
781 
783 // Includes inline functions.
784 #include "DGtal/kernel/BasicPointFunctors.ih"
785 // //
787 
788 #endif // !defined BasicPointFunctors_h
789 #undef BasicPointFunctors_RECURSES
790 #endif // else defined(BasicPointFunctors_RECURSES)
DGtal::functors::Point2DEmbedderIn3D::Point2DEmbedderIn3D
Point2DEmbedderIn3D(const TDomain3D &aDomain3DImg, const Point &anOriginPoint, const Point &anUpperPointOnAxis1, const Point &anUpperPointOnAxis2, const Point &aDefautPoint=Point(0, 0, 0))
Definition: BasicPointFunctors.h:390
DGtal::functors::FlipDomainAxis::Dimension
Space::Dimension Dimension
Definition: BasicPointFunctors.h:716
DGtal::functors::SliceRotator2D::myDimRotated
Dimension myDimRotated
Definition: BasicPointFunctors.h:334
DGtal::functors::Projector
Aim: Functor that maps a point P of dimension i to a point Q of dimension j. The member myDims is an ...
Definition: BasicPointFunctors.h:106
ConstIterator
MyDigitalSurface::ConstIterator ConstIterator
Definition: greedy-plane-segmentation-ex2.cpp:93
DGtal::functors::FlipDomainAxis::FlipDomainAxis
FlipDomainAxis(const TDomain &aSourceDomain, const std::vector< Size > &axisFlipped)
Definition: BasicPointFunctors.h:731
DGtal::functors::Projector::myDims
std::array< Dimension, dimension > myDims
Definition: BasicPointFunctors.h:155
DGtal::SpaceND::Dimension
DGtal::Dimension Dimension
Copy of the type used for the dimension.
Definition: SpaceND.h:129
DGtal::functors::PointFunctorFromPointPredicateAndDomain::BOOST_CONCEPT_ASSERT
BOOST_CONCEPT_ASSERT((concepts::CPointPredicate< PointPredicate >))
DGtal::functors::Projector::Point
Space::Point Point
Definition: BasicPointFunctors.h:112
DGtal::functors::Point2DEmbedderIn3D::Point
Space::Point Point
Definition: BasicPointFunctors.h:377
DGtal::functors::Projector::BOOST_STATIC_CONSTANT
BOOST_STATIC_CONSTANT(Dimension, dimension=Space::dimension)
DGtal::ConstAlias
Aim: This class encapsulates its parameter class so that to indicate to the user that the object/poin...
Definition: ConstAlias.h:186
DGtal::functors::Projector::Dimension
Space::Dimension Dimension
Definition: BasicPointFunctors.h:109
DGtal::functors::SliceRotator2D::Integer
Space::Integer Integer
Definition: BasicPointFunctors.h:207
DGtal::functors::PointFunctorFromPointPredicateAndDomain::myFalseValue
Value myFalseValue
Definition: BasicPointFunctors.h:565
DGtal::functors::BasicDomainSubSampler::Space
TDomain::Space Space
Definition: BasicPointFunctors.h:593
DGtal::functors::Projector::Space
S Space
Definition: BasicPointFunctors.h:108
DGtal::functors::PointFunctorFromPointPredicateAndDomain::operator=
PointFunctorFromPointPredicateAndDomain & operator=(const PointFunctorFromPointPredicateAndDomain &other)
DGtal::NumberTraits
Aim: The traits class for all models of Cinteger.
Definition: NumberTraits.h:531
DGtal::Trace::error
std::ostream & error()
DGtal::functors::BasicDomainSubSampler::Point
Space::Point Point
Definition: BasicPointFunctors.h:597
DGtal::functors::BasicDomainSubSampler::Size
TDomain::Size Size
Definition: BasicPointFunctors.h:594
DGtal::functors::PointFunctorFromPointPredicateAndDomain::PointFunctorFromPointPredicateAndDomain
PointFunctorFromPointPredicateAndDomain(ConstAlias< PointPredicate > aPtrPredicate, ConstAlias< Domain > aDomain, const Value aTrueValue, const Value aFalseValue)
Constructor.
DGtal::functors::Point2DEmbedderIn3D::Space
SpaceND< 3, TInteger > Space
Definition: BasicPointFunctors.h:376
DGtal::functors::Projector::initRemoveOneDim
void initRemoveOneDim(const Dimension &dimRemoved)
DGtal::functors::PointFunctorFromPointPredicateAndDomain
Create a point functor from a point predicate and a domain.
Definition: BasicPointFunctors.h:523
aPoint
const Point aPoint(3, 4)
DGtal::trace
Trace trace
Definition: Common.h:154
DGtal::functors::BasicDomainSubSampler::Dimension
Space::Dimension Dimension
Definition: BasicPointFunctors.h:596
DGtal::functors::SliceRotator2D::SliceRotator2D
SliceRotator2D(const Dimension &dimAdded, const TDomain3D &aDomain3DImg, const Integer &sliceIndex, const Dimension &dimRotated, const Point &ptCenter, double rotationAngle)
Definition: BasicPointFunctors.h:281
DGtal::Dimension
DGtal::uint32_t Dimension
Definition: Common.h:137
DGtal::functors::SliceRotator2D::myDefaultPoint
Point myDefaultPoint
Definition: BasicPointFunctors.h:337
DGtal::functors::SliceRotator2D::Point
Space::Point Point
Definition: BasicPointFunctors.h:206
DGtal::functors::SliceRotator2D::myPosDimAdded
Dimension myPosDimAdded
Definition: BasicPointFunctors.h:330
DGtal::functors::Point2DEmbedderIn3D::mySecondAxisEmbeddedDirection
Space::RealPoint mySecondAxisEmbeddedDirection
Definition: BasicPointFunctors.h:514
DGtal::functors::SliceRotator2D::Dimension
Space::Dimension Dimension
Definition: BasicPointFunctors.h:205
DGtal::functors::VectorRounding
Definition: BasicPointFunctors.h:765
DGtal::functors::FlipDomainAxis::Size
TDomain::Size Size
Definition: BasicPointFunctors.h:715
dim
unsigned int dim(const Vector &z)
Definition: viewDualSurface.cpp:174
DGtal::PointVector< dim, Integer >::diagonal
static Self diagonal(Component val=1)
DGtal::functors::SliceRotator2D::SliceRotator2D
SliceRotator2D(const Dimension &dimAdded, const TDomain3D &aDomain3DImg, const Integer &sliceIndex, const Dimension &dimRotated, const Point &ptCenter, double rotationAngle, const Point &defaultPoint)
Definition: BasicPointFunctors.h:263
DGtal::functors::Projector::Projector
Projector(const Integer &aDefaultInteger=NumberTraits< Integer >::zero())
DGtal::functors::PointFunctorFromPointPredicateAndDomain::Point
Domain::Point Point
Definition: BasicPointFunctors.h:528
DGtal::functors::Point2DEmbedderIn3D::Integer
Space::Integer Integer
Definition: BasicPointFunctors.h:378
DGtal::functors::PointFunctorFromPointPredicateAndDomain::myTrueValue
Value myTrueValue
Definition: BasicPointFunctors.h:564
DGtal::functors::BasicDomainSubSampler::operator()
Point operator()(const Point &aPoint) const
Definition: BasicPointFunctors.h:647
DGtal::functors::Projector::myDefaultInteger
Integer myDefaultInteger
Definition: BasicPointFunctors.h:161
Size
HalfEdgeDataStructure::Size Size
Definition: testHalfEdgeDataStructure.cpp:50
DGtal::functors::Point2DEmbedderIn3D::myDefaultPoint
Point myDefaultPoint
Definition: BasicPointFunctors.h:508
DGtal::PointVector< dim, Integer >::Component
Integer Component
Type for Vector elements.
Definition: PointVector.h:614
DGtal::SpaceND
Definition: SpaceND.h:95
DGtal::functors::SliceRotator2D::Space
SpaceND< 3, TInteger > Space
Definition: BasicPointFunctors.h:204
DGtal::functors::FlipDomainAxis::Space
TDomain::Space Space
Definition: BasicPointFunctors.h:714
DGtal::functors::BasicDomainSubSampler::IntergerDom
TDomain::Integer IntergerDom
Definition: BasicPointFunctors.h:595
DGtal::functors::FlipDomainAxis
Aim: Functor that flips the domain coordinate system from some selected axis. For instance,...
Definition: BasicPointFunctors.h:711
DGtal::functors::FlipDomainAxis::Point
Space::Point Point
Definition: BasicPointFunctors.h:717
DGtal::functors::SliceRotator2D::myDomain
TDomain3D myDomain
Definition: BasicPointFunctors.h:333
DGtal::concepts::CDomain
Aim: This concept represents a digital domain, i.e. a non mutable subset of points of the given digit...
Definition: CDomain.h:129
DGtal::functors::FlipDomainAxis::mySourceDomain
TDomain mySourceDomain
Definition: BasicPointFunctors.h:759
DGtal
DGtal is the top-level namespace which contains all DGtal functions and types.
DGtal::functors::SliceRotator2D::myRotationAngle
double myRotationAngle
Definition: BasicPointFunctors.h:335
DGtal::functors::BasicDomainSubSampler::BasicDomainSubSampler
BasicDomainSubSampler(const TDomain &aSourceDomain, const std::vector< TValue > &aGridSize, const Point &aGridShift)
Definition: BasicPointFunctors.h:610
DGtal::functors::FlipDomainAxis::myAxisFlipped
std::vector< Size > myAxisFlipped
Definition: BasicPointFunctors.h:760
DGtal::functors::PointFunctorFromPointPredicateAndDomain::PointPredicate
TPointPredicate PointPredicate
Definition: BasicPointFunctors.h:525
DGtal::SpaceND::dimension
static const Dimension dimension
static constants to store the dimension.
Definition: SpaceND.h:132
DGtal::functors::Point2DEmbedderIn3D::myOriginPointEmbeddedIn3D
Point myOriginPointEmbeddedIn3D
Definition: BasicPointFunctors.h:506
DGtal::functors::PointFunctorFromPointPredicateAndDomain::myDomain
const Domain * myDomain
Definition: BasicPointFunctors.h:563
DGtal::functors::BasicDomainSubSampler
Aim: Functor that subsamples an initial domain by given a grid size and a shift vector....
Definition: BasicPointFunctors.h:590
DGtal::functors::SliceRotator2D
Special Point Functor that adds one dimension to a 2D point and apply on it a rotation of angle alpha...
Definition: BasicPointFunctors.h:200
DGtal::functors::Point2DEmbedderIn3D::Point2DEmbedderIn3D
Point2DEmbedderIn3D(const TDomain3D &aDomain3DImg, const Point &anOriginPoint, const typename Space::RealPoint &anNormalVector, const typename Point::Component &anWidth, const Point &aDefautPoint=Point(0, 0, 0))
Definition: BasicPointFunctors.h:422
DGtal::functors::Projector::Integer
Space::Integer Integer
Definition: BasicPointFunctors.h:111
DGtal::functors::SliceRotator2D::SliceRotator2D
SliceRotator2D(const Dimension &dimAdded, const TDomain3D &aDomain3DImg, const Integer &sliceIndex, const Dimension &dimRotated, double rotationAngle)
Definition: BasicPointFunctors.h:218
DGtal::functors::Projector::initAddOneDim
void initAddOneDim(const Dimension &newDim)
DGtal::concepts::CQuantity
Aim: defines the concept of quantity in DGtal.
Definition: CQuantity.h:92
DGtal::functors::Point2DEmbedderIn3D::myDomain
TDomain3D myDomain
Definition: BasicPointFunctors.h:503
Integer
Point::Coordinate Integer
Definition: examplePlaneProbingParallelepipedEstimator.cpp:44
DGtal::functors::VectorRounding::BOOST_STATIC_ASSERT
BOOST_STATIC_ASSERT((TRealVector::dimension==TVector::dimension))
DGtal::functors::BasicDomainSubSampler::myGridSampleDomain
TDomain myGridSampleDomain
Definition: BasicPointFunctors.h:687
DGtal::functors::SliceRotator2D::SliceRotator2D
SliceRotator2D(const Dimension &dimAdded, const TDomain3D &aDomain3DImg, const Integer &sliceIndex, const Dimension &dimRotated, double rotationAngle, const Point &defaultPoint)
Definition: BasicPointFunctors.h:240
DGtal::functors::PointFunctorFromPointPredicateAndDomain::myPtrPredicate
const PointPredicate * myPtrPredicate
Definition: BasicPointFunctors.h:562
DGtal::PointVector::norm
double norm(const NormType type=L_2) const
DGtal::functors::SliceRotator2D::myCenter
PointVector< 3, double > myCenter
Definition: BasicPointFunctors.h:336
DGtal::functors::SliceRotator2D::operator()
Point operator()(const TPointDimMinus &aPoint) const
Definition: BasicPointFunctors.h:296
DGtal::PointVector< dim, Integer >
DGtal::functors::PointFunctorFromPointPredicateAndDomain::Domain
TDomain Domain
Definition: BasicPointFunctors.h:526
DGtal::functors::Projector::init
void init(const TIterator &itb, const TIterator &ite)
DGtal::concepts::CPointPredicate
Aim: Defines a predicate on a point.
Definition: CPointPredicate.h:80
DGtal::functors::PointFunctorFromPointPredicateAndDomain::operator()
Value operator()(const Point &aPoint) const
operator ()
DGtal::functors::FlipDomainAxis::operator()
Point operator()(const Point &aPoint) const
Definition: BasicPointFunctors.h:746
Space
SpaceND< 2 > Space
Definition: testSimpleRandomAccessRangeFromPoint.cpp:42
DGtal::functors::BasicDomainSubSampler::myNewDomain
TDomain myNewDomain
Definition: BasicPointFunctors.h:685
DGtal::functors::BasicDomainSubSampler::mySourceDomain
TDomain mySourceDomain
Definition: BasicPointFunctors.h:684
DGtal::functors::BasicDomainSubSampler::getSubSampledDomain
const TDomain & getSubSampledDomain()
Definition: BasicPointFunctors.h:679
DGtal::Trace::warning
std::ostream & warning()
DGtal::functors::Point2DEmbedderIn3D::operator()
Point operator()(const TPoint2D &aPoint, bool checkInsideDomain=true) const
Definition: BasicPointFunctors.h:478
DGtal::functors::VectorRounding::operator()
TVector operator()(const TRealVector &point) const
Definition: BasicPointFunctors.h:769
DGtal::functors::PointFunctorFromPointPredicateAndDomain::Value
TValue Value
Definition: BasicPointFunctors.h:527
DGtal::functors::BasicDomainSubSampler::myGridShift
Point myGridShift
Definition: BasicPointFunctors.h:688
DGtal::PointVector::size
static Dimension size()
DGtal::SpaceND::Integer
TInteger Integer
Arithmetic ring induced by (+,-,*) and Integer numbers.
Definition: SpaceND.h:102
DGtal::functors::BasicDomainSubSampler::myGridSize
std::vector< TValue > myGridSize
Definition: BasicPointFunctors.h:689
DGtal::functors::SliceRotator2D::mySliceIndex
Integer mySliceIndex
Definition: BasicPointFunctors.h:332
DGtal::functors::Projector::operator()
Point operator()(const TInputPoint &aPoint) const
DGtal::functors::Point2DEmbedderIn3D
Aim: Functor that embeds a 2D point into a 3D space from two axis vectors and an origin point given i...
Definition: BasicPointFunctors.h:372
DGtal::functors::Point2DEmbedderIn3D::myFirstAxisEmbeddedDirection
Space::RealPoint myFirstAxisEmbeddedDirection
Definition: BasicPointFunctors.h:511