ENH: Populate the Image MetaDataDictionary when reading

include/itkScancoImageIO.h

@@ -321,6 +321,9 @@ class IOScanco_EXPORT ScancoImageIO : public ImageIOBase
   int
   ReadAIMHeader(std::ifstream * file, unsigned long bytesRead);
 
+  void
+  PopulateMetaDataDictionary();
+
   void
   WriteISQHeader(std::ofstream * file);
 

src/itkScancoImageIO.cxx

@@ -36,6 +36,7 @@
 #include "itkMath.h"
 #include "itkIntTypes.h"
 #include "itkByteSwapper.h"
+#include "itkMetaDataObject.h"
 
 #include <algorithm>
 #include <ctime>
@@ -1022,6 +1023,44 @@ ScancoImageIO::ReadImageInformation()
     this->m_RescaleSlope = 1000.0 / (this->m_MuWater * this->m_MuScaling);
     this->m_RescaleIntercept = -1000.0;
   }
+
+  this->PopulateMetaDataDictionary();
+}
+
+void
+ScancoImageIO::PopulateMetaDataDictionary()
+{
+  MetaDataDictionary & thisDic = this->GetMetaDataDictionary();
+  EncapsulateMetaData<std::string>(thisDic, "Version", std::string(this->m_Version));
+  EncapsulateMetaData<std::string>(thisDic, "PatientName", std::string(this->m_PatientName));
+  EncapsulateMetaData<int>(thisDic, "PatientIndex", this->m_PatientIndex);
+  EncapsulateMetaData<int>(thisDic, "ScannerID", this->m_ScannerID);
+  EncapsulateMetaData<std::string>(thisDic, "CreationDate", std::string(this->m_CreationDate));
+  EncapsulateMetaData<std::string>(thisDic, "ModificationDate", std::string(this->m_ModificationDate));
+  EncapsulateMetaData<double>(thisDic, "SliceThickness", this->m_SliceThickness);
+  EncapsulateMetaData<double>(thisDic, "SliceIncrement", this->m_SliceIncrement);
+  std::vector<double> dataRange(2);
+  dataRange[0] = this->m_DataRange[0];
+  dataRange[1] = this->m_DataRange[1];
+  EncapsulateMetaData<std::vector<double>>(thisDic, "DataRange", dataRange);
+  EncapsulateMetaData<double>(thisDic, "MuScaling", this->m_MuScaling);
+  EncapsulateMetaData<int>(thisDic, "NumberOfSamples", this->m_NumberOfSamples);
+  EncapsulateMetaData<int>(thisDic, "NumberOfProjections", this->m_NumberOfProjections);
+  EncapsulateMetaData<double>(thisDic, "ScanDistance", this->m_ScanDistance);
+  EncapsulateMetaData<double>(thisDic, "SampleTime", this->m_SampleTime);
+  EncapsulateMetaData<int>(thisDic, "ScannerType", this->m_ScannerType);
+  EncapsulateMetaData<int>(thisDic, "MeasurementIndex", this->m_MeasurementIndex);
+  EncapsulateMetaData<int>(thisDic, "Site", this->m_Site);
+  EncapsulateMetaData<int>(thisDic, "ReconstructionAlg", this->m_ReconstructionAlg);
+  EncapsulateMetaData<double>(thisDic, "ReferenceLine", this->m_ReferenceLine);
+  EncapsulateMetaData<double>(thisDic, "Energy", this->m_Energy);
+  EncapsulateMetaData<double>(thisDic, "Intensity", this->m_Intensity);
+  EncapsulateMetaData<int>(thisDic, "RescaleType", this->m_RescaleType);
+  EncapsulateMetaData<std::string>(thisDic, "RescaleUnits", std::string(this->m_RescaleUnits));
+  EncapsulateMetaData<std::string>(thisDic, "CalibrationData", std::string(this->m_CalibrationData));
+  EncapsulateMetaData<double>(thisDic, "RescaleSlope", this->m_RescaleSlope);
+  EncapsulateMetaData<double>(thisDic, "RescaleIntercept", this->m_RescaleIntercept);
+  EncapsulateMetaData<double>(thisDic, "MuWater", this->m_MuWater);
 }
 
 template <typename TBufferType>

test/itkScancoImageIOTest2.cxx

@@ -60,47 +60,89 @@ itkScancoImageIOTest2(int argc, char * argv[])
   reader->SetFileName(inputFileName);
   ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update());
   ImageType::Pointer image = reader->GetOutput();
+  auto               metaData = image->GetMetaDataDictionary();
 
   std::cout << "Version: \t\t" << scancoIO->GetVersion() << std::endl;
   ITK_TEST_EXPECT_EQUAL(scancoIO->GetVersion(), std::string("CTDATA-HEADER_V1"));
+  std::string stringMeta;
+  itk::ExposeMetaData<std::string>(metaData, "Version", stringMeta);
+  ITK_TEST_EXPECT_EQUAL(stringMeta, std::string("CTDATA-HEADER_V1"));
   std::cout << "PatientIndex: \t" << scancoIO->GetPatientIndex() << std::endl;
   ITK_TEST_EXPECT_EQUAL(scancoIO->GetPatientIndex(), 78);
+  int intMeta;
+  itk::ExposeMetaData<int>(metaData, "PatientIndex", intMeta);
+  ITK_TEST_EXPECT_EQUAL(intMeta, 78);
   std::cout << "ScannerID: \t\t" << scancoIO->GetScannerID() << std::endl;
   ITK_TEST_EXPECT_EQUAL(scancoIO->GetScannerID(), 2135);
+  itk::ExposeMetaData<int>(metaData, "ScannerID", intMeta);
+  ITK_TEST_EXPECT_EQUAL(intMeta, 2135);
   std::cout << "SliceThickness: \t" << scancoIO->GetSliceThickness() << std::endl;
   ITK_TEST_EXPECT_TRUE(itk::Math::FloatAlmostEqual(scancoIO->GetSliceThickness(), 0.036, 6, 1e-3));
+  double doubleMeta;
+  itk::ExposeMetaData<double>(metaData, "SliceThickness", doubleMeta);
+  ITK_TEST_EXPECT_TRUE(itk::Math::FloatAlmostEqual(doubleMeta, 0.036, 6, 1e-3));
   std::cout << "SliceIncrement: \t" << scancoIO->GetSliceIncrement() << std::endl;
   ITK_TEST_EXPECT_TRUE(itk::Math::FloatAlmostEqual(scancoIO->GetSliceIncrement(), 0.036, 6, 1e-3));
+  itk::ExposeMetaData<double>(metaData, "SliceIncrement", doubleMeta);
+  ITK_TEST_EXPECT_TRUE(itk::Math::FloatAlmostEqual(doubleMeta, 0.036, 6, 1e-3));
   std::cout << "StartPosition: \t" << scancoIO->GetStartPosition() << std::endl;
   ITK_TEST_EXPECT_TRUE(itk::Math::FloatAlmostEqual(scancoIO->GetStartPosition(), 75.0, 6, 1e-3));
+  std::vector<double> vectorDoubleMeta;
+  itk::ExposeMetaData<std::vector<double>>(metaData, "DataRange", vectorDoubleMeta);
   std::cout << "DataRange[0]: \t" << scancoIO->GetDataRange()[0] << std::endl;
   ITK_TEST_EXPECT_TRUE(itk::Math::FloatAlmostEqual(scancoIO->GetDataRange()[0], -2813.0, 6, 1e-3));
+  ITK_TEST_EXPECT_TRUE(itk::Math::FloatAlmostEqual(vectorDoubleMeta[0], -2813.0, 6, 1e-3));
   std::cout << "DataRange[1]: \t" << scancoIO->GetDataRange()[1] << std::endl;
   ITK_TEST_EXPECT_TRUE(itk::Math::FloatAlmostEqual(scancoIO->GetDataRange()[1], 32767.0, 6, 1e-3));
+  ITK_TEST_EXPECT_TRUE(itk::Math::FloatAlmostEqual(vectorDoubleMeta[1], 32767.0, 6, 1e-3));
   std::cout << "MuScaling: \t\t" << scancoIO->GetMuScaling() << std::endl;
   ITK_TEST_EXPECT_TRUE(itk::Math::FloatAlmostEqual(scancoIO->GetMuScaling(), 4096.0, 6, 1e-3));
+  itk::ExposeMetaData<double>(metaData, "MuScaling", doubleMeta);
+  ITK_TEST_EXPECT_TRUE(itk::Math::FloatAlmostEqual(doubleMeta, 4096.0, 6, 1e-3));
   std::cout << "NumberOfSamples: \t" << scancoIO->GetNumberOfSamples() << std::endl;
   ITK_TEST_EXPECT_EQUAL(scancoIO->GetNumberOfSamples(), 1024);
+  itk::ExposeMetaData<int>(metaData, "NumberOfSamples", intMeta);
+  ITK_TEST_EXPECT_EQUAL(intMeta, 1024);
   std::cout << "NumberOfProjections: " << scancoIO->GetNumberOfProjections() << std::endl;
   ITK_TEST_EXPECT_EQUAL(scancoIO->GetNumberOfProjections(), 500);
+  itk::ExposeMetaData<int>(metaData, "NumberOfProjections", intMeta);
+  ITK_TEST_EXPECT_EQUAL(intMeta, 500);
   std::cout << "ScanDistance: \t" << scancoIO->GetScanDistance() << std::endl;
   ITK_TEST_EXPECT_TRUE(itk::Math::FloatAlmostEqual(scancoIO->GetScanDistance(), 36.864, 6, 1e-3));
+  itk::ExposeMetaData<double>(metaData, "ScanDistance", doubleMeta);
+  ITK_TEST_EXPECT_TRUE(itk::Math::FloatAlmostEqual(doubleMeta, 36.864, 6, 1e-3));
   std::cout << "ScannerType: \t" << scancoIO->GetScannerType() << std::endl;
   ITK_TEST_EXPECT_EQUAL(scancoIO->GetScannerType(), 10);
+  itk::ExposeMetaData<int>(metaData, "ScannerType", intMeta);
+  ITK_TEST_EXPECT_EQUAL(intMeta, 10);
   std::cout << "SampleTime: \t\t" << scancoIO->GetSampleTime() << std::endl;
   ITK_TEST_EXPECT_TRUE(itk::Math::FloatAlmostEqual(scancoIO->GetSampleTime(), 400.0, 6, 1e-3));
+  itk::ExposeMetaData<double>(metaData, "SampleTime", doubleMeta);
+  ITK_TEST_EXPECT_TRUE(itk::Math::FloatAlmostEqual(doubleMeta, 400.0, 6, 1e-3));
   std::cout << "MeasurementIndex: \t" << scancoIO->GetMeasurementIndex() << std::endl;
   ITK_TEST_EXPECT_EQUAL(scancoIO->GetMeasurementIndex(), 4937);
+  itk::ExposeMetaData<int>(metaData, "MeasurementIndex", intMeta);
+  ITK_TEST_EXPECT_EQUAL(intMeta, 4937);
   std::cout << "Site: \t\t" << scancoIO->GetSite() << std::endl;
   ITK_TEST_EXPECT_EQUAL(scancoIO->GetSite(), 5);
+  itk::ExposeMetaData<int>(metaData, "Site", intMeta);
+  ITK_TEST_EXPECT_EQUAL(intMeta, 5);
   std::cout << "ReferenceLine: \t" << scancoIO->GetReferenceLine() << std::endl;
   ITK_TEST_EXPECT_EQUAL(scancoIO->GetReferenceLine(), 0);
+  itk::ExposeMetaData<double>(metaData, "ReferenceLine", doubleMeta);
+  ITK_TEST_EXPECT_EQUAL(doubleMeta, 0);
   std::cout << "ReconstructionAlg: \t" << scancoIO->GetReconstructionAlg() << std::endl;
   ITK_TEST_EXPECT_EQUAL(scancoIO->GetReconstructionAlg(), 3);
+  itk::ExposeMetaData<int>(metaData, "ReconstructionAlg", intMeta);
+  ITK_TEST_EXPECT_EQUAL(intMeta, 3);
   std::cout << "Energy: \t\t" << scancoIO->GetEnergy() << std::endl;
   ITK_TEST_EXPECT_TRUE(itk::Math::FloatAlmostEqual(scancoIO->GetEnergy(), 45.0, 6, 1e-3));
+  itk::ExposeMetaData<double>(metaData, "Energy", doubleMeta);
+  ITK_TEST_EXPECT_TRUE(itk::Math::FloatAlmostEqual(doubleMeta, 45.0, 6, 1e-3));
   std::cout << "Intensity: \t\t" << scancoIO->GetIntensity() << std::endl;
   ITK_TEST_EXPECT_TRUE(itk::Math::FloatAlmostEqual(scancoIO->GetIntensity(), 0.177, 6, 1e-3));
+  itk::ExposeMetaData<double>(metaData, "Intensity", doubleMeta);
+  ITK_TEST_EXPECT_TRUE(itk::Math::FloatAlmostEqual(doubleMeta, 0.177, 6, 1e-3));
   std::cout << "CreationDate: \t" << scancoIO->GetCreationDate() << std::endl;
   std::cout << "ModificationDate: \t" << scancoIO->GetModificationDate() << std::endl;