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 "ifw/odp/clipm/clipm.h"
 
#include <cstdint>
 
// Local header files
#include "ifw/odp/cppcpl/error.hpp"
#include "ifw/odp/cppcpl/mask.hpp"
 
namespace ifw::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);

    explicit Image(uintptr_t image_handle);

    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