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