vtkHDFWriterImplementation.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 vtkHDFWriterImplementation_h
#define vtkHDFWriterImplementation_h
 
#include "vtkAbstractArray.h"
#include "vtkCellArray.h"
#include "vtkHDF5ScopedHandle.h"
#include "vtkHDFWriter.h"
#include "vtkType.h"
#include "vtk_hdf5.h"
 
#include <array>
#include <string>
 
VTK_ABI_NAMESPACE_BEGIN
 
class vtkHDFWriter::Implementation
{
public:
  hid_t GetRoot() { return this->Root; }
  hid_t GetFile() { return this->File; }
  hid_t GetStepsGroup(hid_t currentGroup);
 
  void SetChunkSize(int chunkSize) { this->ChunkSize = chunkSize; };
  void SetCompressionLevel(int level) { this->CompressionLevel = level; };

  bool WriteHeader(hid_t group, const char* hdfType);

  bool CreateFile(bool overwrite, const std::string& filename);

  bool OpenFile();

  void CloseFile();

  bool OpenSubfile(const std::string& filename);


  void SetSubFilesReady(bool status) { this->SubFilesReady = status; }
  bool GetSubFilesReady() { return this->SubFilesReady; }

  bool CreateStepsGroup(hid_t group);

  typedef struct
  {
    const char* hdfGroupName;
    vtkCellArray* cellArray;
  } PolyDataTopos;

  std::vector<PolyDataTopos> GetCellArraysForTopos(vtkPolyData* polydata);
 
  // Creation utility functions

  vtkHDF::ScopedH5DHandle CreateAndWriteHdfDataset(hid_t group, hid_t type, hid_t source_type,
    const char* name, const std::vector<hsize_t>& dimensions, const void* data);

  vtkHDF::ScopedH5SHandle CreateSimpleDataspace(const std::vector<hsize_t>& dimensions);

  vtkHDF::ScopedH5AHandle CreateScalarAttribute(hid_t group, const char* name, int value);

  vtkHDF::ScopedH5AHandle CreateVectorAttribute(
    hid_t group, const char* name, hid_t type, hsize_t size, const void* data);

  vtkHDF::ScopedH5AHandle CreateStringAttribute(
    hid_t group, const char* name, const std::string& value);

  vtkHDF::ScopedH5GHandle CreateHdfGroup(hid_t group, const char* name);

  vtkHDF::ScopedH5GHandle CreateHdfGroupWithLinkOrder(hid_t group, const char* name);

  bool CreateSoftLink(hid_t group, const char* groupName, const char* targetLink);

  bool CreateExternalLink(
    hid_t group, const char* filename, const char* source, const char* targetLink);

  vtkHDF::ScopedH5GHandle OpenExistingGroup(hid_t group, const char* name);

  vtkHDF::ScopedH5DHandle OpenDataset(hid_t group, const char* name);

  hsize_t GetDataSetSize(hid_t group, const char* name);

  std::string GetGroupName(hid_t group);

  vtkHDF::ScopedH5DHandle CreateHdfDataset(
    hid_t group, const char* name, hid_t type, hid_t dataspace);

  vtkHDF::ScopedH5DHandle CreateHdfDataset(
    hid_t group, const char* name, hid_t type, const std::vector<hsize_t>& dimensions);

  bool CreateVirtualDataset(hid_t group, const char* name, hid_t type, int numComp);


  bool WriteSumSteps(hid_t group, const char* name);
  bool WriteSumStepsPolyData(hid_t group, const char* name);

  vtkHDF::ScopedH5SHandle CreateDataspaceFromArray(
    vtkAbstractArray* dataArray, const std::vector<hsize_t>& dims = {});

  vtkHDF::ScopedH5DHandle CreateDatasetFromDataArray(hid_t group, const char* name, hid_t type,
    vtkAbstractArray* dataArray, const std::vector<hsize_t>& dims = {});

  vtkHDF::ScopedH5DHandle CreateSingleRowDataset(
    hid_t group, const char* name, const std::vector<vtkIdType>& values);


  bool InitDynamicDataset(
    hid_t group, const char* name, hid_t type, hsize_t cols, const std::vector<hsize_t>& chunkSize);
  bool InitDynamicDataset(hid_t group, const char* name, hid_t type,
    const std::vector<hsize_t>& dims, const std::vector<hsize_t>& chunkSize);

  bool AddSingleRowToDataset(
    hid_t dataset, const std::vector<vtkIdType>& value, bool offset, bool trim = false);

  bool AddFieldDataSizeValueToDataset(hid_t dataset, vtkIdType* value, vtkIdType size, bool offset);

  bool AddArrayToDataset(hid_t dataset, vtkAbstractArray* dataArray, int trim = 0,
    const std::vector<hsize_t>& dims = {});

  bool AddOrCreateDataset(hid_t group, const char* name, hid_t type, vtkAbstractArray* dataArray,
    const std::vector<hsize_t>& dims = {});

  bool AddOrCreateSingleRowDataset(hid_t group, const char* name,
    const std::vector<vtkIdType>& value, bool offset = false, bool trim = false);

  bool AddOrCreateFieldDataSizeValueDataset(
    hid_t group, const char* name, vtkIdType* value, vtkIdType size, bool offset = false);

  vtkHDF::ScopedH5GHandle GetSubfileNonNullPart(const std::string& blockPath, int& type);

  void CreateArraysFromNonNullPart(hid_t group, vtkDataObject* data);
 
  Implementation(vtkHDFWriter* writer);
  virtual ~Implementation();
 
private:
  vtkHDFWriter* Writer;
  vtkHDF::ScopedH5FHandle File;
  vtkHDF::ScopedH5GHandle Root;
  vtkHDF::ScopedH5GHandle StepsGroup;
  std::vector<vtkHDF::ScopedH5FHandle> Subfiles;
  std::vector<std::string> SubfileNames;
  bool SubFilesReady = false;
 
  // Forwarded constant properties from the writer
  int ChunkSize = 25000;
  int CompressionLevel = 0;
 
  const std::array<std::string, 4> PrimitiveNames = { { "Vertices", "Lines", "Polygons",
    "Strips" } };

  hsize_t GetNumberOfCellsSubfile(const std::string& basePath, std::size_t subfileId, hsize_t part,
    bool isPolyData, const std::string& groupName);

  char GetPrimitive(hid_t group);

  hsize_t GetSubfileNumberOf(const std::string& base, const std::string& qualifier,
    std::size_t subfileId, hsize_t part, char primitive = 0xff);
 
  std::string GetBasePath(const std::string& fullPath);

  bool DatasetAndGroupExist(const std::string& dataset, hid_t group);

  bool GetSubFilesDatasetSize(
    const std::string& datasetPath, const std::string& groupName, hsize_t& totalSize);
 
  // Possible indexing mode of VTKHDF datasets. See `GetDatasetIndexationMode`
  enum class IndexingMode
  {
    Points,
    Cells,
    Connectivity,
    TreeDepths,
    Trees,
    Descriptor,
    HTGCoords,
    MetaData,
    Undefined
  };

  IndexingMode GetDatasetIndexationMode(const std::string& path);
};
 
VTK_ABI_NAMESPACE_END
#endif
// VTK-HeaderTest-Exclude: vtkHDFWriterImplementation.h