src/BOPTest/BOPTest_BOPCommands.cxx

   1 // File:        BOPTest_BOPCommands.cxx
   2 // Created:     10:45:01 2000
   3 // Author:      Peter KURNEV
   4 //              <pkv@irinox>
   5
   6
   7 #include <BOPTest.ixx>
   8
   9 #include <stdio.h>
  10
  11 #include <DBRep.hxx>
  12 #include <DBRep_DrawableShape.hxx>
  13
  14 #include <Draw.hxx>
  15 #include <Draw_Color.hxx>
  16
  17 #include <TCollection_AsciiString.hxx>
  18
  19 #include <TopAbs_ShapeEnum.hxx>
  20 #include <TopoDS.hxx>
  21 #include <TopoDS_Shape.hxx>
  22 #include <TopoDS_Shell.hxx>
  23
  24 #include <TopExp.hxx>
  25 #include <TopTools_IndexedMapOfShape.hxx>
  26
  27 #include <BRep_Builder.hxx>
  28
  29 #include <BooleanOperations_ShapesDataStructure.hxx>
  30 #include <BooleanOperations_StateOfShape.hxx>
  31
  32 #include <BOPTools_SolidStateFiller.hxx>
  33 #include <BOPTools_DSFiller.hxx>
  34 #include <BOPTools_SplitShapesPool.hxx>
  35 #include <BOPTools_ListOfPaveBlock.hxx>
  36 #include <BOPTools_ListIteratorOfListOfPaveBlock.hxx>
  37 #include <BOPTools_PaveBlock.hxx>
  38 #include <BOPTools_PCurveMaker.hxx>
  39 #include <BOPTools_InterferencePool.hxx>
  40 #include <BOPTools_CArray1OfVVInterference.hxx>
  41 #include <BOPTools_CArray1OfVSInterference.hxx>
  42 #include <BOPTools_CArray1OfVEInterference.hxx>
  43 #include <BOPTools_CArray1OfESInterference.hxx>
  44 #include <BOPTools_CArray1OfEEInterference.hxx>
  45 #include <BOPTools_CArray1OfSSInterference.hxx>
  46 #include <BOPTools_VVInterference.hxx>
  47 #include <BOPTools_VEInterference.hxx>
  48 #include <BOPTools_VSInterference.hxx>
  49 #include <BOPTools_EEInterference.hxx>
  50 #include <BOPTools_ESInterference.hxx>
  51 #include <BOPTools_SSInterference.hxx>
  52
  53 #include <BOPTest_DrawableShape.hxx>
  54
  55 #include <BRepAlgoAPI_BooleanOperation.hxx>
  56 #include <BRepAlgoAPI_Section.hxx>
  57 #include <BRepAlgoAPI_Common.hxx>
  58 #include <BRepAlgoAPI_Fuse.hxx>
  59 #include <BRepAlgoAPI_Cut.hxx>
  60
  61 #include <TColStd_IndexedMapOfInteger.hxx>
  62
  63
  64
  65 //XX
  66 // CHRONOMETER
  67 //
  68 #include <Standard_Static.hxx>
  69 #include <OSD_Chronometer.hxx>
  70
  71
  72 Standard_STATIC(OSD_Chronometer, S_Chrono);
  73 static void StartChrono();
  74 static void StopChrono(Draw_Interpretor&);
  75 Standard_Integer btimesum (Draw_Interpretor& , Standard_Integer n, const char** a);
  76 //XX
  77
  78 //
  79 static   Standard_Integer bop        (Draw_Interpretor&,   Standard_Integer,   const char**);
  80 //
  81 static   Standard_Integer bcommon    (Draw_Interpretor& ,  Standard_Integer ,  const char**);
  82 static   Standard_Integer bfuse      (Draw_Interpretor& ,  Standard_Integer ,  const char**);
  83 static   Standard_Integer bcut       (Draw_Interpretor& ,  Standard_Integer ,  const char**);
  84 static   Standard_Integer bsection   (Draw_Interpretor& ,  Standard_Integer ,  const char**);
  85
  86 static   Standard_Integer bFillDS    (Draw_Interpretor& ,  Standard_Integer  , const char**);
  87 //
  88 static   Standard_Integer bopcommon  (Draw_Interpretor& ,  Standard_Integer ,  const char**);
  89 static   Standard_Integer bopfuse    (Draw_Interpretor& ,  Standard_Integer ,  const char**);
  90 static   Standard_Integer bopcut     (Draw_Interpretor& ,  Standard_Integer ,  const char**);
  91 static   Standard_Integer boptuc     (Draw_Interpretor& ,  Standard_Integer ,  const char**);
  92 static   Standard_Integer bopsection (Draw_Interpretor& ,  Standard_Integer ,  const char**);
  93
  94 static   Standard_Integer boperationFiller (Standard_Integer n, const char** a, const BOP_Operation anOp,
  95                                             Draw_Interpretor&);
  96 //
  97 static   Standard_Integer bopstates  (Draw_Interpretor& ,  Standard_Integer ,  const char**);
  98 //
  99 static  Standard_Integer bopwho      (Draw_Interpretor& ,  Standard_Integer ,  const char**);
 100 static  Standard_Integer bopsticks   (Draw_Interpretor& ,  Standard_Integer ,  const char**);
 101
 102
 103 static
 104   void UnUsedMap(BOPTools_SequenceOfCurves& ,
 105                  const BOPTools_PaveSet& ,
 106                  TColStd_IndexedMapOfInteger& );
 107 //=======================================================================
 108 //function : BOPCommands
 109 //purpose  :
 110 //=======================================================================
 111   void  BOPTest::BOPCommands(Draw_Interpretor& theCommands)
 112 {
 113   static Standard_Boolean done = Standard_False;
 114   if (done)
 115     return;
 116
 117   done = Standard_True;
 118   // Chapter's name
 119   const char* g = "CCR commands";
 120   //
 121   // Using DSFiller that is ready.
 122   theCommands.Add("bop"       , "Use  >bop Shape1 Shape2", __FILE__,   bop, g);
 123   theCommands.Add("bopcommon" , "Use  >bopcommon R" , __FILE__, bopcommon , g);
 124   theCommands.Add("bopfuse"   , "Use  >bopfuse R"   , __FILE__, bopfuse   , g);
 125   theCommands.Add("bopcut"    , "Use  >bopcut R"    , __FILE__, bopcut    , g);
 126   theCommands.Add("boptuc"    , "Use  >boptuc R"    , __FILE__, boptuc    , g);
 127   theCommands.Add("bopsection", "Use  >bopsection R", __FILE__, bopsection, g);
 128   //
 129   // States
 130   theCommands.Add("bopstates",  "Use  bopstates [-f] [-t] [-out]", __FILE__, bopstates, g);
 131   //
 132   theCommands.Add("bcommon" , "Use >bcommon R a b"    , __FILE__, bcommon , g);
 133   theCommands.Add("bfuse"   , "Use >bfuse  R a b"     , __FILE__, bfuse   , g);
 134   theCommands.Add("bcut"    , "Use >bcut R a b"       , __FILE__, bcut    , g);
 135   //
 136   //  bsection
 137   theCommands.Add("bsection", "Use >bsection Result s1 s2 [-2d/-2d1/-2d2] [-a]"
 138                   , __FILE__, bsection, g);
 139   //
 140   theCommands.Add("btimesum"   , "Use >btimesum FileName"   , __FILE__, btimesum,  g);
 141   theCommands.Add("bopwho"     , "Use >bopwho Index"        , __FILE__, bopwho,    g);
 142   theCommands.Add("bopsticks"  , "Use >bopsticks"           , __FILE__, bopsticks, g);
 143   //
 144 }
 145 //
 146 //////////////////////////////////
 147 //
 148 // The one and only global variable
 149 //
 150 BOPTools_DSFiller *pDF;
 151 //
 152 //////////////////////////////////
 153 //
 154 //=======================================================================
 155 //function : bop
 156 //purpose  :
 157 //=======================================================================
 158 Standard_Integer bop (Draw_Interpretor& di,
 159                       Standard_Integer n,
 160                       const char** a)
 161 {
 162   StartChrono();
 163
 164   if (n<3) {
 165     di << " Use >bop Shape1 Shape2\n";
 166     StopChrono(di);
 167     return 1;
 168   }
 169
 170   TopoDS_Shape S1 = DBRep::Get(a[1]);
 171   TopoDS_Shape S2 = DBRep::Get(a[2]);
 172
 173   if (S1.IsNull() || S2.IsNull()) {
 174     di << " Null shapes are not allowed \n";
 175     StopChrono(di);
 176     return 1;
 177   }
 178   if (pDF!=NULL) {
 179     delete pDF;
 180     pDF=NULL;
 181   }
 182
 183   pDF=new BOPTools_DSFiller;
 184
 185   pDF->SetShapes (S1, S2);
 186   if (!pDF->IsDone()) {
 187     di << "Check types of the arguments, please\n";
 188     if (pDF!=NULL) {
 189       delete pDF;
 190       pDF=NULL;
 191     }
 192     StopChrono(di);
 193     return 1;
 194   }
 195
 196   pDF->Perform();
 197   //printf(" BOPTools_DSFiller is Ready to use\n");
 198
 199   StopChrono(di);
 200
 201   return 0;
 202 }
 203
 204 //=======================================================================
 205 //function : bFillDS
 206 //purpose  :
 207 //=======================================================================
 208 Standard_Integer bFillDS (Draw_Interpretor& di,
 209                           Standard_Integer n,
 210                           const char** a)
 211 {
 212   if (n!=4) {
 213     di << " Usage: >command  Result Shape1 Shape2\n";
 214     return 1;
 215   }
 216
 217   return bop(di, n, a+1);
 218 }
 219
 220 //=======================================================================
 221 //function : bcommon
 222 //purpose  :
 223 //=======================================================================
 224 Standard_Integer bcommon (Draw_Interpretor& di,
 225                           Standard_Integer n,
 226                           const char** a)
 227 {
 228   Standard_Integer iFlag;
 229
 230   iFlag =bFillDS (di, n, a);
 231
 232   if (iFlag) {
 233     return iFlag;
 234   }
 235
 236   return bopcommon(di, n, a);
 237 }
 238 //=======================================================================
 239 //function : bfuse
 240 //purpose  :
 241 //=======================================================================
 242 Standard_Integer  bfuse(Draw_Interpretor& di,
 243                         Standard_Integer n,
 244                         const char** a)
 245 {
 246   Standard_Integer iFlag;
 247
 248   iFlag =bFillDS (di, n, a);
 249
 250   if (iFlag) {
 251     return iFlag;
 252   }
 253
 254   return bopfuse(di, n, a);
 255 }
 256
 257 //=======================================================================
 258 //function : bcut
 259 //purpose  :
 260 //=======================================================================
 261 Standard_Integer  bcut(Draw_Interpretor& di,
 262                        Standard_Integer n,
 263                        const char** a)
 264 {
 265   Standard_Integer iFlag;
 266
 267   iFlag =bFillDS (di, n, a);
 268
 269   if (iFlag) {
 270     return iFlag;
 271   }
 272
 273   return bopcut(di, n, a);
 274 }
 275 //=======================================================================
 276 //function : bsection
 277 //purpose  :
 278 //=======================================================================
 279 Standard_Integer  bsection(Draw_Interpretor& di,
 280                            Standard_Integer n,
 281                            const char** a)
 282 {
 283   const char* usage = " Usage: bsection Result s1 s2 [-2d/-2d1/-2d2] [-a]\n";
 284   if (n < 4) {
 285     di << usage;
 286     return 1;
 287   }
 288
 289   TopoDS_Shape S1 = DBRep::Get(a[2]);
 290   TopoDS_Shape S2 = DBRep::Get(a[3]);
 291
 292   if (S1.IsNull() || S2.IsNull()) {
 293     di << " Null shapes are not allowed \n";
 294     return 1;
 295   }
 296
 297
 298   BRepAlgoAPI_Section aSec(S1, S2, Standard_False);
 299   aSec.Approximation(Standard_False);
 300   aSec.ComputePCurveOn1(Standard_False);
 301   aSec.ComputePCurveOn2(Standard_False);
 302   Standard_Boolean isbadparameter = Standard_False;
 303
 304   if(n > 4) {
 305     const char* key1 = a[4];
 306     const char* key2 = (n > 5) ? a[5] : NULL;
 307     const char* pcurveconf = NULL;
 308     Standard_Boolean approx = Standard_False;
 309
 310 #ifdef WNT
 311     if (key1 && !strcasecmp(key1,"-2d")) {
 312 #else
 313     if (key1 && !strncasecmp(key1,"-2d", 3)) {
 314 #endif
 315       pcurveconf = key1;
 316     }
 317     else {
 318       if (!strcasecmp(key1,"-a")) {
 319         approx = Standard_True;
 320       }
 321       else {
 322         isbadparameter = Standard_True;
 323       }
 324     }
 325 #ifdef WNT
 326     if (key2 && !strcasecmp(key2,"-2d")) {
 327 #else
 328     if (key2 && !strncasecmp(key2,"-2d", 3)) {
 329 #endif
 330       if(pcurveconf) {
 331         isbadparameter = Standard_True;
 332       }
 333       else {
 334         pcurveconf = key2;
 335       }
 336     }
 337     else {
 338       if(key2) {
 339         if (!strcasecmp(key2,"-a")) {
 340           approx = Standard_True;
 341         }
 342         else {
 343           isbadparameter = Standard_True;
 344         }
 345       }
 346     }
 347
 348     if(!isbadparameter && pcurveconf) {
 349
 350       if (strcasecmp(pcurveconf, "-2d") == 0) {
 351         aSec.ComputePCurveOn1(Standard_True);
 352         aSec.ComputePCurveOn2(Standard_True);
 353       }
 354       else {
 355         if (strcasecmp(pcurveconf, "-2d1") == 0) {
 356           aSec.ComputePCurveOn1(Standard_True);
 357         }
 358         else {
 359           if (strcasecmp(pcurveconf, "-2d2") == 0) {
 360             aSec.ComputePCurveOn2(Standard_True);
 361           }
 362         }
 363       }
 364     }
 365     aSec.Approximation(approx);
 366   }
 367
 368   if(!isbadparameter) {
 369     aSec.Build();
 370     Standard_Boolean anIsDone = aSec.IsDone();
 371
 372     if (anIsDone) {
 373       const TopoDS_Shape& aR = aSec.Shape();
 374       DBRep::Set (a[1], aR);
 375     }
 376     else {
 377       di << "not done ErrorStatus()="<< aSec.ErrorStatus() <<"\n";
 378     }
 379   }
 380   else {
 381     di << usage;
 382     return 1;
 383   }
 384   return 0;
 385 }
 386
 387 //=======================================================================
 388 //function : bopcommon
 389 //purpose  :
 390 //=======================================================================
 391 Standard_Integer bopcommon (Draw_Interpretor& di,
 392                             Standard_Integer n,
 393                             const char** a)
 394 {
 395   return boperationFiller (n, a, BOP_COMMON, di);
 396 }
 397
 398 //=======================================================================
 399 //function : bopfuse
 400 //purpose  :
 401 //=======================================================================
 402 Standard_Integer  bopfuse(Draw_Interpretor& di,
 403                             Standard_Integer n,
 404                             const char** a)
 405 {
 406   return boperationFiller (n, a, BOP_FUSE, di);
 407 }
 408
 409 //=======================================================================
 410 //function : bopcut
 411 //purpose  :
 412 //=======================================================================
 413 Standard_Integer bopcut (Draw_Interpretor& di,
 414                          Standard_Integer n,
 415                          const char** a)
 416 {
 417   return boperationFiller (n, a, BOP_CUT, di);
 418 }
 419 //=======================================================================
 420 //function : boptuc
 421 //purpose  :
 422 //=======================================================================
 423 Standard_Integer boptuc (Draw_Interpretor& di,
 424                          Standard_Integer n,
 425                          const char** a)
 426 {
 427   return boperationFiller (n, a, BOP_CUT21, di);
 428 }
 429 //=======================================================================
 430 //function : bopsection
 431 //purpose  :
 432 //=======================================================================
 433 Standard_Integer bopsection (Draw_Interpretor& di,
 434                              Standard_Integer n,
 435                              const char** a)
 436 {
 437   return boperationFiller (n, a, BOP_SECTION, di);
 438 }
 439
 440 //=======================================================================
 441 //function : boperationFiller
 442 //purpose  :
 443 //=======================================================================
 444 Standard_Integer boperationFiller (Standard_Integer n,
 445                                    const char** a,
 446                                    const BOP_Operation anOp,
 447                                    Draw_Interpretor& di)
 448 {
 449   //XX
 450   StartChrono();
 451   //XX
 452
 453   if (n<2) {
 454     di << " Use oper> Result [-mf]\n";
 455     StopChrono(di);
 456     return 1;
 457   }
 458
 459   if (pDF==NULL) {
 460     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
 461     StopChrono(di);
 462     return 1;
 463   }
 464
 465   const TopoDS_Shape& S1 = pDF->Shape1();
 466   const TopoDS_Shape& S2 = pDF->Shape2();
 467
 468   if (S1.IsNull() || S2.IsNull()) {
 469     di << " Null shapes are not allowed \n";
 470     StopChrono(di);
 471     return 1;
 472   }
 473
 474   Standard_Boolean aMFlag, anIsDone;
 475
 476   aMFlag=Standard_False;
 477   //
 478   BRepAlgoAPI_BooleanOperation* pBuilder=NULL;
 479   //
 480   // SECTION
 481   if (anOp==BOP_SECTION) {
 482     pBuilder=new BRepAlgoAPI_Section(S1, S2, *pDF);
 483   }
 484   else if (anOp==BOP_COMMON) {
 485     pBuilder=new BRepAlgoAPI_Common(S1, S2, *pDF);
 486   }
 487   else if (anOp==BOP_FUSE) {
 488     pBuilder=new BRepAlgoAPI_Fuse(S1, S2, *pDF);
 489   }
 490   else if (anOp==BOP_CUT) {
 491     pBuilder=new BRepAlgoAPI_Cut (S1, S2, *pDF);
 492   }
 493   else if (anOp==BOP_CUT21) {
 494     pBuilder=new BRepAlgoAPI_Cut(S1, S2, *pDF, Standard_False);
 495   }
 496   //
 497   anIsDone=pBuilder->IsDone();
 498   if (anIsDone) {
 499     const TopoDS_Shape& aR=pBuilder->Shape();
 500     DBRep::Set (a[1], aR);
 501   }
 502   else {
 503     di << "not done ErrorStatus()=" << pBuilder->ErrorStatus() << "\n";
 504   }
 505
 506   delete pBuilder;
 507
 508   StopChrono(di);
 509
 510   return 0;
 511 }
 512
 513 //=======================================================================
 514 // OTHER FUNCTIONS
 515 //
 516 static
 517   void GetName (const BooleanOperations_StateOfShape aState,
 518                 TCollection_AsciiString& aNm);
 519 static
 520   TopAbs_ShapeEnum ChooseShapeType(const char* a1);
 521
 522 static
 523   BooleanOperations_StateOfShape ChooseShapeState(const char* a3);
 524
 525 //=======================================================================
 526 //function : bopstates
 527 //purpose  :
 528 //=======================================================================
 529 Standard_Integer  bopstates(Draw_Interpretor& di,
 530                              Standard_Integer n,
 531                              const char** a)
 532 {
 533   if (n>4) {
 534     di << " Use bopstates [-f] [-t] [-out]\n";
 535     return 1;
 536   }
 537
 538   if (pDF==NULL) {
 539     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
 540     return 0;
 541   }
 542
 543   Standard_Integer i, aNbLines, aIsSmtToDraw=0;
 544   BooleanOperations_StateOfShape aState, aChooseState;
 545   aChooseState=BooleanOperations_UNKNOWN;
 546   TopAbs_ShapeEnum aEnumToDisplay = TopAbs_COMPOUND;
 547   Draw_Color aTextColor(Draw_cyan);
 548   //
 549   const BooleanOperations_ShapesDataStructure& aDS=pDF->DS();
 550   //
 551   // Choose Object or Tool or All
 552   i=1;
 553   aNbLines=aDS.NumberOfSourceShapes();
 554   if (n>=3) {
 555     if (!strcmp (a[2], "-o")) {
 556       aDS.ObjectRange(i, aNbLines);
 557     }
 558     if (!strcmp (a[2], "-t")) {
 559       aDS.ToolRange(i, aNbLines);
 560     }
 561   }
 562   //
 563   // ChooseShapeState
 564   if (n==4) {
 565     aChooseState=ChooseShapeState(a[3]);
 566   }
 567   //
 568   // ChooseShapeType
 569   if (n==1) {
 570     aEnumToDisplay=TopAbs_EDGE;
 571   }
 572   else if (n>1) {
 573     aEnumToDisplay=ChooseShapeType(a[1]);
 574   }
 575   //
 576   // Presentation
 577   for (; i<=aNbLines; ++i) {
 578     const TopoDS_Shape& aS=aDS.GetShape(i);
 579     TopAbs_ShapeEnum aCurrentType=aS.ShapeType();
 580     if (aCurrentType==aEnumToDisplay) {
 581       aState=aDS.GetState(i);
 582       TCollection_AsciiString aNm, aInd(i);
 583       GetName(aState, aNm);
 584
 585       if (aState==BooleanOperations_INTERSECTED && aCurrentType==TopAbs_EDGE) {
 586
 587         const BOPTools_SplitShapesPool& aSpPool=pDF->SplitShapesPool();
 588         const BOPTools_ListOfPaveBlock& aSplitsList=aSpPool(aDS.RefEdge(i));
 589         BOPTools_ListIteratorOfListOfPaveBlock anIt(aSplitsList);
 590         for (; anIt.More();anIt.Next()) {
 591           const BOPTools_PaveBlock& aPB=anIt.Value();
 592           Standard_Integer nSplit=aPB.Edge();
 593           const TopoDS_Shape& aSplit=aDS.GetShape(nSplit);
 594           aState=aDS.GetState(nSplit);
 595           GetName(aState, aNm);
 596           aNm=aNm+aInd;
 597           TCollection_AsciiString aNmx, anUnd("_"), aIndx(nSplit);
 598           aNmx=aNm+anUnd;
 599           aNmx=aNmx+aIndx;
 600
 601           Standard_CString aTxt=aNmx.ToCString();
 602
 603           if (aChooseState!=BooleanOperations_UNKNOWN) {
 604             if (aState!=aChooseState) {
 605               continue;
 606             }
 607           }
 608           aIsSmtToDraw++;
 609           //printf("%s ",  aTxt);
 610           di << aTxt << " ";
 611           Handle(BOPTest_DrawableShape) aDSh=
 612             new BOPTest_DrawableShape (aSplit, aTxt, aTextColor);
 613           Draw::Set (aTxt, aDSh);
 614         }
 615           continue;
 616       }
 617
 618       aNm=aNm+aInd;
 619       Standard_CString aText=aNm.ToCString();
 620
 621       if (aChooseState!=BooleanOperations_UNKNOWN) {
 622         if (aState!=aChooseState) {
 623           continue;
 624         }
 625       }
 626       aIsSmtToDraw++;
 627       //printf("%s ",  aText);
 628       di << aText << " ";
 629       Handle(BOPTest_DrawableShape) aDShape=
 630         new BOPTest_DrawableShape (aS, aText, aTextColor);
 631       Draw::Set (aText, aDShape);
 632     }
 633   }
 634
 635   if (!aIsSmtToDraw) {
 636     di << " No specified shapes\n";
 637   }
 638   else {
 639     di << "\n";
 640   }
 641
 642
 643   return 0;
 644 }
 645
 646 //=======================================================================
 647 //function : GetName
 648 //purpose  :
 649 //=======================================================================
 650 void GetName (const BooleanOperations_StateOfShape aState,
 651               TCollection_AsciiString& aNm)
 652 {
 653   TCollection_AsciiString aNmOut("ou_"), aNmIn("in_"),
 654        aNmOn("on_"), aNmUn("un_"), aNmInter("intr_");
 655
 656   switch (aState) {
 657     case BooleanOperations_OUT:
 658       aNm=aNmOut;
 659       break;
 660     case  BooleanOperations_IN:
 661       aNm=aNmIn;
 662       break;
 663     case BooleanOperations_ON:
 664       aNm=aNmOn;
 665       break;
 666     case BooleanOperations_INTERSECTED:
 667       aNm=aNmInter;
 668       break;
 669     default:
 670       aNm=aNmUn;
 671       break;
 672   }
 673 }
 674
 675 //=======================================================================
 676 //function : ChooseShapeType
 677 //purpose  :
 678 //=======================================================================
 679 TopAbs_ShapeEnum ChooseShapeType(const char* a1)
 680 {
 681   TopAbs_ShapeEnum aEnumToDisplay;
 682
 683   if (!strcmp (a1, "-c")) {
 684     aEnumToDisplay=TopAbs_COMPOUND;
 685   }
 686   else if (!strcmp (a1, "-cs")) {
 687     aEnumToDisplay=TopAbs_COMPSOLID;
 688   }
 689   else if (!strcmp (a1, "-s")) {
 690     aEnumToDisplay=TopAbs_SOLID;
 691   }
 692   else if (!strcmp (a1, "-sh")) {
 693     aEnumToDisplay=TopAbs_SHELL;
 694   }
 695   else if (!strcmp (a1, "-f")) {
 696     aEnumToDisplay=TopAbs_FACE;
 697   }
 698   else if (!strcmp (a1, "-w")) {
 699     aEnumToDisplay=TopAbs_WIRE;
 700   }
 701   else if (!strcmp (a1, "-e")) {
 702     aEnumToDisplay=TopAbs_EDGE;
 703   }
 704   else if (!strcmp (a1, "-v")) {
 705     aEnumToDisplay=TopAbs_VERTEX;
 706   }
 707   else {
 708     aEnumToDisplay=TopAbs_EDGE;
 709   }
 710   return aEnumToDisplay;
 711 }
 712
 713 //=======================================================================
 714 //function : ChooseShapeState
 715 //purpose  :
 716 //=======================================================================
 717 BooleanOperations_StateOfShape ChooseShapeState(const char* a3)
 718 {
 719   BooleanOperations_StateOfShape aChooseState=BooleanOperations_UNKNOWN;
 720
 721   if (!strcmp (a3, "-out")) {
 722     aChooseState=BooleanOperations_OUT;
 723   }
 724   if (!strcmp (a3, "-in")) {
 725     aChooseState=BooleanOperations_IN;
 726   }
 727   if (!strcmp (a3, "-on")) {
 728     aChooseState=BooleanOperations_ON;
 729   }
 730   return aChooseState;
 731 }
 732 //XX
 733 // CHRONOMETER
 734 //
 735 #include <OSD_Chronometer.hxx>
 736 #include <TCollection_AsciiString.hxx>
 737 #include <OSD_OpenMode.hxx>
 738 #include <OSD_Path.hxx>
 739 #include <OSD_Protection.hxx>
 740 #include <OSD_File.hxx>
 741
 742 static void SaveTimeInFile(const Standard_CString aFileName,
 743                            const Standard_Real aChrono,
 744                            Draw_Interpretor& di);
 745
 746 //=======================================================================
 747 //function : StartChrono
 748 //purpose  :
 749 //=======================================================================
 750 void StartChrono()
 751 {
 752   char *xr=getenv ("BOPCHRONO");
 753   if (xr!=NULL){
 754     if (!strcmp (xr, "yes")){
 755       S_Chrono().Reset();
 756       S_Chrono().Start();
 757     }
 758   }
 759 }
 760
 761 //=======================================================================
 762 //function : StopChrono
 763 //purpose  :
 764 //=======================================================================
 765 void StopChrono(Draw_Interpretor& di)
 766 {
 767   char *xr=getenv ("BOPCHRONO");
 768   if (xr!=NULL){
 769     if (!strcmp (xr, "yes")) {
 770       Standard_Real Chrono;
 771       S_Chrono().Stop();
 772       S_Chrono().Show(Chrono);
 773       //
 774       char *aFileName=getenv("BOPCHRONOFILE");
 775       if (aFileName!=NULL){
 776         SaveTimeInFile(aFileName, Chrono, di);
 777       }
 778       else {
 779         di << "Tps: " << Chrono << "\n";
 780       }
 781       //
 782     }
 783   }
 784 }
 785 //=======================================================================
 786 //function : SaveTimeInFile
 787 //purpose  :
 788 //=======================================================================
 789 void SaveTimeInFile(const Standard_CString aFileName,
 790                     const Standard_Real aChrono,
 791                     Draw_Interpretor& di)
 792 {
 793   OSD_OpenMode aMode =  OSD_ReadWrite;
 794   OSD_Protection  aProtect(OSD_RW,OSD_RW,OSD_RW,OSD_RW);
 795   TCollection_AsciiString anASName(aFileName);
 796   OSD_Path aPath (anASName);
 797   OSD_File aFile (aPath);
 798   aFile.Append(aMode, aProtect);
 799   if (!( aFile.Exists() && aFile.IsOpen())) {
 800     Standard_CString aStr=anASName.ToCString();
 801     di << "Can not open the file: " << aStr << "\n";
 802     return;
 803   }
 804   TCollection_AsciiString aASTime(aChrono), aASendl("\n");
 805   aASTime=aASTime+aASendl;
 806   aFile.Write (aASTime, aASTime.Length());
 807   aFile.Close();
 808 }
 809 //XX
 810 //=======================================================================
 811 //function : btimesum
 812 //purpose  :
 813 //=======================================================================
 814 Standard_Integer btimesum (Draw_Interpretor& di,
 815                            Standard_Integer n,
 816                            const char** a)
 817 {
 818   if (n!=2) {
 819     di << " Use >btimesum FileName\n";
 820     return 1;
 821   }
 822
 823   TCollection_AsciiString anASName(a[1]);
 824   OSD_OpenMode aMode =  OSD_ReadWrite;
 825   OSD_Protection  aProtect(OSD_RW,OSD_RW,OSD_RW,OSD_RW);
 826   OSD_Path aPath (anASName);
 827   OSD_File aFile (aPath);
 828   aFile.Open(aMode, aProtect);
 829
 830   if (!( aFile.Exists() && aFile.IsOpen())) {
 831     Standard_CString aStr=anASName.ToCString();
 832     di << "Can not open the file: " << aStr << "\n";
 833     return 1;
 834   }
 835
 836   Standard_Integer aNbyteRead, aNByte=256, pos;
 837   Standard_Real aTC, aTime=0.;
 838   while (1) {
 839     if (aFile.IsAtEnd()) {
 840       break;
 841     }
 842
 843     TCollection_AsciiString aStr(aNByte);
 844     aFile.ReadLine(aStr, aNByte, aNbyteRead);
 845     //Standard_CString pStr=aStr.ToCString();
 846
 847     pos=aStr.Search("\n");
 848     if (pos>0){
 849       aStr.Trunc(pos-1);
 850     }
 851
 852     if (aStr.IsRealValue()) {
 853       aTC=aStr.RealValue();
 854       aTime=aTime+aTC;
 855     }
 856   }
 857   aFile.Close();
 858   //
 859   aFile.Append(aMode, aProtect);
 860
 861   TCollection_AsciiString aASLine("----------\n"), aASTime(aTime), aASendl("\n");
 862   aASTime=aASTime+aASendl;
 863   aFile.Write (aASLine, aASLine.Length());
 864   aFile.Write (aASTime, aASTime.Length());
 865   aFile.Close();
 866
 867   return 0;
 868 }
 869
 870
 871 //=======================================================================
 872 //
 873 //                         ex. BOPTest_TSTCommands
 874 //
 875 #include <stdio.h>
 876
 877 #include <BOPTest_DrawableShape.hxx>
 878
 879 #include <DBRep.hxx>
 880 #include <DBRep_DrawableShape.hxx>
 881
 882 #include <Draw.hxx>
 883 #include <Draw_Color.hxx>
 884
 885 #include <TCollection_AsciiString.hxx>
 886
 887 #include <TColStd_ListOfInteger.hxx>
 888 #include <TColStd_ListIteratorOfListOfInteger.hxx>
 889
 890
 891 #include <BooleanOperations_ShapesDataStructure.hxx>
 892 #include <BOPTools_CArray1OfInterferenceLine.hxx>
 893 #include <BOPTools_InterferenceLine.hxx>
 894 #include <BOPTools_ListOfInterference.hxx>
 895 #include <BOPTools_ListIteratorOfListOfInterference.hxx>
 896 #include <BOPTools_Interference.hxx>
 897 #include <BOPTools_InterferencePool.hxx>
 898
 899 #include <BOPTools_DSFiller.hxx>
 900 #include <BOPTools_SplitShapesPool.hxx>
 901 #include <BOPTools_ListOfPaveBlock.hxx>
 902 #include <BOPTools_ListIteratorOfListOfPaveBlock.hxx>
 903 #include <BOPTools_PaveBlock.hxx>
 904
 905 #include <BOPTools_PavePool.hxx>
 906 #include <BOPTools_PaveSet.hxx>
 907 #include <BOPTools_ListOfPave.hxx>
 908 #include <BOPTools_ListIteratorOfListOfPave.hxx>
 909
 910 #include <BOPTools_CommonBlockPool.hxx>
 911 #include <BOPTools_ListOfCommonBlock.hxx>
 912 #include <BOPTools_ListIteratorOfListOfCommonBlock.hxx>
 913 #include <BOPTools_CommonBlock.hxx>
 914 #include <BOPTools_PaveFiller.hxx>
 915 #include <BOPTools_CArray1OfSSInterference.hxx>
 916 #include <BOPTools_SSInterference.hxx>
 917 #include <BOPTools_InterferencePool.hxx>
 918 #include <BOPTools_SequenceOfCurves.hxx>
 919 #include <BOPTools_Curve.hxx>
 920
 921 #include <BOPTools_SequenceOfCurves.hxx>
 922 #include <BOPTools_Curve.hxx>
 923 #include <BOPTools_ListOfPaveBlock.hxx>
 924 #include <BOPTools_PaveBlock.hxx>
 925 #include <BOPTools_ListIteratorOfListOfPaveBlock.hxx>
 926
 927
 928 static Standard_Integer bopinterf (Draw_Interpretor&, Standard_Integer, const char**);
 929 static Standard_Integer bopds     (Draw_Interpretor&, Standard_Integer, const char**);
 930 static Standard_Integer bopsplits (Draw_Interpretor&, Standard_Integer, const char**);
 931 static Standard_Integer bopscts   (Draw_Interpretor&, Standard_Integer, const char**);
 932 static Standard_Integer bopsamedomain(Draw_Interpretor&, Standard_Integer, const char**);
 933 static Standard_Integer bopaves   (Draw_Interpretor&, Standard_Integer, const char**);
 934 static Standard_Integer bopsinf   (Draw_Interpretor&, Standard_Integer, const char**);
 935 static Standard_Integer bopsonf   (Draw_Interpretor&, Standard_Integer, const char**);
 936 static Standard_Integer bopnews   (Draw_Interpretor& ,Standard_Integer, const char**);
 937
 938 //=======================================================================
 939 //function : TSTCommands
 940 //purpose  :
 941 //=======================================================================
 942   void  BOPTest::TSTCommands(Draw_Interpretor& theCommands)
 943 {
 944   static Standard_Boolean done = Standard_False;
 945   if (done) return;
 946   done = Standard_True;
 947   // Chapter's name
 948   const char* g = "CCR commands";
 949   //
 950   theCommands.Add("bopinterf" , "", __FILE__, bopinterf, g);
 951   theCommands.Add("bopds"     , "Use  bopds [-sw]", __FILE__, bopds, g);
 952
 953   theCommands.Add("bopsplits" , "", __FILE__, bopsplits, g);
 954   theCommands.Add("bopscts"   , "", __FILE__, bopscts, g);
 955
 956   theCommands.Add("bopsamedomain" , "", __FILE__, bopsamedomain, g);//SameDomain Edges
 957   theCommands.Add("bopaves"    , "", __FILE__, bopaves, g);
 958   theCommands.Add("bopnews"    , "bopnews [-f,w,e,v]", __FILE__, bopnews, g);
 959   //
 960   // All Splits of face1 IN face2
 961   theCommands.Add("bopsinf" , "Use bopsinf #F1 #F2", __FILE__, bopsinf, g);
 962   //
 963   // All Splits of face1 ON face2
 964   theCommands.Add("bopsonf" , "Use bopsinf #F1 #F2", __FILE__, bopsonf, g);
 965 }
 966
 967
 968 //=======================================================================
 969 //function : bopinterf
 970 //purpose  :
 971 //=======================================================================
 972 Standard_Integer bopinterf (Draw_Interpretor& di,
 973                             Standard_Integer /*n*/,
 974                             const char** /*a*/)
 975 {
 976   if (pDF==NULL) {
 977     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
 978     return 0;
 979   }
 980
 981   Standard_Integer i, aNbLines;
 982   //
 983   // InterferenceTable
 984   Standard_Integer aWith, anIndex, aFst, aLF;
 985   BooleanOperations_KindOfInterference aType;
 986
 987   const BOPTools_InterferencePool& anInterferencePool=pDF->InterfPool();
 988   const BOPTools_CArray1OfInterferenceLine& aTableIL=anInterferencePool.InterferenceTable();
 989
 990   aNbLines=aTableIL.Extent();
 991   for (i=1; i<=aNbLines; ++i) {
 992     aFst=0;
 993     aLF=0;
 994     const BOPTools_InterferenceLine& aIL=aTableIL(i);
 995     const BOPTools_ListOfInterference& aIList=aIL.List();
 996     BOPTools_ListIteratorOfListOfInterference anIt(aIList);
 997     for (; anIt.More(); anIt.Next()) {
 998       const BOPTools_Interference& anInterf=anIt.Value();
 999       aWith=anInterf.With();
1000       aType=anInterf.Type();
1001       anIndex=anInterf.Index();
1002       if (anIndex) {
1003         if (aFst==0){
1004           //printf(" #%d ", i);
1005           di << " #" << i << " ";
1006           aFst=1;
1007         }
1008         aLF=1;
1009         //printf("(%d, %d, %d),", aWith, aType, anIndex);
1010         di << "(" << aWith << ", " << aType << ", " << anIndex << "),";
1011       }
1012     }
1013     if (aLF) {
1014       //printf("\n");
1015       di << "\n";
1016     }
1017   }
1018   return 0;
1019 }
1020
1021 //=======================================================================
1022 //function : bopds
1023 //purpose  :
1024 //=======================================================================
1025 Standard_Integer bopds (Draw_Interpretor& di,
1026                         Standard_Integer n,
1027                         const char** a)
1028 {
1029   if (pDF==NULL) {
1030     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
1031     return 0;
1032   }
1033
1034   const BooleanOperations_ShapesDataStructure& aDS=pDF->DS();
1035   Standard_Integer i, aNbLines;
1036
1037   i=1;
1038   aNbLines=aDS.NumberOfSourceShapes();
1039
1040   if (n==3) {
1041     if (!strcmp (a[2], "-o")) {
1042       aDS.ObjectRange(i, aNbLines);
1043     }
1044     if (!strcmp (a[2], "-t")) {
1045       aDS.ToolRange(i, aNbLines);
1046     }
1047   }
1048
1049   Draw_Color aTextColor(Draw_cyan);
1050   TCollection_AsciiString aNm("z");
1051
1052   for (; i<=aNbLines; ++i) {
1053
1054     const TopoDS_Shape& aS=aDS.GetShape(i);
1055     //
1056     // Prestentation
1057     TopAbs_ShapeEnum aType=aS.ShapeType();
1058     if (n==1) {
1059       if (aType==TopAbs_COMPOUND ||
1060           aType==TopAbs_COMPSOLID ||
1061           aType==TopAbs_SOLID ||
1062           aType==TopAbs_SHELL ||
1063           aType==TopAbs_FACE  ||
1064           aType==TopAbs_WIRE) {
1065         continue;
1066       }
1067     }
1068
1069     if (n>=2) {
1070       if (!strcmp (a[1], "-c")) {
1071         if (aType!=TopAbs_COMPOUND) {
1072           continue;
1073         }
1074       }
1075       else if (!strcmp (a[1], "-cs")) {
1076         if (aType!=TopAbs_COMPSOLID) {
1077           continue;
1078         }
1079       }
1080       else if (!strcmp (a[1], "-s")) {
1081         if (aType!=TopAbs_SOLID) {
1082           continue;
1083         }
1084       }
1085       else if (!strcmp (a[1], "-sh")) {
1086         if (aType!=TopAbs_SHELL) {
1087           continue;
1088         }
1089       }
1090       else if (!strcmp (a[1], "-f")) {
1091         if (aType!=TopAbs_FACE) {
1092           continue;
1093         }
1094       }
1095       else if (!strcmp (a[1], "-w")) {
1096         if (aType!=TopAbs_WIRE) {
1097           continue;
1098         }
1099       }
1100      else  if (!strcmp (a[1], "-e")) {
1101         if (aType!=TopAbs_EDGE) {
1102           continue;
1103         }
1104       }
1105       else if (!strcmp (a[1], "-v")) {
1106         if (aType!=TopAbs_VERTEX) {
1107           continue;
1108         }
1109       }
1110       else {
1111         continue;
1112       }
1113     }
1114
1115     TCollection_AsciiString aInd(i), aName;
1116     aName=aNm+aInd;
1117     Standard_CString aText=aName.ToCString();
1118
1119     Handle(BOPTest_DrawableShape) aDShape=
1120       new BOPTest_DrawableShape (aS, aText, aTextColor);
1121     Draw::Set (aText, aDShape);
1122   }
1123   return 0;
1124 }
1125
1126 //=======================================================================
1127 //function : bopaves
1128 //purpose  :
1129 //=======================================================================
1130 Standard_Integer  bopaves(Draw_Interpretor& di,
1131                           Standard_Integer /*n*/,
1132                           const char** /*a*/)
1133 {
1134   if (pDF==NULL) {
1135     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
1136     return 0;
1137   }
1138   Standard_Integer i, aNbLines, anIndex;
1139   Standard_Real aParam;
1140
1141   const BooleanOperations_ShapesDataStructure& aDS=pDF->DS();
1142   const BOPTools_PavePool& aPavePool=pDF->PavePool();
1143
1144   aNbLines=aDS.NumberOfSourceShapes();
1145   for (i=1; i<=aNbLines; ++i) {
1146     const TopoDS_Shape& aS=aDS.GetShape(i);
1147     if (aS.ShapeType()==TopAbs_EDGE) {
1148       //printf(" Edge#%d\n", i);
1149       di << " Edge#" << i << "\n";
1150       const BOPTools_PaveSet& aPaveSet=aPavePool(aDS.RefEdge(i));
1151       const BOPTools_ListOfPave& aLP= aPaveSet.Set();
1152       BOPTools_ListIteratorOfListOfPave anIt(aLP);
1153       for (; anIt.More(); anIt.Next()){
1154         const BOPTools_Pave& aPave=anIt.Value();
1155         anIndex=aPave.Index();
1156         aParam =aPave.Param();
1157         //printf(" VertIndex=%d, aParam=%f\n", anIndex, aParam);
1158         di << " VertIndex=" << anIndex << ", aParam=" << aParam << "\n";
1159       }
1160     }
1161   }
1162   return 0;
1163 }
1164
1165 //=======================================================================
1166 //function : bopsd
1167 //purpose  : SameDomain Edges
1168 //=======================================================================
1169 Standard_Integer bopsamedomain (Draw_Interpretor& di,
1170                                 Standard_Integer /*n*/,
1171                                 const char** /*a*/)
1172 {
1173   if (pDF==NULL) {
1174     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
1175     return 0;
1176   }
1177   TCollection_AsciiString aNm("s");
1178
1179   const BooleanOperations_ShapesDataStructure& aDS=pDF->DS();
1180   const BOPTools_CommonBlockPool& aCommonBlockPool=pDF->CommonBlockPool();
1181
1182   Standard_Integer i, aNbLines, nFSD, nESD1, nESD2, nOriginal2;
1183
1184   aNbLines=aDS.NumberOfSourceShapes();
1185   for (i=1; i<=aNbLines; ++i) {
1186     const TopoDS_Shape& aSE=aDS.GetShape(i);
1187     TopAbs_ShapeEnum aType=aSE.ShapeType();
1188     if (aType==TopAbs_EDGE) {
1189
1190       const BOPTools_ListOfCommonBlock& aLCB=aCommonBlockPool(aDS.RefEdge(i));
1191
1192       if (aLCB.Extent()) {
1193         //
1194         BOPTools_ListIteratorOfListOfCommonBlock anIt(aLCB);
1195         for (; anIt.More(); anIt.Next()) {
1196           const BOPTools_CommonBlock& aCB=anIt.Value();
1197           nFSD=aCB.Face();
1198           if (nFSD) {
1199             const BOPTools_PaveBlock& aPB1=aCB.PaveBlock1();
1200             nESD1=aPB1.Edge();
1201
1202             TCollection_AsciiString aInd(i), anUnd("_"), aName;
1203             aName=aNm+aInd;
1204             aName=aName+anUnd;
1205             aName=aName+nESD1;
1206             Standard_CString aText=aName.ToCString();
1207
1208             //printf(" (EF %s  %df),", aText, nFSD);
1209             di << " (EF " << aText << "  " << nFSD << "f),";
1210           }
1211
1212           else {
1213             const BOPTools_PaveBlock& aPB1=aCB.PaveBlock1();
1214             nESD1=aPB1.Edge();
1215
1216             TCollection_AsciiString aInd(i), anUnd("_"), aName;
1217             aName=aNm+aInd;
1218             aName=aName+anUnd;
1219             aName=aName+nESD1;
1220             Standard_CString aText=aName.ToCString();
1221
1222             const BOPTools_PaveBlock& aPB2=aCB.PaveBlock2();
1223             nESD2=aPB2.Edge();
1224             nOriginal2=aPB2.OriginalEdge();
1225
1226             TCollection_AsciiString aInd2(nOriginal2), aName2;
1227             aName2=aNm+aInd2;
1228             aName2=aName2+anUnd;
1229             aName2=aName2+nESD2;
1230             Standard_CString aText2=aName2.ToCString();
1231
1232             //printf(" (EE %s %s ),", aText, aText2);
1233             di << " (EE " << aText << " " << aText2 << " ),";
1234           }
1235         }
1236         //printf("\n");
1237         di << "\n";
1238       }
1239     }
1240   }
1241   return 0;
1242 }
1243 //=======================================================================
1244 //function : bopnews
1245 //purpose  :
1246 //=======================================================================
1247 Standard_Integer bopnews (Draw_Interpretor& di,
1248                           Standard_Integer n,
1249                           const char** a)
1250
1251 {
1252   if (pDF==NULL) {
1253     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
1254     return 0;
1255   }
1256
1257   const BooleanOperations_ShapesDataStructure& aDS=pDF->DS();
1258
1259   Standard_Integer i, iStart, aNbLinesTotal;
1260   Draw_Color aTextColor(Draw_cyan);
1261   TCollection_AsciiString aNm("z");
1262   //
1263
1264   TopAbs_ShapeEnum aType=TopAbs_EDGE;
1265   if (n>1) {
1266     if (!strcmp (a[1], "-f")) {
1267       aType=TopAbs_FACE;
1268     }
1269     else if (!strcmp (a[1], "-w")) {
1270       aType=TopAbs_WIRE;
1271     }
1272     else  if (!strcmp (a[1], "-e")) {
1273       aType=TopAbs_EDGE;
1274     }
1275     else if (!strcmp (a[1], "-v")) {
1276       aType=TopAbs_VERTEX;
1277     }
1278   }
1279
1280   //
1281   iStart=aDS.NumberOfSourceShapes()+1;
1282   aNbLinesTotal =aDS.NumberOfInsertedShapes();
1283
1284   for (i=iStart; i<=aNbLinesTotal; ++i) {
1285     const TopoDS_Shape& aS=aDS.Shape(i);
1286     TopAbs_ShapeEnum aTypeCurrent=aS.ShapeType();
1287     if (aTypeCurrent==aType) {
1288       TCollection_AsciiString aName, aInd(i);
1289       aName=aNm+aInd;
1290       Standard_CString aText=aName.ToCString();
1291
1292       Handle(BOPTest_DrawableShape) aDShape=
1293         new BOPTest_DrawableShape (aS, aText, aTextColor);
1294       Draw::Set (aText, aDShape);
1295       //printf("%s ", aText);
1296       di << aText << " ";
1297     }
1298   }
1299
1300   if (iStart>aNbLinesTotal) {
1301     di << " No new shapes occured";
1302   }
1303
1304   di << "\n";
1305   return 0;
1306 }
1307
1308 //=======================================================================
1309 //function : bopsplits
1310 //purpose  :
1311 //=======================================================================
1312 Standard_Integer bopsplits (Draw_Interpretor& di,
1313                             Standard_Integer /*n*/,
1314                             const char** /*a*/)
1315
1316 {
1317   if (pDF==NULL) {
1318     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
1319     return 0;
1320   }
1321
1322   const BOPTools_SplitShapesPool& aSpPool=pDF->SplitShapesPool();
1323   const BooleanOperations_ShapesDataStructure& aDS=pDF->DS();
1324
1325   Standard_Integer i, aNbLines, aNbSplits, aSplitExist=0;
1326   Draw_Color aTextColor(Draw_cyan);
1327   TCollection_AsciiString aNm("s");
1328
1329   aNbLines=aDS.NumberOfSourceShapes();
1330   for (i=1; i<=aNbLines; ++i) {
1331     const TopoDS_Shape& aSE=aDS.GetShape(i);
1332     TopAbs_ShapeEnum aType=aSE.ShapeType();
1333     if (aType==TopAbs_EDGE) {
1334       //
1335       // Splits' Prestentation
1336       const BOPTools_ListOfPaveBlock& aSplitsList=aSpPool(aDS.RefEdge(i));
1337       aNbSplits=aSplitsList.Extent();
1338       if (aNbSplits) {
1339         if (!aSplitExist) {
1340           di << " Splits: ";
1341           aSplitExist=1;
1342         }
1343
1344         BOPTools_ListIteratorOfListOfPaveBlock anIt(aSplitsList);
1345         for (; anIt.More();anIt.Next()) {
1346           const BOPTools_PaveBlock& aPB=anIt.Value();
1347           Standard_Integer nSplit=aPB.Edge();
1348           const TopoDS_Shape& aS=aDS.GetShape(nSplit);
1349
1350           TCollection_AsciiString aInd(i), anUnd("_"), aName;
1351           aName=aNm+aInd;
1352           aName=aName+anUnd;
1353           aName=aName+nSplit;
1354           Standard_CString aText=aName.ToCString();
1355
1356           Handle(BOPTest_DrawableShape) aDShape=
1357             new BOPTest_DrawableShape (aS, aText, aTextColor);
1358           Draw::Set (aText, aDShape);
1359           di << aText << " ";
1360         }
1361       }
1362     }
1363   }
1364
1365   if (!aSplitExist) {
1366     di << " No splits occured";
1367   }
1368   di << "\n";
1369   return 0;
1370 }
1371
1372 //=======================================================================
1373 //function : bopscts
1374 //purpose  :
1375 //=======================================================================
1376 Standard_Integer bopscts (Draw_Interpretor& di,
1377                           Standard_Integer /*n*/,
1378                           const char** /*a*/)
1379
1380 {
1381   if (pDF==NULL) {
1382     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
1383     return 0;
1384   }
1385   Standard_Integer i, nF1, nF2,  aNbFFs, aNbOldSects, aSectExist=0, nSect;
1386   Standard_Integer j, aNbCurves, aNbPaveBlocks, nNewEdge;
1387   Draw_Color aTextColor(Draw_cyan);
1388   TCollection_AsciiString aNm("t");
1389
1390   const BooleanOperations_ShapesDataStructure& aDS=pDF->DS();
1391   const BOPTools_InterferencePool& anInterfPool=pDF->InterfPool();
1392   BOPTools_InterferencePool* pInterfPool= (BOPTools_InterferencePool*) &anInterfPool;
1393   BOPTools_CArray1OfSSInterference& aFFs=pInterfPool->SSInterferences();
1394
1395   aNbFFs=aFFs.Extent();
1396   for (i=1; i<=aNbFFs; ++i) {
1397     BOPTools_SSInterference& aFFi=aFFs(i);
1398     //
1399     nF1=aFFi.Index1();
1400     nF2=aFFi.Index2();
1401     TCollection_AsciiString aInd(nF1), anUnd("_");
1402     //
1403     // Old Section Edges
1404     const BOPTools_ListOfPaveBlock& aSectList=aFFi.PaveBlocks();
1405     aNbOldSects=aSectList.Extent();
1406     if (aNbOldSects) {
1407       if (!aSectExist) {
1408         di << " Sects: ";
1409         aSectExist=1;
1410       }
1411
1412       BOPTools_ListIteratorOfListOfPaveBlock anIt(aSectList);
1413       for (; anIt.More();anIt.Next()) {
1414         const BOPTools_PaveBlock& aPB=anIt.Value();
1415         nSect=aPB.Edge();
1416         const TopoDS_Shape& aS=aDS.GetShape(nSect);
1417
1418         TCollection_AsciiString aName;
1419         aName=aNm+aInd;
1420         aName=aName+anUnd;
1421         aName=aName+nSect;
1422         Standard_CString aText=aName.ToCString();
1423
1424         Handle(BOPTest_DrawableShape) aDShape=
1425           new BOPTest_DrawableShape (aS, aText, aTextColor);
1426         Draw::Set (aText, aDShape);
1427         di << aText << " ";
1428       }
1429     }
1430     //
1431     // New Section Edges
1432     BOPTools_SequenceOfCurves& aBCurves=aFFi.Curves();
1433     aNbCurves=aBCurves.Length();
1434     for (j=1; j<=aNbCurves; j++) {
1435       BOPTools_Curve& aBC=aBCurves(j);
1436       const BOPTools_ListOfPaveBlock& aSectEdges=aBC.NewPaveBlocks();
1437       aNbPaveBlocks=aSectEdges.Extent();
1438       if (aNbPaveBlocks) {
1439         if (!aSectExist) {
1440           di << " Sects: ";
1441           aSectExist=1;
1442         }
1443       }
1444       BOPTools_ListIteratorOfListOfPaveBlock aPBIt(aSectEdges);
1445       for (; aPBIt.More(); aPBIt.Next()) {
1446         BOPTools_PaveBlock& aPB=aPBIt.Value();
1447         nNewEdge=aPB.Edge();
1448         const TopoDS_Shape& aSectEdge=aDS.GetShape(nNewEdge);
1449
1450         TCollection_AsciiString aName;
1451         aName=aNm+aInd;
1452         aName=aName+anUnd;
1453         aName=aName+nNewEdge;
1454         Standard_CString aText=aName.ToCString();
1455
1456         Handle(BOPTest_DrawableShape) aDShape=
1457           new BOPTest_DrawableShape (aSectEdge, aText, aTextColor);
1458         Draw::Set (aText, aDShape);
1459         di << aText << " ";
1460       }
1461     }
1462   }
1463
1464   if (!aSectExist) {
1465     di << " No section edges";
1466   }
1467   di << "\n";
1468   return 0;
1469 }
1470
1471 //=======================================================================
1472 //function : bopsinf
1473 //purpose  :
1474 //=======================================================================
1475 Standard_Integer bopsinf (Draw_Interpretor& di,
1476                           Standard_Integer n,
1477                           const char** a)
1478 {
1479   if (pDF==NULL) {
1480     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
1481     return 0;
1482   }
1483
1484   if (n!=3) {
1485     di << " Use: bopsinf> #F1 #F2\n";
1486     return 0;
1487   }
1488
1489   const BooleanOperations_ShapesDataStructure& aDS=pDF->DS();
1490
1491   Standard_Integer nSp=0, nF1, nF2, anExistFlag=0;
1492   nF1=atoi(a[1]);
1493   nF2=atoi(a[2]);
1494
1495   const TopoDS_Shape& aS1=aDS.GetShape(nF1);
1496   const TopoDS_Shape& aS2=aDS.GetShape(nF2);
1497   if (aS1.IsNull() || aS2.IsNull()) {
1498     //printf(" Null shapes #%d #%d\n", nF1, nF2 );
1499     di << " Null shapes #" << nF1 << " #" << nF2 << "\n";
1500     return 0;
1501   }
1502
1503   if (aS1.ShapeType()!=TopAbs_FACE ||
1504       aS1.ShapeType()!=TopAbs_FACE ) {
1505     //printf(" Shapes #%d #%d are not faces\n", nF1, nF2 );
1506     di << " Shapes #" << nF1 << " #" << nF2 << " are not faces\n";
1507     return 0;
1508   }
1509
1510   TColStd_ListOfInteger aSplList;
1511   const BOPTools_PaveFiller& aPF=pDF->PaveFiller();
1512   BOPTools_PaveFiller* pPF=(BOPTools_PaveFiller*)&aPF;
1513
1514   pPF->SplitsInFace (nSp, nF1, nF2, aSplList);
1515
1516   TColStd_ListIteratorOfListOfInteger anIt (aSplList);
1517   for (; anIt.More(); anIt.Next()) {
1518     anExistFlag=1;
1519     nSp=anIt.Value();
1520     //printf("%d, ", nSp);
1521     di << nSp << ", ";
1522   }
1523
1524   if(anExistFlag) {
1525     di << "\n";
1526   }
1527   else {
1528     di << "No splits of Face" << nF1 << " IN Face " << nF2 << "\n";
1529   }
1530
1531 return 0;
1532 }
1533 //=======================================================================
1534 //function : bopsonf
1535 //purpose  :
1536 //=======================================================================
1537 Standard_Integer bopsonf (Draw_Interpretor& di,
1538                           Standard_Integer n,
1539                           const char** a)
1540 {
1541   if (pDF==NULL) {
1542     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
1543     return 0;
1544   }
1545
1546   if (n!=3) {
1547     di << " Use: bopsonf> #F1 #F2\n";
1548     return 0;
1549   }
1550
1551   const BooleanOperations_ShapesDataStructure& aDS=pDF->DS();
1552
1553   Standard_Integer nSp=0, nF1, nF2, anExistFlag=0;
1554   nF1=atoi(a[1]);
1555   nF2=atoi(a[2]);
1556
1557   const TopoDS_Shape& aS1=aDS.GetShape(nF1);
1558   const TopoDS_Shape& aS2=aDS.GetShape(nF2);
1559   if (aS1.IsNull() || aS2.IsNull()) {
1560     //printf(" Null shapes #%d #%d\n", nF1, nF2 );
1561     di << " Null shapes #" << nF1 << " #" << nF2 << "\n";
1562     return 0;
1563   }
1564
1565   if (aS1.ShapeType()!=TopAbs_FACE ||
1566       aS1.ShapeType()!=TopAbs_FACE ) {
1567     //printf(" Shapes #%d #%d are not faces\n", nF1, nF2 );
1568     di << " Shapes #" << nF1 << " #" << nF2 << " are not faces\n";
1569     return 0;
1570   }
1571
1572   TColStd_ListOfInteger aSplList;
1573   const BOPTools_PaveFiller& aPF=pDF->PaveFiller();
1574   BOPTools_PaveFiller* pPF=(BOPTools_PaveFiller*)&aPF;
1575
1576   pPF->SplitsOnFace (nSp, nF1, nF2, aSplList);
1577
1578   TColStd_ListIteratorOfListOfInteger anIt (aSplList);
1579   for (; anIt.More(); anIt.Next()) {
1580     anExistFlag=1;
1581     nSp=anIt.Value();
1582     //printf("%d, ", nSp);
1583     di << nSp << ", ";
1584   }
1585
1586    if(anExistFlag) {
1587     di << "\n";
1588   }
1589   else {
1590     di << "No splits of Face" << nF1 << " ON Face " << nF2 << "\n";
1591   }
1592
1593   return 0;
1594 }
1595
1596 //=======================================================================
1597 //function : bopwho
1598 //purpose  :
1599 //=======================================================================
1600 Standard_Integer bopwho (Draw_Interpretor& di,
1601                          Standard_Integer n,
1602                          const char** a)
1603 {
1604   if (pDF==NULL) {
1605     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
1606     return 0;
1607   }
1608
1609   if (n!=2) {
1610     di << " Use >bopwho Index\n";
1611     return 1;
1612   }
1613   //
1614   Standard_Boolean bIsNewShape;
1615   Standard_Integer iNum, i, aNbLines, aNbObj, aNewShape, aWhat, aWith;
1616   //
1617   iNum=atoi(a[1]);
1618   if (iNum<=0) {
1619     di << " Shape Index must be >0 .\n";
1620     return 1;
1621   }
1622   //
1623   //printf("Shape #%d is ", iNum);
1624   di << "Shape #" << iNum << " is ";
1625
1626   const BooleanOperations_ShapesDataStructure& aDS=pDF->DS();
1627   aNbLines=aDS.NumberOfSourceShapes();
1628   //
1629   //
1630   // Old shapes processing
1631   //
1632   if (iNum>0 && iNum<=aNbLines) {
1633     di << "from the ";
1634     // Old Shape
1635     aNbObj=aDS.NumberOfShapesOfTheObject();
1636     if (iNum<=aNbObj) {
1637       di << "Object ";
1638     }
1639     else {
1640       di << "Tool ";
1641     }
1642     di << ".\n";
1643     return 0;
1644   }
1645   //
1646   bIsNewShape=aDS.IsNewShape(iNum);
1647   if (bIsNewShape) {
1648     di << "new.\n";
1649   }
1650
1651   else {
1652     di << "undefined.\n";
1653     return 0;
1654   }
1655   //
1656   // New shapes processing
1657   //
1658   const TopoDS_Shape& aShapeToFind=aDS.Shape(iNum);
1659   TopAbs_ShapeEnum aTypeOfShapeToFind=aShapeToFind.ShapeType();
1660   //
1661   // Interferences
1662   const BOPTools_InterferencePool& anInterferencePool=pDF->InterfPool();
1663   //
1664   const BOPTools_CArray1OfVVInterference&  aVVInterfs=anInterferencePool.VVInterfs();
1665   const BOPTools_CArray1OfVEInterference&  aVEInterfs=anInterferencePool.VEInterfs();
1666   const BOPTools_CArray1OfVSInterference&  aVSInterfs=anInterferencePool.VSInterfs();
1667   const BOPTools_CArray1OfEEInterference&  aEEInterfs=anInterferencePool.EEInterfs();
1668   const BOPTools_CArray1OfESInterference&  aESInterfs=anInterferencePool.ESInterfs();
1669   //
1670   // VV
1671   aNbLines=aVVInterfs.Extent();
1672   for (i=1; i<=aNbLines; ++i) {
1673     aNewShape=aVVInterfs(i).NewShape();
1674     if (aNewShape==iNum) {
1675       aVVInterfs(i).Indices(aWhat, aWith);
1676       //printf(" VV: (%d, %d)\n", aWhat, aWith);
1677       di << " VV: (" << aWhat << ", " << aWith << ")\n";
1678     }
1679   }
1680   //
1681   // VE
1682   aNbLines=aVEInterfs.Extent();
1683   for (i=1; i<=aNbLines; ++i) {
1684     aNewShape=aVEInterfs(i).NewShape();
1685     if (aNewShape==iNum) {
1686       aVEInterfs(i).Indices(aWhat, aWith);
1687       //printf(" VE: (%d, %d)\n", aWhat, aWith);
1688       di << " VE: (" << aWhat << ", " << aWith << ")\n";
1689     }
1690   }
1691   //
1692   // VF
1693   aNbLines=aVSInterfs.Extent();
1694   for (i=1; i<=aNbLines; ++i) {
1695     aNewShape=aVSInterfs(i).NewShape();
1696     if (aNewShape==iNum) {
1697       aVSInterfs(i).Indices(aWhat, aWith);
1698       //printf(" VF: (%d, %d)\n", aWhat, aWith);
1699       di << " VF: (" << aWhat << ", " << aWith << ")\n";
1700     }
1701   }
1702   //
1703   // EE
1704   aNbLines=aEEInterfs.Extent();
1705   for (i=1; i<=aNbLines; ++i) {
1706     aNewShape=aEEInterfs(i).NewShape();
1707     if (aNewShape==iNum) {
1708       aEEInterfs(i).Indices(aWhat, aWith);
1709       //printf(" EE: (%d, %d)\n", aWhat, aWith);
1710       di << " EE: (" << aWhat << ", " << aWith << ")\n";
1711     }
1712   }
1713   //
1714   // EF
1715   aNbLines=aESInterfs.Extent();
1716   for (i=1; i<=aNbLines; ++i) {
1717     aNewShape=aESInterfs(i).NewShape();
1718     if (aNewShape==iNum) {
1719       aESInterfs(i).Indices(aWhat, aWith);
1720       //printf(" EF: (%d, %d)\n", aWhat, aWith);
1721       di << " EF: (" << aWhat << ", " << aWith << ")\n";
1722     }
1723   }
1724   //
1725   // FF
1726   Standard_Integer j, aNbCurves;
1727   //
1728   BOPTools_InterferencePool* pInterPool=(BOPTools_InterferencePool*)&pDF->InterfPool();
1729   BOPTools_CArray1OfSSInterference&  aSSInterfs=pInterPool->SSInterferences();
1730   //
1731   aNbLines=aSSInterfs.Extent();
1732   for (i=1; i<=aNbLines; ++i) {
1733     BOPTools_SSInterference& aFF=aSSInterfs(i);
1734     aWhat=aFF.Index1();
1735     aWith=aFF.Index2();
1736
1737
1738     BOPTools_SequenceOfCurves& aSC=aFF.Curves();
1739
1740     aNbCurves=aSC.Length();
1741     for (j=1; j<=aNbCurves; ++j) {
1742       const BOPTools_Curve& aBC=aSC(j);
1743
1744       if (aTypeOfShapeToFind==TopAbs_EDGE) {
1745         const BOPTools_ListOfPaveBlock& aLPB=aBC.NewPaveBlocks();
1746         BOPTools_ListIteratorOfListOfPaveBlock anIt(aLPB);
1747         for (; anIt.More(); anIt.Next()) {
1748           const BOPTools_PaveBlock& aPB=anIt.Value();
1749           aNewShape=aPB.Edge();
1750           if (aNewShape==iNum) {
1751             //printf(" FF: (%d, %d) [Section Edge]\n", aWhat, aWith);
1752             di << " FF: (" << aWhat << ", " << aWith << ") [Section Edge]\n";
1753           }
1754         }
1755       }
1756       //
1757       if (aTypeOfShapeToFind==TopAbs_VERTEX) {
1758         BOPTools_Curve* pBC=(BOPTools_Curve*)&aBC;
1759         TColStd_ListOfInteger& aTVList=pBC->TechnoVertices();
1760         TColStd_ListIteratorOfListOfInteger aTVIt(aTVList);
1761         for (; aTVIt.More(); aTVIt.Next()) {
1762           aNewShape=aTVIt.Value();
1763           if (aNewShape==iNum) {
1764             //printf(" FF: (%d, %d) [Techno Vertex]\n", aWhat, aWith);
1765             di << " FF: (" << aWhat << ", " << aWith << ") [Techno Vertex]\n";
1766           }
1767         }
1768       }
1769     }
1770     //
1771     if (aTypeOfShapeToFind==TopAbs_VERTEX) {
1772       TColStd_ListOfInteger& anAVList=aFF.AloneVertices();
1773       TColStd_ListIteratorOfListOfInteger anAVIt(anAVList);
1774       for (; anAVIt.More(); anAVIt.Next()) {
1775         aNewShape=anAVIt.Value();
1776         if (aNewShape==iNum) {
1777           //printf(" FF: (%d, %d) [Alone Vertex]\n", aWhat, aWith);
1778           di << " FF: (" << aWhat << ", " << aWith << ") [Alone Vertex]\n";
1779         }
1780       }
1781     }
1782   }
1783   //
1784   //
1785   // PaveBlocks
1786   if (aTypeOfShapeToFind==TopAbs_EDGE) {
1787     //
1788     Standard_Integer aNbPaveBlocks, nE, nOriginalEdge, aNbCommonBlocks;
1789     Standard_Integer nFace, nE2,  nOriginalEdge2;
1790     //
1791     const BOPTools_CommonBlockPool& aCommonBlockPool=pDF->CommonBlockPool();
1792     const BOPTools_SplitShapesPool& aSplitShapesPool=pDF->SplitShapesPool();
1793     aNbLines=aSplitShapesPool.Extent();
1794     for (i=1; i<=aNbLines; ++i) {
1795       const BOPTools_ListOfPaveBlock& aSplitEdges=aSplitShapesPool(i);
1796       aNbPaveBlocks=aSplitEdges.Extent();
1797
1798       BOPTools_ListIteratorOfListOfPaveBlock aPBIt(aSplitEdges);
1799       for (; aPBIt.More(); aPBIt.Next()) {
1800         const BOPTools_PaveBlock& aPB=aPBIt.Value();
1801         nE=aPB.Edge();
1802         nOriginalEdge=aPB.OriginalEdge();
1803         if (nE==iNum) {
1804           //printf("  PaveBlock [Base Edge #%d]\n", nOriginalEdge);
1805           di << "  PaveBlock [Base Edge #" << nOriginalEdge << "]\n";
1806           const BOPTools_ListOfCommonBlock& aLCB=
1807             aCommonBlockPool(aDS.RefEdge(nOriginalEdge));
1808           aNbCommonBlocks=aLCB.Extent();
1809
1810           BOPTools_ListIteratorOfListOfCommonBlock aCBIt(aLCB);
1811           for (; aCBIt.More(); aCBIt.Next()) {
1812             BOPTools_CommonBlock& aCB=aCBIt.Value();
1813             nFace=aCB.Face();
1814             if (nFace) {
1815               //printf("  CommonBlock with Face #%d\n", nFace);
1816               di << "  CommonBlock with Face #" << nFace << "\n";
1817             }
1818             else {
1819               BOPTools_PaveBlock& aPB2=aCB.PaveBlock2(nOriginalEdge);
1820               nE2=aPB2.Edge();
1821               nOriginalEdge2=aPB2.OriginalEdge();
1822               //printf("  CommonBlock with Edge #%d [Base Edge #%d]\n",
1823                 //     nE2, nOriginalEdge2);
1824               di << "  CommonBlock with Edge #" << nE2 << " [Base Edge #" << nOriginalEdge2 << "]\n";
1825             }
1826           }
1827
1828         }
1829       }
1830     }
1831
1832   }
1833   return 0;
1834 }
1835
1836 //=======================================================================
1837 //function : bopsticks
1838 //purpose  :
1839 //=======================================================================
1840 Standard_Integer bopsticks (Draw_Interpretor& di,
1841                             Standard_Integer n,
1842                             const char** )
1843 {
1844   if (pDF==NULL) {
1845     di << " Prepare BOPTools_DSFiller first >bop S1 S2\n";
1846     return 1;
1847   }
1848   //
1849   if (n!=1) {
1850     di << " Use >bopsticks\n";
1851     return 1;
1852   }
1853   //
1854   Standard_Integer i, j, aNbLines, nF1, nF2, aNbVtx, nV;
1855   //
1856   const BooleanOperations_ShapesDataStructure& aDS=pDF->DS();
1857   const BOPTools_PaveFiller& aPF=pDF->PaveFiller();
1858   BOPTools_PaveFiller* pPF=(BOPTools_PaveFiller*)&aPF;
1859   BOPTools_InterferencePool* pInterPool=(BOPTools_InterferencePool*)&pDF->InterfPool();
1860   BOPTools_CArray1OfSSInterference&  aSSInterfs=pInterPool->SSInterferences();
1861   //
1862   aNbLines=aSSInterfs.Extent();
1863   //
1864   for (i=1; i<=aNbLines; ++i) {
1865     TColStd_IndexedMapOfInteger aMapUnUsed;
1866     BOPTools_PaveSet aPSF;
1867     //
1868     BOPTools_SSInterference& aFF=aSSInterfs(i);
1869     BOPTools_SequenceOfCurves& aSCvs=aFF.Curves();
1870
1871     nF1=aFF.Index1();
1872     nF2=aFF.Index2();
1873
1874     pPF->PrepareSetForFace(nF1, nF2, aPSF);
1875     UnUsedMap(aSCvs, aPSF, aMapUnUsed);
1876     aNbVtx=aMapUnUsed.Extent();
1877     for (j=1; j<=aNbVtx; ++j) {
1878       nV=aMapUnUsed(j);
1879       if (aDS.IsNewShape(nV)) {
1880         //printf(" Vertex #%d [FF:(%d, %d)]\n", nV, nF1, nF2);
1881         di << " Vertex #" << nV << " [FF:(" << nF1 << ", " << nF2 << ")]\n";
1882       }
1883     }
1884   }
1885   return 0;
1886 }
1887
1888 //=======================================================================
1889 // function: UnUsedMap
1890 // purpose:
1891 //=======================================================================
1892 void UnUsedMap(BOPTools_SequenceOfCurves& aSCvs,
1893                const BOPTools_PaveSet& aPSF,
1894                TColStd_IndexedMapOfInteger& aMapUnUsed)
1895 {
1896   //
1897   // What stick/non-stick vertices we used
1898   TColStd_IndexedMapOfInteger aMapUsed, aMapMustBeUsed;
1899   Standard_Integer j, aNbCurves, aNbVtx, nV1;//, nV2;
1900   BOPTools_ListIteratorOfListOfPave anLPIt;
1901
1902   aNbCurves=aSCvs.Length();
1903   for (j=1; j<=aNbCurves; ++j) {
1904     BOPTools_Curve& aBC=aSCvs(j);
1905     //const IntTools_Curve& aC= aBC.Curve();// Wng in Gcc 3.0
1906
1907     const BOPTools_PaveSet& aPaveSet=aBC.Set();
1908     const BOPTools_ListOfPave& aLPAlreadyUsed=aPaveSet.Set();
1909     anLPIt.Initialize(aLPAlreadyUsed);
1910     for (; anLPIt.More(); anLPIt.Next()) {
1911       const BOPTools_Pave& aPave=anLPIt.Value();
1912       nV1=aPave.Index();
1913       aMapUsed.Add(nV1);
1914     }
1915   }
1916   //
1917   // 2. Stick vertices that must be used
1918   const BOPTools_ListOfPave& aLPMustUsed=aPSF.Set();
1919   anLPIt.Initialize(aLPMustUsed);
1920   for (; anLPIt.More(); anLPIt.Next()) {
1921     const BOPTools_Pave& aPave=anLPIt.Value();
1922     nV1=aPave.Index();
1923     aMapMustBeUsed.Add(nV1);
1924   }
1925   //
1926   // 3.Unused Stick vertices .
1927   aNbVtx=aMapMustBeUsed.Extent();
1928   for (j=1; j<=aNbVtx; ++j) {
1929     nV1=aMapMustBeUsed(j);
1930     if (!aMapUsed.Contains(nV1)) {
1931       aMapUnUsed.Add(nV1);
1932     }
1933   }
1934   //
1935 }