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);
176 SMDS_VtkVolume::~SMDS_VtkVolume()
180 void SMDS_VtkVolume::Print(ostream & OS) const
182 OS << "volume <" << GetID() << "> : ";
185 int SMDS_VtkVolume::NbFaces() const
187 vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
188 vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
193 case VTK_QUADRATIC_TETRA:
198 case VTK_QUADRATIC_PYRAMID:
199 case VTK_QUADRATIC_WEDGE:
203 case VTK_QUADRATIC_HEXAHEDRON:
208 vtkIdType nFaces = 0;
209 vtkIdType* ptIds = 0;
210 grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
215 MESSAGE("invalid volume type")
223 int SMDS_VtkVolume::NbNodes() const
225 vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
226 vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
228 if (aVtkType != VTK_POLYHEDRON)
230 nbPoints = grid->GetCell(myVtkID)->GetNumberOfPoints();
234 vtkIdType nFaces = 0;
235 vtkIdType* ptIds = 0;
236 grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
238 for (int i = 0; i < nFaces; i++)
240 int nodesInFace = ptIds[id];
241 nbPoints += nodesInFace;
242 id += (nodesInFace + 1);
248 int SMDS_VtkVolume::NbEdges() const
250 vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
251 vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
256 case VTK_QUADRATIC_TETRA:
260 case VTK_QUADRATIC_PYRAMID:
264 case VTK_QUADRATIC_WEDGE:
268 case VTK_QUADRATIC_HEXAHEDRON:
273 vtkIdType nFaces = 0;
274 vtkIdType* ptIds = 0;
275 grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
278 for (int i = 0; i < nFaces; i++)
280 int edgesInFace = ptIds[id];
281 id += (edgesInFace + 1);
282 nbEdges += edgesInFace;
284 nbEdges = nbEdges / 2;
288 MESSAGE("invalid volume type")
297 * 1 <= face_ind <= NbFaces()
299 int SMDS_VtkVolume::NbFaceNodes(const int face_ind) const
301 vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
302 vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
304 if (aVtkType == VTK_POLYHEDRON)
306 vtkIdType nFaces = 0;
307 vtkIdType* ptIds = 0;
308 grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
310 for (int i = 0; i < nFaces; i++)
312 int nodesInFace = ptIds[id];
313 id += (nodesInFace + 1);
314 if (i == face_ind - 1)
316 nbNodes = nodesInFace;
325 * 1 <= face_ind <= NbFaces()
326 * 1 <= node_ind <= NbFaceNodes()
328 const SMDS_MeshNode* SMDS_VtkVolume::GetFaceNode(const int face_ind, const int node_ind) const
330 SMDS_Mesh *mesh = SMDS_Mesh::_meshList[myMeshId];
331 vtkUnstructuredGrid* grid = mesh->getGrid();
332 vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
333 const SMDS_MeshNode* node = 0;
334 if (aVtkType == VTK_POLYHEDRON)
336 vtkIdType nFaces = 0;
337 vtkIdType* ptIds = 0;
338 grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
340 for (int i = 0; i < nFaces; i++)
342 int nodesInFace = ptIds[id]; // nodeIds in ptIds[id+1 .. id+nodesInFace]
343 if (i == face_ind - 1) // first face is number 1
345 if ((node_ind > 0) && (node_ind <= nodesInFace))
346 node = mesh->FindNodeVtk(ptIds[id + node_ind]); // ptIds[id+1] : first node
349 id += (nodesInFace + 1);
356 * return number of nodes for each face
358 const std::vector<int> & SMDS_VtkVolume::GetQuantities() const
360 vector<int> quantities;
362 SMDS_Mesh *mesh = SMDS_Mesh::_meshList[myMeshId];
363 vtkUnstructuredGrid* grid = mesh->getGrid();
364 vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
365 if (aVtkType == VTK_POLYHEDRON)
367 vtkIdType nFaces = 0;
368 vtkIdType* ptIds = 0;
369 grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
371 for (int i = 0; i < nFaces; i++)
373 int nodesInFace = ptIds[id]; // nodeIds in ptIds[id+1 .. id+nodesInFace]
374 quantities.push_back(nodesInFace);
375 id += (nodesInFace + 1);
381 SMDS_ElemIteratorPtr SMDS_VtkVolume::elementsIterator(SMDSAbs_ElementType type) const
387 SMDSAbs_EntityType aType = this->GetEntityType();
388 if (aType == SMDSEntity_Polyhedra)
389 return SMDS_ElemIteratorPtr(new SMDS_VtkCellIteratorPolyH(SMDS_Mesh::_meshList[myMeshId], myVtkID, aType));
391 return SMDS_ElemIteratorPtr(new SMDS_VtkCellIterator(SMDS_Mesh::_meshList[myMeshId], myVtkID, aType));
394 MESSAGE("ERROR : Iterator not implemented");
395 return SMDS_ElemIteratorPtr((SMDS_ElemIterator*) NULL);
399 SMDS_ElemIteratorPtr SMDS_VtkVolume::nodesIteratorToUNV() const
401 return SMDS_ElemIteratorPtr(new SMDS_VtkCellIteratorToUNV(SMDS_Mesh::_meshList[myMeshId], myVtkID, GetEntityType()));
404 SMDS_ElemIteratorPtr SMDS_VtkVolume::interlacedNodesElemIterator() const
406 return SMDS_ElemIteratorPtr(new SMDS_VtkCellIteratorToUNV(SMDS_Mesh::_meshList[myMeshId], myVtkID, GetEntityType()));
409 SMDSAbs_ElementType SMDS_VtkVolume::GetType() const
411 return SMDSAbs_Volume;
415 * \brief Return node by its index
416 * \param ind - node index
417 * \retval const SMDS_MeshNode* - the node
419 const SMDS_MeshNode* SMDS_VtkVolume::GetNode(const int ind) const
421 // TODO optimize if possible (vtkCellIterator)
422 return SMDS_MeshElement::GetNode(ind);
425 bool SMDS_VtkVolume::IsQuadratic() const
427 vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
428 vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
429 // TODO quadratic polyhedrons ?
432 case VTK_QUADRATIC_TETRA:
433 case VTK_QUADRATIC_PYRAMID:
434 case VTK_QUADRATIC_WEDGE:
435 case VTK_QUADRATIC_HEXAHEDRON:
443 bool SMDS_VtkVolume::IsPoly() const
445 vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
446 vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
447 return (aVtkType == VTK_POLYHEDRON);
450 bool SMDS_VtkVolume::IsMediumNode(const SMDS_MeshNode* node) const
452 vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
453 vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
454 int rankFirstMedium = 0;
457 case VTK_QUADRATIC_TETRA:
458 rankFirstMedium = 4; // medium nodes are of rank 4 to 9
460 case VTK_QUADRATIC_PYRAMID:
461 rankFirstMedium = 5; // medium nodes are of rank 5 to 12
463 case VTK_QUADRATIC_WEDGE:
464 rankFirstMedium = 6; // medium nodes are of rank 6 to 14
466 case VTK_QUADRATIC_HEXAHEDRON:
467 rankFirstMedium = 8; // medium nodes are of rank 8 to 19
474 grid->GetCellPoints(myVtkID, npts, pts);
475 vtkIdType nodeId = node->getVtkId();
476 for (int rank = 0; rank < npts; rank++)
478 if (pts[rank] == nodeId)
480 if (rank < rankFirstMedium)
486 //throw SALOME_Exception(LOCALIZED("node does not belong to this element"));
487 MESSAGE("======================================================");
488 MESSAGE("= IsMediumNode: node does not belong to this element =");
489 MESSAGE("======================================================");
493 SMDSAbs_EntityType SMDS_VtkVolume::GetEntityType() const
495 vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
496 vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
498 SMDSAbs_EntityType aType = SMDSEntity_Tetra;
502 aType = SMDSEntity_Tetra;
505 aType = SMDSEntity_Pyramid;
508 aType = SMDSEntity_Penta;
511 aType = SMDSEntity_Hexa;
513 case VTK_QUADRATIC_TETRA:
514 aType = SMDSEntity_Quad_Tetra;
516 case VTK_QUADRATIC_PYRAMID:
517 aType = SMDSEntity_Quad_Pyramid;
519 case VTK_QUADRATIC_WEDGE:
520 aType = SMDSEntity_Quad_Penta;
522 case VTK_QUADRATIC_HEXAHEDRON:
523 aType = SMDSEntity_Quad_Hexa;
525 //#ifdef VTK_HAVE_POLYHEDRON
527 aType = SMDSEntity_Polyhedra;
531 aType = SMDSEntity_Polyhedra;
537 vtkIdType SMDS_VtkVolume::GetVtkType() const
539 vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
540 vtkIdType aType = grid->GetCellType(myVtkID);
544 void SMDS_VtkVolume::gravityCenter(SMDS_UnstructuredGrid* grid, vtkIdType *nodeIds, int nbNodes, double* result)
546 for (int j = 0; j < 3; j++)
550 for (int i = 0; i < nbNodes; i++)
552 double *coords = grid->GetPoint(nodeIds[i]);
553 for (int j = 0; j < 3; j++)
554 result[j] += coords[j];
556 for (int j = 0; j < 3; j++)
557 result[j] = result[j] / nbNodes;
558 //MESSAGE("center " << result[0] << " " << result[1] << " " << result[2]);
562 bool SMDS_VtkVolume::isForward(double* a, double* b, double* c, double* d)
564 double u[3], v[3], w[3];
565 for (int j = 0; j < 3; j++)
567 //MESSAGE("a,b,c,d " << a[j] << " " << b[j] << " " << c[j] << " " << d[j]);
571 //MESSAGE("u,v,w " << u[j] << " " << v[j] << " " << w[j]);
573 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]
575 return (prodmixte >= 0);
578 /*! For polyhedron only
579 * @return actual number of nodes (not the sum of nodes of all faces)
581 int SMDS_VtkVolume::NbUniqueNodes() const
583 vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
584 return grid->GetCell(myVtkID)->GetNumberOfPoints();
587 /*! For polyhedron use only
588 * @return iterator on actual nodes (not through the faces)
590 SMDS_ElemIteratorPtr SMDS_VtkVolume::uniqueNodesIterator() const
592 MESSAGE("uniqueNodesIterator");
593 return SMDS_ElemIteratorPtr(new SMDS_VtkCellIterator(SMDS_Mesh::_meshList[myMeshId], myVtkID, GetEntityType()));