image.hpp

Go to the documentation of this file.

 
#ifndef ODP_IMAGE_HPP
#define ODP_IMAGE_HPP
 
#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif
 
// System header files
#include <iostream>
 
// CPL header files
#include "cpl_image.h"
#include "clipm.h"
 
// Local header files
#include "cppcpl/error.hpp"
#include "cppcpl/mask.hpp"
 
 
 
 
namespace odp {
 
 
  class Image : virtual public odp::Error
  {
  public:
   Image();
 
    explicit Image(const cpl_size size_x,
             const cpl_size size_y,
             const cpl_type type);
 
    explicit Image(const Image &image);
 
    explicit Image(const Mask &mask);
 
    explicit Image(const Image &image, cpl_type type);
 
    explicit Image(const Image &image,
                      const cpl_size llx,
                      const cpl_size lly,
                      const cpl_size urx,
                      const cpl_size ury);
 
    explicit Image(const Mask &mask,
             const cpl_size llx,
             const cpl_size lly,
             const cpl_size urx,
             const cpl_size ury);
 
    explicit Image(const Image *image,
             const cpl_size llx,
             const cpl_size lly,
             const cpl_size urx,
             const cpl_size ury);
 
    explicit Image(const Image *image,
             const cpl_size startx,
             const cpl_size starty,
             const cpl_size size_single_det_x,
             const cpl_size size_single_det_y,
             const cpl_size size_gap_x,
             const cpl_size size_gap_y);
 
    virtual ~Image();
 
    void                  GetImagePtr(void **data_ptr) const;
 
    cpl_size              GetTypeSize()               const;
 
    inline void*          GetImagePtr()               const;
 
    inline cpl_size       GetWidth()                  const;
 
    inline cpl_size       GetHeight()                 const;
 
    inline cpl_size       GetSize()                   const;
 
    inline bool           IsImage()                   const;
 
    inline bool           Status()                    const;
 
    inline cpl_type       GetCplType()                const;
 
    inline cpl_image      *GetCplImage()              const;
 
    void                  SetCplImage(cpl_image *image);
 
    void Copy(const Image&,
              const cpl_size pos_x,
              const cpl_size pos_y);
 
    void Save(const std::string filename,
              cpl_type type=CPL_TYPE_FLOAT);
 
    void Load(const std::string filename,
              const cpl_size plane=0,
              const cpl_size extension=0,
              cpl_type type=CPL_TYPE_UNSPECIFIED);
 
    void Load(const std::string filename,
              const cpl_size llx,
              const cpl_size lly,
              const cpl_size urx,
              const cpl_size ury,
              const cpl_size plane=0,
              const cpl_size extension=0,
              cpl_type type=CPL_TYPE_UNSPECIFIED);
 
 
    void Unload();
 
    // Routines to get the pixel value at given position
 
    double      Get(cpl_size xpos, cpl_size ypos) const;
 
    void  Get(cpl_size xpos, cpl_size ypos, double *value);
 
    void  Set(cpl_size xpos, cpl_size ypos, double value);
 
    // Routines to handle bad pixels
 
    void  SetBadPixelMap(const Mask &mask);
 
    cpl_size       CountBadPixelMap();
 
    // Basic interface functions to CPL
    void Exponential(const double base);
 
    void Logarithm  (const double base);
 
    void Power      (const double exponent);
 
    void Absolute   ();
 
    void Normalise  (cpl_norm norm=CPL_NORM_SCALE);
 
    void Turn       (int rotation=-1);
 
    void FFT        (Image *imaginary, unsigned mode=CPL_FFT_DEFAULT);
 
    void Threshold  (double lo_cut,
                             double hi_cut,
                             double assign_lo_cut,
                             double assign_hi_cut);
 
    void Rebin(cpl_size xstart,
                       cpl_size ystart,
                       cpl_size xstep,
                       cpl_size ystep,
                       Image& new_image);
 
    // Generation functions
    void         FillNoise(const double min_pix,
                           const double max_pix);
 
    void         FillGaussian(const double cen_x,
                              const double cen_y,
                              const double norm,
                              const double sigma_x,
                              const double sigma_y);
 
    // Object operators
    Image& operator+(const double);
 
    Image& operator+(const Image&);
 
    Image& operator-(const double);
 
    Image& operator-(const Image&);
 
    Image& operator/(const double);
 
    Image& operator/(const Image&);
 
    Image& operator*(const double);
 
    Image& operator*(const Image&);
 
    Image& operator+=(const double);
 
    Image& operator+=(const Image&);
 
    Image& operator-=(const double);
 
    Image& operator-=(const Image&);
 
    Image& operator/=(const double);
 
    Image& operator/=(const Image&);
 
    Image& operator*=(const double);
 
    Image& operator*=(const Image&);
 
 
    Image& operator=(const Image&);
 
    bool operator==(const Image&) const;
 
    bool operator!=(const Image&) const;
 
  protected:
    cpl_type    m_cpl_type;
    cpl_image*  m_cpl_image;
 
 
  };
}
 
#include "image.ipp"
 
#endif