// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ChangeResolution::preflight()
{
setInPreflight(true);
emit preflightAboutToExecute();
emit updateFilterParameters(this);
dataCheck();
if (getErrorCondition() < 0)
{
emit preflightExecuted();
setInPreflight(false);
return;
}
DataContainer::Pointer m;
if (m_SaveAsNewDataContainer == false)
{
m = getDataContainerArray()->getDataContainer(getCellAttributeMatrixPath().getDataContainerName());
}
else
{
m = getDataContainerArray()->getDataContainer(getNewDataContainerName());
}
size_t dims[3] = { 0, 0, 0 };
m->getGeometryAs<ImageGeom>()->getDimensions(dims);
float sizex = (dims[0]) * m->getGeometryAs<ImageGeom>()->getXRes();
float sizey = (dims[1]) * m->getGeometryAs<ImageGeom>()->getYRes();
float sizez = (dims[2]) * m->getGeometryAs<ImageGeom>()->getZRes();
size_t m_XP = size_t(sizex / m_Resolution.x);
size_t m_YP = size_t(sizey / m_Resolution.y);
size_t m_ZP = size_t(sizez / m_Resolution.z);
if (m_XP == 0) { m_XP = 1; }
if (m_YP == 0) { m_YP = 1; }
if (m_ZP == 0) { m_ZP = 1; }
m->getGeometryAs<ImageGeom>()->setDimensions(m_XP, m_YP, m_ZP);
m->getGeometryAs<ImageGeom>()->setResolution(m_Resolution.x, m_Resolution.y, m_Resolution.z);
QVector<size_t> tDims(3, 0);
tDims[0] = m_XP;
tDims[1] = m_YP;
tDims[2] = m_ZP;
m->getAttributeMatrix(getCellAttributeMatrixPath().getAttributeMatrixName())->setTupleDimensions(tDims);
if (m_RenumberFeatures == true)
{
AttributeMatrix::Pointer cellFeatureAttrMat = m->getAttributeMatrix(getCellFeatureAttributeMatrixPath().getAttributeMatrixName());
QVector<bool> activeObjects(cellFeatureAttrMat->getNumTuples(), true);
cellFeatureAttrMat->removeInactiveObjects(activeObjects, m_FeatureIdsPtr.lock());
}
emit preflightExecuted();
setInPreflight(false);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void CombineAttributeMatrices::execute()
{
setErrorCondition(0);
dataCheck();
if (getErrorCondition() < 0) { return; }
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getFirstAttributeMatrixPath().getDataContainerName());
AttributeMatrix::Pointer firstAttrMat = m->getAttributeMatrix(getFirstAttributeMatrixPath().getAttributeMatrixName());
AttributeMatrix::Pointer secondAttrMat = m->getAttributeMatrix(getSecondAttributeMatrixPath().getAttributeMatrixName());
AttributeMatrix::Pointer combinedAttrMat = m->getAttributeMatrix(getCombinedAttributeMatrixName());
size_t firstAttrMatNumTuples = firstAttrMat->getNumTuples();
size_t totalTuples1 = m_SecondIndexPtr.lock()->getNumberOfTuples();
size_t totalTuples2 = m_SecondIndexPtr.lock()->getNumberOfTuples();
for (size_t i = 0; i < totalTuples1; i++)
{
if (m_FirstIndex > 0) { m_NewIndex[i] = m_FirstIndex[i]; }
}
for (size_t i = 0; i < totalTuples2; i++)
{
//subtract 1 from the index plus numTuples because the second index should be shifted to account for the zeroth tuple (all AMs above element start at tuple 1)
if (m_SecondIndex[i] > 0 && m_NewIndex[i] == 0) m_NewIndex[i] = m_SecondIndex[i] + firstAttrMatNumTuples - 1;
else if (m_SecondIndex[i] > 0 && m_NewIndex[i] != 0)
{
QString ss = QObject::tr("When copying the indices, the indices of the two attribute matrices overlapped. The index of the first attribute matrix was kept.");
notifyWarningMessage(getHumanLabel(), ss, -111);
}
}
QList<QString> arrayNames = firstAttrMat->getAttributeArrayNames();
size_t location = 0;
for (QList<QString>::iterator iter = arrayNames.begin(); iter != arrayNames.end(); ++iter)
{
IDataArray::Pointer fromDataArray = firstAttrMat->getAttributeArray(*iter);
IDataArray::Pointer toDataArray = combinedAttrMat->getAttributeArray(*iter);
EXECUTE_FUNCTION_TEMPLATE(this, copyData, fromDataArray, fromDataArray, toDataArray, location);
}
arrayNames.clear();
arrayNames = secondAttrMat->getAttributeArrayNames();
location = firstAttrMatNumTuples;
for (QList<QString>::iterator iter = arrayNames.begin(); iter != arrayNames.end(); ++iter)
{
IDataArray::Pointer fromDataArray = secondAttrMat->getAttributeArray(*iter);
IDataArray::Pointer toDataArray = combinedAttrMat->getAttributeArray(*iter);
EXECUTE_FUNCTION_TEMPLATE(this, copyData, fromDataArray, fromDataArray, toDataArray, location);
}
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void SineParamsSegmentFeatures::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getDataContainerName());
QVector<size_t> tDims(1, 1);
m->getAttributeMatrix(getCellFeatureAttributeMatrixName())->resizeAttributeArrays(tDims);
// This runs a subfilter
int64_t totalPoints = m_FeatureIdsPtr.lock()->getNumberOfTuples();
// Tell the user we are starting the filter
notifyStatusMessage(getMessagePrefix(), getHumanLabel(), "Starting");
//Convert user defined tolerance to radians.
//angleTolerance = m_AngleTolerance * SIMPLib::Constants::k_Pi / 180.0f;
for(int64_t i = 0; i < totalPoints; i++)
{
m_FeatureIds[i] = 0;
}
// Generate the random voxel indices that will be used for the seed points to start a new grain growth/agglomeration
const size_t rangeMin = 0;
const size_t rangeMax = totalPoints - 1;
initializeVoxelSeedGenerator(rangeMin, rangeMax);
SegmentFeatures::execute();
size_t totalFeatures = m->getAttributeMatrix(getCellFeatureAttributeMatrixName())->getNumTuples();
if (totalFeatures < 2)
{
setErrorCondition(-87000);
notifyErrorMessage(getHumanLabel(), "The number of Features was 0 or 1 which means no features were detected. Is a threshold value set to high?", getErrorCondition());
return;
}
// By default we randomize grains
if (true == m_RandomizeFeatureIds)
{
randomizeFeatureIds(totalPoints, totalFeatures);
}
// If there is an error set this to something negative and also set a message
notifyStatusMessage(getHumanLabel(), "Completed");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ConvertData::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(m_SelectedCellArrayPath.getDataContainerName());
IDataArray::Pointer iArray = m->getAttributeMatrix(m_SelectedCellArrayPath.getAttributeMatrixName())->getAttributeArray(m_SelectedCellArrayPath.getDataArrayName());
bool completed = false;
CHECK_AND_CONVERT(UInt8ArrayType, m, m_ScalarType, iArray, m_SelectedCellArrayPath.getAttributeMatrixName(), m_OutputArrayName)
CHECK_AND_CONVERT(Int8ArrayType, m, m_ScalarType, iArray, m_SelectedCellArrayPath.getAttributeMatrixName(), m_OutputArrayName)
CHECK_AND_CONVERT(UInt16ArrayType, m, m_ScalarType, iArray, m_SelectedCellArrayPath.getAttributeMatrixName(), m_OutputArrayName)
CHECK_AND_CONVERT(Int16ArrayType, m, m_ScalarType, iArray, m_SelectedCellArrayPath.getAttributeMatrixName(), m_OutputArrayName)
CHECK_AND_CONVERT(UInt32ArrayType, m, m_ScalarType, iArray, m_SelectedCellArrayPath.getAttributeMatrixName(), m_OutputArrayName)
CHECK_AND_CONVERT(Int32ArrayType, m, m_ScalarType, iArray, m_SelectedCellArrayPath.getAttributeMatrixName(), m_OutputArrayName)
CHECK_AND_CONVERT(UInt64ArrayType, m, m_ScalarType, iArray, m_SelectedCellArrayPath.getAttributeMatrixName(), m_OutputArrayName)
CHECK_AND_CONVERT(Int64ArrayType, m, m_ScalarType, iArray, m_SelectedCellArrayPath.getAttributeMatrixName(), m_OutputArrayName)
CHECK_AND_CONVERT(FloatArrayType, m, m_ScalarType, iArray, m_SelectedCellArrayPath.getAttributeMatrixName(), m_OutputArrayName)
CHECK_AND_CONVERT(DoubleArrayType, m, m_ScalarType, iArray, m_SelectedCellArrayPath.getAttributeMatrixName(), m_OutputArrayName)
CHECK_AND_CONVERT(BoolArrayType, m, m_ScalarType, iArray, m_SelectedCellArrayPath.getAttributeMatrixName(), m_OutputArrayName)
/* Let the GUI know we are done with this filter */
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int64_t EBSDSegmentFeatures::getSeed(int32_t gnum, int64_t nextSeed)
{
setErrorCondition(0);
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getDataContainerName());
size_t totalPoints = m_FeatureIdsPtr.lock()->getNumberOfTuples();
int64_t seed = -1;
// start with the next voxel after the last seed
size_t randpoint = static_cast<size_t>(nextSeed);
while (seed == -1 && randpoint < totalPoints)
{
if (m_FeatureIds[randpoint] == 0) // If the GrainId of the voxel is ZERO then we can use this as a seed point
{
if ((m_UseGoodVoxels == false || m_GoodVoxels[randpoint] == true) && m_CellPhases[randpoint] > 0)
{
seed = randpoint;
}
else { randpoint += 1; }
}
else { randpoint += 1; }
}
if (seed >= 0)
{
m_FeatureIds[seed] = gnum;
QVector<size_t> tDims(1, gnum + 1);
m->getAttributeMatrix(getCellFeatureAttributeMatrixName())->resizeAttributeArrays(tDims);
updateFeatureInstancePointers();
}
return seed;
}
void writePointScalarData(DataContainer::Pointer dc, const QString& vertexAttributeMatrixName, const QString& dataName, const QString& dataType,
bool writeBinaryData, FILE* vtkFile, int nT)
{
IDataArray::Pointer data = dc->getAttributeMatrix(vertexAttributeMatrixName)->getAttributeArray(dataName);
QString ss;
if (NULL != data.get())
{
T* m = reinterpret_cast<T*>(data->getVoidPointer(0));
fprintf(vtkFile, "\n");
fprintf(vtkFile, "SCALARS %s %s\n", dataName.toLatin1().data(), dataType.toLatin1().data());
fprintf(vtkFile, "LOOKUP_TABLE default\n");
for(int i = 0; i < nT; ++i)
{
T swapped = 0x00;
if(writeBinaryData == true)
{
swapped = static_cast<T>(m[i]);
SIMPLib::Endian::FromSystemToBig::convert(swapped);
fwrite(&swapped, sizeof(T), 1, vtkFile);
}
else
{
ss = QString::number(m[i]) + " ";
fprintf(vtkFile, "%s ", ss.toLatin1().data());
//if (i%50 == 0)
{ fprintf(vtkFile, "\n"); }
}
}
}
}
/**
*
* @param FileName
* @param data
* @param nx X Dimension
* @param ny Y Dimension
* @param nz Z Dimension
*/
int ReadPHFile(QString FileName, QVector<int>& data, int& nx, int& ny, int& nz)
{
DataContainerArray::Pointer dca = DataContainerArray::New();
DataContainer::Pointer m = DataContainer::New(); /* FIXME: What Geometry do we need? */
dca->pushBack(m);
FilterManager::Pointer fm = FilterManager::Instance();
AbstractFilter::Pointer reader = fm->getFactoryForFilter("PhReader")->create();
reader->setDataContainerArray(dca);
bool propWasSet = reader->setProperty("InputFile", FileName);
if(propWasSet == false)
{
}
reader->execute();
if (reader->getErrorCondition() < 0)
{
qDebug() << "Error Reading the Ph File '" << FileName << "' Error Code:" << reader->getErrorCondition();
return -1;
}
Int32ArrayType* featureIds = Int32ArrayType::SafePointerDownCast(m->getAttributeMatrix(DREAM3D::Defaults::CellAttributeMatrixName)->getAttributeArray(DREAM3D::CellData::FeatureIds).get());
size_t count = featureIds->getNumberOfTuples();
data.resize(count);
for(size_t i = 0; i < count; ++i)
{
data[i] = featureIds->getValue(i);
}
return 0;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void LinkFeatureMapToElementArray::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getSelectedCellArrayPath().getDataContainerName());
size_t totalPoints = m_SelectedCellDataPtr.lock()->getNumberOfTuples();
int32_t maxIndex = 0;
std::vector<bool> active;
for (size_t i = 0; i < totalPoints; i++)
{
int32_t index = m_SelectedCellData[i];
if ((index + 1) > maxIndex)
{
active.resize(index + 1);
active[index] = true;
maxIndex = index + 1;
}
}
QVector<size_t> tDims(1, maxIndex);
m->getAttributeMatrix(getCellFeatureAttributeMatrixName())->resizeAttributeArrays(tDims);
updateFeatureInstancePointers();
for (int32_t i = 0; i < maxIndex; i++)
{
m_Active[i] = active[i];
}
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int64_t EBSDSegmentFeatures::getSeed(int32_t gnum)
{
setErrorCondition(0);
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getDataContainerName());
size_t totalPoints = m_FeatureIdsPtr.lock()->getNumberOfTuples();
int64_t seed = -1;
Generator& numberGenerator = *m_NumberGenerator;
while (seed == -1 && m_TotalRandomNumbersGenerated < totalPoints)
{
// Get the next voxel index in the precomputed list of voxel seeds
int64_t randpoint = numberGenerator();
m_TotalRandomNumbersGenerated++; // Increment this counter
if (m_FeatureIds[randpoint] == 0) // If the GrainId of the voxel is ZERO then we can use this as a seed point
{
if ((m_UseGoodVoxels == false || m_GoodVoxels[randpoint] == true) && m_CellPhases[randpoint] > 0)
{
seed = randpoint;
}
}
}
if (seed >= 0)
{
m_FeatureIds[seed] = gnum;
QVector<size_t> tDims(1, gnum + 1);
m->getAttributeMatrix(getCellFeatureAttributeMatrixName())->resizeAttributeArrays(tDims);
updateFeatureInstancePointers();
}
return seed;
}
void writeCellScalarData(DataContainer::Pointer dc, const QString& faceAttributeMatrixName, const QString& dataName, const QString& dataType,
bool writeBinaryData, FILE* vtkFile, QMap<int32_t, int32_t>& featureIds, int32_t* m_SurfaceMeshFaceLabels)
{
TriangleGeom::Pointer triangleGeom = dc->getGeometryAs<TriangleGeom>();
int64_t numTriangles = triangleGeom->getNumberOfTris();
IDataArray::Pointer data = dc->getAttributeMatrix(faceAttributeMatrixName)->getAttributeArray(dataName);
QString ss;
if (NULL != data.get())
{
int32_t totalCellsWritten = 0;
T* m = reinterpret_cast<T*>(data->getVoidPointer(0));
fprintf(vtkFile, "\n");
fprintf(vtkFile, "SCALARS %s %s 1\n", dataName.toLatin1().data(), dataType.toLatin1().data());
fprintf(vtkFile, "LOOKUP_TABLE default\n");
// Loop over all the features
for(QMap<int32_t, int32_t>::iterator featureIter = featureIds.begin(); featureIter != featureIds.end(); ++featureIter)
{
int32_t gid = featureIter.key(); // The current Feature Id
size_t size = featureIter.value(); // The number of triangles for this feature id
std::vector<T> buffer(size, 0);
totalCellsWritten += size;
size_t index = 0;
for (int j = 0; j < numTriangles; j++)
{
if (m_SurfaceMeshFaceLabels[j * 2] != gid && m_SurfaceMeshFaceLabels[j * 2 + 1] != gid) { continue; }
// Get the data
T s0 = static_cast<T>(m[j]);
if (m_SurfaceMeshFaceLabels[j * 2 + 1] == gid)
{ s0 = s0 * -1; }
// Write the values to the buffer after an Endian swap.
if(writeBinaryData == true)
{
SIMPLib::Endian::FromSystemToBig::convert(s0);
buffer[index] = s0;
++index;
}
else
{
ss = QString::number(s0);
fprintf(vtkFile, "%s\n", ss.toLatin1().data());
}
}
// Write the Buffer
if(writeBinaryData == true)
{
fwrite(&(buffer.front()), sizeof(T), size, vtkFile);
}
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void VectorSegmentFeatures::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getDataContainerName());
QVector<size_t> tDims(1, 1);
m->getAttributeMatrix(getCellFeatureAttributeMatrixName())->resizeAttributeArrays(tDims);
updateFeatureInstancePointers();
int64_t totalPoints = static_cast<int64_t>(m_FeatureIdsPtr.lock()->getNumberOfTuples());
m_BeenPickedPtr = BoolArrayType::CreateArray(totalPoints, "BeenPicked INTERNAL ARRAY ONLY");
m_BeenPickedPtr->initializeWithValue(0);
m_BeenPicked = m_BeenPickedPtr->getPointer(0);
// Convert user defined tolerance to radians.
angleTolerance = m_AngleTolerance * SIMPLib::Constants::k_Pi / 180.0f;
// Generate the random voxel indices that will be used for the seed points to start a new grain growth/agglomeration
const int64_t rangeMin = 0;
const int64_t rangeMax = totalPoints - 1;
initializeVoxelSeedGenerator(rangeMin, rangeMax);
SegmentFeatures::execute();
int32_t totalFeatures = static_cast<int32_t>(m->getAttributeMatrix(getCellFeatureAttributeMatrixName())->getNumTuples());
if (totalFeatures < 2)
{
setErrorCondition(-87000);
notifyErrorMessage(getHumanLabel(), "The number of Features was 0 or 1 which means no Features were detected. A threshold value may be set too high", getErrorCondition());
return;
}
// By default we randomize grains
if (true == m_RandomizeFeatureIds)
{
randomizeFeatureIds(totalPoints, totalFeatures);
}
// If there is an error set this to something negative and also set a message
notifyStatusMessage(getHumanLabel(), "Completed");
}
void writeCellNormalData(DataContainer::Pointer dc, const QString& faceAttributeMatrixName, const QString& dataName, const QString& dataType,
bool writeBinaryData, bool writeConformalMesh,
FILE* vtkFile, int nT)
{
IDataArray::Pointer data = dc->getAttributeMatrix(faceAttributeMatrixName)->getAttributeArray(dataName);
QString buf;
QTextStream ss(&buf);
if (NULL != data.get())
{
T* m = reinterpret_cast<T*>(data->getVoidPointer(0));
fprintf(vtkFile, "\n");
fprintf(vtkFile, "NORMALS %s %s\n", dataName.toLatin1().data(), dataType.toLatin1().data());
for(int i = 0; i < nT; ++i)
{
T s0 = 0x00;
T s1 = 0x00;
T s2 = 0x00;
if(writeBinaryData == true)
{
s0 = static_cast<T>(m[i * 3 + 0]);
s1 = static_cast<T>(m[i * 3 + 1]);
s2 = static_cast<T>(m[i * 3 + 2]);
SIMPLib::Endian::FromSystemToBig::convert(s0);
SIMPLib::Endian::FromSystemToBig::convert(s1);
SIMPLib::Endian::FromSystemToBig::convert(s2);
fwrite(&s0, sizeof(T), 1, vtkFile);
fwrite(&s1, sizeof(T), 1, vtkFile);
fwrite(&s2, sizeof(T), 1, vtkFile);
if(false == writeConformalMesh)
{
s0 = static_cast<T>(m[i * 3 + 0]) * -1.0;
s1 = static_cast<T>(m[i * 3 + 1]) * -1.0;
s2 = static_cast<T>(m[i * 3 + 2]) * -1.0;
SIMPLib::Endian::FromSystemToBig::convert(s0);
SIMPLib::Endian::FromSystemToBig::convert(s1);
SIMPLib::Endian::FromSystemToBig::convert(s2);
fwrite(&s0, sizeof(T), 1, vtkFile);
fwrite(&s1, sizeof(T), 1, vtkFile);
fwrite(&s2, sizeof(T), 1, vtkFile);
}
}
else
{
ss << m[i * 3 + 0] << " " << m[i * 3 + 1] << " " << m[i * 3 + 2] << " ";
if(false == writeConformalMesh)
{
ss << -1.0 * m[i * 3 + 0] << " " << -1.0 * m[i * 3 + 1] << " " << -1.0 * m[i * 3 + 2] << " ";
}
fprintf(vtkFile, "%s ", buf.toLatin1().data());
buf.clear();
if (i % 50 == 0) { fprintf(vtkFile, "\n"); }
}
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void InitializeData::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(m_CellAttributeMatrixPath.getDataContainerName());
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]), };
int index;
QString attrMatName = m_CellAttributeMatrixPath.getAttributeMatrixName();
QList<QString> voxelArrayNames = m->getAttributeMatrix(attrMatName)->getAttributeArrayNames();
for (int32_t k = m_ZMin; k < m_ZMax + 1; k++)
{
for (int32_t j = m_YMin; j < m_YMax + 1; j++)
{
for (int32_t i = m_XMin; i < m_XMax + 1; i++)
{
index = (k * dims[0] * dims[1]) + (j * dims[0]) + i;
for (QList<QString>::iterator iter = voxelArrayNames.begin(); iter != voxelArrayNames.end(); ++iter)
{
IDataArray::Pointer p = m->getAttributeMatrix(attrMatName)->getAttributeArray(*iter);
p->initializeTuple(index, 0);
}
}
}
}
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void AddBadData::add_noise()
{
notifyStatusMessage(getHumanLabel(), "Adding Noise");
DREAM3D_RANDOMNG_NEW()
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getGBEuclideanDistancesArrayPath().getDataContainerName());
QString attMatName = getGBEuclideanDistancesArrayPath().getAttributeMatrixName();
QList<QString> voxelArrayNames = m->getAttributeMatrix(attMatName)->getAttributeArrayNames();
float random = 0.0f;
size_t totalPoints = m->getGeometryAs<ImageGeom>()->getNumberOfElements();
for (size_t i = 0; i < totalPoints; ++i)
{
if (m_BoundaryNoise == true && m_GBEuclideanDistances[i] < 1)
{
random = static_cast<float>( rg.genrand_res53() );
if (random < m_BoundaryVolFraction)
{
for (QList<QString>::iterator iter = voxelArrayNames.begin(); iter != voxelArrayNames.end(); ++iter)
{
IDataArray::Pointer p = m->getAttributeMatrix(attMatName)->getAttributeArray(*iter);
p->initializeTuple(i, 0);
}
}
}
if (m_PoissonNoise == true)
{
random = static_cast<float>( rg.genrand_res53() );
if (random < m_PoissonVolFraction)
{
for (QList<QString>::iterator iter = voxelArrayNames.begin(); iter != voxelArrayNames.end(); ++iter)
{
IDataArray::Pointer p = m->getAttributeMatrix(attMatName)->getAttributeArray(*iter);
p->initializeTuple(i, 0);
}
}
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ClearDataMask::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(m_MaskArrayPath.getDataContainerName());
size_t totalPoints = m_MaskPtr.lock()->getNumberOfTuples();
// get list of array names
QString attrMatName = m_MaskArrayPath.getAttributeMatrixName();
QList<QString> voxelArrayNames = m->getAttributeMatrix(attrMatName)->getAttributeArrayNames();
// convert to list of pointers
std::vector<IDataArray::Pointer> arrayList;
for (QList<QString>::iterator iter = voxelArrayNames.begin(); iter != voxelArrayNames.end(); ++iter)
{
IDataArray::Pointer p = m->getAttributeMatrix(attrMatName)->getAttributeArray(*iter);
arrayList.push_back(p);
}
int32_t numArrays = arrayList.size();
for (size_t i = 0; i < totalPoints; i++)
{
if (!m_Mask[i])
{
for (int32_t j = 0; j < numArrays; j++)
{
arrayList[j]->initializeTuple(i, 0);
}
}
}
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void MinNeighbors::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
// If running on a single phase, validate that the user has not entered a phase number
// that is not in the system ; the filter would not crash otherwise, but the user should
// be notified of unanticipated behavior ; this cannot be done in the dataCheck since
// we don't have acces to the data yet
if (m_ApplyToSinglePhase == true)
{
AttributeMatrix::Pointer featAttrMat = getDataContainerArray()->getDataContainer(getFeaturePhasesArrayPath().getDataContainerName())->getAttributeMatrix(getFeaturePhasesArrayPath().getAttributeMatrixName());
size_t numFeatures = featAttrMat->getNumTuples();
bool unavailablePhase = true;
for (size_t i = 0; i < numFeatures; i++)
{
if (m_FeaturePhases[i] == m_PhaseNumber)
{
unavailablePhase = false;
break;
}
}
if (unavailablePhase == true)
{
QString ss = QObject::tr("The phase number (%1) is not available in the supplied Feature phases array with path (%2)").arg(m_PhaseNumber).arg(m_FeaturePhasesArrayPath.serialize());
setErrorCondition(-5555);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
}
QVector<bool> activeObjects = merge_containedfeatures();
if(getErrorCondition() < 0) { return; }
assign_badpoints();
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(m_NumNeighborsArrayPath.getDataContainerName());
AttributeMatrix::Pointer cellFeatureAttrMat = m->getAttributeMatrix(m_NumNeighborsArrayPath.getAttributeMatrixName());
cellFeatureAttrMat->removeInactiveObjects(activeObjects, m_FeatureIdsPtr.lock());
// If there is an error set this to something negative and also set a message
notifyStatusMessage(getHumanLabel(), "Complete");
}
void writeCellVectorData(DataContainer::Pointer dc, const QString& faceAttributeMatrixName, const QString& dataName, const QString& dataType,
bool writeBinaryData, const QString& vtkAttributeType,
FILE* vtkFile, QMap<int32_t, int32_t>& featureIds)
{
TriangleGeom::Pointer triangleGeom = dc->getGeometryAs<TriangleGeom>();
int64_t numTriangles = triangleGeom->getNumberOfTris();
IDataArray::Pointer data = dc->getAttributeMatrix(faceAttributeMatrixName)->getAttributeArray(dataName);
QString ss;
if (NULL != data.get())
{
T* m = reinterpret_cast<T*>(data->getVoidPointer(0));
fprintf(vtkFile, "\n");
fprintf(vtkFile, "%s %s %s\n", vtkAttributeType.toLatin1().data(), dataName.toLatin1().data(), dataType.toLatin1().data());
for(int i = 0; i < numTriangles; ++i)
{
T s0 = 0x00;
T s1 = 0x00;
T s2 = 0x00;
if(writeBinaryData == true)
{
s0 = static_cast<T>(m[i * 3 + 0]);
s1 = static_cast<T>(m[i * 3 + 1]);
s2 = static_cast<T>(m[i * 3 + 2]);
SIMPLib::Endian::FromSystemToBig::convert(s0);
SIMPLib::Endian::FromSystemToBig::convert(s1);
SIMPLib::Endian::FromSystemToBig::convert(s2);
fwrite(&s0, sizeof(T), 1, vtkFile);
fwrite(&s1, sizeof(T), 1, vtkFile);
fwrite(&s2, sizeof(T), 1, vtkFile);
}
else
{
ss << m[i * 3 + 0] << " " << m[i * 3 + 1] << " " << m[i * 3 + 2] << " ";
fprintf(vtkFile, "%s ", ss.toLatin1().data());
if (i % 25 == 0) { fprintf(vtkFile, "\n"); }
}
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void InitializeSyntheticVolume::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getDataContainerName());
AttributeMatrix::Pointer cellAttrMat = m->getAttributeMatrix(getCellAttributeMatrixName());
// Resize the Cell AttributeMatrix to have the correct Tuple Dimensions.
QVector<size_t> tDims(3, 0);
tDims[0] = m->getGeometryAs<ImageGeom>()->getXPoints();
tDims[1] = m->getGeometryAs<ImageGeom>()->getYPoints();
tDims[2] = m->getGeometryAs<ImageGeom>()->getZPoints();
cellAttrMat->resizeAttributeArrays(tDims);
// If there is an error set this to something negative and also set a message
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void InsertAtoms::assign_points(QVector<VertexGeom::Pointer> points, QVector<BoolArrayType::Pointer> inFeature)
{
size_t count = 0;
int32_t numFeatures = points.size();
for (int32_t i = 0; i < numFeatures; i++)
{
int64_t numPoints = points[i]->getNumberOfVertices();
bool* inside = inFeature[i]->getPointer(0);
for (int64_t j = 0; j < numPoints; j++)
{
if (inside[j] == true) { count++; }
}
}
DataContainer::Pointer v = getDataContainerArray()->getDataContainer(getVertexDataContainerName());
VertexGeom::Pointer vertices = VertexGeom::CreateGeometry(count, DREAM3D::VertexData::SurfaceMeshNodes);
AttributeMatrix::Pointer vertexAttrMat = v->getAttributeMatrix(getVertexAttributeMatrixName());
QVector<size_t> tDims(1, count);
vertexAttrMat->resizeAttributeArrays(tDims);
updateVertexInstancePointers();
count = 0;
float coords[3] = { 0.0f, 0.0f, 0.0f };
for (int32_t i = 0; i < numFeatures; i++)
{
int64_t numPoints = points[i]->getNumberOfVertices();
bool* inside = inFeature[i]->getPointer(0);
for (int64_t j = 0; j < numPoints; j++)
{
if (inside[j] == true)
{
coords[0] = points[i]->getVertexPointer(j)[0];
coords[1] = points[i]->getVertexPointer(j)[1];
coords[2] = points[i]->getVertexPointer(j)[2];
vertices->setCoords(count, coords);
m_AtomFeatureLabels[count] = i;
count++;
}
}
}
v->setGeometry(vertices);
}
void writeCellScalarData(DataContainer::Pointer dc, const QString& faceAttributeMatrixName, const QString& dataName, const QString& dataType,
bool writeBinaryData, bool writeConformalMesh, FILE* vtkFile, int nT)
{
// Write the Feature Face ID Data to the file
IDataArray::Pointer data = dc->getAttributeMatrix(faceAttributeMatrixName)->getAttributeArray(dataName);
QString buf;
QTextStream ss(&buf);
if (NULL != data.get())
{
T* m = reinterpret_cast<T*>(data->getVoidPointer(0));
fprintf(vtkFile, "\n");
fprintf(vtkFile, "SCALARS %s %s 1\n", dataName.toLatin1().data(), dataType.toLatin1().data());
fprintf(vtkFile, "LOOKUP_TABLE default\n");
for(int i = 0; i < nT; ++i)
{
T swapped = 0x00;
if(writeBinaryData == true)
{
swapped = static_cast<T>(m[i]);
SIMPLib::Endian::FromSystemToBig::convert(swapped);
fwrite(&swapped, sizeof(T), 1, vtkFile);
if(false == writeConformalMesh)
{
fwrite(&swapped, sizeof(T), 1, vtkFile);
}
}
else
{
ss << m[i] << " ";
if(false == writeConformalMesh)
{
ss << m[i] << " ";
}
fprintf(vtkFile, "%s", buf.toLatin1().data());
buf.clear();
if (i % 50 == 0) { fprintf(vtkFile, "\n"); }
}
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void EBSDSegmentFeatures::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getDataContainerName());
int64_t totalPoints = static_cast<int64_t>(m_FeatureIdsPtr.lock()->getNumberOfTuples());
QVector<size_t> tDims(1, 1);
m->getAttributeMatrix(getCellFeatureAttributeMatrixName())->resizeAttributeArrays(tDims);
updateFeatureInstancePointers();
// Convert user defined tolerance to radians.
misoTolerance = m_MisorientationTolerance * DREAM3D::Constants::k_Pi / 180.0f;
// Generate the random voxel indices that will be used for the seed points to start a new grain growth/agglomeration
const int64_t rangeMin = 0;
const int64_t rangeMax = totalPoints - 1;
initializeVoxelSeedGenerator(rangeMin, rangeMax);
SegmentFeatures::execute();
int64_t totalFeatures = static_cast<int64_t>(m_ActivePtr.lock()->getNumberOfTuples());
if (totalFeatures < 2)
{
setErrorCondition(-87000);
notifyErrorMessage(getHumanLabel(), "The number of Features was 0 or 1 which means no Features were detected. A threshold value may be set too high", getErrorCondition());
return;
}
// By default we randomize grains
if (true == getRandomizeFeatureIds())
{
totalPoints = static_cast<int64_t>(m->getGeometryAs<ImageGeom>()->getNumberOfElements());
randomizeFeatureIds(totalPoints, totalFeatures);
}
// If there is an error set this to something negative and also set a message
notifyStatusMessage(getHumanLabel(), "Complete");
}
void writePointVectorData(DataContainer::Pointer dc, const QString& vertexAttributeMatrixName, const QString& dataName, const QString& dataType,
bool writeBinaryData, bool writeConformalMesh, const QString& vtkAttributeType,
FILE* vtkFile, int nT)
{
IDataArray::Pointer data = dc->getAttributeMatrix(vertexAttributeMatrixName)->getAttributeArray(dataName);
QString ss;
if (NULL != data.get())
{
T* m = reinterpret_cast<T*>(data->getVoidPointer(0));
fprintf(vtkFile, "\n");
fprintf(vtkFile, "%s %s %s\n", vtkAttributeType.toLatin1().data(), dataName.toLatin1().data(), dataType.toLatin1().data());
for(int i = 0; i < nT; ++i)
{
T s0 = 0x00;
T s1 = 0x00;
T s2 = 0x00;
if(writeBinaryData == true)
{
s0 = static_cast<T>(m[i * 3 + 0]);
s1 = static_cast<T>(m[i * 3 + 1]);
s2 = static_cast<T>(m[i * 3 + 2]);
SIMPLib::Endian::FromSystemToBig::convert(s0);
SIMPLib::Endian::FromSystemToBig::convert(s1);
SIMPLib::Endian::FromSystemToBig::convert(s2);
fwrite(&s0, sizeof(T), 1, vtkFile);
fwrite(&s1, sizeof(T), 1, vtkFile);
fwrite(&s1, sizeof(T), 1, vtkFile);
}
else
{
ss = QString::number(m[i * 3 + 0]) + " " + QString::number(m[i * 3 + 1]) + " " + QString::number(m[i * 3 + 2]) + " ";
fprintf(vtkFile, "%s ", ss.toLatin1().data());
//if (i%50 == 0)
{ fprintf(vtkFile, "\n"); }
}
}
}
}
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 GrayToRGB::execute()
{
QString ss;
dataCheck();
if(getErrorCondition() < 0)
{
setErrorCondition(-10000);
ss = QObject::tr("DataCheck did not pass during execute");
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
//get volume container
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getRedArrayPath().getDataContainerName());
QString attrMatName = getRedArrayPath().getAttributeMatrixName();
//get input and output data
IDataArray::Pointer redData = m_RedPtr.lock();
IDataArray::Pointer greenData = m_GreenPtr.lock();
IDataArray::Pointer blueData = m_BluePtr.lock();
IDataArray::Pointer outputData = m_NewCellArrayPtr.lock();
//execute type dependant portion using a Private Implementation that takes care of figuring out if
// we can work on the correct type and actually handling the algorithm execution. We pass in "this" so
// that the private implementation can get access to the current object to pass up status notifications,
// progress or handle "cancel" if needed.
if(GrayToRGBPrivate<int8_t>()(redData))
{
GrayToRGBPrivate<int8_t>::Execute(this, redData, greenData, blueData, outputData, m, attrMatName);
}
else if(GrayToRGBPrivate<uint8_t>()(redData) )
{
GrayToRGBPrivate<uint8_t>::Execute(this, redData, greenData, blueData, outputData, m, attrMatName);
}
else if(GrayToRGBPrivate<int16_t>()(redData) )
{
GrayToRGBPrivate<int16_t>::Execute(this, redData, greenData, blueData, outputData, m, attrMatName);
}
else if(GrayToRGBPrivate<uint16_t>()(redData) )
{
GrayToRGBPrivate<uint16_t>::Execute(this, redData, greenData, blueData, outputData, m, attrMatName);
}
else if(GrayToRGBPrivate<int32_t>()(redData) )
{
GrayToRGBPrivate<int32_t>::Execute(this, redData, greenData, blueData, outputData, m, attrMatName);
}
else if(GrayToRGBPrivate<uint32_t>()(redData) )
{
GrayToRGBPrivate<uint32_t>::Execute(this, redData, greenData, blueData, outputData, m, attrMatName);
}
else if(GrayToRGBPrivate<int64_t>()(redData) )
{
GrayToRGBPrivate<int64_t>::Execute(this, redData, greenData, blueData, outputData, m, attrMatName);
}
else if(GrayToRGBPrivate<uint64_t>()(redData) )
{
GrayToRGBPrivate<uint64_t>::Execute(this, redData, greenData, blueData, outputData, m, attrMatName);
}
else if(GrayToRGBPrivate<float>()(redData) )
{
GrayToRGBPrivate<float>::Execute(this, redData, greenData, blueData, outputData, m, attrMatName);
}
else if(GrayToRGBPrivate<double>()(redData) )
{
GrayToRGBPrivate<double>::Execute(this, redData, greenData, blueData, outputData, m, attrMatName);
}
else
{
setErrorCondition(-10001);
ss = QObject::tr("A Supported DataArray type was not used for an input array.");
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
//array name changing/cleanup
AttributeMatrix::Pointer attrMat = m->getAttributeMatrix(m_RedArrayPath.getAttributeMatrixName());
attrMat->addAttributeArray(getNewCellArrayName(), outputData);
/* Let the GUI know we are done with this filter */
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void RemoveFlaggedFeatures::assign_badpoints()
{
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(m_FeatureIdsArrayPath.getDataContainerName());
size_t totalPoints = m_FeatureIdsPtr.lock()->getNumberOfTuples();
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]),
};
Int32ArrayType::Pointer neighborsPtr = Int32ArrayType::CreateArray(totalPoints, "_INTERNAL_USE_ONLY_Neighbors");
m_Neighbors = neighborsPtr->getPointer(0);
neighborsPtr->initializeWithValue(-1);
int32_t good = 1;
int32_t current = 0;
int32_t most = 0;
int64_t neighpoint = 0;
DimType neighpoints[6];
neighpoints[0] = -dims[0] * dims[1];
neighpoints[1] = -dims[0];
neighpoints[2] = -1;
neighpoints[3] = 1;
neighpoints[4] = dims[0];
neighpoints[5] = dims[0] * dims[1];
size_t counter = 1;
int64_t count = 0;
int64_t kstride = 0, jstride = 0;
int32_t featurename, feature;
int32_t neighbor;
QVector<int32_t> n(m_FlaggedFeaturesPtr.lock()->getNumberOfTuples(), 0);
while (counter != 0)
{
counter = 0;
for (DimType k = 0; k < dims[2]; k++)
{
kstride = dims[0] * dims[1] * k;
for (DimType j = 0; j < dims[1]; j++)
{
jstride = dims[0] * j;
for (DimType i = 0; i < dims[0]; i++)
{
count = kstride + jstride + i;
featurename = m_FeatureIds[count];
if (featurename < 0)
{
counter++;
current = 0;
most = 0;
for (int32_t l = 0; l < 6; l++)
{
good = 1;
neighpoint = count + neighpoints[l];
if (l == 0 && k == 0) { good = 0; }
if (l == 5 && k == (dims[2] - 1)) { good = 0; }
if (l == 1 && j == 0) { good = 0; }
if (l == 4 && j == (dims[1] - 1)) { good = 0; }
if (l == 2 && i == 0) { good = 0; }
if (l == 3 && i == (dims[0] - 1)) { good = 0; }
if (good == 1)
{
feature = m_FeatureIds[neighpoint];
if (feature >= 0)
{
n[feature]++;
current = n[feature];
if (current > most)
{
most = current;
m_Neighbors[count] = neighpoint;
}
}
}
}
for (int32_t l = 0; l < 6; l++)
{
good = 1;
neighpoint = count + neighpoints[l];
if (l == 0 && k == 0) { good = 0; }
if (l == 5 && k == (dims[2] - 1)) { good = 0; }
if (l == 1 && j == 0) { good = 0; }
if (l == 4 && j == (dims[1] - 1)) { good = 0; }
if (l == 2 && i == 0) { good = 0; }
if (l == 3 && i == (dims[0] - 1)) { good = 0; }
if (good == 1)
{
feature = m_FeatureIds[neighpoint];
if (feature >= 0) { n[feature] = 0; }
}
}
}
}
}
}
QString attrMatName = m_FeatureIdsArrayPath.getAttributeMatrixName();
QList<QString> voxelArrayNames = m->getAttributeMatrix(attrMatName)->getAttributeArrayNames();
for (size_t j = 0; j < totalPoints; j++)
{
featurename = m_FeatureIds[j];
neighbor = m_Neighbors[j];
if (neighbor >= 0)
{
if (featurename < 0 && m_FeatureIds[neighbor] >= 0)
{
for (QList<QString>::iterator iter = voxelArrayNames.begin(); iter != voxelArrayNames.end(); ++iter)
{
IDataArray::Pointer p = m->getAttributeMatrix(attrMatName)->getAttributeArray(*iter);
p->copyTuple(neighbor, j);
}
}
}
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ErodeDilateBadData::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getFeatureIdsArrayPath().getDataContainerName());
size_t totalPoints = m_FeatureIdsPtr.lock()->getNumberOfTuples();
Int32ArrayType::Pointer neighborsPtr = Int32ArrayType::CreateArray(totalPoints, "_INTERNAL_USE_ONLY_Neighbors");
m_Neighbors = neighborsPtr->getPointer(0);
neighborsPtr->initializeWithValue(-1);
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]),
};
int32_t good = 1;
int64_t count = 0;
int64_t kstride = 0, jstride = 0;
int32_t featurename = 0, feature = 0;
int32_t current = 0;
int32_t most = 0;
int64_t neighpoint = 0;
size_t numfeatures = 0;
for (size_t i = 0; i < totalPoints; i++)
{
featurename = m_FeatureIds[i];
if (featurename > numfeatures) { numfeatures = featurename; }
}
DimType neighpoints[6] = { 0, 0, 0, 0, 0, 0 };
neighpoints[0] = -dims[0] * dims[1];
neighpoints[1] = -dims[0];
neighpoints[2] = -1;
neighpoints[3] = 1;
neighpoints[4] = dims[0];
neighpoints[5] = dims[0] * dims[1];
QVector<int32_t> n(numfeatures + 1, 0);
for (int32_t iteration = 0; iteration < m_NumIterations; iteration++)
{
for (DimType k = 0; k < dims[2]; k++)
{
kstride = dims[0] * dims[1] * k;
for (DimType j = 0; j < dims[1]; j++)
{
jstride = dims[0] * j;
for (DimType i = 0; i < dims[0]; i++)
{
count = kstride + jstride + i;
featurename = m_FeatureIds[count];
if (featurename == 0)
{
current = 0;
most = 0;
for (int32_t l = 0; l < 6; l++)
{
good = 1;
neighpoint = count + neighpoints[l];
if (l == 0 && (k == 0 || m_ZDirOn == false)) { good = 0; }
else if (l == 5 && (k == (dims[2] - 1) || m_ZDirOn == false)) { good = 0; }
else if (l == 1 && (j == 0 || m_YDirOn == false)) { good = 0; }
else if (l == 4 && (j == (dims[1] - 1) || m_YDirOn == false)) { good = 0; }
else if (l == 2 && (i == 0 || m_XDirOn == false)) { good = 0; }
else if (l == 3 && (i == (dims[0] - 1) || m_XDirOn == false)) { good = 0; }
if (good == 1)
{
feature = m_FeatureIds[neighpoint];
if (m_Direction == 0 && feature > 0)
{
m_Neighbors[neighpoint] = count;
}
if (feature > 0 && m_Direction == 1)
{
n[feature]++;
current = n[feature];
if (current > most)
{
most = current;
m_Neighbors[count] = neighpoint;
}
}
}
}
if (m_Direction == 1)
{
for (int32_t l = 0; l < 6; l++)
{
good = 1;
neighpoint = count + neighpoints[l];
if (l == 0 && k == 0) { good = 0; }
if (l == 5 && k == (dims[2] - 1)) { good = 0; }
if (l == 1 && j == 0) { good = 0; }
if (l == 4 && j == (dims[1] - 1)) { good = 0; }
if (l == 2 && i == 0) { good = 0; }
if (l == 3 && i == (dims[0] - 1)) { good = 0; }
if (good == 1)
{
feature = m_FeatureIds[neighpoint];
n[feature] = 0;
}
}
}
}
}
}
}
QString attrMatName = m_FeatureIdsArrayPath.getAttributeMatrixName();
QList<QString> voxelArrayNames = m->getAttributeMatrix(attrMatName)->getAttributeArrayNames();
for (size_t j = 0; j < totalPoints; j++)
{
featurename = m_FeatureIds[j];
int32_t neighbor = m_Neighbors[j];
if (neighbor >= 0)
{
if ( (featurename == 0 && m_FeatureIds[neighbor] > 0 && m_Direction == 1)
|| (featurename > 0 && m_FeatureIds[neighbor] == 0 && m_Direction == 0))
{
for(QList<QString>::iterator iter = voxelArrayNames.begin(); iter != voxelArrayNames.end(); ++iter)
{
IDataArray::Pointer p = m->getAttributeMatrix(attrMatName)->getAttributeArray(*iter);
p->copyTuple(neighbor, j);
}
}
}
}
}
// If there is an error set this to something negative and also set a message
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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 ChangeResolution::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m;
if(m_SaveAsNewDataContainer == false)
{
m = getDataContainerArray()->getDataContainer(getCellAttributeMatrixPath().getDataContainerName());
}
else
{
m = getDataContainerArray()->getDataContainer(getNewDataContainerName());
}
if(m->getGeometryAs<ImageGeom>()->getXRes() == m_Resolution.x
&& m->getGeometryAs<ImageGeom>()->getYRes() == m_Resolution.y
&& m->getGeometryAs<ImageGeom>()->getZRes() == m_Resolution.z)
{
return;
}
AttributeMatrix::Pointer cellAttrMat = m->getAttributeMatrix(getCellAttributeMatrixPath().getAttributeMatrixName());
size_t dims[3] = { 0, 0, 0 };
m->getGeometryAs<ImageGeom>()->getDimensions(dims);
float sizex = (dims[0]) * m->getGeometryAs<ImageGeom>()->getXRes();
float sizey = (dims[1]) * m->getGeometryAs<ImageGeom>()->getYRes();
float sizez = (dims[2]) * m->getGeometryAs<ImageGeom>()->getZRes();
size_t m_XP = size_t(sizex / m_Resolution.x);
size_t m_YP = size_t(sizey / m_Resolution.y);
size_t m_ZP = size_t(sizez / m_Resolution.z);
if (m_XP == 0) { m_XP = 1; }
if (m_YP == 0) { m_YP = 1; }
if (m_ZP == 0) { m_ZP = 1; }
size_t totalPoints = m_XP * m_YP * m_ZP;
float x = 0.0f, y = 0.0f, z = 0.0f;
size_t col = 0, row = 0, plane = 0;
size_t index;
size_t index_old;
std::vector<size_t> newindicies(totalPoints);
for (size_t i = 0; i < m_ZP; i++)
{
QString ss = QObject::tr("Changing Resolution - %1 Percent Complete").arg(((float)i / m->getGeometryAs<ImageGeom>()->getZPoints()) * 100);
notifyStatusMessage(getMessagePrefix(), getHumanLabel(), ss);
for (size_t j = 0; j < m_YP; j++)
{
for (size_t k = 0; k < m_XP; k++)
{
x = (k * m_Resolution.x);
y = (j * m_Resolution.y);
z = (i * m_Resolution.z);
col = size_t(x / m->getGeometryAs<ImageGeom>()->getXRes());
row = size_t(y / m->getGeometryAs<ImageGeom>()->getYRes());
plane = size_t(z / m->getGeometryAs<ImageGeom>()->getZRes());
index_old = (plane * m->getGeometryAs<ImageGeom>()->getXPoints() * m->getGeometryAs<ImageGeom>()->getYPoints()) + (row * m->getGeometryAs<ImageGeom>()->getXPoints()) + col;
index = (i * m_XP * m_YP) + (j * m_XP) + k;
newindicies[index] = index_old;
}
}
}
QVector<size_t> tDims(3, 0);
tDims[0] = m_XP;
tDims[1] = m_YP;
tDims[2] = m_ZP;
AttributeMatrix::Pointer newCellAttrMat = AttributeMatrix::New(tDims, cellAttrMat->getName(), cellAttrMat->getType());
QList<QString> voxelArrayNames = cellAttrMat->getAttributeArrayNames();
for (QList<QString>::iterator iter = voxelArrayNames.begin(); iter != voxelArrayNames.end(); ++iter)
{
IDataArray::Pointer p = cellAttrMat->getAttributeArray(*iter);
// Make a copy of the 'p' array that has the same name. When placed into
// the data container this will over write the current array with
// the same name. At least in theory.
IDataArray::Pointer data = p->createNewArray(p->getNumberOfTuples(), p->getComponentDimensions(), p->getName());
data->resize(totalPoints);
void* source = NULL;
void* destination = NULL;
size_t newIndicies_I = 0;
int nComp = data->getNumberOfComponents();
for (size_t i = 0; i < static_cast<size_t>(totalPoints); i++)
{
newIndicies_I = newindicies[i];
source = p->getVoidPointer((nComp * newIndicies_I));
destination = data->getVoidPointer((data->getNumberOfComponents() * i));
::memcpy(destination, source, p->getTypeSize() * data->getNumberOfComponents());
}
cellAttrMat->removeAttributeArray(*iter);
newCellAttrMat->addAttributeArray(*iter, data);
}
m->getGeometryAs<ImageGeom>()->setResolution(m_Resolution.x, m_Resolution.y, m_Resolution.z);
m->getGeometryAs<ImageGeom>()->setDimensions(m_XP, m_YP, m_ZP);
m->removeAttributeMatrix(getCellAttributeMatrixPath().getAttributeMatrixName());
m->addAttributeMatrix(getCellAttributeMatrixPath().getAttributeMatrixName(), newCellAttrMat);
// Feature Ids MUST already be renumbered.
if (m_RenumberFeatures == true)
{
totalPoints = m->getGeometryAs<ImageGeom>()->getNumberOfElements();
AttributeMatrix::Pointer cellFeatureAttrMat = m->getAttributeMatrix(getCellFeatureAttributeMatrixPath().getAttributeMatrixName());
size_t totalFeatures = cellFeatureAttrMat->getNumTuples();
QVector<bool> activeObjects(totalFeatures, false);
if (0 == totalFeatures)
{
notifyErrorMessage(getHumanLabel(), "The number of Features is 0 and should be greater than 0", -600);
return;
}
updateCellInstancePointers();
// Find the unique set of feature ids
for (size_t i = 0; i < totalPoints; ++i)
{
activeObjects[m_FeatureIds[i]] = true;
}
cellFeatureAttrMat->removeInactiveObjects(activeObjects, m_FeatureIdsPtr.lock());
}
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void AlignSections::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getDataContainerName());
size_t dims[3] = { 0, 0, 0 };
m->getGeometryAs<ImageGeom>()->getDimensions(dims);
int64_t xspot = 0, yspot = 0;
int64_t newPosition = 0;
int64_t currentPosition = 0;
std::vector<int64_t> xshifts(dims[2], 0);
std::vector<int64_t> yshifts(dims[2], 0);
find_shifts(xshifts, yshifts);
QList<QString> voxelArrayNames = m->getAttributeMatrix(getCellAttributeMatrixName())->getAttributeArrayNames();
size_t progIncrement = dims[2] / 100;
size_t prog = 1;
size_t progressInt = 0;
size_t slice = 0;
for (size_t i = 1; i < dims[2]; i++)
{
if (i > prog)
{
progressInt = ((float)i / dims[2]) * 100.0f;
QString ss = QObject::tr("Transferring Cell Data || %1% Complete").arg(progressInt);
notifyStatusMessage(getMessagePrefix(), getHumanLabel(), ss);
prog = prog + progIncrement;
}
if (getCancel() == true)
{
return;
}
slice = (dims[2] - 1) - i;
for (size_t l = 0; l < dims[1]; l++)
{
for (size_t n = 0; n < dims[0]; n++)
{
if (yshifts[i] >= 0) { yspot = l; }
else if (yshifts[i] < 0) { yspot = dims[1] - 1 - l; }
if (xshifts[i] >= 0) { xspot = n; }
else if (xshifts[i] < 0) { xspot = dims[0] - 1 - n; }
newPosition = (slice * dims[0] * dims[1]) + (yspot * dims[0]) + xspot;
currentPosition = (slice * dims[0] * dims[1]) + ((yspot + yshifts[i]) * dims[0]) + (xspot + xshifts[i]);
if ((yspot + yshifts[i]) >= 0 && (yspot + yshifts[i]) <= static_cast<int64_t>(dims[1]) - 1 && (xspot + xshifts[i]) >= 0
&& (xspot + xshifts[i]) <= static_cast<int64_t>(dims[0]) - 1)
{
for (QList<QString>::iterator iter = voxelArrayNames.begin(); iter != voxelArrayNames.end(); ++iter)
{
IDataArray::Pointer p = m->getAttributeMatrix(getCellAttributeMatrixName())->getAttributeArray(*iter);
p->copyTuple( static_cast<size_t>(currentPosition), static_cast<size_t>(newPosition));
}
}
if ((yspot + yshifts[i]) < 0 || (yspot + yshifts[i]) > static_cast<int64_t>(dims[1] - 1) || (xspot + xshifts[i]) < 0
|| (xspot + xshifts[i]) > static_cast<int64_t>(dims[0]) - 1)
{
for (QList<QString>::iterator iter = voxelArrayNames.begin(); iter != voxelArrayNames.end(); ++iter)
{
IDataArray::Pointer p = m->getAttributeMatrix(getCellAttributeMatrixName())->getAttributeArray(*iter);
EXECUTE_FUNCTION_TEMPLATE(this, initializeArrayValues, p, p, newPosition)
}
}
}
}
}
// If there is an error set this to something negative and also set a message
notifyStatusMessage(getHumanLabel(), "Complete");
}
void writeCellNormalData(DataContainer::Pointer dc, const QString& faceAttributeMatrixName, const QString& dataName, const QString& dataType,
bool writeBinaryData, FILE* vtkFile, QMap<int32_t, int32_t>& featureIds, int32_t* m_SurfaceMeshFaceLabels)
{
TriangleGeom::Pointer triangleGeom = dc->getGeometryAs<TriangleGeom>();
int64_t numTriangles = triangleGeom->getNumberOfTris();
IDataArray::Pointer data = dc->getAttributeMatrix(faceAttributeMatrixName)->getAttributeArray(dataName);
QString buf;
QTextStream ss(&buf);
if (NULL != data.get())
{
int32_t totalCellsWritten = 0;
T* m = reinterpret_cast<T*>(data->getVoidPointer(0));
fprintf(vtkFile, "\n");
fprintf(vtkFile, "NORMALS %s %s\n", dataName.toLatin1().data(), dataType.toLatin1().data());
// Loop over all the features
for(QMap<int32_t, int32_t>::iterator featureIter = featureIds.begin(); featureIter != featureIds.end(); ++featureIter)
{
int32_t gid = featureIter.key(); // The current Feature Id
size_t size = featureIter.value(); // The number of triangles for this feature id
std::vector<T> buffer(size * 3, 0);
totalCellsWritten += size * 3;
size_t index = 0;
for (int j = 0; j < numTriangles; j++)
{
if (m_SurfaceMeshFaceLabels[j * 2] != gid && m_SurfaceMeshFaceLabels[j * 2 + 1] != gid) { continue; }
// Get the data
T s0 = static_cast<T>(m[j * 3 + 0]);
T s1 = static_cast<T>(m[j * 3 + 1]);
T s2 = static_cast<T>(m[j * 3 + 2]);
// Flip the normal if needed because the current feature id is assigned to the triangle.labels[1]
if (m_SurfaceMeshFaceLabels[j * 2 + 1] == gid )
{
s0 *= -1.0;
s1 *= -1.0;
s2 *= -1.0;
}
// Write the values to the buffer after an Endian swap.
if(writeBinaryData == true)
{
SIMPLib::Endian::FromSystemToBig::convert(s0);
buffer[index] = s0;
++index;
SIMPLib::Endian::FromSystemToBig::convert(s1);
buffer[index] = s1;
++index;
SIMPLib::Endian::FromSystemToBig::convert(s2);
buffer[index] = s2;
++index;
}
else
{
ss << s0 << " " << s1 << " " << s2;
fprintf(vtkFile, "%s\n", buf.toLatin1().data());
buf.clear();
}
}
// Write the Buffer
if(writeBinaryData == true)
{
fwrite(&(buffer.front()), sizeof(T), size * 3, vtkFile);
}
}
}
}
