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 <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() { return this->StepsGroup; }
 
  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();
 
  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);
 
  herr_t CreateSoftLink(hid_t group, const char* groupName, const char* targetLink);
 
  herr_t 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[]);
 
  vtkHDF::ScopedH5DHandle 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, int value);
  vtkHDF::ScopedH5DHandle Create2DValueDataset(hid_t group, const char* name, int* value, int size);
 
  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, int value, bool offset, bool trim = false);
 
  bool AddFieldDataSizeValueToDataset(hid_t dataset, int* value, int 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, int value, bool offset = false, bool trim = false);
 
  bool AddOrCreateFieldDataSizeValueDataset(
    hid_t group, const char* name, int* value, int size, bool offset = false);
 
  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;
  std::string HdfType;
  bool SubFilesReady = false;
 
  const std::array<std::string, 4> PrimitiveNames = { { "Vertices", "Lines", "Polygons",
    "Strips" } };
 
  hsize_t GetNumberOfCellsSubfile(
    std::size_t subfileId, hsize_t part, bool isPolyData, const std::string& groupName);
 
  char GetPrimitive(hid_t group);
 
  hsize_t GetSubfileNumberOf(
    const std::string& name, std::size_t subfileId, hsize_t part, char primitive = -1);
 
  bool GetSubFilesDatasetSize(const char* datasetPath, const char* groupName, hsize_t& totalSize);
 
  // Possible indexing mode of VTKHDF datasets. See `GetDatasetIndexationMode`
  enum class IndexingMode
  {
    Points,
    Cells,
    Connectivity,
    MetaData,
    Undefined
  };
 
  IndexingMode GetDatasetIndexationMode(hid_t group, const char* name);
};
 
VTK_ABI_NAMESPACE_END
#endif
// VTK-HeaderTest-Exclude: vtkHDFWriterImplementation.h