X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FStdMeshers%2FStdMeshers_Regular_1D.cxx;h=6746a502c1daef9cd0bd9655ceae17c87baafcde;hp=8f4a105477fd31c27c64093c0b7830158d7fedb7;hb=30ce546b0c5099ad1112929e2db94810e683e54b;hpb=145e217ae6852460e3f461e22fe34cf6bc15fc36

diff --git a/src/StdMeshers/StdMeshers_Regular_1D.cxx b/src/StdMeshers/StdMeshers_Regular_1D.cxx
index 8f4a10547..6746a502c 100644
--- a/src/StdMeshers/StdMeshers_Regular_1D.cxx
+++ b/src/StdMeshers/StdMeshers_Regular_1D.cxx
@@ -50,8 +50,8 @@
 #include "StdMeshers_SegmentLengthAroundVertex.hxx"
 #include "StdMeshers_StartEndLength.hxx"
 
-#include "Utils_SALOME_Exception.hxx"
-#include "utilities.h"
+#include <Utils_SALOME_Exception.hxx>
+#include <utilities.h>
 
 #include <BRepAdaptor_Curve.hxx>
 #include <BRep_Tool.hxx>
@@ -122,10 +122,11 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh&         aMesh,
                                              const TopoDS_Shape& aShape,
                                              Hypothesis_Status&  aStatus )
 {
-  _hypType = NONE;
-  _quadraticMesh = false;
+  _hypType        = NONE;
+  _quadraticMesh  = false;
   _onlyUnaryInput = true;
 
+  // check propagation in a redefined GetUsedHypothesis()
   const list <const SMESHDS_Hypothesis * > & hyps =
     GetUsedHypothesis(aMesh, aShape, /*ignoreAuxiliaryHyps=*/false);
 
@@ -156,13 +157,17 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh&         aMesh,
 
   string hypName = theHyp->GetName();
 
-  if ( hypName == "LocalLength" )
+  if ( !_mainEdge.IsNull() && _hypType == DISTRIB_PROPAGATION )
+  {
+    aStatus = SMESH_Hypothesis::HYP_OK;
+  }
+  else if ( hypName == "LocalLength" )
   {
     const StdMeshers_LocalLength * hyp =
       dynamic_cast <const StdMeshers_LocalLength * >(theHyp);
     ASSERT(hyp);
     _value[ BEG_LENGTH_IND ] = hyp->GetLength();
-    _value[ PRECISION_IND ] = hyp->GetPrecision();
+    _value[ PRECISION_IND  ] = hyp->GetPrecision();
     ASSERT( _value[ BEG_LENGTH_IND ] > 0 );
     _hypType = LOCAL_LENGTH;
     aStatus = SMESH_Hypothesis::HYP_OK;
@@ -386,6 +391,7 @@ static bool computeParamByFunc(Adaptor3d_Curve& C3d,
   }
   if ( theReverse )
     theParams.reverse();
+
   return true;
 }
 
@@ -393,15 +399,15 @@ static bool computeParamByFunc(Adaptor3d_Curve& C3d,
 //================================================================================
 /*!
  * \brief adjust internal node parameters so that the last segment length == an
-  * \param a1 - the first segment length
-  * \param an - the last segment length
-  * \param U1 - the first edge parameter
-  * \param Un - the last edge parameter
-  * \param length - the edge length
-  * \param C3d - the edge curve
-  * \param theParams - internal node parameters to adjust
-  * \param adjustNeighbors2an - to adjust length of segments next to the last one
-  *  and not to remove parameters
+ *  \param a1 - the first segment length
+ *  \param an - the last segment length
+ *  \param U1 - the first edge parameter
+ *  \param Un - the last edge parameter
+ *  \param length - the edge length
+ *  \param C3d - the edge curve
+ *  \param theParams - internal node parameters to adjust
+ *  \param adjustNeighbors2an - to adjust length of segments next to the last one
+ *   and not to remove parameters
  */
 //================================================================================
 
@@ -496,7 +502,7 @@ static void compensateError(double a1, double an,
 //    * \brief Clean mesh on edges
 //    * \param event - algo_event or compute_event itself (of SMESH_subMesh)
 //    * \param eventType - ALGO_EVENT or COMPUTE_EVENT (of SMESH_subMesh)
-//    * \param subMesh - the submesh where the event occures
+//    * \param subMesh - the submesh where the event occurs
 //    */
 //   void ProcessEvent(const int event, const int eventType, SMESH_subMesh* subMesh,
 //                     EventListenerData*, const SMESH_Hypothesis*)
@@ -672,10 +678,10 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh &     theMesh,
 
   // Propagation Of Distribution
   //
-  if ( !_mainEdge.IsNull() && _isPropagOfDistribution )
+  if ( !_mainEdge.IsNull() && _hypType == DISTRIB_PROPAGATION )
   {
     TopoDS_Edge mainEdge = TopoDS::Edge( _mainEdge ); // should not be a reference!
-    _gen->Compute( theMesh, mainEdge, /*aShapeOnly=*/true, /*anUpward=*/true);
+    _gen->Compute( theMesh, mainEdge, SMESH_Gen::SHAPE_ONLY_UPWARD );
 
     SMESHDS_SubMesh* smDS = theMesh.GetMeshDS()->MeshElements( mainEdge );
     if ( !smDS )
@@ -992,8 +998,6 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh &     theMesh,
   {
     const std::vector<double>& aPnts = _fpHyp->GetPoints();
     std::vector<int>          nbsegs = _fpHyp->GetNbSegments();
-    if ( theReverse )
-      std::reverse( nbsegs.begin(), nbsegs.end() );
 
     // sort normalized params, taking into account theReverse
     TColStd_SequenceOfReal Params;
@@ -1031,6 +1035,16 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh &     theMesh,
     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;
@@ -1156,7 +1170,7 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & t
       // take into account reversing the edge the hypothesis is propagated from
       // (_mainEdge.Orientation() marks mutual orientation of EDGEs in propagation chain)
       reversed = ( _mainEdge.Orientation() == TopAbs_REVERSED );
-      if ( !_isPropagOfDistribution ) {
+      if ( _hypType != DISTRIB_PROPAGATION ) {
         int mainID = meshDS->ShapeToIndex(_mainEdge);
         if ( std::find( _revEdgesIDs.begin(), _revEdgesIDs.end(), mainID) != _revEdgesIDs.end())
           reversed = !reversed;
@@ -1268,9 +1282,9 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & t
  */
 //=============================================================================
 
-bool StdMeshers_Regular_1D::Evaluate(SMESH_Mesh & theMesh,
+bool StdMeshers_Regular_1D::Evaluate(SMESH_Mesh &         theMesh,
                                      const TopoDS_Shape & theShape,
-                                     MapShapeNbElems& aResMap)
+                                     MapShapeNbElems&     theResMap)
 {
   if ( _hypType == NONE )
     return false;
@@ -1278,7 +1292,7 @@ bool StdMeshers_Regular_1D::Evaluate(SMESH_Mesh & theMesh,
   if ( _hypType == ADAPTIVE )
   {
     _adaptiveHyp->GetAlgo()->InitComputeError();
-    _adaptiveHyp->GetAlgo()->Evaluate( theMesh, theShape, aResMap );
+    _adaptiveHyp->GetAlgo()->Evaluate( theMesh, theShape, theResMap );
     return error( _adaptiveHyp->GetAlgo()->GetComputeError() );
   }
 
@@ -1303,7 +1317,7 @@ bool StdMeshers_Regular_1D::Evaluate(SMESH_Mesh & theMesh,
     BRepAdaptor_Curve C3d( E );
     if ( ! computeInternalParameters( theMesh, C3d, length, f, l, params, false, true )) {
       SMESH_subMesh * sm = theMesh.GetSubMesh(theShape);
-      aResMap.insert(std::make_pair(sm,aVec));
+      theResMap.insert(std::make_pair(sm,aVec));
       SMESH_ComputeErrorPtr& smError = sm->GetComputeError();
       smError.reset( new SMESH_ComputeError(COMPERR_ALGO_FAILED,"Submesh can not be evaluated",this));
       return false;
@@ -1311,7 +1325,7 @@ bool StdMeshers_Regular_1D::Evaluate(SMESH_Mesh & theMesh,
     redistributeNearVertices( theMesh, C3d, length, params, VFirst, VLast );
 
     if(_quadraticMesh) {
-      aVec[SMDSEntity_Node] = 2*params.size() + 1;
+      aVec[SMDSEntity_Node     ] = 2*params.size() + 1;
       aVec[SMDSEntity_Quad_Edge] = params.size() + 1;
     }
     else {
@@ -1323,7 +1337,7 @@ bool StdMeshers_Regular_1D::Evaluate(SMESH_Mesh & theMesh,
   else {
     // Edge is a degenerated Edge : We put n = 5 points on the edge.
     if ( _quadraticMesh ) {
-      aVec[SMDSEntity_Node] = 11;
+      aVec[SMDSEntity_Node     ] = 11;
       aVec[SMDSEntity_Quad_Edge] = 6;
     }
     else {
@@ -1332,8 +1346,8 @@ bool StdMeshers_Regular_1D::Evaluate(SMESH_Mesh & theMesh,
     }
   }
 
-  SMESH_subMesh * sm = theMesh.GetSubMesh(theShape);
-  aResMap.insert(std::make_pair(sm,aVec));
+  SMESH_subMesh * sm = theMesh.GetSubMesh( theShape );
+  theResMap.insert( std::make_pair( sm, aVec ));
 
   return true;
 }
@@ -1362,10 +1376,13 @@ StdMeshers_Regular_1D::GetUsedHypothesis(SMESH_Mesh &         aMesh,
   if (nbHyp == 0 && aShape.ShapeType() == TopAbs_EDGE)
   {
     // Check, if propagated from some other edge
+    bool isPropagOfDistribution = false;
     _mainEdge = StdMeshers_Propagation::GetPropagationSource( aMesh, aShape,
-                                                              _isPropagOfDistribution );
+                                                              isPropagOfDistribution );
     if ( !_mainEdge.IsNull() )
     {
+      if ( isPropagOfDistribution )
+        _hypType = DISTRIB_PROPAGATION;
       // Propagation of 1D hypothesis from <aMainEdge> on this edge;
       // get non-auxiliary assigned to _mainEdge
       nbHyp = aMesh.GetHypotheses( _mainEdge, *compatibleFilter, _usedHypList, true );