DrawWithDisplay3DModifier.h

#pragma once

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

#define DrawWithDisplay3DModifier_RECURSES

#if !defined DrawWithDisplay3DModifier_h

#define DrawWithDisplay3DModifier_h

// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/CountedPtr.h"
#include "DGtal/helpers/StdDefs.h"



namespace DGtal
{

  struct DrawWithDisplay3DModifier {
    std::string className() const
    {
      return "DrawWithDisplay3DModifier";
    }

    /*DrawableWithDisplay3D* defaultStyleDisplay3D( std::string = "" ) const
    {
      return 0;
    }*/

    /*virtual void setStyleDisplay3D( Display3D &  ) const 
    {}*/
  };






  struct SetMode3D : public DrawWithDisplay3DModifier {
    SetMode3D( std::string classname, std::string mode )
      : myClassname( classname ), myMode( mode )
    {}
    
    /*void setStyleDisplay3D( Display3D & display ) const
    {
      display.myModes[ myClassname ] = myMode;
    }*/
    
    std::string myClassname;
    std::string myMode;
  };




  struct CustomStyle3D : public DrawWithDisplay3DModifier {
    CustomStyle3D( std::string classname, DrawableWithDisplay3D* style )
      : myClassname( classname ), myStyle( style )
    {}

    std::string className() const
    {
      return "CustomStyle3D";
    }

    /*void setStyleDisplay3D( Display3D & display ) const
    {
      display.myStyles[ myClassname ] = myStyle;
    }*/

    std::string myClassname;
    CountedPtr<DrawableWithDisplay3D> myStyle;
  };



  
  struct CustomColors3D : public DrawWithDisplay3DModifier
  {
    Color myPenColor;
    Color myFillColor;

    CustomColors3D( const Color & penColor,
        const Color & fillColor )
      : myPenColor( penColor ), myFillColor( fillColor )
    {}
    
    /*virtual void setStyleDisplay3D( Display3D & display) const
    {
      display.setFillColor(myFillColor);
      display.setLineColor(myPenColor);
    }*/
  };



  
  struct ClippingPlane : public DrawWithDisplay3DModifier {
    ClippingPlane( double a, double b, double c, double d, bool drawPlane=true )
      : myA( a ), myB( b ), myC( c ), myD ( d ), myDrawPlane(drawPlane)  
    {}
    
    // MT: why setStyleViewer3D here and not setStyleDisplay3D ???
    /*void setStyleViewer3D( Display3D & display ) const
    {
      display.addClippingPlane(myA, myB, myC, myD, myDrawPlane);
    }*/
    
    double * getEquation(){
      double *r = new double[4];
      r[0] = myA;
      r[1] = myB;
      r[2] = myC;
      r[3] = myD;
      return r;
    } 
    
    double myA;
    double myB;
    double myC;
    double myD;
    bool myDrawPlane;
  };


  struct CameraPosition : public DrawWithDisplay3DModifier
  {
    CameraPosition( const double x, const double y, const double z )
    {
      eyex=x; eyey=y; eyez=z;
    }
    
    /*void setStyleDisplay3D( Display3D & display) const
    {
      display.setCameraPosition(eyex, eyey, eyez);
    }*/
    
      double eyex, eyey, eyez;
  };
  
  struct CameraDirection : public DrawWithDisplay3DModifier
  {
    CameraDirection( const double x, const double y, const double z )
    {
      dirx=x; diry=y; dirz=z;
    }
    
    /*virtual void setStyleDisplay3D( Display3D & display) const
    {
      display.setCameraDirection(dirx, diry, dirz);
    }*/
    
      double dirx, diry, dirz;
  };
  
  struct CameraUpVector : public DrawWithDisplay3DModifier
  {
    CameraUpVector( const double x, const double y, const double z )
    {
      upx=x; upy=y; upz=z;
    }
    
    /*virtual void setStyleDisplay3D( Display3D & viewer) const
    {
      viewer.setCameraUpVector(upx, upy, upz);
    }*/
    
      double upx, upy, upz;
  };
  
  struct CameraZNearFar : public DrawWithDisplay3DModifier
  {
    CameraZNearFar( const double _near, const double _far )
    {
      ZNear=_near; ZFar=_far;
    }
    
    /*virtual void setStyleDisplay3D( Display3D & viewer) const
    {
      viewer.setNearFar(ZNear, ZFar);
    }*/
    
      double ZNear, ZFar;
  };

 

  struct TransformedKSSurfel : public DrawWithDisplay3DModifier
  {
    TransformedKSSurfel( const DGtal::Z3i::SCell  & aSurfel, double aShift, double aSizeFactor=1.0 )
    {
      mySurfel= aSurfel;
      myShift = aShift;
      mySizeFactor=aSizeFactor;
    }

    TransformedKSSurfel( const DGtal::Z3i::SCell  & aSurfel, const DGtal::Z3i::SCell  & aVoxel, 
                         double aShift=0.05, double aSizeFactor=0.75  )
    {      
      mySurfel= aSurfel;
      myShift = aShift;
      mySizeFactor = aSizeFactor;
      bool xodd = (mySurfel.myCoordinates[ 0 ] & 1 );
      bool yodd = (mySurfel.myCoordinates[ 1 ] & 1 );
      bool zodd = (mySurfel.myCoordinates[ 2 ] & 1 );
      if(!xodd ){
        myShift*= ((aVoxel.myCoordinates[ 0 ]-mySurfel.myCoordinates[ 0 ] <0)? -1.0: 1.0);
      }else if(!yodd ){
        myShift*=((aVoxel.myCoordinates[ 1 ]-mySurfel.myCoordinates[ 1 ] <0)? -1.0: 1.0);
      }else if(!zodd ){
        myShift*=((aVoxel.myCoordinates[ 2 ]-mySurfel.myCoordinates[ 2 ] <0)? -1.0: 1.0);
      }
    }
    
    DGtal::Z3i::SCell mySurfel;
    double myShift;
    double mySizeFactor;
  };

 



} // namespace DGtal




//                                                                           //

#endif // !defined DrawWithDisplay3DModifier_h

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