// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int StatsGenODFWidget::getOrientationData(StatsData* statsData, unsigned int phaseType)
{
int retErr = 0;
QVector<float> e1s;
QVector<float> e2s;
QVector<float> e3s;
QVector<float> weights;
QVector<float> sigmas;
QVector<float> odf;
// Initialize xMax and yMax....
e1s = m_ODFTableModel->getData(SGODFTableModel::Euler1);
e2s = m_ODFTableModel->getData(SGODFTableModel::Euler2);
e3s = m_ODFTableModel->getData(SGODFTableModel::Euler3);
weights = m_ODFTableModel->getData(SGODFTableModel::Weight);
sigmas = m_ODFTableModel->getData(SGODFTableModel::Sigma);
for (QVector<float>::size_type i = 0; i < e1s.size(); i++)
{
e1s[i] = e1s[i] * M_PI / 180.0;
e2s[i] = e2s[i] * M_PI / 180.0;
e3s[i] = e3s[i] * M_PI / 180.0;
}
size_t numEntries = e1s.size();
if ( Ebsd::CrystalStructure::Cubic_High == m_CrystalStructure)
{
odf.resize(CubicOps::k_OdfSize);
Texture::CalculateCubicODFData(e1s.data(), e2s.data(), e3s.data(),
weights.data(), sigmas.data(), true,
odf.data(), numEntries);
}
else if ( Ebsd::CrystalStructure::Hexagonal_High == m_CrystalStructure)
{
odf.resize(HexagonalOps::k_OdfSize);
Texture::CalculateHexODFData(e1s.data(), e2s.data(), e3s.data(),
weights.data(), sigmas.data(), true,
odf.data(), numEntries);
}
if (odf.size() > 0)
{
FloatArrayType::Pointer p = FloatArrayType::FromQVector(odf, DREAM3D::StringConstants::ODF);
if(phaseType == DREAM3D::PhaseType::PrimaryPhase)
{
PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsData);
pp->setODF(p);
}
if(phaseType == DREAM3D::PhaseType::PrecipitatePhase)
{
PrecipitateStatsData* pp = PrecipitateStatsData::SafePointerDownCast(statsData);
pp->setODF(p);
}
if(phaseType == DREAM3D::PhaseType::TransformationPhase)
{
TransformationStatsData* tp = TransformationStatsData::SafePointerDownCast(statsData);
tp->setODF(p);
}
if (e1s.size() > 0)
{
FloatArrayType::Pointer euler1 = FloatArrayType::FromQVector(e1s, DREAM3D::StringConstants::Euler1);
FloatArrayType::Pointer euler2 = FloatArrayType::FromQVector(e2s, DREAM3D::StringConstants::Euler2);
FloatArrayType::Pointer euler3 = FloatArrayType::FromQVector(e3s, DREAM3D::StringConstants::Euler3);
FloatArrayType::Pointer sigma = FloatArrayType::FromQVector(sigmas, DREAM3D::StringConstants::Sigma);
FloatArrayType::Pointer weight = FloatArrayType::FromQVector(weights, DREAM3D::StringConstants::Weight);
VectorOfFloatArray odfWeights;
odfWeights.push_back(euler1);
odfWeights.push_back(euler2);
odfWeights.push_back(euler3);
odfWeights.push_back(sigma);
odfWeights.push_back(weight);
if(phaseType == DREAM3D::PhaseType::PrimaryPhase)
{
PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsData);
pp->setODF_Weights(odfWeights);
}
if(phaseType == DREAM3D::PhaseType::PrecipitatePhase)
{
PrecipitateStatsData* pp = PrecipitateStatsData::SafePointerDownCast(statsData);
pp->setODF_Weights(odfWeights);
}
if(phaseType == DREAM3D::PhaseType::TransformationPhase)
{
TransformationStatsData* tp = TransformationStatsData::SafePointerDownCast(statsData);
tp->setODF_Weights(odfWeights);
}
}
}
// Write the MDF Data if we have that functionality enabled
if (m_MDFWidget != NULL)
{
m_MDFWidget->getMisorientationData(statsData, phaseType);
}
return retErr;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void StatsGeneratorUtilities::GenerateODFBinData(StatsData* statsData,
unsigned int phaseType, unsigned int crystalStructure,
QVector<float> &e1s, QVector<float> &e2s,
QVector<float> &e3s, QVector<float> &weights,
QVector<float> &sigmas, bool computeODF)
{
QVector<float> odf;
size_t numEntries = e1s.size();
if ( Ebsd::CrystalStructure::Cubic_High == crystalStructure)
{
odf.resize(CubicOps::k_OdfSize);
if (computeODF) { Texture::CalculateCubicODFData(e1s.data(), e2s.data(), e3s.data(),
weights.data(), sigmas.data(), true,
odf.data(), numEntries); }
}
else if ( Ebsd::CrystalStructure::Hexagonal_High == crystalStructure)
{
odf.resize(HexagonalOps::k_OdfSize);
if (computeODF) { Texture::CalculateHexODFData(e1s.data(), e2s.data(), e3s.data(),
weights.data(), sigmas.data(), true,
odf.data(), numEntries); }
}
if (odf.size() > 0)
{
FloatArrayType::Pointer p = FloatArrayType::FromQVector(odf, SIMPL::StringConstants::ODF);
if (phaseType == SIMPL::PhaseType::PrimaryPhase)
{
PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsData);
pp->setODF(p);
}
if (phaseType == SIMPL::PhaseType::PrecipitatePhase)
{
PrecipitateStatsData* pp = PrecipitateStatsData::SafePointerDownCast(statsData);
pp->setODF(p);
}
if (phaseType == SIMPL::PhaseType::TransformationPhase)
{
TransformationStatsData* tp = TransformationStatsData::SafePointerDownCast(statsData);
tp->setODF(p);
}
if (e1s.size() > 0)
{
FloatArrayType::Pointer euler1 = FloatArrayType::FromQVector(e1s, SIMPL::StringConstants::Euler1);
FloatArrayType::Pointer euler2 = FloatArrayType::FromQVector(e2s, SIMPL::StringConstants::Euler2);
FloatArrayType::Pointer euler3 = FloatArrayType::FromQVector(e3s, SIMPL::StringConstants::Euler3);
FloatArrayType::Pointer sigma = FloatArrayType::FromQVector(sigmas, SIMPL::StringConstants::Sigma);
FloatArrayType::Pointer weight = FloatArrayType::FromQVector(weights, SIMPL::StringConstants::Weight);
VectorOfFloatArray odfWeights;
odfWeights.push_back(euler1);
odfWeights.push_back(euler2);
odfWeights.push_back(euler3);
odfWeights.push_back(sigma);
odfWeights.push_back(weight);
if (phaseType == SIMPL::PhaseType::PrimaryPhase)
{
PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsData);
pp->setODF_Weights(odfWeights);
}
if (phaseType == SIMPL::PhaseType::PrecipitatePhase)
{
PrecipitateStatsData* pp = PrecipitateStatsData::SafePointerDownCast(statsData);
pp->setODF_Weights(odfWeights);
}
if (phaseType == SIMPL::PhaseType::TransformationPhase)
{
TransformationStatsData* tp = TransformationStatsData::SafePointerDownCast(statsData);
tp->setODF_Weights(odfWeights);
}
}
}
}