imaging_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 IMAGING_MODEL_H
#define IMAGING_MODEL_H


#include <config.h>

#include <iostream>

#include <inttypes.h>

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

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


class Imaging_window
{
    public:

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


        virtual ~Imaging_window() { }


        uint32_t get_col() const { return col; }


        uint32_t get_row() const { return row; }


        uint32_t get_img() const { return img; }


        uint32_t get_num_cols() const { return num_cols; }


        uint32_t get_num_rows() const { return num_rows; }


        uint32_t get_num_imgs() const { return num_imgs; }


        void set
        (
            uint32_t col, 
            uint32_t row, 
            uint32_t img, 
            uint32_t num_cols,
            uint32_t num_rows,
            uint32_t num_imgs
        )
        throw (jwscxx::base::Arg_error);


    protected:

        uint32_t col;

        uint32_t row;

        uint32_t img;

        uint32_t num_cols;

        uint32_t num_rows;

        uint32_t num_imgs;


    friend std::ostream& operator<<(std::ostream&, const Imaging_window&);


    friend std::istream& operator>>(std::istream&, Imaging_window&);
};


class Imaging_scale
{
    public:

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


        virtual ~Imaging_scale() { }


        float get_x() const { return x; }


        float get_y() const { return y; }


        float get_z() const { return z; }


        void set(float x, float y, float z) throw (jwscxx::base::Arg_error);


    protected:

        float x;

        float y;

        float z;


    friend std::ostream& operator<<(std::ostream&, const Imaging_scale&);


    friend std::istream& operator>>(std::istream&, Imaging_scale&);
};


class Imaging_model_density
{
    public:

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


        virtual ~Imaging_model_density() { }


        Imaging_model_density* clone() const;


        const Density::Gaussian_params& get_bg() const { return bg; }


        const Density::Uniform_params& get_c_2() const { return c_2; }


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


        void set_c_2(float min, float max) throw (jwscxx::base::Arg_error);


        float sample_bg() const;


        float sample_c_2() const;


        class Imaging_model* sample
        (
            const Imaging_window* window,
            const Imaging_scale*  scale
        )
        const;


    protected:

        Density::Gaussian_params  bg;

        Density::Uniform_params  c_2;
};


class Imaging_model : public Printable
{
    public:

        Imaging_model
        (
            float                        bg,
            float                        c_2,
            const Imaging_window*        window,
            const Imaging_scale*         scale,
            const Imaging_model_density* density
        )
        throw (jwscxx::base::Arg_error);


        Imaging_model(const Imaging_model& model);


        Imaging_model
        (
            const char* fname, 
            const Imaging_window*        window,
            const Imaging_scale*         scale,
            const Imaging_model_density* density
        )
        throw (jwscxx::base::IO_error, jwscxx::base::Arg_error);


        virtual ~Imaging_model() { }


        Imaging_model* clone();


        const Imaging_window* get_window() const { return window; }


        const Imaging_scale* get_scale() const { return scale; }


        float get_bg() const { return bg; }


        float get_c_2() const { return c_2; }


        double get_log_prob() const { return log_prob; }


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


        void set_bg(float bg) throw (jwscxx::base::Arg_error);


        void set_c_2(float c_2) throw (jwscxx::base::Arg_error);


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


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


    protected:

        void update_log_prob();

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

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


    protected:

        const Imaging_window* window;

        const Imaging_scale* scale;

        float bg;

        float c_2;

        double log_prob;

        const Imaging_model_density* density;
};


#endif