recipe.hpp

Go to the documentation of this file.

#ifndef ODP_RECIPE_HPP
#define ODP_RECIPE_HPP


#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif

// System header files
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <algorithm>

// Local header files
#include <rad/logger.hpp>
#include "cppcpl/image.hpp"
#include "cppcpl/array.hpp"
#include "cppcpl/matrix.hpp"

namespace odp {


  typedef struct
  {
    double xpos;     // x position of the object
    double xposErr;  // x position error
    double ypos;     // y position of the object
    double yposErr;  // y position error
    double fwhmX;    // FWHM along the first axis
    double fwhmXErr; // FWHM error along the first axis
    double fwhmY;    // FWHM along the second axis
    double fwhmYErr; // FWHM error along the second axis
    double angle;    // the angle of the first axis with the horizontal in degrees
    double angleErr; // the angle error
    double peak;     // the peak value of the object
    double peakErr;  // the peak error
    double bckgrd;   // the background computed
    double bckgrdErr;// the background error
  } Iqe;

  struct CenterGauss
  {
    CenterGauss() {}
    std::string Center() {
      std::ostringstream strs;
      strs << center[0] << " " << center[1];
      return strs.str();
    }

    std::array<double, 2> center;
    std::array<double, 2> center_err;
    std::array<double, 2> fwhm;
    std::array<double, 2> fwhm_err;
    std::array<double, 2> sigma;
    std::array<double, 2> sigma_err;
    double intensity;     // Intensity at the center
  };

  typedef struct
  {
    double center_x;      // X slit center
    double center_y;      // Y slit center
    double angle;         // slit angle (tilt)
  } SlitPos;

  typedef struct
  {
    double length;
    double width;
  } Size;

  typedef struct
  {
    SlitPos position;
    Size size;
  } RectAperture;

  typedef struct
  {
    double center_x;
    double center_y;
    double radius;
    double r_sigma;
  } CircularAperture;

  class Recipe : virtual public odp::Error
  {
  public:
    Recipe();

    ~Recipe();

    // Recipes functions

    void GetCenterGauss(const odp::Image *image,
                        cpl_size llx,
                        cpl_size lly,
                        cpl_size urx,
                        cpl_size ury,
                        CenterGauss *cen_gauss,
                        const int robustness=0);

    void GetCenterMoment(const odp::Image *image,
                         cpl_size   llx,
                         cpl_size   lly,
                         cpl_size   urx,
                         cpl_size   ury,
                         bool wdw_enlarge,
                         double  gain,
                         CenterGauss *cenMoment);

    void GetMultiCenterGauss(const odp::Image *image,
                             const odp::Matrix *ref,
                             unsigned int   areasize,
                             odp::Matrix *center,
                             odp::Matrix *center_err,
                             odp::Matrix *sigma,
                             odp::Matrix *sigma_err,
                             odp::Matrix *fwhm,
                             odp::Matrix *fwhm_err,
                             odp::Matrix *intensities,
                             odp::Array  *err_codes,
                             const int robustness);

    void GetIqe(const odp::Image *image,
                const cpl_size startX,
                const cpl_size startY,
                const cpl_size endX,
                const cpl_size endY,
                Iqe *iqe) ;

    void GetSlitPos(const odp::Image *image,
                    const int max_width,
                    SlitPos *slit);
    
    void AlignPoints(const odp::Matrix *matrix1,
                     const odp::Matrix *matrix2,
                     unsigned int    mode,
                     odp::Matrix  *trans,
                     odp::Matrix  *shift,
                     odp::Matrix  *rot);
    
    void AlignCorrelate(const odp::Image *img1,
                        const odp::Image *img2,
                        const odp::Matrix *ref,
                        unsigned int   wsize,
                        double   maxd,
                        unsigned int   mode,
                        odp::Matrix *trans,
                        odp::Matrix *shift,
                        odp::Matrix *pixels,
                        odp::Matrix *locs,
                        odp::Matrix *uncer,
                        odp::Array  *err_codes);
    
    std::vector<double> GetRngPoisson2d(int llx,
                         int lly,
                         int urx,
                         int ury,
                         int homogenity,
                         int npairs);


    void GetRngPoisson2d(double llx,
                         double lly,
                         double urx,
                         double ury,
                         int homogenity,
                         int npairs,
                         void     **buffer_ptr,
                         cpl_type cpltype=CPL_TYPE_DOUBLE);

    void GetRectangularAperture(const odp::Image *image,
                                const cpl_size llx,
                                const cpl_size lly,
                                const cpl_size urx,
                                const cpl_size ury,
                                RectAperture *aperture,
                                odp::Matrix *stat);

    void GetCircularAperture(const odp::Image *image,
                             const cpl_size llx,
                             const cpl_size lly,
                             const cpl_size urx,
                             const cpl_size ury,
                             CircularAperture *aperture,
                             odp::Matrix *stat);

    void EstimateBackground(const odp::Image *img,
                            const cpl_size  llx,
                            const cpl_size  lly,
                            const cpl_size  urx,
                            const cpl_size  ury,
                            double      *sigma,
                            cpl_size       *nused,
                            double      *background);

    void EstimateFwhm(const odp::Image *img,
                      double       peak_pos1,
                      double       peak_pos2,
                      double       bckg_level,
                      double       *fwhm);
    
    void GetBarycentre(const odp::Image *img,
                       const cpl_size  llx,
                       const cpl_size  lly,
                       const cpl_size  urx,
                       const cpl_size  ury,
                       double       bckg_level,
                       double       cut_level,
                       double       centre[2],
                       double       *weight,
                       cpl_size        *nused);

    void DetectCircularApertures(const odp::Image *img,
                                 const cpl_size  llx,
                                 const cpl_size  lly,
                                 const cpl_size  urx,
                                 const cpl_size  ury,
                                 odp::Matrix *stat);

    
  private:
    static bool m_random_seed;

  };

}
#endif