0031007: Coding - eliminate warnings issued while compiling with -pedantic flag
[occt.git] / src / BRepTest / BRepTest_SweepCommands.cxx
1 // Created on: 1993-07-22
2 // Created by: Remi LEQUETTE
3 // Copyright (c) 1993-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 #include <BRepTest.hxx>
18
19 #include <BRepTest_Objects.hxx>
20
21 #include <DBRep.hxx>
22 #include <Draw_Interpretor.hxx>
23 #include <Draw_Appli.hxx>
24
25 #include <BRepFill.hxx>
26 #include <BRepBuilderAPI_PipeError.hxx>
27 #include <BRepFill_Generator.hxx>
28 #include <BRepPrimAPI_MakePrism.hxx>
29 #include <BRepPrimAPI_MakeRevol.hxx>
30 #include <BRepOffsetAPI_MakePipe.hxx>
31 #include <BRepOffsetAPI_MakeEvolved.hxx>
32 #include <BRepOffsetAPI_ThruSections.hxx>
33 #include <BRepOffsetAPI_MakePipeShell.hxx>
34 #include <BRepOffsetAPI_MiddlePath.hxx>
35
36 #include <BRepLib_MakeWire.hxx>
37 #include <TopoDS.hxx>
38 #include <TopTools_ListIteratorOfListOfShape.hxx>
39 #include <TopExp_Explorer.hxx>
40
41 #include <Precision.hxx>
42 #include <Law_Interpol.hxx>
43 #include <gp_Ax1.hxx>
44 #include <gp_Ax2.hxx>
45 #include <gp_Pnt2d.hxx>
46 #include <TColgp_Array1OfPnt2d.hxx>
47
48 static BRepOffsetAPI_MakePipeShell* Sweep = 0;
49 static BRepOffsetAPI_ThruSections* Generator = 0;
50
51 #include <stdio.h>
52 #include <Geom_Curve.hxx>
53 #include <GeomAdaptor_HCurve.hxx>
54 #include <GeomFill_Pipe.hxx>
55 #include <Geom_Surface.hxx>
56 #include <BRepBuilderAPI_MakeFace.hxx>
57 #include <BRep_Tool.hxx>
58 #include <gp_Pnt.hxx>
59 #include <gp_Vec.hxx>
60 #include <Geom_Circle.hxx>
61 #include <gp_Ax2.hxx>
62
63
64 //=======================================================================
65 // prism
66 //=======================================================================
67
68 static Standard_Integer prism(Draw_Interpretor&, Standard_Integer n, const char** a)
69 {
70   if (n < 6) return 1;
71
72   TopoDS_Shape base = DBRep::Get(a[2]);
73   if (base.IsNull()) return 1;
74
75   gp_Vec V(Draw::Atof(a[3]), Draw::Atof(a[4]), Draw::Atof(a[5]));
76
77   Standard_Boolean copy = Standard_False;
78   Standard_Boolean inf = Standard_False;
79   Standard_Boolean sinf = Standard_False;
80
81   if (n > 6) {
82     copy = (*a[6] == 'c') || (*a[6] == 'C');
83     inf = (*a[6] == 'i') || (*a[6] == 'I');
84     sinf = (*a[6] == 's') || (*a[6] == 'S');
85   }
86
87   TopoDS_Shape res;
88
89   BRepPrimAPI_MakePrism* Prism;
90   if (inf || sinf)
91   {
92     Prism = new BRepPrimAPI_MakePrism(base, gp_Dir(V), inf);
93   }
94   else
95   {
96     Prism = new BRepPrimAPI_MakePrism(base, V, copy);
97   }
98
99   res = Prism->Shape();
100
101   DBRep::Set(a[1], res);
102
103   //History 
104   TopTools_ListOfShape anArgs;
105   anArgs.Append(base);
106   BRepTest_Objects::SetHistory(anArgs, *Prism);
107
108   delete Prism;
109
110   return 0;
111 }
112
113
114 //=======================================================================
115 // revol
116 //=======================================================================
117 static Standard_Integer revol(Draw_Interpretor& di,
118   Standard_Integer n, const char** a)
119 {
120   if (n < 10) return 1;
121
122   TopoDS_Shape base = DBRep::Get(a[2]);
123   if (base.IsNull()) return 1;
124
125   gp_Pnt P(Draw::Atof(a[3]), Draw::Atof(a[4]), Draw::Atof(a[5]));
126   gp_Dir D(Draw::Atof(a[6]), Draw::Atof(a[7]), Draw::Atof(a[8]));
127   gp_Ax1 A(P, D);
128
129   Standard_Real angle = Draw::Atof(a[9]) * (M_PI / 180.0);
130
131   Standard_Boolean copy = n > 10;
132
133
134   BRepPrimAPI_MakeRevol Revol(base, A, angle, copy);
135
136   if (Revol.IsDone())
137   {
138     TopoDS_Shape res = Revol.Shape();
139
140     DBRep::Set(a[1], res);
141
142     //History 
143     TopTools_ListOfShape anArgs;
144     anArgs.Append(base);
145     BRepTest_Objects::SetHistory(anArgs, Revol);
146   }
147   else
148   {
149     di << "Revol not done \n";
150   }
151
152   return 0;
153 }
154
155
156 //=======================================================================
157 // pipe
158 //=======================================================================
159
160 static Standard_Integer pipe(Draw_Interpretor& di,
161   Standard_Integer n, const char** a)
162 {
163   if (n == 1)
164   {
165     di << "pipe result Wire_spine Profile [Mode [Approx]]\n";
166     di << "Mode = 0 - CorrectedFrenet,\n";
167     di << "     = 1 - Frenet,\n";
168     di << "     = 2 - DiscreteTrihedron\n";
169     di << "Approx - force C1-approximation if result is C0\n";
170     return 0;
171   }
172
173   if (n > 1 && n < 4) return 1;
174
175   TopoDS_Shape Spine = DBRep::Get(a[2], TopAbs_WIRE);
176   if (Spine.IsNull()) return 1;
177
178   TopoDS_Shape Profile = DBRep::Get(a[3]);
179   if (Profile.IsNull()) return 1;
180
181   GeomFill_Trihedron Mode = GeomFill_IsCorrectedFrenet;
182   if (n >= 5)
183   {
184     Standard_Integer iMode = atoi(a[4]);
185     if (iMode == 1)
186       Mode = GeomFill_IsFrenet;
187     else if (iMode == 2)
188       Mode = GeomFill_IsDiscreteTrihedron;
189   }
190
191   Standard_Boolean ForceApproxC1 = Standard_False;
192   if (n >= 6)
193     ForceApproxC1 = Standard_True;
194
195   BRepOffsetAPI_MakePipe PipeBuilder(TopoDS::Wire(Spine),
196     Profile,
197     Mode,
198     ForceApproxC1);
199   TopoDS_Shape S = PipeBuilder.Shape();
200
201   DBRep::Set(a[1], S);
202
203   // Save history of pipe
204   if (BRepTest_Objects::IsHistoryNeeded())
205   {
206     TopTools_ListOfShape aList;
207     aList.Append(Profile);
208     aList.Append(Spine);
209     BRepTest_Objects::SetHistory(aList, PipeBuilder);
210   }
211
212   return 0;
213 }
214
215 //=======================================================================
216
217 static Standard_Integer geompipe(Draw_Interpretor&,
218   Standard_Integer n, const char** a)
219 {
220   TopoDS_Shape Spine = DBRep::Get(a[2], TopAbs_EDGE);
221   if (Spine.IsNull()) return 1;
222   if (n < 5) return 1;
223   TopoDS_Shape Profile = DBRep::Get(a[3], TopAbs_EDGE);
224   if (Profile.IsNull()) return 1;
225   Standard_Real aSpFirst, aSpLast, aPrFirst, aPrLast;
226   Handle(Geom_Curve) SpineCurve = BRep_Tool::Curve(TopoDS::Edge(Spine), aSpFirst, aSpLast);
227   Handle(Geom_Curve) ProfileCurve = BRep_Tool::Curve(TopoDS::Edge(Profile), aPrFirst, aPrLast);
228   Handle(GeomAdaptor_HCurve) aAdaptCurve = new GeomAdaptor_HCurve(SpineCurve, aSpFirst, aSpLast);
229   Standard_Boolean ByACR = Standard_False;
230   Standard_Boolean rotate = Standard_False;
231   Standard_Real Radius = Draw::Atof(a[4]);
232   gp_Pnt ctr;
233   gp_Vec norm;
234   ProfileCurve->D1(aSpFirst, ctr, norm);
235   gp_Vec xAxisStart(ctr, SpineCurve->Value(aSpFirst));
236   gp_Ax2 aAx2Start(ctr, norm, xAxisStart);
237   Handle(Geom_Circle) cStart = new Geom_Circle(aAx2Start, Radius);
238   Standard_Integer k = 5;
239   if (n > k)
240     ByACR = (Draw::Atoi(a[k++]) == 1);
241   if (n > k)
242     rotate = (Draw::Atoi(a[k++]) == 1);
243   GeomFill_Pipe aPipe(ProfileCurve, aAdaptCurve, cStart, ByACR, rotate);
244   aPipe.Perform(Standard_True);
245   if (!aPipe.IsDone())
246   {
247     std::cout << "GeomFill_Pipe cannot make a surface" << std::endl;
248     return 1;
249   }
250
251   Standard_Real Accuracy = aPipe.ErrorOnSurf();
252   std::cout << "Accuracy of approximation = " << Accuracy << std::endl;
253   
254   Handle(Geom_Surface) Sur = aPipe.Surface();
255   TopoDS_Face F;
256   if (!Sur.IsNull())
257     F = BRepBuilderAPI_MakeFace(Sur, Precision::Confusion());
258   DBRep::Set(a[1], F);
259   return 0;
260 }
261
262 //=======================================================================
263 //function : evolved
264 //purpose  : 
265 //=======================================================================
266
267 Standard_Integer evolved(Draw_Interpretor& di, Standard_Integer n, const char** a)
268 {
269   if (n == 1) {
270     di << " evolved result -s spine -p profile [-solid] [-v] [-a] [-t toler] [-parallel] : \n";
271     di << "   Make evolved profile on spine.\n";
272     di << "   -solid means make closed solid.\n";
273     di << "   -v means use alternative algorithm (volume mode).\n";
274     di << "   -a means referencial CS is automatically computed, otherwise global CS is used. \n";
275     di << "   -t sets the tolerance.\n";
276     di << "   -parallel turns on parallel execution.\n";
277     return 0;
278   }
279
280   if (n < 4) return 1;
281   Standard_Boolean Solid   = Standard_False;  
282   Standard_Boolean isVolume = Standard_False;
283   Standard_Boolean hasToComputeAxes = Standard_False;
284   Standard_Real aTolerance = 0.0;
285   TopoDS_Shape Base;
286   TopoDS_Wire Prof;
287   Standard_Boolean isParallel = Standard_True;
288
289   for (Standard_Integer i = 2; i < n; i++)
290   {
291     if (a[i][0] != '-')
292     {
293       di << "Error: wrong option!\n";
294       return 1;
295     }
296
297     if (!Solid && !strcmp(a[i], "-solid"))
298     {
299       Solid = Standard_True;
300       continue;
301     }
302
303     if (!strcmp(a[i], "-stm"))
304     {
305       isParallel = Standard_False;
306       continue;
307     }
308
309     switch (a[i][1])
310     {
311       case 's':
312       {
313         Base = DBRep::Get(a[++i], TopAbs_WIRE, Standard_False);
314         if (Base.IsNull())
315         {
316           Base = DBRep::Get(a[i], TopAbs_FACE, Standard_False);
317         }
318       }
319       break;
320
321       case 'p':
322       {
323         Prof = TopoDS::Wire(DBRep::Get(a[++i], TopAbs_WIRE, Standard_False));
324       }
325       break;
326
327       case 'v':
328       {
329         isVolume = Standard_True;
330       }
331       break;
332
333       case 'a':
334       {
335         hasToComputeAxes = Standard_True;
336       }
337       break;
338
339       case 't':
340       {
341         aTolerance = Draw::Atof(a[++i]);
342       }
343       break;
344
345       default: 
346         di << "Error: Unknown option!\n";
347         break;
348     }
349   }
350  
351   if (Base.IsNull() || Prof.IsNull())
352   {
353     di << "spine (face or wire) and profile (wire) are expected\n";
354     return 1;
355   }
356
357   TopoDS_Shape Volevo = BRepOffsetAPI_MakeEvolved(Base, Prof, GeomAbs_Arc, !hasToComputeAxes,
358                                                   Solid, Standard_False, 
359                                                   aTolerance, isVolume, isParallel);
360
361   DBRep::Set(a[1],Volevo);
362
363   return 0;
364 }
365
366
367 //=======================================================================
368 //function : pruled
369 //purpose  : 
370 //=======================================================================
371
372 static Standard_Integer pruled(Draw_Interpretor&,
373   Standard_Integer n, const char** a)
374 {
375   if (n != 4) return 1;
376
377   Standard_Boolean YaWIRE = Standard_False;
378   TopoDS_Shape S1 = DBRep::Get(a[2], TopAbs_EDGE);
379   if (S1.IsNull()) {
380     S1 = DBRep::Get(a[2], TopAbs_WIRE);
381     if (S1.IsNull()) return 1;
382     YaWIRE = Standard_True;
383   }
384
385   TopoDS_Shape S2 = DBRep::Get(a[3], TopAbs_EDGE);
386   if (S2.IsNull()) {
387     S2 = DBRep::Get(a[3], TopAbs_WIRE);
388     if (S2.IsNull()) return 1;
389     if (!YaWIRE) {
390       S1 = BRepLib_MakeWire(TopoDS::Edge(S1));
391       YaWIRE = Standard_True;
392     }
393   }
394   else if (YaWIRE) {
395     S2 = BRepLib_MakeWire(TopoDS::Edge(S2));
396   }
397
398   TopoDS_Shape Result;
399   if (YaWIRE) {
400     Result = BRepFill::Shell(TopoDS::Wire(S1), TopoDS::Wire(S2));
401   }
402   else {
403     Result = BRepFill::Face(TopoDS::Edge(S1), TopoDS::Edge(S2));
404   }
405
406   DBRep::Set(a[1], Result);
407   return 0;
408 }
409
410
411 //=======================================================================
412 //function : gener
413 //purpose  : Create a surface between generating wires
414 //=======================================================================
415
416 Standard_Integer gener(Draw_Interpretor&, Standard_Integer n, const char** a)
417 {
418   if (n < 4) return 1;
419
420   TopoDS_Shape Shape;
421
422   BRepFill_Generator aGenerator;
423
424   for (Standard_Integer i = 2; i <= n - 1; i++) {
425     Shape = DBRep::Get(a[i], TopAbs_WIRE);
426     if (Shape.IsNull())
427       return 1;
428
429     aGenerator.AddWire(TopoDS::Wire(Shape));
430   }
431
432   aGenerator.Perform();
433
434   TopoDS_Shell Shell = aGenerator.Shell();
435
436   DBRep::Set(a[1], Shell);
437
438
439   return 0;
440 }
441
442
443 //=======================================================================
444 //function : thrusections
445 //purpose  : 
446 //=======================================================================
447
448 Standard_Integer thrusections(Draw_Interpretor&, Standard_Integer n, const char** a)
449 {
450   if (n < 6) return 1;
451
452   Standard_Boolean check = Standard_True;
453   Standard_Boolean samenumber = Standard_True;
454   Standard_Integer index = 2;
455   // Lecture option
456   if (!strcmp(a[1], "-N")) {
457     if (n < 7) return 1;
458     check = Standard_False;
459     index++;
460   }
461
462   TopoDS_Shape Shape;
463
464   Standard_Boolean issolid = (Draw::Atoi(a[index]) == 1);
465   Standard_Boolean isruled = (Draw::Atoi(a[index + 1]) == 1);
466
467   if (Generator != 0)
468   {
469     delete Generator;
470     Generator = 0;
471   }
472   Generator = new BRepOffsetAPI_ThruSections(issolid, isruled);
473
474   Standard_Integer NbEdges = 0;
475   Standard_Boolean IsFirstWire = Standard_False;
476   for (Standard_Integer i = index + 2; i <= n - 1; i++) {
477     Standard_Boolean IsWire = Standard_True;
478     Shape = DBRep::Get(a[i], TopAbs_WIRE);
479     if (!Shape.IsNull())
480     {
481       Generator->AddWire(TopoDS::Wire(Shape));
482       if (!IsFirstWire)
483         IsFirstWire = Standard_True;
484       else
485         IsFirstWire = Standard_False;
486     }
487     else
488     {
489       Shape = DBRep::Get(a[i], TopAbs_VERTEX);
490       IsWire = Standard_False;
491       if (!Shape.IsNull())
492         Generator->AddVertex(TopoDS::Vertex(Shape));
493       else
494         return 1;
495     }
496
497     Standard_Integer cpt = 0;
498     TopExp_Explorer PE;
499     for (PE.Init(Shape, TopAbs_EDGE); PE.More(); PE.Next()) {
500       cpt++;
501     }
502     if (IsFirstWire)
503       NbEdges = cpt;
504     else
505       if (IsWire && cpt != NbEdges)
506         samenumber = Standard_False;
507
508   }
509
510   check = (check || !samenumber);
511   Generator->CheckCompatibility(check);
512
513   Generator->Build();
514
515   if (Generator->IsDone()) {
516     TopoDS_Shape Shell = Generator->Shape();
517     DBRep::Set(a[index - 1], Shell);
518     // Save history of the lofting
519     if (BRepTest_Objects::IsHistoryNeeded())
520       BRepTest_Objects::SetHistory(Generator->Wires(), *Generator);
521   }
522   else {
523     std::cout << "Algorithm is not done" << std::endl;
524   }
525
526   return 0;
527 }
528
529 //=======================================================================
530 //  mksweep
531 //=======================================================================
532 static Standard_Integer mksweep(Draw_Interpretor&,
533   Standard_Integer n, const char** a)
534 {
535   if (n != 2) return 1;
536   TopoDS_Shape Spine = DBRep::Get(a[1], TopAbs_WIRE);
537   if (Spine.IsNull()) return 1;
538   if (Sweep != 0)  {
539     delete Sweep;
540     Sweep = 0;
541   }
542   Sweep = new BRepOffsetAPI_MakePipeShell(TopoDS::Wire(Spine));
543   return 0;
544 }
545
546 //=======================================================================
547 //  setsweep
548 //=======================================================================
549 static Standard_Integer setsweep(Draw_Interpretor& di,
550   Standard_Integer n, const char** a)
551 {
552   if (n == 1) {
553     //std::cout << "setsweep options [arg1 [arg2 [...]]] : options are :" << std::endl;
554     //std::cout << "   -FR : Tangent and Normal are given by Frenet trihedron" <<std::endl;
555     //std::cout << "   -CF : Tangente is given by Frenet," << std::endl;
556     //std::cout << "         the Normal is computed to minimize the torsion " << std::endl;
557     //std::cout << "   -DX Surf : Tangent and Normal are given by Darboux trihedron,"
558     //  <<std::endl;     
559     //std::cout << "       Surf have to be a shell or a face" <<std::endl;
560     //std::cout << "   -CN dx dy dz : BiNormal is given by dx dy dz" << std::endl;
561     //std::cout << "   -FX Tx Ty TZ [Nx Ny Nz] : Tangent and Normal are fixed" <<std::endl;
562     //std::cout << "   -G guide  0|1(ACR|Plan)  0|1(contact|no contact) : with guide"<<std::endl;
563     di << "setsweep options [arg1 [arg2 [...]]] : options are :\n";
564     di << "   -FR : Tangent and Normal are given by Frenet trihedron\n";
565     di << "   -CF : Tangente is given by Frenet,\n";
566     di << "         the Normal is computed to minimize the torsion \n";
567     di << "   -DT : discrete trihedron\n";
568     di << "   -DX Surf : Tangent and Normal are given by Darboux trihedron,\n";
569     di << "       Surf have to be a shell or a face\n";
570     di << "   -CN dx dy dz : BiNormal is given by dx dy dz\n";
571     di << "   -FX Tx Ty TZ [Nx Ny Nz] : Tangent and Normal are fixed\n";
572     di << "   -G guide  0|1(Plan|ACR)  0|1|2(no contact|contact|contact on border) : with guide\n";
573     return 0;
574   }
575
576   if (Sweep == 0) {
577     //std::cout << "You have forgotten the <<mksweep>> command  !"<< std::endl;
578     di << "You have forgotten the <<mksweep>> command  !\n";
579     return 1;
580   }
581   if (!strcmp(a[1], "-FR")) {
582     Sweep->SetMode(Standard_True);
583   }
584   else if (!strcmp(a[1], "-CF")) {
585     Sweep->SetMode(Standard_False);
586   }
587   else if (!strcmp(a[1], "-DT")) {
588     Sweep->SetDiscreteMode();
589   }
590   else if (!strcmp(a[1], "-DX")) {
591     if (n != 3) {
592       //std::cout << "bad arguments !" << std::endl;
593       di << "bad arguments !\n";
594       return 1;
595     }
596     TopoDS_Shape Surf;
597     Surf = DBRep::Get(a[2], TopAbs_SHAPE);
598     if (Surf.IsNull()) {
599       //std::cout << a[2] <<"is not a shape !" << std::endl;
600       di << a[2] << "is not a shape !\n";
601       return 1;
602     }
603     Sweep->SetMode(Surf);
604   }
605   else if (!strcmp(a[1], "-CN")) {
606     if (n != 5) {
607       //std::cout << "bad arguments !" << std::endl;
608       di << "bad arguments !\n";
609       return 1;
610     }
611     gp_Dir D(Draw::Atof(a[2]), Draw::Atof(a[3]), Draw::Atof(a[4]));
612     Sweep->SetMode(D);
613   }
614   else if (!strcmp(a[1], "-FX")) {
615     if ((n != 5) && (n != 8)) {
616       //std::cout << "bad arguments !" << std::endl;
617       di << "bad arguments !\n";
618       return 1;
619     }
620     gp_Dir D(Draw::Atof(a[2]), Draw::Atof(a[3]), Draw::Atof(a[4]));
621     if (n == 8) {
622       gp_Dir DN(Draw::Atof(a[5]), Draw::Atof(a[6]), Draw::Atof(a[7]));
623       gp_Ax2 Axe(gp_Pnt(0., 0., 0.), D, DN);
624       Sweep->SetMode(Axe);
625     }
626     else {
627       gp_Ax2 Axe(gp_Pnt(0., 0., 0.), D);
628       Sweep->SetMode(Axe);
629     }
630   }
631   else if (!strcmp(a[1], "-G"))  // contour guide
632   {
633     if (n != 5)
634     {
635       //std::cout << "bad arguments !" << std::endl;
636       di << "bad arguments !\n";
637       return 1;
638     }
639     else
640     {
641       TopoDS_Shape Guide = DBRep::Get(a[2], TopAbs_WIRE);
642       Standard_Boolean CurvilinearEquivalence = Draw::Atoi(a[3]) != 0;
643       Standard_Integer KeepContact = Draw::Atoi(a[4]);
644       Sweep->SetMode(TopoDS::Wire(Guide),
645         CurvilinearEquivalence,
646         (BRepFill_TypeOfContact)KeepContact);
647     }
648   }
649
650   else {
651     //std::cout << "The option "<< a[1] << " is unknown !" << std::endl;
652     di << "The option " << a[1] << " is unknown !\n";
653     return 1;
654   }
655   return 0;
656 }
657
658
659 //=======================================================================
660 //  addsweep
661 //=======================================================================
662 static Standard_Integer addsweep(Draw_Interpretor& di,
663   Standard_Integer n, const char** a)
664 {
665   if (n == 1) {
666     //std::cout << "addsweep wire/vertex [Vertex] [-T] [-R] [u0 v0 u1 v1 [...[uN vN]]] : options are :" << std::endl;
667     //std::cout << "   -T : the wire/vertex have to be translated to assume contact"<< std::endl;
668     //std::cout << "        with the spine" <<std::endl;
669     //std::cout << "   -R : the wire have to be rotated to assume orthogonality"<<std::endl;
670     //std::cout << "        with the spine's tangent" << std::endl;
671     di << "addsweep wire/vertex [Vertex] [-T] [-R] [u0 v0 u1 v1 [...[uN vN]]] : options are :\n";
672     di << "   -T : the wire/vertex have to be translated to assume contact\n";
673     di << "        with the spine\n";
674     di << "   -R : the wire have to be rotated to assume orthogonality\n";
675     di << "        with the spine's tangent\n";
676     return 0;
677   }
678
679   if (Sweep == 0) {
680     //std::cout << "You have forgotten the <<mksweep>> command  !"<< std::endl;
681     di << "You have forgotten the <<mksweep>> command  !\n";
682     return 1;
683   }
684
685   TopoDS_Shape  Section;
686   TopoDS_Vertex Vertex;
687   Handle(Law_Interpol) thelaw;
688
689   Section = DBRep::Get(a[1], TopAbs_SHAPE);
690   if (Section.IsNull() ||
691     (Section.ShapeType() != TopAbs_WIRE &&
692     Section.ShapeType() != TopAbs_VERTEX))
693   {
694     //std::cout << a[1] <<"is not a wire and is not a vertex!" << std::endl;
695     di << a[1] << " is not a wire and is not a vertex!\n";
696     return 1;
697   }
698
699   Standard_Boolean HasVertex = Standard_False,
700     isT = Standard_False,
701     isR = Standard_False;
702
703   if (n > 2) {
704     Standard_Integer cur = 2;
705     // Reading of Vertex
706     TopoDS_Shape InputVertex(DBRep::Get(a[cur], TopAbs_VERTEX));
707     Vertex = TopoDS::Vertex(InputVertex);
708     //    Vertex = TopoDS::Vertex(DBRep::Get(a[cur],TopAbs_VERTEX));
709     if (!Vertex.IsNull()) {
710       cur++;
711       HasVertex = Standard_True;
712     }
713
714     // Reading of the translation option
715     if ((n > cur) && !strcmp(a[cur], "-T")) {
716       cur++;
717       isT = Standard_True;
718     }
719
720     // Reading of the rotation option
721     if ((n > cur) && !strcmp(a[cur], "-R")) {
722       cur++;
723       isR = Standard_True;
724     }
725
726     // law ?
727     if (n > cur) {
728       Standard_Integer nbreal = n - cur;
729       if ((nbreal < 4) || (nbreal % 2 != 0)) {
730         //std::cout << "bad arguments ! :" <<a[cur] << std::endl;
731         di << "bad arguments ! :" << a[cur] << "\n";
732       }
733       else { //law of interpolation
734         Standard_Integer ii, L = nbreal / 2;
735         TColgp_Array1OfPnt2d ParAndRad(1, L);
736         for (ii = 1; ii <= L; ii++, cur += 2) {
737           ParAndRad(ii).SetX(Draw::Atof(a[cur]));
738           ParAndRad(ii).SetY(Draw::Atof(a[cur + 1]));
739         }
740         thelaw = new (Law_Interpol)();
741         thelaw->Set(ParAndRad,
742           Abs(ParAndRad(1).Y() - ParAndRad(L).Y()) < Precision::Confusion());
743       }
744     }
745   }
746
747   if (thelaw.IsNull()) {
748     if (HasVertex) Sweep->Add(Section, Vertex, isT, isR);
749     else           Sweep->Add(Section, isT, isR);
750   }
751   else {
752     if (HasVertex) Sweep->SetLaw(Section, thelaw, Vertex, isT, isR);
753     else           Sweep->SetLaw(Section, thelaw, isT, isR);
754   }
755
756   return 0;
757 }
758
759 //=======================================================================
760 //  deletesweep
761 //=======================================================================
762 static Standard_Integer deletesweep(Draw_Interpretor& di,
763   Standard_Integer n, const char** a)
764 {
765   if (n != 2) {
766     return 1;
767   }
768   TopoDS_Wire Section;
769   TopoDS_Shape InputShape(DBRep::Get(a[1], TopAbs_SHAPE));
770   Section = TopoDS::Wire(InputShape);
771   //  Section = TopoDS::Wire(DBRep::Get(a[1],TopAbs_SHAPE));
772   if (Section.IsNull()) {
773     //std::cout << a[1] <<"is not a wire !" << std::endl;
774     di << a[1] << "is not a wire !\n";
775     return 1;
776   }
777
778   Sweep->Delete(Section);
779
780   return 0;
781 }
782
783 //=======================================================================
784 //  buildsweep
785 //=======================================================================
786 static Standard_Integer buildsweep(Draw_Interpretor& di,
787   Standard_Integer n, const char** a)
788 {
789   if (n == 1) {
790     //std::cout << "build sweep result [-M/-C/-R] [-S] [tol] : options are" << std::endl;
791     //std::cout << "   -M : Discontinuities are treated by Modfication of"<< std::endl; 
792     //std::cout << "        the sweeping mode : it is the default" <<std::endl;
793     //std::cout << "   -C : Discontinuities are treated like Right Corner" << std::endl;
794     //std::cout << "        Treatement is Extent && Intersect" << std::endl;
795     //std::cout << "   -R : Discontinuities are treated like Round Corner" << std::endl;
796     //std::cout << "        Treatement is Intersect and Fill" << std::endl;
797     //std::cout << "   -S : To build a Solid" << std::endl;
798     di << "build sweep result [-M/-C/-R] [-S] [tol] : options are\n";
799     di << "   -M : Discontinuities are treated by Modfication of\n";
800     di << "        the sweeping mode : it is the default\n";
801     di << "   -C : Discontinuities are treated like Right Corner\n";
802     di << "        Treatement is Extent && Intersect\n";
803     di << "   -R : Discontinuities are treated like Round Corner\n";
804     di << "        Treatement is Intersect and Fill\n";
805     di << "   -S : To build a Solid\n";
806     return 0;
807   }
808
809   Standard_Boolean mksolid = Standard_False;
810   if (Sweep == 0) {
811     //std::cout << "You have forgotten the <<mksweep>> command  !"<< std::endl;
812     di << "You have forgotten the <<mksweep>> command  !\n";
813     return 1;
814   }
815
816   if (!Sweep->IsReady()) {
817     //std::cout << "You have forgotten the <<addsweep>> command  !"<< std::endl;
818     di << "You have forgotten the <<addsweep>> command  !\n";
819     return 1;
820   }
821
822   TopoDS_Shape result;
823   Standard_Integer cur = 2;
824   if (n > cur) {
825     BRepBuilderAPI_TransitionMode Transition = BRepBuilderAPI_Transformed;
826
827     // Reading Transition
828     if (!strcmp(a[cur], "-C")) {
829       Transition = BRepBuilderAPI_RightCorner;
830       cur++;
831     }
832     else if (!strcmp(a[cur], "-R")) {
833       Transition = BRepBuilderAPI_RoundCorner;
834       cur++;
835     }
836     Sweep->SetTransitionMode(Transition);
837   }
838   // Reading solid ?
839   if ((n > cur) && (!strcmp(a[cur], "-S"))) mksolid = Standard_True;
840
841   // Calcul le resultat
842   Sweep->Build();
843   if (!Sweep->IsDone()) {
844     //std::cout << "Buildsweep : Not Done" << std::endl;
845     di << "Buildsweep : Not Done\n";
846     BRepBuilderAPI_PipeError Stat = Sweep->GetStatus();
847     if (Stat == BRepBuilderAPI_PlaneNotIntersectGuide) {
848       //std::cout << "Buildsweep : One Plane not intersect the guide" << std::endl;
849       di << "Buildsweep : One Plane not intersect the guide\n";
850     }
851     if (Stat == BRepBuilderAPI_ImpossibleContact) {
852       //std::cout << "BuildSweep : One section can not be in contact with the guide" << std::endl;
853       di << "BuildSweep : One section can not be in contact with the guide\n";
854     }
855   }
856   else {
857     if (mksolid) {
858       Standard_Boolean B;
859       B = Sweep->MakeSolid();
860       //if (!B) std::cout << " BuildSweep : It is impossible to make a solid !" << std::endl;
861       if (!B) di << " BuildSweep : It is impossible to make a solid !\n";
862     }
863     result = Sweep->Shape();
864     DBRep::Set(a[1], result);
865     // Save history of sweep
866     if (BRepTest_Objects::IsHistoryNeeded())
867     {
868       TopTools_ListOfShape aList;
869       Sweep->Profiles(aList);
870       TopoDS_Shape aSpine = Sweep->Spine();
871       aList.Append(aSpine);
872       BRepTest_Objects::SetHistory(aList, *Sweep);
873     }
874   }
875
876   return 0;
877 }
878
879 //=======================================================================
880 //function : errorsweep
881 //purpose  : returns the summary error on resulting surfaces
882 //           reached by Sweep
883 //=======================================================================
884 static Standard_Integer errorsweep(Draw_Interpretor& di,
885   Standard_Integer, const char**)
886 {
887   if (!Sweep->IsDone())
888   {
889     di << "Sweep is not done\n";
890     return 1;
891   }
892   Standard_Real ErrorOnSurfaces = Sweep->ErrorOnSurface();
893   di << "Tolerance on surfaces = " << ErrorOnSurfaces << "\n";
894   return 0;
895 }
896
897 //=======================================================================
898 //  simulsweep
899 //=======================================================================
900 static Standard_Integer simulsweep(Draw_Interpretor& di,
901   Standard_Integer n, const char** a)
902 {
903   if ((n != 3) && (n != 4)) return 1;
904
905   if (Sweep == 0) {
906     //std::cout << "You have forgotten the <<mksweep>> command  !"<< std::endl;
907     di << "You have forgotten the <<mksweep>> command  !\n";
908     return 1;
909   }
910
911   if (!Sweep->IsReady()) {
912     //std::cout << "You have forgotten the <<addsweep>> command  !"<< std::endl;
913     di << "You have forgotten the <<addsweep>> command  !\n";
914     return 1;
915   }
916
917   char name[100];
918   TopTools_ListOfShape List;
919   TopTools_ListIteratorOfListOfShape it;
920   Standard_Integer N, ii;
921   N = Draw::Atoi(a[2]);
922
923   if (n > 3) {
924     BRepBuilderAPI_TransitionMode Transition = BRepBuilderAPI_Transformed;
925     // Lecture Transition
926     if (!strcmp(a[3], "-C")) {
927       Transition = BRepBuilderAPI_RightCorner;
928     }
929     else if (!strcmp(a[3], "-R")) {
930       Transition = BRepBuilderAPI_RoundCorner;
931     }
932     Sweep->SetTransitionMode(Transition);
933   }
934
935   // Calculate the result
936   Sweep->Simulate(N, List);
937   for (ii = 1, it.Initialize(List); it.More(); it.Next(), ii++) {
938     Sprintf(name, "%s_%d", a[1], ii);
939     DBRep::Set(name, it.Value());
940   }
941
942   return 0;
943 }
944
945 //=======================================================================
946 //  middlepath
947 //=======================================================================
948 static Standard_Integer middlepath(Draw_Interpretor& /*di*/,
949   Standard_Integer n, const char** a)
950 {
951   if (n < 5) return 1;
952
953   TopoDS_Shape aShape = DBRep::Get(a[2]);
954   if (aShape.IsNull()) return 1;
955
956   TopoDS_Shape StartShape = DBRep::Get(a[3]);
957   if (StartShape.IsNull()) return 1;
958
959   TopoDS_Shape EndShape = DBRep::Get(a[4]);
960   if (EndShape.IsNull()) return 1;
961
962   BRepOffsetAPI_MiddlePath Builder(aShape, StartShape, EndShape);
963   Builder.Build();
964
965   TopoDS_Shape Result = Builder.Shape();
966   DBRep::Set(a[1], Result);
967
968   return 0;
969 }
970
971 //=======================================================================
972 //function : SweepCommands
973 //purpose  : 
974 //=======================================================================
975
976 void  BRepTest::SweepCommands(Draw_Interpretor& theCommands)
977 {
978   static Standard_Boolean done = Standard_False;
979   if (done) return;
980   done = Standard_True;
981
982   DBRep::BasicCommands(theCommands);
983
984   const char* g = "Sweep commands";
985
986   theCommands.Add("prism",
987     "prism result base dx dy dz [Copy | Inf | Seminf]",
988     __FILE__, prism, g);
989
990   theCommands.Add("revol",
991     "revol result base px py pz dx dy dz angle [Copy]",
992     __FILE__, revol, g);
993
994   theCommands.Add("pipe",
995     "pipe result Wire_spine Profile [Mode [Approx]], no args to get help",
996     __FILE__, pipe, g);
997
998   theCommands.Add("evolved",
999     "evolved , no args to get help",
1000     __FILE__, evolved, g);
1001
1002   theCommands.Add("pruled",
1003     "pruled result Edge1/Wire1 Edge2/Wire2",
1004     __FILE__, pruled, g);
1005
1006   theCommands.Add("gener", "gener result wire1 wire2 [..wire..]",
1007     __FILE__, gener, g);
1008
1009   theCommands.Add("thrusections", "thrusections [-N] result issolid isruled shape1 shape2 [..shape..], the option -N means no check on wires, shapes must be wires or vertices (only first or last)",
1010     __FILE__, thrusections, g);
1011
1012   theCommands.Add("mksweep", "mksweep wire",
1013     __FILE__, mksweep, g);
1014
1015   theCommands.Add("setsweep", "setsweep  no args to get help",
1016     __FILE__, setsweep, g);
1017
1018   theCommands.Add("addsweep",
1019     "addsweep wire [vertex] [-M ] [-C] [auxiilaryshape]:no args to get help",
1020     __FILE__, addsweep, g);
1021
1022   theCommands.Add("deletesweep",
1023     "deletesweep wire, To delete a section",
1024     __FILE__, deletesweep, g);
1025
1026   theCommands.Add("buildsweep", "builsweep [r] [option] [Tol] , no args to get help",
1027     __FILE__, buildsweep, g);
1028
1029   theCommands.Add("errorsweep", "errorsweep: returns the summary error on resulting surfaces reached by Sweep",
1030     __FILE__, errorsweep, g);
1031
1032   theCommands.Add("simulsweep", "simulsweep r [n] [option]"
1033     __FILE__, simulsweep, g);
1034   theCommands.Add("geompipe", "geompipe r spineedge profileedge radius [byACR [byrotate]]"
1035     __FILE__, geompipe, g);
1036
1037   theCommands.Add("middlepath", "middlepath res shape startshape endshape",
1038     __FILE__, middlepath, g);
1039 }
1040