CanopyGenerator.h

Go to the documentation of this file.

 
#ifndef CANOPY_GENERATOR
#define CANOPY_GENERATOR
 
#include <random>
#include "Context.h"
 
class CanopyGenerator;
 
struct BaseCanopyParameters {
 
    BaseCanopyParameters();
 
    BaseCanopyParameters(const pugi::xml_node canopy_node);
 
    virtual ~BaseCanopyParameters() = default;
 
 
    void readParametersFromXML(const pugi::xml_node canopy_node);
 
    virtual void buildPlant(CanopyGenerator &canopy_generator, helios::vec3 origin) = 0;
 
    virtual void buildCanopy(CanopyGenerator &canopy_generator) = 0;
 
    helios::vec3 canopy_origin;
 
    float canopy_rotation;
};
 
struct HomogeneousCanopyParameters : BaseCanopyParameters {
 
    HomogeneousCanopyParameters();
 
    HomogeneousCanopyParameters(const pugi::xml_node canopy_node);
 
 
    void readParametersFromXML(const pugi::xml_node canopy_node);
 
    void buildPlant(CanopyGenerator &canopy_generator, helios::vec3 origin) override;
 
    void buildCanopy(CanopyGenerator &canopy_generator) override;
 
    helios::vec2 leaf_size;
 
    helios::int2 leaf_subdivisions;
 
    std::string leaf_texture_file;
 
    helios::RGBcolor leaf_color;
 
    std::string leaf_angle_distribution;
 
    float leaf_area_index;
 
    float canopy_height;
 
    helios::vec2 canopy_extent;
 
    std::vector<float> leaf_angle_PDF;
 
    std::string buffer;
};
 
struct SphericalCrownsCanopyParameters : BaseCanopyParameters {
 
    SphericalCrownsCanopyParameters();
 
    SphericalCrownsCanopyParameters(const pugi::xml_node canopy_node);
 
 
    void readParametersFromXML(const pugi::xml_node canopy_node);
 
    void buildPlant(CanopyGenerator &canopy_generator, helios::vec3 origin) override;
 
    void buildCanopy(CanopyGenerator &canopy_generator) override;
 
    helios::vec2 leaf_size;
 
    helios::int2 leaf_subdivisions;
 
    std::string leaf_texture_file;
 
    helios::RGBcolor leaf_color;
 
    std::string leaf_angle_distribution;
 
    float leaf_area_density;
 
    helios::vec3 crown_radius;
 
    std::string canopy_configuration;
 
    helios::vec2 plant_spacing;
 
    helios::int2 plant_count;
 
    std::vector<float> leaf_angle_PDF;
};
 
struct ConicalCrownsCanopyParameters : BaseCanopyParameters {
 
    ConicalCrownsCanopyParameters();
 
    ConicalCrownsCanopyParameters(const pugi::xml_node canopy_node);
 
 
    void readParametersFromXML(const pugi::xml_node canopy_node);
 
    void buildPlant(CanopyGenerator &canopy_generator, helios::vec3 origin) override;
 
    void buildCanopy(CanopyGenerator &canopy_generator) override;
 
    helios::vec2 leaf_size;
 
    helios::int2 leaf_subdivisions;
 
    std::string leaf_texture_file;
 
    helios::RGBcolor leaf_color;
 
    std::string leaf_angle_distribution;
 
    float leaf_area_density;
 
    float crown_radius;
 
    float crown_height;
 
    std::string canopy_configuration;
 
    helios::vec2 plant_spacing;
 
    helios::int2 plant_count;
 
    std::vector<float> leaf_angle_PDF;
};
 
struct BaseGrapeVineParameters : BaseCanopyParameters {
 
    BaseGrapeVineParameters();
 
    BaseGrapeVineParameters(const pugi::xml_node canopy_node);
 
    virtual ~BaseGrapeVineParameters() = default;
 
 
    void readParametersFromXML(const pugi::xml_node canopy_node);
 
    void buildPlant(CanopyGenerator &canopy_generator, helios::vec3 origin) override;
 
    void buildCanopy(CanopyGenerator &canopy_generator) override;
 
    float leaf_width;
    float leaf_width_spread;
 
    helios::int2 leaf_subdivisions;
 
    std::string leaf_texture_file;
 
    std::string wood_texture_file;
 
    int wood_subdivisions;
    int wood_subdivisions_spread;
 
    float dead_probability;
 
 
    float missing_plant_probability;
 
    float plant_spacing;
    float plant_spacing_spread;
 
    float row_spacing;
    float row_spacing_spread;
 
    float trunk_height;
    float trunk_height_spread;
 
    float trunk_radius;
    float trunk_radius_spread;
 
    float cordon_length;
    float cordon_length_spread;
 
    float cordon_height;
    float cordon_height_spread;
 
    float cordon_radius;
    float cordon_radius_spread;
 
    float shoot_length;
    float shoot_length_spread;
 
    float shoot_radius;
    float shoot_radius_spread;
 
    uint shoots_per_cordon;
    uint shoots_per_cordon_spread;
 
    float leaf_spacing_fraction;
    float leaf_spacing_fraction_spread;
 
    helios::int2 plant_count;
 
    float grape_radius;
    float grape_radius_spread;
 
    float cluster_radius;
    float cluster_radius_spread;
 
    float cluster_height_max;
    float cluster_height_max_spread;
 
    helios::RGBcolor grape_color;
 
    uint grape_subdivisions;
    uint grape_subdivisions_spread;
 
    std::vector<float> leaf_angle_PDF;
 
    float canopy_rotation_spread;
};
 
struct VSPGrapevineParameters : BaseGrapeVineParameters {
 
    VSPGrapevineParameters();
 
    VSPGrapevineParameters(const pugi::xml_node canopy_node);
 
 
    void readParametersFromXML(const pugi::xml_node canopy_node);
 
    void buildPlant(CanopyGenerator &canopy_generator, helios::vec3 origin) override;
 
    void buildCanopy(CanopyGenerator &canopy_generator) override;
};
 
struct SplitGrapevineParameters : BaseGrapeVineParameters {
 
    SplitGrapevineParameters();
 
    SplitGrapevineParameters(const pugi::xml_node canopy_node);
 
 
    void readParametersFromXML(const pugi::xml_node canopy_node);
 
    void buildPlant(CanopyGenerator &canopy_generator, helios::vec3 origin) override;
 
    void buildCanopy(CanopyGenerator &canopy_generator) override;
 
    float cordon_spacing;
    float cordon_spacing_spread;
 
    float shoot_angle_base;
    float shoot_angle_base_spread;
 
    float shoot_angle_tip;
    float shoot_angle_tip_spread;
};
 
struct UnilateralGrapevineParameters : BaseGrapeVineParameters {
 
    UnilateralGrapevineParameters();
 
    UnilateralGrapevineParameters(const pugi::xml_node canopy_node);
 
 
    void readParametersFromXML(const pugi::xml_node canopy_node);
 
    void buildPlant(CanopyGenerator &canopy_generator, helios::vec3 origin) override;
 
    void buildCanopy(CanopyGenerator &canopy_generator) override;
};
 
 
struct GobletGrapevineParameters : BaseGrapeVineParameters {
 
    GobletGrapevineParameters();
 
    GobletGrapevineParameters(const pugi::xml_node canopy_node);
 
 
    void readParametersFromXML(const pugi::xml_node canopy_node);
 
    void buildPlant(CanopyGenerator &canopy_generator, helios::vec3 origin) override;
 
    void buildCanopy(CanopyGenerator &canopy_generator) override;
};
 
struct WhiteSpruceCanopyParameters : BaseCanopyParameters {
 
    WhiteSpruceCanopyParameters();
 
    WhiteSpruceCanopyParameters(const pugi::xml_node canopy_node);
 
 
    void readParametersFromXML(const pugi::xml_node canopy_node);
 
    void buildPlant(CanopyGenerator &canopy_generator, helios::vec3 origin) override;
 
    void buildCanopy(CanopyGenerator &canopy_generator) override;
 
    float needle_width;
 
    float needle_length;
 
    helios::int2 needle_subdivisions;
 
    helios::RGBcolor needle_color;
 
    std::string wood_texture_file;
 
    int wood_subdivisions;
 
    float trunk_height;
 
    float trunk_radius;
 
    float base_height;
 
    float crown_radius;
 
    float shoot_radius;
 
    float level_spacing;
 
    int branches_per_level;
 
    float shoot_angle;
 
    std::string canopy_configuration;
 
    helios::vec2 plant_spacing;
 
    helios::int2 plant_count;
};
 
struct TomatoParameters : BaseCanopyParameters {
 
    TomatoParameters();
 
    TomatoParameters(const pugi::xml_node canopy_node);
 
 
    void readParametersFromXML(const pugi::xml_node canopy_node);
 
    void buildPlant(CanopyGenerator &canopy_generator, helios::vec3 origin) override;
 
    void buildCanopy(CanopyGenerator &canopy_generator) override;
 
    float leaf_length;
 
    helios::int2 leaf_subdivisions;
 
    std::string leaf_texture_file;
 
    helios::RGBcolor shoot_color;
 
    int shoot_subdivisions;
 
    float plant_spacing;
 
    float row_spacing;
 
    float plant_height;
 
    helios::int2 plant_count;
 
    float fruit_radius;
 
    helios::RGBcolor fruit_color;
 
    uint fruit_subdivisions;
};
 
struct StrawberryParameters : BaseCanopyParameters {
 
    StrawberryParameters();
 
    StrawberryParameters(const pugi::xml_node canopy_node);
 
 
    void readParametersFromXML(const pugi::xml_node canopy_node);
 
    void buildPlant(CanopyGenerator &canopy_generator, helios::vec3 origin) override;
 
    void buildCanopy(CanopyGenerator &canopy_generator) override;
 
    float leaf_length;
 
    helios::int2 leaf_subdivisions;
 
    std::string leaf_texture_file;
 
    helios::RGBcolor stem_color;
 
    int stem_subdivisions;
 
    int stems_per_plant;
 
    float stem_radius;
 
    float plant_spacing;
 
    float row_spacing;
 
    float plant_height;
 
    helios::int2 plant_count;
 
    float fruit_radius;
 
    std::string fruit_texture_file;
 
    uint fruit_subdivisions;
 
    float clusters_per_stem;
};
 
struct WalnutCanopyParameters : BaseCanopyParameters {
 
    WalnutCanopyParameters();
 
    WalnutCanopyParameters(const pugi::xml_node canopy_node);
 
 
    void readParametersFromXML(const pugi::xml_node canopy_node);
 
    void buildPlant(CanopyGenerator &canopy_generator, helios::vec3 origin) override;
 
    void buildCanopy(CanopyGenerator &canopy_generator) override;
 
    float leaf_length;
 
    helios::int2 leaf_subdivisions;
 
    std::string leaf_texture_file;
 
    std::string wood_texture_file;
 
    int wood_subdivisions;
 
    float trunk_radius;
 
    float trunk_height;
 
    helios::vec3 branch_length;
 
 
    float plant_spacing;
 
    float row_spacing;
 
    float fruit_radius;
 
    std::string fruit_texture_file;
 
    uint fruit_subdivisions;
 
    helios::int2 plant_count;
};
 
struct SorghumCanopyParameters : BaseCanopyParameters {
 
    SorghumCanopyParameters();
 
    SorghumCanopyParameters(const pugi::xml_node canopy_node);
 
 
    void readParametersFromXML(const pugi::xml_node canopy_node);
 
    void buildPlant(CanopyGenerator &canopy_generator, helios::vec3 origin) override;
 
    void buildCanopy(CanopyGenerator &canopy_generator) override;
 
    int sorghum_stage;
 
    // STAGE 1
 
    float s1_stem_length;
 
    float s1_stem_radius;
 
    float s1_stem_subdivisions;
 
    helios::vec2 s1_leaf_size1;
 
    helios::vec2 s1_leaf_size2;
 
    helios::vec2 s1_leaf_size3;
 
    float s1_leaf1_angle;
 
    float s1_leaf2_angle;
 
    float s1_leaf3_angle;
 
    helios::int2 s1_leaf_subdivisions;
 
    std::string s1_leaf_texture_file;
 
    // STAGE 2
 
    float s2_stem_length;
 
    float s2_stem_radius;
 
    float s2_stem_subdivisions;
 
    helios::vec2 s2_leaf_size1;
 
    helios::vec2 s2_leaf_size2;
 
    helios::vec2 s2_leaf_size3;
 
    helios::vec2 s2_leaf_size4;
 
    helios::vec2 s2_leaf_size5;
 
    float s2_leaf1_angle;
 
    float s2_leaf2_angle;
 
    float s2_leaf3_angle;
 
    float s2_leaf4_angle;
 
    float s2_leaf5_angle;
 
    helios::int2 s2_leaf_subdivisions;
 
    std::string s2_leaf_texture_file;
 
    // STAGE 3
 
    float s3_stem_length;
 
    float s3_stem_radius;
 
    float s3_stem_subdivisions;
 
    helios::vec2 s3_leaf_size;
 
    helios::int2 s3_leaf_subdivisions;
 
    int s3_number_of_leaves;
 
    float s3_mean_leaf_angle;
 
    std::string s3_leaf_texture_file;
 
    // STAGE 4
 
    float s4_stem_length;
 
    float s4_stem_radius;
 
    float s4_stem_subdivisions;
 
    helios::vec2 s4_panicle_size;
 
    int s4_panicle_subdivisions;
 
    std::string s4_seed_texture_file;
 
    helios::vec2 s4_leaf_size;
 
    helios::int2 s4_leaf_subdivisions;
 
    int s4_number_of_leaves;
 
    float s4_mean_leaf_angle;
 
    std::string s4_leaf_texture_file;
 
    // STAGE 5
 
    float s5_stem_length;
 
    float s5_stem_radius;
 
    float s5_stem_bend;
 
    int s5_stem_subdivisions;
 
    helios::vec2 s5_panicle_size;
 
    int s5_panicle_subdivisions;
 
    std::string s5_seed_texture_file;
 
    helios::vec2 s5_leaf_size;
 
    helios::int2 s5_leaf_subdivisions;
 
    int s5_number_of_leaves;
 
    float s5_mean_leaf_angle;
 
    std::string s5_leaf_texture_file;
 
    // CANOPY
    float plant_spacing;
 
    float row_spacing;
 
    helios::int2 plant_count;
};
 
struct BeanParameters : BaseCanopyParameters {
 
    BeanParameters();
 
    BeanParameters(const pugi::xml_node canopy_node);
 
 
    void readParametersFromXML(const pugi::xml_node canopy_node);
 
    void buildPlant(CanopyGenerator &canopy_generator, helios::vec3 origin) override;
 
    void buildCanopy(CanopyGenerator &canopy_generator) override;
 
    float leaf_length;
 
    helios::int2 leaf_subdivisions;
 
    std::string leaf_texture_file;
 
    helios::RGBcolor shoot_color;
 
    int shoot_subdivisions;
 
    float stem_radius;
 
    float stem_length;
 
    float leaflet_length;
 
    float plant_spacing;
 
    float row_spacing;
 
    helios::int2 plant_count;
 
    float germination_probability;
 
    float pod_length;
 
    helios::RGBcolor pod_color;
 
    uint pod_subdivisions;
};
 
class CanopyGenerator {
public:
 
    explicit CanopyGenerator(helios::Context *context);
 
    static int selfTest(int argc = 0, char **argv = nullptr);
 
    template<typename CanopyType, typename... Args>
    void storeCanopyParameters(Args &&...args);
 
    std::vector<std::shared_ptr<BaseCanopyParameters>> getCanopyParametersList();
 
 
    void loadXML(const char *filename, bool build = true);
 
    void buildCanopies();
 
 
    void buildCanopy(const HomogeneousCanopyParameters &params);
 
 
    void buildCanopy(const SphericalCrownsCanopyParameters &params);
 
 
    void buildCanopy(const ConicalCrownsCanopyParameters &params);
 
 
    void buildCanopy(const VSPGrapevineParameters &params);
 
 
    void buildCanopy(const SplitGrapevineParameters &params);
 
 
    void buildCanopy(const UnilateralGrapevineParameters &params);
 
 
    void buildCanopy(const GobletGrapevineParameters &params);
 
 
    void buildCanopy(const WhiteSpruceCanopyParameters &params);
 
 
    void buildCanopy(const TomatoParameters &params);
 
 
    void buildCanopy(const StrawberryParameters &params);
 
 
    void buildCanopy(const WalnutCanopyParameters &params);
 
 
    void buildCanopy(const SorghumCanopyParameters &params);
 
 
    void buildCanopy(const BeanParameters &params);
 
 
    void buildGround(const helios::vec3 &ground_origin, const helios::vec2 &ground_extent, const helios::int2 &texture_subtiles, const helios::int2 &texture_subpatches, const char *ground_texture_file);
 
 
    void buildGround(const helios::vec3 &ground_origin, const helios::vec2 &ground_extent, const helios::int2 &texture_subtiles, const helios::int2 &texture_subpatches, const char *ground_texture_file, float ground_rotation);
 
 
    std::vector<uint> getTrunkUUIDs(uint PlantID);
 
    std::vector<uint> getTrunkUUIDs();
 
 
    std::vector<uint> getBranchUUIDs(uint PlantID);
 
    std::vector<uint> getBranchUUIDs();
 
 
    std::vector<std::vector<uint>> getLeafUUIDs(uint PlantID);
 
    std::vector<uint> getLeafUUIDs();
 
 
    std::vector<std::vector<std::vector<uint>>> getFruitUUIDs(uint PlantID);
 
    std::vector<uint> getFruitUUIDs();
 
    std::vector<uint> getGroundUUIDs();
 
 
    std::vector<uint> getAllUUIDs(uint PlantID);
 
    uint getPlantCount();
 
 
    void seedRandomGenerator(uint seed);
 
    void disableMessages();
 
    void enableMessages();
 
    //---------- PLANT GEOMETRIES ------------ //
 
 
    void buildIndividualPlants(helios::vec3 position);
 
    void buildIndividualPlants();
 
 
    std::vector<std::vector<uint>> addGrapeCluster(helios::vec3 position, float grape_rad, float cluster_rad, helios::RGBcolor grape_color, uint grape_subdiv);
 
 
    uint grapevineVSP(const VSPGrapevineParameters &params, const helios::vec3 &origin);
 
 
    uint grapevineSplit(const SplitGrapevineParameters &params, const helios::vec3 &origin);
 
 
    uint grapevineUnilateral(const UnilateralGrapevineParameters &params, const helios::vec3 &origin);
 
 
    uint grapevineGoblet(const GobletGrapevineParameters &params, const helios::vec3 &origin);
 
 
    uint whitespruce(const WhiteSpruceCanopyParameters &params, const helios::vec3 &origin);
 
 
    uint tomato(const TomatoParameters &params, const helios::vec3 &origin);
 
 
    uint strawberry(const StrawberryParameters &params, const helios::vec3 &origin);
 
 
    uint walnut(const WalnutCanopyParameters &params, const helios::vec3 &origin);
 
 
    uint sorghum(const SorghumCanopyParameters &params, const helios::vec3 &origin);
 
 
    uint bean(const BeanParameters &params, const helios::vec3 &origin);
 
    void createElementLabels();
 
    void disableElementLabels();
 
private:
    helios::Context *context;
 
    std::vector<std::shared_ptr<BaseCanopyParameters>> canopy_parameters_list;
 
 
    std::vector<std::vector<uint>> UUID_trunk;
 
 
    std::vector<std::vector<uint>> UUID_branch;
 
 
    std::vector<std::vector<std::vector<uint>>> UUID_leaf;
 
 
    std::vector<std::vector<std::vector<std::vector<uint>>>> UUID_fruit;
 
    std::vector<uint> UUID_ground;
 
    std::vector<uint> leaf_prototype_global;
 
    float sampleLeafAngle(const std::vector<float> &leafAngleDist);
 
    float sampleLeafPDF(const char *distribution);
 
    std::minstd_rand0 generator;
 
    bool printmessages;
 
    bool enable_element_labels;
 
    void cleanDeletedUUIDs(std::vector<uint> &UUIDs);
 
    void cleanDeletedUUIDs(std::vector<std::vector<uint>> &UUIDs);
 
    void cleanDeletedUUIDs(std::vector<std::vector<std::vector<uint>>> &UUIDs);
};
 
 
float getVariation(float V, std::minstd_rand0 &generator, bool positive = false);
 
 
int getVariation(int V, std::minstd_rand0 &generator, bool positive = false);
 
 
uint getVariation(uint V, std::minstd_rand0 &generator);
 
 
helios::vec3 interpolateTube(const std::vector<helios::vec3> &P, float frac);
 
 
float interpolateTube(const std::vector<float> &P, float frac);
 
 
float evaluateCDFresid(float thetaL, std::vector<float> &ru_v, const void *a_distribution);
 
#endif // CANOPY_GENERATOR