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