vtkDataReader.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 vtkDataReader_h
#define vtkDataReader_h
 
#include "vtkIOLegacyModule.h" // For export macro
#include "vtkSimpleReader.h"
#include "vtkStdString.h" // For API using strings
 
#include <vtkSmartPointer.h> // for smart pointer
 
#include <istream>   // for IStream
#include <locale>    // For locale settings
#include <memory>    // for unique_ptr
#include <streambuf> // for Streambuf
 
#define VTK_ASCII 1
#define VTK_BINARY 2
 
VTK_ABI_NAMESPACE_BEGIN
class vtkAbstractArray;
class vtkCharArray;
class vtkCellArray;
class vtkDataSet;
class vtkDataSetAttributes;
class vtkFieldData;
class vtkGraph;
class vtkPointSet;
class vtkRectilinearGrid;
class vtkResourceStream;
class vtkTable;
 
class VTKIOLEGACY_EXPORT vtkDataReader : public vtkSimpleReader
{
public:
  enum FieldType
  {
    POINT_DATA,
    CELL_DATA,
    FIELD_DATA
  };
 
  static vtkDataReader* New();
  vtkTypeMacro(vtkDataReader, vtkSimpleReader);
  void PrintSelf(ostream& os, vtkIndent indent) override;


  void SetFileName(VTK_FILEPATH const char* fname);
  VTK_FILEPATH const char* GetFileName() const;
  VTK_FILEPATH const char* GetFileName(int i) const
  {
    return this->vtkSimpleReader::GetFileName(i);
  }



  vtkGetMacro(FileVersion, int);
  vtkGetMacro(FileMajorVersion, int);
  vtkGetMacro(FileMinorVersion, int);


  int IsFileValid(const char* dstype);
  int IsFileStructuredPoints() { return this->IsFileValid("structured_points"); }
  int IsFilePolyData() { return this->IsFileValid("polydata"); }
  int IsFileStructuredGrid() { return this->IsFileValid("structured_grid"); }
  int IsFileUnstructuredGrid() { return this->IsFileValid("unstructured_grid"); }
  int IsFileRectilinearGrid() { return this->IsFileValid("rectilinear_grid"); }


  void SetInputString(const char* in);
  vtkGetStringMacro(InputString);
  void SetInputString(const char* in, int len);
  vtkGetMacro(InputStringLength, int);
  void SetBinaryInputString(const char*, int len);
  void SetInputString(const vtkStdString& input)
  {
    this->SetBinaryInputString(input.c_str(), static_cast<int>(input.length()));
  }



  void SetStream(vtkResourceStream* stream);
  vtkResourceStream* GetStream();


  virtual void SetInputArray(vtkCharArray*);
  vtkGetObjectMacro(InputArray, vtkCharArray);


  vtkGetStringMacro(Header);


  vtkSetMacro(ReadFromInputString, vtkTypeBool);
  vtkGetMacro(ReadFromInputString, vtkTypeBool);
  vtkBooleanMacro(ReadFromInputString, vtkTypeBool);


  vtkSetMacro(ReadFromInputStream, bool);
  vtkGetMacro(ReadFromInputStream, bool);
  vtkBooleanMacro(ReadFromInputStream, bool);


  vtkGetMacro(FileType, int);

  int GetNumberOfScalarsInFile()
  {
    this->CharacterizeFile();
    return this->NumberOfScalarsInFile;
  }
  int GetNumberOfVectorsInFile()
  {
    this->CharacterizeFile();
    return this->NumberOfVectorsInFile;
  }
  int GetNumberOfTensorsInFile()
  {
    this->CharacterizeFile();
    return this->NumberOfTensorsInFile;
  }
  int GetNumberOfNormalsInFile()
  {
    this->CharacterizeFile();
    return this->NumberOfNormalsInFile;
  }
  int GetNumberOfTCoordsInFile()
  {
    this->CharacterizeFile();
    return this->NumberOfTCoordsInFile;
  }
  int GetNumberOfFieldDataInFile()
  {
    this->CharacterizeFile();
    return this->NumberOfFieldDataInFile;
  }


  const char* GetScalarsNameInFile(int i);
  const char* GetVectorsNameInFile(int i);
  const char* GetTensorsNameInFile(int i);
  const char* GetNormalsNameInFile(int i);
  const char* GetTCoordsNameInFile(int i);
  const char* GetFieldDataNameInFile(int i);


  vtkSetStringMacro(ScalarsName);
  vtkGetStringMacro(ScalarsName);


  vtkSetStringMacro(VectorsName);
  vtkGetStringMacro(VectorsName);


  vtkSetStringMacro(TensorsName);
  vtkGetStringMacro(TensorsName);


  vtkSetStringMacro(NormalsName);
  vtkGetStringMacro(NormalsName);


  vtkSetStringMacro(TCoordsName);
  vtkGetStringMacro(TCoordsName);


  vtkSetStringMacro(LookupTableName);
  vtkGetStringMacro(LookupTableName);


  vtkSetStringMacro(FieldDataName);
  vtkGetStringMacro(FieldDataName);


  vtkSetMacro(ReadAllScalars, vtkTypeBool);
  vtkGetMacro(ReadAllScalars, vtkTypeBool);
  vtkBooleanMacro(ReadAllScalars, vtkTypeBool);


  vtkSetMacro(ReadAllVectors, vtkTypeBool);
  vtkGetMacro(ReadAllVectors, vtkTypeBool);
  vtkBooleanMacro(ReadAllVectors, vtkTypeBool);


  vtkSetMacro(ReadAllNormals, vtkTypeBool);
  vtkGetMacro(ReadAllNormals, vtkTypeBool);
  vtkBooleanMacro(ReadAllNormals, vtkTypeBool);


  vtkSetMacro(ReadAllTensors, vtkTypeBool);
  vtkGetMacro(ReadAllTensors, vtkTypeBool);
  vtkBooleanMacro(ReadAllTensors, vtkTypeBool);


  vtkSetMacro(ReadAllColorScalars, vtkTypeBool);
  vtkGetMacro(ReadAllColorScalars, vtkTypeBool);
  vtkBooleanMacro(ReadAllColorScalars, vtkTypeBool);


  vtkSetMacro(ReadAllTCoords, vtkTypeBool);
  vtkGetMacro(ReadAllTCoords, vtkTypeBool);
  vtkBooleanMacro(ReadAllTCoords, vtkTypeBool);


  vtkSetMacro(ReadAllFields, vtkTypeBool);
  vtkGetMacro(ReadAllFields, vtkTypeBool);
  vtkBooleanMacro(ReadAllFields, vtkTypeBool);

  int OpenVTKFile(VTK_FILEPATH const char* fname = nullptr);

  int ReadHeader(VTK_FILEPATH const char* fname = nullptr);

  int ReadCellData(vtkDataSet* ds, vtkIdType numCells);

  int ReadPointData(vtkDataSet* ds, vtkIdType numPts);

  int ReadPointCoordinates(vtkPointSet* ps, vtkIdType numPts);

  int ReadPointCoordinates(vtkGraph* g, vtkIdType numPts);

  int ReadVertexData(vtkGraph* g, vtkIdType numVertices);

  int ReadEdgeData(vtkGraph* g, vtkIdType numEdges);

  int ReadRowData(vtkTable* t, vtkIdType numEdges);

  int ReadCells(vtkSmartPointer<vtkCellArray>& cellArray);

  int ReadCellsLegacy(vtkIdType size, int* data);

  int ReadCellsLegacy(vtkIdType size, int* data, int skip1, int read2, int skip3);

  int ReadCoordinates(vtkRectilinearGrid* rg, int axes, int numCoords);


  vtkAbstractArray* ReadArray(const char* dataType, vtkIdType numTuples, vtkIdType numComp);
  vtkFieldData* ReadFieldData(FieldType fieldType = FIELD_DATA);


  int Read(char*);
  int Read(unsigned char*);
  int Read(short*);
  int Read(unsigned short*);
  int Read(int*);
  int Read(unsigned int*);
  int Read(long*);
  int Read(unsigned long*);
  int Read(long long* result);
  int Read(unsigned long long* result);
  int Read(float*);
  int Read(double*);

  size_t Peek(char* str, size_t n);

  void CloseVTKFile();

  int ReadLine(char result[256]);

  int ReadString(char (&result)[256]);

  char* LowerCase(char* str, size_t len = 256);

  istream* GetIStream() { return this->IS; }


  int ReadTimeDependentMetaData(int timestep, vtkInformation* metadata) override;
  int ReadMesh(int piece, int npieces, int nghosts, int timestep, vtkDataObject* output) override;
  int ReadPoints(int /*piece*/, int /*npieces*/, int /*nghosts*/, int /*timestep*/,
    vtkDataObject* /*output*/) override
  {
    return 1;
  }
  int ReadArrays(int /*piece*/, int /*npieces*/, int /*nghosts*/, int /*timestep*/,
    vtkDataObject* /*output*/) override
  {
    return 1;
  }



  int ReadMeshSimple(VTK_FILEPATH const std::string& /*fname*/, vtkDataObject* /*output*/) override
  {
    return 1;
  }
  int ReadPointsSimple(
    VTK_FILEPATH const std::string& /*fname*/, vtkDataObject* /*output*/) override
  {
    return 1;
  }
  int ReadArraysSimple(
    VTK_FILEPATH const std::string& /*fname*/, vtkDataObject* /*output*/) override
  {
    return 1;
  }


  vtkMTimeType GetMTime() override;
 
protected:
  vtkDataReader();
  ~vtkDataReader() override;
 
  std::string CurrentFileName;
  int FileVersion;
  int FileMajorVersion;
  int FileMinorVersion;
  int FileType;
  istream* IS;
 
  char* ScalarsName;
  char* VectorsName;
  char* TensorsName;
  char* TCoordsName;
  char* NormalsName;
  char* LookupTableName;
  char* FieldDataName;
  char* ScalarLut;
 
  vtkTypeBool ReadFromInputString;
  char* InputString;
  int InputStringLength;
  int InputStringPos;
 
  void SetScalarLut(const char* lut);
  vtkGetStringMacro(ScalarLut);
 
  char* Header;
 
  int ReadScalarData(vtkDataSetAttributes* a, vtkIdType num);
  int ReadVectorData(vtkDataSetAttributes* a, vtkIdType num);
  int ReadNormalData(vtkDataSetAttributes* a, vtkIdType num);
  int ReadTensorData(vtkDataSetAttributes* a, vtkIdType num, vtkIdType numComp = 9);
  int ReadCoScalarData(vtkDataSetAttributes* a, vtkIdType num);
  int ReadLutData(vtkDataSetAttributes* a);
  int ReadTCoordsData(vtkDataSetAttributes* a, vtkIdType num);
  int ReadGlobalIds(vtkDataSetAttributes* a, vtkIdType num);
  int ReadPedigreeIds(vtkDataSetAttributes* a, vtkIdType num);
  int ReadEdgeFlags(vtkDataSetAttributes* a, vtkIdType num);

  int ReadInformation(vtkInformation* info, vtkIdType numKeys);
 
  int ReadDataSetData(vtkDataSet* ds);
 
  // This supports getting additional information from vtk files
  int NumberOfScalarsInFile;
  char** ScalarsNameInFile;
  int ScalarsNameAllocSize;
  int NumberOfVectorsInFile;
  char** VectorsNameInFile;
  int VectorsNameAllocSize;
  int NumberOfTensorsInFile;
  char** TensorsNameInFile;
  int TensorsNameAllocSize;
  int NumberOfTCoordsInFile;
  char** TCoordsNameInFile;
  int TCoordsNameAllocSize;
  int NumberOfNormalsInFile;
  char** NormalsNameInFile;
  int NormalsNameAllocSize;
  int NumberOfFieldDataInFile;
  char** FieldDataNameInFile;
  int FieldDataNameAllocSize;
  vtkTimeStamp CharacteristicsTime;
 
  vtkTypeBool ReadAllScalars;
  vtkTypeBool ReadAllVectors;
  vtkTypeBool ReadAllNormals;
  vtkTypeBool ReadAllTensors;
  vtkTypeBool ReadAllColorScalars;
  vtkTypeBool ReadAllTCoords;
  vtkTypeBool ReadAllFields;
 
  std::locale CurrentLocale;
 
  void InitializeCharacteristics();
  int CharacterizeFile(); // read entire file, storing important characteristics
  void CheckFor(const char* name, char* line, int& num, char**& array, int& allocSize);
 
  vtkCharArray* InputArray;

  int DecodeString(char* resname, const char* name);
 
private:
  vtkDataReader(const vtkDataReader&) = delete;
  void operator=(const vtkDataReader&) = delete;
 
  void ConvertGhostLevelsToGhostType(FieldType fieldType, vtkAbstractArray* data) const;
 
  // The stream used to read the input if it is in a resource stream
  vtkSmartPointer<vtkResourceStream> Stream;
  bool ReadFromInputStream = false;
 
  // Used when converting vtkResourceStream into istream
  std::unique_ptr<std::streambuf> Streambuf;
};
 
VTK_ABI_NAMESPACE_END
#endif