0026937: Eliminate NO_CXX_EXCEPTION macro support
[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 { myepsnul=EpsNul;
197   myepsC0= EpsC0;
198   myepsC1= EpsC1;
199   myepsC2= EpsC2;
200   myepsG1= EpsG1;
201   myperce= Percent;
202   mymaxlen= Maxlen;
203   myIsDone = Standard_True;
204 }
205  void LocalAnalysis_SurfaceContinuity::ComputeAnalysis(GeomLProp_SLProps& Surf1,
206                                                        GeomLProp_SLProps& Surf2,
207                                                        const GeomAbs_Shape Order)
208 {  myTypeCont = Order;
209    switch ( Order )
210         { case GeomAbs_C0 : {
211                                 SurfC0(Surf1, Surf2);
212                             }
213                             break;
214           case GeomAbs_C1 : {
215                                SurfC0(Surf1, Surf2);
216                                SurfC1(Surf1, Surf2);}
217                             break;
218           case GeomAbs_C2 : {
219                               SurfC0(Surf1, Surf2);
220                               SurfC1(Surf1, Surf2);
221                               SurfC2(Surf1, Surf2);}
222                             break;
223           case GeomAbs_G1 : {
224                               SurfC0(Surf1, Surf2);
225                               SurfG1(Surf1, Surf2);}
226                             break;
227           case GeomAbs_G2 : {
228                               SurfC0(Surf1, Surf2);
229                               SurfG1(Surf1, Surf2);
230                               SurfG2(Surf1, Surf2);}
231                             break;
232           default         : {}
233         }
234
235 }
236
237 /*********************************************************************************/
238
239 LocalAnalysis_SurfaceContinuity::LocalAnalysis_SurfaceContinuity( const Handle(Geom_Surface)& Surf1, 
240                          const Standard_Real u1, const Standard_Real v1, 
241                          const Handle(Geom_Surface)& Surf2, const Standard_Real u2, 
242                          const Standard_Real v2, const GeomAbs_Shape Ordre, 
243                          const Standard_Real EpsNul,
244                          const Standard_Real EpsC0 ,
245                          const Standard_Real EpsC1 ,
246                          const Standard_Real EpsC2,
247                          const Standard_Real EpsG1,
248                          const Standard_Real Percent,               
249                          const Standard_Real  Maxlen )
250 { myTypeCont = Ordre;
251   myepsnul=EpsNul;
252   myepsC0= EpsC0;
253   myepsC1= EpsC1;
254   myepsC2= EpsC2;
255   myepsG1= EpsG1;
256   myperce= Percent;
257   mymaxlen= Maxlen;
258   myIsDone = Standard_True;
259   switch ( Ordre )
260         { case GeomAbs_C0 : {
261                                GeomLProp_SLProps Surfa1 ( Surf1, u1, v1, 0, myepsnul);
262                                GeomLProp_SLProps Surfa2 ( Surf2, u2, v2, 0, myepsnul);
263                                 SurfC0(Surfa1, Surfa2);
264                             }
265                             break;
266           case GeomAbs_C1 : {
267                                GeomLProp_SLProps Surfa1 ( Surf1, u1, v1, 1, myepsnul); 
268                                GeomLProp_SLProps   Surfa2 ( Surf2, u2, v2, 1, myepsnul);
269                                SurfC0(Surfa1, Surfa2);
270                                SurfC1(Surfa1, Surfa2);}
271                             break;
272           case GeomAbs_C2 : {
273                                GeomLProp_SLProps Surfa1 ( Surf1, u1, v1, 2, myepsnul); 
274                                 GeomLProp_SLProps Surfa2 ( Surf2, u2, v2, 2, myepsnul);
275                               SurfC0(Surfa1, Surfa2);
276                               SurfC1(Surfa1, Surfa2);
277                               SurfC2(Surfa1, Surfa2);}
278                             break;
279           case GeomAbs_G1 : {
280                                GeomLProp_SLProps Surfa1 ( Surf1, u1, v1, 1, myepsnul); 
281                                 GeomLProp_SLProps  Surfa2 ( Surf2, u2, v2, 1, myepsnul);
282                               SurfC0(Surfa1, Surfa2);
283                               SurfG1(Surfa1, Surfa2);}
284                             break;
285           case GeomAbs_G2 : {
286                               GeomLProp_SLProps Surfa1 ( Surf1, u1, v1, 2, myepsnul); 
287                               GeomLProp_SLProps Surfa2 ( Surf2, u2, v2, 2, myepsnul);
288                               SurfC0(Surfa1, Surfa2);
289                               SurfG1(Surfa1, Surfa2);
290                               SurfG2(Surfa1, Surfa2);}
291                             break;
292           default         : {}
293         }
294 }
295
296 /*********************************************************************************/
297
298 LocalAnalysis_SurfaceContinuity::LocalAnalysis_SurfaceContinuity(const Handle(Geom2d_Curve)& curv1, 
299                          const Handle(Geom2d_Curve)& curv2, const Standard_Real U, 
300                          const Handle(Geom_Surface)& Surf1 , 
301                          const Handle(Geom_Surface)& Surf2, 
302                          const GeomAbs_Shape Ordre,
303                          const Standard_Real EpsNul,
304                          const Standard_Real EpsC0 ,
305                          const Standard_Real EpsC1 ,
306                          const Standard_Real EpsC2,
307                          const Standard_Real EpsG1,
308                          const Standard_Real Percent,               
309                          const Standard_Real  Maxlen )
310 { Standard_Real pard1, parf1, pard2, parf2, u1, v1, u2, v2;
311   
312   myTypeCont = Ordre;
313   myepsnul=EpsNul;
314   myepsC0= EpsC0;
315   myepsC1= EpsC1;
316   myepsC2= EpsC2;
317   myepsG1= EpsG1;
318   myperce= Percent;
319   mymaxlen= Maxlen;
320   myIsDone = Standard_True;
321
322   pard1 = curv1->FirstParameter();
323   pard2 = curv2->FirstParameter();
324   parf1 = curv1->LastParameter();
325   parf2 = curv2->LastParameter();
326
327
328   if (!(((U <= parf1) && (U >= pard1)) &&((U <= parf2) && (U >= pard2))) )    myIsDone = Standard_False; 
329     else 
330     { gp_Pnt2d pt1 = curv1->Value(U);
331       gp_Pnt2d pt2 = curv2->Value(U);
332        
333       pt1.Coord(u1, v1);
334       pt2.Coord(u2, v2);
335       switch ( Ordre )
336           { case GeomAbs_C0 : {
337                                  GeomLProp_SLProps Surfa1 ( Surf1, u1, v1, 0, myepsnul);
338                                  GeomLProp_SLProps Surfa2 ( Surf2, u2, v2, 0, myepsnul);
339                                  SurfC0(Surfa1, Surfa2);
340                               }
341                               break;
342             case GeomAbs_C1 : {
343                                  GeomLProp_SLProps Surfa1 ( Surf1, u1, v1, 1, myepsnul);
344                                   GeomLProp_SLProps Surfa2 ( Surf2, u2, v2, 1, myepsnul);
345                                 SurfC0(Surfa1, Surfa2);
346                                 SurfC1(Surfa1, Surfa2);}
347                               break;
348             case GeomAbs_C2 : {
349                                  GeomLProp_SLProps  Surfa1 ( Surf1, u1, v1, 2, myepsnul); 
350                                  GeomLProp_SLProps   Surfa2 ( Surf2, u2, v2, 2, myepsnul);
351                                 SurfC0(Surfa1, Surfa2);
352                                 SurfC1(Surfa1, Surfa2);
353                                 SurfC2(Surfa1, Surfa2);}
354                               break;
355             case GeomAbs_G1 : {
356                                  GeomLProp_SLProps  Surfa1 ( Surf1, u1, v1, 1, myepsnul); 
357                                  GeomLProp_SLProps Surfa2 ( Surf2, u2, v2, 1, myepsnul);
358                                  SurfC0(Surfa1, Surfa2);
359                                  SurfG1(Surfa1, Surfa2);}
360                               break;
361             case GeomAbs_G2 : {
362                                 GeomLProp_SLProps   Surfa1 ( Surf1, u1, v1, 2, myepsnul); 
363                                  GeomLProp_SLProps  Surfa2 ( Surf2, u2, v2, 2, myepsnul);
364                                 SurfC0(Surfa1, Surfa2);
365                                 SurfG1(Surfa1, Surfa2);
366                                 SurfG2(Surfa1, Surfa2);}
367                               break;
368             default         : {}
369           }
370     }
371 }
372
373 /*********************************************************************************/
374
375 Standard_Boolean LocalAnalysis_SurfaceContinuity::IsC0() const 
376 { if (!myIsDone) { throw StdFail_NotDone();}
377   if ( myContC0 <= myepsC0 ) 
378      return Standard_True;
379      else return Standard_False;
380 }
381
382 /*********************************************************************************/
383
384 Standard_Boolean LocalAnalysis_SurfaceContinuity::IsC1() const 
385 { if (!myIsDone) { throw StdFail_NotDone();}
386   if ( IsC0 () && (myContC1U <= myepsC1) && (myContC1V <= myepsC1))
387    return Standard_True;
388   else return Standard_False;
389 }
390
391 /*********************************************************************************/
392
393 Standard_Boolean LocalAnalysis_SurfaceContinuity::IsC2() const 
394 { Standard_Real eps1u, eps1v, eps2u, eps2v;
395
396   if (!myIsDone) { throw StdFail_NotDone();}
397   if ( IsC1())
398      { eps1u = 0.5*myepsC1*myepsC1*myLambda1U;
399        eps1v = 0.5*myepsC1*myepsC1*myLambda1V;
400        eps2u = 0.5*myepsC2*myepsC2*myLambda2U;
401        eps2v = 0.5*myepsC2*myepsC2*myLambda2V;
402        if ((myContC2U < myepsC2) && (myContC2V < myepsC2))
403           { if (Abs(myLambda1U*myLambda1U-myLambda2U) <= (eps1u*eps1u+eps2u))
404                if (Abs(myLambda1V*myLambda1V-myLambda2V) <= (eps1v*eps1v+eps2v))
405                   return Standard_True;
406                else return  Standard_False;
407             else return  Standard_False;
408           }
409           else return  Standard_False;        
410      }
411      else return Standard_False;
412     
413 }
414
415 /*********************************************************************************/
416
417 Standard_Boolean LocalAnalysis_SurfaceContinuity::IsG1() const 
418 {
419   if (!myIsDone) { throw StdFail_NotDone();} 
420   if ( IsC0 () &&( myContG1 <= myepsG1))
421        return Standard_True;
422       else return Standard_False;
423 }
424
425 /*********************************************************************************/
426
427 Standard_Boolean LocalAnalysis_SurfaceContinuity::IsG2()const 
428 { Standard_Real EPSNL;
429   Standard_Integer itype;
430  
431   if (!myIsDone) { throw StdFail_NotDone();} 
432   itype =0;
433   EPSNL= 8*myepsC0/(mymaxlen*mymaxlen);
434   if ( IsG1())
435      { if ( ( Abs(myETA)< EPSNL) && ( Abs(myZETA)< EPSNL))
436           return Standard_True;
437         if ( ( Abs(myZETA1)< EPSNL) && ( Abs(myZETA2)< EPSNL))
438            itype =1;
439            else if ( ( Abs(myETA1)< EPSNL) && ( Abs(myETA2)< EPSNL))
440                    itype =1;
441                    else if ((Abs(Abs(myZETA)-Abs(myETA))) < EPSNL)
442                            itype =1;
443                            else if ((myETA1<myZETA1)&&(myETA2<myZETA2))
444                                    itype =1; 
445                                    else if ((myETA1>myZETA1)&&(myETA2>myZETA2))
446                                            itype =1; 
447        if (itype == 1)
448           { 
449
450             if (( myETA >= (2*myZETA))&&(myGap<=(myperce*(myETA-myZETA)))) return Standard_True;
451             if (( myZETA>= myETA) && ( myGap<= (myperce*myZETA))) return Standard_True;
452             if (( myZETA<= myETA) && ( myETA <= (2*myZETA)) && (myGap <= (myperce * myETA))) 
453                return Standard_True;
454                else  return Standard_False;
455                     
456           }
457           else  return Standard_False;
458      }
459      else return Standard_False;
460
461 }
462
463   
464 /*********************************************************************************/
465
466 GeomAbs_Shape  LocalAnalysis_SurfaceContinuity::ContinuityStatus() const 
467 {
468  if (!myIsDone) { throw StdFail_NotDone();}
469  return (myTypeCont);
470 }
471
472 /*********************************************************************************/
473
474 Standard_Real LocalAnalysis_SurfaceContinuity::C0Value() const 
475
476   if (!myIsDone) { throw StdFail_NotDone();}
477   return ( myContC0    );
478 }
479
480 /*********************************************************************************/
481
482 Standard_Real LocalAnalysis_SurfaceContinuity::C1UAngle() const 
483 {
484   if (!myIsDone) { throw StdFail_NotDone();}
485   return ( myContC1U    );
486 }
487
488 /*********************************************************************************/
489
490 Standard_Real LocalAnalysis_SurfaceContinuity::C1VAngle() const 
491 {
492   if (!myIsDone) { throw StdFail_NotDone();}
493   return ( myContC1V    );
494 }
495
496 /*********************************************************************************/
497
498 Standard_Real LocalAnalysis_SurfaceContinuity::C2UAngle() const 
499 {
500   if (!myIsDone) { throw StdFail_NotDone();}
501   return ( myContC2U    );
502 }
503
504 /*********************************************************************************/
505
506 Standard_Real LocalAnalysis_SurfaceContinuity::C2VAngle() const 
507 {
508   if (!myIsDone) { throw StdFail_NotDone();}
509   return ( myContC2V    );
510 }
511
512 /*********************************************************************************/
513
514 Standard_Real LocalAnalysis_SurfaceContinuity::G1Angle() const 
515 {
516   if (!myIsDone) { throw StdFail_NotDone();}
517   return ( myContG1    );
518 }
519
520 /*********************************************************************************/
521
522 Standard_Real LocalAnalysis_SurfaceContinuity::C1URatio() const 
523 {
524   if (!myIsDone) { throw StdFail_NotDone();}
525   return ( myLambda1U    );
526 }
527
528 /*********************************************************************************/
529
530 Standard_Real LocalAnalysis_SurfaceContinuity::C2URatio() const 
531 {
532   if (!myIsDone) { throw StdFail_NotDone();}
533   return ( myLambda2U    );
534 }
535
536 /*********************************************************************************/
537
538 Standard_Real LocalAnalysis_SurfaceContinuity::C1VRatio() const 
539 {
540   if (!myIsDone) { throw StdFail_NotDone();}
541   return ( myLambda1V    );
542 }
543
544 /*********************************************************************************/
545
546 Standard_Real LocalAnalysis_SurfaceContinuity::C2VRatio() const 
547
548   if (!myIsDone) { throw StdFail_NotDone();}
549  return ( myLambda2V    );
550 }
551
552 /*********************************************************************************/
553
554 Standard_Real LocalAnalysis_SurfaceContinuity::G2CurvatureGap() const 
555 {
556   if (!myIsDone) { throw StdFail_NotDone();}
557   return ( myGap    );
558 }
559
560 /*********************************************************************************/
561
562 Standard_Boolean LocalAnalysis_SurfaceContinuity::IsDone() const
563 { return ( myIsDone );
564 }
565
566 /*********************************************************************************/
567 LocalAnalysis_StatusErrorType  LocalAnalysis_SurfaceContinuity::StatusError() const
568 {
569 return  myErrorStatus;
570 }