Board3DTo2DFactory.h

 
#pragma once
 
#if defined(Board3DTo2DFactory_RECURSES)
#error Recursive header files inclusion detected in Board3DTo2DFactory.h
#else // defined(Board3DTo2DFactory_RECURSES)
#define Board3DTo2DFactory_RECURSES
 
#if !defined Board3DTo2DFactory_h
#define Board3DTo2DFactory_h
 
// Inclusions
 
#include "DGtal/helpers/StdDefs.h"
#include "DGtal/base/Common.h"
 
#include "DGtal/io/Display3DFactory.h"
#include "DGtal/io/boards/DrawWithBoard3DTo2DModifier.h"
#include "DGtal/geometry/curves/StandardDSS6Computer.h"
#include "DGtal/geometry/curves/Naive3DDSSComputer.h"
#include "DGtal/kernel/sets/DigitalSetBySTLSet.h"
#include "DGtal/kernel/sets/DigitalSetByAssociativeContainer.h"
#include "DGtal/kernel/sets/DigitalSetBySTLVector.h"
#include "DGtal/kernel/domains/HyperRectDomain.h"
#include "DGtal/topology/KhalimskySpaceND.h"
#include "DGtal/topology/Object.h"
#include "DGtal/kernel/PointVector.h"
#include "DGtal/geometry/curves/GridCurve.h"
#include "DGtal/shapes/Mesh.h"
#include "DGtal/geometry/tools/SphericalAccumulator.h"
#include "DGtal/io/colormaps/HueShadeColorMap.h"
#include "DGtal/io/colormaps/CColorMap.h"
#include "DGtal/images/ImageContainerBySTLVector.h"
#include "DGtal/images/ImageContainerBySTLMap.h"
#include "DGtal/images/ConstImageAdapter.h"
#include "DGtal/images/ImageAdapter.h"
 
 
namespace DGtal
{
// struct Board3DTo2DFactory
  template <typename TSpace, typename TKSpace>
  struct Board3DTo2DFactory : public Display3DFactory<TSpace,TKSpace>
  {
    typedef TSpace Space;
    typedef TKSpace KSpace;
 
  static void
  draw( Board3DTo2D<Space, KSpace> & board, const DGtal::CameraPosition & aThing );
 
  static void
  draw( Board3DTo2D<Space, KSpace> & board, const DGtal::CameraDirection & aThing );
 
  static void
  draw( Board3DTo2D<Space, KSpace> & board, const DGtal::CameraUpVector & aThing );
 
  static void
  draw( Board3DTo2D<Space, KSpace> & board, const DGtal::CameraZNearFar & aThing );
 
 
  //----------------------------------------------------------------------------------------------
  // heritage
  // SphericalAccumulator
  template <typename TVector>
  static void
  draw( Board3DTo2D<Space, KSpace> & board, const  DGtal::SphericalAccumulator<TVector> & accumulator,
                    const typename DGtal::SphericalAccumulator<TVector>::RealVector & shift =
      typename DGtal::SphericalAccumulator<TVector>::RealVector(0,0,0),
                    const double radius=1.0);
  // SphericalAccumulator
 
  // Mesh
    template <typename TPoint>
  static void
  drawAsFaces( Board3DTo2D<Space, KSpace> & board, const DGtal::Mesh<TPoint> & aMesh );
 
  template <typename TPoint>
  static void
  draw( Board3DTo2D<Space, KSpace> & board, const  DGtal::Mesh<TPoint> & aMesh );
  // Mesh
 
 
 
  // StandardDSS6Computer
  template <typename TIterator, typename TInteger, int connectivity>
  static DGtal::DrawableWithBoard3DTo2D *
  defaultStyle( std::string str, const DGtal::StandardDSS6Computer<TIterator,TInteger,connectivity> & arithm );
 
  template <typename TIterator, typename TInteger, int connectivity>
  static void
  drawAsBalls( Board3DTo2D<Space, KSpace> & board, const DGtal::StandardDSS6Computer<TIterator,TInteger,connectivity> & arithm );
 
  template <typename TIterator, typename TInteger, int connectivity>
  static void
  drawAsBoundingBox( Board3DTo2D<Space, KSpace> & board, const DGtal::StandardDSS6Computer<TIterator,TInteger,connectivity> & arithm );
 
  template <typename TIterator, typename TInteger, int connectivity>
  static void
  draw( Board3DTo2D<Space, KSpace> & board, const DGtal::StandardDSS6Computer<TIterator,TInteger,connectivity> & arithm );
  // StandardDSS6Computer
  
  
    // Naive3DDSSComputer
  template <typename TIterator, typename TInteger, int connectivity>
  static DGtal::DrawableWithBoard3DTo2D *
  defaultStyle( std::string str, const DGtal::Naive3DDSSComputer<TIterator,TInteger,connectivity> & arithm );
 
  template <typename TIterator, typename TInteger, int connectivity>
  static void
  drawAsBalls( Board3DTo2D<Space, KSpace> & board, const DGtal::Naive3DDSSComputer<TIterator,TInteger,connectivity> & arithm );
 
  template <typename TIterator, typename TInteger, int connectivity>
  static void
  drawAsBoundingBox( Board3DTo2D<Space, KSpace> & board, const DGtal::Naive3DDSSComputer<TIterator,TInteger,connectivity> & arithm );
 
  template <typename TIterator, typename TInteger, int connectivity>
  static void
  draw( Board3DTo2D<Space, KSpace> & board, const DGtal::Naive3DDSSComputer<TIterator,TInteger,connectivity> & arithm );
  // Naive3DDSSComputer
 
 
    // DigitalSetBySTLSet
    template<typename Domain, typename Compare>
    static DGtal::DrawableWithBoard3DTo2D *
    defaultStyle( std::string str, const DGtal::DigitalSetBySTLSet<Domain, Compare> & aSet );
    
    template<typename Domain, typename Compare>
    static void
    drawAsPavingTransparent( Board3DTo2D<Space, KSpace> & board, const DGtal::DigitalSetBySTLSet<Domain, Compare> & aSet );
    
    template<typename Domain, typename Compare>
    static void
    drawAsPaving( Board3DTo2D<Space, KSpace> & board, const DGtal::DigitalSetBySTLSet<Domain, Compare> & aSet );
    
    template<typename Domain, typename Compare>
    static void
    drawAsGrid( Board3DTo2D<Space, KSpace> & board, const DGtal::DigitalSetBySTLSet<Domain, Compare> & aSet );
    
    template<typename Domain, typename Compare>
    static void
    draw( Board3DTo2D<Space, KSpace> & board, const DGtal::DigitalSetBySTLSet<Domain, Compare> & aSet );
    // DigitalSetBySTLSet
 
    // DigitalSetByAssociativeContainer
  template<typename Domain, typename Container>
  static DGtal::DrawableWithBoard3DTo2D *
  defaultStyle( std::string str, const DGtal::DigitalSetByAssociativeContainer<Domain, Container> & aSet );
 
  template<typename Domain, typename Container>
  static void
  drawAsPavingTransparent( Board3DTo2D<Space, KSpace> & board, const DGtal::DigitalSetByAssociativeContainer<Domain, Container> & aSet );
 
  template<typename Domain, typename Container>
  static void
  drawAsPaving( Board3DTo2D<Space, KSpace> & board, const DGtal::DigitalSetByAssociativeContainer<Domain, Container> & aSet );
 
  template<typename Domain, typename Container>
  static void
  drawAsGrid( Board3DTo2D<Space, KSpace> & board, const DGtal::DigitalSetByAssociativeContainer<Domain, Container> & aSet );
 
  template<typename Domain, typename Container>
  static void
  draw( Board3DTo2D<Space, KSpace> & board, const DGtal::DigitalSetByAssociativeContainer<Domain, Container> & aSet );
  // DigitalSetByAssociativeContainer
 
 
  // DigitalSetBySTLVector
  template<typename Domain>
  static DGtal::DrawableWithBoard3DTo2D *
  defaultStyle( std::string str, const DGtal::DigitalSetBySTLVector<Domain> & aSet );
 
  template<typename Domain>
  static void
  drawAsPavingTransparent( Board3DTo2D<Space, KSpace> & board, const DGtal::DigitalSetBySTLVector<Domain> & aSet );
 
  template<typename Domain>
  static void
  drawAsPaving( Board3DTo2D<Space, KSpace> & board, const DGtal::DigitalSetBySTLVector<Domain> & aSet );
 
  template<typename Domain>
  static void
  drawAsGrid( Board3DTo2D<Space, KSpace> & board, const DGtal::DigitalSetBySTLVector<Domain> & aSet );
 
  template<typename Domain>
  static void
  draw( Board3DTo2D<Space, KSpace> & board, const DGtal::DigitalSetBySTLVector<Domain> & aSet );
  // DigitalSetBySTLVector
 
 
  // HyperRectDomain
  template<typename SpaceDom>
  static DGtal::DrawableWithBoard3DTo2D *
  defaultStyle( std::string str, const DGtal::HyperRectDomain<SpaceDom> & aDomain );
 
  template<typename SpaceDom>
  static void
  drawAsBoundingBox( Board3DTo2D<Space, KSpace> & board, const DGtal::HyperRectDomain<SpaceDom> & aDomain );
 
  template<typename SpaceDom>
  static void
  drawAsGrid( Board3DTo2D<Space, KSpace> & board, const DGtal::HyperRectDomain<SpaceDom> & aDomain );
 
  template<typename SpaceDom>
  static void
  drawAsPavingBalls( Board3DTo2D<Space, KSpace> & board, const DGtal::HyperRectDomain<SpaceDom> & aDomain );
 
  template<typename SpaceDom>
  static void
  drawAsPaving( Board3DTo2D<Space, KSpace> & board, const DGtal::HyperRectDomain<SpaceDom> & aDomain );
 
  template<typename SpaceDom>
  static void
  draw( Board3DTo2D<Space, KSpace> & board, const DGtal::HyperRectDomain<SpaceDom> & aDomain );
  // HyperRectDomain
 
 
  // KhalimskyCell
  static DGtal::DrawableWithBoard3DTo2D *
  defaultStyle( std::string str, const typename KSpace::Cell & aCell );
 
  static void
  draw( Board3DTo2D<Space, KSpace> & board, const typename KSpace::Cell & aCell );
  // KhalimskyCell
 
 
  // Object
  template <typename TDigitalTopology, typename TDigitalSet>
  static DGtal::DrawableWithBoard3DTo2D *
  defaultStyle( std::string str, const DGtal::Object<TDigitalTopology, TDigitalSet> & anObject );
 
  template <typename TDigitalTopology, typename TDigitalSet>
  static void
  drawWithAdjacencies( Board3DTo2D<Space, KSpace> & board, const DGtal::Object<TDigitalTopology, TDigitalSet> & anObject );
 
  template <typename TDigitalTopology, typename TDigitalSet>
  static void
  draw( Board3DTo2D<Space, KSpace> & board, const DGtal::Object<TDigitalTopology, TDigitalSet> & anObject );
  // Object
 
 
  // PointVector
  template<Dimension dim, typename TComponent, typename TContainer>
  static DGtal::DrawableWithBoard3DTo2D *
  defaultStyle( std::string str, const DGtal::PointVector<dim, TComponent, TContainer> & aPoint );
 
  template<Dimension dim, typename TComponent, typename TContainer>
  static void
  drawAsGrid( Board3DTo2D<Space, KSpace> & board, const DGtal::PointVector<dim, TComponent, TContainer> & aPoint );
 
  template<Dimension dim, typename TComponent, typename TContainer>
  static void
  drawAsPaving( Board3DTo2D<Space, KSpace> & board, const DGtal::PointVector<dim, TComponent, TContainer> & aPoint );
 
  template<Dimension dim, typename TComponent, typename TContainer>
  static void
  drawAsPavingWired( Board3DTo2D<Space, KSpace> & board, const DGtal::PointVector<dim, TComponent, TContainer> & aPoint );
 
  template<Dimension dim, typename TComponent, typename TContainer>
  static void
  draw( Board3DTo2D<Space, KSpace> & board, const DGtal::PointVector<dim, TComponent, TContainer> & aPoint );
 
  template<Dimension dim, typename TComponent1, typename TComponent2, typename TContainer1, typename TContainer2>
  static void
  draw( Board3DTo2D<Space, KSpace> & board, const DGtal::PointVector<dim, TComponent1, TContainer1> & aPoint, const DGtal::PointVector<dim, TComponent2, TContainer2> & aPoint2 );
  // PointVector
 
 
  // SignedKhalimskyCell
  static DGtal::DrawableWithBoard3DTo2D *
  defaultStyle( std::string str, const typename KSpace::SCell & aSCell );
 
  static void
  draw( Board3DTo2D<Space, KSpace> & board, const typename KSpace::SCell & aSCell );
  // SignedKhalimskyCell
 
  // GridCurve
  static void
  draw( Board3DTo2D<Space, KSpace> & board, const DGtal::GridCurve<KSpace> & aGrid );
  // GridCurve
 
  // SCellsRange
  template < typename TIterator, typename TSCell>
  static void
  draw( Board3DTo2D<Space, KSpace> & board,
        const ConstRangeAdapter<TIterator, DGtal::functors::Identity, TSCell> & aRangeAdapter );
  // SCellsRange
 
  // PointsRange
  template <typename TIterator>
  static void
  draw( Board3DTo2D<Space, KSpace> & board,
                    const DGtal::ConstRangeAdapter<TIterator, functors::SCellToPoint<KSpace>, typename KSpace::Point> & aRangeAdapter );
  // PointsRange
 
  // MidPointsRange
  template <typename TIterator>
  static void
  draw( Board3DTo2D<Space, KSpace> & board,
                    const DGtal::ConstRangeAdapter<TIterator, CanonicSCellEmbedder<KSpace>, typename KSpace::Space::RealPoint> & aRangeAdapter );
  // MidPointsRange
 
  // ArrowsRange
    template <typename TIterator>
  static void
  draw( Board3DTo2D<Space, KSpace> & board,
                    const DGtal::ConstRangeAdapter<TIterator, functors::SCellToArrow<KSpace>, std::pair<typename KSpace::Point, typename KSpace::Vector > > & aRangeAdapter );
  // ArrowsRange
 
  // InnerPointsRange
  template <typename TIterator>
  static void
  draw( Board3DTo2D<Space, KSpace> & board,
                    const DGtal::ConstRangeAdapter<TIterator, functors::SCellToInnerPoint<KSpace>, typename KSpace::Point> & aRangeAdapter );
  // InnerPointsRange
 
  // OuterPointsRange
  template <typename TIterator>
  static void
  draw( Board3DTo2D<Space, KSpace> & board,
                    const DGtal::ConstRangeAdapter<TIterator, functors::SCellToOuterPoint<KSpace>, typename KSpace::Point> & aRangeAdapter );
  // OuterPointsRange
 
  // IncidentPointsRange
  template <typename TIterator>
  static void
  draw( Board3DTo2D<Space, KSpace> & board,
                    const DGtal::ConstRangeAdapter<TIterator, functors::SCellToIncidentPoints<KSpace>,std::pair<typename KSpace::Point, typename KSpace::Point > > & aRangeAdapter );
  // IncidentPointsRange
 
 
  static void
  draw( Board3DTo2D<Space, KSpace> & board, const DGtal::SetMode3D & aMode);
 
  static void
  draw( Board3DTo2D<Space, KSpace> & board, const DGtal::CustomStyle3D & aStyle);
 
  static void
  draw( Board3DTo2D<Space, KSpace> & board, const DGtal::CustomColors3D & aColor);
 
  static void
  draw( Board3DTo2D<Space, KSpace> & board, const DGtal::ClippingPlane & aClipping);
 
  static void
  draw( Board3DTo2D<Space, KSpace> & board, const DGtal::TransformedPrism & aTransformedPrism);
 
  // end heritage
  //----------------------------------------------------------------------------------------------
 
}; // end of struct Board3DTo2DFactory
 
} // namespace DGtal
 
 
// Includes inline functions/methods
#include "DGtal/io/boards/Board3DTo2DFactory.ih"
 
 
//                                                                           //
 
#endif // !defined Board3DTo2DFactory_h
 
#undef Board3DTo2DFactory_RECURSES
#endif // else defined(Board3DTo2DFactory_RECURSES)