int main(int argc, char **argv)
{
CtfReader reader;
reader.setFileName(argv[1]);
int err = reader.readHeaderOnly();
if (err < 0)
{
std::cout << "Error Trying to read the header for " << argv[1] << std::endl;
}
return 0;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int H5CtfImporter::writeSliceData(hid_t fileId, CtfReader &reader, int z, int actualSlice)
{
// std::cout << "Writing Slice " << actualSlice << " as " << z << std::endl;
int err = 0;
// Start creating the HDF5 group structures for this file
hid_t ctfGroup = H5Utilities::createGroup(fileId, StringUtils::numToString(z));
if(ctfGroup < 0)
{
std::ostringstream ss;
ss << "H5CtfImporter Error: A Group for Z index " << z << " could not be created."
<< " Please check other error messages from the HDF5 library for possible reasons.";
setPipelineMessage(ss.str());
setErrorCondition(-500);
return -1;
}
hid_t gid = H5Utilities::createGroup(ctfGroup, Ebsd::H5::Header);
if(gid < 0)
{
std::ostringstream ss;
ss << "H5CtfImporter Error: The 'Header' Group for Z index " << z << " could not be created."
<< " Please check other error messages from the HDF5 library for possible reasons.";
progressMessage(ss.str(), 100);
err = H5Gclose(ctfGroup);
setPipelineMessage(ss.str());
setErrorCondition(-600);
return -1;
}
WRITE_EBSD_HEADER_STRING_DATA(reader, std::string, Prj, Ebsd::Ctf::Prj);
WRITE_EBSD_HEADER_STRING_DATA(reader, std::string, Author, Ebsd::Ctf::Author);
WRITE_EBSD_HEADER_STRING_DATA(reader, std::string, JobMode, Ebsd::Ctf::JobMode);
WRITE_EBSD_HEADER_DATA(reader, int, XCells, Ebsd::Ctf::XCells)
xDim = reader.getXCells();
WRITE_EBSD_HEADER_DATA(reader, int, YCells, Ebsd::Ctf::YCells)
yDim = reader.getYCells();
WRITE_EBSD_HEADER_DATA(reader, float, XStep, Ebsd::Ctf::XStep)
xRes = reader.getXStep();
WRITE_EBSD_HEADER_DATA(reader, float, YStep, Ebsd::Ctf::YStep)
yRes = reader.getYStep();
float* zPtr = reader.getZPointer();
if(NULL != zPtr)
{
WRITE_EBSD_HEADER_DATA(reader, int, ZCells, Ebsd::Ctf::ZCells)
zDim = reader.getZCells();
WRITE_EBSD_HEADER_DATA(reader, float, ZStep, Ebsd::Ctf::ZStep)
zRes = reader.getZStep();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
int H5CtfImporter::importFile(hid_t fileId, int64_t z, const std::string &ctfFile)
{
herr_t err = -1;
setCancel(false);
setErrorCondition(0);
setPipelineMessage("");
// std::cout << "H5CtfImporter: Importing " << ctfFile << std::endl;
CtfReader reader;
reader.setFileName(ctfFile);
// Now actually read the file
err = reader.readFile();
// Check for errors
if (err < 0)
{
std::ostringstream ss;
if (err == -200)
{
ss << "H5CtfImporter Error: There was no data in the file.";
}
else if (err == -100)
{
ss << "H5CtfImporter Error: The Ctf file could not be opened.";
}
else if (reader.getXStep() == 0.0f)
{
ss << "H5CtfImporter Error: X Step value equals 0.0. This is bad. Please check the validity of the CTF file.";
}
else if(reader.getYStep() == 0.0f)
{
ss << "H5CtfImporter Error: Y Step value equals 0.0. This is bad. Please check the validity of the CTF file.";
}
else
{
ss << reader.getErrorMessage();
}
setPipelineMessage(ss.str());
setErrorCondition(err);
progressMessage(ss.str(), 100);
return -1;
}
// Write the fileversion attribute if it does not exist
{
std::vector<hsize_t> dims;
H5T_class_t type_class;
size_t type_size = 0;
hid_t attr_type = -1;
err = H5Lite::getAttributeInfo(fileId, "/", Ebsd::H5::FileVersionStr, dims, type_class, type_size, attr_type);
if (attr_type < 0) // The attr_type variable was never set which means the attribute was NOT there
{
// The file version does not exist so write it to the file
err = H5Lite::writeScalarAttribute(fileId, "/", Ebsd::H5::FileVersionStr, m_FileVersion);
}
else
{
H5Aclose(attr_type);
}
}
bool multiSliceFile = false;
// Now we have to figure out if this file is really a 3D file. We can do that
// by looking for the "Z" position array. Only 3D files will have this:
float* zPtr = reader.getZPointer();
if(NULL != zPtr)
{
multiSliceFile = true;
}
int zSlices = reader.getZCells();
// This scheme is going to fail if the user has multiple HKL 3D files where each
// file as multiple slices. We really need to keep track of what slice we are
// on at the next level up that this level.
m_NumSlicesImported = 0;
for(int slice = 0; slice < zSlices; ++slice)
{
writeSliceData(fileId, reader, static_cast<int>(z) + slice, slice);
++m_NumSlicesImported;
}
return err;
}
