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 "vtkHDFUtilities.h"
#include "vtkHDFWriter.h"
#include "vtkType.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::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 CreateSingleValueDataset(hid_t group, const char* name, vtkIdType value);
 
  bool InitDynamicDataset(hid_t group, const char* name, hid_t type, hsize_t cols,
    hsize_t chunkSize[], int compressionLevel = 0);
 
  bool AddSingleValueToDataset(hid_t dataset, 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 AddOrCreateSingleValueDataset(
    hid_t group, const char* name, 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