structure.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 STRUCTURE_H
#define STRUCTURE_H


#include <config.h>

#if defined ALTERNARIA_HAVE_OPENGL_FRAMEWORK
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#elif defined ALTERNARIA_HAVE_OPENGL
#include <GL/gl.h>
#include <GL/glu.h>
#endif

#include <list>
#include <vector>

#include <inttypes.h>

#include <jwsc/vector/vector.h>
#include <jwsc/matrix/matrix.h>
#include <jwsc/matblock/matblock.h>

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

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



class Apical_error : public jwscxx::base::Exception
{
    public:

        Apical_error(const char* msg, const char* file=0, uint32_t line=0) 
            : jwscxx::base::Exception(msg, file, line) { }
};




class Structure : public Printable
{
    public: 

        Structure
        (
            float length,
            float width,
            float base_theta,
            float base_psi,
            float theta,
            float psi,
            float opacity,
            size_t level,
            const class Structure_density* density
        )
        throw (jwscxx::base::Arg_error);


        Structure(const Structure& s);


        virtual ~Structure();


        virtual Structure* clone() const = 0;


        virtual Structure* recursively_clone() const = 0;


        virtual Structure& operator= (const Structure& s);


        uint32_t get_id() const { return id; }


        Structure* get_root();


        std::vector<Structure*>* get_descendants();


        class Apical_structure* get_apical() { return apical; }


        std::list<class Lateral_structure*>& get_laterals() { return laterals; }


        const jwsc::Vector_f* get_begin_pt() const { return begin_pt; }


        const jwsc::Vector_f* get_end_pt() const { return end_pt; }


        const jwsc::Vector_f* get_centroid() const { return centroid; }


        const jwsc::Vector_f* get_growth_dir() const { return growth_dir; }


        Structure* get_parent() const { return parent; }


        size_t get_level() const { return level; }


        float get_length() const { return length; }


        float get_width() const { return width; }


        float get_theta() const { return theta; }


        float get_base_theta() const { return base_theta; }


        float get_psi() const { return psi; }


        float get_base_psi() const { return base_psi; }


        float get_opacity() const { return opacity; }


        float get_log_prob() const { return log_prob; }


        float get_log_prob_descend() const { return log_prob+log_prob_descend; }


        virtual const char* get_type_str() const = 0;


        const class Structure_density* get_density() const 
        { return density; }


        void set_apical(class Apical_structure* s) 
        { apical = s; update_ancestry_log_prob(); }


        void add_lateral(class Lateral_structure* s) 
        { laterals.push_back(s); update_ancestry_log_prob(); }


        void remove_lateral(class Lateral_structure* s) 
            throw (jwscxx::base::Arg_error);


        void set_size(float length, float width) 
            throw (jwscxx::base::Arg_error);


        void set_length(float length) throw (jwscxx::base::Arg_error);


        void set_width(float width) throw (jwscxx::base::Arg_error);


        void set_theta(float theta) throw (jwscxx::base::Arg_error);


        void set_base_theta(float base_theta) throw (jwscxx::base::Arg_error);


        void set_psi(float psi) throw (jwscxx::base::Arg_error);


        void set_base_psi(float base_psi) throw (jwscxx::base::Arg_error);


        void set_orientation(float theta, float psi) 
            throw (jwscxx::base::Arg_error);


        void set_base_orientation(float base_theta, float base_psi) 
            throw (jwscxx::base::Arg_error);


        void set_opacity(float opacity) throw (jwscxx::base::Arg_error);


        virtual bool draw_in_matblock_f
        (
             jwsc::Matblock_f* M_blk, 
             float             x, 
             float             y,
             float             z,
             float             x_scale,
             float             y_scale,
             float             z_scale,
             bool              fill = true
        )
        const = 0;


        bool recursively_draw_in_matblock_f
        (
             jwsc::Matblock_f* M_blk, 
             float             x, 
             float             y,
             float             z,
             float             x_scale,
             float             y_scale,
             float             z_scale,
             bool              fill = true
        )
        const;


#if defined ALTERNARIA_HAVE_OPENGL_FRAMEWORK || defined ALTERNARIA_HAVE_OPENGL
        virtual void draw_in_opengl(GLUquadric* quad, float scale) const = 0;
#endif


#if defined ALTERNARIA_HAVE_OPENGL_FRAMEWORK || defined ALTERNARIA_HAVE_OPENGL
        void recursively_draw_in_opengl(GLUquadric* quad, float scale) const;
#endif


        Structure* get_terminal_apical();


        class Lateral_structure* get_random_lateral() 
            throw (jwscxx::base::Result_error);


        virtual float get_intersection
        (
            jwsc::Vector_f**      isect_out, 
            uint32_t              n,
            const jwsc::Vector_f* p1_in, 
            const jwsc::Vector_f* p2_in
        )
        throw (jwscxx::base::Arg_error) = 0;


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


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


        void recursively_check_structure() const;


    protected:

        void update_angles() throw (jwscxx::base::Arg_error);

        void update_R();

        void recursively_update_R();

        void update_growth_dir_from_R();

        void update_growth_dir_and_length_from_pts() 
            throw (jwscxx::base::Arg_error);

        void update_centroid() throw (jwscxx::base::Arg_error);

        void update_begin_pt();

        void update_end_pt();

        void update_apical() throw (jwscxx::base::Arg_error);

        void update_laterals() throw (jwscxx::base::Arg_error);

        virtual void update_log_prob();

        void update_ancestry_log_prob();

        void recursively_update_levels(int level_delta) 
            throw (jwscxx::base::Result_error);

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

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

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

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

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

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

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

        virtual void check_centroid() const throw (jwscxx::base::Arg_error) = 0;

        bool has_child_id(uint32_t id) const;


    protected:

        Structure* parent;

        class Apical_structure* apical;

        std::list<class Lateral_structure*> laterals;

        jwsc::Vector_f* begin_pt;

        jwsc::Vector_f* end_pt;

        jwsc::Vector_f* centroid;

        jwsc::Vector_f* growth_dir;

        jwsc::Matrix_f* R;

        const class Structure_density* density;

        double log_prob;

        double log_prob_descend;

        float length;

        float width;

        float theta;

        float base_theta;

        float psi;

        float base_psi;

        float opacity;

        uint32_t id;

        size_t level;


    private:

        static uint32_t generate_id();


    friend class Apical_structure;
    friend class Lateral_structure;
};




class Structure_density
{
    public: 

        virtual ~Structure_density() { }


        virtual Structure_density* clone() const = 0;


        const Density::Uniform_params& get_centroid_x() 
            const { return centroid_x; }


        const Density::Uniform_params& get_centroid_z() 
            const { return centroid_z; }


        const Density::Uniform_params& get_centroid_y() 
            const { return centroid_y; }


        const Density::Gaussian_params& get_length() const { return length; }


        const Density::Gaussian_params& get_width() const { return width; }


        const Density::Gaussian_params& get_theta() const { return theta; }


        const Density::Uniform_params& get_psi() const { return psi; }


        const Density::Gaussian_params& get_opacity() const { return opacity; }


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


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


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


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


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


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


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


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


        float sample_centroid_x() const;


        float sample_centroid_y() const;


        float sample_centroid_z() const;


        float sample_length() const;


        float sample_width() const;


        float sample_theta() const;


        float sample_psi() const;


        float sample_opacity() const;


        virtual Structure* sample
        (
            float base_theta, 
            float base_psi, 
            size_t level
        ) 
        const = 0;


        virtual Structure* sample
        (
            float centroid_x, 
            float centroid_y, 
            float centroid_z,
            float base_theta,
            float base_psi,
            size_t level
        ) 
        const throw (jwscxx::base::Arg_error) = 0;


        virtual Structure* sample
        (
            class Structure* parent,
            float base_theta,
            float base_psi
        ) 
        const throw (jwscxx::base::Arg_error) = 0;


    protected:

        Density::Uniform_params  centroid_x;

        Density::Uniform_params  centroid_y;

        Density::Uniform_params  centroid_z;

        Density::Gaussian_params  length;

        Density::Gaussian_params  width;

        Density::Gaussian_params  theta;

        Density::Uniform_params  psi;

        Density::Gaussian_params  opacity;
};






class Printed_structure
{
    public: 

        virtual ~Printed_structure() { }


        uint32_t get_id() const { return id; }


        size_t get_level() const { return level; }


        uint32_t get_parent() const { return parent; }


        virtual Structure* convert(Structure* parent) const 
            throw (jwscxx::base::Arg_error) = 0;


        virtual Structure* recursively_convert
        (
            Structure* parent,
            std::list<class Printed_apical_structure*>::const_iterator 
                            apical_begin, 
            std::list<class Printed_apical_structure*>::const_iterator 
                            apical_end, 
            std::list<class Printed_lateral_structure*>::const_iterator 
                            lateral_begin, 
            std::list<class Printed_lateral_structure*>::const_iterator 
                            lateral_end
        ) 
        const throw (jwscxx::base::Arg_error) = 0;


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


        static bool is_on_istream(std::istream& in, const char* type_str)
            throw (jwscxx::base::IO_error, jwscxx::base::Arg_error);


    protected:

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

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

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

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

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

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

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

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

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

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

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

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

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

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


    protected:

        uint32_t parent;

        uint32_t apical;

        std::list<uint32_t> laterals;

        float centroid_x;

        float centroid_y;

        float centroid_z;

        double log_prob;

        float length;

        float width;

        float theta;

        float base_theta;

        float psi;

        float base_psi;

        float opacity;

        uint32_t id;

        size_t level;
};


class Apical_structure : public Structure
{
    public: 

        Apical_structure
        (
            float centroid_x, 
            float centroid_y,
            float centroid_z,
            float length,
            float width,
            float base_theta,
            float base_psi,
            float theta,
            float psi,
            float opacity,
            size_t level,
            const class Apical_structure_density* density
        ) 
        throw (jwscxx::base::Arg_error);


        Apical_structure
        (
            Structure* parent,
            float      length,
            float      width,
            float      base_theta,
            float      base_psi,
            float      theta,
            float      psi,
            float      opacity,
            const class Apical_structure_density* density
        )
        throw (jwscxx::base::Arg_error, Apical_error);


        Apical_structure
        (
            Structure* parent,
            float      centroid_x,
            float      centroid_y,
            float      centroid_z,
            float      length,
            float      width,
            float      base_theta,
            float      base_psi,
            float      opacity,
            const class Apical_structure_density* density
        )
        throw (jwscxx::base::Arg_error, Apical_error);


        Apical_structure(const Apical_structure& s);


        virtual Apical_structure* clone() const = 0;


        virtual Apical_structure* recursively_clone() const;


        virtual Apical_structure& operator= (const Apical_structure& s);


        virtual ~Apical_structure() { }


        void set_position(float centroid_x, float centroid_y, float centroid_z) 
            throw (jwscxx::base::Arg_error);


        virtual Apical_structure* split_into_apical
        (
            const Apical_structure* rvals_1,
            const Apical_structure* rvals_2
        ) 
        throw (jwscxx::base::Arg_error);


        virtual Apical_structure* merge_with_apical
        (
            const Apical_structure* rvals
        ) 
        throw (jwscxx::base::Arg_error);


        virtual Lateral_structure* split_into_lateral
        (
            const Apical_structure*  rvals_1,
            const Lateral_structure* rvals_2
        ) 
        throw (jwscxx::base::Arg_error);


        virtual Lateral_structure* merge_with_lateral
        (
            Lateral_structure*      lateral,
            const Apical_structure* rvals
        ) 
        throw (jwscxx::base::Arg_error);


        virtual void replace(Apical_structure* s) 
            throw (jwscxx::base::Arg_error);


    protected:

        void update_from_parent_end_pt() throw (jwscxx::base::Arg_error);

        virtual void update_log_prob();

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


    protected:

        const class Apical_structure_density* density;


    friend class Structure;
    friend class Lateral_structure;
};




class Apical_structure_density : public Structure_density
{
    public:

        virtual ~Apical_structure_density() { }


        virtual Apical_structure* sample
        (
            float base_theta, 
            float base_psi,
            size_t level
        ) 
        const = 0;


        virtual Apical_structure* sample
        (
            float centroid_x, 
            float centroid_y, 
            float centroid_z,
            float base_theta,
            float base_psi,
            size_t level
        ) 
        const throw (jwscxx::base::Arg_error) = 0;


        virtual Apical_structure* sample
        (
            class Structure* parent,
            float base_theta,
            float base_psi
        ) 
        const throw (jwscxx::base::Arg_error) = 0;
};





class Printed_apical_structure : public Printed_structure
{
    public: 

        virtual ~Printed_apical_structure() { }


        virtual Apical_structure* convert(Structure* parent) const 
            throw (jwscxx::base::Arg_error) = 0;


        Apical_structure* recursively_convert
        (
            Structure* parent,
            std::list<class Printed_apical_structure*>::const_iterator 
                            apical_begin, 
            std::list<class Printed_apical_structure*>::const_iterator 
                            apical_end, 
            std::list<class Printed_lateral_structure*>::const_iterator 
                            lateral_begin, 
            std::list<class Printed_lateral_structure*>::const_iterator 
                            lateral_end
        ) 
        const throw (jwscxx::base::Arg_error);
};




class Lateral_structure : public Structure
{
    public: 

        Lateral_structure
        (
            float centroid_x, 
            float centroid_y,
            float centroid_z,
            float lat_dist,
            float length,
            float width,
            float base_theta,
            float base_psi,
            float theta,
            float psi,
            float opacity,
            size_t level,
            const class Lateral_structure_density* density
        ) 
        throw (jwscxx::base::Arg_error);


        Lateral_structure
        (
            Structure* parent,
            float      lat_dist,
            float      length,
            float      width,
            float      base_theta,
            float      base_psi,
            float      theta,
            float      psi,
            float      opacity,
            const class Lateral_structure_density* density
        )
        throw (jwscxx::base::Arg_error);


        Lateral_structure(const Lateral_structure& s);


        virtual Lateral_structure* clone() const = 0;


        virtual Lateral_structure* recursively_clone() const;


        virtual Lateral_structure& operator= (const Lateral_structure& s);


        virtual ~Lateral_structure() { }


        float get_lat_dist() const { return lat_dist; }


        void set_parent(Structure* parent, float lat_dist) 
            throw (jwscxx::base::Arg_error);


        void set_lat_dist(float lat_dist) throw (jwscxx::base::Arg_error);


        const class Lateral_structure_density* get_density() const 
        { return density; }


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


    protected:

        void update_from_parent_end_pt() throw (jwscxx::base::Arg_error);

        void update_log_prob();

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

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


    protected:

        const class Lateral_structure_density* density;

        float lat_dist;


    friend class Structure;
    friend class Apical_structure;
};




class Lateral_structure_density : public Structure_density
{
    public: 

        virtual ~Lateral_structure_density() { }


        virtual Lateral_structure_density* clone() const = 0;


        const Density::Gaussian_params& get_lat_dist() 
            const { return lat_dist; }


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


        float sample_lat_dist() const;


        virtual Lateral_structure* sample
        (
            float base_theta, 
            float base_psi,
            size_t level
        ) 
        const = 0;


        virtual Lateral_structure* sample
        (
            float centroid_x, 
            float centroid_y, 
            float centroid_z,
            float base_theta,
            float base_psi,
            size_t level
        ) 
        const throw (jwscxx::base::Arg_error) = 0;


        virtual Lateral_structure* sample
        (
            class Structure* parent,
            float base_theta,
            float base_psi
        ) 
        const throw (jwscxx::base::Arg_error) = 0;


    protected:

        Density::Gaussian_params  lat_dist;
};





class Printed_lateral_structure : public Printed_structure
{
    public: 

        virtual ~Printed_lateral_structure() { }


        virtual Lateral_structure* convert(Structure* parent) const 
            throw (jwscxx::base::Arg_error) = 0;


        Lateral_structure* recursively_convert
        (
            Structure* parent,
            std::list<class Printed_apical_structure*>::const_iterator 
                            apical_begin, 
            std::list<class Printed_apical_structure*>::const_iterator 
                            apical_end, 
            std::list<class Printed_lateral_structure*>::const_iterator 
                            lateral_begin, 
            std::list<class Printed_lateral_structure*>::const_iterator 
                            lateral_end
        ) 
        const throw (jwscxx::base::Arg_error);


    protected:

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

    protected:

        float lat_dist;
};


#endif