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 vtkBitArray;
class vtkDataArray;
class vtkDataAssembly;
class vtkMemoryResourceStream;
class vtkResourceStream;
class vtkStringArray;

class vtkHDFReader::Implementation
{
public:
  Implementation(vtkHDFReader* reader);
  virtual ~Implementation();

  bool Open(VTK_FILEPATH const char* fileName);

  bool Open(vtkResourceStream* stream);

  void Close();
  int GetDataSetType() { return this->DataSetType; }
  vtkHDFReader* GetReader() { return this->Reader; }
  const std::array<int, 2>& GetVersion() { return this->Version; }
  template <typename T>
  bool GetAttribute(const char* attributeName, size_t numberOfElements, T* value);
  bool HasAttribute(const char* groupName, const char* attributeName);
  bool HasDataset(const char* datasetName);
  int GetNumberOfPieces(vtkIdType step = -1);
  bool GetPartitionExtent(hsize_t partitionIndex, int* extent);
  std::vector<std::string> GetArrayNames(int attributeType);
  std::vector<std::string> GetOrderedChildrenOfGroup(const std::string& path);

  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, vtkIdType dimMaxSize = -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 IsPathSoftLink(const std::string& path);


  bool FillAssembly(vtkDataAssembly* data);
  bool FillAssembly(vtkDataAssembly* data, hid_t assemblyHandle, int assemblyID, std::string path);

  std::size_t GetNumberOfSteps();


  vtkDataArray* GetStepValues();
  vtkDataArray* GetStepValues(hid_t group);

  vtkIdType GetArrayOffset(vtkIdType step, int attributeType, std::string name);

  std::array<vtkIdType, 2> GetFieldArraySize(vtkIdType step, std::string name);

  bool OpenGroupAsVTKGroup(const std::string& groupPath);

  bool RetrieveHDFInformation(const std::string& rootName);

  bool GetImageAttributes(int WholeExtent[6], double Origin[3], double Spacing[3]);


  bool ComputeAMRBlocksPerLevels(unsigned int maxLevel);

  bool ComputeAMROffsetsPerLevels(
    vtkDataArraySelection* dataArraySelection[3], vtkIdType step, unsigned int maxLevel);

  bool ReadAMRTopology(vtkOverlappingAMR* data, unsigned int level, unsigned int maxLevel,
    double origin[3], bool isTemporalData);

  bool ReadAMRData(vtkOverlappingAMR* data, unsigned int level, unsigned int maxLevel,
    vtkDataArraySelection* dataArraySelection[3], bool isTemporalData);

  vtkSmartPointer<vtkDataObject> GetNewDataSet(int dataSetType, int numPieces);

  bool ReadHyperTreeGridData(vtkHyperTreeGrid* htg, const vtkDataArraySelection* arraySelection,
    vtkIdType cellOffset, vtkIdType treeIdsOffset, vtkIdType depthOffset,
    vtkIdType descriptorOffset, vtkIdType maskOffset, vtkIdType partOffset,
    vtkIdType verticesPerDepthOffset, vtkIdType depthLimit, vtkIdType step);

  bool ReadHyperTreeGridMetaInfo(vtkHyperTreeGrid* htg);

  bool ReadHyperTreeGridDimensions(vtkHyperTreeGrid* htg);

  bool CreateHyperTreeGridCellArrays(vtkHyperTreeGrid* htg,
    std::vector<vtkSmartPointer<vtkAbstractArray>>& cellArrays,
    const vtkDataArraySelection* arraySelection, vtkIdType cellCount);

  bool AppendCellDataForHyperTree(std::vector<vtkSmartPointer<vtkAbstractArray>>& cellArrays,
    vtkIdType cellOffset, vtkIdType inputCellOffset, vtkIdType step, vtkIdType readableTreeSize);

  bool AppendMaskForHyperTree(vtkHyperTreeGrid* htg, vtkIdType inputCellOffset,
    vtkIdType maskOffset, vtkIdType readableTreeSize);
 
private:
  std::string FileName;
  vtkResourceStream* Stream = nullptr;
  vtkNew<vtkMemoryResourceStream> LocalMemStream;
  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;


  struct AMRBlocksInformation
  {
    std::vector<int> BlocksPerLevel;
    std::vector<vtkIdType> BlockOffsetsPerLevel;
    std::map<std::string, std::vector<vtkIdType>> CellOffsetsPerLevel;
    std::map<std::string, std::vector<vtkIdType>> PointOffsetsPerLevel;
    std::map<std::string, std::vector<vtkIdType>> FieldOffsetsPerLevel;
    std::map<std::string, std::vector<vtkIdType>> FieldSizesPerLevel;
 
    void Clear()
    {
      this->BlocksPerLevel.clear();
      this->BlockOffsetsPerLevel.clear();
      this->PointOffsetsPerLevel.clear();
      this->CellOffsetsPerLevel.clear();
      this->FieldOffsetsPerLevel.clear();
      this->FieldSizesPerLevel.clear();
    }
  };
 
  AMRBlocksInformation AMRInformation;
 
  bool ReadLevelSpacing(hid_t levelGroupID, double* spacing);
  bool ReadAMRBoxRawValues(
    hid_t levelGroupID, std::vector<int>& amrBoxRawData, int level, bool isTemporalData);
  bool ReadLevelTopology(unsigned int level, const std::string& levelGroupName,
    vtkOverlappingAMR* data, double origin[3], bool isTemporalData);
  bool ReadLevelData(unsigned int level, const std::string& levelGroupName, vtkOverlappingAMR* data,
    vtkDataArraySelection* dataArraySelection[3], bool isTemporalData);
};
 
VTK_ABI_NAMESPACE_END
#endif
// VTK-HeaderTest-Exclude: vtkHDFReaderImplementation.h