private IEnumerator ImportVariableRoutine(IDataLoader _loader, ITimeStepDataAssetBuilder _timestepDataAssetBuilder, string _projectFolder, List <TimeStepDataAsset> _timestepDataAssetList, Utils.BitDepth _bitDepth, IProgress <float> _progress)
{
// We assume every directory is a time stamp which contains the level tiffs
string[] directories = Directory.GetDirectories(_projectFolder);
Log.Info(this, "Start variable importing routine");
for (int i = 0; i < directories.Length; i++)
{
string directory = directories[i];
Log.Info(this, "Creating asset from image from " + directory);
TimeStepDataAsset asset = _timestepDataAssetBuilder.BuildTimestepDataAssetFromData(_loader.ImportImageFiles(directory));
_timestepDataAssetList.Add(asset);
// Report progress
float progression = (i + 1) / ( float )directories.Length;
_progress.Report(progression);
yield return(null);
}
yield return(null);
}
private IEnumerator SaveVariableRoutine(IVariable _variable, string _variablePath, int _varIndex, IProgress <float> _progress)
{
string textureAssetPath = Path.Combine(_variablePath, Globals.TEXTURE3D_FOLDER_NAME);
// Only create if it does not exist, yet
if (!Directory.Exists(textureAssetPath))
{
Directory.CreateDirectory(textureAssetPath);
}
List <TimeStepDataAsset> currentVariableTimeStepList = m_DataAssets[_variable.Name];
for (int i = 0; i < currentVariableTimeStepList.Count; i++)
{
string dateTimeString = this.MetaData.Timestamps[_varIndex][i].DateTimeDouble.ToString().Replace(',', '.');
string assetName = Globals.TEXTURE3D_PREFEX + this.MetaData.DataName + "_" + _variable.Name + "_" + dateTimeString;
string assetPath = textureAssetPath + "/";
string assetCompleteName = assetPath + assetName + ".asset";
Log.Info(this, "Create asset " + assetCompleteName);
TimeStepDataAsset asset = currentVariableTimeStepList[i];
AssetDatabase.CreateAsset(asset.DataTexture, assetCompleteName);
// Report progress
_progress.Report(Utils.CalculateProgress(i, currentVariableTimeStepList.Count));
yield return(null);
}
yield return(null);
}
public void SetData(TimeStepDataAsset _data)
{
if (m_Renderer)
{
m_Renderer.enabled = true;
this.Show(true);
}
Singleton.GetCartesianMaterial().SetTexture("_Data", _data.DataTexture);
Singleton.GetSphericalMaterial().SetTexture("_Data", _data.DataTexture);
}
private void OnTimelineChanged(float value)
{
// Bail out if we have no assets yet
if (Singleton.GetDataManager().CurrentDataAssets.Count <= 0)
{
return;
}
TimeStepDataAsset asset = Singleton.GetDataManager().CurrentDataAssets[( int )value];
Singleton.GetDataManager().SetCurrentAsset(asset);
Singleton.GetVolumeRenderer().SetData(asset);
m_TimestampUI.UpdateTimestamp((uint)value);
}
private static TimeStepDataAsset ReadTimeStamp(XmlNode timestampNode)
{
TimeStepDataAsset newTimestamp = new TimeStepDataAsset();
newTimestamp.DateTimeDouble = Utils.ReadAttribute(timestampNode, Globals.TIME_STAMP_DATETIME_ATTRIBUTE);
Debug.Log("loading timestamps: " + newTimestamp.DateTimeDouble);
Vector3 dim = new Vector3();
dim.x = Utils.ReadAttribute(timestampNode, Globals.TIME_STAMP_DATA_ASSET_DIM_X_ATTRIBUTE);
dim.y = Utils.ReadAttribute(timestampNode, Globals.TIME_STAMP_DATA_ASSET_DIM_Y_ATTRIBUTE);
dim.z = Utils.ReadAttribute(timestampNode, Globals.TIME_STAMP_DATA_ASSET_DIM_Z_ATTRIBUTE);
return(newTimestamp);
}
private void FinishLoading(IMetaData _metaData, System.Diagnostics.Stopwatch _stopwatch)
{
Log.Info(this, "Loading and creating assets took " + (_stopwatch.ElapsedMilliseconds / 1000.0f).ToString("0.00") + "seconds.");
this.MetaData = _metaData;
this.CurrentVariableName = m_DataAssets.First().Key;
this.CurrentVariableMin = _metaData.Variables[0].Min;
this.CurrentVariableMax = _metaData.Variables[0].Max;
this.CurrentTimeStepDataAsset = this.CurrentDataAssets.First();
// Set new data
Singleton.GetVolumeRenderer().SetData(this.CurrentTimeStepDataAsset);
m_TransferFunctionUI.Redraw();
OnNewImport?.Invoke();
m_TimestampUI.UpdateTimestamp(m_TimestampUI.CurrentIndex);
}
private IEnumerator LoadVariableRoutine(string _variableFolder, ITimeStepDataAssetBuilder _timestepDataAssetBuilder, List <TimeStepDataAsset> _timestepDataAssetList, IVariable variable, Utils.BitDepth _bitDepth, IProgress <float> _progress)
{
string assetPath = Path.Combine(_variableFolder, Globals.TEXTURE3D_FOLDER_NAME);
Log.Info(this, "Look for assets at " + assetPath);
string[] assets = Directory.GetFiles(assetPath);
Log.Info(this, "Found " + assets.Length + " assets");
Texture3D asset = null;
int assetFileIndex = 0;
foreach (string file in assets)
{
if (file.EndsWith(".asset"))
{
Log.Info(this, "Found " + file);
asset = AssetDatabase.LoadAssetAtPath <Texture3D>(file);
TimeStepDataAsset timestepAsset = _timestepDataAssetBuilder.BuildTimestepDataAssetFromTexture(asset);
_timestepDataAssetList.Add(timestepAsset);
assetFileIndex++;
// Report progress
_progress.Report(Utils.CalculateProgress(assetFileIndex, assets.Length));
yield return(null);
}
}
Log.Info(this, "Found " + assetFileIndex + " assets");
yield return(null);
}
public static IMetaData Import(string _projectFilePath)
{
XmlDocument document = new XmlDocument();
document.Load(_projectFilePath);
XmlElement root = document.DocumentElement;
MetaDataManager.MetaData outputMetaData = new MetaDataManager.MetaData();
outputMetaData = MetaDataReader.LoadProjectAttributes(root, outputMetaData);
// Read in variables
IList <IVariable> variablesList = new List <IVariable>();
IList <IList <TimeStepDataAsset> > timestampLisList = new List <IList <TimeStepDataAsset> >();
if (root.ChildNodes.Count == 0)
{
Log.ThrowValueNotFoundException("MetaDataReader", root.Name + "is empty");
}
foreach (XmlNode varNode in root.ChildNodes)
{
if (varNode.Name == Globals.VARIABLE_ELEMENT)
{
// Read name from variable node
string varNodeName = varNode.Attributes[Globals.VARIABLE_NAME_ATTRIBUTE].Value;
double varNodeMin = Utils.ReadAttribute(varNode, Globals.VARIABLE_MIN_ATTRIBUTE);
double varNodeMax = Utils.ReadAttribute(varNode, Globals.VARIABLE_MAX_ATTRIBUTE);
Debug.Log("Min and Max are " + varNodeMin + " and " + varNodeMax);
List <TimeStepDataAsset> varTimestampList = new List <TimeStepDataAsset>();
if (varNodeName != null)
{
variablesList.Add(new MetaDataManager.Variable()
{
Name = varNodeName, Min = varNodeMin, Max = varNodeMax
});
// Create a new list for timestamps
timestampLisList.Add(varTimestampList);
}
else
{
Log.ThrowValueNotFoundException("MetaDataReader", Globals.VARIABLE_NAME_ATTRIBUTE);
}
if (varNode.ChildNodes.Count == 0)
{
Log.ThrowValueNotFoundException("MetaDataReader", varNode.Name);
}
foreach (XmlNode timestampNode in varNode.ChildNodes)
{
if (timestampNode.Name == Globals.TIME_STAMP_LIST_ELEMENT)
{
TimeStepDataAsset newTimestamp = MetaDataReader.ReadTimeStamp(timestampNode);
// fill last list with timestamps
varTimestampList.Add(newTimestamp);
}
}
}
}
outputMetaData.Timestamps = timestampLisList;
outputMetaData.Variables = variablesList;
return(outputMetaData);
}
// Hold on a specific timestep and display the corresponding data
public void SetCurrentAsset(TimeStepDataAsset _timeStepDataAsset)
{
this.CurrentTimeStepDataAsset = _timeStepDataAsset;
this.OnDataAssetChanged?.Invoke(_timeStepDataAsset);
}
