DGtal/shapes/Shapes.ih

#include <cstdlib>

// IMPLEMENTATION of inline methods.

// ----------------------- Standard services ------------------------------

template <typename TDomain>
inline
DGtal::Shapes<TDomain>::~Shapes()
{
}


template <typename TDomain>
template <typename TDigitalSet>
inline
void
DGtal::Shapes<TDomain>::removeNorm1Ball
( TDigitalSet & aSet,
  const Point & aCenter, 
  UnsignedInteger aRadius )
{
  Point v1( aCenter.diagonal( aRadius ) );
  Point p1( aCenter );
  Point p2( p1 );
  p1 -= v1;
  p2 += v1;
  const Domain & domain = aSet.domain(); 
  typedef DGtal::HyperRectDomain<Space> LocalSpace;
  LocalSpace ballDomain( p1, p2 );
  for ( typename LocalSpace::ConstIterator it = ballDomain.begin(); 
        it != ballDomain.end(); 
        ++it )
    {
      if ( domain.isInside( *it ) 
           && ( (*it - aCenter ).norm1() <= aRadius ) )
        aSet.erase( *it );
    }
}
template <typename TDomain>
template <typename TDigitalSet>
inline
void
DGtal::Shapes<TDomain>::addNorm1Ball
( TDigitalSet & aSet,
  const Point & aCenter, 
  UnsignedInteger aRadius )
{
  Point v1( aCenter.diagonal( aRadius ) );
  Point p1( aCenter );
  Point p2( p1 );
  p1 -= v1;
  p2 += v1;
  const Domain & domain = aSet.domain(); 
  typedef DGtal::HyperRectDomain<Space> LocalSpace;
  LocalSpace ballDomain( p1, p2 );
  for ( typename LocalSpace::ConstIterator it = ballDomain.begin(); 
        it != ballDomain.end(); 
        ++it )
    {
      if ( domain.isInside( *it ) 
           && ( (*it - aCenter ).norm1() <= aRadius ) )
        aSet.insert( *it );
    }
}


template <typename TDomain>
template <typename TDigitalSet>
inline
void
DGtal::Shapes<TDomain>::removeNorm2Ball
( TDigitalSet & aSet,
  const Point & aCenter, 
  UnsignedInteger aRadius )
{
  Point v1( aCenter.diagonal( aRadius ) );
  Point p1( aCenter );
  Point p2( p1 );
  p1 -= v1;
  p2 += v1;
  const Domain & domain = aSet.domain(); 
  typedef DGtal::HyperRectDomain<Space> LocalSpace;
  LocalSpace ballDomain( p1, p2 );
  for ( typename LocalSpace::ConstIterator it = ballDomain.begin(); 
        it != ballDomain.end(); 
        ++it )
    {
      if ( domain.isInside( *it ) 
           && ( (*it - aCenter ).norm() <= aRadius ) )
        aSet.erase( *it );
    }
}


template <typename TDomain>
template <typename TDigitalSet>
inline
void
DGtal::Shapes<TDomain>::addNorm2Ball
( TDigitalSet & aSet,
  const Point & aCenter, 
  UnsignedInteger aRadius )
{
  Point v1( aCenter.diagonal( aRadius ) );
  Point p1( aCenter );
  Point p2( p1 );
  p1 -= v1;
  p2 += v1;
  const Domain & domain = aSet.domain(); 
  typedef DGtal::HyperRectDomain<Space> LocalSpace;
  LocalSpace ballDomain( p1, p2 );
  for ( typename LocalSpace::ConstIterator it = ballDomain.begin(); 
        it != ballDomain.end(); 
        ++it )
    {
      if ( domain.isInside( *it ) 
           && ( (*it - aCenter ).norm() <= aRadius ) )
        aSet.insert( *it );
    }
}

template <typename TDomain>
template <typename TDigitalSet, typename ShapeFunctor>
void
DGtal::Shapes<TDomain>::digitalShaper( TDigitalSet & aSet,
                                       const ShapeFunctor & aFunctor)
{
  typedef DGtal::HyperRectDomain<Space> LocalSpace;
  
  BOOST_CONCEPT_ASSERT((CDigitalBoundedShape<ShapeFunctor>));
  BOOST_CONCEPT_ASSERT((CDigitalOrientedShape<ShapeFunctor>));
 

  Point pLow = aFunctor.getLowerBound();
  Point pUpp = aFunctor.getUpperBound();
  
  LocalSpace implicitDomain( pLow, pUpp );
  for ( typename LocalSpace::ConstIterator it = implicitDomain.begin(); 
        it != implicitDomain.end(); 
        ++it )
    {
      if ( aFunctor.orientation( *it ) == INSIDE)
        aSet.insert( *it );
    }
}


template <typename TDomain>
template <typename TDigitalSet, typename ShapeFunctor>
void
DGtal::Shapes<TDomain>::euclideanShaper( TDigitalSet & aSet,
                                         const ShapeFunctor & aFunctor,
                                         const double h)
{
  
  BOOST_CONCEPT_ASSERT((CEuclideanBoundedShape<ShapeFunctor>));
  BOOST_CONCEPT_ASSERT((CEuclideanOrientedShape<ShapeFunctor>));

  RealPoint pLow = aFunctor.getLowerBound();
  RealPoint pUpp = aFunctor.getUpperBound();
  GaussDigitizer<Space,ShapeFunctor> dig;  
  dig.attach( aFunctor ); // attaches the shape.
  dig.init( pLow, pUpp, h); 
  
  // Creates a set from the digitizer.
  Shapes<Domain>::digitalShaper( aSet, dig );
}

template <typename TDomain>
template <typename DigitalSet, typename PointPredicate>
void
DGtal::Shapes<TDomain>::makeSetFromPointPredicate
( DigitalSet & aSet,
  const PointPredicate & aPP )
{
  
  BOOST_CONCEPT_ASSERT(( CDigitalSet< DigitalSet > ));
  BOOST_CONCEPT_ASSERT(( CPointPredicate< PointPredicate > ));
  BOOST_STATIC_ASSERT
    (( ConceptUtils::SameType< Domain, typename DigitalSet::Domain >::value ));
  BOOST_STATIC_ASSERT
    (( ConceptUtils::SameType< Point, typename PointPredicate::Point >::value ));

  typedef typename Domain::ConstIterator ConstIterator;
  for ( ConstIterator it = aSet.domain().begin(),
          it_end = aSet.domain().end(); it != it_end; ++it )
    if ( aPP( *it ) ) aSet.insert( *it );
}




// Interface - public :

template <typename TDomain>
inline
void
DGtal::Shapes<TDomain>::selfDisplay ( std::ostream & out ) const
{
  out << "[Shapes]";
}

template <typename TDomain>
inline
bool
DGtal::Shapes<TDomain>::isValid() const
{
  return true;
}



// Implementation of inline functions                                        //

template <typename TDomain>
inline
std::ostream&
DGtal::operator<< ( std::ostream & out, 
                    const Shapes<TDomain> & object )
{
  object.selfDisplay( out );
  return out;
}

//                                                                           //