Display3D.h

#pragma once

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

#define Display3D_RECURSES

#if !defined Display3D_h

#define Display3D_h

// Inclusions
#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include "DGtal/kernel/domains/CDomain.h"
#include "DGtal/base/Common.h"
#include "DGtal/base/CountedPtr.h"
#include "DGtal/io/Color.h"
#include "DGtal/images/CImage.h"
#include "DGtal/images/CConstImage.h"
#include "DGtal/shapes/Mesh.h"

#include "DGtal/topology/CanonicCellEmbedder.h"
#include "DGtal/topology/CanonicSCellEmbedder.h"
#include "DGtal/kernel/CanonicEmbedder.h"
#include "DGtal/helpers/StdDefs.h"
#include "DGtal/io/DrawWithDisplay3DModifier.h"
#include "DGtal/kernel/CSpace.h"




namespace DGtal
{

  // class Display3D
  template < typename Space = Z3i::Space, typename KSpace = Z3i::KSpace>
  class Display3D
  {
  public:

    BOOST_CONCEPT_ASSERT((concepts::CSpace<Space>));
  public:

    typedef Display3D<Space,KSpace> Self;
    typedef typename Space::RealPoint RealPoint;
    typedef typename Space::RealVector RealVector;
    typedef CanonicEmbedder<Space> Embedder;
    typedef CanonicCellEmbedder<KSpace> CellEmbedder;
    typedef CanonicSCellEmbedder<KSpace> SCellEmbedder;

    typedef int (*SelectCallbackFct)( void* viewer, DGtal::int32_t name, void* data );

  protected:

    struct SelectCallbackFctStore {
      SelectCallbackFctStore( SelectCallbackFct _fct, 
                              void* _data,
                              DGtal::int32_t _min, DGtal::int32_t _max )
        : fct( _fct ), data( _data ), min( _min ), max( _max ) {}
      bool operator<( const SelectCallbackFctStore& other ) const
      { 
        return ( min < other.min ); // simple since there is no overlap.
      }
      bool isSelected( DGtal::int32_t name ) const
      { return ( min <= name ) && ( name <= max ); }

      SelectCallbackFct fct;
      void*             data;
      DGtal::int32_t    min;
      DGtal::int32_t    max;
    };

    struct CommonD3D {
      DGtal::Color   color; 
      DGtal::int32_t name;  

    protected:
      ~CommonD3D() = default; 
    };

    struct LineD3D : public CommonD3D {
      RealPoint point1;
      RealPoint point2;
      double width;
      bool isSigned;
      bool signPos;
    };

    struct CubeD3D : public CommonD3D {
      RealPoint center;
      double width;
    };

    struct ClippingPlaneD3D : public CommonD3D {
      double a,b,c,d;
    };


    struct QuadD3D : public CommonD3D {
      RealPoint point1;
      RealPoint point2;
      RealPoint point3;
      RealPoint point4;
      double nx, ny, nz;
    };



    struct TriangleD3D : public CommonD3D {
      RealPoint point1;
      RealPoint point2;
      RealPoint point3;
      double nx, ny, nz;
    };


  public:



    //have to be public because of external functions
    struct BallD3D : public CommonD3D
    {
      static const typename RealPoint::Dimension dimension = RealPoint::dimension;
      const double & operator[]( unsigned int i ) const
      {
        assert(i<3);
        return center[i];
      };
      double & operator[]( unsigned int i )
      {
        assert(i<3);
        return center[i];
      };
      RealPoint center;
      bool isSigned;
      bool signPos;
      double radius;
      unsigned int resolution;
    };


    struct PolygonD3D : public CommonD3D
    {
      std::vector<RealPoint> vertices;
      double nx, ny, nz;
      DGtal::Color color;
    };


    enum StreamKey {addNewList, updateDisplay, shiftSurfelVisu};


  public:
    typedef std::map<DGtal::int32_t, std::vector< QuadD3D > > QuadsMap;
    
    typedef std::map<DGtal::int32_t, std::vector< CubeD3D > > CubesMap;


  protected:
    KSpace myKSpace;
    Embedder *myEmbedder;
    CellEmbedder *myCellEmbedder;
    SCellEmbedder *mySCellEmbedder;




    //----end of private data

    // ----------------------- Standard services ------------------------------
  public:

    virtual ~Display3D()
    {
      delete myEmbedder;
      delete mySCellEmbedder;
      delete myCellEmbedder;
    }

    Display3D( const KSpace & KSEmb )
      : myKSpace( KSEmb )
      , myEmbedder( new Embedder() )
      , myCellEmbedder( new CellEmbedder( myKSpace ) )
      , mySCellEmbedder( new SCellEmbedder( myKSpace )  )
      , myBoundingPtEmptyTag( true )
      , myCurrentFillColor( 220, 220, 220 )
      , myCurrentLineColor( 22, 22, 222, 50 )
    {
    }
    
    Display3D()
      : Display3D( KSpace() )
    {
    }

    Display3D( const Display3D & ) = delete;

    Display3D( Display3D && ) = delete;

    Display3D & operator= ( const Display3D & ) = delete;

    Display3D & operator= ( Display3D && ) = delete;

    // ----------------------- Interface --------------------------------------
  public:

    const Embedder& embedder() const 
    { return *myEmbedder; }

    const CellEmbedder& cellEmbedder() const 
    { return *myCellEmbedder; }

    const SCellEmbedder& sCellEmbedder() const 
    { return *mySCellEmbedder; }

    const KSpace& space() const 
    { return myKSpace; }

    virtual void setFillColor(DGtal::Color aColor);

    virtual void setFillTransparency(unsigned char alpha);


    virtual void setLineColor(DGtal::Color aColor);


    virtual DGtal::Color getFillColor();

    virtual DGtal::Color getLineColor();

    virtual void  setKSpace( const KSpace & aKSpace );


    void setName3d( DGtal::int32_t name = -1 );

    DGtal::int32_t name3d() const;

    void setSelectCallback3D( SelectCallbackFct fct, void* data,
                              DGtal::int32_t min_name, DGtal::int32_t max_name );

    SelectCallbackFct getSelectCallback3D( DGtal::int32_t aName, void*& data ) const;

    // ----------------------- Graphical directives ----------------------------------
  public:


    void addClippingPlane(double a, double b, double c, double d, bool drawPlane);




    std::string getMode( const std::string & objectName ) const;

    void createNewLineList(std::string s= "");


    void createNewBallList(std::string s= "");


    DGtal::int32_t createNewCubeList();

    
    bool deleteCubeList(const DGtal::int32_t name);

    DGtal::int32_t createNewQuadList();


    bool deleteQuadList(const DGtal::int32_t name);

    void createNewTriangleList(std::string s= "");

    void createNewPolygonList(std::string s= "");


    void addQuad(const RealPoint &p1, const RealPoint &p2,
                 const RealPoint &p3, const RealPoint &p4);

    void addQuadWithNormal(const RealPoint &p1, const RealPoint &p2,
                           const RealPoint &p3, const RealPoint &p4,
                           const RealPoint &n,
                           const bool enableReorientation,
                           const bool enableDoubleFace = false);

    void addQuadFromSurfelCenter(const RealPoint &baseQuadCenter, 
                                 bool xSurfel, bool ySurfel, bool zSurfel);



    void addQuadFromSurfelCenterWithNormal(const RealPoint &baseQuadCenter, bool xSurfel, bool ySurfel, bool zSurfel,
                                           const RealVector &aNormal,
                                           const bool enableReorientation,
                                           const bool sign,
                                           const bool enableDoubleFace = false);


    void addTriangle(const RealPoint &p1, const RealPoint &p2, const RealPoint &p3);


    void addPolygon(const std::vector<RealPoint> &vertices);


    void addLine(const RealPoint &p1, const RealPoint &p2, const double width=0.03);


    void addCube(const RealPoint &center, double width=1.0);


    void addBall(const RealPoint &center ,
                 const double radius=0.5,
                 const unsigned int resolution = 30);



    void addPrism(const RealPoint &baseQuadCenter,
                        bool xSurfel, bool ySurfel, bool zSurfel, double sizeShiftFactor,
                        double sizeFactor=1.0, bool isSigned= false, bool aSign=true);



    void addBasicSurfel(const RealPoint &baseQuadCenter,
                        bool xSurfel, bool ySurfel, bool zSurfel);


    void addCone(const RealPoint &p1, const RealPoint &p2,
                 double width=0.08);


    void addCylinder(const RealPoint  &p1, const RealPoint &p2,
                     const double width=0.02);


    void updateBoundingBox(const RealPoint &point);




    void exportToMesh(Mesh<RealPoint> & aMesh ) const;


    template <typename TDrawableWithDisplay3D>
    Display3D & operator<<( const TDrawableWithDisplay3D & object );



    void selfDisplay ( std::ostream & out ) const;


    bool isValid() const;


    void clear();



    RealPoint embed(const typename Space::Point & dp) const ;

    RealPoint embedKS( const typename KSpace::SCell & cell ) const;


    RealPoint embedKS( const DGtal::TransformedPrism& aTrans ) const;


    RealPoint embedK( const typename KSpace::Cell & cell ) const;

    //---end interface

    // ------------------------- Protected Datas ------------------------------
  public:

    typedef std::map< std::string, std::string > ModeMapping;

    typedef std::map< std::string,CountedPtr<DrawableWithDisplay3D> > StyleMapping;


    ModeMapping myModes;
    StyleMapping myStyles;

    bool myBoundingPtEmptyTag;
    double myBoundingPtUp [3];
    double myBoundingPtLow [3];

  protected:
    //the current fill color of the display
    DGtal::Color myCurrentFillColor;
    //the current line color of the display
    DGtal::Color myCurrentLineColor;

    double myCurrentfShiftVisuPrisms;

    std::vector< std::vector<LineD3D> > myLineSetList;

    std::vector< std::vector<BallD3D> > myBallSetList;

    std::vector< ClippingPlaneD3D > myClippingPlaneList;

    std::vector< QuadD3D > myPrismList;

    QuadsMap myQuadsMap;

    std::vector<std::vector< TriangleD3D > > myTriangleSetList;

    std::vector<std::vector<PolygonD3D> > myPolygonSetList;


    CubesMap myCubesMap;


    std::vector<std::string> myCubeSetNameList;

    std::vector<std::string> myLineSetNameList;

    std::vector<std::string> myBallSetNameList;
    std::vector<std::string> myClippingPlaneNameList;

    std::vector<std::string> myPrismNameList;

    std::vector<std::string> myQuadSetNameList;

    std::vector<std::string> myTriangleSetNameList;

    std::vector<std::string> myPolygonSetNameList;

    DGtal::int32_t myName3d;

    std::set<SelectCallbackFctStore> mySelectCallBackFcts;

    //----end of protected datas

    // ------------------------- Internals ------------------------------------
  protected:

    static void cross (double dst[3], double srcA[3], double srcB[3]);

    static void normalize (double vec[3]);


  }; // end of class Display3D

  template <typename Space , typename KSpace >
  std::ostream&
  operator<< ( std::ostream & out, const DGtal::Display3D<Space , KSpace > & object );


  template <typename Space , typename KSpace >
  void
  operator>> ( const Display3D<Space , KSpace > &aDisplay3D,
               DGtal::Mesh< typename Display3D<Space , KSpace >::RealPoint > &aMesh);


  template < typename Space , typename KSpace >
  void
  operator>> ( const Display3D< Space , KSpace > &aDisplay3D, std::string aFilename);


} // namespace DGtal


// Includes inline functions.
#include "DGtal/io/Display3D.ih"


// //

#endif // !defined Display3D_h

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