Display2DFactory.h

#pragma once

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

#define Display2DFactory_RECURSES

#if !defined Display2DFactory_h

#define Display2DFactory_h

// Inclusions

#include "DGtal/base/Common.h"

#include "DGtal/math/AngleLinearMinimizer.h"
#include "DGtal/geometry/curves/ArithmeticalDSS.h"
#include "DGtal/shapes/fromPoints/CircleFrom2Points.h"
#include "DGtal/shapes/fromPoints/CircleFrom3Points.h"
#include "DGtal/kernel/sets/DigitalSetBySTLSet.h"
#include "DGtal/kernel/sets/DigitalSetBySTLVector.h"
#include "DGtal/geometry/curves/GridCurve.h"
#include "DGtal/geometry/curves/FP.h"
#include "DGtal/geometry/curves/FreemanChain.h"
#include "DGtal/geometry/curves/GeometricalDSS.h"
#include "DGtal/geometry/curves/GeometricalDCA.h"
#include "DGtal/geometry/curves/FrechetShortcut.h"
#include "DGtal/kernel/domains/HyperRectDomain.h"
#include "DGtal/images/ImageContainerByHashTree.h"
#include "DGtal/images/ImageContainerBySTLVector.h"
#include "DGtal/images/ImageAdapter.h"
#include "DGtal/topology/KhalimskySpaceND.h"
#include "DGtal/topology/Object.h"
#include "DGtal/kernel/PointVector.h"
#include "DGtal/geometry/tools/Preimage2D.h"
#include "DGtal/shapes/fromPoints/StraightLineFrom2Points.h"
#include "DGtal/arithmetic/LatticePolytope2D.h"

#include "DGtal/io/boards/Board2D.h"



namespace DGtal
{

// struct Display2DFactory
  struct Display2DFactory
 {

    
// AngleLinearMinimizer
static void draw( DGtal::Board2D & board, const DGtal::AngleLinearMinimizer & );
// AngleLinearMinimizer
    
    
// ArithmeticalDSS
template <typename TIterator, typename TInteger, int connectivity>
  static void drawAsBoundingBox( DGtal::Board2D & aBoard, 
                          const DGtal::ArithmeticalDSS<TIterator,TInteger,connectivity> & );

template <typename TIterator, typename TInteger, int connectivity>
  static void drawAsDigitalPoints( DGtal::Board2D & aBoard, 
                            const DGtal::ArithmeticalDSS<TIterator,TInteger,connectivity> & );

template <typename TIterator, typename TInteger, int connectivity>
  static void draw( DGtal::Board2D & board, const DGtal::ArithmeticalDSS<TIterator,TInteger,connectivity> & );
// ArithmeticalDSS
    
    
// CircleFrom2Points
template <typename TPoint>
static void draw(Board2D & aBoard, const DGtal::CircleFrom2Points<TPoint> & );
// CircleFrom2Points


// CircleFrom3Points
template <typename Point>
static void drawArc(Board2D & aBoard, const DGtal::CircleFrom3Points<Point> &, const Point &, const Point &, bool anOrientation = true);
    
template <typename Point>
static void drawSector(Board2D & aBoard, const DGtal::CircleFrom3Points<Point> &, const Point &, const Point &, bool anOrientation = true);
    
template <typename Point>
static void drawAnnulus(Board2D & aBoard, const DGtal::CircleFrom3Points<Point> &, const Point &, const Point &, const double& w = 1.0, bool anOrientation = true);
    
template <typename Point>
static void draw(Board2D & aBoard, const DGtal::CircleFrom3Points<Point> &, const Point &, const Point &, bool anOrientation = true);
    
template <typename TPoint>
static void draw(Board2D & aBoard, const DGtal::CircleFrom3Points<TPoint> & );
// CircleFrom3Points
    
    
// DigitalSetBySTLSet
template<typename Domain>
static void draw( DGtal::Board2D & board, const DGtal::DigitalSetBySTLSet<Domain> & );
// DigitalSetBySTLSet
    
    
// DigitalSetBySTLVector
template<typename Domain>
static void draw( DGtal::Board2D & board, const DGtal::DigitalSetBySTLVector<Domain> & );
// DigitalSetBySTLVector
    
    
// FP
template <typename TIterator, typename TInteger, int connectivity>
  static void drawAsPolygon( DGtal::Board2D & aBoard, const DGtal::FP<TIterator,TInteger,connectivity> & );

template <typename TIterator, typename TInteger, int connectivity>
  static void draw( DGtal::Board2D & board, const DGtal::FP<TIterator,TInteger,connectivity> & );
// FP
    
    
// FreemanChain
template <typename TInteger>
static void drawAsGrid( DGtal::Board2D & aBoard, const DGtal::FreemanChain<TInteger> & );
    
template <typename TInteger>
static void drawAsInterGrid( DGtal::Board2D & aBoard, const DGtal::FreemanChain<TInteger> & );
    
template <typename TInteger>
static void draw( DGtal::Board2D & aBoard, const DGtal::FreemanChain<TInteger> & );
// FreemanChain
    
    
// GeometricalDSS
template <typename TConstIterator>
static void draw(DGtal::Board2D & aBoard, const DGtal::GeometricalDSS<TConstIterator> & );
// GeometricalDSS

// GeometricalDCA
template <typename TConstIterator>
static void draw(DGtal::Board2D & aBoard, const DGtal::GeometricalDCA<TConstIterator> & );
// GeometricalDCA


//FrechetShortcut
template <typename TIterator, typename TInteger>
static  void draw(DGtal::Board2D & aBoard, const DGtal::FrechetShortcut<TIterator,TInteger> & );
//FrechetShortcut

    
// GridCurve
template <typename TKSpace>
static void draw( DGtal::Board2D & aBoard, 
           const GridCurve<TKSpace> & object );
// GridCurve
    
// SCellsRange
template <typename TIterator, typename TSCell>
static void draw( DGtal::Board2D & aBoard, 
           const ConstRangeAdapter<TIterator, DefaultFunctor, TSCell> & object );
// SCellsRange
    
// PointsRange
template <typename TIterator, typename TKSpace>
static void draw( DGtal::Board2D & aBoard, 
           const ConstRangeAdapter<TIterator, SCellToPoint<TKSpace>, typename TKSpace::Point> & object );
// PointsRange

// MidPointsRange
template <typename TIterator, typename TKSpace>
static void draw( DGtal::Board2D & aBoard, 
           const ConstRangeAdapter<TIterator, SCellToMidPoint<TKSpace>, 
           typename TKSpace::Space::RealPoint> & object );
// MidPointsRange

// ArrowsRange
template <typename TIterator, typename TKSpace>
static void draw( DGtal::Board2D & aBoard, 
           const ConstRangeAdapter<TIterator, SCellToArrow<TKSpace>, 
           std::pair<typename TKSpace::Point, typename TKSpace::Vector > > & object );
// ArrowsRange

// InnerPointsRange
template <typename TIterator, typename TKSpace>
static void draw( DGtal::Board2D & aBoard, 
           const ConstRangeAdapter<TIterator, SCellToInnerPoint<TKSpace>, 
           typename TKSpace::Point > & object );
// InnerPointsRange

// OuterPointsRange
template <typename TIterator, typename TKSpace>
static void draw( DGtal::Board2D & aBoard, 
           const ConstRangeAdapter<TIterator, SCellToOuterPoint<TKSpace>, 
           typename TKSpace::Point > & object );
// OuterPointsRange

// IncidentPointsRange
template <typename TIterator, typename TKSpace>
static void draw( DGtal::Board2D & aBoard, 
           const ConstRangeAdapter<TIterator, SCellToIncidentPoints<TKSpace>, 
           std::pair<typename TKSpace::Point, typename TKSpace::Point> > & object );
// IncidentPointsRange

// HyperRectDomain
template<typename TSpace>
static void drawAsGrid( DGtal::Board2D & aboard, const DGtal::HyperRectDomain<TSpace> & );

template<typename TSpace>
static void drawAsPaving( DGtal::Board2D & aboard, const DGtal::HyperRectDomain<TSpace> & );

template<typename TSpace>
static void draw( DGtal::Board2D & board, const DGtal::HyperRectDomain<TSpace> & );
// HyperRectDomain
    
    
// ImageContainerByHashTree
template <typename C, typename Domain, typename Value, typename HashKey>
static void drawImageRecursive( DGtal::Board2D & aBoard, 
                         const DGtal::ImageContainerByHashTree<Domain, Value, HashKey> & i,
                         HashKey key,
                         const double p[2],
                         const double len,
                         LibBoard::Board & board,
                         const C& cmap );

template <typename C, typename Domain, typename Value, typename HashKey>
static void drawImageHashTree( Board2D & board,
                const DGtal::ImageContainerByHashTree<Domain, Value, HashKey> &, 
                const Value &, const Value & );
// ImageContainerByHashTree


// ImageContainerBySTLVector, ImageContainerByHashTree, Image and ImageAdapter...
// minV and maxV are bounds values of colormap
template <typename Colormap, typename Image>
  static void drawImage( DGtal::Board2D & board,
                          const Image & i,
                          const typename Image::Value & minV,
                          const typename Image::Value & maxV );
// ImageContainerBySTLVector, ImageContainerByHashTree, Image and ImageAdapter...
    
    
// KhalimskyCell
template < Dimension dim, typename TInteger >
  static void draw( DGtal::Board2D & board, const DGtal::KhalimskyCell<dim, TInteger> & );
// KhalimskyCell
    
    
// Object
template <typename TDigitalTopology, typename TDigitalSet>
  static void drawWithAdjacencies( DGtal::Board2D & aBoard, const DGtal::Object<TDigitalTopology, TDigitalSet> & );

template <typename TDigitalTopology, typename TDigitalSet>
  static void draw( DGtal::Board2D & board, const DGtal::Object<TDigitalTopology, TDigitalSet> & );
// Object
    
    
// PointVector
template<Dimension dim, typename TComponent>
  static void drawAsPaving( DGtal::Board2D & board, const DGtal::PointVector<dim,TComponent> & );

template<Dimension dim, typename TComponent>
  static void drawAsGrid( DGtal::Board2D & board, const DGtal::PointVector<dim,TComponent> & );

template<Dimension dim, typename TComponent>
  static void draw( DGtal::Board2D & board, const DGtal::PointVector<dim,TComponent> & );

template<Dimension dim, typename TComponent>
  static void draw( DGtal::Board2D & board, 
             const DGtal::PointVector<dim,TComponent> &, 
             const DGtal::PointVector<dim,TComponent> & );
// PointVector
    
    
// Preimage2D
template <typename Shape>
static void draw( DGtal::Board2D & aBoard, const DGtal::Preimage2D<Shape> & );
// Preimage2D
    
    
// SignedKhalimskyCell
template < Dimension dim, typename TInteger >
  static void draw( DGtal::Board2D & board, const DGtal::SignedKhalimskyCell<dim, TInteger> & );
// SignedKhalimskyCell
    
    
// StraightLineFrom2Points
template <typename TPoint>
static void draw(Board2D & aBoard, const DGtal::StraightLineFrom2Points<TPoint> & );
// StraightLineFrom2Points
  
    
//
    
    
static void draw( DGtal::Board2D & board, const DGtal::CustomStyle & );
static void draw( DGtal::Board2D & board, const DGtal::SetMode & );


   template <typename TSpace, typename TSequence>
   static
   void draw( DGtal::Board2D & aBoard, 
              const DGtal::LatticePolytope2D<TSpace, TSequence> & cip );

    
  }; // end of struct Display2DFactory

} // namespace DGtal


// Includes inline functions/methods 
#include "DGtal/io/Display2DFactory.ih"

//                                                                           //

#endif // !defined Display2DFactory_h

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