0031007: Coding - eliminate warnings issued while compiling with -pedantic flag
[occt.git] / src / GeomFill / GeomFill_Sweep.cxx
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
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 //  Modified by skv - Fri Feb  6 11:44:48 2004 OCC5073
18
19 #include <AdvApprox_ApproxAFunction.hxx>
20 #include <AdvApprox_PrefAndRec.hxx>
21 #include <Approx_SweepApproximation.hxx>
22 #include <ElCLib.hxx>
23 #include <ElSLib.hxx>
24 #include <Geom2d_BSplineCurve.hxx>
25 #include <Geom2d_Curve.hxx>
26 #include <Geom2d_Line.hxx>
27 #include <Geom2d_TrimmedCurve.hxx>
28 #include <Geom_BSplineSurface.hxx>
29 #include <Geom_Circle.hxx>
30 #include <Geom_ConicalSurface.hxx>
31 #include <Geom_CylindricalSurface.hxx>
32 #include <Geom_Line.hxx>
33 #include <Geom_Plane.hxx>
34 #include <Geom_RectangularTrimmedSurface.hxx>
35 #include <Geom_SphericalSurface.hxx>
36 #include <Geom_Surface.hxx>
37 #include <Geom_SurfaceOfLinearExtrusion.hxx>
38 #include <Geom_SurfaceOfRevolution.hxx>
39 #include <Geom_ToroidalSurface.hxx>
40 #include <Geom_TrimmedCurve.hxx>
41 #include <GeomAbs_CurveType.hxx>
42 #include <GeomAdaptor_Curve.hxx>
43 #include <GeomConvert_ApproxSurface.hxx>
44 #include <GeomFill_LocationLaw.hxx>
45 #include <GeomFill_LocFunction.hxx>
46 #include <GeomFill_SectionLaw.hxx>
47 #include <GeomFill_Sweep.hxx>
48 #include <GeomFill_SweepFunction.hxx>
49 #include <GeomLib.hxx>
50 #include <gp_Ax2.hxx>
51 #include <gp_Circ.hxx>
52 #include <gp_Dir.hxx>
53 #include <gp_Dir2d.hxx>
54 #include <gp_GTrsf.hxx>
55 #include <gp_Lin.hxx>
56 #include <gp_Mat.hxx>
57 #include <gp_Pnt.hxx>
58 #include <gp_Pnt2d.hxx>
59 #include <gp_Sphere.hxx>
60 #include <Precision.hxx>
61 #include <Standard_ConstructionError.hxx>
62 #include <Standard_ErrorHandler.hxx>
63 #include <Standard_OutOfRange.hxx>
64 #include <StdFail_NotDone.hxx>
65 #include <TColgp_Array1OfPnt.hxx>
66 #include <TColgp_Array2OfPnt.hxx>
67 #include <TColgp_HArray2OfPnt.hxx>
68 #include <TColStd_Array1OfInteger.hxx>
69 #include <TColStd_Array1OfReal.hxx>
70 #include <TColStd_Array2OfReal.hxx>
71
72 //#include <GeomLib_Array1OfMat.hxx>
73 //=======================================================================
74 //class : GeomFill_Sweep_Eval
75 //purpose: The evaluator for curve approximation
76 //=======================================================================
77 class GeomFill_Sweep_Eval : public AdvApprox_EvaluatorFunction
78 {
79  public:
80   GeomFill_Sweep_Eval (GeomFill_LocFunction& theTool)
81     : theAncore(theTool) {}
82   
83   virtual void Evaluate (Standard_Integer *Dimension,
84                          Standard_Real     StartEnd[2],
85                          Standard_Real    *Parameter,
86                          Standard_Integer *DerivativeRequest,
87                          Standard_Real    *Result, // [Dimension]
88                          Standard_Integer *ErrorCode);
89   
90  private:
91   GeomFill_LocFunction& theAncore;
92 };
93
94 void GeomFill_Sweep_Eval::Evaluate (Standard_Integer *,/*Dimension*/
95                                     Standard_Real     StartEnd[2],
96                                     Standard_Real    *Parameter,
97                                     Standard_Integer *DerivativeRequest,
98                                     Standard_Real    *Result,// [Dimension]
99                                     Standard_Integer *ErrorCode)
100 {
101   theAncore.DN (*Parameter,
102                 StartEnd[0],
103                 StartEnd[1],
104                 *DerivativeRequest, 
105                 Result[0],
106                 ErrorCode[0]);
107 }
108
109 //===============================================================
110 // Function : Create
111 // Purpose :
112 //===============================================================
113 GeomFill_Sweep::GeomFill_Sweep(const Handle(GeomFill_LocationLaw)& Location,
114                                const Standard_Boolean WithKpart)
115 {
116   done = Standard_False;
117
118   myLoc =  Location;
119   myKPart =  WithKpart;
120   SetTolerance(1.e-4);
121   myForceApproxC1 = Standard_False;
122
123   myLoc->GetDomain(First, Last);
124   SFirst = SLast = 30.081996;
125   SError = RealLast();
126 }
127
128 //===============================================================
129 // Function : SetDomain
130 // Purpose :
131 //===============================================================
132  void GeomFill_Sweep::SetDomain(const Standard_Real LocFirst,
133                                 const Standard_Real LocLast,
134                                 const Standard_Real SectionFirst,
135                                 const Standard_Real SectionLast) 
136 {
137   First = LocFirst;
138   Last =  LocLast;
139   SFirst = SectionFirst;
140   SLast = SectionLast;
141 }
142
143 //===============================================================
144 // Function : SetTolerance
145 // Purpose :
146 //===============================================================
147  void GeomFill_Sweep::SetTolerance(const Standard_Real Tolerance3d,
148                                    const Standard_Real BoundTolerance,
149                                    const Standard_Real Tolerance2d,
150                                    const Standard_Real ToleranceAngular) 
151 {
152   Tol3d = Tolerance3d;
153   BoundTol = BoundTolerance;
154   Tol2d =Tolerance2d;
155   TolAngular = ToleranceAngular;
156 }
157
158 //=======================================================================
159 //Function : SetForceApproxC1
160 //Purpose  : Set the flag that indicates attempt to approximate
161 //           a C1-continuous surface if a swept surface proved
162 //           to be C0.
163 //=======================================================================
164  void GeomFill_Sweep::SetForceApproxC1(const Standard_Boolean ForceApproxC1)
165 {
166   myForceApproxC1 = ForceApproxC1;
167 }
168
169
170 //===============================================================
171 // Function : ExchangeUV
172 // Purpose :
173 //===============================================================
174  Standard_Boolean GeomFill_Sweep::ExchangeUV() const
175 {
176   return myExchUV;
177 }
178
179 //===============================================================
180 // Function : UReversed
181 // Purpose :
182 //===============================================================
183  Standard_Boolean GeomFill_Sweep::UReversed() const
184 {
185   return isUReversed;
186 }
187
188 //===============================================================
189 // Function : VReversed
190 // Purpose :
191 //===============================================================
192  Standard_Boolean GeomFill_Sweep::VReversed() const
193 {
194   return isVReversed;
195 }
196
197 //===============================================================
198 // Function : Build
199 // Purpose :
200 //===============================================================
201  void GeomFill_Sweep::Build(const Handle(GeomFill_SectionLaw)& Section,        
202                             const GeomFill_ApproxStyle Methode,
203                             const GeomAbs_Shape Continuity,
204                             const Standard_Integer Degmax,
205                             const Standard_Integer Segmax) 
206 {
207   // Inits
208   done = Standard_False;
209   myExchUV = Standard_False;
210   isUReversed = isVReversed = Standard_False;
211   mySec =  Section;
212
213   if ((SFirst == SLast) &&  (SLast == 30.081996)) {
214     mySec->GetDomain(SFirst, SLast);
215   }
216    
217   Standard_Boolean isKPart = Standard_False, 
218                    isProduct  = Standard_False;
219  
220  // Traitement des KPart
221  if (myKPart)  isKPart = BuildKPart();
222  
223  // Traitement des produits Formelles
224  if ((!isKPart) && (Methode == GeomFill_Location)) {
225      Handle(Geom_BSplineSurface) BS;
226      BS = mySec->BSplineSurface();
227      if (! BS.IsNull()) {
228       // Approx de la loi
229 //    isProduct = BuildProduct(Continuity, Degmax, Segmax);
230      }
231    }
232
233  if (isKPart || isProduct) {
234  // Approx du 2d
235    done =  Build2d(Continuity, Degmax, Segmax);
236  }
237   else {
238  // Approx globale
239     done =  BuildAll(Continuity, Degmax, Segmax);
240   }
241 }
242
243 //===============================================================
244 // Function ::Build2d
245 // Purpose :A venir...
246 //===============================================================
247 // Standard_Boolean GeomFill_Sweep::Build2d(const GeomAbs_Shape Continuity,
248  Standard_Boolean GeomFill_Sweep::Build2d(const GeomAbs_Shape ,
249 //                                        const Standard_Integer Degmax,
250                                           const Standard_Integer ,
251 //                                        const Standard_Integer Segmax) 
252                                           const Standard_Integer ) 
253 {
254   Standard_Boolean Ok = Standard_False;
255   if (myLoc->Nb2dCurves() == 0) {
256     Ok = Standard_True;
257   }
258   return Ok;
259 }
260
261 //===============================================================
262 // Function : BuildAll
263 // Purpose :
264 //===============================================================
265  Standard_Boolean GeomFill_Sweep::BuildAll(const GeomAbs_Shape Continuity,
266                                            const Standard_Integer Degmax,
267                                            const Standard_Integer Segmax) 
268 {
269   Standard_Boolean Ok = Standard_False;
270
271   Handle(GeomFill_SweepFunction) Func 
272     = new (GeomFill_SweepFunction) (mySec, myLoc, First, SFirst,
273                                    (SLast-SFirst)/(Last-First) );
274   Approx_SweepApproximation Approx( Func );
275
276   Approx.Perform(First,  Last,
277                  Tol3d,  BoundTol,  Tol2d,  TolAngular,
278                  Continuity, Degmax,  Segmax);
279
280   if (Approx.IsDone()) {
281     Ok = Standard_True;
282
283 #ifdef OCCT_DEBUG
284     Approx.Dump(std::cout);
285 #endif
286     
287     // La surface
288     Standard_Integer UDegree,VDegree,NbUPoles,
289                      NbVPoles,NbUKnots,NbVKnots;
290     Approx.SurfShape(UDegree,VDegree,NbUPoles,
291                      NbVPoles,NbUKnots,NbVKnots);
292
293     TColgp_Array2OfPnt Poles(1,NbUPoles, 1,NbVPoles);
294     TColStd_Array2OfReal Weights(1,NbUPoles, 1,NbVPoles);
295     TColStd_Array1OfReal UKnots(1, NbUKnots),VKnots(1, NbVKnots); 
296     TColStd_Array1OfInteger UMults(1, NbUKnots), VMults(1, NbVKnots);
297
298     Approx.Surface(Poles, Weights,
299                    UKnots,VKnots,
300                    UMults,VMults);
301
302     mySurface = new (Geom_BSplineSurface)
303                    (Poles, Weights,
304                     UKnots,VKnots,
305                     UMults,VMults,
306                     Approx.UDegree(),  Approx.VDegree(),
307                     mySec->IsUPeriodic());
308     SError = Approx. MaxErrorOnSurf();
309
310     if (myForceApproxC1 && !mySurface->IsCNv(1))
311     {
312       Standard_Real theTol = 1.e-4;
313       GeomAbs_Shape theUCont = GeomAbs_C1, theVCont = GeomAbs_C1;
314       Standard_Integer degU = 14, degV = 14;
315       Standard_Integer nmax = 16;
316       Standard_Integer thePrec = 1;  
317       
318       GeomConvert_ApproxSurface ConvertApprox(mySurface,theTol,theUCont,theVCont,
319                                               degU,degV,nmax,thePrec);
320       if (ConvertApprox.HasResult())
321       {
322         mySurface = ConvertApprox.Surface();
323         myCurve2d = new  (TColGeom2d_HArray1OfCurve) (1, 2);
324         CError =  new (TColStd_HArray2OfReal) (1,2, 1,2);
325
326         Handle(Geom_BSplineSurface) BSplSurf (Handle(Geom_BSplineSurface)::DownCast(mySurface));
327         
328         gp_Dir2d D(0., 1.);
329         gp_Pnt2d P(BSplSurf->UKnot(1), 0);
330         Handle(Geom2d_Line) LC1 = new (Geom2d_Line) (P, D);
331         Handle(Geom2d_TrimmedCurve) TC1 =
332           new (Geom2d_TrimmedCurve) (LC1, 0, BSplSurf->VKnot(BSplSurf->NbVKnots()));
333         
334         myCurve2d->SetValue(1, TC1);
335         CError->SetValue(1, 1, 0.);
336         CError->SetValue(2, 1, 0.);
337  
338         P.SetCoord(BSplSurf->UKnot(BSplSurf->NbUKnots()), 0);
339         Handle(Geom2d_Line) LC2 = new (Geom2d_Line) (P, D);
340         Handle(Geom2d_TrimmedCurve) TC2 = 
341           new (Geom2d_TrimmedCurve) (LC2, 0, BSplSurf->VKnot(BSplSurf->NbVKnots()));
342         
343         myCurve2d->SetValue(myCurve2d->Length(), TC2);
344         CError->SetValue(1, myCurve2d->Length(), 0.);
345         CError->SetValue(2, myCurve2d->Length(), 0.);
346         
347         SError = theTol;
348       }
349     } //if (!mySurface->IsCNv(1))
350     
351     // Les Courbes 2d
352     if (myCurve2d.IsNull())
353     {
354       myCurve2d = new  (TColGeom2d_HArray1OfCurve) (1, 2+myLoc->TraceNumber());
355       CError =  new (TColStd_HArray2OfReal) (1,2, 1, 2+myLoc->TraceNumber());
356       Standard_Integer kk,ii, ifin = 1, ideb;
357       
358       if (myLoc->HasFirstRestriction()) {
359         ideb = 1;
360       }
361       else {
362         ideb = 2;
363       }
364       ifin += myLoc->TraceNumber();
365       if (myLoc->HasLastRestriction()) ifin++;
366       
367       for (ii=ideb, kk=1; ii<=ifin; ii++, kk++) {
368         Handle(Geom2d_BSplineCurve) C 
369           = new (Geom2d_BSplineCurve) (Approx.Curve2dPoles(kk),
370                                        Approx.Curves2dKnots(),
371                                        Approx.Curves2dMults(),
372                                        Approx.Curves2dDegree());
373         myCurve2d->SetValue(ii, C);
374         CError->SetValue(1, ii,  Approx.Max2dError(kk));
375         CError->SetValue(2, ii,  Approx.Max2dError(kk));
376       }
377       
378       // Si les courbes de restriction, ne sont pas calcules, on prend
379       // les iso Bords.
380       if (! myLoc->HasFirstRestriction()) {
381         gp_Dir2d D(0., 1.);
382         gp_Pnt2d P(UKnots(UKnots.Lower()), 0);
383         Handle(Geom2d_Line) LC = new (Geom2d_Line) (P, D);
384         Handle(Geom2d_TrimmedCurve) TC = new (Geom2d_TrimmedCurve)
385           (LC, First, Last);
386         
387         myCurve2d->SetValue(1, TC);
388         CError->SetValue(1, 1, 0.);
389         CError->SetValue(2, 1, 0.);
390       }
391       
392       if (! myLoc->HasLastRestriction()) {
393         gp_Dir2d D(0., 1.);
394         gp_Pnt2d P(UKnots(UKnots.Upper()), 0);
395         Handle(Geom2d_Line) LC = new (Geom2d_Line) (P, D);
396         Handle(Geom2d_TrimmedCurve) TC = 
397           new (Geom2d_TrimmedCurve) (LC, First, Last);
398         myCurve2d->SetValue(myCurve2d->Length(), TC);
399         CError->SetValue(1, myCurve2d->Length(), 0.);
400         CError->SetValue(2, myCurve2d->Length(), 0.);
401       }
402     } //if (myCurve2d.IsNull())
403   } 
404   return Ok;
405 }
406
407 //===============================================================
408 // Function : BuildProduct
409 // Purpose : A venir...
410 //===============================================================
411  Standard_Boolean GeomFill_Sweep::BuildProduct(const GeomAbs_Shape Continuity,
412                                           const Standard_Integer Degmax,
413                                           const Standard_Integer Segmax) 
414 {
415   Standard_Boolean Ok = Standard_False;
416
417   Handle(Geom_BSplineSurface) BSurf;
418   BSurf = Handle(Geom_BSplineSurface)::DownCast(
419            mySec->BSplineSurface()->Copy());
420   if (BSurf.IsNull()) return Ok; // Ce mode de construction est impossible  
421
422
423   Standard_Integer NbIntervalC2,  NbIntervalC3;
424   GeomFill_LocFunction Func(myLoc);
425
426   NbIntervalC2 = myLoc->NbIntervals(GeomAbs_C2);
427   NbIntervalC3 = myLoc->NbIntervals(GeomAbs_C3);
428   TColStd_Array1OfReal Param_de_decoupeC2 (1, NbIntervalC2+1);
429   myLoc->Intervals(Param_de_decoupeC2, GeomAbs_C2);
430   TColStd_Array1OfReal Param_de_decoupeC3 (1, NbIntervalC3+1);
431   myLoc->Intervals(Param_de_decoupeC3, GeomAbs_C3);
432
433
434   AdvApprox_PrefAndRec Preferentiel(Param_de_decoupeC2,
435                                      Param_de_decoupeC3);
436    
437   Handle(TColStd_HArray1OfReal) ThreeDTol = new (TColStd_HArray1OfReal) (1,4);
438   ThreeDTol->Init(Tol3d); // A Affiner...
439
440   GeomFill_Sweep_Eval eval (Func);
441   AdvApprox_ApproxAFunction Approx(0, 0, 4,
442                                    ThreeDTol,
443                                    ThreeDTol,
444                                    ThreeDTol,
445                                    First,
446                                    Last, 
447                                    Continuity,
448                                    Degmax,
449                                    Segmax, 
450                                    eval,
451                                    Preferentiel);
452 #ifdef OCCT_DEBUG
453   Approx.Dump(std::cout);
454 #endif
455
456   Ok = Approx.HasResult();
457   if (Ok) {
458 /*    TColgp_Array1OfMat TM(1, nbpoles);
459     Handle(TColgp_HArray2OfPnt) ResPoles;
460     ResPoles = Approx.Poles();
461
462     // Produit Tensoriel
463     for (ii=1; ii<=nbpoles; ii++) {
464       TM(ii).SetCols(ResPoles->Value(ii,2).XYZ(), 
465                      ResPoles->Value(ii,3).XYZ(),  
466                      ResPoles->Value(ii,4).XYZ());
467       TR(ii) = ResPoles->Value(ii,1);
468     }
469     GeomLib::TensorialProduct(BSurf, TM, TR,
470                               Approx.Knots()->Array1(), 
471                               Approx.Multiplicities()->Array1());
472
473     // Somme
474     TColgp_Array1OfPnt TPoles(1, nbpoles);
475     for (ii=1; ii<=nbpoles; ii++) {
476       TPoles(ii) = ResPoles->Value(ii,1);
477     }
478     Handle(Geom_BsplineCurve) BS = 
479       new (Geom_BsplineCurve) (Poles, 
480                                Approx.Knots()->Array1(), 
481                                Approx.Multiplicities()->Array1(),
482                                Approx.Degree());
483     for (ii=1; ii<=BSurf->NbVKnots(); ii++)
484       BS->InsertKnot( BSurf->VKnot(ii), 
485                      BSurf->VMultiplicity(ii), 
486                      Precision::Confusion());
487    TColgp_Array2OfPnt SurfPoles (1, BSurf->NbUPoles());
488    for (ii=1; 
489         
490 */
491     mySurface = BSurf;
492   }
493   return Ok;
494 }
495
496 //  Modified by skv - Thu Feb  5 18:05:03 2004 OCC5073 Begin
497 //  Conditions:
498 //     * theSec should be constant
499 //     * the type of section should be a line
500 //     * theLoc should represent a translation.
501
502 static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw) &theLoc,
503                              const Handle(GeomFill_SectionLaw)  &theSec,
504                              const Standard_Real                 theTol)
505 {
506   // Get the first and last transformations of the location
507   Standard_Real aFirst;
508   Standard_Real aLast;
509   gp_Vec        VBegin;
510   gp_Vec        VEnd;
511   gp_Mat        M;
512   gp_GTrsf      GTfBegin;
513   gp_Trsf       TfBegin;
514   gp_GTrsf      GTfEnd;
515   gp_Trsf       TfEnd;
516
517   theLoc->GetDomain(aFirst, aLast);
518
519 // Get the first transformation
520   theLoc->D0(aFirst, M, VBegin);
521
522   GTfBegin.SetVectorialPart(M);
523   GTfBegin.SetTranslationPart(VBegin.XYZ());
524
525   TfBegin.SetValues(GTfBegin(1,1), GTfBegin(1,2), GTfBegin(1,3), GTfBegin(1,4),
526                     GTfBegin(2,1), GTfBegin(2,2), GTfBegin(2,3), GTfBegin(2,4),
527                     GTfBegin(3,1), GTfBegin(3,2), GTfBegin(3,3), GTfBegin(3,4));
528
529 // Get the last transformation
530   theLoc->D0(aLast, M, VEnd);
531
532   GTfEnd.SetVectorialPart(M);
533   GTfEnd.SetTranslationPart(VEnd.XYZ());
534
535   TfEnd.SetValues(GTfEnd(1,1), GTfEnd(1,2), GTfEnd(1,3), GTfEnd(1,4),
536                   GTfEnd(2,1), GTfEnd(2,2), GTfEnd(2,3), GTfEnd(2,4),
537                   GTfEnd(3,1), GTfEnd(3,2), GTfEnd(3,3), GTfEnd(3,4));
538
539   Handle(Geom_Surface) aSurf = theSec->BSplineSurface();
540   Standard_Real Umin;
541   Standard_Real Umax;
542   Standard_Real Vmin;
543   Standard_Real Vmax;
544
545   aSurf->Bounds(Umin, Umax, Vmin, Vmax);
546
547   // Get and transform the first section
548   Handle(Geom_Curve) FirstSection = theSec->ConstantSection();
549   GeomAdaptor_Curve  ACFirst(FirstSection);
550
551   Standard_Real UFirst = ACFirst.FirstParameter();
552   gp_Lin        L      = ACFirst.Line();
553
554   L.Transform(TfBegin);
555
556   // Get and transform the last section
557   Handle(Geom_Curve) aLastSection    = aSurf->VIso(Vmax);
558   Standard_Real      aFirstParameter = aLastSection->FirstParameter();
559   gp_Pnt             aPntLastSec     = aLastSection->Value(aFirstParameter);
560
561   aPntLastSec.Transform(TfEnd);
562
563   gp_Pnt        aPntFirstSec = ElCLib::Value( UFirst, L );
564   gp_Vec        aVecSec( aPntFirstSec, aPntLastSec );
565   gp_Vec        aVecSpine = VEnd - VBegin;
566
567   Standard_Boolean isParallel = aVecSec.IsParallel(aVecSpine, theTol);
568
569   return isParallel;
570 }
571 //  Modified by skv - Thu Feb  5 18:05:01 2004 OCC5073 End
572
573 //===============================================================
574 // Function : BuildKPart
575 // Purpose :
576 //===============================================================
577  Standard_Boolean GeomFill_Sweep::BuildKPart() 
578 {
579   Standard_Boolean Ok = Standard_False;
580   Standard_Boolean isUPeriodic = Standard_False;
581   Standard_Boolean isVPeriodic = Standard_False;
582   Standard_Boolean IsTrsf = Standard_True;
583
584   isUPeriodic = mySec->IsUPeriodic();
585   Handle(Geom_Surface) S;
586   GeomAbs_CurveType SectionType;
587   gp_Vec V;
588   gp_Mat M;
589   Standard_Real levier, error = 0 ;
590   Standard_Real UFirst=0, VFirst=First, ULast=0, VLast=Last;
591   Standard_Real Tol = Min (Tol3d, BoundTol);
592
593   // (1) Trajectoire Rectilignes -------------------------
594   if (myLoc->IsTranslation(error)) {
595     // Donne de la translation
596     gp_Vec DP, DS;
597     myLoc->D0(1, M, DS);
598     myLoc->D0(0, M, V);
599     DP = DS - V;
600     DP.Normalize();
601     gp_GTrsf Tf;
602     gp_Trsf Tf2;
603     Tf.SetVectorialPart(M);
604     Tf.SetTranslationPart(V.XYZ());
605     try { // Pas joli mais il n'y as pas d'autre moyens de tester SetValues
606       OCC_CATCH_SIGNALS
607       Tf2.SetValues(Tf(1,1), Tf(1,2), Tf(1,3), Tf(1,4),
608                     Tf(2,1), Tf(2,2), Tf(2,3), Tf(2,4),
609                     Tf(3,1), Tf(3,2), Tf(3,3), Tf(3,4));
610     }
611     catch (Standard_ConstructionError const&) {
612       IsTrsf = Standard_False;
613     }
614     if (!IsTrsf) {
615       return Standard_False;
616     }
617
618     // (1.1) Cas Extrusion
619     if (mySec->IsConstant(error)) {
620       Handle(Geom_Curve) Section;
621       Section = mySec->ConstantSection();
622       GeomAdaptor_Curve AC(Section);
623       SectionType = AC.GetType();
624       UFirst = AC.FirstParameter();
625       ULast  = AC.LastParameter();
626   // (1.1.a) Cas Plan
627       if ( (SectionType == GeomAbs_Line) && IsTrsf) {
628 //  Modified by skv - Thu Feb  5 11:39:06 2004 OCC5073 Begin
629         if (!IsSweepParallelSpine(myLoc, mySec, Tol))
630           return Standard_False;
631 //  Modified by skv - Thu Feb  5 11:39:08 2004 OCC5073 End
632         gp_Lin L = AC.Line();
633         L.Transform(Tf2);
634         DS.SetXYZ(L.Position().Direction().XYZ());
635         DS.Normalize();
636         levier = Abs(DS.Dot(DP));
637         SError = error + levier * Abs(Last-First);
638         if (SError <= Tol) {
639           Ok = Standard_True;
640           gp_Ax2 AxisOfPlane (L.Location(), DS^DP, DS);
641           S = new (Geom_Plane) (AxisOfPlane);
642         }
643         else SError = 0.;
644       }
645     
646   // (1.1.b) Cas Cylindrique
647       if ( (SectionType == GeomAbs_Circle) && IsTrsf) {
648         const Standard_Real TolProd = 1.e-6;
649         
650         gp_Circ C = AC.Circle();
651         C.Transform(Tf2);
652         
653         DS.SetXYZ (C.Position().Direction().XYZ());
654         DS.Normalize();
655         levier = Abs(DS.CrossMagnitude(DP)) * C.Radius();
656         SError = levier * Abs(Last - First);
657         if (SError <= TolProd) {
658           Ok = Standard_True;
659           gp_Ax3 axe (C.Location(), DP, C.Position().XDirection());
660           S = new (Geom_CylindricalSurface) 
661             (axe, C.Radius());
662             if (C.Position().Direction().
663                 IsOpposite(axe.Direction(), 0.1) ) {
664               Standard_Real f, l;
665               // L'orientation parametrique est inversee
666               l = 2*M_PI - UFirst;
667               f = 2*M_PI - ULast;
668               UFirst = f;
669               ULast  = l;
670               isUReversed = Standard_True;
671             }
672         }
673         else SError = 0.;
674       }
675
676   // (1.1.c) C'est bien une extrusion
677       if (!Ok) {
678         if (IsTrsf) {
679           Section->Transform(Tf2);
680           S = new (Geom_SurfaceOfLinearExtrusion)
681             (Section, DP);
682           SError = 0.;
683           Ok = Standard_True;
684         }
685         else { // extrusion sur BSpline
686           
687         }
688       }
689     }
690   
691   // (1.2) Cas conique
692    else if (mySec->IsConicalLaw(error)) {
693
694      gp_Pnt P1, P2, Centre0, Centre1, Centre2;
695      gp_Vec dsection;
696      Handle(Geom_Curve) Section;
697      GeomAdaptor_Curve AC;
698      gp_Circ C;
699      Standard_Real R1, R2;
700
701
702      Section = mySec->CirclSection(SLast);
703      Section->Transform(Tf2);
704      Section->Translate(Last*DP);
705      AC.Load(Section);
706      C = AC.Circle();
707      Centre2 = C.Location();
708      AC.D1(0, P2, dsection);
709      R2 = C.Radius();
710     
711      Section = mySec->CirclSection(SFirst);
712      Section->Transform(Tf2);
713      Section->Translate(First*DP);
714      AC.Load(Section);
715      C =  AC.Circle();
716      Centre1 = C.Location();
717      P1 = AC.Value(0);
718      R1 = C.Radius();
719
720      Section = mySec->CirclSection(SFirst - First*(SLast-SFirst)/(Last-First));
721      Section->Transform(Tf2);
722      AC.Load(Section);
723      C =  AC.Circle();     
724      Centre0 = C.Location();
725      
726      Standard_Real Angle;
727      gp_Vec  N(Centre1, P1);
728      if (N.Magnitude() < 1.e-9) {
729        gp_Vec Bis(Centre2, P2);
730        N = Bis;
731      }
732      gp_Vec  L(P1, P2), Dir(Centre1,Centre2);
733
734      Angle = L.Angle(Dir);
735      if ((Angle > 0.01) && (Angle < M_PI/2-0.01)) {
736        if (R2<R1) Angle = -Angle;
737        SError = error;
738        gp_Ax3 Axis(Centre0, Dir, N);
739        S = new (Geom_ConicalSurface) 
740          (Axis, Angle, C.Radius());
741        // Calcul du glissement parametrique
742        VFirst = First / Cos(Angle);
743        VLast  = Last  / Cos(Angle);
744
745        // Bornes en U
746        UFirst = AC.FirstParameter();
747        ULast  = AC.LastParameter();
748        gp_Vec diso;
749        gp_Pnt pbis;
750        S->VIso(VLast)->D1(0, pbis, diso);
751        if (diso.Magnitude()>1.e-9 && dsection.Magnitude()>1.e-9)
752          isUReversed = diso.IsOpposite(dsection, 0.1);
753        if (isUReversed ) {
754          Standard_Real f, l;
755          // L'orientation parametrique est inversee
756          l = 2*M_PI - UFirst;
757          f = 2*M_PI - ULast;
758          UFirst = f;
759          ULast  = l;
760        } 
761
762        // C'est un cone
763        Ok = Standard_True;
764      }
765    }
766   }
767
768   // (2) Trajectoire Circulaire
769   if (myLoc->IsRotation(error)) {
770     if (mySec->IsConstant(error)) {
771       // La trajectoire
772       gp_Pnt Centre;
773       isVPeriodic = (Abs(Last-First -2*M_PI) < 1.e-15);
774       Standard_Real RotRadius;
775       gp_Vec DP, DS, DN;
776       myLoc->D0(0.1, M, DS);
777       myLoc->D0(0, M, V);
778       myLoc->Rotation(Centre);
779
780       DP = DS - V;
781       DS.SetXYZ(V.XYZ() - Centre.XYZ());   
782       RotRadius = DS.Magnitude();
783       if (RotRadius > 1.e-15) DS.Normalize();
784       else return Standard_False; // Pas de KPart, rotation degeneree
785       DN = DS ^ DP;
786       DN.Normalize();
787       DP = DN ^ DS;
788       DP.Normalize();
789
790       gp_GTrsf Tf;
791       gp_Trsf Tf2;
792       Tf.SetVectorialPart(M);
793       Tf.SetTranslationPart(V.XYZ());
794 //      try { // Pas joli mais il n'y as pas d'autre moyens de tester SetValues
795 //        OCC_CATCH_SIGNALS
796         Tf2.SetValues(Tf(1,1), Tf(1,2), Tf(1,3), Tf(1,4),
797                       Tf(2,1), Tf(2,2), Tf(2,3), Tf(2,4),
798                       Tf(3,1), Tf(3,2), Tf(3,3), Tf(3,4));
799 //      }
800 //      catch (Standard_ConstructionError) {
801 //      IsTrsf = Standard_False;
802 //      }
803       // La section
804       Handle(Geom_Curve) Section;
805       Section = mySec->ConstantSection();
806       GeomAdaptor_Curve AC(Section);
807       SectionType = AC.GetType();
808       UFirst = AC.FirstParameter();
809       ULast  = AC.LastParameter();
810
811       // (2.1) Tore/Sphere ?
812       if ((SectionType == GeomAbs_Circle) && IsTrsf) {
813         gp_Circ C = AC.Circle();
814         Standard_Real Radius;
815         Standard_Boolean IsGoodSide = Standard_True;
816         C.Transform(Tf2);
817         gp_Vec DC;
818         // On calcul le centre eventuel
819         DC.SetXYZ(C.Location().XYZ() - Centre.XYZ());
820         Centre.ChangeCoord() += (DC.Dot(DN))*DN.XYZ();
821         DC.SetXYZ(C.Location().XYZ() - Centre.XYZ());
822         Radius = DC.Magnitude(); //grand Rayon du tore
823         if ((Radius > Tol) && (DC.Dot(DS) < 0)) IsGoodSide = Standard_False;
824         if (Radius < Tol/100) DC = DS; // Pour definir le tore
825
826         // On verifie d'abord que le plan de la section est // a 
827         // l'axe de rotation
828         gp_Vec NC;
829         NC.SetXYZ (C.Position().Direction().XYZ());
830         NC.Normalize();
831         error =  Abs(NC.Dot(DN));
832         // Puis on evalue l'erreur commise sur la section, 
833         // en pivotant son plan ( pour contenir l'axe de rotation)
834         error += Abs(NC.Dot(DS));
835         error *= C.Radius();
836         if (error <= Tol) {
837           SError = error;
838           error += Radius;
839           if (Radius <= Tol) {
840             // (2.1.a) Sphere
841             Standard_Real f = UFirst , l =  ULast, aRadius = 0.0;
842             SError = error;
843             Centre.BaryCenter(1.0, C.Location(), 1.0); 
844             gp_Ax3 AxisOfSphere(Centre, DN, DS);
845             aRadius = C.Radius();
846             gp_Sphere theSphere( AxisOfSphere, aRadius );
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)
861             {
862               f = VfirstOnSec;
863               l = VlastOnSec;
864             }
865             else
866             {
867               // L'orientation parametrique est inversee
868               f = VlastOnSec;
869               l = VfirstOnSec;
870               isUReversed = Standard_True;
871             }
872
873             if ( (f >= -M_PI/2) && (l <= M_PI/2)) {
874               Ok = Standard_True;
875               myExchUV = Standard_True;
876               UFirst = f;
877               ULast  = l;
878             }
879             else { // On restaure ce qu'il faut
880               isUReversed = Standard_False;
881             }
882           }
883           else if (IsGoodSide) {         
884             // (2.1.b) Tore
885             gp_Ax3 AxisOfTore(Centre, DN, DC);
886             S = new (Geom_ToroidalSurface) (AxisOfTore, 
887                    Radius , C.Radius());
888         
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.));
894             gp_Ax2 axeiso;
895             axeiso = Iso->Circ().Position();
896               
897             if (C.Position().Direction().
898                 IsOpposite(axeiso.Direction(), 0.1) ) {
899               Standard_Real f, l;
900               // L'orientation parametrique est inversee
901               l = 2*M_PI - UFirst;
902               f = 2*M_PI - ULast;
903               UFirst = f;
904               ULast  = l;
905               isUReversed = Standard_True;
906             }
907             // On calcul le "glissement" parametrique.
908             Standard_Real rot; 
909             rot = C.Position().XDirection().AngleWithRef
910               (axeiso.XDirection(), axeiso.Direction());
911             UFirst -= rot;
912             ULast  -= rot;
913
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...
919             Ok = Standard_True;
920           }
921         }
922         else {
923           SError = 0.;
924         }
925       }
926       // (2.2) Cone / Cylindre
927       if ((SectionType == GeomAbs_Line) && IsTrsf)  {
928         gp_Lin L =  AC.Line();
929         L.Transform(Tf2);
930         gp_Vec DL;
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));
935         if (SError <= Tol) {
936           Standard_Boolean reverse;
937           gp_Lin Dir(Centre, DN);
938           Standard_Real aux;
939           aux = DL.Dot(DN);
940           reverse = (aux < 0);  // On choisit ici le sens de parametrisation
941             
942           // Calcul du centre du vecteur supportant la "XDirection"
943           gp_Pnt CentreOfSurf;
944           gp_Vec O1O2(Centre, L.Location()), trans;
945           trans = DN;
946           trans *= DN.Dot(O1O2);
947           CentreOfSurf = Centre.Translated(trans);
948           DS.SetXYZ(L.Location().XYZ() - CentreOfSurf.XYZ());
949
950           error = SError;
951           error += (DL.XYZ()).CrossMagnitude(DN.XYZ())*levier;
952           if (error <= Tol) {
953             // (2.2.a) Cylindre
954             // si la line est orthogonale au plan de rotation
955             SError = error;
956             gp_Ax3 Axis(CentreOfSurf, Dir.Direction(), DS);
957             S = new (Geom_CylindricalSurface) 
958                     (Axis, L.Distance(CentreOfSurf));
959             Ok = Standard_True;
960             myExchUV = Standard_True;
961           }
962           else {
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;
967             aux = DS.Dot(DL);
968             if (aux < 0) {
969               Angle = - Angle;
970             }
971             if (Abs(Abs(Angle) - M_PI/2) > 0.01) {
972               // (2.2.b) Cone
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;
979               Ok = Standard_True;
980             }
981             else {
982               // On n'as pas conclue, on remet l'erreur a 0.
983               SError = 0.;
984             }
985           }
986           if (Ok && reverse) {
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);
992             UFirst = uf;
993             ULast = ul;
994             isUReversed = Standard_True;
995           }
996         }
997         else SError = 0.;
998       }
999   
1000       // (2.3) Revolution
1001       if (!Ok) {
1002         if (IsTrsf) { 
1003           Section->Transform(Tf2);
1004           gp_Ax1 Axis (Centre, DN);
1005           S = new (Geom_SurfaceOfRevolution)
1006             (Section, Axis);
1007           myExchUV = Standard_True;
1008           SError = 0.;
1009           Ok = Standard_True;
1010         }
1011       }
1012     }
1013   }
1014
1015
1016   if (Ok) { // On trimme la surface
1017     if (myExchUV) {
1018       Standard_Boolean b;
1019       b = isUPeriodic; isUPeriodic = isVPeriodic;  isVPeriodic = b;
1020       Standard_Real r;
1021       r = UFirst; UFirst = VFirst; VFirst = r;
1022       r = ULast; ULast = VLast; VLast = r;
1023     }
1024
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);
1032     }
1033     else
1034       mySurface = new (Geom_RectangularTrimmedSurface)
1035         (S,UFirst, ULast, Standard_True);
1036
1037 #ifdef OCCT_DEBUG
1038   if (isUPeriodic && !mySurface->IsUPeriodic()) 
1039     std::cout<<"Pb de periodicite en U" << std::endl;
1040   if (isUPeriodic && !mySurface->IsUClosed())
1041     std::cout<<"Pb de fermeture en U" << std::endl;
1042   if (isVPeriodic && !mySurface->IsVPeriodic()) 
1043     std::cout << "Pb de periodicite en V" << std::endl;
1044   if (isVPeriodic && !mySurface->IsVClosed())
1045     std::cout<<"Pb de fermeture en V" << std::endl;
1046 #endif
1047   }
1048
1049
1050   return Ok;
1051 }
1052
1053 //===============================================================
1054 // Function : IsDone
1055 // Purpose :
1056 //===============================================================
1057  Standard_Boolean GeomFill_Sweep::IsDone() const
1058 {
1059   return done;
1060 }
1061
1062 //===============================================================
1063 // Function :ErrorOnSurface
1064 // Purpose :
1065 //===============================================================
1066  Standard_Real GeomFill_Sweep::ErrorOnSurface() const
1067 {
1068   return SError;
1069 }
1070
1071 //===============================================================
1072 // Function ::ErrorOnRestriction
1073 // Purpose :
1074 //===============================================================
1075  void GeomFill_Sweep::ErrorOnRestriction(const Standard_Boolean IsFirst,
1076                                          Standard_Real& UError,
1077                                          Standard_Real& VError) const
1078 {
1079   Standard_Integer ind;
1080   if (IsFirst) ind=1;
1081   else ind = myCurve2d->Length();
1082
1083   UError =  CError->Value(1, ind);
1084   VError =  CError->Value(2, ind);
1085 }
1086
1087 //===============================================================
1088 // Function :ErrorOnTrace
1089 // Purpose :
1090 //===============================================================
1091  void GeomFill_Sweep::ErrorOnTrace(const Standard_Integer IndexOfTrace,
1092                                    Standard_Real& UError,
1093                                    Standard_Real& VError) const
1094 {
1095   Standard_Integer ind = IndexOfTrace+1;
1096   if (IndexOfTrace > myLoc->TraceNumber())
1097     throw Standard_OutOfRange(" GeomFill_Sweep::ErrorOnTrace");
1098
1099   UError =  CError->Value(1, ind);
1100   VError =  CError->Value(2, ind);
1101 }
1102
1103 //===============================================================
1104 // Function :Surface
1105 // Purpose :
1106 //===============================================================
1107  Handle(Geom_Surface) GeomFill_Sweep::Surface() const
1108 {
1109   return mySurface;
1110 }
1111
1112 //===============================================================
1113 // Function ::Restriction
1114 // Purpose :
1115 //===============================================================
1116  Handle(Geom2d_Curve) GeomFill_Sweep::Restriction(const Standard_Boolean IsFirst) const
1117 {
1118   if (IsFirst)
1119     return  myCurve2d->Value(1);
1120   return  myCurve2d->Value(myCurve2d->Length());
1121  
1122 }
1123
1124 //===============================================================
1125 // Function :
1126 // Purpose :
1127 //===============================================================
1128  Standard_Integer GeomFill_Sweep::NumberOfTrace() const
1129 {
1130   return myLoc->TraceNumber();
1131 }
1132
1133 //===============================================================
1134 // Function : 
1135 // Purpose :
1136 //===============================================================
1137  Handle(Geom2d_Curve) 
1138      GeomFill_Sweep::Trace(const Standard_Integer IndexOfTrace) const
1139 {
1140   Standard_Integer ind = IndexOfTrace+1;
1141   if (IndexOfTrace > myLoc->TraceNumber())
1142     throw Standard_OutOfRange(" GeomFill_Sweep::Trace");
1143   return  myCurve2d->Value(ind);  
1144 }