// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int H5PrimaryStatsDataDelegate::readAxisODFWeights(hid_t pid, PrimaryStatsData* data)
{
int err = 0;
FloatArrayType::Pointer euler1 = FloatArrayType::CreateArray(0, DREAM3D::HDF5::Euler1);
FloatArrayType::Pointer euler2 = FloatArrayType::CreateArray(0, DREAM3D::HDF5::Euler2);
FloatArrayType::Pointer euler3 = FloatArrayType::CreateArray(0, DREAM3D::HDF5::Euler3);
FloatArrayType::Pointer sigma = FloatArrayType::CreateArray(0, DREAM3D::HDF5::Sigma);
FloatArrayType::Pointer weight = FloatArrayType::CreateArray(0, DREAM3D::HDF5::Weight);
VectorOfFloatArray odfWeights;
odfWeights.push_back(euler1);
odfWeights.push_back(euler2);
odfWeights.push_back(euler3);
odfWeights.push_back(sigma);
odfWeights.push_back(weight);
hid_t groupId = H5Utilities::openHDF5Object(pid, DREAM3D::HDF5::AxisODFWeights);
if (groupId > 0)
{
err = readVectorOfArrays(groupId, odfWeights);
if(err >= 0)
{
data->setAxisODF_Weights(odfWeights);
}
}
err |= H5Utilities::closeHDF5Object(groupId);
return err;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int H5PrimaryStatsDataDelegate::readMDFWeights(hid_t pid, PrimaryStatsData* data)
{
int err = 0;
QVector<size_t> dims(1, 1);
FloatArrayType::Pointer angles = FloatArrayType::CreateArray(1, dims, DREAM3D::StringConstants::Angle);
FloatArrayType::Pointer weight = FloatArrayType::CreateArray(1, DREAM3D::StringConstants::Weight);
dims[0] = 3;
FloatArrayType::Pointer axis = FloatArrayType::CreateArray(3, dims, DREAM3D::StringConstants::Axis);
VectorOfFloatArray mdfWeights;
mdfWeights.push_back(angles);
mdfWeights.push_back(axis);
mdfWeights.push_back(weight);
hid_t groupId = QH5Utilities::openHDF5Object(pid, DREAM3D::StringConstants::MDFWeights);
if (groupId > 0)
{
err = readVectorOfArrays(groupId, mdfWeights);
if(err >= 0)
{
data->setMDF_Weights(mdfWeights);
}
}
err = QH5Utilities::closeHDF5Object(groupId);
return err;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int H5PrimaryStatsDataDelegate::readMDFWeights(hid_t pid, PrimaryStatsData* data)
{
int err = 0;
FloatArrayType::Pointer angles = FloatArrayType::CreateArray(1, DREAM3D::HDF5::Angle);
FloatArrayType::Pointer axis = FloatArrayType::CreateArray(3, DREAM3D::HDF5::Axis);
axis->SetNumberOfComponents(3);
FloatArrayType::Pointer weight = FloatArrayType::CreateArray(1, DREAM3D::HDF5::Weight);
VectorOfFloatArray mdfWeights;
mdfWeights.push_back(angles);
mdfWeights.push_back(axis);
mdfWeights.push_back(weight);
hid_t groupId = H5Utilities::openHDF5Object(pid, DREAM3D::HDF5::MDFWeights);
if (groupId > 0)
{
err = readVectorOfArrays(groupId, mdfWeights);
if(err >= 0)
{
data->setMDF_Weights(mdfWeights);
}
}
err = H5Utilities::closeHDF5Object(groupId);
return err;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int H5TransformationStatsDataDelegate::readODFWeights(hid_t pid, TransformationStatsData* data)
{
int err = 0;
FloatArrayType::Pointer euler1 = FloatArrayType::CreateArray(0, DREAM3D::StringConstants::Euler1);
FloatArrayType::Pointer euler2 = FloatArrayType::CreateArray(0, DREAM3D::StringConstants::Euler2);
FloatArrayType::Pointer euler3 = FloatArrayType::CreateArray(0, DREAM3D::StringConstants::Euler3);
FloatArrayType::Pointer weight = FloatArrayType::CreateArray(0, DREAM3D::StringConstants::Weight);
FloatArrayType::Pointer sigma = FloatArrayType::CreateArray(0, DREAM3D::StringConstants::Sigma);
VectorOfFloatArray odfWeights;
odfWeights.push_back(euler1);
odfWeights.push_back(euler2);
odfWeights.push_back(euler3);
odfWeights.push_back(weight);
odfWeights.push_back(sigma);
hid_t groupId = QH5Utilities::openHDF5Object(pid, DREAM3D::StringConstants::ODFWeights);
err = readVectorOfArrays(groupId, odfWeights);
if(err >= 0)
{
data->setODF_Weights(odfWeights);
}
err |= QH5Utilities::closeHDF5Object(groupId);
return err;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
VectorOfFloatArray StatsGenPlotWidget::getStatisticsData()
{
VectorOfFloatArray data;
if (m_StatsType == DREAM3D::StatisticsType::UnknownStatisticsGroup)
{
QMessageBox::critical(this, tr("StatsGenerator"),
tr("This Plot has not been assigned a Statistics Group. This should be happening from within the program. Contact the developer."),
QMessageBox::Ok,
QMessageBox::Ok);
return data;
}
if (m_DistributionType == DREAM3D::DistributionType::UnknownDistributionType)
{
QMessageBox::critical(this, tr("StatsGenerator"),
tr("This Plot has not been assigned a known Distribution Type. This should be happening from within the program. Contact the developer."),
QMessageBox::Ok,
QMessageBox::Ok);
return data;
}
FloatArrayType::Pointer col0;
FloatArrayType::Pointer col1;
FloatArrayType::Pointer col2;
QVector<float> v0;
QVector<float> v1;
QVector<float> v2;
Q_ASSERT(m_PhaseIndex >= 0);
// Create a new Table Model
switch(m_DistributionType)
{
case DREAM3D::DistributionType::Beta:
v0 = m_TableModel->getData(SGBetaTableModel::Alpha);
v1 = m_TableModel->getData(SGBetaTableModel::Beta);
col0 = FloatArrayType::FromQVector(v0, DREAM3D::StringConstants::Alpha);
col1 = FloatArrayType::FromQVector(v1, DREAM3D::StringConstants::Beta);
data.push_back(col0);
data.push_back(col1);
break;
case DREAM3D::DistributionType::LogNormal:
v0 = m_TableModel->getData(SGLogNormalTableModel::Average);
v1 = m_TableModel->getData(SGLogNormalTableModel::StdDev);
col0 = FloatArrayType::FromQVector(v0, DREAM3D::StringConstants::Average);
col1 = FloatArrayType::FromQVector(v1, DREAM3D::StringConstants::StandardDeviation);
data.push_back(col0);
data.push_back(col1);
break;
case DREAM3D::DistributionType::Power:
v0 = m_TableModel->getData(SGPowerLawTableModel::Alpha);
v1 = m_TableModel->getData(SGPowerLawTableModel::K);
v2 = m_TableModel->getData(SGPowerLawTableModel::Beta);
col0 = FloatArrayType::FromQVector(v0, DREAM3D::StringConstants::Alpha);
col1 = FloatArrayType::FromQVector(v1, DREAM3D::StringConstants::Exp_k);
col2 = FloatArrayType::FromQVector(v2, DREAM3D::StringConstants::Beta);
data.push_back(col0);
data.push_back(col1);
data.push_back(col2);
break;
default:
return data;
}
return data;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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);
}
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void StatsGeneratorUtilities::GenerateMisorientationBinData(StatsData* statsData,
unsigned int phaseType, unsigned int crystalStruct,
QVector<float> &odf,
QVector<float> &angles, QVector<float> &axes,
QVector<float> &weights, bool computeMDF)
{
QVector<float> x;
QVector<float> y;
QVector<float> mdf;
if (Ebsd::CrystalStructure::Cubic_High == crystalStruct)
{
mdf.resize(CubicOps::k_MdfSize);
if (computeMDF) { Texture::CalculateMDFData<float, CubicOps>(angles.data(), axes.data(), weights.data(), odf.data(), mdf.data(), angles.size()); }
//nElements = 18 * 18 * 18;
}
else if (Ebsd::CrystalStructure::Hexagonal_High == crystalStruct)
{
mdf.resize(HexagonalOps::k_MdfSize);
if (computeMDF) { Texture::CalculateMDFData<float, HexagonalOps>(angles.data(), axes.data(), weights.data(), odf.data(), mdf.data(), angles.size()); }
//nElements = 36 * 36 * 12;
}
if (mdf.size() > 0)
{
FloatArrayType::Pointer p = FloatArrayType::FromPointer(mdf.data(), mdf.size(), SIMPL::StringConstants::MisorientationBins);
if (phaseType == SIMPL::PhaseType::PrimaryPhase)
{
PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsData);
pp->setMisorientationBins(p);
}
if (phaseType == SIMPL::PhaseType::PrecipitatePhase)
{
PrecipitateStatsData* pp = PrecipitateStatsData::SafePointerDownCast(statsData);
pp->setMisorientationBins(p);
}
if (phaseType == SIMPL::PhaseType::TransformationPhase)
{
TransformationStatsData* tp = TransformationStatsData::SafePointerDownCast(statsData);
tp->setMisorientationBins(p);
}
if (angles.size() > 0)
{
FloatArrayType::Pointer anglesArray = FloatArrayType::FromPointer(angles.data(), angles.size(), SIMPL::StringConstants::Angle);
FloatArrayType::Pointer axisArray = FloatArrayType::FromPointer(axes.data(), axes.size(), SIMPL::StringConstants::Axis);
FloatArrayType::Pointer weightArray = FloatArrayType::FromPointer(weights.data(), weights.size(), SIMPL::StringConstants::Weight);
VectorOfFloatArray mdfWeights;
mdfWeights.push_back(anglesArray);
mdfWeights.push_back(axisArray);
mdfWeights.push_back(weightArray);
if (phaseType == SIMPL::PhaseType::PrimaryPhase)
{
PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsData);
pp->setMDF_Weights(mdfWeights);
}
if (phaseType == SIMPL::PhaseType::PrecipitatePhase)
{
PrecipitateStatsData* pp = PrecipitateStatsData::SafePointerDownCast(statsData);
pp->setMDF_Weights(mdfWeights);
}
if (phaseType == SIMPL::PhaseType::TransformationPhase)
{
TransformationStatsData* tp = TransformationStatsData::SafePointerDownCast(statsData);
tp->setMDF_Weights(mdfWeights);
}
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void StatsGeneratorUtilities::GenerateAxisODFBinData(StatsData* statsData, unsigned int phaseType,
QVector<float> &e1s, QVector<float> &e2s,
QVector<float> &e3s, QVector<float> &weights,
QVector<float> &sigmas, bool computeAxisODF)
{
QVector<float> aodf;
size_t numEntries = e1s.size();
aodf.resize(OrthoRhombicOps::k_OdfSize);
if (computeAxisODF) { Texture::CalculateOrthoRhombicODFData(e1s.data(), e2s.data(), e3s.data(),
weights.data(), sigmas.data(), true,
aodf.data(), numEntries); }
if (aodf.size() > 0)
{
FloatArrayType::Pointer aodfData = FloatArrayType::FromQVector(aodf, SIMPL::StringConstants::AxisOrientation);
if (phaseType == SIMPL::PhaseType::PrimaryPhase)
{
PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsData);
pp->setAxisOrientation(aodfData);
}
if (phaseType == SIMPL::PhaseType::PrecipitatePhase)
{
PrecipitateStatsData* pp = PrecipitateStatsData::SafePointerDownCast(statsData);
pp->setAxisOrientation(aodfData);
}
if (phaseType == SIMPL::PhaseType::TransformationPhase)
{
TransformationStatsData* tp = TransformationStatsData::SafePointerDownCast(statsData);
tp->setAxisOrientation(aodfData);
}
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 aodfWeights;
aodfWeights.push_back(euler1);
aodfWeights.push_back(euler2);
aodfWeights.push_back(euler3);
aodfWeights.push_back(sigma);
aodfWeights.push_back(weight);
if (phaseType == SIMPL::PhaseType::PrimaryPhase)
{
PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsData);
pp->setAxisODF_Weights(aodfWeights);
}
if (phaseType == SIMPL::PhaseType::PrecipitatePhase)
{
PrecipitateStatsData* pp = PrecipitateStatsData::SafePointerDownCast(statsData);
pp->setAxisODF_Weights(aodfWeights);
}
if (phaseType == SIMPL::PhaseType::TransformationPhase)
{
TransformationStatsData* tp = TransformationStatsData::SafePointerDownCast(statsData);
tp->setAxisODF_Weights(aodfWeights);
}
}
}
}