psf_model.h

Go to the documentation of this file.

/*
 * This work is licensed under a Creative Commons 
 * Attribution-Noncommercial-Share Alike 3.0 United States License.
 * 
 *    http://creativecommons.org/licenses/by-nc-sa/3.0/us/
 * 
 * You are free:
 * 
 *    to Share - to copy, distribute, display, and perform the work
 *    to Remix - to make derivative works
 * 
 * Under the following conditions:
 * 
 *    Attribution. You must attribute the work in the manner specified by the
 *    author or licensor (but not in any way that suggests that they endorse you
 *    or your use of the work).
 * 
 *    Noncommercial. You may not use this work for commercial purposes.
 * 
 *    Share Alike. If you alter, transform, or build upon this work, you may
 *    distribute the resulting work only under the same or similar license to
 *    this one.
 * 
 * For any reuse or distribution, you must make clear to others the license
 * terms of this work. The best way to do this is by including this header.
 * 
 * Any of the above conditions can be waived if you get permission from the
 * copyright holder.
 * 
 * Apart from the remix rights granted under this license, nothing in this
 * license impairs or restricts the author's moral rights.
 */


#ifndef PSF_MODEL_H
#define PSF_MODEL_H


#include <config.h>

#include <iostream>

#include <inttypes.h>

#include <jwsc/matblock/matblock.h>

#include <jwsc++/base/exception.h>

#include "density.h"
#include "printable.h"
#include "imaging_model.h"


class PSF_padding
{
    public:

        PSF_padding();


        virtual ~PSF_padding() { }


        uint32_t conv;

        uint32_t fft;
};


class PSF
{
    public:

        PSF(const PSF_padding* padding);


        virtual ~PSF();


        virtual PSF& operator= (const PSF& psf);


        const PSF_padding* get_padding() const { return padding; }


        const jwsc::Matblock_f* get_h() const { return h; }


        virtual void update_h(const Imaging_model* imaging) = 0;


        void write_h(const char* fname_fmt) const 
            throw (jwscxx::base::IO_error);


    protected:

        const PSF_padding* padding;

        jwsc::Matblock_f* h;
};


class PSF_model_density
{
    public:

        PSF_model_density() throw (jwscxx::base::Arg_error);


        virtual ~PSF_model_density() { }


        PSF_model_density* clone() const;


        const Density::Gaussian_params& get_alpha() const { return alpha; }


        const Density::Gaussian_params& get_beta() const { return beta; }


        const Density::Gaussian_params& get_gamma() const { return gamma; }


        void set_alpha(float mu, float sigma, float min, float max) 
            throw (jwscxx::base::Arg_error);


        void set_beta(float mu, float sigma, float min, float max) 
            throw (jwscxx::base::Arg_error);


        void set_gamma(float mu, float sigma, float min, float max) 
            throw (jwscxx::base::Arg_error);


        float sample_alpha() const;


        float sample_beta() const;


        float sample_gamma() const;


        class PSF_model* sample
        (
            const PSF_padding*   padding, 
            const Imaging_model* imaging
        ) 
        const;


    protected:

        Density::Gaussian_params  alpha;

        Density::Gaussian_params  beta;

        Density::Gaussian_params  gamma;
};


class PSF_model : public PSF, Printable
{
    public:

        PSF_model
        (
            float                    alpha,
            float                    beta,
            float                    gamma,
            const PSF_padding*       padding,
            const PSF_model_density* density,
            const Imaging_model*     imaging
        )
        throw (jwscxx::base::Arg_error);


        PSF_model(const PSF_model& model);


        PSF_model
        (
            const char*              fname, 
            const PSF_padding*       padding,
            const PSF_model_density* density,
            const Imaging_model*     imaging
        )
        throw (jwscxx::base::IO_error, jwscxx::base::Arg_error);


        virtual ~PSF_model() { }


        PSF_model& operator= (const PSF_model& psf);


        PSF_model* clone();


        float get_alpha() const { return alpha; }


        float get_beta() const { return beta; }


        float get_gamma() const { return gamma; }


        double get_log_prob() const { return log_prob; }


        const PSF_model_density* get_density() const { return density; }


        void set
        (
            float                alpha, 
            float                beta, 
            float                gamma, 
            const Imaging_model* imaging
        ) 
        throw (jwscxx::base::Arg_error);


        void set_alpha(float alpha, const Imaging_model* imaging) 
            throw (jwscxx::base::Arg_error);


        void set_beta(float beta, const Imaging_model* imaging) 
            throw (jwscxx::base::Arg_error);


        void set_gamma(float gamma, const Imaging_model* imaging) 
            throw (jwscxx::base::Arg_error);


        void print(std::ostream& out=std::cout) const;


        void print(const char* fname) const throw (jwscxx::base::IO_error);


        void update_h(const Imaging_model* imaging);


    protected:

        void update_log_prob();

        void check_alpha() const throw (jwscxx::base::Arg_error);

        void check_beta() const throw (jwscxx::base::Arg_error);


        void check_gamma() const throw (jwscxx::base::Arg_error);


    protected:

        float alpha;

        float beta;

        float gamma;

        double log_prob;

        const PSF_model_density* density;
};


class PSF_delta_model : public PSF
{
    public:

        PSF_delta_model
        (
            const PSF_padding*   padding, 
            const Imaging_model* imaging
        );


        virtual ~PSF_delta_model() { }


        void update_h(const Imaging_model* imaging);
};


class PSF_gauss_model : public PSF
{
    public:

        PSF_gauss_model
        (
            float                sigma, 
            const PSF_padding*   padding, 
            const Imaging_model* imaging
        )
        throw (jwscxx::base::Arg_error);


        virtual ~PSF_gauss_model() { }


        void update_h(const Imaging_model* imaging);


        PSF_gauss_model& operator= (const PSF_gauss_model& psf);


    protected:

        float sigma;
};


#endif