vtkHDFReaderImplementation.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkHDFReaderImplementation_h
#define vtkHDFReaderImplementation_h
 
#include "vtkHDFReader.h"
#include "vtk_hdf5.h"
#include <array>
#include <map>
#include <string>
#include <vector>
 
VTK_ABI_NAMESPACE_BEGIN
class vtkAbstractArray;
class vtkDataArray;
class vtkStringArray;
 
class vtkHDFReader::Implementation
{
public:
  Implementation(vtkHDFReader* reader);
  virtual ~Implementation();
  bool Open(VTK_FILEPATH const char* fileName);
  void Close();
  int GetDataSetType() { return this->DataSetType; }
  const std::array<int, 2>& GetVersion() { return this->Version; }
  template <typename T>
  bool GetAttribute(const char* attributeName, size_t numberOfElements, T* value);
  template <typename T>
  bool GetAttribute(hid_t group, const char* attributeName, size_t numberOfElements, T* value);
  int GetNumberOfPieces(vtkIdType step = -1);
  bool GetPartitionExtent(hsize_t partitionIndex, int* extent);
  std::vector<std::string> GetArrayNames(int attributeType);
 
  vtkDataArray* NewArray(
    int attributeType, const char* name, const std::vector<hsize_t>& fileExtent);
  vtkDataArray* NewArray(int attributeType, const char* name, hsize_t offset, hsize_t size);
  vtkAbstractArray* NewFieldArray(const char* name, vtkIdType offset = -1, vtkIdType size = -1);
 
 
  vtkDataArray* NewMetadataArray(const char* name, hsize_t offset, hsize_t size);
  std::vector<vtkIdType> GetMetadata(const char* name, hsize_t size, hsize_t offset = 0);
 
  std::vector<hsize_t> GetDimensions(const char* dataset);
 
  bool FillAMR(vtkOverlappingAMR* data, unsigned int maximumLevelsToReadByDefault, double origin[3],
    vtkDataArraySelection* dataArraySelection[3]);
 
 
  std::size_t GetNumberOfSteps();
  std::size_t GetNumberOfSteps(hid_t group);
 
 
  vtkDataArray* GetStepValues();
  vtkDataArray* GetStepValues(hid_t group);
 
  vtkIdType GetArrayOffset(vtkIdType step, int attributeType, std::string name);
 
protected:
  struct TypeDescription
  {
    int Class;
    size_t Size;
    int Sign;
    TypeDescription()
      : Class(H5T_NO_CLASS)
      , Size(0)
      , Sign(H5T_SGN_ERROR)
    {
    }
    bool operator<(const TypeDescription& other) const
    {
      return Class < other.Class || (Class == other.Class && Size < other.Size) ||
        (Class == other.Class && Size == other.Size && Sign < other.Sign);
    }
  };
 
  hid_t OpenDataSet(hid_t group, const char* name, hid_t* nativeType, std::vector<hsize_t>& dims);
  template <typename T>
  hid_t TemplateTypeToHdfNativeType();
  template <typename T>
  vtkDataArray* NewVtkDataArray();
 
 
  vtkDataArray* NewArrayForGroup(
    hid_t group, const char* name, const std::vector<hsize_t>& fileExtent);
  vtkDataArray* NewArrayForGroup(hid_t dataset, hid_t nativeType, const std::vector<hsize_t>& dims,
    const std::vector<hsize_t>& fileExtent);
  template <typename T>
  vtkDataArray* NewArray(
    hid_t dataset, const std::vector<hsize_t>& fileExtent, hsize_t numberOfComponents);
  template <typename T>
  bool NewArray(
    hid_t dataset, const std::vector<hsize_t>& fileExtent, hsize_t numberOfComponents, T* data);
  vtkStringArray* NewStringArray(hid_t dataset, hsize_t size);
 
  void BuildTypeReaderMap();
  TypeDescription GetTypeDescription(hid_t type);
 
private:
  std::string FileName;
  hid_t File;
  hid_t VTKGroup;
  // in the same order as vtkDataObject::AttributeTypes: POINT, CELL, FIELD
  std::array<hid_t, 3> AttributeDataGroup;
  int DataSetType;
  int NumberOfPieces;
  std::array<int, 2> Version;
  vtkHDFReader* Reader;
  using ArrayReader = vtkDataArray* (vtkHDFReader::Implementation::*)(hid_t dataset,
    const std::vector<hsize_t>& fileExtent, hsize_t numberOfComponents);
  std::map<TypeDescription, ArrayReader> TypeReaderMap;
 
  bool ReadDataSetType();
 
 
  bool ComputeAMRBlocksPerLevels(std::vector<int>& levels);
  bool ReadLevelSpacing(hid_t levelGroupID, double* spacing);
  bool ReadAMRBoxRawValues(hid_t levelGroupID, std::vector<int>& amrBoxRawData);
  bool ReadLevelTopology(unsigned int level, const std::string& levelGroupName,
    vtkOverlappingAMR* data, double origin[3]);
  bool ReadLevelData(unsigned int level, const std::string& levelGroupName, vtkOverlappingAMR* data,
    vtkDataArraySelection* dataArraySelection[3]);
};
 
VTK_ABI_NAMESPACE_END
#endif
// VTK-HeaderTest-Exclude: vtkHDFReaderImplementation.h