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)