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;
 
    bool myBoundingPtChangedTag = false;
 
    //----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)