0031035: Coding - uninitialized class fields reported by Visual Studio Code Analysis
[occt.git] / src / Law / Law_BSpFunc.cxx
1 // Created on: 1995-11-16
2 // Created by: Laurent BOURESCHE
3 // Copyright (c) 1995-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 // pmn -> 17/01/1996 added : Continuity, (Nb)Intervals, D2, Trim
18
19 #include <BSplCLib.hxx>
20 #include <Law_BSpFunc.hxx>
21 #include <Law_BSpline.hxx>
22 #include <Law_BSplineKnotSplitting.hxx>
23 #include <Law_Function.hxx>
24 #include <Precision.hxx>
25 #include <Standard_OutOfRange.hxx>
26 #include <Standard_Type.hxx>
27 #include <TColStd_Array1OfInteger.hxx>
28
29 IMPLEMENT_STANDARD_RTTIEXT(Law_BSpFunc,Law_Function)
30
31 #define PosTol Precision::PConfusion()/2
32
33 //=======================================================================
34 //function : Law_BSpFunc
35 //purpose  : 
36 //=======================================================================
37
38 Law_BSpFunc::Law_BSpFunc()
39 : first(0.0),
40   last(0.0)
41 {
42 }
43
44 //=======================================================================
45 //function : Law_BSpFunc
46 //purpose  : 
47 //=======================================================================
48 Law_BSpFunc::Law_BSpFunc(const Handle(Law_BSpline)& C,
49                          const Standard_Real First,
50                          const Standard_Real Last)
51                          :curv(C), first(First), last(Last)
52 {  
53 }
54
55 //=======================================================================
56 //function : Continuity
57 //purpose  : 
58 //=======================================================================
59 GeomAbs_Shape Law_BSpFunc::Continuity() const 
60 {
61   return curv->Continuity();
62 }
63 //=======================================================================
64 //function : NbIntervals
65 //purpose  : Inspirer de GeomAdaptor_Curve
66 //=======================================================================
67
68 Standard_Integer Law_BSpFunc::NbIntervals(const GeomAbs_Shape S) const
69 {
70   Standard_Integer myNbIntervals = 1;
71   if ( S > Continuity()) {
72     Standard_Integer Cont;
73     switch ( S) {
74     case GeomAbs_G1:
75     case GeomAbs_G2:
76       throw Standard_DomainError("Law_BSpFunc::NbIntervals");
77       break;
78     case GeomAbs_C0:
79       myNbIntervals = 1;
80       break;
81     case GeomAbs_C1:
82     case GeomAbs_C2:
83     case GeomAbs_C3: 
84     case GeomAbs_CN: 
85       {
86         if      ( S == GeomAbs_C1) Cont = 1;
87         else if ( S == GeomAbs_C2) Cont = 2;
88         else if ( S == GeomAbs_C3) Cont = 3;
89         else                       Cont = curv->Degree();
90         Law_BSplineKnotSplitting Convector(curv, Cont);
91         Standard_Integer NbInt = Convector.NbSplits()-1;
92         TColStd_Array1OfInteger Inter(1,NbInt+1);
93         Convector.Splitting( Inter);
94           
95         Standard_Integer Nb = curv->NbKnots();
96         Standard_Integer Index1 = 0;
97         Standard_Integer Index2 = 0;
98         Standard_Real newFirst, newLast;
99         TColStd_Array1OfReal    TK(1,Nb);
100         TColStd_Array1OfInteger TM(1,Nb);
101         curv->Knots(TK);
102         curv->Multiplicities(TM);
103         BSplCLib::LocateParameter(curv->Degree(),TK,TM,first,
104                                   curv->IsPeriodic(),
105                                   1,Nb,Index1,newFirst);
106         BSplCLib::LocateParameter(curv->Degree(),TK,TM,last,
107                                   curv->IsPeriodic(),
108                                   1,Nb,Index2,newLast);
109         if ( Abs(newFirst-TK(Index1+1))<Precision::PConfusion()) 
110           Index1++;
111         if ( newLast-TK(Index2)>Precision::PConfusion()) 
112           Index2++;
113           
114         myNbIntervals = 1;
115         for ( Standard_Integer i=1; i<=NbInt; i++)
116           if (Inter(i)>Index1 && Inter(i)<Index2) myNbIntervals++;
117       }
118       break;
119     }
120   }
121
122   return myNbIntervals;
123 }
124
125 //=======================================================================
126 //function : Intervals
127 //purpose  : Inspirer de GeomAdaptor_Curve
128 //=======================================================================
129
130 void Law_BSpFunc::Intervals(TColStd_Array1OfReal& T,
131                             const GeomAbs_Shape S   ) const 
132 {
133   Standard_Integer myNbIntervals = 1;
134   if ( S > Continuity()) {
135     Standard_Integer Cont;
136     switch ( S) {
137     case GeomAbs_G1:
138     case GeomAbs_G2:
139       throw Standard_DomainError("Law_BSpFunc_Curve::Intervals");
140       break;
141     case GeomAbs_C0:
142       myNbIntervals = 1;
143       break;
144     case GeomAbs_C1:
145     case GeomAbs_C2:
146     case GeomAbs_C3: 
147     case GeomAbs_CN: 
148       {
149         if      ( S == GeomAbs_C1) Cont = 1;
150         else if ( S == GeomAbs_C2) Cont = 2;
151         else if ( S == GeomAbs_C3) Cont = 3;
152         else                       Cont = curv->Degree();
153         Law_BSplineKnotSplitting Convector(curv, Cont);
154         Standard_Integer NbInt = Convector.NbSplits()-1;
155         TColStd_Array1OfInteger Inter(1,NbInt+1);
156         Convector.Splitting( Inter);
157           
158         Standard_Integer Nb = curv->NbKnots();
159         Standard_Integer Index1 = 0;
160         Standard_Integer Index2 = 0;
161         Standard_Real newFirst, newLast;
162         TColStd_Array1OfReal    TK(1,Nb);
163         TColStd_Array1OfInteger TM(1,Nb);
164         curv->Knots(TK);
165         curv->Multiplicities(TM);
166         BSplCLib::LocateParameter(curv->Degree(),TK,TM,first,
167                                   curv->IsPeriodic(),
168                                   1,Nb,Index1,newFirst);
169         BSplCLib::LocateParameter(curv->Degree(),TK,TM,last,
170                                   curv->IsPeriodic(),
171                                   1,Nb,Index2,newLast);
172         if ( Abs(newFirst-TK(Index1+1))<Precision::PConfusion()) 
173           Index1++;
174         if ( newLast-TK(Index2)>Precision::PConfusion()) 
175           Index2++;
176           
177         Inter( 1) = Index1;
178         myNbIntervals = 1;
179         for ( Standard_Integer i=1; i<=NbInt; i++) {
180           if (Inter(i) > Index1 && Inter(i)<Index2 ) {
181             myNbIntervals++;
182             Inter(myNbIntervals) = Inter(i);
183           }
184         }
185         Inter(myNbIntervals+1) = Index2;
186           
187         for (Standard_Integer I=1;I<=myNbIntervals+1;I++) {
188           T(I) = TK(Inter(I));
189         }
190       }
191       break;
192     }
193   }
194   T( T.Lower() ) = first;
195   T( T.Lower() + myNbIntervals ) = last;
196 }
197
198
199 //=======================================================================
200 //function : Value
201 //purpose  : 
202 //=======================================================================
203
204 Standard_Real Law_BSpFunc::Value(const Standard_Real X)
205 {
206   if ((X==first) || (X==last)) {
207     Standard_Integer Ideb = 0, Ifin = 0;
208     if (X==first) {
209       curv->LocateU(first, PosTol, Ideb, Ifin);
210       if (Ideb<1) Ideb=1;
211       if (Ideb>=Ifin) Ifin = Ideb+1;
212       }
213     if (X==last) {
214       curv->LocateU(last, PosTol, Ideb, Ifin);
215       if (Ifin>curv->NbKnots()) Ifin = curv->NbKnots();
216       if (Ideb>=Ifin) Ideb = Ifin-1;
217       }
218     return curv->LocalValue(X, Ideb, Ifin);
219   }
220   else {
221     return curv->Value(X);
222    }
223 }
224
225
226 //=======================================================================
227 //function : D1
228 //purpose  : 
229 //=======================================================================
230
231 void Law_BSpFunc::D1(const Standard_Real X, 
232                      Standard_Real& F, 
233                      Standard_Real& D)
234 {
235   if ((X==first) || (X==last)) {
236     Standard_Integer Ideb = 0, Ifin = 0;
237     if (X==first) {
238       curv->LocateU(first, PosTol, Ideb, Ifin);
239       if (Ideb<1) Ideb=1;
240       if (Ideb>=Ifin) Ifin = Ideb+1;
241       }
242     if (X==last) {
243       curv->LocateU(last, PosTol, Ideb, Ifin);
244       if (Ifin>curv->NbKnots()) Ifin = curv->NbKnots();
245       if (Ideb>=Ifin) Ideb = Ifin-1;
246       }
247     curv->LocalD1(X, Ideb, Ifin, F, D);
248   }
249   else {
250     curv->D1(X, F, D);
251    }
252 }
253
254 //=======================================================================
255 //function : D2
256 //purpose  : 
257 //=======================================================================
258
259 void Law_BSpFunc::D2(const Standard_Real X, 
260                      Standard_Real& F, 
261                      Standard_Real& D,
262                      Standard_Real& D2)
263 {
264   if ((X==first) || (X==last)) {
265     Standard_Integer Ideb = 0, Ifin = 0;
266     if (X==first) {
267       curv->LocateU(first, PosTol, Ideb, Ifin);
268       if (Ideb<1) Ideb=1;
269       if (Ideb>=Ifin) Ifin = Ideb+1;
270       }
271     if (X==last) {
272       curv->LocateU(last, PosTol, Ideb, Ifin);
273       if (Ifin>curv->NbKnots()) Ifin = curv->NbKnots();
274       if (Ideb>=Ifin) Ideb = Ifin-1;
275       }
276     curv->LocalD2(X, Ideb, Ifin, F, D, D2);
277   }
278   else {
279     curv->D2(X, F, D, D2);
280    }
281
282 }
283
284 //=======================================================================
285 //function : Trim
286 //purpose  : 
287 //=======================================================================
288
289 Handle(Law_Function) Law_BSpFunc::Trim(const Standard_Real PFirst, 
290                                        const Standard_Real PLast, 
291 //                                     const Standard_Real Tol) const 
292                                        const Standard_Real ) const 
293 {
294   Handle(Law_BSpFunc) l = new (Law_BSpFunc)(curv, PFirst, PLast);
295   return l;
296 }
297
298 //=======================================================================
299 //function : Bounds
300 //purpose  : 
301 //=======================================================================
302
303 void Law_BSpFunc::Bounds(Standard_Real& PFirst, Standard_Real& PLast)
304 {
305   PFirst = first;
306   PLast  = last;
307 }
308
309
310 //=======================================================================
311 //function : Curve
312 //purpose  : 
313 //=======================================================================
314
315 Handle(Law_BSpline) Law_BSpFunc::Curve() const 
316 {
317   return curv;
318 }
319
320
321 //=======================================================================
322 //function : SetCurve
323 //purpose  : 
324 //=======================================================================
325
326 void Law_BSpFunc::SetCurve(const Handle(Law_BSpline)& C)
327 {
328   curv = C;
329   first = C->FirstParameter();
330   last  = C->LastParameter();
331 }