vtkMesh.C File Reference

Go to the source code of this file.

Functions
bool	readLegacyVTKHeader (const std::string &line)
bool	readLegacyVTKFieldData (std::istream &meshStream, std::string &line, vtkSmartPointer< vtkUnstructuredGrid > dataSet_tmp)
bool	readLegacyVTKPoints (std::istream &meshStream, std::string &line, nemId_t &numPoints, vtkSmartPointer< vtkPoints > points, vtkSmartPointer< vtkUnstructuredGrid > dataSet_tmp)
bool	readLegacyVTKCells (std::istream &meshStream, std::string &line, nemId_t &numCells, std::vector< vtkSmartPointer< vtkIdList >> &vtkCellIds, vtkSmartPointer< vtkUnstructuredGrid > dataSet_tmp)
bool	readLegacyVTKData (std::ifstream &meshStream, std::string &line, const nemId_t numTuple, const bool pointOrCell, bool &hasPointOrCell, vtkSmartPointer< vtkUnstructuredGrid > dataSet_tmp)
vtkSmartPointer< vtkUnstructuredGrid >	ReadALegacyVTKFile (const std::string &fileName)
vtkSmartPointer< vtkUnstructuredGrid >	ReadDegenerateVTKFile (const std::string &fileName)

Function Documentation

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;
}

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	(	std::istream &	meshStream,
		std::string &	line,
		nemId_t &	numCells,
		std::vector< vtkSmartPointer< vtkIdList >> &	vtkCellIds,
		vtkSmartPointer< vtkUnstructuredGrid >	dataSet_tmp
	)

Definition at line 358 of file vtkMesh.C.

References cellType, id, NEM::MSH::New(), and meshBase::numCells.

Referenced by ReadALegacyVTKFile().

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

readLegacyVTKData()

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

Definition at line 406 of file vtkMesh.C.

References NEM::MSH::New().

Referenced by ReadALegacyVTKFile().

                                                                         {
  // determines whether more than one point or cell array in dataSet
  bool inProgress(true);
  // while there is a cell or point array to be read
  while (inProgress) {
    int numComponent(0);
    std::string line, attribute, name, type;
    vtkSmartPointer<vtkDoubleArray> arr =
        vtkSmartPointer<vtkDoubleArray>::New();
    while (getline(meshStream, line)) {
      if (!line.empty()) {
        if (line.find("LOOKUP_TABLE default") != std::string::npos) break;

        size_t hasScalar = line.find("SCALARS");
        size_t hasVector = line.find("VECTORS");
        size_t hasNormal = line.find("NORMALS");
        if (hasScalar == std::string::npos && hasVector == std::string::npos &&
            hasNormal == std::string::npos) {
          std::cerr << "attribute type in " << line << " not supported"
                    << std::endl;
          exit(1);
        } else {
          std::istringstream ss(line);
          ss >> attribute >> name >> type >> numComponent;
          if (hasScalar != std::string::npos)
            numComponent =
                numComponent > 4 || numComponent < 1 ? 1 : numComponent;
          else if (hasVector != std::string::npos ||
                   hasNormal != std::string::npos)
            numComponent = 3;
          arr->SetName(name.c_str());
          arr->SetNumberOfComponents(numComponent);
          arr->SetNumberOfTuples(numTuple);
          // std::cout << arr->GetName() << " " << arr->GetNumberOfComponents()
          //           << " " << arr->GetNumberOfTuples() << std::endl;
          break;
        }
      }
    }

    nemId_t i = 0;
    while (i < numTuple && getline(meshStream, line)) {
      if (!line.empty() && line.find("LOOKUP") == std::string::npos) {
        std::istringstream ss(line);
        // double vals[numComponent];
        std::vector<double> vals;
        vals.resize(numComponent, 0.);

        for (int j = 0; j < numComponent; ++j) ss >> vals[j];
        arr->InsertTuple(i, vals.data());
        ++i;
      }
    }

    if (pointOrCell)
      dataSet_tmp->GetPointData()->AddArray(arr);
    else
      dataSet_tmp->GetCellData()->AddArray(arr);

    bool moreData(false);
    std::streampos curr = meshStream.tellg();
    while (getline(meshStream, line)) {
      // if point data encountered while looking for more cell data, we know we
      // read all cell data
      if (line.find("POINT_DATA") != std::string::npos && !pointOrCell) {
        curr = meshStream.tellg();
        hasPointOrCell = true;
        break;
      }
      // if cell data encountered while looking for more point data, we know we
      // read all point data
      if (line.find("CELL_DATA") != std::string::npos && pointOrCell) {
        hasPointOrCell = true;
        curr = meshStream.tellg();
        break;
      }
      // if the previous two conditions are not met and this one is,
      // we know we have more than one point/cell data array
      if (line.find("SCALARS") != std::string::npos ||
          line.find("VECTORS") != std::string::npos ||
          line.find("NORMALS") != std::string::npos) {
        moreData = true;
        break;
      }
    }

    meshStream.seekg(curr);

    if (!moreData) inProgress = false;
  }
  return true;
}

readLegacyVTKFieldData()

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

Definition at line 305 of file vtkMesh.C.

References NEM::MSH::New().

Referenced by ReadALegacyVTKFile().

                                                                              {
  if (line.find("FIELD") != std::string::npos) {
    if (getline(meshStream, line)) {
      std::string arrname, type;
      int numComponent;
      nemId_t numTuple;
      std::stringstream ss;
      ss.str(line);
      ss >> arrname >> numComponent >> numTuple >> type;
      vtkSmartPointer<vtkDoubleArray> arr =
          vtkSmartPointer<vtkDoubleArray>::New();
      arr->SetName(arrname.c_str());
      arr->SetNumberOfComponents(numComponent);
      arr->SetNumberOfTuples(numTuple);
      getline(meshStream, line);
      ss.str(line);
      double val;
      for (int i = 0; i < numTuple; ++i) {
        ss >> val;
        arr->InsertTuple(i, &val);
      }
      dataSet_tmp->GetFieldData()->AddArray(arr);
      return true;
    }
  }
  return false;
}

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	(	std::istream &	meshStream,
		std::string &	line,
		nemId_t &	numPoints,
		vtkSmartPointer< vtkPoints >	points,
		vtkSmartPointer< vtkUnstructuredGrid >	dataSet_tmp
	)

Definition at line 334 of file vtkMesh.C.

References meshBase::numPoints.

Referenced by ReadALegacyVTKFile().

                                                                           {
  if (line.find("POINTS") != std::string::npos) {
    std::istringstream ss(line);
    std::string tmp;
    ss >> tmp >> numPoints;
    points->SetNumberOfPoints(numPoints);
    double point[3];
    nemId_t i = 0;
    while (getline(meshStream, line) && i < numPoints) {
      if (!line.empty()) {
        std::istringstream ss(line);
        ss >> point[0] >> point[1] >> point[2];
        points->SetPoint(i, point);
        ++i;
      }
    }
    dataSet_tmp->SetPoints(points);
    return true;
  }
  return false;
}