// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void StatsGenODFWidget::on_loadODFTextureBtn_clicked()
{
QString file = angleFilePath->text();
if(true == file.isEmpty())
{
return;
}
QFileInfo fi(angleFilePath->text());
if(fi.exists() == false)
{
return;
}
size_t count = 0;
QVector<float> e1s(count);
QVector<float> e2s(count);
QVector<float> e3s(count);
QVector<float> weights(count);
QVector<float> sigmas(count);
QProgressDialog progress("Loading Data ....", "Cancel", 0, 3, this);
progress.setWindowModality(Qt::WindowModal);
progress.setMinimumDuration(2000);
if (fi.suffix().compare(Ebsd::Ang::FileExt) == 0)
{
progress.setValue(1);
progress.setLabelText("[1/3] Reading File ...");
AngReader loader;
loader.setFileName(angleFilePath->text());
int err = loader.readFile();
if(err < 0)
{
QMessageBox::critical(this, "Error loading the ANG file", loader.getErrorMessage(), QMessageBox::Ok);
return;
}
float* phi1 = loader.getPhi1Pointer();
float* phi = loader.getPhiPointer();
float* phi2 = loader.getPhi2Pointer();
int xDim = loader.getXDimension();
int yDim = loader.getYDimension();
count = xDim * yDim;
e1s.resize(count);
e2s.resize(count);
e3s.resize(count);
weights.resize(count);
sigmas.resize(count);
for(size_t i = 0; i < count; ++i)
{
e1s[i] = phi1[i];
e2s[i] = phi[i];
e3s[i] = phi2[i];
weights[i] = 1.0;
sigmas[i] = 0.0;
}
}
else if (fi.suffix().compare(Ebsd::Ctf::FileExt) == 0)
{
progress.setValue(1);
progress.setLabelText("[1/3] Reading File ...");
CtfReader loader;
loader.setFileName(angleFilePath->text());
int err = loader.readFile();
if(err < 0)
{
QMessageBox::critical(this, "Error loading the CTF file", loader.getErrorMessage(), QMessageBox::Ok);
return;
}
float* phi1 = loader.getEuler1Pointer();
float* phi = loader.getEuler2Pointer();
float* phi2 = loader.getEuler3Pointer();
int xDim = loader.getXDimension();
int yDim = loader.getYDimension();
count = xDim * yDim;
e1s.resize(count);
e2s.resize(count);
e3s.resize(count);
weights.resize(count);
sigmas.resize(count);
for(size_t i = 0; i < count; ++i)
{
e1s[i] = phi1[i];
e2s[i] = phi[i];
e3s[i] = phi2[i];
weights[i] = 1.0;
sigmas[i] = 0.0;
}
}
else
{
progress.setValue(1);
progress.setLabelText("[1/3] Reading File ...");
AngleFileLoader::Pointer loader = AngleFileLoader::New();
loader->setInputFile(angleFilePath->text());
loader->setAngleRepresentation(angleRepresentation->currentIndex());
loader->setFileAnglesInDegrees(anglesInDegrees->isChecked());
loader->setOutputAnglesInDegrees(true);
QString delim;
int index = delimiter->currentIndex();
switch(index)
{
case 0:
delim = " ";
break;
case 1:
delim = "\t";
break;
case 2:
delim = ",";
break;
case 3:
delim = ";";
break;
default:
delim = " ";
}
loader->setDelimiter(delim);
FloatArrayType::Pointer data = loader->loadData();
if (loader->getErrorCode() < 0)
{
QMessageBox::critical(this, "Error Loading Angle data", loader->getErrorMessage(), QMessageBox::Ok);
return;
}
count = data->getNumberOfTuples();
e1s.resize(count);
e2s.resize(count);
e3s.resize(count);
weights.resize(count);
sigmas.resize(count);
for(size_t i = 0; i < count; ++i)
{
e1s[i] = data->getComponent(i, 0);
e2s[i] = data->getComponent(i, 1);
e3s[i] = data->getComponent(i, 2);
weights[i] = data->getComponent(i, 3);
sigmas[i] = data->getComponent(i, 4);
}
}
progress.setValue(2);
progress.setLabelText("[2/3] Rendering Pole Figure ...");
m_OdfBulkTableModel->removeRows(0, m_OdfBulkTableModel->rowCount());
#if 1
m_OdfBulkTableModel->blockSignals(true);
m_OdfBulkTableModel->setColumnData(SGODFTableModel::Euler1, e1s);
m_OdfBulkTableModel->setColumnData(SGODFTableModel::Euler2, e2s);
m_OdfBulkTableModel->setColumnData(SGODFTableModel::Euler3, e3s);
m_OdfBulkTableModel->setColumnData(SGODFTableModel::Weight, weights);
m_OdfBulkTableModel->setColumnData(SGODFTableModel::Sigma, sigmas);
m_OdfBulkTableModel->blockSignals(false);
#endif
on_m_CalculateODFBtn_clicked();
progress.setValue(3);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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");
}
