1 #include "SMDS_VtkVolume.hxx"
2 #include "SMDS_MeshNode.hxx"
3 #include "SMDS_Mesh.hxx"
4 #include "SMDS_VtkCellIterator.hxx"
10 SMDS_VtkVolume::SMDS_VtkVolume()
14 SMDS_VtkVolume::SMDS_VtkVolume(std::vector<vtkIdType> nodeIds, SMDS_Mesh* mesh)
19 * typed used are vtk types (@see vtkCellType.h)
20 * see GetEntityType() for conversion in SMDS type (@see SMDSAbs_ElementType.hxx)
22 void SMDS_VtkVolume::init(std::vector<vtkIdType> nodeIds, SMDS_Mesh* mesh)
24 vtkUnstructuredGrid* grid = mesh->getGrid();
26 myMeshId = mesh->getMeshId();
27 vtkIdType aType = VTK_TETRA;
28 switch (nodeIds.size())
40 aType = VTK_HEXAHEDRON;
43 aType = VTK_QUADRATIC_TETRA;
46 aType = VTK_QUADRATIC_PYRAMID;
49 aType = VTK_QUADRATIC_WEDGE;
52 aType = VTK_QUADRATIC_HEXAHEDRON;
55 aType = VTK_HEXAHEDRON;
58 myVtkID = grid->InsertNextLinkedCell(aType, nodeIds.size(), &nodeIds[0]);
59 mesh->setMyModified();
60 //MESSAGE("SMDS_VtkVolume::init myVtkID " << myVtkID);
63 //#ifdef VTK_HAVE_POLYHEDRON
64 void SMDS_VtkVolume::initPoly(std::vector<vtkIdType> nodeIds, std::vector<int> nbNodesPerFace, SMDS_Mesh* mesh)
66 MESSAGE("SMDS_VtkVolume::initPoly");
67 SMDS_UnstructuredGrid* grid = mesh->getGrid();
68 // TODO is it useful to orient faces ?
70 this->gravityCenter(grid, &nodeIds[0], nodeIds.size(), ¢er[0]);
71 vector<vtkIdType> ptIds;
73 vtkIdType nbFaces = nbNodesPerFace.size();
75 for (int i = 0; i < nbFaces; i++)
77 int nf = nbNodesPerFace[i];
82 // grid->GetPoints()->GetPoint(nodeIds[k], a);
83 // grid->GetPoints()->GetPoint(nodeIds[k + 1], b);
84 // grid->GetPoints()->GetPoint(nodeIds[k + 2], c);
85 // bool isFaceForward = this->isForward(a, b, c, center);
86 bool isFaceForward = true;
87 //MESSAGE("isFaceForward " << i << " " << isFaceForward);
88 vtkIdType *facePts = &nodeIds[k];
90 for (int n = 0; n < nf; n++)
91 ptIds.push_back(facePts[n]);
93 for (int n = nf - 1; n >= 0; n--)
94 ptIds.push_back(facePts[n]);
97 myVtkID = grid->InsertNextLinkedCell(VTK_POLYHEDRON, nbFaces, &ptIds[0]);
98 mesh->setMyModified();
102 bool SMDS_VtkVolume::ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes)
104 vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
107 grid->GetCellPoints(myVtkID, npts, pts);
110 MESSAGE("ChangeNodes problem: not the same number of nodes " << npts << " -> " << nbNodes);
113 for (int i = 0; i < nbNodes; i++)
115 pts[i] = nodes[i]->getVtkId();
117 SMDS_Mesh::_meshList[myMeshId]->setMyModified();
122 * Reorder in VTK order a list of nodes given in SMDS order.
123 * To be used before ChangeNodes: lists are given or computed in SMDS order.
125 bool SMDS_VtkVolume::vtkOrder(const SMDS_MeshNode* nodes[], const int nbNodes)
127 if (nbNodes != this->NbNodes())
129 MESSAGE("vtkOrder, wrong number of nodes " << nbNodes << " instead of "<< this->NbNodes());
132 vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
133 vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
137 this->exchange(nodes, 1, 2);
139 case VTK_QUADRATIC_TETRA:
140 this->exchange(nodes, 1, 2);
141 this->exchange(nodes, 4, 6);
142 this->exchange(nodes, 8, 9);
145 this->exchange(nodes, 1, 3);
149 case VTK_QUADRATIC_PYRAMID:
150 this->exchange(nodes, 1, 3);
151 this->exchange(nodes, 5, 8);
152 this->exchange(nodes, 6, 7);
153 this->exchange(nodes, 10, 12);
155 case VTK_QUADRATIC_WEDGE:
158 this->exchange(nodes, 1, 3);
159 this->exchange(nodes, 5, 7);
161 case VTK_QUADRATIC_HEXAHEDRON:
162 this->exchange(nodes, 1, 3);
163 this->exchange(nodes, 5, 7);
164 this->exchange(nodes, 8, 11);
165 this->exchange(nodes, 9, 10);
166 this->exchange(nodes, 12, 15);
167 this->exchange(nodes, 13, 14);
168 this->exchange(nodes, 17, 19);
177 SMDS_VtkVolume::~SMDS_VtkVolume()
181 void SMDS_VtkVolume::Print(ostream & OS) const
183 OS << "volume <" << GetID() << "> : ";
186 int SMDS_VtkVolume::NbFaces() const
188 vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
189 vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
194 case VTK_QUADRATIC_TETRA:
199 case VTK_QUADRATIC_PYRAMID:
200 case VTK_QUADRATIC_WEDGE:
204 case VTK_QUADRATIC_HEXAHEDRON:
209 vtkIdType nFaces = 0;
210 vtkIdType* ptIds = 0;
211 grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
216 MESSAGE("invalid volume type")
224 int SMDS_VtkVolume::NbNodes() const
226 vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
227 vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
229 if (aVtkType != VTK_POLYHEDRON)
231 nbPoints = grid->GetCell(myVtkID)->GetNumberOfPoints();
235 vtkIdType nFaces = 0;
236 vtkIdType* ptIds = 0;
237 grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
239 for (int i = 0; i < nFaces; i++)
241 int nodesInFace = ptIds[id];
242 nbPoints += nodesInFace;
243 id += (nodesInFace + 1);
249 int SMDS_VtkVolume::NbEdges() const
251 vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
252 vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
257 case VTK_QUADRATIC_TETRA:
261 case VTK_QUADRATIC_PYRAMID:
265 case VTK_QUADRATIC_WEDGE:
269 case VTK_QUADRATIC_HEXAHEDRON:
274 vtkIdType nFaces = 0;
275 vtkIdType* ptIds = 0;
276 grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
279 for (int i = 0; i < nFaces; i++)
281 int edgesInFace = ptIds[id];
282 id += (edgesInFace + 1);
283 nbEdges += edgesInFace;
285 nbEdges = nbEdges / 2;
289 MESSAGE("invalid volume type")
298 * 1 <= face_ind <= NbFaces()
300 int SMDS_VtkVolume::NbFaceNodes(const int face_ind) const
302 vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
303 vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
305 if (aVtkType == VTK_POLYHEDRON)
307 vtkIdType nFaces = 0;
308 vtkIdType* ptIds = 0;
309 grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
311 for (int i = 0; i < nFaces; i++)
313 int nodesInFace = ptIds[id];
314 id += (nodesInFace + 1);
315 if (i == face_ind - 1)
317 nbNodes = nodesInFace;
326 * 1 <= face_ind <= NbFaces()
327 * 1 <= node_ind <= NbFaceNodes()
329 const SMDS_MeshNode* SMDS_VtkVolume::GetFaceNode(const int face_ind, const int node_ind) const
331 SMDS_Mesh *mesh = SMDS_Mesh::_meshList[myMeshId];
332 vtkUnstructuredGrid* grid = mesh->getGrid();
333 vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
334 const SMDS_MeshNode* node = 0;
335 if (aVtkType == VTK_POLYHEDRON)
337 vtkIdType nFaces = 0;
338 vtkIdType* ptIds = 0;
339 grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
341 for (int i = 0; i < nFaces; i++)
343 int nodesInFace = ptIds[id]; // nodeIds in ptIds[id+1 .. id+nodesInFace]
344 if (i == face_ind - 1) // first face is number 1
346 if ((node_ind > 0) && (node_ind <= nodesInFace))
347 node = mesh->FindNodeVtk(ptIds[id + node_ind]); // ptIds[id+1] : first node
350 id += (nodesInFace + 1);
357 * return number of nodes for each face
359 const std::vector<int> SMDS_VtkVolume::GetQuantities() const
361 vector<int> quantities;
363 SMDS_Mesh *mesh = SMDS_Mesh::_meshList[myMeshId];
364 vtkUnstructuredGrid* grid = mesh->getGrid();
365 vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
366 if (aVtkType == VTK_POLYHEDRON)
368 vtkIdType nFaces = 0;
369 vtkIdType* ptIds = 0;
370 grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
372 for (int i = 0; i < nFaces; i++)
374 int nodesInFace = ptIds[id]; // nodeIds in ptIds[id+1 .. id+nodesInFace]
375 quantities.push_back(nodesInFace);
376 id += (nodesInFace + 1);
382 SMDS_ElemIteratorPtr SMDS_VtkVolume::elementsIterator(SMDSAbs_ElementType type) const
388 SMDSAbs_EntityType aType = this->GetEntityType();
389 if (aType == SMDSEntity_Polyhedra)
390 return SMDS_ElemIteratorPtr(new SMDS_VtkCellIteratorPolyH(SMDS_Mesh::_meshList[myMeshId], myVtkID, aType));
392 return SMDS_ElemIteratorPtr(new SMDS_VtkCellIterator(SMDS_Mesh::_meshList[myMeshId], myVtkID, aType));
395 MESSAGE("ERROR : Iterator not implemented");
396 return SMDS_ElemIteratorPtr((SMDS_ElemIterator*) NULL);
400 SMDS_ElemIteratorPtr SMDS_VtkVolume::nodesIteratorToUNV() const
402 return SMDS_ElemIteratorPtr(new SMDS_VtkCellIteratorToUNV(SMDS_Mesh::_meshList[myMeshId], myVtkID, GetEntityType()));
405 SMDS_ElemIteratorPtr SMDS_VtkVolume::interlacedNodesElemIterator() const
407 return SMDS_ElemIteratorPtr(new SMDS_VtkCellIteratorToUNV(SMDS_Mesh::_meshList[myMeshId], myVtkID, GetEntityType()));
410 SMDSAbs_ElementType SMDS_VtkVolume::GetType() const
412 return SMDSAbs_Volume;
416 * \brief Return node by its index
417 * \param ind - node index
418 * \retval const SMDS_MeshNode* - the node
420 const SMDS_MeshNode* SMDS_VtkVolume::GetNode(const int ind) const
422 // TODO optimize if possible (vtkCellIterator)
423 return SMDS_MeshElement::GetNode(ind);
426 bool SMDS_VtkVolume::IsQuadratic() const
428 vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
429 vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
430 // TODO quadratic polyhedrons ?
433 case VTK_QUADRATIC_TETRA:
434 case VTK_QUADRATIC_PYRAMID:
435 case VTK_QUADRATIC_WEDGE:
436 case VTK_QUADRATIC_HEXAHEDRON:
444 bool SMDS_VtkVolume::IsPoly() const
446 vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
447 vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
448 return (aVtkType == VTK_POLYHEDRON);
451 bool SMDS_VtkVolume::IsMediumNode(const SMDS_MeshNode* node) const
453 vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
454 vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
455 int rankFirstMedium = 0;
458 case VTK_QUADRATIC_TETRA:
459 rankFirstMedium = 4; // medium nodes are of rank 4 to 9
461 case VTK_QUADRATIC_PYRAMID:
462 rankFirstMedium = 5; // medium nodes are of rank 5 to 12
464 case VTK_QUADRATIC_WEDGE:
465 rankFirstMedium = 6; // medium nodes are of rank 6 to 14
467 case VTK_QUADRATIC_HEXAHEDRON:
468 rankFirstMedium = 8; // medium nodes are of rank 8 to 19
475 grid->GetCellPoints(myVtkID, npts, pts);
476 vtkIdType nodeId = node->getVtkId();
477 for (int rank = 0; rank < npts; rank++)
479 if (pts[rank] == nodeId)
481 if (rank < rankFirstMedium)
487 //throw SALOME_Exception(LOCALIZED("node does not belong to this element"));
488 MESSAGE("======================================================");
489 MESSAGE("= IsMediumNode: node does not belong to this element =");
490 MESSAGE("======================================================");
494 SMDSAbs_EntityType SMDS_VtkVolume::GetEntityType() const
496 vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
497 vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
499 SMDSAbs_EntityType aType = SMDSEntity_Tetra;
503 aType = SMDSEntity_Tetra;
506 aType = SMDSEntity_Pyramid;
509 aType = SMDSEntity_Penta;
512 aType = SMDSEntity_Hexa;
514 case VTK_QUADRATIC_TETRA:
515 aType = SMDSEntity_Quad_Tetra;
517 case VTK_QUADRATIC_PYRAMID:
518 aType = SMDSEntity_Quad_Pyramid;
520 case VTK_QUADRATIC_WEDGE:
521 aType = SMDSEntity_Quad_Penta;
523 case VTK_QUADRATIC_HEXAHEDRON:
524 aType = SMDSEntity_Quad_Hexa;
526 //#ifdef VTK_HAVE_POLYHEDRON
528 aType = SMDSEntity_Polyhedra;
532 aType = SMDSEntity_Polyhedra;
538 vtkIdType SMDS_VtkVolume::GetVtkType() const
540 vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
541 vtkIdType aType = grid->GetCellType(myVtkID);
545 void SMDS_VtkVolume::gravityCenter(SMDS_UnstructuredGrid* grid, vtkIdType *nodeIds, int nbNodes, double* result)
547 for (int j = 0; j < 3; j++)
551 for (int i = 0; i < nbNodes; i++)
553 double *coords = grid->GetPoint(nodeIds[i]);
554 for (int j = 0; j < 3; j++)
555 result[j] += coords[j];
557 for (int j = 0; j < 3; j++)
558 result[j] = result[j] / nbNodes;
559 //MESSAGE("center " << result[0] << " " << result[1] << " " << result[2]);
563 bool SMDS_VtkVolume::isForward(double* a, double* b, double* c, double* d)
565 double u[3], v[3], w[3];
566 for (int j = 0; j < 3; j++)
568 //MESSAGE("a,b,c,d " << a[j] << " " << b[j] << " " << c[j] << " " << d[j]);
572 //MESSAGE("u,v,w " << u[j] << " " << v[j] << " " << w[j]);
574 double prodmixte = (u[2] * v[3] - u[3] * v[2]) * w[1] + (u[3] * v[1] - u[1] * v[3]) * w[2] + (u[1] * v[2] - u[2]
576 return (prodmixte >= 0);
579 /*! For polyhedron only
580 * @return actual number of nodes (not the sum of nodes of all faces)
582 int SMDS_VtkVolume::NbUniqueNodes() const
584 vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
585 return grid->GetCell(myVtkID)->GetNumberOfPoints();
588 /*! For polyhedron use only
589 * @return iterator on actual nodes (not through the faces)
591 SMDS_ElemIteratorPtr SMDS_VtkVolume::uniqueNodesIterator() const
593 MESSAGE("uniqueNodesIterator");
594 return SMDS_ElemIteratorPtr(new SMDS_VtkCellIterator(SMDS_Mesh::_meshList[myMeshId], myVtkID, GetEntityType()));