ImageContainerBySTLVector.ih

/**
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU Lesser General Public License as
 *  published by the Free Software Foundation, either version 3 of the
 *  License, or  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 **/
 
/**
 * @file ImageContainerBySTLVector.ih
 * @author David Coeurjolly (\c david.coeurjolly@liris.cnrs.fr )
 * @author Guillaume Damiand
 * Laboratoire d'InfoRmatique en Image et Systèmes d'information - LIRIS (CNRS, UMR 5205), CNRS, France
 *
 * @date 2010/06/15
 *
 * @author Tristan Roussillon (\c tristan.roussillon@liris.cnrs.fr )
 * Laboratoire d'InfoRmatique en Image et Systèmes d'information - LIRIS (CNRS, UMR 5205), CNRS, France
 *
 * @date 2012/02/16
 *
 * Implementation of inline methods defined in ImageContainerBySTLVector.h
 *
 * This file is part of the DGtal library.
 */
 
///////////////////////////////////////////////////////////////////////////////
// IMPLEMENTATION of inline methods.
///////////////////////////////////////////////////////////////////////////////
 
//////////////////////////////////////////////////////////////////////////////
#include <cstdlib>
#include <DGtal/kernel/domains/Linearizer.h>
//////////////////////////////////////////////////////////////////////////////
 
//------------------------------------------------------------------------------
template <typename Domain, typename T>
inline
DGtal::ImageContainerBySTLVector<Domain, T>::
ImageContainerBySTLVector(const Domain &aDomain ) :
  myDomain(aDomain)
{
  myExtent =  (aDomain.upperBound() - aDomain.lowerBound()) + Point::diagonal(1);
  this->resize( myDomain.size() );
}
 
//------------------------------------------------------------------------------
template <typename Domain, typename T>
inline
DGtal::ImageContainerBySTLVector<Domain,T>
::ImageContainerBySTLVector(const ImageContainerBySTLVector& other)
  : std::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
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 DGtal::ImageContainerBySTLVector<Domain, T>::Range
DGtal::ImageContainerBySTLVector<Domain, T>::range()
{
  return Range ( this->begin(), this->end(), DistanceFunctorFromPoint<Self>(this) );
}
//------------------------------------------------------------------------------
template <typename Domain, typename T>
inline
const 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 true;
}
 
 
//------------------------------------------------------------------------------
template <typename D, typename V>
inline
std::string
DGtal::ImageContainerBySTLVector<D, V>::className() const
{
  return "ImageContainerBySTLVector";
}
 
 
///////////////////////////////////////////////////////////////////////////////
// Internals - private :
template<typename Domain, typename T>
inline
typename DGtal::ImageContainerBySTLVector<Domain, T>::Size
DGtal::ImageContainerBySTLVector<Domain, T>::linearized(const Point &aPoint) const
{
  return DGtal::Linearizer<Domain, ColMajorStorage>::getIndex( aPoint, myDomain.lowerBound(), myExtent );
}