DigitalSetBySTLVector.ih

#include <cstdlib>
#include <algorithm>

// IMPLEMENTATION of inline methods.

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

template <typename Domain>
inline
DGtal::DigitalSetBySTLVector<Domain>::~DigitalSetBySTLVector()
{
}

template <typename Domain>
inline
DGtal::DigitalSetBySTLVector<Domain>::DigitalSetBySTLVector
( const Domain & d )
  : myDomain( d ), myVector()
{
}

template <typename Domain>
inline
DGtal::DigitalSetBySTLVector<Domain>::DigitalSetBySTLVector
( const DigitalSetBySTLVector & other )
  : myDomain( other.myDomain ), myVector( other.myVector )
{
}

template <typename Domain>
inline
DGtal::DigitalSetBySTLVector<Domain> &
DGtal::DigitalSetBySTLVector<Domain>::operator=
( const DigitalSetBySTLVector & other )
{
  ASSERT( ( myDomain.lowerBound() <= other.myDomain.lowerBound() )
    && ( myDomain.upperBound() >= other.myDomain.upperBound() )
    && "This domain should include the domain of the other set in case of assignment." );
  myVector = other.myVector;
  return *this;
}


template <typename Domain>
inline
const Domain & 
DGtal::DigitalSetBySTLVector<Domain>::domain() const
{
  return myDomain;
}


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

template <typename Domain>
inline
typename DGtal::DigitalSetBySTLVector<Domain>::Size
DGtal::DigitalSetBySTLVector<Domain>::size() const
{
  return (unsigned int)myVector.size();
}

template <typename Domain>
inline
bool
DGtal::DigitalSetBySTLVector<Domain>::empty() const
{
  return myVector.empty();
}
     
template <typename Domain>
inline
void
DGtal::DigitalSetBySTLVector<Domain>::insert( const Point & p )
{
  // ASSERT( myDomain.isInside( p ) );
  Iterator it = find( p );
  if ( it == end() ) 
    myVector.push_back( p );
}

template <typename Domain>
template <typename PointInputIterator>
inline
void
DGtal::DigitalSetBySTLVector<Domain>::insert
( PointInputIterator first, PointInputIterator last )
{
  for ( ; first != last; ++first )
    insert( *first );
}

template <typename Domain>
inline
void
DGtal::DigitalSetBySTLVector<Domain>::insertNew( const Point & p )
{
  // ASSERT( myDomain.isInside( p ) );
  ASSERT_ALL_PRE( find( p ) == end() );
  myVector.push_back( p );
}

template <typename Domain>
template <typename PointInputIterator>
inline
void
DGtal::DigitalSetBySTLVector<Domain>::insertNew
( PointInputIterator first, PointInputIterator last )
{
  while ( first != last )
    myVector.push_back( *first++ );
  // std::copy( first, last, myVector.end() );
}


template <typename Domain>
inline
typename DGtal::DigitalSetBySTLVector<Domain>::Size
DGtal::DigitalSetBySTLVector<Domain>::erase( const Point & p )
{
  Iterator it = find( p );
  if ( it != end() )
    {
      erase( it );
      return 1;
    }
  return 0;
}

template <typename Domain>
inline
void
DGtal::DigitalSetBySTLVector<Domain>::erase( Iterator it )
{
  *it = myVector.back();
  myVector.pop_back();
}

template <typename Domain>
inline
void
DGtal::DigitalSetBySTLVector<Domain>::erase( Iterator first, Iterator last )
{
  while ( ( last != end() ) 
    && ( first != last ) )
    {
      *first++ = myVector.back();
      myVector.pop_back();
    }
  if ( first != last )
    while ( first != end() )
      myVector.pop_back();
}

template <typename Domain>
inline
void
DGtal::DigitalSetBySTLVector<Domain>::clear()
{
  myVector.clear();
}

template <typename Domain>
inline
typename DGtal::DigitalSetBySTLVector<Domain>::ConstIterator 
DGtal::DigitalSetBySTLVector<Domain>::find( const Point & p ) const
{
  const ConstIterator it_end = end();
  for ( ConstIterator it = begin(); it != it_end; ++it )
    if ( p == *it ) return it;
  return it_end;
}

template <typename Domain>
inline
typename DGtal::DigitalSetBySTLVector<Domain>::Iterator 
DGtal::DigitalSetBySTLVector<Domain>::find( const Point & p )
{
  const Iterator it_end = end();
  for ( Iterator it = begin(); it != it_end; ++it )
    if ( p == *it ) return it;
  return it_end;
}


template <typename Domain>
inline
typename DGtal::DigitalSetBySTLVector<Domain>::ConstIterator 
DGtal::DigitalSetBySTLVector<Domain>::begin() const
{
  return myVector.begin();
}

template <typename Domain>
inline
typename DGtal::DigitalSetBySTLVector<Domain>::ConstIterator 
DGtal::DigitalSetBySTLVector<Domain>::end() const
{
  return myVector.end();
}


template <typename Domain>
inline
typename DGtal::DigitalSetBySTLVector<Domain>::Iterator 
DGtal::DigitalSetBySTLVector<Domain>::begin()
{
  return myVector.begin();
}


template <typename Domain>
inline
typename DGtal::DigitalSetBySTLVector<Domain>::Iterator 
DGtal::DigitalSetBySTLVector<Domain>::end()
{
  return myVector.end();
}

template <typename Domain>
inline
DGtal::DigitalSetBySTLVector<Domain> & 
DGtal::DigitalSetBySTLVector<Domain>
::operator+=( const DigitalSetBySTLVector<Domain> & aSet )
{
  if ( this != &aSet )
    {
      std::vector<Point> other( aSet.myVector );
      std::stable_sort( other.begin(), other.end() );
      std::stable_sort( begin(), end() );
      std::vector<Point> new_vector;
      new_vector.reserve( size() + other.size() );
      std::set_union( begin(), end(), other.begin(), other.end(), 
          std::back_insert_iterator< std::vector<Point> >
          ( new_vector ) );
      myVector.swap( new_vector );
    }
  return *this;
}


// ----------------------- Other Set services -----------------------------
    

template <typename Domain>
template <typename TOutputIterator>
inline
void
DGtal::DigitalSetBySTLVector<Domain>::computeComplement(TOutputIterator& ito) const
{
  typename Domain::ConstIterator itPoint = myDomain.begin();
  typename Domain::ConstIterator itEnd = myDomain.end();
  while ( itPoint != itEnd ) {
    if ( std::find( begin(), end(), *itPoint ) == end() ) {
      *ito++ = *itPoint;
    }
    ++itPoint;
  }
}

template <typename Domain>
inline
void
DGtal::DigitalSetBySTLVector<Domain>::assignFromComplement
( const DigitalSetBySTLVector<Domain> & other_set )
{
  clear();
  typename Domain::ConstIterator itPoint = myDomain.begin();
  typename Domain::ConstIterator itEnd = myDomain.end();
  while ( itPoint != itEnd ) {
    if ( std::find( other_set.begin(),
        other_set.end(),
        *itPoint ) == other_set.end() ) {
      insert( *itPoint );
    }
    ++itPoint;
  }
}
    
template <typename Domain>
inline
void
DGtal::DigitalSetBySTLVector<Domain>::computeBoundingBox
( Point & lower, Point & upper ) const
{
  if ( begin() != end() )
    {
      ConstIterator it = begin();
      ConstIterator it_end = end();
      upper = lower = *it;
      for ( ; it != it_end; ++it )
  if ( it->isLower( lower ) ) lower = *it;
  else if ( it->isUpper( upper ) ) upper = *it;
    }
  else
    {
      lower = myDomain.upperBound();
      upper = myDomain.lowerBound();
    }
}


// Interface - public :

template <typename Domain>
inline
void
DGtal::DigitalSetBySTLVector<Domain>::selfDisplay ( std::ostream & out ) const
{
  out << "[DigitalSetBySTLVector]" << " size=" << size();
}

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



// --------------- CDrawableWithBoard2D realization -------------------------


template<typename Domain>
inline
std::string
DGtal::DigitalSetBySTLVector<Domain>::className() const
{
  return "DigitalSetBySTLVector";
}

// Implementation of inline function                                         //

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

//                                                                           //