LeafOptics.h

Go to the documentation of this file.

 
#include "Context.h"
 
 
struct LeafOpticsProperties {
 
    float numberlayers = 1.5;
    float brownpigments = 0.f;
    float chlorophyllcontent = 30.f; // µg.cm-2
    float carotenoidcontent = 7.f; // µg.cm-2
    float anthocyancontent = 1; // µg.cm-2
    float watermass = 0.015f; // g.cm-2
    float drymass = 0.09f; // g.cm-2
    float protein = 0.f; // g.cm-2
    float carbonconstituents = 0.f; // g.cm-2
 
    // === Fluspect-B SIF parameters (optional) ===
    // These are used by the radiation plugin's SIF (solar-induced fluorescence)
    // pipeline when it is active. They are ignored by the pure reflectance/
    // transmittance PROSPECT calculation performed by LeafOptics. When
    // LeafOptics::run() is called, it writes these values alongside the PROSPECT
    // parameters to global data keyed by the spectrum label so that the radiation
    // model can look them up per primitive.
 
    float V2Z = 0.f;
 
    float fqe = 1.f;
 
    // Default values for Prospect-D
    // float N=1.5;  float CHL= 30.0 ;  float CAR = 10.0;  float ANT = 1.0; float Brown=0.0; float EWT= 0.015; float LMA = 0.009;
 
    // Default values for Prospect-PRO
    //  float N=1.5;  float CHL= 40.0 ;  float CAR = 10.0;  float ANT = 0.5; float Brown=0.0; float EWT= 0.015; float pro = 0.001; float carbon = 0.009;
 
    LeafOpticsProperties() {};
 
    LeafOpticsProperties(float chlorophyllcontent, float carotenoidcontent, float anthocyancontent, float watermass, float drymass, float protein, float carbonconstituents) :
        chlorophyllcontent(chlorophyllcontent), carotenoidcontent(carotenoidcontent), anthocyancontent(anthocyancontent), watermass(watermass), drymass(drymass), protein(protein), carbonconstituents(carbonconstituents) {
    }
};
 
 
struct LeafOpticsProperties_Nauto {
 
    // === Nitrogen-to-pigment conversion coefficients ===
 
    float f_photosynthetic = 0.50f;
 
 
    float N_to_Cab_coefficient = 0.40f;
 
 
    float Car_to_Cab_ratio = 0.25f;
 
    // === Fixed PROSPECT parameters (not derived from nitrogen) ===
 
    float numberlayers = 1.5f; 
    float anthocyancontent = 1.0f; 
    float brownpigments = 0.0f; 
    float watermass = 0.015f; 
    float drymass = 0.006f; 
    float protein = 0.0f; 
    float carbonconstituents = 0.0f; 
 
    // === Fluspect-B SIF parameters (optional, fixed per bin) ===
    float V2Z = 0.f;   
    float fqe = 1.f;   
 
    // === Adaptive binning configuration ===
 
 
    uint num_bins = 20;
 
 
    float reassignment_threshold = 0.30f;
 
 
    float min_reassignment_change = 0.3f;
};
 
class LeafOptics {
public:
    LeafOptics(helios::Context *a_context);
 
 
    static int selfTest(int argc = 0, char **argv = nullptr);
 
 
    void run(const std::vector<uint> &UUIDs, const LeafOpticsProperties &leafproperties, const std::string &label);
 
 
    void run(const LeafOpticsProperties &leafproperties, const std::string &label);
 
 
    void PROSPECT(float numberlayers, float Chlorophyllcontent, float carotenoidcontent, float anthocyancontent, float brownpigments, float watermass, float drymass, float protein, float carbonconstituents, std::vector<float> &reflectivities_fit,
                  std::vector<float> &transmissivities_fit);
 
 
    void getLeafSpectra(const LeafOpticsProperties &leafproperties, std::vector<helios::vec2> &reflectivities_fit, std::vector<helios::vec2> &transmissivities_fit);
 
 
    void setProperties(const std::vector<uint> &UUIDs, const LeafOpticsProperties &leafproperties);
 
 
    void getPropertiesFromSpectrum(const std::vector<uint> &UUIDs);
 
 
    void getPropertiesFromSpectrum(uint UUID);
 
 
    void getPropertiesFromLibrary(const std::string &species, LeafOpticsProperties &leafproperties);
 
    void disableMessages();
 
    void enableMessages();
 
 
    void optionalOutputPrimitiveData(const char *label);
 
 
    void run(const std::vector<uint> &UUIDs, const LeafOpticsProperties_Nauto &params);
 
 
    void updateNitrogenBasedSpectra();
 
private:
    std::vector<float> R_spec_normal, R_spec_diffuse, wave_length, Rtotal, Ttotal;
 
    const uint nw = 2101;
 
    helios::Context *context;
    std::map<std::string, LeafOpticsProperties> spectrum_parameters_map;
    std::map<std::string, LeafOpticsProperties> species_library;
    void initializeSpeciesLibrary();
    float chlorophyll_default = 43.0; 
    float chlorophyll_default_grass = 57.0;
    float carotenoid2chlorophyll = 0.23; 
    float carotenoid2chlorophyll_grass = 0.21;
    float anthocyanin2carotenoid = 0.06; 
    float anthocyanin2carotenoid_grass = 0.006;
    float drymass2chlorophyll = 1.2669e-04; 
    float drymass2chlorophyll_grass = 9.2196e-05;
    float watercontent = 0.9; 
 
    //
    std::vector<float> refractiveindex, absorption_chlorophyll, absorption_carotenoid, absorption_anthocyanin, absorption_brown, absorption_water, absorption_drymass;
    std::vector<float> absorption_protein, absorption_carbonconstituents;
    std::vector<float> Rcof, Tcof;
    //  std::vector<float> R_spec_normal, R_spec_diffuse, wave_length;
 
 
    void validateProperties(const LeafOpticsProperties &leafproperties);
 
    float transmittance(double k);
    // Computes the diffuse transmittance through an elementary layer
 
    void surface(float degree, std::vector<float> &reflectivities);
    // Computes surface reflectances for normal and diffuse light incidence
 
    bool message_flag = true;
 
    std::vector<std::string> output_prim_data;
 
    // === Nitrogen mode state ===
 
    bool nitrogen_mode_active = false;
 
    LeafOpticsProperties_Nauto nitrogen_params;
 
    struct SpectrumBin {
        float N_center; 
        std::string spectrum_label; 
    };
 
    std::vector<SpectrumBin> nitrogen_bins;
 
    struct ObjectAssignment {
        uint bin_index; 
        float N_at_assignment; 
        std::vector<uint> primitive_UUIDs; 
    };
 
    std::map<uint, ObjectAssignment> object_assignments;
 
    std::map<uint, uint> primitive_to_object;
 
    // === Nitrogen mode helper methods ===
 
    LeafOpticsProperties computePropertiesFromNitrogen(float N_area_gN_m2, const LeafOpticsProperties_Nauto &params);
 
    std::map<uint, std::vector<uint>> groupPrimitivesByObject(const std::vector<uint> &UUIDs);
 
    void createAdaptiveBins(const std::vector<float> &nitrogen_values);
 
    uint findNearestBin(float N_value);
 
    bool shouldReassign(float current_N, uint current_bin);
 
    bool isSignificantImprovement(float current_N, uint old_bin, uint new_bin);
 
    void assignSpectrumToPrimitives(const std::vector<uint> &UUIDs, uint bin_index);
};