ImageContainerBySTLVector.ih

// IMPLEMENTATION of inline methods.

#include <cstdlib>
#include "DGtal/images/ImageContainerBySTLVector.h"

//------------------------------------------------------------------------------
template <typename Domain, typename T>
inline
ImageContainerBySTLVector<Domain, T>::
ImageContainerBySTLVector(const Domain &aDomain ) :
  myDomain(aDomain), myExtent(aDomain.extent())
{
  this->resize( myDomain.size() );
}

//------------------------------------------------------------------------------
template <typename Domain, typename T>
inline
DGtal::ImageContainerBySTLVector<Domain,T>
::ImageContainerBySTLVector(const ImageContainerBySTLVector& other)
  : vector<T>(other),
    myDomain(other.myDomain), myExtent(other.myExtent)
{
}
//------------------------------------------------------------------------------
template <typename Domain, typename T>
inline
DGtal::ImageContainerBySTLVector<Domain,T>&
DGtal::ImageContainerBySTLVector<Domain,T>
::operator=(const ImageContainerBySTLVector& other)
{
  if (this != &other)
    {
      std::vector<T>::operator=(other);
      myDomain = other.myDomain;
      myExtent = other.myExtent;
    }
  return *this;
}


//------------------------------------------------------------------------------
template <typename Domain, typename T>
inline
DGtal::ImageContainerBySTLVector<Domain, T>::~ImageContainerBySTLVector( )
{
}


//------------------------------------------------------------------------------
template <typename Domain, typename T>
inline
T
DGtal::ImageContainerBySTLVector<Domain, T>::operator()(const Point &aPoint) const
{
  ASSERT(this->domain().isInside(aPoint));
  return this->operator[](linearized( aPoint ) );
}

//------------------------------------------------------------------------------
// template <typename Domain, typename T>
// inline
// typename ImageContainerBySTLVector<Domain, T>::ConstIterator
// ImageContainerBySTLVector<Domain, T>::begin(const Point &aPoint) const
// {
//   ASSERT(this->domain().isInside(aPoint));
//   return this->begin() + linearized( aPoint );
// }


//------------------------------------------------------------------------------
template <typename Domain, typename T>
inline
void
DGtal::ImageContainerBySTLVector<Domain, T>::setValue(const Point &aPoint, const T &V)
{
  ASSERT(this->domain().isInside(aPoint));
  this->operator[](linearized( aPoint )) = V;
}

//------------------------------------------------------------------------------
template <typename Domain, typename T>
inline
const typename DGtal::ImageContainerBySTLVector<Domain, T>::Domain&
DGtal::ImageContainerBySTLVector<Domain, T>::domain() const
{
  return myDomain;
}

//------------------------------------------------------------------------------
template <typename Domain, typename T>
inline
typename DGtal::ImageContainerBySTLVector<Domain, T>::ConstRange
DGtal::ImageContainerBySTLVector<Domain, T>::constRange() const
{
  return ConstRange( this->begin(), this->end(), DistanceFunctorFromPoint<Self>(this));
}

//------------------------------------------------------------------------------
template <typename Domain, typename T>
inline
typename ImageContainerBySTLVector<Domain, T>::Range
DGtal::ImageContainerBySTLVector<Domain, T>::range()
{
  return Range ( this->begin(), this->end(), DistanceFunctorFromPoint<Self>(this) );
}
//------------------------------------------------------------------------------
template <typename Domain, typename T>
inline
typename DGtal::ImageContainerBySTLVector<Domain, T>::Vector
DGtal::ImageContainerBySTLVector<Domain, T>::extent() const
{
  return myExtent;
}

//------------------------------------------------------------------------------
template <typename Domain, typename T>
inline
void
DGtal::ImageContainerBySTLVector<Domain, T>::translateDomain(const Vector& aShift)
{
  myDomain = Domain(myDomain.lowerBound()+aShift, myDomain.upperBound()+aShift);
}

//------------------------------------------------------------------------------
template <typename TDomain, typename V>
inline
void
DGtal::ImageContainerBySTLVector<TDomain, V>::selfDisplay ( std::ostream & out ) const
{
  out << "[Image - STLVector] size=" << this->size() << " valuetype="
      << sizeof(V) << "bytes Domain=" << myDomain;
}

//------------------------------------------------------------------------------
template <typename Domain, typename T>
inline
bool
DGtal::ImageContainerBySTLVector<Domain, T>::isValid() const
{
  return (this != NULL);
}


//------------------------------------------------------------------------------
template <typename D, typename V>
inline
std::string
DGtal::ImageContainerBySTLVector<D, V>::className() const
{
  return "ImageContainerBySTLVector";
}

// Helper classes defined in the compilation unit (anonymous namespace)

namespace
{

  template < typename Domain, int dimension>
  struct linearizer
  {

    typedef typename Domain::Point Point;
    typedef typename Domain::Size Size;

    static Size apply( const Point & aPoint, const Point & lowerBound,
        const Point & extent )
    {
      Size pos = aPoint[ 0 ] - lowerBound[ 0 ] ;
      Size multiplier = 1;
      for (typename Domain::Dimension k = 1 ; k < dimension ; ++k)
      {
        multiplier *= extent[ k-1  ];
        pos += multiplier * ( aPoint[ k ] - lowerBound[ k ] );
      }
      return pos;
    }
  };

  template < typename Domain >
  struct linearizer< Domain, 1 >
  {
    typedef typename Domain::Point Point;
    typedef typename Domain::Size Size;

    static Size apply( const Point & aPoint,
        const Point & lowerBound,
        const Point & /*extent*/ )
    {
      return aPoint[ 0 ] - lowerBound[ 0 ];
    }
  };

  template < typename Domain >
  struct linearizer< Domain, 2 >
  {
    typedef typename Domain::Point Point;
    typedef typename Domain::Size Size;

    static Size apply( const Point & aPoint,
        const Point & lowerBound,
        const Point & extent )
    {
      return ( aPoint[ 0 ] - lowerBound[ 0 ] ) + extent[ 0 ] *
        (aPoint[ 1 ] - lowerBound[ 1 ] );
    }
  };

  template < typename Domain >
  struct linearizer< Domain, 3 >
  {
    typedef typename Domain::Point Point;
    typedef typename Domain::Size Size;

    static Size apply( const Point & aPoint,
        const Point & lowerBound,
        const Point & extent )
    {
      Size res = aPoint[ 0 ] - lowerBound[ 0 ];
      Size multiplier = extent[ 0 ];
      res += multiplier * ( aPoint[ 1 ] - lowerBound[ 1 ] );
      multiplier *= extent[ 1 ];
      res += multiplier * ( aPoint[ 2 ] - lowerBound[ 2 ] );
      return res;
    }
  };
}



// Internals - private :
template<typename Domain, typename T>
inline
typename ImageContainerBySTLVector<Domain, T>::Size
ImageContainerBySTLVector<Domain, T>::linearized(const Point &aPoint) const
{
  return linearizer<Domain, Domain::dimension >::apply( aPoint,
                                                        myDomain.lowerBound(),
                                                        myExtent );
}