Adjust Nb Segments hypothesis for creating a huge mesh

+ fix some warnings

idl/SMESH_BasicHypothesis.idl

@@ -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();
 
   };
 

src/SMESH/SMESH_Mesh.hxx

@@ -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
 

src/SMESH/SMESH_MeshEditor.hxx

@@ -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;

src/SMESHDS/SMESHDS_Mesh.hxx

@@ -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;

src/SMESHDS/SMESHDS_SubMesh.hxx

@@ -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

src/SMESHUtils/SMESH_Delaunay.hxx

@@ -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;

src/StdMeshers/StdMeshers_CartesianParameters3D.cxx

@@ -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 );
   }

src/StdMeshers/StdMeshers_Distribution.cxx

@@ -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,
+bool buildDistribution( const Function& func, const double start, const double end,
-                        vector<double>& data, const double eps )
+                        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 );

src/StdMeshers/StdMeshers_Distribution.hxx

@@ -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

src/StdMeshers/StdMeshers_FaceSide.cxx

@@ -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;
 }

src/StdMeshers/StdMeshers_FaceSide.hxx

@@ -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;
 }

src/StdMeshers/StdMeshers_FixedPoints1D.cxx

@@ -62,20 +62,26 @@ StdMeshers_FixedPoints1D::~StdMeshers_FixedPoints1D()
 
 void StdMeshers_FixedPoints1D::SetPoints(const std::vector<double>& listParams)
 {
-  _params = listParams;
+  if ( _params != listParams )
-  NotifySubMeshesHypothesisModification();
+  {
+    _params = listParams;
+    NotifySubMeshesHypothesisModification();
+  }
 }
 
 //=============================================================================
 /*!
- *  
+ *
  */
 //=============================================================================
 
-void StdMeshers_FixedPoints1D::SetNbSegments(const std::vector<int>& listNbSeg) 
+void StdMeshers_FixedPoints1D::SetNbSegments(const std::vector<smIdType>& listNbSeg)
 {
-  _nbsegs = listNbSeg;
+  if ( _nbsegs != listNbSeg )
-  NotifySubMeshesHypothesisModification();
+  {
+    _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);

src/StdMeshers/StdMeshers_FixedPoints1D.hxx

@@ -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:
+ protected:
-  std::vector<double> _params;
+  std::vector<double>   _params;
-  std::vector<int>    _nbsegs;
+  std::vector<smIdType> _nbsegs;
 };
 
 #endif

src/StdMeshers/StdMeshers_NumberOfSegments.cxx

@@ -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;
   }

src/StdMeshers/StdMeshers_Prism_3D.hxx

@@ -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; }
 

src/StdMeshers/StdMeshers_Quadrangle_2D.cxx

@@ -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);
   }

src/StdMeshers/StdMeshers_Regular_1D.cxx

@@ -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 theC3d - wire curve
-  * \param theLength - curve length
+ *  \param theLength - curve length
-  * \param theParameters - internal nodes parameters to modify
+ *  \param theParameters - internal nodes parameters to modify
-  * \param theVf - 1st vertex
+ *  \param theVf - 1st vertex
-  * \param theVl - 2nd 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++) {
+            for ( smIdType i = 1; i < nbSegments; i++) {
-              double param = f + (l - f) * i / nbSegments;
+              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 );
+    divideIntoEqualSegments( theMesh, theC3d, nbSegments + 1, tol,
-    if ( !Discret.IsDone() )
+                             theLength, theFirstU, theLastU, theParams );
-      return error( "GCPnts_UniformAbscissa failed");
-    if ( Discret.NbPoints() < nbSegments + 1 )
-      Discret.Initialize(theC3d, nbSegments + 2, f, l, tol );
 
-    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++ ) {
+      for ( ; j <= Params.Length() &&  !IsExist; j++ )
-        if ( Abs( u - Params.Value(j) ) < tol ) {
+      {
-          IsExist = true;
+        IsExist = ( Abs( u - Params.Value(j) ) < tol );
-          break;
-        }
         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 )
+      if ((int) nbsegs.size() > Params.Length() - 1 )
-        nbsegs.resize( 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 );
+    if ((int) nbsegs.size() < Params.Length() - 1 )
-    Params.Append( 1.0 );
+      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 ( !divideIntoEqualSegments( theMesh, theC3d, nbseg + 1, tol,
-        if ( !Discret.IsDone() )
+                                       segmentSize, par1, par2, theParams ))
-          return error( "GCPnts_UniformAbscissa failed");
+          return false;
-        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 );
-        }
       }
     }
     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
   {

src/StdMeshers/StdMeshers_Regular_1D.hxx

@@ -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];
+  double              _value [2];
-  int    _ivalue[3];
+  smIdType            _ivalue[3];
   std::vector<double> _vvalue[1];
   std::string         _svalue[1];
   std::vector<int>    _revEdgesIDs;

src/StdMeshersGUI/StdMeshersGUI_FixedPointsParamWdg.cxx

@@ -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() ) {
+  if ( idx >= 0 && idx < myTreeWidget->topLevelItemCount() )
-    myTreeWidget->topLevelItem( idx )->setData( 1, Qt::UserRole, val );
+  {
+    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);

src/StdMeshersGUI/StdMeshersGUI_FixedPointsParamWdg.h

@@ -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();
+  SMESH::smIdType_array_var      GetListOfSegments();
-  void                           SetListOfSegments( SMESH::long_array_var );
+  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 );
+  void                           setNbSegments( int, SMESH::smIdType );
-  int                            nbSegments( int ) const;
+  smIdType                       nbSegments( int ) const;
 
   static QTreeWidgetItem*        newTreeItem( double v1, double v2 );
   static QListWidgetItem*        newListItem( double v1 );

src/StdMeshersGUI/StdMeshersGUI_ObjectReferenceParamWdg.h

@@ -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; }
 

src/StdMeshersGUI/StdMeshersGUI_QuadrangleParamWdg.cxx

@@ -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()

src/StdMeshers_I/StdMeshers_FixedPoints1D_i.cxx

@@ -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() );
+    std::vector<smIdType> nbsegs( listNbSeg.length() );
-    CORBA::Long iEnd = listNbSeg.length();
+    CORBA::ULong iEnd = listNbSeg.length();
-    for ( CORBA::Long i = 0; i < iEnd; i++ )
+    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;
+  SMESH::smIdType_array_var anArray = new SMESH::smIdType_array;
-  std::vector<int> nbsegs = this->GetImpl()->GetNbSegments();
+  std::vector<smIdType> nbsegs = this->GetImpl()->GetNbSegments();
-  anArray->length( nbsegs.size() );
+  anArray->length( static_cast<CORBA::ULong>( nbsegs.size() ));
   for ( CORBA::ULong i = 0; i < nbsegs.size(); i++)
     anArray [ i ] = nbsegs [ i ];
 

src/StdMeshers_I/StdMeshers_FixedPoints1D_i.hxx

@@ -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();