0031313: Foundation Classes - Dump improvement for classes
[occt.git] / src / Geom / Geom_BezierCurve.cxx
1 // Created on: 1993-03-09
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 // Revised RLE  Aug 19 1993
24 // Suppressed Swaps, added Init, removed typedefs
25
26 #define No_Standard_OutOfRange
27 #define No_Standard_DimensionError
28
29
30 #include <Geom_BezierCurve.hxx>
31 #include <Geom_Geometry.hxx>
32 #include <gp.hxx>
33 #include <gp_Pnt.hxx>
34 #include <gp_Trsf.hxx>
35 #include <gp_Vec.hxx>
36 #include <gp_XYZ.hxx>
37 #include <PLib.hxx>
38 #include <Precision.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
46 IMPLEMENT_STANDARD_RTTIEXT(Geom_BezierCurve,Geom_BoundedCurve)
47
48 //=======================================================================
49 //function : Rational
50 //purpose  : check rationality of an array of weights
51 //=======================================================================
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
68 Geom_BezierCurve::Geom_BezierCurve(const TColgp_Array1OfPnt& Poles)
69 {
70   Standard_Integer nbpoles = Poles.Length();
71   if(nbpoles < 2 || nbpoles > (Geom_BezierCurve::MaxDegree() + 1))
72     throw Standard_ConstructionError();
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, 
90                                    const TColStd_Array1OfReal& Weights)
91 {
92   // copy the poles
93   Standard_Integer nbpoles = Poles.Length();
94   if(nbpoles < 2 || nbpoles > (Geom_BezierCurve::MaxDegree() + 1))
95     throw Standard_ConstructionError();
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)
106     throw Standard_ConstructionError();
107
108   Standard_Integer i;
109   for (i = 1; i <= nbpoles; i++) {
110     if (Weights(i) <= gp::Resolution()) {
111       throw Standard_ConstructionError();
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()) 
140     throw Standard_ConstructionError("Geom_BezierCurve::Increase");
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(),
154                              &weights->Array1(),
155                              bidknots, bidmults,
156                              npoles->ChangeArray1(),
157                              &nweights->ChangeArray1(),
158                              bidknots, bidmults);
159   }
160   else {
161     BSplCLib::IncreaseDegree(Degree(), Deg, 0,
162                              poles->Array1(),
163                              BSplCLib::NoWeights(),
164                              bidknots, bidmults,
165                              npoles->ChangeArray1(),
166                              BSplCLib::NoWeights(),
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())
209     throw Standard_ConstructionError("Geom_BezierCurve::InsertPoleAfter");
210
211   if(Index < 0 || Index > nbpoles)
212     throw Standard_OutOfRange("Geom_BezierCurve::InsertPoleAfter");
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)
295     throw Standard_ConstructionError("Geom_BezierCurve::RemovePole");
296
297   if(Index < 1 || Index > nbpoles)
298     throw Standard_OutOfRange("Geom_BezierCurve::RemovePole");
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   }
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
383   TColStd_Array1OfReal bidflatknots(BSplCLib::FlatBezierKnots(Degree()), 1, 2 * (Degree() + 1));
384   TColgp_HArray1OfPnt coeffs(1, poles->Size());
385   if (IsRational()) {
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());
391   }
392   else {
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());
397   }
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())
409     throw Standard_OutOfRange("Geom_BezierCurve::SetPole");
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   }
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)
443     throw Standard_OutOfRange("Geom_BezierCurve::SetWeight");
444   if(Weight <= gp::Resolution ())
445     throw Standard_ConstructionError("Geom_BezierCurve::SetWeight");
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);
455     weights->Init(1.);
456   }
457   
458   TColStd_Array1OfReal & cweights = weights->ChangeArray1();
459   cweights(Index) = Weight;
460   
461   // is it turning into non rational
462   if (wasrat && !Rational(cweights))
463     weights.Nullify();
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 {
533   BSplCLib::D0(U, Poles(), Weights(), P);
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 {
543   BSplCLib::D1(U, Poles(), Weights(), P, V1);
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 {
556   BSplCLib::D2(U, Poles(), Weights(), P, V1, V2);
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 {
570   BSplCLib::D3(U, Poles(), Weights(), P, V1, V2, V3);
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) 
582     throw Standard_RangeError("Geom_BezierCurve::DN");
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(),
592                  &weights->Array1(),
593                  bidknots,&bidmults,V);
594   else 
595 //    BSplCLib::DN(U,N,0,Degree(),0.,
596     BSplCLib::DN(U,N,0,Degree(),Standard_False,
597                  poles->Array1(),
598                  BSplCLib::NoWeights(),
599                  bidknots,&bidmults,V);
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
658 const gp_Pnt& Geom_BezierCurve::Pole (const Standard_Integer Index) const
659 {
660   if(Index < 1 || Index > poles->Length()) 
661     throw Standard_OutOfRange("Geom_BezierCurve::Pole");
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()) 
673     throw Standard_DimensionError("Geom_BezierCurve::Poles");
674   P = poles->Array1();
675 }
676
677
678 //=======================================================================
679 //function : Poles
680 //purpose  : 
681 //=======================================================================
682
683 const TColgp_Array1OfPnt& Geom_BezierCurve::Poles() const
684 {
685   return poles->Array1();
686 }
687
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()) 
697     throw Standard_OutOfRange("Geom_BezierCurve::Weight");
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)
715     throw Standard_DimensionError("Geom_BezierCurve::Weights");
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);
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(),
753                            &weights->Array1(),
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;
808
809   if (rational)
810     weights = Weights;
811   else
812     weights.Nullify();
813 }
814
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