vtkDataReader.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkDataReader.h

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
#ifndef vtkDataReader_h
#define vtkDataReader_h

#include "vtkIOLegacyModule.h" // For export macro
#include "vtkSimpleReader.h"
#include "vtkStdString.h" // For API using strings

#define VTK_ASCII 1
#define VTK_BINARY 2

class vtkAbstractArray;
class vtkCharArray;
class vtkDataSet;
class vtkDataSetAttributes;
class vtkFieldData;
class vtkGraph;
class vtkPointSet;
class vtkRectilinearGrid;
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(const char* fname);
  const char* GetFileName() const;
  const char* GetFileName(int i) const
  {
    return this->vtkSimpleReader::GetFileName(i);
  }


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


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


  vtkGetStringMacro(Header);


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


  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(const char* fname = nullptr);

  int ReadHeader(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(vtkIdType size, int *data);

  int ReadCells(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);


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


  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, const 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(const std::string& /*fname*/,
                     vtkDataObject* /*output*/) override {return 1;}
  int ReadPointsSimple(const std::string& /*fname*/,
                       vtkDataObject* /*output*/) override {return 1;}
  int ReadArraysSimple(const std::string& /*fname*/,
                       vtkDataObject* /*output*/) override {return 1;}


protected:
  vtkDataReader();
  ~vtkDataReader() override;

  std::string CurrentFileName;
  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;
  int FileMajorVersion;
  int FileMinorVersion;

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

  int ProcessRequest(vtkInformation *, vtkInformationVector **,
                             vtkInformationVector *) override;
  virtual int RequestData(vtkInformation *, vtkInformationVector **,
                          vtkInformationVector *)
    { return 1; }
  virtual int RequestUpdateExtent(vtkInformation *, vtkInformationVector **,
                                  vtkInformationVector *)
    { return 1; }
  virtual int RequestInformation(vtkInformation *, vtkInformationVector **,
                                 vtkInformationVector *)
    { return 1; }

private:
  vtkDataReader(const vtkDataReader&) = delete;
  void operator=(const vtkDataReader&) = delete;

  void ConvertGhostLevelsToGhostType(
    FieldType fieldType, vtkAbstractArray *data) const;
};

#endif