// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
UInt8ArrayType::Pointer TriclinicOps::generateIPFTriangleLegend(int imageDim)
{
QVector<size_t> dims(1, 4);
UInt8ArrayType::Pointer image = UInt8ArrayType::CreateArray( static_cast<size_t>(imageDim * imageDim), dims, "Orthorhombic Triangle Legend");
uint32_t* pixelPtr = reinterpret_cast<uint32_t*>(image->getPointer(0));
static const float xInc = 1.0 / (imageDim);
static const float yInc = 1.0 / (imageDim);
static const float rad = 1.0f;
float x = 0.0f;
float y = 0.0f;
float a = 0.0f;
float b = 0.0f;
float c = 0.0f;
float val = 0.0f;
float x1 = 0.0f;
float y1 = 0.0f;
float z1 = 0.0f;
float denom = 0.0f;
DREAM3D::Rgb color;
size_t idx = 0;
size_t yScanLineIndex = 0; // We use this to control where the data is drawn. Otherwise the image will come out flipped vertically
// Loop over every pixel in the image and project up to the sphere to get the angle and then figure out the RGB from
// there.
for (int32_t yIndex = 0; yIndex < imageDim; ++yIndex)
{
for (int32_t xIndex = 0; xIndex < imageDim; ++xIndex)
{
idx = (imageDim * yScanLineIndex) + xIndex;
x = -1.0f + 2.0f * xIndex * xInc;
y = -1.0f + 2.0f * yIndex * yInc;
float sumSquares = (x * x) + (y * y);
if( sumSquares > 1.0f) // Outside unit circle
{
color = 0xFFFFFFFF;
}
else if ( sumSquares > (rad-2*xInc) && sumSquares < (rad+2*xInc)) // Black Border line
{
color = 0xFF000000;
}
else
{
a = (x * x + y * y + 1);
b = (2 * x * x + 2 * y * y);
c = (x * x + y * y - 1);
val = (-b + sqrtf(b * b - 4.0 * a * c)) / (2.0 * a);
x1 = (1 + val) * x;
y1 = (1 + val) * y;
z1 = val;
denom = (x1 * x1) + (y1 * y1) + (z1 * z1);
denom = sqrtf(denom);
x1 = x1 / denom;
y1 = y1 / denom;
z1 = z1 / denom;
color = generateIPFColor(0.0, 0.0, 0.0, x1, y1, z1, false);
}
pixelPtr[idx] = color;
}
yScanLineIndex++;
}
return image;
}
/**
* @brief ConvertData Templated function that converts an IDataArray to a given primitive type
* @param ptr IDataArray instance pointer
* @param dims Component dimensions
* @param m DataContainer instance pointer
* @param scalarType Primitive type to convert to
* @param attributeMatrixName Name of target AttributeMatrix
* @param name Name of converted array
*/
void ConvertData(T* ptr, QVector<size_t> dims, DataContainer::Pointer m, int32_t scalarType, const QString attributeMatrixName, const QString& name)
{
int voxels = ptr->getNumberOfTuples();
size_t size = ptr->getSize();
if (scalarType == Detail::Int8)
{
Int8ArrayType::Pointer p = Int8ArrayType::CreateArray(voxels, dims, name);
m->getAttributeMatrix(attributeMatrixName)->addAttributeArray(p->getName(), p);
for(size_t v = 0; v < size; ++v)
{
p->setValue(v, ptr->getValue(v) );
}
}
else if (scalarType == Detail::UInt8)
{
UInt8ArrayType::Pointer p = UInt8ArrayType::CreateArray(voxels, dims, name);
m->getAttributeMatrix(attributeMatrixName)->addAttributeArray(p->getName(), p);
for(size_t v = 0; v < size; ++v)
{
p->setValue(v, ptr->getValue(v) );
}
}
else if (scalarType == Detail::Int16)
{
Int16ArrayType::Pointer p = Int16ArrayType::CreateArray(voxels, dims, name);
m->getAttributeMatrix(attributeMatrixName)->addAttributeArray(p->getName(), p);
for(size_t v = 0; v < size; ++v)
{
p->setValue(v, ptr->getValue(v) );
}
}
else if (scalarType == Detail::UInt16)
{
UInt16ArrayType::Pointer p = UInt16ArrayType::CreateArray(voxels, dims, name);
m->getAttributeMatrix(attributeMatrixName)->addAttributeArray(p->getName(), p);
for(size_t v = 0; v < size; ++v)
{
p->setValue(v, ptr->getValue(v) );
}
}
else if (scalarType == Detail::Int32)
{
Int32ArrayType::Pointer p = Int32ArrayType::CreateArray(voxels, dims, name);
m->getAttributeMatrix(attributeMatrixName)->addAttributeArray(p->getName(), p);
for(size_t v = 0; v < size; ++v)
{
p->setValue(v, ptr->getValue(v) );
}
}
else if (scalarType == Detail::UInt32)
{
UInt32ArrayType::Pointer p = UInt32ArrayType::CreateArray(voxels, dims, name);
m->getAttributeMatrix(attributeMatrixName)->addAttributeArray(p->getName(), p);
for(size_t v = 0; v < size; ++v)
{
p->setValue(v, ptr->getValue(v) );
}
}
else if (scalarType == Detail::Int64)
{
Int64ArrayType::Pointer p = Int64ArrayType::CreateArray(voxels, dims, name);
m->getAttributeMatrix(attributeMatrixName)->addAttributeArray(p->getName(), p);
for(size_t v = 0; v < size; ++v)
{
p->setValue(v, ptr->getValue(v) );
}
}
else if (scalarType == Detail::UInt64)
{
UInt64ArrayType::Pointer p = UInt64ArrayType::CreateArray(voxels, dims, name);
m->getAttributeMatrix(attributeMatrixName)->addAttributeArray(p->getName(), p);
for(size_t v = 0; v < size; ++v)
{
p->setValue(v, ptr->getValue(v) );
}
}
else if (scalarType == Detail::Float)
{
FloatArrayType::Pointer p = FloatArrayType::CreateArray(voxels, dims, name);
m->getAttributeMatrix(attributeMatrixName)->addAttributeArray(p->getName(), p);
for(size_t v = 0; v < size; ++v)
{
p->setValue(v, ptr->getValue(v) );
}
}
else if (scalarType == Detail::Double)
{
DoubleArrayType::Pointer p = DoubleArrayType::CreateArray(voxels, dims, name);
m->getAttributeMatrix(attributeMatrixName)->addAttributeArray(p->getName(), p);
for(size_t v = 0; v < size; ++v)
{
p->setValue(v, ptr->getValue(v) );
}
}
}
void ConvertData(T* ptr, VoxelDataContainer* m, int32_t scalarType, const std::string &name)
{
int numberOfComponents = ptr->GetNumberOfComponents();
int voxels = ptr->GetNumberOfTuples();
size_t size = ptr->GetSize();
if (scalarType == Detail::Int8)
{
Int8ArrayType::Pointer p = Int8ArrayType::CreateArray(voxels, numberOfComponents, name);
m->addCellData(p->GetName(), p);
for(size_t v = 0; v < size; ++v)
{
p->SetValue(v, ptr->GetValue(v) );
}
}
else if (scalarType == Detail::UInt8)
{
UInt8ArrayType::Pointer p = UInt8ArrayType::CreateArray(voxels, numberOfComponents, name);
m->addCellData(p->GetName(), p);
for(size_t v = 0; v < size; ++v)
{
p->SetValue(v, ptr->GetValue(v) );
}
}
else if (scalarType == Detail::Int16)
{
Int16ArrayType::Pointer p = Int16ArrayType::CreateArray(voxels, numberOfComponents, name);
m->addCellData(p->GetName(), p);
for(size_t v = 0; v < size; ++v)
{
p->SetValue(v, ptr->GetValue(v) );
}
}
else if (scalarType == Detail::UInt16)
{
UInt16ArrayType::Pointer p = UInt16ArrayType::CreateArray(voxels, numberOfComponents, name);
m->addCellData(p->GetName(), p);
for(size_t v = 0; v < size; ++v)
{
p->SetValue(v, ptr->GetValue(v) );
}
}
else if (scalarType == Detail::Int32)
{
Int32ArrayType::Pointer p = Int32ArrayType::CreateArray(voxels, numberOfComponents, name);
m->addCellData(p->GetName(), p);
for(size_t v = 0; v < size; ++v)
{
p->SetValue(v, ptr->GetValue(v) );
}
}
else if (scalarType == Detail::UInt32)
{
UInt32ArrayType::Pointer p = UInt32ArrayType::CreateArray(voxels, numberOfComponents, name);
m->addCellData(p->GetName(), p);
for(size_t v = 0; v < size; ++v)
{
p->SetValue(v, ptr->GetValue(v) );
}
}
else if (scalarType == Detail::Int64)
{
Int64ArrayType::Pointer p = Int64ArrayType::CreateArray(voxels, numberOfComponents, name);
m->addCellData(p->GetName(), p);
for(size_t v = 0; v < size; ++v)
{
p->SetValue(v, ptr->GetValue(v) );
}
}
else if (scalarType == Detail::UInt64)
{
UInt64ArrayType::Pointer p = UInt64ArrayType::CreateArray(voxels, numberOfComponents, name);
m->addCellData(p->GetName(), p);
for(size_t v = 0; v < size; ++v)
{
p->SetValue(v, ptr->GetValue(v) );
}
}
else if (scalarType == Detail::Float)
{
FloatArrayType::Pointer p = FloatArrayType::CreateArray(voxels, numberOfComponents, name);
m->addCellData(p->GetName(), p);
}
else if (scalarType == Detail::Double)
{
DoubleArrayType::Pointer p = DoubleArrayType::CreateArray(voxels, numberOfComponents, name);
m->addCellData(p->GetName(), p);
for(size_t v = 0; v < size; ++v)
{
p->SetValue(v, ptr->GetValue(v) );
}
}
}
