ProjectBuilder.h

Go to the documentation of this file.

 
#ifndef PROJECT_BUILDER
#define PROJECT_BUILDER
 
// #pragma once
 
#include <set>
 
#include "Context.h"
 
// Forward Declaration
class BLConductanceModel;
class EnergyBalanceModel;
class PlantArchitecture;
class RadiationModel;
class SolarPosition;
class Visualizer;
class CameraProperties;
class CanopyGenerator;
void BuildGeometry(const std::string &xml_input_file, PlantArchitecture *plant_architecture_ptr, helios::Context *context_ptr);
void InitializeRadiation(const std::string &xml_input_file, SolarPosition *solarposition_ptr, RadiationModel *radiation_ptr, helios::Context *context_ptr);
void InitializeEnergyBalance(const std::string &xml_input_file, BLConductanceModel *boundarylayerconductancemodel, EnergyBalanceModel *energybalancemodel, helios::Context *context_ptr);
void InitializeSimulation(const std::string &xml_input_file, helios::Context *context_ptr);
 
 
#ifdef ENABLE_BOUNDARYLAYERCONDUCTANCEMODEL
#include "BoundaryLayerConductanceModel.h"
#endif // BOUNDARYLAYERCONDUCTANCEMODEL
 
#ifdef ENABLE_ENERGYBALANCEMODEL
#include "EnergyBalanceModel.h"
#endif // ENERGYBALANCEMODEL
 
#if defined(ENABLE_BOUNDARYLAYERCONDUCTANCEMODEL) && defined(ENABLE_ENERGYBALANCEMODEL)
#include "InitializeEnergyBalance.h"
#endif // BOUNDARYLAYERCONDUCTANCEMODEL && ENERGYBALANCEMODEL
 
#ifdef ENABLE_PLANT_ARCHITECTURE
#include "BuildGeometry.h"
#include "PlantArchitecture.h"
#endif // PLANT_ARCHITECTURE
 
#ifdef ENABLE_CANOPY_GENERATOR
#include "CanopyGenerator.h"
#endif // CANOPY_GENERATOR
 
#ifdef ENABLE_RADIATION_MODEL
#include "InitializeRadiation.h"
#include "RadiationModel.h"
#endif // RADIATION_MODEL
 
#ifdef ENABLE_SOLARPOSITION
#include "SolarPosition.h"
#endif // SOLARPOSITION
 
#ifdef ENABLE_HELIOS_VISUALIZER
#include "Visualizer.h"
// Forward declarations to avoid pulling in heavy OpenGL/ImGui headers
struct ImVec2;
struct ImVec4;
struct ImGuiIO;
struct ImFont;
#endif // HELIOS_VISUALIZER
 
 
 
std::string vec_to_string(const helios::vec2 &v);
 
 
std::string vec_to_string(const helios::vec3 &v);
 
 
std::string vec_to_string(const helios::int2 &v);
 
 
[[nodiscard]] std::vector<helios::vec3> interpolate(const std::vector<int> &keypoints, const std::vector<helios::vec3> &positions, int num_points);
 
 
void toggle_button(const char *str_id, bool *v);
 
std::string file_dialog();
 
 
std::string save_as_file_dialog(std::vector<std::string> extensions);
 
 
[[nodiscard]] std::vector<std::string> get_xml_node_values(const std::string &xml_file, const std::string &label_name, const std::string &node_name);
 
union digitPtr {
    int *i;
    float *f;
};
 
struct obj {
    int idx;
    bool isCanopy;
};
 
struct taggedPtr {
    digitPtr ptr;
    bool isInt;
    bool *dirty;
};
 
 
[[nodiscard]] taggedPtr createTaggedPtr(int *ptr, bool *dirty);
 
 
[[nodiscard]] taggedPtr createTaggedPtr(float *ptr, bool *dirty);
 
 
[[nodiscard]] taggedPtr createTaggedPtr(int *ptr);
 
 
[[nodiscard]] taggedPtr createTaggedPtr(float *ptr);
 
union distUnion {
    std::normal_distribution<float> *normal;
    std::uniform_real_distribution<float> *uniform;
    std::weibull_distribution<float> *weibull;
};
 
struct distribution {
    distUnion dist;
    int flag;
    bool repeat;
};
 
struct bandGroup {
    std::vector<std::string> bands;
    bool grayscale;
    bool norm;
};
 
struct canopy {
    int idx;
    float age;
    float ground_clipping_height;
    std::string label;
    std::string library_name;
    std::string library_name_verbose;
    std::vector<uint> IDs;
    std::vector<helios::vec3> individual_plant_locations;
    helios::vec2 plant_spacing;
    helios::int2 plant_count;
    helios::vec3 origin;
    std::string data_group;
    bool is_dirty;
};
 
struct object {
    int index;
    std::string name;
    std::string file;
    std::string data_group;
    std::vector<uint> UUIDs;
    helios::vec3 position;
    helios::vec3 prev_position;
    helios::vec3 orientation;
    helios::vec3 prev_orientation;
    helios::vec3 scale;
    helios::vec3 prev_scale;
    helios::RGBcolor color;
    helios::RGBcolor prev_color;
    bool use_texture_file;
    bool is_dirty;
};
 
struct rig {
    std::string label;
    std::vector<distribution> position_noise;
    helios::RGBcolor color;
    helios::vec3 position;
    helios::vec3 lookat;
    std::set<std::string> camera_labels;
    std::set<std::string> light_labels;
    bool write_depth;
    bool write_norm_depth;
};
 
bool parse_distribution(const std::string &input_string, distribution &converted_distribution);
 
 
distribution createDistribution(const std::normal_distribution<float> &dist, bool randomize_repeat);
 
 
distribution createDistribution(const std::uniform_real_distribution<float> &dist, bool randomize_repeat);
 
 
distribution createDistribution(const std::weibull_distribution<float> &dist, bool randomize_repeat);
 
 
class ProjectBuilder {
private:
    pugi::xml_document xmldoc;
 
    std::string xml_input_file = "plugins/projectbuilder/inputs/inputs.xml";
 
    bool user_input;
 
    bool light_coord_type = false;
 
    bool is_dirty = false;
 
    bool built = false;
 
    float PAR_absorbed;
 
    float NIR_absorbed;
 
    float LW_absorbed;
 
    float turbidity;
 
    float diffuse_extinction_coeff = 0.1;
 
    bool enforce_periodic_boundary_x = true;
 
    bool enforce_periodic_boundary_y = true;
 
    uint sun_ID;
 
    std::vector<std::string> bandlabels;
 
    std::set<std::string> band_group_names;
 
    std::map<std::string, bandGroup> band_group_lookup;
 
    std::string current_band_group;
 
    std::set<std::string> bandlabels_set;
 
    std::set<std::string> bandlabels_set_emissivity;
 
    std::set<std::string> bandlabels_set_wavelength;
 
    std::map<std::string, int> direct_ray_count_dict;
 
    std::map<std::string, int> diffuse_ray_count_dict;
 
    std::map<std::string, int> scattering_depth_dict;
 
    std::string new_band_label;
 
    float wavelength_min = 400.0f;
 
    float wavelength_max = 700.0f;
 
    bool enable_wavelength;
 
    bool enable_emission;
 
    std::vector<uint> ground_UUIDs;
 
    uint ground_objID;
 
    std::vector<uint> leaf_UUIDs;
 
    std::vector<uint> petiolule_UUIDs;
 
    std::vector<uint> petiole_UUIDs;
 
    std::vector<uint> internode_UUIDs;
 
    std::vector<uint> peduncle_UUIDs;
 
    std::vector<uint> petal_UUIDs;
 
    std::vector<uint> flower_UUIDs;
 
    std::vector<uint> sepal_UUIDs;
 
    std::vector<uint> pedicel_UUIDs;
 
    std::vector<uint> fruit_UUIDs;
 
    std::vector<std::string> primitive_names = {"All", "ground", "leaf", "petiolule", "petiole", "internode", "peduncle", "petal", "pedicel", "fruit"};
 
    std::map<std::string, bool> bounding_boxes = {
            {"plantID", false}, {"leafID", false}, {"peduncleID", false}, {"closedflowerID", false}, {"openflowerID", false}, {"fruitID", false}, {"rank", false}, {"age", false}, {"carbohydrate_concentration", false}};
 
    std::map<std::string, int> bounding_boxes_map;
 
    std::set<std::string> primitive_names_set = {"All", "ground", "leaf", "petiolule", "petiole", "internode", "peduncle", "petal", "pedicel", "fruit"};
 
    std::map<std::string, std::vector<uint> *> primitive_addresses;
 
    std::map<std::string, std::vector<uint>> primitive_UUIDs;
 
    std::map<std::string, std::map<std::string, std::vector<uint>>> primitive_UUIDs_dict;
 
    std::map<std::string, std::vector<bool>> primitive_continuous;
 
    std::map<std::string, std::map<std::string, std::vector<bool>>> primitive_continuous_dict;
 
    std::map<std::string, std::vector<std::string>> primitive_spectra;
 
    std::map<std::string, std::map<std::string, std::vector<std::string>>> primitive_spectra_dict;
 
    std::map<std::string, std::map<std::string, std::vector<float>>> primitive_values;
 
    std::map<std::string, std::map<std::string, std::map<std::string, std::vector<float>>>> primitive_values_dict;
 
    std::set<std::string> data_groups_set = {"All"};
 
    float ground_area;
 
    std::vector<std::string> timeseries_variables;
 
    float air_temperature = 300.f;
 
    float air_humidity = 0.5f;
 
    helios::vec3 sun_dir_vec;
 
    float R_PAR_dir;
 
    float R_NIR_dir;
 
    float fdiff;
 
    std::string xml_error_string;
 
    std::vector<std::string> rig_labels;
 
    std::vector<std::vector<distribution>> rig_position_noise;
 
    std::vector<std::vector<distribution>> rig_lookat_noise;
 
    std::vector<helios::RGBcolor> rig_colors;
 
    std::vector<helios::vec3> camera_positions;
 
    std::vector<helios::vec3> camera_lookats;
 
    std::vector<std::string> camera_labels;
 
    std::vector<helios::int2> camera_resolutions;
 
    std::vector<float> focal_plane_distances;
 
    std::vector<float> lens_diameters;
 
    std::vector<float> FOV_aspect_ratios;
 
    std::vector<float> HFOVs;
 
    std::map<std::string, int> rig_dict;
 
    std::set<std::string> rig_labels_set;
 
    std::vector<bool> write_depth;
 
    std::vector<bool> write_norm_depth;
 
    helios::vec3 camera_position = {0, 0, 0};
 
    std::vector<std::vector<int>> keypoint_frames;
 
    std::vector<std::vector<helios::vec3>> camera_position_vec;
 
    std::vector<std::vector<helios::vec3>> camera_lookat_vec;
 
    helios::vec3 camera_lookat = {0, 0, 0};
 
    std::string camera_label = "RGB";
 
    int num_images = 5;
 
    std::vector<int> num_images_vec;
 
    std::vector<std::string> camera_names;
 
    std::set<std::string> camera_names_set;
 
    helios::int2 camera_resolution = {1024, 1024};
 
    float focal_plane_distance = 0.4;
 
    float lens_diameter = 0.02;
 
    float FOV_aspect_ratio = 1.4;
 
    float HFOV = 50.0;
 
    std::map<std::string, int> camera_dict;
 
    std::vector<std::set<std::string>> rig_camera_labels;
 
    std::vector<std::string> light_names;
 
    std::set<std::string> light_names_set;
 
    std::vector<std::string> light_types;
 
    // std::vector<std::string> all_light_types = {"collimated", "sphere", "sunsphere", "rectangle", "disk"};
    std::vector<std::string> all_light_types = {"sphere", "rectangle", "disk"};
 
    std::vector<helios::vec3> light_direction_vec;
 
    std::vector<helios::SphericalCoord> light_direction_sph_vec;
 
    std::vector<helios::vec3> light_rotation_vec;
 
    std::vector<helios::vec2> light_size_vec;
 
    std::vector<float> light_radius_vec;
 
    std::vector<float> light_flux_vec;
 
    std::map<std::string, int> light_dict;
 
    std::vector<std::set<std::string>> rig_light_labels;
 
    std::map<std::string, std::vector<std::vector<uint>>> arrow_dict;
 
    int arrow_count = 0;
 
    pugi::xml_node helios;
 
    bool enable_coordinate_axes = true;
 
    bool enable_colorbar = false;
 
    float latitude = 38.55;
 
    float longitude = 121.76;
 
    int UTC_offset = 8;
 
    std::string csv_weather_file = "plugins/projectbuilder/inputs/weather_data.csv";
 
    std::string cimis_weather_file;
 
    bool is_weather_file_csv = true;
 
    helios::vec3 domain_origin = {0, 0, 0};
 
    helios::vec2 domain_extent = {10, 10};
 
    helios::int2 ground_resolution = {1, 1};
 
    std::string ground_texture_file = "plugins/projectbuilder/inputs/dirt.jpg";
 
    int ground_flag = 1;
 
    bool use_ground_texture = true;
 
    float ground_color[3] = {0.0, 0.0, 0.0};
 
    std::string ground_model_file;
 
    std::vector<std::string> canopy_labels;
 
    std::set<std::string> canopy_labels_set;
 
    std::vector<std::string> canopy_data_groups;
 
    helios::vec3 canopy_origin = {0, 0, 0};
 
    std::vector<helios::vec3> canopy_origins;
 
    helios::int2 plant_count = {1, 1};
 
    std::vector<helios::int2> plant_counts;
 
    helios::vec2 plant_spacing = {0.5, 0.5};
 
    std::vector<helios::vec2> plant_spacings;
 
    std::vector<std::vector<helios::vec3>> individual_plant_locations;
 
    std::string plant_library_name = "cowpea";
 
    std::string plant_library_name_verbose = "Cowpea (Vigna unguiculata)";
 
    std::vector<std::string> plant_library_names;
 
    std::vector<std::string> plant_library_names_verbose;
 
    std::set<std::string> plant_types = {"almond", "apple",     "bindweed",     "butterlettuce", "cheeseweed", "bean",    "cowpea",    "easternredbud", "grapevine_VSP", "maize",
                                         "olive",  "pistachio", "puncturevine", "rice",          "sorghum",    "soybean", "sugarbeet", "tomato",        "walnut",        "wheat"};
 
    std::set<std::string> plant_types_verbose = {"Almond Tree (Prunus dulcis)",        "Apple Tree (Malus pumila)",
                                                 "Bindweed (Convolvulus arvensis)",    "Butter Lettuce (Lactuca sativa)",
                                                 "Cheeseweed (Malva neglecta)",        "Common Bean (Phaseolus vulgaris)",
                                                 "Cowpea (Vigna unguiculata)",         "Eastern Redbud (Cercis canadensis)",
                                                 "Grapevine (Vitis vinifera)",         "Maize (Zea mays)",
                                                 "Olive Tree (Olea europaea)",         "Pistachio Tree (Pistachia vera)",
                                                 "Puncturevine (Tribulus terrestris)", "Rice (Oryza sativa)",
                                                 "Sorghum (Sorghum bicolor)",          "Soybean (Glycine max)",
                                                 "Sugar Beet (Beta vulgaris)",         "Tomato (Solanum lycopersicum)",
                                                 "Walnut Tree (Juglans regia)",        "Wheat (Triticum aestivum)"};
 
    std::map<std::string, std::string> plant_type_lookup = {{"Almond Tree (Prunus dulcis)", "almond"},
                                                            {"Apple Tree (Malus pumila)", "apple"},
                                                            {"Bindweed (Convolvulus arvensis)", "bindweed"},
                                                            {"Butter Lettuce (Lactuca sativa)", "butterlettuce"},
                                                            {"Cheeseweed (Malva neglecta)", "cheeseweed"},
                                                            {"Common Bean (Phaseolus vulgaris)", "bean"},
                                                            {"Cowpea (Vigna unguiculata)", "cowpea"},
                                                            {"Eastern Redbud (Cercis canadensis)", "easternredbud"},
                                                            {"Grapevine (Vitis vinifera)", "grapevine_VSP"},
                                                            {"Maize (Zea mays)", "maize"},
                                                            {"Olive Tree (Olea europaea)", "olive"},
                                                            {"Pistachio Tree (Pistachia vera)", "pistachio"},
                                                            {"Puncturevine (Tribulus terrestris)", "puncturevine"},
                                                            {"Rice (Oryza sativa)", "rice"},
                                                            {"Sorghum (Sorghum bicolor)", "sorghum"},
                                                            {"Soybean (Glycine max)", "soybean"},
                                                            {"Sugar Beet (Beta vulgaris)", "sugarbeet"},
                                                            {"Tomato (Solanum lycopersicum)", "tomato"},
                                                            {"Walnut Tree (Juglans regia)", "walnut"},
                                                            {"Wheat (Triticum aestivum)", "wheat"}};
 
    std::map<std::string, std::string> plant_type_verbose_lookup = {{"almond", "Almond Tree (Prunus dulcis)"},
                                                                    {"apple", "Apple Tree (Malus pumila)"},
                                                                    {"bindweed", "Bindweed (Convolvulus arvensis)"},
                                                                    {"butterlettuce", "Butter Lettuce (Lactuca sativa)"},
                                                                    {"cheeseweed", "Cheeseweed (Malva neglecta)"},
                                                                    {"bean", "Common Bean (Phaseolus vulgaris)"},
                                                                    {"cowpea", "Cowpea (Vigna unguiculata)"},
                                                                    {"easternredbud", "Eastern Redbud (Cercis canadensis)"},
                                                                    {"grapevine_VSP", "Grapevine (Vitis vinifera)"},
                                                                    {"maize", "Maize (Zea mays)"},
                                                                    {"olive", "Olive Tree (Olea europaea)"},
                                                                    {"pistachio", "Pistachio Tree (Pistachia vera)"},
                                                                    {"puncturevine", "Puncturevine (Tribulus terrestris)"},
                                                                    {"rice", "Rice (Oryza sativa)"},
                                                                    {"sorghum", "Sorghum (Sorghum bicolor)"},
                                                                    {"soybean", "Soybean (Glycine max)"},
                                                                    {"sugarbeet", "Sugar Beet (Beta vulgaris)"},
                                                                    {"tomato", "Tomato (Solanum lycopersicum)"},
                                                                    {"walnut", "Walnut Tree (Juglans regia)"},
                                                                    {"wheat", "Wheat (Triticum aestivum)"}};
 
    float plant_age = 0;
 
    std::vector<float> plant_ages;
 
    float ground_clipping_height = 0;
 
    std::vector<float> ground_clipping_heights;
 
    std::map<std::string, int> canopy_labels_dict;
 
    std::vector<std::vector<uint>> canopy_IDs;
 
    int direct_ray_count = 100;
 
    int diffuse_ray_count = 1000;
 
    int scattering_depth = 2;
 
    float air_turbidity = 0.05;
 
    std::vector<std::string> obj_files;
 
    std::vector<std::vector<uint>> obj_UUIDs;
 
    std::vector<std::string> obj_names;
 
    std::set<std::string> obj_names_set;
 
    std::string current_obj;
 
    std::map<std::string, int> obj_names_dict;
 
    std::vector<helios::vec3> obj_positions;
 
    std::vector<helios::vec3> prev_obj_positions;
 
    std::vector<helios::vec3> obj_orientations;
 
    std::vector<helios::vec3> prev_obj_orientations;
 
    std::vector<std::string> obj_data_groups;
 
    std::vector<helios::vec3> prev_obj_scales;
 
    std::vector<helios::vec3> obj_scales;
 
    std::vector<helios::RGBcolor> obj_colors;
 
    std::set<std::string> xml_library_files = {"plugins/radiation/spectral_data/leaf_surface_spectral_library.xml", "plugins/radiation/spectral_data/soil_surface_spectral_library.xml"};
 
    std::set<std::string> possible_spectra;
 
    std::set<std::string> camera_xml_library_files = {"plugins/radiation/spectral_data/camera_spectral_library.xml"};
 
    std::vector<std::string> possible_camera_calibrations;
 
    std::vector<std::map<std::string, std::string>> camera_calibrations;
 
    std::string current_calibration_band;
 
    std::set<std::string> light_xml_library_files = {"plugins/radiation/spectral_data/light_spectral_library.xml"};
 
    std::vector<std::string> possible_light_spectra;
 
    std::vector<std::string> light_spectra;
 
    std::string solar_direct_spectrum = "solar_spectrum_direct_ASTMG173";
 
    float reflectivity = 0.0;
 
    float transmissivity = 0.0;
 
    float emissivity = 1.0;
 
    float leaf_reflectivity = 0.0;
 
    float leaf_transmissivity = 0.0;
 
    float leaf_emissivity = 0.0;
 
    float ground_reflectivity = 0.0;
 
    float ground_transmissivity = 0.0;
 
    float ground_emissivity = 1.0;
 
    float petiolule_reflectivity = 0.0;
 
    float petiolule_transmissivity = 0.0;
 
    float petiolule_emissivity = 0.0;
 
    float petiole_reflectivity = 0.0;
 
    float petiole_transmissivity = 0.0;
 
    float petiole_emissivity = 0.0;
 
    float internode_reflectivity = 0.0;
 
    float internode_transmissivity = 0.0;
 
    float internode_emissivity = 0.0;
 
    float peduncle_reflectivity = 0.0;
 
    float peduncle_transmissivity = 0.0;
 
    float peduncle_emissivity = 0.0;
 
    float petal_reflectivity = 0.0;
 
    float petal_transmissivity = 0.0;
 
    float petal_emissivity = 0.0;
 
    float pedicel_reflectivity = 0.0;
 
    float pedicel_transmissivity = 0.0;
 
    float pedicel_emissivity = 0.0;
 
    float fruit_reflectivity = 0.0;
 
    float fruit_transmissivity = 0.0;
 
    float fruit_emissivity = 0.0;
 
    std::string reflectivity_spectrum;
 
    std::string transmissivity_spectrum;
 
    std::string emissivity_spectrum;
 
    std::string leaf_reflectivity_spectrum = "grape_leaf_reflectivity_0000";
 
    std::string leaf_transmissivity_spectrum = "grape_leaf_transmissivity_0000";
 
    std::string leaf_emissivity_spectrum;
 
    std::string ground_reflectivity_spectrum = "soil_reflectivity_0000";
 
    std::string ground_transmissivity_spectrum;
 
    std::string ground_emissivity_spectrum;
 
    std::string petiolule_reflectivity_spectrum;
 
    std::string petiolule_transmissivity_spectrum;
 
    std::string petiolule_emissivity_spectrum;
 
    std::string petiole_reflectivity_spectrum;
 
    std::string petiole_transmissivity_spectrum;
 
    std::string petiole_emissivity_spectrum;
 
    std::string internode_reflectivity_spectrum;
 
    std::string internode_transmissivity_spectrum;
 
    std::string internode_emissivity_spectrum;
 
    std::string peduncle_reflectivity_spectrum;
 
    std::string peduncle_transmissivity_spectrum;
 
    std::string peduncle_emissivity_spectrum;
 
    std::string petal_reflectivity_spectrum;
 
    std::string petal_transmissivity_spectrum;
 
    std::string petal_emissivity_spectrum;
 
    std::string pedicel_reflectivity_spectrum;
 
    std::string pedicel_transmissivity_spectrum;
 
    std::string pedicel_emissivity_spectrum;
 
    std::string fruit_reflectivity_spectrum;
 
    std::string fruit_transmissivity_spectrum;
 
    std::string fruit_emissivity_spectrum;
 
    std::set<std::string> visualization_types_primitive = {"radiation_flux_PAR", "radiation_flux_NIR", "radiation_flux_LW"};
 
    std::set<std::string> visualization_types_object = {};
 
    std::map<std::string, helios::HeliosDataType> primitive_data_types;
 
    std::map<std::string, helios::HeliosDataType> object_data_types;
 
    std::string visualization_type = "RGB";
 
    std::string current_canopy;
 
    std::string current_rig;
 
    std::string current_cam;
 
    std::string current_light;
 
    std::string current_keypoint;
 
    std::string current_primitive = "All";
 
    std::string current_data_group = "All";
 
    std::string current_band = "red";
 
    std::string current_band_reflectivity = "red";
 
    std::string current_band_transmissivity = "red";
 
    std::string current_band_emissivity = "red";
 
    std::map<std::string, std::vector<uint>> camera_models_dict;
 
    void deleteArrows();
 
 
    void deleteCanopy(const std::string &canopy);
 
 
    void deleteObject(const std::string &obj);
 
 
    void updateCanopy(const std::string &canopy);
 
    void addCanopy();
 
    void updateArrows();
 
    void updateCameraModels();
 
    void deleteCameraModels();
 
    void updateDataGroups();
 
    void updatePrimitiveTypes();
 
    helios::int2 dragging_start_position{0, 0};
 
    std::string currently_dragging;
 
    std::string currently_dragging_type;
 
    bool disable_dragging = false;
 
    void canopyTab(std::string curr_canopy_name, int id);
 
    void rigTab(std::string curr_rig_name, int id);
 
    void objectTab(std::string curr_obj_name, int id);
 
    void saveObject(std::string file_name, std::vector<uint> obj_UUID_vec, std::string file_extension);
 
    void saveCanopy(std::string file_name, std::vector<uint> canopy_ID_vec, helios::vec3 position, std::string file_extension) const;
 
    void saveCanopy(std::string file_name_base, std::vector<uint> canopy_ID_vec, std::vector<helios::vec3> positions, std::string file_extension) const;
 
    bool save_plants_individually = false;
 
    void addBand(std::string label, float wavelength_min, float wavelength_max, bool enable_emission);
 
    void addBand(std::string label, bool enable_emission);
 
    std::map<std::string, std::string> distribution_types;
 
    std::map<std::string, std::vector<float>> distribution_params;
 
    std::map<std::string, int> distribution_dict;
 
    std::map<std::string, taggedPtr> randomized_variable_lookup;
 
    std::default_random_engine generator;
 
    std::string current_distribution = "Normal (Gaussian)";
 
    std::string current_axis = "X";
 
    std::set<std::string> possible_axes = {"X", "Y", "Z"};
 
    std::vector<std::string> distribution_names = {"N/A", "Normal (Gaussian)", "Uniform", "Weibull"};
 
    std::vector<distribution> distributions;
 
    std::vector<float> curr_distribution_params = {0.0, 0.0};
 
    bool randomize_repeatedly = false;
 
    std::streambuf *old_cout_stream_buf = std::cout.rdbuf();
 
    std::stringstream captured_cout;
 
    std::size_t last_console_size = 0;
 
    int num_recordings = 1;
 
    std::map<std::string, object> objects_dict;
 
    std::map<std::string, canopy> canopy_dict;
 
    int obj_idx = 0;
 
    int canopy_idx = 0;
 
    std::set<int> dirty_objects = {};
 
    std::set<int> dirty_canopies = {};
 
    std::set<std::string> lighting_models = {"None", "Phong", "Phong Shadowed"};
 
    std::string lighting_model = "None";
 
    helios::vec3 light_direction{0, 0, 1};
 
    float light_intensity = 1.0;
 
    helios::int2 num_tiles{5, 5};
 
public:
    helios::Context *context = nullptr;
 
    Visualizer *visualizer = nullptr;
 
    PlantArchitecture *plantarchitecture = nullptr;
 
    CanopyGenerator *canopygenerator = nullptr;
 
    RadiationModel *radiation = nullptr;
 
    SolarPosition *solarposition = nullptr;
 
    EnergyBalanceModel *energybalancemodel = nullptr;
 
    BLConductanceModel *boundarylayerconductance = nullptr;
 
    CameraProperties *cameraproperties = nullptr;
 
    static int selfTest(int argc = 0, char **argv = nullptr);
 
    void updateSpectra();
 
    void updateCameras();
 
    void record();
 
    void buildFromXML();
 
 
    void buildFromXML(std::string xml_input_file);
 
    void visualize();
 
    void buildAndVisualize();
 
 
    void buildAndVisualize(std::string xml_input_file);
 
    void xmlSetValues();
 
 
    void xmlSetValues(std::string xml_path);
 
    void xmlGetValues();
 
 
    void xmlGetValues(std::string xml_input_file);
 
 
    std::map<std::string, int> getNodeLabels(const std::string &label_name, const std::string &node_name, std::vector<std::string> &labels_vec);
 
 
    void getKeypoints(const std::string &name, const std::string &field, std::vector<std::vector<int>> &keypoints);
 
 
    void setKeypoints(const std::string &name, const std::string &field, std::vector<std::vector<int>> &keypoints);
 
 
    void xmlGetValue(const std::string &name, const std::string &parent, int &default_value);
 
 
    void xmlGetValue(const std::string &name, const std::string &parent, float &default_value);
 
 
    void xmlGetValue(const std::string &name, const std::string &parent, std::string &default_value);
 
 
    void xmlGetValue(const std::string &name, const std::string &parent, helios::vec2 &default_value);
 
 
    void xmlGetValue(const std::string &name, const std::string &parent, helios::vec3 &default_value);
 
 
    void xmlGetValue(const std::string &name, const std::string &parent, helios::int2 &default_value);
 
 
    void xmlGetDistribution(const std::string &name, const std::string &parent, distribution &distribution);
 
 
    void xmlSetDistribution(const std::string &name, const std::string &parent, distribution &distribution);
 
 
    void xmlGetValues(const std::string &name, const std::string &parent, std::vector<helios::vec2> &default_vec);
 
 
    void xmlGetValues(const std::string &name, const std::string &parent, std::vector<helios::vec3> &default_vec);
 
 
    void xmlGetValues(const std::string &name, const std::string &parent, std::vector<helios::int2> &default_vec);
 
 
    void xmlGetValues(const std::string &name, const std::string &parent, std::vector<std::string> &default_vec);
 
 
    void xmlGetValues(const std::string &name, const std::string &parent, std::vector<float> &default_vec);
 
 
    void xmlGetValues(const std::string &name, const std::string &parent, std::vector<int> &default_vec);
 
 
    void xmlGetValues(const std::string &name, const std::string &parent, std::vector<helios::RGBcolor> &default_vec);
 
 
    void xmlGetValues(const std::string &name, const std::string &parent, std::vector<std::vector<helios::vec3>> &default_vec);
 
 
    void xmlGetValues(const std::string &name, const std::string &parent, std::vector<std::set<std::string>> &default_vec);
 
 
    void xmlGetValues(const std::string &name, const std::string &parent, std::set<std::string> &default_set);
 
 
    void xmlRemoveField(const std::string &name, const std::string &parent);
 
 
    void xmlSetValue(const std::string &name, const std::string &parent, int &default_value);
 
 
    void xmlSetValue(const std::string &name, const std::string &parent, float &default_value);
 
 
    void xmlSetValue(const std::string &name, const std::string &parent, std::string &default_value);
 
 
    void xmlSetValue(const std::string &name, const std::string &parent, helios::vec2 &default_value);
 
 
    void xmlSetValue(const std::string &name, const std::string &parent, helios::vec3 &default_value);
 
 
    void xmlSetValue(const std::string &name, const std::string &parent, helios::int2 &default_value);
 
 
    void xmlSetValues(const std::string &field_name, const std::string &node_name, std::vector<helios::vec2> &values_vec, std::map<std::string, int> &node_map);
 
 
    void xmlSetValues(const std::string &field_name, const std::string &node_name, std::vector<helios::vec3> &values_vec, std::map<std::string, int> &node_map);
 
 
    void xmlSetValues(const std::string &field_name, const std::string &node_name, std::vector<helios::int2> &values_vec, std::map<std::string, int> &node_map);
 
 
    void xmlSetValues(const std::string &field_name, const std::string &node_name, std::vector<std::string> &values_vec, std::map<std::string, int> &node_map);
 
 
    void xmlSetValues(const std::string &field_name, const std::string &node_name, std::vector<int> &values_vec, std::map<std::string, int> &node_map);
 
 
    void xmlSetValues(const std::string &field_name, const std::string &node_name, std::vector<float> &values_vec, std::map<std::string, int> &node_map);
 
 
    void xmlSetValues(const std::string &field_name, const std::string &node_name, std::vector<helios::RGBcolor> &values_vec, std::map<std::string, int> &node_map);
 
 
    void xmlSetValues(const std::string &field_name, const std::string &node_name, std::vector<std::vector<helios::vec3>> &values_vec, std::map<std::string, int> &node_map);
 
 
    void xmlSetValues(const std::string &field_name, const std::string &node_name, std::vector<std::set<std::string>> &values_vec, std::map<std::string, int> &node_map);
 
 
    void xmlSetValues(const std::string &field_name, const std::string &node_name, std::set<std::string> &values_set);
 
 
    void setNodeLabels(const std::string &label_name, const std::string &node_name, std::set<std::string> &labels_set);
 
#ifdef ENABLE_HELIOS_VISUALIZER
 
    void randomizePopup(std::string popup_name, taggedPtr ptr);
 
 
    void noisePopup(std::string popup_name, std::vector<distribution> &dist_vec);
#else
    void randomizePopup(std::string popup_name, taggedPtr ptr);
    void noisePopup(std::string popup_name, std::vector<distribution> &dist_vec);
#endif // ENABLE_HELIOS_VISUALIZER
 
 
    void applyDistribution(std::string var_name, taggedPtr ptr);
 
 
    void applyDistribution(std::string var_name, distribution dist, taggedPtr ptr);
 
 
    void randomize(bool randomize_all);
 
#ifdef ENABLE_HELIOS_VISUALIZER
 
    void randomizerParams(std::string var_name);
#else
    void randomizerParams(std::string var_name);
#endif // ENABLE_HELIOS_VISUALIZER
 
 
    void sample(std::string var_name);
 
    void sampleAll();
 
#ifdef ENABLE_HELIOS_VISUALIZER
    void outputConsole();
#else
    void outputConsole();
#endif // ENABLE_HELIOS_VISUALIZER
 
 
    void updateColor(std::string curr_obj, std::string obj_type, float *new_color);
 
 
    void updateObject(std::string curr_obj);
 
    void updateRigs();
 
 
    void deleteRig(std::string curr_rig);
 
#ifdef ENABLE_HELIOS_VISUALIZER
 
    void dropDown(std::string widget_name, std::string &selected, std::vector<std::string> choices);
 
 
    void dropDown(std::string widget_name, std::string &selected, std::set<std::string> choices);
#else
    void dropDown(std::string widget_name, std::string &selected, std::vector<std::string> choices);
    void dropDown(std::string widget_name, std::string &selected, std::set<std::string> choices);
#endif // ENABLE_HELIOS_VISUALIZER
 
#ifdef ENABLE_HELIOS_VISUALIZER
    void refreshVisualization();
 
    void refreshVisualizationTypes();
#else
    void refreshVisualization();
    void refreshVisualizationTypes();
#endif // ENABLE_HELIOS_VISUALIZER
 
#ifdef ENABLE_HELIOS_VISUALIZER
    void recordPopup();
#else
    void recordPopup();
#endif // ENABLE_HELIOS_VISUALIZER
 
    void updateLocation();
 
    void updateGround();
 
    void deleteGround();
 
    void updateContext();
 
 
    std::string shortenPath(std::string path_name);
 
    void setBoundingBoxObjects();
 
 
    void buildTiledGround(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);
 
 
    void buildTiledGround(const helios::vec3 &ground_origin, const helios::vec2 &ground_extent, const helios::int2 &texture_subtiles, const helios::int2 &texture_subpatches, helios::RGBcolor ground_color, float ground_rotation);
 
    ProjectBuilder() {
        std::cout.rdbuf(captured_cout.rdbuf());
        primitive_UUIDs = {{"ground", ground_UUIDs},     {"leaf", leaf_UUIDs},   {"petiolule", petiolule_UUIDs}, {"petiole", petiole_UUIDs}, {"internode", internode_UUIDs},
                           {"peduncle", peduncle_UUIDs}, {"petal", petal_UUIDs}, {"pedicel", pedicel_UUIDs},     {"fruit", fruit_UUIDs}};
        primitive_continuous = {{"All", {false, false, false}},       {"ground", {false, false, false}},   {"leaf", {false, false, false}},  {"petiolule", {false, false, false}}, {"petiole", {false, false, false}},
                                {"internode", {false, false, false}}, {"peduncle", {false, false, false}}, {"petal", {false, false, false}}, {"pedicel", {false, false, false}},   {"fruit", {false, false, false}}};
        bandlabels = {"red", "green", "blue", "PAR", "NIR", "LW"};
        bandlabels_set = {"All", "red", "green", "blue", "PAR", "NIR", "LW"};
        bandlabels_set_emissivity = {"red", "green", "blue", "PAR", "NIR", "LW"};
        // bandlabels = {"red", "green", "blue"};
        // bandlabels_set = {"All", "red", "green", "blue"};
        for (std::string band: bandlabels) {
            primitive_values[band] = {{"All", {reflectivity, transmissivity, emissivity}},
                                      {"ground", {ground_reflectivity, ground_transmissivity, ground_emissivity}},
                                      {"leaf", {leaf_reflectivity, leaf_transmissivity, leaf_emissivity}},
                                      {"petiolule", {petiolule_reflectivity, petiolule_transmissivity, petiolule_emissivity}},
                                      {"petiole", {petiole_reflectivity, petiole_transmissivity, petiole_emissivity}},
                                      {"internode", {internode_reflectivity, internode_transmissivity, internode_emissivity}},
                                      {"peduncle", {peduncle_reflectivity, peduncle_transmissivity, peduncle_emissivity}},
                                      {"petal", {petal_reflectivity, petal_transmissivity, petal_emissivity}},
                                      {"pedicel", {pedicel_reflectivity, pedicel_transmissivity, pedicel_emissivity}},
                                      {"fruit", {fruit_reflectivity, fruit_transmissivity, fruit_emissivity}}};
            direct_ray_count_dict[band] = direct_ray_count; // direct ray counts per band
            diffuse_ray_count_dict[band] = diffuse_ray_count; // diffuse ray counts per band
            scattering_depth_dict[band] = scattering_depth; // scattering depth per band
        }
        primitive_spectra = {{"All", {reflectivity_spectrum, transmissivity_spectrum, emissivity_spectrum}},
                             {"ground", {ground_reflectivity_spectrum, ground_transmissivity_spectrum, ground_emissivity_spectrum}},
                             {"leaf", {leaf_reflectivity_spectrum, leaf_transmissivity_spectrum, leaf_emissivity_spectrum}},
                             {"petiolule", {petiolule_reflectivity_spectrum, petiolule_transmissivity_spectrum, petiolule_emissivity_spectrum}},
                             {"petiole", {petiole_reflectivity_spectrum, petiole_transmissivity_spectrum, petiole_emissivity_spectrum}},
                             {"internode", {internode_reflectivity_spectrum, internode_transmissivity_spectrum, internode_emissivity_spectrum}},
                             {"peduncle", {peduncle_reflectivity_spectrum, peduncle_transmissivity_spectrum, peduncle_emissivity_spectrum}},
                             {"petal", {petal_reflectivity_spectrum, petal_transmissivity_spectrum, petal_emissivity_spectrum}},
                             {"pedicel", {pedicel_reflectivity_spectrum, pedicel_transmissivity_spectrum, pedicel_emissivity_spectrum}},
                             {"fruit", {fruit_reflectivity_spectrum, fruit_transmissivity_spectrum, fruit_emissivity_spectrum}}};
    }
 
    ~ProjectBuilder() {
        std::cout.rdbuf(old_cout_stream_buf);
 
        delete context;
 
#ifdef HELIOS_VISUALIZER
        delete visualizer;
#endif // HELIOS_VISUALIZER
 
#ifdef PLANT_ARCHITECTURE
        delete plantarchitecture;
#endif // PLANT_ARCHITECTURE
 
#ifdef RADIATION_MODEL
        delete radiation;
        delete cameraproperties;
#endif // RADIATION_MODEL
 
#ifdef SOLARPOSITION
        delete solarposition;
#endif // SOLARPOSITION
 
#ifdef ENERGYBALANCEMODEL
        delete energybalancemodel;
#endif // ENERGYBALANCEMODEL
 
#ifdef BOUNDARYLAYERCONDUCTANCEMODEL
        delete boundarylayerconductance;
#endif // BOUNDARYLAYERCONDUCTANCEMODEL
    }
};
 
#endif // PROJECT_BUILDER