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