From 7155478a3e86a989e2e6df53406b72c9677aa8d1 Mon Sep 17 00:00:00 2001 From: eap Date: Fri, 16 Dec 2011 09:13:11 +0000 Subject: [PATCH] 0021347: [CEA 497] Visualisation into SMESH and VISU of hexagonal prism cells (MED_OCTA12) 0021380: EDF 1937 SMESH: Take into account QUAD9 and HEXA27 + optimization --- src/SMDS/SMDS_VtkCellIterator.cxx | 102 +++++++---------------- src/SMDS/SMDS_VtkEdge.cxx | 6 +- src/SMDS/SMDS_VtkFace.cxx | 51 ++++++------ src/SMDS/SMDS_VtkFace.hxx | 7 +- src/SMDS/SMDS_VtkVolume.cxx | 129 +++++++++++++++++------------- src/SMDS/SMDS_VtkVolume.hxx | 12 +-- 6 files changed, 140 insertions(+), 167 deletions(-) diff --git a/src/SMDS/SMDS_VtkCellIterator.cxx b/src/SMDS/SMDS_VtkCellIterator.cxx index db5f808bb..7b1c62efa 100644 --- a/src/SMDS/SMDS_VtkCellIterator.cxx +++ b/src/SMDS/SMDS_VtkCellIterator.cxx @@ -23,76 +23,21 @@ SMDS_VtkCellIterator::SMDS_VtkCellIterator(SMDS_Mesh* mesh, int vtkCellId, SMDSAbs_EntityType aType) : _mesh(mesh), _cellId(vtkCellId), _index(0), _type(aType) { - //MESSAGE("SMDS_VtkCellIterator " << _type); - _vtkIdList = vtkIdList::New(); vtkUnstructuredGrid* grid = _mesh->getGrid(); - grid->GetCellPoints(_cellId, _vtkIdList); - _nbNodes = _vtkIdList->GetNumberOfIds(); - switch (_type) + _vtkIdList = vtkIdList::New(); + const std::vector& interlace = SMDS_MeshCell::fromVtkOrder( aType ); + if ( interlace.empty() ) { - case SMDSEntity_Tetra: - { - this->exchange(1, 2); - break; - } - case SMDSEntity_Pyramid: - { - this->exchange(1, 3); - break; - } - case SMDSEntity_Penta: - { - //this->exchange(1, 2); - //this->exchange(4, 5); - break; - } - case SMDSEntity_Hexa: - { - this->exchange(1, 3); - this->exchange(5, 7); - break; - } - case SMDSEntity_Quad_Tetra: - { - this->exchange(1, 2); - this->exchange(4, 6); - this->exchange(8, 9); - break; - } - case SMDSEntity_Quad_Pyramid: - { - this->exchange(1, 3); - this->exchange(5, 8); - this->exchange(6, 7); - this->exchange(10, 12); - break; - } - case SMDSEntity_Quad_Penta: - { - //this->exchange(1, 2); - //this->exchange(4, 5); - //this->exchange(6, 8); - //this->exchange(9, 11); - //this->exchange(13, 14); - break; - } - case SMDSEntity_Quad_Hexa: - { - MESSAGE("SMDS_VtkCellIterator Quad_Hexa"); - this->exchange(1, 3); - this->exchange(5, 7); - this->exchange(8, 11); - this->exchange(9, 10); - this->exchange(12, 15); - this->exchange(13, 14); - this->exchange(17, 19); - break; - } - case SMDSEntity_Polyhedra: - MESSAGE("SMDS_VtkCellIterator Polyhedra (iterate on actual nodes)"); - break; - default: - break; + grid->GetCellPoints(_cellId, _vtkIdList); + _nbNodes = _vtkIdList->GetNumberOfIds(); + } + else + { + vtkIdType npts, *pts; + grid->GetCellPoints( _cellId, npts, pts ); + _vtkIdList->SetNumberOfIds( _nbNodes = npts ); + for (int i = 0; i < _nbNodes; i++) + _vtkIdList->SetId(i, pts[interlace[i]]); } } @@ -142,9 +87,11 @@ SMDS_VtkCellIteratorToUNV::SMDS_VtkCellIteratorToUNV(SMDS_Mesh* mesh, int vtkCel break; } case SMDSEntity_Quad_Quadrangle: + case SMDSEntity_BiQuad_Quadrangle: { static int id[] = { 0, 4, 1, 5, 2, 6, 3, 7 }; ids = id; + _nbNodes = 8; break; } case SMDSEntity_Quad_Tetra: @@ -172,9 +119,11 @@ SMDS_VtkCellIteratorToUNV::SMDS_VtkCellIteratorToUNV(SMDS_Mesh* mesh, int vtkCel break; } case SMDSEntity_Quad_Hexa: + case SMDSEntity_TriQuad_Hexa: { static int id[] = { 0, 8, 1, 9, 2, 10, 3, 11, 16, 17, 18, 19, 4, 12, 5, 13, 6, 14, 7, 15 }; ids = id; + _nbNodes = 20; break; } case SMDSEntity_Polygon: @@ -183,15 +132,18 @@ SMDS_VtkCellIteratorToUNV::SMDS_VtkCellIteratorToUNV(SMDS_Mesh* mesh, int vtkCel case SMDSEntity_Quad_Polyhedra: default: { - static int id[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29 }; - ids = id; - break; + // static int id[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + // 25, 26, 27, 28, 29 }; + // ids = id; + // break; } } - //MESSAGE("_nbNodes " << _nbNodes); - for (int i = 0; i < _nbNodes; i++) - _vtkIdList->SetId(i, pts[ids[i]]); + if ( ids ) + for (int i = 0; i < _nbNodes; i++) + _vtkIdList->SetId(i, pts[ids[i]]); + else + for (int i = 0; i < _nbNodes; i++) + _vtkIdList->SetId(i, pts[i]); } SMDS_VtkCellIteratorToUNV::~SMDS_VtkCellIteratorToUNV() diff --git a/src/SMDS/SMDS_VtkEdge.cxx b/src/SMDS/SMDS_VtkEdge.cxx index d39aff052..5596700bb 100644 --- a/src/SMDS/SMDS_VtkEdge.cxx +++ b/src/SMDS/SMDS_VtkEdge.cxx @@ -134,8 +134,10 @@ vtkIdType SMDS_VtkEdge::GetVtkType() const const SMDS_MeshNode* SMDS_VtkEdge::GetNode(const int ind) const { - // TODO optimize !! - return SMDS_MeshElement::GetNode(ind); + vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid(); + vtkIdType npts, *pts; + grid->GetCellPoints( this->myVtkID, npts, pts ); + return SMDS_Mesh::_meshList[myMeshId]->FindNodeVtk( pts[ ind ]); } bool SMDS_VtkEdge::IsQuadratic() const diff --git a/src/SMDS/SMDS_VtkFace.cxx b/src/SMDS/SMDS_VtkFace.cxx index 01501db47..df4b059d1 100644 --- a/src/SMDS/SMDS_VtkFace.cxx +++ b/src/SMDS/SMDS_VtkFace.cxx @@ -32,7 +32,7 @@ SMDS_VtkFace::SMDS_VtkFace() { } -SMDS_VtkFace::SMDS_VtkFace(std::vector nodeIds, SMDS_Mesh* mesh) +SMDS_VtkFace::SMDS_VtkFace(const std::vector& nodeIds, SMDS_Mesh* mesh) { init(nodeIds, mesh); } @@ -41,7 +41,7 @@ SMDS_VtkFace::~SMDS_VtkFace() { } -void SMDS_VtkFace::init(std::vector nodeIds, SMDS_Mesh* mesh) +void SMDS_VtkFace::init(const std::vector& nodeIds, SMDS_Mesh* mesh) { SMDS_MeshFace::init(); vtkUnstructuredGrid* grid = mesh->getGrid(); @@ -61,21 +61,24 @@ void SMDS_VtkFace::init(std::vector nodeIds, SMDS_Mesh* mesh) case 8: aType = VTK_QUADRATIC_QUAD; break; + case 9: + aType = VTK_BIQUADRATIC_QUAD; + break; default: aType = VTK_POLYGON; break; } - myVtkID = grid->InsertNextLinkedCell(aType, nodeIds.size(), &nodeIds[0]); + myVtkID = grid->InsertNextLinkedCell(aType, nodeIds.size(), (vtkIdType*) &nodeIds[0]); mesh->setMyModified(); //MESSAGE("SMDS_VtkFace::init myVtkID " << myVtkID); } -void SMDS_VtkFace::initPoly(std::vector nodeIds, SMDS_Mesh* mesh) +void SMDS_VtkFace::initPoly(const std::vector& nodeIds, SMDS_Mesh* mesh) { SMDS_MeshFace::init(); vtkUnstructuredGrid* grid = mesh->getGrid(); myMeshId = mesh->getMeshId(); - myVtkID = grid->InsertNextLinkedCell(VTK_POLYGON, nodeIds.size(), &nodeIds[0]); + myVtkID = grid->InsertNextLinkedCell(VTK_POLYGON, nodeIds.size(), (vtkIdType*) &nodeIds[0]); mesh->setMyModified(); } @@ -117,6 +120,7 @@ int SMDS_VtkFace::NbEdges() const break; case VTK_QUAD: case VTK_QUADRATIC_QUAD: + case VTK_BIQUADRATIC_QUAD: nbEdges = 4; break; case VTK_POLYGON: @@ -147,7 +151,10 @@ int SMDS_VtkFace::NbNodes() const const SMDS_MeshNode* SMDS_VtkFace::GetNode(const int ind) const { - return SMDS_MeshElement::GetNode(ind); // --- a optimiser ! + vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid(); + vtkIdType npts, *pts; + grid->GetCellPoints( this->myVtkID, npts, pts ); + return SMDS_Mesh::_meshList[myMeshId]->FindNodeVtk( pts[ ind ]); } bool SMDS_VtkFace::IsQuadratic() const @@ -159,6 +166,7 @@ bool SMDS_VtkFace::IsQuadratic() const { case VTK_QUADRATIC_TRIANGLE: case VTK_QUADRATIC_QUAD: + case VTK_BIQUADRATIC_QUAD: return true; break; default: @@ -184,6 +192,7 @@ bool SMDS_VtkFace::IsMediumNode(const SMDS_MeshNode* node) const rankFirstMedium = 3; // medium nodes are of rank 3,4,5 break; case VTK_QUADRATIC_QUAD: + case VTK_BIQUADRATIC_QUAD: rankFirstMedium = 4; // medium nodes are of rank 4,5,6,7 break; default: @@ -212,29 +221,21 @@ bool SMDS_VtkFace::IsMediumNode(const SMDS_MeshNode* node) const return false; } +int SMDS_VtkFace::NbCornerNodes() const +{ + vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid(); + int nbPoints = grid->GetCell(myVtkID)->GetNumberOfPoints(); + vtkIdType aVtkType = grid->GetCellType(myVtkID); + if ( aVtkType != VTK_POLYGON ) + return nbPoints <= 4 ? nbPoints : nbPoints / 2; + return nbPoints; +} + SMDSAbs_EntityType SMDS_VtkFace::GetEntityType() const { vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid(); vtkIdType aVtkType = grid->GetCellType(this->myVtkID); - SMDSAbs_EntityType aType = SMDSEntity_Polygon; - switch (aVtkType) - { - case VTK_TRIANGLE: - aType = SMDSEntity_Triangle; - break; - case VTK_QUAD: - aType = SMDSEntity_Quadrangle; - break; - case VTK_QUADRATIC_TRIANGLE: - aType = SMDSEntity_Quad_Triangle; - break; - case VTK_QUADRATIC_QUAD: - aType = SMDSEntity_Quad_Quadrangle; - break; - default: - aType = SMDSEntity_Polygon; - } - return aType; + return SMDS_MeshCell::toSmdsType( VTKCellType( aVtkType )); } vtkIdType SMDS_VtkFace::GetVtkType() const diff --git a/src/SMDS/SMDS_VtkFace.hxx b/src/SMDS/SMDS_VtkFace.hxx index dd88f314c..11364d8c4 100644 --- a/src/SMDS/SMDS_VtkFace.hxx +++ b/src/SMDS/SMDS_VtkFace.hxx @@ -30,10 +30,10 @@ class SMDS_EXPORT SMDS_VtkFace: public SMDS_MeshFace { public: SMDS_VtkFace(); - SMDS_VtkFace(std::vector nodeIds, SMDS_Mesh* mesh); + SMDS_VtkFace(const std::vector& nodeIds, SMDS_Mesh* mesh); ~SMDS_VtkFace(); - void init(std::vector nodeIds, SMDS_Mesh* mesh); - void initPoly(std::vector nodeIds, SMDS_Mesh* mesh); + void init(const std::vector& nodeIds, SMDS_Mesh* mesh); + void initPoly(const std::vector& nodeIds, SMDS_Mesh* mesh); bool ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes); void ChangeApex(SMDS_MeshNode* node); // to use only for tmp triangles void Print(std::ostream & OS) const; @@ -47,6 +47,7 @@ public: virtual bool IsQuadratic() const; virtual bool IsPoly() const; virtual bool IsMediumNode(const SMDS_MeshNode* node) const; + virtual int NbCornerNodes() const; virtual SMDS_ElemIteratorPtr elementsIterator(SMDSAbs_ElementType type) const; virtual SMDS_ElemIteratorPtr nodesIteratorToUNV() const; diff --git a/src/SMDS/SMDS_VtkVolume.cxx b/src/SMDS/SMDS_VtkVolume.cxx index d4f4a9abc..d8fb8d236 100644 --- a/src/SMDS/SMDS_VtkVolume.cxx +++ b/src/SMDS/SMDS_VtkVolume.cxx @@ -30,7 +30,7 @@ SMDS_VtkVolume::SMDS_VtkVolume() { } -SMDS_VtkVolume::SMDS_VtkVolume(std::vector nodeIds, SMDS_Mesh* mesh) +SMDS_VtkVolume::SMDS_VtkVolume(const std::vector& nodeIds, SMDS_Mesh* mesh) { init(nodeIds, mesh); } @@ -38,57 +38,64 @@ SMDS_VtkVolume::SMDS_VtkVolume(std::vector nodeIds, SMDS_Mesh* mesh) * typed used are vtk types (@see vtkCellType.h) * see GetEntityType() for conversion in SMDS type (@see SMDSAbs_ElementType.hxx) */ -void SMDS_VtkVolume::init(std::vector nodeIds, SMDS_Mesh* mesh) +void SMDS_VtkVolume::init(const std::vector& nodeIds, SMDS_Mesh* mesh) { SMDS_MeshVolume::init(); vtkUnstructuredGrid* grid = mesh->getGrid(); myMeshId = mesh->getMeshId(); vtkIdType aType = VTK_TETRA; - switch (nodeIds.size()) + switch (nodeIds.size()) // cases are in order of usage frequency { case 4: aType = VTK_TETRA; break; + case 8: + aType = VTK_HEXAHEDRON; + break; case 5: aType = VTK_PYRAMID; break; case 6: aType = VTK_WEDGE; break; - case 8: - aType = VTK_HEXAHEDRON; - break; case 10: aType = VTK_QUADRATIC_TETRA; break; + case 20: + aType = VTK_QUADRATIC_HEXAHEDRON; + break; case 13: aType = VTK_QUADRATIC_PYRAMID; break; case 15: aType = VTK_QUADRATIC_WEDGE; break; - case 20: - aType = VTK_QUADRATIC_HEXAHEDRON; + case 12: + aType = VTK_HEXAGONAL_PRISM; + break; + case 27: + aType = VTK_TRIQUADRATIC_HEXAHEDRON; break; default: aType = VTK_HEXAHEDRON; break; } - myVtkID = grid->InsertNextLinkedCell(aType, nodeIds.size(), &nodeIds[0]); + myVtkID = grid->InsertNextLinkedCell(aType, nodeIds.size(), (vtkIdType *) &nodeIds[0]); mesh->setMyModified(); //MESSAGE("SMDS_VtkVolume::init myVtkID " << myVtkID); } //#ifdef VTK_HAVE_POLYHEDRON -void SMDS_VtkVolume::initPoly(std::vector nodeIds, std::vector nbNodesPerFace, SMDS_Mesh* mesh) +void SMDS_VtkVolume::initPoly(const std::vector& nodeIds, + const std::vector& nbNodesPerFace, + SMDS_Mesh* mesh) { SMDS_MeshVolume::init(); //MESSAGE("SMDS_VtkVolume::initPoly"); SMDS_UnstructuredGrid* grid = mesh->getGrid(); - double center[3]; - this->gravityCenter(grid, &nodeIds[0], nodeIds.size(), ¢er[0]); + //double center[3]; + //this->gravityCenter(grid, &nodeIds[0], nodeIds.size(), ¢er[0]); vector ptIds; - ptIds.clear(); vtkIdType nbFaces = nbNodesPerFace.size(); int k = 0; for (int i = 0; i < nbFaces; i++) @@ -99,7 +106,7 @@ void SMDS_VtkVolume::initPoly(std::vector nodeIds, std::vector n // - either the user should care of order of nodes or // - the user should use a service method arranging nodes if he // don't want or can't to do it by him-self - // The method below works OK only with planar faces + // The method below works OK only with planar faces and convex polyhedrones // // double a[3]; // double b[3]; @@ -109,7 +116,7 @@ void SMDS_VtkVolume::initPoly(std::vector nodeIds, std::vector n // grid->GetPoints()->GetPoint(nodeIds[k + 2], c); // bool isFaceForward = this->isForward(a, b, c, center); //MESSAGE("isFaceForward " << i << " " << isFaceForward); - vtkIdType *facePts = &nodeIds[k]; + const vtkIdType *facePts = &nodeIds[k]; //if (isFaceForward) for (int n = 0; n < nf; n++) ptIds.push_back(facePts[n]); @@ -155,45 +162,13 @@ bool SMDS_VtkVolume::vtkOrder(const SMDS_MeshNode* nodes[], const int nbNodes) } vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid(); vtkIdType aVtkType = grid->GetCellType(this->myVtkID); - switch (aVtkType) + const std::vector& interlace = SMDS_MeshCell::toVtkOrder( VTKCellType( aVtkType )); + if ( !interlace.empty() ) { - case VTK_TETRA: - this->exchange(nodes, 1, 2); - break; - case VTK_QUADRATIC_TETRA: - this->exchange(nodes, 1, 2); - this->exchange(nodes, 4, 6); - this->exchange(nodes, 8, 9); - break; - case VTK_PYRAMID: - this->exchange(nodes, 1, 3); - break; - case VTK_WEDGE: - break; - case VTK_QUADRATIC_PYRAMID: - this->exchange(nodes, 1, 3); - this->exchange(nodes, 5, 8); - this->exchange(nodes, 6, 7); - this->exchange(nodes, 10, 12); - break; - case VTK_QUADRATIC_WEDGE: - break; - case VTK_HEXAHEDRON: - this->exchange(nodes, 1, 3); - this->exchange(nodes, 5, 7); - break; - case VTK_QUADRATIC_HEXAHEDRON: - this->exchange(nodes, 1, 3); - this->exchange(nodes, 5, 7); - this->exchange(nodes, 8, 11); - this->exchange(nodes, 9, 10); - this->exchange(nodes, 12, 15); - this->exchange(nodes, 13, 14); - this->exchange(nodes, 17, 19); - break; - case VTK_POLYHEDRON: - default: - break; + ASSERT( interlace.size() == nbNodes ); + std::vector initNodes( nodes, nodes+nbNodes ); + for ( size_t i = 0; i < interlace.size(); ++i ) + nodes[i] = initNodes[ interlace[i] ]; } return true; } @@ -226,6 +201,7 @@ int SMDS_VtkVolume::NbFaces() const break; case VTK_HEXAHEDRON: case VTK_QUADRATIC_HEXAHEDRON: + case VTK_TRIQUADRATIC_HEXAHEDRON: nbFaces = 6; break; case VTK_POLYHEDRON: @@ -236,6 +212,9 @@ int SMDS_VtkVolume::NbFaces() const nbFaces = nFaces; break; } + case VTK_HEXAGONAL_PRISM: + nbFaces = 8; + break; default: MESSAGE("invalid volume type") ; @@ -291,6 +270,7 @@ int SMDS_VtkVolume::NbEdges() const break; case VTK_HEXAHEDRON: case VTK_QUADRATIC_HEXAHEDRON: + case VTK_TRIQUADRATIC_HEXAHEDRON: nbEdges = 12; break; case VTK_POLYHEDRON: @@ -309,6 +289,9 @@ int SMDS_VtkVolume::NbEdges() const nbEdges = nbEdges / 2; break; } + case VTK_HEXAGONAL_PRISM: + nbEdges = 18; + break; default: MESSAGE("invalid volume type") ; @@ -380,7 +363,7 @@ const SMDS_MeshNode* SMDS_VtkVolume::GetFaceNode(const int face_ind, const int n /*! polyhedron only, * return number of nodes for each face */ -const std::vector SMDS_VtkVolume::GetQuantities() const +std::vector SMDS_VtkVolume::GetQuantities() const { vector quantities; quantities.clear(); @@ -443,8 +426,12 @@ SMDSAbs_ElementType SMDS_VtkVolume::GetType() const */ const SMDS_MeshNode* SMDS_VtkVolume::GetNode(const int ind) const { - // TODO optimize if possible (vtkCellIterator) - return SMDS_MeshElement::GetNode(ind); + vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid(); + vtkIdType aVtkType = grid->GetCellType(this->myVtkID); + vtkIdType npts, *pts; + grid->GetCellPoints( this->myVtkID, npts, pts ); + const std::vector& interlace = SMDS_MeshCell::fromVtkOrder( VTKCellType( aVtkType )); + return SMDS_Mesh::_meshList[myMeshId]->FindNodeVtk( pts[ interlace.empty() ? ind : interlace[ind]] ); } bool SMDS_VtkVolume::IsQuadratic() const @@ -458,6 +445,7 @@ bool SMDS_VtkVolume::IsQuadratic() const case VTK_QUADRATIC_PYRAMID: case VTK_QUADRATIC_WEDGE: case VTK_QUADRATIC_HEXAHEDRON: + case VTK_TRIQUADRATIC_HEXAHEDRON: return true; break; default: @@ -489,6 +477,7 @@ bool SMDS_VtkVolume::IsMediumNode(const SMDS_MeshNode* node) const rankFirstMedium = 6; // medium nodes are of rank 6 to 14 break; case VTK_QUADRATIC_HEXAHEDRON: + case VTK_TRIQUADRATIC_HEXAHEDRON: rankFirstMedium = 8; // medium nodes are of rank 8 to 19 break; default: @@ -515,6 +504,23 @@ bool SMDS_VtkVolume::IsMediumNode(const SMDS_MeshNode* node) const return false; } +int SMDS_VtkVolume::NbCornerNodes() const +{ + vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid(); + int nbN = grid->GetCell(myVtkID)->GetNumberOfPoints(); + vtkIdType aVtkType = grid->GetCellType(myVtkID); + switch (aVtkType) + { + case VTK_QUADRATIC_TETRA: return 4; + case VTK_QUADRATIC_PYRAMID: return 5; + case VTK_QUADRATIC_WEDGE: return 6; + case VTK_QUADRATIC_HEXAHEDRON: + case VTK_TRIQUADRATIC_HEXAHEDRON: return 8; + default:; + } + return nbN; +} + SMDSAbs_EntityType SMDS_VtkVolume::GetEntityType() const { vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid(); @@ -547,6 +553,12 @@ SMDSAbs_EntityType SMDS_VtkVolume::GetEntityType() const case VTK_QUADRATIC_HEXAHEDRON: aType = SMDSEntity_Quad_Hexa; break; + case VTK_TRIQUADRATIC_HEXAHEDRON: + aType = SMDSEntity_TriQuad_Hexa; + break; + case VTK_HEXAGONAL_PRISM: + aType = SMDSEntity_Hexagonal_Prism; + break; //#ifdef VTK_HAVE_POLYHEDRON case VTK_POLYHEDRON: aType = SMDSEntity_Polyhedra; @@ -566,7 +578,10 @@ vtkIdType SMDS_VtkVolume::GetVtkType() const return aType; } -void SMDS_VtkVolume::gravityCenter(SMDS_UnstructuredGrid* grid, vtkIdType *nodeIds, int nbNodes, double* result) +void SMDS_VtkVolume::gravityCenter(SMDS_UnstructuredGrid* grid, + const vtkIdType * nodeIds, + int nbNodes, + double* result) { for (int j = 0; j < 3; j++) result[j] = 0; diff --git a/src/SMDS/SMDS_VtkVolume.hxx b/src/SMDS/SMDS_VtkVolume.hxx index fe12d0afa..218c7a820 100644 --- a/src/SMDS/SMDS_VtkVolume.hxx +++ b/src/SMDS/SMDS_VtkVolume.hxx @@ -30,11 +30,12 @@ class SMDS_EXPORT SMDS_VtkVolume: public SMDS_MeshVolume { public: SMDS_VtkVolume(); - SMDS_VtkVolume(std::vector nodeIds, SMDS_Mesh* mesh); + SMDS_VtkVolume(const std::vector& nodeIds, SMDS_Mesh* mesh); ~SMDS_VtkVolume(); - void init(std::vector nodeIds, SMDS_Mesh* mesh); + void init(const std::vector& nodeIds, SMDS_Mesh* mesh); //#ifdef VTK_HAVE_POLYHEDRON - void initPoly(std::vector nodeIds, std::vector nbNodesPerFace, SMDS_Mesh* mesh); + void initPoly(const std::vector& nodeIds, + const std::vector& nbNodesPerFace, SMDS_Mesh* mesh); //#endif virtual bool ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes); virtual bool vtkOrder(const SMDS_MeshNode* nodes[], const int nbNodes); @@ -57,14 +58,15 @@ public: virtual bool IsQuadratic() const; virtual bool IsPoly() const; virtual bool IsMediumNode(const SMDS_MeshNode* node) const; + virtual int NbCornerNodes() const; static void gravityCenter(SMDS_UnstructuredGrid* grid, - vtkIdType *nodeIds, + const vtkIdType *nodeIds, int nbNodes, double* result); static bool isForward(double* a,double* b,double* c,double* d); int NbUniqueNodes() const; SMDS_ElemIteratorPtr uniqueNodesIterator() const; - const std::vector GetQuantities() const; + std::vector GetQuantities() const; virtual SMDS_ElemIteratorPtr elementsIterator(SMDSAbs_ElementType type) const; virtual SMDS_ElemIteratorPtr nodesIteratorToUNV() const; -- 2.39.2