0031007: Coding - eliminate warnings issued while compiling with -pedantic flag
[occt.git] / src / Bisector / Bisector_Bisec.cxx
1 // Created on: 1994-07-04
2 // Created by: Yves FRICAUD
3 // Copyright (c) 1994-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 <Bisector.hxx>
19 #include <Bisector_Bisec.hxx>
20 #include <Bisector_BisecAna.hxx>
21 #include <Bisector_BisecCC.hxx>
22 #include <Bisector_BisecPC.hxx>
23 #include <Bisector_Curve.hxx>
24 #include <GCE2d_MakeSegment.hxx>
25 #include <Geom2d_BSplineCurve.hxx>
26 #include <Geom2d_CartesianPoint.hxx>
27 #include <Geom2d_Circle.hxx>
28 #include <Geom2d_Curve.hxx>
29 #include <Geom2d_Line.hxx>
30 #include <Geom2d_Point.hxx>
31 #include <Geom2d_TrimmedCurve.hxx>
32 #include <gp.hxx>
33 #include <gp_Pnt2d.hxx>
34 #include <gp_Vec2d.hxx>
35 #include <Precision.hxx>
36 #include <Standard_NotImplemented.hxx>
37 #include <StdFail_NotDone.hxx>
38
39 #ifdef OCCT_DEBUG
40 //#define DRAW
41 #ifdef DRAW
42 #include <DrawTrSurf.hxx>
43 #pragma comment(lib, "TKDraw.lib")
44 static char name[100];
45 static Standard_Integer nbb  = 0;
46 static Standard_Boolean Affich = Standard_False;
47 #endif
48 #endif
49
50
51 static Standard_Boolean IsMaxRC (const Handle(Geom2d_Curve)& C,
52   Standard_Real         U,
53   Standard_Real&        R);
54
55 static void ReplaceByLineIfIsToSmall (Handle(Bisector_Curve)& Bis,
56   Standard_Real&        UFirst,
57   Standard_Real&        ULast);                                 
58 //=============================================================================
59 //function : Empty Constructor                                                
60 //=============================================================================
61 Bisector_Bisec::Bisector_Bisec()
62 {
63 }
64
65 //===========================================================================
66 //    calculate the bissectrice between two curves coming from a point.         
67 //                                                                          
68 //   afirstcurve   : \ curves between which the          
69 //   asecondcurve  : / bissectrice is calculated.                                         
70 //   apoint        :   point through which the bissectrice should pass.         
71 //   afirstvector  : \ vectors to determine the sector where       
72 //   asecondvector : / the bissectrice should be located.                      
73 //   adirection    :   shows the the side of the bissectrice to be preserved.       
74 //   tolerance     :   threshold starting from which the bisectrices are degenerated
75 //===========================================================================
76
77 void Bisector_Bisec::Perform(const Handle(Geom2d_Curve)& afirstcurve   ,
78                              const Handle(Geom2d_Curve)& asecondcurve  ,
79                              const gp_Pnt2d&             apoint        ,
80                              const gp_Vec2d&             afirstvector  ,
81                              const gp_Vec2d&             asecondvector ,
82                              const Standard_Real         adirection    ,
83                              const GeomAbs_JoinType      ajointype     ,
84                              const Standard_Real         tolerance     ,
85                              const Standard_Boolean      oncurve       )
86 {
87   Handle(Standard_Type)  Type1 = afirstcurve ->DynamicType();
88   Handle(Standard_Type)  Type2 = asecondcurve->DynamicType();
89   Handle(Bisector_Curve) Bis;
90   Standard_Real          UFirst,ULast;
91
92   if (Type1 == STANDARD_TYPE(Geom2d_TrimmedCurve)) {
93     Type1 = Handle(Geom2d_TrimmedCurve)::DownCast(afirstcurve)
94       ->BasisCurve()->DynamicType();
95   }
96   if (Type2 == STANDARD_TYPE(Geom2d_TrimmedCurve)) {
97     Type2 = Handle(Geom2d_TrimmedCurve)::DownCast(asecondcurve)
98       ->BasisCurve()->DynamicType();
99   }
100
101   Handle(Geom2d_Curve) afirstcurve1 = afirstcurve;
102   Handle(Geom2d_Curve) asecondcurve1 = asecondcurve;
103
104   if(Type1 == STANDARD_TYPE(Geom2d_BSplineCurve))
105   {
106     Handle(Geom2d_BSplineCurve) aBS;
107     if(afirstcurve->DynamicType() == STANDARD_TYPE(Geom2d_TrimmedCurve))
108     {
109       aBS = Handle(Geom2d_BSplineCurve)::DownCast(Handle(Geom2d_TrimmedCurve)::DownCast(afirstcurve)
110                                                                                ->BasisCurve());
111     }
112     else
113     {
114       aBS = Handle(Geom2d_BSplineCurve)::DownCast(afirstcurve);
115     }
116     if(aBS->Degree() == 1 && aBS->NbPoles() == 2)
117     {
118       if(aBS->Pole(1).Distance(aBS->Pole(2)) < 1.e-4)
119       {
120         afirstcurve1 = GCE2d_MakeSegment(aBS->Pole(1), aBS->Pole(2)).Value();
121         Type1 = STANDARD_TYPE(Geom2d_Line);
122       }
123     }
124   }
125
126
127   if(Type2 == STANDARD_TYPE(Geom2d_BSplineCurve))
128   {
129     Handle(Geom2d_BSplineCurve) aBS;
130     if(asecondcurve->DynamicType() == STANDARD_TYPE(Geom2d_TrimmedCurve))
131     {
132       aBS = Handle(Geom2d_BSplineCurve)::DownCast(Handle(Geom2d_TrimmedCurve)::DownCast(asecondcurve)
133                                                                                ->BasisCurve());
134     }
135     else
136     {
137       aBS = Handle(Geom2d_BSplineCurve)::DownCast(asecondcurve);
138     }
139     if(aBS->Degree() == 1 && aBS->NbPoles() == 2)
140     {
141       if(aBS->Pole(1).Distance(aBS->Pole(2)) < 1.e-4)
142       {
143         asecondcurve1 = GCE2d_MakeSegment(aBS->Pole(1), aBS->Pole(2)).Value();
144         Type2 = STANDARD_TYPE(Geom2d_Line);
145       }
146     }
147   }
148
149   if ( (Type1 == STANDARD_TYPE(Geom2d_Circle) || Type1 == STANDARD_TYPE(Geom2d_Line)) &&
150     (Type2 == STANDARD_TYPE(Geom2d_Circle) || Type2 == STANDARD_TYPE(Geom2d_Line))   )
151   {    
152     //------------------------------------------------------------------
153     // Analytic Bissectrice.
154     //------------------------------------------------------------------
155      Handle(Bisector_BisecAna) BisAna = new Bisector_BisecAna();
156      BisAna->Perform(afirstcurve1  ,
157                      asecondcurve1 ,
158                      apoint        ,
159                      afirstvector  ,
160                      asecondvector ,
161                      adirection    ,
162                      ajointype     ,
163                      tolerance     ,
164                      oncurve       );
165      UFirst = BisAna->ParameterOfStartPoint();
166      ULast  = BisAna->ParameterOfEndPoint();    
167      Bis = BisAna;   
168   }
169   else {  
170     Standard_Boolean IsLine = Standard_False;
171
172     if (oncurve) {
173       gp_Dir2d Fd(afirstvector);
174       gp_Dir2d Sd(asecondvector);
175       //if (Fd.Dot(Sd) < Precision::Angular() - 1.) { 
176       //if (Fd.Dot(Sd) < 10*Precision::Angular() - 1.) //patch
177       if (Fd.Dot(Sd) < Sqrt(2.*Precision::Angular()) - 1.)
178         IsLine = Standard_True;
179     }
180     if (IsLine) {     
181       //------------------------------------------------------------------
182       // Half-Staight.
183       //------------------------------------------------------------------
184       gp_Dir2d N ( - adirection*afirstvector.Y(), adirection*afirstvector.X());
185       Handle (Geom2d_CartesianPoint) PG     = new Geom2d_CartesianPoint(apoint);
186       Handle (Geom2d_Line)           L      = new Geom2d_Line (apoint,N);
187       Handle (Geom2d_TrimmedCurve)   
188         BisL   = new Geom2d_TrimmedCurve (L,0,Precision::Infinite());
189       Handle(Bisector_BisecAna)      BisAna = new Bisector_BisecAna ();
190       BisAna->Init(BisL);
191       UFirst = BisAna->ParameterOfStartPoint();
192       ULast  = BisAna->ParameterOfEndPoint();
193       Bis    = BisAna;
194     }
195     else {
196       //-------------------------------------------------------------------
197       // Bissectrice algo
198       //-------------------------------------------------------------------
199       Handle(Bisector_BisecCC) BisCC = new Bisector_BisecCC();
200       BisCC -> Perform(asecondcurve1, 
201         afirstcurve1 ,
202         adirection  , 
203         adirection  , 
204         apoint);
205
206       if (BisCC -> IsEmpty()) {
207         // bissectrice is empty. a point is projected at the end of the guide curve. 
208         // Construction of a false bissectrice.
209         //  modified by NIZHNY-EAP Mon Feb 21 12:00:13 2000 ___BEGIN___
210         gp_Pnt2d aP1 = afirstcurve1->Value(afirstcurve1->LastParameter());
211         gp_Pnt2d aP2 = asecondcurve1->Value(asecondcurve1->FirstParameter());
212         gp_Pnt2d aPm(.5*(aP1.XY()+aP2.XY()));
213         Standard_Real Nx, Ny;
214         if(aPm.Distance(apoint) > 10.*Precision::Confusion())
215         {
216           Nx = apoint.X() - aPm.X();
217           Ny = apoint.Y() - aPm.Y();
218           if(adirection < 0)
219           {
220             Nx = -Nx;
221             Ny = -Ny;
222           }
223         }
224         else
225         {
226           gp_Dir2d dir1(afirstvector), dir2(asecondvector);
227           Nx = - dir1.X() - dir2.X(),
228           Ny = - dir1.Y() - dir2.Y();
229           if (Abs(Nx) <= gp::Resolution() && Abs(Ny) <= gp::Resolution()) {
230             Nx = -afirstvector.Y();
231             Ny = afirstvector.X();
232           }
233         }
234         gp_Dir2d N ( adirection*Nx, adirection*Ny);
235         //  modified by NIZHNY-EAP Mon Feb 21 12:00:19 2000 ___END___
236
237         Handle (Geom2d_CartesianPoint) PG     = new Geom2d_CartesianPoint(apoint);
238         Handle (Geom2d_Line)           L      = new Geom2d_Line (apoint,N);
239         Handle (Geom2d_TrimmedCurve)   
240           BisL   = new Geom2d_TrimmedCurve (L,0,Precision::Infinite());
241         Handle(Bisector_BisecAna)      BisAna = new Bisector_BisecAna ();
242         BisAna->Init(BisL);
243         UFirst = BisAna->ParameterOfStartPoint();
244         ULast  = BisAna->ParameterOfEndPoint();
245         Bis    = BisAna;
246       }
247       else {
248         UFirst = BisCC->FirstParameter();
249         ULast  = BisCC->LastParameter ();
250         Bis    = BisCC;
251         ReplaceByLineIfIsToSmall(Bis,UFirst,ULast);
252       }
253     }
254   }
255   UFirst = Max(UFirst, Bis->FirstParameter());
256   ULast = Min(ULast, Bis->LastParameter());
257   thebisector = new Geom2d_TrimmedCurve(Bis,UFirst,ULast);
258 #ifdef DRAW  
259   if(Affich) 
260   {
261     sprintf( name, "c1_%d", ++nbb );
262     DrawTrSurf::Set( name, afirstcurve );
263     sprintf( name, "c2_%d", nbb );
264     DrawTrSurf::Set( name, asecondcurve );
265     sprintf( name, "p%d", nbb );
266     DrawTrSurf::Set( name, apoint );
267     sprintf( name, "b%d", nbb );
268     DrawTrSurf::Set( name, thebisector );
269   }
270 #endif
271   
272 }
273
274 //===========================================================================
275 //  calculate the bissectrice between a curve and a point starting in a point. 
276 //                                                                          
277 //   afirstcurve   : \ curve and point the bissectrice between which is calculated.
278 //   asecondpoint  : /                                          
279 //   apoint        :   point through which the bissectrice should pass.         
280 //   afirstvector  : \ vectors to find the sector where       
281 //   asecondvector : / the bissectrice should be located.                      
282 //   adirection    :   shows the side of the bissectrice to be preserved.       
283 //   tolerance     :   threshold starting from which the bisectrices are degenerated
284 //===========================================================================
285
286 void Bisector_Bisec::Perform(const Handle(Geom2d_Curve)& afirstcurve  ,
287   const Handle(Geom2d_Point)& asecondpoint ,
288   const gp_Pnt2d&             apoint       ,
289   const gp_Vec2d&             afirstvector ,
290   const gp_Vec2d&             asecondvector,
291   const Standard_Real         adirection   ,
292   const Standard_Real         tolerance    ,
293   const Standard_Boolean      oncurve       )
294 {  
295   //gp_Pnt2d SecondPnt = asecondpoint->Pnt2d();
296
297   Handle(Bisector_Curve) Bis;
298   Handle(Standard_Type)  Type1 = afirstcurve ->DynamicType();
299   Standard_Real          UFirst,ULast;
300
301   if (Type1 == STANDARD_TYPE(Geom2d_TrimmedCurve)) {
302     Type1 = Handle(Geom2d_TrimmedCurve)::DownCast(afirstcurve)
303       ->BasisCurve()->DynamicType();
304   }
305
306   if ( Type1 == STANDARD_TYPE(Geom2d_Circle) || Type1 == STANDARD_TYPE(Geom2d_Line)) {
307     //------------------------------------------------------------------
308     // Analytic Bissectrice.
309     //------------------------------------------------------------------
310     Handle(Bisector_BisecAna) BisAna = new Bisector_BisecAna();
311     BisAna -> Perform (afirstcurve   ,
312       asecondpoint  ,
313       apoint        ,
314       afirstvector  ,
315       asecondvector ,
316       adirection    ,
317       tolerance     ,
318       oncurve       );
319     UFirst = BisAna->ParameterOfStartPoint();
320     ULast  = BisAna->ParameterOfEndPoint();
321     Bis    = BisAna;
322   }
323   else {  
324     Standard_Boolean IsLine    = Standard_False;
325     Standard_Real    RC        = Precision::Infinite();
326
327     if (oncurve) {
328       if (Bisector::IsConvex(afirstcurve,adirection) || 
329         IsMaxRC(afirstcurve,afirstcurve->LastParameter(),RC)) { 
330           IsLine = Standard_True; 
331       }
332     }
333     if (IsLine) {     
334       //------------------------------------------------------------------
335       // Half-Right.
336       //------------------------------------------------------------------
337       gp_Dir2d N ( -adirection*afirstvector.Y(), adirection*afirstvector.X());
338       Handle (Geom2d_Line)         L      = new Geom2d_Line (apoint,N);
339       Handle (Geom2d_TrimmedCurve) BisL   = new Geom2d_TrimmedCurve(L,0,RC);
340       Handle(Bisector_BisecAna)    BisAna = new Bisector_BisecAna ();
341       BisAna->Init(BisL);
342       UFirst = BisAna->ParameterOfStartPoint();
343       ULast  = BisAna->ParameterOfEndPoint();
344       Bis    = BisAna;
345     }
346     else {
347       //-------------------------------------------------------------------
348       // Bissectrice algo
349       //-------------------------------------------------------------------
350       Handle(Bisector_BisecPC) BisPC = new Bisector_BisecPC();
351       Handle(Geom2d_Curve) afirstcurvereverse = afirstcurve->Reversed();
352
353       BisPC -> Perform(afirstcurvereverse   ,
354         asecondpoint->Pnt2d(),
355         - adirection         );
356       //  Modified by Sergey KHROMOV - Thu Feb 21 16:49:54 2002 Begin
357       if (BisPC -> IsEmpty()) {
358         gp_Dir2d dir1(afirstvector), dir2(asecondvector);
359         Standard_Real
360           Nx = - dir1.X() - dir2.X(),
361           Ny = - dir1.Y() - dir2.Y();
362         if (Abs(Nx) <= gp::Resolution() && Abs(Ny) <= gp::Resolution()) {
363           Nx = - afirstvector.Y();
364           Ny = afirstvector.X();
365         }
366         //      gp_Dir2d N ( -adirection*afirstvector.Y(), adirection*afirstvector.X());
367         gp_Dir2d N ( adirection*Nx, adirection*Ny);
368         Handle (Geom2d_Line)         L      = new Geom2d_Line (apoint,N);
369         Handle (Geom2d_TrimmedCurve) BisL   = new Geom2d_TrimmedCurve(L,0,RC);
370         Handle(Bisector_BisecAna)    BisAna = new Bisector_BisecAna ();
371         BisAna->Init(BisL);
372         UFirst = BisAna->ParameterOfStartPoint();
373         ULast  = BisAna->ParameterOfEndPoint();
374         Bis    = BisAna;
375       } else {
376         //  Modified by Sergey KHROMOV - Wed Mar  6 17:01:08 2002 End
377         UFirst = BisPC->Parameter(apoint);
378         ULast  = BisPC->LastParameter();
379         if(UFirst >= ULast)
380         {
381           //Standard_Real t = .9;
382           //UFirst = (1. - t) * BisPC->FirstParameter() + t * ULast;
383           //Extrapolate by line
384           //gp_Dir2d N ( -adirection*afirstvector.Y(), adirection*afirstvector.X());
385           gp_Vec2d V( BisPC->Value(BisPC->FirstParameter()), BisPC->Value(ULast) );
386           gp_Dir2d N( V );
387           Handle (Geom2d_Line)         L      = new Geom2d_Line         (apoint,N);
388           Handle (Geom2d_TrimmedCurve) BisL   = new Geom2d_TrimmedCurve (L,0,RC);
389           Handle(Bisector_BisecAna)    BisAna = new Bisector_BisecAna   ();
390           BisAna->Init(BisL);
391           UFirst = BisAna->ParameterOfStartPoint();
392           ULast  = BisAna->ParameterOfEndPoint();
393           Bis    = BisAna;
394         }
395         else
396           Bis    = BisPC;
397       }
398     }
399   }
400   if(UFirst < Bis->FirstParameter())
401     UFirst = Bis->FirstParameter();
402   if(ULast > Bis->LastParameter())
403     ULast = Bis->LastParameter();
404   thebisector = new Geom2d_TrimmedCurve(Bis,UFirst,ULast);
405
406 #ifdef DRAW
407   if(Affich)
408   {
409   sprintf( name, "c1_%d", ++nbb );
410   DrawTrSurf::Set( name, afirstcurve );
411   sprintf( name, "c2_%d", nbb );
412   DrawTrSurf::Set( name, asecondpoint->Pnt2d() );
413   sprintf( name, "p%d", nbb );
414   DrawTrSurf::Set( name, apoint );
415   sprintf( name, "b%d", nbb );
416   DrawTrSurf::Set( name, thebisector );
417   }
418 #endif
419 }
420
421 //===========================================================================
422 //   calculate the bissectrice between a curve and a point starting in a point. 
423 //                                                                          
424 //   afirstpoint   : \ curve and point the bissectrice between which is calculated.         
425 //   asecondcurve  : /                                          
426 //   apoint        :   point through which the bissectrice should pass.         
427 //   afirstvector  : \ vectors to find the sector where       
428 //   asecondvector : / the bissectrice should be located.                      
429 //   adirection    :   shows the side of the bissectrice to be preserved.       
430 //   tolerance     :   threshold starting from which the bisectrices are degenerated
431 //===========================================================================
432
433 void Bisector_Bisec::Perform(const Handle(Geom2d_Point)& afirstpoint  ,
434   const Handle(Geom2d_Curve)& asecondcurve ,
435   const gp_Pnt2d&             apoint       ,
436   const gp_Vec2d&             afirstvector ,
437   const gp_Vec2d&             asecondvector,
438   const Standard_Real         adirection   ,
439   const Standard_Real         tolerance    ,
440   const Standard_Boolean      oncurve       )
441
442 {  
443   //gp_Pnt2d FirstPnt = afirstpoint->Pnt2d();
444
445   Handle(Bisector_Curve) Bis;
446   Handle(Standard_Type)  Type1 = asecondcurve ->DynamicType();
447   Standard_Real          UFirst,ULast;
448
449   if (Type1 == STANDARD_TYPE(Geom2d_TrimmedCurve)) {
450     Type1 = Handle(Geom2d_TrimmedCurve)::DownCast(asecondcurve)
451       ->BasisCurve()->DynamicType();
452   }
453
454   if ( Type1 == STANDARD_TYPE(Geom2d_Circle) || Type1 == STANDARD_TYPE(Geom2d_Line)) {
455     //------------------------------------------------------------------
456     // Analytic Bissectrice.
457     //------------------------------------------------------------------
458     Handle(Bisector_BisecAna) BisAna = new Bisector_BisecAna();
459     BisAna -> Perform (afirstpoint   ,
460       asecondcurve  ,
461       apoint        ,
462       afirstvector  ,
463       asecondvector ,
464       adirection    ,
465       tolerance     ,
466       oncurve       );
467     UFirst = BisAna->ParameterOfStartPoint();
468     ULast  = BisAna->ParameterOfEndPoint();
469     Bis    = BisAna;
470   }
471   else {   
472     //  Standard_Real    UPoint    = 0.;
473     Standard_Boolean IsLine    = Standard_False;
474     Standard_Real    RC        = Precision::Infinite();
475
476     if (oncurve) {
477       if (Bisector::IsConvex(asecondcurve, adirection) || 
478         IsMaxRC(asecondcurve,asecondcurve->FirstParameter(),RC)) {
479           IsLine = Standard_True;
480       }
481     }    
482     if (IsLine) {     
483       //------------------------------------------------------------------
484       // Half-Staight.
485       //------------------------------------------------------------------
486       gp_Dir2d N ( -adirection*afirstvector.Y(), adirection*afirstvector.X());
487       Handle (Geom2d_Line)         L      = new Geom2d_Line         (apoint,N);
488       Handle (Geom2d_TrimmedCurve) BisL   = new Geom2d_TrimmedCurve (L,0,RC);
489       Handle(Bisector_BisecAna)    BisAna = new Bisector_BisecAna   ();
490       BisAna->Init(BisL);
491       UFirst = BisAna->ParameterOfStartPoint();
492       ULast  = BisAna->ParameterOfEndPoint();
493       Bis    = BisAna;
494     }
495     else {
496       //-------------------------------------------------------------------
497       // Bissectrice algo
498       //-------------------------------------------------------------------
499       Handle(Bisector_BisecPC) BisPC = new Bisector_BisecPC();
500       BisPC -> Perform(asecondcurve        ,
501         afirstpoint->Pnt2d(),
502         adirection          );
503       //  Modified by Sergey KHROMOV - Thu Feb 21 16:49:54 2002 Begin
504       if (BisPC -> IsEmpty()) {
505         gp_Dir2d dir1(afirstvector), dir2(asecondvector);
506         Standard_Real
507           Nx = - dir1.X() - dir2.X(),
508           Ny = - dir1.Y() - dir2.Y();
509         if (Abs(Nx) <= gp::Resolution() && Abs(Ny) <= gp::Resolution()) {
510           Nx = - afirstvector.Y();
511           Ny = afirstvector.X();
512         }
513         //      gp_Dir2d N ( -adirection*afirstvector.Y(), adirection*afirstvector.X());
514         gp_Dir2d N ( adirection*Nx, adirection*Ny);
515         Handle (Geom2d_Line)         L      = new Geom2d_Line (apoint,N);
516         Handle (Geom2d_TrimmedCurve) BisL   = new Geom2d_TrimmedCurve(L,0,RC);
517         Handle(Bisector_BisecAna)    BisAna = new Bisector_BisecAna ();
518         BisAna->Init(BisL);
519         UFirst = BisAna->ParameterOfStartPoint();
520         ULast  = BisAna->ParameterOfEndPoint();
521         Bis    = BisAna;
522       } else {
523         //  Modified by Sergey KHROMOV - Thu Feb 21 16:49:58 2002 End
524         UFirst = BisPC->Parameter(apoint);
525         ULast  = BisPC->LastParameter();
526         if(UFirst >= ULast)
527         {
528           //Extrapolate by line
529           //gp_Dir2d N ( -adirection*afirstvector.Y(), adirection*afirstvector.X());
530           gp_Vec2d V( BisPC->Value(BisPC->FirstParameter()), BisPC->Value(ULast) );
531           gp_Dir2d N( V );
532           Handle (Geom2d_Line)         L      = new Geom2d_Line         (apoint,N);
533           Handle (Geom2d_TrimmedCurve) BisL   = new Geom2d_TrimmedCurve (L,0,RC);
534           Handle(Bisector_BisecAna)    BisAna = new Bisector_BisecAna   ();
535           BisAna->Init(BisL);
536           UFirst = BisAna->ParameterOfStartPoint();
537           ULast  = BisAna->ParameterOfEndPoint();
538           Bis    = BisAna;
539         }
540         else
541           Bis    = BisPC;
542       }
543     }
544   }
545  
546   UFirst = Max(UFirst, Bis->FirstParameter());
547   ULast = Min(ULast, Bis->LastParameter());
548   thebisector = new Geom2d_TrimmedCurve(Bis,UFirst,ULast);
549
550 #ifdef DRAW
551   if(Affich)
552   {
553   sprintf( name, "c1_%d", ++nbb );
554   DrawTrSurf::Set( name, afirstpoint->Pnt2d() );
555   sprintf( name, "c2_%d", nbb );
556   DrawTrSurf::Set( name, asecondcurve );
557   sprintf( name, "p%d", nbb );
558   DrawTrSurf::Set( name, apoint );
559   sprintf( name, "b%d", nbb );
560   DrawTrSurf::Set( name, thebisector );
561   }
562 #endif
563
564 }
565
566 //===========================================================================
567 //        calculate the bissectrice between two points starting in a point.      
568 //                                                                          
569 //   afirstpoint   : \ curves the bissectrice between which should be          
570 //   asecondpoint  : / calculated.                                         
571 //   apoint        :   point through which the bissectrice should pass.         
572 //   afirstvector  : \ vectors to find the sector where       
573 //   asecondvector : / the bissectrice should be located.                      
574 //   adirection    :   shows the side of the bissectrice to be preserved.       
575 //===========================================================================
576
577 void Bisector_Bisec::Perform(const Handle(Geom2d_Point)& afirstpoint  ,
578   const Handle(Geom2d_Point)& asecondpoint ,
579   const gp_Pnt2d&             apoint       ,
580   const gp_Vec2d&             afirstvector ,
581   const gp_Vec2d&             asecondvector,
582   const Standard_Real         adirection   ,
583   const Standard_Real         tolerance    ,
584   const Standard_Boolean      oncurve      )
585 {
586   Handle(Bisector_BisecAna) Bis = new Bisector_BisecAna();
587
588   Bis -> Perform (afirstpoint   ,
589     asecondpoint  ,
590     apoint        ,
591     afirstvector  ,
592     asecondvector ,
593     adirection    ,
594     tolerance     ,
595     oncurve       ); 
596   thebisector = new Geom2d_TrimmedCurve(Bis,
597     Bis->ParameterOfStartPoint(),
598     Bis->ParameterOfEndPoint());
599
600 #ifdef DRAW
601   if(Affich)
602   {
603   sprintf( name, "c1_%d", ++nbb );
604   DrawTrSurf::Set( name, afirstpoint->Pnt2d() );
605   sprintf( name, "c2_%d", nbb );
606   DrawTrSurf::Set( name, asecondpoint->Pnt2d() );
607   sprintf( name, "p%d", nbb );
608   DrawTrSurf::Set( name, apoint );
609   sprintf( name, "b%d", nbb );
610   DrawTrSurf::Set( name, thebisector );
611   }
612 #endif
613 }
614
615 //=============================================================================
616 //function : Value
617 //purpose  :
618 //=============================================================================
619 const Handle(Geom2d_TrimmedCurve)&  Bisector_Bisec::Value() const
620 {
621   return thebisector;
622 }
623
624 //=============================================================================
625 //function : ChangeValue
626 //purpose  :
627 //=============================================================================
628 const Handle(Geom2d_TrimmedCurve)&  Bisector_Bisec::ChangeValue()
629 {
630   return thebisector;
631 }
632
633 //=============================================================================
634 //function : ReplaceByLineIfIsToSmall 
635 //purpose  : If the size of an algorithmic bissectrice is negligeable it is
636 //           replaced by a half-straight.
637 //=============================================================================
638 static void ReplaceByLineIfIsToSmall (Handle(Bisector_Curve)& Bis,
639   Standard_Real&        UFirst,
640   Standard_Real&        ULast )
641
642 {
643   if (Abs(ULast - UFirst) > 2.*Precision::PConfusion()*10.) return; //patch
644
645   gp_Pnt2d PF = Bis->Value(UFirst);
646   gp_Pnt2d PL = Bis->Value(ULast);
647
648   if (PF.Distance(PL) > Precision::Confusion()*10.) return;
649
650   gp_Vec2d T1 = Bis->DN(UFirst,1);
651
652   Handle (Geom2d_CartesianPoint) PG     = new Geom2d_CartesianPoint(PF);
653   Handle (Geom2d_Line)           L      = new Geom2d_Line (PF,T1);
654   Handle (Geom2d_TrimmedCurve)   
655     BisL   = new Geom2d_TrimmedCurve (L,0,Precision::Infinite());
656   Handle(Bisector_BisecAna)      BisAna = new Bisector_BisecAna ();
657   BisAna->Init(BisL);
658   UFirst = BisAna->ParameterOfStartPoint();
659   ULast  = BisAna->ParameterOfEndPoint();
660   Bis    = BisAna;
661 }
662
663 //=============================================================================
664 //function : IsMaxRC
665 //purpose  :
666 //=============================================================================
667 static Standard_Boolean  IsMaxRC (const Handle(Geom2d_Curve)& C,
668   Standard_Real         U,
669   Standard_Real&        R)
670 {  
671   Standard_Real KF,KL;
672   Standard_Real US = C->FirstParameter();
673   Standard_Real UL = C->LastParameter();
674
675   gp_Vec2d      D1,D2;
676   gp_Pnt2d      P;
677   Standard_Real Norm2;
678
679   C->D2(US,P,D1,D2);
680   Norm2 = D1.SquareMagnitude();
681   if (Norm2 < gp::Resolution()) { KF = 0.0;}
682   else                          { KF = Abs(D1^D2)/(Norm2*sqrt(Norm2));}
683
684   C->D2(UL,P,D1,D2);
685   Norm2 = D1.SquareMagnitude();
686   if (Norm2 < gp::Resolution()) { KL = 0.0;}
687   else                          { KL = Abs(D1^D2)/(Norm2*sqrt(Norm2));}
688
689   Standard_Boolean IsMax = Standard_False;
690
691   if (U == UL) {
692     if (KL < KF) {
693       if (KL == 0.0) R = Precision::Infinite(); else R = 1/KL;
694       IsMax = Standard_True;
695     }
696   }
697   else {   
698     if (KF < KL) {
699       if (KF == 0.0) R = Precision::Infinite(); else R = 1/KF;
700       IsMax = Standard_True;
701     }
702   }
703   return IsMax;
704 }