Display3D.h

 
#pragma once

 
#include <vector>
#include <map>
 
#include "DGtal/dec/DiscreteExteriorCalculus.h"
 
#include "Eigen/Geometry"
 
#include "DGtal/helpers/StdDefs.h"
 
#include "DGtal/io/Color.h"
#include "DGtal/kernel/CanonicEmbedder.h" 
 
#include "DGtal/topology/KhalimskySpaceND.h"
#include "DGtal/topology/CanonicCellEmbedder.h"
#include "DGtal/topology/CanonicSCellEmbedder.h"
 
// Objects to draw
#include "DGtal/base/ConstRangeAdapter.h"
 
#include "DGtal/shapes/Mesh.h"
 
#include "DGtal/dec/DiscreteExteriorCalculus.h"
 
#include "DGtal/topology/Object.h"
 
#include "DGtal/images/ImageAdapter.h"
#include "DGtal/images/ConstImageAdapter.h"
#include "DGtal/images/ImageContainerBySTLVector.h"
 
#include "DGtal/geometry/tools/SphericalAccumulator.h"
#include "DGtal/geometry/curves/StandardDSS6Computer.h"
#include "DGtal/geometry/curves/Naive3DDSSComputer.h"
#include "DGtal/geometry/curves/GridCurve.h"
 
namespace DGtal {
    namespace drawutils { // Namespace for some utilities
      template<size_t I>
      std::vector<std::array<size_t, I>> makeIndices(size_t N);
      
      template<typename T> 
      std::array<T, 8> getCubeVertices(T center, double size);
      
      template<typename T, typename U>
      void insertCubeVertices(U& dest, T center, double scale);
      
      template <typename T>
      std::array<T, 4> getAASquareVertices(T center, int orientation, double size);
      
      template<typename U, typename T>
      void insertAASquare(U& dest, T center, int orientation, double size);
      
      template<typename T>
      std::array<T, 8> getPrism(
          T center, int orientation, 
          double size1, double size2, double shift1, double shift2
      );
       
      template<typename T, typename U>
      void insertPrism(U& dest, T center, int orientation, 
          double size1, double size2, double shift1, double shift2);
    } // drawutils
    namespace drawutils { // Namespace for some utilities {…}

    struct DisplayStyle {
      // Color of an object
      Color color = Color(200, 200, 200, 255);
      // When set, color is ignored and the viewer is free to choose
      bool useDefaultColors = true;            
      // Maintains uniform scale of the object independently for easy access
      double width = 1.0;                      

      enum DrawMode : size_t {
        DEFAULT      = (1 << 0), //< Default mode
        PAVING       = (1 << 1), //< For voxels, render them as cubes
        BALLS        = (1 << 2), //< For voxels, render them as balls
        ADJACENCIES  = (1 << 3), //< For objects, draws adjacencies
        GRID         = (1 << 4), //< For domains, draws a grid
        SIMPLIFIED   = (1 << 5)  //< For KCell, draws quads instead of prisms
      };
      enum DrawMode : size_t {…};
 
      size_t mode = static_cast<size_t>(DrawMode::DEFAULT);
    };
    struct DisplayStyle {…};
    
    enum class QuantityScale {
      VERTEX  = 0, 
      EDGE    = 1, 
      FACE    = 2, 
      CELL    = 3, 
      UNKNOWN = 4 // Also used as a default to decide later
    };
    enum class QuantityScale {…};

    template<typename T>
    struct Quantity {
      using QType = std::map<std::string, std::vector<T>>;
 
      QType& operator[](int idx) { return data[idx]; }
 
      const QType& operator[](int idx) const { return data[idx]; }
 
      QType& operator[](const QuantityScale& scale) { 
        return data[static_cast<size_t>(scale)]; 
      };
      QType& operator[](const QuantityScale& scale) {…}
 
      const QType& operator[](const QuantityScale& scale) const {
        return data[static_cast<size_t>(scale)];
      };
      const QType& operator[](const QuantityScale& scale) const  {…}
 
      std::array<QType, static_cast<size_t>(QuantityScale::UNKNOWN)> data;
    };
    struct Quantity {…};
 
    template<typename RealPoint>
    struct DisplayData {
      std::size_t           elementSize; 
      
      // Return the default quantity level associated with 
      // a given element size.
      static constexpr auto getDefaultQuantityLevel = [](size_t eSize) {
        switch(eSize) {
          case 1: return QuantityScale::VERTEX;
          case 2: return QuantityScale::EDGE;
          case 0: // Polygonal meshes
          case 3: // Triangle meshes
          case 4: // Quad meshes
                  return QuantityScale::FACE;
          case 8: return QuantityScale::CELL;
          default: 
                  return QuantityScale::UNKNOWN;
        };
      };
      static constexpr auto getDefaultQuantityLevel = [](size_t eSize) {…};
      
      // Indices for elements when elementSize is 0
      std::vector<std::vector<uint32_t>> indices;
      
      // List of vertices
      std::vector<RealPoint>   vertices;
 
      // Transform of the object
      Eigen::Affine3d transform = Eigen::Affine3d::Identity(); 
      
      // Draw style of the object (color, scale)
      DisplayStyle style;
      
      // Color to apply to each element
      Quantity<Color>  colorQuantities;
      // Vector to attach to each element
      Quantity<RealPoint> vectorQuantities;
      // Values to attach to each element (may serve for coloring)
      Quantity<double> scalarQuantities;
    };
    struct DisplayData {…};
    
    struct ClippingPlane {
      double a, b, c; //< Normal components
      double d;       //< Offset
      
      // Some style for rendering (colors)
      DisplayStyle style;
    };
    struct ClippingPlane {…};
    
    template<typename T, typename Type>
    struct WithQuantity {
      WithQuantity(const T& object, const std::string& name, const Type& value, QuantityScale s = QuantityScale::UNKNOWN) : 
        scale(s), object(object), name(name) 
      {
        values.push_back(value);
      }
      WithQuantity(const T& object, const std::string& name, const Type& value, QuantityScale s = QuantityScale::UNKNOWN) :  {…}
      
      WithQuantity(const T& object, const std::string& name, const std::vector<Type>& values, QuantityScale s = QuantityScale::UNKNOWN) : 
        scale(s), object(object), name(name) 
      {
        this->values = values;
      }
      WithQuantity(const T& object, const std::string& name, const std::vector<Type>& values, QuantityScale s = QuantityScale::UNKNOWN) :  {…}
      
      // Scale to apply the quantity at
      QuantityScale scale;
 
      // Copy of the object
      T object;
      // Copy of the values to attach
      std::vector<Type> values;
      // Name of the property
      std::string name;
    };
    struct WithQuantity {…};

    template < typename Space = Z3i::Space, typename KSpace = Z3i::KSpace>
    class Display3D {
    public:
      Display3D(const KSpace& space) :
        myKSpace(space), 
        myCellEmbedder(myKSpace),
        mySCellEmbedder(myKSpace)
      { }
      Display3D(const KSpace& space) : {…}
 
      Display3D() : Display3D(KSpace()) {}
 
      // Usefull definitions
      using Point = typename Space::Point;
      using KCell = typename KSpace::Cell;
      using SCell = typename KSpace::SCell;
      using RealPoint = typename Space::RealPoint ;
 
      using Embedder = CanonicEmbedder<Space>;
      using CellEmbedder = CanonicCellEmbedder<KSpace>;
      using SCellEmbedder = CanonicSCellEmbedder<KSpace>;

      struct Callback{
        virtual void OnAttach(void* viewer) {};
        virtual void OnUI(void* viewerData) {};
        virtual void OnClick(const std::string& name, size_t index, const DisplayData<RealPoint>& data, void* viewerData) {};
 
        // Pointer to the Display3D instance the callback is attached to
        Display3D<Space, KSpace>* viewer = nullptr;
      };
      struct Callback {…};
    public: // General commands
      virtual void show() = 0;
      virtual void renderNewData() = 0;

      virtual void renderAll() {
        myToRender.clear();
        myToRender.reserve(data.size());
 
        for (const auto& m : data) 
          myToRender.push_back(m.first);
 
        renderNewData();
      }
      virtual void renderAll() {…}

      virtual void clearView() = 0;
      virtual void clear();
      virtual void setCallback(Callback* callback);
 
    public: // Group/Lists managements
      std::string newList(const std::string& name, size_t eSize = 0);

      bool setCurrentList(const std::string& name);

      bool canCreateNewList(size_t elementSize) const;

      std::string createOrReuseList(const std::string& name, size_t elementSize);

      void endCurrentGroup();
 
      // Some shortcuts for clearer code
 
      std::string newCubeList(const std::string& name)       { return newList(name, 8); }
      std::string newBallList(const std::string& name)       { return newList(name, 1); }
      std::string newLineList(const std::string& name)       { return newList(name, 2); }
      std::string newQuadList(const std::string& name)       { return newList(name, 4); }
      std::string newPolygonList(const std::string& name)    { return newList(name, 0); }
      std::string newTriangleList(const std::string& name)   { return newList(name, 3); }
      std::string newVolumetricList(const std::string& name) { return newList(name, 8); }
 
      std::string createOrReuseCubeList(const std::string& name)       { return createOrReuseList(name, 8); }
      std::string createOrReuseBallList(const std::string& name)       { return createOrReuseList(name, 1); }
      std::string createOrReuseLineList(const std::string& name)       { return createOrReuseList(name, 2); }
      std::string createOrReuseQuadList(const std::string& name)       { return createOrReuseList(name, 4); }
      std::string createOrReusePolygonList(const std::string& name)    { return createOrReuseList(name, 0); }
      std::string createOrReuseTriangleList(const std::string& name)   { return createOrReuseList(name, 3); }
      std::string createOrReuseVolumetricList(const std::string& name) { return createOrReuseList(name, 8); }
    
    public: // Draw commands
 
      template<typename Obj>
      Display3D& operator<<(const Obj& obj);
 
      // @brief Draws a Point with integer coodinates
      std::string draw(const Point& p, const std::string& uname = "Point_{i}");
 
      // @brief Draws a RealPoint with real coodinates
      std::string draw(const RealPoint& rp, const std::string& uname = "Point_{i}");
      
      // @brief Draws a vector of objects
      template<typename T>
      std::string draw(const std::vector<T>& vec, const std::string& uname = "");
 
      // @brief Draws a range of any object
      template<typename A, typename B, typename C>
      std::string draw(const ConstRangeAdapter<A, B, C> range, const std::string& uname = "");
 
      // @brief Draws any object provided through a ConstIteratorAdapter
      template<typename A, typename B, typename C>
      std::string draw(const ConstIteratorAdapter<A, B, C>& adapter, const std::string& uname = "");
      
      // @brief Draws a grid curve
      std::string draw(const GridCurve<KSpace>& curve, const std::string& uname = "GridCurve_{i}");
      
      // @brief Draws a grid curve as mid points 
      std::string draw(const typename GridCurve<KSpace>::MidPointsRange& range, const std::string& uname = "MidPoints_{i}");
      
      // @brief Draws a grid curve as arrows
      std::string draw(const typename GridCurve<KSpace>::ArrowsRange& range, const std::string& uname = "Arrows_{i}");
 
      // @brief Draws a DiscreteExteriorCalculus
      template<DGtal::Dimension emb, DGtal::Dimension amb, typename Algebra, typename Int>
      std::string draw(const DiscreteExteriorCalculus<emb, amb, Algebra, Int>& calc, const std::string& uname = "Calculus_{i}");
 
      // @brief Draws a KForm
      template<typename Calculus, DGtal::Order order, DGtal::Duality duality>
      std::string draw(const KForm<Calculus, order, duality>& kform, const std::string& uname = "KForm_{i}");
 
      // @brief Draws a VectorField
      template<typename Calculus, DGtal::Duality dual> 
      std::string draw(const VectorField<Calculus, dual>& field, const std::string& uname = "Field_{i}");
 
      // @brief Draws an unsigned KCell
      std::string draw(const KCell& cell, const std::string& name = "KCell_{i}_{d}d");
      
      // @brief Draws a singed KCell
      std::string draw(const SCell& cell, const std::string& name = "SCell_{i}_{d}d");
 
      // @brief Draws a Domain
      //
      // Note: the default name has a special hex code in the begining
      // so that string based view-order draws domain in the background
      std::string draw(const HyperRectDomain<Space>& domain, const std::string& uname = "\xff Domain_{i}");

      template<typename Vec>
      std::string drawPolygon(const std::vector<Vec>& vertices, const std::string& uname = "Polygon_{i}");
 
      // @brief Draws a ball
      std::string drawBall(const RealPoint& c, const std::string& uname = "Ball_{i}");
      
      // @brief Draws a line
      std::string drawLine(const RealPoint& a, const RealPoint& b, const std::string& uname = "Line_{i}");
 
      // @brief Draws a quad
      std::string drawQuad(const RealPoint& a, const RealPoint& b, const RealPoint& c, const RealPoint& d, const std::string& uname = "Quad_{i}");
      
      // @brief Draws a DigitalSet
      template<typename Obj, typename Cont>
      std::string draw(const DigitalSetByAssociativeContainer<Obj, Cont>& set, const std::string& name = "Set_{i}");
 
      // @brief Draws an Object
      template<typename Adj, typename Set>
      std::string draw(const DGtal::Object<Adj, Set>& obj, const std::string& uname = "Object_{i}");
 
      // @brief Draws an Image
      template<typename D, typename T>
      std::string draw(const ImageContainerBySTLVector<D, T>& image, const std::string& name = "Image_{i}");
            
      // @brief Draws an Image
      template <typename TImageContainer,
                typename TNewDomain,
                typename TFunctorD,
                typename TNewValue,
                typename TFunctorV,
                typename TFunctorVm1>
      std::string draw(const ImageAdapter<TImageContainer, TNewDomain, TFunctorD, TNewValue, TFunctorV, TFunctorVm1>& adapter, const std::string& name = "Image_{i}");
            
      // @brief Draws an Image
      template <typename TImageContainer,
                typename TNewDomain,
                typename TFunctorD,
                typename TNewValue,
                typename TFunctorV>
      std::string draw(const ConstImageAdapter<TImageContainer, TNewDomain, TFunctorD, TNewValue, TFunctorV>& adapter, const std::string& name = "Image_{i}");
 
      // @brief Draws a mesh
      template <typename Pt>
      std::string draw(const Mesh<Pt>& mesh, const std::string& uname = "Mesh_{i}");
 
      // @brief Draws a DSS6Computer
      template<typename It, typename Int, int Con>
      std::string draw(const StandardDSS6Computer<It, Int, Con>& computer, const std::string& uname = "Computer_{i}");
      
      template<typename It, typename Int, int Con>
      std::string draw(const Naive3DDSSComputer<It, Int, Con>& computer, const std::string& uname = "Computer_{i}");
      
      // @brief Draws any object with a property
      template<typename T, typename Type>
      std::string draw(const WithQuantity<T, Type>& props, const std::string& uname = "");
 
      template<typename Type>
      void addQuantity(const std::string& oName, const std::string& qName, const Type& value, QuantityScale scale = QuantityScale::UNKNOWN);
 
      template<typename Type>
      void addQuantity(const std::string& oName, const std::string& qName, const std::vector<Type>& value, QuantityScale scale = QuantityScale::UNKNOWN);
 
      
      // @brief Adds a clipping plane
      std::string draw(const ClippingPlane& plane, const std::string& name = "");
    
      // @brief Draws a Spherical Accumulator
      template<typename T>
      std::string draw(const SphericalAccumulator<T> accumulator, const std::string& uname = "SphericalAccumulator_{i}");
 
      // @brief Set the current draw color 
      std::string draw(const DGtal::Color& color, const std::string& name = "");
      
      // @brief Set the current draw color 
      void drawColor(const DGtal::Color& color);
 
      // @brief Use default colors
      void setDefaultColors();
      
      // @brief Draws adjacencies of further Object
      void drawAdjacencies(bool toggle = true);
      
      // @brief Draws 2D KCell as simplifed mode
      void drawAsSimplified(bool toggle = true);
 
      // @brief Draws grid of further domains
      void drawAsGrid(bool toggle = true);
 
      // @brief Reset style
      void defaultStyle();
 
      // @brief Draws voxels of further object, domains and points
      void drawAsPaving();
 
      // @brief Draws balls of further object, domains and points
      void drawAsBalls();
    private: // Draw commands
      // To avoid confusion, keep this function as private: 
 
      // @brief Draws an /!\ arrow (NOT A LINE)
      std::string draw(const std::pair<RealPoint, RealPoint>& arrow, const std::string& uname = "Arrow_{i}");

      template<typename Range> 
      std::string drawGenericRange(const Range& range, const std::string& uname);
 
      // @brief Draws an image through an iterator
      template<typename T>
      std::string drawImage(const std::string& uname, const T& image);
 
      // @brief Draws a KCell (signed or not)
      std::string drawKCell(std::string uname, const RealPoint& rp, bool xodd, bool yodd, bool zodd, bool hasSign, bool sign);
 
    public:
      // The user is responsible for using these wrong..
      //
      DisplayStyle currentStyle;
      bool allowReuseList = false;
 
      std::vector<ClippingPlane> planes;
      // Leave access to the user for thin modifications
      std::map<std::string, DisplayData<RealPoint>> data;
 
    protected:
      KSpace myKSpace;
      Embedder myEmbedder;
      CellEmbedder myCellEmbedder;
      SCellEmbedder mySCellEmbedder;
 
      Callback* myCallback = nullptr;
      std::vector<std::string> myToRender;
 
      std::string myCurrentName = "";
      DisplayData<RealPoint>* myCurrentData = nullptr;
    }; // Display3D
    class Display3D {…};
} // DGtal
 
#include "Display3D.ih"