bool ImportWorker::processFilesAndDatastore(int Step)
{
emit stepEntered(tr("Copying files and populating datastore..."));
int i=0;
bool OKToContinue = true;
while (i<m_SourcesInfos.size() && OKToContinue)
{
if (m_SourcesInfos[i].IsDatasetImport)
{
// local copy of files in dataset
QString FullSrcFilePath = m_SourcesInfos[i].SourceURI;
if (!m_SourcesInfos[i].CachedSourceURI.isEmpty())
FullSrcFilePath = m_SourcesInfos[i].CachedSourceURI;
QString FullDestFilePath = m_InputDir + "/" + m_SourcesInfos[i].RelativeDatasetPath;
QString FullDestPath = QFileInfo(FullDestFilePath).absolutePath();
QString DestExtension = QFileInfo(FullDestFilePath).suffix();
QDir().mkpath(FullDestPath);
GDALAllRegister_COMPAT();
GDALDataset_COMPAT* SrcDS = GDALOpenRO_COMPAT(FullSrcFilePath.toStdString().c_str());
if (SrcDS != nullptr)
{
GDALDriver_COMPAT *CopyDriver;
QString DriverName = OGRGDALHelpers::getDriverFromFileExt(DestExtension);
CopyDriver = GDALGetDriverByName_COMPAT(DriverName.toStdString().c_str());
if (CopyDriver != nullptr)
{
GDALDataset_COMPAT* DestDS = GDALCopy_COMPAT(CopyDriver,SrcDS,FullDestFilePath.toStdString().c_str());
GDALClose_COMPAT(DestDS);
}
GDALClose_COMPAT(SrcDS);
}
}
if (m_SourcesInfos[i].IsDatastore)
{
QString RelativePath = m_SourcesInfos[i].RelativeDatasetPath;
if (m_SourcesInfos[i].IsAlreadyInDataset)
RelativePath = QDir(m_InputDir).relativeFilePath(m_SourcesInfos[i].SourceURI);
// populate datastore
openfluid::fluidx::DatastoreItemDescriptor* DSItem =
new openfluid::fluidx::DatastoreItemDescriptor(m_SourcesInfos[i].DatastoreID.toStdString(),
m_InputDir.toStdString(),
RelativePath.toStdString(),
openfluid::core::UnstructuredValue::GeoVectorValue);
DSItem->setUnitsClass(m_SourcesInfos[i].UnitsClass.toStdString());
mp_AdvDesc->datastore().appendItem(DSItem);
}
i++;
}
emit stepCompleted(Step,getStyledText(tr("[OK]"),"green"));
return true;
}
void processSerie(GeoVectorSerie& Serie)
{
QString IndexStr = "init";
openfluid::base::SimulationStatus::SimulationStage CurrentStage =
OPENFLUID_GetCurrentStage();
bool OKToWrite = false;
if (CurrentStage == openfluid::base::SimulationStatus::INITIALIZERUN)
{
OKToWrite = Serie.WhenMode == GeoVectorSerie::WHENINIT ||
Serie.WhenMode == GeoVectorSerie::WHENCONTINUOUS;
}
else if (CurrentStage == openfluid::base::SimulationStatus::RUNSTEP)
{
if (Serie.WhenMode == GeoVectorSerie::WHENCONTINUOUS)
{
openfluid::core::TimeIndex_t CurrentIndex = OPENFLUID_GetCurrentTimeIndex();
IndexStr = QString("%1").arg(CurrentIndex);
if (Serie.LatestContinuousIndex + Serie.WhenContinuousDelay < CurrentIndex)
{
OKToWrite = true;
Serie.LatestContinuousIndex = CurrentIndex;
}
}
}
else if (CurrentStage == openfluid::base::SimulationStatus::FINALIZERUN)
{
IndexStr = "final";
OKToWrite = Serie.WhenMode == GeoVectorSerie::WHENCONTINUOUS ||
Serie.WhenMode == GeoVectorSerie::WHENFINAL;
}
else
{
OPENFLUID_LogWarning("Internal stage error when processing geographic series");
return;
}
if (OKToWrite)
{
std::string FullFilePath =
m_OutputPath + "/" + QString(QString::fromStdString(Serie.OutfilePattern).arg(IndexStr)).toStdString();
GDALDriver_COMPAT* Driver = GDALGetDriverByName_COMPAT(m_GDALFormat.c_str());
if (openfluid::tools::Filesystem::isFile(FullFilePath))
{
// deletion of an existing file or files set
GDALDelete_COMPAT(Driver,FullFilePath.c_str());
}
GDALDataset_COMPAT* CreatedFile = GDALCreate_COMPAT(Driver,FullFilePath.c_str());
std::string CreatedLayerName = QFileInfo(QString::fromStdString(FullFilePath)).completeBaseName().toStdString();
OGRLayer* CreatedLayer = CreatedFile->CreateLayer(CreatedLayerName.c_str(),nullptr,
Serie.GeoLayer->GetLayerDefn()->GetGeomType(),
nullptr);
OGRFieldDefn IDField("OFLD_ID",OFTInteger);
CreatedLayer->CreateField(&IDField);
GeoVectorSerie::VariablesSet_t::const_iterator itV;
GeoVectorSerie::VariablesSet_t::const_iterator itVb = Serie.VariablesSet.begin();
GeoVectorSerie::VariablesSet_t::const_iterator itVe = Serie.VariablesSet.end();
for (itV = itVb; itV != itVe; ++itV)
{
std::string FieldName = (*itV).second;
OGRFieldDefn VarField(FieldName.c_str(),OFTReal);
VarField.SetWidth(24);
VarField.SetPrecision(15);
CreatedLayer->CreateField(&VarField);
}
OGRFeature* SourceFeature;
openfluid::core::SpatialUnit* UU;
Serie.GeoLayer->ResetReading();
while ((SourceFeature = Serie.GeoLayer->GetNextFeature()) != nullptr)
{
int SourceID = SourceFeature->GetFieldAsInteger(Serie.OFLDIDFieldIndex);
UU = OPENFLUID_GetUnit(Serie.UnitsClass,SourceID);
if (UU)
{
CreatedLayer->GetLayerDefn();
OGRFeature* CreatedFeature = OGRFeature::CreateFeature(CreatedLayer->GetLayerDefn());
CreatedFeature->SetGeometry(SourceFeature->GetGeometryRef()->clone());
CreatedFeature->SetField("OFLD_ID",SourceID);
for (itV = itVb; itV != itVe; ++itV)
{
std::string VarName = (*itV).first;
std::string FieldName = (*itV).second;
openfluid::core::DoubleValue CreatedValue = 0.0;
bool IsValueCreated = false;
if (FieldName.empty())
FieldName = VarName;
openfluid::core::IndexedValue VarValue;
if (OPENFLUID_IsVariableExist(UU,VarName))
{
OPENFLUID_GetLatestVariable(UU,VarName,VarValue);
if (VarValue.value()->isDoubleValue()) // OpenFLUID value is double
{
CreatedValue = VarValue.value()->asDoubleValue();
IsValueCreated = true;
}
else if (VarValue.value()->convert(CreatedValue)) // OpenFLUID value can be converted to double
{
IsValueCreated = true;
}
else
{
QString Msg = QString("Variable %1 on unit %2#%3 is not a double or a compatible type")
.arg(VarName.c_str()).arg(UU->getClass().c_str()).arg(UU->getID());
OPENFLUID_LogWarning(Msg.toStdString());
}
}
else
{
QString Msg = QString("Variable %1 does not exist on unit %2#%3")
.arg(VarName.c_str()).arg(UU->getClass().c_str()).arg(UU->getID());
OPENFLUID_LogWarning(Msg.toStdString());
}
if (IsValueCreated) // OpenFLUID value is written to GIS file only if it is double or converted to double
CreatedFeature->SetField(FieldName.c_str(),CreatedValue);
}
if (CreatedLayer->CreateFeature(CreatedFeature) != OGRERR_NONE)
{
QString Msg = QString("Feature for unit %1#%2 cannot be created")
.arg(UU->getClass().c_str()).arg(UU->getID());
OPENFLUID_LogWarning(Msg.toStdString());
}
OGRFeature::DestroyFeature(CreatedFeature);
}
}
GDALClose_COMPAT(CreatedFile);
}
}
