// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int AttributeMatrix::readAttributeArraysFromHDF5(hid_t amGid, bool preflight, AttributeMatrixProxy& attrMatProxy)
{
int err = 0;
QMap<QString, DataArrayProxy> dasToRead = attrMatProxy.dataArrays;
QString classType;
for (QMap<QString, DataArrayProxy>::iterator iter = dasToRead.begin(); iter != dasToRead.end(); ++iter)
{
//qDebug() << "Reading the " << iter->name << " Array from the " << m_Name << " Attribute Matrix \n";
if(iter->flag == DREAM3D::Unchecked)
{
continue;
}
QH5Lite::readStringAttribute(amGid, iter->name, DREAM3D::HDF5::ObjectType, classType);
// qDebug() << groupName << " Array: " << *iter << " with C++ ClassType of " << classType << "\n";
IDataArray::Pointer dPtr = IDataArray::NullPointer();
if(classType.startsWith("DataArray") == true)
{
dPtr = H5DataArrayReader::ReadIDataArray(amGid, iter->name, preflight);
}
else if(classType.compare("StringDataArray") == 0)
{
dPtr = H5DataArrayReader::ReadStringDataArray(amGid, iter->name, preflight);
}
else if(classType.compare("vector") == 0)
{
}
else if(classType.compare("NeighborList<T>") == 0)
{
dPtr = H5DataArrayReader::ReadNeighborListData(amGid, iter->name, preflight);
}
else if(classType.compare("Statistics") == 0)
{
StatsDataArray::Pointer statsData = StatsDataArray::New();
statsData->setName(iter->name);
statsData->readH5Data(amGid);
dPtr = statsData;
}
// else if ( (iter->name).compare(DREAM3D::EnsembleData::Statistics) == 0)
// {
// StatsDataArray::Pointer statsData = StatsDataArray::New();
// statsData->setName(DREAM3D::EnsembleData::Statistics);
// statsData->readH5Data(amGid);
// dPtr = statsData;
// }
if (NULL != dPtr.get())
{
addAttributeArray(dPtr->getName(), dPtr);
}
}
H5Gclose(amGid); // Close the Cell Group
return err;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int AttributeMatrix::addAttributeArrayFromHDF5Path(hid_t gid, QString name, bool preflight)
{
int err = 0;
QString classType;
QH5Lite::readStringAttribute(gid, name, DREAM3D::HDF5::ObjectType, classType);
// qDebug() << groupName << " Array: " << *iter << " with C++ ClassType of " << classType << "\n";
IDataArray::Pointer dPtr = IDataArray::NullPointer();
if(classType.startsWith("DataArray") == true)
{
dPtr = H5DataArrayReader::ReadIDataArray(gid, name, preflight);
if(preflight == true)
{
dPtr->resize(getNumTuples());
}
}
else if(classType.compare("StringDataArray") == 0)
{
dPtr = H5DataArrayReader::ReadStringDataArray(gid, name, preflight);
if (preflight == true)
{
dPtr->resize(getNumTuples());
}
}
else if(classType.compare("vector") == 0)
{
}
else if(classType.compare("NeighborList<T>") == 0)
{
dPtr = H5DataArrayReader::ReadNeighborListData(gid, name, preflight);
if (preflight == true)
{
dPtr->resize(getNumTuples());
}
}
else if ( name.compare(DREAM3D::EnsembleData::Statistics) == 0)
{
StatsDataArray::Pointer statsData = StatsDataArray::New();
statsData->setName(DREAM3D::EnsembleData::Statistics);
statsData->readH5Data(gid);
dPtr = statsData;
if (preflight == true)
{
dPtr->resize(getNumTuples());
}
}
if (NULL != dPtr.get())
{
addAttributeArray(dPtr->getName(), dPtr);
}
return err;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
StatsDataArray::Pointer StatsDataArray::CreateArray(size_t numTuples, int rank, size_t* dims, const QString& name, bool allocate)
{
if (name.isEmpty() == true)
{
return NullPointer();
}
StatsDataArray::Pointer ptr = StatsDataArray::New();
ptr->setName(name);
std::vector<unsigned int> phase_types(numTuples, DREAM3D::PhaseType::UnknownPhaseType);
if(allocate) { ptr->fillArrayWithNewStatsData(numTuples, &(phase_types.front()) ); }
return ptr;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
IDataArray::Pointer StatsDataArray::deepCopy(bool forceNoAllocate)
{
StatsDataArray::Pointer daCopyPtr = StatsDataArray::New();
if(forceNoAllocate == false)
{
daCopyPtr->resize(getNumberOfTuples());
StatsDataArray& daCopy = *daCopyPtr;
for(size_t i = 0; i < getNumberOfTuples(); i++)
{
daCopy[i] = m_StatsDataArray[i];
}
}
return daCopyPtr;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
IDataArray::Pointer StatsDataArray::reorderCopy(QVector<size_t> newOrderMap)
{
if( static_cast<size_t>(newOrderMap.size()) != getNumberOfTuples())
{
return IDataArray::Pointer();
}
StatsDataArray::Pointer daCopyPtr = StatsDataArray::New();
daCopyPtr->resize(getNumberOfTuples());
daCopyPtr->initializeWithZeros();
StatsDataArray& daCopy = *daCopyPtr;
for(size_t i = 0; i < getNumberOfTuples(); i++)
{
daCopy[newOrderMap[i]] = m_StatsDataArray[i];
}
return daCopyPtr;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void InitializeSyntheticVolume::dataCheck()
{
setErrorCondition(0);
// Create the output Data Container
DataContainer::Pointer m = getDataContainerArray()->createNonPrereqDataContainer<AbstractFilter>(this, getDataContainerName());
if(getErrorCondition() < 0) { return; }
ImageGeom::Pointer image = ImageGeom::CreateGeometry(DREAM3D::Geometry::ImageGeometry);
m->setGeometry(image);
// Sanity Check the Dimensions and Resolution
INIT_SYNTH_VOLUME_CHECK(Dimensions.x, -5000);
INIT_SYNTH_VOLUME_CHECK(Dimensions.y, -5001);
INIT_SYNTH_VOLUME_CHECK(Dimensions.z, -5002);
INIT_SYNTH_VOLUME_CHECK(Resolution.x, -5003);
INIT_SYNTH_VOLUME_CHECK(Resolution.y, -5004);
INIT_SYNTH_VOLUME_CHECK(Resolution.z, -5005);
// Set the Dimensions, Resolution and Origin of the output data container
m->getGeometryAs<ImageGeom>()->setDimensions(m_Dimensions.x, m_Dimensions.y, m_Dimensions.z);
m->getGeometryAs<ImageGeom>()->setResolution(m_Resolution.x, m_Resolution.y, m_Resolution.z);
m->getGeometryAs<ImageGeom>()->setOrigin(m_Origin.x, m_Origin.y, m_Origin.z);
// Create our output Cell and Ensemble Attribute Matrix objects
QVector<size_t> tDims(3, 0);
tDims[0] = m_Dimensions.x;
tDims[1] = m_Dimensions.y;
tDims[2] = m_Dimensions.z;
AttributeMatrix::Pointer cellAttrMat = m->createNonPrereqAttributeMatrix<AbstractFilter>(this, getCellAttributeMatrixName(), tDims, DREAM3D::AttributeMatrixType::Cell);
if(getErrorCondition() < 0 && cellAttrMat.get() == NULL) { return; }
QVector<size_t> cDims(1, 1); // This states that we are looking for an array with a single component
UInt32ArrayType::Pointer phaseType = getDataContainerArray()->getPrereqArrayFromPath<UInt32ArrayType, AbstractFilter>(this, getInputPhaseTypesArrayPath(), cDims);
if(getErrorCondition() < 0 && phaseType.get() == NULL) { return; }
QVector<size_t> statsDims(1, 1);
StatsDataArray::Pointer statsPtr = getDataContainerArray()->getPrereqArrayFromPath<StatsDataArray, AbstractFilter>(this, getInputStatsArrayPath(), statsDims);
if(getErrorCondition() < 0 && statsPtr.get() == NULL) { return; }
if(m_EstimateNumberOfFeatures)
{
m_EstimatedPrimaryFeatures = estimateNumFeatures(m_Dimensions, m_Resolution);
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FindAxisODF::dataCheck(bool preflight, size_t voxels, size_t fields, size_t ensembles)
{
setErrorCondition(0);
std::stringstream ss;
VoxelDataContainer* m = getVoxelDataContainer();
int err = 0;
GET_PREREQ_DATA(m, DREAM3D, FieldData, AxisEulerAngles, ss, -301, float, FloatArrayType, fields, 3)
TEST_PREREQ_DATA(m, DREAM3D, FieldData, SurfaceFields, err, -302, bool, BoolArrayType, fields, 1)
if(err == -302)
{
setErrorCondition(0);
FindSurfaceGrains::Pointer find_surfacefields = FindSurfaceGrains::New();
find_surfacefields->setObservers(this->getObservers());
find_surfacefields->setVoxelDataContainer(getVoxelDataContainer());
if(preflight == true) find_surfacefields->preflight();
if(preflight == false) find_surfacefields->execute();
}
GET_PREREQ_DATA(m, DREAM3D, FieldData, SurfaceFields, ss, -302, bool, BoolArrayType, fields, 1)
err = 0;
TEST_PREREQ_DATA(m, DREAM3D, FieldData, FieldPhases, err, -303, int32_t, Int32ArrayType, fields, 1)
if(err == -303)
{
setErrorCondition(0);
FindGrainPhases::Pointer find_grainphases = FindGrainPhases::New();
find_grainphases->setObservers(this->getObservers());
find_grainphases->setVoxelDataContainer(getVoxelDataContainer());
if(preflight == true) find_grainphases->preflight();
if(preflight == false) find_grainphases->execute();
}
GET_PREREQ_DATA(m, DREAM3D, FieldData, FieldPhases, ss, -303, int32_t, Int32ArrayType, fields, 1)
typedef DataArray<unsigned int> PhaseTypeArrayType;
GET_PREREQ_DATA(m, DREAM3D, EnsembleData, PhaseTypes, ss, -307, unsigned int, PhaseTypeArrayType, ensembles, 1)
m_StatsDataArray = StatsDataArray::SafeObjectDownCast<IDataArray*, StatsDataArray*>(m->getEnsembleData(DREAM3D::EnsembleData::Statistics).get());
if(m_StatsDataArray == NULL)
{
StatsDataArray::Pointer p = StatsDataArray::New();
m_StatsDataArray = p.get();
m_StatsDataArray->fillArrayWithNewStatsData(ensembles, m_PhaseTypes);
m->addEnsembleData(DREAM3D::EnsembleData::Statistics, p);
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
StatsDataArray::Pointer StatsDataArray::CreateArray(QVector<size_t> tDims, QVector<size_t> cDims, const QString& name, bool allocate)
{
if (name.isEmpty() == true)
{
return NullPointer();
}
size_t numTuples = tDims[0];
qint32 size = tDims.size();
for(qint32 iter = 1; iter < size; iter++)
{
numTuples *= tDims[iter];
}
StatsDataArray::Pointer ptr = StatsDataArray::New();
ptr->setName(name);
std::vector<unsigned int> phase_types(numTuples, DREAM3D::PhaseType::UnknownPhaseType);
if(allocate) { ptr->fillArrayWithNewStatsData(numTuples, &(phase_types.front()) ); }
return ptr;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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);
}
