Read and calculate model specific meta data

modules/dataloader/operators/loader.cpp

@@ -25,6 +25,10 @@
 #include <iostream>
 #include <thread>
 #include <string>
+#include <algorithm>
+#include <sstream>
+#include <fstream>
+#include <regex>
 
 #include <nfd.h>
 #include <stdio.h>  // nfd
@@ -33,6 +37,7 @@
 
 #include <ghoul/lua/lua_helper.h>
 #include <ghoul/misc/dictionaryluaformatter.h>
+#include <ghoul/misc/dictionaryjsonformatter.h>
 #include <modules/dataloader/operators/loader.h>
 #include <modules/dataloader/dataloadermodule.h>
 #include <openspace/scene/scene.h>
@@ -50,7 +55,6 @@
 #include <modules/kameleonvolume/kameleonvolumereader.h>
 #include <ext/json/json.hpp>
 
-#include <fstream>
 #include <chrono>
 #include <ghoul/glm.h>
 
@@ -325,23 +329,108 @@ void Loader::getVolumeMetaData(ghoul::Dictionary &metaDataDictionary)
     _volumeMetaDataDictionary.getValue<ghoul::Dictionary>(KeyGlobalAttributes, gAttribDictionary);
     _volumeMetaDataDictionary.getValue<ghoul::Dictionary>(KeyVariableAttributes, vAttribDictionary);
 
+    constexpr const char *MetaDataModelNameKey = "model_name";
     constexpr const char *MetaDataGridSystemKey = "grid_system_1";
     constexpr const char *MetaDataGridSystemDimension1 = "grid_system_1_dimension_1_size";
     constexpr const char *MetaDataGridSystemDimension2 = "grid_system_1_dimension_2_size";
     constexpr const char *MetaDataGridSystemDimension3 = "grid_system_1_dimension_3_size";
 
     const std::vector<std::string> vKeys = vAttribDictionary.keys();
-    const std::string gridSystem1 = gAttribDictionary.value<std::string>(MetaDataGridSystemKey);
+    const std::string modelName = gAttribDictionary.value<std::string>(MetaDataModelNameKey);
+    std::string gridSystemString = gAttribDictionary.value<std::string>(MetaDataGridSystemKey);
     const int gridSystem1DimensionSize = gAttribDictionary.value<int>(MetaDataGridSystemDimension1);
     const int gridSystem2DimensionSize = gAttribDictionary.value<int>(MetaDataGridSystemDimension2);
     const int gridSystem3DimensionSize = gAttribDictionary.value<int>(MetaDataGridSystemDimension3);
 
+    ghoul::DictionaryJsonFormatter formatter;
+    const std::string variableAttributesJsonString = formatter.format(vAttribDictionary);
+
+    std::string gridType;
+    if (gridSystemString.find("theta") != std::string::npos && gridSystemString.find("phi") != std::string::npos)
+    {
+        gridType = "Spherical";
+    }
+    else
+    {
+        gridType = "Cartesian";
+    }
+
+    std::regex nonAlphanumeric("[^a-zA-Z0-9 $]+");
+    gridSystemString = std::regex_replace(gridSystemString, nonAlphanumeric, " ");
+
+    std::vector<std::string> gridSystem;
+    std::istringstream iss(gridSystemString);
+    for (std::string s; iss >> s;)
+    {
+        gridSystem.push_back(s);
+    }
+
+    std::string radiusUnit;
+    std::vector<int> dataDimensions;
+    if (modelName == "enlil")
+    {
+        dataDimensions = {64, 64, 64};
+        radiusUnit = "AU";
+    }
+    else if (modelName == "batsrus")
+    {
+        dataDimensions = {128, 64, 64};
+        radiusUnit = "Earth radius";
+    }
+    else if (modelName == "mas")
+    {
+        dataDimensions = {100, 100, 128};
+        radiusUnit = "Sun radius";
+    }
+    else
+    {
+        dataDimensions = {100, 100, 100};
+        radiusUnit = "";
+    }
+
+    json variableMinMaxBoundsJson;
+    const std::string KeyActualMax = "actual_max";
+    const std::string KeyActualMin = "actual_min";
+    if (gridType == "Spherical")
+    {
+        const std::string KeyR = "r";
+
+        ghoul::Dictionary rDictionary;
+        vAttribDictionary.getValue<ghoul::Dictionary>(KeyR, rDictionary);
+
+        const float actualMax = rDictionary.value<float>(KeyActualMax);
+        const float actualMin = rDictionary.value<float>(KeyActualMin);
+        const float AUmeters = 149597871000.0;
+
+        variableMinMaxBoundsJson["r"]["min"] = actualMin / AUmeters;
+        variableMinMaxBoundsJson["r"]["max"] = actualMax / AUmeters;
+    }
+    else
+    {
+        std::vector<std::string> keys = {"x", "y", "z"};
+        for (auto key : keys)
+        {
+            ghoul::Dictionary dict;
+            vAttribDictionary.getValue<ghoul::Dictionary>(key, dict);
+            const float actualMax = dict.value<float>(KeyActualMax);
+            const float actualMin = dict.value<float>(KeyActualMin);
+            variableMinMaxBoundsJson[key]["max"] = actualMax;
+            variableMinMaxBoundsJson[key]["min"] = actualMin;
+        }
+    }
+
     json j;
-    j["gridSystem"] = gridSystem1;
+    j["modelName"] = modelName;
+    j["dataDimensions"] = dataDimensions;
+    j["gridSystem"] = gridSystem;
+    j["gridType"] = gridType;
+    j["radiusUnit"] = radiusUnit;
     j["gridSystem1DimensionSize"] = gridSystem1DimensionSize;
     j["gridSystem2DimensionSize"] = gridSystem2DimensionSize;
     j["gridSystem3DimensionSize"] = gridSystem3DimensionSize;
-    j["variableAttributes"] = vKeys;
+    j["variableKeys"] = vKeys;
+    j["variableMinMaxBounds"] = variableMinMaxBoundsJson;
+    j["variableAttributes"] = json::parse(variableAttributesJsonString);
 
     _volumeMetaDataJSON = j.dump();
 }

modules/webgui/web/src/components/DataLoader/PrepareUploadedData.jsx

@@ -79,7 +79,6 @@ class PrepareUploadedData extends Component {
     this.handleSetTranslationTarget = this.handleSetTranslationTarget.bind(this);
     this.handleSelectedTFImage = this.handleSelectedTFImage.bind(this);
     this.handleTfPresetsJSON = this.handleTfPresetsJSON.bind(this);
-    this.processMetaData = this.processMetaData.bind(this);
   }
 
   componentDidUpdate(prevProps, prevState) {
@@ -98,7 +97,7 @@ class PrepareUploadedData extends Component {
 
     if (prevProps.metaDataStringifiedJSON !== this.props.metaDataStringifiedJSON) {
       const metaData = this.props.metaDataStringifiedJSON ? handleReceivedJSON(this.props.metaDataStringifiedJSON) : undefined
-      this.processMetaData(metaData)
+      console.log(metaData)
 
       let newDimensions
       if (metaData && metaData.gridSystem1DimensionSize && metaData.gridSystem2DimensionSize && metaData.gridSystem3DimensionSize) {
@@ -247,17 +246,6 @@ class PrepareUploadedData extends Component {
     DataManager.runScript(payloadScript);
   }
 
-  processMetaData(metaData) {
-    let gridType = ''
-    if (metaData && metaData.gridSystem) {
-      gridType = (metaData.gridSystem.includes('theta') && metaData.gridSystem.includes('phi')) ? 'Spherical' : 'Cartesian'
-      metaData.gridSystem = stringArrayToArray(metaData.gridSystem)
-      metaData.gridType = gridType
-    }
-
-    return metaData
-  }
-
   render() {
     const { width, currentVolumesConvertedCount, currentVolumesToConvertCount } = this.props;
     const { volumeProgress, translationType, translationPos, translationTarget, metaData } = this.state;
@@ -319,13 +307,13 @@ class PrepareUploadedData extends Component {
                 <Row><Label>Visualization grid type </Label></Row>
                 {(metaData && metaData.gridType) ? metaData.gridType : 'undefined'}
               </div>
-              <MultiInputs presentationLabel='Dimensions'
+              <MultiInputs presentationLabel='Data Dimensions'
                 inputLabels={(metaData && metaData.gridSystem) ? metaData.gridSystem : ['x', 'y', 'z']}
                 options={dimensions}
                 disabled={isUnEditable}
                 onChange={(target) => this.onChangeMultiInputs(target, KEY_DIMENSIONS)} />
               <Variables variable={variable}
-                options={metaData.variableAttributes}
+                options={metaData ? metaData.variableKeys : undefined}
                 disabled={isUnEditable}
                 onChange={this.changeVariable} />
               <MultiInputs presentationLabel='Lower Domain Bounds'