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/topology/CVertexMap.h"

namespace DGtal
{
  // Template class Image
  template < typename TImageContainer >
  class Image
  {

    // ----------------------- Types ------------------------------

  public:

    BOOST_CONCEPT_ASSERT(( CImage<TImageContainer> ));
    BOOST_CONCEPT_ASSERT(( 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)