0024510: Remove unused local variables
[occt.git] / src / BRepBlend / BRepBlend_RstRstLineBuilder.cxx
1 // Created on: 1997-01-24
2 // Created by: Laurent BOURESCHE
3 // Copyright (c) 1997-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
9 // under the terms of the GNU Lesser General Public 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 #include <stdio.h>
18
19 #include <BRepBlend_RstRstLineBuilder.ixx>
20 #include <BRepBlend_BlendTool.hxx>
21 #include <TopAbs.hxx>
22 #include <IntSurf.hxx>
23 #include <math_FunctionSetRoot.hxx>
24 #include <gp_Pnt2d.hxx>
25 #include <gp_Pnt.hxx>
26 #include <gp_Vec2d.hxx>
27 #include <gp_Vec.hxx>
28
29 #ifdef DEB
30 #include <TColStd_Array1OfInteger.hxx>
31 #include <TColStd_Array1OfReal.hxx>
32 #include <TColgp_Array1OfPnt2d.hxx>
33 #include <TColgp_Array1OfVec.hxx>
34 #include <TColgp_Array1OfVec2d.hxx>
35 #include <TColgp_Array1OfPnt.hxx>
36 #include <Geom_BSplineCurve.hxx>
37 #ifdef DRAW
38 #include <DrawTrSurf.hxx>
39 #endif
40 static Standard_Integer IndexOfSection = 0;
41 extern Standard_Boolean Blend_GettraceDRAWSECT(); 
42
43 #ifdef DEB_BBPP_N_TRDERIV
44 //-----------------------------------------------------
45 // For debug : visualisation of the section
46 static Standard_Boolean BBPP(const Standard_Real param,
47                              Blend_RstRstFunction& Func,
48                              const math_Vector& sol,
49                              const Standard_Real tol,
50                              Blend_Point& BP)
51 {
52   if(!Func.IsSolution(sol,tol)) return 0;
53   gp_Pnt pntrst1    = Func.PointOnRst1();
54   gp_Pnt pntrst2    = Func.PointOnRst2();
55   gp_Pnt2d p2drst1  = Func.Pnt2dOnRst1();
56   gp_Pnt2d p2drst2  = Func.Pnt2dOnRst2();
57   Standard_Real w1  = Func.ParameterOnRst1();
58   Standard_Real w2  = Func.ParameterOnRst2();
59   BP = Blend_Point(pntrst1, pntrst2, param,
60                    p2drst1.X(), p2drst1.Y(),
61                    p2drst2.X(), p2drst2.Y(), w1, w2);
62   return 1;
63 }
64
65
66 //-----------------------------------------------------
67 static void tracederiv(Blend_RstRstFunction& Func,
68                        const Blend_Point& BP1,
69                        const Blend_Point& BP2)
70 {
71   Standard_Integer hp,hk,hd,hp2d,i;
72   Func.GetShape(hp,hk,hd,hp2d);
73   TColgp_Array1OfPnt TP1(1,hp);
74   TColgp_Array1OfVec TDP1(1,hp);
75   TColgp_Array1OfPnt2d TP2d1(1,hp2d);
76   TColgp_Array1OfVec2d TDP2d1(1,hp2d);
77   TColStd_Array1OfReal TW1(1,hp);
78   TColStd_Array1OfReal TDW1(1,hp);
79   Func.Section(BP1, TP1,TDP1,TP2d1,TDP2d1,TW1,TDW1);
80
81   TColgp_Array1OfPnt TP2(1,hp);
82   TColgp_Array1OfVec TDP2(1,hp);
83   TColgp_Array1OfPnt2d TP2d2(1,hp2d);
84   TColgp_Array1OfVec2d TDP2d2(1,hp2d);
85   TColStd_Array1OfReal TW2(1,hp);
86   TColStd_Array1OfReal TDW2(1,hp);
87   Func.Section(BP2,TP2,TDP2,TP2d2,TDP2d2,TW2,TDW2);
88
89   Standard_Real param1 = BP1.Parameter();
90   Standard_Real param2 = BP2.Parameter();
91   Standard_Real scal = 1./ (param1 - param2);
92
93   cout<<endl;
94   cout<<"control of derivatives at point : "<<param1<<endl;
95
96   for(i = 1; i <= hp; i++){
97     cout<<endl;
98     cout<<"point : "<<i<<endl;
99     cout<<"dx calculated : "<<TDP1(i).X()<<endl;
100     cout<<"dx estimated  : "<<scal*(TP1(i).X()-TP2(i).X())<<endl;
101     cout<<"dy calculated : "<<TDP1(i).Y()<<endl;
102     cout<<"dy estimated  : "<<scal*(TP1(i).Y()-TP2(i).Y())<<endl;
103     cout<<"dz calculated : "<<TDP1(i).Z()<<endl;
104     cout<<"dz estimated  : "<<scal*(TP1(i).Z()-TP2(i).Z())<<endl;
105     cout<<"dw calculated : "<<TDW1(i)<<endl;
106     cout<<"dw estimated  : "<<scal*(TW1(i)-TW2(i))<<endl;
107   }
108   for(i = 1; i <= hp2d; i++){
109     cout<<endl;
110     cout<<"point 2d : "<<i<<endl;
111     cout<<"dx calculated : "<<TDP2d1(i).X()<<endl;
112     cout<<"dx estimated  : "<<scal*(TP2d1(i).X()-TP2d2(i).X())<<endl;
113     cout<<"dy calculated : "<<TDP2d1(i).Y()<<endl;
114     cout<<"dy estimated  : "<<scal*(TP2d1(i).Y()-TP2d2(i).Y())<<endl;
115   }
116 }
117 #endif
118
119 //-----------------------------------------------------
120 static void Drawsect(const Standard_Real param,
121                      Blend_RstRstFunction& Func)
122 {
123   gp_Pnt pntrst1   = Func.PointOnRst1();
124   gp_Pnt pntrst2   = Func.PointOnRst2();
125   gp_Pnt2d p2drst1 = Func.Pnt2dOnRst1();
126   gp_Pnt2d p2drst2 = Func.Pnt2dOnRst2();
127   Standard_Real u  = Func.ParameterOnRst1();
128   Standard_Real v  = Func.ParameterOnRst2();
129   Blend_Point BP(pntrst1, pntrst2, param,
130                  p2drst1.X(), p2drst1.Y(),
131                  p2drst2.X(), p2drst2.Y(), u, v);
132   Standard_Integer hp,hk,hd,hp2d;
133   Func.GetShape(hp,hk,hd,hp2d);
134   TColStd_Array1OfReal TK(1,hk);
135   Func.Knots(TK);
136   TColStd_Array1OfInteger TMul(1,hk);
137   Func.Mults(TMul);
138   TColgp_Array1OfPnt TP(1,hp);
139   TColgp_Array1OfPnt2d TP2d(1,hp2d);
140   TColStd_Array1OfReal TW(1,hp);
141   Func.Section(BP,TP,TP2d,TW);
142   Handle(Geom_BSplineCurve) sect = new Geom_BSplineCurve
143     (TP,TW,TK,TMul,hd);
144   IndexOfSection++;
145 #ifdef DRAW
146   char tname[100];
147   Standard_CString name = tname ;
148   sprintf(name,"%s_%d","Section",IndexOfSection);
149   DrawTrSurf::Set(name,sect);
150 #endif
151 }
152 #endif
153
154 //=======================================================================
155 //function : BRepBlend_RstRstLineBuilder
156 //purpose  : 
157 //=======================================================================
158
159 BRepBlend_RstRstLineBuilder::BRepBlend_RstRstLineBuilder
160 (const Handle(Adaptor3d_HSurface)&  Surf1,
161  const Handle(Adaptor2d_HCurve2d)&  Rst1,
162  const Handle(Adaptor3d_TopolTool)& Domain1,
163  const Handle(Adaptor3d_HSurface)&  Surf2,
164  const Handle(Adaptor2d_HCurve2d)&  Rst2,
165  const Handle(Adaptor3d_TopolTool)& Domain2):
166  sol(1,2), surf1(Surf1), domain1(Domain1),
167  surf2(Surf2), domain2(Domain2), rst1(Rst1), rst2(Rst2)
168 {
169 }
170
171 //=======================================================================
172 //function : Perform
173 //purpose  : launch the processing
174 //=======================================================================
175
176 void BRepBlend_RstRstLineBuilder::Perform(Blend_RstRstFunction&   Func,
177                                           Blend_SurfCurvFuncInv& Finv1,
178                                           Blend_CurvPointFuncInv& FinvP1,
179                                           Blend_SurfCurvFuncInv& Finv2,
180                                           Blend_CurvPointFuncInv& FinvP2,
181                                           const Standard_Real     Pdep,
182                                           const Standard_Real     Pmax,
183                                           const Standard_Real     MaxStep,
184                                           const Standard_Real     TolGuide,
185                                           const math_Vector&      ParDep,
186                                           const Standard_Real     Tolesp,
187                                           const Standard_Real     Fleche,
188                                           const Standard_Boolean  Appro) 
189 {
190   done       = Standard_False;
191   iscomplete = Standard_False;
192   comptra    = Standard_False;
193   line       = new BRepBlend_Line();
194   tolesp     = Abs(Tolesp);
195   tolgui     = Abs(TolGuide);
196   fleche     = Abs(Fleche);
197   rebrou     = Standard_False;
198   pasmax     = Abs(MaxStep);
199   
200   if (Pmax - Pdep >= 0.) {
201     sens = 1.;
202   }
203   else {
204     sens = -1.;
205   }
206   
207   Blend_Status State;
208   
209   param = Pdep;
210   Func.Set(param);
211   
212   if (Appro) {
213     TopAbs_State siturst1, siturst2;
214     Blend_DecrochStatus decroch;
215     math_Vector tolerance(1, 2), infbound(1, 2), supbound(1, 2);
216     Func.GetTolerance(tolerance, tolesp);
217     Func.GetBounds(infbound, supbound);
218     math_FunctionSetRoot rsnld(Func, tolerance, 30);
219     
220     rsnld.Perform(Func, ParDep, infbound, supbound);
221     
222     if (!rsnld.IsDone()) {
223       return;
224     }
225     rsnld.Root(sol);
226     if (!CheckInside(Func, siturst1, siturst2, decroch)) {
227       return;
228     }
229   }
230   else {
231     sol = ParDep;
232   }
233
234   State = TestArret(Func, Standard_False, Blend_OK);
235   if (State != Blend_OK) {
236     return;
237   }
238 #ifdef DEB
239   if (Blend_GettraceDRAWSECT()){
240     Drawsect(param, Func);
241   }
242 #endif
243   // Update the line.
244   line->Append(previousP);
245   Standard_Real U, V;
246   U = previousP.ParameterOnC1();
247   V = previousP.ParameterOnC2();
248   BRepBlend_Extremity ptf1 (previousP.PointOnC1(),
249                             U, previousP.Parameter(),tolesp);
250   BRepBlend_Extremity ptf2 (previousP.PointOnC2(),
251                             V, previousP.Parameter(),tolesp);
252   if (!previousP.IsTangencyPoint()) {
253     ptf1.SetTangent(previousP.TangentOnC1());
254     ptf2.SetTangent(previousP.TangentOnC2());
255   }
256   
257   if (sens > 0.) {
258     line->SetStartPoints(ptf1, ptf2);
259   }
260   else {
261     line->SetEndPoints(ptf1, ptf2);
262   }
263
264   InternalPerform(Func, Finv1, FinvP1, Finv2, FinvP2, Pmax);
265   done = Standard_True;
266 }
267
268 //=======================================================================
269 //function : PerformFirstSection
270 //purpose  : Creation of the first section
271 //=======================================================================
272
273 Standard_Boolean BRepBlend_RstRstLineBuilder::PerformFirstSection
274 (Blend_RstRstFunction&   Func,
275  Blend_SurfCurvFuncInv&  Finv1,
276  Blend_CurvPointFuncInv& FinvP1,
277  Blend_SurfCurvFuncInv&  Finv2,
278  Blend_CurvPointFuncInv& FinvP2,
279  const Standard_Real     Pdep,
280  const Standard_Real     Pmax,
281  const math_Vector&      ParDep,
282  const Standard_Real     Tolesp,
283  const Standard_Real     TolGuide,
284  const Standard_Boolean  RecRst1,
285  const Standard_Boolean  RecP1,
286  const Standard_Boolean  RecRst2,
287  const Standard_Boolean  RecP2,
288  Standard_Real&          Psol,   
289  math_Vector&            ParSol)
290 {
291   done       = Standard_False;
292   iscomplete = Standard_False;
293   comptra    = Standard_False;
294   line       = new BRepBlend_Line();
295   tolesp     = Abs(Tolesp);
296   tolgui     = Abs(TolGuide);
297   rebrou     = Standard_False;
298   
299   if (Pmax - Pdep >= 0.) {
300     sens = 1.;
301   }
302   else {
303     sens = -1.;
304   }
305   
306   Standard_Boolean recadp1, recadp2, recadrst1, recadrst2;
307   Standard_Real wp1, wp2, wrst1, wrst2;
308   Blend_Status State = Blend_OnRst12;
309   Standard_Real trst11 = 0., trst12 = 0., trst21 = 0., trst22 = 0.;
310   math_Vector infbound(1, 2), supbound(1, 2), tolerance(1, 2);
311   math_Vector solinvp1(1, 2), solinvp2(1, 2), solinvrst1(1, 3), solinvrst2(1, 3);
312   Handle(Adaptor3d_HVertex) Vtxp1, Vtxp2, Vtxrst1, Vtxrst2, Vtxc;
313   Standard_Boolean IsVtxp1 = 0, IsVtxp2 = 0, IsVtxrst1 = 0, IsVtxrst2 = 0;
314   Handle(Adaptor2d_HCurve2d) Arc;
315   wp1   = wp2 = wrst1 = wrst2 = Pmax;
316   param = Pdep;
317   Func.Set(param);
318   Func.GetTolerance(tolerance, tolesp);
319   Func.GetBounds(infbound, supbound);
320
321   math_FunctionSetRoot rsnld(Func, tolerance, 30);
322   rsnld.Perform(Func, ParDep, infbound, supbound);
323   if (!rsnld.IsDone()) return Standard_False;
324   rsnld.Root(sol);
325
326   recadrst1 = RecRst1 && Recadre1(Func, Finv1, solinvrst1, IsVtxrst1, Vtxrst1);
327   if (recadrst1) {
328     wrst1 = solinvrst1(1);
329   }
330
331   recadp1 = RecP1 && Recadre1(FinvP1, solinvp1, IsVtxp1, Vtxp1);
332   if (recadp1) {
333     wp1 = solinvp1(1);
334   }
335
336   recadrst2 = RecRst2 && Recadre2(Func, Finv2, solinvrst2, IsVtxrst2, Vtxrst2);
337   if (recadrst2) {
338     wrst2 = solinvrst2(1);
339   }
340
341   recadp2 = RecP2 && Recadre2(FinvP2, solinvp2, IsVtxp2, Vtxp2);
342   if (recadp2) {
343     wp2 = solinvp2(1);
344   }
345
346   if (!recadrst1 && !recadp1 && !recadrst2 && !recadp2) return Standard_False;
347
348
349   // it is checked if the contact was lost or domain 1 was left
350   if (recadp1 && recadrst1) {
351     if (sens * (wrst1 - wp1) > tolgui){ //at first one leaves the domain
352       wrst1     = wp1;
353       trst12    = solinvp1(2);
354       trst11    = BRepBlend_BlendTool::Parameter(Vtxp1, rst1);
355       IsVtxrst2 = IsVtxp1;
356       Vtxrst2   = Vtxp1;
357       recadrst1 = Standard_False;
358     }
359     else { // the contact is lost
360       trst11  = solinvrst1(3);
361       trst12  = solinvrst1(2);
362       recadp1 = Standard_False;
363     }
364   }
365   else if (recadp1) {
366     wrst1     = wp1;
367     trst12    = solinvp1(2);
368     trst11    = BRepBlend_BlendTool::Parameter(Vtxp1, rst1);
369     IsVtxrst1 = IsVtxp1;
370     Vtxrst1   = Vtxp1;
371   }
372   else if (recadrst1) {
373     trst11  = solinvrst1(3);
374     trst12  = solinvrst1(2);
375   }
376
377   // it is checked if the contact was lost or domain 2 was left
378   if (recadp2 && recadrst2) {
379     if (sens * (wrst2 - wp2) > tolgui) { //at first one leaves the domain
380       wrst2     = wp2;
381       trst21    = solinvp2(2);
382       trst22    = BRepBlend_BlendTool::Parameter(Vtxp2, rst2);
383       IsVtxrst2 = IsVtxp2;
384       Vtxrst2   = Vtxp2;
385       recadrst2 = Standard_False;
386     }
387     else { 
388       trst22  = solinvrst2(3);
389       trst21  = solinvrst2(2);
390       recadp2 = Standard_False;
391     }
392   }
393   else if (recadp2) {
394     wrst2     = wp2;
395     trst21    = solinvp2(2);
396     trst22    = BRepBlend_BlendTool::Parameter(Vtxp2, rst2);
397     IsVtxrst2 = IsVtxp2;
398     Vtxrst2   = Vtxp2;
399   }
400   else if (recadrst2) {
401     trst22  = solinvrst2(3);
402     trst21  = solinvrst2(2);
403   }
404
405   // it is checked on which curve the contact is lost earlier
406   if (recadrst1 && recadrst2) {
407     if (Abs(wrst1 - wrst2) < tolgui) {
408       State    = Blend_OnRst12;
409       param    = 0.5 * (wrst1 + wrst2);
410       sol(1)   = trst11;
411       sol(2)   = trst22;
412     }
413     else if (sens * (wrst1 - wrst2) < 0) {
414       // contact lost on Rst1
415       State   = Blend_OnRst1;
416       param   = wrst1;
417       sol(1)  = trst11;
418       sol(2)  = trst12;
419     }
420     else {
421       // contact lost on rst2
422       State   = Blend_OnRst2;
423       param   = wrst2;
424       sol(1)  = trst21;
425       sol(2)  = trst22;
426     }
427   Func.Set(param);
428   }
429   else if (recadrst1) {
430     // ground on rst1
431     State   = Blend_OnRst1;
432     param   = wrst1;
433     sol(1)  = trst11;
434     sol(2)  = trst12;
435     Func.Set(param);
436   }
437   else if (recadrst2) {
438     // ground on rst2
439     State   = Blend_OnRst2;
440     param   = wrst2;
441     sol(1)  = trst21;
442     sol(2)  = trst22;
443     Func.Set(param);
444   }
445   // it is checked on which curves one leaves first
446   else if (recadp1 && recadp2) {
447     if (Abs(wrst1 - wrst2) < tolgui) {
448       State  = Blend_OnRst12;
449       param  = 0.5 * (wrst1 + wrst2);
450       sol(1) = trst11;
451       sol(2) = trst22;
452     }
453     else if (sens * (wrst1 - wrst2) < 0) {
454       // sol on Rst1
455       State  = Blend_OnRst1;
456       param  = wrst1;
457       sol(1) = trst11;
458       sol(2) = trst12;
459     }
460     else {
461       // ground on rst2
462       State  = Blend_OnRst2;
463       param  = wrst2;
464       sol(1) = trst21;
465       sol(2) = trst22;
466     }
467     Func.Set(param);
468   }
469   else if (recadp1) {
470     // ground on rst1
471     State  = Blend_OnRst1;
472     param  = wrst1;
473     sol(1) = trst11;
474     sol(2) = trst12;
475     Func.Set(param);
476   }
477   else if (recadp2) {
478     // ground on rst2
479     State  = Blend_OnRst2;
480     param  = wrst2;
481     sol(1) = trst21;
482     sol(2) = trst22;
483     Func.Set(param);
484   }
485
486   State  = TestArret(Func, Standard_False, State);
487   Psol   = param;
488   ParSol = sol;
489   return Standard_True;
490 }  
491
492 //=======================================================================
493 //function : Complete
494 //purpose  : 
495 //=======================================================================
496
497 Standard_Boolean BRepBlend_RstRstLineBuilder::Complete(Blend_RstRstFunction&   Func,
498                                                        Blend_SurfCurvFuncInv&  Finv1,
499                                                        Blend_CurvPointFuncInv& FinvP1,
500                                                        Blend_SurfCurvFuncInv&  Finv2,
501                                                        Blend_CurvPointFuncInv& FinvP2, 
502                                                        const Standard_Real     Pmin) 
503 {
504   if (!done) {StdFail_NotDone::Raise();}
505   if (iscomplete) {return Standard_True;}
506   if (sens >0.) {
507     previousP = line->Point(1);
508   }
509   else {
510     previousP = line->Point(line->NbPoints());
511   }
512   sens   = -sens;
513   param  = previousP.Parameter();
514   sol(1) = previousP.ParameterOnC1();
515   sol(2) = previousP.ParameterOnC2();
516
517   InternalPerform(Func, Finv1, FinvP1, Finv2, FinvP2, Pmin);
518   iscomplete = Standard_True;
519   return Standard_True;
520 }
521
522 //=======================================================================
523 //function : InternalPerform
524 //purpose  : algorithm of processing without extremities
525 //=======================================================================
526
527 void BRepBlend_RstRstLineBuilder::InternalPerform(Blend_RstRstFunction&   Func,
528                                                   Blend_SurfCurvFuncInv&  Finv1,
529                                                   Blend_CurvPointFuncInv& FinvP1,
530                                                   Blend_SurfCurvFuncInv&  Finv2,
531                                                   Blend_CurvPointFuncInv& FinvP2,
532                                                   const Standard_Real     Bound) 
533 {
534   Standard_Real stepw  = pasmax;
535   Standard_Integer nbp = line->NbPoints();
536   if(nbp >= 2){ //The last step is redone if it is not too small.
537     if(sens < 0.){
538       stepw = (line->Point(2).Parameter() - line->Point(1).Parameter());
539     }
540     else{
541       stepw = (line->Point(nbp).Parameter() - line->Point(nbp - 1).Parameter());
542     }
543     stepw = Max(stepw, 100. * tolgui);
544   }
545   Standard_Real parprec = param;
546   if (sens* (parprec - Bound) >= -tolgui) {
547     return;
548   }
549   Blend_Status State = Blend_OnRst12;
550   Standard_Real trst11 = 0., trst12 = 0., trst21 = 0., trst22 = 0.;
551   TopAbs_State situonc1 = TopAbs_UNKNOWN, situonc2 = TopAbs_UNKNOWN;
552   Blend_DecrochStatus decroch = Blend_NoDecroch;
553   Standard_Boolean Arrive, recadp1, recadp2, recadrst1, recadrst2, echecrecad;
554   Standard_Real wp1, wp2, wrst1, wrst2;
555   math_Vector infbound(1, 2), supbound(1, 2);
556   math_Vector parinit(1, 2), tolerance(1, 2);
557   math_Vector solinvp1(1, 2),  solinvp2(1, 2), solinvrst1(1, 3), solinvrst2(1, 3);
558   Handle(Adaptor3d_HVertex) Vtxp1, Vtxp2, Vtxrst1, Vtxrst2;
559   Standard_Boolean IsVtxp1 = 0, IsVtxp2 = 0, IsVtxrst1 = 0, IsVtxrst2 = 0;
560   BRepBlend_Extremity Extrst1, Extrst2;
561
562   //IntSurf_Transition Tline, Tarc;
563
564   Func.GetTolerance(tolerance, tolesp);
565   Func.GetBounds(infbound, supbound);
566
567   math_FunctionSetRoot rsnld(Func, tolerance, 30);
568   parinit = sol;
569
570   Arrive = Standard_False;
571   param = parprec + sens * stepw;
572   if (sens * (param - Bound) > 0.) {
573     stepw = sens * (Bound - parprec) * 0.5;
574     param = parprec + sens * stepw;
575   }
576
577   while (!Arrive) {
578     Standard_Boolean bonpoint = 1;
579 #ifdef DEB_BBPP_N_TRDERIV
580     //debdebdebdebdebdeb
581     Func.Set(param);
582     rsnld.Perform(Func, parinit, infbound, supbound);
583     if (rsnld.IsDone()) {
584       rsnld.Root(sol);
585       Blend_Point bp1;
586       if(BBPP(param, Func, sol, tolesp, bp1)){
587         Standard_Real dw = 1.e-10;
588         Func.Set(param + dw);
589         rsnld.Perform(Func, parinit, infbound, supbound);
590         if (rsnld.IsDone()) {
591           rsnld.Root(sol);
592           Blend_Point bp2;
593           if(BBPP(param + dw, Func, sol, tolesp, bp2)){
594             tracederiv(Func, bp1, bp2);
595           }
596         }
597       }
598     }
599     //debdebdebdebdebdeb
600 #endif
601     Func.Set(param);
602     rsnld.Perform(Func, parinit, infbound, supbound);
603     
604     if (rsnld.IsDone()) {
605       rsnld.Root(sol);
606       if(!CheckInside(Func, situonc1, situonc2, decroch) && line->NbPoints() == 1){
607         State = Blend_StepTooLarge;
608         bonpoint = 0;
609       }
610     }
611     else {
612       State = Blend_StepTooLarge;
613       bonpoint = 0;
614     }
615     if(bonpoint){
616       wp1     = wp2 = wrst1 = wrst2 = Bound;
617       recadp1 = recadp2 = recadrst1 = recadrst2 = Standard_False;
618       echecrecad = Standard_False;
619       if (situonc1 != TopAbs_IN) {
620         // pb inversion rst/rst
621         recadp1 = Recadre1(FinvP1, solinvp1, IsVtxp1, Vtxp1);
622         if (recadp1) {
623           wp1 = solinvp1(1);
624         }
625         else {
626           echecrecad = Standard_True;
627         }
628       }
629
630       if (situonc2 != TopAbs_IN) {
631         // pb inversion point/surf
632         recadp2 = Recadre2(FinvP2, solinvp2, IsVtxp2, Vtxp2);
633         if (recadp2) {
634           wp2 = solinvp2(1);
635         }
636         else {
637           echecrecad = Standard_True;
638         }
639       }
640
641       if (decroch == Blend_DecrochRst1 || decroch == Blend_DecrochBoth) {
642         // pb inversion rst1/surf1
643         recadrst1 = Recadre1(Func, Finv1, solinvrst1, IsVtxrst1, Vtxrst1);
644         if (recadrst1) {
645           wrst1 = solinvrst1(1);
646         }
647         else {
648           echecrecad = Standard_True;
649         }
650       }
651
652       if (decroch == Blend_DecrochRst2 || decroch == Blend_DecrochBoth) {
653         // pb inverse rst2/surf2
654         recadrst2 = Recadre2(Func, Finv2, solinvrst2, IsVtxrst2, Vtxrst2);
655         if (recadrst2) {
656           wrst2 = solinvrst2(1);
657         }
658         else {
659           echecrecad = Standard_True;
660         }
661       }
662
663       decroch = Blend_NoDecroch;
664       if (recadp1 || recadp2 || recadrst1 || recadrst2) echecrecad = Standard_False;
665  
666       if (!echecrecad) {
667         // it is checked if the contact was lost or domain 1 was left
668         if (recadp1 && recadrst1) {
669           if (sens * (wrst1 - wp1) > tolgui){ //first one leaves the domain
670             wrst1     = wp1;
671             trst12    = solinvp1(2);
672             trst11    = BRepBlend_BlendTool::Parameter(Vtxp1, rst1);
673             IsVtxrst2 = IsVtxp1;
674             Vtxrst2   = Vtxp1;
675             recadrst1 = Standard_False;
676           }
677           else { // contact is lost
678             trst11  = solinvrst1(3);
679             trst12  = solinvrst1(2);
680             recadp1 = Standard_False;
681           }
682         }
683         else if (recadp1) {
684           wrst1     = wp1;
685           trst12    = solinvp1(2);
686           trst11    = BRepBlend_BlendTool::Parameter(Vtxp1, rst1);
687           IsVtxrst1 = IsVtxp1;
688           Vtxrst1   = Vtxp1;
689         }
690         else if (recadrst1) {
691           trst11  = solinvrst1(3);
692           trst12  = solinvrst1(2);
693         }
694
695         // it is checked if the contact was lost or domain 2 was left
696         if (recadp2 && recadrst2) {
697           if (sens * (wrst2 - wp2) > tolgui) { //first one leaves the domain
698             wrst2     = wp2;
699             trst21    = solinvp2(2);
700             trst22    = BRepBlend_BlendTool::Parameter(Vtxp2, rst2);
701             IsVtxrst2 = IsVtxp2;
702             Vtxrst2   = Vtxp2;
703             recadrst2 = Standard_False;
704           }
705           else { 
706             trst22  = solinvrst2(3);
707             trst21  = solinvrst2(2);
708             recadp2 = Standard_False;
709           }
710         }
711         else if (recadp2) {
712           wrst2     = wp2;
713           trst21    = solinvp2(2);
714           trst22    = BRepBlend_BlendTool::Parameter(Vtxp2, rst2);
715           IsVtxrst2 = IsVtxp2;
716           Vtxrst2   = Vtxp2;
717         }
718         else if (recadrst2) {
719           trst22  = solinvrst2(3);
720           trst21  = solinvrst2(2);
721         }
722
723         // it is checked on which curve the contact is lost earlier
724         if (recadrst1 && recadrst2) {
725           if (Abs(wrst1 - wrst2) < tolgui) {
726             State    = Blend_OnRst12;
727             decroch  = Blend_DecrochBoth;
728             param    = 0.5 * (wrst1 + wrst2);
729             sol(1)   = trst11;
730             sol(2)   = trst22;
731           }
732           else if (sens * (wrst1 - wrst2) < 0) {
733             // contact is lost on Rst1
734             State   = Blend_OnRst1;
735             decroch = Blend_DecrochRst1; 
736             param   = wrst1;
737             sol(1)  = trst11;
738             sol(2)  = trst12;
739           }
740           else {
741             // contact is lost on rst2
742             State   = Blend_OnRst2;
743             decroch = Blend_DecrochRst2;
744             param   = wrst2;
745             sol(1)  = trst21;
746             sol(2)  = trst22;
747           }
748           Func.Set(param);
749         }
750         else if (recadrst1) {
751           // ground on rst1
752           State   = Blend_OnRst1;
753           decroch = Blend_DecrochRst1;
754           param   = wrst1;
755           sol(1)  = trst11;
756           sol(2)  = trst12;
757           Func.Set(param);
758         }
759         else if (recadrst2) {
760           // ground on rst2
761           State   = Blend_OnRst2;
762           decroch = Blend_DecrochRst2;
763           param   = wrst2;
764           sol(1)  = trst21;
765           sol(2)  = trst22;
766           Func.Set(param);
767         }
768         //  it is checked on which curve the contact is lost earlier
769         else if (recadp1 && recadp2) {
770           if (Abs(wrst1 - wrst2) < tolgui) {
771             State  = Blend_OnRst12;
772             param  = 0.5 * (wrst1 + wrst2);
773             sol(1) = trst11;
774             sol(2) = trst22;
775           }
776           else if (sens * (wrst1 - wrst2) < 0) {
777             // ground on Rst1
778             State  = Blend_OnRst1;
779             param  = wrst1;
780             sol(1) = trst11;
781             sol(2) = trst12;
782           }
783           else {
784             // ground on rst2
785             State  = Blend_OnRst2;
786             param  = wrst2;
787             sol(1) = trst21;
788             sol(2) = trst22;
789           }
790           Func.Set(param);
791         }
792         else if (recadp1) {
793           // ground on rst1
794           State  = Blend_OnRst1;
795           param  = wrst1;
796           sol(1) = trst11;
797           sol(2) = trst12;
798           Func.Set(param);
799         }
800         else if (recadp2) {
801           // ground on rst2
802           State  = Blend_OnRst2;
803           param  = wrst2;
804           sol(1) = trst21;
805           sol(2) = trst22;
806           Func.Set(param);
807         }
808         else {
809           State = Blend_OK;
810         }
811
812         State = TestArret(Func, Standard_True, State);
813       }
814       else{
815         // reframing failed. Leave with PointsConfondus
816         cout<<"reframing failed"<<endl;
817         State = Blend_SamePoints;
818       }
819     }
820     
821     switch (State) {
822     case Blend_OK :
823       {
824 #ifdef DEB
825         if (Blend_GettraceDRAWSECT()){
826           Drawsect(param, Func);
827         }
828 #endif
829         // Update the line.
830         if (sens > 0.) {
831           line->Append(previousP);
832         }
833         else {
834           line->Prepend(previousP);
835         }
836         parinit = sol;
837         parprec = param;
838         
839         if (param == Bound) {
840           Arrive = Standard_True;
841           Extrst1.SetValue(previousP.PointOnC1(),
842                            previousP.ParameterOnC1(),
843                            previousP.Parameter(), tolesp);
844           MakeExtremity(Extrst2, Standard_False, rst2, sol(2), IsVtxrst2, Vtxrst2);
845           // Show that end is on Bound.
846         }
847         else {
848           param = param + sens * stepw;
849           if (sens * (param - Bound) > - tolgui) {
850             param = Bound;
851           }
852         }
853       }
854       break;
855       
856     case Blend_StepTooLarge :
857       {
858         stepw = stepw / 2.;
859         if (Abs(stepw) < tolgui) {
860           Extrst1.SetValue(previousP.PointOnC1(),
861                            previousP.ParameterOnC1(),
862                            previousP.Parameter(), tolesp);
863           Extrst2.SetValue(previousP.PointOnC2(),
864                            previousP.ParameterOnC2(),
865                            previousP.Parameter(), tolesp);
866           Arrive = Standard_True;
867           if (line->NbPoints()>=2) {
868             // Show that there is a stop during processing 
869             cout<<"No more advancement in the processing"<<endl;
870           }
871         }
872         else {
873           param = parprec + sens * stepw;  // there is no risk to exceed Bound.
874         }
875       }
876       break;
877       
878     case Blend_StepTooSmall :
879       {
880 #ifdef DEB
881         if (Blend_GettraceDRAWSECT()){
882           Drawsect(param,Func);
883         }
884 #endif
885         // Update the line.
886         if (sens > 0.) {
887           line->Append(previousP);
888         }
889         else {
890           line->Prepend(previousP);
891         }
892         parinit = sol;
893         parprec = param;
894         
895         stepw   = Min(1.5 * stepw, pasmax);
896         if (param == Bound) {
897           Arrive = Standard_True;
898           Extrst1.SetValue(previousP.PointOnC1(),
899                            previousP.ParameterOnC1(),
900                            previousP.Parameter(), tolesp);
901           MakeExtremity(Extrst2, Standard_False, rst2, sol(2), IsVtxrst2, Vtxrst2);
902           // Indicate that end is on Bound.
903         }
904         else {
905           param = param + sens * stepw;
906           if (sens * (param - Bound) > - tolgui) {
907             param = Bound;
908           }
909         }
910       }
911       break;
912       
913     case Blend_OnRst1  :
914       {
915 #ifdef DEB
916         if (Blend_GettraceDRAWSECT()){
917           Drawsect(param, Func);
918         }
919 #endif
920         if (sens > 0.) {
921           line->Append(previousP);
922         }
923         else {
924           line->Prepend(previousP);
925         }
926         MakeExtremity(Extrst1, Standard_True, rst1, sol(1), IsVtxrst1, Vtxrst1);
927         MakeExtremity(Extrst2, Standard_False, rst2, sol(2), IsVtxrst2, Vtxrst2);
928         Arrive = Standard_True;
929       }
930       break;
931       
932     case Blend_OnRst2  :
933       {
934 #ifdef DEB
935         if (Blend_GettraceDRAWSECT()){
936           Drawsect(param, Func);
937         }
938 #endif
939         if (sens>0.) {
940           line->Append(previousP);
941         }
942         else {
943           line->Prepend(previousP);
944         }
945
946         MakeExtremity(Extrst1, Standard_True, rst1, sol(1), IsVtxrst1, Vtxrst1);
947         MakeExtremity(Extrst2, Standard_False, rst2, sol(2), IsVtxrst2, Vtxrst2);
948         Arrive = Standard_True;
949       }
950       break;
951       
952     case Blend_OnRst12  :
953       {
954 #ifdef DEB
955         if (Blend_GettraceDRAWSECT()){
956           Drawsect(param, Func);
957         }
958 #endif
959         if (sens > 0.) {
960           line->Append(previousP);
961         }
962         else {
963           line->Prepend(previousP);
964         }
965
966         MakeExtremity(Extrst1, Standard_True, rst1, sol(1), IsVtxrst1, Vtxrst1);
967         MakeExtremity(Extrst2, Standard_False, rst2, sol(2), IsVtxrst2, Vtxrst2);
968         Arrive = Standard_True;
969       }
970       break;
971       
972     case Blend_SamePoints :
973       {
974         // Stop
975         cout << " Mixed points in the processing" << endl;
976         Extrst1.SetValue(previousP.PointOnC1(),
977                          previousP.ParameterOnC1(),
978                          previousP.Parameter(), tolesp);
979         Extrst2.SetValue(previousP.PointOnC2(),
980                          previousP.ParameterOnC2(),
981                          previousP.Parameter(), tolesp);
982         Arrive = Standard_True;
983       }
984       break;
985     default:
986       break;
987     }
988     if (Arrive) {
989       if (sens > 0.) {
990         line->SetEndPoints(Extrst1, Extrst2);
991         decrochfin = decroch;
992       }
993       else {
994         line->SetStartPoints(Extrst1, Extrst2);
995         decrochdeb = decroch;
996       }
997     }
998   }
999 }
1000
1001
1002 //=======================================================================
1003 //function : Recadre1
1004 //purpose  : Contact lost on 1
1005 //=======================================================================
1006
1007 Standard_Boolean BRepBlend_RstRstLineBuilder::Recadre1(Blend_RstRstFunction&    Func,
1008                                                        Blend_SurfCurvFuncInv&   Finv,
1009                                                        math_Vector&             Solinv,
1010                                                        Standard_Boolean&        IsVtx,
1011                                                        Handle(Adaptor3d_HVertex)& Vtx) 
1012 {
1013   math_Vector toler(1, 3), infb(1, 3), supb(1, 3);
1014   Finv.GetTolerance(toler, tolesp);
1015   Finv.GetBounds(infb, supb);
1016   Solinv(1) = param;
1017   Solinv(2) = sol(2);
1018   Solinv(3) = sol(1);
1019  
1020   // The point where contact is not lost is found
1021   math_FunctionSetRoot rsnld(Finv, toler, 30);
1022   rsnld.Perform(Finv, Solinv, infb, supb);
1023   if (!rsnld.IsDone()) {
1024     cout << "RSNLD not done "<< endl << endl;
1025     return Standard_False;
1026   }
1027
1028   rsnld.Root(Solinv);
1029
1030   // It is necessary to check if the function value meets the
1031   // second restriction
1032   if (Finv.IsSolution(Solinv, tolesp)) {
1033     Standard_Real w = Solinv(2);
1034     if(w < rst2->FirstParameter() - toler(2)||
1035        w > rst2->LastParameter() + toler(2)){
1036       return Standard_False;
1037     }
1038  
1039     // it is checked if it is on a Vertex
1040     domain1->Initialize(rst1);
1041     domain1->InitVertexIterator();
1042     IsVtx = !domain1->MoreVertex();
1043     while (!IsVtx) {
1044       Vtx = domain1->Vertex();
1045       if (Abs(BRepBlend_BlendTool::Parameter(Vtx, rst1)-Solinv(3)) <=
1046           BRepBlend_BlendTool::Tolerance(Vtx, rst1)) {
1047         IsVtx = Standard_True;
1048       }
1049       else {
1050         domain1->NextVertex();
1051         IsVtx = !domain1->MoreVertex();
1052       }
1053     }
1054     if (!domain1->MoreVertex()) {
1055       IsVtx = Standard_False;
1056     }
1057     // The section is recalculated by direct solution, otherwise return 
1058     // incoherences between the parameter and the ground caused by yawn.
1059
1060     math_Vector infbound(1, 2), supbound(1, 2);
1061     math_Vector parinit(1, 2), tolerance(1, 2);
1062     Func.GetTolerance(tolerance, tolesp);
1063     Func.GetBounds(infbound, supbound);
1064
1065     math_FunctionSetRoot rsnld2(Func, tolerance, 30);
1066     parinit(1) = Solinv(3);
1067     parinit(2) = Solinv(2);
1068     Func.Set(Solinv(1));
1069     rsnld2.Perform(Func, parinit, infbound, supbound);
1070     if(!rsnld2.IsDone()) return Standard_False;
1071     rsnld2.Root(parinit);
1072     Solinv(2) = parinit(2);
1073     Solinv(3) = parinit(1);
1074     return Standard_True;
1075   }
1076   return Standard_False;
1077 }
1078
1079
1080
1081
1082
1083 //=======================================================================
1084 //function : Recadre2
1085 //purpose  : Contact lost on Rst2
1086 //=======================================================================
1087
1088 Standard_Boolean BRepBlend_RstRstLineBuilder::Recadre2(Blend_RstRstFunction&    Func,
1089                                                        Blend_SurfCurvFuncInv&   Finv,
1090                                                        math_Vector&             Solinv,
1091                                                        Standard_Boolean&        IsVtx,
1092                                                        Handle(Adaptor3d_HVertex)& Vtx) 
1093 {
1094   math_Vector toler(1, 3), infb(1, 3), supb(1, 3);
1095   Finv.GetTolerance(toler, tolesp);
1096   Finv.GetBounds(infb, supb);
1097   Solinv(1) = param;
1098   Solinv(2) = sol(1);
1099   Solinv(3) = sol(2);
1100  
1101   math_FunctionSetRoot rsnld(Finv, toler, 30);
1102   rsnld.Perform(Finv, Solinv, infb, supb);
1103   if (!rsnld.IsDone()) {
1104     cout << "RSNLD not done "<< endl << endl;
1105     return Standard_False;
1106   }
1107
1108   rsnld.Root(Solinv);
1109
1110   // It is necessary to check the value of the function
1111   if (Finv.IsSolution(Solinv, tolesp)) {
1112     Standard_Real w = Solinv(2);
1113     if(w < rst1->FirstParameter() - toler(2)||
1114        w > rst1->LastParameter() + toler(2)){
1115       return Standard_False;
1116     }
1117  
1118     domain2->Initialize(rst2);
1119     domain2->InitVertexIterator();
1120     IsVtx = !domain2->MoreVertex();
1121     while (!IsVtx) {
1122       Vtx = domain2->Vertex();
1123       if (Abs(BRepBlend_BlendTool::Parameter(Vtx, rst2)-Solinv(3)) <=
1124           BRepBlend_BlendTool::Tolerance(Vtx, rst2)) {
1125         IsVtx = Standard_True;
1126       }
1127       else {
1128         domain2->NextVertex();
1129         IsVtx = !domain2->MoreVertex();
1130       }
1131     }
1132     if (!domain2->MoreVertex()) {
1133       IsVtx = Standard_False;
1134     }
1135     // The section is recalculated by direct solution, otherwise return 
1136     // incoherences between the parameter and the ground caused by yawn.
1137    
1138     math_Vector infbound(1, 2), supbound(1, 2);
1139     math_Vector parinit(1,2), tolerance(1,2);
1140     Func.GetTolerance(tolerance, tolesp);
1141     Func.GetBounds(infbound, supbound);
1142
1143     math_FunctionSetRoot rsnld2(Func, tolerance, 30);
1144     parinit(1) = Solinv(2);
1145     parinit(2) = Solinv(3);
1146     Func.Set(Solinv(1));
1147     rsnld2.Perform(Func, parinit, infbound, supbound);
1148     if(!rsnld2.IsDone()) return Standard_False;
1149     rsnld2.Root(parinit);
1150     Solinv(2) = parinit(1);
1151     Solinv(3) = parinit(2);
1152     return Standard_True;
1153   }
1154   return Standard_False;
1155 }
1156
1157 //=======================================================================
1158 //function : Recadre
1159 //purpose  : This is the end of curve rst1
1160 //=======================================================================
1161
1162 Standard_Boolean BRepBlend_RstRstLineBuilder::Recadre1(Blend_CurvPointFuncInv&  FinvP,
1163                                                        math_Vector&             Solinv,
1164                                                        Standard_Boolean&        IsVtx,
1165                                                        Handle(Adaptor3d_HVertex)& Vtx) 
1166 {
1167   // One is located on the last or the first point, following the
1168   // direction of processing.
1169   gp_Pnt2d p2drst1;
1170   Standard_Real firstrst1 = rst1->FirstParameter();
1171   Standard_Real lastrst1  = rst1->LastParameter();
1172   Standard_Real upoint    = firstrst1;
1173
1174   if((sol(1) - firstrst1) > (lastrst1 - sol(1))) upoint = lastrst1;
1175   p2drst1 = rst1->Value(upoint);
1176   gp_Pnt thepoint = surf1->Value(p2drst1.X(), p2drst1.Y());
1177
1178   FinvP.Set(thepoint);
1179   math_Vector toler(1,2), infb(1, 2), supb(1, 2);
1180   FinvP.GetTolerance(toler, tolesp);
1181   FinvP.GetBounds(infb, supb);
1182   Solinv(1) = param;
1183   Solinv(2) = sol(2);
1184
1185   math_FunctionSetRoot rsnld(FinvP, toler, 30);
1186   rsnld.Perform(FinvP, Solinv, infb, supb);
1187   if (!rsnld.IsDone()) {
1188     cout << "RSNLD not done "<< endl << endl;
1189     return Standard_False;
1190   }
1191   rsnld.Root(Solinv);
1192   
1193   if(FinvP.IsSolution(Solinv, tolesp)){
1194     gp_Pnt2d p2drst2  = rst2->Value(Solinv(2));
1195     TopAbs_State situ = domain2->Classify(p2drst2, toler(2), 0);
1196     if ((situ != TopAbs_IN) && (situ != TopAbs_ON)) {
1197       return Standard_False;
1198     }
1199     domain1->Initialize(rst1);
1200     domain1->InitVertexIterator();
1201     IsVtx = !domain1->MoreVertex();
1202     while (!IsVtx) {
1203       Vtx = domain1->Vertex();
1204       if (Abs(BRepBlend_BlendTool::Parameter(Vtx, rst1) - upoint) <=
1205           BRepBlend_BlendTool::Tolerance(Vtx, rst1)) {
1206         IsVtx = Standard_True;
1207       }
1208       else {
1209         domain1->NextVertex();
1210         IsVtx = !domain1->MoreVertex();
1211       }
1212     }
1213     if (!domain1->MoreVertex()) {
1214       IsVtx = Standard_False;
1215     }
1216     return Standard_True;
1217   }
1218   return Standard_False;
1219 }
1220
1221
1222
1223 //=======================================================================
1224 //function : Recadre2
1225 //purpose  : This is the end of curve rst2
1226 //=======================================================================
1227
1228 Standard_Boolean BRepBlend_RstRstLineBuilder::Recadre2(Blend_CurvPointFuncInv&  FinvP,
1229                                                        math_Vector&             Solinv,
1230                                                        Standard_Boolean&        IsVtx,
1231                                                        Handle(Adaptor3d_HVertex)& Vtx) 
1232 {
1233   // One is located on the last or the first point, following the 
1234   // direction of processing.
1235   gp_Pnt2d p2drst2;
1236   Standard_Real firstrst2 = rst2->FirstParameter();
1237   Standard_Real lastrst2  = rst2->LastParameter();
1238   Standard_Real vpoint    = firstrst2;
1239
1240   if((sol(2) - firstrst2) > (lastrst2 - sol(2))) vpoint = lastrst2;
1241   p2drst2 = rst2->Value(vpoint);
1242   gp_Pnt thepoint = surf2->Value(p2drst2.X(), p2drst2.Y());
1243
1244   FinvP.Set(thepoint);
1245   math_Vector toler(1,2), infb(1, 2), supb(1, 2);
1246   FinvP.GetTolerance(toler, tolesp);
1247   FinvP.GetBounds(infb, supb);
1248   Solinv(1) = param;
1249   Solinv(2) = sol(1);
1250
1251   math_FunctionSetRoot rsnld(FinvP, toler, 30);
1252   rsnld.Perform(FinvP, Solinv, infb, supb);
1253   if (!rsnld.IsDone()) {
1254     cout << "RSNLD not done "<< endl << endl;
1255     return Standard_False;
1256   }
1257   rsnld.Root(Solinv);
1258   
1259   if(FinvP.IsSolution(Solinv, tolesp)){
1260     gp_Pnt2d p2drst1  = rst1->Value(Solinv(2));
1261     TopAbs_State situ = domain1->Classify(p2drst1, toler(2), 0);
1262     if ((situ != TopAbs_IN) && (situ != TopAbs_ON)) {
1263       return Standard_False;
1264     }
1265     domain2->Initialize(rst2);
1266     domain2->InitVertexIterator();
1267     IsVtx = !domain2->MoreVertex();
1268     while (!IsVtx) {
1269       Vtx = domain2->Vertex();
1270       if (Abs(BRepBlend_BlendTool::Parameter(Vtx, rst2) - vpoint) <=
1271           BRepBlend_BlendTool::Tolerance(Vtx, rst2)) {
1272         IsVtx = Standard_True;
1273       }
1274       else {
1275         domain2->NextVertex();
1276         IsVtx = !domain2->MoreVertex();
1277       }
1278     }
1279     if (!domain2->MoreVertex()) {
1280       IsVtx = Standard_False;
1281     }
1282     return Standard_True;
1283   }
1284   return Standard_False;
1285 }
1286
1287
1288 //=======================================================================
1289 //function : Transition
1290 //purpose  : 
1291 //=======================================================================
1292
1293 void BRepBlend_RstRstLineBuilder::Transition(const Standard_Boolean          OnFirst,
1294                                              const Handle(Adaptor2d_HCurve2d)& Arc,
1295                                              const Standard_Real             Param,
1296                                              IntSurf_Transition&             TLine,
1297                                              IntSurf_Transition&             TArc) 
1298 {
1299   Standard_Boolean computetranstionaveclacorde = 0;
1300   gp_Vec tgline;
1301   Blend_Point prevprev;
1302
1303   if(previousP.IsTangencyPoint()){
1304     if(line->NbPoints() < 2) return;
1305     computetranstionaveclacorde = 1;
1306     if(sens < 0){
1307       prevprev = line->Point(2);
1308     }
1309     else {
1310       prevprev = line->Point(line->NbPoints() - 1);
1311     }
1312   }
1313   gp_Pnt2d p2d;
1314   gp_Vec2d dp2d;
1315   
1316   gp_Pnt pbid;
1317   gp_Vec d1u, d1v, normale, tgrst;
1318   
1319   Arc->D1(Param, p2d, dp2d);
1320   if (OnFirst) {
1321     surf1->D1(p2d.X(), p2d.Y(), pbid, d1u, d1v);
1322     if(!computetranstionaveclacorde) tgline = previousP.TangentOnC1();
1323     else tgline = gp_Vec(prevprev.PointOnC1(), previousP.PointOnC1());
1324   }
1325   else {
1326     surf2->D1(p2d.X(), p2d.Y(), pbid, d1u, d1v);
1327     if(!computetranstionaveclacorde) tgline = previousP.TangentOnC2();
1328     else tgline = gp_Vec(prevprev.PointOnC2(), previousP.PointOnC2());
1329   }
1330   
1331   tgrst.SetLinearForm(dp2d.X(), d1u, dp2d.Y(), d1v);
1332   normale = d1u.Crossed(d1v);
1333   
1334   IntSurf::MakeTransition(tgline, tgrst, normale, TLine, TArc);
1335 }
1336
1337 //=======================================================================
1338 //function : MakeExtremity
1339 //purpose  : produce the extremity of a curve
1340 //=======================================================================
1341
1342 void BRepBlend_RstRstLineBuilder::MakeExtremity(BRepBlend_Extremity&            Extrem,
1343                                                 const Standard_Boolean          OnFirst,
1344                                                 const Handle(Adaptor2d_HCurve2d)& Arc,
1345                                                 const Standard_Real             Param,
1346                                                 const Standard_Boolean          IsVtx,
1347                                                 const Handle(Adaptor3d_HVertex)&  Vtx) 
1348 {
1349   IntSurf_Transition Tline, Tarc;
1350   Standard_Real prm;
1351   Handle(Adaptor3d_TopolTool) Iter;
1352   if (OnFirst) {
1353     Extrem.SetValue(previousP.PointOnC1(),
1354                     sol(1),
1355                     previousP.Parameter(), tolesp);
1356     if (!previousP.IsTangencyPoint()) 
1357       Extrem.SetTangent(previousP.TangentOnC1());
1358     Iter = domain1;
1359   }
1360   else {
1361     Extrem.SetValue(previousP.PointOnC2(),
1362                     sol(2),
1363                     previousP.Parameter(), tolesp);
1364     if (!previousP.IsTangencyPoint()) 
1365       Extrem.SetTangent(previousP.TangentOnC1());
1366     Iter = domain2;
1367   }
1368   
1369   Iter->Init();
1370   if (!IsVtx) {
1371     Transition(OnFirst, Arc, Param, Tline, Tarc);
1372     Extrem.AddArc(Arc, Param, Tline, Tarc);
1373   }
1374   else {
1375     Extrem.SetVertex(Vtx);
1376     while (Iter->More()) {
1377       Handle(Adaptor2d_HCurve2d) arc = Iter->Value();
1378      if (arc != Arc) {
1379         Iter->Initialize(arc);
1380         Iter->InitVertexIterator();
1381         while (Iter->MoreVertex()) {
1382           if (Iter->Identical(Vtx, Iter->Vertex())) {
1383             prm = BRepBlend_BlendTool::Parameter(Vtx, arc);
1384             Transition(OnFirst, arc, prm, Tline, Tarc);
1385             Extrem.AddArc(arc, prm, Tline, Tarc);
1386           }
1387           Iter->NextVertex();
1388         }
1389       }
1390       else {
1391         Transition(OnFirst, arc, Param, Tline, Tarc);
1392         Extrem.AddArc(arc, Param, Tline, Tarc);
1393       }
1394       Iter->Next();
1395     }
1396   }
1397 }
1398
1399 //=======================================================================
1400 //function : CheckDeflectionOnRst1
1401 //purpose  : 
1402 //=======================================================================
1403
1404 Blend_Status BRepBlend_RstRstLineBuilder::CheckDeflectionOnRst1(const Blend_Point& CurPoint)
1405 {
1406   //Controls 3d of Blend_CSWalking.
1407
1408   // rule by tests in U4 corresponds to 11.478 
1409   const Standard_Real CosRef3D = 0.98;
1410   Standard_Real Cosi, Cosi2;
1411   Standard_Boolean curpointistangent  = CurPoint.IsTangencyPoint();
1412   Standard_Boolean prevpointistangent = previousP.IsTangencyPoint();
1413
1414   gp_Pnt Psurf = CurPoint.PointOnC1();
1415   gp_Vec Tgsurf;
1416   if(!curpointistangent){
1417     Tgsurf = CurPoint.TangentOnC1();
1418   }
1419   gp_Pnt prevP = previousP.PointOnC1();
1420   gp_Vec prevTg;
1421   if(!prevpointistangent){
1422     prevTg = previousP.TangentOnC1();
1423   }
1424   Standard_Real Norme;
1425   Standard_Real prevNorme = 0.;
1426   gp_Vec Corde(prevP, Psurf);
1427   Norme = Corde.SquareMagnitude();
1428   if (!prevpointistangent) prevNorme = prevTg.SquareMagnitude();
1429
1430   if (Norme <= tolesp * tolesp) {
1431     // it can be necessary to force the same point
1432     return Blend_SamePoints;
1433   }
1434   if(!prevpointistangent){
1435     if (prevNorme <= tolesp * tolesp) {
1436       return Blend_SamePoints;
1437     }
1438     Cosi = sens * Corde * prevTg;
1439     if (Cosi < 0.) { // angle 3d>pi/2. --> return back
1440       return Blend_Backward;
1441     }
1442     
1443     Cosi2 = Cosi * Cosi / prevNorme / Norme;
1444     if (Cosi2 < CosRef3D) { 
1445       return Blend_StepTooLarge;
1446     }
1447   }
1448   
1449   if(!curpointistangent){
1450     // Check if it is necessary to control the sign of prevtg*Tgsurf
1451     Cosi = sens * Corde * Tgsurf;
1452     Cosi2 = Cosi * Cosi / Tgsurf.SquareMagnitude() / Norme;
1453     if (Cosi2 < CosRef3D || Cosi < 0.) { 
1454       return Blend_StepTooLarge;
1455     }
1456   }  
1457
1458   if (!curpointistangent && !prevpointistangent) {
1459     // Estimation of the current arrow
1460     Standard_Real FlecheCourante = 
1461       (prevTg.Normalized().XYZ() - Tgsurf.Normalized().XYZ()).SquareModulus() * Norme / 64.;
1462     
1463     if (FlecheCourante <= 0.25 * fleche * fleche) {
1464       return Blend_StepTooSmall;
1465     }
1466     if (FlecheCourante > fleche * fleche) {
1467       // not too great
1468       return Blend_StepTooLarge;
1469     }
1470   }
1471   return Blend_OK;
1472 }
1473
1474
1475 //=======================================================================
1476 //function : CheckDeflectionOnRst2
1477 //purpose  : 
1478 //=======================================================================
1479
1480 Blend_Status BRepBlend_RstRstLineBuilder::CheckDeflectionOnRst2(const Blend_Point& CurPoint)
1481 {
1482   //3D Controls of Blend_CSWalking.
1483
1484   // rule by tests in U4 corresponding to 11.478 d
1485   const Standard_Real CosRef3D = 0.98;
1486   Standard_Real Cosi, Cosi2;
1487   Standard_Boolean curpointistangent  = CurPoint.IsTangencyPoint();
1488   Standard_Boolean prevpointistangent = previousP.IsTangencyPoint();
1489
1490   gp_Pnt Psurf = CurPoint.PointOnC2();
1491   gp_Vec Tgsurf;
1492
1493   if (!curpointistangent) {
1494     Tgsurf = CurPoint.TangentOnC2();
1495   }
1496   gp_Pnt prevP = previousP.PointOnC2();
1497   gp_Vec prevTg;
1498   if (!prevpointistangent) {
1499     prevTg = previousP.TangentOnC2();
1500   }
1501   Standard_Real Norme;
1502   Standard_Real prevNorme = 0.;
1503   gp_Vec Corde(prevP, Psurf);
1504   Norme = Corde.SquareMagnitude();
1505   if (!prevpointistangent) prevNorme = prevTg.SquareMagnitude();
1506
1507   if (Norme <= tolesp * tolesp){
1508     // it can be necessary to force the same point
1509     return Blend_SamePoints;
1510   }
1511   if (!prevpointistangent) {
1512     if (prevNorme <= tolesp * tolesp) {
1513       return Blend_SamePoints;
1514     }
1515     Cosi = sens * Corde * prevTg;
1516     if (Cosi < 0.) { // angle 3d>pi/2. --> return back
1517       return Blend_Backward;
1518     }
1519     
1520     Cosi2 = Cosi * Cosi / prevNorme / Norme;
1521     if (Cosi2 < CosRef3D) { 
1522       return Blend_StepTooLarge;
1523     }
1524   }
1525   
1526   if (!curpointistangent) {
1527     // Check if it is necessary to control the sign of prevtg*Tgsurf
1528     Cosi  = sens * Corde * Tgsurf;
1529     Cosi2 = Cosi * Cosi / Tgsurf.SquareMagnitude() / Norme;
1530     if (Cosi2 < CosRef3D || Cosi < 0.) { 
1531       return Blend_StepTooLarge;
1532     }
1533   }  
1534
1535   if(!curpointistangent && !prevpointistangent){
1536     // Estimation of the current arrow
1537     Standard_Real FlecheCourante = 
1538       (prevTg.Normalized().XYZ() - Tgsurf.Normalized().XYZ()).SquareModulus() * Norme/64.;
1539     
1540     if (FlecheCourante <= 0.25 * fleche * fleche) {
1541       return Blend_StepTooSmall;
1542     }
1543     if (FlecheCourante > fleche * fleche) {
1544       // not too great
1545       return Blend_StepTooLarge;
1546     }
1547   }
1548   return Blend_OK;
1549 }
1550
1551 static IntSurf_TypeTrans ConvOrToTra(const TopAbs_Orientation O)
1552 {
1553   if(O == TopAbs_FORWARD) return IntSurf_In;
1554   return IntSurf_Out;
1555 }
1556
1557 //=======================================================================
1558 //function : TestArret
1559 //purpose  : 
1560 //=======================================================================
1561
1562 Blend_Status BRepBlend_RstRstLineBuilder::TestArret(Blend_RstRstFunction& Func,
1563                                                     const Standard_Boolean TestDeflection,
1564                                                     const Blend_Status     State) 
1565 {
1566   gp_Pnt ptrst1, ptrst2;
1567   gp_Pnt2d pt2drst1, pt2drst2;
1568   gp_Vec tgrst1, tgrst2;
1569   gp_Vec2d tg2drst1, tg2drst2;
1570   Blend_Status StateRst1, StateRst2;
1571   IntSurf_TypeTrans trarst1 = IntSurf_Undecided, trarst2 = IntSurf_Undecided;
1572   Blend_Point curpoint;
1573
1574   if (Func.IsSolution(sol, tolesp)) {
1575     Standard_Boolean curpointistangent = Func.IsTangencyPoint();
1576     ptrst1   = Func.PointOnRst1();
1577     ptrst2   = Func.PointOnRst2();
1578     pt2drst1 = Func.Pnt2dOnRst1();
1579     pt2drst2 = Func.Pnt2dOnRst2();
1580
1581     if(curpointistangent){
1582       curpoint.SetValue(ptrst1, ptrst2, param, pt2drst1.X(), pt2drst1.Y(), 
1583                         pt2drst2.X(), pt2drst2.Y(), sol(1), sol(2));
1584     }
1585     else{
1586       tgrst1   = Func.TangentOnRst1();
1587       tgrst2   = Func.TangentOnRst2();
1588       tg2drst1 = Func.Tangent2dOnRst1();
1589       tg2drst2 = Func.Tangent2dOnRst2();
1590       curpoint.SetValue(ptrst1, ptrst2, param, pt2drst1.X(), pt2drst1.Y(), 
1591                         pt2drst2.X(), pt2drst2.Y(), sol(1), sol(2),
1592                         tgrst1, tgrst2, tg2drst1, tg2drst2);
1593     }
1594     if (TestDeflection) {
1595       StateRst1 = CheckDeflectionOnRst1(curpoint);
1596       StateRst2 = CheckDeflectionOnRst2(curpoint);
1597     }
1598     else {
1599       StateRst1 = StateRst2 = Blend_OK;
1600     }
1601     if (StateRst1 == Blend_Backward) {
1602       StateRst1 = Blend_StepTooLarge;
1603       rebrou    = Standard_True;
1604     }
1605     if (StateRst2 == Blend_Backward) {
1606       StateRst2 = Blend_StepTooLarge;
1607       rebrou    = Standard_True;
1608     }
1609     if (StateRst1 == Blend_StepTooLarge ||
1610         StateRst2 == Blend_StepTooLarge) {
1611       return Blend_StepTooLarge;
1612     }
1613
1614     if (!comptra && !curpointistangent) {
1615       gp_Pnt2d p2drstref;
1616       gp_Vec2d tg2drstref;
1617       rst1->D1(sol(1), p2drstref, tg2drstref);
1618       Standard_Real testra = tg2drst1.Dot(tg2drstref);
1619       TopAbs_Orientation Or = domain1->Orientation(rst1);
1620
1621       if (Abs(testra) > tolesp) {
1622         if (testra < 0.) {
1623           trarst1 = ConvOrToTra(TopAbs::Reverse(Or));
1624         }
1625         else if (testra >0.) {
1626           trarst1 = ConvOrToTra(Or);
1627         }
1628
1629         rst2->D1(sol(2), p2drstref, tg2drstref);
1630         testra = tg2drst2.Dot(tg2drstref);
1631
1632         Or = domain2->Orientation(rst2);
1633         if (Abs(testra) > tolesp) {
1634           if (testra < 0.) {
1635             trarst2 = ConvOrToTra(TopAbs::Reverse(Or));
1636           }
1637           else if (testra >0.) {
1638             trarst2 = ConvOrToTra(Or);
1639           }
1640           comptra = Standard_True;
1641           line->Set(trarst1, trarst2);
1642         }
1643       }
1644     }
1645     if (StateRst1 == Blend_OK ||
1646         StateRst2 == Blend_OK ) {
1647       previousP = curpoint;
1648       return State;
1649     }
1650     if (StateRst1 == Blend_StepTooSmall &&
1651         StateRst2 == Blend_StepTooSmall) {
1652       previousP = curpoint;
1653       if (State == Blend_OK) {
1654         return Blend_StepTooSmall;
1655       }
1656       else {
1657         return State;
1658       }
1659     }
1660     if (State == Blend_OK) {
1661       return Blend_SamePoints;
1662     }
1663     else {
1664       return State;
1665     }
1666   }
1667   return Blend_StepTooLarge;
1668 }
1669
1670 //=======================================================================
1671 //function : CheckInside
1672 //purpose  : 
1673 //=======================================================================
1674
1675 Standard_Boolean BRepBlend_RstRstLineBuilder::CheckInside(Blend_RstRstFunction&  Func,
1676                                                           TopAbs_State&          SituOnC1,
1677                                                           TopAbs_State&          SituOnC2,
1678                                                           Blend_DecrochStatus &  Decroch)
1679 {
1680 //  Standard_Boolean inside = Standard_True;
1681   math_Vector tolerance(1, 2);
1682   Func.GetTolerance(tolerance, tolesp);
1683
1684   //face pcurve 1.
1685   Standard_Real v = sol(1);
1686   if(v < rst1->FirstParameter() - tolerance(2)||
1687      v > rst1->LastParameter() + tolerance(2)){
1688     SituOnC1 = TopAbs_OUT;
1689   }
1690   else if (v > rst1->FirstParameter() &&
1691            v < rst1->LastParameter()){
1692     SituOnC1 = TopAbs_IN;
1693   }
1694   else SituOnC1 = TopAbs_ON;
1695
1696   //face pcurve 2.
1697   v = sol(2);
1698   if(v < rst2->FirstParameter() - tolerance(2)||
1699      v > rst2->LastParameter() + tolerance(2)){
1700     SituOnC2 = TopAbs_OUT;
1701   }
1702   else if (v > rst2->FirstParameter() &&
1703            v < rst2->LastParameter()){
1704     SituOnC2 = TopAbs_IN;
1705   }
1706   else SituOnC2 = TopAbs_ON;
1707
1708
1709   //lost contact
1710   gp_Vec tgrst1, norst1, tgrst2, norst2;
1711   Decroch = Func.Decroch(sol,tgrst1, norst1, tgrst2, norst2);
1712
1713   return (SituOnC1 == TopAbs_IN && SituOnC2 == TopAbs_IN && Decroch == Blend_NoDecroch);
1714 }
1715
1716
1717