Skip to content

[WIP] ENH: H5 Readers - Allow Separate Scans from Single File #1130

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Draft
nyoungbq wants to merge 9 commits into
base: develop
Choose a base branch
from
Draft

[WIP] ENH: H5 Readers - Allow Separate Scans from Single File #1130

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
9 commits
Select commit Hold shift + click to select a range
f36d608
Inital preflight changes
nyoungbq Nov 6, 2024
d934dbb
simplify and consolidate preflight code (caching not needed, header o…
nyoungbq Nov 6, 2024
80e2d3d
complete h5Oim
nyoungbq Nov 7, 2024
6bf2b2b
Oim patches and Oina intial filter [broken]
nyoungbq Nov 8, 2024
5d2f768
preflight patches for all 3 and added filter preflight updates for E…
nyoungbq Nov 8, 2024
57bdbda
complete baseline algorithms [compiling, uncomplete]
nyoungbq Nov 14, 2024
7e46d45
add origin updating to base reader class and overload in OIM where it…
nyoungbq Nov 14, 2024
4395c39
[Compiling|Functional][UNIT TESTS NEEDED]
nyoungbq Nov 15, 2024
cb5e92c
clang formatting
nyoungbq Nov 15, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
121 changes: 111 additions & 10 deletions ...ugins/OrientationAnalysis/src/OrientationAnalysis/Filters/Algorithms/ReadH5EspritData.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -23,10 +23,26 @@ Result<> ReadH5EspritData::operator()()
return execute();
}

// -----------------------------------------------------------------------------
Result<> ReadH5EspritData::updateOrigin(const std::string& scanName)
{
/*
* Unfortunately, the file does not have the correct data to find an origin.
* This means that the origin will remain {0,0,0}.
*
* Down the line, if a solution crops up, look to ReadH5Oina.cpp for an example
* implementation.
*/
return {};
}

// -----------------------------------------------------------------------------
Result<> ReadH5EspritData::copyRawEbsdData(int index)
{
const auto& imageGeom = m_DataStructure.getDataRefAs<ImageGeom>(m_InputValues->ImageGeometryPath);
const DataPath imagePath(m_InputValues->ImageGeometryPath);
const DataPath cellAMPath = imagePath.createChildPath(m_InputValues->CellAttributeMatrixName);

const auto& imageGeom = m_DataStructure.getDataRefAs<ImageGeom>(imagePath);
const usize totalPoints = imageGeom.getNumXCells() * imageGeom.getNumYCells();
const usize offset = index * totalPoints;

Expand All @@ -35,28 +51,28 @@ Result<> ReadH5EspritData::copyRawEbsdData(int index)
const auto* phi1 = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::H5Esprit::phi1));
const auto* phi = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::H5Esprit::PHI));
const auto* phi2 = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::H5Esprit::phi2));
auto& eulerAngles = m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->CellAttributeMatrixPath.createChildPath(EbsdLib::Esprit::EulerAngles));
auto& eulerAngles = m_DataStructure.getDataRefAs<Float32Array>(cellAMPath.createChildPath(EbsdLib::Esprit::EulerAngles));

const auto* m1 = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::H5Esprit::MAD));
auto& mad = m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->CellAttributeMatrixPath.createChildPath(EbsdLib::H5Esprit::MAD));
auto& mad = m_DataStructure.getDataRefAs<Float32Array>(cellAMPath.createChildPath(EbsdLib::H5Esprit::MAD));

const auto* nIndBands = reinterpret_cast<int32*>(m_Reader->getPointerByName(EbsdLib::H5Esprit::NIndexedBands));
auto& nIndexBands = m_DataStructure.getDataRefAs<Int32Array>(m_InputValues->CellAttributeMatrixPath.createChildPath(EbsdLib::H5Esprit::NIndexedBands));
auto& nIndexBands = m_DataStructure.getDataRefAs<Int32Array>(cellAMPath.createChildPath(EbsdLib::H5Esprit::NIndexedBands));

const auto* p1 = reinterpret_cast<int32*>(m_Reader->getPointerByName(EbsdLib::H5Esprit::Phase));
auto& phase = m_DataStructure.getDataRefAs<Int32Array>(m_InputValues->CellAttributeMatrixPath.createChildPath(EbsdLib::H5Esprit::Phase));
auto& phase = m_DataStructure.getDataRefAs<Int32Array>(cellAMPath.createChildPath(EbsdLib::H5Esprit::Phase));

const auto* radBandCnt = reinterpret_cast<int32*>(m_Reader->getPointerByName(EbsdLib::H5Esprit::RadonBandCount));
auto& radonBandCount = m_DataStructure.getDataRefAs<Int32Array>(m_InputValues->CellAttributeMatrixPath.createChildPath(EbsdLib::H5Esprit::RadonBandCount));
auto& radonBandCount = m_DataStructure.getDataRefAs<Int32Array>(cellAMPath.createChildPath(EbsdLib::H5Esprit::RadonBandCount));

const auto* radQual = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::H5Esprit::RadonQuality));
auto& radonQuality = m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->CellAttributeMatrixPath.createChildPath(EbsdLib::H5Esprit::RadonQuality));
auto& radonQuality = m_DataStructure.getDataRefAs<Float32Array>(cellAMPath.createChildPath(EbsdLib::H5Esprit::RadonQuality));

const auto* xBm = reinterpret_cast<int32*>(m_Reader->getPointerByName(EbsdLib::H5Esprit::XBEAM));
auto& xBeam = m_DataStructure.getDataRefAs<Int32Array>(m_InputValues->CellAttributeMatrixPath.createChildPath(EbsdLib::H5Esprit::XBEAM));
auto& xBeam = m_DataStructure.getDataRefAs<Int32Array>(cellAMPath.createChildPath(EbsdLib::H5Esprit::XBEAM));

const auto* yBm = reinterpret_cast<int32*>(m_Reader->getPointerByName(EbsdLib::H5Esprit::YBEAM));
auto& yBeam = m_DataStructure.getDataRefAs<Int32Array>(m_InputValues->CellAttributeMatrixPath.createChildPath(EbsdLib::H5Esprit::YBEAM));
auto& yBeam = m_DataStructure.getDataRefAs<Int32Array>(cellAMPath.createChildPath(EbsdLib::H5Esprit::YBEAM));

for(size_t i = 0; i < totalPoints; i++)
{
Expand Down Expand Up @@ -91,7 +107,7 @@ Result<> ReadH5EspritData::copyRawEbsdData(int index)
std::vector<usize> pDimsV(2);
pDimsV[0] = pDims[0];
pDimsV[1] = pDims[1];
auto& patternData = m_DataStructure.getDataRefAs<UInt8Array>(m_InputValues->CellAttributeMatrixPath.createChildPath(EbsdLib::H5Esprit::RawPatterns));
auto& patternData = m_DataStructure.getDataRefAs<UInt8Array>(cellAMPath.createChildPath(EbsdLib::H5Esprit::RawPatterns));
const usize numComponents = patternData.getNumberOfComponents();
for(usize i = 0; i < totalPoints; i++)
{
Expand All @@ -105,3 +121,88 @@ Result<> ReadH5EspritData::copyRawEbsdData(int index)

return {};
}

// -----------------------------------------------------------------------------
Result<> ReadH5EspritData::copyRawEbsdData(const std::string& scanName)
{
const DataPath imagePath({scanName});
const DataPath cellAMPath = imagePath.createChildPath(m_InputValues->CellAttributeMatrixName);

const auto& imageGeom = m_DataStructure.getDataRefAs<ImageGeom>(imagePath);
const usize totalPoints = imageGeom.getNumXCells() * imageGeom.getNumYCells();

{
const float32 degToRad = m_EspritInputValues->DegreesToRadians ? Constants::k_PiOver180F : 1.0f;
const auto* phi1 = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::H5Esprit::phi1));
const auto* phi = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::H5Esprit::PHI));
const auto* phi2 = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::H5Esprit::phi2));
auto& eulerAngles = m_DataStructure.getDataRefAs<Float32Array>(cellAMPath.createChildPath(EbsdLib::Esprit::EulerAngles));

const auto* m1 = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::H5Esprit::MAD));
auto& mad = m_DataStructure.getDataRefAs<Float32Array>(cellAMPath.createChildPath(EbsdLib::H5Esprit::MAD));

const auto* nIndBands = reinterpret_cast<int32*>(m_Reader->getPointerByName(EbsdLib::H5Esprit::NIndexedBands));
auto& nIndexBands = m_DataStructure.getDataRefAs<Int32Array>(cellAMPath.createChildPath(EbsdLib::H5Esprit::NIndexedBands));

const auto* p1 = reinterpret_cast<int32*>(m_Reader->getPointerByName(EbsdLib::H5Esprit::Phase));
auto& phase = m_DataStructure.getDataRefAs<Int32Array>(cellAMPath.createChildPath(EbsdLib::H5Esprit::Phase));

const auto* radBandCnt = reinterpret_cast<int32*>(m_Reader->getPointerByName(EbsdLib::H5Esprit::RadonBandCount));
auto& radonBandCount = m_DataStructure.getDataRefAs<Int32Array>(cellAMPath.createChildPath(EbsdLib::H5Esprit::RadonBandCount));

const auto* radQual = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::H5Esprit::RadonQuality));
auto& radonQuality = m_DataStructure.getDataRefAs<Float32Array>(cellAMPath.createChildPath(EbsdLib::H5Esprit::RadonQuality));

const auto* xBm = reinterpret_cast<int32*>(m_Reader->getPointerByName(EbsdLib::H5Esprit::XBEAM));
auto& xBeam = m_DataStructure.getDataRefAs<Int32Array>(cellAMPath.createChildPath(EbsdLib::H5Esprit::XBEAM));

const auto* yBm = reinterpret_cast<int32*>(m_Reader->getPointerByName(EbsdLib::H5Esprit::YBEAM));
auto& yBeam = m_DataStructure.getDataRefAs<Int32Array>(cellAMPath.createChildPath(EbsdLib::H5Esprit::YBEAM));

for(size_t i = 0; i < totalPoints; i++)
{
// Condense the Euler Angles from 3 separate arrays into a single 1x3 array
eulerAngles[3 * i] = phi1[i] * degToRad;
eulerAngles[3 * i + 1] = phi[i] * degToRad;
eulerAngles[3 * i + 2] = phi2[i] * degToRad;

mad[i] = m1[i];

nIndexBands[i] = nIndBands[i];

phase[i] = p1[i];

radonBandCount[i] = radBandCnt[i];

radonQuality[i] = radQual[i];

xBeam[i] = xBm[i];

yBeam[i] = yBm[i];
}
}

if(m_InputValues->ReadPatternData)
{
const uint8* patternDataPtr = m_Reader->getPatternData();
std::array<int32, 2> pDims = {{0, 0}};
m_Reader->getPatternDims(pDims);
if(pDims[0] != 0 && pDims[1] != 0)
{
std::vector<usize> pDimsV(2);
pDimsV[0] = pDims[0];
pDimsV[1] = pDims[1];
auto& patternData = m_DataStructure.getDataRefAs<UInt8Array>(cellAMPath.createChildPath(EbsdLib::H5Esprit::RawPatterns));
const usize numComponents = patternData.getNumberOfComponents();
for(usize i = 0; i < totalPoints; i++)
{
for(usize j = 0; j < numComponents; ++j)
{
patternData[numComponents * i + j] = patternDataPtr[numComponents * i + j];
}
}
}
}

return {};
}
3 changes: 3 additions & 0 deletions ...ugins/OrientationAnalysis/src/OrientationAnalysis/Filters/Algorithms/ReadH5EspritData.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -33,7 +33,10 @@ class ORIENTATIONANALYSIS_EXPORT ReadH5EspritData : public IEbsdOemReader<H5Espr

Result<> operator()();

Result<> updateOrigin(const std::string& scanName) override;

Result<> copyRawEbsdData(int index) override;
Result<> copyRawEbsdData(const std::string& scanName) override;

private:
const ReadH5EspritDataInputValues* m_EspritInputValues = nullptr;
Expand Down
108 changes: 100 additions & 8 deletions src/Plugins/OrientationAnalysis/src/OrientationAnalysis/Filters/Algorithms/ReadH5OimData.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -20,33 +20,48 @@ Result<> ReadH5OimData::operator()()
return execute();
}

// -----------------------------------------------------------------------------
Result<> ReadH5OimData::updateOrigin(const std::string& scanName)
{
/*
* This function intentionally has no logic in order to avoid extra calculations;
* The origins were set in preflight, but this file type is an outlier in that it stores
* the origin in the header. Thus, this function overrides the general need to access
* the X and Y positions data as seen in the super/baseclass.
*/
return {};
}

// -----------------------------------------------------------------------------
Result<> ReadH5OimData::copyRawEbsdData(int index)
{
const auto& imageGeom = m_DataStructure.getDataRefAs<ImageGeom>(m_InputValues->ImageGeometryPath);
const DataPath imagePath(m_InputValues->ImageGeometryPath);
const DataPath cellAMPath = imagePath.createChildPath(m_InputValues->CellAttributeMatrixName);

const auto& imageGeom = m_DataStructure.getDataRefAs<ImageGeom>(imagePath);
const usize totalPoints = imageGeom.getNumXCells() * imageGeom.getNumYCells();
const usize offset = index * totalPoints;

// Adjust the values of the 'phase' data to correct for invalid values
auto& phases = m_DataStructure.getDataRefAs<Int32Array>(m_InputValues->CellAttributeMatrixPath.createChildPath(EbsdLib::AngFile::Phases));
auto& phases = m_DataStructure.getDataRefAs<Int32Array>(cellAMPath.createChildPath(EbsdLib::AngFile::Phases));
auto* phasePtr = reinterpret_cast<int32*>(m_Reader->getPointerByName(EbsdLib::Ang::PhaseData));

const auto* phi1 = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::Phi1));
const auto* phi = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::Phi));
const auto* phi2 = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::Phi2));
auto& eulerAngles = m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->CellAttributeMatrixPath.createChildPath(EbsdLib::AngFile::EulerAngles));
auto& eulerAngles = m_DataStructure.getDataRefAs<Float32Array>(cellAMPath.createChildPath(EbsdLib::AngFile::EulerAngles));

const auto* imageQual = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::ImageQuality));
auto& imageQuality = m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->CellAttributeMatrixPath.createChildPath(EbsdLib::Ang::ImageQuality));
auto& imageQuality = m_DataStructure.getDataRefAs<Float32Array>(cellAMPath.createChildPath(EbsdLib::Ang::ImageQuality));

const auto* confIndex = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::ConfidenceIndex));
auto& confidenceIndex = m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->CellAttributeMatrixPath.createChildPath(EbsdLib::Ang::ConfidenceIndex));
auto& confidenceIndex = m_DataStructure.getDataRefAs<Float32Array>(cellAMPath.createChildPath(EbsdLib::Ang::ConfidenceIndex));

const auto* semSig = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::SEMSignal));
auto& semSignal = m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->CellAttributeMatrixPath.createChildPath(EbsdLib::Ang::SEMSignal));
auto& semSignal = m_DataStructure.getDataRefAs<Float32Array>(cellAMPath.createChildPath(EbsdLib::Ang::SEMSignal));

const auto* f1 = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::Fit));
auto& fit = m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->CellAttributeMatrixPath.createChildPath(EbsdLib::Ang::Fit));
auto& fit = m_DataStructure.getDataRefAs<Float32Array>(cellAMPath.createChildPath(EbsdLib::Ang::Fit));

for(size_t i = 0; i < totalPoints; i++)
{
Expand Down Expand Up @@ -80,7 +95,7 @@ Result<> ReadH5OimData::copyRawEbsdData(int index)
std::vector<usize> pDimsV(2);
pDimsV[0] = pDims[0];
pDimsV[1] = pDims[1];
auto& patternData = m_DataStructure.getDataRefAs<UInt8Array>(m_InputValues->CellAttributeMatrixPath.createChildPath(EbsdLib::Ang::PatternData));
auto& patternData = m_DataStructure.getDataRefAs<UInt8Array>(cellAMPath.createChildPath(EbsdLib::Ang::PatternData));
const usize numComponents = patternData.getNumberOfComponents();
for(usize i = 0; i < totalPoints; i++)
{
Expand All @@ -94,3 +109,80 @@ Result<> ReadH5OimData::copyRawEbsdData(int index)

return {};
}

// -----------------------------------------------------------------------------
Result<> ReadH5OimData::copyRawEbsdData(const std::string& scanName)
{
const DataPath imagePath({scanName});
const DataPath cellAMPath = imagePath.createChildPath(m_InputValues->CellAttributeMatrixName);

const auto& imageGeom = m_DataStructure.getDataRefAs<ImageGeom>(imagePath);
const usize totalPoints = imageGeom.getNumXCells() * imageGeom.getNumYCells();

// Adjust the values of the 'phase' data to correct for invalid values
auto& phases = m_DataStructure.getDataRefAs<Int32Array>(cellAMPath.createChildPath(EbsdLib::AngFile::Phases));
auto* phasePtr = reinterpret_cast<int32*>(m_Reader->getPointerByName(EbsdLib::Ang::PhaseData));

const auto* phi1 = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::Phi1));
const auto* phi = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::Phi));
const auto* phi2 = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::Phi2));
auto& eulerAngles = m_DataStructure.getDataRefAs<Float32Array>(cellAMPath.createChildPath(EbsdLib::AngFile::EulerAngles));

const auto* imageQual = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::ImageQuality));
auto& imageQuality = m_DataStructure.getDataRefAs<Float32Array>(cellAMPath.createChildPath(EbsdLib::Ang::ImageQuality));

const auto* confIndex = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::ConfidenceIndex));
auto& confidenceIndex = m_DataStructure.getDataRefAs<Float32Array>(cellAMPath.createChildPath(EbsdLib::Ang::ConfidenceIndex));

const auto* semSig = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::SEMSignal));
auto& semSignal = m_DataStructure.getDataRefAs<Float32Array>(cellAMPath.createChildPath(EbsdLib::Ang::SEMSignal));

const auto* f1 = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::Fit));
auto& fit = m_DataStructure.getDataRefAs<Float32Array>(cellAMPath.createChildPath(EbsdLib::Ang::Fit));

for(usize i = 0; i < totalPoints; i++)
{
if(phasePtr[i] < 1)
{
phasePtr[i] = 1;
}
phases[i] = phasePtr[i];

// Condense the Euler Angles from 3 separate arrays into a single 1x3 array
eulerAngles[3 * i] = phi1[i];
eulerAngles[3 * i + 1] = phi[i];
eulerAngles[3 * i + 2] = phi2[i];

imageQuality[i] = imageQual[i];

confidenceIndex[i] = confIndex[i];

semSignal[i] = semSig[i];

fit[i] = f1[i];
}

if(m_InputValues->ReadPatternData)
{
const uint8* patternDataPtr = m_Reader->getPatternData();
std::array<int32, 2> pDims = {{0, 0}};
m_Reader->getPatternDims(pDims);
if(pDims[0] != 0 && pDims[1] != 0)
{
std::vector<usize> pDimsV(2);
pDimsV[0] = pDims[0];
pDimsV[1] = pDims[1];
auto& patternData = m_DataStructure.getDataRefAs<UInt8Array>(cellAMPath.createChildPath(EbsdLib::Ang::PatternData));
const usize numComponents = patternData.getNumberOfComponents();
for(usize i = 0; i < totalPoints; i++)
{
for(usize j = 0; j < numComponents; ++j)
{
patternData[numComponents * i + j] = patternDataPtr[numComponents * i + j];
}
}
}
}

return {};
}
2 changes: 2 additions & 0 deletions src/Plugins/OrientationAnalysis/src/OrientationAnalysis/Filters/Algorithms/ReadH5OimData.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -25,6 +25,8 @@ class ORIENTATIONANALYSIS_EXPORT ReadH5OimData : public IEbsdOemReader<H5OIMRead
Result<> operator()();

Result<> copyRawEbsdData(int index) override;
Result<> copyRawEbsdData(const std::string& scanName) override;
Result<> updateOrigin(const std::string& scanName) override;
};

} // namespace nx::core
Loading
Loading