Image.h

 
#pragma once
 
#if defined(Image_RECURSES)
#error Recursive header files inclusion detected in Image.h
#else // defined(Image_RECURSES)
 
#define Image_RECURSES
 
#if !defined Image_h
 
#define Image_h
 
// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/ConceptUtils.h"
#include "DGtal/images/CImage.h"
#include "DGtal/kernel/domains/CDomain.h"
#include "DGtal/base/CowPtr.h"
#include "DGtal/graph/CVertexMap.h"
 
namespace DGtal
{
  // Template class Image
  template < typename TImageContainer >
  class Image
  {
 
    // ----------------------- Types ------------------------------
 
  public:
 
    BOOST_CONCEPT_ASSERT(( concepts::CImage<TImageContainer> ));
    BOOST_CONCEPT_ASSERT(( concepts::CVertexMap<TImageContainer> ));
 
    typedef TImageContainer ImageContainer;
    typedef typename TImageContainer::Domain Domain;
    typedef typename TImageContainer::Point Point;
    typedef typename TImageContainer::Value Value;
    typedef typename TImageContainer::ConstRange ConstRange;
    typedef typename TImageContainer::Range Range;
    typedef typename TImageContainer::OutputIterator OutputIterator;
 
    typedef CowPtr<TImageContainer> ImagePointer;
 
    // ----------------------- Standard services ------------------------------
 
  public:
 
    Image() {
#ifdef DEBUG_VERBOSE
trace.warning() << "Image Ctor default "<<std::endl;
#endif
 
    };
 
    Image(ImageContainer *anImageContainer):
      myImagePointer(anImageContainer)
    {
#ifdef DEBUG_VERBOSE
    trace.warning() << "Image Ctor fromPointer "<<std::endl;
#endif
    }
 
    Image(const CowPtr<ImageContainer> &anImageContainerCowPointer):
      myImagePointer(anImageContainerCowPointer)
    {
      #ifdef DEBUG_VERBOSE
trace.warning() << "Image Ctor fromCow  "<<std::endl;
#endif
    }
 
   Image(const ImageContainer &other):
      myImagePointer(new ImageContainer(other) )
      {
#ifdef DEBUG_VERBOSE
trace.warning() << "Image Ctor fromConstRef "<<std::endl;
#endif
      }
 
 
   Image(const Image &other):
      myImagePointer(other.myImagePointer )
      {
          #ifdef DEBUG_VERBOSE
trace.warning() << "Image copy Ctor  "<<std::endl;
#endif
      }
 
    Image & operator= ( const Image & other )
    {
      #ifdef DEBUG_VERBOSE
 trace.warning() << "Image assignment "<<std::endl;
#endif
      if (&other != this)
        {
          myImagePointer = other.myImagePointer;
        }
      return *this;
    }
 
 
    ~Image() {}
 
    // ----------------------- Interface --------------------------------------
  public:
 
 
    const Domain & domain() const
    {
      return myImagePointer->domain();
    }
 
    ConstRange constRange() const
    {
      return myImagePointer->constRange();
    }
 
    Range range()
    {
      return myImagePointer->range();
    }
 
 
 
    Value operator()(const Point & aPoint) const
    {
      return myImagePointer->operator()(aPoint);
    }
 
 
 
    void setValue(const Point &aPoint, const Value &aValue)
    {
      myImagePointer->setValue(aPoint,aValue);
    }
 
 
 
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const
    {
      return (myImagePointer->isValid() );
    }
 
 
    const ImagePointer getPointer() const
    {
      return myImagePointer;
    }
 
    // ------------------------- Protected Datas ------------------------------
  private:
    // ------------------------- Private Datas --------------------------------
  protected:
 
    ImagePointer myImagePointer;
 
 
  private:
 
 
    // ------------------------- Internals ------------------------------------
  private:
 
  }; // end of class Image
 
 
  template <typename T>
  std::ostream&
  operator<< ( std::ostream & out, const Image<T> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/images/Image.ih"
 
//                                                                           //
 
#endif // !defined Image_h
 
#undef Image_RECURSES
#endif // else defined(Image_RECURSES)