spore.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 SPORE_H
#define SPORE_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 "dd_spore.h"
#include "hypha.h"


class Spore : public Apical_structure
{
    public:

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


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


        Spore
        (
            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 Spore_density* density
        )
        throw (jwscxx::base::Arg_error, Apical_error);


        Spore(const Spore& s);


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


        Spore* clone() const;


        Spore& operator= (const Spore& s);


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


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


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


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


        void replace(class Apical_hypha* hypha) throw (jwscxx::base::Arg_error);


        bool draw_in_matrix_f
        (
             jwsc::Matrix_f* M, 
             float           x, 
             float           y,
             float           z,
             float           x_scale,
             float           y_scale,
             float           z_scale,
             bool            fill = true
        ) 
        const;


        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 "Spore"; }


    protected:

        void draw_in_zeroed_matrix_f
        (
             jwsc::Matrix_f* M, 
             float           x, 
             float           y,
             float           z,
             float           x_scale,
             float           y_scale,
             float           z_scale,
             bool            fill = true
        ) 
        const;

        void update_log_prob();


    protected:

        const class Spore_density* density;
}; 




class Spore_density : public Apical_structure_density
{
    public:

        Spore_density(const class DD_spore_set* dd_spores=0) 
            throw (jwscxx::base::Arg_error);


        Spore_density* clone() const;


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


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


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


        const DD_spore_set* get_dd_spores() const { return dd_spores; }


    protected:

        const DD_spore_set* dd_spores;
};




class Printed_spore : public Printed_apical_structure
{
    public: 

        Printed_spore(const Spore_density* density);


        Printed_spore(std::istream& in, const Spore_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);


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


    protected:

        const Spore_density* density;
};


#endif