1ce9a6de64a9b4dd5b7beebb58ae9d99abe35fa8
[occt.git] / src / ChFiDS / ChFiDS_FilSpine.cxx
1 // Created on: 1995-04-24
2 // Created by: Modelistation
3 // Copyright (c) 1995-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17
18 #include <ChFiDS_FilSpine.hxx>
19 #include <ChFiDS_HElSpine.hxx>
20 #include <ChFiDS_ListIteratorOfListOfHElSpine.hxx>
21 #include <ElCLib.hxx>
22 #include <gp_XY.hxx>
23 #include <Law_Composite.hxx>
24 #include <Law_Constant.hxx>
25 #include <Law_Function.hxx>
26 #include <Law_Interpol.hxx>
27 #include <Law_ListIteratorOfLaws.hxx>
28 #include <Law_S.hxx>
29 #include <Precision.hxx>
30 #include <Standard_DomainError.hxx>
31 #include <Standard_Type.hxx>
32 #include <TColgp_Array1OfPnt2d.hxx>
33 #include <TColStd_Array1OfInteger.hxx>
34 #include <TColStd_HArray1OfBoolean.hxx>
35 #include <TopoDS_Edge.hxx>
36 #include <TopoDS_Vertex.hxx>
37
38 IMPLEMENT_STANDARD_RTTIEXT(ChFiDS_FilSpine,ChFiDS_Spine)
39
40 //=======================================================================
41 //function : ChFiDS_FilSpine
42 //purpose  : 
43 //=======================================================================
44 ChFiDS_FilSpine::ChFiDS_FilSpine() {}
45
46 ChFiDS_FilSpine::ChFiDS_FilSpine(const Standard_Real Tol) :
47 ChFiDS_Spine(Tol)
48 {}
49
50 //=======================================================================
51 //function : Reset
52 //purpose  : 
53 //=======================================================================
54
55 void ChFiDS_FilSpine::Reset(const Standard_Boolean AllData)
56 {
57   ChFiDS_Spine::Reset(AllData);
58   laws.Clear();
59   if(AllData)
60     parandrad.Clear();
61   else //Complete parandrad
62     {
63       Standard_Real spinedeb = FirstParameter();
64       Standard_Real spinefin = LastParameter();
65
66       gp_XY FirstUandR = parandrad.First();
67       gp_XY LastUandR  = parandrad.Last();
68       if (Abs( spinedeb - FirstUandR.X() ) > gp::Resolution())
69         {
70           FirstUandR.SetX( spinedeb );
71           parandrad.Prepend( FirstUandR );
72         }
73       if (Abs( spinefin - LastUandR.X() ) > gp::Resolution())
74         {
75           LastUandR.SetX( spinefin );
76           parandrad.Append( LastUandR );
77         }
78
79       if (IsPeriodic())
80         parandrad(parandrad.Length()).SetY( parandrad(1).Y() );
81     }
82 }
83
84 //=======================================================================
85 //function : SetRadius
86 //purpose  : 
87 //=======================================================================
88
89 void  ChFiDS_FilSpine::SetRadius(const Standard_Real Radius,
90                                  const TopoDS_Edge&  E)
91 {
92   splitdone = Standard_False;
93   Standard_Integer IE = Index(E);
94   gp_XY FirstUandR( 0., Radius ), LastUandR( 1., Radius );
95   SetRadius( FirstUandR, IE );
96   SetRadius( LastUandR, IE );
97 }
98
99 //=======================================================================
100 //function : UnSetRadius
101 //purpose  : 
102 //=======================================================================
103
104 void  ChFiDS_FilSpine::UnSetRadius(const TopoDS_Edge&  E)
105 {
106   splitdone = Standard_False;
107   Standard_Integer IE = Index(E);
108
109   Standard_Real Uf = FirstParameter(IE);
110   Standard_Real Ul = LastParameter(IE);
111   Standard_Integer ifirst = 0, ilast = 0;
112   for (Standard_Integer i = 1; i <= parandrad.Length(); i++)
113     {
114       if (Abs(parandrad(i).X()-Uf) <= gp::Resolution())
115         ifirst = i;
116       if (Abs(parandrad(i).X()-Ul) <= gp::Resolution())
117         ilast = i;
118     }
119   if (ifirst != 0 && ilast != 0)
120     parandrad.Remove( ifirst, ilast );
121 }
122
123 //=======================================================================
124 //function : SetRadius
125 //purpose  : 
126 //=======================================================================
127
128 void  ChFiDS_FilSpine::SetRadius(const Standard_Real  Radius,
129                                  const TopoDS_Vertex& V)
130 {
131   Standard_Real npar = Absc(V);
132   gp_XY UandR( npar, Radius );
133   SetRadius( UandR, 0 );
134 }
135
136 //=======================================================================
137 //function : SetRadius
138 //purpose  : 
139 //=======================================================================
140
141 void  ChFiDS_FilSpine::SetRadius(const Standard_Real  Radius)
142 {
143   parandrad.Clear();
144   gp_XY FirstUandR( FirstParameter(), Radius );
145   gp_XY LastUandR( LastParameter(), Radius );
146   SetRadius( FirstUandR, 0 );
147   SetRadius( LastUandR, 0 );
148 }
149
150 //=======================================================================
151 //function : SetRadius
152 //purpose  : 
153 //=======================================================================
154
155 void  ChFiDS_FilSpine::SetRadius(const gp_XY&           UandR,
156                                  const Standard_Integer IinC)
157 {
158   Standard_Real W;
159   if (IinC == 0)
160     W = UandR.X();
161   else
162     {
163       Standard_Real Uf = FirstParameter(IinC);
164       Standard_Real Ul = LastParameter(IinC);
165       W = Uf + UandR.X()*( Ul - Uf );
166     }
167
168   gp_XY pr( W, UandR.Y() );
169   Standard_Integer i;
170   for(i = 1; i <= parandrad.Length(); i++){
171     if(parandrad.Value(i).X() == W) {
172       parandrad.ChangeValue(i).SetY( UandR.Y() );
173       if (!splitdone) return;
174       else break;
175     }
176     else if(parandrad.Value(i).X() > W) {
177       parandrad.InsertBefore(i,pr);
178       if (!splitdone) return;
179       else break;
180     }
181   }
182   if (i == parandrad.Length()+1) parandrad.Append(pr);
183
184   //si le split est done il faut rejouer la law 
185   //correspondant au parametre W 
186   if (splitdone) {
187     ChFiDS_ListIteratorOfListOfHElSpine It(elspines);
188     Law_ListIteratorOfLaws Itl(laws);
189     Handle(ChFiDS_HElSpine) Els = It.Value();
190     if (Els->IsPeriodic()) Itl.Value() = ComputeLaw(Els);
191     else{
192       for (; It.More(); It.Next(), Itl.Next()) {
193         Els = It.Value();
194         Standard_Real uf = Els->FirstParameter();
195         Standard_Real ul = Els->LastParameter();
196         if(uf <= W && W <= ul) {
197           Itl.Value() = ComputeLaw(Els);
198         }
199       }  
200     }
201   }
202 }
203
204 //=======================================================================
205 //function : UnSetRadius
206 //purpose  : 
207 //=======================================================================
208
209 void  ChFiDS_FilSpine::UnSetRadius(const TopoDS_Vertex& V)
210 {
211   Standard_Real npar = Absc(V);
212   for(Standard_Integer i = 1; i <= parandrad.Length(); i++){
213     if(parandrad.Value(i).X() == npar) {
214       parandrad.Remove(i);
215       break;
216     }
217   }
218 }
219
220 //=======================================================================
221 //function : SetRadius
222 //purpose  : 
223 //=======================================================================
224
225 void  ChFiDS_FilSpine::SetRadius(const Handle(Law_Function)& C,
226                                  const Standard_Integer      /*IinC*/)
227 {
228   splitdone = Standard_False;
229   Handle(Law_Composite) prout = new Law_Composite();
230   Law_Laws& lst = prout->ChangeLaws();
231   lst.Append(C);
232   parandrad.Clear();
233 }
234
235
236 //=======================================================================
237 //function : IsConstant
238 //purpose  : 
239 //=======================================================================
240
241 Standard_Boolean  ChFiDS_FilSpine::IsConstant()const 
242 {
243   if (parandrad.IsEmpty())
244     return Standard_False;
245
246   Standard_Boolean isconst = Standard_True;
247   Standard_Real Radius = parandrad(1).Y();
248   for (Standard_Integer i = 2; i <= parandrad.Length(); i++)
249     if (Abs( Radius - parandrad(i).Y() ) > Precision::Confusion())
250       {
251         isconst = Standard_False;
252         break;
253       }
254   return isconst;
255 }
256
257 //=======================================================================
258 //function : IsConstant
259 //purpose  : 
260 //=======================================================================
261
262 Standard_Boolean  ChFiDS_FilSpine::IsConstant(const Standard_Integer IE)const 
263 {
264   Standard_Real Uf = FirstParameter(IE);
265   Standard_Real Ul = LastParameter(IE);
266
267   Standard_Real StartRad = 0.0, par, rad;
268   Standard_Integer i;
269   for (i = 1; i < parandrad.Length(); i++)
270     {
271       par = parandrad(i).X();
272       rad = parandrad(i).Y();
273       Standard_Real nextpar = parandrad(i+1).X();
274       if (Abs( Uf-par ) <= gp::Resolution() ||
275          (par < Uf && Uf < nextpar && nextpar-Uf > gp::Resolution()))
276         {
277           StartRad = rad;
278           break;
279         }
280     }
281   for (i++; i <= parandrad.Length(); i++)
282     {
283       par = parandrad(i).X();
284       rad = parandrad(i).Y();
285       if (Abs( rad-StartRad ) > Precision::Confusion())
286         return Standard_False;
287       if (Abs( Ul-par ) <= gp::Resolution())
288         return Standard_True;
289       if (par > Ul)
290         return Standard_True;
291     }
292   return Standard_True;
293 }
294
295 //=======================================================================
296 //function : Radius
297 //purpose  : 
298 //=======================================================================
299
300 Standard_Real  ChFiDS_FilSpine::Radius(const TopoDS_Edge& E)const 
301 {
302   Standard_Integer IE = Index(E);
303   return Radius(IE);
304 }
305
306 //=======================================================================
307 //function : Radius
308 //purpose  : 
309 //=======================================================================
310
311 Standard_Real  ChFiDS_FilSpine::Radius(const Standard_Integer IE)const 
312 {
313   Standard_Real Uf = FirstParameter(IE);
314   Standard_Real Ul = LastParameter(IE);
315
316   Standard_Real StartRad = 0., par, rad;
317   Standard_Integer i;
318   for (i = 1; i < parandrad.Length(); i++)
319     {
320       par = parandrad(i).X();
321       rad = parandrad(i).Y();
322       Standard_Real nextpar = parandrad(i+1).X();
323       if (Abs( Uf-par ) <= gp::Resolution() ||
324           (par < Uf && Uf < nextpar && nextpar-Uf > gp::Resolution()))
325         {
326           StartRad = rad;
327           break;
328         }
329     }
330   for (i++; i <= parandrad.Length(); i++)
331     {
332       par = parandrad(i).X();
333       rad = parandrad(i).Y();
334       if (Abs( rad-StartRad ) > Precision::Confusion())
335         Standard_DomainError::Raise("Edge is not constant");
336       if (Abs( Ul-par ) <= gp::Resolution())
337         return StartRad;
338       if (par > Ul)
339         return StartRad;
340     }
341   return StartRad;
342 }
343
344 //=======================================================================
345 //function : Radius
346 //purpose  : 
347 //=======================================================================
348
349 Standard_Real  ChFiDS_FilSpine::Radius()const 
350 {
351   if (!IsConstant()) Standard_DomainError::Raise("Spine is not constant");
352   return parandrad(1).Y();
353 }
354
355 //=======================================================================
356 //function : AppendElSpine
357 //purpose  : 
358 //=======================================================================
359
360 void ChFiDS_FilSpine::AppendElSpine(const Handle(ChFiDS_HElSpine)& Els)
361 {
362   ChFiDS_Spine::AppendElSpine(Els);
363   AppendLaw(Els);
364 }
365
366 //=======================================================================
367 //function : AppendLaw
368 //purpose  : 
369 //=======================================================================
370
371 void ChFiDS_FilSpine::AppendLaw(const Handle(ChFiDS_HElSpine)& Els)
372 {
373   Handle(Law_Composite) l = ComputeLaw(Els);
374   laws.Append(l);
375 }
376
377 static void mklaw(Law_Laws&                  res, 
378                   const TColgp_SequenceOfXY& pr,
379                   const Standard_Real        curdeb,
380                   const Standard_Real        curfin,
381                   const Standard_Real        Rdeb,
382                   const Standard_Real        Rfin,
383                   const Standard_Boolean     recadre,
384                   const Standard_Real        deb,
385                   const Standard_Real        fin,
386                   const Standard_Real        tol3d)
387 {
388   TColgp_SequenceOfXY npr;
389   Standard_Real rad = Rdeb, raf = Rfin;
390   Standard_Boolean yaunpointsurledeb = Standard_False;
391   Standard_Boolean yaunpointsurlefin = Standard_False;
392   if(!pr.IsEmpty()){
393     for (Standard_Integer i = 1; i <= pr.Length(); i++){
394       const gp_XY& cur = pr.Value(i);
395       Standard_Real wcur = cur.X();
396       if(recadre) wcur = ElCLib::InPeriod(wcur,deb,fin);
397       if( curdeb - tol3d <= wcur && wcur <= curfin + tol3d) {
398         if(wcur - curdeb < tol3d) {
399           yaunpointsurledeb = Standard_True;
400           gp_XY ncur = cur;
401           if(Rdeb < 0.) rad = cur.Y();
402           ncur.SetCoord(curdeb,rad);
403           npr.Append(ncur);
404         }  
405         else if(curfin - wcur < tol3d) {
406           yaunpointsurlefin = Standard_True;
407           gp_XY ncur = cur;
408           if(Rfin < 0.) raf = cur.Y();
409           ncur.SetCoord(curfin,raf);
410           npr.Append(ncur);
411         }  
412         else npr.Append(gp_XY(wcur,cur.Y()));
413       }
414     }
415   }
416
417   if(npr.IsEmpty()){
418     if( Rdeb < 0. && Rfin <0. ) 
419       Standard_DomainError::Raise("Impossible to create the law");
420     else if(Rdeb < 0. || Rfin <0.){
421       Standard_Real r = (Rfin<0.)? Rdeb  : Rfin;
422       Handle(Law_Constant) loi = new Law_Constant();
423       loi->Set(r,curdeb,curfin);
424       res.Append(loi);
425     }
426     else{
427       Handle(Law_S) loi = new Law_S();
428       loi->Set(curdeb,Rdeb,curfin,Rfin);
429       res.Append(loi);
430     }
431   }
432   else{
433     if(!yaunpointsurledeb && Rdeb >= 0.) npr.Append(gp_XY(curdeb,Rdeb));
434     if(!yaunpointsurlefin && Rfin >= 0.) npr.Append(gp_XY(curfin,Rfin));
435     Standard_Integer nbp = npr.Length();
436 //    for(Standard_Integer i = 1; i < nbp; i++){
437     Standard_Integer i;
438     for(i = 1; i < nbp; i++){
439       for(Standard_Integer j = i + 1; j <= nbp; j++){
440         if(npr.Value(i).X() > npr.Value(j).X()){
441           gp_XY temp = npr.Value(i);
442           npr.ChangeValue(i) = npr.Value(j);
443           npr.ChangeValue(j) = temp;
444         }
445       }      
446     }
447     //Duplicates are removed.
448     Standard_Boolean fini = (nbp <= 1);
449     i = 1;
450     while (!fini) {
451       if(fabs(npr.Value(i).X() - npr.Value(i+1).X()) < tol3d) {
452         npr.Remove(i);
453         nbp--;
454       }
455       else i++;
456       fini = (i >= nbp);
457     }
458
459     if(rad < 0.) {
460       Handle(Law_Constant) loi = new Law_Constant();
461       loi->Set(npr.First().Y(),curdeb,npr.First().X());
462       res.Append(loi);
463     }
464     if(nbp > 1){
465       TColgp_Array1OfPnt2d tpr(1,nbp);
466       for (Standard_Integer l = 1; l <= nbp; l++) {
467         tpr(l).SetXY(npr.Value(l));
468       }
469       Handle(Law_Interpol) curloi = new Law_Interpol();
470       curloi->Set(tpr,0.,0.,Standard_False);
471       res.Append(curloi);
472     }
473     if(raf < 0.) {
474       Handle(Law_Constant) loi = new Law_Constant();
475       loi->Set(npr.Last().Y(),npr.Last().X(),curfin);
476       res.Append(loi);
477     }
478   }
479 }
480                                   
481 //=======================================================================
482 //function : ComputeLaw
483 //purpose  : 
484 //=======================================================================
485
486 Handle(Law_Composite) ChFiDS_FilSpine::ComputeLaw
487 (const Handle(ChFiDS_HElSpine)& Els)
488 {
489   Standard_Real tol3d = Precision::Confusion();
490   Standard_Real deb,fin,curdeb,curfin;
491   curdeb = deb = Els->FirstParameter();
492   curfin = fin = Els->LastParameter();
493   Standard_Integer ideb = Index(deb,Standard_True);
494   Standard_Integer ifin = Index(fin,Standard_False);
495   Standard_Integer len = NbEdges();
496   // if the spine is periodic, attention to the index and parameters
497   Standard_Real spinedeb = FirstParameter();
498   Standard_Real spinefin = LastParameter();
499
500   Standard_Integer nbed = ifin - ideb + 1;
501   Standard_Integer bidfin = ifin;
502
503   Handle(Law_Composite) loi = new Law_Composite();
504   Law_Laws& list = loi->ChangeLaws();
505   Standard_Real Rdeb = 0., Rfin = 0., Rcur;
506   Standard_Integer icur = 1;
507   Handle(Law_S) sl;
508   Handle(Law_Constant) lastloi;
509   Standard_Boolean lawencours = Standard_False;
510
511
512   if(IsPeriodic()){
513     if(deb < 0 && ideb > ifin)  bidfin += len;
514     else if(fin > LastParameter(len) && ideb > ifin)  bidfin += len;
515     nbed = bidfin - ideb + 1;
516   }
517   TColStd_Array1OfInteger ind(1,nbed);
518   Standard_Integer j = 1;
519   for(Standard_Integer i = ideb; i <= bidfin; i++){
520     ind(j++) = ((i - 1)%len) + 1; 
521   }
522
523   if(Els->IsPeriodic()){
524     // A pereodic composite is created at range, which is eventually  
525     // offset relatively to the elspine, to avoid a single point at 
526     // origin.
527     loi->SetPeriodic();
528     //Is there a constant edge?
529 //    for(Standard_Integer k = 1; k <= len; k++){
530     Standard_Integer k;
531     for( k = 1; k <= len; k++){
532       if (IsConstant(k)){ // yes  !
533         spinedeb = deb = curdeb = FirstParameter(k);
534         spinefin = fin = deb + Period();
535         for(Standard_Integer l = 1; l <= len; l++){
536           ind(l) = ((k + l -2)%len) + 1; 
537         }
538         Rdeb = Rfin = Radius(k);
539         icur++;
540         if(len == 1) curfin = LastParameter(k);//because InPeriod will make 0.!!!
541         else curfin = ElCLib::InPeriod(LastParameter(k),spinedeb,spinefin);
542         Handle(Law_Constant) curloi = new Law_Constant();
543         curloi->Set(Rdeb,curdeb,curfin);
544         list.Append(curloi);
545         curdeb = curfin;
546         break;
547       }
548     }
549     if(k > len){ // no !
550       if(parandrad.IsEmpty()) 
551         Standard_DomainError::Raise("Radius not defined");
552       Standard_Integer nbp = parandrad.Length();
553       if(nbp > 1){
554         deb = parandrad.First().X();
555         fin = deb + Period();
556         if(parandrad.Last().X() - fin <  - tol3d) nbp++;
557       }
558       else nbp++;
559       TColgp_Array1OfPnt2d pr(1,nbp);
560       for (Standard_Integer l = 1; l < nbp; l++) {
561         pr(l).SetXY(parandrad(l));
562       }
563       pr(nbp).SetCoord(fin,pr(1).Y());
564       Handle(Law_Interpol) curloi = new Law_Interpol();
565       curloi->Set(pr,Standard_True);
566       list.Append(curloi);
567       return loi;
568     }
569   }
570   else if(IsPeriodic()){
571     // start radius.
572     if (IsConstant(ind(1))) {
573       Rdeb = Radius(ind(1));
574       curfin = LastParameter(ind(1));
575       curfin = ElCLib::InPeriod(curfin,spinedeb + tol3d, spinefin + tol3d);
576       curfin = Min(fin,curfin);
577       Handle(Law_Constant) curloi = new Law_Constant();
578       curloi->Set(Rdeb,curdeb,curfin);
579       list.Append(curloi);
580       curdeb = curfin;
581       icur++;
582     } 
583     else{
584       // There is inevitably kpart right before!
585       Standard_Integer iprec = (ind(1) - 1);
586       if(iprec == 0) iprec = len;
587       if (IsConstant(iprec)){
588         Rdeb = Radius(iprec);
589       }
590       else Standard_DomainError::Raise("AppendLaw : previous constant is missing!");
591       lawencours = Standard_True;
592     }
593     // the raduis at end.
594     if (IsConstant(ind(nbed))) Rfin = Radius(ind(nbed));
595     else{
596       // There is inevitably kpart right after!
597       Standard_Integer isuiv = (ind(nbed) + 1);
598       if(isuiv == len + 1) isuiv = 1;
599       if (IsConstant(isuiv)) {
600         Rfin = Radius(isuiv);
601       }
602       else Standard_DomainError::Raise("AppendLaw : next constant is missing!");
603     }
604   }
605   else{
606     // the radius at start.
607     if (IsConstant(ind(1))) {
608       Rdeb = Radius(ind(1));
609       curfin = Min(fin,LastParameter(ind(1)));
610       Handle(Law_Constant) curloi = new Law_Constant();
611       curloi->Set(Rdeb,curdeb,curfin);
612       list.Append(curloi);
613       curdeb = curfin;
614       icur++;
615     } 
616     else{
617       if(ind(1) > 1){
618         if (IsConstant(ind(1) - 1)){
619           Rdeb = Radius(ind(1) - 1);
620         }
621         else Standard_DomainError::Raise("AppendLaw : previous constant is missing");
622       }
623       else if(parandrad.IsEmpty()){
624         Standard_DomainError::Raise("AppendLaw : no radius on vertex");
625       }
626       else Rdeb = -1.;
627       lawencours = Standard_True;
628     }
629     // the radius at end.
630     if (IsConstant(ind(nbed))) Rfin = Radius(ind(nbed));
631     else{
632       if(ind(nbed) < len){
633         if (IsConstant(ind(nbed) + 1)) Rfin = Radius(ind(nbed) + 1);
634         else Standard_DomainError::Raise("AppendLaw : next constant is missing");
635       }
636       else if(parandrad.IsEmpty()){
637         Standard_DomainError::Raise("AppendLaw : no radius on vertex");
638       }
639       else Rfin = -1.;
640     }
641   }
642
643   // There are infos on the extremities of the elspine, 
644   // all edges are parsed 
645   for(; icur <= nbed; icur++){
646     if (IsConstant(ind(icur))) {
647       Rcur = Radius(ind(icur));
648       if(lawencours){
649         Law_Laws temp;
650         mklaw(temp,parandrad,curdeb,curfin,Rdeb,Rcur,
651               IsPeriodic(),spinedeb,spinefin,tol3d);
652         list.Append(temp);
653         lawencours = Standard_False;
654         curdeb = curfin;
655       }
656       curfin = LastParameter(ind(icur));
657       if(IsPeriodic()){ 
658         curfin = ElCLib::InPeriod(curfin,spinedeb + tol3d, spinefin + tol3d);
659         if(ind(icur) == ind(nbed)){
660           // Attention the curfin can be wrong if the last edge passes 
661           // above the  origin periodic spline.
662           Standard_Real biddeb = FirstParameter(ind(icur));
663           biddeb = ElCLib::InPeriod(biddeb,spinedeb + tol3d, spinefin + tol3d);
664           if(biddeb >= curfin) curfin = fin;
665           else curfin = Min(fin,curfin);
666         }
667         else curfin = Min(fin,curfin);
668       }
669       if((curfin - curdeb) > tol3d){
670         Rdeb = Rcur;
671         Handle(Law_Constant) curloi = new Law_Constant();
672         curloi->Set(Rdeb,curdeb,curfin);
673         list.Append(curloi);
674         curdeb = curfin;
675       }
676     }
677     else {
678       curfin = LastParameter(ind(icur));
679       if(IsPeriodic()) 
680         curfin = ElCLib::InPeriod(curfin,spinedeb + tol3d, spinefin + tol3d);
681       curfin = Min(fin,curfin);
682       lawencours = Standard_True;
683       if(ind(icur) == ind(nbed)){
684         // Attention the curfin can be wrong if the last edge passes 
685           // above the  origin periodic spline.
686         if(IsPeriodic()) {
687           Standard_Real biddeb = FirstParameter(ind(icur));
688           curfin = LastParameter(ind(icur));
689           biddeb = ElCLib::InPeriod(biddeb,spinedeb + tol3d, spinefin + tol3d);
690           curfin = ElCLib::InPeriod(curfin,spinedeb + tol3d, spinefin + tol3d);
691           if(biddeb >= curfin) curfin = fin;
692           else curfin = Min(fin,curfin);
693         }
694         // or if it is the end of spine with extension.
695         else if(ind(icur) == len) curfin = fin;
696         Law_Laws temp;
697         mklaw(temp,parandrad,curdeb,curfin,Rdeb,Rfin,
698               IsPeriodic(),spinedeb,spinefin,tol3d);
699         list.Append(temp);
700       }
701     }
702   }
703   if(!lastloi.IsNull()) list.Append(lastloi);
704   return loi;
705 }
706
707 //=======================================================================
708 //function : Law
709 //purpose  : 
710 //=======================================================================
711
712 Handle(Law_Composite) ChFiDS_FilSpine::Law(const Handle(ChFiDS_HElSpine)& Els) const 
713 {
714   ChFiDS_ListIteratorOfListOfHElSpine Itsp(elspines);
715   Law_ListIteratorOfLaws Itl(laws);
716   for(; Itsp.More(); Itsp.Next(), Itl.Next()){
717     if(Els == Itsp.Value()){
718       return Handle(Law_Composite)::DownCast(Itl.Value());
719     }
720   }
721   return Handle(Law_Composite)();
722 }
723
724 //=======================================================================
725 //function : Law
726 //purpose  : 
727 //=======================================================================
728
729 Handle(Law_Function)& ChFiDS_FilSpine::ChangeLaw(const TopoDS_Edge& E)
730 {
731   if(!SplitDone()) {
732     Standard_DomainError::Raise("ChFiDS_FilSpine::ChangeLaw : the limits are not up-to-date");
733   }
734   Standard_Integer IE = Index(E);
735   if (IsConstant(IE)) {
736     Standard_DomainError::Raise("ChFiDS_FilSpine::ChangeLaw : no law on constant edges");
737   }
738   Handle(ChFiDS_HElSpine) hsp = ElSpine(IE);
739   Standard_Real w = 0.5*(FirstParameter(IE) + LastParameter(IE));
740   Handle(Law_Composite) lc = Law(hsp);
741   return lc->ChangeElementaryLaw(w);
742 }
743
744
745 //=======================================================================
746 //function : Radius
747 //purpose  : 
748 //=======================================================================
749
750 Standard_Real  ChFiDS_FilSpine::MaxRadFromSeqAndLaws()const 
751 {
752   Standard_Real MaxRad = 0.;
753
754   for (Standard_Integer i = 1; i <= parandrad.Length(); i++)
755     if (parandrad(i).Y() > MaxRad)
756       MaxRad = parandrad(i).Y();
757
758   Law_ListIteratorOfLaws itl( laws );
759   for (; itl.More(); itl.Next())
760     {
761       Handle(Law_Function) law = itl.Value();
762       Standard_Real fpar, lpar, par, delta, rad;
763       law->Bounds( fpar, lpar );
764       delta = (lpar - fpar)*0.2;
765       for (Standard_Integer i = 0; i <= 4; i++)
766         {
767           par = fpar + i*delta;
768           rad = law->Value(par);
769           if (rad > MaxRad)
770             MaxRad = rad;
771         }
772       rad = law->Value(lpar);
773       if (rad > MaxRad)
774         MaxRad = rad;
775     }
776   
777   return MaxRad;
778 }