FACE,
VOLUME
};
+
+ /*!
+ * ElementOrder points out entities of what order are requested
+ */
+ enum ElementOrder {
+ ORDER_ANY, /*! entities of any order */
+ ORDER_LINEAR, /*! entities of 1st order */
+ ORDER_SQUARE /*! entities of 2nd order */
+ };
/*!
* Enumeration for hypothesis status (used by AddHypothesis() and RemoveHypothesis() methods)
long NbEdges()
raises (SALOME::SALOME_Exception);
+ long NbEdgesOfOrder(in ElementOrder order)
+ raises (SALOME::SALOME_Exception);
+
long NbFaces()
raises (SALOME::SALOME_Exception);
+ long NbFacesOfOrder(in ElementOrder order)
+ raises (SALOME::SALOME_Exception);
+
long NbTriangles()
raises (SALOME::SALOME_Exception);
+ long NbTrianglesOfOrder(in ElementOrder order)
+ raises (SALOME::SALOME_Exception);
+
long NbQuadrangles()
raises (SALOME::SALOME_Exception);
+ long NbQuadranglesOfOrder(in ElementOrder order)
+ raises (SALOME::SALOME_Exception);
+
long NbPolygons()
raises (SALOME::SALOME_Exception);
long NbVolumes()
raises (SALOME::SALOME_Exception);
+ long NbVolumesOfOrder(in ElementOrder order)
+ raises (SALOME::SALOME_Exception);
+
long NbTetras()
raises (SALOME::SALOME_Exception);
+ long NbTetrasOfOrder(in ElementOrder order)
+ raises (SALOME::SALOME_Exception);
+
long NbHexas()
raises (SALOME::SALOME_Exception);
+ long NbHexasOfOrder(in ElementOrder order)
+ raises (SALOME::SALOME_Exception);
+
long NbPyramids()
raises (SALOME::SALOME_Exception);
+ long NbPyramidsOfOrder(in ElementOrder order)
+ raises (SALOME::SALOME_Exception);
+
long NbPrisms()
raises (SALOME::SALOME_Exception);
+ long NbPrismsOfOrder(in ElementOrder order)
+ raises (SALOME::SALOME_Exception);
+
long NbPolyhedrons()
raises (SALOME::SALOME_Exception);
*
*/
//=============================================================================
-int SMESH_Mesh::NbEdges() throw(SALOME_Exception)
+int SMESH_Mesh::NbEdges(ElementOrder order) throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
- return _myMeshDS->NbEdges();
+ if (order == ORDER_ANY)
+ return _myMeshDS->NbEdges();
+
+ int Nb = 0;
+ SMDS_EdgeIteratorPtr it = _myMeshDS->edgesIterator();
+ while (it->more()) {
+ const SMDS_MeshEdge* cur = it->next();
+ if ( order == ORDER_LINEAR && !cur->IsQuadratic() ||
+ order == ORDER_SQUARE && cur->IsQuadratic() )
+ Nb++;
+ }
+ return Nb;
}
//=============================================================================
*
*/
//=============================================================================
-int SMESH_Mesh::NbFaces() throw(SALOME_Exception)
+int SMESH_Mesh::NbFaces(ElementOrder order) throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
- return _myMeshDS->NbFaces();
+ if (order == ORDER_ANY)
+ return _myMeshDS->NbFaces();
+
+ int Nb = 0;
+ SMDS_FaceIteratorPtr it = _myMeshDS->facesIterator();
+ while (it->more()) {
+ const SMDS_MeshFace* cur = it->next();
+ if ( order == ORDER_LINEAR && !cur->IsQuadratic() ||
+ order == ORDER_SQUARE && cur->IsQuadratic() )
+ Nb++;
+ }
+ return Nb;
}
///////////////////////////////////////////////////////////////////////////////
/// Return the number of 3 nodes faces in the mesh. This method run in O(n)
///////////////////////////////////////////////////////////////////////////////
-int SMESH_Mesh::NbTriangles() throw(SALOME_Exception)
+int SMESH_Mesh::NbTriangles(ElementOrder order) throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
int Nb = 0;
SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator();
- //while(itFaces->more()) if(itFaces->next()->NbNodes()==3) Nb++;
- const SMDS_MeshFace * curFace;
while (itFaces->more()) {
- curFace = itFaces->next();
+ const SMDS_MeshFace* curFace = itFaces->next();
+ int nbnod = curFace->NbNodes();
if ( !curFace->IsPoly() &&
- ( curFace->NbNodes()==3 || curFace->NbNodes()==6 ) ) Nb++;
+ ( order == ORDER_ANY && (nbnod==3 || nbnod==6) ||
+ order == ORDER_LINEAR && nbnod==3 ||
+ order == ORDER_SQUARE && nbnod==6 ) )
+ Nb++;
}
return Nb;
}
///////////////////////////////////////////////////////////////////////////////
/// Return the number of 4 nodes faces in the mesh. This method run in O(n)
///////////////////////////////////////////////////////////////////////////////
-int SMESH_Mesh::NbQuadrangles() throw(SALOME_Exception)
+int SMESH_Mesh::NbQuadrangles(ElementOrder order) throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
int Nb = 0;
SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator();
- //while(itFaces->more()) if(itFaces->next()->NbNodes()==4) Nb++;
- const SMDS_MeshFace * curFace;
while (itFaces->more()) {
- curFace = itFaces->next();
+ const SMDS_MeshFace* curFace = itFaces->next();
+ int nbnod = curFace->NbNodes();
if ( !curFace->IsPoly() &&
- ( curFace->NbNodes() == 4 || curFace->NbNodes()==8 ) ) Nb++;
+ ( order == ORDER_ANY && (nbnod==4 || nbnod==8) ||
+ order == ORDER_LINEAR && nbnod==4 ||
+ order == ORDER_SQUARE && nbnod==8 ) )
+ Nb++;
}
return Nb;
}
*
*/
//=============================================================================
-int SMESH_Mesh::NbVolumes() throw(SALOME_Exception)
+int SMESH_Mesh::NbVolumes(ElementOrder order) throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
- return _myMeshDS->NbVolumes();
+ if (order == ORDER_ANY)
+ return _myMeshDS->NbVolumes();
+
+ int Nb = 0;
+ SMDS_VolumeIteratorPtr it = _myMeshDS->volumesIterator();
+ while (it->more()) {
+ const SMDS_MeshVolume* cur = it->next();
+ if ( order == ORDER_LINEAR && !cur->IsQuadratic() ||
+ order == ORDER_SQUARE && cur->IsQuadratic() )
+ Nb++;
+ }
+ return Nb;
}
-int SMESH_Mesh::NbTetras() throw(SALOME_Exception)
+int SMESH_Mesh::NbTetras(ElementOrder order) throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
int Nb = 0;
SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
- //while(itVolumes->more()) if(itVolumes->next()->NbNodes()==4) Nb++;
- const SMDS_MeshVolume * curVolume;
while (itVolumes->more()) {
- curVolume = itVolumes->next();
+ const SMDS_MeshVolume* curVolume = itVolumes->next();
+ int nbnod = curVolume->NbNodes();
if ( !curVolume->IsPoly() &&
- ( curVolume->NbNodes() == 4 || curVolume->NbNodes()==10 ) ) Nb++;
+ ( order == ORDER_ANY && (nbnod==4 || nbnod==10) ||
+ order == ORDER_LINEAR && nbnod==4 ||
+ order == ORDER_SQUARE && nbnod==10 ) )
+ Nb++;
}
return Nb;
}
-int SMESH_Mesh::NbHexas() throw(SALOME_Exception)
+int SMESH_Mesh::NbHexas(ElementOrder order) throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
int Nb = 0;
SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
- //while(itVolumes->more()) if(itVolumes->next()->NbNodes()==8) Nb++;
- const SMDS_MeshVolume * curVolume;
while (itVolumes->more()) {
- curVolume = itVolumes->next();
+ const SMDS_MeshVolume* curVolume = itVolumes->next();
+ int nbnod = curVolume->NbNodes();
if ( !curVolume->IsPoly() &&
- ( curVolume->NbNodes() == 8 || curVolume->NbNodes()==20 ) ) Nb++;
+ ( order == ORDER_ANY && (nbnod==8 || nbnod==20) ||
+ order == ORDER_LINEAR && nbnod==8 ||
+ order == ORDER_SQUARE && nbnod==20 ) )
+ Nb++;
}
return Nb;
}
-int SMESH_Mesh::NbPyramids() throw(SALOME_Exception)
+int SMESH_Mesh::NbPyramids(ElementOrder order) throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
int Nb = 0;
SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
- //while(itVolumes->more()) if(itVolumes->next()->NbNodes()==5) Nb++;
- const SMDS_MeshVolume * curVolume;
while (itVolumes->more()) {
- curVolume = itVolumes->next();
+ const SMDS_MeshVolume* curVolume = itVolumes->next();
+ int nbnod = curVolume->NbNodes();
if ( !curVolume->IsPoly() &&
- ( curVolume->NbNodes() == 5 || curVolume->NbNodes()==13 ) ) Nb++;
+ ( order == ORDER_ANY && (nbnod==5 || nbnod==13) ||
+ order == ORDER_LINEAR && nbnod==5 ||
+ order == ORDER_SQUARE && nbnod==13 ) )
+ Nb++;
}
return Nb;
}
-int SMESH_Mesh::NbPrisms() throw(SALOME_Exception)
+int SMESH_Mesh::NbPrisms(ElementOrder order) throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
int Nb = 0;
SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
- //while(itVolumes->more()) if(itVolumes->next()->NbNodes()==6) Nb++;
- const SMDS_MeshVolume * curVolume;
while (itVolumes->more()) {
- curVolume = itVolumes->next();
+ const SMDS_MeshVolume* curVolume = itVolumes->next();
+ int nbnod = curVolume->NbNodes();
if ( !curVolume->IsPoly() &&
- ( curVolume->NbNodes() == 6 || curVolume->NbNodes()==15 ) ) Nb++;
+ ( order == ORDER_ANY && (nbnod==6 || nbnod==15) ||
+ order == ORDER_LINEAR && nbnod==6 ||
+ order == ORDER_SQUARE && nbnod==15 ) )
+ Nb++;
}
return Nb;
}
int NbNodes() throw(SALOME_Exception);
- int NbEdges() throw(SALOME_Exception);
+ /*!
+ * ElementOrder points out entities of what order are requested
+ */
+ enum ElementOrder {
+ ORDER_ANY, /*! entities of any order */
+ ORDER_LINEAR, /*! entities of 1st order */
+ ORDER_SQUARE /*! entities of 2nd order */
+ };
+
+ int NbEdges(ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
- int NbFaces() throw(SALOME_Exception);
+ int NbFaces(ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
- int NbTriangles() throw(SALOME_Exception);
+ int NbTriangles(ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
- int NbQuadrangles() throw(SALOME_Exception);
+ int NbQuadrangles(ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
int NbPolygons() throw(SALOME_Exception);
- int NbVolumes() throw(SALOME_Exception);
+ int NbVolumes(ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
- int NbTetras() throw(SALOME_Exception);
+ int NbTetras(ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
- int NbHexas() throw(SALOME_Exception);
+ int NbHexas(ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
- int NbPyramids() throw(SALOME_Exception);
+ int NbPyramids(ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
- int NbPrisms() throw(SALOME_Exception);
+ int NbPrisms(ElementOrder order = ORDER_ANY) throw(SALOME_Exception);
int NbPolyhedrons() throw(SALOME_Exception);
myMeshNbNodes = new QLabel(myMeshWidget, "myMeshNbNodes");
myMeshNbNodes->setMinimumWidth(100);
+ // --> header with orders
+ QLabel* myMeshOrder0Lab = new QLabel(tr("SMESH_MESHINFO_ORDER0"), myMeshWidget, "myMeshOrder0Lab");
+ QLabel* myMeshOrder1Lab = new QLabel(tr("SMESH_MESHINFO_ORDER1"), myMeshWidget, "myMeshOrder1Lab");
+ QLabel* myMeshOrder2Lab = new QLabel(tr("SMESH_MESHINFO_ORDER2"), myMeshWidget, "myMeshOrder2Lab");
+ QFont fnti = myMeshOrder0Lab->font(); fnti.setItalic(true);
+ myMeshOrder0Lab->setFont(fnti);
+ myMeshOrder1Lab->setFont(fnti);
+ myMeshOrder2Lab->setFont(fnti);
+
// --> edges
QLabel* myMeshNbEdgesLab = new QLabel(COLONIZE(tr("SMESH_MESHINFO_EDGES")), myMeshWidget, "myMeshNbEdgesLab");
myMeshNbEdges = new QLabel(myMeshWidget, "myMeshNbEdges");
myMeshNbEdges->setMinimumWidth(100);
+ myMeshNbEdges1 = new QLabel(myMeshWidget, "myMeshNbEdges1");
+ myMeshNbEdges1->setMinimumWidth(100);
+ myMeshNbEdges2 = new QLabel(myMeshWidget, "myMeshNbEdges2");
+ myMeshNbEdges2->setMinimumWidth(100);
// --> faces
myMeshFacesGroup = new QGroupBox(tr("SMESH_MESHINFO_FACES"), myMeshWidget, "myMeshFacesGroup");
myMeshNbFaces = new QLabel(myMeshFacesGroup, "myMeshNbFaces");
myMeshNbFaces->setMinimumWidth(100);
myMeshNbFaces->setFont(fnt);
+ myMeshNbFaces1 = new QLabel(myMeshFacesGroup, "myMeshNbFaces1");
+ myMeshNbFaces1->setMinimumWidth(100);
+ myMeshNbFaces1->setFont(fnt);
+ myMeshNbFaces2 = new QLabel(myMeshFacesGroup, "myMeshNbFaces2");
+ myMeshNbFaces2->setMinimumWidth(100);
+ myMeshNbFaces2->setFont(fnt);
// --> faces --> triangles
QLabel* myMeshNbTrianglesLab = new QLabel(COLONIZE(tr("SMESH_MESHINFO_TRIANGLES")), myMeshFacesGroup, "myMeshNbTrianglesLab");
myMeshNbTriangles = new QLabel(myMeshFacesGroup, "myMeshNbTriangles");
myMeshNbTriangles->setMinimumWidth(100);
+ myMeshNbTriangles1 = new QLabel(myMeshFacesGroup, "myMeshNbTriangles1");
+ myMeshNbTriangles1->setMinimumWidth(100);
+ myMeshNbTriangles2 = new QLabel(myMeshFacesGroup, "myMeshNbTriangles2");
+ myMeshNbTriangles2->setMinimumWidth(100);
// --> faces --> quadrangles
QLabel* myMeshNbQuadranglesLab = new QLabel(COLONIZE(tr("SMESH_MESHINFO_QUADRANGLES")), myMeshFacesGroup, "myMeshNbQuadranglesLab");
myMeshNbQuadrangles = new QLabel(myMeshFacesGroup, "myMeshNbQuadrangles");
myMeshNbQuadrangles->setMinimumWidth(100);
+ myMeshNbQuadrangles1 = new QLabel(myMeshFacesGroup, "myMeshNbQuadrangles1");
+ myMeshNbQuadrangles1->setMinimumWidth(100);
+ myMeshNbQuadrangles2 = new QLabel(myMeshFacesGroup, "myMeshNbQuadrangles2");
+ myMeshNbQuadrangles2->setMinimumWidth(100);
// --> faces --> polygons
QLabel* myMeshNbPolygonesLab = new QLabel( COLONIZE( tr( "SMESH_MESHINFO_POLYGONES" ) ), myMeshFacesGroup, "myMeshNbPolygonesLab" );
myMeshFacesGroupLayout->addWidget(myMeshNbFacesLab, 0, 0);
myMeshFacesGroupLayout->addWidget(myMeshNbFaces, 0, 1);
+ myMeshFacesGroupLayout->addWidget(myMeshNbFaces1, 0, 2);
+ myMeshFacesGroupLayout->addWidget(myMeshNbFaces2, 0, 3);
myMeshFacesGroupLayout->addWidget(myMeshNbTrianglesLab, 1, 0);
myMeshFacesGroupLayout->addWidget(myMeshNbTriangles, 1, 1);
+ myMeshFacesGroupLayout->addWidget(myMeshNbTriangles1, 1, 2);
+ myMeshFacesGroupLayout->addWidget(myMeshNbTriangles2, 1, 3);
myMeshFacesGroupLayout->addWidget(myMeshNbQuadranglesLab, 2, 0);
myMeshFacesGroupLayout->addWidget(myMeshNbQuadrangles, 2, 1);
+ myMeshFacesGroupLayout->addWidget(myMeshNbQuadrangles1, 2, 2);
+ myMeshFacesGroupLayout->addWidget(myMeshNbQuadrangles2, 2, 3);
myMeshFacesGroupLayout->addWidget( myMeshNbPolygonesLab, 3, 0 );
myMeshFacesGroupLayout->addWidget( myMeshNbPolygones, 3, 1 );
myMeshNbVolumes = new QLabel(myMeshVolumesGroup, "myMeshNbVolumes");
myMeshNbVolumes->setMinimumWidth(100);
myMeshNbVolumes->setFont(fnt);
+ myMeshNbVolumes1 = new QLabel(myMeshVolumesGroup, "myMeshNbVolumes1");
+ myMeshNbVolumes1->setMinimumWidth(100);
+ myMeshNbVolumes1->setFont(fnt);
+ myMeshNbVolumes2 = new QLabel(myMeshVolumesGroup, "myMeshNbVolumes2");
+ myMeshNbVolumes2->setMinimumWidth(100);
+ myMeshNbVolumes2->setFont(fnt);
// --> volumes --> tetrahedrons
QLabel* myMeshNbTetraLab = new QLabel(COLONIZE(tr("SMESH_MESHINFO_TETRAS")), myMeshVolumesGroup, "myMeshNbTetraLab");
myMeshNbTetra = new QLabel(myMeshVolumesGroup, "myMeshNbTetra");
myMeshNbTetra->setMinimumWidth(100);
+ myMeshNbTetra1 = new QLabel(myMeshVolumesGroup, "myMeshNbTetra1");
+ myMeshNbTetra1->setMinimumWidth(100);
+ myMeshNbTetra2 = new QLabel(myMeshVolumesGroup, "myMeshNbTetra2");
+ myMeshNbTetra2->setMinimumWidth(100);
// --> volumes --> hexahedrons
QLabel* myMeshNbHexaLab = new QLabel(COLONIZE(tr("SMESH_MESHINFO_HEXAS")), myMeshVolumesGroup, "myMeshNbHexaLab");
myMeshNbHexa = new QLabel(myMeshVolumesGroup, "myMeshNbHexa");
- myMeshNbHexaLab->setMinimumWidth(100);
+ myMeshNbHexa->setMinimumWidth(100);
+ myMeshNbHexa1 = new QLabel(myMeshVolumesGroup, "myMeshNbHexa1");
+ myMeshNbHexa1->setMinimumWidth(100);
+ myMeshNbHexa2 = new QLabel(myMeshVolumesGroup, "myMeshNbHexa2");
+ myMeshNbHexa2->setMinimumWidth(100);
// --> volumes --> prisms
QLabel* myMeshNbPrismLab = new QLabel(COLONIZE(tr("SMESH_MESHINFO_PRISMS")), myMeshVolumesGroup, "myMeshNbPrismLab");
myMeshNbPrism = new QLabel(myMeshVolumesGroup, "myMeshNbPrism");
myMeshNbPrism->setMinimumWidth(100);
+ myMeshNbPrism1 = new QLabel(myMeshVolumesGroup, "myMeshNbPrism1");
+ myMeshNbPrism1->setMinimumWidth(100);
+ myMeshNbPrism2 = new QLabel(myMeshVolumesGroup, "myMeshNbPrism2");
+ myMeshNbPrism2->setMinimumWidth(100);
// --> volumes --> pyramids
QLabel* myMeshNbPyraLab = new QLabel(COLONIZE(tr("SMESH_MESHINFO_PYRAS")), myMeshVolumesGroup, "myMeshNbPyraLab");
myMeshNbPyra = new QLabel(myMeshVolumesGroup, "myMeshNbPyra");
myMeshNbPyra->setMinimumWidth(100);
+ myMeshNbPyra1 = new QLabel(myMeshVolumesGroup, "myMeshNbPyra1");
+ myMeshNbPyra1->setMinimumWidth(100);
+ myMeshNbPyra2 = new QLabel(myMeshVolumesGroup, "myMeshNbPyra2");
+ myMeshNbPyra2->setMinimumWidth(100);
// --> volumes --> polyherones
QLabel* myMeshNbPolyhedronesLab = new QLabel( COLONIZE( tr( "SMESH_MESHINFO_POLYEDRES" ) ), myMeshVolumesGroup, "myMeshNbPolyhedronLab" );
myMeshVolumesGroupLayout->addWidget(myMeshNbVolumesLab, 0, 0);
myMeshVolumesGroupLayout->addWidget(myMeshNbVolumes, 0, 1);
+ myMeshVolumesGroupLayout->addWidget(myMeshNbVolumes1, 0, 2);
+ myMeshVolumesGroupLayout->addWidget(myMeshNbVolumes2, 0, 3);
myMeshVolumesGroupLayout->addWidget(myMeshNbTetraLab, 1, 0);
myMeshVolumesGroupLayout->addWidget(myMeshNbTetra, 1, 1);
+ myMeshVolumesGroupLayout->addWidget(myMeshNbTetra1, 1, 2);
+ myMeshVolumesGroupLayout->addWidget(myMeshNbTetra2, 1, 3);
myMeshVolumesGroupLayout->addWidget(myMeshNbHexaLab, 2, 0);
myMeshVolumesGroupLayout->addWidget(myMeshNbHexa, 2, 1);
+ myMeshVolumesGroupLayout->addWidget(myMeshNbHexa1, 2, 2);
+ myMeshVolumesGroupLayout->addWidget(myMeshNbHexa2, 2, 3);
myMeshVolumesGroupLayout->addWidget(myMeshNbPrismLab, 3, 0);
myMeshVolumesGroupLayout->addWidget(myMeshNbPrism, 3, 1);
+ myMeshVolumesGroupLayout->addWidget(myMeshNbPrism1, 3, 2);
+ myMeshVolumesGroupLayout->addWidget(myMeshNbPrism2, 3, 3);
myMeshVolumesGroupLayout->addWidget(myMeshNbPyraLab, 4, 0);
myMeshVolumesGroupLayout->addWidget(myMeshNbPyra, 4, 1);
+ myMeshVolumesGroupLayout->addWidget(myMeshNbPyra1, 4, 2);
+ myMeshVolumesGroupLayout->addWidget(myMeshNbPyra2, 4, 3);
myMeshVolumesGroupLayout->addWidget( myMeshNbPolyhedronesLab, 5, 0 );
myMeshVolumesGroupLayout->addWidget( myMeshNbPolyhedrones, 5, 1 );
aMeshLayout->addMultiCellWidget(line1, 1, 1, 0, 1);
aMeshLayout->addWidget(myMeshNbNodesLab, 2, 0);
aMeshLayout->addWidget(myMeshNbNodes, 2, 1);
- aMeshLayout->addWidget(myMeshNbEdgesLab, 3, 0);
- aMeshLayout->addWidget(myMeshNbEdges, 3, 1);
- aMeshLayout->addMultiCellWidget(myMeshFacesGroup, 4, 4, 0, 1);
- aMeshLayout->addMultiCellWidget(myMeshVolumesGroup, 5, 5, 0, 1);
- aMeshLayout->addItem(new QSpacerItem(5, 5, QSizePolicy::Minimum, QSizePolicy::Expanding), 6, 0);
+ aMeshLayout->addWidget(myMeshOrder0Lab, 3, 1);
+ aMeshLayout->addWidget(myMeshOrder1Lab, 3, 2);
+ aMeshLayout->addWidget(myMeshOrder2Lab, 3, 3);
+ aMeshLayout->addWidget(myMeshNbEdgesLab, 4, 0);
+ aMeshLayout->addWidget(myMeshNbEdges, 4, 1);
+ aMeshLayout->addWidget(myMeshNbEdges1, 4, 2);
+ aMeshLayout->addWidget(myMeshNbEdges2, 4, 3);
+ aMeshLayout->addMultiCellWidget(myMeshFacesGroup, 5, 5, 0, 3);
+ aMeshLayout->addMultiCellWidget(myMeshVolumesGroup, 6, 6, 0, 3);
+ aMeshLayout->addItem(new QSpacerItem(6, 6, QSizePolicy::Minimum, QSizePolicy::Expanding), 7, 0);
// submesh
mySubMeshWidget = new QWidget(myWGStack);
myMeshName->setText(aSO->GetName().c_str());
myMeshNbNodes->setNum((int)aMesh->NbNodes());
myMeshNbEdges->setNum((int)aMesh->NbEdges());
+ myMeshNbEdges1->setNum((int)aMesh->NbEdgesOfOrder(SMESH::ORDER_LINEAR));
+ myMeshNbEdges2->setNum((int)aMesh->NbEdgesOfOrder(SMESH::ORDER_SQUARE));
myMeshNbFaces->setNum((int)aMesh->NbFaces());
+ myMeshNbFaces1->setNum((int)aMesh->NbFacesOfOrder(SMESH::ORDER_LINEAR));
+ myMeshNbFaces2->setNum((int)aMesh->NbFacesOfOrder(SMESH::ORDER_SQUARE));
myMeshNbTriangles->setNum((int)aMesh->NbTriangles());
+ myMeshNbTriangles1->setNum((int)aMesh->NbTrianglesOfOrder(SMESH::ORDER_LINEAR));
+ myMeshNbTriangles2->setNum((int)aMesh->NbTrianglesOfOrder(SMESH::ORDER_SQUARE));
myMeshNbQuadrangles->setNum((int)aMesh->NbQuadrangles());
+ myMeshNbQuadrangles1->setNum((int)aMesh->NbQuadranglesOfOrder(SMESH::ORDER_LINEAR));
+ myMeshNbQuadrangles2->setNum((int)aMesh->NbQuadranglesOfOrder(SMESH::ORDER_SQUARE));
myMeshNbPolygones->setNum( (int)aMesh->NbPolygons() );
myMeshNbVolumes->setNum((int)aMesh->NbVolumes());
+ myMeshNbVolumes1->setNum((int)aMesh->NbVolumesOfOrder(SMESH::ORDER_LINEAR));
+ myMeshNbVolumes2->setNum((int)aMesh->NbVolumesOfOrder(SMESH::ORDER_SQUARE));
myMeshNbTetra->setNum((int)aMesh->NbTetras());
+ myMeshNbTetra1->setNum((int)aMesh->NbTetrasOfOrder(SMESH::ORDER_LINEAR));
+ myMeshNbTetra2->setNum((int)aMesh->NbTetrasOfOrder(SMESH::ORDER_SQUARE));
myMeshNbHexa->setNum((int)aMesh->NbHexas());
+ myMeshNbHexa1->setNum((int)aMesh->NbHexasOfOrder(SMESH::ORDER_LINEAR));
+ myMeshNbHexa2->setNum((int)aMesh->NbHexasOfOrder(SMESH::ORDER_SQUARE));
myMeshNbPrism->setNum((int)aMesh->NbPrisms());
+ myMeshNbPrism1->setNum((int)aMesh->NbPrismsOfOrder(SMESH::ORDER_LINEAR));
+ myMeshNbPrism2->setNum((int)aMesh->NbPrismsOfOrder(SMESH::ORDER_SQUARE));
myMeshNbPyra->setNum((int)aMesh->NbPyramids());
+ myMeshNbPyra1->setNum((int)aMesh->NbPyramidsOfOrder(SMESH::ORDER_LINEAR));
+ myMeshNbPyra2->setNum((int)aMesh->NbPyramidsOfOrder(SMESH::ORDER_SQUARE));
myMeshNbPolyhedrones->setNum( (int)aMesh->NbPolyhedrons() );
return;
}
QLabel* myMeshName;
QLabel* myMeshNbNodes;
QLabel* myMeshNbEdges;
+ QLabel* myMeshNbEdges1;
+ QLabel* myMeshNbEdges2;
QGroupBox* myMeshFacesGroup;
QLabel* myMeshNbFaces;
+ QLabel* myMeshNbFaces1;
+ QLabel* myMeshNbFaces2;
QLabel* myMeshNbTriangles;
+ QLabel* myMeshNbTriangles1;
+ QLabel* myMeshNbTriangles2;
QLabel* myMeshNbQuadrangles;
+ QLabel* myMeshNbQuadrangles1;
+ QLabel* myMeshNbQuadrangles2;
QLabel* myMeshNbPolygones;
QGroupBox* myMeshVolumesGroup;
QLabel* myMeshNbVolumes;
+ QLabel* myMeshNbVolumes1;
+ QLabel* myMeshNbVolumes2;
QLabel* myMeshNbTetra;
+ QLabel* myMeshNbTetra1;
+ QLabel* myMeshNbTetra2;
QLabel* myMeshNbHexa;
+ QLabel* myMeshNbHexa1;
+ QLabel* myMeshNbHexa2;
QLabel* myMeshNbPyra;
+ QLabel* myMeshNbPyra1;
+ QLabel* myMeshNbPyra2;
QLabel* myMeshNbPrism;
+ QLabel* myMeshNbPrism1;
+ QLabel* myMeshNbPrism2;
QLabel* myMeshNbPolyhedrones;
QWidget* mySubMeshWidget;
msgid "SMESH_MESHINFO_NAME"
msgstr "Name"
-#Faces :
+#Order :
+msgid "SMESH_MESHINFO_ORDER0"
+msgstr "Total"
+
+msgid "SMESH_MESHINFO_ORDER1"
+msgstr "Linear"
+
+msgid "SMESH_MESHINFO_ORDER2"
+msgstr "Square"
+
+#Elements :
msgid "SMESH_MESHINFO_ELEMENTS"
msgstr "Elements"
return _impl->NbEdges();
}
+CORBA::Long SMESH_Mesh_i::NbEdgesOfOrder(SMESH::ElementOrder order)
+ throw(SALOME::SALOME_Exception)
+{
+ Unexpect aCatch(SALOME_SalomeException);
+ return _impl->NbEdges( (::SMESH_Mesh::ElementOrder) order);
+}
+
//=============================================================================
/*!
*
return _impl->NbPolygons();
}
+CORBA::Long SMESH_Mesh_i::NbFacesOfOrder(SMESH::ElementOrder order)
+ throw(SALOME::SALOME_Exception)
+{
+ Unexpect aCatch(SALOME_SalomeException);
+ return _impl->NbFaces( (::SMESH_Mesh::ElementOrder) order);
+}
+
+CORBA::Long SMESH_Mesh_i::NbTrianglesOfOrder(SMESH::ElementOrder order)
+ throw(SALOME::SALOME_Exception)
+{
+ Unexpect aCatch(SALOME_SalomeException);
+ return _impl->NbTriangles( (::SMESH_Mesh::ElementOrder) order);
+}
+
+CORBA::Long SMESH_Mesh_i::NbQuadranglesOfOrder(SMESH::ElementOrder order)
+ throw(SALOME::SALOME_Exception)
+{
+ Unexpect aCatch(SALOME_SalomeException);
+ return _impl->NbQuadrangles( (::SMESH_Mesh::ElementOrder) order);
+}
+
//=============================================================================
/*!
*
return _impl->NbPolyhedrons();
}
+CORBA::Long SMESH_Mesh_i::NbVolumesOfOrder(SMESH::ElementOrder order)
+ throw(SALOME::SALOME_Exception)
+{
+ Unexpect aCatch(SALOME_SalomeException);
+ return _impl->NbVolumes( (::SMESH_Mesh::ElementOrder) order);
+}
+
+CORBA::Long SMESH_Mesh_i::NbTetrasOfOrder(SMESH::ElementOrder order)
+ throw(SALOME::SALOME_Exception)
+{
+ Unexpect aCatch(SALOME_SalomeException);
+ return _impl->NbTetras( (::SMESH_Mesh::ElementOrder) order);
+}
+
+CORBA::Long SMESH_Mesh_i::NbHexasOfOrder(SMESH::ElementOrder order)
+ throw(SALOME::SALOME_Exception)
+{
+ Unexpect aCatch(SALOME_SalomeException);
+ return _impl->NbHexas( (::SMESH_Mesh::ElementOrder) order);
+}
+
+CORBA::Long SMESH_Mesh_i::NbPyramidsOfOrder(SMESH::ElementOrder order)
+ throw(SALOME::SALOME_Exception)
+{
+ Unexpect aCatch(SALOME_SalomeException);
+ return _impl->NbPyramids( (::SMESH_Mesh::ElementOrder) order);
+}
+
+CORBA::Long SMESH_Mesh_i::NbPrismsOfOrder(SMESH::ElementOrder order)
+ throw(SALOME::SALOME_Exception)
+{
+ Unexpect aCatch(SALOME_SalomeException);
+ return _impl->NbPrisms( (::SMESH_Mesh::ElementOrder) order);
+}
+
//=============================================================================
/*!
*
CORBA::Long NbEdges()
throw (SALOME::SALOME_Exception);
+ CORBA::Long NbEdgesOfOrder(SMESH::ElementOrder order)
+ throw (SALOME::SALOME_Exception);
+
CORBA::Long NbFaces()
throw (SALOME::SALOME_Exception);
+ CORBA::Long NbFacesOfOrder(SMESH::ElementOrder order)
+ throw (SALOME::SALOME_Exception);
+
CORBA::Long NbTriangles()
throw (SALOME::SALOME_Exception);
+ CORBA::Long NbTrianglesOfOrder(SMESH::ElementOrder order)
+ throw (SALOME::SALOME_Exception);
+
CORBA::Long NbQuadrangles()
throw (SALOME::SALOME_Exception);
+ CORBA::Long NbQuadranglesOfOrder(SMESH::ElementOrder order)
+ throw (SALOME::SALOME_Exception);
+
CORBA::Long NbPolygons()
throw (SALOME::SALOME_Exception);
CORBA::Long NbVolumes()
throw (SALOME::SALOME_Exception);
+ CORBA::Long NbVolumesOfOrder(SMESH::ElementOrder order)
+ throw (SALOME::SALOME_Exception);
+
CORBA::Long NbTetras()
throw (SALOME::SALOME_Exception);
+ CORBA::Long NbTetrasOfOrder(SMESH::ElementOrder order)
+ throw (SALOME::SALOME_Exception);
+
CORBA::Long NbHexas()
throw (SALOME::SALOME_Exception);
+ CORBA::Long NbHexasOfOrder(SMESH::ElementOrder order)
+ throw (SALOME::SALOME_Exception);
+
CORBA::Long NbPyramids()
throw (SALOME::SALOME_Exception);
+ CORBA::Long NbPyramidsOfOrder(SMESH::ElementOrder order)
+ throw (SALOME::SALOME_Exception);
+
CORBA::Long NbPrisms()
throw (SALOME::SALOME_Exception);
+ CORBA::Long NbPrismsOfOrder(SMESH::ElementOrder order)
+ throw (SALOME::SALOME_Exception);
+
CORBA::Long NbPolyhedrons()
throw (SALOME::SALOME_Exception);
