src/BOPTest/BOPTest_BOPCommands.cxx

   1 // Created on: 2000-03-16
   2 // Created by: Peter KURNEV
   3 // Copyright (c) 2000-2014 OPEN CASCADE SAS
   4 //
   5 // This file is part of Open CASCADE Technology software library.
   6 //
   7 // This library is free software; you can redistribute it and/or modify it under
   8 // the terms of the GNU Lesser General Public License version 2.1 as published
   9 // by the Free Software Foundation, with special exception defined in the file
  10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  11 // distribution for complete text of the license and disclaimer of any warranty.
  12 //
  13 // Alternatively, this file may be used under the terms of Open CASCADE
  14 // commercial license or contractual agreement.
  15
  16 #include <BOPTest.ixx>
  17
  18 #include <stdio.h>
  19
  20 #include <TCollection_AsciiString.hxx>
  21
  22 #include <DBRep.hxx>
  23 #include <DrawTrSurf.hxx>
  24 #include <Draw_Color.hxx>
  25 #include <Draw.hxx>
  26
  27 #include <NCollection_BaseAllocator.hxx>
  28 #include <NCollection_IncAllocator.hxx>
  29
  30 #include <TopoDS_Shape.hxx>
  31 #include <TopoDS_Compound.hxx>
  32 #include <TopoDS_Iterator.hxx>
  33 //
  34 #include <BRep_Builder.hxx>
  35
  36 #include <IntTools_FaceFace.hxx>
  37 #include <IntTools_Curve.hxx>
  38
  39 #include <BOPCol_ListOfShape.hxx>
  40
  41 #include <BOPDS_DS.hxx>
  42
  43 #include <BOPAlgo_PaveFiller.hxx>
  44 #include <BOPAlgo_Operation.hxx>
  45 #include <BOPAlgo_BOP.hxx>
  46 #include <BOPAlgo_MakerVolume.hxx>
  47 #include <BOPAlgo_Section.hxx>
  48
  49 #include <BRepAlgoAPI_BooleanOperation.hxx>
  50 #include <BRepAlgoAPI_Common.hxx>
  51 #include <BRepAlgoAPI_Fuse.hxx>
  52 #include <BRepAlgoAPI_Cut.hxx>
  53 #include <BRepAlgoAPI_Section.hxx>
  54
  55 #include <BOPTest_DrawableShape.hxx>
  56 #include <BOPTest_Objects.hxx>
  57
  58 //
  59 static BOPAlgo_PaveFiller* pPF=NULL;
  60 //
  61
  62 static
  63   Standard_Integer bopsmt(Draw_Interpretor& di,
  64                           Standard_Integer n,
  65                           const char** a,
  66                           const BOPAlgo_Operation aOp);
  67 //
  68 static
  69   Standard_Integer bsmt (Draw_Interpretor& di,
  70                        Standard_Integer n,
  71                        const char** a,
  72                        const BOPAlgo_Operation aOp);
  73 //
  74 static Standard_Integer bop       (Draw_Interpretor&, Standard_Integer, const char**);
  75 static Standard_Integer bopsection(Draw_Interpretor&, Standard_Integer, const char**);
  76 static Standard_Integer boptuc    (Draw_Interpretor&, Standard_Integer, const char**);
  77 static Standard_Integer bopcut    (Draw_Interpretor&, Standard_Integer, const char**);
  78 static Standard_Integer bopfuse   (Draw_Interpretor&, Standard_Integer, const char**);
  79 static Standard_Integer bopcommon (Draw_Interpretor&, Standard_Integer, const char**);
  80 //
  81 static Standard_Integer bsection  (Draw_Interpretor&, Standard_Integer, const char**);
  82 static Standard_Integer btuc      (Draw_Interpretor&, Standard_Integer, const char**);
  83 static Standard_Integer bcut      (Draw_Interpretor&, Standard_Integer, const char**);
  84 static Standard_Integer bfuse     (Draw_Interpretor&, Standard_Integer, const char**);
  85 static Standard_Integer bcommon   (Draw_Interpretor&, Standard_Integer, const char**);
  86 //
  87 static Standard_Integer bopcurves (Draw_Interpretor&, Standard_Integer, const char**);
  88 static Standard_Integer bopnews   (Draw_Interpretor&, Standard_Integer, const char**);
  89 static Standard_Integer mkvolume   (Draw_Interpretor&, Standard_Integer, const char**);
  90
  91 //=======================================================================
  92 //function : BOPCommands
  93 //purpose  :
  94 //=======================================================================
  95   void BOPTest::BOPCommands(Draw_Interpretor& theCommands)
  96 {
  97   static Standard_Boolean done = Standard_False;
  98   if (done) return;
  99   done = Standard_True;
 100   // Chapter's name
 101   const char* g = "BOPTest commands";
 102   // Commands
 103
 104   theCommands.Add("bop"       , "use bop s1 s2" , __FILE__, bop, g);
 105   theCommands.Add("bopcommon" , "use bopcommon r"     , __FILE__, bopcommon, g);
 106   theCommands.Add("bopfuse"   , "use bopfuse r"       , __FILE__,bopfuse, g);
 107   theCommands.Add("bopcut"    , "use bopcut r"        , __FILE__,bopcut, g);
 108   theCommands.Add("boptuc"    , "use boptuc r"        , __FILE__,boptuc, g);
 109   theCommands.Add("bopsection", "use bopsection r"    , __FILE__,bopsection, g);
 110   //
 111   theCommands.Add("bcommon" , "use bcommon r s1 s2" , __FILE__,bcommon, g);
 112   theCommands.Add("bfuse"   , "use bfuse r s1 s2"   , __FILE__,bfuse, g);
 113   theCommands.Add("bcut"    , "use bcut r s1 s2"    , __FILE__,bcut, g);
 114   theCommands.Add("btuc"    , "use btuc r s1 s2"    , __FILE__,btuc, g);
 115   theCommands.Add("bsection", "use bsection r s1 s2 [-n2d/-n2d1/-n2d2] [-na]",
 116                                                       __FILE__, bsection, g);
 117   //
 118   theCommands.Add("bopcurves", "use bopcurves F1 F2 [-2d/-2d1/-2d2]",
 119                                                       __FILE__, bopcurves, g);
 120   theCommands.Add("bopnews"  , "use  bopnews -v[e,f]"      , __FILE__, bopnews, g);
 121   theCommands.Add("mkvolume", "make solids from set of shapes.\nmkvolume r b1 b2 ... [-c] [-ni]",
 122                   __FILE__, mkvolume , g);
 123 }
 124
 125 //=======================================================================
 126 //function : bop
 127 //purpose  :
 128 //=======================================================================
 129 Standard_Integer bop(Draw_Interpretor& di,
 130                      Standard_Integer n,
 131                      const char** a)
 132 {
 133   char buf[32];
 134   Standard_Boolean bRunParallel;
 135   Standard_Integer iErr;
 136   Standard_Real aTol;
 137   TopoDS_Shape aS1, aS2;
 138   BOPCol_ListOfShape aLC;
 139   //
 140   if (n != 3) {
 141     di << " use bop s1 s2 \n";
 142     return 0;
 143   }
 144   //
 145   aS1=DBRep::Get(a[1]);
 146   aS2=DBRep::Get(a[2]);
 147   //
 148   if (aS1.IsNull() || aS2.IsNull()) {
 149     di << " null shapes are not allowed \n";
 150     return 0;
 151   }
 152   //
 153   aTol=BOPTest_Objects::FuzzyValue();
 154   bRunParallel=BOPTest_Objects::RunParallel();
 155   //
 156   aLC.Append(aS1);
 157   aLC.Append(aS2);
 158   //
 159   if (pPF!=NULL) {
 160     delete pPF;
 161     pPF=NULL;
 162   }
 163   Handle(NCollection_BaseAllocator)aAL=new NCollection_IncAllocator;
 164   pPF=new BOPAlgo_PaveFiller(aAL);
 165   //
 166   pPF->SetArguments(aLC);
 167   pPF->SetFuzzyValue(aTol);
 168   pPF->SetRunParallel(bRunParallel);
 169   //
 170   pPF->Perform();
 171   iErr=pPF->ErrorStatus();
 172   if (iErr) {
 173     Sprintf(buf, " ErrorStatus : %d\n",  iErr);
 174     di << buf;
 175     return 0;
 176   }
 177   //
 178   return 0;
 179 }
 180 //=======================================================================
 181 //function : bopcommon
 182 //purpose  :
 183 //=======================================================================
 184 Standard_Integer bopcommon (Draw_Interpretor& di,
 185                             Standard_Integer n,
 186                             const char** a)
 187 {
 188   return bopsmt(di, n, a, BOPAlgo_COMMON);
 189 }
 190 //=======================================================================
 191 //function : bopfuse
 192 //purpose  :
 193 //=======================================================================
 194 Standard_Integer bopfuse(Draw_Interpretor& di,
 195                          Standard_Integer n,
 196                          const char** a)
 197 {
 198   return bopsmt(di, n, a, BOPAlgo_FUSE);
 199 }
 200 //=======================================================================
 201 //function : bopcut
 202 //purpose  :
 203 //=======================================================================
 204 Standard_Integer bopcut(Draw_Interpretor& di,
 205                         Standard_Integer n,
 206                         const char** a)
 207 {
 208   return bopsmt(di, n, a, BOPAlgo_CUT);
 209 }
 210 //=======================================================================
 211 //function : boptuc
 212 //purpose  :
 213 //=======================================================================
 214 Standard_Integer boptuc(Draw_Interpretor& di,
 215                         Standard_Integer n,
 216                         const char** a)
 217 {
 218   return bopsmt(di, n, a, BOPAlgo_CUT21);
 219 }
 220 //=======================================================================
 221 //function : bopsmt
 222 //purpose  :
 223 //=======================================================================
 224 Standard_Integer bopsmt(Draw_Interpretor& di,
 225                         Standard_Integer n,
 226                         const char** a,
 227                         const BOPAlgo_Operation aOp)
 228 {
 229   if (n<2) {
 230     di << " use bopsmt r\n";
 231     return 0;
 232   }
 233   //
 234   if (!pPF) {
 235     di << " prepare PaveFiller first\n";
 236     return 0;
 237   }
 238   //
 239   if (pPF->ErrorStatus()) {
 240     di << " PaveFiller has not been done\n";
 241     return 0;
 242   }
 243   //
 244   char buf[64];
 245   Standard_Boolean bRunParallel;
 246   Standard_Integer aNb, iErr;
 247   BOPAlgo_BOP aBOP;
 248   //
 249   const BOPCol_ListOfShape& aLC=pPF->Arguments();
 250   aNb=aLC.Extent();
 251   if (aNb!=2) {
 252     Sprintf (buf, " wrong number of arguments %s\n", aNb);
 253     di << buf;
 254     return 0;
 255   }
 256   //
 257   bRunParallel=BOPTest_Objects::RunParallel();
 258   //
 259   const TopoDS_Shape& aS1=aLC.First();
 260   const TopoDS_Shape& aS2=aLC.Last();
 261   //
 262   aBOP.AddArgument(aS1);
 263   aBOP.AddTool(aS2);
 264   aBOP.SetOperation(aOp);
 265   aBOP.SetRunParallel (bRunParallel);
 266   //
 267   aBOP.PerformWithFiller(*pPF);
 268   iErr=aBOP.ErrorStatus();
 269   if (iErr) {
 270     Sprintf(buf, " ErrorStatus : %d\n",  iErr);
 271     di << buf;
 272     return 0;
 273   }
 274   //
 275   const TopoDS_Shape& aR=aBOP.Shape();
 276   if (aR.IsNull()) {
 277     di << " null shape\n";
 278     return 0;
 279   }
 280   //
 281   DBRep::Set(a[1], aR);
 282   return 0;
 283 }
 284 //=======================================================================
 285 //function : bopsection
 286 //purpose  :
 287 //=======================================================================
 288 Standard_Integer bopsection(Draw_Interpretor& di,
 289                             Standard_Integer n,
 290                             const char** a)
 291 {
 292   if (n<2) {
 293     di << " use bopsection r\n";
 294     return 0;
 295   }
 296   //
 297   if (!pPF) {
 298     di << " prepare PaveFiller first\n";
 299     return 0;
 300   }
 301   //
 302   if (pPF->ErrorStatus()) {
 303     di << " PaveFiller has not been done\n";
 304     return 0;
 305   }
 306   //
 307   char buf[64];
 308   Standard_Boolean bRunParallel;
 309   Standard_Integer aNb, iErr;
 310   BOPAlgo_Section aBOP;
 311   //
 312   const BOPCol_ListOfShape& aLC=pPF->Arguments();
 313   aNb=aLC.Extent();
 314   if (aNb!=2) {
 315     Sprintf (buf, " wrong number of arguments %s\n", aNb);
 316     di << buf;
 317     return 0;
 318   }
 319   //
 320   bRunParallel=BOPTest_Objects::RunParallel();
 321   //
 322   const TopoDS_Shape& aS1=aLC.First();
 323   const TopoDS_Shape& aS2=aLC.Last();
 324   //
 325   aBOP.AddArgument(aS1);
 326   aBOP.AddArgument(aS2);
 327   aBOP.SetRunParallel (bRunParallel);
 328   //
 329   aBOP.PerformWithFiller(*pPF);
 330   iErr=aBOP.ErrorStatus();
 331   if (iErr) {
 332     Sprintf(buf, " ErrorStatus : %d\n",  iErr);
 333     di << buf;
 334     return 0;
 335   }
 336   //
 337   const TopoDS_Shape& aR=aBOP.Shape();
 338   if (aR.IsNull()) {
 339     di << " null shape\n";
 340     return 0;
 341   }
 342   //
 343   DBRep::Set(a[1], aR);
 344   return 0;
 345 }
 346 //=======================================================================
 347 //function : bcommon
 348 //purpose  :
 349 //=======================================================================
 350 Standard_Integer bcommon (Draw_Interpretor& di,
 351                           Standard_Integer n,
 352                           const char** a)
 353 {
 354   return bsmt(di, n, a, BOPAlgo_COMMON);
 355 }
 356 //=======================================================================
 357 //function : bfuse
 358 //purpose  :
 359 //=======================================================================
 360 Standard_Integer bfuse (Draw_Interpretor& di,
 361                         Standard_Integer n,
 362                         const char** a)
 363 {
 364   return bsmt(di, n, a, BOPAlgo_FUSE);
 365 }
 366 //=======================================================================
 367 //function : bcut
 368 //purpose  :
 369 //=======================================================================
 370 Standard_Integer bcut (Draw_Interpretor& di,
 371                        Standard_Integer n,
 372                        const char** a)
 373 {
 374   return bsmt(di, n, a, BOPAlgo_CUT);
 375 }
 376 //=======================================================================
 377 //function : btuc
 378 //purpose  :
 379 //=======================================================================
 380 Standard_Integer btuc (Draw_Interpretor& di,
 381                        Standard_Integer n,
 382                        const char** a)
 383 {
 384   return bsmt(di, n, a, BOPAlgo_CUT21);
 385 }
 386 //=======================================================================
 387 //function : bsection
 388 //purpose  :
 389 //=======================================================================
 390 Standard_Integer  bsection(Draw_Interpretor& di,
 391                            Standard_Integer n,
 392                            const char** a)
 393 {
 394   if (n < 4) {
 395     di << "use bsection r s1 s2 [-n2d/-n2d1/-n2d2] [-na] [tol]\n";
 396     return 0;
 397   }
 398   //
 399   TopoDS_Shape aS1, aS2;
 400   //
 401   aS1=DBRep::Get(a[2]);
 402   aS2=DBRep::Get(a[3]);
 403   if (aS1.IsNull() || aS2.IsNull()) {
 404     di << " Null shapes are not allowed \n";
 405     return 0;
 406   }
 407   //
 408   char buf[80];
 409   Standard_Boolean bRunParallel, bApp, bPC1, bPC2;
 410   Standard_Integer i, iErr;
 411   Standard_Real aTol;
 412   //
 413   bApp = Standard_True;
 414   bPC1 = Standard_True;
 415   bPC2 = Standard_True;
 416   aTol = BOPTest_Objects::FuzzyValue();
 417   bRunParallel = BOPTest_Objects::RunParallel();
 418   //
 419   for (i = 4; i < n; ++i) {
 420     if (!strcmp(a[i], "-n2d")) {
 421       bPC1 = Standard_False;
 422       bPC2 = Standard_False;
 423     }
 424     else if (!strcmp(a[i], "-n2d1")) {
 425       bPC1 = Standard_False;
 426     }
 427     else if (!strcmp(a[i], "-n2d2")) {
 428       bPC2 = Standard_False;
 429     }
 430     else if (!strcmp(a[i], "-na")) {
 431       bApp = Standard_False;
 432     }
 433   }
 434   //
 435   BRepAlgoAPI_Section aSec(aS1, aS2, Standard_False);
 436   //
 437   aSec.Approximation(bApp);
 438   aSec.ComputePCurveOn1(bPC1);
 439   aSec.ComputePCurveOn2(bPC2);
 440   //
 441   aSec.SetFuzzyValue(aTol);
 442   aSec.SetRunParallel(bRunParallel);
 443   //
 444   aSec.Build();
 445   iErr=aSec.ErrorStatus();
 446   if (!aSec.IsDone()) {
 447     Sprintf(buf, " ErrorStatus : %d\n",  iErr);
 448     di << buf;
 449     return 0;
 450   }
 451   //
 452   const TopoDS_Shape& aR=aSec.Shape();
 453   if (aR.IsNull()) {
 454     di << " null shape\n";
 455     return 0;
 456   }
 457   DBRep::Set(a[1], aR);
 458   return 0;
 459 }
 460 //=======================================================================
 461 //function : bsmt
 462 //purpose  :
 463 //=======================================================================
 464 Standard_Integer bsmt (Draw_Interpretor& di,
 465                        Standard_Integer n,
 466                        const char** a,
 467                        const BOPAlgo_Operation aOp)
 468 {
 469   char buf[32];
 470   Standard_Boolean bRunParallel;
 471   Standard_Integer iErr;
 472   TopoDS_Shape aS1, aS2;
 473   BOPCol_ListOfShape aLC;
 474   Standard_Real aTol;
 475   //
 476   if (n != 4) {
 477     di << " use bx r s1 s2\n";
 478     return 0;
 479   }
 480   //
 481   aS1=DBRep::Get(a[2]);
 482   aS2=DBRep::Get(a[3]);
 483   //
 484   if (aS1.IsNull() || aS2.IsNull()) {
 485     di << " null shapes are not allowed \n";
 486     return 0;
 487   }
 488   aLC.Append(aS1);
 489   aLC.Append(aS2);
 490   //
 491   aTol=BOPTest_Objects::FuzzyValue();
 492   bRunParallel = BOPTest_Objects::RunParallel();
 493   //
 494   Handle(NCollection_BaseAllocator)aAL=new NCollection_IncAllocator;
 495   //
 496   //---------------------------------------------------------------
 497   BOPAlgo_PaveFiller aPF(aAL);
 498   //
 499   aPF.SetArguments(aLC);
 500   aPF.SetFuzzyValue(aTol);
 501   aPF.SetRunParallel(bRunParallel);
 502   //
 503   aPF.Perform();
 504   iErr=aPF.ErrorStatus();
 505   if (iErr) {
 506     Sprintf(buf, " ErrorStatus : %d\n",  iErr);
 507     di << buf;
 508     return 0;
 509   }
 510   //
 511   //---------------------------------------------------------------
 512   BOPAlgo_BOP aBOP(aAL);
 513   //
 514   aBOP.AddArgument(aS1);
 515   aBOP.AddTool(aS2);
 516   aBOP.SetOperation(aOp);
 517   aBOP.SetRunParallel(bRunParallel);
 518   //
 519   aBOP.PerformWithFiller(aPF);
 520   //
 521   iErr=aBOP.ErrorStatus();
 522   if (iErr) {
 523     Sprintf(buf, " ErrorStatus : %d\n",  iErr);
 524     di << buf;
 525     return 0;
 526   }
 527   const TopoDS_Shape& aR=aBOP.Shape();
 528   if (aR.IsNull()) {
 529     di << " null shape\n";
 530     return 0;
 531   }
 532   //
 533   DBRep::Set(a[1], aR);
 534   return 0;
 535 }
 536 //=======================================================================
 537 //function : bopnews
 538 //purpose  :
 539 //=======================================================================
 540 Standard_Integer bopnews (Draw_Interpretor& di,
 541                           Standard_Integer n,
 542                           const char** a)
 543 {
 544   if (n!=2) {
 545     di << " use bopnews -v[e,f]\n";
 546     return 0;
 547   }
 548   //
 549   if (pPF==NULL) {
 550     di << " Prepare BOPAlgo_PaveFiller first >bop S1 S2\n";
 551     return 0;
 552   }
 553   //
 554   char buf[32];
 555   Standard_CString aText;
 556   Standard_Integer i, i1, i2, iFound;
 557   Draw_Color aTextColor(Draw_cyan);
 558   TopAbs_ShapeEnum aT;
 559   Handle(BOPTest_DrawableShape) aDShape;
 560   //
 561   const BOPDS_PDS& pDS=pPF->PDS();
 562   //
 563   aT=TopAbs_SHAPE;
 564   if (!strcmp (a[1], "-f")) {
 565     aT=TopAbs_FACE;
 566   }
 567   else if (!strcmp (a[1], "-e")){
 568     aT=TopAbs_EDGE;
 569   }
 570   else if (!strcmp (a[1], "-v")){
 571     aT=TopAbs_VERTEX;
 572   }
 573   else {
 574     di << " use bopnews -v[e,f]\n";
 575     return 0;
 576   }
 577   //
 578   iFound=0;
 579   i1=pDS->NbSourceShapes();
 580   i2=pDS->NbShapes();
 581   for (i=i1; i<i2; ++i) {
 582     const BOPDS_ShapeInfo& aSI=pDS->ShapeInfo(i);
 583     if (aSI.ShapeType()==aT) {
 584       const TopoDS_Shape& aS=aSI.Shape();
 585       //
 586       Sprintf (buf, "z%d", i);
 587       aText=buf;
 588       aDShape=new BOPTest_DrawableShape (aS, aText, aTextColor);
 589       Draw::Set (aText, aDShape);
 590       //
 591       Sprintf (buf, " z%d", i);
 592       di << buf;
 593       //
 594       iFound=1;
 595     }
 596   }
 597   //
 598   if (iFound) {
 599     di << "\n";
 600   }
 601   else {
 602     di << " not found\n";
 603   }
 604   //
 605   return 0;
 606 }
 607 //=======================================================================
 608 //function : bopcurves
 609 //purpose  :
 610 //=======================================================================
 611 Standard_Integer bopcurves (Draw_Interpretor& di,
 612                             Standard_Integer n,
 613                             const char** a)
 614 {
 615   if (n<3) {
 616     di << " use bopcurves F1 F2 [-2d/-2d1/-2d2]\n";
 617     return 1;
 618   }
 619   //
 620   TopoDS_Shape S1 = DBRep::Get(a[1]);
 621   TopoDS_Shape S2 = DBRep::Get(a[2]);
 622   TopAbs_ShapeEnum aType;
 623   //
 624   if (S1.IsNull() || S2.IsNull()) {
 625     di << " Null shapes is not allowed \n";
 626     return 1;
 627   }
 628   //
 629   aType=S1.ShapeType();
 630   if (aType != TopAbs_FACE) {
 631     di << " Type mismatch F1\n";
 632     return 1;
 633   }
 634   aType=S2.ShapeType();
 635   if (aType != TopAbs_FACE) {
 636     di << " Type mismatch F2\n";
 637     return 1;
 638   }
 639   //
 640   const TopoDS_Face& aF1=*(TopoDS_Face*)(&S1);
 641   const TopoDS_Face& aF2=*(TopoDS_Face*)(&S2);
 642   //
 643   Standard_Boolean aToApproxC3d, aToApproxC2dOnS1, aToApproxC2dOnS2, anIsDone;
 644   Standard_Integer i, aNbCurves;
 645   Standard_Real anAppTol, aTolR;
 646   TCollection_AsciiString aNm("c_");
 647   //
 648   anAppTol = 0.0000001;
 649   aToApproxC3d = Standard_True;
 650   aToApproxC2dOnS1 = Standard_False;
 651   aToApproxC2dOnS2 = Standard_False;
 652   //
 653   if (n > 3) {
 654     if (!strcasecmp(a[3],"-2d")) {
 655       aToApproxC2dOnS1 = Standard_True;
 656       aToApproxC2dOnS2 = Standard_True;
 657     }
 658     else if (!strcasecmp(a[3],"-2d1")) {
 659       aToApproxC2dOnS1 = Standard_True;
 660     }
 661     else if (!strcasecmp(a[3],"-2d2")) {
 662       aToApproxC2dOnS2 = Standard_True;
 663     }
 664     else {
 665       di << "Wrong key. To build 2d curves use: bopcurves F1 F2 -2d/-2d1/-2d2 \n";
 666       return 1;
 667     }
 668   }
 669   //
 670   IntTools_FaceFace aFF;
 671   //
 672   aFF.SetParameters (aToApproxC3d,
 673                      aToApproxC2dOnS1,
 674                      aToApproxC2dOnS2,
 675                      anAppTol);
 676   //
 677   aFF.Perform (aF1, aF2);
 678   //
 679   anIsDone=aFF.IsDone();
 680   if (!anIsDone) {
 681     di << "Error: anIsDone=" << (Standard_Integer) anIsDone << "\n";
 682     return 0;
 683   }
 684   //
 685   aFF.PrepareLines3D(Standard_False);
 686   const IntTools_SequenceOfCurves& aSCs=aFF.Lines();
 687
 688   //
 689   aTolR=aFF.TolReached3d();
 690   di << "Tolerance Reached=" << aTolR << "\n";
 691
 692   aNbCurves=aSCs.Length();
 693   if (!aNbCurves) {
 694     di << " has no 3d curve\n";
 695     return 0;
 696   }
 697   else
 698   {
 699     di << aNbCurves << " curve(s) found.\n";
 700   }
 701
 702   for (i=1; i<=aNbCurves; i++) {
 703     const IntTools_Curve& anIC=aSCs(i);
 704
 705     Handle (Geom_Curve)  aC3D = anIC.Curve();
 706
 707     if (aC3D.IsNull()) {
 708       di << " has Null 3d curve# " << i << "\n";
 709       continue;
 710     }
 711
 712     TCollection_AsciiString anIndx(i), aNmx;
 713     aNmx = aNm + anIndx;
 714
 715     Standard_CString nameC = aNmx.ToCString();
 716
 717     DrawTrSurf::Set(nameC, aC3D);
 718     di << nameC << " ";
 719     //
 720     Handle(Geom2d_Curve) aPC1 = anIC.FirstCurve2d();
 721     Handle(Geom2d_Curve) aPC2 = anIC.SecondCurve2d();
 722     //
 723     if (!aPC1.IsNull() || !aPC2.IsNull()) {
 724       di << "(";
 725       //
 726       if (!aPC1.IsNull()) {
 727         TCollection_AsciiString pc1N("c2d1_"), pc1Nx;
 728         pc1Nx = pc1N + anIndx;
 729         Standard_CString nameC2d1 = pc1Nx.ToCString();
 730         //
 731         DrawTrSurf::Set(nameC2d1, aPC1);
 732         di << nameC2d1;
 733       }
 734       //
 735       if (!aPC2.IsNull()) {
 736         TCollection_AsciiString pc2N("c2d2_"), pc2Nx;
 737         pc2Nx = pc2N + anIndx;
 738         Standard_CString nameC2d2 = pc2Nx.ToCString();
 739         //
 740         DrawTrSurf::Set(nameC2d2, aPC2);
 741         //
 742         if (!aPC1.IsNull()) {
 743           di << ", ";
 744         }
 745         di << nameC2d2;
 746       }
 747       di << ") ";
 748     }
 749   }
 750   //
 751   di << "\n";
 752   return 0;
 753 }
 754 //=======================================================================
 755 //function : mkvolume
 756 //purpose  :
 757 //=======================================================================
 758 Standard_Integer mkvolume(Draw_Interpretor& di, Standard_Integer n, const char** a)
 759 {
 760   if (n < 3) {
 761     di << "Usage: mkvolume r b1 b2 ... [-c] [-ni]\n";
 762     di << "Options:\n";
 763     di << " -c  - use this option if the arguments are compounds\n";
 764     di << "       containing shapes that should be interfered;\n";
 765     di << " -ni - use this option if the arguments should not be interfered;\n";
 766     return 1;
 767   }
 768   //
 769   const char* usage = "Type mkvolume without arguments for the usage of the command.\n";
 770   //
 771   Standard_Boolean bToIntersect, bRunParallel, bCompounds;
 772   Standard_Integer i;
 773   Standard_Real aTol;
 774   TopoDS_Shape aS;
 775   BOPCol_ListOfShape aLS;
 776   //
 777   aTol = BOPTest_Objects::FuzzyValue();
 778   bRunParallel = BOPTest_Objects::RunParallel();
 779   //
 780   bToIntersect = Standard_True;
 781   bCompounds = Standard_False;
 782   //
 783   for (i = 2; i < n; ++i) {
 784     aS = DBRep::Get(a[i]);
 785     if (!aS.IsNull()) {
 786       aLS.Append(aS);
 787     }
 788     else {
 789       if (!strcmp(a[i], "-c")) {
 790         bCompounds = Standard_True;
 791       }
 792       else if (!strcmp(a[i], "-ni")) {
 793         bToIntersect = Standard_False;
 794       }
 795     }
 796   }
 797   //
 798   if (aLS.IsEmpty()) {
 799     di << "No shapes to process.\n";
 800     di << usage;
 801     return 1;
 802   }
 803   //
 804   // treat list of arguments for the case of compounds
 805   if (bToIntersect && bCompounds) {
 806     BOPCol_ListOfShape aLSx;
 807     BOPCol_ListIteratorOfListOfShape aItLS;
 808     //
 809     aItLS.Initialize(aLS);
 810     for (; aItLS.More(); aItLS.Next()) {
 811       const TopoDS_Shape& aSx = aItLS.Value();
 812       TopoDS_Iterator aItS(aSx);
 813       for (; aItS.More(); aItS.Next()) {
 814         const TopoDS_Shape& aSxS = aItS.Value();
 815         aLSx.Append(aSxS);
 816       }
 817     }
 818     //
 819     aLS.Clear();
 820     aLS.Assign(aLSx);
 821   }
 822   //
 823   BOPAlgo_MakerVolume aMV;
 824   aMV.SetArguments(aLS);
 825   aMV.SetIntersect(bToIntersect);
 826   aMV.SetRunParallel(bRunParallel);
 827   aMV.SetFuzzyValue(aTol);
 828   //
 829   aMV.Perform();
 830   if (aMV.ErrorStatus()) {
 831     di << "Error status: " << aMV.ErrorStatus();
 832     return 1;
 833   }
 834   //
 835   const TopoDS_Shape& aR = aMV.Shape();
 836   //
 837   DBRep::Set(a[1], aR);
 838   //
 839   return 0;
 840 }