ImageFactoryFromImage.h

#pragma once

#if defined(ImageFactoryFromImage_RECURSES)
#error Recursive header files inclusion detected in ImageFactoryFromImage.h
#else // defined(ImageFactoryFromImage_RECURSES)

#define ImageFactoryFromImage_RECURSES

#if !defined ImageFactoryFromImage_h

#define ImageFactoryFromImage_h

// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/ConceptUtils.h"
#include "DGtal/images/CImage.h"
#include "DGtal/base/Alias.h"

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

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

  public:
    typedef ImageFactoryFromImage<TImageContainer> Self; 
    
    BOOST_CONCEPT_ASSERT(( concepts::CImage<TImageContainer> ));

    typedef TImageContainer ImageContainer;
    typedef typename ImageContainer::Domain Domain;
    
    typedef ImageContainer OutputImage;

    // ----------------------- Standard services ------------------------------

  public:

    ImageFactoryFromImage(Alias<ImageContainer> anImage):
      myImagePtr(&anImage)
    {
    }

    ~ImageFactoryFromImage() {}
    
  private:
    
    ImageFactoryFromImage( const ImageFactoryFromImage & other );
    
    ImageFactoryFromImage & operator=( const ImageFactoryFromImage & other );

    // ----------------------- Interface --------------------------------------
  public:

      
    const Domain & domain() const
    {
        return myImagePtr->domain();
    }


    

    void selfDisplay ( std::ostream & out ) const;

    bool isValid() const
    {
      return (myImagePtr->isValid());
    }

    OutputImage * requestImage(const Domain &aDomain)
    {
      OutputImage* outputImage = new OutputImage(aDomain);
      
      typename Domain::Iterator it = outputImage->domain().begin();
      typename Domain::Iterator it_end = outputImage->domain().end();
      for (; it != it_end; ++it)
      {
        outputImage->setValue(*it, (*myImagePtr)(*it));
      }
        
      return outputImage;
    }
    
    void flushImage(OutputImage* outputImage)
    {
      typename Domain::Iterator it = outputImage->domain().begin();
      typename Domain::Iterator it_end = outputImage->domain().end();
      for (; it != it_end; ++it)
      {
        myImagePtr->setValue(*it, (*outputImage)(*it));
      }
    }
    
    void detachImage(OutputImage* outputImage)
    {
      delete outputImage;
    }

    // ------------------------- Protected Datas ------------------------------
  private:
    //ImageFactoryFromImage() {}
    
    // ------------------------- Private Datas --------------------------------
  protected:

    ImageContainer * myImagePtr;

    // ------------------------- Internals ------------------------------------
  private:

  }; // end of class ImageFactoryFromImage


  template <typename TImageContainer>
  std::ostream&
  operator<< ( std::ostream & out, const ImageFactoryFromImage<TImageContainer> & object );

} // namespace DGtal


// Includes inline functions.
#include "DGtal/images/ImageFactoryFromImage.ih"

//                                                                           //

#endif // !defined ImageFactoryFromImage_h

#undef ImageFactoryFromImage_RECURSES
#endif // else defined(ImageFactoryFromImage_RECURSES)