// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FindFeatureClustering::dataCheck()
{
setErrorCondition(0);
initialize();
getDataContainerArray()->getPrereqGeometryFromDataContainer<ImageGeom, AbstractFilter>(this, getEquivalentDiametersArrayPath().getDataContainerName());
DataArrayPath tempPath;
QVector<size_t> cDims(1, 1);
m_EquivalentDiametersPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<float>, AbstractFilter>(this, getEquivalentDiametersArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_EquivalentDiametersPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_EquivalentDiameters = m_EquivalentDiametersPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
m_FeaturePhasesPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter>(this, getFeaturePhasesArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_FeaturePhasesPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_FeaturePhases = m_FeaturePhasesPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
cDims[0] = 3;
m_CentroidsPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<float>, AbstractFilter>(this, getCentroidsArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_CentroidsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_Centroids = m_CentroidsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
if (m_RemoveBiasedFeatures == true)
{
cDims[0] = 1;
m_BiasedFeaturesPtr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<bool>, AbstractFilter>(this, getBiasedFeaturesArrayPath(), cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_BiasedFeaturesPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_BiasedFeatures = m_BiasedFeaturesPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
}
cDims[0] = m_NumberOfBins;
tempPath.update(getCellEnsembleAttributeMatrixName().getDataContainerName(), getCellEnsembleAttributeMatrixName().getAttributeMatrixName(), getNewEnsembleArrayArrayName() );
m_NewEnsembleArrayPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<float>, AbstractFilter>(this, tempPath, 0, cDims); /* Assigns the shared_ptr<>(this, tempPath, 0, dims); Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_NewEnsembleArrayPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_NewEnsembleArray = m_NewEnsembleArrayPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
cDims[0] = 2;
tempPath.update(getCellEnsembleAttributeMatrixName().getDataContainerName(), getCellEnsembleAttributeMatrixName().getAttributeMatrixName(), getMaxMinArrayName() );
m_MaxMinArrayPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<float>, AbstractFilter>(this, tempPath, 0, cDims);
if( NULL != m_MaxMinArrayPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_MaxMinArray = m_MaxMinArrayPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
cDims[0] = 1;
tempPath.update(getFeaturePhasesArrayPath().getDataContainerName(), getFeaturePhasesArrayPath().getAttributeMatrixName(), getClusteringListArrayName() );
m_ClusteringList = getDataContainerArray()->createNonPrereqArrayFromPath<NeighborList<float>, AbstractFilter, float>(this, tempPath, 0, cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
}
void YSChoiAbaqusReader::execute()
{
dataCheck();
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getDataContainerName());
int xpoints, ypoints, zpoints, totalpoints = 0;
float resx, resy, resz;
float** *mat = NULL;
//const unsigned int size(1024);
// Read header from data file to figure out how many points there are
QFile in(getInputFile());
if (!in.open(QIODevice::ReadOnly | QIODevice::Text))
{
QString msg = QObject::tr("Abaqus file could not be opened: %1").arg(getInputFile());
setErrorCondition(-100);
notifyErrorMessage(getHumanLabel(), "", getErrorCondition());
return;
}
QString word;
bool ok = false;
bool headerdone = false;
while (headerdone == false)
{
QByteArray buf = in.readLine();
if (buf.startsWith(DIMS))
{
QList<QByteArray> tokens = buf.split(' ');
xpoints = tokens[1].toInt(&ok, 10);
ypoints = tokens[2].toInt(&ok, 10);
zpoints = tokens[3].toInt(&ok, 10);
totalpoints = xpoints * ypoints * zpoints;
size_t dims[3] = { static_cast<size_t>(xpoints), static_cast<size_t>(ypoints), static_cast<size_t>(zpoints) };
m->getGeometryAs<ImageGeom>()->setDimensions(dims);
m->getGeometryAs<ImageGeom>()->setOrigin(0, 0, 0);
}
if (buf.startsWith(RES))
{
QList<QByteArray> tokens = buf.split(' ');
resx = tokens[1].toInt(&ok, 10);
resy = tokens[2].toInt(&ok, 10);
resz = tokens[3].toInt(&ok, 10);
float res[3] = {resx, resy, resz};
m->getGeometryAs<ImageGeom>()->setResolution(res);
}
if (buf.startsWith(LOOKUP))
{
headerdone = true;
word = QString(buf);
}
}
// Read header from grain info file to figure out how many features there are
QFile in2(getInputFeatureInfoFile());
if (!in2.open(QIODevice::ReadOnly | QIODevice::Text))
{
QString msg = QObject::tr("Abaqus Feature Info file could not be opened: %1").arg(getInputFeatureInfoFile());
setErrorCondition(-100);
notifyErrorMessage(getHumanLabel(), "", getErrorCondition());
return;
}
int numfeatures;
QByteArray buf = in2.readLine();
numfeatures = buf.toInt(&ok, 10);
buf = in2.readLine();
QList<QByteArray> tokens = buf.split(' ');
// in2 >> word >> word >> word >> word >> word >> word;
QVector<size_t> tDims(3, 0);
tDims[0] = xpoints;
tDims[1] = ypoints;
tDims[2] = zpoints;
m->getAttributeMatrix(getCellAttributeMatrixName())->resizeAttributeArrays(tDims);
tDims.resize(1);
tDims[0] = numfeatures + 1;
m->getAttributeMatrix(getCellFeatureAttributeMatrixName())->resizeAttributeArrays(tDims);
tDims[0] = 2;
m->getAttributeMatrix(getCellEnsembleAttributeMatrixName())->resizeAttributeArrays(tDims);
updateCellInstancePointers();
updateFeatureInstancePointers();
updateEnsembleInstancePointers();
//Read data file
int gnum = 0;
bool onedge = false;
int col, row, plane;
float value;
for (int i = 0; i < totalpoints; i++)
{
mat[i] = new float *[3];
for(int j = 0; j < 3; j++)
{
mat[i][j] = new float [3];
}
onedge = false;
gnum = tokens[6].toInt(&ok, 10);
col = i % xpoints;
row = (i / xpoints) % ypoints;
plane = i / (xpoints * ypoints);
if (col == 0 || col == (xpoints - 1) || row == 0 || row == (ypoints - 1) || plane == 0 || plane == (zpoints - 1)) { onedge = true; }
m_FeatureIds[i] = gnum;
m_SurfaceFeatures[gnum] = onedge;
}
for (int iter1 = 0; iter1 < 3; iter1++)
{
for (int iter2 = 0; iter2 < 3; iter2++)
{
headerdone = false;
while (headerdone == false)
{
buf = in2.readLine();
if (buf.startsWith(LOOKUP))
{
headerdone = true;
//in >> word;
}
}
for (int i = 0; i < totalpoints; i++)
{
onedge = 0;
value = buf.toInt(&ok, 10);
mat[i][iter1][iter2] = value;
}
}
}
//Read feature info
QuatF* avgQuats = reinterpret_cast<QuatF*>(m_AvgQuats);
avgQuats[0].x = 0.0;
avgQuats[0].y = 0.0;
avgQuats[0].z = 0.0;
avgQuats[0].w = 0.0;
for (int i = 1; i < numfeatures + 1; i++)
{
buf = in2.readLine();
tokens = buf.split(' ');
gnum = tokens[0].toInt(&ok, 10);
avgQuats[i].x = tokens[2].toFloat(&ok);
avgQuats[i].y = tokens[3].toFloat(&ok);
avgQuats[i].z = tokens[4].toFloat(&ok);
avgQuats[i].w = tokens[5].toFloat(&ok);
}
QuatF q;
QuatF* quats = reinterpret_cast<QuatF*>(m_Quats);
float g[3][3];
for(int i = 0; i < (xpoints * ypoints * zpoints); i++)
{
for(int j = 0; j < 3; j++)
{
for(int k = 0; k < 3; k++)
{
g[j][k] = mat[i][j][k];
}
}
MatrixMath::Normalize3x3(g);
q.w = static_cast<float>( sqrt((1.0 + g[0][0] + g[1][1] + g[2][2])) / 2.0 );
q.x = static_cast<float>( (g[1][2] - g[2][1]) / (4.0 * q.w) );
q.y = static_cast<float>( (g[2][0] - g[0][2]) / (4.0 * q.w) );
q.z = static_cast<float>( (g[0][1] - g[1][0]) / (4.0 * q.w) );
QuaternionMathF::Copy(q, quats[i]);
FOrientArrayType eu(m_CellEulerAngles + (3 * i), 3);
FOrientTransformsType::qu2eu(FOrientArrayType(q), eu);
delete[] mat[i];
}
delete[] mat;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void YSChoiAbaqusReader::dataCheck()
{
DataArrayPath tempPath;
setErrorCondition(0);
DataContainer::Pointer m = getDataContainerArray()->createNonPrereqDataContainer<AbstractFilter>(this, getDataContainerName());
if(getErrorCondition() < 0) { return; }
ImageGeom::Pointer image = ImageGeom::CreateGeometry(DREAM3D::Geometry::ImageGeometry);
m->setGeometry(image);
QVector<size_t> tDims(3, 0);
AttributeMatrix::Pointer cellAttrMat = m->createNonPrereqAttributeMatrix<AbstractFilter>(this, getCellAttributeMatrixName(), tDims, DREAM3D::AttributeMatrixType::Cell);
if(getErrorCondition() < 0 || NULL == cellAttrMat.get()) { return; }
tDims.resize(1);
tDims[0] = 0;
AttributeMatrix::Pointer cellFeatureAttrMat = m->createNonPrereqAttributeMatrix<AbstractFilter>(this, getCellFeatureAttributeMatrixName(), tDims, DREAM3D::AttributeMatrixType::CellFeature);
if(getErrorCondition() < 0 || NULL == cellFeatureAttrMat.get()) { return; }
AttributeMatrix::Pointer cellEnsembleAttrMat = m->createNonPrereqAttributeMatrix<AbstractFilter>(this, getCellEnsembleAttributeMatrixName(), tDims, DREAM3D::AttributeMatrixType::CellEnsemble);
if(getErrorCondition() < 0 || NULL == cellEnsembleAttrMat.get()) { return; }
QFileInfo fi(getInputFile());
if (getInputFile().isEmpty() == true)
{
QString ss = QObject::tr("%1 needs the Input File Set and it was not.").arg(ClassName());
setErrorCondition(-387);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
else if (fi.exists() == false)
{
QString ss = QObject::tr("The input file does not exist");
setErrorCondition(-388);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
else
{
bool ok = false;
//const unsigned int size(1024);
// Read header from data file to figure out how many points there are
QFile in(getInputFile());
if (!in.open(QIODevice::ReadOnly | QIODevice::Text))
{
QString msg = QObject::tr("Abaqus file could not be opened: %1").arg(getInputFile());
setErrorCondition(-100);
notifyErrorMessage(getHumanLabel(), "", getErrorCondition());
return;
}
QString word;
bool headerdone = false;
int xpoints, ypoints, zpoints;
float resx, resy, resz;
while (headerdone == false)
{
QByteArray buf = in.readLine();
if (buf.startsWith(DIMS))
{
QList<QByteArray> tokens = buf.split(' ');
xpoints = tokens[1].toInt(&ok, 10);
ypoints = tokens[2].toInt(&ok, 10);
zpoints = tokens[3].toInt(&ok, 10);
size_t dims[3] = { static_cast<size_t>(xpoints), static_cast<size_t>(ypoints), static_cast<size_t>(zpoints) };
m->getGeometryAs<ImageGeom>()->setDimensions(dims);
m->getGeometryAs<ImageGeom>()->setOrigin(0, 0, 0);
}
if (RES == word)
{
QList<QByteArray> tokens = buf.split(' ');
resx = tokens[1].toInt(&ok, 10);
resy = tokens[2].toInt(&ok, 10);
resz = tokens[3].toInt(&ok, 10);
float res[3] = {resx, resy, resz};
m->getGeometryAs<ImageGeom>()->setResolution(res);
}
}
}
QVector<size_t> dims(1, 3);
tempPath.update(getDataContainerName(), getCellAttributeMatrixName(), getCellEulerAnglesArrayName() );
m_CellEulerAnglesPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<float>, AbstractFilter, float>(this, tempPath, 0, dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_CellEulerAnglesPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_CellEulerAngles = m_CellEulerAnglesPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
dims[0] = 4;
tempPath.update(getDataContainerName(), getCellAttributeMatrixName(), getQuatsArrayName() );
m_QuatsPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<float>, AbstractFilter, float>(this, tempPath, 0, dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_QuatsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_Quats = m_QuatsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
tempPath.update(getDataContainerName(), getCellFeatureAttributeMatrixName(), getAvgQuatsArrayName() );
m_AvgQuatsPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<float>, AbstractFilter, float>(this, tempPath, 0, dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_AvgQuatsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_AvgQuats = m_AvgQuatsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
dims[0] = 1;
tempPath.update(getDataContainerName(), getCellAttributeMatrixName(), getCellPhasesArrayName() );
m_CellPhasesPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter, int32_t>(this, tempPath, 1, dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_CellPhasesPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_CellPhases = m_CellPhasesPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
tempPath.update(getDataContainerName(), getCellFeatureAttributeMatrixName(), getSurfaceFeaturesArrayName() );
m_SurfaceFeaturesPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<bool>, AbstractFilter, bool>(this, tempPath, false, dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_SurfaceFeaturesPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_SurfaceFeatures = m_SurfaceFeaturesPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
tempPath.update(getDataContainerName(), getCellAttributeMatrixName(), getFeatureIdsArrayName() );
m_FeatureIdsPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<int32_t>, AbstractFilter, int32_t>(this, tempPath, 0, dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_FeatureIdsPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_FeatureIds = m_FeatureIdsPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
//typedef DataArray<unsigned int> XTalStructArrayType;
tempPath.update(getDataContainerName(), getCellEnsembleAttributeMatrixName(), getCrystalStructuresArrayName() );
m_CrystalStructuresPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<uint32_t>, AbstractFilter, uint32_t>(this, tempPath, Ebsd::CrystalStructure::Cubic_High, dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_CrystalStructuresPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_CrystalStructures = m_CrystalStructuresPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void YSChoiAbaqusReader::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
reader->openFilterGroup(this, index);
setDataContainerName(reader->readString("DataContainerName", getDataContainerName() ) );
setCellAttributeMatrixName(reader->readString("CellAttributeMatrixName", getCellAttributeMatrixName() ) );
setCellFeatureAttributeMatrixName(reader->readString("CellFeatureAttributeMatrixName", getCellFeatureAttributeMatrixName() ) );
setCellEnsembleAttributeMatrixName(reader->readString("CellEnsembleAttributeMatrixName", getCellEnsembleAttributeMatrixName() ) );
setCrystalStructuresArrayName(reader->readString("CrystalStructuresArrayName", getCrystalStructuresArrayName() ) );
setFeatureIdsArrayName(reader->readString("FeatureIdsArrayName", getFeatureIdsArrayName() ) );
setSurfaceFeaturesArrayName(reader->readString("SurfaceFeaturesArrayName", getSurfaceFeaturesArrayName() ) );
setCellPhasesArrayName(reader->readString("CellPhasesArrayName", getCellPhasesArrayName() ) );
setAvgQuatsArrayName(reader->readString("AvgQuatsArrayName", getAvgQuatsArrayName() ) );
setQuatsArrayName(reader->readString("QuatsArrayName", getQuatsArrayName() ) );
setCellEulerAnglesArrayName(reader->readString("CellEulerAnglesArrayName", getCellEulerAnglesArrayName() ) );
setInputFile( reader->readString( "InputFile", getInputFile() ) );
setInputFeatureInfoFile( reader->readString( "InputFeatureInfoFile", getInputFeatureInfoFile() ) );
reader->closeFilterGroup();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void YSChoiAbaqusReader::setupFilterParameters()
{
FilterParameterVector parameters;
parameters.push_back(InputFileFilterParameter::New("Input File", "InputFile", getInputFile(), FilterParameter::Parameter));
parameters.push_back(InputFileFilterParameter::New("Input Feature Orientation File", "InputFeatureInfoFile", getInputFeatureInfoFile(), FilterParameter::Parameter));
parameters.push_back(StringFilterParameter::New("Data Container Name", "CellEulerAnglesArrayName", getCellEulerAnglesArrayName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Cell Attribute Matrix Name", "CellAttributeMatrixName", getCellAttributeMatrixName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Cell Feature Attribute Matrix Name", "CellFeatureAttributeMatrixName", getCellFeatureAttributeMatrixName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Cell Ensemble Attribute Matrix Name", "CellEnsembleAttributeMatrixName", getCellEnsembleAttributeMatrixName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Quats", "QuatsArrayName", getQuatsArrayName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("AvgQuats", "AvgQuatsArrayName", getAvgQuatsArrayName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Cell Phases", "CellPhasesArrayName", getCellPhasesArrayName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("SurfaceFeatures", "SurfaceFeaturesArrayName", getSurfaceFeaturesArrayName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("FeatureIds", "FeatureIdsArrayName", getFeatureIdsArrayName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Crystal Structures", "CrystalStructuresArrayName", getCrystalStructuresArrayName(), FilterParameter::CreatedArray));
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void EnsembleInfoReader::setupFilterParameters()
{
FilterParameterVector parameters;
parameters.push_back(InputFileFilterParameter::New("Input Ensemble Info File", "InputFile", getInputFile(), FilterParameter::Parameter, "*.ini *.txt"));
{
DataContainerSelectionFilterParameter::RequirementType req;
parameters.push_back(DataContainerSelectionFilterParameter::New("Data Container", "DataContainerName", getDataContainerName(), FilterParameter::RequiredArray, req));
}
parameters.push_back(SeparatorFilterParameter::New("Ensemble Data", FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Ensemble Attribute Matrix", "CellEnsembleAttributeMatrixName", getCellEnsembleAttributeMatrixName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Crystal Structures", "CrystalStructuresArrayName", getCrystalStructuresArrayName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Phase Types", "PhaseTypesArrayName", getPhaseTypesArrayName(), FilterParameter::CreatedArray));
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int32_t EnsembleInfoReader::readFile()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return getErrorCondition(); }
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getDataContainerName());
AttributeMatrix::Pointer cellensembleAttrMat = m->getAttributeMatrix(getCellEnsembleAttributeMatrixName());
int32_t numphases = 0;
QSettings settings(getInputFile(), QSettings::IniFormat); // The .ini or .txt input file
settings.beginGroup("EnsembleInfo");
numphases = settings.value("Number_Phases").toInt(); // read number of phases from input file
settings.endGroup();
if (0 == numphases) // Either the group name "EnsembleInfo" is incorrect or 0 was entered as the Number_Phases
{
QString ss = QObject::tr("Check the group name EnsembleInfo and that Number_Phases > 0");
setErrorCondition(-10003);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return -1;
}
// Figure out if we are reading contiguous groups
std::vector<bool> visited(numphases + 1, false);
visited[0] = true; //this is DREAM3D's internal, which is always visited.
QVector<size_t> tDims(1, numphases + 1);
cellensembleAttrMat->resizeAttributeArrays(tDims);
updateEnsembleInstancePointers();
for (int32_t index = 1; index < numphases + 1; index++)
{
QString group = QString::number(index);
settings.beginGroup(group);
QString xtalString = settings.value(DREAM3D::StringConstants::CrystalStructure, "MissingCrystalStructure").toString();
QString phaseTypeString = settings.value(DREAM3D::StringConstants::PhaseType, "MissingPhaseType").toString();
// Check to make sure the user has something for each of the Crystal Structure and Phase Type
if (xtalString.compare("MissingCrystalStructure") == 0)
{
QString ss = QObject::tr("Missing crystal structure for phase '%1'").arg(group);
setErrorCondition(-10008);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return -1;
}
if (phaseTypeString.compare("MissingPhaseType") == 0)
{
QString ss = QObject::tr("Missing phase type for phase '%1'").arg(group);
setErrorCondition(-10009);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return -1;
}
// Past that sanity check, so we have values, lets parse them
QStringList values;
values << xtalString << phaseTypeString;
ensembleLookup(values); // Lookup number for the crystal number string and the phase type string read from the file
// Check to see if the Crystal Structure string was valid
if (m_crystruct == Ebsd::CrystalStructure::UnknownCrystalStructure) // The crystal structure name read from the file was not found in the lookup table
{
QString ss = QObject::tr("Incorrect crystal structure name '%1'").arg(xtalString);
setErrorCondition(-10006);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return -1;
}
else
{
m_CrystalStructures[index] = m_crystruct;
}
// now check to see if the Phase type string was valid.
if (m_ptype == DREAM3D::PhaseType::UnknownPhaseType)
{
QString ss = QObject::tr("Incorrect phase type name '%1'").arg(phaseTypeString); // The phase type name read from the file was not found in the lookup table
setErrorCondition(-10007);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return -1;
}
else
{
m_PhaseTypes[index] = m_ptype;
}
visited[index] = true;
// Close up this group
settings.endGroup();
}
//Make sure we visited all the groups.
for(std::vector<bool>::size_type i = 0; i < visited.size(); i++)
{
if(visited[i] == false)
{
QString ss = QObject::tr("Phase '%1' did not have entries in the file. Phase numbering must start at 1 and no phases may be skipped").arg(i); // The phase type name read from the file was not found in the lookup table
setErrorCondition(-10005);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return -1;
}
}
notifyStatusMessage(getHumanLabel(), "Complete");
return 0;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void EnsembleInfoReader::dataCheck()
{
setErrorCondition(0);
DataArrayPath tempPath;
QFileInfo fi(getInputFile());
if (getInputFile().isEmpty() == true)
{
QString ss = QObject::tr("The input file must be set");
setErrorCondition(-387);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
else if (fi.exists() == false)
{
QString ss = QObject::tr("The input file does not exist");
setErrorCondition(-388);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
QString ext = fi.suffix();
if (ext != "ini" && ext != "txt")
{
QString ss = QObject::tr("Incorrect file extension in '%1'. The file extension must be .ini or .txt").arg(getInputFile());
setErrorCondition(-10018);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
if (m_CellEnsembleAttributeMatrixName.isEmpty() == true)
{
QString ss = QObject::tr("Ensemble Attribute Matrix name must be set");
setErrorCondition(-1);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
DataContainer::Pointer m = getDataContainerArray()->getPrereqDataContainer<AbstractFilter>(this, getDataContainerName());
if(getErrorCondition() < 0) { return; }
int32_t numphases = 0;
QSettings settings(getInputFile(), QSettings::IniFormat); // The .ini or .txt input file
settings.beginGroup("EnsembleInfo");
numphases = settings.value("Number_Phases").toInt(); // read number of phases from input file
settings.endGroup();
if (0 == numphases) // Either the group name "EnsembleInfo" is incorrect or 0 was entered as the Number_Phases
{
QString ss = QObject::tr("Check the group name EnsembleInfo and that Number_Phases > 0");
setErrorCondition(-10003);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
QVector<size_t> tDims(1, numphases + 1);
m->createNonPrereqAttributeMatrix<AbstractFilter>(this, getCellEnsembleAttributeMatrixName(), tDims, DREAM3D::AttributeMatrixType::CellEnsemble);
if(getErrorCondition() < 0) { return; }
QVector<size_t> cDims(1, 1);
tempPath.update(getDataContainerName(), getCellEnsembleAttributeMatrixName(), getCrystalStructuresArrayName() );
m_CrystalStructuresPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<uint32_t>, AbstractFilter, uint32_t>(this, tempPath, Ebsd::CrystalStructure::UnknownCrystalStructure, cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_CrystalStructuresPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_CrystalStructures = m_CrystalStructuresPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
tempPath.update(getDataContainerName(), getCellEnsembleAttributeMatrixName(), getPhaseTypesArrayName() );
m_PhaseTypesPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<uint32_t>, AbstractFilter, uint32_t>(this, tempPath, DREAM3D::PhaseType::UnknownPhaseType, cDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */
if( NULL != m_PhaseTypesPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */
{ m_PhaseTypes = m_PhaseTypesPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void EnsembleInfoReader::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
reader->openFilterGroup(this, index);
setDataContainerName(reader->readString("DataContainerName", getDataContainerName() ) );
setCellEnsembleAttributeMatrixName(reader->readString("CellEnsembleAttributeMatrixName", getCellEnsembleAttributeMatrixName() ) );
setPhaseTypesArrayName(reader->readString("PhaseTypesArrayName", getPhaseTypesArrayName() ) );
setCrystalStructuresArrayName(reader->readString("CrystalStructuresArrayName", getCrystalStructuresArrayName() ) );
setInputFile( reader->readString( "InputFile", getInputFile() ) );
reader->closeFilterGroup();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FindFeatureClustering::setupFilterParameters()
{
FilterParameterVector parameters;
parameters.push_back(IntFilterParameter::New("Number of Bins for RDF", "NumberOfBins", getNumberOfBins(), FilterParameter::Parameter));
parameters.push_back(IntFilterParameter::New("Phase Index", "PhaseNumber", getPhaseNumber(), FilterParameter::Parameter));
QStringList linkedProps("BiasedFeaturesArrayPath");
parameters.push_back(LinkedBooleanFilterParameter::New("Remove Biased Features", "RemoveBiasedFeatures", getRemoveBiasedFeatures(), linkedProps, FilterParameter::Parameter));
parameters.push_back(SeparatorFilterParameter::New("Cell Feature Data", FilterParameter::RequiredArray));
{
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateRequirement(SIMPL::TypeNames::Float, 1, SIMPL::AttributeMatrixType::CellFeature, SIMPL::GeometryType::ImageGeometry);
parameters.push_back(DataArraySelectionFilterParameter::New("Equivalent Diameters", "EquivalentDiametersArrayPath", getEquivalentDiametersArrayPath(), FilterParameter::RequiredArray, req));
}
{
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateRequirement(SIMPL::TypeNames::Int32, 1, SIMPL::AttributeMatrixType::CellFeature, SIMPL::GeometryType::ImageGeometry);
parameters.push_back(DataArraySelectionFilterParameter::New("Phases", "FeaturePhasesArrayPath", getFeaturePhasesArrayPath(), FilterParameter::RequiredArray, req));
}
{
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateRequirement(SIMPL::TypeNames::Float, 3, SIMPL::AttributeMatrixType::CellFeature, SIMPL::GeometryType::ImageGeometry);
parameters.push_back(DataArraySelectionFilterParameter::New("Centroids", "CentroidsArrayPath", getCentroidsArrayPath(), FilterParameter::RequiredArray, req));
}
{
DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateRequirement(SIMPL::TypeNames::Bool, 1, SIMPL::AttributeMatrixType::CellFeature, SIMPL::GeometryType::ImageGeometry);
parameters.push_back(DataArraySelectionFilterParameter::New("Biased Features", "BiasedFeaturesArrayPath", getBiasedFeaturesArrayPath(), FilterParameter::RequiredArray, req));
}
parameters.push_back(SeparatorFilterParameter::New("Cell Ensemble Data", FilterParameter::RequiredArray));
{
AttributeMatrixSelectionFilterParameter::RequirementType amReq = AttributeMatrixSelectionFilterParameter::CreateRequirement(SIMPL::AttributeMatrixType::CellEnsemble, SIMPL::GeometryType::ImageGeometry);
parameters.push_back(AttributeMatrixSelectionFilterParameter::New("Cell Ensemble Attribute Matrix", "CellEnsembleAttributeMatrixName", getCellEnsembleAttributeMatrixName(), FilterParameter::RequiredArray, amReq));
}
parameters.push_back(SeparatorFilterParameter::New("Cell Feature Data", FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Clustering List", "ClusteringListArrayName", getClusteringListArrayName(), FilterParameter::CreatedArray));
parameters.push_back(SeparatorFilterParameter::New("Cell Ensemble Data", FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Radial Distribution Function", "NewEnsembleArrayArrayName", getNewEnsembleArrayArrayName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Max and Min Separation Distances", "MaxMinArrayName", getMaxMinArrayName(), FilterParameter::CreatedArray));
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FindFeatureClustering::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
reader->openFilterGroup(this, index);
setCellEnsembleAttributeMatrixName(reader->readDataArrayPath("CellEnsembleAttributeMatrixName", getCellEnsembleAttributeMatrixName() ) );
setNumberOfBins( reader->readValue( "NumberOfBins", getNumberOfBins() ) );
setNewEnsembleArrayArrayName(reader->readString("NewEnsembleArrayArrayName", getNewEnsembleArrayArrayName() ) );
setMaxMinArrayName(reader->readString("MaxMinArrayName", getMaxMinArrayName() ) );
setClusteringListArrayName(reader->readString("ClusteringListArrayName", getClusteringListArrayName() ) );
setCentroidsArrayPath(reader->readDataArrayPath("CentroidsArrayPath", getCentroidsArrayPath() ) );
setFeaturePhasesArrayPath(reader->readDataArrayPath("FeaturePhasesArrayPath", getFeaturePhasesArrayPath() ) );
setEquivalentDiametersArrayPath(reader->readDataArrayPath("EquivalentDiametersArrayPath", getEquivalentDiametersArrayPath() ) );
setPhaseNumber( reader->readValue("PhaseNumber", getPhaseNumber() ) );
setBiasedFeaturesArrayPath(reader->readDataArrayPath("BiasedFeaturesArrayPath", getBiasedFeaturesArrayPath() ) );
setRemoveBiasedFeatures( reader->readValue( "RemoveBiasedFeatures", getRemoveBiasedFeatures() ) );
reader->closeFilterGroup();
}