hypha.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 HYPHA_H
#define HYPHA_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 <jwsc/vector/vector.h>
#include <jwsc/matrix/matrix.h>
#include <jwsc/matblock/matblock.h>

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

#include "density.h"
#include "structure.h"
#include "spore.h"


class Apical_hypha : public Apical_structure
{
    public:

        Apical_hypha
        (
            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_hypha_density* density
        ) 
        throw (jwscxx::base::Arg_error);


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


        Apical_hypha(const Apical_hypha& h);


        Apical_hypha
        (
            const class Spore&          s, 
            float                       width,
            const Apical_hypha_density* density
        )
        throw (jwscxx::base::Arg_error);


        Apical_hypha* clone() const;


        Apical_hypha& operator= (const Apical_hypha& h);


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


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


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


        Apical_hypha* merge_with_apical
        (
            class Spore**        spore_out,
            const class Spore*   rvals
        ) 
        throw (jwscxx::base::Arg_error);


        class Lateral_hypha* split_into_lateral
        (
            const Apical_hypha*        rvals_1,
            const class Lateral_hypha* rvals_2
        ) 
        throw (jwscxx::base::Arg_error);


        class Lateral_hypha* merge_with_lateral
        (
            class Lateral_hypha* lateral, 
            const Apical_hypha*  rvals
        ) 
        throw (jwscxx::base::Arg_error);


        void replace(class Spore* spore) throw (jwscxx::base::Arg_error);


        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;


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


        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);


        const char* get_type_str() const { return type_str(); }


        static const char* type_str() { return "Apical hypha"; }


    protected:

        void update_log_prob();


    protected:

        const class Apical_hypha_density* density;
}; 




class Apical_hypha_density : public Apical_structure_density
{
    public:

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


        Apical_hypha_density* clone() const;


        const Density::Gaussian_params& get_dwidth() const { return dwidth; }


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


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


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


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


        float sample_dwidth() const;


    protected:

        Density::Gaussian_params  dwidth;
};




class Printed_apical_hypha : public Printed_apical_structure
{
    public: 

        Printed_apical_hypha(const Apical_hypha_density* density);


        Printed_apical_hypha
        (
            std::istream& in, 
            const Apical_hypha_density* density
        ) 
        throw (jwscxx::base::IO_error, jwscxx::base::Arg_error);


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


        Apical_hypha* convert(Structure* parent) const 
            throw (jwscxx::base::Arg_error);


    protected:

        const Apical_hypha_density* density;
};




class Lateral_hypha : public Lateral_structure
{
    public:

        Lateral_hypha
        (
            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_hypha_density* density
        ) 
        throw (jwscxx::base::Arg_error);


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


        Lateral_hypha(const Lateral_hypha& h);


        Lateral_hypha* clone() const;


        Lateral_hypha& operator= (const Lateral_hypha& h);


        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;


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


        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);


        const char* get_type_str() const { return type_str(); }


        static const char* type_str() { return "Lateral hypha"; }


    protected:

        const class Lateral_hypha_density* density;
}; 




class Lateral_hypha_density : public Lateral_structure_density
{
    public:

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


        Lateral_hypha_density* clone() const;


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


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


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




class Printed_lateral_hypha : public Printed_lateral_structure
{
    public: 

        Printed_lateral_hypha
        (
            const Lateral_hypha_density* level_1_density,
            const Lateral_hypha_density* level_n_density
        );


        Printed_lateral_hypha
        (
            std::istream& in, 
            const Lateral_hypha_density* level_1_density,
            const Lateral_hypha_density* level_n_density
        ) 
        throw (jwscxx::base::IO_error, jwscxx::base::Arg_error);


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


        Lateral_hypha* convert(Structure* parent) const 
            throw (jwscxx::base::Arg_error);


    protected:

        const Lateral_hypha_density* level_1_density;

        const Lateral_hypha_density* level_n_density;
};


#endif