ImageContainerBySTLMap.h

 
#pragma once
 
#if defined(ImageContainerBySTLMap_RECURSES)
#error Recursive header files inclusion detected in ImageContainerBySTLMap.h
#else // defined(ImageContainerBySTLMap_RECURSES)
 
#define ImageContainerBySTLMap_RECURSES
 
#if !defined ImageContainerBySTLMap_h
 
#define ImageContainerBySTLMap_h
 
// Inclusions
#include <iostream>
#include <map>
 
#include "DGtal/base/Common.h"
#include "DGtal/base/BasicFunctors.h"
#include "DGtal/base/CowPtr.h"
#include "DGtal/base/Clone.h"
#include "DGtal/images/DefaultConstImageRange.h"
#include "DGtal/images/DefaultImageRange.h"
#include "DGtal/images/SetValueIterator.h"
#include "DGtal/base/CLabel.h"
#include "DGtal/kernel/domains/CDomain.h"
 
 
#ifdef _MSC_VER
#pragma warning(disable : 4290)
#endif
 
namespace DGtal
{
 
  // class ImageContainerBySTLMap
  template <typename TDomain, typename TValue>
  class ImageContainerBySTLMap:
    public std::map<typename TDomain::Point, TValue >
  {
 
  public:
 
    typedef ImageContainerBySTLMap<TDomain,TValue> Self;
    typedef std::map<typename TDomain::Point, TValue > Parent;
    typedef Parent Container;
 
    BOOST_CONCEPT_ASSERT(( concepts::CDomain<TDomain> ));
    typedef TDomain Domain;
    typedef typename Domain::Point Point;
    typedef typename Domain::Vector Vector;
    typedef typename Domain::Integer Integer;
    typedef typename Domain::Size Size;
    typedef typename Domain::Dimension Dimension;
    typedef Point Vertex;
 
    // Pointer to the (const) Domain given at construction.
    typedef CowPtr< const Domain >  DomainPtr;
 
    static const typename Domain::Dimension dimension;
 
    BOOST_CONCEPT_ASSERT(( concepts::CLabel<TValue> ));
    typedef TValue Value;
    typedef DefaultConstImageRange<Self> ConstRange;
    typedef DefaultImageRange<Self> Range;
 
    typedef SetValueIterator<Self> OutputIterator;
 
  private:
 
    DomainPtr myDomainPtr;
 
    Value myDefaultValue;
 
 
  public:
 
    ImageContainerBySTLMap( Clone<const Domain> aDomain, const Value& aValue = 0);
 
    ImageContainerBySTLMap(const ImageContainerBySTLMap& other);
 
    ImageContainerBySTLMap& operator=(const ImageContainerBySTLMap& other);
 
    ~ImageContainerBySTLMap();
 
 
 
    Value operator()(const Point & aPoint) const;
 
    void setValue(const Point &aPoint, const Value &aValue);
 
 
    const Domain &domain() const;
 
    ConstRange constRange() const;
 
    Range range();
 
    const Container & container() const { return static_cast<Parent>(*this); };
    Container & container() { return static_cast<Parent>(*this); };
 
    void selfDisplay ( std::ostream & out ) const;
 
 
    bool isValid() const;
 
    std::string className() const;
 
 
    typedef typename std::map<Point,Value>::iterator Iterator;
    typedef typename std::map<Point,Value>::const_iterator ConstIterator;
    typedef typename std::map<Point,Value>::reverse_iterator ReverseIterator;
    typedef typename std::map<Point,Value>::const_reverse_iterator ConstReverseIterator;
 
    OutputIterator outputIterator();
 
 
  };
 
  template <typename TDomain, typename TValue>
  inline
  std::ostream&
  operator<< ( std::ostream & out,
               const ImageContainerBySTLMap<TDomain,TValue> & object )
  {
    object.selfDisplay ( out );
    return out;
  }
 
 
} // namespace DGtal
 
 
// Includes inline functions
#include "DGtal/images/ImageContainerBySTLMap.ih"
//                                                                           //
 
#endif // !defined ImageContainerBySTLMap_h
 
#undef ImageContainerBySTLMap_RECURSES
#endif // else defined(ImageContainerBySTLMap_RECURSES)