Style2DFactory.ih

// Implementation of inline methods                                          //

// Implementation of inline functions and external operators                 //

#ifndef UNUSED_ARGUMENT
#define UNUSED_ARGUMENT(x) (void)x
#endif



namespace DGtal
{

  
  // AngleLinearMinimizer
  struct DefaultDrawStyleCircular_AngleLinearMinimizer : public DrawableWithBoard2D
  {
    virtual void setStyle( Board2D & aBoard ) const
    {
      aBoard.setPenColorRGBi(160,160,160);
      aBoard.setLineStyle( Board2D::Shape::SolidStyle );
      aBoard.setFillColorRGBi(220,220,220);
      aBoard.setLineWidth(1);
    }
  };
  // AngleLinearMinimizer
  
  
  // ArithmeticalDSS
  struct DefaultDrawStyleBB_ArithmeticalDSS : public DrawableWithBoard2D
  {
    virtual void setStyle(Board2D & aBoard) const
    {
      // Set board style
      aBoard.setLineStyle(Board2D::Shape::SolidStyle);
      aBoard.setPenColor(Color::Red);
      aBoard.setLineWidth(1);
      aBoard.setFillColor(Color::None);
    }
  };
  
  struct DefaultDrawStylePoints_ArithmeticalDSS : public DrawableWithBoard2D
  {
    virtual void setStyle(Board2D & aBoard) const
    {
      // Set board style
      aBoard.setLineStyle(Board2D::Shape::SolidStyle);
      aBoard.setPenColor(Color::Black);
      aBoard.setLineWidth(2);
      aBoard.setFillColor(Color::None);
    }
  };
  // ArithmeticalDSS

  
  // CircleFrom2Points
  // CircleFrom2Points


  // CircleFrom3Points
  // CircleFrom3Points
  
  
  // DigitalSetBySTLSet
  struct DefaultDrawStyle_DigitalSetBySTLSet : public DrawableWithBoard2D
  {
    virtual void setStyle(Board2D & aBoard) const
    {
      aBoard.setLineStyle(Board2D::Shape::SolidStyle);
      aBoard.setFillColorRGBi(160,160,160);
      aBoard.setPenColorRGBi(80,80,80);
    }
  };
  // DigitalSetBySTLSet


  // DigitalSetBySTLVector
  struct DefaultDrawStyle_DigitalSetBySTLVector : public DrawableWithBoard2D
  {
    virtual void setStyle(Board2D & aBoard) const
    {
      aBoard.setLineWidth(1);
      aBoard.setLineStyle(Board2D::Shape::SolidStyle);
      aBoard.setFillColorRGBi(160,160,160);
      aBoard.setPenColorRGBi(80,80,80);
    }
  };
  // DigitalSetBySTLVector
  
  
  // FP
  struct DefaultDrawStyle_FP : public DrawableWithBoard2D
  {
    virtual void setStyle(Board2D & aBoard) const
    {
      // Set board style
      aBoard.setLineStyle(Board2D::Shape::SolidStyle);
      aBoard.setPenColor(Color::Red);
      aBoard.setLineWidth(2);
      aBoard.setFillColor(Color::None);
    }
  };
  // FP
  
  
  // FreemanChain
  struct DefaultDrawStyleGrid_FreemanChain : public DrawableWithBoard2D
  {
    virtual void setStyle( Board2D & aBoard ) const
    {
      aBoard.setLineStyle (LibBoard::Shape::SolidStyle );
      aBoard.setFillColor(Color::None);
    }
  };

  struct DefaultDrawStyleInterGrid_FreemanChain : public DrawableWithBoard2D
  {
    virtual void setStyle( Board2D & aBoard ) const
    {
      aBoard.setLineStyle (LibBoard::Shape::SolidStyle );
      aBoard.setFillColor(Color::None);
    }
  };
  // FreemanChain
  
  
  // GeometricalDSS
  struct DefaultDrawStyle_GeometricalDSS : public DrawableWithBoard2D
  {
    virtual void setStyle(Board2D & aBoard) const
    {
      aBoard.setLineStyle(Board2D::Shape::SolidStyle);
      aBoard.setPenColor(Color::Red);
      aBoard.setLineWidth(1.5);
      aBoard.setFillColor(Color::None);
    }
  };
  // GeometricalDSS

  //GeometricalDCA
  struct DefaultDrawStyle_GeometricalDCA : public DrawableWithBoard2D
  {
    virtual void setStyle(Board2D & aBoard) const
    {
      aBoard.setLineStyle(Board2D::Shape::SolidStyle);
      aBoard.setPenColor(Color::Red);
      aBoard.setLineWidth(1.5);
      aBoard.setFillColor(Color::None);
    }
  };
  // GeometricalDCA
  

  //FrechetShortcut
  struct DefaultDrawStyle_FrechetShortcut : public DrawableWithBoard2D
  {
    virtual void setStyle(Board2D & aBoard) const
    {
      aBoard.setLineStyle(Board2D::Shape::SolidStyle);
      aBoard.setPenColor(Color::Red);
      aBoard.setLineWidth(1.5);
      aBoard.setFillColor(Color::None);
    }
  };
  
  //FrechetShortcut

  // GridCurve
  // we use friend because of inner classes
  // GridCurve
  
  
  // HyperRectDomain
  struct DefaultDrawStylePaving_HyperRectDomain : public DrawableWithBoard2D
  {
    virtual void setStyle(Board2D & aBoard) const
    {
      aBoard.setPenColorRGBi(160, 160, 160);
      aBoard.setFillColorRGBi(255, 255, 255);
      aBoard.setLineStyle(Board2D::Shape::SolidStyle);
      aBoard.setLineWidth( 1 );
    }
  };

  struct DefaultDrawStyleGrid_HyperRectDomain : public DrawableWithBoard2D
  {
    virtual void setStyle(Board2D & aBoard) const
    {
      aBoard.setPenColorRGBi(160, 160, 160);
      aBoard.setFillColorRGBi(160, 160, 160);
      aBoard.setLineStyle(Board2D::Shape::DashStyle);
      aBoard.setLineWidth( 1 );
    }
  };
  // HyperRectDomain
  
  
  // ImageContainerByHashTree
  struct DefaultDrawStyle_ImageContainerByHashTree : public DrawableWithBoard2D
  {
    virtual void setStyle(Board2D & aboard) const
    {
      aboard.setPenColorRGBi(60, 60, 60);
      aboard.setLineStyle(Board2D::Shape::SolidStyle);
    }
  };
  // ImageContainerByHashTree


  // ImageContainerBySTLVector
  struct DefaultDrawStyle_ImageContainerBySTLVector : public DrawableWithBoard2D
  {
    virtual void setStyle( Board2D & aBoard ) const
    {
      aBoard.setPenColorRGBi(60, 60, 60);
      aBoard.setLineStyle(Board2D::Shape::SolidStyle);
    }
  };
  // ImageContainerBySTLVector
  
  
  // KhalimskyCell
  struct DefaultDrawStyle_KhalimskyCell : public DrawableWithBoard2D
  {
    virtual void setStyle( Board2D & aBoard ) const
    {
      aBoard.setPenColorRGBi( 50, 50, 50 );
      aBoard.setLineStyle( Board2D::Shape::SolidStyle );
      aBoard.setFillColorRGBi( 80, 80, 80 );
      aBoard.setLineWidth( 1 );
    }
  };
  // KhalimskyCell
  
  
  // Object
  struct DefaultDrawStyle_Object : public DrawableWithBoard2D
  {
    virtual void setStyle(Board2D & aBoard) const
    {
      // line width decreased to avoid too large arrows to display adjacency.
      aBoard.setLineWidth(0.75);
      aBoard.setLineStyle(Board2D::Shape::SolidStyle);
      aBoard.setFillColorRGBi(160, 160, 160);
      aBoard.setPenColorRGBi(80, 80, 80);
    }
  };
  // Object
  
  
  // PointVector
  struct DefaultDrawStylePaving_PointVector : public DrawableWithBoard2D
  {
    virtual void setStyle( Board2D & aBoard ) const
    {
      aBoard.setPenColorRGBi(160,160,160);
      aBoard.setLineStyle( Board2D::Shape::SolidStyle );
      aBoard.setFillColorRGBi(220,220,220);
      aBoard.setLineWidth(1);
    }
  };

  struct DefaultDrawStyleGrid_PointVector : public DrawableWithBoard2D
  {
    virtual void setStyle( Board2D & aBoard ) const
    {
      aBoard.setPenColor(Color::Black);
      aBoard.setLineStyle( Board2D::Shape::SolidStyle );
    }
  };
  // PointVector

  
  // Preimage2D
  // Preimage2D

  
  // SignedKhalimskyCell
  struct DefaultDrawStyle_SignedKhalimskyCell : public DrawableWithBoard2D
  {
    virtual void setStyle( Board2D & aBoard ) const
    {
      aBoard.setPenColorRGBi( 50, 50, 50 );
      aBoard.setLineStyle( Board2D::Shape::SolidStyle );
      aBoard.setFillColorRGBi( 80, 80, 80 );
      aBoard.setLineWidth( 1 );
    }
  };
  // SignedKhalimskyCell

  // LatticePolytope2D
  struct DefaultDrawStyleFilled_LatticePolytope2D : public DrawableWithBoard2D
  {
    virtual void setStyle( Board2D & aBoard ) const
    {
      aBoard.setPenColorRGBi( 30, 30, 30 );
      aBoard.setLineStyle( Board2D::Shape::SolidStyle );
      aBoard.setFillColorRGBi( 200, 200, 200 );
      aBoard.setLineWidth( 2 );
    }
  };
  struct DefaultDrawStyleTransparent_LatticePolytope2D : public DrawableWithBoard2D
  {
    virtual void setStyle( Board2D & aBoard ) const
    {
      aBoard.setPenColorRGBi( 30, 30, 30 );
      aBoard.setLineStyle( Board2D::Shape::SolidStyle );
      aBoard.setFillColor( DGtal::Color::None ); //200, 200, 200 );
      aBoard.setLineWidth( 2 );
    }
  };
  // LatticePolytope2D

  
  // StraightLineFrom2Points
  // StraightLineFrom2Points
  
  
}


//


// AngleLinearMinimizer
inline
DGtal::DrawableWithBoard2D* defaultStyle(const DGtal::AngleLinearMinimizer & /*a*/, std::string mode = "" )
{
  UNUSED_ARGUMENT(mode);
  //only one style actually...
  return new DefaultDrawStyleCircular_AngleLinearMinimizer;
}
// AngleLinearMinimizer


// ArithmeticalDSS
template <typename TIterator, typename TInteger, int connectivity>
inline
DGtal::DrawableWithBoard2D* defaultStyle(const DGtal::ArithmeticalDSS<TIterator,TInteger,connectivity> & /*a*/, std::string mode = "" )
{
  if ( ( mode == "" ) || ( mode == "BoundingBox" ) ) 
    return new DefaultDrawStyleBB_ArithmeticalDSS;
  else // mode == "Points"
    return new DefaultDrawStylePoints_ArithmeticalDSS;
}
// ArithmeticalDSS


// CircleFrom2Points
template <typename TPoint>
inline
DGtal::DrawableWithBoard2D* defaultStyle(const DGtal::CircleFrom2Points<TPoint> & /*cf2p*/, std::string mode = "" )
{
  UNUSED_ARGUMENT(mode);
  return new DrawableWithBoard2D; 
}
// CircleFrom2Points


// CircleFrom3Points
template <typename TPoint>
inline
DGtal::DrawableWithBoard2D* defaultStyle(const DGtal::CircleFrom3Points<TPoint> & /*cf3p*/, std::string mode = "" )
{
  UNUSED_ARGUMENT(mode);
  return new DrawableWithBoard2D; 
}
// CircleFrom3Points


// DigitalSetBySTLSet
template<typename Domain>
inline
DGtal::DrawableWithBoard2D* defaultStyle(const DGtal::DigitalSetBySTLSet<Domain> & /*s*/, std::string mode = "" )
{
  UNUSED_ARGUMENT(mode);
  return new DefaultDrawStyle_DigitalSetBySTLSet;
}
// DigitalSetBySTLSet


// DigitalSetBySTLVector
template<typename Domain>
inline
DGtal::DrawableWithBoard2D* defaultStyle(const DGtal::DigitalSetBySTLVector<Domain> & /*v*/, std::string mode = "" )
{
  UNUSED_ARGUMENT(mode);
  return new DefaultDrawStyle_DigitalSetBySTLVector;
}
// DigitalSetBySTLVector


// FP
template <typename TIterator, typename TInteger, int connectivity>
inline
DGtal::DrawableWithBoard2D* defaultStyle(const DGtal::FP<TIterator,TInteger,connectivity> & /*fp*/, 
                                         std::string mode = "" )
{
  UNUSED_ARGUMENT(mode);
  return new DefaultDrawStyle_FP;
}
// FP


// FreemanChain
template <typename TInteger>
inline
DGtal::DrawableWithBoard2D* defaultStyle(const DGtal::FreemanChain<TInteger> & /*f*/, 
                                         std::string mode = "" )
{
  if ( ( mode == "" ) || ( mode == "Grid" ) ) 
    return new DefaultDrawStyleGrid_FreemanChain;
  else 
    return new DefaultDrawStyleInterGrid_FreemanChain;  
}
// FreemanChain


// GeometricalDSS
template <typename TConstIterator>
inline
DGtal::DrawableWithBoard2D* defaultStyle(const DGtal::GeometricalDSS<TConstIterator> & /*g*/, 
                                         std::string mode = "" )
{
  UNUSED_ARGUMENT(mode);
  return new DefaultDrawStyle_GeometricalDSS; 
}
// GeometricalDSS

// GeometricalDCA
template <typename TConstIterator>
inline
DGtal::DrawableWithBoard2D* defaultStyle(const DGtal::GeometricalDCA<TConstIterator> & /*g*/,
                                         std::string mode = "" )
{
  UNUSED_ARGUMENT(mode);
  return new DefaultDrawStyle_GeometricalDCA; 
}
// GeometricalDCA

// // FrechetShortcut
template <typename TIterator, typename TInteger>
inline
DGtal::DrawableWithBoard2D* defaultStyle(const DGtal::FrechetShortcut<TIterator,TInteger> & /*f*/, std::string mode = "" )
{
  UNUSED_ARGUMENT(mode);
  return new DefaultDrawStyle_FrechetShortcut; 
}
// // FrechetShortcut



// GridCurve
template <typename TKSpace>
DGtal::DrawableWithBoard2D* 
defaultStyle(const GridCurve<TKSpace> & /*object*/, 
             std::string mode = "" )
{
  UNUSED_ARGUMENT(mode);
  return new DrawableWithBoard2D; 
}
// GridCurve

// SCellsRange
template <typename TIterator, typename TSCell>
DGtal::DrawableWithBoard2D* 
defaultStyle(const ConstRangeAdapter<TIterator, DefaultFunctor, TSCell> & /*object*/, 
             std::string mode = "" )
{
  UNUSED_ARGUMENT(mode);
  return new DrawableWithBoard2D; 
}
// SCellsRange

// PointsRange
template <typename TIterator, typename TKSpace>
DGtal::DrawableWithBoard2D* 
defaultStyle(const ConstRangeAdapter<TIterator, SCellToPoint<TKSpace>, typename TKSpace::Point> & /*object*/, 
             std::string mode = "" )
{
  UNUSED_ARGUMENT(mode);
  return new DrawableWithBoard2D; 
}
// PointsRange

// MidPointsRange
template <typename TIterator, typename TKSpace>
DGtal::DrawableWithBoard2D* 
defaultStyle(const ConstRangeAdapter<TIterator, SCellToMidPoint<TKSpace>, 
             typename TKSpace::Space::RealPoint> & /*object*/, 
             std::string mode = "" )
{
  UNUSED_ARGUMENT(mode);
  return new DrawableWithBoard2D; 
}
// MidPointsRange

// ArrowsRange
template <typename TIterator, typename TKSpace>
DGtal::DrawableWithBoard2D* 
defaultStyle(const ConstRangeAdapter<TIterator, SCellToArrow<TKSpace>, 
             std::pair<typename TKSpace::Point, typename TKSpace::Vector> > & /*object*/, 
             std::string mode = "" )
{
  UNUSED_ARGUMENT(mode);
  return new DrawableWithBoard2D; 
}
// ArrowsRange

// InnerPointsRange
template <typename TIterator, typename TKSpace>
DGtal::DrawableWithBoard2D* 
defaultStyle(const ConstRangeAdapter<TIterator, SCellToInnerPoint<TKSpace>, typename TKSpace::Point> & /*object*/, 
             std::string mode = "" )
{
  UNUSED_ARGUMENT(mode);
  return new DrawableWithBoard2D; 
}
// InnerPointsRange

// OuterPointsRange
template <typename TIterator, typename TKSpace>
DGtal::DrawableWithBoard2D* 
defaultStyle(const ConstRangeAdapter<TIterator, SCellToOuterPoint<TKSpace>, typename TKSpace::Point> & /*object*/, 
             std::string mode = "" )
{
  UNUSED_ARGUMENT(mode);
  return new DrawableWithBoard2D; 
}
// OuterPointsRange

// IncidentPointsRange
template <typename TIterator, typename TKSpace>
DGtal::DrawableWithBoard2D* 
defaultStyle(const ConstRangeAdapter<TIterator, SCellToIncidentPoints<TKSpace>, 
             std::pair<typename TKSpace::Point, typename TKSpace::Point> > & /*object*/, 
             std::string mode = "" )
{
  UNUSED_ARGUMENT(mode);
  return new DrawableWithBoard2D; 
}
// IncidentPointsRange

// HyperRectDomain
template<typename TSpace>
inline
DGtal::DrawableWithBoard2D* defaultStyle(const DGtal::HyperRectDomain<TSpace> & /*h*/, std::string mode = "" )
{
  if ( ( mode == "" ) || ( mode == "Both" ) || ( mode == "Grid" ) ) 
    return new DefaultDrawStyleGrid_HyperRectDomain;
  else // mode == "Paving"
    return new DefaultDrawStylePaving_HyperRectDomain;
}
// HyperRectDomain


// ImageContainerByHashTree
template <typename Domain, typename Value, typename HashKey  >
inline
DGtal::DrawableWithBoard2D* defaultStyle(const DGtal::ImageContainerByHashTree<Domain, Value, HashKey > & /*icbht*/, std::string mode = "" )
{
  UNUSED_ARGUMENT(mode);
  return new DefaultDrawStyle_ImageContainerByHashTree;
}
// ImageContainerByHashTree


// ImageContainerBySTLVector
template <typename D, typename V>
inline
DGtal::DrawableWithBoard2D* defaultStyle(const DGtal::ImageContainerBySTLVector<D, V> & /*icbsv*/, std::string mode = "" )
{
  UNUSED_ARGUMENT(mode);
  return new DefaultDrawStyle_ImageContainerBySTLVector;
}
// ImageContainerBySTLVector


// KhalimskyCell
template < Dimension dim, typename TInteger >
inline
DGtal::DrawableWithBoard2D* defaultStyle(const DGtal::KhalimskyCell<dim, TInteger> & /*k*/, std::string mode = "" )
{
  UNUSED_ARGUMENT(mode);
  return new DefaultDrawStyle_KhalimskyCell;
}
// KhalimskyCell


// Object
template <typename TDigitalTopology, typename TDigitalSet>
inline
DGtal::DrawableWithBoard2D* defaultStyle(const DGtal::Object<TDigitalTopology, TDigitalSet> & /*o*/, std::string mode = "" )
{
  UNUSED_ARGUMENT(mode);
  return new DefaultDrawStyle_Object;
}
// Object


// PointVector
template<Dimension dim, typename TComponent>
inline
DGtal::DrawableWithBoard2D* defaultStyle(const DGtal::PointVector<dim,TComponent> & /*p*/, std::string mode = "")
{
  if ( ( mode == "" ) || ( mode == "Paving" ) ) 
    return new DefaultDrawStylePaving_PointVector;
  else // mode == "Grid"
    return new DefaultDrawStyleGrid_PointVector;  
}
// PointVector


// Preimage2D
template <typename Shape>
inline
DGtal::DrawableWithBoard2D* defaultStyle(const DGtal::Preimage2D<Shape> & /*p*/, std::string mode = "")
{
  UNUSED_ARGUMENT(mode);
  return new DrawableWithBoard2D; 
}
// Preimage2D


// SignedKhalimskyCell
template < Dimension dim, typename TInteger >
inline
DGtal::DrawableWithBoard2D* defaultStyle(const DGtal::SignedKhalimskyCell<dim, TInteger> & /*sk*/, std::string mode = "" )
{
  UNUSED_ARGUMENT(mode);
  return new DefaultDrawStyle_SignedKhalimskyCell;
}
// SignedKhalimskyCell


// StraightLineFrom2Points
template <typename TPoint>
inline
DGtal::DrawableWithBoard2D* defaultStyle(const DGtal::StraightLineFrom2Points<TPoint> & /*slf2p*/, std::string mode = "" )
{
  UNUSED_ARGUMENT(mode);
  return new DrawableWithBoard2D;
}
// StraightLineFrom2Points

// LatticePolytope2D
template < typename TSpace, typename TSequence>
inline
DGtal::DrawableWithBoard2D* 
defaultStyle( const DGtal::LatticePolytope2D<TSpace,TSequence> & /*cip*/, 
              std::string mode = "" )
{
  if ( ( mode == "" ) || ( mode == "Transparent" ) ) 
    return new DefaultDrawStyleTransparent_LatticePolytope2D;
  else // "Filled"
    return new DefaultDrawStyleFilled_LatticePolytope2D;
}
// LatticePolytope2D

//


inline
DGtal::DrawableWithBoard2D* defaultStyle(const DGtal::CustomStyle & /*cs*/, std::string mode = "" )
{
  UNUSED_ARGUMENT(mode);
  return 0;
}

inline
DGtal::DrawableWithBoard2D* defaultStyle(const DGtal::SetMode & /*sm*/, std::string mode = "" )
{
  UNUSED_ARGUMENT(mode);
  return 0;
}


//                                                                           //