vtkAVSucdReader.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkAVSucdReader.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 vtkAVSucdReader_h
#define vtkAVSucdReader_h
 
#include "vtkIOGeometryModule.h" // For export macro
#include "vtkUnstructuredGridAlgorithm.h"
 
class vtkIntArray;
class vtkFloatArray;
class vtkIdTypeArray;
class vtkDataArraySelection;
 
class VTKIOGEOMETRY_EXPORT vtkAVSucdReader : public vtkUnstructuredGridAlgorithm
{
public:
  static vtkAVSucdReader* New();
  vtkTypeMacro(vtkAVSucdReader, vtkUnstructuredGridAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  vtkSetFilePathMacro(FileName);
  vtkGetFilePathMacro(FileName);
 
 
  vtkSetMacro(BinaryFile, vtkTypeBool);
  vtkGetMacro(BinaryFile, vtkTypeBool);
  vtkBooleanMacro(BinaryFile, vtkTypeBool);
 
 
  vtkGetMacro(NumberOfCells, int);
 
 
  vtkGetMacro(NumberOfNodes, int);
 
 
  vtkGetMacro(NumberOfNodeFields, int);
 
 
  vtkGetMacro(NumberOfCellFields, int);
 
 
  vtkGetMacro(NumberOfFields, int);
 
 
  vtkGetMacro(NumberOfNodeComponents, int);
  vtkGetMacro(NumberOfCellComponents, int);
 
 
  void SetByteOrderToBigEndian();
  void SetByteOrderToLittleEndian();
  const char* GetByteOrderAsString();
 
  vtkSetMacro(ByteOrder, int);
  vtkGetMacro(ByteOrder, int);
 
 
  int GetNumberOfPointArrays();
  int GetNumberOfCellArrays();
  const char* GetPointArrayName(int index);
  const char* GetCellArrayName(int index);
  int GetPointArrayStatus(const char* name);
  int GetCellArrayStatus(const char* name);
  void SetPointArrayStatus(const char* name, int status);
  void SetCellArrayStatus(const char* name, int status);
 
  void DisableAllCellArrays();
  void EnableAllCellArrays();
  void DisableAllPointArrays();
  void EnableAllPointArrays();
 
  // get min and max value for the index-th value of a cell component
  // index varies from 0 to (veclen - 1)
  void GetCellDataRange(int cellComp, int index, float* min, float* max);
 
  // get min and max value for the index-th value of a node component
  // index varies from 0 to (veclen - 1)
  void GetNodeDataRange(int nodeComp, int index, float* min, float* max);
 
protected:
  vtkAVSucdReader();
  ~vtkAVSucdReader() override;
  int RequestInformation(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
  char* FileName;
  vtkTypeBool BinaryFile;
 
  int NumberOfNodes;
  int NumberOfCells;
  int NumberOfNodeFields;
  int NumberOfNodeComponents;
  int NumberOfCellComponents;
  int NumberOfCellFields;
  int NumberOfFields;
  int NlistNodes;
 
  istream* FileStream;
 
  vtkDataArraySelection* PointDataArraySelection;
  vtkDataArraySelection* CellDataArraySelection;
 
  int ByteOrder;
  int GetLabel(char* string, int number, char* label);
 
  enum
  {
    FILE_BIG_ENDIAN = 0,
    FILE_LITTLE_ENDIAN = 1
  };
  enum UCDCell_type
  {
    PT = 0,
    LINE = 1,
    TRI = 2,
    QUAD = 3,
    TET = 4,
    PYR = 5,
    PRISM = 6,
    HEX = 7
  };
 
  struct DataInfo
  {
    long foffset; // offset in binary file
    int veclen;   // number of components in the node or cell variable
    float min[3]; // pre-calculated data minima (max size 3 for vectors)
    float max[3]; // pre-calculated data maxima (max size 3 for vectors)
  };
 
  DataInfo* NodeDataInfo;
  DataInfo* CellDataInfo;
 
private:
  struct idMapping;
 
  void ReadFile(vtkUnstructuredGrid* output);
  void ReadGeometry(vtkUnstructuredGrid* output, idMapping& nodeMap, idMapping& cellMap);
  void ReadNodeData(vtkUnstructuredGrid* output, const idMapping& nodeMap);
  void ReadCellData(vtkUnstructuredGrid* output, const idMapping& cellMap);
 
  int ReadFloatBlock(int n, float* block);
  int ReadIntBlock(int n, int* block);
  void ReadXYZCoords(vtkFloatArray* coords, idMapping& nodeMap);
  void ReadBinaryCellTopology(vtkIntArray* material, int* types, vtkIdTypeArray* listcells);
  void ReadASCIICellTopology(vtkIntArray* material, vtkUnstructuredGrid* output,
    const idMapping& nodeMap, idMapping& cellMap);
 
  vtkAVSucdReader(const vtkAVSucdReader&) = delete;
  void operator=(const vtkAVSucdReader&) = delete;
};
 
#endif