// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- 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 ConvertOrientations::dataCheck() { setErrorCondition(0); if(getInputType() == getOutputType()) { QString ss = QObject::tr("Input and output orientation representation types must be different"); setErrorCondition(-1000); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); } if( getInputType() < OrientationConverter<float>::GetMinIndex() || getInputType() > OrientationConverter<float>::GetMaxIndex() ) { QString ss = QObject::tr("There was an error with teh selection of the input orientation type. The valid values range from 0 to %1").arg(OrientationConverter<float>::GetMaxIndex()); setErrorCondition(-1001); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); } if( getOutputType() < OrientationConverter<float>::GetMinIndex() || getOutputType() > OrientationConverter<float>::GetMaxIndex() ) { QString ss = QObject::tr("There was an error with the selection of the output orientation type. The valid values range from 0 to %1").arg(OrientationConverter<float>::GetMaxIndex()); setErrorCondition(-1002); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); } // We need to return NOW because the next lines assume we have and index that is within // the valid bounds if(getErrorCondition() < 0) { return; } // Figure out what kind of Array the user selected // Get the input data and create the output Data appropriately 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()]); getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<float>, AbstractFilter, float>(this, outputArrayPath, 0, outputCDims); } 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()]); getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<double>, AbstractFilter, double>(this, outputArrayPath, 0, outputCDims); } }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void StatsGenODFWidget::on_m_CalculateODFBtn_clicked() { int err = 0; QwtArray<float> e1s; QwtArray<float> e2s; QwtArray<float> e3s; QwtArray<float> weights; QwtArray<float> sigmas; QwtArray<float> odf; SGODFTableModel* tableModel = NULL; if(weightSpreadGroupBox->isChecked() ) { tableModel = m_ODFTableModel; } else { tableModel = m_OdfBulkTableModel; } e1s = tableModel->getData(SGODFTableModel::Euler1); e2s = tableModel->getData(SGODFTableModel::Euler2); e3s = tableModel->getData(SGODFTableModel::Euler3); weights = tableModel->getData(SGODFTableModel::Weight); sigmas = tableModel->getData(SGODFTableModel::Sigma); // Convert from Degrees to Radians for(int 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(); int imageSize = pfImageSize->value(); int lamberSize = pfLambertSize->value(); int numColors = 16; int npoints = pfSamplePoints->value(); QVector<size_t> dims(1, 3); FloatArrayType::Pointer eulers = FloatArrayType::CreateArray(npoints, dims, "Eulers"); PoleFigureConfiguration_t config; QVector<UInt8ArrayType::Pointer> figures; if ( Ebsd::CrystalStructure::Cubic_High == m_CrystalStructure) { // We now need to resize all the arrays here to make sure they are all allocated odf.resize(CubicOps::k_OdfSize); Texture::CalculateCubicODFData(e1s.data(), e2s.data(), e3s.data(), weights.data(), sigmas.data(), true, odf.data(), numEntries); err = StatsGen::GenCubicODFPlotData(odf.data(), eulers->getPointer(0), npoints); CubicOps ops; config.eulers = eulers.get(); config.imageDim = imageSize; config.lambertDim = lamberSize; config.numColors = numColors; figures = ops.generatePoleFigure(config); } else if ( Ebsd::CrystalStructure::Hexagonal_High == m_CrystalStructure) { // We now need to resize all the arrays here to make sure they are all allocated odf.resize(HexagonalOps::k_OdfSize); Texture::CalculateHexODFData(e1s.data(), e2s.data(), e3s.data(), weights.data(), sigmas.data(), true, odf.data(), numEntries); err = StatsGen::GenHexODFPlotData(odf.data(), eulers->getPointer(0), npoints); HexagonalOps ops; config.eulers = eulers.get(); config.imageDim = imageSize; config.lambertDim = lamberSize; config.numColors = numColors; figures = ops.generatePoleFigure(config); } else if ( Ebsd::CrystalStructure::OrthoRhombic == m_CrystalStructure) { // // We now need to resize all the arrays here to make sure they are all allocated odf.resize(OrthoRhombicOps::k_OdfSize); Texture::CalculateOrthoRhombicODFData(e1s.data(), e2s.data(), e3s.data(), weights.data(), sigmas.data(), true, odf.data(), numEntries); err = StatsGen::GenOrthoRhombicODFPlotData(odf.data(), eulers->getPointer(0), npoints); OrthoRhombicOps ops; config.eulers = eulers.get(); config.imageDim = imageSize; config.lambertDim = lamberSize; config.numColors = numColors; figures = ops.generatePoleFigure(config); } if (err == 1) { //TODO: Present Error Message return; } QImage image = PoleFigureImageUtilities::Create3ImagePoleFigure(figures[0].get(), figures[1].get(), figures[2].get(), config, imageLayout->currentIndex()); m_PoleFigureLabel->setPixmap(QPixmap::fromImage(image)); // Enable the MDF tab if (m_MDFWidget != NULL) { m_MDFWidget->setEnabled(true); m_MDFWidget->updateMDFPlot(odf); } }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void WritePoleFigure::execute() { setErrorCondition(0); dataCheck(); if(getErrorCondition() < 0) { return; } DataContainer::Pointer m = getDataContainerArray()->getDataContainer(m_CellPhasesArrayPath.getDataContainerName()); size_t dims[3] = { 0, 0, 0 }; m->getGeometryAs<ImageGeom>()->getDimensions(dims); // Make sure any directory path is also available as the user may have just typed // in a path without actually creating the full path QDir path(getOutputPath()); if (!path.mkpath(".") ) { QString ss = QObject::tr("Error creating parent path '%1'").arg(path.absolutePath()); setErrorCondition(-1); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); return; } bool missingGoodVoxels = true; if (NULL != m_GoodVoxels) { missingGoodVoxels = false; } // Find how many phases we have by getting the number of Crystal Structures size_t numPoints = m->getGeometryAs<ImageGeom>()->getNumberOfElements(); size_t numPhases = m_CrystalStructuresPtr.lock()->getNumberOfTuples(); // Loop over all the voxels gathering the Eulers for a specific phase into an array for (size_t phase = 1; phase < numPhases; ++phase) { size_t count = 0; // First find out how many voxels we are going to have. This is probably faster to loop twice than to // keep allocating memory everytime we find one. for (size_t i = 0; i < numPoints; ++i) { if (m_CellPhases[i] == phase) { if (missingGoodVoxels == true || m_GoodVoxels[i] == true) { count++; } } } QVector<size_t> eulerCompDim(1, 3); FloatArrayType::Pointer subEulers = FloatArrayType::CreateArray(count, eulerCompDim, "Eulers_Per_Phase"); subEulers->initializeWithValue(std::numeric_limits<float>::signaling_NaN()); float* eu = subEulers->getPointer(0); // Now loop through the eulers again and this time add them to the subEulers Array count = 0; for (size_t i = 0; i < numPoints; ++i) { if (m_CellPhases[i] == phase) { if (missingGoodVoxels == true || m_GoodVoxels[i] == true) { eu[count * 3] = m_CellEulerAngles[i * 3]; eu[count * 3 + 1] = m_CellEulerAngles[i * 3 + 1]; eu[count * 3 + 2] = m_CellEulerAngles[i * 3 + 2]; count++; } } } if (subEulers->getNumberOfTuples() == 0) { continue; } // Skip because we have no Pole Figure data QVector<UInt8ArrayType::Pointer> figures; PoleFigureConfiguration_t config; config.eulers = subEulers.get(); config.imageDim = getImageSize(); config.lambertDim = getLambertSize(); config.numColors = getNumColors(); QString label("Phase_"); label.append(QString::number(phase)); QString ss = QObject::tr("Generating Pole Figures for Phase %1").arg(phase); notifyStatusMessage(getMessagePrefix(), getHumanLabel(), ss); switch(m_CrystalStructures[phase]) { case Ebsd::CrystalStructure::Cubic_High: figures = makePoleFigures<CubicOps>(config); break; case Ebsd::CrystalStructure::Cubic_Low: figures = makePoleFigures<CubicLowOps>(config); break; case Ebsd::CrystalStructure::Hexagonal_High: figures = makePoleFigures<HexagonalOps>(config); break; case Ebsd::CrystalStructure::Hexagonal_Low: figures = makePoleFigures<HexagonalLowOps>(config); break; case Ebsd::CrystalStructure::Trigonal_High: // figures = makePoleFigures<TrigonalOps>(config); notifyWarningMessage(getHumanLabel(), "Trigonal High Symmetry is not supported for Pole figures. This phase will be omitted from results", -1010); break; case Ebsd::CrystalStructure::Trigonal_Low: // figures = makePoleFigures<TrigonalLowOps>(config); notifyWarningMessage(getHumanLabel(), "Trigonal Low Symmetry is not supported for Pole figures. This phase will be omitted from results", -1010); break; case Ebsd::CrystalStructure::Tetragonal_High: // figures = makePoleFigures<TetragonalOps>(config); notifyWarningMessage(getHumanLabel(), "Tetragonal High Symmetry is not supported for Pole figures. This phase will be omitted from results", -1010); break; case Ebsd::CrystalStructure::Tetragonal_Low: // figures = makePoleFigures<TetragonalLowOps>(config); notifyWarningMessage(getHumanLabel(), "Tetragonal Low Symmetry is not supported for Pole figures. This phase will be omitted from results", -1010); break; case Ebsd::CrystalStructure::OrthoRhombic: figures = makePoleFigures<OrthoRhombicOps>(config); break; case Ebsd::CrystalStructure::Monoclinic: figures = makePoleFigures<MonoclinicOps>(config); break; case Ebsd::CrystalStructure::Triclinic: figures = makePoleFigures<TriclinicOps>(config); break; default: break; } if (figures.size() == 3) { QImage combinedImage = PoleFigureImageUtilities::Create3ImagePoleFigure(figures[0].get(), figures[1].get(), figures[2].get(), config, getImageLayout()); writeImage(combinedImage, label); } } /* Let the GUI know we are done with this filter */ notifyStatusMessage(getHumanLabel(), "Complete"); }