// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void MatrixPhaseWidget::extractStatsData(VoxelDataContainer::Pointer m, int index)
{
setPhaseIndex(index);
IDataArray* iDataPtr = NULL;
iDataPtr = m->getEnsembleData(DREAM3D::EnsembleData::CrystalStructures).get();
UInt32ArrayType* data = UInt32ArrayType::SafeObjectDownCast<IDataArray*, UInt32ArrayType*>(iDataPtr);
m_CrystalStructure = data->GetValue(index);
iDataPtr = m->getEnsembleData(DREAM3D::EnsembleData::PhaseTypes).get();
data = UInt32ArrayType::SafeObjectDownCast<IDataArray*, UInt32ArrayType*>(iDataPtr);
m_PhaseType = data->GetValue(index);
iDataPtr = m->getEnsembleData(DREAM3D::EnsembleData::Statistics).get();
StatsDataArray* statsDataArray = StatsDataArray::SafeObjectDownCast<IDataArray*, StatsDataArray*>(iDataPtr);
if (statsDataArray == NULL)
{
return;
}
StatsData::Pointer statsData = statsDataArray->getStatsData(index);
MatrixStatsData* matrixStatsData = MatrixStatsData::SafePointerDownCast(statsData.get());
m_PhaseFraction = matrixStatsData->getPhaseFraction();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int MatrixPhaseWidget::gatherStatsData(VoxelDataContainer::Pointer m)
{
if (m_PhaseIndex < 1)
{
QMessageBox::critical(this, tr("StatsGenerator"),
tr("The Phase Index is Less than 1. This is not allowed."),
QMessageBox::Default);
return -1;
}
int retErr = 0;
// int err = 0;
float calcPhaseFraction = m_PhaseFraction / m_TotalPhaseFraction;
typedef DataArray<unsigned int> XTalStructArrayType;
typedef DataArray<unsigned int> PhaseTypeArrayType;
typedef DataArray<unsigned int> ShapeTypeArrayType;
size_t ensembles = m->getNumEnsembleTuples();
// Get pointers
unsigned int* crystalStructures = m->getEnsembleDataSizeCheck<unsigned int, XTalStructArrayType, AbstractFilter>(DREAM3D::EnsembleData::CrystalStructures, ensembles, 1, NULL);
unsigned int* phaseTypes = m->getEnsembleDataSizeCheck<unsigned int, PhaseTypeArrayType, AbstractFilter>(DREAM3D::EnsembleData::PhaseTypes, ensembles, 1, NULL);
//unsigned int* shapeTypes = m->getEnsembleDataSizeCheck<unsigned int, ShapeTypeArrayType, AbstractFilter>(DREAM3D::EnsembleData::ShapeTypes, ensembles*1, NULL);
crystalStructures[m_PhaseIndex] = m_CrystalStructure;
phaseTypes[m_PhaseIndex] = m_PhaseType;
StatsDataArray* statsDataArray = StatsDataArray::SafeObjectDownCast<IDataArray*, StatsDataArray*>(m->getEnsembleData(DREAM3D::EnsembleData::Statistics).get());
StatsData::Pointer statsData = statsDataArray->getStatsData(m_PhaseIndex);
MatrixStatsData* matrixStatsData = MatrixStatsData::SafePointerDownCast(statsData.get());
if(NULL != matrixStatsData)
{
matrixStatsData->setPhaseFraction(calcPhaseFraction);
}
else
{
retErr = -1000;
}
return retErr;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int MatrixPhaseWidget::gatherStatsData(AttributeMatrix::Pointer attrMat)
{
if (m_PhaseIndex < 1)
{
QMessageBox::critical(this, tr("StatsGenerator"),
tr("The Phase Index is Less than 1. This is not allowed."),
QMessageBox::Default);
return -1;
}
int retErr = 0;
float calcPhaseFraction = m_PhaseFraction / m_TotalPhaseFraction;
//size_t ensembles = attrMat->getNumTuples();
// Get pointers
IDataArray::Pointer iDataArray = attrMat->getAttributeArray(DREAM3D::EnsembleData::CrystalStructures);
unsigned int* crystalStructures = boost::dynamic_pointer_cast< UInt32ArrayType >(iDataArray)->getPointer(0);
iDataArray = attrMat->getAttributeArray(DREAM3D::EnsembleData::PhaseTypes);
unsigned int* phaseTypes = boost::dynamic_pointer_cast< UInt32ArrayType >(iDataArray)->getPointer(0);
crystalStructures[m_PhaseIndex] = m_CrystalStructure;
phaseTypes[m_PhaseIndex] = m_PhaseType;
StatsDataArray* statsDataArray = StatsDataArray::SafeObjectDownCast<IDataArray*, StatsDataArray*>(attrMat->getAttributeArray(DREAM3D::EnsembleData::Statistics).get());
if (NULL != statsDataArray)
{
StatsData::Pointer statsData = statsDataArray->getStatsData(m_PhaseIndex);
MatrixStatsData* matrixStatsData = MatrixStatsData::SafePointerDownCast(statsData.get());
if(NULL != matrixStatsData)
{
matrixStatsData->setPhaseFraction(calcPhaseFraction);
}
else
{
retErr = -1000;
}
}
return retErr;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void MatrixPhaseWidget::extractStatsData(AttributeMatrix::Pointer attrMat, int index)
{
setPhaseIndex(index);
IDataArray::Pointer iDataArray = attrMat->getAttributeArray(DREAM3D::EnsembleData::CrystalStructures);
unsigned int* attributeArray = boost::dynamic_pointer_cast< UInt32ArrayType >(iDataArray)->getPointer(0);
m_CrystalStructure = attributeArray[index];
iDataArray = attrMat->getAttributeArray(DREAM3D::EnsembleData::PhaseTypes);
attributeArray = boost::dynamic_pointer_cast< UInt32ArrayType >(iDataArray)->getPointer(0);
m_PhaseType = attributeArray[index];
iDataArray = attrMat->getAttributeArray(DREAM3D::EnsembleData::Statistics);
StatsDataArray* statsDataArray = StatsDataArray::SafeObjectDownCast<IDataArray*, StatsDataArray*>(iDataArray.get());
if (statsDataArray == NULL)
{
return;
}
StatsData::Pointer statsData = statsDataArray->getStatsData(index);
MatrixStatsData* matrixStatsData = MatrixStatsData::SafePointerDownCast(statsData.get());
m_PhaseFraction = matrixStatsData->getPhaseFraction();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void EstablishMatrixPhase::establish_matrix()
{
notifyStatusMessage(getHumanLabel(), "Establishing Matrix");
SIMPL_RANDOMNG_NEW()
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getOutputCellAttributeMatrixPath().getDataContainerName());
StatsDataArray& statsDataArray = *(m_StatsDataArray.lock());
size_t udims[3] =
{ 0, 0, 0 };
m->getGeometryAs<ImageGeom>()->getDimensions(udims);
#if (CMP_SIZEOF_SIZE_T == 4)
typedef int32_t DimType;
#else
typedef int64_t DimType;
#endif
DimType dims[3] =
{
static_cast<DimType>(udims[0]),
static_cast<DimType>(udims[1]),
static_cast<DimType>(udims[2]),
};
sizex = dims[0] * m->getGeometryAs<ImageGeom>()->getXRes();
sizey = dims[1] * m->getGeometryAs<ImageGeom>()->getYRes();
sizez = dims[2] * m->getGeometryAs<ImageGeom>()->getZRes();
totalvol = sizex * sizey * sizez;
size_t totalPoints = m_FeatureIdsPtr.lock()->getNumberOfTuples();
size_t currentnumfeatures = m_FeaturePhasesPtr.lock()->getNumberOfTuples();
size_t numensembles = m_PhaseTypesPtr.lock()->getNumberOfTuples();
QVector<size_t> tDims(1, 1);
if (currentnumfeatures == 0)
{
m->getAttributeMatrix(m_OutputCellFeatureAttributeMatrixName)->resizeAttributeArrays(tDims);
updateFeatureInstancePointers();
currentnumfeatures = 1;
}
firstMatrixFeature = currentnumfeatures;
float random = 0.0f;
float totalmatrixfractions = 0.0f;
for (size_t i = 1; i < numensembles; ++i)
{
if (m_PhaseTypes[i] == DREAM3D::PhaseType::MatrixPhase)
{
MatrixStatsData* mp = MatrixStatsData::SafePointerDownCast(statsDataArray[i].get());
if (NULL == mp)
{
QString ss = QObject::tr("Tried to cast a statsDataArray[%1].get() to a MatrixStatsData* "
"pointer but this resulted in a NULL pointer. The value at m_PhaseTypes[%2] = %3 does not match up "
"with the type of pointer stored in the StatsDataArray (MatrixStatsData)\n")
.arg(i).arg(i).arg(m_PhaseTypes[i]);
notifyErrorMessage(getHumanLabel(), ss, -666);
setErrorCondition(-666);
return;
}
matrixphases.push_back(i);
matrixphasefractions.push_back(mp->getPhaseFraction());
totalmatrixfractions = totalmatrixfractions + mp->getPhaseFraction();
}
}
for (int32_t i = 0; i < matrixphases.size(); i++)
{
matrixphasefractions[i] = matrixphasefractions[i] / totalmatrixfractions;
if (i > 0) { matrixphasefractions[i] = matrixphasefractions[i] + matrixphasefractions[i - 1]; }
}
size_t j = 0;
for (size_t i = 0; i < totalPoints; ++i)
{
if ((m_UseMask == false && m_FeatureIds[i] <= 0) || (m_UseMask == true && m_Mask[i] == true && m_FeatureIds[i] <= 0))
{
random = static_cast<float>( rg.genrand_res53() );
j = 0;
while (random > matrixphasefractions[j])
{
j++;
}
if (m->getAttributeMatrix(m_OutputCellFeatureAttributeMatrixName)->getNumTuples() <= (firstMatrixFeature + j))
{
tDims[0] = (firstMatrixFeature + j) + 1;
m->getAttributeMatrix(m_OutputCellFeatureAttributeMatrixName)->resizeAttributeArrays(tDims);
updateFeatureInstancePointers();
m_NumFeatures[j] = 1;
}
m_FeatureIds[i] = (firstMatrixFeature + j);
m_CellPhases[i] = matrixphases[j];
m_FeaturePhases[(firstMatrixFeature + j)] = matrixphases[j];
}
else if (m_UseMask == true && m_Mask[i] == false)
{
m_FeatureIds[i] = 0;
m_CellPhases[i] = 0;
}
}
}