DrawWithViewer3DModifier.h

#pragma once

#if defined(DrawWithViewer3DModifier_RECURSES)
#error Recursive header files inclusion detected in DrawWithViewer3DModifier.h
#else // defined(DrawWithViewer3DModifier_RECURSES)

#define DrawWithViewer3DModifier_RECURSES

#if !defined DrawWithViewer3DModifier_h

#define DrawWithViewer3DModifier_h

// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/Alias.h"
#include "DGtal/base/ConstAlias.h"
#include "DGtal/images/CConstImage.h"
#include "DGtal/base/CountedPtr.h"
#include "DGtal/topology/KhalimskySpaceND.h"
#include "DGtal/io/DrawWithDisplay3DModifier.h"

namespace DGtal
{

  struct DrawWithViewer3DModifier : public DrawWithDisplay3DModifier
  {
    std::string className() const;
  };


#ifndef DrawWithBoard3DTo2DModifier_h

  struct CameraPosition : public DrawWithViewer3DModifier
  {
    CameraPosition( const double x, const double y, const double z ):eyex(x), eyey(y), eyez(z)
    {
    }

    double eyex, eyey, eyez;
  };


  struct CameraDirection : public DrawWithViewer3DModifier
  {
    CameraDirection( const double x, const double y, const double z ): dirx(x), diry(y), dirz(z)
    {
    }

    double dirx, diry, dirz;
  };


  struct CameraUpVector : public DrawWithViewer3DModifier
  {
    CameraUpVector( const double x, const double y, const double z ): upx(x), upy(y), upz(z)
    {
      upx=x; upy=y; upz=z;
    }

    double upx, upy, upz;
  };



  struct CameraZNearFar : public DrawWithViewer3DModifier
  {
    CameraZNearFar( const double near, const double far ): ZNear(near), ZFar(far)
    {
    }
    double ZNear, ZFar;
  };

#endif


  

  template < typename Space, typename KSpace>
  struct UpdateImage3DEmbedding : public DrawWithViewer3DModifier
  {

    UpdateImage3DEmbedding(unsigned int anIndex, 
                           typename Space::Point aPoint1, typename Space::Point aPoint2,
                           typename Space::Point aPoint3, typename Space::Point aPoint4): myIndex(anIndex),
                                                                                          myNewPoint1(aPoint1),
                                                                                          myNewPoint2(aPoint2),
                                                                                          myNewPoint3(aPoint3),
                                                                                          myNewPoint4(aPoint4)
    {
    }
    unsigned int myIndex;
    typename Space::Point myNewPoint1;
    typename Space::Point myNewPoint2;
    typename Space::Point myNewPoint3;
    typename Space::Point myNewPoint4;
  };
    
    
  template < typename Space, typename KSpace>
  struct UpdateImagePosition : public DrawWithViewer3DModifier
  {

    UpdateImagePosition(unsigned int anIndex,typename Viewer3D<Space,KSpace>::ImageDirection newDir,
                        double posXbottomLeft, double posYbottomLeft, double posZbottomLeft ):  myIndex(anIndex),
                                                                                                myPosXBottomLeft(posXbottomLeft),
                                                                                                myPosYBottomLeft(posYbottomLeft),
                                                                                                myPosZBottomLeft(posZbottomLeft),
                                                                                                myNewDirection(newDir)
    {}

    unsigned int myIndex;
    double  myPosXBottomLeft;
    double  myPosYBottomLeft;
    double  myPosZBottomLeft;
    typename Viewer3D<Space,KSpace>::ImageDirection myNewDirection;
  };



  template <typename TImageType, typename TFunctor, typename Space, typename KSpace>
  struct AddTextureImage2DWithFunctor : public DrawWithViewer3DModifier
  {
    BOOST_CONCEPT_ASSERT((  concepts::CConstImage<TImageType> )) ;
    typedef typename Viewer3D<Space,KSpace>::TextureMode TTextureMode;
    
    AddTextureImage2DWithFunctor(ConstAlias<TImageType> anImage,
                                 Clone<TFunctor> aFunctor,
                                 TTextureMode aMode = TTextureMode::GrayScaleMode): my2DImage(&anImage),
                                                                                    myFunctor(aFunctor),
                                                                                    myMode(aMode)
    {

    }
    const TImageType *my2DImage;
    const TFunctor myFunctor;
    TTextureMode myMode;
  };

  template <typename TImageType, typename TFunctor, typename Space, typename KSpace>
  struct AddTextureImage3DWithFunctor : public DrawWithViewer3DModifier
  {
    BOOST_CONCEPT_ASSERT((  concepts::CConstImage<TImageType> )) ;
    typedef typename Viewer3D<Space,KSpace>::TextureMode TTextureMode;
    AddTextureImage3DWithFunctor(ConstAlias<TImageType> anImage,
                                 Clone<TFunctor> aFunctor,
                                 TTextureMode aMode =
                                 TTextureMode::GrayScaleMode): my3DImage(&anImage),
                                                                         myFunctor(aFunctor),
                                                                         myMode(aMode)
    {

    }
    const TImageType *my3DImage;
    const TFunctor myFunctor;
    TTextureMode myMode;
  };



  template < typename Space, typename KSpace>
  struct UpdateLastImagePosition : public DrawWithViewer3DModifier
  {

    UpdateLastImagePosition( typename Viewer3D<Space, KSpace>::ImageDirection newDir,
                             double posXbottomLeft, double posYbottomLeft, double posZbottomLeft ):
      myPosXBottomLeft(posXbottomLeft),
      myPosYBottomLeft(posYbottomLeft),
      myPosZBottomLeft(posZbottomLeft),
      myNewDirection(newDir)
    {

    }
    double  myPosXBottomLeft;
    double  myPosYBottomLeft;
    double  myPosZBottomLeft;
    typename Viewer3D<Space, KSpace>::ImageDirection myNewDirection;
  };




  template<typename TImageType, typename TFunctor= functors::Cast<unsigned int> >
  struct UpdateImageData : public DrawWithViewer3DModifier
  {

    UpdateImageData(unsigned int anIndex, ConstAlias<TImageType> anImage, double translateX=0,
                    double translateY=0, double translateZ=0,
                    double rotationAngle=0.0, typename Viewer3D<>::ImageDirection dirRotation=Viewer3D<>::zDirection,
                    Clone<TFunctor> aFunctor = TFunctor() ): myIndex(anIndex),
                                                           myImage(&anImage),
                                                           myTranslateX (translateX),
                                                           myTranslateY (translateY),
                                                           myTranslateZ (translateZ),
                                                           myFunctor(aFunctor),
                                                           myRotationAngle(rotationAngle),
                                                           myRotationDir(dirRotation)
    {}

    unsigned int myIndex;
    const TImageType *myImage;
    int myTranslateX;
    int myTranslateY;
    int myTranslateZ;
    const TFunctor myFunctor;
    double myRotationAngle;
    typename Viewer3D<>::ImageDirection  myRotationDir;
   };




  struct Translate2DDomain : public DrawWithViewer3DModifier
  {

    Translate2DDomain(unsigned int anIndex, double translateX=0,
                      double translateY=0, double translateZ=0 ): myIndex(anIndex),
                                                                  myTranslateX (translateX),
                                                                  myTranslateY (translateY),
                                                                  myTranslateZ (translateZ)
    { }

    unsigned int myIndex;
    int myTranslateX;
    int myTranslateY;
    int myTranslateZ;
  };






  template < typename Space, typename KSpace>
  struct Update2DDomainPosition : public DrawWithViewer3DModifier
  {

    Update2DDomainPosition(unsigned int anIndex, typename Viewer3D<Space,KSpace>::ImageDirection newDir,
                           double posXbottomLeft, double posYbottomLeft, double posZbottomLeft ):  myIndex(anIndex),
                                                                                                   myPosXBottomLeft(posXbottomLeft),
                                                                                                   myPosYBottomLeft(posYbottomLeft),
                                                                                                   myPosZBottomLeft(posZbottomLeft),
      myNewDirection(newDir)
    { }

    unsigned int myIndex;
    double  myPosXBottomLeft;
    double  myPosYBottomLeft;
    double  myPosZBottomLeft;
    typename Viewer3D<Space, KSpace>::ImageDirection myNewDirection;
  };




} // namespace DGtal


//                                                                           //

#endif // !defined DrawWithViewer3DModifier_h

#undef DrawWithViewer3DModifier_RECURSES
#endif // else defined(DrawWithViewer3DModifier_RECURSES)