0031035: Coding - uninitialized class fields reported by Visual Studio Code Analysis
[occt.git] / src / LocalAnalysis / LocalAnalysis_CurveContinuity.cxx
1 // Copyright (c) 1996-1999 Matra Datavision
2 // Copyright (c) 1999-2014 OPEN CASCADE SAS
3 //
4 // This file is part of Open CASCADE Technology software library.
5 //
6 // This library is free software; you can redistribute it and/or modify it under
7 // the terms of the GNU Lesser General Public License version 2.1 as published
8 // by the Free Software Foundation, with special exception defined in the file
9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10 // distribution for complete text of the license and disclaimer of any warranty.
11 //
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
14
15
16 #include <Geom_Curve.hxx>
17 #include <GeomLProp_CLProps.hxx>
18 #include <gp.hxx>
19 #include <gp_Dir.hxx>
20 #include <gp_Pnt.hxx>
21 #include <gp_Vec.hxx>
22 #include <LocalAnalysis_CurveContinuity.hxx>
23 #include <LocalAnalysis_StatusErrorType.hxx>
24 #include <StdFail_NotDone.hxx>
25
26 /***********************************************************************/
27 void LocalAnalysis_CurveContinuity::CurvC0( GeomLProp_CLProps& Curv1, 
28                                       GeomLProp_CLProps& Curv2)
29 { myContC0= (Curv1.Value()).Distance(Curv2.Value());  
30 }
31
32 /****************************************************************************/
33 void LocalAnalysis_CurveContinuity::CurvC1(  GeomLProp_CLProps& Curv1, 
34                                                 GeomLProp_CLProps& Curv2)
35 { gp_Vec V1, V2;
36   Standard_Real ang; 
37   V1 = Curv1.D1();
38   V2 = Curv2.D1();
39   Standard_Real norm1,norm2; 
40   norm1 = V1.Magnitude();
41   norm2 = V2.Magnitude();
42  
43   if ((norm1>myepsnul)&&(norm2>myepsnul))
44    { if ( norm1 >= norm2 ) 
45        { myLambda1 = norm2 / norm1;}   
46        else { myLambda1  = norm1 / norm2;} 
47        ang= V1.Angle(V2);
48        if (ang>M_PI/2)   myContC1=M_PI-ang;
49        else  myContC1=ang;
50    }
51    else  {myIsDone= Standard_False;
52           myErrorStatus=LocalAnalysis_NullFirstDerivative;} 
53 }
54
55 /*********************************************************************************/
56
57 void LocalAnalysis_CurveContinuity::CurvC2(GeomLProp_CLProps& Curv1,  
58                                      GeomLProp_CLProps& Curv2)
59 { gp_Vec V1, V2, V12, V22;
60 //  gp_Dir D1, D2;
61   Standard_Real norm1, norm2, norm12, norm22,ang;
62   V1 = Curv1.D1();
63   V2 = Curv2.D1();
64   V12 = Curv1.D2();
65   V22 = Curv2.D2();
66   norm1 = V1.Magnitude();
67   norm2 = V2.Magnitude();
68   norm12 = V12.Magnitude();
69   norm22 = V22.Magnitude();
70
71   if ((norm1>myepsnul)&&(norm2>myepsnul))
72        {if((norm12>myepsnul)&&(norm22>myepsnul)) 
73             {if (norm1 >= norm2 ) 
74                 { myLambda1 = norm2 / norm1; 
75                   myLambda2 = norm22 / norm12;}
76        
77             else {myLambda1  = norm1 / norm2; 
78                   myLambda2 = norm12 / norm22;}
79             ang=V12.Angle(V22);
80             if (ang>M_PI/2)  myContC2=M_PI-ang;
81             else myContC2=ang; }
82     
83         else{myIsDone= Standard_False ;
84              myErrorStatus=LocalAnalysis_NullSecondDerivative;} }  
85      
86   else  {myIsDone= Standard_False ;
87          myErrorStatus=LocalAnalysis_NullFirstDerivative;}
88 }
89
90 /*********************************************************************************/
91
92 void LocalAnalysis_CurveContinuity::CurvG1 (   GeomLProp_CLProps& Curv1, 
93                                         GeomLProp_CLProps & Curv2) 
94 { gp_Dir Tang1,Tang2;
95   Standard_Real ang;
96    if (Curv1.IsTangentDefined() && Curv2.IsTangentDefined ()) 
97      {   Curv1.Tangent(Tang1);
98          Curv2.Tangent(Tang2);
99          ang=Tang1.Angle(Tang2);
100          if (ang>M_PI/2)  myContG1=M_PI-ang;
101          else myContG1=ang;
102      } 
103    else {myIsDone= Standard_False ;
104          myErrorStatus=LocalAnalysis_TangentNotDefined;}  
105 }
106
107 /*********************************************************************************/
108
109 void LocalAnalysis_CurveContinuity::CurvG2( GeomLProp_CLProps& Curv1, 
110                                       GeomLProp_CLProps & Curv2 ) 
111 { gp_Vec V1, V2;
112   gp_Dir D1, D2;
113   Standard_Real ang;
114   Standard_Real epscrb= 8*myepsC0/(myMaxLon*myMaxLon);  
115  
116   if (Curv1.IsTangentDefined() && Curv2.IsTangentDefined())
117     {  myCourbC1= Curv1.Curvature();
118        myCourbC2 = Curv2.Curvature();
119        if( (Abs(myCourbC1)>epscrb)&& (Abs(myCourbC2)>epscrb)) 
120           { V1 = Curv1.D1();
121             V2 = Curv2.D1();
122             Curv1.Normal(D1);
123             Curv2.Normal(D2);
124             ang =D1.Angle(D2);
125            if (ang>M_PI/2)  myContG2=M_PI-ang;
126            else myContG2=ang;
127             myCourbC1= Curv1.Curvature();
128             myCourbC2 = Curv2.Curvature();
129             myG2Variation= Abs(myCourbC1-myCourbC2) /  sqrt (myCourbC1* myCourbC2);}
130        else {myIsDone = Standard_False ; 
131              myErrorStatus=LocalAnalysis_NormalNotDefined; }
132      }
133     else  { myIsDone = Standard_False ;
134            myErrorStatus=LocalAnalysis_TangentNotDefined;}
135 }
136  
137 /*********************************************************************************/
138
139 LocalAnalysis_CurveContinuity::LocalAnalysis_CurveContinuity(const Handle(Geom_Curve)& Curv1, 
140  const Standard_Real u1, const Handle(Geom_Curve)& Curv2, const Standard_Real u2, 
141  const GeomAbs_Shape Order, 
142  const Standard_Real Epsnul,
143  const Standard_Real EpsC0,
144  const Standard_Real EpsC1,
145  const Standard_Real EpsC2,
146  const Standard_Real EpsG1,
147  const Standard_Real EpsG2,
148  const Standard_Real Percent,
149  const Standard_Real Maxlen )
150 : myContC0(0.0),
151   myContC1(0.0),
152   myContC2(0.0),
153   myContG1(0.0),
154   myContG2(0.0),
155   myCourbC1(0.0),
156   myCourbC2(0.0),
157   myG2Variation(0.0),
158   myLambda1(0.0),
159   myLambda2(0.0)
160 { myTypeCont = Order;
161   myepsnul= Epsnul; 
162   myMaxLon=Maxlen;
163   myepsC0= EpsC0;
164   myepsC1= EpsC1;
165   myepsC2= EpsC2;
166   myepsG1= EpsG1;
167   myepsG2= EpsG2;
168   myperce=Percent;
169
170   myIsDone = Standard_True;
171  
172   switch ( Order)
173         { case GeomAbs_C0 : { //TypeCont=GeomAbs_C0;
174                                GeomLProp_CLProps Curve1 ( Curv1, u1, 0, myepsnul); 
175                                GeomLProp_CLProps Curve2 ( Curv2, u2, 0, myepsnul);           
176                                CurvC0(Curve1, Curve2);}
177                             break;
178           case GeomAbs_C1 : { //TypeCont=GeomAbs_C1;
179                             
180                                GeomLProp_CLProps  Curve1 ( Curv1, u1, 1, myepsnul); 
181                                GeomLProp_CLProps  Curve2 ( Curv2, u2, 1, myepsnul );
182                                CurvC0(Curve1, Curve2);
183                                CurvC1(Curve1, Curve2);}
184                             break;
185           case GeomAbs_C2 : { //TypeCont=GeomAbs_C2;
186                         
187                               GeomLProp_CLProps  Curve1 ( Curv1, u1, 2, myepsnul); 
188                               GeomLProp_CLProps Curve2 ( Curv2, u2, 2, myepsnul);
189                               CurvC0(Curve1, Curve2);
190                               CurvC1(Curve1, Curve2);
191                               CurvC2(Curve1, Curve2);}
192                             break;              
193           case GeomAbs_G1 : { //TypeCont=GeomAbs_G1; 
194                                GeomLProp_CLProps Curve1 ( Curv1, u1, 1, myepsnul); 
195                                 GeomLProp_CLProps Curve2 ( Curv2, u2, 1, myepsnul);
196                                CurvC0(Curve1, Curve2);
197                                CurvG1(Curve1, Curve2);}
198                             break;
199           case GeomAbs_G2 : { //TypeCont=GeomAbs_G2; 
200                                GeomLProp_CLProps  Curve1 ( Curv1, u1, 2, myepsnul); 
201                                GeomLProp_CLProps Curve2 ( Curv2, u2, 2, myepsnul);
202                                CurvC0(Curve1, Curve2);
203                                CurvG1(Curve1, Curve2);
204                                CurvG2(Curve1, Curve2);}
205                             break;
206           default         : {}
207         }
208 }
209
210 /*********************************************************************************/
211
212 Standard_Boolean LocalAnalysis_CurveContinuity::IsC0() const 
213
214   if (!myIsDone) { throw StdFail_NotDone();}
215   if (myContC0 <= myepsC0 )
216      return Standard_True;
217      else return Standard_False;
218 }
219
220 /*********************************************************************************/
221
222 Standard_Boolean LocalAnalysis_CurveContinuity::IsC1() const  
223 {
224   if (!myIsDone) { throw StdFail_NotDone();}
225   if ( IsC0() && ( (myContC1 <= myepsC1)||(Abs(myContC1-M_PI)<=myepsC1)))
226      return Standard_True;
227      else return Standard_False;        
228 }
229
230 /*********************************************************************************/
231
232 Standard_Boolean LocalAnalysis_CurveContinuity::IsC2() const  
233 { Standard_Real epsil1, epsil2;
234
235   if (!myIsDone) { throw StdFail_NotDone();}
236   if ( IsC1())
237     { if ((myContC2 <= myepsC2)||(Abs(myContC2-M_PI)<=myepsC2))
238       { epsil1 = 0.5*myepsC1*myepsC1*myLambda1;
239         epsil2 = 0.5*myepsC2*myepsC2*myLambda2;
240        if ( (Abs(myLambda1*myLambda1-myLambda2)) <= (epsil1*epsil1+epsil2))
241         return Standard_True;}
242       else  return Standard_False;
243     }
244   return Standard_False;        
245
246 }
247
248
249 /*********************************************************************************/
250
251 Standard_Boolean LocalAnalysis_CurveContinuity::IsG1() const  
252 {
253   if (!myIsDone) { throw StdFail_NotDone();}
254  if ( IsC0() && (( myContG1 <= myepsG1||(Abs(myContG1-M_PI)<=myepsG1))))
255      return Standard_True;
256      else return Standard_False;        
257 }
258
259 /*********************************************************************************/
260
261 Standard_Boolean LocalAnalysis_CurveContinuity::IsG2()const 
262 { Standard_Real CRBINF, CRBNUL;
263   Standard_Integer IETA1, IETA2;
264         // etat des coubures IETA. -> 0 Crbure nulle 
265         //                         -> 1 Crbure finie
266         //                         -> 2 Crbure infinie
267
268   if (!myIsDone) { throw StdFail_NotDone();}
269   if ( IsG1 ())
270      { CRBINF = 1/myepsC0;
271        CRBNUL = 8*myepsC0/(myMaxLon*myMaxLon);
272
273        if (myCourbC1 > CRBINF) IETA1=2;
274           else if (myCourbC1 < CRBNUL) IETA1=0; 
275                   else IETA1=1;
276        if (myCourbC2 > CRBINF) IETA2=2;
277           else if (myCourbC2 < CRBNUL) IETA2=0; 
278                   else IETA2=1;
279        if (IETA1 == IETA2)
280           { if (IETA1 == 1)
281                { Standard_Real eps= RealPart( (myContG2+myepsG2)/M_PI) * M_PI;
282                  if (Abs( eps - myepsG2) < myepsG2)
283                     {if (myG2Variation < myperce )
284                        return Standard_True;
285                     else return Standard_False;}
286                  else return Standard_False;
287                }
288                else return  Standard_True;
289           }     
290           else return  Standard_False;    
291      }
292      else return  Standard_False; 
293 }
294
295 /*********************************************************************************/
296
297 Standard_Real LocalAnalysis_CurveContinuity::C0Value() const 
298
299   if (!myIsDone) {throw StdFail_NotDone();}
300   return ( myContC0 );
301 }
302
303 /*********************************************************************************/
304
305 Standard_Real LocalAnalysis_CurveContinuity::C1Angle() const 
306 {
307   if (!myIsDone) { throw StdFail_NotDone();}
308   return ( myContC1 );
309 }
310
311 /*********************************************************************************/
312
313 Standard_Real LocalAnalysis_CurveContinuity::C2Angle() const 
314 {
315   if (!myIsDone) { throw StdFail_NotDone();}
316   return ( myContC2 );
317 }
318
319 /*********************************************************************************/
320
321 Standard_Real LocalAnalysis_CurveContinuity::G1Angle() const 
322 {
323   if (!myIsDone) { throw StdFail_NotDone();}
324   return ( myContG1    );
325 }
326 /*********************************************************************************/
327
328 Standard_Real LocalAnalysis_CurveContinuity::G2Angle() const 
329 {
330   if (!myIsDone) { throw StdFail_NotDone();}
331   return ( myContG2    );
332 }
333
334
335
336 /*********************************************************************************/
337
338 Standard_Real LocalAnalysis_CurveContinuity::C1Ratio() const 
339 {
340   if (!myIsDone) {throw StdFail_NotDone();}
341   return ( myLambda1    );
342 }
343
344 /*********************************************************************************/
345
346 Standard_Real LocalAnalysis_CurveContinuity::C2Ratio() const 
347 {
348   if (!myIsDone) {throw StdFail_NotDone();}
349   return ( myLambda2    );
350 }
351
352 /********************************************************************************/
353 Standard_Real LocalAnalysis_CurveContinuity::G2CurvatureVariation() const 
354 {
355   if (!myIsDone) {throw StdFail_NotDone();}
356   return ( myG2Variation);
357 }
358
359
360 /********************************************************************************/
361
362 Standard_Boolean LocalAnalysis_CurveContinuity::IsDone() const
363 { return ( myIsDone );
364 }
365
366 /*********************************************************************************/
367
368 LocalAnalysis_StatusErrorType  LocalAnalysis_CurveContinuity::StatusError() const
369 {
370 return  myErrorStatus;
371 }
372 /*************************************************************************/
373 GeomAbs_Shape  LocalAnalysis_CurveContinuity::ContinuityStatus() const 
374 {
375  if (!myIsDone) { throw StdFail_NotDone();}
376  return (myTypeCont);
377 }
378 /*********************************************************************************/
379
380
381
382
383
384
385
386
387
388