Skip to content

Commit 8089b99

Browse files
nyoungbqimikejackson
nyoungbq
authored and
imikejackson
committed
complete h5Oim
1 parent 03581d3 commit 8089b99

File tree

4 files changed

+142
-55
lines changed

4 files changed

+142
-55
lines changed

‎src/Plugins/OrientationAnalysis/src/OrientationAnalysis/Filters/Algorithms/ReadH5OimData.cpp

Lines changed: 120 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -23,74 +23,147 @@ Result<> ReadH5OimData::operator()()
2323
// -----------------------------------------------------------------------------
2424
Result<> ReadH5OimData::copyRawEbsdData(int index)
2525
{
26+
const auto& imageGeom = m_DataStructure.getDataRefAs<ImageGeom>(m_InputValues->ImageGeometryPath);
27+
const usize totalPoints = imageGeom.getNumXCells() * imageGeom.getNumYCells();
28+
const usize offset = index * totalPoints;
2629

27-
if(m_InputValues->CombineScans)
28-
{
29-
const auto& imageGeom = m_DataStructure.getDataRefAs<ImageGeom>(m_InputValues->ImageGeometryPath);
30-
const usize totalPoints = imageGeom.getNumXCells() * imageGeom.getNumYCells();
31-
const usize offset = index * totalPoints;
30+
// Adjust the values of the 'phase' data to correct for invalid values
31+
auto& phases = m_DataStructure.getDataRefAs<Int32Array>(m_InputValues->ImageGeometryPath.createChildPath(m_InputValues->CellAttributeMatrixName).createChildPath(EbsdLib::AngFile::Phases));
32+
auto* phasePtr = reinterpret_cast<int32*>(m_Reader->getPointerByName(EbsdLib::Ang::PhaseData));
33+
34+
const auto* phi1 = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::Phi1));
35+
const auto* phi = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::Phi));
36+
const auto* phi2 = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::Phi2));
37+
auto& eulerAngles =
38+
m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->ImageGeometryPath.createChildPath(m_InputValues->CellAttributeMatrixName).createChildPath(EbsdLib::AngFile::EulerAngles));
39+
40+
const auto* imageQual = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::ImageQuality));
41+
auto& imageQuality = m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->ImageGeometryPath.createChildPath(m_InputValues->CellAttributeMatrixName).createChildPath(EbsdLib::Ang::ImageQuality));
42+
43+
const auto* confIndex = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::ConfidenceIndex));
44+
auto& confidenceIndex =
45+
m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->ImageGeometryPath.createChildPath(m_InputValues->CellAttributeMatrixName).createChildPath(EbsdLib::Ang::ConfidenceIndex));
3246

33-
// Adjust the values of the 'phase' data to correct for invalid values
34-
auto& phases = m_DataStructure.getDataRefAs<Int32Array>(m_InputValues->CellAttributeMatrixPath.createChildPath(EbsdLib::AngFile::Phases));
35-
auto* phasePtr = reinterpret_cast<int32*>(m_Reader->getPointerByName(EbsdLib::Ang::PhaseData));
47+
const auto* semSig = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::SEMSignal));
48+
auto& semSignal = m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->ImageGeometryPath.createChildPath(m_InputValues->CellAttributeMatrixName).createChildPath(EbsdLib::Ang::SEMSignal));
49+
50+
const auto* f1 = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::Fit));
51+
auto& fit = m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->ImageGeometryPath.createChildPath(m_InputValues->CellAttributeMatrixName).createChildPath(EbsdLib::Ang::Fit));
52+
53+
for(size_t i = 0; i < totalPoints; i++)
54+
{
55+
if(phasePtr[i] < 1)
56+
{
57+
phasePtr[i] = 1;
58+
}
59+
phases[offset + i] = phasePtr[i];
3660

37-
const auto* phi1 = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::Phi1));
38-
const auto* phi = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::Phi));
39-
const auto* phi2 = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::Phi2));
40-
auto& eulerAngles = m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->CellAttributeMatrixPath.createChildPath(EbsdLib::AngFile::EulerAngles));
61+
// Condense the Euler Angles from 3 separate arrays into a single 1x3 array
62+
eulerAngles[offset + 3 * i] = phi1[i];
63+
eulerAngles[offset + 3 * i + 1] = phi[i];
64+
eulerAngles[offset + 3 * i + 2] = phi2[i];
4165

42-
const auto* imageQual = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::ImageQuality));
43-
auto& imageQuality = m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->CellAttributeMatrixPath.createChildPath(EbsdLib::Ang::ImageQuality));
66+
imageQuality[offset + i] = imageQual[i];
4467

45-
const auto* confIndex = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::ConfidenceIndex));
46-
auto& confidenceIndex = m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->CellAttributeMatrixPath.createChildPath(EbsdLib::Ang::ConfidenceIndex));
68+
confidenceIndex[offset + i] = confIndex[i];
4769

48-
const auto* semSig = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::SEMSignal));
49-
auto& semSignal = m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->CellAttributeMatrixPath.createChildPath(EbsdLib::Ang::SEMSignal));
70+
semSignal[offset + i] = semSig[i];
5071

51-
const auto* f1 = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::Fit));
52-
auto& fit = m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->CellAttributeMatrixPath.createChildPath(EbsdLib::Ang::Fit));
72+
fit[offset + i] = f1[i];
73+
}
5374

54-
for(size_t i = 0; i < totalPoints; i++)
75+
if(m_InputValues->ReadPatternData)
76+
{
77+
const uint8* patternDataPtr = m_Reader->getPatternData();
78+
std::array<int32, 2> pDims = {{0, 0}};
79+
m_Reader->getPatternDims(pDims);
80+
if(pDims[0] != 0 && pDims[1] != 0)
5581
{
56-
if(phasePtr[i] < 1)
82+
std::vector<usize> pDimsV(2);
83+
pDimsV[0] = pDims[0];
84+
pDimsV[1] = pDims[1];
85+
auto& patternData = m_DataStructure.getDataRefAs<UInt8Array>(m_InputValues->ImageGeometryPath.createChildPath(m_InputValues->CellAttributeMatrixName).createChildPath(EbsdLib::Ang::PatternData));
86+
const usize numComponents = patternData.getNumberOfComponents();
87+
for(usize i = 0; i < totalPoints; i++)
5788
{
58-
phasePtr[i] = 1;
89+
for(usize j = 0; j < numComponents; ++j)
90+
{
91+
patternData[offset + numComponents * i + j] = patternDataPtr[numComponents * i + j];
92+
}
5993
}
60-
phases[offset + i] = phasePtr[i];
94+
}
95+
}
96+
97+
return {};
98+
}
99+
100+
// -----------------------------------------------------------------------------
101+
Result<> ReadH5OimData::copyRawEbsdData(const std::string& scanName)
102+
{
103+
DataPath imagePath({scanName});
104+
const auto& imageGeom = m_DataStructure.getDataRefAs<ImageGeom>(imagePath);
105+
const usize totalPoints = imageGeom.getNumXCells() * imageGeom.getNumYCells();
106+
107+
// Adjust the values of the 'phase' data to correct for invalid values
108+
auto& phases = m_DataStructure.getDataRefAs<Int32Array>(imagePath.createChildPath(m_InputValues->CellAttributeMatrixName).createChildPath(EbsdLib::AngFile::Phases));
109+
auto* phasePtr = reinterpret_cast<int32*>(m_Reader->getPointerByName(EbsdLib::Ang::PhaseData));
61110

62-
// Condense the Euler Angles from 3 separate arrays into a single 1x3 array
63-
eulerAngles[offset + 3 * i] = phi1[i];
64-
eulerAngles[offset + 3 * i + 1] = phi[i];
65-
eulerAngles[offset + 3 * i + 2] = phi2[i];
111+
const auto* phi1 = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::Phi1));
112+
const auto* phi = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::Phi));
113+
const auto* phi2 = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::Phi2));
114+
auto& eulerAngles = m_DataStructure.getDataRefAs<Float32Array>(imagePath.createChildPath(m_InputValues->CellAttributeMatrixName).createChildPath(EbsdLib::AngFile::EulerAngles));
66115

67-
imageQuality[offset + i] = imageQual[i];
116+
const auto* imageQual = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::ImageQuality));
117+
auto& imageQuality = m_DataStructure.getDataRefAs<Float32Array>(imagePath.createChildPath(m_InputValues->CellAttributeMatrixName).createChildPath(EbsdLib::Ang::ImageQuality));
68118

69-
confidenceIndex[offset + i] = confIndex[i];
119+
const auto* confIndex = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::ConfidenceIndex));
120+
auto& confidenceIndex = m_DataStructure.getDataRefAs<Float32Array>(imagePath.createChildPath(m_InputValues->CellAttributeMatrixName).createChildPath(EbsdLib::Ang::ConfidenceIndex));
70121

71-
semSignal[offset + i] = semSig[i];
122+
const auto* semSig = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::SEMSignal));
123+
auto& semSignal = m_DataStructure.getDataRefAs<Float32Array>(imagePath.createChildPath(m_InputValues->CellAttributeMatrixName).createChildPath(EbsdLib::Ang::SEMSignal));
72124

73-
fit[offset + i] = f1[i];
125+
const auto* f1 = reinterpret_cast<float32*>(m_Reader->getPointerByName(EbsdLib::Ang::Fit));
126+
auto& fit = m_DataStructure.getDataRefAs<Float32Array>(imagePath.createChildPath(m_InputValues->CellAttributeMatrixName).createChildPath(EbsdLib::Ang::Fit));
127+
128+
for(usize i = 0; i < totalPoints; i++)
129+
{
130+
if(phasePtr[i] < 1)
131+
{
132+
phasePtr[i] = 1;
74133
}
134+
phases[i] = phasePtr[i];
135+
136+
// Condense the Euler Angles from 3 separate arrays into a single 1x3 array
137+
eulerAngles[3 * i] = phi1[i];
138+
eulerAngles[3 * i + 1] = phi[i];
139+
eulerAngles[3 * i + 2] = phi2[i];
140+
141+
imageQuality[i] = imageQual[i];
142+
143+
confidenceIndex[i] = confIndex[i];
75144

76-
if(m_InputValues->ReadPatternData)
145+
semSignal[i] = semSig[i];
146+
147+
fit[i] = f1[i];
148+
}
149+
150+
if(m_InputValues->ReadPatternData)
151+
{
152+
const uint8* patternDataPtr = m_Reader->getPatternData();
153+
std::array<int32, 2> pDims = {{0, 0}};
154+
m_Reader->getPatternDims(pDims);
155+
if(pDims[0] != 0 && pDims[1] != 0)
77156
{
78-
const uint8* patternDataPtr = m_Reader->getPatternData();
79-
std::array<int32, 2> pDims = {{0, 0}};
80-
m_Reader->getPatternDims(pDims);
81-
if(pDims[0] != 0 && pDims[1] != 0)
157+
std::vector<usize> pDimsV(2);
158+
pDimsV[0] = pDims[0];
159+
pDimsV[1] = pDims[1];
160+
auto& patternData = m_DataStructure.getDataRefAs<UInt8Array>(imagePath.createChildPath(m_InputValues->CellAttributeMatrixName).createChildPath(EbsdLib::Ang::PatternData));
161+
const usize numComponents = patternData.getNumberOfComponents();
162+
for(usize i = 0; i < totalPoints; i++)
82163
{
83-
std::vector<usize> pDimsV(2);
84-
pDimsV[0] = pDims[0];
85-
pDimsV[1] = pDims[1];
86-
auto& patternData = m_DataStructure.getDataRefAs<UInt8Array>(m_InputValues->CellAttributeMatrixPath.createChildPath(EbsdLib::Ang::PatternData));
87-
const usize numComponents = patternData.getNumberOfComponents();
88-
for(usize i = 0; i < totalPoints; i++)
164+
for(usize j = 0; j < numComponents; ++j)
89165
{
90-
for(usize j = 0; j < numComponents; ++j)
91-
{
92-
patternData[offset + numComponents * i + j] = patternDataPtr[numComponents * i + j];
93-
}
166+
patternData[numComponents * i + j] = patternDataPtr[numComponents * i + j];
94167
}
95168
}
96169
}

‎src/Plugins/OrientationAnalysis/src/OrientationAnalysis/Filters/Algorithms/ReadH5OimData.hpp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -25,6 +25,7 @@ class ORIENTATIONANALYSIS_EXPORT ReadH5OimData : public IEbsdOemReader<H5OIMRead
2525
Result<> operator()();
2626

2727
Result<> copyRawEbsdData(int index) override;
28+
Result<> copyRawEbsdData(const std::string& scanName) override;
2829
};
2930

3031
} // namespace nx::core

‎src/Plugins/OrientationAnalysis/src/OrientationAnalysis/Filters/ReadH5OimDataFilter.cpp

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -258,11 +258,12 @@ Result<> ReadH5OimDataFilter::executeImpl(DataStructure& dataStructure, const Ar
258258
{
259259
ReadH5DataInputValues inputValues;
260260

261+
inputValues.CombineScans = filterArgs.value<bool>(k_CombineScans_Key);
261262
inputValues.SelectedScanNames = filterArgs.value<OEMEbsdScanSelectionParameter::ValueType>(k_SelectedScanNames_Key);
262263
inputValues.ReadPatternData = filterArgs.value<bool>(k_ReadPatternData_Key);
263264
inputValues.ImageGeometryPath = filterArgs.value<DataPath>(k_CreatedImageGeometryPath_Key);
264-
inputValues.CellEnsembleAttributeMatrixPath = inputValues.ImageGeometryPath.createChildPath(filterArgs.value<std::string>(k_CellEnsembleAttributeMatrixName_Key));
265-
inputValues.CellAttributeMatrixPath = inputValues.ImageGeometryPath.createChildPath(filterArgs.value<std::string>(k_CellAttributeMatrixName_Key));
265+
inputValues.CellEnsembleAttributeMatrixName = filterArgs.value<std::string>(k_CellEnsembleAttributeMatrixName_Key);
266+
inputValues.CellAttributeMatrixName = filterArgs.value<std::string>(k_CellAttributeMatrixName_Key);
266267

267268
return ReadH5OimData(dataStructure, messageHandler, shouldCancel, &inputValues)();
268269
}

‎src/Plugins/OrientationAnalysis/src/OrientationAnalysis/utilities/IEbsdOemReader.hpp

Lines changed: 18 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -22,16 +22,15 @@ struct ORIENTATIONANALYSIS_EXPORT ReadH5DataInputValues
2222
bool CombineScans;
2323
bool ReadPatternData;
2424
DataPath ImageGeometryPath;
25-
DataPath CellAttributeMatrixPath;
26-
DataPath CellEnsembleAttributeMatrixPath;
25+
std::string CellAttributeMatrixName;
26+
std::string CellEnsembleAttributeMatrixName;
2727
bool EdaxHexagonalAlignment;
2828
bool ConvertPhaseToInt32;
2929
};
3030

3131
/**
3232
* @class ReadH5Data
3333
*/
34-
3534
template <class T>
3635
class ORIENTATIONANALYSIS_EXPORT IEbsdOemReader
3736
{
@@ -55,8 +54,11 @@ class ORIENTATIONANALYSIS_EXPORT IEbsdOemReader
5554

5655
Result<> execute()
5756
{
58-
auto& imageGeom = m_DataStructure.getDataRefAs<ImageGeom>(m_InputValues->ImageGeometryPath);
59-
imageGeom.setUnits(IGeometry::LengthUnit::Micrometer);
57+
if(m_InputValues->CombineScans)
58+
{
59+
auto& imageGeom = m_DataStructure.getDataRefAs<ImageGeom>(m_InputValues->ImageGeometryPath);
60+
imageGeom.setUnits(IGeometry::LengthUnit::Micrometer);
61+
}
6062

6163
int index = 0;
6264
for(const auto& currentScanName : m_InputValues->SelectedScanNames.scanNames)
@@ -69,7 +71,16 @@ class ORIENTATIONANALYSIS_EXPORT IEbsdOemReader
6971
return readResults;
7072
}
7173

72-
Result<> copyDataResults = copyRawEbsdData(index);
74+
Result<> copyDataResults = {};
75+
if(m_InputValues->CombineScans)
76+
{
77+
copyDataResults = copyRawEbsdData(index);
78+
}
79+
else
80+
{
81+
copyDataResults = copyRawEbsdData(currentScanName);
82+
}
83+
7384
if(copyDataResults.invalid())
7485
{
7586
return copyDataResults;
@@ -136,6 +147,7 @@ class ORIENTATIONANALYSIS_EXPORT IEbsdOemReader
136147
}
137148

138149
virtual Result<> copyRawEbsdData(int index) = 0;
150+
virtual Result<> copyRawEbsdData(const std::string& scanName) = 0;
139151

140152
protected:
141153
std::shared_ptr<T> m_Reader;

0 commit comments

Comments
 (0)