// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void StatsGenODFWidget::extractStatsData(int index, StatsData* statsData, unsigned int phaseType) { VectorOfFloatArray arrays; if(phaseType == DREAM3D::PhaseType::PrimaryPhase) { PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsData); arrays = pp->getODF_Weights(); } if(phaseType == DREAM3D::PhaseType::PrecipitatePhase) { PrecipitateStatsData* pp = PrecipitateStatsData::SafePointerDownCast(statsData); arrays = pp->getODF_Weights(); } if(phaseType == DREAM3D::PhaseType::TransformationPhase) { TransformationStatsData* tp = TransformationStatsData::SafePointerDownCast(statsData); arrays = tp->getODF_Weights(); } if (arrays.size() > 0) { QVector<float> e1(static_cast<int>(arrays[0]->getNumberOfTuples())); ::memcpy( e1.data(), arrays[0]->getVoidPointer(0), sizeof(float)*e1.size() ); QVector<float> e2(static_cast<int>(arrays[1]->getNumberOfTuples())); ::memcpy( e2.data(), arrays[1]->getVoidPointer(0), sizeof(float)*e2.size() ); QVector<float> e3(static_cast<int>(arrays[2]->getNumberOfTuples())); ::memcpy( e3.data(), arrays[2]->getVoidPointer(0), sizeof(float)*e3.size() ); QVector<float> weights(static_cast<int>(arrays[3]->getNumberOfTuples())); ::memcpy( weights.data(), arrays[3]->getVoidPointer(0), sizeof(float)*weights.size() ); QVector<float> sigmas(static_cast<int>(arrays[4]->getNumberOfTuples())); ::memcpy( sigmas.data(), arrays[4]->getVoidPointer(0), sizeof(float)*sigmas.size() ); // Convert from Radians to Degrees for the Euler Angles for(int i = 0; i < e1.size(); ++i) { e1[i] = e1[i] * 180.0f / M_PI; e2[i] = e2[i] * 180.0f / M_PI; e3[i] = e3[i] * 180.0f / M_PI; } if(e1.size() > 0) { // Load the data into the table model m_ODFTableModel->setTableData(e1, e2, e3, weights, sigmas); } } // Write the MDF Data if we have that functionality enabled if (m_MDFWidget != NULL) { m_MDFWidget->extractStatsData(index, statsData, phaseType); } updatePlots(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void StatsGenMDFWidget::extractStatsData(int index, StatsData* statsData, unsigned int phaseType) { Q_UNUSED(index) VectorOfFloatArray arrays; if(phaseType == SIMPL::PhaseType::PrimaryPhase) { PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsData); arrays = pp->getMDF_Weights(); } if(phaseType == SIMPL::PhaseType::PrecipitatePhase) { PrecipitateStatsData* pp = PrecipitateStatsData::SafePointerDownCast(statsData); arrays = pp->getMDF_Weights(); } if(phaseType == SIMPL::PhaseType::TransformationPhase) { TransformationStatsData* tp = TransformationStatsData::SafePointerDownCast(statsData); arrays = tp->getMDF_Weights(); } QVector<float> axis; QVector<float> angle; QVector<float> weights; for (int i = 0; i < arrays.size(); i++) { if(arrays[i]->getName().compare(SIMPL::StringConstants::Axis) == 0) { axis = QVector<float>(static_cast<int>(arrays[i]->getSize())); // This one is 3xn in size ::memcpy( &(axis.front()), arrays[i]->getVoidPointer(0), sizeof(float)*axis.size() ); } if(arrays[i]->getName().compare(SIMPL::StringConstants::Angle) == 0) { angle = QVector<float>(static_cast<int>(arrays[i]->getNumberOfTuples())); ::memcpy( &(angle.front()), arrays[i]->getVoidPointer(0), sizeof(float)*angle.size() ); } if(arrays[i]->getName().compare(SIMPL::StringConstants::Weight) == 0) { weights = QVector<float>(static_cast<int>(arrays[i]->getNumberOfTuples())); ::memcpy( &(weights.front()), arrays[i]->getVoidPointer(0), sizeof(float)*weights.size() ); } } if (arrays.size() > 0) { // Load the data into the table model m_MDFTableModel->setTableData(angle, axis, weights); } on_m_MDFUpdateBtn_clicked(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- 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); } } } }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void FindAxisODF::execute() { VoxelDataContainer* m = getVoxelDataContainer(); if(NULL == m) { setErrorCondition(-999); notifyErrorMessage("The DataContainer Object was NULL", -999); return; } setErrorCondition(0); dataCheck(false, m->getTotalPoints(), m->getNumFieldTuples(), m->getNumEnsembleTuples()); if(getErrorCondition() < 0) { return; } StatsDataArray& statsDataArray = *m_StatsDataArray; typedef DataArray<unsigned int> XTalType; XTalType* crystruct = XTalType::SafeObjectDownCast<IDataArray*, XTalType*>(m->getEnsembleData(DREAM3D::EnsembleData::CrystalStructures).get()); float r1, r2, r3; int bin; std::vector<FloatArrayType::Pointer> axisodf; std::vector<float> totalaxes; size_t numXTals = crystruct->GetNumberOfTuples(); axisodf.resize(numXTals); totalaxes.resize(numXTals); for (size_t i = 1; i < numXTals; i++) { totalaxes[i] = 0.0; axisodf[i] = FloatArrayType::CreateArray((36 * 36 * 36), DREAM3D::HDF5::AxisOrientation); for (int j = 0; j < (36 * 36 * 36); j++) { axisodf[i]->SetValue(j, 0.0); } } size_t numgrains = m->getNumFieldTuples(); for (size_t i = 0; i < numgrains; i++) { if(m_SurfaceFields[i] == false) { totalaxes[m_FieldPhases[i]]++; } } for (size_t i = 1; i < numgrains; i++) { float ea1 = m_AxisEulerAngles[3 * i]; float ea2 = m_AxisEulerAngles[3 * i + 1]; float ea3 = m_AxisEulerAngles[3 * i + 2]; if(m_SurfaceFields[i] == 0) { OrientationMath::EulerToRod( ea1, ea2, ea3, r1, r2, r3); m_OrientationOps[Ebsd::CrystalStructure::OrthoRhombic]->getODFFZRod(r1, r2, r3); bin = m_OrientationOps[Ebsd::CrystalStructure::OrthoRhombic]->getOdfBin(r1, r2, r3); axisodf[m_FieldPhases[i]]->SetValue(bin, (axisodf[m_FieldPhases[i]]->GetValue(bin) + static_cast<float>((1.0 / totalaxes[m_FieldPhases[i]])))); } } // int err; for (size_t i = 1; i < numXTals; i++) { if(m_PhaseTypes[i] == DREAM3D::PhaseType::PrimaryPhase) { PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsDataArray[i].get()); pp->setAxisOrientation(axisodf[i]); } if(m_PhaseTypes[i] == DREAM3D::PhaseType::PrecipitatePhase) { PrecipitateStatsData* pp = PrecipitateStatsData::SafePointerDownCast(statsDataArray[i].get()); pp->setAxisOrientation(axisodf[i]); } if(m_PhaseTypes[i] == DREAM3D::PhaseType::TransformationPhase) { TransformationStatsData* tp = TransformationStatsData::SafePointerDownCast(statsDataArray[i].get()); tp->setAxisOrientation(axisodf[i]); } } notifyStatusMessage("Completed"); }