]> SALOME platform Git repositories - modules/smesh.git/blob - src/StdMeshers/StdMeshers_Regular_1D.cxx
Salome HOME
Update test for new version of PartitionAlgo.
[modules/smesh.git] / src / StdMeshers / StdMeshers_Regular_1D.cxx
1 //  SMESH SMESH : implementaion of SMESH idl descriptions
2 //
3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
5 // 
6 //  This library is free software; you can redistribute it and/or 
7 //  modify it under the terms of the GNU Lesser General Public 
8 //  License as published by the Free Software Foundation; either 
9 //  version 2.1 of the License. 
10 // 
11 //  This library is distributed in the hope that it will be useful, 
12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of 
13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
14 //  Lesser General Public License for more details. 
15 // 
16 //  You should have received a copy of the GNU Lesser General Public 
17 //  License along with this library; if not, write to the Free Software 
18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
19 // 
20 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 //
22 //
23 //
24 //  File   : StdMeshers_Regular_1D.cxx
25 //           Moved here from SMESH_Regular_1D.cxx
26 //  Author : Paul RASCLE, EDF
27 //  Module : SMESH
28 //  $Header$
29
30 using namespace std;
31
32 #include "StdMeshers_Regular_1D.hxx"
33 #include "StdMeshers_Distribution.hxx"
34
35 #include "StdMeshers_LocalLength.hxx"
36 #include "StdMeshers_NumberOfSegments.hxx"
37 #include "StdMeshers_Arithmetic1D.hxx"
38 #include "StdMeshers_StartEndLength.hxx"
39 #include "StdMeshers_Deflection1D.hxx"
40 #include "StdMeshers_AutomaticLength.hxx"
41
42 #include "SMESH_Gen.hxx"
43 #include "SMESH_Mesh.hxx"
44 #include "SMESH_HypoFilter.hxx"
45 #include "SMESH_subMesh.hxx"
46
47 #include "SMDS_MeshElement.hxx"
48 #include "SMDS_MeshNode.hxx"
49 #include "SMDS_EdgePosition.hxx"
50
51 #include "Utils_SALOME_Exception.hxx"
52 #include "utilities.h"
53
54 #include <BRep_Tool.hxx>
55 #include <TopoDS_Edge.hxx>
56 #include <TopoDS_Shape.hxx>
57 #include <TopTools_ListIteratorOfListOfShape.hxx>
58 #include <GeomAdaptor_Curve.hxx>
59 #include <GCPnts_AbscissaPoint.hxx>
60 #include <GCPnts_UniformAbscissa.hxx>
61 #include <GCPnts_UniformDeflection.hxx>
62 #include <Precision.hxx>
63 #include <Expr_GeneralExpression.hxx>
64 #include <Expr_NamedUnknown.hxx>
65 #include <Expr_Array1OfNamedUnknown.hxx>
66 #include <ExprIntrp_GenExp.hxx>
67 #include <TColStd_Array1OfReal.hxx>
68 #include <OSD.hxx>
69
70 #include <Standard_ErrorHandler.hxx>
71 #include <Standard_Failure.hxx>
72
73 #include <string>
74 #include <math.h>
75
76 using namespace std;
77
78 //=============================================================================
79 /*!
80  *  
81  */
82 //=============================================================================
83
84 StdMeshers_Regular_1D::StdMeshers_Regular_1D(int hypId, int studyId,
85         SMESH_Gen * gen):SMESH_1D_Algo(hypId, studyId, gen)
86 {
87         MESSAGE("StdMeshers_Regular_1D::StdMeshers_Regular_1D");
88         _name = "Regular_1D";
89         _shapeType = (1 << TopAbs_EDGE);
90
91         _compatibleHypothesis.push_back("LocalLength");
92         _compatibleHypothesis.push_back("NumberOfSegments");
93         _compatibleHypothesis.push_back("StartEndLength");
94         _compatibleHypothesis.push_back("Deflection1D");
95         _compatibleHypothesis.push_back("Arithmetic1D");
96         _compatibleHypothesis.push_back("AutomaticLength");
97
98         _compatibleHypothesis.push_back("QuadraticMesh"); // auxiliary !!!
99 }
100
101 //=============================================================================
102 /*!
103  *  
104  */
105 //=============================================================================
106
107 StdMeshers_Regular_1D::~StdMeshers_Regular_1D()
108 {
109 }
110
111 //=============================================================================
112 /*!
113  *  
114  */
115 //=============================================================================
116
117 bool StdMeshers_Regular_1D::CheckHypothesis
118                          (SMESH_Mesh&                          aMesh,
119                           const TopoDS_Shape&                  aShape,
120                           SMESH_Hypothesis::Hypothesis_Status& aStatus)
121 {
122   _hypType = NONE;
123   _quadraticMesh = false;
124
125   const bool ignoreAuxiliaryHyps = false;
126   const list <const SMESHDS_Hypothesis * > & hyps =
127     GetUsedHypothesis(aMesh, aShape, ignoreAuxiliaryHyps);
128
129   // find non-auxiliary hypothesis
130   const SMESHDS_Hypothesis *theHyp = 0;
131   list <const SMESHDS_Hypothesis * >::const_iterator h = hyps.begin();
132   for ( ; h != hyps.end(); ++h ) {
133     if ( static_cast<const SMESH_Hypothesis*>(*h)->IsAuxiliary() ) {
134       if ( strcmp( "QuadraticMesh", (*h)->GetName() ) == 0 )
135         _quadraticMesh = true;
136     }
137     else {
138       if ( !theHyp )
139         theHyp = *h; // use only the first non-auxiliary hypothesis
140     }
141   }
142
143   if ( !theHyp )
144   {
145     aStatus = SMESH_Hypothesis::HYP_MISSING;
146     return false;  // can't work without a hypothesis
147   }
148
149   string hypName = theHyp->GetName();
150
151   if (hypName == "LocalLength")
152   {
153     const StdMeshers_LocalLength * hyp =
154       dynamic_cast <const StdMeshers_LocalLength * >(theHyp);
155     ASSERT(hyp);
156     _value[ BEG_LENGTH_IND ] = _value[ END_LENGTH_IND ] = hyp->GetLength();
157     ASSERT( _value[ BEG_LENGTH_IND ] > 0 );
158     _hypType = LOCAL_LENGTH;
159     aStatus = SMESH_Hypothesis::HYP_OK;
160   }
161
162   else if (hypName == "NumberOfSegments")
163   {
164     const StdMeshers_NumberOfSegments * hyp =
165       dynamic_cast <const StdMeshers_NumberOfSegments * >(theHyp);
166     ASSERT(hyp);
167     _ivalue[ NB_SEGMENTS_IND  ] = hyp->GetNumberOfSegments();
168     ASSERT( _ivalue[ NB_SEGMENTS_IND ] > 0 );
169     _ivalue[ DISTR_TYPE_IND ] = (int) hyp->GetDistrType();
170     switch (_ivalue[ DISTR_TYPE_IND ])
171     {
172     case StdMeshers_NumberOfSegments::DT_Scale:
173       _value[ SCALE_FACTOR_IND ] = hyp->GetScaleFactor();
174       break;
175     case StdMeshers_NumberOfSegments::DT_TabFunc:
176       _vvalue[ TAB_FUNC_IND ] = hyp->GetTableFunction();
177       break;
178     case StdMeshers_NumberOfSegments::DT_ExprFunc:
179       _svalue[ EXPR_FUNC_IND ] = hyp->GetExpressionFunction();
180       break;
181     case StdMeshers_NumberOfSegments::DT_Regular:
182       break;
183     default:
184       ASSERT(0);
185       break;
186     }
187     if (_ivalue[ DISTR_TYPE_IND ] == StdMeshers_NumberOfSegments::DT_TabFunc ||
188         _ivalue[ DISTR_TYPE_IND ] == StdMeshers_NumberOfSegments::DT_ExprFunc)
189         _ivalue[ CONV_MODE_IND ] = hyp->ConversionMode();
190     _hypType = NB_SEGMENTS;
191     aStatus = SMESH_Hypothesis::HYP_OK;
192   }
193
194   else if (hypName == "Arithmetic1D")
195   {
196     const StdMeshers_Arithmetic1D * hyp =
197       dynamic_cast <const StdMeshers_Arithmetic1D * >(theHyp);
198     ASSERT(hyp);
199     _value[ BEG_LENGTH_IND ] = hyp->GetLength( true );
200     _value[ END_LENGTH_IND ] = hyp->GetLength( false );
201     ASSERT( _value[ BEG_LENGTH_IND ] > 0 && _value[ END_LENGTH_IND ] > 0 );
202     _hypType = ARITHMETIC_1D;
203     aStatus = SMESH_Hypothesis::HYP_OK;
204   }
205
206   else if (hypName == "StartEndLength")
207   {
208     const StdMeshers_StartEndLength * hyp =
209       dynamic_cast <const StdMeshers_StartEndLength * >(theHyp);
210     ASSERT(hyp);
211     _value[ BEG_LENGTH_IND ] = hyp->GetLength( true );
212     _value[ END_LENGTH_IND ] = hyp->GetLength( false );
213     ASSERT( _value[ BEG_LENGTH_IND ] > 0 && _value[ END_LENGTH_IND ] > 0 );
214     _hypType = BEG_END_LENGTH;
215     aStatus = SMESH_Hypothesis::HYP_OK;
216   }
217
218   else if (hypName == "Deflection1D")
219   {
220     const StdMeshers_Deflection1D * hyp =
221       dynamic_cast <const StdMeshers_Deflection1D * >(theHyp);
222     ASSERT(hyp);
223     _value[ DEFLECTION_IND ] = hyp->GetDeflection();
224     ASSERT( _value[ DEFLECTION_IND ] > 0 );
225     _hypType = DEFLECTION;
226     aStatus = SMESH_Hypothesis::HYP_OK;
227   }
228
229   else if (hypName == "AutomaticLength")
230   {
231     StdMeshers_AutomaticLength * hyp = const_cast<StdMeshers_AutomaticLength *>
232       (dynamic_cast <const StdMeshers_AutomaticLength * >(theHyp));
233     ASSERT(hyp);
234     _value[ BEG_LENGTH_IND ] = _value[ END_LENGTH_IND ] = hyp->GetLength( &aMesh, aShape );
235     ASSERT( _value[ BEG_LENGTH_IND ] > 0 );
236     _hypType = LOCAL_LENGTH;
237     aStatus = SMESH_Hypothesis::HYP_OK;
238   }
239   else
240     aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE;
241
242   return ( _hypType != NONE );
243 }
244
245 //=======================================================================
246 //function : compensateError
247 //purpose  : adjust theParams so that the last segment length == an
248 //=======================================================================
249
250 static void compensateError(double a1, double an,
251                             double U1, double Un,
252                             double             length,
253                             GeomAdaptor_Curve& C3d,
254                             list<double> &     theParams)
255 {
256   int i, nPar = theParams.size();
257   if ( a1 + an < length && nPar > 1 )
258   {
259     list<double>::reverse_iterator itU = theParams.rbegin();
260     double Ul = *itU++;
261     // dist from the last point to the edge end <Un>, it should be equal <an>
262     double Ln = GCPnts_AbscissaPoint::Length( C3d, Ul, Un );
263     double dLn = an - Ln; // error of <an>
264     if ( Abs( dLn ) <= Precision::Confusion() )
265       return;
266     double dU = Abs( Ul - *itU ); // parametric length of the last but one segment
267     double dUn = dLn * Abs( Un - U1 ) / length; // parametric error of <an>
268     if ( dUn < 0.5 * dU ) { // last segment is a bit shorter than it should
269       dUn = -dUn; // move the last parameter to the edge beginning
270     }
271     else {  // last segment is much shorter than it should -> remove the last param and
272       theParams.pop_back(); nPar--; // move the rest points toward the edge end
273       Ln = GCPnts_AbscissaPoint::Length( C3d, theParams.back(), Un );
274       dUn = ( an - Ln ) * Abs( Un - U1 ) / length;
275       if ( dUn < 0.5 * dU )
276         dUn = -dUn;
277     }
278     if ( U1 > Un )
279       dUn = -dUn;
280     double q  = dUn / ( nPar - 1 );
281     for ( itU = theParams.rbegin(), i = 1; i < nPar; itU++, i++ ) {
282       (*itU) += dUn;
283       dUn -= q;
284     }
285   }
286 }
287
288 static bool computeParamByFunc(Adaptor3d_Curve& C3d, double first, double last,
289                                double length, bool theReverse, 
290                                int nbSeg, Function& func,
291                                list<double>& theParams)
292 {
293   // never do this way
294   //OSD::SetSignal( true );
295
296   if( nbSeg<=0 )
297     return false;
298
299   MESSAGE( "computeParamByFunc" );
300
301   int nbPnt = 1 + nbSeg;
302   vector<double> x(nbPnt, 0.);
303
304   if( !buildDistribution( func, 0.0, 1.0, nbSeg, x, 1E-4 ) )
305      return false;
306
307   MESSAGE( "Points:\n" );
308   char buf[1024];
309   for( int i=0; i<=nbSeg; i++ )
310   {
311     sprintf(  buf, "%f\n", float(x[i] ) );
312     MESSAGE( buf );
313   }
314     
315
316
317   // apply parameters in range [0,1] to the space of the curve
318   double prevU = first;
319   double sign = 1.;
320   if (theReverse)
321   {
322     prevU = last;
323     sign = -1.;
324   }
325   for( int i = 1; i < nbSeg; i++ )
326   {
327     double curvLength = length * (x[i] - x[i-1]) * sign;
328     GCPnts_AbscissaPoint Discret( C3d, curvLength, prevU );
329     if ( !Discret.IsDone() )
330       return false;
331     double U = Discret.Parameter();
332     if ( U > first && U < last )
333       theParams.push_back( U );
334     else
335       return false;
336     prevU = U;
337   }
338   return true;
339 }
340
341 //=============================================================================
342 /*!
343  *  
344  */
345 //=============================================================================
346 bool StdMeshers_Regular_1D::computeInternalParameters(const TopoDS_Edge& theEdge,
347                                                       list<double> &     theParams,
348                                                       const bool         theReverse) const
349 {
350   theParams.clear();
351
352   double f, l;
353   Handle(Geom_Curve) Curve = BRep_Tool::Curve(theEdge, f, l);
354   GeomAdaptor_Curve C3d (Curve, f, l);
355
356   double length = EdgeLength(theEdge);
357
358   switch( _hypType )
359   {
360   case LOCAL_LENGTH:
361   case NB_SEGMENTS: {
362
363     double eltSize = 1;
364     if ( _hypType == LOCAL_LENGTH )
365     {
366       // Local Length hypothesis
367       double nbseg = ceil(length / _value[ BEG_LENGTH_IND ]); // integer sup
368       if (nbseg <= 0)
369         nbseg = 1;                        // degenerated edge
370       eltSize = length / nbseg;
371     }
372     else
373     {
374       // Number Of Segments hypothesis
375       int NbSegm = _ivalue[ NB_SEGMENTS_IND ];
376       if ( NbSegm < 1 )  return false;
377       if ( NbSegm == 1 ) return true;
378
379       switch (_ivalue[ DISTR_TYPE_IND ])
380       {
381       case StdMeshers_NumberOfSegments::DT_Scale:
382         {
383           double scale = _value[ SCALE_FACTOR_IND ];
384
385           if (fabs(scale - 1.0) < Precision::Confusion()) {
386             // special case to avoid division on zero
387             for (int i = 1; i < NbSegm; i++) {
388               double param = f + (l - f) * i / NbSegm;
389               theParams.push_back( param );
390             }
391           } else {
392             // general case of scale distribution
393             if ( theReverse )
394               scale = 1.0 / scale;
395
396             double alpha = pow(scale, 1.0 / (NbSegm - 1));
397             double factor = (l - f) / (1.0 - pow(alpha, NbSegm));
398
399             for (int i = 1; i < NbSegm; i++) {
400               double param = f + factor * (1.0 - pow(alpha, i));
401               theParams.push_back( param );
402             }
403           }
404           return true;
405         }
406         break;
407       case StdMeshers_NumberOfSegments::DT_TabFunc:
408         {
409           FunctionTable func(_vvalue[ TAB_FUNC_IND ], _ivalue[ CONV_MODE_IND ]);
410           return computeParamByFunc(C3d, f, l, length, theReverse,
411                                     _ivalue[ NB_SEGMENTS_IND ], func,
412                                     theParams);
413         }
414         break;
415       case StdMeshers_NumberOfSegments::DT_ExprFunc:
416         {
417           FunctionExpr func(_svalue[ EXPR_FUNC_IND ].c_str(), _ivalue[ CONV_MODE_IND ]);
418           return computeParamByFunc(C3d, f, l, length, theReverse,
419                                     _ivalue[ NB_SEGMENTS_IND ], func,
420                                     theParams);
421         }
422         break;
423       case StdMeshers_NumberOfSegments::DT_Regular:
424         eltSize = length / _ivalue[ NB_SEGMENTS_IND ];
425         break;
426       default:
427         return false;
428       }
429     }
430     GCPnts_UniformAbscissa Discret(C3d, eltSize, f, l);
431     if ( !Discret.IsDone() )
432       return false;
433
434     int NbPoints = Discret.NbPoints();
435     for ( int i = 2; i < NbPoints; i++ )
436     {
437       double param = Discret.Parameter(i);
438       theParams.push_back( param );
439     }
440     compensateError( eltSize, eltSize, f, l, length, C3d, theParams ); // for PAL9899
441     return true;
442   }
443
444   case BEG_END_LENGTH: {
445
446     // geometric progression: SUM(n) = ( a1 - an * q ) / ( 1 - q ) = length
447
448     double a1 = _value[ BEG_LENGTH_IND ];
449     double an = _value[ END_LENGTH_IND ];
450     double q  = ( length - a1 ) / ( length - an );
451
452     double U1 = theReverse ? l : f;
453     double Un = theReverse ? f : l;
454     double param = U1;
455     double eltSize = theReverse ? -a1 : a1;
456     while ( 1 ) {
457       // computes a point on a curve <C3d> at the distance <eltSize>
458       // from the point of parameter <param>.
459       GCPnts_AbscissaPoint Discret( C3d, eltSize, param );
460       if ( !Discret.IsDone() ) break;
461       param = Discret.Parameter();
462       if ( param > f && param < l )
463         theParams.push_back( param );
464       else
465         break;
466       eltSize *= q;
467     }
468     compensateError( a1, an, U1, Un, length, C3d, theParams );
469     return true;
470   }
471
472   case ARITHMETIC_1D: {
473
474     // arithmetic progression: SUM(n) = ( an - a1 + q ) * ( a1 + an ) / ( 2 * q ) = length
475
476     double a1 = _value[ BEG_LENGTH_IND ];
477     double an = _value[ END_LENGTH_IND ];
478
479     double  q = ( an - a1 ) / ( 2 *length/( a1 + an ) - 1 );
480     int     n = int( 1 + ( an - a1 ) / q );
481
482     double U1 = theReverse ? l : f;
483     double Un = theReverse ? f : l;
484     double param = U1;
485     double eltSize = a1;
486     if ( theReverse ) {
487       eltSize = -eltSize;
488       q = -q;
489     }
490     while ( n-- > 0 && eltSize * ( Un - U1 ) > 0 ) {
491       // computes a point on a curve <C3d> at the distance <eltSize>
492       // from the point of parameter <param>.
493       GCPnts_AbscissaPoint Discret( C3d, eltSize, param );
494       if ( !Discret.IsDone() ) break;
495       param = Discret.Parameter();
496       if ( param > f && param < l )
497         theParams.push_back( param );
498       else
499         break;
500       eltSize += q;
501     }
502     compensateError( a1, an, U1, Un, length, C3d, theParams );
503
504     return true;
505   }
506
507   case DEFLECTION: {
508
509     GCPnts_UniformDeflection Discret(C3d, _value[ DEFLECTION_IND ], f, l, true);
510     if ( !Discret.IsDone() )
511       return false;
512
513     int NbPoints = Discret.NbPoints();
514     for ( int i = 2; i < NbPoints; i++ )
515     {
516       double param = Discret.Parameter(i);
517       theParams.push_back( param );
518     }
519     return true;
520     
521   }
522
523   default:;
524   }
525
526   return false;
527 }
528
529 //=============================================================================
530 /*!
531  *  
532  */
533 //=============================================================================
534
535 bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape)
536 {
537   MESSAGE("StdMeshers_Regular_1D::Compute");
538
539   if ( _hypType == NONE )
540     return false;
541
542   SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
543   aMesh.GetSubMesh(aShape);
544
545   const TopoDS_Edge & EE = TopoDS::Edge(aShape);
546   TopoDS_Edge E = TopoDS::Edge(EE.Oriented(TopAbs_FORWARD));
547   int shapeID = meshDS->ShapeToIndex( E );
548
549   double f, l;
550   Handle(Geom_Curve) Curve = BRep_Tool::Curve(E, f, l);
551
552   TopoDS_Vertex VFirst, VLast;
553   TopExp::Vertices(E, VFirst, VLast);   // Vfirst corresponds to f and Vlast to l
554
555   ASSERT(!VFirst.IsNull());
556   SMDS_NodeIteratorPtr lid= aMesh.GetSubMesh(VFirst)->GetSubMeshDS()->GetNodes();
557   if (!lid->more())
558   {
559     MESSAGE (" NO NODE BUILT ON VERTEX ");
560     return false;
561   }
562   const SMDS_MeshNode * idFirst = lid->next();
563
564   ASSERT(!VLast.IsNull());
565   lid=aMesh.GetSubMesh(VLast)->GetSubMeshDS()->GetNodes();
566   if (!lid->more()) {
567     MESSAGE (" NO NODE BUILT ON VERTEX ");
568     return false;
569   }
570   const SMDS_MeshNode * idLast = lid->next();
571
572   if (!Curve.IsNull()) {
573     list< double > params;
574     bool reversed = false;
575     if ( !_mainEdge.IsNull() )
576       reversed = aMesh.IsReversedInChain( EE, _mainEdge );
577     try {
578 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
579       OCC_CATCH_SIGNALS;
580 #endif
581       if ( ! computeInternalParameters( E, params, reversed )) {
582         //cout << "computeInternalParameters() failed" <<endl;
583         return false;
584       }
585     }
586     catch ( Standard_Failure ) {
587       //cout << "computeInternalParameters() failed, Standard_Failure" <<endl;
588       return false;
589     }
590
591     // edge extrema (indexes : 1 & NbPoints) already in SMDS (TopoDS_Vertex)
592     // only internal nodes receive an edge position with param on curve
593
594     const SMDS_MeshNode * idPrev = idFirst;
595     double parPrev = f;
596     double parLast = l;
597 //     if(reversed) {
598 //       parPrev = l;
599 //       parLast = f;
600 //     }
601     
602     for (list<double>::iterator itU = params.begin(); itU != params.end(); itU++) {
603       double param = *itU;
604       gp_Pnt P = Curve->Value(param);
605
606       //Add the Node in the DataStructure
607       SMDS_MeshNode * node = meshDS->AddNode(P.X(), P.Y(), P.Z());
608       meshDS->SetNodeOnEdge(node, shapeID, param);
609
610       if(_quadraticMesh) {
611         // create medium node
612         double prm = ( parPrev + param )/2;
613         gp_Pnt PM = Curve->Value(prm);
614         SMDS_MeshNode * NM = meshDS->AddNode(PM.X(), PM.Y(), PM.Z());
615         meshDS->SetNodeOnEdge(NM, shapeID, prm);
616         SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, node, NM);
617         meshDS->SetMeshElementOnShape(edge, shapeID);
618       }
619       else {
620         SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, node);
621         meshDS->SetMeshElementOnShape(edge, shapeID);
622       }
623
624       idPrev = node;
625       parPrev = param;
626     }
627     if(_quadraticMesh) {
628       double prm = ( parPrev + parLast )/2;
629       gp_Pnt PM = Curve->Value(prm);
630       SMDS_MeshNode * NM = meshDS->AddNode(PM.X(), PM.Y(), PM.Z());
631       meshDS->SetNodeOnEdge(NM, shapeID, prm);
632       SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, idLast, NM);
633       meshDS->SetMeshElementOnShape(edge, shapeID);
634     }
635     else {
636       SMDS_MeshEdge* edge = meshDS->AddEdge(idPrev, idLast);
637       meshDS->SetMeshElementOnShape(edge, shapeID);
638     }
639   }
640   else {
641     // Edge is a degenerated Edge : We put n = 5 points on the edge.
642     const int NbPoints = 5;
643     BRep_Tool::Range(E, f, l);
644     double du = (l - f) / (NbPoints - 1);
645     //MESSAGE("************* Degenerated edge! *****************");
646
647     TopoDS_Vertex V1, V2;
648     TopExp::Vertices(E, V1, V2);
649     gp_Pnt P = BRep_Tool::Pnt(V1);
650
651     const SMDS_MeshNode * idPrev = idFirst;
652     for (int i = 2; i < NbPoints; i++) {
653       double param = f + (i - 1) * du;
654       SMDS_MeshNode * node = meshDS->AddNode(P.X(), P.Y(), P.Z());
655       if(_quadraticMesh) {
656         // create medium node
657         double prm = param - du/2.;
658         SMDS_MeshNode * NM = meshDS->AddNode(P.X(), P.Y(), P.Z());
659         meshDS->SetNodeOnEdge(NM, shapeID, prm);
660         SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, node, NM);
661         meshDS->SetMeshElementOnShape(edge, shapeID);
662       }
663       else {
664         SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, node);
665         meshDS->SetMeshElementOnShape(edge, shapeID);
666       }
667       meshDS->SetNodeOnEdge(node, shapeID, param);
668       idPrev = node;
669     }
670     if(_quadraticMesh) {
671       // create medium node
672       double prm = l - du/2.;
673       SMDS_MeshNode * NM = meshDS->AddNode(P.X(), P.Y(), P.Z());
674       meshDS->SetNodeOnEdge(NM, shapeID, prm);
675       SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, idLast, NM);
676       meshDS->SetMeshElementOnShape(edge, shapeID);
677     }
678     else {
679       SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, idLast);
680       meshDS->SetMeshElementOnShape(edge, shapeID);
681     }
682   }
683   return true;
684 }
685
686 //=============================================================================
687 /*!
688  *  See comments in SMESH_Algo.cxx
689  */
690 //=============================================================================
691
692 const list <const SMESHDS_Hypothesis *> &
693 StdMeshers_Regular_1D::GetUsedHypothesis(SMESH_Mesh &         aMesh,
694                                          const TopoDS_Shape & aShape,
695                                          const bool           ignoreAuxiliary)
696 {
697   _usedHypList.clear();
698   _mainEdge.Nullify();
699
700   SMESH_HypoFilter auxiliaryFilter, compatibleFilter;
701   auxiliaryFilter.Init( SMESH_HypoFilter::IsAuxiliary() );
702   const bool ignoreAux = true;
703   InitCompatibleHypoFilter( compatibleFilter, ignoreAux );
704
705   // get non-auxiliary assigned to aShape
706   int nbHyp = aMesh.GetHypotheses( aShape, compatibleFilter, _usedHypList, false );
707
708   if (nbHyp == 0)
709   {
710     // Check, if propagated from some other edge
711     if (aShape.ShapeType() == TopAbs_EDGE &&
712         aMesh.IsPropagatedHypothesis(aShape, _mainEdge))
713     {
714       // Propagation of 1D hypothesis from <aMainEdge> on this edge;
715       // get non-auxiliary assigned to _mainEdge
716       nbHyp = aMesh.GetHypotheses( _mainEdge, compatibleFilter, _usedHypList, true );
717     }
718   }
719
720   if (nbHyp == 0) // nothing propagated nor assigned to aShape
721   {
722     SMESH_Algo::GetUsedHypothesis( aMesh, aShape, ignoreAuxiliary );
723     nbHyp = _usedHypList.size();
724   }
725   else
726   {
727     // get auxiliary hyps from aShape
728     aMesh.GetHypotheses( aShape, auxiliaryFilter, _usedHypList, true );
729   }
730   if ( nbHyp > 1 && ignoreAuxiliary )
731     _usedHypList.clear(); //only one compatible non-auxiliary hypothesis allowed
732
733   return _usedHypList;
734 }
735
736 //=============================================================================
737 /*!
738  *  
739  */
740 //=============================================================================
741
742 ostream & StdMeshers_Regular_1D::SaveTo(ostream & save)
743 {
744   return save;
745 }
746
747 //=============================================================================
748 /*!
749  *  
750  */
751 //=============================================================================
752
753 istream & StdMeshers_Regular_1D::LoadFrom(istream & load)
754 {
755   return load;
756 }
757
758 //=============================================================================
759 /*!
760  *  
761  */
762 //=============================================================================
763
764 ostream & operator <<(ostream & save, StdMeshers_Regular_1D & hyp)
765 {
766   return hyp.SaveTo( save );
767 }
768
769 //=============================================================================
770 /*!
771  *  
772  */
773 //=============================================================================
774
775 istream & operator >>(istream & load, StdMeshers_Regular_1D & hyp)
776 {
777   return hyp.LoadFrom( load );
778 }