vtkMesh.H File Reference

Go to the source code of this file.

Classes
class	vtkMesh

Functions
template<class TReader >
vtkDataSet *	ReadAnXMLOrSTLFile (const std::string &fileName)
vtkSmartPointer< vtkUnstructuredGrid >	ReadALegacyVTKFile (const std::string &fileName)
vtkSmartPointer< vtkUnstructuredGrid >	ReadDegenerateVTKFile (const std::string &fileName)
bool	readLegacyVTKHeader (const std::string &line)
bool	readLegacyVTKFieldData (const std::istream &meshStream, const std::string &line, vtkSmartPointer< vtkUnstructuredGrid > dataSet_tmp)
bool	readLegacyVTKPoints (const std::istream &meshStream, const std::string &line, nemId_t &numPoints, vtkSmartPointer< vtkPoints > points, vtkSmartPointer< vtkUnstructuredGrid > dataSet_tmp)
bool	readLegacyVTKCells (const std::istream &meshStream, const std::string &line, nemId_t &numCells, const std::vector< vtkSmartPointer< vtkIdList >> &vtkCellIds, vtkSmartPointer< vtkUnstructuredGrid > dataSet_tmp)
bool	readLegacyVTKData (const std::ifstream &meshStream, const std::string &line, nemId_t numTuple, bool pointOrCell, bool &hasPointOrCell, vtkSmartPointer< vtkUnstructuredGrid > dataSet_tmp)
void	addLegacyVTKData (vtkDataArray *arr, const std::string &type, bool pointOrCell, vtkSmartPointer< vtkUnstructuredGrid > dataSet_tmp)
template<class TWriter >
void	writeVTFile (const std::string &fname, vtkSmartPointer< vtkDataSet > dataSet)

Function Documentation

addLegacyVTKData()

void addLegacyVTKData	(	vtkDataArray *	arr,
		const std::string &	type,
		bool	pointOrCell,
		vtkSmartPointer< vtkUnstructuredGrid >	dataSet_tmp
	)

Referenced by ReadAnXMLOrSTLFile().

ReadALegacyVTKFile()

vtkSmartPointer<vtkUnstructuredGrid> ReadALegacyVTKFile

(

const std::string &

fileName

)

Definition at line 502 of file vtkMesh.C.

References NEM::MSH::New(), meshBase::numCells, meshBase::numPoints, points, readLegacyVTKCells(), readLegacyVTKData(), readLegacyVTKFieldData(), readLegacyVTKHeader(), and readLegacyVTKPoints().

Referenced by ReadAnXMLOrSTLFile(), and vtkMesh::vtkMesh().

                               {
  std::ifstream meshStream;
  meshStream.open(fileName, std::ifstream::in);
  if (!meshStream.good()) {
    std::cerr << "Could not open file " << fileName << std::endl;
    exit(1);
  }

  // declare points to be pushed into dataSet_tmp
  vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
  // declare vector of cell ids to be pushed into dataSet_tmp
  std::vector<vtkSmartPointer<vtkIdList>> vtkCellIds;
  // declare dataSet_tmp which will be associated to output vtkMesh
  vtkSmartPointer<vtkUnstructuredGrid> dataSet_tmp =
      vtkSmartPointer<vtkUnstructuredGrid>::New();
  nemId_t numPoints(0), numCells(0);
  bool readHeader(false), readPoints(false), readCells(false),
      readFieldData(false), readCellData(false), readPointData(false),
      cellDataFirst(false), pointDataFirst(false), hasPointData(false),
      hasCellData(false);
  std::string line;

  while (getline(meshStream, line)) {
    if (!readHeader)
      if ((readHeader = readLegacyVTKHeader(line)))
        std::cout << "read header" << std::endl;

    if (!readFieldData)
      if ((readFieldData =
               readLegacyVTKFieldData(meshStream, line, dataSet_tmp)))
        std::cout << "read field data" << std::endl;

    if (!readPoints)
      if ((readPoints = readLegacyVTKPoints(meshStream, line, numPoints, points,
                                            dataSet_tmp)))
        std::cout << "read points" << std::endl;

    if (!readCells)
      if ((readCells = readLegacyVTKCells(meshStream, line, numCells,
                                          vtkCellIds, dataSet_tmp)))
        std::cout << "read cells" << std::endl;

    // call functions based on which data appears first in file
    if (!readCellData && !readPointData) {
      cellDataFirst =
          line.find("CELL_DATA") != std::string::npos && !pointDataFirst;
      pointDataFirst =
          line.find("POINT_DATA") != std::string::npos && !cellDataFirst;
    }

    // read cell data then point data if it exists
    if (cellDataFirst) {
      if (!readCellData)  // boolean telling us if there is point data
        if ((readCellData = readLegacyVTKData(meshStream, line, numCells, false,
                                              hasPointData, dataSet_tmp)))
          std::cout << "read cell data" << std::endl;

      if (!readPointData && hasPointData)
        if ((readPointData = readLegacyVTKData(meshStream, line, numPoints,
                                               true, hasCellData, dataSet_tmp)))
          std::cout << "read point data" << std::endl;
    }
    // read point data and then cell data if it exists
    else if (pointDataFirst) {
      if (!readPointData)
        if ((readPointData = readLegacyVTKData(meshStream, line, numPoints,
                                               true, hasCellData, dataSet_tmp)))
          std::cout << "read point data" << std::endl;

      if (!readCellData && hasCellData)
        if ((readCellData = readLegacyVTKData(meshStream, line, numCells, false,
                                              hasPointData, dataSet_tmp)))
          std::cout << "read cell data" << std::endl;
    }
  }
  return dataSet_tmp;
}

ReadAnXMLOrSTLFile()

template<class TReader >

vtkDataSet* ReadAnXMLOrSTLFile

(

const std::string &

fileName

)

Definition at line 40 of file vtkMesh.H.

References addLegacyVTKData(), NEM::MSH::New(), points, ReadALegacyVTKFile(), ReadDegenerateVTKFile(), readLegacyVTKCells(), readLegacyVTKData(), readLegacyVTKFieldData(), readLegacyVTKHeader(), and readLegacyVTKPoints().

                                                          {
  vtkSmartPointer<TReader> reader = vtkSmartPointer<TReader>::New();
  reader->SetFileName(fileName.c_str());
  reader->Update();
  reader->GetOutput()->Register(reader);
  return vtkDataSet::SafeDownCast(reader->GetOutput());
}

ReadDegenerateVTKFile()

vtkSmartPointer<vtkUnstructuredGrid> ReadDegenerateVTKFile

(

const std::string &

fileName

)

Definition at line 581 of file vtkMesh.C.

References cellType, nemAux::flip_map(), id, NEM::MSH::New(), meshBase::numCells, meshBase::numPoints, and points.

Referenced by ReadAnXMLOrSTLFile(), and vtkMesh::vtkMesh().

                               {
  std::ifstream meshStream(fileName);
  if (!meshStream.good()) {
    std::cerr << "Error opening file " << fileName << std::endl;
    exit(1);
  }

  std::string line;
  std::map<std::vector<double>, int> point_map;
  std::map<int, int> duplicate_point_map;
  std::pair<std::map<std::vector<double>, int>::iterator, bool> point_ret;
  int numPoints;
  int numCells;
  int cellListSize;
  std::vector<vtkSmartPointer<vtkIdList>> vtkCellIds;
  vtkSmartPointer<vtkUnstructuredGrid> dataSet_tmp =
      vtkSmartPointer<vtkUnstructuredGrid>::New();
  while (getline(meshStream, line)) {
    if (line.find("POINTS") != std::string::npos) {
      std::istringstream ss(line);
      std::string tmp;
      ss >> tmp >> numPoints;
      std::vector<double> point(3);
      int pntId = 0;
      int realPntId = 0;
      while (getline(meshStream, line) && pntId < numPoints) {
        if (!line.empty()) {
          std::istringstream ss(line);
          ss >> point[0] >> point[1] >> point[2];
          point_ret = point_map.insert(
              std::pair<std::vector<double>, int>(point, realPntId));
          if (point_ret.second) ++realPntId;
          duplicate_point_map.insert(
              std::pair<int, int>(pntId, point_ret.first->second));
          ++pntId;
        }
      }
    }

    if (line.find("CELLS") != std::string::npos) {
      std::istringstream ss(line);
      std::string tmp;
      ss >> tmp >> numCells >> cellListSize;
      int cellId = 0;
      // int realCellId = 0;
      vtkCellIds.resize(numCells);
      while (cellId < numCells && getline(meshStream, line)) {
        if (!line.empty()) {
          std::istringstream ss(line);
          int numId;
          int id;
          ss >> numId;
          vtkCellIds[cellId] = vtkSmartPointer<vtkIdList>::New();
          vtkCellIds[cellId]->SetNumberOfIds(numId);
          // cells[cellId].resize(numId);
          for (int j = 0; j < numId; ++j) {
            ss >> id;
            vtkCellIds[cellId]->SetId(j, duplicate_point_map[id]);
            // cells[cellId][j] = duplicate_point_map[id];
          }
          ++cellId;
        }
      }
      // get cell types
      while (getline(meshStream, line)) {
        if (line.find("CELL_TYPES") != std::string::npos) {
          dataSet_tmp->Allocate(numCells);
          cellId = 0;
          // cellTypes.resize(numCells);
          while (cellId < numCells && getline(meshStream, line)) {
            if (!line.empty()) {
              std::istringstream ss(line);
              int cellType;
              ss >> cellType;
              // cellTypes[cellId] = cellType;
              dataSet_tmp->InsertNextCell(cellType, vtkCellIds[cellId]);
              ++cellId;
            }
          }
          break;
        }
      }
    }
  }

  std::multimap<int, std::vector<double>> flipped = nemAux::flip_map(point_map);
  auto flip_it = flipped.begin();

  vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
  points->SetNumberOfPoints(point_map.size());
  int pnt = 0;
  while (flip_it != flipped.end()) {
    points->SetPoint(pnt, flip_it->second.data());
    ++flip_it;
    ++pnt;
  }
  dataSet_tmp->SetPoints(points);
  return dataSet_tmp;
}

readLegacyVTKCells()

bool readLegacyVTKCells	(	const std::istream &	meshStream,
		const std::string &	line,
		nemId_t &	numCells,
		const std::vector< vtkSmartPointer< vtkIdList >> &	vtkCellIds,
		vtkSmartPointer< vtkUnstructuredGrid >	dataSet_tmp
	)

Referenced by ReadAnXMLOrSTLFile().

readLegacyVTKData()

bool readLegacyVTKData	(	const std::ifstream &	meshStream,
		const std::string &	line,
		nemId_t	numTuple,
		bool	pointOrCell,
		bool &	hasPointOrCell,
		vtkSmartPointer< vtkUnstructuredGrid >	dataSet_tmp
	)

Referenced by ReadAnXMLOrSTLFile().

readLegacyVTKFieldData()

bool readLegacyVTKFieldData	(	const std::istream &	meshStream,
		const std::string &	line,
		vtkSmartPointer< vtkUnstructuredGrid >	dataSet_tmp
	)

Referenced by ReadAnXMLOrSTLFile().

readLegacyVTKHeader()

bool readLegacyVTKHeader

(

const std::string &

line

)

Definition at line 294 of file vtkMesh.C.

Referenced by ReadALegacyVTKFile(), and ReadAnXMLOrSTLFile().

                                                {
  if (line.find("DATASET") != -1) {
    if (line.find("UNSTRUCTURED_GRID") == std::string::npos) {
      std::cerr << "Reading a " << line << " is not supported" << std::endl;
      exit(1);
    }
    return true;
  }
  return false;
}

readLegacyVTKPoints()

bool readLegacyVTKPoints	(	const std::istream &	meshStream,
		const std::string &	line,
		nemId_t &	numPoints,
		vtkSmartPointer< vtkPoints >	points,
		vtkSmartPointer< vtkUnstructuredGrid >	dataSet_tmp
	)

Referenced by ReadAnXMLOrSTLFile().

writeVTFile()

template<class TWriter >

void writeVTFile	(	const std::string &	fname,
		vtkSmartPointer< vtkDataSet >	dataSet
	)

Definition at line 87 of file vtkMesh.H.

References NEM::MSH::New().

                                                      {
  vtkSmartPointer<TWriter> Writer = vtkSmartPointer<TWriter>::New();
  Writer->SetFileName(fname.c_str());
  Writer->SetInputData(dataSet);
  // WARNING: ASCII does not work for STL and legacy VTK files
  // WARNING: large files will be generated
  // Writer->SetDataModeToAscii();
  Writer->Update();
  Writer->Write();
}