Integration of OCCT 6.5.0 from SVN
[occt.git] / samples / mfc / occtdemo / Sweep / Sweep_Presentation.cpp
1 // Sweep_Presentation.cpp: implementation of the Sweep_Presentation class.
2 // Sweeping capabilities presentation
3 //////////////////////////////////////////////////////////////////////
4
5 #include "stdafx.h"
6 #include "Sweep_Presentation.h"
7
8 #include <Geom_BezierCurve.hxx>
9 #include <TColgp_Array1OfPnt.hxx>
10 #include <GeomFill_Pipe.hxx>
11 #include <Geom_Surface.hxx>
12 #include <TColgp_Array1OfPnt2d.hxx>
13 #include <Geom2d_BezierCurve.hxx>
14 #include <TColgp_Array2OfPnt.hxx>
15 #include <Geom_BezierSurface.hxx>
16 #include <Geom2dAdaptor_HCurve.hxx>
17 #include <GeomAdaptor_HSurface.hxx>
18 #include <Approx_CurveOnSurface.hxx>
19 #include <TopoDS_Wire.hxx>
20 #include <TopoDS_Edge.hxx>
21 #include <BRepBuilderAPI_MakeEdge.hxx>
22 #include <BRepBuilderAPI_MakeWire.hxx>
23 #include <BRepOffsetAPI_MakePipe.hxx>
24 #include <BRepOffsetAPI_MakePipeShell.hxx>
25 #include <Law_Interpol.hxx>
26 #include <BRepBuilderAPI_TransitionMode.hxx>
27 #include <TColStd_Array1OfReal.hxx>
28 #include <TColStd_Array1OfInteger.hxx>
29 #include <Geom_BSplineCurve.hxx>
30 #include <BRepBuilderAPI_MakePolygon.hxx>
31
32
33 // Initialization of global variable with an instance of this class
34 OCCDemo_Presentation* OCCDemo_Presentation::Current = new Sweep_Presentation;
35
36 // Initialization of array of samples
37 const Sweep_Presentation::PSampleFuncType Sweep_Presentation::SampleFuncs[] =
38 {
39   &Sweep_Presentation::sample1,
40   &Sweep_Presentation::sample2,
41   //&Sweep_Presentation::sample3,
42   &Sweep_Presentation::sample4,
43   &Sweep_Presentation::sample5,
44 };
45
46 #ifdef WNT
47  #define EOL "\r\n"
48 #else
49  #define EOL "\n"
50 #endif
51
52 #define PathColor   Quantity_Color(Quantity_NOC_CYAN1)
53
54 //////////////////////////////////////////////////////////////////////
55 // Construction/Destruction
56 //////////////////////////////////////////////////////////////////////
57
58 Sweep_Presentation::Sweep_Presentation()
59 {
60   myNbSamples = sizeof(SampleFuncs)/sizeof(PSampleFuncType);
61   setName ("Sweep");
62 }
63
64 //////////////////////////////////////////////////////////////////////
65 // Sample execution
66 //////////////////////////////////////////////////////////////////////
67
68 void Sweep_Presentation::DoSample()
69 {
70   getAISContext()->EraseAll();
71   if (myIndex >=0 && myIndex < myNbSamples)
72     (this->*SampleFuncs[myIndex])();
73 }
74
75 //////////////////////////////////////////////////////////////////////
76 // Auxiliary functions
77 //////////////////////////////////////////////////////////////////////
78
79 static Handle_Geom_Curve mkBezierCurve(const Standard_Integer nPoles,
80                                  const Standard_Real theCoords[][3],
81                                  const Standard_Real aScale = 1,
82                                  const gp_XYZ& aShift = gp_XYZ(0,0,0))
83 {
84   TColgp_Array1OfPnt aPoles (1, nPoles);
85   for (Standard_Integer i=0; i < nPoles; i++)
86   {
87     gp_XYZ aP (theCoords[i][0], theCoords[i][1], theCoords[i][2]);
88     aPoles(i+1) = gp_Pnt (aP * aScale + aShift);
89   }
90   return new Geom_BezierCurve (aPoles);
91 }
92
93 static Handle_Geom_Curve mkPBSplineCurve(const Standard_Integer nPoles,
94                                  const Standard_Real theCoords[][3],
95                                  const Standard_Real aScale = 1,
96                                  const gp_XYZ& aShift = gp_XYZ(0,0,0))
97 {
98   TColgp_Array1OfPnt aPoles (1, nPoles);
99   TColStd_Array1OfReal aKnots (1, nPoles+1);
100   TColStd_Array1OfInteger aMults(1, nPoles+1);
101
102   for (Standard_Integer i=0; i < nPoles; i++)
103   {
104     gp_XYZ aP (theCoords[i][0], theCoords[i][1], theCoords[i][2]);
105     aPoles(i+1) = gp_Pnt (aP * aScale + aShift);
106   }
107   for (i=1; i <= nPoles+1; i++)
108     aKnots(i) = Standard_Real(i-1);
109   aMults.Init(1);
110
111   return new Geom_BSplineCurve (aPoles, aKnots, aMults, 3, Standard_True);
112 }
113
114 static Handle_Geom2d_Curve mk2dBezierCurve(const Standard_Integer nPoles,
115                                      const Standard_Real theCoords[][2],
116                                      const Standard_Real aScale = 1,
117                                      const gp_XY& aShift = gp_XY(0,0))
118 {
119   TColgp_Array1OfPnt2d aPoles (1, nPoles);
120   for (Standard_Integer i=0; i < nPoles; i++)
121   {
122     gp_XY aP (theCoords[i][0], theCoords[i][1]);
123     aPoles(i+1) = gp_Pnt2d (aP * aScale + aShift);
124   }
125   return new Geom2d_BezierCurve (aPoles);
126 }
127
128 static TopoDS_Wire mkPolygonWire(const Standard_Integer nPoints,
129                                  const Standard_Real theCoords[][3],
130                                  const Standard_Real aScale = 1,
131                                  const gp_XYZ& aShift = gp_XYZ(0,0,0))
132 {
133   BRepBuilderAPI_MakePolygon aPol;
134   for (Standard_Integer i=0; i < nPoints; i++)
135   {
136     gp_XYZ aP(theCoords[i][0], theCoords[i][1], theCoords[i][2]);
137     aPol.Add (gp_Pnt (aP * aScale + aShift));
138   }
139   return aPol.Wire();
140 }
141
142 static Handle_Geom_Curve mkCurve1()
143 {
144   Standard_Real aCoords[][3] = {
145     {0,0,0},{0,0,10},{0,10,10},{0,10,20}
146   };
147   Standard_Integer nPoles = sizeof(aCoords)/(sizeof(Standard_Real)*3);
148   return mkBezierCurve (nPoles, aCoords);
149 }
150
151 static Handle_Geom_Curve mkCurve2()
152 {
153   Standard_Real aCoords[][3] = {
154     {0,0,0},{10,0,0},{20,10,12},{25,30,20},{50,40,50}
155   };
156   Standard_Integer nPoles = sizeof(aCoords)/(sizeof(Standard_Real)*3);
157   return mkBezierCurve (nPoles, aCoords);
158 }
159
160 static Handle_Geom_Curve mkCurve3()
161 {
162   Standard_Real aCoords[][3] = {
163     {50,40,50},{70,30,30},{90,20,20},{100,50,0}
164   };
165   Standard_Integer nPoles = sizeof(aCoords)/(sizeof(Standard_Real)*3);
166   return mkBezierCurve (nPoles, aCoords);
167 }
168
169 static Handle_Geom2d_Curve mk2dCurve1()
170 {
171   Standard_Real aCoords[][2] = {
172     {0,0},{0.3,0},{0.1,0.5},{0.3,0.6},{0.6,0.5}
173   };
174   Standard_Integer nPoles = sizeof(aCoords)/(sizeof(Standard_Real)*2);
175   return mk2dBezierCurve (nPoles, aCoords);
176 }
177
178 static Handle_Geom_Surface mkSurface1()
179 {
180   Standard_Real aCoords[3][3][3] = {
181     {{-10,-10,-30},{-10,50,40},{-10,70,-20}},
182     {{50,-10,40},{50,50,0},{50,70,30}},
183     {{70,-10,20},{70,50,30},{70,70,-20}}
184   };
185   TColgp_Array2OfPnt aPoles (1, 3, 1, 3);
186   for (Standard_Integer iV=0; iV < 3; iV++)
187     for (Standard_Integer iU=0; iU < 3; iU++)
188       aPoles(iU+1, iV+1) = gp_Pnt (aCoords[iV][iU][0],
189                                    aCoords[iV][iU][1],
190                                    aCoords[iV][iU][2]);
191   return new Geom_BezierSurface (aPoles);
192 }
193
194 static TopoDS_Edge mkEdge1()
195 {
196   BRepBuilderAPI_MakeEdge aMkEdge (mkCurve1());
197   return aMkEdge.Edge();
198 }
199
200 static TopoDS_Wire mkWire1()
201 {
202   BRepBuilderAPI_MakeEdge aMkEdge1 (mkCurve2());
203   BRepBuilderAPI_MakeEdge aMkEdge2 (mkCurve3());
204   BRepBuilderAPI_MakeWire aMkWire (aMkEdge1, aMkEdge2);
205   return aMkWire.Wire();
206 }
207
208 static TopoDS_Wire mkWire2()
209 {
210   Standard_Real aCoords[][3] = {
211     {-20,0,0},{20,0,0},{20,10,12},{25,30,20},{50,40,50},
212   };
213   Standard_Integer nPoles = sizeof(aCoords)/(sizeof(Standard_Real)*3);
214   Handle(Geom_Curve) aCurve = mkBezierCurve (nPoles, aCoords);
215   BRepBuilderAPI_MakeEdge aMkEdge1 (aCurve);
216   BRepBuilderAPI_MakeEdge aMkEdge2 (mkCurve3());
217   BRepBuilderAPI_MakeWire aMkWire (aMkEdge1, aMkEdge2);
218   return aMkWire.Wire();
219 }
220
221 static TopoDS_Wire mkWire3()
222 {
223   BRepBuilderAPI_MakeEdge aMkEdge1 (mkCurve1());
224   Standard_Real aCoords[][3] = {
225     {0,10,20},{0,20,10},{0,20,0},{0,0,0}
226   };
227   Standard_Integer nPoles = sizeof(aCoords)/(sizeof(Standard_Real)*3);
228   Handle(Geom_Curve) aCurve = mkBezierCurve (nPoles, aCoords);
229   BRepBuilderAPI_MakeEdge aMkEdge2 (aCurve);
230   BRepBuilderAPI_MakeWire aMkWire (aMkEdge1, aMkEdge2);
231   return aMkWire.Wire();
232 }
233
234 static TopoDS_Wire mkWire4()
235 {
236   Standard_Real aCoords[][3] = {
237     {0,-3,0},{0,-6,6},{0,0,3},{0,6,6},{0,3,0},{0,6,-6},{0,0,-3},{0,-6,-6}
238   };
239   Standard_Integer nPoles = sizeof(aCoords)/(sizeof(Standard_Real)*3);
240   Handle(Geom_Curve) aCurve = mkPBSplineCurve (nPoles, aCoords);
241   BRepBuilderAPI_MakeEdge aMkEdge (aCurve);
242   BRepBuilderAPI_MakeWire aMkWire (aMkEdge);
243   return aMkWire.Wire();
244 }
245
246 static TopoDS_Wire mkWire5()
247 {
248   Standard_Real aCoords[][3] = {
249     {0,0,0},{10,0,0},{10,0,10},{10,10,10},{0,10,10},{0,10,0},{0,0,0}
250   };
251   Standard_Integer nPoints = sizeof(aCoords)/(sizeof(Standard_Real)*3);
252   return mkPolygonWire(nPoints, aCoords);
253 }
254
255 static TopoDS_Wire mkWire6()
256 {
257   Standard_Real aCoords[][3] = {
258     {0,-2,-2},{0,2,-2},{0,2,2},{0,-2,2},{0,-2,-2}
259   };
260   Standard_Integer nPoints = sizeof(aCoords)/(sizeof(Standard_Real)*3);
261   return mkPolygonWire(nPoints, aCoords);
262 }
263
264 static TopoDS_Wire mkWire7()
265 {
266   Standard_Real aCoords[][3] = {
267     {0,0,0},{10,0,0},{10,10,0}
268   };
269   Standard_Integer nPoints = sizeof(aCoords)/(sizeof(Standard_Real)*3);
270   return mkPolygonWire(nPoints, aCoords);
271 }
272
273 static TopoDS_Wire mkWire8()
274 {
275   Standard_Real aCoords[][3] = {
276     {0,-10,0},{20,-10,10},{20,10,0}
277   };
278   Standard_Integer nPoints = sizeof(aCoords)/(sizeof(Standard_Real)*3);
279   return mkPolygonWire(nPoints, aCoords);
280 }
281
282 static TopoDS_Wire mkWire9()
283 {
284   Standard_Real aCoords[][3] = {
285     {0,-1,0},{0,-2,2},{0,0,1},{0,2,2},{0,1,0},{0,2,-2},{0,0,-1},{0,-2,-2}
286   };
287   Standard_Integer nPoles = sizeof(aCoords)/(sizeof(Standard_Real)*3);
288   Handle(Geom_Curve) aCurve = mkPBSplineCurve (nPoles, aCoords);
289   BRepBuilderAPI_MakeEdge aMkEdge (aCurve);
290   BRepBuilderAPI_MakeWire aMkWire (aMkEdge);
291   return aMkWire.Wire();
292 }
293
294
295 Handle_AIS_InteractiveObject Sweep_Presentation::drawCurveOnSurface 
296     (const Handle_Geom2d_Curve& aC2d,
297      const Handle_Geom_Surface& aSurf,
298      const Quantity_Color& aColor)
299 {
300   Handle(Geom2dAdaptor_HCurve) aHC = new Geom2dAdaptor_HCurve(aC2d);
301   Handle(GeomAdaptor_HSurface) aHS = new GeomAdaptor_HSurface(aSurf);
302
303   Standard_Real aFirst = Min (aC2d->FirstParameter(), 500.);
304   Standard_Real aLast = Min (aC2d->LastParameter(), 500.);
305   Standard_Real aTol = 1.e-4;
306   Standard_Integer aMaxDegree = 8;
307   Standard_Integer aMaxSegments = 30;
308   Approx_CurveOnSurface aApprox(aHC, aHS, aFirst, aLast, aTol,
309     GeomAbs_C2, aMaxDegree, aMaxSegments, Standard_True);
310   if (aApprox.IsDone() && aApprox.HasResult())
311   {
312     Handle(Geom_Curve) aCurve = aApprox.Curve3d();
313     return drawCurve (aCurve, aColor);
314   }
315   else
316     return Handle(AIS_InteractiveObject)();
317 }
318
319 //////////////////////////////////////////////////////////////////////
320 // Sample functions
321 //////////////////////////////////////////////////////////////////////
322
323 void Sweep_Presentation::sample1()
324 {
325   ResetView();
326   SetViewCenter(35.024312615272, 4.0878339858469);
327   SetViewScale(7.8145774983540); 
328
329   setResultTitle ("Sweeping Curve along Path");
330   // Creation of a pipe by sweeping a curve (the section)
331   // along another curve (the path)
332
333   // Create the section and the path
334   Handle(Geom_Curve) aSection = mkCurve1();
335   Handle(Geom_Curve) aPath = mkCurve2();
336
337   // Creation of the swept surface
338   Standard_Real aTol=1.e-4;
339   GeomFill_Pipe aPipe;
340
341   // Case 1: Tangent and Normal are fixed
342   GeomFill_Trihedron aOption = GeomFill_IsFixed;
343   aPipe.Init (aPath, aSection, aOption);
344   aPipe.Perform (aTol, Standard_False);
345   Handle(Geom_Surface) aSurface1 = aPipe.Surface();
346
347   // Case 2: Tangent and Normal are given by Frenet frame
348   aOption = GeomFill_IsFrenet;
349   aPipe.Init (aPath, aSection, aOption);
350   aPipe.Perform (aTol, Standard_False);
351   Handle(Geom_Surface) aSurface2 = aPipe.Surface();
352
353   // Case 3: Tangent and Normal are given by Corrected Frenet frame
354   aOption = GeomFill_IsCorrectedFrenet;
355   aPipe.Init (aPath, aSection, aOption);
356   aPipe.Perform (aTol, Standard_False);
357   Handle(Geom_Surface) aSurface3 = aPipe.Surface();
358
359   // Case 4: constant Normal to have all the sections in a same plane
360   aOption = GeomFill_IsConstantNormal;
361   aPipe.Init (aPath, aSection, aOption);
362   aPipe.Perform (aTol, Standard_False);
363   Handle(Geom_Surface) aSurface4 = aPipe.Surface();
364
365   // Case 5: Define the path by a surface and a 2dcurve,
366   // the surface is used to define the trihedron's normal.
367   Handle(Geom2d_Curve) a2dPath5 = mk2dCurve1();
368   Handle(Geom_Surface) aSupport5 = mkSurface1();
369   aPipe.Init (a2dPath5, aSupport5, aSection);
370   aPipe.Perform (aTol, Standard_False);
371   Handle(Geom_Surface) aSurface5 = aPipe.Surface();
372
373   // Show source code
374   TCollection_AsciiString aText;
375   aText = aText +
376     "  // Sweeping a curve (the section) along a curve (the path)" EOL EOL
377
378     "  // Create the section and the path" EOL
379     "  Handle(Geom_Curve) aSection = mkCurve1();" EOL
380     "  Handle(Geom_Curve) aPath = mkCurve2();" EOL EOL
381
382     "  // Create swept surface" EOL
383     "  Standard_Real aTol=1.e-4;" EOL
384     "  GeomFill_Pipe aPipe;" EOL EOL
385
386     "  // Case 1: Tangent and Normal are fixed" EOL
387     "  GeomFill_Trihedron aOption = GeomFill_IsFixed;" EOL
388     "  aPipe.Init (aPath, aSection, aOption);" EOL
389     "  aPipe.Perform (aTol, Standard_False);" EOL
390     "  Handle(Geom_Surface) aSurface1 = aPipe.Surface();" EOL EOL
391
392     "  // Case 2: Tangent and Normal are given by Frenet frame" EOL
393     "  aOption = GeomFill_IsFrenet;" EOL
394     "  aPipe.Init (aPath, aSection, aOption);" EOL
395     "  aPipe.Perform (aTol, Standard_False);" EOL
396     "  Handle(Geom_Surface) aSurface2 = aPipe.Surface();" EOL EOL
397
398     "  // Case 3: Tangent and Normal are given by Corrected Frenet frame" EOL
399     "  aOption = GeomFill_IsCorrectedFrenet;" EOL
400     "  aPipe.Init (aPath, aSection, aOption);" EOL
401     "  aPipe.Perform (aTol, Standard_False);" EOL
402     "  Handle(Geom_Surface) aSurface3 = aPipe.Surface();" EOL EOL
403
404     "  // Case 4: constant Normal to have all the sections in a same plane" EOL
405     "  aOption = GeomFill_IsConstantNormal;" EOL
406     "  aPipe.Init (aPath, aSection, aOption);" EOL
407     "  aPipe.Perform (aTol, Standard_False);" EOL
408     "  Handle(Geom_Surface) aSurface4 = aPipe.Surface();" EOL EOL
409
410     "  // Case 5: Define the path by a surface and a 2dcurve," EOL
411     "  // the surface is used to define the trihedron's normal." EOL
412     "  Handle(Geom2d_Curve) a2dPath5 = mk2dCurve1();" EOL
413     "  Handle(Geom_Surface) aSupport5 = mkSurface1();" EOL
414     "  aPipe.Init (a2dPath5, aSupport5, aSection);" EOL
415     "  aPipe.Perform (aTol, Standard_False);" EOL
416     "  Handle(Geom_Surface) aSurface5 = aPipe.Surface();" EOL;
417   setResultText (aText.ToCString());
418
419   // Draw objects
420   Handle(AIS_InteractiveObject) aICurv1, aICurv2, aISurf, aISupp;
421
422   aICurv1 = drawCurve (aSection);
423   if (WAIT_A_LITTLE) return;
424   aICurv2 = drawCurve (aPath, PathColor);
425   if (WAIT_A_LITTLE) return;
426   aISurf = drawSurface (aSurface1);
427   if (WAIT_A_SECOND) return;
428
429   getAISContext()->Erase (aISurf);
430   if (WAIT_A_LITTLE) return;
431   aISurf = drawSurface (aSurface2);
432   if (WAIT_A_SECOND) return;
433
434   getAISContext()->Erase (aISurf);
435   if (WAIT_A_LITTLE) return;
436   aISurf = drawSurface (aSurface3);
437   if (WAIT_A_SECOND) return;
438
439   getAISContext()->Erase (aISurf);
440   if (WAIT_A_LITTLE) return;
441   aISurf = drawSurface (aSurface4);
442   if (WAIT_A_SECOND) return;
443
444   getAISContext()->Erase(aICurv2);
445   getAISContext()->Erase(aISurf);
446   if (WAIT_A_LITTLE) return;
447
448   aISupp = drawSurface (aSupport5, Quantity_NOC_BLUE1);
449   aICurv2 = drawCurveOnSurface (a2dPath5, aSupport5, PathColor);
450   if (WAIT_A_LITTLE) return;
451   aISurf = drawSurface (aSurface5);
452 }
453
454 void Sweep_Presentation::sample2()
455 {
456   ResetView();
457   SetViewCenter(51.059243819711, 16.906093324128);
458   SetViewScale(8.5662184369261); 
459
460   setResultTitle ("Sweeping Shape along Wire");
461
462   // Show source code
463   TCollection_AsciiString aText;
464   aText = aText +
465     "  // Creation of a pipe by sweeping a shape (the profile)" EOL
466     "  // along a wire (the spine)" EOL EOL
467
468     "  TopoDS_Wire aSpine;" EOL
469     "  TopoDS_Shape aProfile, aResult;" EOL
470     "  aSpine = mkWire1();" EOL EOL
471
472     "  // Case 1: unclosed edge profile" EOL
473     "  aProfile = mkEdge1();" EOL
474     "  aResult = BRepOffsetAPI_MakePipe (aSpine, aProfile);" EOL EOL;
475 /*
476     "  // Case 2: closed wire profile" EOL
477     "  aProfile = mkWire4();" EOL
478     "  aResult = BRepOffsetAPI_MakePipe (aSpine, aProfile);" EOL;*/
479   setResultText (aText.ToCString());
480
481   // Creation of a pipe by sweeping a shape (the profile)
482   // along a wire (the spine)
483
484   TopoDS_Wire aSpine;
485   TopoDS_Shape aProfile, aResult;
486   aSpine = mkWire1();
487
488   // Case 1: unclosed edge profile
489   aProfile = mkEdge1();
490   aResult = BRepOffsetAPI_MakePipe (aSpine, aProfile);
491
492   // Draw objects
493   Handle(AIS_InteractiveObject) aISpine, aIProf, aIRes;
494   aISpine = drawShape (aSpine, PathColor);
495   if (WAIT_A_LITTLE) return;
496   aIProf = drawShape (aProfile, Quantity_NOC_RED);
497   if (WAIT_A_LITTLE) return;
498   aIRes = drawShape (aResult);
499   if (WAIT_A_SECOND) return;
500
501   // Case 2: closed wire profile
502   /*
503   aProfile = mkWire4();
504   aResult = BRepOffsetAPI_MakePipe (aSpine, aProfile);
505
506   getAISContext()->Erase (aIProf);
507   getAISContext()->Erase (aIRes);
508   if (WAIT_A_LITTLE) return;
509   aIProf = drawShape (aProfile, Quantity_NOC_RED);
510   if (WAIT_A_LITTLE) return;
511   aIRes = drawShape (aResult);
512   if (WAIT_A_SECOND) return;
513   */
514 }
515
516 void Sweep_Presentation::sample3()
517 {
518   setResultTitle ("Sweeping Wire along Wire");
519
520   // Show source code
521   TCollection_AsciiString aText;
522   aText = aText +
523     "  // Creation of a shell-like pipe by sweeping a wire (the profile)" EOL
524     "  // along a wire (the spine)" EOL
525     "  // CorrectedFrenet mode + interpolate sections" EOL EOL
526
527     "  // define a spine" EOL
528     "  TopoDS_Wire aSpine = mkWire2();" EOL
529     "  BRepOffsetAPI_MakePipeShell aSweep(aSpine);" EOL
530     "  // set a CorrectedFrenet trihedron mode" EOL
531     "  aSweep.SetMode(Standard_False);" EOL
532     "  // define a profile and an interpolation law" EOL
533     "  TopoDS_Wire aProfile = mkWire3();" EOL
534     "  TColgp_Array1OfPnt2d aParAndRad(1, 3);" EOL
535     "  aParAndRad(1) = gp_Pnt2d (0,1);" EOL
536     "  aParAndRad(2) = gp_Pnt2d (1,2);" EOL
537     "  aParAndRad(3) = gp_Pnt2d (2,0.5);" EOL
538     "  Handle(Law_Interpol) aLaw = new Law_Interpol();" EOL
539     "  aLaw->Set (aParAndRad, Standard_False);  // set non-periodic law" EOL
540     "  aSweep.SetLaw (aProfile, aLaw, " EOL
541     "                  Standard_True,    // profile have to be translated" EOL
542     "                                    //  to be in contact with the spine" EOL
543     "                  Standard_True);   // profile have to be rotated " EOL
544     "                                    //  to be orthogonal to the spine's tangent" EOL
545     "  // define transition mode to manage discontinuities on the sweep" EOL
546     "  BRepBuilderAPI_TransitionMode aTransition = BRepBuilderAPI_RoundCorner;" EOL
547     "  aSweep.SetTransitionMode (aTransition);" EOL EOL
548
549     "  // perform sweeping and get a result" EOL
550     "  aSweep.Build();" EOL
551     "  TopoDS_Shape aResult;" EOL
552     "  if (aSweep.IsDone())" EOL
553     "    aResult = aSweep.Shape();" EOL;
554   setResultText (aText.ToCString());
555
556   // Creation of a shell-like pipe by sweeping a wire (the profile)
557   // along a wire (the spine)
558   // CorrectedFrenet mode + interpolate sections
559
560   // define a spine
561   TopoDS_Wire aSpine = mkWire2();
562   BRepOffsetAPI_MakePipeShell aSweep(aSpine);
563   // set a CorrectedFrenet trihedron mode
564   aSweep.SetMode(Standard_False);
565   // define a profile and an interpolation law
566   TopoDS_Wire aProfile = mkWire3();
567   TColgp_Array1OfPnt2d aParAndRad(1, 3);
568   aParAndRad(1) = gp_Pnt2d (0,1);
569   aParAndRad(2) = gp_Pnt2d (1,2);
570   aParAndRad(3) = gp_Pnt2d (2,0.5);
571   Handle(Law_Interpol) aLaw = new Law_Interpol();
572   aLaw->Set (aParAndRad, Standard_False);  // set non-periodic law
573   aSweep.SetLaw (aProfile, aLaw, 
574                   Standard_True,    // profile have to be translated
575                                     //  to be in contact with the spine
576                   Standard_True);   // profile have to be rotated 
577                                     //  to be orthogonal to the spine's tangent
578   // define transition mode to manage discontinuities on the sweep
579   BRepBuilderAPI_TransitionMode aTransition = BRepBuilderAPI_RoundCorner;
580   aSweep.SetTransitionMode (aTransition);
581
582   // Draw objects
583   Handle(AIS_InteractiveObject) aISpine, aIProf, aIRes;
584   if (WAIT_A_LITTLE) return;
585   aISpine = drawShape (aSpine, PathColor);
586   if (WAIT_A_LITTLE) return;
587   aIProf = drawShape (aProfile, Quantity_NOC_RED);
588   if (WAIT_A_LITTLE) return;
589
590   // perform sweeping and get a result
591   aSweep.Build();
592   TopoDS_Shape aResult;
593   if (aSweep.IsDone())
594     aResult = aSweep.Shape();
595
596   // Draw objects
597   aIRes = drawShape (aResult);
598 }
599
600 void Sweep_Presentation::sample4()
601 {
602   ResetView();
603   SetViewCenter(7.0710681182763, 4.0824832263318);
604   SetViewScale(43.307810016829); 
605  
606   setResultTitle ("Sweeping Wire along Wire");
607
608   // Show source code
609   TCollection_AsciiString aText;
610   aText = aText +
611     "  // Creation of a shell-like pipe by sweeping a wire (the profile)" EOL
612     "  // along a wire (the spine)" EOL
613     "  // CorrectedFrenet mode" EOL EOL
614
615     "  // define a spine" EOL
616     "  TopoDS_Wire aSpine = mkWire5();" EOL
617     "  BRepOffsetAPI_MakePipeShell aSweep(aSpine);" EOL
618     "  // set a CorrectedFrenet trihedron mode" EOL
619     "  aSweep.SetMode(Standard_False);" EOL
620     "  // define a profile" EOL
621     "  TopoDS_Wire aProfile = mkWire6();" EOL
622     "  aSweep.Add (aProfile);" EOL
623     "  // define transition mode to manage discontinuities on the sweep" EOL
624     "  BRepBuilderAPI_TransitionMode aTransition = BRepBuilderAPI_RoundCorner;" EOL
625     "  aSweep.SetTransitionMode (aTransition);" EOL EOL
626
627     "  // perform sweeping and get a result" EOL
628     "  aSweep.Build();" EOL
629     "  TopoDS_Shape aResult;" EOL
630     "  if (aSweep.IsDone())" EOL
631     "    aResult = aSweep.Shape();" EOL;
632   setResultText (aText.ToCString());
633
634   // Creation of a shell-like pipe by sweeping a wire (the profile)
635   // along a wire (the spine)
636   // CorrectedFrenet mode
637
638   // define a spine
639   TopoDS_Wire aSpine = mkWire5();
640   BRepOffsetAPI_MakePipeShell aSweep(aSpine);
641   // set a CorrectedFrenet trihedron mode
642   aSweep.SetMode(Standard_False);
643   // define a profile
644   TopoDS_Wire aProfile = mkWire6();
645   aSweep.Add (aProfile);
646   // define transition mode to manage discontinuities on the sweep
647   BRepBuilderAPI_TransitionMode aTransition = BRepBuilderAPI_RoundCorner;
648   aSweep.SetTransitionMode (aTransition);
649
650   // Draw objects
651   Handle(AIS_InteractiveObject) aISpine, aIProf, aIRes;
652   if (WAIT_A_LITTLE) return;
653   aISpine = drawShape (aSpine, PathColor);
654   if (WAIT_A_LITTLE) return;
655   aIProf = drawShape (aProfile, Quantity_NOC_RED);
656   if (WAIT_A_LITTLE) return;
657
658   // perform sweeping and get a result
659   aSweep.Build();
660   TopoDS_Shape aResult;
661   if (aSweep.IsDone())
662     aResult = aSweep.Shape();
663
664   // Draw objects
665   aIRes = drawShape (aResult);
666 }
667
668 void Sweep_Presentation::sample5()
669 {
670   ResetView();
671   SetViewCenter(7.0710673644044, -0.81673684677605);
672   SetViewScale(37.893638277722); 
673
674   setResultTitle ("Sweeping Wire along Wire");
675
676   // Show source code
677   TCollection_AsciiString aText;
678   aText = aText +
679     "  // Creation of a shell-like pipe by sweeping a wire (the profile)" EOL
680     "  // along a wire (the spine)" EOL
681     "  // Guide line mode" EOL EOL
682
683     "  // define a spine" EOL
684     "  TopoDS_Wire aSpine = mkWire7();" EOL
685     "  BRepOffsetAPI_MakePipeShell aSweep(aSpine);" EOL
686     "  // define a guide" EOL
687     "  TopoDS_Wire aGuide = mkWire8();" EOL
688     "  aSweep.SetMode(aGuide, Standard_False);" EOL
689     "  // define a profile" EOL
690     "  TopoDS_Wire aProfile = mkWire9();" EOL
691     "  aSweep.Add (aProfile);" EOL
692     "  // define transition mode to manage discontinuities on the sweep" EOL
693     "  BRepBuilderAPI_TransitionMode aTransition = BRepBuilderAPI_RoundCorner;" EOL
694     "  aSweep.SetTransitionMode (aTransition);" EOL EOL
695
696     "  // perform sweeping and get a result" EOL
697     "  aSweep.Build();" EOL
698     "  TopoDS_Shape aResult;" EOL
699     "  if (aSweep.IsDone())" EOL
700     "    aResult = aSweep.Shape();" EOL;
701   setResultText (aText.ToCString());
702
703   // Creation of a shell-like pipe by sweeping a wire (the profile)
704   // along a wire (the spine)
705   // Guide line mode
706
707   // define a spine
708   TopoDS_Wire aSpine = mkWire7();
709   BRepOffsetAPI_MakePipeShell aSweep(aSpine);
710   // define a guide
711   TopoDS_Wire aGuide = mkWire8();
712   aSweep.SetMode(aGuide, Standard_False, Standard_False);
713   // define a profile
714   TopoDS_Wire aProfile = mkWire9();
715   aSweep.Add (aProfile, Standard_False, Standard_False);
716   // define transition mode to manage discontinuities on the sweep
717   BRepBuilderAPI_TransitionMode aTransition = BRepBuilderAPI_RoundCorner;
718   aSweep.SetTransitionMode (aTransition);
719
720   // Draw objects
721   Handle(AIS_InteractiveObject) aISpine, aIGuide, aIProf, aIRes;
722   if (WAIT_A_LITTLE) return;
723   aISpine = drawShape (aSpine, PathColor);
724   if (WAIT_A_LITTLE) return;
725   aIGuide = drawShape (aGuide, Quantity_NOC_GREEN);
726   if (WAIT_A_LITTLE) return;
727   aIProf = drawShape (aProfile, Quantity_NOC_RED);
728   if (WAIT_A_LITTLE) return;
729
730   // perform sweeping and get a result
731   aSweep.Build();
732   TopoDS_Shape aResult;
733   if (aSweep.IsDone())
734     aResult = aSweep.Shape();
735
736   // Draw objects
737   aIRes = drawShape (aResult);
738 }