ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-01-14 02:30:33 +05:00
Code Issues Packages Projects Releases Wiki Activity

Adjust Nb Segments hypothesis for creating a huge mesh

Browse Source 
+ fix some warnings
This commit is contained in:
eap 2021-02-26 14:56:11 +03:00
parent 2507fe6a42
commit 495625c0d4
24 changed files with 235 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
idl/SMESH_BasicHypothesis.idl
View File

@ -395,7 +395,7 @@ module StdMeshers
*/
void SetPoints(in SMESH::double_array listParams)
raises (SALOME::SALOME_Exception);
void SetNbSegments(in SMESH::long_array listNbSeg)
void SetNbSegments(in SMESH::smIdType_array listNbSeg)
raises (SALOME::SALOME_Exception);
/*!
@ -406,7 +406,7 @@ module StdMeshers
/*!
* Returns list of numbers of segments
*/
SMESH::long_array GetNbSegments();
SMESH::smIdType_array GetNbSegments();
};

2
src/SMESH/SMESH_Mesh.hxx
View File

@ -308,7 +308,7 @@ class SMESH_EXPORT SMESH_Mesh
smIdType NbSubMesh() const;
int NbGroup() const { return _mapGroup.size(); }
size_t NbGroup() const { return _mapGroup.size(); }
int NbMeshes() const; // nb meshes in the Study

2
src/SMESH/SMESH_MeshEditor.hxx
View File

@ -352,7 +352,7 @@ public:
bool IsScaleVariation() const { return myFlags & EXTRUSION_FLAG_SCALE_LINEAR_VARIATION; }
bool IsAngleVariation() const { return myFlags & EXTRUSION_FLAG_ANGLE_LINEAR_VARIATION; }
int NbSteps() const {
return mySteps.IsNull() ? myPathPoints.size() - 1: mySteps->Length();
return mySteps.IsNull() ? (int)myPathPoints.size() - 1: mySteps->Length();
}
// stores elements to use for extrusion by normal, depending on
// state of EXTRUSION_FLAG_USE_INPUT_ELEMS_ONLY flag;

2
src/SMESHDS/SMESHDS_Mesh.hxx
View File

@ -641,7 +641,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
// Groups. SMESHDS_Mesh is not an owner of groups
void AddGroup (SMESHDS_GroupBase* theGroup) { myGroups.insert(theGroup); }
void RemoveGroup (SMESHDS_GroupBase* theGroup) { myGroups.erase(theGroup); }
int GetNbGroups() const { return myGroups.size(); }
size_t GetNbGroups() const { return myGroups.size(); }
const std::set<SMESHDS_GroupBase*>& GetGroups() const { return myGroups; }
bool IsGroupOfSubShapes (const TopoDS_Shape& aSubShape) const;

2
src/SMESHDS/SMESHDS_SubMesh.hxx
View File

@ -63,7 +63,7 @@ class SMESHDS_EXPORT SMESHDS_SubMesh : public SMDS_ElementHolder
bool RemoveSubMesh( const SMESHDS_SubMesh* theSubMesh );
void RemoveAllSubmeshes();
bool ContainsSubMesh( const SMESHDS_SubMesh* theSubMesh ) const;
int NbSubMeshes() const { return mySubMeshes.size(); }
size_t NbSubMeshes() const { return mySubMeshes.size(); }
SMESHDS_SubMeshIteratorPtr GetSubMeshIterator() const;
// for both types

2
src/SMESHUtils/SMESH_Delaunay.hxx
View File

@ -61,7 +61,7 @@ class SMESHUtils_EXPORT SMESH_Delaunay
const SMDS_MeshNode* NextNode( double bc[3], int triaNodes[3] );
// return nb of nodes returned by NextNode()
int NbVisitedNodes() const { return _nbVisitedNodes; }
size_t NbVisitedNodes() const { return _nbVisitedNodes; }
// find a triangle containing an UV, starting from a given triangle;

14
src/StdMeshers/StdMeshers_CartesianParameters3D.cxx
View File

@ -331,13 +331,13 @@ void StdMeshers_CartesianParameters3D::ComputeCoordinates(const double x0,
const double p1 = x0 * ( 1. - points[i+1]) + x1 * points[i+1];
const double length = p1 - p0;
const size_t nbSections = 1000;
const int nbSections = 1000;
const double sectionLen = ( p1 - p0 ) / nbSections;
vector< double > nbSegments( nbSections + 1 );
nbSegments[ 0 ] = 0.;
double t, spacing = 0;
for ( size_t i = 1; i <= nbSections; ++i )
for ( int i = 1; i <= nbSections; ++i )
{
t = double( i ) / nbSections;
if ( !fun.value( t, spacing ) || spacing < std::numeric_limits<double>::min() )
@ -350,11 +350,11 @@ void StdMeshers_CartesianParameters3D::ComputeCoordinates(const double x0,
if ( coords.empty() ) coords.push_back( p0 );
for ( size_t iCell = 1, i = 1; i <= nbSections; ++i )
for ( int iCell = 1, j = 1; j <= nbSections; ++j )
{
if ( nbSegments[i]*corr >= iCell )
if ( nbSegments[j]*corr >= iCell )
{
t = (i - ( nbSegments[i] - iCell/corr )/( nbSegments[i] - nbSegments[i-1] )) / nbSections;
t = (j - ( nbSegments[j] - iCell/corr )/( nbSegments[j] - nbSegments[j-1] )) / nbSections;
coords.push_back( p0 + t * length );
++iCell;
}
@ -379,9 +379,9 @@ void StdMeshers_CartesianParameters3D::ComputeCoordinates(const double x0,
const double tol = minLen * 1e-3;
int iRem = -1;
if (( iF > 1 ) && ( coords[iF] - coords[iF-1] < tol ))
iRem = iF-1;
iRem = (int) iF-1;
else if (( iF < coords.size()-2 ) && ( coords[iF+1] - coords[iF] < tol ))
iRem = iF+1;
iRem = (int) iF+1;
if ( iRem > 0 )
coords.erase( coords.begin() + iRem );
}

14
src/StdMeshers/StdMeshers_Distribution.cxx
View File

@ -156,7 +156,7 @@ double FunctionTable::integral( const double a, const double b ) const
bool FunctionTable::findBounds( const double x, int& x_ind_1, int& x_ind_2 ) const
{
int n = myData.size() / 2;
int n = (int) myData.size() / 2;
if( n==0 || x<myData[0] )
{
x_ind_1 = x_ind_2 = 0;
@ -289,35 +289,35 @@ double dihotomySolve( Function& f, const double val, const double _start, const
}
bool buildDistribution( const TCollection_AsciiString& f, const int conv, const double start, const double end,
const int nbSeg, vector<double>& data, const double eps )
const smIdType nbSeg, vector<double>& data, const double eps )
{
FunctionExpr F( f.ToCString(), conv );
return buildDistribution( F, start, end, nbSeg, data, eps );
}
bool buildDistribution( const std::vector<double>& f, const int conv, const double start, const double end,
const int nbSeg, vector<double>& data, const double eps )
const smIdType nbSeg, vector<double>& data, const double eps )
{
FunctionTable F( f, conv );
return buildDistribution( F, start, end, nbSeg, data, eps );
}
bool buildDistribution( const Function& func, const double start, const double end, const int nbSeg,
vector<double>& data, const double eps )
bool buildDistribution( const Function& func, const double start, const double end,
const smIdType nbSeg, vector<double>& data, const double eps )
{
if( nbSeg<=0 )
return false;
data.resize( nbSeg+1 );
data[0] = start;
double J = func.integral( start, end ) / nbSeg;
double J = func.integral( start, end ) / double( nbSeg );
if( J<1E-10 )
return false;
bool ok;
//MESSAGE( "distribution:" );
//char buf[1024];
for( int i=1; i<nbSeg; i++ )
for( smIdType i = 1; i < nbSeg; i++ )
{
FunctionIntegral f_int( &func, data[i-1] );
data[i] = dihotomySolve( f_int, J, data[i-1], end, eps, ok );

8
src/StdMeshers/StdMeshers_Distribution.hxx
View File

@ -37,6 +37,8 @@
#include <Expr_Array1OfNamedUnknown.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <smIdType.hxx>
namespace StdMeshers
{
class STDMESHERS_EXPORT Function
@ -105,15 +107,15 @@ private:
STDMESHERS_EXPORT
bool buildDistribution( const Function& f,
const double start, const double end,
const int nbSeg,
const smIdType nbSeg,
std::vector<double>& data,
const double eps );
STDMESHERS_EXPORT
bool buildDistribution( const TCollection_AsciiString& f, const int conv, const double start, const double end,
const int nbSeg, std::vector<double>& data, const double eps );
const smIdType nbSeg, std::vector<double>& data, const double eps );
STDMESHERS_EXPORT
bool buildDistribution( const std::vector<double>& f, const int conv, const double start, const double end,
const int nbSeg, std::vector<double>& data, const double eps );
const smIdType nbSeg, std::vector<double>& data, const double eps );
}
#endif

4
src/StdMeshers/StdMeshers_FaceSide.cxx
View File

@ -1045,7 +1045,7 @@ void StdMeshers_FaceSide::SetIgnoreMediumNodes(bool toIgnore)
// since creation of this side
//=======================================================================
int StdMeshers_FaceSide::NbPoints(const bool update) const
smIdType StdMeshers_FaceSide::NbPoints(const bool update) const
{
if ( !myPoints.empty() )
return myPoints.size();
@ -1112,7 +1112,7 @@ int StdMeshers_FaceSide::NbPoints(const bool update) const
// since creation of this side
//=======================================================================
int StdMeshers_FaceSide::NbSegments(const bool update) const
smIdType StdMeshers_FaceSide::NbSegments(const bool update) const
{
return NbPoints( update ), myNbSegments;
}

8
src/StdMeshers/StdMeshers_FaceSide.hxx
View File

@ -172,13 +172,13 @@ public:
* Call it with update == true if mesh of this side can be recomputed
* since creation of this side
*/
int NbPoints(const bool update = false) const;
smIdType NbPoints(const bool update = false) const;
/*!
* \brief Return nb edges
* Call it with update == true if mesh of this side can be recomputed
* since creation of this side
*/
int NbSegments(const bool update = false) const;
smIdType NbSegments(const bool update = false) const;
/*!
* \brief Return mesh
*/
@ -255,7 +255,7 @@ public:
/*!
* \brief Return nb of wrapped edges
*/
int NbEdges() const { return myEdge.size(); }
size_t NbEdges() const { return myEdge.size(); }
/*!
* \brief Return i-th edge (count starts from zero)
*/
@ -364,7 +364,7 @@ protected:
inline int StdMeshers_FaceSide::EdgeIndex( double U ) const
{
int i = myNormPar.size() - 1;
int i = (int)myNormPar.size() - 1;
while ( i > 0 && U < myNormPar[ i-1 ] ) --i;
return i;
}

20
src/StdMeshers/StdMeshers_FixedPoints1D.cxx
View File

@ -62,20 +62,26 @@ StdMeshers_FixedPoints1D::~StdMeshers_FixedPoints1D()
void StdMeshers_FixedPoints1D::SetPoints(const std::vector<double>& listParams)
{
_params = listParams;
NotifySubMeshesHypothesisModification();
if ( _params != listParams )
{
_params = listParams;
NotifySubMeshesHypothesisModification();
}
}
//=============================================================================
/*!
*
*
*/
//=============================================================================
void StdMeshers_FixedPoints1D::SetNbSegments(const std::vector<int>& listNbSeg)
void StdMeshers_FixedPoints1D::SetNbSegments(const std::vector<smIdType>& listNbSeg)
{
_nbsegs = listNbSeg;
NotifySubMeshesHypothesisModification();
if ( _nbsegs != listNbSeg )
{
_nbsegs = listNbSeg;
NotifySubMeshesHypothesisModification();
}
}
ostream & StdMeshers_FixedPoints1D::SaveTo(ostream & save)
@ -113,7 +119,7 @@ ostream & StdMeshers_FixedPoints1D::SaveTo(ostream & save)
istream & StdMeshers_FixedPoints1D::LoadFrom(istream & load)
{
bool isOK = true;
int intVal;
smIdType intVal;
double dblVal;
isOK = static_cast<bool>(load >> intVal);

13
src/StdMeshers/StdMeshers_FixedPoints1D.hxx
View File

@ -25,13 +25,12 @@
#ifndef _SMESH_FIXEDPOINTS1D_HXX_
#define _SMESH_FIXEDPOINTS1D_HXX_
#include "SMESH_StdMeshers.hxx"
#include "StdMeshers_Reversible1D.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include <smIdType.hxx>
#include <vector>
@ -43,11 +42,11 @@ public:
void SetPoints(const std::vector<double>& listParams);
void SetNbSegments(const std::vector<int>& listNbSeg) ;
void SetNbSegments(const std::vector<smIdType>& listNbSeg) ;
const std::vector<double>& GetPoints() const { return _params; }
const std::vector<int>& GetNbSegments() const { return _nbsegs; }
const std::vector<smIdType>& GetNbSegments() const { return _nbsegs; }
virtual std::ostream & SaveTo(std::ostream & save);
virtual std::istream & LoadFrom(std::istream & load);
@ -66,9 +65,9 @@ public:
*/
virtual bool SetParametersByDefaults(const TDefaults& dflts, const SMESH_Mesh* theMesh=0);
protected:
std::vector<double> _params;
std::vector<int> _nbsegs;
protected:
std::vector<double> _params;
std::vector<smIdType> _nbsegs;
};
#endif

4
src/StdMeshers/StdMeshers_NumberOfSegments.cxx
View File

@ -477,7 +477,7 @@ int StdMeshers_NumberOfSegments::ConversionMode() const
ostream & StdMeshers_NumberOfSegments::SaveTo(ostream & save)
{
int listSize = _edgeIDs.size();
size_t listSize = _edgeIDs.size();
save << _numberOfSegments << " " << (int)_distrType;
switch (_distrType)
{
@ -502,7 +502,7 @@ ostream & StdMeshers_NumberOfSegments::SaveTo(ostream & save)
if ( _distrType != DT_Regular && listSize > 0 ) {
save << " " << listSize;
for ( int i = 0; i < listSize; i++ )
for ( size_t i = 0; i < listSize; i++ )
save << " " << _edgeIDs[i];
save << " " << _objEntry;
}

2
src/StdMeshers/StdMeshers_Prism_3D.hxx
View File

@ -154,7 +154,7 @@ class STDMESHERS_EXPORT StdMeshers_PrismAsBlock: public SMESH_Block
* \brief Return number of nodes on every vertical edge
* \retval int - number of nodes including end nodes
*/
int VerticalSize() const { return myParam2ColumnMaps[0].begin()->second.size(); }
size_t VerticalSize() const { return myParam2ColumnMaps[0].begin()->second.size(); }
bool HasNotQuadElemOnTop() const { return myNotQuadOnTop; }

2
src/StdMeshers/StdMeshers_Quadrangle_2D.cxx
View File

@ -1531,7 +1531,7 @@ int StdMeshers_Quadrangle_2D::getCorners(const TopoDS_Face& theFace,
if ( theConsiderMesh )
{
const int nbSegments = Max( faceSide.NbPoints()-1, faceSide.NbSegments() );
const size_t nbSegments = std::max( faceSide.NbPoints()-1, faceSide.NbSegments() );
if ( nbSegments < nbCorners )
return error(COMPERR_BAD_INPUT_MESH, TComm("Too few boundary nodes: ") << nbSegments);
}

219
src/StdMeshers/StdMeshers_Regular_1D.cxx
View File

@ -350,7 +350,7 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh& aMesh,
static bool computeParamByFunc(Adaptor3d_Curve& C3d,
double first, double last, double length,
bool theReverse, int nbSeg, Function& func,
bool theReverse, smIdType nbSeg, Function& func,
list<double>& theParams)
{
// never do this way
@ -359,11 +359,11 @@ static bool computeParamByFunc(Adaptor3d_Curve& C3d,
if ( nbSeg <= 0 )
return false;
int nbPnt = 1 + nbSeg;
smIdType nbPnt = 1 + nbSeg;
vector<double> x( nbPnt, 0. );
const double eps = Min( 1E-4, 1./nbSeg/100. );
const double eps = Min( 1E-4, 0.01 / double( nbSeg ));
if ( !buildDistribution( func, 0.0, 1.0, nbSeg, x, eps ))
return false;
@ -377,7 +377,7 @@ static bool computeParamByFunc(Adaptor3d_Curve& C3d,
sign = -1.;
}
for ( int i = 1; i < nbSeg; i++ )
for ( smIdType i = 1; i < nbSeg; i++ )
{
double curvLength = length * (x[i] - x[i-1]) * sign;
double tol = Min( Precision::Confusion(), curvLength / 100. );
@ -420,7 +420,7 @@ static void compensateError(double a1, double an,
list<double> & theParams,
bool adjustNeighbors2an = false)
{
int i, nPar = theParams.size();
smIdType i, nPar = theParams.size();
if ( a1 + an <= length && nPar > 1 )
{
bool reverse = ( U1 > Un );
@ -459,7 +459,7 @@ static void compensateError(double a1, double an,
}
else
{
double q = dUn / ( nPar - 1 );
double q = dUn / double( nPar - 1 );
theParams.back() += dUn;
double sign = reverse ? -1 : 1;
double prevU = theParams.back();
@ -565,14 +565,68 @@ StdMeshers_Regular_1D::getVertexHyp(SMESH_Mesh & theMesh,
return 0;
}
//================================================================================
/*!
* \brief Divide a curve into equal segments
*/
//================================================================================
bool StdMeshers_Regular_1D::divideIntoEqualSegments( SMESH_Mesh & theMesh,
Adaptor3d_Curve & theC3d,
smIdType theNbPoints,
double theTol,
double theLength,
double theFirstU,
double theLastU,
std::list<double> & theParameters )
{
bool ok = false;
if ( theNbPoints < IntegerLast() )
{
int nbPnt = FromIdType<int>( theNbPoints );
GCPnts_UniformAbscissa discret(theC3d, nbPnt, theFirstU, theLastU, theTol );
if ( !discret.IsDone() )
return error( "GCPnts_UniformAbscissa failed");
if ( discret.NbPoints() < nbPnt )
discret.Initialize(theC3d, nbPnt + 1, theFirstU, theLastU, theTol );
int nbPoints = Min( discret.NbPoints(), nbPnt );
for ( int i = 2; i < nbPoints; i++ ) // skip 1st and last points
{
double param = discret.Parameter(i);
theParameters.push_back( param );
}
ok = true;
}
else // huge nb segments
{
// use FIXED_POINTS_1D method
StdMeshers_FixedPoints1D fixedPointsHyp( GetGen()->GetANewId(), GetGen() );
_fpHyp = &fixedPointsHyp;
std::vector<double> params = { 0., 1. };
std::vector<smIdType> nbSegs = { theNbPoints - 1 };
fixedPointsHyp.SetPoints( params );
fixedPointsHyp.SetNbSegments( nbSegs );
HypothesisType curType = _hypType;
_hypType = FIXED_POINTS_1D;
ok = computeInternalParameters( theMesh, theC3d, theLength, theFirstU, theLastU,
theParameters, /*reverse=*/false );
_hypType = curType;
_fpHyp = 0;
}
return ok;
}
//================================================================================
/*!
* \brief Tune parameters to fit "SegmentLengthAroundVertex" hypothesis
* \param theC3d - wire curve
* \param theLength - curve length
* \param theParameters - internal nodes parameters to modify
* \param theVf - 1st vertex
* \param theVl - 2nd vertex
* \param theC3d - wire curve
* \param theLength - curve length
* \param theParameters - internal nodes parameters to modify
* \param theVf - 1st vertex
* \param theVl - 2nd vertex
*/
//================================================================================
@ -584,7 +638,7 @@ void StdMeshers_Regular_1D::redistributeNearVertices (SMESH_Mesh & theM
const TopoDS_Vertex & theVl)
{
double f = theC3d.FirstParameter(), l = theC3d.LastParameter();
int nPar = theParameters.size();
size_t nPar = theParameters.size();
for ( int isEnd1 = 0; isEnd1 < 2; ++isEnd1 )
{
const TopoDS_Vertex & V = isEnd1 ? theVf : theVl;
@ -623,7 +677,7 @@ void StdMeshers_Regular_1D::redistributeNearVertices (SMESH_Mesh & theM
{
// recompute params between the last segment and a middle one.
// find size of a middle segment
int nHalf = ( nPar-1 ) / 2;
smIdType nHalf = ( nPar-1 ) / 2;
list< double >::reverse_iterator itU = theParameters.rbegin();
std::advance( itU, nHalf );
double Um = *itU++;
@ -714,7 +768,7 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh,
size_t dSeg = theReverse ? -1 : +1;
double param = theFirstU;
size_t nbParams = 0;
for ( int i = 0, nb = segLen.size()-1; i < nb; ++i, iSeg += dSeg )
for ( size_t i = 1; i < segLen.size(); ++i, iSeg += dSeg )
{
double tol = Min( Precision::Confusion(), 0.01 * segLen[ iSeg ]);
GCPnts_AbscissaPoint Discret( tol, theC3d, segLen[ iSeg ], param );
@ -740,14 +794,14 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh,
case NB_SEGMENTS:
{
double eltSize = 1;
int nbSegments;
smIdType nbSegments;
if ( _hypType == MAX_LENGTH )
{
double nbseg = ceil(theLength / _value[ BEG_LENGTH_IND ]); // integer sup
if (nbseg <= 0)
nbseg = 1; // degenerated edge
eltSize = theLength / nbseg * ( 1. - 1e-9 );
nbSegments = (int) nbseg;
nbSegments = ToIdType( nbseg );
}
else if ( _hypType == LOCAL_LENGTH )
{
@ -773,7 +827,7 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh,
smIdType nb_segments = smds->NbElements();
if (nbseg - 1 <= nb_segments && nb_segments <= nbseg + 1) {
isFound = true;
nbseg = nb_segments;
nbseg = FromIdType<double>( nb_segments );
}
}
}
@ -788,7 +842,7 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh,
if (nbseg <= 0)
nbseg = 1; // degenerated edge
eltSize = theLength / nbseg;
nbSegments = (int) nbseg;
nbSegments = ToIdType( nbseg );
}
else
{
@ -805,19 +859,19 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh,
if (fabs(scale - 1.0) < Precision::Confusion()) {
// special case to avoid division by zero
for (int i = 1; i < nbSegments; i++) {
double param = f + (l - f) * i / nbSegments;
for ( smIdType i = 1; i < nbSegments; i++) {
double param = f + (l - f) * double( i ) / double( nbSegments );
theParams.push_back( param );
}
} else {
// general case of scale distribution
}
else { // general case of scale distribution
if ( theReverse )
scale = 1.0 / scale;
double alpha = pow(scale, 1.0 / (nbSegments - 1));
double alpha = pow(scale, 1.0 / double( nbSegments - 1 ));
double factor = (l - f) / (1.0 - pow(alpha, nbSegments));
for (int i = 1; i < nbSegments; i++) {
for ( smIdType i = 1; i < nbSegments; i++) {
double param = f + factor * (1.0 - pow(alpha, i));
theParams.push_back( param );
}
@ -837,7 +891,7 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh,
break;
case StdMeshers_NumberOfSegments::DT_TabFunc:
{
FunctionTable func(_vvalue[ TAB_FUNC_IND ], _ivalue[ CONV_MODE_IND ]);
FunctionTable func(_vvalue[ TAB_FUNC_IND ], FromIdType<int>( _ivalue[ CONV_MODE_IND ]));
return computeParamByFunc(theC3d, f, l, theLength, theReverse,
_ivalue[ NB_SEGMENTS_IND ], func,
theParams);
@ -845,14 +899,15 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh,
break;
case StdMeshers_NumberOfSegments::DT_ExprFunc:
{
FunctionExpr func(_svalue[ EXPR_FUNC_IND ].c_str(), _ivalue[ CONV_MODE_IND ]);
FunctionExpr func(_svalue[ EXPR_FUNC_IND ].c_str(),
FromIdType<int>( _ivalue[ CONV_MODE_IND ]));
return computeParamByFunc(theC3d, f, l, theLength, theReverse,
_ivalue[ NB_SEGMENTS_IND ], func,
theParams);
}
break;
case StdMeshers_NumberOfSegments::DT_Regular:
eltSize = theLength / nbSegments;
eltSize = theLength / double( nbSegments );
break;
default:
return false;
@ -860,18 +915,9 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh,
}
double tol = Min( Precision::Confusion(), 0.01 * eltSize );
GCPnts_UniformAbscissa Discret(theC3d, nbSegments + 1, f, l, tol );
if ( !Discret.IsDone() )
return error( "GCPnts_UniformAbscissa failed");
if ( Discret.NbPoints() < nbSegments + 1 )
Discret.Initialize(theC3d, nbSegments + 2, f, l, tol );
divideIntoEqualSegments( theMesh, theC3d, nbSegments + 1, tol,
theLength, theFirstU, theLastU, theParams );
int NbPoints = Min( Discret.NbPoints(), nbSegments + 1 );
for ( int i = 2; i < NbPoints; i++ ) // skip 1st and last points
{
double param = Discret.Parameter(i);
theParams.push_back( param );
}
compensateError( eltSize, eltSize, f, l, theLength, theC3d, theParams, true ); // for PAL9899
return true;
}
@ -1001,11 +1047,11 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh,
case FIXED_POINTS_1D:
{
const std::vector<double>& aPnts = _fpHyp->GetPoints();
std::vector<int> nbsegs = _fpHyp->GetNbSegments();
std::vector<smIdType> nbsegs = _fpHyp->GetNbSegments();
// sort normalized params, taking into account theReverse
TColStd_SequenceOfReal Params;
double tol = 1e-7 / theLength; // GCPnts_UniformAbscissa allows u2-u1 > 1e-7
double tol = 1e-7;
for ( size_t i = 0; i < aPnts.size(); i++ )
{
if( aPnts[i] < tol || aPnts[i] > 1 - tol )
@ -1013,50 +1059,70 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh,
double u = theReverse ? ( 1 - aPnts[i] ) : aPnts[i];
int j = 1;
bool IsExist = false;
for ( ; j <= Params.Length(); j++ ) {
if ( Abs( u - Params.Value(j) ) < tol ) {
IsExist = true;
break;
}
for ( ; j <= Params.Length() && !IsExist; j++ )
{
IsExist = ( Abs( u - Params.Value(j) ) < tol );
if ( u < Params.Value(j) ) break;
}
if ( !IsExist ) Params.InsertBefore( j, u );
}
Params.InsertBefore( 1, 0.0 );
Params.Append( 1.0 );
// transform normalized Params into real ones
std::vector< double > uVec( Params.Length() + 2 );
uVec[ 0 ] = theFirstU;
double abscissa;
for ( int i = 1; i <= Params.Length(); i++ )
{
abscissa = Params( i ) * theLength;
tol = Min( Precision::Confusion(), 0.01 * abscissa );
GCPnts_AbscissaPoint APnt( tol, theC3d, abscissa, theFirstU );
if ( !APnt.IsDone() )
return error( "GCPnts_AbscissaPoint failed");
uVec[ i ] = APnt.Parameter();
}
uVec.back() = theLastU;
// divide segments
if ( theReverse )
{
if ((int) nbsegs.size() > Params.Length() + 1 )
nbsegs.resize( Params.Length() + 1 );
if ((int) nbsegs.size() > Params.Length() - 1 )
nbsegs.resize( Params.Length() - 1 );
std::reverse( nbsegs.begin(), nbsegs.end() );
}
if ( nbsegs.empty() )
{
nbsegs.push_back( 1 );
}
Params.InsertBefore( 1, 0.0 );
Params.Append( 1.0 );
if ((int) nbsegs.size() < Params.Length() - 1 )
nbsegs.resize( Params.Length() - 1, nbsegs[0] );
// care of huge nbsegs - additionally divide diapasons
for ( int i = 2; i <= Params.Length(); i++ )
{
smIdType nbTot = nbsegs[ i-2 ];
if ( nbTot <= IntegerLast() )
continue;
smIdType nbDiapason = nbTot / IntegerLast() + 1;
smIdType nbSegPerDiap = nbTot / nbDiapason;
double par0 = Params( i - 1 ), par1 = Params( i );
for ( smIdType iDiap = 0; iDiap < nbDiapason - 1; ++iDiap )
{
double r = double( nbSegPerDiap * ( iDiap + 1 )) / double( nbTot );
double parI = par0 + ( par1 - par0 ) * r;
Params.InsertBefore( i, parI );
nbsegs.insert( nbsegs.begin() + i-2 + iDiap, nbSegPerDiap );
}
nbsegs[ i-2 + nbDiapason - 1 ] = nbSegPerDiap + nbTot % nbDiapason;
}
// transform normalized Params into real ones
std::vector< double > uVec( Params.Length() );
uVec[ 0 ] = theFirstU;
double abscissa;
for ( int i = 2; i < Params.Length(); i++ )
{
abscissa = Params( i ) * theLength;
tol = Min( Precision::Confusion(), 0.01 * abscissa );
GCPnts_AbscissaPoint APnt( tol, theC3d, abscissa, theFirstU );
if ( !APnt.IsDone() )
return error( "GCPnts_AbscissaPoint failed");
uVec[ i-1 ] = APnt.Parameter();
}
uVec.back() = theLastU;
// divide segments
double eltSize, segmentSize, par1, par2;
for ( size_t i = 0; i < uVec.size()-1; i++ )
for ( int i = 0; i < (int)uVec.size()-1; i++ )
{
par1 = uVec[ i ];
par2 = uVec[ i+1 ];
int nbseg = ( i < nbsegs.size() ) ? nbsegs[i] : nbsegs[0];
smIdType nbseg = ( i < (int) nbsegs.size() ) ? nbsegs[i] : nbsegs[0];
if ( nbseg == 1 )
{
theParams.push_back( par2 );
@ -1064,20 +1130,11 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh,
else
{
segmentSize = ( Params( i+2 ) - Params( i+1 )) * theLength;
eltSize = segmentSize / nbseg;
eltSize = segmentSize / double( nbseg );
tol = Min( Precision::Confusion(), 0.01 * eltSize );
GCPnts_UniformAbscissa Discret( theC3d, eltSize, par1, par2, tol );
if ( !Discret.IsDone() )
return error( "GCPnts_UniformAbscissa failed");
if ( Discret.NbPoints() < nbseg + 1 ) {
eltSize = segmentSize / ( nbseg + 0.5 );
Discret.Initialize( theC3d, eltSize, par1, par2, tol );
}
int NbPoints = Discret.NbPoints();
for ( int i = 2; i <= NbPoints; i++ ) {
double param = Discret.Parameter(i);
theParams.push_back( param );
}
if ( !divideIntoEqualSegments( theMesh, theC3d, nbseg + 1, tol,
segmentSize, par1, par2, theParams ))
return false;
}
}
theParams.pop_back();
@ -1396,7 +1453,7 @@ StdMeshers_Regular_1D::GetUsedHypothesis(SMESH_Mesh & aMesh,
if (nbHyp == 0) // nothing propagated nor assigned to aShape
{
SMESH_Algo::GetUsedHypothesis( aMesh, aShape, ignoreAuxiliary );
nbHyp = _usedHypList.size();
nbHyp = (int)_usedHypList.size();
}
else
{

15
src/StdMeshers/StdMeshers_Regular_1D.hxx
View File

@ -95,7 +95,16 @@ protected:
double theLength,
std::list< double > & theParameters,
const TopoDS_Vertex & theVf,
const TopoDS_Vertex & theVl);
const TopoDS_Vertex & thieve);
bool divideIntoEqualSegments( SMESH_Mesh & theMesh,
Adaptor3d_Curve & theC3d,
smIdType theNbPoints,
double theTol,
double theLength,
double theFirstU,
double theLastU,
std::list<double> & theParameters );
/*!
* \brief Return StdMeshers_SegmentLengthAroundVertex assigned to vertex
@ -133,8 +142,8 @@ protected:
const StdMeshers_FixedPoints1D* _fpHyp;
const StdMeshers_Adaptive1D* _adaptiveHyp;
double _value[2];
int _ivalue[3];
double _value [2];
smIdType _ivalue[3];
std::vector<double> _vvalue[1];
std::string _svalue[1];
std::vector<int> _revEdgesIDs;

17
src/StdMeshersGUI/StdMeshersGUI_FixedPointsParamWdg.cxx
View File

@ -301,17 +301,18 @@ double StdMeshersGUI_FixedPointsParamWdg::point( int idx ) const
return idx >= 0 && idx < myListWidget->count() ? myListWidget->item( idx )->data( Qt::UserRole ).toDouble() : 0.;
}
void StdMeshersGUI_FixedPointsParamWdg::setNbSegments( int idx, int val )
void StdMeshersGUI_FixedPointsParamWdg::setNbSegments( int idx, SMESH::smIdType val )
{
if ( idx >= 0 && idx < myTreeWidget->topLevelItemCount() ) {
myTreeWidget->topLevelItem( idx )->setData( 1, Qt::UserRole, val );
if ( idx >= 0 && idx < myTreeWidget->topLevelItemCount() )
{
myTreeWidget->topLevelItem( idx )->setData( 1, Qt::UserRole, FromIdType<int>( val ));
myTreeWidget->topLevelItem( idx )->setText( 1, idx > 0 && mySameValues->isChecked() ? QString( SAME_TEXT ) : QString::number( val ) );
}
}
int StdMeshersGUI_FixedPointsParamWdg::nbSegments( int idx ) const
smIdType StdMeshersGUI_FixedPointsParamWdg::nbSegments( int idx ) const
{
return idx >= 0 && idx < myTreeWidget->topLevelItemCount() ? myTreeWidget->topLevelItem( idx )->data( 1, Qt::UserRole ).toInt() : 1;
return ToIdType( idx >= 0 && idx < myTreeWidget->topLevelItemCount() ? myTreeWidget->topLevelItem( idx )->data( 1, Qt::UserRole ).toInt() : 1 );
}
//=================================================================================
@ -369,9 +370,9 @@ void StdMeshersGUI_FixedPointsParamWdg::SetListOfPoints( SMESH::double_array_var
// function : GetListOfSegments
// purpose : Called to get the list Number of Segments
//=================================================================================
SMESH::long_array_var StdMeshersGUI_FixedPointsParamWdg::GetListOfSegments()
SMESH::smIdType_array_var StdMeshersGUI_FixedPointsParamWdg::GetListOfSegments()
{
SMESH::long_array_var anArray = new SMESH::long_array;
SMESH::smIdType_array_var anArray = new SMESH::smIdType_array;
int size = mySameValues->isChecked() ? 1 : myTreeWidget->topLevelItemCount();
anArray->length( size );
for (int i = 0; i < size; i++) {
@ -384,7 +385,7 @@ SMESH::long_array_var StdMeshersGUI_FixedPointsParamWdg::GetListOfSegments()
// function : SetListOfPoints
// purpose : Called to set the list of Points
//=================================================================================
void StdMeshersGUI_FixedPointsParamWdg::SetListOfSegments( SMESH::long_array_var theSegments)
void StdMeshersGUI_FixedPointsParamWdg::SetListOfSegments( SMESH::smIdType_array_var theSegments)
{
if ( myListWidget->count() > 0 && theSegments->length() == 1)
mySameValues->setChecked(true);

10
src/StdMeshersGUI/StdMeshersGUI_FixedPointsParamWdg.h
View File

@ -27,6 +27,8 @@
#include <SMESHGUI.h>
#include "SMESH_StdMeshersGUI.hxx"
#include <smIdType.hxx>
// Qt includes
#include <QWidget>
#include <QStringList>
@ -56,8 +58,8 @@ public:
SMESH::double_array_var GetListOfPoints();
void SetListOfPoints( SMESH::double_array_var );
SMESH::long_array_var GetListOfSegments();
void SetListOfSegments( SMESH::long_array_var );
SMESH::smIdType_array_var GetListOfSegments();
void SetListOfSegments( SMESH::smIdType_array_var );
QString GetValue() const { return myParamValue; }
@ -72,8 +74,8 @@ private:
void addPoint( double );
void removePoints();
double point( int ) const;
void setNbSegments( int, int );
int nbSegments( int ) const;
void setNbSegments( int, SMESH::smIdType );
smIdType nbSegments( int ) const;
static QTreeWidgetItem* newTreeItem( double v1, double v2 );
static QListWidgetItem* newListItem( double v1 );

2
src/StdMeshersGUI/StdMeshersGUI_ObjectReferenceParamWdg.h
View File

@ -73,7 +73,7 @@ public:
return TInterface::_nil();
}
int NbObjects() const { return myObjects.size(); }
size_t NbObjects() const { return myObjects.size(); }
QString GetValue() const { return myParamValue; }

4
src/StdMeshersGUI/StdMeshersGUI_QuadrangleParamWdg.cxx
View File

@ -226,7 +226,7 @@ void StdMeshersGUI_QuadrangleParamCreator::retrieveParams() const
GEOM::ListOfGO_var shapes;
SMESH::nodes_array_var points;
h->GetEnforcedNodes( shapes, points );
for ( size_t i = 0; i < shapes->length(); ++i )
for ( CORBA::ULong i = 0; i < shapes->length(); ++i )
{
CORBA::String_var name = shapes[i]->GetName();
CORBA::String_var entry = shapes[i]->GetStudyEntry();
@ -234,7 +234,7 @@ void StdMeshersGUI_QuadrangleParamCreator::retrieveParams() const
item->setData( Qt::UserRole, entry.in() );
myShapesList->addItem( item );
}
for ( size_t i = 0; i < points->length(); ++i )
for ( CORBA::ULong i = 0; i < points->length(); ++i )
{
QTreeWidgetItem* item = new QTreeWidgetItem
( QStringList()

20
src/StdMeshers_I/StdMeshers_FixedPoints1D_i.cxx
View File

@ -71,14 +71,14 @@ StdMeshers_FixedPoints1D_i::~StdMeshers_FixedPoints1D_i()
*/
//=============================================================================
void StdMeshers_FixedPoints1D_i::SetNbSegments(const SMESH::long_array& listNbSeg)
void StdMeshers_FixedPoints1D_i::SetNbSegments(const SMESH::smIdType_array& listNbSeg)
{
ASSERT( myBaseImpl );
try {
std::vector<int> nbsegs( listNbSeg.length() );
CORBA::Long iEnd = listNbSeg.length();
for ( CORBA::Long i = 0; i < iEnd; i++ )
std::vector<smIdType> nbsegs( listNbSeg.length() );
CORBA::ULong iEnd = listNbSeg.length();
for ( CORBA::ULong i = 0; i < iEnd; i++ )
nbsegs[ i ] = listNbSeg[ i ];
this->GetImpl()->SetNbSegments( nbsegs );
}
@ -130,7 +130,7 @@ SMESH::double_array* StdMeshers_FixedPoints1D_i::GetPoints()
ASSERT( myBaseImpl );
SMESH::double_array_var anArray = new SMESH::double_array;
std::vector<double> params = this->GetImpl()->GetPoints();
anArray->length( params.size() );
anArray->length( static_cast<CORBA::ULong>( params.size() ));
for ( CORBA::ULong i = 0; i < params.size(); i++)
anArray [ i ] = params [ i ];
@ -145,12 +145,12 @@ SMESH::double_array* StdMeshers_FixedPoints1D_i::GetPoints()
*/
//=============================================================================
SMESH::long_array* StdMeshers_FixedPoints1D_i::GetNbSegments()
SMESH::smIdType_array* StdMeshers_FixedPoints1D_i::GetNbSegments()
{
ASSERT( myBaseImpl );
SMESH::long_array_var anArray = new SMESH::long_array;
std::vector<int> nbsegs = this->GetImpl()->GetNbSegments();
anArray->length( nbsegs.size() );
SMESH::smIdType_array_var anArray = new SMESH::smIdType_array;
std::vector<smIdType> nbsegs = this->GetImpl()->GetNbSegments();
anArray->length( static_cast<CORBA::ULong>( nbsegs.size() ));
for ( CORBA::ULong i = 0; i < nbsegs.size(); i++)
anArray [ i ] = nbsegs [ i ];

4
src/StdMeshers_I/StdMeshers_FixedPoints1D_i.hxx
View File

@ -53,13 +53,13 @@ public:
// create list of reversed edges if it is needed) and sets numbers
// of segments between given points (default values are equals 1)
void SetPoints(const SMESH::double_array& listParams);
void SetNbSegments(const SMESH::long_array& listNbSeg);
void SetNbSegments(const SMESH::smIdType_array& listNbSeg);
// Returns list of point's parameters
SMESH::double_array* GetPoints();
// Returns list of numbers of segments
SMESH::long_array* GetNbSegments();
SMESH::smIdType_array* GetNbSegments();
// Get implementation
::StdMeshers_FixedPoints1D* GetImpl();