projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
0031313: Foundation Classes - Dump improvement for classes
[occt.git] / src / Geom / Geom_BezierCurve.cxx
CommitLineData
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 46IMPLEMENT_STANDARD_RTTIEXT(Geom_BezierCurve,Geom_BoundedCurve)
47
7fd59977 48//=======================================================================
49//function : Rational
50//purpose : check rationality of an array of weights
51//=======================================================================
7fd59977 52static 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 68Geom_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
89Geom_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
134void 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
178Standard_Integer Geom_BezierCurve::MaxDegree ()
179{
180 return BSplCLib::MaxDegree();
181}
182
183//=======================================================================
184//function : InsertPoleAfter
185//purpose :
186//=======================================================================
187
188void 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
200void 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
264void 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
276void 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
289void 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
339void 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
369Standard_Real Geom_BezierCurve::ReversedParameter(const Standard_Real U) const
370{
371 return ( 1. - U);
372}
373
374//=======================================================================
375//function : Segment
376//purpose :
377//=======================================================================
378
379void 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
405void 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
424void 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
437void 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
471Standard_Boolean Geom_BezierCurve::IsClosed () const
472{
473 return closed;
474}
475
476//=======================================================================
477//function : IsCN
478//purpose :
479//=======================================================================
480
481Standard_Boolean Geom_BezierCurve::IsCN (const Standard_Integer ) const
482{
483 return Standard_True;
484}
485
486//=======================================================================
487//function : IsPeriodic
488//purpose :
489//=======================================================================
490
491Standard_Boolean Geom_BezierCurve::IsPeriodic () const
492{
493 return Standard_False;
494}
495
496//=======================================================================
497//function : IsRational
498//purpose :
499//=======================================================================
500
501Standard_Boolean Geom_BezierCurve::IsRational () const
502{
503 return !weights.IsNull();
504}
505
506//=======================================================================
507//function : Continuity
508//purpose :
509//=======================================================================
510
511GeomAbs_Shape Geom_BezierCurve::Continuity () const
512{
513 return GeomAbs_CN;
514}
515
516//=======================================================================
517//function : Degree
518//purpose :
519//=======================================================================
520
521Standard_Integer Geom_BezierCurve::Degree () const
522{
523 return poles->Length()-1;
524}
525
526//=======================================================================
527//function : D0
528//purpose :
529//=======================================================================
530
531void 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
541void 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
551void 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
564void 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
578gp_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
608gp_Pnt Geom_BezierCurve::StartPoint () const
609{
610 return poles->Value(1);
611}
612
613//=======================================================================
614//function : EndPoint
615//purpose :
616//=======================================================================
617
618gp_Pnt Geom_BezierCurve::EndPoint () const
619{
620 return poles->Value (poles->Upper());
621}
622
623//=======================================================================
624//function : FirstParameter
625//purpose :
626//=======================================================================
627
628Standard_Real Geom_BezierCurve::FirstParameter () const
629{
630 return 0.0;
631}
632
633//=======================================================================
634//function : LastParameter
635//purpose :
636//=======================================================================
637
638Standard_Real Geom_BezierCurve::LastParameter () const
639{
640 return 1.0;
641}
642
643//=======================================================================
644//function : NbPoles
645//purpose :
646//=======================================================================
647
648Standard_Integer Geom_BezierCurve::NbPoles () const
649{
650 return poles->Length();
651}
652
653//=======================================================================
654//function : Pole
655//purpose :
656//=======================================================================
657
81093856 658const 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
670void 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
683const TColgp_Array1OfPnt& Geom_BezierCurve::Poles() const
684{
685 return poles->Array1();
686}
687
7fd59977 688//=======================================================================
689//function : Weight
690//purpose :
691//=======================================================================
692
693Standard_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
709void 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
730void 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
744void 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
779Handle(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
794void 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//=======================================================================
819void 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
Open CASCADE Technology repository