// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void GenerateNodeTriangleConnectivity::execute()
{
int err = 0;
std::stringstream ss;
setErrorCondition(err);
SurfaceMeshDataContainer* m = getSurfaceMeshDataContainer();
if(NULL == m)
{
setErrorCondition(-999);
notifyErrorMessage("The SurfaceMesh DataContainer Object was NULL", -999);
return;
}
setErrorCondition(0);
// Just to double check we have everything.
dataCheck(false, 0,0,0);
if (getErrorCondition() < 0)
{
return;
}
notifyStatusMessage("Starting");
// Generate the connectivity data
generateConnectivity();
/* Let the GUI know we are done with this filter */
notifyStatusMessage("Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void GenerateFaceSchuhMisorientationColoring::execute()
{
int err = 0;
setErrorCondition(err);
dataCheckSurfaceMesh();
if(getErrorCondition() < 0) { return; }
dataCheckVoxel();
if(getErrorCondition() < 0) { return; }
notifyStatusMessage(getMessagePrefix(), getHumanLabel(), "Starting");
// Run the data check to allocate the memory for the centroid array
int64_t numTriangles = m_SurfaceMeshFaceLabelsPtr.lock()->getNumberOfTuples();
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
bool doParallel = true;
#endif
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
if (doParallel == true)
{
tbb::parallel_for(tbb::blocked_range<size_t>(0, numTriangles),
CalculateFaceSchuhMisorientationColorsImpl(m_SurfaceMeshFaceLabels, m_FeaturePhases, m_AvgQuats, m_SurfaceMeshFaceSchuhMisorientationColors, m_CrystalStructures), tbb::auto_partitioner());
}
else
#endif
{
CalculateFaceSchuhMisorientationColorsImpl serial(m_SurfaceMeshFaceLabels, m_FeaturePhases, m_AvgQuats, m_SurfaceMeshFaceSchuhMisorientationColors, m_CrystalStructures);
serial.generate(0, numTriangles);
}
/* Let the GUI know we are done with this filter */
notifyStatusMessage(getHumanLabel(), "Complete");
}
void SetupTabViewManager::WireMessages(Settings& config)
{
connect(&config, SIGNAL(notifyStatusMessage(QString)),
&m_setupTab, SLOT(onStatusUpdate(QString)) );
connect(&m_systemController, SIGNAL(notifyStatusMessage(QString)),
&m_setupTab, SLOT(onStatusUpdate(QString)));
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void Watershed::execute()
{
//int err = 0;
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getSelectedCellArrayPath().getDataContainerName());
QString attrMatName = getSelectedCellArrayPath().getAttributeMatrixName();
//wrap m_RawImageData as itk::image
ImageProcessing::DefaultImageType::Pointer inputImage = ITKUtilitiesType::CreateItkWrapperForDataPointer(m, attrMatName, m_SelectedCellArray);
//create gradient magnitude filter
notifyStatusMessage(getHumanLabel(), "Calculating Gradient Magnitude");
typedef itk::GradientMagnitudeImageFilter<ImageProcessing::DefaultImageType, ImageProcessing::DefaultImageType > GradientMagnitudeImageFilterType;
GradientMagnitudeImageFilterType::Pointer gradientMagnitudeImageFilter = GradientMagnitudeImageFilterType::New();
gradientMagnitudeImageFilter->SetInput(inputImage);
gradientMagnitudeImageFilter->Update();
//watershed image
notifyStatusMessage(getHumanLabel(), "Watershedding");
typedef itk::WatershedImageFilter<ImageProcessing::DefaultImageType> WatershedFilterType;
WatershedFilterType::Pointer watershed = WatershedFilterType::New();
watershed->SetThreshold(m_Threshold);
watershed->SetLevel(m_Level);
watershed->SetInput(gradientMagnitudeImageFilter->GetOutput());
//execute filter
try
{
watershed->Update();
}
catch( itk::ExceptionObject& err )
{
setErrorCondition(-5);
QString ss = QObject::tr("Failed to execute itk::GradientMagnitudeImageFilter filter. Error Message returned from ITK:\n %1").arg(err.GetDescription());
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
}
//get output and copy to grainids
typedef itk::Image<unsigned long, ImageProcessing::ImageDimension> WatershedImageType;
WatershedImageType::Pointer output = watershed->GetOutput();
WatershedImageType::RegionType filterRegion = output->GetLargestPossibleRegion();
typedef itk::ImageRegionConstIterator<itk::Image<unsigned long, ImageProcessing::ImageDimension> > WatershedIteratorType;
WatershedIteratorType it(output, filterRegion);
it.GoToBegin();
int index = 0;
while(!it.IsAtEnd())
{
m_FeatureIds[index] = it.Get();
++it;
++index;
}
/* Let the GUI know we are done with this filter */
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void GenerateSurfaceMeshConnectivity::execute()
{
int err = 0;
std::stringstream ss;
setErrorCondition(err);
VoxelDataContainer* m = getVoxelDataContainer();
if(NULL == m)
{
setErrorCondition(-999);
notifyErrorMessage("The Voxel DataContainer Object was NULL", -999);
return;
}
setErrorCondition(0);
dataCheck(false, 1, 1, 1);
if (getErrorCondition() < 0)
{
return;
}
// We need the vertex->Triangle Lists to build the Triangle Neighbor lists so if either
// of those are true then build the vertex->triangle lists
if (m_GenerateVertexTriangleLists == true || m_GenerateTriangleNeighbors == true)
{
notifyStatusMessage("Generating Vertex Triangle List");
getSurfaceMeshDataContainer()->buildMeshVertLinks();
}
if (m_GenerateTriangleNeighbors == true)
{
notifyStatusMessage("Generating Face Neighbors List");
getSurfaceMeshDataContainer()->buildMeshFaceNeighborLists();
}
if (m_GenerateEdgeIdList == true)
{
// There was no Edge connectivity before this filter so delete it when we are done with it
GenerateUniqueEdges::Pointer conn = GenerateUniqueEdges::New();
ss.str("");
ss << getMessagePrefix() << " |->Generating Unique Edge Ids |->";
conn->setMessagePrefix(ss.str());
conn->setObservers(getObservers());
conn->setVoxelDataContainer(getVoxelDataContainer());
conn->setSurfaceMeshDataContainer(getSurfaceMeshDataContainer());
conn->setSolidMeshDataContainer(getSolidMeshDataContainer());
conn->execute();
if(conn->getErrorCondition() < 0)
{
setErrorCondition(conn->getErrorCondition());
return;
}
}
/* Let the GUI know we are done with this filter */
notifyStatusMessage("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 FeatureFaceCurvatureFilter::tbbTaskProgress()
{
m_CompletedFeatureFaces++;
QString ss = QObject::tr("%1/%2 Complete").arg(m_CompletedFeatureFaces).arg(m_TotalFeatureFaces);
notifyStatusMessage(getMessagePrefix(), getHumanLabel(), ss);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void GenerateIPFColors::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
size_t totalPoints = m_CellEulerAnglesPtr.lock()->getNumberOfTuples();
// Make sure we are dealing with a unit 1 vector.
FloatVec3_t normRefDir = m_ReferenceDir; // Make a copy of the reference Direction
MatrixMath::Normalize3x1(normRefDir.x, normRefDir.y, normRefDir.z);
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
tbb::task_scheduler_init init;
bool doParallel = true;
#endif
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
if (doParallel == true)
{
tbb::parallel_for(tbb::blocked_range<size_t>(0, totalPoints),
GenerateIPFColorsImpl(normRefDir, m_CellEulerAngles, m_CellPhases, m_CrystalStructures, m_GoodVoxels, m_CellIPFColors), tbb::auto_partitioner());
}
else
#endif
{
GenerateIPFColorsImpl serial(normRefDir, m_CellEulerAngles, m_CellPhases, m_CrystalStructures, m_GoodVoxels, m_CellIPFColors);
serial.convert(0, totalPoints);
}
/* Let the GUI know we are done with this filter */
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void TriangleNormalFilter::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer sm = getDataContainerArray()->getDataContainer(getSurfaceMeshTriangleNormalsArrayPath().getDataContainerName());
TriangleGeom::Pointer triangleGeom = sm->getGeometryAs<TriangleGeom>();
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
bool doParallel = true;
#endif
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
if (doParallel == true)
{
tbb::parallel_for(tbb::blocked_range<size_t>(0, triangleGeom->getNumberOfTris()),
CalculateNormalsImpl(triangleGeom->getVertices(), triangleGeom->getTriangles(), m_SurfaceMeshTriangleNormals), tbb::auto_partitioner());
}
else
#endif
{
CalculateNormalsImpl serial(triangleGeom->getVertices(), triangleGeom->getTriangles(), m_SurfaceMeshTriangleNormals);
serial.generate(0, triangleGeom->getNumberOfTris());
}
/* Let the GUI know we are done with this filter */
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void AddOrientationNoise::add_orientation_noise()
{
notifyStatusMessage("Adding Orientation Noise");
DREAM3D_RANDOMNG_NEW()
VoxelDataContainer* m = getVoxelDataContainer();
//float ea1, ea2, ea3;
float g[3][3];
float newg[3][3];
float rot[3][3];
float w, n1, n2, n3;
int64_t totalPoints = m->getTotalPoints();
for (size_t i = 0; i < static_cast<size_t>(totalPoints); ++i)
{
float ea1 = m_CellEulerAngles[3*i+0];
float ea2 = m_CellEulerAngles[3*i+1];
float ea3 = m_CellEulerAngles[3*i+2];
OrientationMath::EulertoMat(ea1, ea2, ea3, g);
n1 = static_cast<float>( rg.genrand_res53() );
n2 = static_cast<float>( rg.genrand_res53() );
n3 = static_cast<float>( rg.genrand_res53() );
w = static_cast<float>( rg.genrand_res53() );
w = 2.0*(w-0.5);
w = (m_Magnitude*w);
OrientationMath::AxisAngletoMat(w, n1, n2, n3, rot);
MatrixMath::Multiply3x3with3x3(g, rot, newg);
OrientationMath::MattoEuler(newg, ea1, ea2, ea3);
m_CellEulerAngles[3*i+0] = ea1;
m_CellEulerAngles[3*i+1] = ea2;
m_CellEulerAngles[3*i+2] = ea3;
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void AdjustVolumeOrigin::execute()
{
VoxelDataContainer* m = getVoxelDataContainer();
if(NULL == m)
{
setErrorCondition(-999);
notifyErrorMessage("The DataContainer Object was NULL", -999);
return;
}
setErrorCondition(0);
std::stringstream ss;
// Set the Voxel Volume First, since this is easy
if (m_ApplyToVoxelVolume ==true)
{
m->setOrigin(m_Origin.x, m_Origin.y, m_Origin.z);
}
if (m_ApplyToSurfaceMesh == true)
{
updateSurfaceMesh();
}
if (m_ApplyToSolidMesh == true)
{
updatesSolidMesh();
}
notifyStatusMessage("Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void AlignSectionsFeature::execute()
{
setErrorCondition(0);
VoxelDataContainer* m = getVoxelDataContainer();
if(NULL == m)
{
setErrorCondition(-999);
notifyErrorMessage("The DataContainer Object was NULL", -999);
return;
}
int64_t totalPoints = m->getTotalPoints();
size_t numgrains = m->getNumFieldTuples();
size_t numensembles = m->getNumEnsembleTuples();
dataCheck(false, totalPoints, numgrains, numensembles);
if (getErrorCondition() < 0)
{
return;
}
AlignSections::execute();
// If there is an error set this to something negative and also set a message
notifyStatusMessage("Aligning Sections Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void RequiredZThickness::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer dataContainer = getDataContainerArray()->getPrereqDataContainer<AbstractFilter>(this, getDataContainerSelection());
if (getErrorCondition() < 0) { return; }
ImageGeom::Pointer image = dataContainer->getGeometryAs<ImageGeom>();
size_t dims[3] = { 0, 0, 0 };
image->getDimensions(dims);
if (dims[2] < getNumZVoxels())
{
QString str;
QTextStream ss(&str);
ss << "Number of Z Voxels does not meet required value during execution of the filter. \n";
ss << " Required Z Voxels: " << m_NumZVoxels << "\n";
ss << " Current Z Voxels: " << dims[2];
setErrorCondition(-7788);
notifyErrorMessage(getHumanLabel(), str, getErrorCondition());
bool needMoreData = true;
emit decisionMade(needMoreData);
}
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FindModulusMismatch::execute()
{
setErrorCondition(0);
dataCheckVoxel();
if(getErrorCondition() < 0) { return; }
dataCheckSurfaceMesh();
if(getErrorCondition() < 0) { return; }
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
tbb::task_scheduler_init init;
bool doParallel = true;
#endif
int64_t numTriangles = m_SurfaceMeshFaceLabelsPtr.lock()->getNumberOfTuples();
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
if (doParallel == true)
{
tbb::parallel_for(tbb::blocked_range<size_t>(0, numTriangles),
FindModulusMismatchImpl(m_SurfaceMeshFaceLabels, m_Moduli, m_SurfaceMeshDeltaModulus), tbb::auto_partitioner());
}
else
#endif
{
FindModulusMismatchImpl serial(m_SurfaceMeshFaceLabels, m_Moduli, m_SurfaceMeshDeltaModulus);
serial.generate(0, numTriangles);
}
notifyStatusMessage(getHumanLabel(), "Completed");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void EmptyFilter::execute()
{
dataCheck();
/* Let the GUI know we are done with this filter */
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ConvertOrientations::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
IDataArray::Pointer iDataArrayPtr = getDataContainerArray()->getPrereqIDataArrayFromPath<IDataArray, AbstractFilter>(this, getInputOrientationArrayPath());
DataArrayPath outputArrayPath = getInputOrientationArrayPath();
outputArrayPath.setDataArrayName(getOutputOrientationArrayName());
FloatArrayType::Pointer fArray = std::dynamic_pointer_cast<FloatArrayType>(iDataArrayPtr);
if(NULL != fArray.get())
{
QVector<int32_t> componentCounts = OrientationConverter<float>::GetComponentCounts();
QVector<size_t> outputCDims(1, componentCounts[getOutputType()]);
FloatArrayType::Pointer outData = getDataContainerArray()->getPrereqArrayFromPath<DataArray<float>, AbstractFilter>(this, outputArrayPath, outputCDims);
generateRepresentation<float>(this, fArray, outData);
}
DoubleArrayType::Pointer dArray = std::dynamic_pointer_cast<DoubleArrayType>(iDataArrayPtr);
if(NULL != dArray.get())
{
QVector<int32_t> componentCounts = OrientationConverter<double>::GetComponentCounts();
QVector<size_t> outputCDims(1, componentCounts[getOutputType()]);
DoubleArrayType::Pointer outData = getDataContainerArray()->getPrereqArrayFromPath<DataArray<double>, AbstractFilter>(this, outputArrayPath, outputCDims);
generateRepresentation<double>(this, dArray, outData);
}
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void ScaleVolume::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
if (m_ApplyToVoxelVolume == true)
{
DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getDataContainerName());
ImageGeom::Pointer image = m->getGeometryAs<ImageGeom>();
float resolution[3] = { 0.0f, 0.0f, 0.0f };
image->getResolution(resolution);
resolution[0] *= m_ScaleFactor.x;
resolution[1] *= m_ScaleFactor.y;
resolution[2] *= m_ScaleFactor.z;
image->setResolution(resolution);
}
if (m_ApplyToSurfaceMesh == true)
{
updateSurfaceMesh();
}
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void RotateEulerRefFrame::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
size_t totalPoints = m_CellEulerAnglesPtr.lock()->getNumberOfTuples();
float rotAngle = m_RotationAngle * SIMPLib::Constants::k_Pi / 180.0f;
float rotAxis[3] = {m_RotationAxis.x, m_RotationAxis.y, m_RotationAxis.z};
MatrixMath::Normalize3x1(rotAxis);
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
tbb::task_scheduler_init init;
bool doParallel = true;
#endif
#ifdef SIMPLib_USE_PARALLEL_ALGORITHMS
if (doParallel == true)
{
tbb::parallel_for(tbb::blocked_range<size_t>(0, totalPoints),
RotateEulerRefFrameImpl(m_CellEulerAngles, rotAngle, rotAxis), tbb::auto_partitioner());
}
else
#endif
{
RotateEulerRefFrameImpl serial(m_CellEulerAngles, rotAngle, rotAxis);
serial.convert(0, totalPoints);
}
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void AddOrientationNoise::execute()
{
int err = 0;
setErrorCondition(err);
DREAM3D_RANDOMNG_NEW()
VoxelDataContainer* m = getVoxelDataContainer();
if(NULL == m)
{
setErrorCondition(-999);
notifyErrorMessage("The DataContainer Object was NULL", -999);
return;
}
int64_t totalPoints = m->getTotalPoints();
size_t totalFields = m->getNumFieldTuples();
dataCheck(false, totalPoints, totalFields, m->getNumEnsembleTuples());
if (getErrorCondition() < 0)
{
return;
}
m_Magnitude = m_Magnitude*m_pi/180.0;
add_orientation_noise();
// If there is an error set this to something negative and also set a message
notifyStatusMessage("AddOrientationNoises Completed");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void MultiEmmpmFilter::execute()
{
setErrorCondition(0);
dataCheck();
if (getErrorCondition() < 0) { return; }
DataArrayPath inputAMPath = DataArrayPath::GetAttributeMatrixPath(getInputDataArrayVector());
QList<QString> arrayNames = DataArrayPath::GetDataArrayNames(getInputDataArrayVector());
QListIterator<QString> iter(arrayNames);
QString msgPrefix = getMessagePrefix();
int32_t i = 1;
// This is the routine that sets up the EM/MPM to segment the image
while (iter.hasNext())
{
DataArrayPath arrayPath = inputAMPath;
QString name = iter.next();
arrayPath.setDataArrayName(name);
setInputDataArrayPath(arrayPath);
// Change the output AttributeMatrix
arrayPath.setAttributeMatrixName(getOutputAttributeMatrixName());
QString outName = getOutputArrayPrefix() + arrayPath.getDataArrayName();
arrayPath.setDataArrayName(outName);
// Remove the array if it already exists ; this would be very strange but check for it anyway
getDataContainerArray()->getAttributeMatrix(arrayPath)->removeAttributeArray(outName);
setOutputDataArrayPath(arrayPath);
QString prefix = QObject::tr("%1 (Array %2 of %3)").arg(msgPrefix).arg(i).arg(arrayNames.size());
setMessagePrefix(prefix);
if ( i == 2 && getUsePreviousMuSigma())
{
setEmmpmInitType(EMMPM_ManualInit);
}
else
{
setEmmpmInitType(EMMPM_Basic);
}
EMMPMFilter::execute();
if (getErrorCondition() < 0) { break; }
i++;
if (getCancel()) { break; }
}
if (getErrorCondition() < 0)
{
QString ss = QObject::tr("Error occurred running the EM/MPM algorithm");
setErrorCondition(-60009);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
/* Let the GUI know we are done with this filter */
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FlattenImage::execute()
{
VoxelDataContainer* m = getVoxelDataContainer();
if(NULL == m)
{
setErrorCondition(-999);
notifyErrorMessage("The DataContainer Object was NULL", -999);
return;
}
setErrorCondition(0);
int64_t totalPoints = m->getTotalPoints();
size_t numgrains = m->getNumFieldTuples();
size_t numensembles = m->getNumEnsembleTuples();
dataCheck(false, totalPoints, numgrains, numensembles);
if (getErrorCondition() < 0)
{
return;
}
float Rfactor = 1.0;
float Gfactor = 1.0;
float Bfactor = 1.0;
if (m_FlattenMethod == DREAM3D::FlattenImageMethod::Average)
{
Rfactor = 1.0/3.0;
Gfactor = 1.0/3.0;
Bfactor = 1.0/3.0;
}
else if (m_FlattenMethod == DREAM3D::FlattenImageMethod::Luminosity)
{
Rfactor = 0.21;
Gfactor = 0.72;
Bfactor = 0.07;
}
#ifdef DREAM3D_USE_PARALLEL_ALGORITHMS
tbb::task_scheduler_init init;
bool doParallel = true;
#endif
size_t comp = m->getCellData(m_ImageDataArrayName)->GetNumberOfComponents();
// std::cout << "FlattenImage: " << m_ConversionFactor << std::endl;
#ifdef DREAM3D_USE_PARALLEL_ALGORITHMS
if (doParallel == true)
{
tbb::parallel_for(tbb::blocked_range<size_t>(0, totalPoints),
FlattenImageImpl(m_ImageData, m_FlatImageData, Rfactor, Gfactor, Bfactor, comp), tbb::auto_partitioner());
}
else
#endif
{
FlattenImageImpl serial(m_ImageData, m_FlatImageData, Rfactor, Gfactor, Bfactor, comp);
serial.convert(0, totalPoints);
}
notifyStatusMessage("Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void RenameAttributeMatrix::execute()
{
setErrorCondition(0);
dataCheck(); // calling the dataCheck will rename the array, so nothing is required here
if(getErrorCondition() < 0) { return; }
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void SetOriginResolutionImageGeom::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void GenerateMisorientationColors::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) { return; }
size_t totalPoints = m_CellPhasesPtr.lock()->getNumberOfTuples();
// Make sure we are dealing with a unit 1 vector.
FloatVec3_t normRefDir = m_ReferenceAxis; // Make a copy of the reference Direction
MatrixMath::Normalize3x1(normRefDir.x, normRefDir.y, normRefDir.z);
// Create 1 of every type of Ops class. This condenses the code below
UInt8ArrayType::Pointer notSupported = UInt8ArrayType::CreateArray(13, "_INTERNAL_USE_ONLY_NotSupportedArray");
notSupported->initializeWithZeros();
#ifdef DREAM3D_USE_PARALLEL_ALGORITHMS
tbb::task_scheduler_init init;
bool doParallel = true;
#endif
#ifdef DREAM3D_USE_PARALLEL_ALGORITHMS
if (doParallel == true)
{
tbb::parallel_for(tbb::blocked_range<size_t>(0, totalPoints),
GenerateMisorientationColorsImpl( normRefDir, m_ReferenceAngle, reinterpret_cast<QuatF*>(m_Quats), m_CellPhases, m_CrystalStructures, m_GoodVoxels, notSupported->getPointer(0), m_MisorientationColor), tbb::auto_partitioner());
}
else
#endif
{
GenerateMisorientationColorsImpl serial( normRefDir, m_ReferenceAngle, reinterpret_cast<QuatF*>(m_Quats), m_CellPhases, m_CrystalStructures, m_GoodVoxels, notSupported->getPointer(0), m_MisorientationColor);
serial.convert(0, totalPoints);
}
QVector<SpaceGroupOps::Pointer> ops = SpaceGroupOps::getOrientationOpsQVector();
// Check and warn about unsupported crystal symmetries in the computation which will show as black
for (size_t i = 0; i < notSupported->getNumberOfTuples() - 1; i++)
{
if (notSupported->getValue(i) == 1)
{
QString msg("The symmetry of ");
msg.append(ops[i]->getSymmetryName()).append(" is not currently supported for misorientation coloring. Elements with this symmetry have been set to black");
notifyWarningMessage(getHumanLabel(), msg, -5000);
}
}
// Check for bad voxels which will show up as black also.
if (notSupported->getValue(12) == 1)
{
QString msg("There were elements with an unknown crystal symmetry due most likely being marked as 'a 'bad'. These elements have been colored black BUT black is a valid color for misorientation coloring. Please understand this when visualizing your data");
notifyWarningMessage(getHumanLabel(), msg, -5001);
}
/* Let the GUI know we are done with this filter */
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void TriangleNormalFilter::execute()
{
int err = 0;
std::stringstream ss;
setErrorCondition(err);
SurfaceMeshDataContainer* m = getSurfaceMeshDataContainer();
if(NULL == m)
{
setErrorCondition(-999);
notifyErrorMessage("The SurfaceMesh DataContainer Object was NULL", -999);
return;
}
setErrorCondition(0);
notifyStatusMessage("Starting");
#ifdef DREAM3D_USE_PARALLEL_ALGORITHMS
bool doParallel = true;
#endif
DREAM3D::SurfaceMesh::VertListPointer_t nodesPtr = getSurfaceMeshDataContainer()->getVertices();
DREAM3D::SurfaceMesh::FaceListPointer_t trianglesPtr = getSurfaceMeshDataContainer()->getFaces();
size_t totalPoints = trianglesPtr->GetNumberOfTuples();
// Run the data check to allocate the memory for the centroid array
dataCheck(false, trianglesPtr->GetNumberOfTuples(), 0, 0);
#ifdef DREAM3D_USE_PARALLEL_ALGORITHMS
if (doParallel == true)
{
tbb::parallel_for(tbb::blocked_range<size_t>(0, totalPoints),
CalculateNormalsImpl(nodesPtr, trianglesPtr, m_SurfaceMeshTriangleNormals), tbb::auto_partitioner());
}
else
#endif
{
CalculateNormalsImpl serial(nodesPtr, trianglesPtr, m_SurfaceMeshTriangleNormals);
serial.generate(0, totalPoints);
}
/* Let the GUI know we are done with this filter */
notifyStatusMessage("Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void MoveData::execute()
{
setErrorCondition(0);
// Simply running the preflight will do what we need it to.
dataCheck();
if(getErrorCondition() < 0) { return; }
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void FindAvgOrientations::execute()
{
setErrorCondition(0);
dataCheck();
if(getErrorCondition() < 0) {
return;
}
size_t totalPoints = m_FeatureIdsPtr.lock()->getNumberOfTuples();
size_t totalFeatures = m_AvgQuatsPtr.lock()->getNumberOfTuples();
std::vector<float> counts(totalFeatures, 0.0f);
int32_t phase = 0;
QuatF voxquat = QuaternionMathF::New();
QuatF curavgquat = QuaternionMathF::New();
QuatF* avgQuats = reinterpret_cast<QuatF*>(m_AvgQuats);
QuatF* quats = reinterpret_cast<QuatF*>(m_Quats);
for (size_t i = 1; i < totalFeatures; i++)
{
QuaternionMathF::ElementWiseAssign(avgQuats[i], 0.0);
}
for (size_t i = 0; i < totalPoints; i++)
{
if (m_FeatureIds[i] > 0 && m_CellPhases[i] > 0)
{
counts[m_FeatureIds[i]] += 1;
phase = m_CellPhases[i];
QuaternionMathF::Copy(quats[i], voxquat);
QuaternionMathF::Copy(avgQuats[m_FeatureIds[i]], curavgquat);
QuaternionMathF::ScalarDivide(curavgquat, counts[m_FeatureIds[i]]);
if (counts[m_FeatureIds[i]] == 1)
{
QuaternionMathF::Identity(curavgquat);
}
m_OrientationOps[m_CrystalStructures[phase]]->getNearestQuat(curavgquat, voxquat);
QuaternionMathF::Add(avgQuats[m_FeatureIds[i]], voxquat, avgQuats[m_FeatureIds[i]]);
}
}
for (size_t i = 1; i < totalFeatures; i++)
{
if (counts[i] == 0)
{
QuaternionMathF::Identity(avgQuats[i]);
}
QuaternionMathF::ScalarDivide(avgQuats[i], counts[i]);
QuaternionMathF::UnitQuaternion(avgQuats[i]);
FOrientArrayType eu(m_FeatureEulerAngles + (3 * i), 3);
FOrientTransformsType::qu2eu(FOrientArrayType(avgQuats[i]), eu);
}
notifyStatusMessage(getHumanLabel(), "Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void AdjustVolumeOrigin::updateSurfaceMesh()
{
int err = 0;
std::stringstream ss;
setErrorCondition(err);
SurfaceMeshDataContainer* m = getSurfaceMeshDataContainer();
if(NULL == m)
{
setErrorCondition(-999);
notifyErrorMessage("The SurfaceMeshing DataContainer Object was NULL", -999);
return;
}
setErrorCondition(0);
notifyStatusMessage("Starting");
#ifdef DREAM3D_USE_PARALLEL_ALGORITHMS
tbb::task_scheduler_init init;
bool doParallel = true;
#endif
DREAM3D::SurfaceMesh::VertListPointer_t nodesPtr = getSurfaceMeshDataContainer()->getVertices();
DREAM3D::SurfaceMesh::Vert_t* nodes = nodesPtr->GetPointer(0);
// First get the min/max coords.
float min[3] = { std::numeric_limits<float>::max(), std::numeric_limits<float>::max(), std::numeric_limits<float>::max() };
// float max[3] = { std::numeric_limits<float>::min(), std::numeric_limits<float>::min(), std::numeric_limits<float>::min() };
size_t count = nodesPtr->GetNumberOfTuples();
for (size_t i = 0; i < count; i++)
{
// if (nodes[i].pos[0] > max[0]) { max[0] = nodes[i].pos[0]; }
// if (nodes[i].pos[1] > max[1]) { max[1] = nodes[i].pos[1]; }
// if (nodes[i].pos[2] > max[2]) { max[2] = nodes[i].pos[2]; }
if (nodes[i].pos[0] < min[0]) { min[0] = nodes[i].pos[0]; }
if (nodes[i].pos[1] < min[1]) { min[1] = nodes[i].pos[1]; }
if (nodes[i].pos[2] < min[2]) { min[2] = nodes[i].pos[2]; }
}
float delta[3] = {min[0] - m_Origin.x, min[1] - m_Origin.y, min[2] - m_Origin.z };
#ifdef DREAM3D_USE_PARALLEL_ALGORITHMS
if (doParallel == true)
{
tbb::parallel_for(tbb::blocked_range<size_t>(0, count),
Detail::UpdateVerticesImpl(nodesPtr, delta), tbb::auto_partitioner());
}
else
#endif
{
Detail::UpdateVerticesImpl serial(nodesPtr, delta);
serial.generate(0, count);
}
}
