ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-04-09 18:57:27 +05:00
Code Issues Packages Projects Releases Wiki Activity

IPAL52980: Wire Discretization with Table density fails

Browse Source 
(StdMeshers_Regular_1D.cxx)

+ Compilation warnings

+ WIN specific errors
   (StdMeshers_Adaptive1D.cxx)
This commit is contained in:
eap 2015-11-19 14:29:23 +03:00
parent 70e7642a8c
commit 831ca6c828
37 changed files with 1508 additions and 1474 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
doc/salome/examples/filters_ex36.py
View File

@ -1,13 +1,17 @@
# Combine filters with Criterion structures using of "criteria". # Combine several criteria into a filter
# create mesh # create mesh
from SMESH_mechanic import * from SMESH_mechanic import *
# get all the quadrangle faces ... # get all the quadrangle faces ...
criterion1 = smesh.GetCriterion(SMESH.FACE, SMESH.FT_ElemGeomType, SMESH.Geom_QUADRANGLE, SMESH.FT_LogicalAND) criterion1 = smesh.GetCriterion(SMESH.FACE, SMESH.FT_ElemGeomType, SMESH.Geom_QUADRANGLE, SMESH.FT_LogicalAND)
# ... AND do NOT get those from sub_face3 # ... but those from sub_face3
criterion2 = smesh.GetCriterion(SMESH.FACE, SMESH.FT_BelongToGeom, sub_face3, SMESH.FT_LogicalNOT) criterion2 = smesh.GetCriterion(SMESH.FACE, SMESH.FT_BelongToGeom, sub_face3, SMESH.FT_LogicalNOT)
filter = smesh.CreateFilterManager().CreateFilter()
filter.SetCriteria([criterion1,criterion2])
ids = mesh.GetIdsFromFilter(filter)
myGroup = mesh.MakeGroupByIds("Quads_on_cylindrical_faces",SMESH.FACE,ids) quadFilter = smesh.GetFilterFromCriteria([criterion1,criterion2])
# get faces satisfying the criteria
ids = mesh.GetIdsFromFilter(quadFilter)
# create a group of faces satisfying the criteria
myGroup = mesh.GroupOnFilter(SMESH.FACE,"Quads_on_cylindrical_faces",quadFilter)

4
doc/salome/gui/SMESH/input/about_meshes.doc
View File

@ -19,7 +19,7 @@ Mesh module provides several ways to create the mesh:
Construction of \subpage constructing_submeshes_page "sub-meshes" Construction of \subpage constructing_submeshes_page "sub-meshes"
allows to discretize some sub-shapes of the main shape, for example a face, allows to discretize some sub-shapes of the main shape, for example a face,
using the meshing parameters that differ from those for other sub-shapes.<br> using the meshing parameters that differ from those used for other sub-shapes.<br>
Meshing parameters of meshes and sub-meshes can be Meshing parameters of meshes and sub-meshes can be
\subpage editing_meshes_page "edited". (Upon edition only mesh entities \subpage editing_meshes_page "edited". (Upon edition only mesh entities
generated using changed meshing parameters are removed and will be generated using changed meshing parameters are removed and will be
@ -39,7 +39,7 @@ Mesh module provides several ways to create the mesh:
(and exported to) the file in MED, UNV, STL, CGNS, DAT, GMF and (and exported to) the file in MED, UNV, STL, CGNS, DAT, GMF and
SAUVE formats. SAUVE formats.
</li> </li>
<li>The 3D mesh can be generated from the 2D mesh, \ref <li>The 3D mesh can be generated from the 2D mesh, which was \ref
importing_exporting_meshes_page "imported" or manually created. To importing_exporting_meshes_page "imported" or manually created. To
setup the meshing parameters of a mesh not based on a geometry, just setup the meshing parameters of a mesh not based on a geometry, just
invoke \ref editing_meshes_page "Edit mesh / sub-mesh" command on invoke \ref editing_meshes_page "Edit mesh / sub-mesh" command on

6
doc/salome/gui/SMESH/input/tui_filters.doc
View File

@ -10,7 +10,7 @@ or edit mesh groups, remove elements from the mesh object, control
mesh quality by different parameters, etc. mesh quality by different parameters, etc.
Several filtering criteria can be combined together by using logical Several filtering criteria can be combined together by using logical
operators \a AND and \a OR. In addition, applied filter criterion can operators \a AND and \a OR. In addition, a filtering criterion can
be reverted using logical operator \a NOT. be reverted using logical operator \a NOT.
Mesh filters can use the functionality of mesh quality controls to filter Mesh filters can use the functionality of mesh quality controls to filter
@ -416,9 +416,9 @@ entity type.
\tui_script{filters_ex35.py} \tui_script{filters_ex35.py}
\section combining_filters How to combine filters with Criterion structures? \section combining_filters How to combine several criteria into a filter?
Filters can be combined by making use of "criteria". Several criteria can be combined into a filter.
Example : Example :

75
src/Controls/SMESH_Controls.cxx
View File

@ -44,6 +44,7 @@
#include <Geom_CylindricalSurface.hxx> #include <Geom_CylindricalSurface.hxx>
#include <Geom_Plane.hxx> #include <Geom_Plane.hxx>
#include <Geom_Surface.hxx> #include <Geom_Surface.hxx>
#include <NCollection_Map.hxx>
#include <Precision.hxx> #include <Precision.hxx>
#include <TColStd_MapIteratorOfMapOfInteger.hxx> #include <TColStd_MapIteratorOfMapOfInteger.hxx>
#include <TColStd_MapOfInteger.hxx> #include <TColStd_MapOfInteger.hxx>
@ -521,11 +522,10 @@ double MaxElementLength3D::GetValue( long theElementId )
if( GetPoints( theElementId, P ) ) { if( GetPoints( theElementId, P ) ) {
double aVal = 0; double aVal = 0;
const SMDS_MeshElement* aElem = myMesh->FindElement( theElementId ); const SMDS_MeshElement* aElem = myMesh->FindElement( theElementId );
SMDSAbs_ElementType aType = aElem->GetType(); SMDSAbs_EntityType aType = aElem->GetEntityType();
int len = P.size(); int len = P.size();
switch ( aType ) { switch ( aType ) {
case SMDSAbs_Volume: case SMDSEntity_Tetra: { // tetras
if( len == 4 ) { // tetras
double L1 = getDistance(P( 1 ),P( 2 )); double L1 = getDistance(P( 1 ),P( 2 ));
double L2 = getDistance(P( 2 ),P( 3 )); double L2 = getDistance(P( 2 ),P( 3 ));
double L3 = getDistance(P( 3 ),P( 1 )); double L3 = getDistance(P( 3 ),P( 1 ));
@ -535,7 +535,7 @@ double MaxElementLength3D::GetValue( long theElementId )
aVal = Max(Max(Max(L1,L2),Max(L3,L4)),Max(L5,L6)); aVal = Max(Max(Max(L1,L2),Max(L3,L4)),Max(L5,L6));
break; break;
} }
else if( len == 5 ) { // pyramids case SMDSEntity_Pyramid: { // pyramids
double L1 = getDistance(P( 1 ),P( 2 )); double L1 = getDistance(P( 1 ),P( 2 ));
double L2 = getDistance(P( 2 ),P( 3 )); double L2 = getDistance(P( 2 ),P( 3 ));
double L3 = getDistance(P( 3 ),P( 4 )); double L3 = getDistance(P( 3 ),P( 4 ));
@ -548,7 +548,7 @@ double MaxElementLength3D::GetValue( long theElementId )
aVal = Max(aVal,Max(L7,L8)); aVal = Max(aVal,Max(L7,L8));
break; break;
} }
else if( len == 6 ) { // pentas case SMDSEntity_Penta: { // pentas
double L1 = getDistance(P( 1 ),P( 2 )); double L1 = getDistance(P( 1 ),P( 2 ));
double L2 = getDistance(P( 2 ),P( 3 )); double L2 = getDistance(P( 2 ),P( 3 ));
double L3 = getDistance(P( 3 ),P( 1 )); double L3 = getDistance(P( 3 ),P( 1 ));
@ -562,7 +562,7 @@ double MaxElementLength3D::GetValue( long theElementId )
aVal = Max(aVal,Max(Max(L7,L8),L9)); aVal = Max(aVal,Max(Max(L7,L8),L9));
break; break;
} }
else if( len == 8 ) { // hexas case SMDSEntity_Hexa: { // hexas
double L1 = getDistance(P( 1 ),P( 2 )); double L1 = getDistance(P( 1 ),P( 2 ));
double L2 = getDistance(P( 2 ),P( 3 )); double L2 = getDistance(P( 2 ),P( 3 ));
double L3 = getDistance(P( 3 ),P( 4 )); double L3 = getDistance(P( 3 ),P( 4 ));
@ -585,13 +585,13 @@ double MaxElementLength3D::GetValue( long theElementId )
aVal = Max(aVal,Max(Max(D1,D2),Max(D3,D4))); aVal = Max(aVal,Max(Max(D1,D2),Max(D3,D4)));
break; break;
} }
else if( len == 12 ) { // hexagonal prism case SMDSEntity_Hexagonal_Prism: { // hexagonal prism
for ( int i1 = 1; i1 < 12; ++i1 ) for ( int i1 = 1; i1 < 12; ++i1 )
for ( int i2 = i1+1; i1 <= 12; ++i1 ) for ( int i2 = i1+1; i1 <= 12; ++i1 )
aVal = Max( aVal, getDistance(P( i1 ),P( i2 ))); aVal = Max( aVal, getDistance(P( i1 ),P( i2 )));
break; break;
} }
else if( len == 10 ) { // quadratic tetras case SMDSEntity_Quad_Tetra: { // quadratic tetras
double L1 = getDistance(P( 1 ),P( 5 )) + getDistance(P( 5 ),P( 2 )); double L1 = getDistance(P( 1 ),P( 5 )) + getDistance(P( 5 ),P( 2 ));
double L2 = getDistance(P( 2 ),P( 6 )) + getDistance(P( 6 ),P( 3 )); double L2 = getDistance(P( 2 ),P( 6 )) + getDistance(P( 6 ),P( 3 ));
double L3 = getDistance(P( 3 ),P( 7 )) + getDistance(P( 7 ),P( 1 )); double L3 = getDistance(P( 3 ),P( 7 )) + getDistance(P( 7 ),P( 1 ));
@ -601,7 +601,7 @@ double MaxElementLength3D::GetValue( long theElementId )
aVal = Max(Max(Max(L1,L2),Max(L3,L4)),Max(L5,L6)); aVal = Max(Max(Max(L1,L2),Max(L3,L4)),Max(L5,L6));
break; break;
} }
else if( len == 13 ) { // quadratic pyramids case SMDSEntity_Quad_Pyramid: { // quadratic pyramids
double L1 = getDistance(P( 1 ),P( 6 )) + getDistance(P( 6 ),P( 2 )); double L1 = getDistance(P( 1 ),P( 6 )) + getDistance(P( 6 ),P( 2 ));
double L2 = getDistance(P( 2 ),P( 7 )) + getDistance(P( 7 ),P( 3 )); double L2 = getDistance(P( 2 ),P( 7 )) + getDistance(P( 7 ),P( 3 ));
double L3 = getDistance(P( 3 ),P( 8 )) + getDistance(P( 8 ),P( 4 )); double L3 = getDistance(P( 3 ),P( 8 )) + getDistance(P( 8 ),P( 4 ));
@ -614,7 +614,7 @@ double MaxElementLength3D::GetValue( long theElementId )
aVal = Max(aVal,Max(L7,L8)); aVal = Max(aVal,Max(L7,L8));
break; break;
} }
else if( len == 15 ) { // quadratic pentas case SMDSEntity_Quad_Penta: { // quadratic pentas
double L1 = getDistance(P( 1 ),P( 7 )) + getDistance(P( 7 ),P( 2 )); double L1 = getDistance(P( 1 ),P( 7 )) + getDistance(P( 7 ),P( 2 ));
double L2 = getDistance(P( 2 ),P( 8 )) + getDistance(P( 8 ),P( 3 )); double L2 = getDistance(P( 2 ),P( 8 )) + getDistance(P( 8 ),P( 3 ));
double L3 = getDistance(P( 3 ),P( 9 )) + getDistance(P( 9 ),P( 1 )); double L3 = getDistance(P( 3 ),P( 9 )) + getDistance(P( 9 ),P( 1 ));
@ -628,7 +628,8 @@ double MaxElementLength3D::GetValue( long theElementId )
aVal = Max(aVal,Max(Max(L7,L8),L9)); aVal = Max(aVal,Max(Max(L7,L8),L9));
break; break;
} }
else if( len == 20 || len == 27 ) { // quadratic hexas case SMDSEntity_Quad_Hexa:
case SMDSEntity_TriQuad_Hexa: { // quadratic hexas
double L1 = getDistance(P( 1 ),P( 9 )) + getDistance(P( 9 ),P( 2 )); double L1 = getDistance(P( 1 ),P( 9 )) + getDistance(P( 9 ),P( 2 ));
double L2 = getDistance(P( 2 ),P( 10 )) + getDistance(P( 10 ),P( 3 )); double L2 = getDistance(P( 2 ),P( 10 )) + getDistance(P( 10 ),P( 3 ));
double L3 = getDistance(P( 3 ),P( 11 )) + getDistance(P( 11 ),P( 4 )); double L3 = getDistance(P( 3 ),P( 11 )) + getDistance(P( 11 ),P( 4 ));
@ -651,7 +652,8 @@ double MaxElementLength3D::GetValue( long theElementId )
aVal = Max(aVal,Max(Max(D1,D2),Max(D3,D4))); aVal = Max(aVal,Max(Max(D1,D2),Max(D3,D4)));
break; break;
} }
else if( len > 1 && aElem->IsPoly() ) { // polys case SMDSEntity_Quad_Polyhedra:
case SMDSEntity_Polyhedra: { // polys
// get the maximum distance between all pairs of nodes // get the maximum distance between all pairs of nodes
for( int i = 1; i <= len; i++ ) { for( int i = 1; i <= len; i++ ) {
for( int j = 1; j <= len; j++ ) { for( int j = 1; j <= len; j++ ) {
@ -661,8 +663,23 @@ double MaxElementLength3D::GetValue( long theElementId )
} }
} }
} }
break;
} }
} case SMDSEntity_Node:
case SMDSEntity_0D:
case SMDSEntity_Edge:
case SMDSEntity_Quad_Edge:
case SMDSEntity_Triangle:
case SMDSEntity_Quad_Triangle:
case SMDSEntity_BiQuad_Triangle:
case SMDSEntity_Quadrangle:
case SMDSEntity_Quad_Quadrangle:
case SMDSEntity_BiQuad_Quadrangle:
case SMDSEntity_Polygon:
case SMDSEntity_Quad_Polygon:
case SMDSEntity_Ball:
case SMDSEntity_Last: return 0;
} // switch ( aType )
if( myPrecision >= 0 ) if( myPrecision >= 0 )
{ {
@ -701,7 +718,7 @@ double MinimumAngle::GetValue( const TSequenceOfXYZ& P )
aMin = getAngle(P( P.size() ), P( 1 ), P( 2 )); aMin = getAngle(P( P.size() ), P( 1 ), P( 2 ));
aMin = Min(aMin,getAngle(P( P.size()-1 ), P( P.size() ), P( 1 ))); aMin = Min(aMin,getAngle(P( P.size()-1 ), P( P.size() ), P( 1 )));
for ( int i = 2; i < P.size(); i++ ) for ( size_t i = 2; i < P.size(); i++ )
{ {
double A0 = getAngle( P( i-1 ), P( i ), P( i+1 ) ); double A0 = getAngle( P( i-1 ), P( i ), P( i+1 ) );
aMin = Min(aMin,A0); aMin = Min(aMin,A0);
@ -1476,7 +1493,7 @@ double Area::GetValue( const TSequenceOfXYZ& P )
gp_Vec aVec2( P(3) - P(1) ); gp_Vec aVec2( P(3) - P(1) );
gp_Vec SumVec = aVec1 ^ aVec2; gp_Vec SumVec = aVec1 ^ aVec2;
for (int i=4; i<=P.size(); i++) for (size_t i=4; i<=P.size(); i++)
{ {
gp_Vec aVec1( P(i-1) - P(1) ); gp_Vec aVec1( P(i-1) - P(1) );
gp_Vec aVec2( P(i ) - P(1) ); gp_Vec aVec2( P(i ) - P(1) );
@ -2994,6 +3011,16 @@ bool ConnectedElements::IsSatisfy( long theElementId )
*/ */
//================================================================================ //================================================================================
namespace
{
inline bool isLessAngle( const gp_Vec& v1, const gp_Vec& v2, const double cos2 )
{
double dot = v1 * v2; // cos * |v1| * |v2|
double l1 = v1.SquareMagnitude();
double l2 = v2.SquareMagnitude();
return ( dot * dot ) / l1 / l2 >= cos2;
}
}
CoplanarFaces::CoplanarFaces() CoplanarFaces::CoplanarFaces()
: myFaceID(0), myToler(0) : myFaceID(0), myToler(0)
{ {
@ -3005,7 +3032,7 @@ void CoplanarFaces::SetMesh( const SMDS_Mesh* theMesh )
{ {
// Build a set of coplanar face ids // Build a set of coplanar face ids
myCoplanarIDs.clear(); myCoplanarIDs.Clear();
if ( !myMeshModifTracer.GetMesh() || !myFaceID || !myToler ) if ( !myMeshModifTracer.GetMesh() || !myFaceID || !myToler )
return; return;
@ -3019,8 +3046,8 @@ void CoplanarFaces::SetMesh( const SMDS_Mesh* theMesh )
if (!normOK) if (!normOK)
return; return;
const double radianTol = myToler * M_PI / 180.; const double cosTol2 = Cos( myToler ) * Cos( myToler );
std::set< SMESH_TLink > checkedLinks; NCollection_Map< SMESH_TLink, SMESH_TLink > checkedLinks;
std::list< pair< const SMDS_MeshElement*, gp_Vec > > faceQueue; std::list< pair< const SMDS_MeshElement*, gp_Vec > > faceQueue;
faceQueue.push_back( make_pair( face, myNorm )); faceQueue.push_back( make_pair( face, myNorm ));
@ -3034,7 +3061,7 @@ void CoplanarFaces::SetMesh( const SMDS_Mesh* theMesh )
{ {
const SMDS_MeshNode* n1 = face->GetNode( i ); const SMDS_MeshNode* n1 = face->GetNode( i );
const SMDS_MeshNode* n2 = face->GetNode(( i+1 )%nbN); const SMDS_MeshNode* n2 = face->GetNode(( i+1 )%nbN);
if ( !checkedLinks.insert( SMESH_TLink( n1, n2 )).second ) if ( !checkedLinks.Add( SMESH_TLink( n1, n2 )))
continue; continue;
SMDS_ElemIteratorPtr fIt = n1->GetInverseElementIterator(SMDSAbs_Face); SMDS_ElemIteratorPtr fIt = n1->GetInverseElementIterator(SMDSAbs_Face);
while ( fIt->more() ) while ( fIt->more() )
@ -3043,9 +3070,9 @@ void CoplanarFaces::SetMesh( const SMDS_Mesh* theMesh )
if ( f->GetNodeIndex( n2 ) > -1 ) if ( f->GetNodeIndex( n2 ) > -1 )
{ {
gp_Vec norm = getNormale( static_cast<const SMDS_MeshFace*>(f), &normOK ); gp_Vec norm = getNormale( static_cast<const SMDS_MeshFace*>(f), &normOK );
if (!normOK || myNorm.Angle( norm ) <= radianTol) if (!normOK || isLessAngle( myNorm, norm, cosTol2))
{ {
myCoplanarIDs.insert( f->GetID() ); myCoplanarIDs.Add( f->GetID() );
faceQueue.push_back( make_pair( f, norm )); faceQueue.push_back( make_pair( f, norm ));
} }
} }
@ -3056,7 +3083,7 @@ void CoplanarFaces::SetMesh( const SMDS_Mesh* theMesh )
} }
bool CoplanarFaces::IsSatisfy( long theElementId ) bool CoplanarFaces::IsSatisfy( long theElementId )
{ {
return myCoplanarIDs.count( theElementId ); return myCoplanarIDs.Contains( theElementId );
} }
/* /*
@ -3667,7 +3694,7 @@ bool ManifoldPart::process()
myMapIds.Add( aFaceId ); myMapIds.Add( aFaceId );
} }
if ( fi == ( myAllFacePtr.size() - 1 ) ) if ( fi == int( myAllFacePtr.size() - 1 ))
fi = 0; fi = 0;
} // end run on vector of faces } // end run on vector of faces
return !myMapIds.IsEmpty(); return !myMapIds.IsEmpty();
@ -4458,6 +4485,7 @@ bool BelongToGeom::IsSatisfy (long theId)
case SMDS_TOP_FACE : return ( IsContains( myMeshDS,myShape,aNode,TopAbs_FACE )); case SMDS_TOP_FACE : return ( IsContains( myMeshDS,myShape,aNode,TopAbs_FACE ));
case SMDS_TOP_3DSPACE: return ( IsContains( myMeshDS,myShape,aNode,TopAbs_SOLID ) || case SMDS_TOP_3DSPACE: return ( IsContains( myMeshDS,myShape,aNode,TopAbs_SOLID ) ||
IsContains( myMeshDS,myShape,aNode,TopAbs_SHELL )); IsContains( myMeshDS,myShape,aNode,TopAbs_SHELL ));
default:;
} }
} }
} }
@ -4483,6 +4511,7 @@ bool BelongToGeom::IsSatisfy (long theId)
case SMDSAbs_Face : return ( IsContains( myMeshDS,myShape,anElem,TopAbs_FACE )); case SMDSAbs_Face : return ( IsContains( myMeshDS,myShape,anElem,TopAbs_FACE ));
case SMDSAbs_Volume: return ( IsContains( myMeshDS,myShape,anElem,TopAbs_SOLID )|| case SMDSAbs_Volume: return ( IsContains( myMeshDS,myShape,anElem,TopAbs_SOLID )||
IsContains( myMeshDS,myShape,anElem,TopAbs_SHELL )); IsContains( myMeshDS,myShape,anElem,TopAbs_SHELL ));
default:;
} }
} }
} }

2
src/Controls/SMESH_ControlsDef.hxx
View File

@ -1088,7 +1088,7 @@ namespace SMESH{
TMeshModifTracer myMeshModifTracer; TMeshModifTracer myMeshModifTracer;
long myFaceID; long myFaceID;
double myToler; double myToler;
std::set< long > myCoplanarIDs; TColStd_MapOfInteger myCoplanarIDs;
}; };
typedef boost::shared_ptr<CoplanarFaces> CoplanarFacesPtr; typedef boost::shared_ptr<CoplanarFaces> CoplanarFacesPtr;

15
src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx
View File

@ -500,7 +500,8 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
default:; default:;
} }
vector<TInt> aNodeIds(aNbNodes); vector<TInt> aNodeIds(aNbNodes);
for(int iElem = 0; iElem < aNbElems; iElem++){ for ( int iElem = 0; iElem < aNbElems; iElem++ )
{
bool anIsValidConnect = false; bool anIsValidConnect = false;
TCConnSlice aConnSlice = aCellInfo->GetConnSlice(iElem); TCConnSlice aConnSlice = aCellInfo->GetConnSlice(iElem);
#ifndef _DEXCEPT_ #ifndef _DEXCEPT_
@ -950,6 +951,8 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
} }
break; break;
default:;
} // switch(aGeom) } // switch(aGeom)
#ifndef _DEXCEPT_ #ifndef _DEXCEPT_
@ -977,11 +980,13 @@ Driver_Mesh::Status DriverMED_R_SMESHDS_Mesh::Perform()
myFamilies[aFamNum]->SetType(anElement->GetType()); myFamilies[aFamNum]->SetType(anElement->GetType());
} }
} }
} } // loop on aNbElems
}} }} // switch(aGeom)
} } // loop on aGeom2Size
} } // loop on aEntityInfo
if (aDescendingEntitiesMap.Extent()) isDescConn = true; // Mantis issue 0020483 if (aDescendingEntitiesMap.Extent()) isDescConn = true; // Mantis issue 0020483
} // for(int iMesh = 0; iMesh < aNbMeshes; iMesh++) } // for(int iMesh = 0; iMesh < aNbMeshes; iMesh++)
#ifndef _DEXCEPT_ #ifndef _DEXCEPT_
} }

2
src/SMESH/SMESH_Mesh.cxx
View File

@ -1349,6 +1349,8 @@ bool SMESH_Mesh::HasModificationsToDiscard() const
hasNotComputed = true; hasNotComputed = true;
if ( hasComputed && hasNotComputed) if ( hasComputed && hasNotComputed)
return true; return true;
default:;
} }
} }
if ( NbNodes() < 1 ) if ( NbNodes() < 1 )

103
src/SMESH/SMESH_MeshEditor.cxx
View File

@ -1325,7 +1325,7 @@ int SMESH_MeshEditor::Reorient2DBy3D (TIDSortedElemSet & theFaces,
if ( face->GetType() != SMDSAbs_Face ) if ( face->GetType() != SMDSAbs_Face )
continue; continue;
const int nbCornersNodes = face->NbCornerNodes(); const size_t nbCornersNodes = face->NbCornerNodes();
faceNodes.assign( face->begin_nodes(), face->end_nodes() ); faceNodes.assign( face->begin_nodes(), face->end_nodes() );
checkedVolumes.clear(); checkedVolumes.clear();
@ -1341,7 +1341,7 @@ int SMESH_MeshEditor::Reorient2DBy3D (TIDSortedElemSet & theFaces,
// is volume adjacent? // is volume adjacent?
bool allNodesCommon = true; bool allNodesCommon = true;
for ( int iN = 1; iN < nbCornersNodes && allNodesCommon; ++iN ) for ( size_t iN = 1; iN < nbCornersNodes && allNodesCommon; ++iN )
allNodesCommon = ( volume->GetNodeIndex( faceNodes[ iN ]) > -1 ); allNodesCommon = ( volume->GetNodeIndex( faceNodes[ iN ]) > -1 );
if ( !allNodesCommon ) if ( !allNodesCommon )
continue; continue;
@ -1361,7 +1361,7 @@ int SMESH_MeshEditor::Reorient2DBy3D (TIDSortedElemSet & theFaces,
for ( int i = 0; i < 2; ++i ) for ( int i = 0; i < 2; ++i )
{ {
const SMDS_MeshNode* n = facetNodes[ i*iQ ]; const SMDS_MeshNode* n = facetNodes[ i*iQ ];
for ( int iN = 0; iN < nbCornersNodes; ++iN ) for ( size_t iN = 0; iN < nbCornersNodes; ++iN )
if ( faceNodes[ iN ] == n ) if ( faceNodes[ iN ] == n )
{ {
iNN[ i ] = iN; iNN[ i ] = iN;
@ -1925,7 +1925,7 @@ namespace
if ( hasAdjacentSplits && method._nbSplits > 0 ) if ( hasAdjacentSplits && method._nbSplits > 0 )
{ {
bool facetCreated = true; bool facetCreated = true;
for ( int iF = 0; facetCreated && iF < triaSplitsByFace.size(); ++iF ) for ( size_t iF = 0; facetCreated && iF < triaSplitsByFace.size(); ++iF )
{ {
list< TTriangleFacet >::const_iterator facet = triaSplitsByFace[iF].begin(); list< TTriangleFacet >::const_iterator facet = triaSplitsByFace[iF].begin();
for ( ; facetCreated && facet != triaSplitsByFace[iF].end(); ++facet ) for ( ; facetCreated && facet != triaSplitsByFace[iF].end(); ++facet )
@ -2432,7 +2432,7 @@ void SMESH_MeshEditor::SplitVolumes (const TFacetOfElem & theElems,
volNodes[ facet->_n3 ])); volNodes[ facet->_n3 ]));
} }
} }
for ( int i = 0; i < triangles.size(); ++i ) for ( size_t i = 0; i < triangles.size(); ++i )
{ {
if ( !triangles[ i ]) continue; if ( !triangles[ i ]) continue;
if ( fSubMesh ) if ( fSubMesh )
@ -2530,7 +2530,7 @@ void SMESH_MeshEditor::GetHexaFacetsToSplit( TIDSortedElemSet& theHexas,
set<const SMDS_MeshNode*> facetNodes; set<const SMDS_MeshNode*> facetNodes;
const SMDS_MeshElement* curHex; const SMDS_MeshElement* curHex;
const bool allHex = ( theHexas.size() == myMesh->NbHexas() ); const bool allHex = ((int) theHexas.size() == myMesh->NbHexas() );
while ( startHex ) while ( startHex )
{ {
@ -2913,7 +2913,7 @@ void SMESH_MeshEditor::ReplaceElemInGroups (const SMDS_MeshElement*
for ( ; grIt != groups.end(); grIt++ ) { for ( ; grIt != groups.end(); grIt++ ) {
SMESHDS_Group* group = dynamic_cast<SMESHDS_Group*>( *grIt ); SMESHDS_Group* group = dynamic_cast<SMESHDS_Group*>( *grIt );
if ( group && group->SMDSGroup().Remove( elemToRm ) ) if ( group && group->SMDSGroup().Remove( elemToRm ) )
for ( int i = 0; i < elemToAdd.size(); ++i ) for ( size_t i = 0; i < elemToAdd.size(); ++i )
group->SMDSGroup().Add( elemToAdd[ i ] ); group->SMDSGroup().Add( elemToAdd[ i ] );
} }
} }
@ -4006,7 +4006,7 @@ void SMESH_MeshEditor::Smooth (TIDSortedElemSet & theElems,
Handle(Geom_Surface) surface; Handle(Geom_Surface) surface;
SMESHDS_SubMesh* faceSubMesh = 0; SMESHDS_SubMesh* faceSubMesh = 0;
TopoDS_Face face; TopoDS_Face face;
double fToler2 = 0, f,l; double fToler2 = 0;
double u1 = 0, u2 = 0, v1 = 0, v2 = 0; double u1 = 0, u2 = 0, v1 = 0, v2 = 0;
bool isUPeriodic = false, isVPeriodic = false; bool isUPeriodic = false, isVPeriodic = false;
if ( *fId ) if ( *fId )
@ -4492,7 +4492,7 @@ namespace
void SMESH_MeshEditor::sweepElement(const SMDS_MeshElement* elem, void SMESH_MeshEditor::sweepElement(const SMDS_MeshElement* elem,
const vector<TNodeOfNodeListMapItr> & newNodesItVec, const vector<TNodeOfNodeListMapItr> & newNodesItVec,
list<const SMDS_MeshElement*>& newElems, list<const SMDS_MeshElement*>& newElems,
const int nbSteps, const size_t nbSteps,
SMESH_SequenceOfElemPtr& srcElements) SMESH_SequenceOfElemPtr& srcElements)
{ {
//MESSAGE("sweepElement " << nbSteps); //MESSAGE("sweepElement " << nbSteps);
@ -4620,7 +4620,7 @@ void SMESH_MeshEditor::sweepElement(const SMDS_MeshElement* elem,
} }
// make new elements // make new elements
for (int iStep = 0; iStep < nbSteps; iStep++ ) for ( size_t iStep = 0; iStep < nbSteps; iStep++ )
{ {
// get next nodes // get next nodes
for ( iNode = 0; iNode < nbNodes; iNode++ ) for ( iNode = 0; iNode < nbNodes; iNode++ )
@ -5853,7 +5853,7 @@ SMESH_MeshEditor::ExtrusionSweep (TIDSortedElemSet theElemSets[2],
// source elements for each generated one // source elements for each generated one
SMESH_SequenceOfElemPtr srcElems, srcNodes; SMESH_SequenceOfElemPtr srcElems, srcNodes;
SMESHDS_Mesh* aMesh = GetMeshDS(); //SMESHDS_Mesh* aMesh = GetMeshDS();
setElemsFirst( theElemSets ); setElemsFirst( theElemSets );
const int nbSteps = theParams.NbSteps(); const int nbSteps = theParams.NbSteps();
@ -6244,21 +6244,19 @@ SMESH_MeshEditor::ExtrusionAlongTrack (TIDSortedElemSet theElements[2],
return EXTR_PATH_NOT_EDGE; return EXTR_PATH_NOT_EDGE;
TopTools_SequenceOfShape Edges; TopTools_SequenceOfShape Edges;
double x1,x2,y1,y2,z1,z2;
list< list<SMESH_MeshEditor_PathPoint> > LLPPs; list< list<SMESH_MeshEditor_PathPoint> > LLPPs;
int startNid = theN1->GetID(); int startNid = theN1->GetID();
for(int i = 1; i < aNodesList.size(); i++) { for ( size_t i = 1; i < aNodesList.size(); i++ )
x1 = aNodesList[i-1]->X();x2 = aNodesList[i]->X(); {
y1 = aNodesList[i-1]->Y();y2 = aNodesList[i]->Y(); gp_Pnt p1 = SMESH_TNodeXYZ( aNodesList[i-1] );
z1 = aNodesList[i-1]->Z();z2 = aNodesList[i]->Z(); gp_Pnt p2 = SMESH_TNodeXYZ( aNodesList[i] );
TopoDS_Edge e = BRepBuilderAPI_MakeEdge(gp_Pnt(x1,y1,z1),gp_Pnt(x2,y2,z2)); TopoDS_Edge e = BRepBuilderAPI_MakeEdge( p1, p2 );
list<SMESH_MeshEditor_PathPoint> LPP; list<SMESH_MeshEditor_PathPoint> LPP;
aPrms.clear(); aPrms.clear();
MakeEdgePathPoints(aPrms, e, (aNodesList[i-1]->GetID()==startNid), LPP); MakeEdgePathPoints(aPrms, e, (aNodesList[i-1]->GetID()==startNid), LPP);
LLPPs.push_back(LPP); LLPPs.push_back(LPP);
if ( aNodesList[i-1]->GetID() == startNid ) startNid = aNodesList[i ]->GetID(); if ( aNodesList[i-1]->GetID() == startNid ) startNid = aNodesList[i ]->GetID();
else startNid = aNodesList[i-1]->GetID(); else startNid = aNodesList[i-1]->GetID();
} }
list< list<SMESH_MeshEditor_PathPoint> >::iterator itLLPP = LLPPs.begin(); list< list<SMESH_MeshEditor_PathPoint> >::iterator itLLPP = LLPPs.begin();
@ -6278,8 +6276,7 @@ SMESH_MeshEditor::ExtrusionAlongTrack (TIDSortedElemSet theElements[2],
PP2 = currList.front(); PP2 = currList.front();
gp_Dir D1 = PP1.Tangent(); gp_Dir D1 = PP1.Tangent();
gp_Dir D2 = PP2.Tangent(); gp_Dir D2 = PP2.Tangent();
gp_Dir Dnew( gp_Vec( (D1.X()+D2.X())/2, (D1.Y()+D2.Y())/2, gp_Dir Dnew( 0.5 * ( D1.XYZ() + D2.XYZ() ));
(D1.Z()+D2.Z())/2 ) );
PP1.SetTangent(Dnew); PP1.SetTangent(Dnew);
fullList.push_back(PP1); fullList.push_back(PP1);
itPP++; itPP++;
@ -6292,7 +6289,8 @@ SMESH_MeshEditor::ExtrusionAlongTrack (TIDSortedElemSet theElements[2],
fullList.push_back(PP1); fullList.push_back(PP1);
} // Sub-shape for the Pattern must be an Edge or Wire } // Sub-shape for the Pattern must be an Edge or Wire
else if( aS.ShapeType() == TopAbs_EDGE ) { else if ( aS.ShapeType() == TopAbs_EDGE )
{
aTrackEdge = TopoDS::Edge( aS ); aTrackEdge = TopoDS::Edge( aS );
// the Edge must not be degenerated // the Edge must not be degenerated
if ( SMESH_Algo::isDegenerated( aTrackEdge ) ) if ( SMESH_Algo::isDegenerated( aTrackEdge ) )
@ -6636,7 +6634,7 @@ SMESH_MeshEditor::MakeExtrElements(TIDSortedElemSet theElemSets
// if current elem is quadratic and current node is not medium // if current elem is quadratic and current node is not medium
// we have to check - may be it is needed to insert additional nodes // we have to check - may be it is needed to insert additional nodes
list< const SMDS_MeshNode* > & listNewNodes = nIt->second; list< const SMDS_MeshNode* > & listNewNodes = nIt->second;
if ( listNewNodes.size() == aNbTP-1 ) if ((int) listNewNodes.size() == aNbTP-1 )
{ {
vector<const SMDS_MeshNode*> aNodes(2*(aNbTP-1)); vector<const SMDS_MeshNode*> aNodes(2*(aNbTP-1));
gp_XYZ P(node->X(), node->Y(), node->Z()); gp_XYZ P(node->X(), node->Y(), node->Z());
@ -6893,7 +6891,7 @@ SMESH_MeshEditor::Transform (TIDSortedElemSet & theElems,
if ( !elem ) continue; if ( !elem ) continue;
SMDSAbs_GeometryType geomType = elem->GetGeomType(); SMDSAbs_GeometryType geomType = elem->GetGeomType();
int nbNodes = elem->NbNodes(); size_t nbNodes = elem->NbNodes();
if ( geomType == SMDSGeom_NONE ) continue; // node if ( geomType == SMDSGeom_NONE ) continue; // node
nodes.resize( nbNodes ); nodes.resize( nbNodes );
@ -6931,7 +6929,7 @@ SMESH_MeshEditor::Transform (TIDSortedElemSet & theElems,
const vector<int>& i = needReverse ? iRev : iForw; const vector<int>& i = needReverse ? iRev : iForw;
// find transformed nodes // find transformed nodes
int iNode = 0; size_t iNode = 0;
SMDS_ElemIteratorPtr itN = elem->nodesIterator(); SMDS_ElemIteratorPtr itN = elem->nodesIterator();
while ( itN->more() ) { while ( itN->more() ) {
const SMDS_MeshNode* node = static_cast<const SMDS_MeshNode*>( itN->next() ); const SMDS_MeshNode* node = static_cast<const SMDS_MeshNode*>( itN->next() );
@ -9001,8 +8999,8 @@ void SMESH_MeshEditor::InsertNodesIntoLink(const SMDS_MeshElement* theElemen
// create new elements // create new elements
i1 = 0; i2 = 1; i1 = 0; i2 = 1;
for ( iSplit = 0; iSplit < nbSplits - 1; iSplit++ ) { for ( iSplit = 0; iSplit < nbSplits - 1; iSplit++ )
SMDS_MeshElement* newElem = 0; {
if ( iSplit == iBestQuad ) if ( iSplit == iBestQuad )
newElems.push_back( aMesh->AddFace (linkNodes[ i1++ ], newElems.push_back( aMesh->AddFace (linkNodes[ i1++ ],
linkNodes[ i2++ ], linkNodes[ i2++ ],
@ -11097,16 +11095,16 @@ bool SMESH_MeshEditor::DoubleNodesInRegion( const TIDSortedElemSet& theElems,
return false; return false;
const double aTol = Precision::Confusion(); const double aTol = Precision::Confusion();
auto_ptr< BRepClass3d_SolidClassifier> bsc3d; SMESHUtils::Deleter< BRepClass3d_SolidClassifier> bsc3d;
auto_ptr<_FaceClassifier> aFaceClassifier; SMESHUtils::Deleter<_FaceClassifier> aFaceClassifier;
if ( theShape.ShapeType() == TopAbs_SOLID ) if ( theShape.ShapeType() == TopAbs_SOLID )
{ {
bsc3d.reset( new BRepClass3d_SolidClassifier(theShape));; bsc3d._obj = new BRepClass3d_SolidClassifier( theShape );
bsc3d->PerformInfinitePoint(aTol); bsc3d->PerformInfinitePoint(aTol);
} }
else if (theShape.ShapeType() == TopAbs_FACE ) else if (theShape.ShapeType() == TopAbs_FACE )
{ {
aFaceClassifier.reset( new _FaceClassifier(TopoDS::Face(theShape))); aFaceClassifier._obj = new _FaceClassifier( TopoDS::Face( theShape ));
} }
// iterates on indicated elements and get elements by back references from their nodes // iterates on indicated elements and get elements by back references from their nodes
@ -11129,7 +11127,7 @@ bool SMESH_MeshEditor::DoubleNodesInRegion( const TIDSortedElemSet& theElems,
{ {
const SMDS_MeshElement* curElem = backElemItr->next(); const SMDS_MeshElement* curElem = backElemItr->next();
if ( curElem && theElems.find(curElem) == theElems.end() && if ( curElem && theElems.find(curElem) == theElems.end() &&
( bsc3d.get() ? ( bsc3d ?
isInside( curElem, *bsc3d, aTol ) : isInside( curElem, *bsc3d, aTol ) :
isInside( curElem, *aFaceClassifier, aTol ))) isInside( curElem, *aFaceClassifier, aTol )))
anAffected.insert( curElem ); anAffected.insert( curElem );
@ -11229,7 +11227,8 @@ bool SMESH_MeshEditor::DoubleNodesOnGroupBoundaries( const std::vector<TIDSorted
{ {
const SMDS_MeshElement* anElem = *elemItr; const SMDS_MeshElement* anElem = *elemItr;
int idombisdeb = idom + 1 ; int idombisdeb = idom + 1 ;
for (int idombis = idombisdeb; idombis < theElems.size(); idombis++) // check if the element belongs to a domain further in the list // check if the element belongs to a domain further in the list
for ( size_t idombis = idombisdeb; idombis < theElems.size(); idombis++ )
{ {
const TIDSortedElemSet& domainbis = theElems[idombis]; const TIDSortedElemSet& domainbis = theElems[idombis];
if ( domainbis.count( anElem )) if ( domainbis.count( anElem ))
@ -11272,7 +11271,7 @@ bool SMESH_MeshEditor::DoubleNodesOnGroupBoundaries( const std::vector<TIDSorted
if (elem && ! domain.count(elem)) // neighbor is in another domain : face is shared if (elem && ! domain.count(elem)) // neighbor is in another domain : face is shared
{ {
bool ok = false; bool ok = false;
for (int idombis = 0; idombis < theElems.size() && !ok; idombis++) // check if the neighbor belongs to another domain of the list for ( size_t idombis = 0; idombis < theElems.size() && !ok; idombis++) // check if the neighbor belongs to another domain of the list
{ {
// MESSAGE("Domain " << idombis); // MESSAGE("Domain " << idombis);
const TIDSortedElemSet& domainbis = theElems[idombis]; const TIDSortedElemSet& domainbis = theElems[idombis];
@ -11474,8 +11473,8 @@ bool SMESH_MeshEditor::DoubleNodesOnGroupBoundaries( const std::vector<TIDSorted
vector<int> vn0 = mutipleNodes[nodes[0]]; vector<int> vn0 = mutipleNodes[nodes[0]];
vector<int> vn1 = mutipleNodes[nodes[nbNodes - 1]]; vector<int> vn1 = mutipleNodes[nodes[nbNodes - 1]];
vector<int> doms; vector<int> doms;
for (int i0 = 0; i0 < vn0.size(); i0++) for ( size_t i0 = 0; i0 < vn0.size(); i0++ )
for (int i1 = 0; i1 < vn1.size(); i1++) for ( size_t i1 = 0; i1 < vn1.size(); i1++ )
if ( vn0[i0] == vn1[i1] ) if ( vn0[i0] == vn1[i1] )
doms.push_back( vn0[ i0 ]); doms.push_back( vn0[ i0 ]);
if ( doms.size() > 2 ) if ( doms.size() > 2 )
@ -11490,7 +11489,7 @@ bool SMESH_MeshEditor::DoubleNodesOnGroupBoundaries( const std::vector<TIDSorted
map<int, SMDS_VtkVolume*> domvol; // domain --> a volume with the edge map<int, SMDS_VtkVolume*> domvol; // domain --> a volume with the edge
map<int, double> angleDom; // oriented angles between planes defined by edge and volume centers map<int, double> angleDom; // oriented angles between planes defined by edge and volume centers
int nbvol = grid->GetParentVolumes(vtkVolIds, downEdgeIds[ie], edgeType[ie]); int nbvol = grid->GetParentVolumes(vtkVolIds, downEdgeIds[ie], edgeType[ie]);
for (int id=0; id < doms.size(); id++) for ( size_t id = 0; id < doms.size(); id++ )
{ {
int idom = doms[id]; int idom = doms[id];
const TIDSortedElemSet& domain = (idom == iRestDom) ? theRestDomElems : theElems[idom]; const TIDSortedElemSet& domain = (idom == iRestDom) ? theRestDomElems : theElems[idom];
@ -11616,7 +11615,7 @@ bool SMESH_MeshEditor::DoubleNodesOnGroupBoundaries( const std::vector<TIDSorted
int node = itn->first; int node = itn->first;
vector<int> orderDom = itn->second; vector<int> orderDom = itn->second;
vector<vtkIdType> orderedNodes; vector<vtkIdType> orderedNodes;
for (int idom = 0; idom <orderDom.size(); idom++) for ( size_t idom = 0; idom < orderDom.size(); idom++ )
orderedNodes.push_back( nodeDomains[ node ][ orderDom[ idom ]]); orderedNodes.push_back( nodeDomains[ node ][ orderDom[ idom ]]);
SMDS_MeshFace* face = this->GetMeshDS()->AddFaceFromVtkIds(orderedNodes); SMDS_MeshFace* face = this->GetMeshDS()->AddFaceFromVtkIds(orderedNodes);
@ -11643,9 +11642,9 @@ bool SMESH_MeshEditor::DoubleNodesOnGroupBoundaries( const std::vector<TIDSorted
if (nodes.size() == 2) if (nodes.size() == 2)
{ {
//MESSAGE(" use edgesMultiDomains " << nodes[0] << " " << nodes[1]); //MESSAGE(" use edgesMultiDomains " << nodes[0] << " " << nodes[1]);
for (int ino=0; ino < nodes.size(); ino++) for ( size_t ino = 0; ino < nodes.size(); ino++ )
if ( orderDom.size() == 3 ) if ( orderDom.size() == 3 )
for (int idom = 0; idom <orderDom.size(); idom++) for ( size_t idom = 0; idom < orderDom.size(); idom++ )
orderedNodes.push_back( nodeDomains[ nodes[ ino ]][ orderDom[ idom ]]); orderedNodes.push_back( nodeDomains[ nodes[ ino ]][ orderDom[ idom ]]);
else else
for (int idom = orderDom.size()-1; idom >=0; idom--) for (int idom = orderDom.size()-1; idom >=0; idom--)
@ -11797,7 +11796,7 @@ bool SMESH_MeshEditor::CreateFlatElementsOnFacesGroups(const std::vector<TIDSort
std::map<std::string, SMESH_Group*> mapOfJunctionGroups; std::map<std::string, SMESH_Group*> mapOfJunctionGroups;
mapOfJunctionGroups.clear(); mapOfJunctionGroups.clear();
for (int idom = 0; idom < theElems.size(); idom++) for ( size_t idom = 0; idom < theElems.size(); idom++ )
{ {
const TIDSortedElemSet& domain = theElems[idom]; const TIDSortedElemSet& domain = theElems[idom];
TIDSortedElemSet::const_iterator elemItr = domain.begin(); TIDSortedElemSet::const_iterator elemItr = domain.begin();
@ -12071,7 +12070,7 @@ void SMESH_MeshEditor::CreateHoleSkin(double radius,
else if (isNodeCoords) else if (isNodeCoords)
{ {
MESSAGE("list of nodes coordinates provided"); MESSAGE("list of nodes coordinates provided");
int i = 0; size_t i = 0;
int k = 0; int k = 0;
while ( i < nodesCoords.size()-2 ) while ( i < nodesCoords.size()-2 )
{ {
@ -12158,7 +12157,7 @@ void SMESH_MeshEditor::CreateHoleSkin(double radius,
double *coords = grid->GetPoint(pts[i]); double *coords = grid->GetPoint(pts[i]);
gp_Pnt aPoint = gp_Pnt(coords[0], coords[1], coords[2]); gp_Pnt aPoint = gp_Pnt(coords[0], coords[1], coords[2]);
distance2 = 1.E40; distance2 = 1.E40;
for (int j=0; j<gpnts.size(); j++) for ( size_t j = 0; j < gpnts.size(); j++ )
{ {
double d2 = aPoint.SquareDistance( gpnts[ j ]); double d2 = aPoint.SquareDistance( gpnts[ j ]);
if (d2 < distance2) if (d2 < distance2)
@ -12386,10 +12385,10 @@ void SMESH_MeshEditor::CreateHoleSkin(double radius,
{ {
int nodeTofind = order.back(); // try first to push back int nodeTofind = order.back(); // try first to push back
int i = 0; int i = 0;
for (i = 0; i<nodesEdges.size(); i++) for ( i = 0; i < (int)nodesEdges.size(); i++ )
if (nodesEdges[i] == nodeTofind) if (nodesEdges[i] == nodeTofind)
break; break;
if (i == nodesEdges.size()) if ( i == (int) nodesEdges.size() )
found = false; // no follower found on back found = false; // no follower found on back
else else
{ {
@ -12415,10 +12414,10 @@ void SMESH_MeshEditor::CreateHoleSkin(double radius,
// try to push front // try to push front
found = true; found = true;
nodeTofind = order.front(); // try to push front nodeTofind = order.front(); // try to push front
for (i = 0; i<nodesEdges.size(); i++) for ( i = 0; i < (int)nodesEdges.size(); i++ )
if ( nodesEdges[i] == nodeTofind ) if ( nodesEdges[i] == nodeTofind )
break; break;
if (i == nodesEdges.size()) if ( i == (int)nodesEdges.size() )
{ {
found = false; // no predecessor found on front found = false; // no predecessor found on front
continue; continue;
@ -12627,9 +12626,9 @@ int SMESH_MeshEditor::MakeBoundaryMesh(const TIDSortedElemSet& elements,
if ( missType == SMDSAbs_Edge ) // boundary edges if ( missType == SMDSAbs_Edge ) // boundary edges
{ {
nodes.resize( 2+iQuad ); nodes.resize( 2+iQuad );
for ( int i = 0; i < nbFaceNodes; i += 1+iQuad) for ( size_t i = 0; i < nbFaceNodes; i += 1+iQuad )
{ {
for ( int j = 0; j < nodes.size(); ++j ) for ( size_t j = 0; j < nodes.size(); ++j )
nodes[ j ] = nn[ i+j ]; nodes[ j ] = nn[ i+j ];
if ( const SMDS_MeshElement* edge = if ( const SMDS_MeshElement* edge =
aMesh->FindElement( nodes, SMDSAbs_Edge, /*noMedium=*/false )) aMesh->FindElement( nodes, SMDSAbs_Edge, /*noMedium=*/false ))
@ -12717,7 +12716,7 @@ int SMESH_MeshEditor::MakeBoundaryMesh(const TIDSortedElemSet& elements,
++nbAddedBnd; ++nbAddedBnd;
} }
else else
for ( int i = 0; i < missingBndElems.size(); ++i ) for ( size_t i = 0; i < missingBndElems.size(); ++i )
{ {
TConnectivity& nodes = missingBndElems[ i ]; TConnectivity& nodes = missingBndElems[ i ];
if ( aroundElements && tgtEditor.GetMeshDS()->FindElement( nodes, if ( aroundElements && tgtEditor.GetMeshDS()->FindElement( nodes,
@ -12761,16 +12760,16 @@ int SMESH_MeshEditor::MakeBoundaryMesh(const TIDSortedElemSet& elements,
// 3. Copy present boundary elements // 3. Copy present boundary elements
// ---------------------------------- // ----------------------------------
if ( toCopyExistingBoundary ) if ( toCopyExistingBoundary )
for ( int i = 0 ; i < presentBndElems.size(); ++i ) for ( size_t i = 0 ; i < presentBndElems.size(); ++i )
{ {
const SMDS_MeshElement* e = presentBndElems[i]; const SMDS_MeshElement* e = presentBndElems[i];
tgtNodes.resize( e->NbNodes() ); tgtNodes.resize( e->NbNodes() );
for ( inode = 0; inode < nodes.size(); ++inode ) for ( inode = 0; inode < tgtNodes.size(); ++inode )
tgtNodes[inode] = getNodeWithSameID( tgtMeshDS, e->GetNode(inode) ); tgtNodes[inode] = getNodeWithSameID( tgtMeshDS, e->GetNode(inode) );
presentEditor->AddElement( tgtNodes, elemToCopy.Init( e )); presentEditor->AddElement( tgtNodes, elemToCopy.Init( e ));
} }
else // store present elements to add them to a group else // store present elements to add them to a group
for ( int i = 0 ; i < presentBndElems.size(); ++i ) for ( size_t i = 0 ; i < presentBndElems.size(); ++i )
{ {
presentEditor->myLastCreatedElems.Append( presentBndElems[ i ]); presentEditor->myLastCreatedElems.Append( presentBndElems[ i ]);
} }

2
src/SMESH/SMESH_MeshEditor.hxx
View File

@ -730,7 +730,7 @@ public:
void sweepElement(const SMDS_MeshElement* elem, void sweepElement(const SMDS_MeshElement* elem,
const std::vector<TNodeOfNodeListMapItr> & newNodesItVec, const std::vector<TNodeOfNodeListMapItr> & newNodesItVec,
std::list<const SMDS_MeshElement*>& newElems, std::list<const SMDS_MeshElement*>& newElems,
const int nbSteps, const size_t nbSteps,
SMESH_SequenceOfElemPtr& srcElements); SMESH_SequenceOfElemPtr& srcElements);
/*! /*!

62
src/SMESH/SMESH_MesherHelper.cxx
View File

@ -139,7 +139,7 @@ bool SMESH_MesherHelper::IsQuadraticSubMesh(const TopoDS_Shape& aSh)
SMDSAbs_ElementType elemType( subType==TopAbs_FACE ? SMDSAbs_Face : SMDSAbs_Edge ); SMDSAbs_ElementType elemType( subType==TopAbs_FACE ? SMDSAbs_Face : SMDSAbs_Edge );
int nbOldLinks = myTLinkNodeMap.size(); //int nbOldLinks = myTLinkNodeMap.size();
if ( !myMesh->HasShapeToMesh() ) if ( !myMesh->HasShapeToMesh() )
{ {
@ -2070,7 +2070,7 @@ SMDS_MeshFace* SMESH_MesherHelper::AddPolygonalFace (const vector<const SMDS_Mes
{ {
vector<const SMDS_MeshNode*> newNodes( nodes.size() * 2 ); vector<const SMDS_MeshNode*> newNodes( nodes.size() * 2 );
newNodes = nodes; newNodes = nodes;
for ( int i = 0; i < nodes.size(); ++i ) for ( size_t i = 0; i < nodes.size(); ++i )
{ {
const SMDS_MeshNode* n1 = nodes[i]; const SMDS_MeshNode* n1 = nodes[i];
const SMDS_MeshNode* n2 = nodes[(i+1)%nodes.size()]; const SMDS_MeshNode* n2 = nodes[(i+1)%nodes.size()];
@ -2393,7 +2393,7 @@ SMESH_MesherHelper::AddPolyhedralVolume (const std::vector<const SMDS_MeshNode*>
{ {
vector<const SMDS_MeshNode*> newNodes; vector<const SMDS_MeshNode*> newNodes;
vector<int> newQuantities; vector<int> newQuantities;
for ( int iFace=0, iN=0; iFace < quantities.size(); ++iFace) for ( size_t iFace = 0, iN = 0; iFace < quantities.size(); ++iFace )
{ {
int nbNodesInFace = quantities[iFace]; int nbNodesInFace = quantities[iFace];
newQuantities.push_back(0); newQuantities.push_back(0);
@ -2606,8 +2606,8 @@ bool SMESH_MesherHelper::LoadNodeColumns(TParam2ColumnMap & theParam2
} }
// nb rows of nodes // nb rows of nodes
int prevNbRows = theParam2ColumnMap.begin()->second.size(); // current, at least 1 here size_t prevNbRows = theParam2ColumnMap.begin()->second.size(); // current, at least 1 here
int expectedNbRows = faceSubMesh->NbElements() / ( theParam2ColumnMap.size()-1 ); // to be added size_t expectNbRows = faceSubMesh->NbElements() / ( theParam2ColumnMap.size()-1 ); // to be added
// fill theParam2ColumnMap column by column by passing from nodes on // fill theParam2ColumnMap column by column by passing from nodes on
// theBaseEdge up via mesh faces on theFace // theBaseEdge up via mesh faces on theFace
@ -2620,10 +2620,10 @@ bool SMESH_MesherHelper::LoadNodeColumns(TParam2ColumnMap & theParam2
{ {
vector<const SMDS_MeshNode*>& nCol1 = par_nVec_1->second; vector<const SMDS_MeshNode*>& nCol1 = par_nVec_1->second;
vector<const SMDS_MeshNode*>& nCol2 = par_nVec_2->second; vector<const SMDS_MeshNode*>& nCol2 = par_nVec_2->second;
nCol1.resize( prevNbRows + expectedNbRows ); nCol1.resize( prevNbRows + expectNbRows );
nCol2.resize( prevNbRows + expectedNbRows ); nCol2.resize( prevNbRows + expectNbRows );
int i1, i2, foundNbRows = 0; int i1, i2; size_t foundNbRows = 0;
const SMDS_MeshNode *n1 = nCol1[ prevNbRows-1 ]; const SMDS_MeshNode *n1 = nCol1[ prevNbRows-1 ];
const SMDS_MeshNode *n2 = nCol2[ prevNbRows-1 ]; const SMDS_MeshNode *n2 = nCol2[ prevNbRows-1 ];
// find face sharing node n1 and n2 and belonging to faceSubMesh // find face sharing node n1 and n2 and belonging to faceSubMesh
@ -2635,7 +2635,7 @@ bool SMESH_MesherHelper::LoadNodeColumns(TParam2ColumnMap & theParam2
int nbNodes = face->NbCornerNodes(); int nbNodes = face->NbCornerNodes();
if ( nbNodes != 4 ) if ( nbNodes != 4 )
return false; return false;
if ( foundNbRows + 1 > expectedNbRows ) if ( foundNbRows + 1 > expectNbRows )
return false; return false;
n1 = face->GetNode( (i2+2) % 4 ); // opposite corner of quadrangle face n1 = face->GetNode( (i2+2) % 4 ); // opposite corner of quadrangle face
n2 = face->GetNode( (i1+2) % 4 ); n2 = face->GetNode( (i1+2) % 4 );
@ -2645,12 +2645,12 @@ bool SMESH_MesherHelper::LoadNodeColumns(TParam2ColumnMap & theParam2
} }
avoidSet.insert( face ); avoidSet.insert( face );
} }
if ( foundNbRows != expectedNbRows ) if ((size_t) foundNbRows != expectNbRows )
return false; return false;
avoidSet.clear(); avoidSet.clear();
} }
return ( theParam2ColumnMap.size() > 1 && return ( theParam2ColumnMap.size() > 1 &&
theParam2ColumnMap.begin()->second.size() == prevNbRows + expectedNbRows ); theParam2ColumnMap.begin()->second.size() == prevNbRows + expectNbRows );
} }
namespace namespace
@ -3553,11 +3553,11 @@ namespace { // Structures used by FixQuadraticElements()
int NbVolumes() const { return !_volumes[0] ? 0 : !_volumes[1] ? 1 : 2; } int NbVolumes() const { return !_volumes[0] ? 0 : !_volumes[1] ? 1 : 2; }
void AddSelfToLinks() const { void AddSelfToLinks() const {
for ( int i = 0; i < _sides.size(); ++i ) for ( size_t i = 0; i < _sides.size(); ++i )
_sides[i]->_faces.push_back( this ); _sides[i]->_faces.push_back( this );
} }
int LinkIndex( const QLink* side ) const { int LinkIndex( const QLink* side ) const {
for (int i=0; i<_sides.size(); ++i ) if ( _sides[i] == side ) return i; for (size_t i = 0; i<_sides.size(); ++i ) if ( _sides[i] == side ) return i;
return -1; return -1;
} }
bool GetLinkChain( int iSide, TChain& chain, SMDS_TypeOfPosition pos, int& err) const; bool GetLinkChain( int iSide, TChain& chain, SMDS_TypeOfPosition pos, int& err) const;
@ -3589,7 +3589,7 @@ namespace { // Structures used by FixQuadraticElements()
const SMDS_MeshNode* nodeToContain) const; const SMDS_MeshNode* nodeToContain) const;
const SMDS_MeshNode* GetNodeInFace() const { const SMDS_MeshNode* GetNodeInFace() const {
for ( int iL = 0; iL < _sides.size(); ++iL ) for ( size_t iL = 0; iL < _sides.size(); ++iL )
if ( _sides[iL]->MediumPos() == SMDS_TOP_FACE ) return _sides[iL]->_mediumNode; if ( _sides[iL]->MediumPos() == SMDS_TOP_FACE ) return _sides[iL]->_mediumNode;
return 0; return 0;
} }
@ -3642,7 +3642,7 @@ namespace { // Structures used by FixQuadraticElements()
_sides = links; _sides = links;
_sideIsAdded[0]=_sideIsAdded[1]=_sideIsAdded[2]=_sideIsAdded[3]=false; _sideIsAdded[0]=_sideIsAdded[1]=_sideIsAdded[2]=_sideIsAdded[3]=false;
_normal.SetCoord(0,0,0); _normal.SetCoord(0,0,0);
for ( int i = 1; i < _sides.size(); ++i ) { for ( size_t i = 1; i < _sides.size(); ++i ) {
const QLink *l1 = _sides[i-1], *l2 = _sides[i]; const QLink *l1 = _sides[i-1], *l2 = _sides[i];
insert( l1->node1() ); insert( l1->node2() ); insert( l1->node1() ); insert( l1->node2() );
// compute normal // compute normal
@ -3676,7 +3676,7 @@ namespace { // Structures used by FixQuadraticElements()
bool QFace::GetLinkChain( int iSide, TChain& chain, SMDS_TypeOfPosition pos, int& error) const bool QFace::GetLinkChain( int iSide, TChain& chain, SMDS_TypeOfPosition pos, int& error) const
{ {
if ( iSide >= _sides.size() ) // wrong argument iSide if ( iSide >= (int)_sides.size() ) // wrong argument iSide
return false; return false;
if ( _sideIsAdded[ iSide ]) // already in chain if ( _sideIsAdded[ iSide ]) // already in chain
return true; return true;
@ -3687,7 +3687,7 @@ namespace { // Structures used by FixQuadraticElements()
list< const QFace* > faces( 1, this ); list< const QFace* > faces( 1, this );
while ( !faces.empty() ) { while ( !faces.empty() ) {
const QFace* face = faces.front(); const QFace* face = faces.front();
for ( int i = 0; i < face->_sides.size(); ++i ) { for ( size_t i = 0; i < face->_sides.size(); ++i ) {
if ( !face->_sideIsAdded[i] && face->_sides[i] ) { if ( !face->_sideIsAdded[i] && face->_sides[i] ) {
face->_sideIsAdded[i] = true; face->_sideIsAdded[i] = true;
// find a face side in the chain // find a face side in the chain
@ -3770,7 +3770,7 @@ namespace { // Structures used by FixQuadraticElements()
typedef list< pair< const QFace*, TLinkInSet > > TFaceLinkList; typedef list< pair< const QFace*, TLinkInSet > > TFaceLinkList;
TFaceLinkList adjacentFaces; TFaceLinkList adjacentFaces;
for ( int iL = 0; iL < _sides.size(); ++iL ) for ( size_t iL = 0; iL < _sides.size(); ++iL )
{ {
if ( avoidLink._qlink == _sides[iL] ) if ( avoidLink._qlink == _sides[iL] )
continue; continue;
@ -3823,7 +3823,7 @@ namespace { // Structures used by FixQuadraticElements()
const TChainLink& avoidLink, const TChainLink& avoidLink,
const SMDS_MeshNode* nodeToContain) const const SMDS_MeshNode* nodeToContain) const
{ {
for ( int i = 0; i < _sides.size(); ++i ) for ( size_t i = 0; i < _sides.size(); ++i )
if ( avoidLink._qlink != _sides[i] && if ( avoidLink._qlink != _sides[i] &&
(_sides[i]->node1() == nodeToContain || _sides[i]->node2() == nodeToContain )) (_sides[i]->node1() == nodeToContain || _sides[i]->node2() == nodeToContain ))
return links.find( _sides[i] ); return links.find( _sides[i] );
@ -3877,7 +3877,7 @@ namespace { // Structures used by FixQuadraticElements()
if ( !theStep ) if ( !theStep )
return thePrevLen; // propagation limit reached return thePrevLen; // propagation limit reached
int iL; // index of theLink size_t iL; // index of theLink
for ( iL = 0; iL < _sides.size(); ++iL ) for ( iL = 0; iL < _sides.size(); ++iL )
if ( theLink._qlink == _sides[ iL ]) if ( theLink._qlink == _sides[ iL ])
break; break;
@ -4017,7 +4017,7 @@ namespace { // Structures used by FixQuadraticElements()
int iFaceCont = -1, nbBoundary = 0, iBoundary[2]={-1,-1}; int iFaceCont = -1, nbBoundary = 0, iBoundary[2]={-1,-1};
if ( _faces[0]->IsBoundary() ) if ( _faces[0]->IsBoundary() )
iBoundary[ nbBoundary++ ] = 0; iBoundary[ nbBoundary++ ] = 0;
for ( int iF = 1; iFaceCont < 0 && iF < _faces.size(); ++iF ) for ( size_t iF = 1; iFaceCont < 0 && iF < _faces.size(); ++iF )
{ {
// look for a face bounding none of volumes bound by _faces[0] // look for a face bounding none of volumes bound by _faces[0]
bool sameVol = false; bool sameVol = false;
@ -4059,10 +4059,10 @@ namespace { // Structures used by FixQuadraticElements()
const QFace* QLink::GetContinuesFace( const QFace* face ) const const QFace* QLink::GetContinuesFace( const QFace* face ) const
{ {
for ( int i = 0; i < _faces.size(); ++i ) { for ( size_t i = 0; i < _faces.size(); ++i ) {
if ( _faces[i] == face ) { if ( _faces[i] == face ) {
int iF = i < 2 ? 1-i : 5-i; int iF = i < 2 ? 1-i : 5-i;
return iF < _faces.size() ? _faces[iF] : 0; return iF < (int)_faces.size() ? _faces[iF] : 0;
} }
} }
return 0; return 0;
@ -4075,7 +4075,7 @@ namespace { // Structures used by FixQuadraticElements()
bool QLink::OnBoundary() const bool QLink::OnBoundary() const
{ {
for ( int i = 0; i < _faces.size(); ++i ) for ( size_t i = 0; i < _faces.size(); ++i )
if (_faces[i] && _faces[i]->IsBoundary()) return true; if (_faces[i] && _faces[i]->IsBoundary()) return true;
return false; return false;
} }
@ -4144,7 +4144,7 @@ namespace { // Structures used by FixQuadraticElements()
for ( ; bnd != bndEnd; ++bnd ) for ( ; bnd != bndEnd; ++bnd )
{ {
const QLink* bndLink = *bnd; const QLink* bndLink = *bnd;
for ( int i = 0; i < bndLink->_faces.size(); ++i ) // loop on faces of bndLink for ( size_t i = 0; i < bndLink->_faces.size(); ++i ) // loop on faces of bndLink
{ {
const QFace* face = bndLink->_faces[i]; // quadrange lateral face of a prism const QFace* face = bndLink->_faces[i]; // quadrange lateral face of a prism
if ( !face ) continue; if ( !face ) continue;
@ -4211,7 +4211,7 @@ namespace { // Structures used by FixQuadraticElements()
{ {
// put links in the set and evalute number of result chains by number of boundary links // put links in the set and evalute number of result chains by number of boundary links
TLinkSet linkSet; TLinkSet linkSet;
int nbBndLinks = 0; size_t nbBndLinks = 0;
for ( TChain::iterator lnk = allLinks.begin(); lnk != allLinks.end(); ++lnk ) { for ( TChain::iterator lnk = allLinks.begin(); lnk != allLinks.end(); ++lnk ) {
linkSet.insert( *lnk ); linkSet.insert( *lnk );
nbBndLinks += lnk->IsBoundary(); nbBndLinks += lnk->IsBoundary();
@ -4260,7 +4260,7 @@ namespace { // Structures used by FixQuadraticElements()
TLinkInSet botLink = startLink; // current horizontal link to go up from TLinkInSet botLink = startLink; // current horizontal link to go up from
corner = startCorner; // current corner the botLink ends at corner = startCorner; // current corner the botLink ends at
int iRow = 0; size_t iRow = 0;
while ( botLink != linksEnd ) // loop on rows while ( botLink != linksEnd ) // loop on rows
{ {
// add botLink to the columnChain // add botLink to the columnChain
@ -4357,7 +4357,7 @@ namespace { // Structures used by FixQuadraticElements()
// In the linkSet, there must remain the last links of rowChains; add them // In the linkSet, there must remain the last links of rowChains; add them
if ( linkSet.size() != rowChains.size() ) if ( linkSet.size() != rowChains.size() )
return _BAD_SET_SIZE; return _BAD_SET_SIZE;
for ( int iRow = 0; iRow < rowChains.size(); ++iRow ) { for ( size_t iRow = 0; iRow < rowChains.size(); ++iRow ) {
// find the link (startLink) ending at startCorner // find the link (startLink) ending at startCorner
corner = 0; corner = 0;
for ( startLink = linkSet.begin(); startLink != linksEnd; ++startLink ) { for ( startLink = linkSet.begin(); startLink != linksEnd; ++startLink ) {
@ -4449,6 +4449,7 @@ namespace { // Structures used by FixQuadraticElements()
{ {
continue; continue;
} }
default:;
} }
// get nodes shared by faces that may be distorted // get nodes shared by faces that may be distorted
SMDS_NodeIteratorPtr nodeIt; SMDS_NodeIteratorPtr nodeIt;
@ -4562,6 +4563,7 @@ namespace { // Structures used by FixQuadraticElements()
{ {
concaveFaces.push_back( face ); concaveFaces.push_back( face );
} }
default:;
} }
} }
if ( concaveFaces.empty() ) if ( concaveFaces.empty() )
@ -4627,7 +4629,7 @@ namespace { // Structures used by FixQuadraticElements()
while ( volIt->more() ) while ( volIt->more() )
{ {
const SMDS_MeshElement* vol = volIt->next(); const SMDS_MeshElement* vol = volIt->next();
int nbN = vol->NbCornerNodes(); size_t nbN = vol->NbCornerNodes();
if ( ( nbN != 4 && nbN != 5 ) || if ( ( nbN != 4 && nbN != 5 ) ||
!solidSM->Contains( vol ) || !solidSM->Contains( vol ) ||
!checkedVols.insert( vol ).second ) !checkedVols.insert( vol ).second )
@ -4957,7 +4959,7 @@ void SMESH_MesherHelper::FixQuadraticElements(SMESH_ComputeErrorPtr& compError,
else { else {
continue; continue;
} }
for ( int iC = 0; iC < chains.size(); ++iC ) for ( size_t iC = 0; iC < chains.size(); ++iC )
{ {
TChain& chain = chains[iC]; TChain& chain = chains[iC];
if ( chain.empty() ) continue; if ( chain.empty() ) continue;

28
src/SMESH/SMESH_Pattern.cxx
View File

@ -792,7 +792,7 @@ bool SMESH_Pattern::Load (SMESH_Mesh* theMesh,
double u = epos->GetUParameter(); double u = epos->GetUParameter();
paramNodeMap.insert( make_pair( u, node )); paramNodeMap.insert( make_pair( u, node ));
} }
if ( paramNodeMap.size() != eSubMesh->NbNodes() ) { if ((int) paramNodeMap.size() != eSubMesh->NbNodes() ) {
// wrong U on edge, project // wrong U on edge, project
Extrema_ExtPC proj; Extrema_ExtPC proj;
BRepAdaptor_Curve aCurve( edge ); BRepAdaptor_Curve aCurve( edge );
@ -818,7 +818,7 @@ bool SMESH_Pattern::Load (SMESH_Mesh* theMesh,
} }
//rnv : To fix the bug IPAL21999 Pattern Mapping - New - collapse of pattern mesh //rnv : To fix the bug IPAL21999 Pattern Mapping - New - collapse of pattern mesh
if ( paramNodeMap.size() != eSubMesh->NbNodes() - nbMeduimNodes ) if ((int) paramNodeMap.size() != eSubMesh->NbNodes() - nbMeduimNodes )
return setErrorCode(ERR_UNEXPECTED); return setErrorCode(ERR_UNEXPECTED);
} }
@ -1206,7 +1206,7 @@ struct TIsoNode {
TIsoNode* myNext[4]; // order: (iDir=0,isForward=0), (1,0), (0,1), (1,1) TIsoNode* myNext[4]; // order: (iDir=0,isForward=0), (1,0), (0,1), (1,1)
TIsoNode* myBndNodes[4]; // order: (iDir=0,i=0), (1,0), (0,1), (1,1) TIsoNode* myBndNodes[4]; // order: (iDir=0,i=0), (1,0), (0,1), (1,1)
TIsoNode(double initU, double initV): TIsoNode(double initU, double initV):
myInitUV( initU, initV ), myUV( 1e100, 1e100 ), myIsMovable(true) myIsMovable(true), myInitUV( initU, initV ), myUV( 1e100, 1e100 )
{ myNext[0] = myNext[1] = myNext[2] = myNext[3] = 0; } { myNext[0] = myNext[1] = myNext[2] = myNext[3] = 0; }
bool IsUVComputed() const bool IsUVComputed() const
{ return myUV.X() != 1e100; } { return myUV.X() != 1e100; }
@ -2425,7 +2425,7 @@ bool SMESH_Pattern::Apply (const TopoDS_Face& theFace,
int nbVertices = loadVE( eList, myShapeIDMap ); int nbVertices = loadVE( eList, myShapeIDMap );
myShapeIDMap.Add( face ); myShapeIDMap.Add( face );
if ( myShapeIDToPointsMap.size() != myShapeIDMap.Extent() ) { if ((int) myShapeIDToPointsMap.size() != myShapeIDMap.Extent() ) {
MESSAGE( myShapeIDToPointsMap.size() <<" != " << myShapeIDMap.Extent()); MESSAGE( myShapeIDToPointsMap.size() <<" != " << myShapeIDMap.Extent());
return setErrorCode( ERR_APPLF_INTERNAL_EEROR ); return setErrorCode( ERR_APPLF_INTERNAL_EEROR );
} }
@ -2501,7 +2501,7 @@ bool SMESH_Pattern::Apply (const TopoDS_Face& theFace,
while ( wlIt != wireList.end() ) while ( wlIt != wireList.end() )
{ {
list< TopoDS_Edge >& wire = (*wlIt); list< TopoDS_Edge >& wire = (*wlIt);
int nbEdges = wire.size(); size_t nbEdges = wire.size();
wlIt++; wlIt++;
if ( wlIt != wireList.end() && (*wlIt).size() != nbEdges ) // a unique size wire if ( wlIt != wireList.end() && (*wlIt).size() != nbEdges ) // a unique size wire
{ {
@ -2528,7 +2528,7 @@ bool SMESH_Pattern::Apply (const TopoDS_Face& theFace,
wlIt = wireList.begin(); wlIt = wireList.begin();
while ( wlIt != wireList.end() ) while ( wlIt != wireList.end() )
{ {
int nbSameSize = 0, nbEdges = (*wlIt).size(); size_t nbSameSize = 0, nbEdges = (*wlIt).size();
list< list< TopoDS_Edge > >::iterator wlIt2 = wlIt; list< list< TopoDS_Edge > >::iterator wlIt2 = wlIt;
wlIt2++; wlIt2++;
while ( wlIt2 != wireList.end() && (*wlIt2).size() == nbEdges ) { // a same size wire while ( wlIt2 != wireList.end() && (*wlIt2).size() == nbEdges ) { // a same size wire
@ -2867,7 +2867,7 @@ bool SMESH_Pattern::Apply (SMESH_Mesh* theMesh,
// compute UV and XYZ of points on edges // compute UV and XYZ of points on edges
for ( int i = 0; i < myOrderedNodes.size(); ++i, ++iSub ) for ( size_t i = 0; i < myOrderedNodes.size(); ++i, ++iSub )
{ {
gp_XY& uv1 = keyUV[ i ]; gp_XY& uv1 = keyUV[ i ];
gp_XY& uv2 = ( i+1 < keyUV.size() ) ? keyUV[ i+1 ] : keyUV[ 0 ]; gp_XY& uv2 = ( i+1 < keyUV.size() ) ? keyUV[ i+1 ] : keyUV[ 0 ];
@ -3104,7 +3104,7 @@ bool SMESH_Pattern::Apply (std::set<const SMDS_MeshVolume*> & theVolumes,
// to find point index // to find point index
map< TPoint*, int > pointIndex; map< TPoint*, int > pointIndex;
for ( int i = 0; i < myPoints.size(); i++ ) for ( size_t i = 0; i < myPoints.size(); i++ )
pointIndex.insert( make_pair( & myPoints[ i ], i )); pointIndex.insert( make_pair( & myPoints[ i ], i ));
int ind1 = 0; // lowest point index for an element int ind1 = 0; // lowest point index for an element
@ -4014,7 +4014,7 @@ bool SMESH_Pattern::MakeMesh(SMESH_Mesh* theMesh,
for ( ; i_node != myXYZIdToNodeMap.end(); i_node++ ) { for ( ; i_node != myXYZIdToNodeMap.end(); i_node++ ) {
nodesVector[ i_node->first ] = i_node->second; nodesVector[ i_node->first ] = i_node->second;
} }
for ( int i = 0; i < myXYZ.size(); ++i ) { for ( size_t i = 0; i < myXYZ.size(); ++i ) {
if ( !nodesVector[ i ] && isDefined( myXYZ[ i ] ) ) if ( !nodesVector[ i ] && isDefined( myXYZ[ i ] ) )
nodesVector[ i ] = aMeshDS->AddNode (myXYZ[ i ].X(), nodesVector[ i ] = aMeshDS->AddNode (myXYZ[ i ].X(),
myXYZ[ i ].Y(), myXYZ[ i ].Y(),
@ -4184,7 +4184,7 @@ void SMESH_Pattern::createElements(SMESH_Mesh* theMes
groups.resize( theElements.size() ); groups.resize( theElements.size() );
const set<SMESHDS_GroupBase*>& allGroups = aMeshDS->GetGroups(); const set<SMESHDS_GroupBase*>& allGroups = aMeshDS->GetGroups();
set<SMESHDS_GroupBase*>::const_iterator grIt; set<SMESHDS_GroupBase*>::const_iterator grIt;
for ( int i = 0; i < theElements.size(); i++ ) for ( size_t i = 0; i < theElements.size(); i++ )
{ {
shapeIDs[ i ] = editor.FindShape( theElements[ i ] ); shapeIDs[ i ] = editor.FindShape( theElements[ i ] );
for ( grIt = allGroups.begin(); grIt != allGroups.end(); grIt++ ) { for ( grIt = allGroups.begin(); grIt != allGroups.end(); grIt++ ) {
@ -4226,7 +4226,7 @@ void SMESH_Pattern::createElements(SMESH_Mesh* theMes
TElemDef::const_iterator id = elemNodeInd.begin(); TElemDef::const_iterator id = elemNodeInd.begin();
int nbNodes; int nbNodes;
for ( nbNodes = 0; id != elemNodeInd.end(); id++ ) { for ( nbNodes = 0; id != elemNodeInd.end(); id++ ) {
if ( *id < theNodesVector.size() ) if ( *id < (int) theNodesVector.size() )
nodes[ nbNodes++ ] = theNodesVector[ *id ]; nodes[ nbNodes++ ] = theNodesVector[ *id ];
else else
nodes[ nbNodes++ ] = myXYZIdToNodeMap[ *id ]; nodes[ nbNodes++ ] = myXYZIdToNodeMap[ *id ];
@ -4325,7 +4325,7 @@ void SMESH_Pattern::createElements(SMESH_Mesh* theMes
} }
if ( onMeshElements ) { if ( onMeshElements ) {
list< int > elemIDs; list< int > elemIDs;
for ( int i = 0; i < theElements.size(); i++ ) for ( size_t i = 0; i < theElements.size(); i++ )
{ {
subMesh = theMesh->GetSubMeshContaining( shapeIDs[ i ] ); subMesh = theMesh->GetSubMeshContaining( shapeIDs[ i ] );
if ( subMesh ) if ( subMesh )
@ -4354,7 +4354,7 @@ bool SMESH_Pattern::isReversed(const SMDS_MeshNode* theFirstNode,
gp_Pnt P[2]; gp_Pnt P[2];
list<int>::const_iterator id = theIdsList.begin(); list<int>::const_iterator id = theIdsList.begin();
for ( int i = 0; i < 2; ++i, ++id ) { for ( int i = 0; i < 2; ++i, ++id ) {
if ( *id < myXYZ.size() ) if ( *id < (int) myXYZ.size() )
P[ i ] = myXYZ[ *id ]; P[ i ] = myXYZ[ *id ];
else { else {
map< int, const SMDS_MeshNode*>::const_iterator i_n; map< int, const SMDS_MeshNode*>::const_iterator i_n;
@ -4790,7 +4790,7 @@ bool SMESH_Pattern::setShapeToMesh(const TopoDS_Shape& theShape)
// check nb of vertices // check nb of vertices
TopTools_IndexedMapOfShape vMap; TopTools_IndexedMapOfShape vMap;
TopExp::MapShapes( theShape, TopAbs_VERTEX, vMap ); TopExp::MapShapes( theShape, TopAbs_VERTEX, vMap );
if ( vMap.Extent() + nbNodeOnSeamEdge != myKeyPointIDs.size() ) { if ( vMap.Extent() + nbNodeOnSeamEdge != (int)myKeyPointIDs.size() ) {
MESSAGE( myKeyPointIDs.size() + nbNodeOnSeamEdge << " != " << vMap.Extent() ); MESSAGE( myKeyPointIDs.size() + nbNodeOnSeamEdge << " != " << vMap.Extent() );
return setErrorCode( ERR_APPL_BAD_NB_VERTICES ); return setErrorCode( ERR_APPL_BAD_NB_VERTICES );
} }

44
src/SMESHClient/SMESH_Client.cxx
View File

@ -90,7 +90,7 @@ namespace
const SMESH::double_array& aCoords = theSeq[theId].coords; const SMESH::double_array& aCoords = theSeq[theId].coords;
const SMESH::long_array& anIndexes = theSeq[theId].indexes; const SMESH::long_array& anIndexes = theSeq[theId].indexes;
CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number; CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
if(3*aNbElems != aCoords.length()) if(3*aNbElems != (CORBA::Long) aCoords.length())
EXCEPTION(runtime_error,"AddNodesWithID - 3*aNbElems != aCoords.length()"); EXCEPTION(runtime_error,"AddNodesWithID - 3*aNbElems != aCoords.length()");
for(CORBA::Long aCoordId = 0; anElemId < aNbElems; anElemId++, aCoordId+=3){ for(CORBA::Long aCoordId = 0; anElemId < aNbElems; anElemId++, aCoordId+=3){
SMDS_MeshElement* anElem = theMesh->AddNodeWithID(aCoords[aCoordId], SMDS_MeshElement* anElem = theMesh->AddNodeWithID(aCoords[aCoordId],
@ -112,7 +112,7 @@ namespace
{ {
const SMESH::long_array& anIndexes = theSeq[theId].indexes; const SMESH::long_array& anIndexes = theSeq[theId].indexes;
CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number; CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
if (2*aNbElems != anIndexes.length()) if (2*aNbElems != (CORBA::Long) anIndexes.length())
EXCEPTION(runtime_error,"AddEdgeWithID - 2*aNbElems != aCoords.length()"); EXCEPTION(runtime_error,"AddEdgeWithID - 2*aNbElems != aCoords.length()");
CORBA::Long anIndexId = 0; CORBA::Long anIndexId = 0;
for (; anElemId < aNbElems; anElemId++, anIndexId+=2) for (; anElemId < aNbElems; anElemId++, anIndexId+=2)
@ -135,9 +135,9 @@ namespace
const SMESH::double_array& aDiameter = theSeq[theId].coords; const SMESH::double_array& aDiameter = theSeq[theId].coords;
const SMESH::long_array& anIndexes = theSeq[theId].indexes; const SMESH::long_array& anIndexes = theSeq[theId].indexes;
CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number; CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
if (2*aNbElems != anIndexes.length() ) if (2*aNbElems != (CORBA::Long) anIndexes.length() )
EXCEPTION(runtime_error,"AddEdgeWithID - 2*aNbElems != anIndexes.length()"); EXCEPTION(runtime_error,"AddEdgeWithID - 2*aNbElems != anIndexes.length()");
if (aNbElems != aDiameter.length()) if (aNbElems != (CORBA::Long) aDiameter.length())
EXCEPTION(runtime_error,"AddEdgeWithID - aNbElems != aDiameter.length()"); EXCEPTION(runtime_error,"AddEdgeWithID - aNbElems != aDiameter.length()");
CORBA::Long anIndexId = 0; CORBA::Long anIndexId = 0;
for (; anElemId < aNbElems; anElemId++, anIndexId+=2) for (; anElemId < aNbElems; anElemId++, anIndexId+=2)
@ -160,7 +160,7 @@ namespace
{ {
const SMESH::long_array& anIndexes = theSeq[theId].indexes; const SMESH::long_array& anIndexes = theSeq[theId].indexes;
CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number; CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
if(3*aNbElems != anIndexes.length()) if(3*aNbElems != (CORBA::Long) anIndexes.length())
EXCEPTION(runtime_error,"AddEdgeWithID - 3*aNbElems != aCoords.length()"); EXCEPTION(runtime_error,"AddEdgeWithID - 3*aNbElems != aCoords.length()");
for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=3){ for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=3){
SMDS_MeshElement* anElem = theMesh->AddEdgeWithID(anIndexes[anIndexId+1], SMDS_MeshElement* anElem = theMesh->AddEdgeWithID(anIndexes[anIndexId+1],
@ -181,7 +181,7 @@ namespace
{ {
const SMESH::long_array& anIndexes = theSeq[theId].indexes; const SMESH::long_array& anIndexes = theSeq[theId].indexes;
CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number; CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
if(4*aNbElems != anIndexes.length()) if(4*aNbElems != (CORBA::Long) anIndexes.length())
EXCEPTION(runtime_error,"AddTriasWithID - 4*aNbElems != anIndexes.length()"); EXCEPTION(runtime_error,"AddTriasWithID - 4*aNbElems != anIndexes.length()");
for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=4){ for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=4){
SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1], SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1],
@ -203,7 +203,7 @@ namespace
{ {
const SMESH::long_array& anIndexes = theSeq[theId].indexes; const SMESH::long_array& anIndexes = theSeq[theId].indexes;
CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number; CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
if(5*aNbElems != anIndexes.length()) if(5*aNbElems != (CORBA::Long) anIndexes.length())
EXCEPTION(runtime_error,"AddQuadsWithID - 4*aNbElems != anIndexes.length()"); EXCEPTION(runtime_error,"AddQuadsWithID - 4*aNbElems != anIndexes.length()");
for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=5){ for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=5){
SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1], SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1],
@ -280,7 +280,7 @@ namespace
{ {
const SMESH::long_array& anIndexes = theSeq[theId].indexes; const SMESH::long_array& anIndexes = theSeq[theId].indexes;
CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number; CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
if(5*aNbElems != anIndexes.length()) if(5*aNbElems != (CORBA::Long) anIndexes.length())
EXCEPTION(runtime_error,"AddTetrasWithID - 5*aNbElems != anIndexes.length()"); EXCEPTION(runtime_error,"AddTetrasWithID - 5*aNbElems != anIndexes.length()");
for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=5){ for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=5){
SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1], SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
@ -303,7 +303,7 @@ namespace
{ {
const SMESH::long_array& anIndexes = theSeq[theId].indexes; const SMESH::long_array& anIndexes = theSeq[theId].indexes;
CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number; CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
if(6*aNbElems != anIndexes.length()) if(6*aNbElems != (CORBA::Long) anIndexes.length())
EXCEPTION(runtime_error,"AddPiramidsWithID - 6*aNbElems != anIndexes.length()"); EXCEPTION(runtime_error,"AddPiramidsWithID - 6*aNbElems != anIndexes.length()");
for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=6){ for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=6){
SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1], SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
@ -327,7 +327,7 @@ namespace
{ {
const SMESH::long_array& anIndexes = theSeq[theId].indexes; const SMESH::long_array& anIndexes = theSeq[theId].indexes;
CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number; CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
if(7*aNbElems != anIndexes.length()) if(7*aNbElems != (CORBA::Long) anIndexes.length())
EXCEPTION(runtime_error,"AddPrismsWithID - 7*aNbElems != anIndexes.length()"); EXCEPTION(runtime_error,"AddPrismsWithID - 7*aNbElems != anIndexes.length()");
for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=7){ for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=7){
SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1], SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
@ -352,7 +352,7 @@ namespace
{ {
const SMESH::long_array& anIndexes = theSeq[theId].indexes; const SMESH::long_array& anIndexes = theSeq[theId].indexes;
CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number; CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
if(9*aNbElems != anIndexes.length()) if(9*aNbElems != (CORBA::Long) anIndexes.length())
EXCEPTION(runtime_error,"AddHexasWithID - 9*aNbElems != anIndexes.length()"); EXCEPTION(runtime_error,"AddHexasWithID - 9*aNbElems != anIndexes.length()");
for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=9){ for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=9){
SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1], SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
@ -378,7 +378,7 @@ namespace
{ {
const SMESH::long_array& anIndexes = theSeq[theId].indexes; const SMESH::long_array& anIndexes = theSeq[theId].indexes;
CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number; CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
if(13*aNbElems != anIndexes.length()) if(13*aNbElems != (CORBA::Long) anIndexes.length())
EXCEPTION(runtime_error,"AddHexPrismWithID - 13*aNbElems != anIndexes.length()"); EXCEPTION(runtime_error,"AddHexPrismWithID - 13*aNbElems != anIndexes.length()");
for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=13){ for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=13){
SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1], SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
@ -443,7 +443,7 @@ namespace
{ {
const SMESH::long_array& anIndexes = theSeq[theId].indexes; const SMESH::long_array& anIndexes = theSeq[theId].indexes;
CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number; CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
if(4*aNbElems != anIndexes.length()) if(4*aNbElems != (CORBA::Long) anIndexes.length())
EXCEPTION(runtime_error,"AddQuadEdgeWithID - 4*aNbElems != aCoords.length()"); EXCEPTION(runtime_error,"AddQuadEdgeWithID - 4*aNbElems != aCoords.length()");
for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=4){ for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=4){
SMDS_MeshElement* anElem = theMesh->AddEdgeWithID(anIndexes[anIndexId+1], SMDS_MeshElement* anElem = theMesh->AddEdgeWithID(anIndexes[anIndexId+1],
@ -465,7 +465,7 @@ namespace
{ {
const SMESH::long_array& anIndexes = theSeq[theId].indexes; const SMESH::long_array& anIndexes = theSeq[theId].indexes;
CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number; CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
if(7*aNbElems != anIndexes.length()) if(7*aNbElems != (CORBA::Long) anIndexes.length())
EXCEPTION(runtime_error,"AddQuadTriasWithID - 7*aNbElems != anIndexes.length()"); EXCEPTION(runtime_error,"AddQuadTriasWithID - 7*aNbElems != anIndexes.length()");
for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=7){ for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=7){
SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1], SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1],
@ -490,7 +490,7 @@ namespace
{ {
const SMESH::long_array& anIndexes = theSeq[theId].indexes; const SMESH::long_array& anIndexes = theSeq[theId].indexes;
CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number; CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
if(9*aNbElems != anIndexes.length()) if(9*aNbElems != (CORBA::Long) anIndexes.length())
EXCEPTION(runtime_error,"AddQuadQuadsWithID - 9*aNbElems != anIndexes.length()"); EXCEPTION(runtime_error,"AddQuadQuadsWithID - 9*aNbElems != anIndexes.length()");
for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=9){ for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=9){
SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1], SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1],
@ -516,7 +516,7 @@ namespace
{ {
const SMESH::long_array& anIndexes = theSeq[theId].indexes; const SMESH::long_array& anIndexes = theSeq[theId].indexes;
CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number; CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
if(10*aNbElems != anIndexes.length()) if(10*aNbElems != (CORBA::Long) anIndexes.length())
EXCEPTION(runtime_error,"AddBiQuadQuadsWithID - 10*aNbElems != anIndexes.length()"); EXCEPTION(runtime_error,"AddBiQuadQuadsWithID - 10*aNbElems != anIndexes.length()");
for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=10){ for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=10){
SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1], SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1],
@ -543,7 +543,7 @@ namespace
{ {
const SMESH::long_array& anIndexes = theSeq[theId].indexes; const SMESH::long_array& anIndexes = theSeq[theId].indexes;
CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number; CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
if(8*aNbElems != anIndexes.length()) if(8*aNbElems != (CORBA::Long) anIndexes.length())
EXCEPTION(runtime_error,"AddBiQuadTriasWithID - 8*aNbElems != anIndexes.length()"); EXCEPTION(runtime_error,"AddBiQuadTriasWithID - 8*aNbElems != anIndexes.length()");
for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=8){ for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=8){
SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1], SMDS_MeshElement* anElem = theMesh->AddFaceWithID(anIndexes[anIndexId+1],
@ -569,7 +569,7 @@ namespace
{ {
const SMESH::long_array& anIndexes = theSeq[theId].indexes; const SMESH::long_array& anIndexes = theSeq[theId].indexes;
CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number; CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
if(11*aNbElems != anIndexes.length()) if(11*aNbElems != (CORBA::Long) anIndexes.length())
EXCEPTION(runtime_error,"AddQuadTetrasWithID - 11*aNbElems != anIndexes.length()"); EXCEPTION(runtime_error,"AddQuadTetrasWithID - 11*aNbElems != anIndexes.length()");
for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=11){ for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=11){
SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1], SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
@ -598,7 +598,7 @@ namespace
{ {
const SMESH::long_array& anIndexes = theSeq[theId].indexes; const SMESH::long_array& anIndexes = theSeq[theId].indexes;
CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number; CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
if(14*aNbElems != anIndexes.length()) if(14*aNbElems != (CORBA::Long) anIndexes.length())
EXCEPTION(runtime_error,"AddQuadPiramidsWithID - 14*aNbElems != anIndexes.length()"); EXCEPTION(runtime_error,"AddQuadPiramidsWithID - 14*aNbElems != anIndexes.length()");
for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=14){ for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=14){
SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1], SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
@ -630,7 +630,7 @@ namespace
{ {
const SMESH::long_array& anIndexes = theSeq[theId].indexes; const SMESH::long_array& anIndexes = theSeq[theId].indexes;
CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number; CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
if(16*aNbElems != anIndexes.length()) if(16*aNbElems != (CORBA::Long) anIndexes.length())
EXCEPTION(runtime_error,"AddQuadPentasWithID - 16*aNbElems != anIndexes.length()"); EXCEPTION(runtime_error,"AddQuadPentasWithID - 16*aNbElems != anIndexes.length()");
for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=16){ for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=16){
SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1], SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
@ -664,7 +664,7 @@ namespace
{ {
const SMESH::long_array& anIndexes = theSeq[theId].indexes; const SMESH::long_array& anIndexes = theSeq[theId].indexes;
CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number; CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
if(21*aNbElems != anIndexes.length()) if(21*aNbElems != (CORBA::Long) anIndexes.length())
EXCEPTION(runtime_error,"AddQuadHexasWithID - 21*aNbElems != anIndexes.length()"); EXCEPTION(runtime_error,"AddQuadHexasWithID - 21*aNbElems != anIndexes.length()");
for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=21){ for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=21){
SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1], SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],
@ -702,7 +702,7 @@ namespace
{ {
const SMESH::long_array& anIndexes = theSeq[theId].indexes; const SMESH::long_array& anIndexes = theSeq[theId].indexes;
CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number; CORBA::Long anElemId = 0, aNbElems = theSeq[theId].number;
if(28*aNbElems != anIndexes.length()) if(28*aNbElems != (CORBA::Long) anIndexes.length())
EXCEPTION(runtime_error,"AddTriQuadHexasWithID - 28*aNbElems != anIndexes.length()"); EXCEPTION(runtime_error,"AddTriQuadHexasWithID - 28*aNbElems != anIndexes.length()");
for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=28){ for(CORBA::Long anIndexId = 0; anElemId < aNbElems; anElemId++, anIndexId+=28){
SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1], SMDS_MeshElement* anElem = theMesh->AddVolumeWithID(anIndexes[anIndexId+1],

12
src/SMESHGUI/SMESHGUI_MeshInfo.cxx
View File

@ -1268,7 +1268,7 @@ void SMESHGUI_SimpleElemInfo::information( const QList<long>& ids )
SMESH::ListOfGroups_var groups = aMesh->GetGroups(); SMESH::ListOfGroups_var groups = aMesh->GetGroups();
myInfo->append( "" ); // separator myInfo->append( "" ); // separator
bool top_created = false; bool top_created = false;
for ( int i = 0; i < groups->length(); i++ ) { for ( CORBA::ULong i = 0; i < groups->length(); i++ ) {
SMESH::SMESH_GroupBase_var aGrp = groups[i]; SMESH::SMESH_GroupBase_var aGrp = groups[i];
if ( CORBA::is_nil( aGrp ) ) continue; if ( CORBA::is_nil( aGrp ) ) continue;
QString aName = aGrp->GetName(); QString aName = aGrp->GetName();
@ -1528,7 +1528,7 @@ void SMESHGUI_SimpleElemInfo::information( const QList<long>& ids )
SMESH::ListOfGroups_var groups = aMesh->GetGroups(); SMESH::ListOfGroups_var groups = aMesh->GetGroups();
myInfo->append( "" ); // separator myInfo->append( "" ); // separator
bool top_created = false; bool top_created = false;
for ( int i = 0; i < groups->length(); i++ ) { for ( CORBA::ULong i = 0; i < groups->length(); i++ ) {
SMESH::SMESH_GroupBase_var aGrp = groups[i]; SMESH::SMESH_GroupBase_var aGrp = groups[i];
if ( CORBA::is_nil( aGrp ) ) continue; if ( CORBA::is_nil( aGrp ) ) continue;
QString aName = aGrp->GetName(); QString aName = aGrp->GetName();
@ -1788,7 +1788,7 @@ void SMESHGUI_TreeElemInfo::information( const QList<long>& ids )
if ( !CORBA::is_nil( aMesh ) ) { if ( !CORBA::is_nil( aMesh ) ) {
SMESH::ListOfGroups_var groups = aMesh->GetGroups(); SMESH::ListOfGroups_var groups = aMesh->GetGroups();
QTreeWidgetItem* groupsItem = 0; QTreeWidgetItem* groupsItem = 0;
for ( int i = 0; i < groups->length(); i++ ) { for ( CORBA::ULong i = 0; i < groups->length(); i++ ) {
SMESH::SMESH_GroupBase_var aGrp = groups[i]; SMESH::SMESH_GroupBase_var aGrp = groups[i];
if ( CORBA::is_nil( aGrp ) ) continue; if ( CORBA::is_nil( aGrp ) ) continue;
QString aName = aGrp->GetName(); QString aName = aGrp->GetName();
@ -2086,7 +2086,7 @@ void SMESHGUI_TreeElemInfo::information( const QList<long>& ids )
if ( !CORBA::is_nil( aMesh ) ) { if ( !CORBA::is_nil( aMesh ) ) {
SMESH::ListOfGroups_var groups = aMesh->GetGroups(); SMESH::ListOfGroups_var groups = aMesh->GetGroups();
QTreeWidgetItem* groupsItem = 0; QTreeWidgetItem* groupsItem = 0;
for ( int i = 0; i < groups->length(); i++ ) { for ( CORBA::ULong i = 0; i < groups->length(); i++ ) {
SMESH::SMESH_GroupBase_var aGrp = groups[i]; SMESH::SMESH_GroupBase_var aGrp = groups[i];
if ( CORBA::is_nil( aGrp ) ) continue; if ( CORBA::is_nil( aGrp ) ) continue;
QString aName = aGrp->GetName(); QString aName = aGrp->GetName();
@ -2643,7 +2643,7 @@ void SMESHGUI_AddInfo::showGroups()
itemGroups->setData( 0, Qt::UserRole, GROUPS_ID ); itemGroups->setData( 0, Qt::UserRole, GROUPS_ID );
// total number of groups > 10, show extra widgets for info browsing // total number of groups > 10, show extra widgets for info browsing
if ( myGroups->length() > MAXITEMS ) { if ((int) myGroups->length() > MAXITEMS ) {
ExtraWidget* extra = new ExtraWidget( this, true ); ExtraWidget* extra = new ExtraWidget( this, true );
connect( extra->prev, SIGNAL( clicked() ), this, SLOT( showPreviousGroups() ) ); connect( extra->prev, SIGNAL( clicked() ), this, SLOT( showPreviousGroups() ) );
connect( extra->next, SIGNAL( clicked() ), this, SLOT( showNextGroups() ) ); connect( extra->next, SIGNAL( clicked() ), this, SLOT( showNextGroups() ) );
@ -2704,7 +2704,7 @@ void SMESHGUI_AddInfo::showSubMeshes()
itemSubMeshes->setData( 0, Qt::UserRole, SUBMESHES_ID ); itemSubMeshes->setData( 0, Qt::UserRole, SUBMESHES_ID );
// total number of sub-meshes > 10, show extra widgets for info browsing // total number of sub-meshes > 10, show extra widgets for info browsing
if ( mySubMeshes->length() > MAXITEMS ) { if ((int) mySubMeshes->length() > MAXITEMS ) {
ExtraWidget* extra = new ExtraWidget( this, true ); ExtraWidget* extra = new ExtraWidget( this, true );
connect( extra->prev, SIGNAL( clicked() ), this, SLOT( showPreviousSubMeshes() ) ); connect( extra->prev, SIGNAL( clicked() ), this, SLOT( showPreviousSubMeshes() ) );
connect( extra->next, SIGNAL( clicked() ), this, SLOT( showNextSubMeshes() ) ); connect( extra->next, SIGNAL( clicked() ), this, SLOT( showNextSubMeshes() ) );

4
src/SMESHUtils/SMESH_Block.cxx
View File

@ -166,7 +166,7 @@ void SMESH_Block::TFace::Set( const int faceID,
// pcurves // pcurves
vector< int > edgeIdVec; vector< int > edgeIdVec;
GetFaceEdgesIDs( faceID, edgeIdVec ); GetFaceEdgesIDs( faceID, edgeIdVec );
for ( int iE = 0; iE < edgeIdVec.size(); iE++ ) // loop on 4 edges for ( size_t iE = 0; iE < edgeIdVec.size(); iE++ ) // loop on 4 edges
{ {
myCoordInd[ iE ] = GetCoordIndOnEdge( edgeIdVec[ iE ] ); myCoordInd[ iE ] = GetCoordIndOnEdge( edgeIdVec[ iE ] );
if ( myC2d[ iE ]) delete myC2d[ iE ]; if ( myC2d[ iE ]) delete myC2d[ iE ];
@ -2083,7 +2083,7 @@ bool SMESH_Block::LoadFace(const TopoDS_Face& theFace,
bool isForward[4]; bool isForward[4];
vector< int > edgeIdVec; vector< int > edgeIdVec;
GetFaceEdgesIDs( theFaceID, edgeIdVec ); GetFaceEdgesIDs( theFaceID, edgeIdVec );
for ( int iE = 0; iE < edgeIdVec.size(); iE++ ) // loop on 4 edges for ( size_t iE = 0; iE < edgeIdVec.size(); iE++ ) // loop on 4 edges
{ {
if ( edgeIdVec[ iE ] > theShapeIDMap.Extent() ) if ( edgeIdVec[ iE ] > theShapeIDMap.Extent() )
return false; return false;

15
src/SMESHUtils/SMESH_FreeBorders.cxx
View File

@ -344,19 +344,6 @@ namespace
} // namespace } // namespace
// struct needed for NCollection_Map
struct TLinkHasher
{
static int HashCode(const SMESH_TLink& link, int aLimit)
{
return ::HashCode( link.node1()->GetID() + link.node2()->GetID(), aLimit );
}
static Standard_Boolean IsEqual(const SMESH_TLink& l1, const SMESH_TLink& l2)
{
return ( l1.node1() == l2.node1() && l1.node2() == l2.node2() );
}
};
//================================================================================ //================================================================================
/* /*
* Returns groups of TFreeBorder's coincident within the given tolerance. * Returns groups of TFreeBorder's coincident within the given tolerance.
@ -370,7 +357,7 @@ void SMESH_MeshAlgos::FindCoincidentFreeBorders(SMDS_Mesh& mesh,
CoincidentFreeBorders & foundFreeBordes) CoincidentFreeBorders & foundFreeBordes)
{ {
// find free links // find free links
typedef NCollection_DataMap<SMESH_TLink, const SMDS_MeshElement*, TLinkHasher > TLink2FaceMap; typedef NCollection_DataMap<SMESH_TLink, const SMDS_MeshElement*, SMESH_TLink > TLink2FaceMap;
TLink2FaceMap linkMap; TLink2FaceMap linkMap;
int nbSharedLinks = 0; int nbSharedLinks = 0;
SMDS_FaceIteratorPtr faceIt = mesh.facesIterator(); SMDS_FaceIteratorPtr faceIt = mesh.facesIterator();

16
src/SMESHUtils/SMESH_MeshAlgos.cxx
View File

@ -270,7 +270,7 @@ namespace // Utils used in SMESH_ElementSearcherImpl::FindElementsByPoint()
ElementBndBoxTree::~ElementBndBoxTree() ElementBndBoxTree::~ElementBndBoxTree()
{ {
for ( int i = 0; i < _elements.size(); ++i ) for ( size_t i = 0; i < _elements.size(); ++i )
if ( --_elements[i]->_refCount <= 0 ) if ( --_elements[i]->_refCount <= 0 )
delete _elements[i]; delete _elements[i];
} }
@ -284,7 +284,7 @@ namespace // Utils used in SMESH_ElementSearcherImpl::FindElementsByPoint()
Bnd_B3d* ElementBndBoxTree::buildRootBox() Bnd_B3d* ElementBndBoxTree::buildRootBox()
{ {
Bnd_B3d* box = new Bnd_B3d; Bnd_B3d* box = new Bnd_B3d;
for ( int i = 0; i < _elements.size(); ++i ) for ( size_t i = 0; i < _elements.size(); ++i )
box->Add( *_elements[i] ); box->Add( *_elements[i] );
return box; return box;
} }
@ -297,7 +297,7 @@ namespace // Utils used in SMESH_ElementSearcherImpl::FindElementsByPoint()
void ElementBndBoxTree::buildChildrenData() void ElementBndBoxTree::buildChildrenData()
{ {
for ( int i = 0; i < _elements.size(); ++i ) for ( size_t i = 0; i < _elements.size(); ++i )
{ {
for (int j = 0; j < 8; j++) for (int j = 0; j < 8; j++)
{ {
@ -315,7 +315,7 @@ namespace // Utils used in SMESH_ElementSearcherImpl::FindElementsByPoint()
for (int j = 0; j < 8; j++) for (int j = 0; j < 8; j++)
{ {
ElementBndBoxTree* child = static_cast<ElementBndBoxTree*>( myChildren[j]); ElementBndBoxTree* child = static_cast<ElementBndBoxTree*>( myChildren[j]);
if ( child->_elements.size() <= MaxNbElemsInLeaf ) if ((int) child->_elements.size() <= MaxNbElemsInLeaf )
child->myIsLeaf = true; child->myIsLeaf = true;
if ( child->_elements.capacity() - child->_elements.size() > 1000 ) if ( child->_elements.capacity() - child->_elements.size() > 1000 )
@ -337,7 +337,7 @@ namespace // Utils used in SMESH_ElementSearcherImpl::FindElementsByPoint()
if ( isLeaf() ) if ( isLeaf() )
{ {
for ( int i = 0; i < _elements.size(); ++i ) for ( size_t i = 0; i < _elements.size(); ++i )
if ( !_elements[i]->IsOut( point.XYZ() )) if ( !_elements[i]->IsOut( point.XYZ() ))
foundElems.insert( _elements[i]->_element ); foundElems.insert( _elements[i]->_element );
} }
@ -362,7 +362,7 @@ namespace // Utils used in SMESH_ElementSearcherImpl::FindElementsByPoint()
if ( isLeaf() ) if ( isLeaf() )
{ {
for ( int i = 0; i < _elements.size(); ++i ) for ( size_t i = 0; i < _elements.size(); ++i )
if ( !_elements[i]->IsOut( line )) if ( !_elements[i]->IsOut( line ))
foundElems.insert( _elements[i]->_element ); foundElems.insert( _elements[i]->_element );
} }
@ -388,7 +388,7 @@ namespace // Utils used in SMESH_ElementSearcherImpl::FindElementsByPoint()
if ( isLeaf() ) if ( isLeaf() )
{ {
for ( int i = 0; i < _elements.size(); ++i ) for ( size_t i = 0; i < _elements.size(); ++i )
if ( !_elements[i]->IsOut( center, radius )) if ( !_elements[i]->IsOut( center, radius ))
foundElems.insert( _elements[i]->_element ); foundElems.insert( _elements[i]->_element );
} }
@ -1325,6 +1325,7 @@ double SMESH_MeshAlgos::GetDistance( const SMDS_MeshElement* elem,
return GetDistance( dynamic_cast<const SMDS_MeshEdge*>( elem ), point); return GetDistance( dynamic_cast<const SMDS_MeshEdge*>( elem ), point);
case SMDSAbs_Node: case SMDSAbs_Node:
return point.Distance( SMESH_TNodeXYZ( elem )); return point.Distance( SMESH_TNodeXYZ( elem ));
default:;
} }
return -1; return -1;
} }
@ -1421,6 +1422,7 @@ double SMESH_MeshAlgos::GetDistance( const SMDS_MeshFace* face,
// cout << distVec.Magnitude() << " VERTEX " << face->GetNode(pos._index)->GetID() << endl; // cout << distVec.Magnitude() << " VERTEX " << face->GetNode(pos._index)->GetID() << endl;
return distVec.Magnitude(); return distVec.Magnitude();
} }
default:;
} }
return badDistance; return badDistance;
} }

4
src/SMESHUtils/SMESH_OctreeNode.cxx
View File

@ -102,7 +102,7 @@ Bnd_B3d* SMESH_OctreeNode::buildRootBox()
gp_XYZ p1( n1->X(), n1->Y(), n1->Z() ); gp_XYZ p1( n1->X(), n1->Y(), n1->Z() );
box->Add(p1); box->Add(p1);
} }
if ( myNodes.size() <= getMaxNbNodes() ) if ((int) myNodes.size() <= getMaxNbNodes() )
myIsLeaf = true; myIsLeaf = true;
return box; return box;
@ -151,7 +151,7 @@ void SMESH_OctreeNode::buildChildrenData()
for (int i = 0; i < 8; i++) for (int i = 0; i < 8; i++)
{ {
SMESH_OctreeNode* myChild = dynamic_cast<SMESH_OctreeNode*> (myChildren[i]); SMESH_OctreeNode* myChild = dynamic_cast<SMESH_OctreeNode*> (myChildren[i]);
if ( myChild->myNodes.size() <= getMaxNbNodes() ) if ((int) myChild->myNodes.size() <= getMaxNbNodes() )
myChild->myIsLeaf = true; myChild->myIsLeaf = true;
} }
} }

15
src/SMESHUtils/SMESH_TypeDefs.hxx
View File

@ -80,8 +80,11 @@ namespace SMESHUtils
struct Deleter struct Deleter
{ {
TOBJ* _obj; TOBJ* _obj;
Deleter( TOBJ* obj = (TOBJ*)NULL ): _obj( obj ) {} explicit Deleter( TOBJ* obj = (TOBJ*)NULL ): _obj( obj ) {}
~Deleter() { delete _obj; _obj = 0; } ~Deleter() { delete _obj; _obj = 0; }
TOBJ& operator*() const { return *_obj; }
TOBJ* operator->() const { return _obj; }
operator bool() const { return _obj; }
private: private:
Deleter( const Deleter& ); Deleter( const Deleter& );
}; };
@ -113,6 +116,16 @@ struct SMESH_TLink: public NLink
{ if ( first->GetID() < second->GetID() ) std::swap( first, second ); } { if ( first->GetID() < second->GetID() ) std::swap( first, second ); }
const SMDS_MeshNode* node1() const { return first; } const SMDS_MeshNode* node1() const { return first; }
const SMDS_MeshNode* node2() const { return second; } const SMDS_MeshNode* node2() const { return second; }
// methods for usage of SMESH_TLink as a hasher in NCollection maps
static int HashCode(const SMESH_TLink& link, int aLimit)
{
return ::HashCode( link.node1()->GetID() + link.node2()->GetID(), aLimit );
}
static Standard_Boolean IsEqual(const SMESH_TLink& l1, const SMESH_TLink& l2)
{
return ( l1.node1() == l2.node1() && l1.node2() == l2.node2() );
}
}; };
//======================================================================= //=======================================================================

10
src/SMESH_I/SMESH_DumpPython.cxx
View File

@ -98,7 +98,7 @@ namespace SMESH
myStream << "[ "; myStream << "[ ";
for ( size_t i = 1; i <= theVarValue.myVals.size(); ++i ) for ( size_t i = 1; i <= theVarValue.myVals.size(); ++i )
{ {
if ( myVarsCounter < varIDs.size() && varIDs[ myVarsCounter ] >= 0 ) if ( myVarsCounter < (int)varIDs.size() && varIDs[ myVarsCounter ] >= 0 )
myStream << TVar::Quote() << varIDs[ myVarsCounter ] << TVar::Quote(); myStream << TVar::Quote() << varIDs[ myVarsCounter ] << TVar::Quote();
else else
myStream << theVarValue.myVals[i-1]; myStream << theVarValue.myVals[i-1];
@ -110,7 +110,7 @@ namespace SMESH
} }
else else
{ {
if ( myVarsCounter < varIDs.size() && varIDs[ myVarsCounter ] >= 0 ) if ( myVarsCounter < (int)varIDs.size() && varIDs[ myVarsCounter ] >= 0 )
myStream << TVar::Quote() << varIDs[ myVarsCounter ] << TVar::Quote(); myStream << TVar::Quote() << varIDs[ myVarsCounter ] << TVar::Quote();
else else
myStream << theVarValue.myVals[0]; myStream << theVarValue.myVals[0];
@ -247,7 +247,7 @@ namespace SMESH
else else
{ {
theStream << "[ "; theStream << "[ ";
for (int i = 1; i <= theArray.length(); i++) { for (CORBA::ULong i = 1; i <= theArray.length(); i++) {
theStream << theArray[i-1]; theStream << theArray[i-1];
if ( i < theArray.length() ) if ( i < theArray.length() )
theStream << ", "; theStream << ", ";
@ -281,7 +281,7 @@ namespace SMESH
TPythonDump::operator<<(const SMESH::string_array& theArray) TPythonDump::operator<<(const SMESH::string_array& theArray)
{ {
myStream << "[ "; myStream << "[ ";
for (int i = 1; i <= theArray.length(); i++) { for ( CORBA::ULong i = 1; i <= theArray.length(); i++ ) {
myStream << "'" << theArray[i-1] << "'"; myStream << "'" << theArray[i-1] << "'";
if ( i < theArray.length() ) if ( i < theArray.length() )
myStream << ", "; myStream << ", ";
@ -564,7 +564,7 @@ namespace SMESH
for ( CORBA::ULong iP = 0; iP < aGRP.length(); ++iP ) for ( CORBA::ULong iP = 0; iP < aGRP.length(); ++iP )
{ {
const SMESH::FreeBorderPart& aPART = aGRP[ iP ]; const SMESH::FreeBorderPart& aPART = aGRP[ iP ];
if ( 0 <= aPART.border && aPART.border < theCFB.borders.length() ) if ( 0 <= aPART.border && aPART.border < (CORBA::Long)theCFB.borders.length() )
{ {
if ( iP ) myStream << ", "; if ( iP ) myStream << ", ";
const SMESH::FreeBorder& aBRD = theCFB.borders[ aPART.border ]; const SMESH::FreeBorder& aBRD = theCFB.borders[ aPART.border ];

55
src/SMESH_I/SMESH_Gen_i.cxx
View File

@ -1204,7 +1204,7 @@ SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMEDorSAUV( const char* theFileNa
aPythonDump << "], status) = " << this << "." << theCommandNameForPython << "(r'" << theFileNameForPython << "')"; aPythonDump << "], status) = " << this << "." << theCommandNameForPython << "(r'" << theFileNameForPython << "')";
} }
// Dump creation of groups // Dump creation of groups
for ( int i = 0; i < aResult->length(); ++i ) for ( CORBA::ULong i = 0; i < aResult->length(); ++i )
SMESH::ListOfGroups_var groups = aResult[ i ]->GetGroups(); SMESH::ListOfGroups_var groups = aResult[ i ]->GetGroups();
return aResult._retn(); return aResult._retn();
@ -1382,7 +1382,7 @@ SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromCGNS( const char* theFileName,
aPythonDump << "], status) = " << this << ".CreateMeshesFromCGNS(r'" << theFileName << "')"; aPythonDump << "], status) = " << this << ".CreateMeshesFromCGNS(r'" << theFileName << "')";
} }
// Dump creation of groups // Dump creation of groups
for ( int i = 0; i < aResult->length(); ++i ) for ( CORBA::ULong i = 0; i < aResult->length(); ++i )
SMESH::ListOfGroups_var groups = aResult[ i ]->GetGroups(); SMESH::ListOfGroups_var groups = aResult[ i ]->GetGroups();
#else #else
THROW_SALOME_CORBA_EXCEPTION("CGNS library is unavailable", SALOME::INTERNAL_ERROR); THROW_SALOME_CORBA_EXCEPTION("CGNS library is unavailable", SALOME::INTERNAL_ERROR);
@ -1777,7 +1777,8 @@ SMESH::algo_error_array* SMESH_Gen_i::GetAlgoState( SMESH::SMESH_Mesh_ptr theMes
*/ */
//============================================================================= //=============================================================================
SMESH::long_array* SMESH_Gen_i::GetSubShapesId( GEOM::GEOM_Object_ptr theMainShapeObject, SMESH::long_array*
SMESH_Gen_i::GetSubShapesId( GEOM::GEOM_Object_ptr theMainShapeObject,
const SMESH::object_array& theListOfSubShapeObject ) const SMESH::object_array& theListOfSubShapeObject )
throw ( SALOME::SALOME_Exception ) throw ( SALOME::SALOME_Exception )
{ {
@ -1788,8 +1789,7 @@ SMESH::long_array* SMESH_Gen_i::GetSubShapesId( GEOM::GEOM_Object_ptr theMainSha
set<int> setId; set<int> setId;
if ( CORBA::is_nil( theMainShapeObject ) ) if ( CORBA::is_nil( theMainShapeObject ) )
THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference", THROW_SALOME_CORBA_EXCEPTION( "bad shape object reference", SALOME::BAD_PARAM );
SALOME::BAD_PARAM );
try try
{ {
@ -1797,7 +1797,7 @@ SMESH::long_array* SMESH_Gen_i::GetSubShapesId( GEOM::GEOM_Object_ptr theMainSha
TopTools_IndexedMapOfShape myIndexToShape; TopTools_IndexedMapOfShape myIndexToShape;
TopExp::MapShapes(myMainShape,myIndexToShape); TopExp::MapShapes(myMainShape,myIndexToShape);
for ( int i = 0; i < theListOfSubShapeObject.length(); i++ ) for ( CORBA::ULong i = 0; i < theListOfSubShapeObject.length(); i++ )
{ {
GEOM::GEOM_Object_var aShapeObject GEOM::GEOM_Object_var aShapeObject
= GEOM::GEOM_Object::_narrow(theListOfSubShapeObject[i]); = GEOM::GEOM_Object::_narrow(theListOfSubShapeObject[i]);
@ -2172,7 +2172,7 @@ SMESH::long_array* SMESH_Gen_i::Evaluate(SMESH::SMESH_Mesh_ptr theMesh,
MapShapeNbElemsItr anIt = aResMap.begin(); MapShapeNbElemsItr anIt = aResMap.begin();
for(; anIt!=aResMap.end(); anIt++) { for(; anIt!=aResMap.end(); anIt++) {
const vector<int>& aVec = (*anIt).second; const vector<int>& aVec = (*anIt).second;
for(i = SMESH::Entity_Node; i < aVec.size(); i++) { for ( i = SMESH::Entity_Node; i < (int)aVec.size(); i++ ) {
int nbElem = aVec[i]; int nbElem = aVec[i];
if ( nbElem < 0 ) // algo failed, check that it has reported a message if ( nbElem < 0 ) // algo failed, check that it has reported a message
{ {
@ -2434,7 +2434,7 @@ SMESH_Gen_i::ConcatenateCommon(const SMESH::ListOfIDSources& theMeshesArray,
std::vector<const SMDS_MeshNode*> aNodesArray; std::vector<const SMDS_MeshNode*> aNodesArray;
// loop on sub-meshes // loop on sub-meshes
for ( int i = 0; i < theMeshesArray.length(); i++) for ( CORBA::ULong i = 0; i < theMeshesArray.length(); i++)
{ {
if ( CORBA::is_nil( theMeshesArray[i] )) continue; if ( CORBA::is_nil( theMeshesArray[i] )) continue;
SMESH::SMESH_Mesh_var anInitMesh = theMeshesArray[i]->GetMesh(); SMESH::SMESH_Mesh_var anInitMesh = theMeshesArray[i]->GetMesh();
@ -2443,8 +2443,8 @@ SMESH_Gen_i::ConcatenateCommon(const SMESH::ListOfIDSources& theMeshesArray,
if ( !anInitImpl ) continue; if ( !anInitImpl ) continue;
anInitImpl->Load(); anInitImpl->Load();
::SMESH_Mesh& aInitLocMesh = anInitImpl->GetImpl(); //::SMESH_Mesh& aInitLocMesh = anInitImpl->GetImpl();
SMESHDS_Mesh* anInitMeshDS = aInitLocMesh.GetMeshDS(); //SMESHDS_Mesh* anInitMeshDS = aInitLocMesh.GetMeshDS();
// remember nb of elements before filling in // remember nb of elements before filling in
SMESH::long_array_var prevState = aNewMesh->GetNbElementsByType(); SMESH::long_array_var prevState = aNewMesh->GetNbElementsByType();
@ -2517,7 +2517,7 @@ SMESH_Gen_i::ConcatenateCommon(const SMESH::ListOfIDSources& theMeshesArray,
const char* typeNames[] = { "All","Nodes","Edges","Faces","Volumes","0DElems","Balls" }; const char* typeNames[] = { "All","Nodes","Edges","Faces","Volumes","0DElems","Balls" };
{ // check of typeNames, compilation failure mains that NB_ELEMENT_TYPES changed: { // check of typeNames, compilation failure mains that NB_ELEMENT_TYPES changed:
const int nbNames = sizeof(typeNames) / sizeof(const char*); const int nbNames = sizeof(typeNames) / sizeof(const char*);
int _assert[( nbNames == SMESH::NB_ELEMENT_TYPES ) ? 1 : -1 ]; int _assert[( nbNames == SMESH::NB_ELEMENT_TYPES ) ? 1 : -1 ]; _assert[0]=0;
} }
string groupName = "Gr"; string groupName = "Gr";
SALOMEDS::SObject_wrap aMeshSObj = ObjectToSObject( myCurrentStudy, theMeshesArray[i] ); SALOMEDS::SObject_wrap aMeshSObj = ObjectToSObject( myCurrentStudy, theMeshesArray[i] );
@ -2558,7 +2558,7 @@ SMESH_Gen_i::ConcatenateCommon(const SMESH::ListOfIDSources& theMeshesArray,
if ( SMESH_Mesh_i* anSrcImpl = SMESH::DownCast<SMESH_Mesh_i*>( theMeshesArray[i] )) if ( SMESH_Mesh_i* anSrcImpl = SMESH::DownCast<SMESH_Mesh_i*>( theMeshesArray[i] ))
{ {
// copy orphan nodes // copy orphan nodes
if ( anSrcImpl->NbNodes() > nodesMap.size() ) if ( anSrcImpl->NbNodes() > (int)nodesMap.size() )
{ {
SMDS_ElemIteratorPtr itNodes = anInitImpl->GetElements( theMeshesArray[i], SMESH::NODE ); SMDS_ElemIteratorPtr itNodes = anInitImpl->GetElements( theMeshesArray[i], SMESH::NODE );
while ( itNodes->more() ) while ( itNodes->more() )
@ -2580,7 +2580,7 @@ SMESH_Gen_i::ConcatenateCommon(const SMESH::ListOfIDSources& theMeshesArray,
// loop on groups of a source mesh // loop on groups of a source mesh
aListOfGroups = anSrcImpl->GetGroups(); aListOfGroups = anSrcImpl->GetGroups();
for (int iG = 0; iG < aListOfGroups->length(); iG++) for ( CORBA::ULong iG = 0; iG < aListOfGroups->length(); iG++ )
{ {
aGroup = aListOfGroups[iG]; aGroup = aListOfGroups[iG];
aGroupType = aGroup->GetType(); aGroupType = aGroup->GetType();
@ -2632,7 +2632,7 @@ SMESH_Gen_i::ConcatenateCommon(const SMESH::ListOfIDSources& theMeshesArray,
aNewGroups.front()->SetName(aNewGroupName.c_str()); aNewGroups.front()->SetName(aNewGroupName.c_str());
} }
char aGroupNum[128]; char aGroupNum[128];
sprintf(aGroupNum, "%u", aNewGroups.size()+1); sprintf(aGroupNum, "%u", (unsigned int)aNewGroups.size()+1);
aNewGroupName = aName + "_" + string(aGroupNum); aNewGroupName = aName + "_" + string(aGroupNum);
aNewGroup->SetName(aNewGroupName.c_str()); aNewGroup->SetName(aNewGroupName.c_str());
aNewGroups.push_back(aNewGroup); aNewGroups.push_back(aNewGroup);
@ -2656,7 +2656,7 @@ SMESH_Gen_i::ConcatenateCommon(const SMESH::ListOfIDSources& theMeshesArray,
aPythonDump << aNewMesh << " = " << this << "." aPythonDump << aNewMesh << " = " << this << "."
<< ( theCommonGroups ? "ConcatenateWithGroups" : "Concatenate" ) << ( theCommonGroups ? "ConcatenateWithGroups" : "Concatenate" )
<< "(["; << "([";
for ( int i = 0; i < theMeshesArray.length(); i++) { for ( CORBA::ULong i = 0; i < theMeshesArray.length(); i++) {
if (i > 0) aPythonDump << ", "; if (i > 0) aPythonDump << ", ";
aPythonDump << theMeshesArray[i]; aPythonDump << theMeshesArray[i];
} }
@ -2747,13 +2747,13 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CopyMesh(SMESH::SMESH_IDSource_ptr meshPart,
SMESH::long_array_var ids = meshPart->GetIDs(); SMESH::long_array_var ids = meshPart->GetIDs();
if ( srcElemTypes->length() == 1 && srcElemTypes[0] == SMESH::NODE ) // group of nodes if ( srcElemTypes->length() == 1 && srcElemTypes[0] == SMESH::NODE ) // group of nodes
{ {
for (int i=0; i < ids->length(); i++) for ( CORBA::ULong i=0; i < ids->length(); i++ )
if ( const SMDS_MeshElement * elem = srcMeshDS->FindNode( ids[i] )) if ( const SMDS_MeshElement * elem = srcMeshDS->FindNode( ids[i] ))
srcElems.insert( elem ); srcElems.insert( elem );
} }
else else
{ {
for (int i=0; i < ids->length(); i++) for ( CORBA::ULong i = 0; i < ids->length(); i++ )
if ( const SMDS_MeshElement * elem = srcMeshDS->FindElement( ids[i] )) if ( const SMDS_MeshElement * elem = srcMeshDS->FindElement( ids[i] ))
srcElems.insert( elem ); srcElems.insert( elem );
} }
@ -3044,7 +3044,7 @@ SALOMEDS::TMPFile* SMESH_Gen_i::Save( SALOMEDS::SComponent_ptr theComponent,
TPythonDump pd; // not to dump GetGroups() TPythonDump pd; // not to dump GetGroups()
SMESH::ListOfGroups_var groups = myMesh->GetGroups(); SMESH::ListOfGroups_var groups = myMesh->GetGroups();
pd << ""; // to avoid optimizing pd out pd << ""; // to avoid optimizing pd out
for ( int i = 0; i < groups->length(); ++i ) for ( CORBA::ULong i = 0; i < groups->length(); ++i )
{ {
SMESH_GroupBase_i* grImpl = SMESH::DownCast<SMESH_GroupBase_i*>( groups[i]); SMESH_GroupBase_i* grImpl = SMESH::DownCast<SMESH_GroupBase_i*>( groups[i]);
if ( grImpl ) if ( grImpl )
@ -5070,7 +5070,7 @@ void SMESH_Gen_i::Move( const SMESH::sobject_list& what,
} }
} }
for ( int i = 0; i < what.length(); i++ ) { for ( CORBA::ULong i = 0; i < what.length(); i++ ) {
SALOMEDS::SObject_var sobj = what[i]; SALOMEDS::SObject_var sobj = what[i];
if ( CORBA::is_nil( sobj ) ) continue; // skip bad object if ( CORBA::is_nil( sobj ) ) continue; // skip bad object
// insert the object to the use case tree // insert the object to the use case tree
@ -5130,7 +5130,8 @@ SMESH::long_array* SMESH_Gen_i::GetInsideSphere( SMESH::SMESH_IDSource_ptr meshP
CORBA::Double theX, CORBA::Double theX,
CORBA::Double theY, CORBA::Double theY,
CORBA::Double theZ, CORBA::Double theZ,
CORBA::Double theR) { CORBA::Double theR)
{
SMESH::long_array_var aResult = new SMESH::long_array(); SMESH::long_array_var aResult = new SMESH::long_array();
if ( meshPart->_is_nil() ) if ( meshPart->_is_nil() )
return aResult._retn(); return aResult._retn();
@ -5143,7 +5144,7 @@ SMESH::long_array* SMESH_Gen_i::GetInsideSphere( SMESH::SMESH_IDSource_ptr meshP
if ( lst.size() > 0 ) { if ( lst.size() > 0 ) {
aResult->length( lst.size() ); aResult->length( lst.size() );
for ( long i = 0; i < lst.size(); i++ ) { for ( size_t i = 0; i < lst.size(); i++ ) {
aResult[i] = lst[i]; aResult[i] = lst[i];
} }
} }
@ -5168,7 +5169,7 @@ SMESH::long_array* SMESH_Gen_i::GetInsideBox( SMESH::SMESH_IDSource_ptr meshPart
if( lst.size() > 0 ) { if( lst.size() > 0 ) {
aResult->length( lst.size() ); aResult->length( lst.size() );
for ( long i = 0; i < lst.size(); i++ ) { for ( size_t i = 0; i < lst.size(); i++ ) {
aResult[i] = lst[i]; aResult[i] = lst[i];
} }
} }
@ -5199,7 +5200,7 @@ SMESH::long_array* SMESH_Gen_i::GetInsideCylinder( SMESH::SMESH_IDSource_ptr mes
if( lst.size() > 0 ) { if( lst.size() > 0 ) {
aResult->length( lst.size() ); aResult->length( lst.size() );
for ( long i = 0; i < lst.size(); i++ ) { for ( size_t i = 0; i < lst.size(); i++ ) {
aResult[i] = lst[i]; aResult[i] = lst[i];
} }
} }
@ -5220,7 +5221,7 @@ SMESH::long_array* SMESH_Gen_i::GetInside( SMESH::SMESH_IDSource_ptr meshPart,
if( lst.size() > 0 ) { if( lst.size() > 0 ) {
aResult->length( lst.size() ); aResult->length( lst.size() );
for ( long i = 0; i < lst.size(); i++ ) { for ( size_t i = 0; i < lst.size(); i++ ) {
aResult[i] = lst[i]; aResult[i] = lst[i];
} }
} }
@ -5274,7 +5275,7 @@ std::vector<long> SMESH_Gen_i::_GetInside( SMESH::SMESH_IDSource_ptr meshPart,
if ( !gsource->_is_nil() ) { if ( !gsource->_is_nil() ) {
if(theElemType == SMESH::NODE) { if(theElemType == SMESH::NODE) {
SMESH::long_array_var nodes = gsource->GetNodeIDs(); SMESH::long_array_var nodes = gsource->GetNodeIDs();
for ( int i = 0; i < nodes->length(); ++i ) { for ( CORBA::ULong i = 0; i < nodes->length(); ++i ) {
if ( const SMDS_MeshNode* node = meshDS->FindNode( nodes[i] )) { if ( const SMDS_MeshNode* node = meshDS->FindNode( nodes[i] )) {
long anId = node->GetID(); long anId = node->GetID();
if ( anElementsOnShape->IsSatisfy( anId ) ) if ( anElementsOnShape->IsSatisfy( anId ) )
@ -5283,7 +5284,7 @@ std::vector<long> SMESH_Gen_i::_GetInside( SMESH::SMESH_IDSource_ptr meshPart,
} }
} else if (gsource->GetType() == theElemType || theElemType == SMESH::ALL ) { } else if (gsource->GetType() == theElemType || theElemType == SMESH::ALL ) {
SMESH::long_array_var elems = gsource->GetListOfID(); SMESH::long_array_var elems = gsource->GetListOfID();
for ( int i = 0; i < elems->length(); ++i ) { for ( CORBA::ULong i = 0; i < elems->length(); ++i ) {
if ( const SMDS_MeshElement* elem = meshDS->FindElement( elems[i] )) { if ( const SMDS_MeshElement* elem = meshDS->FindElement( elems[i] )) {
long anId = elem->GetID(); long anId = elem->GetID();
if ( anElementsOnShape->IsSatisfy( anId ) ) if ( anElementsOnShape->IsSatisfy( anId ) )
@ -5295,7 +5296,7 @@ std::vector<long> SMESH_Gen_i::_GetInside( SMESH::SMESH_IDSource_ptr meshPart,
SMESH::SMESH_subMesh_var smsource = SMESH::SMESH_subMesh::_narrow(meshPart); SMESH::SMESH_subMesh_var smsource = SMESH::SMESH_subMesh::_narrow(meshPart);
if ( !smsource->_is_nil() ) { if ( !smsource->_is_nil() ) {
SMESH::long_array_var elems = smsource->GetElementsByType( theElemType ); SMESH::long_array_var elems = smsource->GetElementsByType( theElemType );
for ( int i = 0; i < elems->length(); ++i ) { for ( CORBA::ULong i = 0; i < elems->length(); ++i ) {
const SMDS_MeshElement* elem = ( theElemType == SMESH::NODE ) ? meshDS->FindNode( elems[i] ) : meshDS->FindElement( elems[i] ); const SMDS_MeshElement* elem = ( theElemType == SMESH::NODE ) ? meshDS->FindNode( elems[i] ) : meshDS->FindElement( elems[i] );
if (elem) { if (elem) {
long anId = elem->GetID(); long anId = elem->GetID();

6
src/SMESH_I/SMESH_Gen_i_1.cxx
View File

@ -585,7 +585,7 @@ SALOMEDS::SObject_ptr SMESH_Gen_i::PublishMesh (SALOMEDS::Study_ptr theStudy,
// Publish global hypotheses // Publish global hypotheses
SMESH::ListOfHypothesis_var hypList = theMesh->GetHypothesisList( aShapeObject ); SMESH::ListOfHypothesis_var hypList = theMesh->GetHypothesisList( aShapeObject );
for ( int i = 0; i < hypList->length(); i++ ) for ( CORBA::ULong i = 0; i < hypList->length(); i++ )
{ {
SMESH::SMESH_Hypothesis_var aHyp = SMESH::SMESH_Hypothesis::_narrow( hypList[ i ]); SMESH::SMESH_Hypothesis_var aHyp = SMESH::SMESH_Hypothesis::_narrow( hypList[ i ]);
SALOMEDS::SObject_wrap so = PublishHypothesis( theStudy, aHyp ); SALOMEDS::SObject_wrap so = PublishHypothesis( theStudy, aHyp );
@ -710,7 +710,7 @@ SALOMEDS::SObject_ptr SMESH_Gen_i::PublishSubMesh (SALOMEDS::Study_ptr theS
// Publish hypothesis // Publish hypothesis
SMESH::ListOfHypothesis_var hypList = theMesh->GetHypothesisList( theShapeObject ); SMESH::ListOfHypothesis_var hypList = theMesh->GetHypothesisList( theShapeObject );
for ( int i = 0; i < hypList->length(); i++ ) { for ( CORBA::ULong i = 0; i < hypList->length(); i++ ) {
SMESH::SMESH_Hypothesis_var aHyp = SMESH::SMESH_Hypothesis::_narrow( hypList[ i ]); SMESH::SMESH_Hypothesis_var aHyp = SMESH::SMESH_Hypothesis::_narrow( hypList[ i ]);
SALOMEDS::SObject_wrap so = PublishHypothesis( theStudy, aHyp ); SALOMEDS::SObject_wrap so = PublishHypothesis( theStudy, aHyp );
AddHypothesisToShape( theStudy, theMesh, theShapeObject, aHyp ); AddHypothesisToShape( theStudy, theMesh, theShapeObject, aHyp );
@ -742,7 +742,7 @@ SALOMEDS::SObject_ptr SMESH_Gen_i::PublishGroup (SALOMEDS::Study_ptr theStudy
if ( aMeshSO->_is_nil()) if ( aMeshSO->_is_nil())
return SALOMEDS::SObject::_nil(); return SALOMEDS::SObject::_nil();
} }
int aType = (int)theGroup->GetType(); size_t aType = (int)theGroup->GetType();
const char* aRootNames[] = { const char* aRootNames[] = {
"Compound Groups", "Groups of Nodes", "Groups of Edges", "Compound Groups", "Groups of Nodes", "Groups of Edges",
"Groups of Faces", "Groups of Volumes", "Groups of 0D Elements", "Groups of Faces", "Groups of Volumes", "Groups of 0D Elements",

1
src/StdMeshers/CMakeLists.txt
View File

@ -62,6 +62,7 @@ SET(_link_LIBRARIES
${CAS_TKAdvTools} ${CAS_TKAdvTools}
${CAS_TKTopAlgo} ${CAS_TKTopAlgo}
${CAS_TKG3d} ${CAS_TKG3d}
${CAS_TKOffset}
${GEOM_GEOMUtils} ${GEOM_GEOMUtils}
SMESHimpl SMESHimpl
SMESHDS SMESHDS

29
src/StdMeshers/StdMeshers_Adaptive1D.cxx
View File

@ -703,7 +703,7 @@ namespace // internal utils
void ElementBndBoxTree::buildChildrenData() void ElementBndBoxTree::buildChildrenData()
{ {
ElemTreeData* data = GetElemData(); ElemTreeData* data = GetElemData();
for ( int i = 0; i < _elementIDs.size(); ++i ) for ( size_t i = 0; i < _elementIDs.size(); ++i )
{ {
const Bnd_B3d* elemBox = data->GetBox( _elementIDs[i] ); const Bnd_B3d* elemBox = data->GetBox( _elementIDs[i] );
for (int j = 0; j < 8; j++) for (int j = 0; j < 8; j++)
@ -718,7 +718,7 @@ namespace // internal utils
{ {
ElementBndBoxTree* child = static_cast<ElementBndBoxTree*>( myChildren[j] ); ElementBndBoxTree* child = static_cast<ElementBndBoxTree*>( myChildren[j] );
child->_elementIDs = data->myWorkIDs[ j ]; child->_elementIDs = data->myWorkIDs[ j ];
if ( child->_elementIDs.size() <= theMaxNbElemsInLeaf ) if ((int) child->_elementIDs.size() <= theMaxNbElemsInLeaf )
child->myIsLeaf = true; child->myIsLeaf = true;
data->myWorkIDs[ j ].clear(); data->myWorkIDs[ j ].clear();
} }
@ -741,7 +741,7 @@ namespace // internal utils
if ( isLeaf() ) if ( isLeaf() )
{ {
ElemTreeData* data = GetElemData(); ElemTreeData* data = GetElemData();
for ( int i = 0; i < _elementIDs.size(); ++i ) for ( size_t i = 0; i < _elementIDs.size(); ++i )
if ( !data->GetBox( _elementIDs[i] )->IsOut( center, radius )) if ( !data->GetBox( _elementIDs[i] )->IsOut( center, radius ))
foundElemIDs.push_back( _elementIDs[i] ); foundElemIDs.push_back( _elementIDs[i] );
} }
@ -1197,7 +1197,7 @@ bool AdaptiveAlgo::Compute(SMESH_Mesh & theMesh,
StdMeshers_Regular_1D::_value[ DEFLECTION_IND ] = myHyp->GetDeflection(); StdMeshers_Regular_1D::_value[ DEFLECTION_IND ] = myHyp->GetDeflection();
list< double > params; list< double > params;
for ( int iE = 0; iE < myEdges.size(); ++iE ) for ( size_t iE = 0; iE < myEdges.size(); ++iE )
{ {
EdgeData& eData = myEdges[ iE ]; EdgeData& eData = myEdges[ iE ];
//cout << "E " << theMesh.GetMeshDS()->ShapeToIndex( eData.Edge() ) << endl; //cout << "E " << theMesh.GetMeshDS()->ShapeToIndex( eData.Edge() ) << endl;
@ -1243,7 +1243,7 @@ bool AdaptiveAlgo::Compute(SMESH_Mesh & theMesh,
triaSearcher->SetSizeByTrias( sizeTree, myHyp->GetDeflection() ); triaSearcher->SetSizeByTrias( sizeTree, myHyp->GetDeflection() );
for ( int iE = 0; iE < myEdges.size(); ++iE ) for ( size_t iE = 0; iE < myEdges.size(); ++iE )
{ {
EdgeData& eData = myEdges[ iE ]; EdgeData& eData = myEdges[ iE ];
@ -1260,7 +1260,7 @@ bool AdaptiveAlgo::Compute(SMESH_Mesh & theMesh,
double maxSegSize = 0; double maxSegSize = 0;
// get points to check distance to the face // get points to check distance to the face
EdgeData::TPntIter pIt2 = eData.myPoints.begin(), pIt1 = pIt2++, pItLast; EdgeData::TPntIter pIt2 = eData.myPoints.begin(), pIt1 = pIt2++;
maxSegSize = pIt1->mySegSize = Min( pIt1->mySegSize, sizeTree.GetSize( pIt1->myP )); maxSegSize = pIt1->mySegSize = Min( pIt1->mySegSize, sizeTree.GetSize( pIt1->myP ));
for ( ; pIt2 != eData.myPoints.end(); ) for ( ; pIt2 != eData.myPoints.end(); )
{ {
@ -1290,7 +1290,7 @@ bool AdaptiveAlgo::Compute(SMESH_Mesh & theMesh,
//cout << "E " << theMesh.GetMeshDS()->ShapeToIndex( eData.Edge() ) << endl; //cout << "E " << theMesh.GetMeshDS()->ShapeToIndex( eData.Edge() ) << endl;
sizeDecreased = false; sizeDecreased = false;
const gp_Pnt* avoidPnt = & eData.First().myP; const gp_Pnt* avoidPnt = & eData.First().myP;
pItLast = --eData.myPoints.end(); EdgeData::TPntIter pItLast = --eData.myPoints.end(), pItFirst = eData.myPoints.begin();
for ( pIt1 = eData.myPoints.begin(); pIt1 != eData.myPoints.end(); ) for ( pIt1 = eData.myPoints.begin(); pIt1 != eData.myPoints.end(); )
{ {
double distToFace = double distToFace =
@ -1308,19 +1308,16 @@ bool AdaptiveAlgo::Compute(SMESH_Mesh & theMesh,
// << "\t SetSize " << allowedSize << " at " // << "\t SetSize " << allowedSize << " at "
// << pIt1->myP.X() <<", "<< pIt1->myP.Y()<<", "<<pIt1->myP.Z() << endl; // << pIt1->myP.X() <<", "<< pIt1->myP.Y()<<", "<<pIt1->myP.Z() << endl;
pIt2 = pIt1; pIt2 = pIt1;
if ( --pIt2 != eData.myPoints.end() && pIt2->mySegSize > allowedSize ) if ( pIt1 != pItFirst && ( --pIt2 )->mySegSize > allowedSize )
sizeTree.SetSize( eData.myC3d.Value( 0.6*pIt2->myU + 0.4*pIt1->myU ), allowedSize ); sizeTree.SetSize( eData.myC3d.Value( 0.6*pIt2->myU + 0.4*pIt1->myU ), allowedSize );
pIt2 = pIt1; pIt2 = pIt1;
if ( ++pIt2 != eData.myPoints.end() && pIt2->mySegSize > allowedSize ) if ( pIt1 != pItLast && ( ++pIt2 )->mySegSize > allowedSize )
sizeTree.SetSize( eData.myC3d.Value( 0.6*pIt2->myU + 0.4*pIt1->myU ), allowedSize ); sizeTree.SetSize( eData.myC3d.Value( 0.6*pIt2->myU + 0.4*pIt1->myU ), allowedSize );
} }
pIt1->mySegSize = allowedSize; pIt1->mySegSize = allowedSize;
} }
++pIt1; ++pIt1;
if ( pIt1 == pItLast ) avoidPnt = ( pIt1 == pItLast ) ? & eData.Last().myP : NULL;
avoidPnt = & eData.Last().myP;
else
avoidPnt = NULL;
if ( iLoop > 20 ) if ( iLoop > 20 )
{ {
@ -1357,7 +1354,7 @@ bool AdaptiveAlgo::makeSegments()
vector< double > nbSegs, params; vector< double > nbSegs, params;
for ( int iE = 0; iE < myEdges.size(); ++iE ) for ( size_t iE = 0; iE < myEdges.size(); ++iE )
{ {
EdgeData& eData = myEdges[ iE ]; EdgeData& eData = myEdges[ iE ];
@ -1371,7 +1368,7 @@ bool AdaptiveAlgo::makeSegments()
const double f = eData.myC3d.FirstParameter(), l = eData.myC3d.LastParameter(); const double f = eData.myC3d.FirstParameter(), l = eData.myC3d.LastParameter();
const double parLen = l - f; const double parLen = l - f;
const int nbDivSeg = 5; const int nbDivSeg = 5;
int nbDiv = Max( 1, int ( eData.myLength / edgeMinSize * nbDivSeg )); size_t nbDiv = Max( 1, int ( eData.myLength / edgeMinSize * nbDivSeg ));
// compute nb of segments // compute nb of segments
bool toRecompute = true; bool toRecompute = true;
@ -1432,7 +1429,7 @@ bool AdaptiveAlgo::makeSegments()
} }
// compute parameters of nodes // compute parameters of nodes
int nbSegFinal = Max( 1, int(floor( nbSegs.back() + 0.5 ))); size_t nbSegFinal = Max( 1, int(floor( nbSegs.back() + 0.5 )));
double fact = nbSegFinal / nbSegs.back(); double fact = nbSegFinal / nbSegs.back();
if ( maxSegSize / fact > myHyp->GetMaxSize() ) if ( maxSegSize / fact > myHyp->GetMaxSize() )
fact = ++nbSegFinal / nbSegs.back(); fact = ++nbSegFinal / nbSegs.back();

6
src/StdMeshers/StdMeshers_CartesianParameters3D.cxx
View File

@ -240,6 +240,7 @@ bool StdMeshers_CartesianParameters3D::GetFixedPoint(double p[3]) const
if ( Precision::IsInfinite( _fixedPoint[0] )) if ( Precision::IsInfinite( _fixedPoint[0] ))
return false; return false;
std::copy( &_fixedPoint[0], &_fixedPoint[0]+3, &p[0] ); std::copy( &_fixedPoint[0], &_fixedPoint[0]+3, &p[0] );
return true;
} }
@ -371,7 +372,7 @@ void StdMeshers_CartesianParameters3D::ComputeCoordinates(const double x0,
// correct coords if a forced point is too close to a neighbor node // correct coords if a forced point is too close to a neighbor node
if ( forced ) if ( forced )
{ {
int iF = 0; size_t iF = 0;
double minLen = ( x1 - x0 ); double minLen = ( x1 - x0 );
for ( size_t i = 1; i < coords.size(); ++i ) for ( size_t i = 1; i < coords.size(); ++i )
{ {
@ -522,9 +523,8 @@ ComputeOptimalAxesDirs(const TopoDS_Shape& shape,
const TCooTriple* norm1 = 0; const TCooTriple* norm1 = 0;
double sumArea = 0; double sumArea = 0;
vector< const TCooTriple* > norms; vector< const TCooTriple* > norms;
for ( int iF = 1; norm2a != areasByNormal.end(); ++norm2a, ++iF ) for ( size_t iF = 1; norm2a != areasByNormal.end(); ++norm2a, ++iF )
{ {
if ( !norm1 || !sameDir( *norm1, norm2a->first )) if ( !norm1 || !sameDir( *norm1, norm2a->first ))
{ {
if ( !norms.empty() ) if ( !norms.empty() )

4
src/StdMeshers/StdMeshers_Cartesian_3D.cxx
View File

@ -2731,7 +2731,7 @@ namespace
chn.back()->IsLinked( quad._eIntNodes[ iP ]->_intPoint )) chn.back()->IsLinked( quad._eIntNodes[ iP ]->_intPoint ))
{ {
chn.push_back( quad._eIntNodes[ iP ]); chn.push_back( quad._eIntNodes[ iP ]);
found = quad._eIntNodes[ iP ]->_usedInFace = &quad; found = ( quad._eIntNodes[ iP ]->_usedInFace = &quad );
break; break;
} }
} while ( found && ! chn.back()->IsLinked( n2->_intPoint ) ); } while ( found && ! chn.back()->IsLinked( n2->_intPoint ) );
@ -2823,7 +2823,7 @@ namespace
( !avoidFace || quad._eIntNodes[ iP ]->IsOnFace( avoidFace ))) ( !avoidFace || quad._eIntNodes[ iP ]->IsOnFace( avoidFace )))
{ {
chn.push_back( quad._eIntNodes[ iP ]); chn.push_back( quad._eIntNodes[ iP ]);
found = quad._eIntNodes[ iP ]->_usedInFace = &quad; found = ( quad._eIntNodes[ iP ]->_usedInFace = &quad );
break; break;
} }
} while ( found ); } while ( found );

6
src/StdMeshers/StdMeshers_CompositeHexa_3D.cxx
View File

@ -62,9 +62,7 @@
#ifdef _DEBUG_ #ifdef _DEBUG_
// #define DEB_FACES // #define DEB_FACES
// #define DEB_GRID // #define DEB_GRID
// #define DUMP_VERT(msg,V) \ // #define DUMP_VERT(msg,V) { TopoDS_Vertex v = V; gp_Pnt p = BRep_Tool::Pnt(v); cout << msg << "( "<< p.X()<<", "<<p.Y()<<", "<<p.Z()<<" )"<<endl; }
// { TopoDS_Vertex v = V; gp_Pnt p = BRep_Tool::Pnt(v); \
// cout << msg << "( "<< p.X()<<", "<<p.Y()<<", "<<p.Z()<<" )"<<endl;}
#endif #endif
#ifndef DUMP_VERT #ifndef DUMP_VERT
@ -1150,7 +1148,7 @@ bool _QuadFaceGrid::LoadGrid( SMESH_Mesh& mesh )
TIDSortedElemSet emptySet, avoidSet; TIDSortedElemSet emptySet, avoidSet;
const SMDS_MeshElement* firstQuad = 0; // most left face above the last row of found nodes const SMDS_MeshElement* firstQuad = 0; // most left face above the last row of found nodes
int nbFoundNodes = myIndexer._xSize; size_t nbFoundNodes = myIndexer._xSize;
while ( nbFoundNodes != myGrid.size() ) while ( nbFoundNodes != myGrid.size() )
{ {
// first and last nodes of the last filled row of nodes // first and last nodes of the last filled row of nodes

26
src/StdMeshers/StdMeshers_CompositeSegment_1D.cxx
View File

@ -25,18 +25,18 @@
// Module : SMESH // Module : SMESH
// //
#include "StdMeshers_CompositeSegment_1D.hxx" #include "StdMeshers_CompositeSegment_1D.hxx"
#include "StdMeshers_FaceSide.hxx"
#include "StdMeshers_AutomaticLength.hxx"
#include "SMESH_Gen.hxx"
#include "SMESH_Mesh.hxx"
#include "SMESH_HypoFilter.hxx"
#include "SMESH_subMesh.hxx"
#include "SMESH_subMeshEventListener.hxx"
#include "SMESH_Comment.hxx"
#include "SMDS_MeshElement.hxx" #include "SMDS_MeshElement.hxx"
#include "SMDS_MeshNode.hxx" #include "SMDS_MeshNode.hxx"
#include "SMESH_Comment.hxx"
#include "SMESH_Gen.hxx"
#include "SMESH_HypoFilter.hxx"
#include "SMESH_Mesh.hxx"
#include "SMESH_TypeDefs.hxx"
#include "SMESH_subMesh.hxx"
#include "SMESH_subMeshEventListener.hxx"
#include "StdMeshers_AutomaticLength.hxx"
#include "StdMeshers_FaceSide.hxx"
#include "utilities.h" #include "utilities.h"
@ -173,7 +173,7 @@ namespace {
// check if an edge is a part of a complex side // check if an edge is a part of a complex side
TopoDS_Face face; TopoDS_Face face;
TopoDS_Edge edge = TopoDS::Edge( subMesh->GetSubShape() ); TopoDS_Edge edge = TopoDS::Edge( subMesh->GetSubShape() );
auto_ptr< StdMeshers_FaceSide > side SMESHUtils::Deleter< StdMeshers_FaceSide > side
( StdMeshers_CompositeSegment_1D::GetFaceSide(*subMesh->GetFather(), ( StdMeshers_CompositeSegment_1D::GetFaceSide(*subMesh->GetFather(),
edge, face, false )); edge, face, false ));
if ( side->NbEdges() > 1 && side->NbSegments() ) if ( side->NbEdges() > 1 && side->NbSegments() )
@ -287,7 +287,7 @@ void StdMeshers_CompositeSegment_1D::SetEventListener(SMESH_subMesh* subMesh)
// check if an edge is a part of a complex side // check if an edge is a part of a complex side
TopoDS_Face face; TopoDS_Face face;
TopoDS_Edge edge = TopoDS::Edge( subMesh->GetSubShape() ); TopoDS_Edge edge = TopoDS::Edge( subMesh->GetSubShape() );
auto_ptr< StdMeshers_FaceSide > side SMESHUtils::Deleter< StdMeshers_FaceSide > side
( StdMeshers_CompositeSegment_1D::GetFaceSide( *subMesh->GetFather(), edge, face, false )); ( StdMeshers_CompositeSegment_1D::GetFaceSide( *subMesh->GetFather(), edge, face, false ));
if ( side->NbEdges() > 1 ) { // complex if ( side->NbEdges() > 1 ) { // complex
@ -368,7 +368,7 @@ bool StdMeshers_CompositeSegment_1D::Compute(SMESH_Mesh & aMesh,
// Get edges to be discretized as a whole // Get edges to be discretized as a whole
TopoDS_Face nullFace; TopoDS_Face nullFace;
auto_ptr< StdMeshers_FaceSide > side( GetFaceSide(aMesh, edge, nullFace, true )); SMESHUtils::Deleter< StdMeshers_FaceSide > side( GetFaceSide(aMesh, edge, nullFace, true ));
//side->dump("IN COMPOSITE SEG"); //side->dump("IN COMPOSITE SEG");
if ( side->NbEdges() < 2 ) if ( side->NbEdges() < 2 )
@ -384,7 +384,7 @@ bool StdMeshers_CompositeSegment_1D::Compute(SMESH_Mesh & aMesh,
} }
// Compute node parameters // Compute node parameters
auto_ptr< BRepAdaptor_CompCurve > C3d ( side->GetCurve3d() ); SMESHUtils::Deleter< BRepAdaptor_CompCurve > C3d ( side->GetCurve3d() );
double f = C3d->FirstParameter(), l = C3d->LastParameter(); double f = C3d->FirstParameter(), l = C3d->LastParameter();
list< double > params; list< double > params;
if ( !computeInternalParameters ( aMesh, *C3d, side->Length(), f, l, params, false )) if ( !computeInternalParameters ( aMesh, *C3d, side->Length(), f, l, params, false ))

4
src/StdMeshers/StdMeshers_Hexa_3D.cxx
View File

@ -504,8 +504,8 @@ bool StdMeshers_Hexa_3D::Compute(SMESH_Mesh & aMesh,
{ {
aCubeSide[i]._columns.resize( aCubeSide[i]._u2nodesMap.size() ); aCubeSide[i]._columns.resize( aCubeSide[i]._u2nodesMap.size() );
int iFwd = 0, iRev = aCubeSide[i]._columns.size()-1; size_t iFwd = 0, iRev = aCubeSide[i]._columns.size()-1;
int* pi = isReverse[i] ? &iRev : &iFwd; size_t* pi = isReverse[i] ? &iRev : &iFwd;
TParam2ColumnMap::iterator u2nn = aCubeSide[i]._u2nodesMap.begin(); TParam2ColumnMap::iterator u2nn = aCubeSide[i]._u2nodesMap.begin();
for ( ; iFwd < aCubeSide[i]._columns.size(); --iRev, ++iFwd, ++u2nn ) for ( ; iFwd < aCubeSide[i]._columns.size(); --iRev, ++iFwd, ++u2nn )
aCubeSide[i]._columns[ *pi ].swap( u2nn->second ); aCubeSide[i]._columns[ *pi ].swap( u2nn->second );

10
src/StdMeshers/StdMeshers_ImportSource.cxx
View File

@ -125,14 +125,14 @@ namespace
bool loaded=false) bool loaded=false)
{ {
vector<SMESH_Group*> okGroups; vector<SMESH_Group*> okGroups;
for ( int i = 0; i < groups.size(); ++i ) for ( size_t i = 0; i < groups.size(); ++i )
{ {
try try
{ {
// we expect SIGSEGV on a dead group // we expect SIGSEGV on a dead group
OCC_CATCH_SIGNALS; OCC_CATCH_SIGNALS;
SMESH_Group* okGroup = 0; SMESH_Group* okGroup = 0;
map<int, SMESH_Mesh*>::iterator itm = itm = studyContext->mapMesh.begin(); map<int, SMESH_Mesh*>::iterator itm = studyContext->mapMesh.begin();
for ( ; !okGroup && itm != studyContext->mapMesh.end(); itm++) for ( ; !okGroup && itm != studyContext->mapMesh.end(); itm++)
{ {
SMESH_Mesh::GroupIteratorPtr gIt = itm->second->GetGroups(); SMESH_Mesh::GroupIteratorPtr gIt = itm->second->GetGroups();
@ -174,7 +174,7 @@ namespace
{ {
int tgtID = resMapKey.second; int tgtID = resMapKey.second;
SMESH_Mesh* tgtMesh = 0; SMESH_Mesh* tgtMesh = 0;
map<int, SMESH_Mesh*>::iterator itm = itm = studyContext->mapMesh.begin(); map<int, SMESH_Mesh*>::iterator itm = studyContext->mapMesh.begin();
for ( ; !tgtMesh && itm != studyContext->mapMesh.end(); itm++) for ( ; !tgtMesh && itm != studyContext->mapMesh.end(); itm++)
{ {
tgtMesh = (*itm).second; tgtMesh = (*itm).second;
@ -250,7 +250,7 @@ std::vector<SMESH_Mesh*> StdMeshers_ImportSource1D::GetSourceMeshes() const
StudyContextStruct* studyContext = _gen->GetStudyContext(_studyId); StudyContextStruct* studyContext = _gen->GetStudyContext(_studyId);
for ( set<int>::iterator id = meshIDs.begin(); id != meshIDs.end(); ++id ) for ( set<int>::iterator id = meshIDs.begin(); id != meshIDs.end(); ++id )
{ {
map<int, SMESH_Mesh*>::iterator itm = itm = studyContext->mapMesh.begin(); map<int, SMESH_Mesh*>::iterator itm = studyContext->mapMesh.begin();
for ( ; itm != studyContext->mapMesh.end(); itm++) for ( ; itm != studyContext->mapMesh.end(); itm++)
{ {
SMESH_Mesh* mesh = (*itm).second; SMESH_Mesh* mesh = (*itm).second;
@ -394,7 +394,7 @@ void StdMeshers_ImportSource1D::RestoreGroups(const std::vector<SMESH_Group*>& g
_groups = groups; _groups = groups;
_resultGroups.clear(); _resultGroups.clear();
int i = 0; size_t i = 0;
while ( i < _resultGroupsStorage.size() ) while ( i < _resultGroupsStorage.size() )
{ {
int key1 = _resultGroupsStorage[i++]; int key1 = _resultGroupsStorage[i++];

39
src/StdMeshers/StdMeshers_ProjectionUtils.cxx
View File

@ -79,23 +79,9 @@ using namespace std;
#define RETURN_BAD_RESULT(msg) { MESSAGE(")-: Error: " << msg); return false; } #define RETURN_BAD_RESULT(msg) { MESSAGE(")-: Error: " << msg); return false; }
#define CONT_BAD_RESULT(msg) { MESSAGE(")-: Error: " << msg); continue; } #define CONT_BAD_RESULT(msg) { MESSAGE(")-: Error: " << msg); continue; }
#define SHOW_SHAPE(v,msg) \ #define SHOW_SHAPE(v,msg) \
// { \ // { show_shape((v),(msg)); }
// if ( (v).IsNull() ) cout << msg << " NULL SHAPE" << endl; \
// else if ((v).ShapeType() == TopAbs_VERTEX) {\
// gp_Pnt p = BRep_Tool::Pnt( TopoDS::Vertex( (v) ));\
// cout<<msg<<" "<<shapeIndex((v))<<" ( "<<p.X()<<", "<<p.Y()<<", "<<p.Z()<<" )"<<endl;} \
// else {\
// cout << msg << " "; TopAbs::Print((v).ShapeType(),cout) <<" "<<shapeIndex((v))<<endl;}\
// }
#define SHOW_LIST(msg,l) \ #define SHOW_LIST(msg,l) \
// { \ // { show_list((msg),(l)); }
// cout << msg << " ";\
// list< TopoDS_Edge >::const_iterator e = l.begin();\
// for ( int i = 0; e != l.end(); ++e, ++i ) {\
// cout << i << "V (" << TopExp::FirstVertex( *e, true ).TShape().operator->() << ") "\
// << i << "E (" << e->TShape().operator->() << "); "; }\
// cout << endl;\
// }
namespace HERE = StdMeshers_ProjectionUtils; namespace HERE = StdMeshers_ProjectionUtils;
@ -108,7 +94,24 @@ namespace {
return max(theMeshDS[0]->ShapeToIndex(S), theMeshDS[1]->ShapeToIndex(S) ); return max(theMeshDS[0]->ShapeToIndex(S), theMeshDS[1]->ShapeToIndex(S) );
return long(S.TShape().operator->()); return long(S.TShape().operator->());
} }
void show_shape( TopoDS_Shape v, const char* msg ) // debug
{
if ( v.IsNull() ) cout << msg << " NULL SHAPE" << endl;
else if (v.ShapeType() == TopAbs_VERTEX) {
gp_Pnt p = BRep_Tool::Pnt( TopoDS::Vertex( v ));
cout<<msg<<" "<<shapeIndex((v))<<" ( "<<p.X()<<", "<<p.Y()<<", "<<p.Z()<<" )"<<endl;}
else {
cout << msg << " "; TopAbs::Print((v).ShapeType(),cout) <<" "<<shapeIndex((v))<<endl;}
}
void show_list( const char* msg, const list< TopoDS_Edge >& l ) // debug
{
cout << msg << " ";
list< TopoDS_Edge >::const_iterator e = l.begin();
for ( int i = 0; e != l.end(); ++e, ++i ) {
cout << i << "V (" << TopExp::FirstVertex( *e, true ).TShape().operator->() << ") "
<< i << "E (" << e->TShape().operator->() << "); "; }
cout << endl;
}
//================================================================================ //================================================================================
/*! /*!
* \brief Write shape for debug purposes * \brief Write shape for debug purposes
@ -2180,7 +2183,7 @@ FindMatchingNodesOnFaces( const TopoDS_Face& face1,
static_cast<const SMDS_EdgePosition*>(node->GetPosition()); static_cast<const SMDS_EdgePosition*>(node->GetPosition());
pos2nodes.insert( make_pair( pos->GetUParameter(), node )); pos2nodes.insert( make_pair( pos->GetUParameter(), node ));
} }
if ( pos2nodes.size() != edgeSM->NbNodes() ) if ((int) pos2nodes.size() != edgeSM->NbNodes() )
RETURN_BAD_RESULT("Equal params of nodes on edge " RETURN_BAD_RESULT("Equal params of nodes on edge "
<< smDS->ShapeToIndex( edge ) << " of face " << is2 ); << smDS->ShapeToIndex( edge ) << " of face " << is2 );
} }

13
src/StdMeshers/StdMeshers_Projection_2D.cxx
View File

@ -423,15 +423,13 @@ namespace {
TAssocTool::TNodeNodeMap& src2tgtNodes, TAssocTool::TNodeNodeMap& src2tgtNodes,
bool& is1DComputed) bool& is1DComputed)
{ {
SMESHDS_Mesh* tgtMeshDS = tgtMesh->GetMeshDS();
SMESHDS_Mesh* srcMeshDS = srcMesh->GetMeshDS();
src2tgtNodes.clear(); src2tgtNodes.clear();
// get ordered src EDGEs // get ordered src EDGEs
TError err; TError err;
srcWires = StdMeshers_FaceSide::GetFaceWires( srcFace, *srcMesh,/*skipMediumNodes=*/0, err); srcWires = StdMeshers_FaceSide::GetFaceWires( srcFace, *srcMesh,/*skipMediumNodes=*/0, err);
if ( err && !err->IsOK() || srcWires.empty() ) if (( err && !err->IsOK() ) ||
( srcWires.empty() ))
return err; return err;
SMESH_MesherHelper srcHelper( *srcMesh ); SMESH_MesherHelper srcHelper( *srcMesh );
@ -591,7 +589,7 @@ namespace {
const double minSegLen = srcWires[iW]->Length() / totNbSeg; const double minSegLen = srcWires[iW]->Length() / totNbSeg;
for ( int iE = 0; iE < srcWires[iW]->NbEdges(); ++iE ) for ( int iE = 0; iE < srcWires[iW]->NbEdges(); ++iE )
{ {
int nbSeg = Max( 1, int( srcWires[iW]->EdgeLength( iE ) / minSegLen )); size_t nbSeg = Max( 1, int( srcWires[iW]->EdgeLength( iE ) / minSegLen ));
double srcU = srcWires[iW]->FirstParameter( iE ); double srcU = srcWires[iW]->FirstParameter( iE );
double tgtU = tgtWires[iW]->FirstParameter( iE ); double tgtU = tgtWires[iW]->FirstParameter( iE );
double srcDu = ( srcWires[iW]->LastParameter( iE )- srcU ) / nbSeg; double srcDu = ( srcWires[iW]->LastParameter( iE )- srcU ) / nbSeg;
@ -830,7 +828,7 @@ namespace {
const double minSegLen = srcWires[iW]->Length() / totNbSeg; const double minSegLen = srcWires[iW]->Length() / totNbSeg;
for ( int iE = 0; iE < srcWires[iW]->NbEdges(); ++iE ) for ( int iE = 0; iE < srcWires[iW]->NbEdges(); ++iE )
{ {
int nbSeg = Max( 1, int( srcWires[iW]->EdgeLength( iE ) / minSegLen )); size_t nbSeg = Max( 1, int( srcWires[iW]->EdgeLength( iE ) / minSegLen ));
double srcU = srcWires[iW]->FirstParameter( iE ); double srcU = srcWires[iW]->FirstParameter( iE );
double tgtU = tgtWires[iW]->FirstParameter( iE ); double tgtU = tgtWires[iW]->FirstParameter( iE );
double srcDu = ( srcWires[iW]->LastParameter( iE )- srcU ) / nbSeg; double srcDu = ( srcWires[iW]->LastParameter( iE )- srcU ) / nbSeg;
@ -920,6 +918,7 @@ namespace {
tgtMeshDS->SetNodeOnVertex( n, TopoDS::Vertex( tgtV )); tgtMeshDS->SetNodeOnVertex( n, TopoDS::Vertex( tgtV ));
break; break;
} }
default:;
} }
srcN_tgtN->second = n; srcN_tgtN->second = n;
} }
@ -952,7 +951,7 @@ namespace {
{ {
SMESH_Mesh * tgtMesh = tgtWires[0]->GetMesh(); SMESH_Mesh * tgtMesh = tgtWires[0]->GetMesh();
SMESH_Mesh * srcMesh = srcWires[0]->GetMesh(); SMESH_Mesh * srcMesh = srcWires[0]->GetMesh();
SMESHDS_Mesh * tgtMeshDS = tgtMesh->GetMeshDS(); //SMESHDS_Mesh * tgtMeshDS = tgtMesh->GetMeshDS();
SMESHDS_Mesh * srcMeshDS = srcMesh->GetMeshDS(); SMESHDS_Mesh * srcMeshDS = srcMesh->GetMeshDS();
if ( srcWires[0]->NbEdges() != 4 ) if ( srcWires[0]->NbEdges() != 4 )

11
src/StdMeshers/StdMeshers_QuadToTriaAdaptor.cxx
View File

@ -556,9 +556,9 @@ bool StdMeshers_QuadToTriaAdaptor::CheckIntersection (const gp_Pnt& P,
vector< const SMDS_MeshElement* > suspectElems; vector< const SMDS_MeshElement* > suspectElems;
searcher->GetElementsNearLine( line, SMDSAbs_Face, suspectElems); searcher->GetElementsNearLine( line, SMDSAbs_Face, suspectElems);
for ( int i = 0; i < suspectElems.size(); ++i ) for ( size_t iF = 0; iF < suspectElems.size(); ++iF )
{ {
const SMDS_MeshElement* face = suspectElems[i]; const SMDS_MeshElement* face = suspectElems[iF];
if ( face == NotCheckedFace ) continue; if ( face == NotCheckedFace ) continue;
Handle(TColgp_HSequenceOfPnt) aContour = new TColgp_HSequenceOfPnt; Handle(TColgp_HSequenceOfPnt) aContour = new TColgp_HSequenceOfPnt;
for ( int i = 0; i < face->NbCornerNodes(); ++i ) for ( int i = 0; i < face->NbCornerNodes(); ++i )
@ -986,7 +986,7 @@ bool StdMeshers_QuadToTriaAdaptor::Compute(SMESH_Mesh& aMesh)
vector< const SMDS_MeshElement* > suspectElems; vector< const SMDS_MeshElement* > suspectElems;
searcher->GetElementsNearLine( line, SMDSAbs_Face, suspectElems); searcher->GetElementsNearLine( line, SMDSAbs_Face, suspectElems);
for ( int iF = 0; iF < suspectElems.size(); ++iF ) { for ( size_t iF = 0; iF < suspectElems.size(); ++iF ) {
const SMDS_MeshElement* F = suspectElems[iF]; const SMDS_MeshElement* F = suspectElems[iF];
if ( F == face ) continue; if ( F == face ) continue;
Handle(TColgp_HSequenceOfPnt) aContour = new TColgp_HSequenceOfPnt; Handle(TColgp_HSequenceOfPnt) aContour = new TColgp_HSequenceOfPnt;
@ -1074,7 +1074,7 @@ bool StdMeshers_QuadToTriaAdaptor::Compute(SMESH_Mesh& aMesh)
vector< const SMDS_MeshElement* > suspectElems; vector< const SMDS_MeshElement* > suspectElems;
searcher->GetElementsNearLine( line, SMDSAbs_Face, suspectElems); searcher->GetElementsNearLine( line, SMDSAbs_Face, suspectElems);
for ( int iF = 0; iF < suspectElems.size(); ++iF ) for ( size_t iF = 0; iF < suspectElems.size(); ++iF )
{ {
const SMDS_MeshElement* F = suspectElems[iF]; const SMDS_MeshElement* F = suspectElems[iF];
if ( F == face ) continue; if ( F == face ) continue;
@ -1162,7 +1162,8 @@ bool StdMeshers_QuadToTriaAdaptor::Compute2ndPart(SMESH_Mesh&
return true; return true;
SMESHDS_Mesh * meshDS = aMesh.GetMeshDS(); SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
int i, j, k, myShapeID = myPyramids[0]->GetNode(4)->getshapeId(); size_t i, j, k;
int myShapeID = myPyramids[0]->GetNode(4)->getshapeId();
if ( myElemSearcher ) delete myElemSearcher; if ( myElemSearcher ) delete myElemSearcher;
myElemSearcher = SMESH_MeshAlgos::GetElementSearcher( *meshDS ); myElemSearcher = SMESH_MeshAlgos::GetElementSearcher( *meshDS );

1
src/StdMeshers/StdMeshers_RadialPrism_3D.cxx
View File

@ -598,7 +598,6 @@ bool StdMeshers_RadialPrism_3D::Evaluate(SMESH_Mesh& aMesh,
bool StdMeshers_RadialPrism_3D::IsApplicable( const TopoDS_Shape & aShape, bool toCheckAll ) bool StdMeshers_RadialPrism_3D::IsApplicable( const TopoDS_Shape & aShape, bool toCheckAll )
{ {
bool isCurShellApp;
int nbFoundSolids = 0; int nbFoundSolids = 0;
for (TopExp_Explorer exp( aShape, TopAbs_SOLID ); exp.More(); exp.Next(), ++nbFoundSolids ) for (TopExp_Explorer exp( aShape, TopAbs_SOLID ); exp.More(); exp.Next(), ++nbFoundSolids )
{ {

20
src/StdMeshers/StdMeshers_Regular_1D.cxx
View File

@ -343,9 +343,9 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh& aMesh,
return ( aStatus == SMESH_Hypothesis::HYP_OK ); return ( aStatus == SMESH_Hypothesis::HYP_OK );
} }
static bool computeParamByFunc(Adaptor3d_Curve& C3d, double first, double last, static bool computeParamByFunc(Adaptor3d_Curve& C3d,
double length, bool theReverse, double first, double last, double length,
int nbSeg, Function& func, bool theReverse, int nbSeg, Function& func,
list<double>& theParams) list<double>& theParams)
{ {
// never do this way // never do this way
@ -362,16 +362,6 @@ static bool computeParamByFunc(Adaptor3d_Curve& C3d, double first, double last,
if ( !buildDistribution( func, 0.0, 1.0, nbSeg, x, 1E-4 )) if ( !buildDistribution( func, 0.0, 1.0, nbSeg, x, 1E-4 ))
return false; return false;
MESSAGE( "Points:\n" );
char buf[1024];
for ( int i=0; i<=nbSeg; i++ )
{
sprintf( buf, "%f\n", float(x[i] ) );
MESSAGE( buf );
}
// apply parameters in range [0,1] to the space of the curve // apply parameters in range [0,1] to the space of the curve
double prevU = first; double prevU = first;
double sign = 1.; double sign = 1.;
@ -380,10 +370,12 @@ static bool computeParamByFunc(Adaptor3d_Curve& C3d, double first, double last,
prevU = last; prevU = last;
sign = -1.; sign = -1.;
} }
for ( int i = 1; i < nbSeg; i++ ) for ( int i = 1; i < nbSeg; i++ )
{ {
double curvLength = length * (x[i] - x[i-1]) * sign; double curvLength = length * (x[i] - x[i-1]) * sign;
GCPnts_AbscissaPoint Discret( C3d, curvLength, prevU ); double tol = Min( Precision::Confusion(), curvLength / 100. );
GCPnts_AbscissaPoint Discret( tol, C3d, curvLength, prevU );
if ( !Discret.IsDone() ) if ( !Discret.IsDone() )
return false; return false;
double U = Discret.Parameter(); double U = Discret.Parameter();

18
src/StdMeshers_I/StdMeshers_NumberOfSegments_i.cxx
View File

@ -88,7 +88,7 @@ SMESH::double_array* StdMeshers_NumberOfSegments_i::BuildDistributionExpr( const
SMESH::double_array_var aRes = new SMESH::double_array(); SMESH::double_array_var aRes = new SMESH::double_array();
const std::vector<double>& res = this->GetImpl()->BuildDistributionExpr( func, nbSeg, conv ); const std::vector<double>& res = this->GetImpl()->BuildDistributionExpr( func, nbSeg, conv );
aRes->length( res.size() ); aRes->length( res.size() );
for (int i = 0; i < res.size(); i++) for (size_t i = 0; i < res.size(); i++)
aRes[i] = res[i]; aRes[i] = res[i];
return aRes._retn(); return aRes._retn();
} }
@ -98,7 +98,8 @@ SMESH::double_array* StdMeshers_NumberOfSegments_i::BuildDistributionExpr( const
} }
} }
SMESH::double_array* StdMeshers_NumberOfSegments_i::BuildDistributionTab( const SMESH::double_array& func, SMESH::double_array*
StdMeshers_NumberOfSegments_i::BuildDistributionTab( const SMESH::double_array& func,
CORBA::Long nbSeg, CORBA::Long nbSeg,
CORBA::Long conv ) CORBA::Long conv )
throw ( SALOME::SALOME_Exception ) throw ( SALOME::SALOME_Exception )
@ -106,7 +107,7 @@ SMESH::double_array* StdMeshers_NumberOfSegments_i::BuildDistributionTab( const
ASSERT( myBaseImpl ); ASSERT( myBaseImpl );
std::vector<double> tbl( func.length() ); std::vector<double> tbl( func.length() );
for (int i = 0; i < func.length(); i++) for ( size_t i = 0; i < tbl.size(); i++ )
tbl[i] = func[i]; tbl[i] = func[i];
try try
@ -114,7 +115,7 @@ SMESH::double_array* StdMeshers_NumberOfSegments_i::BuildDistributionTab( const
SMESH::double_array_var aRes = new SMESH::double_array(); SMESH::double_array_var aRes = new SMESH::double_array();
const std::vector<double>& res = this->GetImpl()->BuildDistributionTab( tbl, nbSeg, conv ); const std::vector<double>& res = this->GetImpl()->BuildDistributionTab( tbl, nbSeg, conv );
aRes->length( res.size() ); aRes->length( res.size() );
for (int i = 0; i < res.size(); i++) for (size_t i = 0; i < res.size(); i++)
aRes[i] = res[i]; aRes[i] = res[i];
return aRes._retn(); return aRes._retn();
} }
@ -251,7 +252,7 @@ SMESH::long_array* StdMeshers_NumberOfSegments_i::GetReversedEdges()
SMESH::long_array_var anArray = new SMESH::long_array; SMESH::long_array_var anArray = new SMESH::long_array;
std::vector<int> ids = this->GetImpl()->GetReversedEdges(); std::vector<int> ids = this->GetImpl()->GetReversedEdges();
anArray->length( ids.size() ); anArray->length( ids.size() );
for ( CORBA::Long i = 0; i < ids.size(); i++) for ( size_t i = 0; i < ids.size(); i++)
anArray [ i ] = ids [ i ]; anArray [ i ] = ids [ i ];
return anArray._retn(); return anArray._retn();
@ -348,7 +349,7 @@ void StdMeshers_NumberOfSegments_i::SetTableFunction(const SMESH::double_array&
{ {
ASSERT( myBaseImpl ); ASSERT( myBaseImpl );
std::vector<double> tbl( table.length() ); std::vector<double> tbl( table.length() );
for (int i = 0; i < table.length(); i++) for ( CORBA::ULong i = 0; i < table.length(); i++)
tbl[i] = table[i]; tbl[i] = table[i];
try { try {
this->GetImpl()->SetTableFunction( tbl ); this->GetImpl()->SetTableFunction( tbl );
@ -375,12 +376,11 @@ SMESH::double_array* StdMeshers_NumberOfSegments_i::GetTableFunction()
tbl = &this->GetImpl()->GetTableFunction(); tbl = &this->GetImpl()->GetTableFunction();
} }
catch ( SALOME_Exception& S_ex ) { catch ( SALOME_Exception& S_ex ) {
THROW_SALOME_CORBA_EXCEPTION( S_ex.what(), THROW_SALOME_CORBA_EXCEPTION( S_ex.what(), SALOME::BAD_PARAM );
SALOME::BAD_PARAM );
} }
SMESH::double_array_var aRes = new SMESH::double_array(); SMESH::double_array_var aRes = new SMESH::double_array();
aRes->length(tbl->size()); aRes->length(tbl->size());
for (int i = 0; i < tbl->size(); i++) for ( size_t i = 0; i < tbl->size(); i++ )
aRes[i] = (*tbl)[i]; aRes[i] = (*tbl)[i];
return aRes._retn(); return aRes._retn();
} }