vtkChacoReader.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-FileCopyrightText: Copyright (c) Sandia Corporation
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef vtkChacoReader_h
#define vtkChacoReader_h
 
#include "vtkIOGeometryModule.h" // For export macro
#include "vtkUnstructuredGridAlgorithm.h"
 
#include <string> // For std::string
#include <vector> // For std::vector
 
VTK_ABI_NAMESPACE_BEGIN
class VTKIOGEOMETRY_EXPORT vtkChacoReader : public vtkUnstructuredGridAlgorithm
{
public:
  static vtkChacoReader* New();
  vtkTypeMacro(vtkChacoReader, vtkUnstructuredGridAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  vtkSetStringMacro(BaseName);
  vtkGetStringMacro(BaseName);
 
  vtkSetMacro(GenerateGlobalElementIdArray, vtkTypeBool);
  vtkGetMacro(GenerateGlobalElementIdArray, vtkTypeBool);
  vtkBooleanMacro(GenerateGlobalElementIdArray, vtkTypeBool);
 
  static const char* GetGlobalElementIdArrayName() { return "GlobalElementId"; }
 
  vtkSetMacro(GenerateGlobalNodeIdArray, vtkTypeBool);
  vtkGetMacro(GenerateGlobalNodeIdArray, vtkTypeBool);
  vtkBooleanMacro(GenerateGlobalNodeIdArray, vtkTypeBool);
 
  static const char* GetGlobalNodeIdArrayName() { return "GlobalNodeId"; }
 
  vtkSetMacro(GenerateVertexWeightArrays, vtkTypeBool);
  vtkGetMacro(GenerateVertexWeightArrays, vtkTypeBool);
  vtkBooleanMacro(GenerateVertexWeightArrays, vtkTypeBool);
 
  vtkGetMacro(NumberOfVertexWeights, int);
 
  const char* GetVertexWeightArrayName(int weight);
 
  vtkSetMacro(GenerateEdgeWeightArrays, vtkTypeBool);
  vtkGetMacro(GenerateEdgeWeightArrays, vtkTypeBool);
  vtkBooleanMacro(GenerateEdgeWeightArrays, vtkTypeBool);
 
  vtkGetMacro(NumberOfEdgeWeights, int);
 
  const char* GetEdgeWeightArrayName(int weight);
 
 
  vtkGetMacro(Dimensionality, int);
  vtkGetMacro(NumberOfEdges, vtkIdType);
  vtkGetMacro(NumberOfVertices, vtkIdType);
 
  vtkGetMacro(NumberOfCellWeightArrays, int);
 
  vtkGetMacro(NumberOfPointWeightArrays, int);
 
protected:
  vtkChacoReader();
  ~vtkChacoReader() override;
 
  int BuildOutputGrid(vtkUnstructuredGrid* gr);
 
  // methods for parsing Chaco files
 
  void CloseCurrentFile();
  int OpenCurrentFile();
 
  int InputGeom(vtkIdType nvtxs, int igeom, double* x, double* y, double* z);
  int InputGraph1();
  int InputGraph2(vtkIdType** start, vtkIdType** adjacency, double** vweights, double** eweights);
  int GetCoordsMetadata();
  void GetGraphMetadata();
 
  // methods for creating vtkUnstructuredGrid from Chaco file data
 
  int ReadFile(vtkUnstructuredGrid* output);
  void AddElementIds(vtkUnstructuredGrid* output);
  void AddNodeIds(vtkUnstructuredGrid* output);
 
  void MakeWeightArrayNames(int nv, int ne);
 
  // Parameters for controlling what is read in.
  char* BaseName;
  vtkTypeBool GenerateGlobalElementIdArray;
  vtkTypeBool GenerateGlobalNodeIdArray;
 
  vtkTypeBool GenerateVertexWeightArrays;
  vtkTypeBool GenerateEdgeWeightArrays;
 
  FILE* CurrentGeometryFP;
  FILE* CurrentGraphFP;
  char* CurrentBaseName;
  vtkSetStringMacro(CurrentBaseName);
 
  std::vector<std::string> VarrayName;
  std::vector<std::string> EarrayName;
 
  //----------------------------------------------------------------------
  // The following metadata is read during RequestInformation.  If you
  // add new metadata, you must modify vtkPChacoReader::RequestInformation
  // to include it when process 0 broadcasts the metadata.
 
  int Dimensionality;
  vtkIdType NumberOfVertices;
  vtkIdType NumberOfEdges;
  int NumberOfVertexWeights; // in file
  int NumberOfEdgeWeights;   // in file
  int GraphFileHasVertexNumbers;
 
  //----------------------------------------------------------------------
 
  int NumberOfPointWeightArrays; // in output unstructured grid
  int NumberOfCellWeightArrays;  // in output unstructured grid
 
  // Keep the points and cells
  // around so they don't need to be re-read when the
  // options change.
  vtkUnstructuredGrid* DataCache;
 
  // Should I re-read in the geometry and topology of the dataset
  int RemakeDataCacheFlag;
 
  int RequestInformation(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
private:
  vtkChacoReader(const vtkChacoReader&) = delete;
  void operator=(const vtkChacoReader&) = delete;
 
  double ReadVal(FILE* infile, int* end_flag);
  vtkIdType ReadInt(FILE* infile, int* end_flag);
  void FlushLine(FILE* infile);
  void ResetInputBuffers();
 
  char Line[200];
  const int Line_length = 200;
  int Offset;
  int Break_pnt;
  int Save_pnt;
 
  void ClearWeightArrayNames();
};
 
VTK_ABI_NAMESPACE_END
#endif