alternaria_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 ALTERNARIA_MODEL_H
#define ALTERNARIA_MODEL_H


#include <config.h>

#include <cassert>
#include <iostream>
#include <list>
#include <vector>

#include <inttypes.h>

#include <jwsc/config.h>
#include <jwsc/matblock/matblock.h>

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

#include "density.h"
#include "printable.h"
#include "structure.h"
#include "spore.h"
#include "hypha.h"
#include "psf_model.h"
#include "imaging_model.h"


class Alternaria_density
{
    public:

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


        virtual ~Alternaria_density() { }


        float get_num_levels_p() const { return num_levels_p; }


        float get_spore_p() const { return spore_p; }


        float get_apical_hypha_p() const { return apical_hypha_p; }


        float get_lateral_hypha_1_p() const { return lateral_hypha_1_p; }


        float get_lateral_hypha_n_p() const { return lateral_hypha_n_p; }


        const Density::Uniform_params& get_c_1() const { return c_1; }


        void set_num_levels_p(float p) throw (jwscxx::base::Arg_error);


        void set_structure_p
        (
            float spore_p, 
            float apical_hypha_p, 
            float lateral_hypha_1_p,
            float lateral_hypha_n_p
        ) 
        throw (jwscxx::base::Arg_error);


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


        float sample_c_1() const;


        virtual class Alternaria* sample
        (
            size_t                       N,
            float                        centroid_x, 
            float                        centroid_y, 
            float                        centroid_z,
            float                        theta,
            float                        psi,
            size_t                       base_level,
            const Spore_density*         spore_d,
            const Apical_hypha_density*  apical_hypha_d,
            const Lateral_hypha_density* lateral_hypha_1_d,
            const Lateral_hypha_density* lateral_hypha_n_d
        ) 
        const throw (jwscxx::base::Arg_error);


    protected:

        void generate_structure
        (
            Alternaria* alternaria, 
            size_t      N, 
            float       centroid_x, 
            float       centroid_y, 
            float       centroid_z
        ) 
        const throw (jwscxx::base::Arg_error);


    protected:

        float num_levels_p;

        float spore_p;

        float apical_hypha_p;

        float lateral_hypha_1_p;

        float lateral_hypha_n_p;

        Density::Uniform_params  c_1;
};


class Alternaria : public Printable
{
    public:

        Alternaria
        (
            float                        c_1,
            float                        theta,
            float                        psi,
            size_t                       base_level,
            const Alternaria_density*    alt_d,
            const Spore_density*         spore_d,
            const Apical_hypha_density*  apical_hypha_d,
            const Lateral_hypha_density* lateral_hypha_1_d,
            const Lateral_hypha_density* lateral_hypha_n_d
        )
        throw (jwscxx::base::Arg_error);


        Alternaria(const Alternaria& alt);


        Alternaria
        (
            const char*                  fname,
            const Alternaria_density*    alt_d,
            const Spore_density*         spore_d,
            const Apical_hypha_density*  apical_hypha_d,
            const Lateral_hypha_density* lateral_hypha_1_d,
            const Lateral_hypha_density* lateral_hypha_n_d
        )
        throw (jwscxx::base::IO_error, jwscxx::base::Arg_error);


        virtual ~Alternaria();


        Alternaria* clone() const;


        virtual Alternaria& operator= (const Alternaria& alternaria);


        Structure* get_root() const { return root; }


        const float get_theta() const { return theta; }


        const float get_psi() const { return psi; }


        const size_t get_base_level() const { return base_level; }


        const Alternaria_density* get_alt_d() const { return alt_d; }


        const Spore_density* get_spore_d() const { return spore_d; }


        const Apical_hypha_density* get_apical_hypha_d() const 
        { return apical_hypha_d; }


        const Lateral_hypha_density* get_lateral_hypha_1_d() const 
        { return lateral_hypha_1_d; }


        const Lateral_hypha_density* get_lateral_hypha_n_d() const 
        { return lateral_hypha_n_d; }


        double get_log_prob() const;


        float get_c_1() const { return c_1; }


        void set_root(Structure* root) throw (jwscxx::base::Arg_error);


        void set_c_1(float c_1) throw (jwscxx::base::Arg_error);


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


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


        size_t get_num_levels() const { return level_structs.size(); }


        size_t get_num_structures() const;


        size_t get_num_apical_hypha() const;


        size_t get_num_lateral_hypha() const;


        size_t get_num_spores() const;


        size_t get_uniform_random_level() const 
            throw (jwscxx::base::Result_error);


        size_t get_geometric_random_level() const 
            throw (jwscxx::base::Result_error);


        Structure* get_random_structure(size_t level) const 
            throw (jwscxx::base::Arg_error, jwscxx::base::Result_error);


        Lateral_hypha* get_random_lateral_hypha(size_t level) const
            throw (jwscxx::base::Arg_error, jwscxx::base::Result_error);


        Apical_hypha* get_random_apical_hypha(size_t level) const
            throw (jwscxx::base::Arg_error, jwscxx::base::Result_error);


        Spore* get_random_spore(size_t level) const
            throw (jwscxx::base::Arg_error, jwscxx::base::Result_error);


        Structure* get_random_terminal(size_t level) const
            throw (jwscxx::base::Arg_error, jwscxx::base::Result_error);


        Apical_hypha* get_random_terminal_apical_hypha(size_t level) const
            throw (jwscxx::base::Arg_error, jwscxx::base::Result_error);


        Spore* get_random_terminal_spore(size_t level) const
            throw (jwscxx::base::Arg_error, jwscxx::base::Result_error);


        Lateral_hypha* get_random_terminal_lateral_hypha(size_t level) const
            throw (jwscxx::base::Arg_error, jwscxx::base::Result_error);


        void add_lateral_hypha(Lateral_hypha* h) 
            throw (jwscxx::base::Arg_error);


        void remove_lateral_hypha(Lateral_hypha* h)
            throw (jwscxx::base::Arg_error);


        void add_apical_hypha(Apical_hypha* h) throw (jwscxx::base::Arg_error);


        void remove_apical_hypha(Apical_hypha* h) 
            throw (jwscxx::base::Arg_error);


        void merge_2_apical_with_spore
        (
            Apical_hypha* hypha_1,
            const Spore*  rvals
        ) 
        throw (jwscxx::base::Arg_error);


        void split_apical_hypha_into_apical
        (
            Apical_hypha*       h,
            const Apical_hypha* rvals_1,
            const Apical_hypha* rvals_2
        ) 
        throw (jwscxx::base::Arg_error);


        void merge_apical_hypha_with_apical
        (
            Apical_hypha*       h, 
            const Apical_hypha* rvals
        ) 
        throw (jwscxx::base::Arg_error);


        void split_apical_hypha_into_lateral
        (
            Apical_hypha*        h,
            const Apical_hypha*  rvals_1,
            const Lateral_hypha* rvals_2
        ) 
        throw (jwscxx::base::Arg_error);


        void merge_apical_hypha_with_lateral
        (
            Apical_hypha*       h, 
            Lateral_hypha*      lat,
            const Apical_hypha* rvals
        ) 
        throw (jwscxx::base::Arg_error);


        void replace_apical_hypha_with_spore
        (
            Apical_hypha* hypha,
            Spore*        spore
        )
        throw (jwscxx::base::Arg_error);


        void split_spore_into_2_apical
        (
            Spore*              spore,
            const Apical_hypha* rvals_1,
            const Apical_hypha* rvals_2
        ) 
        throw (jwscxx::base::Arg_error);


        void add_spore(Spore* s) throw (jwscxx::base::Arg_error);


        void remove_spore(Spore* s) throw (jwscxx::base::Arg_error);


        void replace_spore_with_apical_hypha
        (
            Spore*        spore,
            Apical_hypha* hypha
        )
        throw (jwscxx::base::Arg_error);


        void split_spore_into_spore
        (
            Spore*       s,
            const Spore* rvals_1,
            const Spore* rvals_2
        ) 
        throw (jwscxx::base::Arg_error);


        void merge_spore_with_spore
        (
            Spore*       s, 
            const Spore* rvals
        ) 
        throw (jwscxx::base::Arg_error);


    protected:

        void read(std::istream& in) 
            throw (jwscxx::base::IO_error, jwscxx::base::Arg_error);

        void build_levels(Structure* s);

        void check_levels();

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

        void ensure_level_space(size_t level);

        void recursively_update_level(Structure* s, size_t old_level)
            throw (jwscxx::base::Arg_error);


    protected:

        Structure* root;

        float theta;

        float psi;

        size_t base_level;

        const Alternaria_density* alt_d;

        const Spore_density* spore_d;

        const Apical_hypha_density* apical_hypha_d;

        const Lateral_hypha_density* lateral_hypha_1_d;

        const Lateral_hypha_density* lateral_hypha_n_d;

        std::vector< std::vector<Structure*>* > level_structs;

        std::vector< std::vector<Apical_hypha*>* > level_apical_hypha;

        std::vector< std::vector<Lateral_hypha*>* > level_lateral_hypha;

        std::vector< std::vector<Spore*>* > level_spores;

        std::vector< std::vector<Structure*>* > level_terminals;

        double log_prob;

        float c_1;
};


#if defined ALTERNARIA_HAVE_FFTW3F
class Alternaria_model_density : public Alternaria_density
{
    public:

        virtual ~Alternaria_model_density() { }


        class Alternaria_model* sample
        (
            size_t                       N,
            float                        centroid_x, 
            float                        centroid_y, 
            float                        centroid_z,
            float                        theta,
            float                        psi,
            size_t                       base_level,
            const Spore_density*         spore_d,
            const Apical_hypha_density*  apical_hypha_d,
            const Lateral_hypha_density* lateral_hypha_1_d,
            const Lateral_hypha_density* lateral_hypha_n_d,
            const PSF_model*             psf,
            const Imaging_model*         imaging
        ) 
        const throw (jwscxx::base::Arg_error);
};
#endif


#if defined ALTERNARIA_HAVE_FFTW3F
class Alternaria_model : public Alternaria
{
    public:

        Alternaria_model
        (
            float                        c_1,
            float                        theta,
            float                        psi,
            size_t                       base_level,
            const Alternaria_density*    alt_d,
            const Spore_density*         spore_d,
            const Apical_hypha_density*  apical_hypha_d,
            const Lateral_hypha_density* lateral_hypha_1_d,
            const Lateral_hypha_density* lateral_hypha_n_d,
            const PSF_model*             psf,
            const Imaging_model*         imaging
        )
        throw (jwscxx::base::Arg_error);


        Alternaria_model(const Alternaria_model& model);


        Alternaria_model
        (
            const Alternaria&    alt,
            const PSF_model*     psf,
            const Imaging_model* imaging
        );


        Alternaria_model
        (
            const char*                  fname,
            const Alternaria_density*    alt_d,
            const Spore_density*         spore_d,
            const Apical_hypha_density*  apical_hypha_d,
            const Lateral_hypha_density* lateral_hypha_1_d,
            const Lateral_hypha_density* lateral_hypha_n_d,
            const PSF_model*             psf,
            const Imaging_model*         imaging
        )
        throw (jwscxx::base::IO_error, jwscxx::base::Arg_error);


        virtual ~Alternaria_model();


        Alternaria_model* clone() const;


        virtual Alternaria_model& operator= (const Alternaria_model&);


        double calc_log_likelihood
        (
            const PSF_model*        psf,
            const Imaging_model*    imaging,
            const jwsc::Matblock_f* data,
            float                   data_avg
        ) 
        const throw (jwscxx::base::Arg_error);


        bool update_scene(const PSF_model* psf, const Imaging_model* imaging);


        void write_scene(const char* fname_fmt, const PSF_model* psf)
            const throw (jwscxx::base::IO_error);


    protected:

        jwsc::Matblock_f* scene;

        jwsc::Matblock_cf* s_1;

        jwsc::Matblock_cf* s_2;

        jwsc::Matblock_f* s_3;

        jwsc::Matblock_cf* s_4;
};
#endif


#endif