*/
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);
/*!
/*!
* Returns list of numbers of segments
*/
- SMESH::long_array GetNbSegments();
+ SMESH::smIdType_array GetNbSegments();
};
smIdType NbSubMesh() const;
- int NbGroup() const { return _mapGroup.size(); }
+ size_t NbGroup() const { return _mapGroup.size(); }
int NbMeshes() const; // nb meshes in the Study
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;
// 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;
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
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;
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() )
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;
}
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 );
}
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;
}
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 );
#include <Expr_Array1OfNamedUnknown.hxx>
#include <TColStd_Array1OfReal.hxx>
+#include <smIdType.hxx>
+
namespace StdMeshers
{
class STDMESHERS_EXPORT Function
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
// 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();
// 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;
}
* 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
*/
/*!
* \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)
*/
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;
}
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)
istream & StdMeshers_FixedPoints1D::LoadFrom(istream & load)
{
bool isOK = true;
- int intVal;
+ smIdType intVal;
double dblVal;
isOK = static_cast<bool>(load >> intVal);
#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>
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);
*/
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
ostream & StdMeshers_NumberOfSegments::SaveTo(ostream & save)
{
- int listSize = _edgeIDs.size();
+ size_t listSize = _edgeIDs.size();
save << _numberOfSegments << " " << (int)_distrType;
switch (_distrType)
{
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;
}
* \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; }
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);
}
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
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;
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. );
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 );
}
else
{
- double q = dUn / ( nPar - 1 );
+ double q = dUn / double( nPar - 1 );
theParams.back() += dUn;
double sign = reverse ? -1 : 1;
double prevU = theParams.back();
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
*/
//================================================================================
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;
{
// 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++;
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 );
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 )
{
smIdType nb_segments = smds->NbElements();
if (nbseg - 1 <= nb_segments && nb_segments <= nbseg + 1) {
isFound = true;
- nbseg = nb_segments;
+ nbseg = FromIdType<double>( nb_segments );
}
}
}
if (nbseg <= 0)
nbseg = 1; // degenerated edge
eltSize = theLength / nbseg;
- nbSegments = (int) nbseg;
+ nbSegments = ToIdType( nbseg );
}
else
{
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 );
}
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);
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;
}
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;
}
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 )
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 );
+
+ if ( theReverse )
+ {
+ 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 );
+ }
+ 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() + 2 );
+ std::vector< double > uVec( Params.Length() );
uVec[ 0 ] = theFirstU;
double abscissa;
- for ( int i = 1; i <= Params.Length(); i++ )
+ 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 ] = APnt.Parameter();
+ uVec[ i-1 ] = APnt.Parameter();
}
uVec.back() = theLastU;
// divide segments
- if ( theReverse )
- {
- 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 );
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 );
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();
if (nbHyp == 0) // nothing propagated nor assigned to aShape
{
SMESH_Algo::GetUsedHypothesis( aMesh, aShape, ignoreAuxiliary );
- nbHyp = _usedHypList.size();
+ nbHyp = (int)_usedHypList.size();
}
else
{
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
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;
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 );
}
//=================================================================================
// 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++) {
// 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);
#include <SMESHGUI.h>
#include "SMESH_StdMeshersGUI.hxx"
+#include <smIdType.hxx>
+
// Qt includes
#include <QWidget>
#include <QStringList>
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; }
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 );
return TInterface::_nil();
}
- int NbObjects() const { return myObjects.size(); }
+ size_t NbObjects() const { return myObjects.size(); }
QString GetValue() const { return myParamValue; }
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();
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()
*/
//=============================================================================
-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 );
}
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 ];
*/
//=============================================================================
-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 ];
// 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();
