b311480e |
1 | // Created on: 1993-03-09 |
2 | // Created by: JCV |
3 | // Copyright (c) 1993-1999 Matra Datavision |
973c2be1 |
4 | // Copyright (c) 1999-2014 OPEN CASCADE SAS |
b311480e |
5 | // |
973c2be1 |
6 | // This file is part of Open CASCADE Technology software library. |
b311480e |
7 | // |
d5f74e42 |
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 |
973c2be1 |
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. |
b311480e |
13 | // |
973c2be1 |
14 | // Alternatively, this file may be used under the terms of Open CASCADE |
15 | // commercial license or contractual agreement. |
7fd59977 |
16 | |
7fd59977 |
17 | // Passage en classe persistante - 23/01/91 |
18 | // Modif suite a la deuxieme revue de projet toolkit Geometry -23/01/91 |
19 | // Infos : |
20 | // Actuellement pour les champs de la courbe le tableau des poles est |
21 | // declare de 1 a NbPoles et le tableau des poids est declare de 1 a NbPoles |
22 | |
23 | // Revised RLE Aug 19 1993 |
24 | // Suppressed Swaps, added Init, removed typedefs |
25 | |
26 | #define No_Standard_OutOfRange |
27 | #define No_Standard_DimensionError |
28 | |
42cf5bc1 |
29 | |
42cf5bc1 |
30 | #include <Geom_BezierCurve.hxx> |
31 | #include <Geom_Geometry.hxx> |
7fd59977 |
32 | #include <gp.hxx> |
42cf5bc1 |
33 | #include <gp_Pnt.hxx> |
34 | #include <gp_Trsf.hxx> |
35 | #include <gp_Vec.hxx> |
7fd59977 |
36 | #include <gp_XYZ.hxx> |
42cf5bc1 |
37 | #include <PLib.hxx> |
38 | #include <Precision.hxx> |
7fd59977 |
39 | #include <Standard_ConstructionError.hxx> |
40 | #include <Standard_DimensionError.hxx> |
41 | #include <Standard_OutOfRange.hxx> |
42 | #include <Standard_RangeError.hxx> |
42cf5bc1 |
43 | #include <Standard_Type.hxx> |
7fd59977 |
44 | #include <TColStd_Array1OfInteger.hxx> |
7fd59977 |
45 | |
92efcf78 |
46 | IMPLEMENT_STANDARD_RTTIEXT(Geom_BezierCurve,Geom_BoundedCurve) |
47 | |
7fd59977 |
48 | //======================================================================= |
49 | //function : Rational |
50 | //purpose : check rationality of an array of weights |
51 | //======================================================================= |
7fd59977 |
52 | static Standard_Boolean Rational(const TColStd_Array1OfReal& W) |
53 | { |
54 | Standard_Integer i, n = W.Length(); |
55 | Standard_Boolean rat = Standard_False; |
56 | for (i = 1; i < n; i++) { |
57 | rat = Abs(W(i) - W(i+1)) > gp::Resolution(); |
58 | if (rat) break; |
59 | } |
60 | return rat; |
61 | } |
62 | |
63 | //======================================================================= |
64 | //function : Geom_BezierCurve |
65 | //purpose : |
66 | //======================================================================= |
67 | |
c8b5b3d8 |
68 | Geom_BezierCurve::Geom_BezierCurve(const TColgp_Array1OfPnt& Poles) |
7fd59977 |
69 | { |
70 | Standard_Integer nbpoles = Poles.Length(); |
71 | if(nbpoles < 2 || nbpoles > (Geom_BezierCurve::MaxDegree() + 1)) |
9775fa61 |
72 | throw Standard_ConstructionError(); |
7fd59977 |
73 | // copy the poles |
74 | Handle(TColgp_HArray1OfPnt) npoles = |
75 | new TColgp_HArray1OfPnt(1,nbpoles); |
76 | |
77 | npoles->ChangeArray1() = Poles; |
78 | |
79 | // Init non rational |
80 | Init(npoles, |
81 | Handle(TColStd_HArray1OfReal)()); |
82 | } |
83 | |
84 | //======================================================================= |
85 | //function : Geom_BezierCurve |
86 | //purpose : |
87 | //======================================================================= |
88 | |
89 | Geom_BezierCurve::Geom_BezierCurve(const TColgp_Array1OfPnt& Poles, |
c8b5b3d8 |
90 | const TColStd_Array1OfReal& Weights) |
7fd59977 |
91 | { |
92 | // copy the poles |
93 | Standard_Integer nbpoles = Poles.Length(); |
94 | if(nbpoles < 2 || nbpoles > (Geom_BezierCurve::MaxDegree() + 1)) |
9775fa61 |
95 | throw Standard_ConstructionError(); |
7fd59977 |
96 | |
97 | Handle(TColgp_HArray1OfPnt) npoles = |
98 | new TColgp_HArray1OfPnt(1,nbpoles); |
99 | |
100 | npoles->ChangeArray1() = Poles; |
101 | |
102 | |
103 | // check the weights |
104 | |
105 | if (Weights.Length() != nbpoles) |
9775fa61 |
106 | throw Standard_ConstructionError(); |
7fd59977 |
107 | |
108 | Standard_Integer i; |
109 | for (i = 1; i <= nbpoles; i++) { |
110 | if (Weights(i) <= gp::Resolution()) { |
9775fa61 |
111 | throw Standard_ConstructionError(); |
7fd59977 |
112 | } |
113 | } |
114 | |
115 | // check really rational |
116 | Standard_Boolean rat = Rational(Weights); |
117 | |
118 | // copy the weights |
119 | Handle(TColStd_HArray1OfReal) nweights; |
120 | if (rat) { |
121 | nweights = new TColStd_HArray1OfReal(1,nbpoles); |
122 | nweights->ChangeArray1() = Weights; |
123 | } |
124 | |
125 | // Init |
126 | Init(npoles,nweights); |
127 | } |
128 | |
129 | //======================================================================= |
130 | //function : Increase |
131 | //purpose : increase degree |
132 | //======================================================================= |
133 | |
134 | void Geom_BezierCurve::Increase (const Standard_Integer Deg) |
135 | { |
136 | if (Deg == Degree()) return; |
137 | |
138 | if(Deg < Degree() || |
139 | Deg > Geom_BezierCurve::MaxDegree()) |
9775fa61 |
140 | throw Standard_ConstructionError("Geom_BezierCurve::Increase"); |
7fd59977 |
141 | |
142 | Handle(TColgp_HArray1OfPnt) npoles = |
143 | new TColgp_HArray1OfPnt(1,Deg+1); |
144 | |
145 | Handle(TColStd_HArray1OfReal) nweights; |
146 | |
147 | TColStd_Array1OfReal bidknots(1,2); bidknots(1) = 0.; bidknots(2) = 1.; |
148 | TColStd_Array1OfInteger bidmults(1,2); bidmults.Init(Degree() + 1); |
149 | |
150 | if (IsRational()) { |
151 | nweights = new TColStd_HArray1OfReal(1,Deg+1); |
152 | BSplCLib::IncreaseDegree(Degree(), Deg, 0, |
153 | poles->Array1(), |
0e14656b |
154 | &weights->Array1(), |
7fd59977 |
155 | bidknots, bidmults, |
156 | npoles->ChangeArray1(), |
0e14656b |
157 | &nweights->ChangeArray1(), |
7fd59977 |
158 | bidknots, bidmults); |
159 | } |
160 | else { |
161 | BSplCLib::IncreaseDegree(Degree(), Deg, 0, |
162 | poles->Array1(), |
0e14656b |
163 | BSplCLib::NoWeights(), |
7fd59977 |
164 | bidknots, bidmults, |
165 | npoles->ChangeArray1(), |
0e14656b |
166 | BSplCLib::NoWeights(), |
7fd59977 |
167 | bidknots, bidmults); |
168 | } |
169 | |
170 | Init(npoles,nweights); |
171 | } |
172 | |
173 | //======================================================================= |
174 | //function : MaxDegree |
175 | //purpose : |
176 | //======================================================================= |
177 | |
178 | Standard_Integer Geom_BezierCurve::MaxDegree () |
179 | { |
180 | return BSplCLib::MaxDegree(); |
181 | } |
182 | |
183 | //======================================================================= |
184 | //function : InsertPoleAfter |
185 | //purpose : |
186 | //======================================================================= |
187 | |
188 | void Geom_BezierCurve::InsertPoleAfter |
189 | (const Standard_Integer Index, |
190 | const gp_Pnt& P) |
191 | { |
192 | InsertPoleAfter(Index,P,1.); |
193 | } |
194 | |
195 | //======================================================================= |
196 | //function : InsertPoleAfter |
197 | //purpose : |
198 | //======================================================================= |
199 | |
200 | void Geom_BezierCurve::InsertPoleAfter |
201 | (const Standard_Integer Index, |
202 | const gp_Pnt& P, |
203 | const Standard_Real Weight) |
204 | { |
205 | Standard_Integer nbpoles = NbPoles(); |
206 | |
207 | if(nbpoles >= Geom_BezierCurve::MaxDegree() || |
208 | Weight <= gp::Resolution()) |
9775fa61 |
209 | throw Standard_ConstructionError("Geom_BezierCurve::InsertPoleAfter"); |
7fd59977 |
210 | |
211 | if(Index < 0 || Index > nbpoles) |
9775fa61 |
212 | throw Standard_OutOfRange("Geom_BezierCurve::InsertPoleAfter"); |
7fd59977 |
213 | |
214 | Standard_Integer i; |
215 | |
216 | // Insert the pole |
217 | Handle(TColgp_HArray1OfPnt) npoles = |
218 | new TColgp_HArray1OfPnt(1,nbpoles+1); |
219 | |
220 | TColgp_Array1OfPnt& newpoles = npoles->ChangeArray1(); |
221 | const TColgp_Array1OfPnt& oldpoles = poles->Array1(); |
222 | |
223 | for (i = 1; i <= Index; i++) |
224 | newpoles(i) = oldpoles(i); |
225 | |
226 | newpoles(Index+1) = P; |
227 | |
228 | for (i = Index+1; i <= nbpoles; i++) |
229 | newpoles(i+1) = oldpoles(i); |
230 | |
231 | |
232 | // Insert the weight |
233 | Handle(TColStd_HArray1OfReal) nweights; |
234 | Standard_Boolean rat = IsRational() || Abs(Weight-1.) > gp::Resolution(); |
235 | |
236 | if (rat) { |
237 | nweights = new TColStd_HArray1OfReal(1,nbpoles+1); |
238 | TColStd_Array1OfReal& newweights = nweights->ChangeArray1(); |
239 | |
240 | for (i = 1; i <= Index; i++) |
241 | if (IsRational()) |
242 | newweights(i) = weights->Value(i); |
243 | else |
244 | newweights(i) = 1.; |
245 | |
246 | newweights(Index+1) = Weight; |
247 | |
248 | for (i = Index+1; i <= nbpoles; i++) |
249 | if (IsRational()) |
250 | newweights(i+1) = weights->Value(i); |
251 | else |
252 | newweights(i+1) = 1.; |
253 | } |
254 | |
255 | |
256 | Init(npoles,nweights); |
257 | } |
258 | |
259 | //======================================================================= |
260 | //function : InsertPoleBefore |
261 | //purpose : |
262 | //======================================================================= |
263 | |
264 | void Geom_BezierCurve::InsertPoleBefore |
265 | (const Standard_Integer Index, |
266 | const gp_Pnt& P) |
267 | { |
268 | InsertPoleAfter(Index-1,P); |
269 | } |
270 | |
271 | //======================================================================= |
272 | //function : InsertPoleBefore |
273 | //purpose : |
274 | //======================================================================= |
275 | |
276 | void Geom_BezierCurve::InsertPoleBefore |
277 | (const Standard_Integer Index, |
278 | const gp_Pnt& P, |
279 | const Standard_Real Weight) |
280 | { |
281 | InsertPoleAfter(Index-1,P,Weight); |
282 | } |
283 | |
284 | //======================================================================= |
285 | //function : RemovePole |
286 | //purpose : |
287 | //======================================================================= |
288 | |
289 | void Geom_BezierCurve::RemovePole |
290 | (const Standard_Integer Index) |
291 | { |
292 | Standard_Integer nbpoles = NbPoles(); |
293 | |
294 | if(nbpoles <= 2) |
9775fa61 |
295 | throw Standard_ConstructionError("Geom_BezierCurve::RemovePole"); |
7fd59977 |
296 | |
297 | if(Index < 1 || Index > nbpoles) |
9775fa61 |
298 | throw Standard_OutOfRange("Geom_BezierCurve::RemovePole"); |
7fd59977 |
299 | |
300 | Standard_Integer i; |
301 | |
302 | // Remove the pole |
303 | Handle(TColgp_HArray1OfPnt) npoles = |
304 | new TColgp_HArray1OfPnt(1,nbpoles-1); |
305 | |
306 | TColgp_Array1OfPnt& newpoles = npoles->ChangeArray1(); |
307 | const TColgp_Array1OfPnt& oldpoles = poles->Array1(); |
308 | |
309 | for (i = 1; i < Index; i++) |
310 | newpoles(i) = oldpoles(i); |
311 | |
312 | for (i = Index+1; i <= nbpoles; i++) |
313 | newpoles(i-1) = oldpoles(i); |
314 | |
315 | |
316 | // Remove the weight |
317 | Handle(TColStd_HArray1OfReal) nweights; |
318 | |
319 | if (IsRational()) { |
320 | nweights = new TColStd_HArray1OfReal(1,nbpoles-1); |
321 | TColStd_Array1OfReal& newweights = nweights->ChangeArray1(); |
322 | const TColStd_Array1OfReal& oldweights = weights->Array1(); |
323 | |
324 | for (i = 1; i < Index; i++) |
325 | newweights(i) = oldweights(i); |
326 | |
327 | for (i = Index+1; i <= nbpoles; i++) |
328 | newweights(i-1) = oldweights(i); |
329 | } |
330 | |
331 | Init(npoles,nweights); |
332 | } |
333 | |
334 | //======================================================================= |
335 | //function : Reverse |
336 | //purpose : |
337 | //======================================================================= |
338 | |
339 | void Geom_BezierCurve::Reverse () |
340 | { |
341 | gp_Pnt P; |
342 | Standard_Integer i, nbpoles = NbPoles(); |
343 | TColgp_Array1OfPnt & cpoles = poles->ChangeArray1(); |
344 | |
345 | // reverse poles |
346 | for (i = 1; i <= nbpoles / 2; i++) { |
347 | P = cpoles(i); |
348 | cpoles(i) = cpoles(nbpoles-i+1); |
349 | cpoles(nbpoles-i+1) = P; |
350 | } |
351 | |
352 | // reverse weights |
353 | if (IsRational()) { |
354 | TColStd_Array1OfReal & cweights = weights->ChangeArray1(); |
355 | Standard_Real w; |
356 | for (i = 1; i <= nbpoles / 2; i++) { |
357 | w = cweights(i); |
358 | cweights(i) = cweights(nbpoles-i+1); |
359 | cweights(nbpoles-i+1) = w; |
360 | } |
361 | } |
7fd59977 |
362 | } |
363 | |
364 | //======================================================================= |
365 | //function : ReversedParameter |
366 | //purpose : |
367 | //======================================================================= |
368 | |
369 | Standard_Real Geom_BezierCurve::ReversedParameter(const Standard_Real U) const |
370 | { |
371 | return ( 1. - U); |
372 | } |
373 | |
374 | //======================================================================= |
375 | //function : Segment |
376 | //purpose : |
377 | //======================================================================= |
378 | |
379 | void Geom_BezierCurve::Segment(const Standard_Real U1, const Standard_Real U2) |
380 | { |
381 | closed = (Abs(Value(U1).Distance (Value(U2))) <= Precision::Confusion()); |
382 | |
c8b5b3d8 |
383 | TColStd_Array1OfReal bidflatknots(BSplCLib::FlatBezierKnots(Degree()), 1, 2 * (Degree() + 1)); |
384 | TColgp_HArray1OfPnt coeffs(1, poles->Size()); |
7fd59977 |
385 | if (IsRational()) { |
c8b5b3d8 |
386 | TColStd_Array1OfReal wcoeffs(1, poles->Size()); |
387 | BSplCLib::BuildCache(0.0, 1.0, 0, Degree(), bidflatknots, |
388 | poles->Array1(), &weights->Array1(), coeffs, &wcoeffs); |
389 | PLib::Trimming(U1, U2, coeffs, &wcoeffs); |
390 | PLib::CoefficientsPoles(coeffs, &wcoeffs, poles->ChangeArray1(), &weights->ChangeArray1()); |
7fd59977 |
391 | } |
392 | else { |
c8b5b3d8 |
393 | BSplCLib::BuildCache(0.0, 1.0, 0, Degree(), bidflatknots, |
394 | poles->Array1(), BSplCLib::NoWeights(), coeffs, BSplCLib::NoWeights()); |
395 | PLib::Trimming(U1, U2, coeffs, PLib::NoWeights()); |
396 | PLib::CoefficientsPoles(coeffs, PLib::NoWeights(), poles->ChangeArray1(), PLib::NoWeights()); |
7fd59977 |
397 | } |
7fd59977 |
398 | } |
399 | |
400 | //======================================================================= |
401 | //function : SetPole |
402 | //purpose : |
403 | //======================================================================= |
404 | |
405 | void Geom_BezierCurve::SetPole (const Standard_Integer Index, |
406 | const gp_Pnt& P) |
407 | { |
408 | if(Index < 1 || Index > NbPoles()) |
9775fa61 |
409 | throw Standard_OutOfRange("Geom_BezierCurve::SetPole"); |
7fd59977 |
410 | |
411 | TColgp_Array1OfPnt& cpoles = poles->ChangeArray1(); |
412 | cpoles(Index) = P; |
413 | |
414 | if (Index == 1 || Index == cpoles.Length()) { |
415 | closed = (cpoles(1).Distance(cpoles(NbPoles())) <= Precision::Confusion()); |
416 | } |
7fd59977 |
417 | } |
418 | |
419 | //======================================================================= |
420 | //function : SetPole |
421 | //purpose : |
422 | //======================================================================= |
423 | |
424 | void Geom_BezierCurve::SetPole(const Standard_Integer Index, |
425 | const gp_Pnt& P, |
426 | const Standard_Real Weight) |
427 | { |
428 | SetPole(Index,P); |
429 | SetWeight(Index,Weight); |
430 | } |
431 | |
432 | //======================================================================= |
433 | //function : SetWeight |
434 | //purpose : |
435 | //======================================================================= |
436 | |
437 | void Geom_BezierCurve::SetWeight(const Standard_Integer Index, |
438 | const Standard_Real Weight) |
439 | { |
440 | Standard_Integer nbpoles = NbPoles(); |
441 | |
442 | if(Index < 1 || Index > nbpoles) |
9775fa61 |
443 | throw Standard_OutOfRange("Geom_BezierCurve::SetWeight"); |
7fd59977 |
444 | if(Weight <= gp::Resolution ()) |
9775fa61 |
445 | throw Standard_ConstructionError("Geom_BezierCurve::SetWeight"); |
7fd59977 |
446 | |
447 | // compute new rationality |
448 | Standard_Boolean wasrat = IsRational(); |
449 | if (!wasrat) { |
450 | // a weight of 1. does not turn to rational |
451 | if (Abs(Weight - 1.) <= gp::Resolution()) return; |
452 | |
453 | // set weights of 1. |
454 | weights = new TColStd_HArray1OfReal(1,nbpoles); |
7fd59977 |
455 | weights->Init(1.); |
456 | } |
457 | |
458 | TColStd_Array1OfReal & cweights = weights->ChangeArray1(); |
459 | cweights(Index) = Weight; |
460 | |
461 | // is it turning into non rational |
c8b5b3d8 |
462 | if (wasrat && !Rational(cweights)) |
463 | weights.Nullify(); |
7fd59977 |
464 | } |
465 | |
466 | //======================================================================= |
467 | //function : IsClosed |
468 | //purpose : |
469 | //======================================================================= |
470 | |
471 | Standard_Boolean Geom_BezierCurve::IsClosed () const |
472 | { |
473 | return closed; |
474 | } |
475 | |
476 | //======================================================================= |
477 | //function : IsCN |
478 | //purpose : |
479 | //======================================================================= |
480 | |
481 | Standard_Boolean Geom_BezierCurve::IsCN (const Standard_Integer ) const |
482 | { |
483 | return Standard_True; |
484 | } |
485 | |
486 | //======================================================================= |
487 | //function : IsPeriodic |
488 | //purpose : |
489 | //======================================================================= |
490 | |
491 | Standard_Boolean Geom_BezierCurve::IsPeriodic () const |
492 | { |
493 | return Standard_False; |
494 | } |
495 | |
496 | //======================================================================= |
497 | //function : IsRational |
498 | //purpose : |
499 | //======================================================================= |
500 | |
501 | Standard_Boolean Geom_BezierCurve::IsRational () const |
502 | { |
503 | return !weights.IsNull(); |
504 | } |
505 | |
506 | //======================================================================= |
507 | //function : Continuity |
508 | //purpose : |
509 | //======================================================================= |
510 | |
511 | GeomAbs_Shape Geom_BezierCurve::Continuity () const |
512 | { |
513 | return GeomAbs_CN; |
514 | } |
515 | |
516 | //======================================================================= |
517 | //function : Degree |
518 | //purpose : |
519 | //======================================================================= |
520 | |
521 | Standard_Integer Geom_BezierCurve::Degree () const |
522 | { |
523 | return poles->Length()-1; |
524 | } |
525 | |
526 | //======================================================================= |
527 | //function : D0 |
528 | //purpose : |
529 | //======================================================================= |
530 | |
531 | void Geom_BezierCurve::D0 (const Standard_Real U, gp_Pnt& P ) const |
532 | { |
c8b5b3d8 |
533 | BSplCLib::D0(U, Poles(), Weights(), P); |
7fd59977 |
534 | } |
535 | |
536 | //======================================================================= |
537 | //function : D1 |
538 | //purpose : |
539 | //======================================================================= |
540 | |
541 | void Geom_BezierCurve::D1(const Standard_Real U, gp_Pnt& P, gp_Vec& V1) const |
542 | { |
c8b5b3d8 |
543 | BSplCLib::D1(U, Poles(), Weights(), P, V1); |
7fd59977 |
544 | } |
545 | |
546 | //======================================================================= |
547 | //function : D2 |
548 | //purpose : |
549 | //======================================================================= |
550 | |
551 | void Geom_BezierCurve::D2 (const Standard_Real U, |
552 | gp_Pnt& P, |
553 | gp_Vec& V1, |
554 | gp_Vec& V2) const |
555 | { |
c8b5b3d8 |
556 | BSplCLib::D2(U, Poles(), Weights(), P, V1, V2); |
7fd59977 |
557 | } |
558 | |
559 | //======================================================================= |
560 | //function : D3 |
561 | //purpose : |
562 | //======================================================================= |
563 | |
564 | void Geom_BezierCurve::D3 (const Standard_Real U, |
565 | gp_Pnt& P, |
566 | gp_Vec& V1, |
567 | gp_Vec& V2, |
568 | gp_Vec& V3) const |
569 | { |
c8b5b3d8 |
570 | BSplCLib::D3(U, Poles(), Weights(), P, V1, V2, V3); |
7fd59977 |
571 | } |
572 | |
573 | //======================================================================= |
574 | //function : DN |
575 | //purpose : |
576 | //======================================================================= |
577 | |
578 | gp_Vec Geom_BezierCurve::DN (const Standard_Real U, |
579 | const Standard_Integer N) const |
580 | { |
581 | if(N < 1) |
9775fa61 |
582 | throw Standard_RangeError("Geom_BezierCurve::DN"); |
7fd59977 |
583 | gp_Vec V; |
584 | |
585 | TColStd_Array1OfReal bidknots(1,2); bidknots(1) = 0.; bidknots(2) = 1.; |
586 | TColStd_Array1OfInteger bidmults(1,2); bidmults.Init(Degree() + 1); |
587 | |
588 | if (IsRational()) |
589 | // BSplCLib::DN(U,N,0,Degree(),0., |
590 | BSplCLib::DN(U,N,0,Degree(),Standard_False, |
591 | poles->Array1(), |
0e14656b |
592 | &weights->Array1(), |
593 | bidknots,&bidmults,V); |
7fd59977 |
594 | else |
595 | // BSplCLib::DN(U,N,0,Degree(),0., |
596 | BSplCLib::DN(U,N,0,Degree(),Standard_False, |
597 | poles->Array1(), |
0e14656b |
598 | BSplCLib::NoWeights(), |
599 | bidknots,&bidmults,V); |
7fd59977 |
600 | return V; |
601 | } |
602 | |
603 | //======================================================================= |
604 | //function : StartPoint |
605 | //purpose : |
606 | //======================================================================= |
607 | |
608 | gp_Pnt Geom_BezierCurve::StartPoint () const |
609 | { |
610 | return poles->Value(1); |
611 | } |
612 | |
613 | //======================================================================= |
614 | //function : EndPoint |
615 | //purpose : |
616 | //======================================================================= |
617 | |
618 | gp_Pnt Geom_BezierCurve::EndPoint () const |
619 | { |
620 | return poles->Value (poles->Upper()); |
621 | } |
622 | |
623 | //======================================================================= |
624 | //function : FirstParameter |
625 | //purpose : |
626 | //======================================================================= |
627 | |
628 | Standard_Real Geom_BezierCurve::FirstParameter () const |
629 | { |
630 | return 0.0; |
631 | } |
632 | |
633 | //======================================================================= |
634 | //function : LastParameter |
635 | //purpose : |
636 | //======================================================================= |
637 | |
638 | Standard_Real Geom_BezierCurve::LastParameter () const |
639 | { |
640 | return 1.0; |
641 | } |
642 | |
643 | //======================================================================= |
644 | //function : NbPoles |
645 | //purpose : |
646 | //======================================================================= |
647 | |
648 | Standard_Integer Geom_BezierCurve::NbPoles () const |
649 | { |
650 | return poles->Length(); |
651 | } |
652 | |
653 | //======================================================================= |
654 | //function : Pole |
655 | //purpose : |
656 | //======================================================================= |
657 | |
81093856 |
658 | const gp_Pnt& Geom_BezierCurve::Pole (const Standard_Integer Index) const |
7fd59977 |
659 | { |
660 | if(Index < 1 || Index > poles->Length()) |
9775fa61 |
661 | throw Standard_OutOfRange("Geom_BezierCurve::Pole"); |
7fd59977 |
662 | return poles->Value(Index); |
663 | } |
664 | |
665 | //======================================================================= |
666 | //function : Poles |
667 | //purpose : |
668 | //======================================================================= |
669 | |
670 | void Geom_BezierCurve::Poles (TColgp_Array1OfPnt& P) const |
671 | { |
672 | if(P.Length() != poles->Length()) |
9775fa61 |
673 | throw Standard_DimensionError("Geom_BezierCurve::Poles"); |
7fd59977 |
674 | P = poles->Array1(); |
675 | } |
676 | |
bcd19756 |
677 | |
678 | //======================================================================= |
679 | //function : Poles |
680 | //purpose : |
681 | //======================================================================= |
682 | |
683 | const TColgp_Array1OfPnt& Geom_BezierCurve::Poles() const |
684 | { |
685 | return poles->Array1(); |
686 | } |
687 | |
7fd59977 |
688 | //======================================================================= |
689 | //function : Weight |
690 | //purpose : |
691 | //======================================================================= |
692 | |
693 | Standard_Real Geom_BezierCurve::Weight |
694 | (const Standard_Integer Index) const |
695 | { |
696 | if(Index < 1 || Index > poles->Length()) |
9775fa61 |
697 | throw Standard_OutOfRange("Geom_BezierCurve::Weight"); |
7fd59977 |
698 | if (IsRational()) |
699 | return weights->Value(Index); |
700 | else |
701 | return 1.; |
702 | } |
703 | |
704 | //======================================================================= |
705 | //function : Weights |
706 | //purpose : |
707 | //======================================================================= |
708 | |
709 | void Geom_BezierCurve::Weights |
710 | (TColStd_Array1OfReal& W) const |
711 | { |
712 | |
713 | Standard_Integer nbpoles = NbPoles(); |
714 | if(W.Length() != nbpoles) |
9775fa61 |
715 | throw Standard_DimensionError("Geom_BezierCurve::Weights"); |
7fd59977 |
716 | if (IsRational()) |
717 | W = weights->Array1(); |
718 | else { |
719 | Standard_Integer i; |
720 | for (i = 1; i <= nbpoles; i++) |
721 | W(i) = 1.; |
722 | } |
723 | } |
724 | |
725 | //======================================================================= |
726 | //function : Transform |
727 | //purpose : |
728 | //======================================================================= |
729 | |
730 | void Geom_BezierCurve::Transform (const gp_Trsf& T) |
731 | { |
732 | Standard_Integer nbpoles = NbPoles(); |
733 | TColgp_Array1OfPnt & cpoles = poles->ChangeArray1(); |
734 | |
735 | for (Standard_Integer i = 1; i <= nbpoles; i++) |
736 | cpoles (i).Transform(T); |
7fd59977 |
737 | } |
738 | |
739 | //======================================================================= |
740 | //function : Resolution |
741 | //purpose : |
742 | //======================================================================= |
743 | |
744 | void Geom_BezierCurve::Resolution(const Standard_Real Tolerance3D, |
745 | Standard_Real & UTolerance) |
746 | { |
747 | if(!maxderivinvok){ |
748 | TColStd_Array1OfReal bidflatknots(BSplCLib::FlatBezierKnots(Degree()), |
749 | 1, 2*(Degree()+1)); |
750 | |
751 | if (IsRational()) { |
752 | BSplCLib::Resolution(poles->Array1(), |
0e14656b |
753 | &weights->Array1(), |
7fd59977 |
754 | poles->Length(), |
755 | bidflatknots, |
756 | Degree(), |
757 | 1., |
758 | maxderivinv) ; |
759 | } |
760 | else { |
761 | BSplCLib::Resolution(poles->Array1(), |
762 | BSplCLib::NoWeights(), |
763 | poles->Length(), |
764 | bidflatknots, |
765 | Degree(), |
766 | 1., |
767 | maxderivinv) ; |
768 | } |
769 | maxderivinvok = 1; |
770 | } |
771 | UTolerance = Tolerance3D * maxderivinv; |
772 | } |
773 | |
774 | //======================================================================= |
775 | //function : Copy |
776 | //purpose : |
777 | //======================================================================= |
778 | |
779 | Handle(Geom_Geometry) Geom_BezierCurve::Copy() const { |
780 | |
781 | Handle(Geom_BezierCurve) C; |
782 | if (IsRational()) |
783 | C = new Geom_BezierCurve (poles->Array1(),weights->Array1()); |
784 | else |
785 | C = new Geom_BezierCurve (poles->Array1()); |
786 | return C; |
787 | } |
788 | |
789 | //======================================================================= |
790 | //function : Init |
791 | //purpose : |
792 | //======================================================================= |
793 | |
794 | void Geom_BezierCurve::Init |
795 | (const Handle(TColgp_HArray1OfPnt)& Poles, |
796 | const Handle(TColStd_HArray1OfReal)& Weights) |
797 | { |
798 | Standard_Integer nbpoles = Poles->Length(); |
799 | // closed ? |
800 | const TColgp_Array1OfPnt& cpoles = Poles->Array1(); |
801 | closed = cpoles(1).Distance(cpoles(nbpoles)) <= Precision::Confusion(); |
802 | |
803 | // rational |
804 | rational = !Weights.IsNull(); |
805 | |
806 | // set fields |
807 | poles = Poles; |
7fd59977 |
808 | |
c8b5b3d8 |
809 | if (rational) |
7fd59977 |
810 | weights = Weights; |
7fd59977 |
811 | else |
c8b5b3d8 |
812 | weights.Nullify(); |
7fd59977 |
813 | } |
814 | |
bc73b006 |
815 | //======================================================================= |
816 | //function : DumpJson |
817 | //purpose : |
818 | //======================================================================= |
819 | void Geom_BezierCurve::DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth) const |
820 | { |
821 | OCCT_DUMP_TRANSIENT_CLASS_BEGIN (theOStream) |
822 | |
823 | OCCT_DUMP_BASE_CLASS (theOStream, theDepth, Geom_BoundedCurve) |
824 | |
825 | OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, rational) |
826 | OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, closed) |
827 | if (!poles.IsNull()) |
828 | OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, poles->Size()) |
829 | if (!weights.IsNull()) |
830 | OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, weights->Size()) |
831 | |
832 | OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, maxderivinv) |
833 | OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, maxderivinvok) |
834 | } |
835 | |