DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger > Class Template Reference

Aim: Functor that embeds a 2D point into a 3D space from two axis vectors and an origin point given in the 3D space. More...

#include <DGtal/kernel/BasicPointFunctors.h>

Public Types
typedef SpaceND< 3, TInteger >	Space
typedef Space::Point	Point
typedef Space::Integer	Integer

Public Member Functions
	Point2DEmbedderIn3D (const TDomain3D &aDomain3DImg, const Point &anOriginPoint, const Point &anUpperPointOnAxis1, const Point &anUpperPointOnAxis2, const Point &aDefautPoint=Point(0, 0, 0))
	Point2DEmbedderIn3D (const TDomain3D &aDomain3DImg, const Point &anOriginPoint, const typename Space::RealPoint &aNormalVector, const typename Point::Component &aWidth, const Point &aDefautPoint=Point(0, 0, 0))
	Point2DEmbedderIn3D (const TDomain3D &aDomain3DImg, const Point &anOriginPoint, const typename Space::RealPoint &aNormalVector, const typename Space::RealPoint &orientXaxisVector, const typename Point::Component &aWidth, const Point &aDefautPoint=Point(0, 0, 0))
template<typename TPoint2D >
Point	operator() (const TPoint2D &aPoint, bool checkInsideDomain=true) const
void	shiftOriginPoint (const typename Space::RealPoint &shift)

Private Attributes
TDomain3D	myDomain
Space::RealPoint	myOriginPointEmbeddedIn3D
Point	myDefaultPoint
Space::RealPoint	myFirstAxisEmbeddedDirection
Space::RealPoint	mySecondAxisEmbeddedDirection

Detailed Description

template<typename TDomain3D, typename TInteger = DGtal::Z3i::Integer>
class DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >

Aim: Functor that embeds a 2D point into a 3D space from two axis vectors and an origin point given in the 3D space.

Description of template class 'Point2DEmbedderIn3D'

It also checks if the resulting point is inside the 3D domain, else it returns a particular point (by default the point at domain origin (from the domain method lowerBound())).

It can be used to extract 2D images from volumetric files. For instance (see full example images/extract2DImagesFrom3D.cpp):

• First some image types and ConstImageAdapter are defined to exploit the functor:

     typedef ImageSelector < Z3i::Domain, unsigned char>::Type Image3D;
     typedef DGtal::ConstImageAdapter<Image3D, Z2i::Domain, DGtal::functors::Point2DEmbedderIn3D<DGtal::Z3i::Domain>,
                                      Image3D::Value,  DGtal::functors::Identity >  ImageAdapterExtractor;

• Then, we define the origin point and axis vector used to extract 2D image values and we also deduce the associated 2D domain:

     DGtal::Z3i::Point origin(150, 150, 10);
     DGtal::Z3i::Point ptUpper1(220, 220, 10);
     DGtal::Z3i::Point ptUpper2(150, 150, 50);
     DGtal::Z2i::Domain domainImage2D (DGtal::Z2i::Point(0,0),
                                       DGtal::Z2i::Point(static_cast<int>((ptUpper1-origin).norm()),
                                                         static_cast<int>((ptUpper2-origin).norm())));

• The 2D image we can now be constructed from the embeder and from the ConstImageAdapter class:

       DGtal::functors::Point2DEmbedderIn3D<DGtal::Z3i::Domain >  embedder(domainImage3D, origin+DGtal::Z3i::Point(i,i,0),
                                                                 ptUpper1+DGtal::Z3i::Point(i,i,0),
                                                                 ptUpper2+DGtal::Z3i::Point(i,i,0));
   
       ImageAdapterExtractor extractedImage(image, domainImage2D, embedder, idV);

• Alternatively, you can also construct the same functor from a reference center point, a normal, and a size:

       DGtal::functors::Point2DEmbedderIn3D<DGtal::Z3i::Domain >  embedder2(domainImage3D, ptCenter+DGtal::Z3i::Point(i,i,0),
                                                                  DGtal::Z3i::RealPoint(1,-1,0),
                                                                  IMAGE_PATCH_WIDTH);
       ImageAdapterExtractor extractedImage2(image, domainImage2D2, embedder2, idV);

See also

tests/kernel/testBasicPointFunctors.cpp

Template Parameters

TDomain3D	the type of the 3d domain.
TInteger	specifies the integer number type used to define the space.

Examples

images/extract2DImagesFrom3D.cpp, and io/viewers/viewer3D-8bis-2Dimages.cpp.

Definition at line 379 of file BasicPointFunctors.h.

Member Typedef Documentation

Integer

template<typename TDomain3D , typename TInteger = DGtal::Z3i::Integer>

typedef Space::Integer DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::Integer

Definition at line 385 of file BasicPointFunctors.h.

Point

template<typename TDomain3D , typename TInteger = DGtal::Z3i::Integer>

typedef Space::Point DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::Point

Definition at line 384 of file BasicPointFunctors.h.

Space

template<typename TDomain3D , typename TInteger = DGtal::Z3i::Integer>

typedef SpaceND< 3, TInteger> DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::Space

Definition at line 383 of file BasicPointFunctors.h.

Constructor & Destructor Documentation

Point2DEmbedderIn3D() [1/3]

template<typename TDomain3D , typename TInteger = DGtal::Z3i::Integer>

DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::Point2DEmbedderIn3D ( const TDomain3D &  aDomain3DImg, const Point &  anOriginPoint, const Point &  anUpperPointOnAxis1, const Point &  anUpperPointOnAxis2, const Point &  aDefautPoint = Point(0,0,0)  )

inline

Constructor. Construct the functor from an origin 3D point, and two other 3D points defining the upper part of the 2D domain.

Parameters

aDomain3DImg	the 3D domain used to keep the resulting point in the domain.
anOriginPoint	the origin point given in the 3D domain.
anUpperPointOnAxis1	the upper point given in the 3D domain to define the first axis of the 2D domain.
anUpperPointOnAxis2	the upper point given in the 3D domain to define the second axis of the 2D domain.
aDefautPoint	the point given when the resulting point is outside the domain (default Point(0,0,0)).

Definition at line 397 of file BasicPointFunctors.h.

                                                                  : myDomain(aDomain3DImg),
                                                                    myOriginPointEmbeddedIn3D(anOriginPoint),
                                                                    myDefaultPoint (aDefautPoint),
                                                                    myFirstAxisEmbeddedDirection(Point(anUpperPointOnAxis1[0]-anOriginPoint[0],
                                                                                                       anUpperPointOnAxis1[1]-anOriginPoint[1],
                                                                                                       anUpperPointOnAxis1[2]-anOriginPoint[2])),
      mySecondAxisEmbeddedDirection(Point(anUpperPointOnAxis2[0]-anOriginPoint[0],
                                          anUpperPointOnAxis2[1]-anOriginPoint[1],
                                          anUpperPointOnAxis2[2]-anOriginPoint[2]))
 
 
    {
      myFirstAxisEmbeddedDirection /= myFirstAxisEmbeddedDirection.norm();
      mySecondAxisEmbeddedDirection /= mySecondAxisEmbeddedDirection.norm();
    }

References DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::myFirstAxisEmbeddedDirection, DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::mySecondAxisEmbeddedDirection, and DGtal::PointVector< dim, TEuclideanRing, TContainer >::norm().

Point2DEmbedderIn3D() [2/3]

template<typename TDomain3D , typename TInteger = DGtal::Z3i::Integer>

DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::Point2DEmbedderIn3D ( const TDomain3D &  aDomain3DImg, const Point &  anOriginPoint, const typename Space::RealPoint &  aNormalVector, const typename Point::Component &  aWidth, const Point &  aDefautPoint = Point(0,0,0)  )

inline

Constructor. Construct the functor from an origin 3D point, an normal vector (normal to the 2D domain), and a width. The points of an 2D domain are embedded in 3D by using a normal vector giving the direction of the 2D domain embedded in the 3D space.

Parameters

aDomain3DImg	the 3D domain used to keep the resulting point in the domain.
anOriginPoint	the center point given in the 3D domain.
aNormalVector	the normal vector to the 2d domain embedded in 3D.
aWidth	the width to determine the 2d domain bounds (the resulting 2d domain will be a square of length aWidth).
aDefautPoint	the point given when the resulting point is outside the domain (default Point(0,0,0)).

Definition at line 429 of file BasicPointFunctors.h.

                                                                  : myDomain(aDomain3DImg),
                                                                    myDefaultPoint (aDefautPoint)
    {
      double d = -aNormalVector[0]*anOriginPoint[0] - aNormalVector[1]*anOriginPoint[1] - aNormalVector[2]*anOriginPoint[2];
      typename Space::RealPoint pRefOrigin;
      if(aNormalVector[0]!=0){
        pRefOrigin [0]= -d/aNormalVector[0];
        pRefOrigin [1]= 0.0;
        pRefOrigin [2]= 0.0;
        if(pRefOrigin==anOriginPoint){
          pRefOrigin[1]=-1.0;
        }
      }else if (aNormalVector[1]!=0){
        pRefOrigin [0]= 0.0;
        pRefOrigin [1]= -d/aNormalVector[1];
        pRefOrigin [2]= 0.0;
        if(pRefOrigin==anOriginPoint){
          pRefOrigin[0]=-1.0;
        }
      }else if (aNormalVector[2]!=0){
        pRefOrigin [0]= 0.0;
        pRefOrigin [1]= 0.0;
        pRefOrigin [2]= -d/aNormalVector[2];
        if(pRefOrigin==anOriginPoint){
          pRefOrigin[0]=-1.0;
        }
      }
      typename Space::RealPoint uDir1;
      uDir1=(pRefOrigin-anOriginPoint)/((pRefOrigin-anOriginPoint).norm());
      typename Space::RealPoint uDir2;
      uDir2[0] = uDir1[1]*aNormalVector[2]-uDir1[2]*aNormalVector[1];
      uDir2[1] = uDir1[2]*aNormalVector[0]-uDir1[0]*aNormalVector[2];
      uDir2[2] = uDir1[0]*aNormalVector[1]-uDir1[1]*aNormalVector[0];
 
      uDir2/=uDir2.norm();
      
      myOriginPointEmbeddedIn3D = anOriginPoint + Point(uDir1*aWidth/2) + Point(uDir2*aWidth/2);
      myFirstAxisEmbeddedDirection = -uDir1;
      mySecondAxisEmbeddedDirection = -uDir2;
    }

References DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::myFirstAxisEmbeddedDirection, DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::myOriginPointEmbeddedIn3D, DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::mySecondAxisEmbeddedDirection, and DGtal::PointVector< dim, TEuclideanRing, TContainer >::norm().

Point2DEmbedderIn3D() [3/3]

template<typename TDomain3D , typename TInteger = DGtal::Z3i::Integer>

DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::Point2DEmbedderIn3D ( const TDomain3D &  aDomain3DImg, const Point &  anOriginPoint, const typename Space::RealPoint &  aNormalVector, const typename Space::RealPoint &  orientXaxisVector, const typename Point::Component &  aWidth, const Point &  aDefautPoint = Point(0,0,0)  )

inline

Constructor. Construct the functor from an origin 3D point, an normal vector (normal to the 2D domain), another vector fixing the direction of the the image plane (from the x axis) and a width. The points of an 2D domain are embedded in 3D by using a normal vector giving the direction of the 2D domain embedded in the 3D space.

Parameters

aDomain3DImg	the 3D domain used to keep the resulting point in the domain.
anOriginPoint	the center point given in the 3D domain.
aNormalVector	the normal vector to the 2d domain embedded in 3D.
orientXaxisVector	the vector determining the 3D orientation of the image plane (from the x axis).
aWidth	the width to determine the 2d domain bounds (the resulting 2d domain will be a square of length aWidth).
aDefautPoint	the point given when the resulting point is outside the domain (default Point(0,0,0)).

Definition at line 487 of file BasicPointFunctors.h.

                                                                  : myDomain(aDomain3DImg),
                                                                    myDefaultPoint (aDefautPoint)
    {
     
      typename Space::RealPoint uDir1;
      uDir1 = orientXaxisVector/orientXaxisVector.norm();
      typename Space::RealPoint uDir2;
      uDir2[0] = uDir1[1]*aNormalVector[2]-uDir1[2]*aNormalVector[1];
      uDir2[1] = uDir1[2]*aNormalVector[0]-uDir1[0]*aNormalVector[2];
      uDir2[2] = uDir1[0]*aNormalVector[1]-uDir1[1]*aNormalVector[0];
      uDir2/=uDir2.norm();
      myOriginPointEmbeddedIn3D = anOriginPoint + Point(-uDir1*aWidth/2) + Point(-uDir2*aWidth/2);
      myFirstAxisEmbeddedDirection = uDir1;
      mySecondAxisEmbeddedDirection = uDir2;
    }

References DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::myFirstAxisEmbeddedDirection, DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::myOriginPointEmbeddedIn3D, DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::mySecondAxisEmbeddedDirection, and DGtal::PointVector< dim, TEuclideanRing, TContainer >::norm().

Member Function Documentation

operator()()

template<typename TDomain3D , typename TInteger = DGtal::Z3i::Integer>

template<typename TPoint2D >

Point DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::operator() ( const TPoint2D &  aPoint, bool  checkInsideDomain = true  ) const

inline

The operator just recover the 3D Point associated to the Point2DEmbederIn3D parameters.

Parameters

[in]	aPoint	point of the input domain (of dimension 2).
	checkInsideDomain	if 'true', checks that the point lies inside the domain.

Returns

the digital point of dimension 3 (value rounded downward with floor).

Definition at line 517 of file BasicPointFunctors.h.

    {
      Point pt ;
      for( Dimension i=0; i<pt.size(); i++){
 
        pt[i] = static_cast<Integer>(floor(NumberTraits<Integer>::castToDouble(aPoint[0])
                                                 *myFirstAxisEmbeddedDirection[i]+myOriginPointEmbeddedIn3D[i]));
        pt[i] += static_cast<Integer>(floor(NumberTraits<Integer>::castToDouble(aPoint[1])
                                                 *mySecondAxisEmbeddedDirection[i]));
      }
 
      if(myDomain.isInside(pt)|| !checkInsideDomain)
        {
          return pt;
        }
      else
        {
#ifdef DEBUG_VERBOSE
          trace.warning() << "Warning pt outside the 3D domain " << pt << std::endl;
#endif
          return  myDefaultPoint;
        }
    }

References aPoint, DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::myDefaultPoint, DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::myDomain, DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::myFirstAxisEmbeddedDirection, DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::myOriginPointEmbeddedIn3D, DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::mySecondAxisEmbeddedDirection, DGtal::PointVector< dim, TEuclideanRing, TContainer >::size(), DGtal::trace, and DGtal::Trace::warning().

shiftOriginPoint()

template<typename TDomain3D , typename TInteger = DGtal::Z3i::Integer>

void DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::shiftOriginPoint ( const typename Space::RealPoint &  shift )

inline

Shift the image plane center of the functor (without modify the the image plane direction).

Parameters

[in]

shift

direction.

Definition at line 548 of file BasicPointFunctors.h.

      {
       for( Dimension i=0; i<myOriginPointEmbeddedIn3D.size(); i++){
         myOriginPointEmbeddedIn3D[i] = myOriginPointEmbeddedIn3D[i] + shift[i];
       }
      }

References DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::myOriginPointEmbeddedIn3D, and DGtal::PointVector< dim, TEuclideanRing, TContainer >::size().

Referenced by testProjector().

Field Documentation

myDefaultPoint

template<typename TDomain3D , typename TInteger = DGtal::Z3i::Integer>

Point DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::myDefaultPoint

private

Definition at line 562 of file BasicPointFunctors.h.

Referenced by DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::operator()().

myDomain

template<typename TDomain3D , typename TInteger = DGtal::Z3i::Integer>

TDomain3D DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::myDomain

private

Definition at line 557 of file BasicPointFunctors.h.

Referenced by DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::operator()().

myFirstAxisEmbeddedDirection

template<typename TDomain3D , typename TInteger = DGtal::Z3i::Integer>

Space::RealPoint DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::myFirstAxisEmbeddedDirection

private

Definition at line 565 of file BasicPointFunctors.h.

Referenced by DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::operator()(), DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::Point2DEmbedderIn3D(), DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::Point2DEmbedderIn3D(), and DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::Point2DEmbedderIn3D().

myOriginPointEmbeddedIn3D

template<typename TDomain3D , typename TInteger = DGtal::Z3i::Integer>

Space::RealPoint DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::myOriginPointEmbeddedIn3D

private

Definition at line 560 of file BasicPointFunctors.h.

Referenced by DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::operator()(), DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::Point2DEmbedderIn3D(), DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::Point2DEmbedderIn3D(), and DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::shiftOriginPoint().

mySecondAxisEmbeddedDirection

template<typename TDomain3D , typename TInteger = DGtal::Z3i::Integer>

Space::RealPoint DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::mySecondAxisEmbeddedDirection

private

Definition at line 568 of file BasicPointFunctors.h.

Referenced by DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::operator()(), DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::Point2DEmbedderIn3D(), DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::Point2DEmbedderIn3D(), and DGtal::functors::Point2DEmbedderIn3D< TDomain3D, TInteger >::Point2DEmbedderIn3D().

---

The documentation for this class was generated from the following file:

• BasicPointFunctors.h