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/base/Common.h"
#include "DGtal/base/CountedPtr.h"
#include "DGtal/io/Color.h"
#include "DGtal/shapes/fromPoints/MeshFromPoints.h"



namespace DGtal
{

  // class Display3D
  class Display3D
  {

 
    // ------------------------- Private Datas --------------------------------
  private:
    

  protected:
    // Used to ajust the visualisation for data where scale are not constant in the three axis.
    // Uses in Viewer3D class and on export method.
    float myScaleX;
    float myScaleY;
    float myScaleZ;
    

    
  
    struct lineD3D{
      double x1, y1, z1;
      double x2, y2, z2;
      double width;
      unsigned int R,G,B,T;
      bool isSigned;
      bool signPos;
    };
    


    struct voxelD3D{      
      int x, y,z;
      
      unsigned int R,G,B,T;
      
      double width;
    };
  
  
    struct clippingPlaneD3D{
      double a,b,c,d;
    };

  
    struct  quadD3D{
      double x1,y1,z1;
      double x2,y2,z2;
      double x3,y3,z3;
      double x4,y4,z4;    
      double nx, ny, nz;
      unsigned int R,G,B,T;
    };



    struct  triangleD3D{
      double x1,y1,z1;
      double x2,y2,z2;
      double x3,y3,z3;
      double nx, ny, nz;
      unsigned int R,G,B,T;
    };





  public:
    
    struct pointD3D{
      const double & operator[]( unsigned int i ) const{
        assert(i<3);
        switch (i){
        case 0: {return x;}
        case 1: {return y;}
        case 2: {return z;}
        }
        return x;
      };
       double & operator[]( unsigned int i ) {
        assert(i<3);
        switch (i){
        case 0: {return x;}
        case 1: {return y;}
        case 2: {return z;}
        }
        return x;
      };
      double  x, y, z;
      unsigned int R,G,B,T;
      bool isSigned;
      bool signPos;
      double size;
    };



    struct  polygonD3D{
      vector<pointD3D> vectPoints;
      double nx, ny, nz;
      unsigned int R,G,B,T;
    };

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

    virtual ~Display3D(){};


    Display3D(){ 
      myCurrentFillColor = Color ( 220, 220, 220 );
      myCurrentLineColor = Color ( 22, 22, 222, 50 );
      myScaleX=1.0;
      myScaleY=1.0;
      myScaleZ=1.0;
      myBoundingPtEmptyTag = true;
      
    };

    // ----------------------- Interface --------------------------------------
  public:
    enum StreamKey {addNewList, updateDisplay, shiftSurfelVisu};
  
 

    virtual void setFillColor(DGtal::Color aColor);


    virtual void setLineColor(DGtal::Color aColor);

    
    virtual DGtal::Color getFillColor();
   
    virtual DGtal::Color getLineColor();

   
  
    virtual void addClippingPlane(double a, double b, double c, double d, bool drawPlane);
  
  
    virtual void setCameraUpVector(double , double , double ){}; 
  
    virtual void setCameraPosition(double , double , double ) {  };
  
    virtual void setNearFar(double , double ){};
  

    
    virtual void setCameraDirection(double , double , double ) { };

  
  
    virtual std::string getMode( const std::string & objectName ) const;
  
    virtual void createNewLineList();
  

    virtual void createNewPointList();


    virtual void createNewVoxelList(bool depthTest=true);

  
    virtual void addQuad(double x1, double y1, double z1,  double x2, double y2, double z2,
                         double x3, double y3, double z3,  double x4, double y4, double z4, 
                         DGtal::Color aColor);

    virtual void addTriangle(double x1, double y1, double z1,  double x2, double y2, double z2,
                             double x3, double y3, double z3, DGtal::Color aColor);
    



    virtual void addPolygon(std::vector<pointD3D> vectPointsPolygon, DGtal::Color aColor);

    


    virtual void addLine(double x1, double y1, double z1, double x2, double y2, double z2, 
                         const DGtal::Color &color=DGtal::Color(20,20,20,200), double width=1.5);
  

    virtual void addVoxel(DGtal::int64_t x, DGtal::int64_t y, DGtal::int64_t z, 
                          DGtal::Color color= DGtal::Color(220, 220, 220),
                          double width=0.5,bool withWire=false);
    

    virtual void addPoint(double x, double y, double z ,const DGtal::Color &color=DGtal::Color(200,20,20),
                          double size=40);
   
  
    
    virtual void addKSSurfel(double x, double y, double z, 
                             bool xSurfel, bool ySurfel, bool zSurfel, double sizeShiftFactor,
                             double positionShift=0.0, double sizeFactor=1.0,
                             bool isSigned= false, bool aSign=true, bool basicMode=false);
    
    


    virtual void addKSVoxel(int x, int y, int z, double sizeFactor=0.94);
  
    
    virtual void addKSPointel(double x, double y, double z, double size=0.1,
                              bool isSigned=false, bool aSign=true);
  

    
    virtual void addKSLinel(double x1, double y1, double z1,
                            double x2, double y2, double z2,
                            double width=0.02, bool isSigned=false, bool aSign=true);
  

    void updateBoundingBox(double x, double y, double z);
  

    
    
    void exportToMesh(MeshFromPoints<Display3D::pointD3D> & aMesh ) const;
    
    
    
    template <typename TDrawableWithDisplay3D>
    Display3D & operator<<( const  TDrawableWithDisplay3D & object );
  


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

    bool isValid() const;





    void setScale(float sx, float sy, float sz);
    
    

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



    // ------------------------- Protected Datas ------------------------------
  public:
  
    
    ModeMapping myModes;  
    StyleMapping myStyles;
  
  
    
    bool myBoundingPtEmptyTag;
    double  myBoundingPtUp [3];
    double  myBoundingPtLow [3];

  
  



  protected:


    DGtal::Color myCurrentFillColor;

    DGtal::Color myCurrentLineColor;



    double myCurrentfShiftVisuKSSurfels;

  

    std::vector< std::vector<voxelD3D> > myVoxelSetList;
  
  
  
    std::vector< std::vector<lineD3D> > myLineSetList;
  
  
  
    std::vector< std::vector<pointD3D> > myPointSetList;

  

    std::vector< clippingPlaneD3D > myClippingPlaneList;
 
  
 

    std::vector< quadD3D > myKSSurfelList;
  
  

    std::vector< pointD3D > myKSPointelList;



    std::vector< lineD3D > myKSLinelList;
  
  
    // Represents all the planes drawn in the Display3D
    std::vector< quadD3D > myQuadList;


    // Represents all the triangles drawn in the Display3D
    std::vector< triangleD3D > myTriangleList;
    

   // Represents all the polygon drawn in the Display3D
    std::vector<polygonD3D> myPolygonList;
    
    
    std::vector<bool> myListVoxelDepthTest;

    float myMeshDefaultLineWidth;
    
    
    // ------------------------- Hidden services ------------------------------

  private:

    Display3D ( const Display3D & other );
  
    Display3D & operator= ( const Display3D & other );
  
    // ------------------------- Internals ------------------------------------
  private:



  
  }; // end of class Display3D

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

  static void normalize (double vec[3]);


  std::ostream&
  operator<< ( std::ostream & out, const DGtal::Display3D & object );





  void
  operator>> ( const Display3D &aDisplay3D, DGtal::MeshFromPoints<Display3D::pointD3D> &aMesh);
  
  


  void
  operator>> ( const Display3D &aDisplay3D,  string aFilename);
  
  

  
} // namespace DGtal


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


//                                                                           //

#endif // !defined Display3D_h

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