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 Data ------------------------------
  private:
    //ImageFactoryFromImage() {}
 
    // ------------------------- Private Data --------------------------------
  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)