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);

  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, int rank, std::vector<hsize_t> dimensions, const void* data);

  vtkHDF::ScopedH5SHandle CreateSimpleDataspace(int rank, const hsize_t dimensions[]);

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

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

  vtkHDF::ScopedH5SHandle CreateUnlimitedSimpleDataspace(hsize_t numCols);

  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);

  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, int rank, const 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::ScopedH5DHandle CreateChunkedHdfDataset(hid_t group, const char* name, hid_t type,
    hid_t dataspace, hsize_t numCols, hsize_t chunkSize[], int compressionLevel = 0);

  vtkHDF::ScopedH5SHandle CreateDataspaceFromArray(vtkAbstractArray* dataArray);

  vtkHDF::ScopedH5DHandle CreateDatasetFromDataArray(
    hid_t group, const char* name, hid_t type, vtkAbstractArray* dataArray);


  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,
    hsize_t chunkSize[], int compressionLevel = 0);

  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);

  bool AddOrCreateDataset(hid_t group, const char* name, hid_t type, vtkAbstractArray* dataArray);

  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;
 
  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,
    MetaData,
    Undefined
  };

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