ENH: H5OINA Reader Implementation

Signed-off-by: Michael Jackson <mike.jackson@bluequartz.net>

Author: imikejackson

Source/EbsdLib/IO/EbsdReader.h

@@ -143,6 +143,7 @@ class EbsdLib_EXPORT EbsdReader
    * Different manufacturers call this value different thingsl. TSL = NumRows | NumCols,
    * HKL=XCells. These methods should be implemented by subclasses to return the proper value.
    */
+
   /**
    * @brief Returns the X Dimension of the data. This method is pure virtual
    * and should be implemented by subclasses.

Source/EbsdLib/IO/HKL/CtfConstants.h

@@ -192,4 +192,82 @@ const std::string MaterialName("MaterialName");
 const std::string LatticeConstants("LatticeConstants");
 const std::string BravaisLattice("BravaisLattice");
 } // namespace CtfFile
+
+
+//-----------------------------------------------------------------------------
+// https://github.com/oinanoanalysis/h5oina/blob/master/H5OINAFile.md#ebsd-data
+//-----------------------------------------------------------------------------
+namespace H5OINA
+{
+
+const std::string H5FileExt("h5oina");
+const std::string Index("Index");
+const std::string FormatVersion("Format Version"); // String 2.0 is the earliest that I seem to have
+const std::string Manufacturer("Manufacturer"); // String
+const std::string SoftwareVersion("Software Version"); // String
+
+const std::string FormatVersion_2("2.0");
+const std::string FormatVersion_3("3.0");
+const std::string FormatVersion_4("4.0");
+const std::string FormatVersion_5("5.0");
+
+//-----------------------------------------------------------------------------
+// These are for header names in the hdf5 file
+// Format Version: 2
+//-----------------------------------------------------------------------------
+const std::string Header("Header");
+const std::string AcquisitionData("Acquisition Date");
+const std::string AcquisitionSpeed("Acquisition Speed");
+const std::string AcquisitionTime("Acquisition Time");
+const std::string BeamVoltage("Beam Voltage");
+const std::string DetectorOrientationEuler("Detector Orientation Euler");
+const std::string Magnification("Magnification");
+const std::string ProjectFile("Project File");
+const std::string ProjectLabel("Project Label");
+const std::string ProjectNotes("Project Notes");
+const std::string ScanningRotationAngle("Scanning Rotation Angle");
+const std::string SiteNotes("Site Notes");
+const std::string SpecimenOrientationEuler("Specimen Orientation Euler");
+const std::string TiltAngle("Tilt Angle");
+const std::string TiltAxis("Tilt Axis");
+const std::string XCells("X Cells");
+const std::string XStep("X Step");
+const std::string YCells("Y Cells");
+const std::string YStep("Y Step");
+// Phase Headers: Format Version 2
+const std::string Phases("Phases");
+const std::string Color("Color");
+const std::string LatticeAngles("Lattice Angles");
+const std::string LatticeDimensions("Lattice Dimensions");
+const std::string LaueGroup("Laue Group");
+const std::string NumberReflectors("Number Reflectors");
+const std::string PhaseName("Phase Name");
+const std::string Reference("Reference");
+const std::string SpaceGroup("Space Group");
+// Data: Format Version 2
+const std::string EBSD("EBSD");
+const std::string Data("Data");
+const std::string BandContrast("Band Contrast"); // uint8
+const std::string BandSlope("Band Slope"); // uint8
+const std::string Bands("Bands"); // uint8
+const std::string Error("Error"); // uint8
+const std::string Euler("Euler"); // 3xFloat32
+const std::string MeanAngularDeviation("Mean Angular Deviation"); // Float
+const std::string Phase("Phase"); // uint8
+const std::string X("X"); // uint8
+const std::string Y("Y"); // uint8
+
+
+// Data Format Version 5
+
+const std::string UnprocessedPatterns("Unprocessed Patterns");
+const std::string ProcessedPatterns("Processed Patterns");
+
+
+
+
+
+
+}
+
 } // namespace EbsdLib

Source/EbsdLib/IO/HKL/DataParser.hpp

@@ -116,6 +116,111 @@ class DataParser
   DataParser& operator=(const DataParser&) = delete; // Copy Assignment Not Implemented
   DataParser& operator=(DataParser&&) = delete;      // Move Assignment Not Implemented
 };
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+class UInt8Parser : public DataParser
+{
+public:
+  using Self = UInt8Parser;
+  using Pointer = std::shared_ptr<Self>;
+  using ConstPointer = std::shared_ptr<const Self>;
+  using WeakPointer = std::weak_ptr<Self>;
+  using ConstWeakPointer = std::weak_ptr<Self>;
+  static Pointer NullPointer()
+  {
+    return Pointer(static_cast<Self*>(nullptr));
+  }
+
+  /**
+   * @brief Returns the name of the class for AbstractMessage
+   */
+  std::string getNameOfClass() const
+  {
+    return std::string("UInt8Parser");
+  }
+  /**
+   * @brief Returns the name of the class for AbstractMessage
+   */
+  static std::string ClassName()
+  {
+    return std::string("UInt8Parser");
+  }
+
+  int32_t IsA() const override
+  {
+    return 1;
+  }
+
+  static Pointer New(uint8_t* ptr, size_t size, const std::string& name, int index)
+  {
+    Pointer sharedPtr(new UInt8Parser(ptr, size, name, index));
+    return sharedPtr;
+  }
+
+  ~UInt8Parser() override
+  {
+    if(m_Ptr != nullptr && getManageMemory())
+    {
+      delete[] m_Ptr;
+      m_Ptr = nullptr;
+    }
+  }
+
+  void setPtr(uint8_t* value)
+  {
+    this->m_Ptr = value;
+  }
+  uint8_t* getPtr()
+  {
+    return m_Ptr;
+  }
+
+  bool allocateArray(size_t numberOfElements) override
+  {
+    m_Ptr = new(std::nothrow) uint8_t[numberOfElements]();
+    return (m_Ptr != nullptr);
+  }
+
+  void* getVoidPointer() override
+  {
+    return reinterpret_cast<void*>(m_Ptr);
+  }
+  void setVoidPointer(void* p) override
+  {
+    m_Ptr = reinterpret_cast<uint8_t*>(p);
+  }
+
+  uint8_t* getPointer(size_t offset)
+  {
+    return m_Ptr + offset;
+  }
+
+  void parse(const std::string& token, size_t index) override
+  {
+    EBSD_INDEX_OUT_OF_RANGE(index < getSize());
+    m_Ptr[index] = std::stoi(token);
+  }
+
+protected:
+  UInt8Parser(uint8_t* ptr, size_t size, const std::string& name, int index)
+  : m_Ptr(ptr)
+  {
+    setManageMemory(true);
+    setSize(size);
+    setColumnName(name);
+    setColumnIndex(index);
+  }
+
+private:
+  uint8_t* m_Ptr;
+
+public:
+  UInt8Parser(const UInt8Parser&) = delete;            // Copy Constructor Not Implemented
+  UInt8Parser(UInt8Parser&&) = delete;                 // Move Constructor Not Implemented
+  UInt8Parser& operator=(const UInt8Parser&) = delete; // Copy Assignment Not Implemented
+  UInt8Parser& operator=(UInt8Parser&&) = delete;      // Move Assignment Not Implemented
+};
 
 // -----------------------------------------------------------------------------
 //
@@ -223,8 +328,7 @@ class Int32Parser : public DataParser
   Int32Parser& operator=(Int32Parser&&) = delete;      // Move Assignment Not Implemented
 };
 
-// -----------------------------------------------------------------------------
-//
+
 // -----------------------------------------------------------------------------
 class FloatParser : public DataParser
 {
@@ -327,3 +431,107 @@ class FloatParser : public DataParser
   FloatParser& operator=(const FloatParser&) = delete; // Copy Assignment Not Implemented
   FloatParser& operator=(FloatParser&&) = delete;      // Move Assignment Not Implemented
 };
+
+template<typename T>
+class NumericParser : public DataParser
+{
+public:
+  using Self = NumericParser<T>;
+  using Pointer = std::shared_ptr<Self>;
+  using ConstPointer = std::shared_ptr<const Self>;
+  using WeakPointer = std::weak_ptr<Self>;
+  using ConstWeakPointer = std::weak_ptr<Self>;
+  static Pointer NullPointer()
+  {
+    return Pointer(static_cast<Self*>(nullptr));
+  }
+
+  /**
+   * @brief Returns the name of the class for AbstractMessage
+   */
+  const std::string getNameOfClass() const
+  {
+    return std::string("NumericParser");
+  }
+  /**
+   * @brief Returns the name of the class for AbstractMessage
+   */
+  static std::string ClassName()
+  {
+    return std::string("NumericParser");
+  }
+
+  int32_t IsA() const override
+  {
+    return 2;
+  }
+
+  static Pointer New(T* ptr, size_t size, const std::string& name, int index)
+  {
+    Pointer sharedPtr(new NumericParser<T>(ptr, size, name, index));
+    return sharedPtr;
+  }
+
+  ~NumericParser() override
+  {
+    if(m_Ptr != nullptr && getManageMemory())
+    {
+      delete[] m_Ptr;
+      m_Ptr = nullptr;
+    }
+  }
+
+  void setPtr(T* value)
+  {
+    this->m_Ptr = value;
+  }
+  T* getPtr()
+  {
+    return m_Ptr;
+  }
+
+  bool allocateArray(size_t numberOfElements) override
+  {
+    m_Ptr = new(std::nothrow) T[numberOfElements]();
+    return (m_Ptr != nullptr);
+  }
+
+  void* getVoidPointer() override
+  {
+    return reinterpret_cast<void*>(m_Ptr);
+  }
+  void setVoidPointer(void* p) override
+  {
+    m_Ptr = reinterpret_cast<T*>(p);
+  }
+
+  T* getPointer(size_t offset)
+  {
+    return m_Ptr + offset;
+  }
+
+  void parse(const std::string& token, size_t index) override
+  {
+    m_Ptr[index] = std::stof(token);
+  }
+
+protected:
+  NumericParser<T>(T* ptr, size_t size, const std::string& name, int index)
+  : m_Ptr(ptr)
+  {
+    setManageMemory(true);
+    setSize(size);
+    setColumnName(name);
+    setColumnIndex(index);
+  }
+
+private:
+  T* m_Ptr;
+
+public:
+  NumericParser<T>(const NumericParser<T>&) = delete;            // Copy Constructor Not Implemented
+  NumericParser<T>(NumericParser<T>&&) = delete;                 // Move Constructor Not Implemented
+  NumericParser<T>& operator=(const NumericParser<T>&) = delete; // Copy Assignment Not Implemented
+  NumericParser<T>& operator=(NumericParser<T>&&) = delete;      // Move Assignment Not Implemented
+};
+