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)