// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int StatsDataArray::writeH5Data(hid_t parentId, QVector<size_t> tDims)
{
herr_t err = 0;
hid_t gid = QH5Utilities::createGroup(parentId, m_Name);
if (gid < 0)
{
return -1;
}
HDF5ScopedGroupSentinel scopedFileSentinel(&gid, false); // This makes sure our H5Group is closed up as we exit this function
// We start numbering our phases at 1. Anything in slot 0 is considered "Dummy" or invalid
for(qint32 i = 1; i < m_StatsDataArray.size(); ++i)
{
if (m_StatsDataArray[i].get() != NULL)
{
QString indexString = QString::number(i);
hid_t tupleId = QH5Utilities::createGroup(gid, indexString);
err = QH5Lite::writeStringAttribute(gid, indexString, DREAM3D::StringConstants::StatsType, m_StatsDataArray[i]->getStatsType() );
err = QH5Lite::writeScalarAttribute(gid, indexString, DREAM3D::StringConstants::PhaseType, m_StatsDataArray[i]->getPhaseType() );
err = m_StatsDataArray[i]->writeHDF5Data(tupleId);
err = QH5Utilities::closeHDF5Object(tupleId);
}
}
QVector<size_t> cDims(1, 1);
err = H5DataArrayWriter::writeDataArrayAttributes<StatsDataArray>(parentId, this, tDims, cDims);
return err;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
QString InitializeSyntheticVolume::estimateNumFeatures(IntVec3_t dims, FloatVec3_t res)
{
float totalvol = 0.0f;
int32_t phase = 0;
totalvol = (dims.x * res.x) * (dims.y * res.y) * (dims.z * res.z);
if (totalvol == 0.0)
{
return "-1";
}
DataContainerArray::Pointer dca = getDataContainerArray();
// Get the PhaseTypes - Remember there is a Dummy PhaseType in the first slot of the array
QVector<size_t> cDims(1, 1); // This states that we are looking for an array with a single component
UInt32ArrayType::Pointer phaseType = dca->getPrereqArrayFromPath<UInt32ArrayType, AbstractFilter>(NULL, getInputPhaseTypesArrayPath(), cDims);
if (phaseType.get() == NULL)
{
QString ss = QObject::tr("Phase types array could not be downcast using std::dynamic_pointer_cast<T> when estimating the number of grains. The path is %1").arg(getInputPhaseTypesArrayPath().serialize());
setErrorCondition(-11002);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return "0";
}
QVector<size_t> statsDims(1, 1);
StatsDataArray::Pointer statsPtr = dca->getPrereqArrayFromPath<StatsDataArray, AbstractFilter>(this, getInputStatsArrayPath(), statsDims);
if (statsPtr.get() == NULL)
{
QString ss = QObject::tr("Statistics array could not be downcast using std::dynamic_pointer_cast<T> when estimating the number of grains. The path is %1").arg(getInputStatsArrayPath().serialize());
notifyErrorMessage(getHumanLabel(), ss, -11001);
return "0";
}
if (!phaseType->isAllocated())
{
if (getInputStatsFile().isEmpty())
{
QString ss = QObject::tr("Phase types array has not been allocated and the input statistics file is empty");
setErrorCondition(-1000);
notifyWarningMessage(getHumanLabel(), ss, getErrorCondition());
return "-1";
}
QFileInfo fi(getInputStatsFile());
if (fi.exists() == false)
{
QString ss = QObject::tr("Phase types array has not been allocated and the input statistics file does not exist at '%1'").arg(fi.absoluteFilePath());
setErrorCondition(-1001);
notifyWarningMessage(getHumanLabel(), ss, getErrorCondition());
return "-1";
}
hid_t fileId = -1;
herr_t err = 0;
// open the file
fileId = H5Utilities::openFile(getInputStatsFile().toLatin1().constData(), true);
// This will make sure if we return early from this method that the HDF5 File is properly closed.
HDF5ScopedFileSentinel scopedFileSentinel(&fileId, true);
DataArrayPath dap = getInputPhaseTypesArrayPath();
// Generate the path to the AttributeMatrix
QString hPath = DREAM3D::StringConstants::DataContainerGroupName + "/" + dap.getDataContainerName() + "/" + dap.getAttributeMatrixName();
// Open the AttributeMatrix Group
hid_t amGid = H5Gopen(fileId, hPath.toLatin1().data(), H5P_DEFAULT );
scopedFileSentinel.addGroupId(&amGid);
err = phaseType->readH5Data(amGid);
if (err < 0)
{
QString ss = QObject::tr("Error reading phase type data");
setErrorCondition(-1003);
notifyWarningMessage(getHumanLabel(), ss, getErrorCondition());
return "-1";
}
if (!phaseType->isAllocated())
{
QString ss = QObject::tr("Phase types Array was not allocated due to an error reading the data from the statistics file %1").arg(fi.absoluteFilePath());
setErrorCondition(-1002);
notifyWarningMessage(getHumanLabel(), ss, getErrorCondition());
return "-1";
}
}
// Create a Reference Variable so we can use the [] syntax
StatsDataArray& statsDataArray = *(statsPtr.get());
std::vector<int32_t> primaryphases;
std::vector<double> primaryphasefractions;
double totalprimaryfractions = 0.0;
// find which phases are primary phases
for (size_t i = 1; i < phaseType->getNumberOfTuples(); ++i)
{
if (phaseType->getValue(i) == DREAM3D::PhaseType::PrimaryPhase)
{
PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsDataArray[i].get());
primaryphases.push_back(i);
primaryphasefractions.push_back(pp->getPhaseFraction());
totalprimaryfractions = totalprimaryfractions + pp->getPhaseFraction();
}
}
// scale the primary phase fractions to total to 1
for (int32_t i = 0; i < primaryphasefractions.size(); i++)
{
primaryphasefractions[i] = primaryphasefractions[i] / totalprimaryfractions;
}
SIMPL_RANDOMNG_NEW()
// generate the Features
int32_t gid = 1;
float currentvol = 0.0f;
float vol = 0.0f;
float diam = 0.0f;
bool volgood = false;
for (int32_t j = 0; j < primaryphases.size(); ++j)
{
float curphasetotalvol = totalvol * primaryphasefractions[j];
while (currentvol < curphasetotalvol)
{
volgood = false;
phase = primaryphases[j];
PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsDataArray[phase].get());
if (NULL == pp)
{
QString ss = QObject::tr("Tried to cast a statsDataArray[%1].get() to a PrimaryStatsData* "
"pointer but this resulted in a NULL pointer.\n")
.arg(phase).arg(phase);
setErrorCondition(-666);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return "-1";
}
while (volgood == false)
{
volgood = true;
if (pp->getFeatureSize_DistType() == DREAM3D::DistributionType::LogNormal)
{
float avgdiam = pp->getFeatureSizeDistribution().at(0)->getValue(0);
float sddiam = pp->getFeatureSizeDistribution().at(1)->getValue(0);
diam = rg.genrand_norm(avgdiam, sddiam);
diam = expf(diam);
if (diam >= pp->getMaxFeatureDiameter()) { volgood = false; }
if (diam < pp->getMinFeatureDiameter()) { volgood = false; }
vol = (4.0f / 3.0f) * (M_PI) * ((diam * 0.5f) * (diam * 0.5f) * (diam * 0.5f));
}
}
currentvol = currentvol + vol;
gid++;
}
}
return QString::number(gid);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int H5FilterParametersWriter::WritePipelineToFile(FilterPipeline::Pointer pipeline, QString filePath, QString name, IObserver* obs)
{
if (NULL == pipeline.get())
{
if (NULL != obs)
{
PipelineMessage pm(H5FilterParametersWriter::ClassName(), "FilterPipeline Object was NULL for writing", -1, PipelineMessage::Error);
obs->processPipelineMessage(pm);
}
return -1;
}
QFileInfo fileInfo(filePath);
// WRITE THE PIPELINE TO THE HDF5 FILE
H5FilterParametersWriter::Pointer writer = H5FilterParametersWriter::New();
hid_t fileId = -1;
fileId = QH5Utilities::createFile(filePath);
if (fileId < 0)
{
if (NULL != obs)
{
PipelineMessage pm(H5FilterParametersWriter::ClassName(), "Output .dream3d file could not be created.", -1, PipelineMessage::Error);
obs->processPipelineMessage(pm);
}
return -1;
}
// This will make sure if we return early from this method that the HDF5 File is properly closed.
// This will also take care of making sure all groups and file ids are closed
// before this method returns.
HDF5ScopedFileSentinel scopedFileSentinel(&fileId, true);
// Write our File Version string to the Root "/" group
QH5Lite::writeStringAttribute(fileId, "/", DREAM3D::HDF5::FileVersionName, DREAM3D::HDF5::FileVersion);
QH5Lite::writeStringAttribute(fileId, "/", DREAM3D::HDF5::DREAM3DVersion, DREAM3DLib::Version::Complete() );
hid_t pipelineGroupId = QH5Utilities::createGroup(fileId, DREAM3D::StringConstants::PipelineGroupName);
scopedFileSentinel.addGroupId(&pipelineGroupId);
writer->setGroupId(pipelineGroupId);
FilterPipeline::FilterContainerType& filters = pipeline->getFilterContainer();
// Loop over each filter and write it's input parameters to the file
int count = filters.size();
int index = 0;
for (qint32 i = 0; i < count; ++i)
{
AbstractFilter::Pointer filter = filters.at(i);
if (NULL != filter.get())
{
index = filter->writeFilterParameters(writer.get(), index);
}
else
{
AbstractFilter::Pointer badFilter = AbstractFilter::New();
writer->openFilterGroup(badFilter.get(), i);
writer->writeValue("Unknown Filter", "ERROR: Filter instance was NULL within the PipelineFilterWidget instance. Report this error to the DREAM3D Developers");
writer->closeFilterGroup();
}
}
return 0;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void DataContainerReader::readData(bool preflight, DataContainerArrayProxy& proxy, DataContainerArray::Pointer dca)
{
setErrorCondition(0);
QString ss;
int32_t err = 0;
QString m_FileVersion;
float fVersion = 0.0f;
bool check = false;
// qDebug() << "DataContainerReader::readData() " << m_InputFile;
// Read the Meta Data and Array names from the file
hid_t fileId = QH5Utilities::openFile(m_InputFile, true); // Open the file Read Only
if (fileId < 0)
{
ss = QObject::tr("Error opening input file '%1'").arg(m_InputFile);
setErrorCondition(-150);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
// This will make sure if we return early from this method that the HDF5 File is properly closed.
HDF5ScopedFileSentinel scopedFileSentinel(&fileId, true);
// Check to see if version of .dream3d file is prior to new data container names
err = QH5Lite::readStringAttribute(fileId, "/", DREAM3D::HDF5::FileVersionName, m_FileVersion);
fVersion = m_FileVersion.toFloat(&check);
if (fVersion < 5.0 || err < 0)
{
QH5Utilities::closeFile(fileId);
fileId = QH5Utilities::openFile(m_InputFile, false); // Re-Open the file as Read/Write
err = H5Lmove(fileId, "VoxelDataContainer", fileId, DREAM3D::Defaults::DataContainerName.toLatin1().data(), H5P_DEFAULT, H5P_DEFAULT);
err = H5Lmove(fileId, "SurfaceMeshDataContainer", fileId, DREAM3D::Defaults::DataContainerName.toLatin1().data(), H5P_DEFAULT, H5P_DEFAULT);
err = QH5Lite::writeStringAttribute(fileId, "/", DREAM3D::HDF5::FileVersionName, "5.0");
QH5Utilities::closeFile(fileId);
fileId = QH5Utilities::openFile(m_InputFile, true); // Re-Open the file as Read Only
}
if (fVersion < 7.0)
{
ss = QObject::tr("File unable to be read - file structure older than 7.0");
setErrorCondition(-250);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
hid_t dcaGid = H5Gopen(fileId, DREAM3D::StringConstants::DataContainerGroupName.toLatin1().data(), 0);
if (dcaGid < 0)
{
setErrorCondition(-1923123);
QString ss = QObject::tr("Error attempting to open the HDF5 Group '%1'").arg(DREAM3D::StringConstants::DataContainerGroupName);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
scopedFileSentinel.addGroupId(&dcaGid);
err = dca->readDataContainersFromHDF5(preflight, dcaGid, proxy, this);
if (err < 0)
{
setErrorCondition(err);
QString ss = QObject::tr("Error trying to read the DataContainers from the file '%1'").arg(getInputFile());
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
err = H5Gclose(dcaGid);
dcaGid = -1;
err = readDataContainerBundles(fileId, dca);
if (err < 0)
{
setErrorCondition(err);
QString ss = QObject::tr("Error trying to read the DataContainerBundles from the file '%1'").arg(getInputFile());
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
if (!getInPreflight())
{
err = readExistingPipelineFromFile(fileId);
if(err < 0)
{
setErrorCondition(err);
QString ss = QObject::tr("Error trying to read the existing pipeline from the file '%1'").arg(getInputFile());
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
}
}
