1 // Created on: 1997-11-21
2 // Created by: Philippe MANGIN
3 // Copyright (c) 1997-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
6 // This file is part of Open CASCADE Technology software library.
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.
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
17 // Modified by skv - Fri Feb 6 11:44:48 2004 OCC5073
19 #include <GeomFill_Sweep.ixx>
20 #include <GeomFill_SweepFunction.hxx>
21 #include <GeomFill_LocFunction.hxx>
23 #include <Standard_ErrorHandler.hxx>
25 #include <gp_Pnt2d.hxx>
26 #include <gp_Dir2d.hxx>
30 #include <gp_Circ.hxx>
31 #include <gp_GTrsf.hxx>
34 #include <gp_Sphere.hxx>
36 #include <TColgp_Array1OfPnt.hxx>
37 #include <TColgp_Array2OfPnt.hxx>
38 #include <TColgp_HArray2OfPnt.hxx>
39 //#include <GeomLib_Array1OfMat.hxx>
40 #include <TColStd_Array1OfInteger.hxx>
41 #include <TColStd_Array1OfReal.hxx>
42 #include <TColStd_Array2OfReal.hxx>
44 #include <GeomAbs_CurveType.hxx>
45 #include <GeomAdaptor_Curve.hxx>
46 #include <GeomLib.hxx>
48 #include <Geom2d_Line.hxx>
49 #include <Geom2d_BSplineCurve.hxx>
50 #include <Geom2d_TrimmedCurve.hxx>
52 #include <Geom_Circle.hxx>
53 #include <Geom_Line.hxx>
54 #include <Geom_BSplineSurface.hxx>
55 #include <Geom_Plane.hxx>
56 #include <Geom_SurfaceOfLinearExtrusion.hxx>
57 #include <Geom_CylindricalSurface.hxx>
58 #include <Geom_ConicalSurface.hxx>
59 #include <Geom_ToroidalSurface.hxx>
60 #include <Geom_SphericalSurface.hxx>
61 #include <Geom_SurfaceOfRevolution.hxx>
62 #include <Geom_RectangularTrimmedSurface.hxx>
63 #include <Geom_TrimmedCurve.hxx>
65 #include <Approx_SweepApproximation.hxx>
66 #include <AdvApprox_PrefAndRec.hxx>
67 #include <AdvApprox_ApproxAFunction.hxx>
68 #include <GeomConvert_ApproxSurface.hxx>
70 #include <Precision.hxx>
74 //=======================================================================
75 //class : GeomFill_Sweep_Eval
76 //purpose: The evaluator for curve approximation
77 //=======================================================================
79 class GeomFill_Sweep_Eval : public AdvApprox_EvaluatorFunction
82 GeomFill_Sweep_Eval (GeomFill_LocFunction& theTool)
83 : theAncore(theTool) {}
85 virtual void Evaluate (Standard_Integer *Dimension,
86 Standard_Real StartEnd[2],
87 Standard_Real *Parameter,
88 Standard_Integer *DerivativeRequest,
89 Standard_Real *Result, // [Dimension]
90 Standard_Integer *ErrorCode);
93 GeomFill_LocFunction& theAncore;
96 void GeomFill_Sweep_Eval::Evaluate (Standard_Integer *,/*Dimension*/
97 Standard_Real StartEnd[2],
98 Standard_Real *Parameter,
99 Standard_Integer *DerivativeRequest,
100 Standard_Real *Result,// [Dimension]
101 Standard_Integer *ErrorCode)
103 theAncore.DN (*Parameter,
111 //===============================================================
114 //===============================================================
115 GeomFill_Sweep::GeomFill_Sweep(const Handle(GeomFill_LocationLaw)& Location,
116 const Standard_Boolean WithKpart)
118 done = Standard_False;
123 myForceApproxC1 = Standard_False;
125 myLoc->GetDomain(First, Last);
126 SFirst = SLast = 30.081996;
130 //===============================================================
131 // Function : SetDomain
133 //===============================================================
134 void GeomFill_Sweep::SetDomain(const Standard_Real LocFirst,
135 const Standard_Real LocLast,
136 const Standard_Real SectionFirst,
137 const Standard_Real SectionLast)
141 SFirst = SectionFirst;
145 //===============================================================
146 // Function : SetTolerance
148 //===============================================================
149 void GeomFill_Sweep::SetTolerance(const Standard_Real Tolerance3d,
150 const Standard_Real BoundTolerance,
151 const Standard_Real Tolerance2d,
152 const Standard_Real ToleranceAngular)
155 BoundTol = BoundTolerance;
157 TolAngular = ToleranceAngular;
160 //=======================================================================
161 //Function : SetForceApproxC1
162 //Purpose : Set the flag that indicates attempt to approximate
163 // a C1-continuous surface if a swept surface proved
165 //=======================================================================
166 void GeomFill_Sweep::SetForceApproxC1(const Standard_Boolean ForceApproxC1)
168 myForceApproxC1 = ForceApproxC1;
172 //===============================================================
173 // Function : ExchangeUV
175 //===============================================================
176 Standard_Boolean GeomFill_Sweep::ExchangeUV() const
181 //===============================================================
182 // Function : UReversed
184 //===============================================================
185 Standard_Boolean GeomFill_Sweep::UReversed() const
190 //===============================================================
191 // Function : VReversed
193 //===============================================================
194 Standard_Boolean GeomFill_Sweep::VReversed() const
199 //===============================================================
202 //===============================================================
203 void GeomFill_Sweep::Build(const Handle(GeomFill_SectionLaw)& Section,
204 const GeomFill_ApproxStyle Methode,
205 const GeomAbs_Shape Continuity,
206 const Standard_Integer Degmax,
207 const Standard_Integer Segmax)
210 done = Standard_False;
211 myExchUV = Standard_False;
212 isUReversed = isVReversed = Standard_False;
215 if ((SFirst == SLast) && (SLast == 30.081996)) {
216 mySec->GetDomain(SFirst, SLast);
219 Standard_Boolean isKPart = Standard_False,
220 isProduct = Standard_False;
222 // Traitement des KPart
223 if (myKPart) isKPart = BuildKPart();
225 // Traitement des produits Formelles
226 if ((!isKPart) && (Methode == GeomFill_Location)) {
227 Handle(Geom_BSplineSurface) BS;
228 BS = mySec->BSplineSurface();
231 // isProduct = BuildProduct(Continuity, Degmax, Segmax);
235 if (isKPart || isProduct) {
237 done = Build2d(Continuity, Degmax, Segmax);
241 done = BuildAll(Continuity, Degmax, Segmax);
245 //===============================================================
246 // Function ::Build2d
247 // Purpose :A venir...
248 //===============================================================
249 // Standard_Boolean GeomFill_Sweep::Build2d(const GeomAbs_Shape Continuity,
250 Standard_Boolean GeomFill_Sweep::Build2d(const GeomAbs_Shape ,
251 // const Standard_Integer Degmax,
252 const Standard_Integer ,
253 // const Standard_Integer Segmax)
254 const Standard_Integer )
256 Standard_Boolean Ok = Standard_False;
257 if (myLoc->Nb2dCurves() == 0) {
263 //===============================================================
264 // Function : BuildAll
266 //===============================================================
267 Standard_Boolean GeomFill_Sweep::BuildAll(const GeomAbs_Shape Continuity,
268 const Standard_Integer Degmax,
269 const Standard_Integer Segmax)
271 Standard_Boolean Ok = Standard_False;
273 Handle(GeomFill_SweepFunction) Func
274 = new (GeomFill_SweepFunction) (mySec, myLoc, First, SFirst,
275 (SLast-SFirst)/(Last-First) );
276 Approx_SweepApproximation Approx( Func );
278 Approx.Perform(First, Last,
279 Tol3d, BoundTol, Tol2d, TolAngular,
280 Continuity, Degmax, Segmax);
282 if (Approx.IsDone()) {
290 Standard_Integer UDegree,VDegree,NbUPoles,
291 NbVPoles,NbUKnots,NbVKnots;
292 Approx.SurfShape(UDegree,VDegree,NbUPoles,
293 NbVPoles,NbUKnots,NbVKnots);
295 TColgp_Array2OfPnt Poles(1,NbUPoles, 1,NbVPoles);
296 TColStd_Array2OfReal Weights(1,NbUPoles, 1,NbVPoles);
297 TColStd_Array1OfReal UKnots(1, NbUKnots),VKnots(1, NbVKnots);
298 TColStd_Array1OfInteger UMults(1, NbUKnots), VMults(1, NbVKnots);
300 Approx.Surface(Poles, Weights,
304 mySurface = new (Geom_BSplineSurface)
308 Approx.UDegree(), Approx.VDegree(),
309 mySec->IsUPeriodic());
310 SError = Approx. MaxErrorOnSurf();
312 if (myForceApproxC1 && !mySurface->IsCNv(1))
314 Standard_Real theTol = 1.e-4;
315 GeomAbs_Shape theUCont = GeomAbs_C1, theVCont = GeomAbs_C1;
316 Standard_Integer degU = 14, degV = 14;
317 Standard_Integer nmax = 16;
318 Standard_Integer thePrec = 1;
320 GeomConvert_ApproxSurface ConvertApprox(mySurface,theTol,theUCont,theVCont,
321 degU,degV,nmax,thePrec);
322 if (ConvertApprox.HasResult())
324 mySurface = ConvertApprox.Surface();
325 myCurve2d = new (TColGeom2d_HArray1OfCurve) (1, 2);
326 CError = new (TColStd_HArray2OfReal) (1,2, 1,2);
328 const Handle(Geom_BSplineSurface)& BSplSurf =
329 Handle(Geom_BSplineSurface)::DownCast(mySurface);
332 gp_Pnt2d P(BSplSurf->UKnot(1), 0);
333 Handle(Geom2d_Line) LC1 = new (Geom2d_Line) (P, D);
334 Handle(Geom2d_TrimmedCurve) TC1 =
335 new (Geom2d_TrimmedCurve) (LC1, 0, BSplSurf->VKnot(BSplSurf->NbVKnots()));
337 myCurve2d->SetValue(1, TC1);
338 CError->SetValue(1, 1, 0.);
339 CError->SetValue(2, 1, 0.);
341 P.SetCoord(BSplSurf->UKnot(BSplSurf->NbUKnots()), 0);
342 Handle(Geom2d_Line) LC2 = new (Geom2d_Line) (P, D);
343 Handle(Geom2d_TrimmedCurve) TC2 =
344 new (Geom2d_TrimmedCurve) (LC2, 0, BSplSurf->VKnot(BSplSurf->NbVKnots()));
346 myCurve2d->SetValue(myCurve2d->Length(), TC2);
347 CError->SetValue(1, myCurve2d->Length(), 0.);
348 CError->SetValue(2, myCurve2d->Length(), 0.);
352 } //if (!mySurface->IsCNv(1))
355 if (myCurve2d.IsNull())
357 myCurve2d = new (TColGeom2d_HArray1OfCurve) (1, 2+myLoc->TraceNumber());
358 CError = new (TColStd_HArray2OfReal) (1,2, 1, 2+myLoc->TraceNumber());
359 Standard_Integer kk,ii, ifin = 1, ideb;
361 if (myLoc->HasFirstRestriction()) {
367 ifin += myLoc->TraceNumber();
368 if (myLoc->HasLastRestriction()) ifin++;
370 for (ii=ideb, kk=1; ii<=ifin; ii++, kk++) {
371 Handle(Geom2d_BSplineCurve) C
372 = new (Geom2d_BSplineCurve) (Approx.Curve2dPoles(kk),
373 Approx.Curves2dKnots(),
374 Approx.Curves2dMults(),
375 Approx.Curves2dDegree());
376 myCurve2d->SetValue(ii, C);
377 CError->SetValue(1, ii, Approx.Max2dError(kk));
378 CError->SetValue(2, ii, Approx.Max2dError(kk));
381 // Si les courbes de restriction, ne sont pas calcules, on prend
383 if (! myLoc->HasFirstRestriction()) {
385 gp_Pnt2d P(UKnots(UKnots.Lower()), 0);
386 Handle(Geom2d_Line) LC = new (Geom2d_Line) (P, D);
387 Handle(Geom2d_TrimmedCurve) TC = new (Geom2d_TrimmedCurve)
390 myCurve2d->SetValue(1, TC);
391 CError->SetValue(1, 1, 0.);
392 CError->SetValue(2, 1, 0.);
395 if (! myLoc->HasLastRestriction()) {
397 gp_Pnt2d P(UKnots(UKnots.Upper()), 0);
398 Handle(Geom2d_Line) LC = new (Geom2d_Line) (P, D);
399 Handle(Geom2d_TrimmedCurve) TC =
400 new (Geom2d_TrimmedCurve) (LC, First, Last);
401 myCurve2d->SetValue(myCurve2d->Length(), TC);
402 CError->SetValue(1, myCurve2d->Length(), 0.);
403 CError->SetValue(2, myCurve2d->Length(), 0.);
405 } //if (myCurve2d.IsNull())
410 //===============================================================
411 // Function : BuildProduct
412 // Purpose : A venir...
413 //===============================================================
414 Standard_Boolean GeomFill_Sweep::BuildProduct(const GeomAbs_Shape Continuity,
415 const Standard_Integer Degmax,
416 const Standard_Integer Segmax)
418 Standard_Boolean Ok = Standard_False;
420 Handle(Geom_BSplineSurface) BSurf;
421 BSurf = Handle(Geom_BSplineSurface)::DownCast(
422 mySec->BSplineSurface()->Copy());
423 if (BSurf.IsNull()) return Ok; // Ce mode de construction est impossible
426 Standard_Integer NbIntervalC2, NbIntervalC3;
427 GeomFill_LocFunction Func(myLoc);
429 NbIntervalC2 = myLoc->NbIntervals(GeomAbs_C2);
430 NbIntervalC3 = myLoc->NbIntervals(GeomAbs_C3);
431 TColStd_Array1OfReal Param_de_decoupeC2 (1, NbIntervalC2+1);
432 myLoc->Intervals(Param_de_decoupeC2, GeomAbs_C2);
433 TColStd_Array1OfReal Param_de_decoupeC3 (1, NbIntervalC3+1);
434 myLoc->Intervals(Param_de_decoupeC3, GeomAbs_C3);
437 AdvApprox_PrefAndRec Preferentiel(Param_de_decoupeC2,
440 Handle(TColStd_HArray1OfReal) ThreeDTol = new (TColStd_HArray1OfReal) (1,4);
441 ThreeDTol->Init(Tol3d); // A Affiner...
443 GeomFill_Sweep_Eval eval (Func);
444 AdvApprox_ApproxAFunction Approx(0, 0, 4,
459 Ok = Approx.HasResult();
461 /* TColgp_Array1OfMat TM(1, nbpoles);
462 Handle(TColgp_HArray2OfPnt) ResPoles;
463 ResPoles = Approx.Poles();
466 for (ii=1; ii<=nbpoles; ii++) {
467 TM(ii).SetCols(ResPoles->Value(ii,2).XYZ(),
468 ResPoles->Value(ii,3).XYZ(),
469 ResPoles->Value(ii,4).XYZ());
470 TR(ii) = ResPoles->Value(ii,1);
472 GeomLib::TensorialProduct(BSurf, TM, TR,
473 Approx.Knots()->Array1(),
474 Approx.Multiplicities()->Array1());
477 TColgp_Array1OfPnt TPoles(1, nbpoles);
478 for (ii=1; ii<=nbpoles; ii++) {
479 TPoles(ii) = ResPoles->Value(ii,1);
481 Handle(Geom_BsplineCurve) BS =
482 new (Geom_BsplineCurve) (Poles,
483 Approx.Knots()->Array1(),
484 Approx.Multiplicities()->Array1(),
486 for (ii=1; ii<=BSurf->NbVKnots(); ii++)
487 BS->InsertKnot( BSurf->VKnot(ii),
488 BSurf->VMultiplicity(ii),
489 Precision::Confusion());
490 TColgp_Array2OfPnt SurfPoles (1, BSurf->NbUPoles());
499 // Modified by skv - Thu Feb 5 18:05:03 2004 OCC5073 Begin
501 // * theSec should be constant
502 // * the type of section should be a line
503 // * theLoc should represent a translation.
505 static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw) &theLoc,
506 const Handle(GeomFill_SectionLaw) &theSec,
507 const Standard_Real theTol)
509 // Get the first and last transformations of the location
510 Standard_Real aFirst;
520 theLoc->GetDomain(aFirst, aLast);
522 // Get the first transformation
523 theLoc->D0(aFirst, M, VBegin);
525 GTfBegin.SetVectorialPart(M);
526 GTfBegin.SetTranslationPart(VBegin.XYZ());
528 TfBegin.SetValues(GTfBegin(1,1), GTfBegin(1,2), GTfBegin(1,3), GTfBegin(1,4),
529 GTfBegin(2,1), GTfBegin(2,2), GTfBegin(2,3), GTfBegin(2,4),
530 GTfBegin(3,1), GTfBegin(3,2), GTfBegin(3,3), GTfBegin(3,4));
532 // Get the last transformation
533 theLoc->D0(aLast, M, VEnd);
535 GTfEnd.SetVectorialPart(M);
536 GTfEnd.SetTranslationPart(VEnd.XYZ());
538 TfEnd.SetValues(GTfEnd(1,1), GTfEnd(1,2), GTfEnd(1,3), GTfEnd(1,4),
539 GTfEnd(2,1), GTfEnd(2,2), GTfEnd(2,3), GTfEnd(2,4),
540 GTfEnd(3,1), GTfEnd(3,2), GTfEnd(3,3), GTfEnd(3,4));
542 Handle(Geom_Surface) aSurf = theSec->BSplineSurface();
548 aSurf->Bounds(Umin, Umax, Vmin, Vmax);
550 // Get and transform the first section
551 Handle(Geom_Curve) FirstSection = theSec->ConstantSection();
552 GeomAdaptor_Curve ACFirst(FirstSection);
554 Standard_Real UFirst = ACFirst.FirstParameter();
555 gp_Lin L = ACFirst.Line();
557 L.Transform(TfBegin);
559 // Get and transform the last section
560 Handle(Geom_Curve) aLastSection = aSurf->VIso(Vmax);
561 Standard_Real aFirstParameter = aLastSection->FirstParameter();
562 gp_Pnt aPntLastSec = aLastSection->Value(aFirstParameter);
564 aPntLastSec.Transform(TfEnd);
566 gp_Pnt aPntFirstSec = ElCLib::Value( UFirst, L );
567 gp_Vec aVecSec( aPntFirstSec, aPntLastSec );
568 gp_Vec aVecSpine = VEnd - VBegin;
570 Standard_Boolean isParallel = aVecSec.IsParallel(aVecSpine, theTol);
574 // Modified by skv - Thu Feb 5 18:05:01 2004 OCC5073 End
576 //===============================================================
577 // Function : BuildKPart
579 //===============================================================
580 Standard_Boolean GeomFill_Sweep::BuildKPart()
582 Standard_Boolean Ok = Standard_False;
583 Standard_Boolean isUPeriodic = Standard_False;
584 Standard_Boolean isVPeriodic = Standard_False;
585 Standard_Boolean IsTrsf = Standard_True;
587 isUPeriodic = mySec->IsUPeriodic();
588 Handle(Geom_Surface) S;
589 GeomAbs_CurveType SectionType;
592 Standard_Real levier, error = 0 ;
593 Standard_Real UFirst=0, VFirst=First, ULast=0, VLast=Last;
594 Standard_Real Tol = Min (Tol3d, BoundTol);
596 // (1) Trajectoire Rectilignes -------------------------
597 if (myLoc->IsTranslation(error)) {
598 // Donne de la translation
606 Tf.SetVectorialPart(M);
607 Tf.SetTranslationPart(V.XYZ());
608 try { // Pas joli mais il n'y as pas d'autre moyens de tester SetValues
610 Tf2.SetValues(Tf(1,1), Tf(1,2), Tf(1,3), Tf(1,4),
611 Tf(2,1), Tf(2,2), Tf(2,3), Tf(2,4),
612 Tf(3,1), Tf(3,2), Tf(3,3), Tf(3,4));
614 catch (Standard_ConstructionError) {
615 IsTrsf = Standard_False;
618 return Standard_False;
621 // (1.1) Cas Extrusion
622 if (mySec->IsConstant(error)) {
623 Handle(Geom_Curve) Section;
624 Section = mySec->ConstantSection();
625 GeomAdaptor_Curve AC(Section);
626 SectionType = AC.GetType();
627 UFirst = AC.FirstParameter();
628 ULast = AC.LastParameter();
630 if ( (SectionType == GeomAbs_Line) && IsTrsf) {
631 // Modified by skv - Thu Feb 5 11:39:06 2004 OCC5073 Begin
632 if (!IsSweepParallelSpine(myLoc, mySec, Tol))
633 return Standard_False;
634 // Modified by skv - Thu Feb 5 11:39:08 2004 OCC5073 End
635 gp_Lin L = AC.Line();
637 DS.SetXYZ(L.Position().Direction().XYZ());
639 levier = Abs(DS.Dot(DP));
640 SError = error + levier * Abs(Last-First);
643 gp_Ax2 AxisOfPlane (L.Location(), DS^DP, DS);
644 S = new (Geom_Plane) (AxisOfPlane);
649 // (1.1.b) Cas Cylindrique
650 if ( (SectionType == GeomAbs_Circle) && IsTrsf) {
651 gp_Circ C = AC.Circle();
654 DS.SetXYZ (C.Position().Direction().XYZ());
656 levier = Abs(DS.CrossMagnitude(DP)) * C.Radius();
657 SError = levier * Abs(Last - First);
660 gp_Ax3 axe (C.Location(), DP, C.Position().XDirection());
661 S = new (Geom_CylindricalSurface)
663 if (C.Position().Direction().
664 IsOpposite(axe.Direction(), 0.1) ) {
666 // L'orientation parametrique est inversee
671 isUReversed = Standard_True;
677 // (1.1.c) C'est bien une extrusion
680 Section->Transform(Tf2);
681 S = new (Geom_SurfaceOfLinearExtrusion)
686 else { // extrusion sur BSpline
693 else if (mySec->IsConicalLaw(error)) {
695 gp_Pnt P1, P2, Centre0, Centre1, Centre2;
697 Handle(Geom_Curve) Section;
698 GeomAdaptor_Curve AC;
700 Standard_Real R1, R2;
703 Section = mySec->CirclSection(SLast);
704 Section->Transform(Tf2);
705 Section->Translate(Last*DP);
708 Centre2 = C.Location();
709 AC.D1(0, P2, dsection);
712 Section = mySec->CirclSection(SFirst);
713 Section->Transform(Tf2);
714 Section->Translate(First*DP);
717 Centre1 = C.Location();
721 Section = mySec->CirclSection(SFirst - First*(SLast-SFirst)/(Last-First));
722 Section->Transform(Tf2);
725 Centre0 = C.Location();
728 gp_Vec N(Centre1, P1);
729 if (N.Magnitude() < 1.e-9) {
730 gp_Vec Bis(Centre2, P2);
733 gp_Vec L(P1, P2), Dir(Centre1,Centre2);
735 Angle = L.Angle(Dir);
736 if ((Angle > 0.01) && (Angle < M_PI/2-0.01)) {
737 if (R2<R1) Angle = -Angle;
739 gp_Ax3 Axis(Centre0, Dir, N);
740 S = new (Geom_ConicalSurface)
741 (Axis, Angle, C.Radius());
742 // Calcul du glissement parametrique
743 VFirst = First / Cos(Angle);
744 VLast = Last / Cos(Angle);
747 UFirst = AC.FirstParameter();
748 ULast = AC.LastParameter();
751 S->VIso(VLast)->D1(0, pbis, diso);
752 if (diso.Magnitude()>1.e-9 && dsection.Magnitude()>1.e-9)
753 isUReversed = diso.IsOpposite(dsection, 0.1);
756 // L'orientation parametrique est inversee
769 // (2) Trajectoire Circulaire
770 if (myLoc->IsRotation(error)) {
771 if (mySec->IsConstant(error)) {
774 isVPeriodic = (Abs(Last-First -2*M_PI) < 1.e-15);
775 Standard_Real RotRadius;
777 myLoc->D0(0.1, M, DS);
779 myLoc->Rotation(Centre);
782 DS.SetXYZ(V.XYZ() - Centre.XYZ());
783 RotRadius = DS.Magnitude();
784 if (RotRadius > 1.e-15) DS.Normalize();
785 else return Standard_False; // Pas de KPart, rotation degeneree
793 Tf.SetVectorialPart(M);
794 Tf.SetTranslationPart(V.XYZ());
795 // try { // Pas joli mais il n'y as pas d'autre moyens de tester SetValues
797 Tf2.SetValues(Tf(1,1), Tf(1,2), Tf(1,3), Tf(1,4),
798 Tf(2,1), Tf(2,2), Tf(2,3), Tf(2,4),
799 Tf(3,1), Tf(3,2), Tf(3,3), Tf(3,4));
801 // catch (Standard_ConstructionError) {
802 // IsTrsf = Standard_False;
805 Handle(Geom_Curve) Section;
806 Section = mySec->ConstantSection();
807 GeomAdaptor_Curve AC(Section);
808 SectionType = AC.GetType();
809 UFirst = AC.FirstParameter();
810 ULast = AC.LastParameter();
812 // (2.1) Tore/Sphere ?
813 if ((SectionType == GeomAbs_Circle) && IsTrsf) {
814 gp_Circ C = AC.Circle();
815 Standard_Real Radius;
816 Standard_Boolean IsGoodSide = Standard_True;;
819 // On calcul le centre eventuel
820 DC.SetXYZ(C.Location().XYZ() - Centre.XYZ());
821 Centre.ChangeCoord() += (DC.Dot(DN))*DN.XYZ();
822 DC.SetXYZ(C.Location().XYZ() - Centre.XYZ());
823 Radius = DC.Magnitude(); //grand Rayon du tore
824 if ((Radius > Tol) && (DC.Dot(DS) < 0)) IsGoodSide = Standard_False;
825 if (Radius < Tol/100) DC = DS; // Pour definir le tore
827 // On verifie d'abord que le plan de la section est // a
830 NC.SetXYZ (C.Position().Direction().XYZ());
832 error = Abs(NC.Dot(DN));
833 // Puis on evalue l'erreur commise sur la section,
834 // en pivotant son plan ( pour contenir l'axe de rotation)
835 error += Abs(NC.Dot(DS));
839 error += Radius + Abs(RotRadius - C.Radius())/2;
842 Standard_Real f = UFirst , l = ULast;
844 Centre.BaryCenter(1.0, C.Location(), 1.0);
845 gp_Ax3 AxisOfSphere(Centre, DN, DS);
846 gp_Sphere theSphere( AxisOfSphere, (RotRadius + C.Radius())/2 );
847 S = new Geom_SphericalSurface(theSphere);
848 // Pour les spheres on ne peut pas controler le parametre
849 // V (donc U car myExchUV = Standard_True)
850 // Il faut donc modifier UFirst, ULast...
851 Standard_Real fpar = AC.FirstParameter();
852 Standard_Real lpar = AC.LastParameter();
853 Handle(Geom_Curve) theSection = new Geom_TrimmedCurve(Section, fpar, lpar);
854 theSection->Transform(Tf2);
855 gp_Pnt FirstPoint = theSection->Value(theSection->FirstParameter());
856 gp_Pnt LastPoint = theSection->Value(theSection->LastParameter());
857 Standard_Real UfirstOnSec, VfirstOnSec, UlastOnSec, VlastOnSec;
858 ElSLib::Parameters(theSphere, FirstPoint, UfirstOnSec, VfirstOnSec);
859 ElSLib::Parameters(theSphere, LastPoint, UlastOnSec, VlastOnSec);
860 if (VfirstOnSec < VlastOnSec)
867 // L'orientation parametrique est inversee
870 isUReversed = Standard_True;
873 if ( (f >= -M_PI/2) && (l <= M_PI/2)) {
875 myExchUV = Standard_True;
879 else { // On restaure ce qu'il faut
880 isUReversed = Standard_False;
883 else if (IsGoodSide) {
885 gp_Ax3 AxisOfTore(Centre, DN, DC);
886 S = new (Geom_ToroidalSurface) (AxisOfTore,
887 Radius , C.Radius());
889 // Pour les tores on ne peut pas controler le parametre
890 // V (donc U car myExchUV = Standard_True)
891 // Il faut donc modifier UFirst, ULast...
892 Handle(Geom_Circle) Iso;
893 Iso = Handle(Geom_Circle)::DownCast(S->UIso(0.));
895 axeiso = Iso->Circ().Position();
897 if (C.Position().Direction().
898 IsOpposite(axeiso.Direction(), 0.1) ) {
900 // L'orientation parametrique est inversee
905 isUReversed = Standard_True;
907 // On calcul le "glissement" parametrique.
909 rot = C.Position().XDirection().AngleWithRef
910 (axeiso.XDirection(), axeiso.Direction());
914 myExchUV = Standard_True;
915 // Attention l'arete de couture dans le cas periodique
916 // n'est peut etre pas a la bonne place...
917 if (isUPeriodic && Abs(UFirst)>Precision::PConfusion())
918 isUPeriodic = Standard_False; //Pour trimmer la surface...
926 // (2.2) Cone / Cylindre
927 if ((SectionType == GeomAbs_Line) && IsTrsf) {
928 gp_Lin L = AC.Line();
931 DL.SetXYZ(L.Direction().XYZ());
932 levier = Max(Abs(AC.FirstParameter()), AC.LastParameter());
933 // si la line est ortogonale au cercle de rotation
934 SError = error + levier * Abs(DL.Dot(DP));
936 Standard_Boolean reverse;
937 gp_Lin Dir(Centre, DN);
940 reverse = (aux < 0); // On choisit ici le sens de parametrisation
942 // Calcul du centre du vecteur supportant la "XDirection"
944 gp_Vec O1O2(Centre, L.Location()), trans;
946 trans *= DN.Dot(O1O2);
947 CentreOfSurf = Centre.Translated(trans);
948 DS.SetXYZ(L.Location().XYZ() - CentreOfSurf.XYZ());
951 error += (DL.XYZ()).CrossMagnitude(DN.XYZ())*levier;
954 // si la line est orthogonale au plan de rotation
956 gp_Ax3 Axis(CentreOfSurf, Dir.Direction(), DS);
957 S = new (Geom_CylindricalSurface)
958 (Axis, L.Distance(CentreOfSurf));
960 myExchUV = Standard_True;
963 // On evalue l'angle du cone
964 Standard_Real Angle = Abs(Dir.Angle(L));
965 if (Angle > M_PI/2) Angle = M_PI -Angle;
966 if (reverse) Angle = -Angle;
971 if (Abs(Abs(Angle) - M_PI/2) > 0.01) {
973 // si les 2 droites ne sont pas orthogonales
974 Standard_Real Radius = CentreOfSurf.Distance(L.Location());
975 gp_Ax3 Axis(CentreOfSurf, Dir.Direction(), DS);
976 S = new (Geom_ConicalSurface)
977 (Axis, Angle, Radius);
978 myExchUV = Standard_True;
982 // On n'as pas conclue, on remet l'erreur a 0.
987 // On reverse le parametre
988 Standard_Real uf, ul;
989 Handle(Geom_Line) CL = new (Geom_Line)(L);
990 uf = CL->ReversedParameter(ULast);
991 ul = CL->ReversedParameter(UFirst);
994 isUReversed = Standard_True;
1003 Section->Transform(Tf2);
1004 gp_Ax1 Axis (Centre, DN);
1005 S = new (Geom_SurfaceOfRevolution)
1007 myExchUV = Standard_True;
1016 if (Ok) { // On trimme la surface
1019 b = isUPeriodic; isUPeriodic = isVPeriodic; isVPeriodic = b;
1021 r = UFirst; UFirst = VFirst; VFirst = r;
1022 r = ULast; ULast = VLast; VLast = r;
1025 if (!isUPeriodic && !isVPeriodic)
1026 mySurface = new (Geom_RectangularTrimmedSurface)
1027 (S, UFirst, ULast, VFirst, VLast);
1028 else if (isUPeriodic) {
1029 if (isVPeriodic) mySurface = S;
1030 else mySurface = new (Geom_RectangularTrimmedSurface)
1031 (S, VFirst, VLast, Standard_False);
1034 mySurface = new (Geom_RectangularTrimmedSurface)
1035 (S,UFirst, ULast, Standard_True);
1038 if (isUPeriodic && !mySurface->IsUPeriodic())
1039 cout<<"Pb de periodicite en U" << endl;
1040 if (isUPeriodic && !mySurface->IsUClosed())
1041 cout<<"Pb de fermeture en U" << endl;
1042 if (isVPeriodic && !mySurface->IsVPeriodic())
1043 cout << "Pb de periodicite en V" << endl;
1044 if (isVPeriodic && !mySurface->IsVClosed())
1045 cout<<"Pb de fermeture en V" << endl;
1053 //===============================================================
1054 // Function : IsDone
1056 //===============================================================
1057 Standard_Boolean GeomFill_Sweep::IsDone() const
1062 //===============================================================
1063 // Function :ErrorOnSurface
1065 //===============================================================
1066 Standard_Real GeomFill_Sweep::ErrorOnSurface() const
1071 //===============================================================
1072 // Function ::ErrorOnRestriction
1074 //===============================================================
1075 void GeomFill_Sweep::ErrorOnRestriction(const Standard_Boolean IsFirst,
1076 Standard_Real& UError,
1077 Standard_Real& VError) const
1079 Standard_Integer ind;
1081 else ind = myCurve2d->Length();
1083 UError = CError->Value(1, ind);
1084 VError = CError->Value(2, ind);
1087 //===============================================================
1088 // Function :ErrorOnTrace
1090 //===============================================================
1091 void GeomFill_Sweep::ErrorOnTrace(const Standard_Integer IndexOfTrace,
1092 Standard_Real& UError,
1093 Standard_Real& VError) const
1095 Standard_Integer ind = IndexOfTrace+1;
1096 if (IndexOfTrace > myLoc->TraceNumber())
1097 Standard_OutOfRange::Raise(" GeomFill_Sweep::ErrorOnTrace");
1099 UError = CError->Value(1, ind);
1100 VError = CError->Value(2, ind);
1103 //===============================================================
1104 // Function :Surface
1106 //===============================================================
1107 Handle(Geom_Surface) GeomFill_Sweep::Surface() const
1112 //===============================================================
1113 // Function ::Restriction
1115 //===============================================================
1116 Handle(Geom2d_Curve) GeomFill_Sweep::Restriction(const Standard_Boolean IsFirst) const
1119 return myCurve2d->Value(1);
1120 return myCurve2d->Value(myCurve2d->Length());
1124 //===============================================================
1127 //===============================================================
1128 Standard_Integer GeomFill_Sweep::NumberOfTrace() const
1130 return myLoc->TraceNumber();
1133 //===============================================================
1136 //===============================================================
1137 Handle(Geom2d_Curve)
1138 GeomFill_Sweep::Trace(const Standard_Integer IndexOfTrace) const
1140 Standard_Integer ind = IndexOfTrace+1;
1141 if (IndexOfTrace > myLoc->TraceNumber())
1142 Standard_OutOfRange::Raise(" GeomFill_Sweep::Trace");
1143 return myCurve2d->Value(ind);