v/vtk6/vtk6-doc_6.3.0%2Bdfsg2-2%2Bci202008041822_all.deb

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


  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 "vtkAlgorithm.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 vtkAlgorithm

{

public:

  enum FieldType

  {

    POINT_DATA,

    CELL_DATA,

    FIELD_DATA,

  };


  static vtkDataReader *New();

  vtkTypeMacro(vtkDataReader,vtkAlgorithm);

  void PrintSelf(ostream& os, vtkIndent indent);


  vtkSetStringMacro(FileName);

  vtkGetStringMacro(FileName);


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

  vtkGetMacro(ReadFromInputString,int);

  vtkBooleanMacro(ReadFromInputString,int);


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

  vtkGetMacro(ReadAllScalars,int);

  vtkBooleanMacro(ReadAllScalars,int);


  vtkSetMacro(ReadAllVectors,int);

  vtkGetMacro(ReadAllVectors,int);

  vtkBooleanMacro(ReadAllVectors,int);


  vtkSetMacro(ReadAllNormals,int);

  vtkGetMacro(ReadAllNormals,int);

  vtkBooleanMacro(ReadAllNormals,int);


  vtkSetMacro(ReadAllTensors,int);

  vtkGetMacro(ReadAllTensors,int);

  vtkBooleanMacro(ReadAllTensors,int);


  vtkSetMacro(ReadAllColorScalars,int);

  vtkGetMacro(ReadAllColorScalars,int);

  vtkBooleanMacro(ReadAllColorScalars,int);


  vtkSetMacro(ReadAllTCoords,int);

  vtkGetMacro(ReadAllTCoords,int);

  vtkBooleanMacro(ReadAllTCoords,int);


  vtkSetMacro(ReadAllFields,int);

  vtkGetMacro(ReadAllFields,int);

  vtkBooleanMacro(ReadAllFields,int);


  int OpenVTKFile();


  int ReadHeader();


  int ReadCellData(vtkDataSet *ds, int numCells);


  int ReadPointData(vtkDataSet *ds, int numPts);


  int ReadPoints(vtkPointSet *ps, int numPts);


  int ReadPoints(vtkGraph *g, int numPts);


  int ReadVertexData(vtkGraph *g, int numVertices);


  int ReadEdgeData(vtkGraph *g, int numEdges);


  int ReadRowData(vtkTable *t, int numEdges);


  int ReadCells(int size, int *data);


  int ReadCells(int size, int *data, int skip1, int read2, int skip3);


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


  vtkAbstractArray *ReadArray(const char *dataType, int numTuples, int numComp);

  vtkFieldData *ReadFieldData(FieldType fieldType = FIELD_DATA);


  vtkGetMacro(FileMajorVersion, int);

  vtkGetMacro(FileMinorVersion, int);


//BTX


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

#if defined(VTK_TYPE_USE___INT64)

  int Read(__int64 *result);

  int Read(unsigned __int64 *result);

#endif

#if defined(VTK_TYPE_USE_LONG_LONG)

  int Read(long long *result);

  int Read(unsigned long long *result);

#endif

  int Read(float *);

  int Read(double *);

//ETX


  void CloseVTKFile();


//BTX

  int ReadLine(char result[256]);


  int ReadString(char result[256]);


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


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

//ETX


  virtual int ReadMetaData(vtkInformation *) { return 1; }


protected:

  vtkDataReader();

  ~vtkDataReader();


  char *FileName;

  int FileType;

  istream *IS;


  char *ScalarsName;

  char *VectorsName;

  char *TensorsName;

  char *TCoordsName;

  char *NormalsName;

  char *LookupTableName;

  char *FieldDataName;

  char *ScalarLut;


  int ReadFromInputString;

  char *InputString;

  int InputStringLength;

  int InputStringPos;


  void SetScalarLut(const char* lut);

  vtkGetStringMacro(ScalarLut);


  char *Header;


  int ReadScalarData(vtkDataSetAttributes *a, int num);

  int ReadVectorData(vtkDataSetAttributes *a, int num);

  int ReadNormalData(vtkDataSetAttributes *a, int num);

  int ReadTensorData(vtkDataSetAttributes *a, int num);

  int ReadCoScalarData(vtkDataSetAttributes *a, int num);

  int ReadLutData(vtkDataSetAttributes *a);

  int ReadTCoordsData(vtkDataSetAttributes *a, int num);

  int ReadGlobalIds(vtkDataSetAttributes *a, int num);

  int ReadPedigreeIds(vtkDataSetAttributes *a, int num);

  int ReadEdgeFlags(vtkDataSetAttributes *a, int num);


  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;


  int ReadAllScalars;

  int ReadAllVectors;

  int ReadAllNormals;

  int ReadAllTensors;

  int ReadAllColorScalars;

  int ReadAllTCoords;

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


  virtual int ProcessRequest(vtkInformation *, vtkInformationVector **,

                             vtkInformationVector *);

  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&);  // Not implemented.

  void operator=(const vtkDataReader&);  // Not implemented.


  void ConvertGhostLevelsToGhostType(

    FieldType fieldType, vtkAbstractArray *data) const;

};


#endif