0031035: Coding - uninitialized class fields reported by Visual Studio Code Analysis
[occt.git] / src / LocalAnalysis / LocalAnalysis_SurfaceContinuity.cxx
1 // Created on: 1996-09-09
2 // Created by: Herve LOUESSARD
3 // Copyright (c) 1996-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 <Geom2d_Curve.hxx>
19 #include <Geom_Surface.hxx>
20 #include <GeomLProp_SLProps.hxx>
21 #include <gp.hxx>
22 #include <gp_Dir.hxx>
23 #include <gp_Pnt.hxx>
24 #include <gp_Pnt2d.hxx>
25 #include <gp_Vec.hxx>
26 #include <LocalAnalysis_SurfaceContinuity.hxx>
27 #include <StdFail_NotDone.hxx>
28
29 /*********************************************************************************/
30 /*********************************************************************************/
31 void LocalAnalysis_SurfaceContinuity::SurfC0 (const GeomLProp_SLProps& Surf1, 
32                                                const GeomLProp_SLProps& Surf2
33                                                )  
34 {  myContC0=(Surf1.Value()).Distance(Surf2.Value());
35 }
36
37 /*********************************************************************************/
38
39 void LocalAnalysis_SurfaceContinuity::SurfC1(  GeomLProp_SLProps& Surf1, 
40                                        GeomLProp_SLProps & Surf2) 
41 { gp_Vec V1u, V2u, V1v, V2v;
42   Standard_Real norm1u, norm2u, norm1v, norm2v,angu,angv; 
43   
44   V1u = Surf1.D1U();
45   V2u = Surf2.D1U();
46
47   V1v = Surf1.D1V();
48   V2v = Surf2.D1V();
49
50   norm1u = V1u.Magnitude();
51   norm2u = V2u.Magnitude();
52   norm1v = V1v.Magnitude();
53   norm2v = V2v.Magnitude();
54
55   if ((norm1u>myepsnul )&&(norm2u>myepsnul )&&(norm1v>myepsnul)
56        &&(norm2v>myepsnul))
57     { if (norm1u >= norm2u ) 
58          myLambda1U= norm2u / norm1u;
59       else myLambda1U = norm1u / norm2u;
60       if (norm1v >= norm2v ) 
61          myLambda1V= norm2v / norm1v;
62       else myLambda1V = norm1v / norm2v;
63       angu= V1u.Angle(V2u);
64       if (angu>M_PI/2) myContC1U=M_PI-angu;
65       else myContC1U=angu;
66       angv= V1v.Angle(V2v);
67       if (angv>M_PI/2) myContC1V=M_PI-angv;
68        else myContC1V=angv;   }
69   else {myIsDone = Standard_False;  
70         myErrorStatus=LocalAnalysis_NullFirstDerivative;}
71 }
72
73 /*********************************************************************************/
74
75 void LocalAnalysis_SurfaceContinuity::SurfC2(  GeomLProp_SLProps& Surf1, 
76                                                GeomLProp_SLProps& Surf2)
77
78 { gp_Vec V11u, V12u, V21u, V22u, V11v, V12v, V21v, V22v;
79   Standard_Real norm11u, norm12u, norm21u, norm22u, norm11v, norm12v, norm21v, norm22v;
80   Standard_Real ang;
81   V11u = Surf1.D1U();
82   V12u = Surf2.D1U();
83   V21u = Surf1.D2U();
84   V22u = Surf2.D2U();
85   norm11u = V11u.Magnitude();
86   norm12u = V12u.Magnitude();
87   norm21u = V21u.Magnitude();
88   norm22u = V22u.Magnitude();
89
90   if ((norm11u>myepsnul)&&(norm12u>myepsnul))
91      { if( (norm21u>myepsnul)&&(norm22u>myepsnul))
92           { if (norm11u >= norm12u ) 
93                 {myLambda1U= norm12u / norm11u;
94                  myLambda2U = norm22u /norm21u;}
95             else {myLambda1U = norm11u / norm12u;
96                   myLambda2U = norm21u / norm22u;}
97             ang=V21u.Angle(V22u);
98             if(ang>M_PI/2) myContC2U=M_PI-ang;
99             else myContC2U=ang; }
100        else
101           {  myIsDone=Standard_False;
102             myErrorStatus=LocalAnalysis_NullSecondDerivative;}
103      }
104    
105    else { myIsDone=Standard_False; 
106           myErrorStatus=LocalAnalysis_NullFirstDerivative;}
107
108   V11v = Surf1.D1V();
109   V12v = Surf2.D1V();
110   V21v = Surf1.D2V();
111   V22v = Surf2.D2V();
112   norm11v = V11v.Magnitude();
113   norm12v = V12v.Magnitude();
114   norm21v = V21v.Magnitude();
115   norm22v = V22v.Magnitude();
116
117   if ((norm11v>myepsnul)&&(norm12v>myepsnul))
118      {if ((norm21v>myepsnul)&&(norm22v>myepsnul))
119          {if ( norm11v >= norm12v ) 
120              {myLambda1V= norm12v / norm11v;
121               myLambda2V= norm22v / norm21v;}       
122           else{ myLambda1V = norm11v / norm12v;
123                 myLambda2V = norm21v / norm22v;}
124           ang= V21v.Angle(V22v);
125           if (ang>M_PI/2)  myContC2V=M_PI-ang;
126           else myContC2V=ang;
127          }
128       else{ myIsDone= Standard_False;
129             myErrorStatus=LocalAnalysis_NullSecondDerivative; }
130     }
131    else{ myIsDone=Standard_False;
132          myErrorStatus=LocalAnalysis_NullFirstDerivative;}
133 }
134
135 /*********************************************************************************/
136 void LocalAnalysis_SurfaceContinuity::SurfG1(  GeomLProp_SLProps& Surf1, 
137                                                 GeomLProp_SLProps& Surf2) 
138 { if (Surf1.IsNormalDefined()&&Surf2.IsNormalDefined()) 
139   { gp_Dir D1 = Surf1.Normal();
140     gp_Dir D2 = Surf2.Normal();
141     Standard_Real ang=D1.Angle(D2);
142     if (ang>M_PI/2)  myContG1= M_PI-ang;
143     else  myContG1=ang; 
144   }
145   else{ myIsDone=Standard_False;
146         myErrorStatus=LocalAnalysis_NormalNotDefined;} 
147 }
148
149 /*********************************************************************************/
150
151 void   LocalAnalysis_SurfaceContinuity::SurfG2 ( GeomLProp_SLProps& Surf1, 
152                                           GeomLProp_SLProps & Surf2)
153 { gp_Dir DMIN1, DMIN2, DMAX1, DMAX2;
154   Standard_Real RMIN1,RMIN2,RMAX1,RMAX2;
155   Standard_Real  x1, x2, y1, y2, z1, z2;
156  
157   if ( Surf1.IsCurvatureDefined() && Surf2.IsCurvatureDefined())
158     { 
159       Surf1.CurvatureDirections(DMIN1, DMAX1);
160       Surf2.CurvatureDirections(DMIN2, DMAX2);
161       DMIN1.Coord(x1, y1, z1);
162       DMAX1.Coord(x2, y2, z2);
163       gp_Dir MCD1( (Abs(x1)+Abs(x2))/2, (Abs(y1)+Abs(y2))/2, (Abs(z1)+Abs(z2))/2 );
164       DMIN2.Coord(x1, y1, z1);
165       DMAX2.Coord(x2, y2, z2);
166       gp_Dir MCD2( (Abs(x1)+Abs(x2))/2, (Abs(y1)+Abs(y2))/2, (Abs(z1)+Abs(z2))/2 );
167   
168       myAlpha = MCD1.Angle( MCD2 );
169       RMIN1 = Surf1.MinCurvature();  
170       RMAX1 = Surf1.MaxCurvature();  
171       RMIN2 = Surf2.MinCurvature();  
172       RMAX2 = Surf2.MaxCurvature();
173       myETA1 = (RMIN1+RMAX1)/2;
174       myETA2 = (RMIN2+RMAX2)/2;
175       myETA  = (myETA1+myETA2)/2;
176       myZETA1 = (RMAX1-RMIN1)/2;
177       myZETA2 = (RMAX2-RMIN2)/2;
178       myZETA = (myZETA1+myZETA2)/2;
179       Standard_Real DETA,DZETA; 
180       DETA = ( myETA1- myETA2)/2;
181       DZETA =( myZETA1- myZETA2)/2;
182        myGap= Abs(DETA) + sqrt( DZETA*DZETA*Cos(myAlpha)*Cos(myAlpha)
183                      + myZETA*myZETA*Sin(myAlpha)*Sin(myAlpha));
184        }   
185    else {myIsDone = Standard_False;
186          myErrorStatus=LocalAnalysis_CurvatureNotDefined;}
187           
188 }
189 LocalAnalysis_SurfaceContinuity::LocalAnalysis_SurfaceContinuity(const Standard_Real EpsNul,
190                                                                  const Standard_Real EpsC0,
191                                                                  const Standard_Real EpsC1,
192                                                                  const Standard_Real EpsC2,
193                                                                  const Standard_Real EpsG1,
194                                                                  const Standard_Real Percent,
195                                                                  const Standard_Real Maxlen)
196 : myContC0(0.0),
197   myContC1U(0.0),
198   myContC1V(0.0),
199   myContC2U(0.0),
200   myContC2V(0.0),
201   myContG1(0.0),
202   myLambda1U(0.0),
203   myLambda2U(0.0),
204   myLambda1V(0.0),
205   myLambda2V(0.0),
206   myETA1(0.0),
207   myETA2(0.0),
208   myETA(0.0),
209   myZETA1(0.0),
210   myZETA2(0.0),
211   myZETA(0.0),
212   myAlpha(0.0),
213   myGap(0.0)
214 { myepsnul=EpsNul;
215   myepsC0= EpsC0;
216   myepsC1= EpsC1;
217   myepsC2= EpsC2;
218   myepsG1= EpsG1;
219   myperce= Percent;
220   mymaxlen= Maxlen;
221   myIsDone = Standard_True;
222 }
223  void LocalAnalysis_SurfaceContinuity::ComputeAnalysis(GeomLProp_SLProps& Surf1,
224                                                        GeomLProp_SLProps& Surf2,
225                                                        const GeomAbs_Shape Order)
226 {  myTypeCont = Order;
227    switch ( Order )
228         { case GeomAbs_C0 : {
229                                 SurfC0(Surf1, Surf2);
230                             }
231                             break;
232           case GeomAbs_C1 : {
233                                SurfC0(Surf1, Surf2);
234                                SurfC1(Surf1, Surf2);}
235                             break;
236           case GeomAbs_C2 : {
237                               SurfC0(Surf1, Surf2);
238                               SurfC1(Surf1, Surf2);
239                               SurfC2(Surf1, Surf2);}
240                             break;
241           case GeomAbs_G1 : {
242                               SurfC0(Surf1, Surf2);
243                               SurfG1(Surf1, Surf2);}
244                             break;
245           case GeomAbs_G2 : {
246                               SurfC0(Surf1, Surf2);
247                               SurfG1(Surf1, Surf2);
248                               SurfG2(Surf1, Surf2);}
249                             break;
250           default         : {}
251         }
252
253 }
254
255 /*********************************************************************************/
256
257 LocalAnalysis_SurfaceContinuity::LocalAnalysis_SurfaceContinuity( const Handle(Geom_Surface)& Surf1, 
258                          const Standard_Real u1, const Standard_Real v1, 
259                          const Handle(Geom_Surface)& Surf2, const Standard_Real u2, 
260                          const Standard_Real v2, const GeomAbs_Shape Ordre, 
261                          const Standard_Real EpsNul,
262                          const Standard_Real EpsC0 ,
263                          const Standard_Real EpsC1 ,
264                          const Standard_Real EpsC2,
265                          const Standard_Real EpsG1,
266                          const Standard_Real Percent,               
267                          const Standard_Real  Maxlen )
268 : myContC0(0.0),
269   myContC1U(0.0),
270   myContC1V(0.0),
271   myContC2U(0.0),
272   myContC2V(0.0),
273   myContG1(0.0),
274   myLambda1U(0.0),
275   myLambda2U(0.0),
276   myLambda1V(0.0),
277   myLambda2V(0.0),
278   myETA1(0.0),
279   myETA2(0.0),
280   myETA(0.0),
281   myZETA1(0.0),
282   myZETA2(0.0),
283   myZETA(0.0),
284   myAlpha(0.0),
285   myGap(0.0)
286 { myTypeCont = Ordre;
287   myepsnul=EpsNul;
288   myepsC0= EpsC0;
289   myepsC1= EpsC1;
290   myepsC2= EpsC2;
291   myepsG1= EpsG1;
292   myperce= Percent;
293   mymaxlen= Maxlen;
294   myIsDone = Standard_True;
295   switch ( Ordre )
296         { case GeomAbs_C0 : {
297                                GeomLProp_SLProps Surfa1 ( Surf1, u1, v1, 0, myepsnul);
298                                GeomLProp_SLProps Surfa2 ( Surf2, u2, v2, 0, myepsnul);
299                                 SurfC0(Surfa1, Surfa2);
300                             }
301                             break;
302           case GeomAbs_C1 : {
303                                GeomLProp_SLProps Surfa1 ( Surf1, u1, v1, 1, myepsnul); 
304                                GeomLProp_SLProps   Surfa2 ( Surf2, u2, v2, 1, myepsnul);
305                                SurfC0(Surfa1, Surfa2);
306                                SurfC1(Surfa1, Surfa2);}
307                             break;
308           case GeomAbs_C2 : {
309                                GeomLProp_SLProps Surfa1 ( Surf1, u1, v1, 2, myepsnul); 
310                                 GeomLProp_SLProps Surfa2 ( Surf2, u2, v2, 2, myepsnul);
311                               SurfC0(Surfa1, Surfa2);
312                               SurfC1(Surfa1, Surfa2);
313                               SurfC2(Surfa1, Surfa2);}
314                             break;
315           case GeomAbs_G1 : {
316                                GeomLProp_SLProps Surfa1 ( Surf1, u1, v1, 1, myepsnul); 
317                                 GeomLProp_SLProps  Surfa2 ( Surf2, u2, v2, 1, myepsnul);
318                               SurfC0(Surfa1, Surfa2);
319                               SurfG1(Surfa1, Surfa2);}
320                             break;
321           case GeomAbs_G2 : {
322                               GeomLProp_SLProps Surfa1 ( Surf1, u1, v1, 2, myepsnul); 
323                               GeomLProp_SLProps Surfa2 ( Surf2, u2, v2, 2, myepsnul);
324                               SurfC0(Surfa1, Surfa2);
325                               SurfG1(Surfa1, Surfa2);
326                               SurfG2(Surfa1, Surfa2);}
327                             break;
328           default         : {}
329         }
330 }
331
332 /*********************************************************************************/
333
334 LocalAnalysis_SurfaceContinuity::LocalAnalysis_SurfaceContinuity(const Handle(Geom2d_Curve)& curv1, 
335                          const Handle(Geom2d_Curve)& curv2, const Standard_Real U, 
336                          const Handle(Geom_Surface)& Surf1 , 
337                          const Handle(Geom_Surface)& Surf2, 
338                          const GeomAbs_Shape Ordre,
339                          const Standard_Real EpsNul,
340                          const Standard_Real EpsC0 ,
341                          const Standard_Real EpsC1 ,
342                          const Standard_Real EpsC2,
343                          const Standard_Real EpsG1,
344                          const Standard_Real Percent,               
345                          const Standard_Real  Maxlen )
346 : myContC0(0.0),
347   myContC1U(0.0),
348   myContC1V(0.0),
349   myContC2U(0.0),
350   myContC2V(0.0),
351   myContG1(0.0),
352   myLambda1U(0.0),
353   myLambda2U(0.0),
354   myLambda1V(0.0),
355   myLambda2V(0.0),
356   myETA1(0.0),
357   myETA2(0.0),
358   myETA(0.0),
359   myZETA1(0.0),
360   myZETA2(0.0),
361   myZETA(0.0),
362   myAlpha(0.0),
363   myGap(0.0)
364 { Standard_Real pard1, parf1, pard2, parf2, u1, v1, u2, v2;
365   
366   myTypeCont = Ordre;
367   myepsnul=EpsNul;
368   myepsC0= EpsC0;
369   myepsC1= EpsC1;
370   myepsC2= EpsC2;
371   myepsG1= EpsG1;
372   myperce= Percent;
373   mymaxlen= Maxlen;
374   myIsDone = Standard_True;
375
376   pard1 = curv1->FirstParameter();
377   pard2 = curv2->FirstParameter();
378   parf1 = curv1->LastParameter();
379   parf2 = curv2->LastParameter();
380
381
382   if (!(((U <= parf1) && (U >= pard1)) &&((U <= parf2) && (U >= pard2))) )    myIsDone = Standard_False; 
383     else 
384     { gp_Pnt2d pt1 = curv1->Value(U);
385       gp_Pnt2d pt2 = curv2->Value(U);
386        
387       pt1.Coord(u1, v1);
388       pt2.Coord(u2, v2);
389       switch ( Ordre )
390           { case GeomAbs_C0 : {
391                                  GeomLProp_SLProps Surfa1 ( Surf1, u1, v1, 0, myepsnul);
392                                  GeomLProp_SLProps Surfa2 ( Surf2, u2, v2, 0, myepsnul);
393                                  SurfC0(Surfa1, Surfa2);
394                               }
395                               break;
396             case GeomAbs_C1 : {
397                                  GeomLProp_SLProps Surfa1 ( Surf1, u1, v1, 1, myepsnul);
398                                   GeomLProp_SLProps Surfa2 ( Surf2, u2, v2, 1, myepsnul);
399                                 SurfC0(Surfa1, Surfa2);
400                                 SurfC1(Surfa1, Surfa2);}
401                               break;
402             case GeomAbs_C2 : {
403                                  GeomLProp_SLProps  Surfa1 ( Surf1, u1, v1, 2, myepsnul); 
404                                  GeomLProp_SLProps   Surfa2 ( Surf2, u2, v2, 2, myepsnul);
405                                 SurfC0(Surfa1, Surfa2);
406                                 SurfC1(Surfa1, Surfa2);
407                                 SurfC2(Surfa1, Surfa2);}
408                               break;
409             case GeomAbs_G1 : {
410                                  GeomLProp_SLProps  Surfa1 ( Surf1, u1, v1, 1, myepsnul); 
411                                  GeomLProp_SLProps Surfa2 ( Surf2, u2, v2, 1, myepsnul);
412                                  SurfC0(Surfa1, Surfa2);
413                                  SurfG1(Surfa1, Surfa2);}
414                               break;
415             case GeomAbs_G2 : {
416                                 GeomLProp_SLProps   Surfa1 ( Surf1, u1, v1, 2, myepsnul); 
417                                  GeomLProp_SLProps  Surfa2 ( Surf2, u2, v2, 2, myepsnul);
418                                 SurfC0(Surfa1, Surfa2);
419                                 SurfG1(Surfa1, Surfa2);
420                                 SurfG2(Surfa1, Surfa2);}
421                               break;
422             default         : {}
423           }
424     }
425 }
426
427 /*********************************************************************************/
428
429 Standard_Boolean LocalAnalysis_SurfaceContinuity::IsC0() const 
430 { if (!myIsDone) { throw StdFail_NotDone();}
431   if ( myContC0 <= myepsC0 ) 
432      return Standard_True;
433      else return Standard_False;
434 }
435
436 /*********************************************************************************/
437
438 Standard_Boolean LocalAnalysis_SurfaceContinuity::IsC1() const 
439 { if (!myIsDone) { throw StdFail_NotDone();}
440   if ( IsC0 () && (myContC1U <= myepsC1) && (myContC1V <= myepsC1))
441    return Standard_True;
442   else return Standard_False;
443 }
444
445 /*********************************************************************************/
446
447 Standard_Boolean LocalAnalysis_SurfaceContinuity::IsC2() const 
448 { Standard_Real eps1u, eps1v, eps2u, eps2v;
449
450   if (!myIsDone) { throw StdFail_NotDone();}
451   if ( IsC1())
452      { eps1u = 0.5*myepsC1*myepsC1*myLambda1U;
453        eps1v = 0.5*myepsC1*myepsC1*myLambda1V;
454        eps2u = 0.5*myepsC2*myepsC2*myLambda2U;
455        eps2v = 0.5*myepsC2*myepsC2*myLambda2V;
456        if ((myContC2U < myepsC2) && (myContC2V < myepsC2))
457           { if (Abs(myLambda1U*myLambda1U-myLambda2U) <= (eps1u*eps1u+eps2u))
458                if (Abs(myLambda1V*myLambda1V-myLambda2V) <= (eps1v*eps1v+eps2v))
459                   return Standard_True;
460                else return  Standard_False;
461             else return  Standard_False;
462           }
463           else return  Standard_False;        
464      }
465      else return Standard_False;
466     
467 }
468
469 /*********************************************************************************/
470
471 Standard_Boolean LocalAnalysis_SurfaceContinuity::IsG1() const 
472 {
473   if (!myIsDone) { throw StdFail_NotDone();} 
474   if ( IsC0 () &&( myContG1 <= myepsG1))
475        return Standard_True;
476       else return Standard_False;
477 }
478
479 /*********************************************************************************/
480
481 Standard_Boolean LocalAnalysis_SurfaceContinuity::IsG2()const 
482 { Standard_Real EPSNL;
483   Standard_Integer itype;
484  
485   if (!myIsDone) { throw StdFail_NotDone();} 
486   itype =0;
487   EPSNL= 8*myepsC0/(mymaxlen*mymaxlen);
488   if ( IsG1())
489      { if ( ( Abs(myETA)< EPSNL) && ( Abs(myZETA)< EPSNL))
490           return Standard_True;
491         if ( ( Abs(myZETA1)< EPSNL) && ( Abs(myZETA2)< EPSNL))
492            itype =1;
493            else if ( ( Abs(myETA1)< EPSNL) && ( Abs(myETA2)< EPSNL))
494                    itype =1;
495                    else if ((Abs(Abs(myZETA)-Abs(myETA))) < EPSNL)
496                            itype =1;
497                            else if ((myETA1<myZETA1)&&(myETA2<myZETA2))
498                                    itype =1; 
499                                    else if ((myETA1>myZETA1)&&(myETA2>myZETA2))
500                                            itype =1; 
501        if (itype == 1)
502           { 
503
504             if (( myETA >= (2*myZETA))&&(myGap<=(myperce*(myETA-myZETA)))) return Standard_True;
505             if (( myZETA>= myETA) && ( myGap<= (myperce*myZETA))) return Standard_True;
506             if (( myZETA<= myETA) && ( myETA <= (2*myZETA)) && (myGap <= (myperce * myETA))) 
507                return Standard_True;
508                else  return Standard_False;
509                     
510           }
511           else  return Standard_False;
512      }
513      else return Standard_False;
514
515 }
516
517   
518 /*********************************************************************************/
519
520 GeomAbs_Shape  LocalAnalysis_SurfaceContinuity::ContinuityStatus() const 
521 {
522  if (!myIsDone) { throw StdFail_NotDone();}
523  return (myTypeCont);
524 }
525
526 /*********************************************************************************/
527
528 Standard_Real LocalAnalysis_SurfaceContinuity::C0Value() const 
529
530   if (!myIsDone) { throw StdFail_NotDone();}
531   return ( myContC0    );
532 }
533
534 /*********************************************************************************/
535
536 Standard_Real LocalAnalysis_SurfaceContinuity::C1UAngle() const 
537 {
538   if (!myIsDone) { throw StdFail_NotDone();}
539   return ( myContC1U    );
540 }
541
542 /*********************************************************************************/
543
544 Standard_Real LocalAnalysis_SurfaceContinuity::C1VAngle() const 
545 {
546   if (!myIsDone) { throw StdFail_NotDone();}
547   return ( myContC1V    );
548 }
549
550 /*********************************************************************************/
551
552 Standard_Real LocalAnalysis_SurfaceContinuity::C2UAngle() const 
553 {
554   if (!myIsDone) { throw StdFail_NotDone();}
555   return ( myContC2U    );
556 }
557
558 /*********************************************************************************/
559
560 Standard_Real LocalAnalysis_SurfaceContinuity::C2VAngle() const 
561 {
562   if (!myIsDone) { throw StdFail_NotDone();}
563   return ( myContC2V    );
564 }
565
566 /*********************************************************************************/
567
568 Standard_Real LocalAnalysis_SurfaceContinuity::G1Angle() const 
569 {
570   if (!myIsDone) { throw StdFail_NotDone();}
571   return ( myContG1    );
572 }
573
574 /*********************************************************************************/
575
576 Standard_Real LocalAnalysis_SurfaceContinuity::C1URatio() const 
577 {
578   if (!myIsDone) { throw StdFail_NotDone();}
579   return ( myLambda1U    );
580 }
581
582 /*********************************************************************************/
583
584 Standard_Real LocalAnalysis_SurfaceContinuity::C2URatio() const 
585 {
586   if (!myIsDone) { throw StdFail_NotDone();}
587   return ( myLambda2U    );
588 }
589
590 /*********************************************************************************/
591
592 Standard_Real LocalAnalysis_SurfaceContinuity::C1VRatio() const 
593 {
594   if (!myIsDone) { throw StdFail_NotDone();}
595   return ( myLambda1V    );
596 }
597
598 /*********************************************************************************/
599
600 Standard_Real LocalAnalysis_SurfaceContinuity::C2VRatio() const 
601
602   if (!myIsDone) { throw StdFail_NotDone();}
603  return ( myLambda2V    );
604 }
605
606 /*********************************************************************************/
607
608 Standard_Real LocalAnalysis_SurfaceContinuity::G2CurvatureGap() const 
609 {
610   if (!myIsDone) { throw StdFail_NotDone();}
611   return ( myGap    );
612 }
613
614 /*********************************************************************************/
615
616 Standard_Boolean LocalAnalysis_SurfaceContinuity::IsDone() const
617 { return ( myIsDone );
618 }
619
620 /*********************************************************************************/
621 LocalAnalysis_StatusErrorType  LocalAnalysis_SurfaceContinuity::StatusError() const
622 {
623 return  myErrorStatus;
624 }