9.1/html/vtkDataReader_8h_source.html

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


  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


#include <vtkSmartPointer.h> // for smart pointer


#include <locale> // For locale settings


#define VTK_ASCII 1

#define VTK_BINARY 2


class vtkAbstractArray;

class vtkCharArray;

class vtkCellArray;

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

  }


  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(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, 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(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;

  }


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;

};


#endif