FlowDataBlueprint.h

Go to the documentation of this file.

#ifndef GlobeEngine_FlowDataBlueprint_h
#define GlobeEngine_FlowDataBlueprint_h

#include <vmmlib/vmmlib.hpp>
#include <memory>
#include "Jzon.h"
#include "BluePrints.h"

namespace geFlow {

    struct ClimateLoadingRange {
        std::vector<size_t> start;
        std::vector<size_t> count;
    };

    struct ClimateDataVariable {
        std::string name;
        int timestepsToLoad;
        double animationIntervall;
        std::vector<std::string> variables;
        std::vector<std::string> ordering;
    };

    struct ArrowFieldInfo {
        double arrowlength;
        std::shared_ptr<ge::ShaderBlueprint> shader;
        ClimateDataVariable ncinfo;
    };

    struct AnimatedTextureInfo {
        std::shared_ptr<ge::ShaderBlueprint> shader;
        ClimateDataVariable ncinfo;
    };

    struct VolumeInfo {
        std::shared_ptr<ge::ShaderBlueprint> shader;
        ClimateDataVariable ncinfo;
    };

    struct WeatherDataLoadingInfo {
        std::string fileName;
        std::vector<std::string> gridInfo; // long lat variables
        std::vector<ArrowFieldInfo> arrowFieldInfos;
        std::vector<AnimatedTextureInfo> animatedTextureInfos;
        std::vector<VolumeInfo> volumeInfos;
    };

    static std::vector<std::string> getStringfieldFromNode(const Jzon::Node& _node)
    {
        std::vector<std::string> resVec;
        int idx = 0;
        for (Jzon::Node::const_iterator it = _node.begin(); it != _node.end(); ++it) {
            resVec.push_back(it->second.toString());
            idx++;
        }
        return resVec;
    }

    static ClimateDataVariable getClimateDataVariable(const Jzon::Node& _config) {
        ClimateDataVariable res;
        res.name = _config.get("name").toString();
        res.animationIntervall = _config.get("animationIntervall").toDouble();
        res.timestepsToLoad = _config.get("timesteps").toInt();
        res.variables = geFlow::getStringfieldFromNode(_config.get("vars"));
        res.ordering = geFlow::getStringfieldFromNode(_config.get("orderInNetCDF"));
        return res;
    }

    static ArrowFieldInfo getArrowFieldFromJSON(const Jzon::Node& _config) {
        ArrowFieldInfo res;
        res.arrowlength = _config.get("arrowlenght").toDouble();
        res.shader = ge::Blueprint::readShaderContentFromJSONElement(_config.get("shader"));
        res.ncinfo = geFlow::getClimateDataVariable(_config);
        return res;
    }

    static AnimatedTextureInfo getAnimatedTextureFromJSON(const Jzon::Node& _config) {
        AnimatedTextureInfo res;
        res.ncinfo = geFlow::getClimateDataVariable(_config);
        res.shader = ge::Blueprint::readShaderContentFromJSONElement(_config.get("shader"));
        return res;
    }

    static VolumeInfo getVolumeInfoFromJSON(const Jzon::Node& _config) {
        VolumeInfo res;
        res.ncinfo = geFlow::getClimateDataVariable(_config);
        res.shader = ge::Blueprint::readShaderContentFromJSONElement(_config.get("shader"));
        return res;
    }

    static std::shared_ptr<geFlow::WeatherDataLoadingInfo> getWeatherLoadingInfoFromJSONElement(const Jzon::Node& _config) {
        std::shared_ptr<geFlow::WeatherDataLoadingInfo> res = std::make_shared<WeatherDataLoadingInfo>();
        res->fileName = _config.get("url").toString();
        // read grid info
        res->gridInfo.push_back(_config.get("grid").get("longitude").toString());
        res->gridInfo.push_back(_config.get("grid").get("latitude").toString());
        if (_config.get("grid").get("height")) {
            res->gridInfo.push_back(_config.get("grid").get("height").toString());
        }
        if (_config.get("grid").get("time")) {
            res->gridInfo.push_back(_config.get("grid").get("time").toString());
        }
        // read out arrowfield info
        if (_config.get("arrowfield")) {
            res->arrowFieldInfos.push_back(geFlow::getArrowFieldFromJSON(_config.get("arrowfield")));
        }
        // read out animated texture info
        if (_config.get("texture")) {
            res->animatedTextureInfos.push_back(geFlow::getAnimatedTextureFromJSON(_config.get("texture")));

        }
        // read out animated volume info
        if (_config.get("volume")) {
            res->volumeInfos.push_back(geFlow::getVolumeInfoFromJSON(_config.get("volume")));
        }
        return res;
    }
}
#endif