src/BOP/BOP_ArgumentAnalyzer.cxx

   1 // Created on: 2004-09-02
   2 // Copyright (c) 2004-2012 OPEN CASCADE SAS
   3 //
   4 // The content of this file is subject to the Open CASCADE Technology Public
   5 // License Version 6.5 (the "License"). You may not use the content of this file
   6 // except in compliance with the License. Please obtain a copy of the License
   7 // at http://www.opencascade.org and read it completely before using this file.
   8 //
   9 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
  10 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
  11 //
  12 // The Original Code and all software distributed under the License is
  13 // distributed on an "AS IS" basis, without warranty of any kind, and the
  14 // Initial Developer hereby disclaims all such warranties, including without
  15 // limitation, any warranties of merchantability, fitness for a particular
  16 // purpose or non-infringement. Please see the License for the specific terms
  17 // and conditions governing the rights and limitations under the License.
  18
  19
  20 #include <BOP_ArgumentAnalyzer.ixx>
  21 #include <BOP_CheckResult.hxx>
  22 #include <BOP_ShellSolid.hxx>
  23 #include <BOP_WireSolid.hxx>
  24 #include <BOP_WireShell.hxx>
  25 #include <BOP_WireEdgeSet.hxx>
  26 #include <BOP_FaceBuilder.hxx>
  27
  28 #include <TopExp.hxx>
  29 #include <TopExp_Explorer.hxx>
  30 #include <BRep_Builder.hxx>
  31 #include <BRep_Tool.hxx>
  32 #include <BRepExtrema_DistShapeShape.hxx>
  33 #include <gp_Pnt.hxx>
  34 #include <TopoDS_Iterator.hxx>
  35 #include <TopoDS.hxx>
  36 #include <TopoDS_Vertex.hxx>
  37 #include <TopoDS_Edge.hxx>
  38 #include <TopoDS_Wire.hxx>
  39 #include <TopoDS_Shell.hxx>
  40 #include <TopoDS_Solid.hxx>
  41 #include <TopTools_ListOfShape.hxx>
  42 #include <TopTools_ListIteratorOfListOfShape.hxx>
  43 #include <TopTools_SequenceOfShape.hxx>
  44 #include <TopTools_MapOfShape.hxx>
  45
  46 #include <TColStd_Array2OfBoolean.hxx>
  47
  48 #include <IntTools_Context.hxx>
  49 #include <IntTools_Range.hxx>
  50 #include <IntTools_ShrunkRange.hxx>
  51 #include <IntTools_EdgeEdge.hxx>
  52 #include <IntTools_CommonPrt.hxx>
  53
  54 #include <BOPTools_DSFiller.hxx>
  55 #include <BOPTools_Tools3D.hxx>
  56 #include <BOPTools_Checker.hxx>
  57 #include <BOPTools_CheckResult.hxx>
  58 #include <BOPTools_ListOfCheckResults.hxx>
  59 #include <BOPTools_ListIteratorOfListOfCheckResults.hxx>
  60
  61 #include <Standard_ErrorHandler.hxx>
  62 #include <Standard_Failure.hxx>
  63
  64 static Standard_Boolean TestShapeType(const TopoDS_Shape & TheShape);
  65
  66 static Standard_Boolean CheckEdge(const TopoDS_Edge& theEdge);
  67
  68 static Standard_Boolean TestSubShapeType(const TopAbs_ShapeEnum theT1,
  69                                          const TopAbs_ShapeEnum theT2,
  70                                          const BOP_Operation    theOP);
  71
  72 // ================================================================================
  73 // function: Constructor
  74 // purpose:
  75 // ================================================================================
  76 BOP_ArgumentAnalyzer::BOP_ArgumentAnalyzer() :
  77 myStopOnFirst(Standard_False),
  78 myOperation(BOP_UNKNOWN),
  79 myArgumentTypeMode(Standard_False),
  80 mySelfInterMode(Standard_False),
  81 mySmallEdgeMode(Standard_False),
  82 myRebuildFaceMode(Standard_False),
  83 myTangentMode(Standard_False),
  84 myMergeVertexMode(Standard_False),
  85 myMergeEdgeMode(Standard_False)
  86 // myMergeFaceMode(Standard_False)
  87 {
  88 }
  89
  90 // ================================================================================
  91 // function: SetShape1
  92 // purpose:
  93 // ================================================================================
  94 void BOP_ArgumentAnalyzer::SetShape1(const TopoDS_Shape & TheShape)
  95 {
  96   myShape1 = TheShape;
  97 }
  98
  99 // ================================================================================
 100 // function: SetShape2
 101 // purpose:
 102 // ================================================================================
 103 void BOP_ArgumentAnalyzer::SetShape2(const TopoDS_Shape & TheShape)
 104 {
 105   myShape2 = TheShape;
 106 }
 107
 108 // ================================================================================
 109 // function: GetShape1
 110 // purpose:
 111 // ================================================================================
 112 const TopoDS_Shape & BOP_ArgumentAnalyzer::GetShape1() const
 113 {
 114   return myShape1;
 115 }
 116
 117 // ================================================================================
 118 // function: GetShape2
 119 // purpose:
 120 // ================================================================================
 121 const TopoDS_Shape & BOP_ArgumentAnalyzer::GetShape2() const
 122 {
 123   return myShape2;
 124 }
 125
 126 // ================================================================================
 127 // function: OperationType
 128 // purpose:
 129 // ================================================================================
 130 BOP_Operation& BOP_ArgumentAnalyzer::OperationType()
 131 {
 132   return myOperation;
 133 }
 134
 135 // ================================================================================
 136 // function: StopOnFirstFaulty
 137 // purpose:
 138 // ================================================================================
 139 Standard_Boolean & BOP_ArgumentAnalyzer::StopOnFirstFaulty()
 140 {
 141   return myStopOnFirst;
 142 }
 143
 144 // ================================================================================
 145 // function: Perform
 146 // purpose:
 147 // ================================================================================
 148 void BOP_ArgumentAnalyzer::Perform()
 149 {
 150   try {
 151     OCC_CATCH_SIGNALS
 152     myResult.Clear();
 153
 154     if(myArgumentTypeMode) {
 155       TestTypes();
 156     }
 157
 158     if(mySelfInterMode) {
 159       TestSelfInterferences();
 160     }
 161
 162     if(mySmallEdgeMode) {
 163       if(!(!myResult.IsEmpty() && myStopOnFirst))
 164         TestSmallEdge();
 165     }
 166
 167     if(myRebuildFaceMode) {
 168       if(!(!myResult.IsEmpty() && myStopOnFirst))
 169         TestRebuildFace();
 170     }
 171
 172     if(myTangentMode) {
 173       if(!(!myResult.IsEmpty() && myStopOnFirst))
 174         TestTangent();
 175     }
 176
 177     if(myMergeVertexMode) {
 178       if(!(!myResult.IsEmpty() && myStopOnFirst))
 179         TestMergeVertex();
 180     }
 181
 182     if(myMergeEdgeMode) {
 183       if(!(!myResult.IsEmpty() && myStopOnFirst))
 184         TestMergeEdge();
 185     }
 186
 187 //     if(myMergeFaceMode) {
 188 //       TestMergeFace();
 189 //     }
 190   }
 191   catch(Standard_Failure) {
 192     BOP_CheckResult aResult;
 193     aResult.SetCheckStatus(BOP_CheckUnknown);
 194     myResult.Append(aResult);
 195   }
 196 }
 197
 198 // ================================================================================
 199 // function: HasFaulty
 200 // purpose:
 201 // ================================================================================
 202 Standard_Boolean BOP_ArgumentAnalyzer::HasFaulty() const
 203 {
 204   return ( !myResult.IsEmpty());
 205 }
 206
 207 // ================================================================================
 208 // function: GetCheckResult
 209 // purpose:
 210 // ================================================================================
 211 const BOP_ListOfCheckResult& BOP_ArgumentAnalyzer::GetCheckResult() const
 212 {
 213   return myResult;
 214 }
 215
 216 // ================================================================================
 217 // function: TestTypes
 218 // purpose:
 219 // ================================================================================
 220 void BOP_ArgumentAnalyzer::TestTypes()
 221 {
 222   Standard_Boolean isS1 = myShape1.IsNull(), isS2 = myShape2.IsNull();
 223
 224   if(isS1 && isS2) {
 225     BOP_CheckResult aResult;
 226     aResult.SetCheckStatus(BOP_BadType);
 227     myResult.Append(aResult);
 228     return;
 229   }
 230
 231   Standard_Boolean testS1 = TestShapeType(myShape1);
 232   Standard_Boolean testS2 = TestShapeType(myShape2);
 233
 234   // single shape check (begin)
 235   if((isS1 && !isS2) || (!isS1 && isS2)) {
 236 //     Standard_Boolean testS = (isS1) ? testS1 : testS2;
 237     Standard_Boolean testS = (isS1) ? testS2 : testS1;
 238
 239     if(!testS) {
 240       const TopoDS_Shape & aS = (isS1) ? myShape1 : myShape2;
 241       BOP_CheckResult aResult;
 242       aResult.SetShape1(aS);
 243       aResult.SetCheckStatus(BOP_BadType);
 244       myResult.Append(aResult);
 245       return;
 246     }
 247
 248   } // single shape is set (end)
 249   // two shapes check (begin)
 250   else {
 251     // test compounds and compsolids
 252     if(!testS1 || !testS2) {
 253       BOP_CheckResult aResult;
 254       if(!testS1 && !testS2) {
 255         aResult.SetShape1(myShape1);
 256         aResult.SetShape2(myShape2);
 257       }
 258       else {
 259         const TopoDS_Shape & aS = (!testS1) ? myShape1 : myShape2;
 260         if(!testS1)
 261           aResult.SetShape1(aS);
 262         else
 263           aResult.SetShape2(aS);
 264       }
 265       aResult.SetCheckStatus(BOP_BadType);
 266       myResult.Append(aResult);
 267       return;
 268     }
 269     // test faces, wires, edges
 270     TopAbs_ShapeEnum aT1 = myShape1.ShapeType(), aT2 = myShape2.ShapeType();
 271
 272     if(aT1 != TopAbs_COMPOUND && aT2 != TopAbs_COMPOUND) {
 273       Standard_Boolean aTestRes = TestSubShapeType(aT1,aT2,myOperation);
 274       if(!aTestRes) {
 275         BOP_CheckResult aResult;
 276         aResult.SetShape1(myShape1);
 277         aResult.SetShape2(myShape2);
 278         aResult.SetCheckStatus(BOP_BadType);
 279         myResult.Append(aResult);
 280         return;
 281       }
 282     }
 283     else {
 284       Standard_Boolean aTestRes = Standard_True;
 285       if(aT1 == TopAbs_COMPOUND && aT2 != TopAbs_COMPOUND) {
 286         TopoDS_Iterator itS1(myShape1);
 287         while(itS1.More()) {
 288           aT1 = itS1.Value().ShapeType();
 289           aTestRes = TestSubShapeType(aT1,aT2,myOperation);
 290           if(!aTestRes)
 291             break;
 292           itS1.Next();
 293         }
 294       }
 295       else if(aT1 != TopAbs_COMPOUND && aT2 == TopAbs_COMPOUND) {
 296         TopoDS_Iterator itS2(myShape2);
 297         while(itS2.More()) {
 298           aT2 = itS2.Value().ShapeType();
 299           aTestRes = TestSubShapeType(aT1,aT2,myOperation);
 300           if(!aTestRes)
 301             break;
 302           itS2.Next();
 303         }
 304       }
 305       else {
 306         TopoDS_Iterator itS1(myShape1);
 307         while(itS1.More()) {
 308           aT1 = itS1.Value().ShapeType();
 309           TopoDS_Iterator itS2(myShape2);
 310           while(itS2.More()) {
 311             aT2 = itS2.Value().ShapeType();
 312             aTestRes = TestSubShapeType(aT1,aT2,myOperation);
 313             if(!aTestRes)
 314               break;
 315             itS2.Next();
 316           }
 317           if(!aTestRes)
 318             break;
 319           itS1.Next();
 320         }
 321       }
 322
 323       if(!aTestRes) {
 324         BOP_CheckResult aResult;
 325         aResult.SetShape1(myShape1);
 326         aResult.SetShape2(myShape2);
 327         aResult.SetCheckStatus(BOP_BadType);
 328         myResult.Append(aResult);
 329         return;
 330       }
 331     }
 332   } // both shapes are set (end)
 333 }
 334
 335 // ================================================================================
 336 // function: TestSelfInterferences
 337 // purpose:
 338 // ================================================================================
 339 void BOP_ArgumentAnalyzer::TestSelfInterferences()
 340 {
 341   Standard_Integer i = 0;
 342
 343   for(i = 0; i < 2; i++) {
 344     TopoDS_Shape aS = (i == 0) ? myShape1 : myShape2;
 345
 346     if(aS.IsNull())
 347       continue;
 348     BOPTools_Checker aChecker(aS);
 349     aChecker.Perform();
 350
 351     if (aChecker.HasFaulty()) {
 352       const BOPTools_ListOfCheckResults& aResultList = aChecker.GetCheckResult();
 353       BOPTools_ListIteratorOfListOfCheckResults anIt(aResultList);
 354
 355       for(; anIt.More(); anIt.Next()) {
 356         const BOPTools_CheckResult& aCheckResult = anIt.Value();
 357
 358         if((aCheckResult.GetCheckStatus() == BOPTools_CHKUNKNOWN) ||
 359            (aCheckResult.GetCheckStatus() == BOPTools_BADSHRANKRANGE) ||
 360            (aCheckResult.GetCheckStatus() == BOPTools_NULLSRANKRANGE)) {
 361           continue;
 362         }
 363         BOP_CheckResult aResult;
 364         if(i == 0)
 365           aResult.SetShape1(myShape1);
 366         else
 367           aResult.SetShape2(myShape2);
 368         TopTools_ListIteratorOfListOfShape anIt2(aCheckResult.GetShapes());
 369
 370         for(; anIt2.More(); anIt2.Next()) {
 371           if(i == 0)
 372             aResult.AddFaultyShape1(anIt2.Value());
 373           else
 374             aResult.AddFaultyShape2(anIt2.Value());
 375         }
 376         aResult.SetCheckStatus(BOP_SelfIntersect);
 377         myResult.Append(aResult);
 378
 379         if(myStopOnFirst) {
 380           return;
 381         }
 382       }
 383     }
 384   }
 385 }
 386
 387 // ================================================================================
 388 // function: TestSmallEdge
 389 // purpose:
 390 // ================================================================================
 391 void BOP_ArgumentAnalyzer::TestSmallEdge()
 392 {
 393   Standard_Integer i = 0;
 394   BRepExtrema_DistShapeShape aDist;
 395
 396   for(i = 0; i < 2; i++) {
 397     TopoDS_Shape aS = (i == 0) ? myShape1 : myShape2;
 398
 399     if(aS.IsNull())
 400       continue;
 401
 402     TopExp_Explorer anExp(aS, TopAbs_EDGE);
 403
 404     for(; anExp.More(); anExp.Next()) {
 405       TopoDS_Edge anEdge = TopoDS::Edge(anExp.Current());
 406
 407       if(!CheckEdge(anEdge)) {
 408         Standard_Boolean bKeepResult = Standard_True;
 409
 410         if(myOperation == BOP_SECTION) {
 411           TopoDS_Shape anOtherS = (i == 0) ? myShape2 : myShape1;
 412
 413           if(!anOtherS.IsNull()) {
 414 //          BRepExtrema_DistShapeShape aDist;
 415             aDist.LoadS2(anOtherS);
 416
 417             Standard_Boolean bVertexIsOnShape = Standard_False;
 418             Standard_Integer ii = 0;
 419             TopExp_Explorer anExpV(anEdge, TopAbs_VERTEX);
 420
 421             for(; anExpV.More(); anExpV.Next()) {
 422               TopoDS_Shape aV = anExpV.Current();
 423
 424               aDist.LoadS1(aV);
 425               aDist.Perform();
 426
 427               if(aDist.IsDone()) {
 428
 429                 for(ii = 1; ii <= aDist.NbSolution(); ii++) {
 430                   Standard_Real aTolerance = BRep_Tool::Tolerance(TopoDS::Vertex(aV));
 431                   TopoDS_Shape aSupportShape = aDist.SupportOnShape2(ii);
 432
 433                   switch(aSupportShape.ShapeType()) {
 434                   case TopAbs_VERTEX: {
 435                     aTolerance += BRep_Tool::Tolerance(TopoDS::Vertex(aSupportShape));
 436                     break;
 437                   }
 438                   case TopAbs_EDGE: {
 439                     aTolerance += BRep_Tool::Tolerance(TopoDS::Edge(aSupportShape));
 440                     break;
 441                   }
 442                   case TopAbs_FACE: {
 443                     aTolerance += BRep_Tool::Tolerance(TopoDS::Face(aSupportShape));
 444                     break;
 445                   }
 446                   default:
 447                     break;
 448                   }
 449
 450                   if(aDist.Value() < aTolerance) {
 451                     bVertexIsOnShape = Standard_True;
 452                     break;
 453                   }
 454                 }
 455               }
 456             }
 457
 458             if(!bVertexIsOnShape) {
 459               bKeepResult = Standard_False;
 460             }
 461           }
 462         }
 463
 464         if(bKeepResult) {
 465           BOP_CheckResult aResult;
 466
 467           if(i == 0) {
 468             aResult.SetShape1(myShape1);
 469             aResult.AddFaultyShape1(anEdge);
 470           }
 471           else {
 472             aResult.SetShape2(myShape2);
 473             aResult.AddFaultyShape2(anEdge);
 474           }
 475
 476           aResult.SetCheckStatus(BOP_TooSmallEdge);
 477           myResult.Append(aResult);
 478
 479           if(myStopOnFirst) {
 480             return;
 481           }
 482         }
 483       }
 484     }
 485   }
 486 }
 487
 488 // ================================================================================
 489 // function: TestRebuildFace
 490 // purpose:
 491 // ================================================================================
 492 void BOP_ArgumentAnalyzer::TestRebuildFace()
 493 {
 494   if((myOperation == BOP_SECTION) ||
 495      (myOperation == BOP_UNKNOWN))
 496     return;
 497   Standard_Integer i = 0;
 498
 499   for(i = 0; i < 2; i++) {
 500     TopoDS_Shape aS = (i == 0) ? myShape1 : myShape2;
 501
 502     if(aS.IsNull())
 503       continue;
 504
 505     TopExp_Explorer anExp(aS, TopAbs_FACE);
 506
 507     for(; anExp.More(); anExp.Next()) {
 508       TopoDS_Face aFace = TopoDS::Face(anExp.Current());
 509
 510       BOP_WireEdgeSet aWES (aFace);
 511       TopExp_Explorer anExpE(aFace, TopAbs_EDGE);
 512       Standard_Integer nbstartedges = 0;
 513
 514       for(; anExpE.More(); anExpE.Next()) {
 515         aWES.AddStartElement(anExpE.Current());
 516         nbstartedges++;
 517       }
 518       BOP_FaceBuilder aFB;
 519       aFB.Do(aWES);
 520       const TopTools_ListOfShape& aLF = aFB.NewFaces();
 521       Standard_Boolean bBadFace = Standard_False;
 522
 523       if(aLF.Extent() != 1) {
 524         bBadFace = Standard_True;
 525       }
 526       else {
 527         Standard_Integer nbedgeused = 0;
 528         anExpE.Init(aLF.First(), TopAbs_EDGE);
 529
 530         for(; anExpE.More(); anExpE.Next(), nbedgeused++);
 531
 532         if(nbstartedges != nbedgeused) {
 533           bBadFace = Standard_True;
 534         }
 535       }
 536
 537       if(bBadFace) {
 538         BOP_CheckResult aResult;
 539
 540         if(i == 0) {
 541           aResult.SetShape1(myShape1);
 542           aResult.AddFaultyShape1(aFace);
 543         }
 544         else {
 545           aResult.SetShape2(myShape2);
 546           aResult.AddFaultyShape2(aFace);
 547         }
 548
 549         aResult.SetCheckStatus(BOP_NonRecoverableFace);
 550         myResult.Append(aResult);
 551
 552         if(myStopOnFirst) {
 553           return;
 554         }
 555       }
 556     }
 557   }
 558 }
 559
 560 // ================================================================================
 561 // function: TestTangent
 562 // purpose:
 563 // ================================================================================
 564 void BOP_ArgumentAnalyzer::TestTangent()
 565 {
 566  // not implemented
 567 }
 568
 569 // ================================================================================
 570 // function: TestMergeSubShapes
 571 // purpose:
 572 // ================================================================================
 573  void BOP_ArgumentAnalyzer::TestMergeSubShapes(const TopAbs_ShapeEnum theType)
 574 {
 575   if(myShape1.IsNull() || myShape2.IsNull())
 576     return;
 577
 578   BOP_CheckStatus aStatus = BOP_CheckUnknown;
 579
 580   switch(theType) {
 581   case TopAbs_VERTEX: {
 582     aStatus = BOP_IncompatibilityOfVertex;
 583     break;
 584   }
 585   case TopAbs_EDGE: {
 586     aStatus = BOP_IncompatibilityOfEdge;
 587     break;
 588   }
 589   case TopAbs_FACE: {
 590     aStatus = BOP_IncompatibilityOfFace;
 591     break;
 592   }
 593   default:
 594     return;
 595   }
 596   TopExp_Explorer anExp1(myShape1, theType);
 597   TopExp_Explorer anExp2(myShape2, theType);
 598   TopTools_SequenceOfShape aSeq1, aSeq2;
 599   TopTools_MapOfShape aMap1, aMap2;
 600
 601   for(; anExp1.More(); anExp1.Next()) {
 602     TopoDS_Shape aS1 = anExp1.Current();
 603
 604     if(aMap1.Contains(aS1))
 605       continue;
 606     aSeq1.Append(aS1);
 607     aMap1.Add(aS1);
 608   }
 609
 610   for(; anExp2.More(); anExp2.Next()) {
 611     TopoDS_Shape aS2 = anExp2.Current();
 612     if(aMap2.Contains(aS2))
 613       continue;
 614     aSeq2.Append(aS2);
 615     aMap2.Add(aS2);
 616   }
 617
 618   TColStd_Array2OfBoolean anArrayOfFlag(1, aSeq1.Length(), 1, aSeq2.Length());
 619   Standard_Integer i = 0, j = 0;
 620   for(i = 1; i <= aSeq1.Length(); i++)
 621     for(j = 1; j <= aSeq2.Length(); j++)
 622       anArrayOfFlag.SetValue(i, j, Standard_False);
 623
 624   for(i = 1; i <= aSeq1.Length(); i++) {
 625     TopoDS_Shape aS1 = aSeq1.Value(i);
 626     TopTools_ListOfShape aListOfS2;
 627     Standard_Integer nbs = 0;
 628
 629     for(j = 1; j <= aSeq2.Length(); j++) {
 630       TopoDS_Shape aS2 = aSeq2.Value(j);
 631       Standard_Boolean bIsEqual = Standard_False;
 632
 633       if(theType == TopAbs_VERTEX) {
 634
 635         TopoDS_Vertex aV1 = TopoDS::Vertex(aS1);
 636         TopoDS_Vertex aV2 = TopoDS::Vertex(aS2);
 637         gp_Pnt aP1 = BRep_Tool::Pnt(aV1);
 638         gp_Pnt aP2 = BRep_Tool::Pnt(aV2);
 639         Standard_Real aDist = aP1.Distance(aP2);
 640
 641         if(aDist <= (BRep_Tool::Tolerance(aV1) + BRep_Tool::Tolerance(aV2))) {
 642           bIsEqual = Standard_True;
 643         }
 644       }
 645       else if(theType == TopAbs_EDGE) {
 646         Standard_Integer aDiscretize = 30;
 647         Standard_Real    aDeflection = 0.01;
 648         TopoDS_Edge aE1 = TopoDS::Edge(aS1);
 649         TopoDS_Edge aE2 = TopoDS::Edge(aS2);
 650
 651         IntTools_EdgeEdge aEE;
 652         aEE.SetEdge1 (aE1);
 653         aEE.SetEdge2 (aE2);
 654         aEE.SetTolerance1 (BRep_Tool::Tolerance(aE1));
 655         aEE.SetTolerance2 (BRep_Tool::Tolerance(aE2));
 656         aEE.SetDiscretize (aDiscretize);
 657         aEE.SetDeflection (aDeflection);
 658
 659         Standard_Real f = 0., l = 0.;
 660         BRep_Tool::Range(aE1, f, l);
 661         aEE.SetRange1(f, l);
 662
 663         BRep_Tool::Range(aE2, f, l);
 664         aEE.SetRange2(f, l);
 665
 666         aEE.Perform();
 667
 668         if (aEE.IsDone()) {
 669           const IntTools_SequenceOfCommonPrts& aCPrts = aEE.CommonParts();
 670           Standard_Integer ii = 0;
 671
 672           for (ii = 1; ii <= aCPrts.Length(); ii++) {
 673             const IntTools_CommonPrt& aCPart = aCPrts(ii);
 674
 675             if (aCPart.Type() == TopAbs_EDGE) {
 676               bIsEqual = Standard_True;
 677             }
 678           }
 679         }
 680       }
 681       else if(theType == TopAbs_FACE) {
 682         // not yet implemented!
 683       }
 684
 685       if(bIsEqual) {
 686         anArrayOfFlag.SetValue(i, j, Standard_True );
 687         aListOfS2.Append(aS2);
 688         nbs++;
 689       }
 690     }
 691
 692     if(nbs > 1) {
 693       BOP_CheckResult aResult;
 694
 695       aResult.SetShape1(myShape1);
 696       aResult.SetShape2(myShape2);
 697       aResult.AddFaultyShape1(aS1);
 698       TopTools_ListIteratorOfListOfShape anIt(aListOfS2);
 699
 700       for(; anIt.More(); anIt.Next()) {
 701         aResult.AddFaultyShape2(anIt.Value());
 702       }
 703
 704       aResult.SetCheckStatus(aStatus);
 705       myResult.Append(aResult);
 706
 707       if(myStopOnFirst) {
 708         return;
 709       }
 710     }
 711   }
 712
 713   for(i = 1; i <= aSeq2.Length(); i++) {
 714     TopoDS_Shape aS2 = aSeq2.Value(i);
 715     TopTools_ListOfShape aListOfS1;
 716     Standard_Integer nbs = 0;
 717
 718     for(j = 1; j <= aSeq1.Length(); j++) {
 719       TopoDS_Shape aS1 = aSeq1.Value(j);
 720
 721       if(anArrayOfFlag.Value(j, i)) {
 722         aListOfS1.Append(aS1);
 723         nbs++;
 724       }
 725     }
 726
 727     if(nbs > 1) {
 728       BOP_CheckResult aResult;
 729
 730       aResult.SetShape1(myShape1);
 731       aResult.SetShape2(myShape2);
 732       TopTools_ListIteratorOfListOfShape anIt(aListOfS1);
 733
 734       for(; anIt.More(); anIt.Next()) {
 735         aResult.AddFaultyShape1(anIt.Value());
 736       }
 737       aResult.AddFaultyShape2(aS2);
 738
 739       aResult.SetCheckStatus(aStatus);
 740       myResult.Append(aResult);
 741
 742       if(myStopOnFirst) {
 743         return;
 744       }
 745     }
 746   }
 747 }
 748
 749 // ================================================================================
 750 // function: TestMergeVertex
 751 // purpose:
 752 // ================================================================================
 753 void BOP_ArgumentAnalyzer::TestMergeVertex()
 754 {
 755   TestMergeSubShapes(TopAbs_VERTEX);
 756 }
 757
 758 // ================================================================================
 759 // function: TestMergeEdge
 760 // purpose:
 761 // ================================================================================
 762 void BOP_ArgumentAnalyzer::TestMergeEdge()
 763 {
 764   TestMergeSubShapes(TopAbs_EDGE);
 765 }
 766
 767 // ================================================================================
 768 // function: TestMergeFace
 769 // purpose:
 770 // ================================================================================
 771 // void BOP_ArgumentAnalyzer::TestMergeFace()
 772 // {
 773   // not implemented
 774 // }
 775
 776 // ----------------------------------------------------------------------
 777 // static function: TestShapeType
 778 // purpose:
 779 // ----------------------------------------------------------------------
 780 Standard_Boolean TestShapeType(const TopoDS_Shape & TheShape)
 781 {
 782   if(TheShape.IsNull())
 783     return Standard_False;
 784
 785   TopAbs_ShapeEnum aT = TheShape.ShapeType();
 786
 787   if(aT == TopAbs_COMPOUND && BOPTools_Tools3D::IsEmptyShape(TheShape))
 788     return Standard_False;
 789
 790   TopoDS_Iterator anIt;
 791   TopoDS_Shape aSTmp, aShape;
 792   Standard_Integer aNbShapes, TreatRes = 0;
 793
 794   if(aT==TopAbs_COMPOUND || aT==TopAbs_COMPSOLID) {
 795     aNbShapes=0;
 796     anIt.Initialize(TheShape);
 797     for (; anIt.More(); anIt.Next()) {
 798       if(!aNbShapes) {
 799         aSTmp=anIt.Value();
 800       }
 801       aNbShapes++;
 802       if(aNbShapes>1) {
 803         break;
 804       }
 805     }
 806     if(aT == TopAbs_COMPOUND) {
 807       if (aNbShapes==1) {
 808         TreatRes = BOPTools_DSFiller::TreatCompound(TheShape, aSTmp);
 809         if(TreatRes != 0)
 810           return Standard_False;
 811         aShape=aSTmp;
 812         aT = aShape.ShapeType();
 813       }
 814       else if (aNbShapes>1) {
 815         TreatRes = BOPTools_DSFiller::TreatCompound(TheShape, aSTmp);
 816         if(TreatRes != 0)
 817           return Standard_False;
 818         aShape=aSTmp;
 819         aT=aShape.ShapeType();
 820       }
 821     }
 822   }
 823
 824   if(aT==TopAbs_COMPOUND || aT==TopAbs_COMPSOLID) {
 825     return Standard_False;
 826   }
 827
 828   return Standard_True;
 829 }
 830
 831 // ----------------------------------------------------------------------
 832 // static function: CheckEdge
 833 // purpose:
 834 // ----------------------------------------------------------------------
 835 Standard_Boolean CheckEdge(const TopoDS_Edge& theEdge)
 836 {
 837   Handle(IntTools_Context) aContext;
 838   TopoDS_Vertex aV1, aV2;
 839   //
 840   //modified by NIZNHY-PKV Tue Jan 31 15:07:13 2012f
 841   aContext=new IntTools_Context;
 842   ////modified by NIZNHY-PKV Tue Jan 31 15:07:16 2012t
 843   TopExp::Vertices(theEdge, aV1, aV2);
 844
 845
 846   if(aV1.IsNull() || aV2.IsNull() || BRep_Tool::Degenerated(theEdge))
 847     return Standard_True;
 848   Standard_Real aFirst = 0., aLast = 0.;
 849   BRep_Tool::Range(theEdge, aFirst, aLast);
 850   IntTools_Range aRange(aFirst, aLast);
 851   IntTools_ShrunkRange aSR(theEdge, aV1, aV2, aRange, aContext);
 852
 853   if (!aSR.IsDone() || aSR.ErrorStatus() == 6) {
 854     return Standard_False;
 855   }
 856   return Standard_True;
 857 }
 858
 859 // ----------------------------------------------------------------------
 860 // static function: TestSubShapeType
 861 // purpose:
 862 // ----------------------------------------------------------------------
 863 Standard_Boolean TestSubShapeType(const TopAbs_ShapeEnum theT1,
 864                                   const TopAbs_ShapeEnum theT2,
 865                                   const BOP_Operation    theOP)
 866 {
 867   TopAbs_ShapeEnum aT1 = theT1, aT2 = theT2;
 868
 869   if(aT1==TopAbs_FACE) {
 870     if(aT2==TopAbs_SOLID || aT2==TopAbs_SHELL || aT2==TopAbs_FACE ||
 871        aT2==TopAbs_WIRE || aT2==TopAbs_EDGE) {
 872       aT1=TopAbs_SHELL;
 873     }
 874   }
 875   if(aT2==TopAbs_FACE) {
 876     if(aT1==TopAbs_SOLID || aT1==TopAbs_SHELL ||
 877        aT1==TopAbs_WIRE || aT1==TopAbs_EDGE) {
 878       aT2=TopAbs_SHELL;
 879     }
 880   }
 881   if(aT1==TopAbs_EDGE) {
 882     if(aT2==TopAbs_SOLID || aT2==TopAbs_SHELL ||
 883        aT2==TopAbs_WIRE || aT2==TopAbs_EDGE) {
 884       aT1=TopAbs_WIRE;
 885     }
 886   }
 887   if(aT2==TopAbs_EDGE) {
 888     if(aT1==TopAbs_SOLID || aT1==TopAbs_SHELL || aT1==TopAbs_WIRE) {
 889       aT2=TopAbs_WIRE;
 890     }
 891   }
 892
 893   // test operations
 894   if(theOP!=BOP_UNKNOWN) {
 895     Standard_Boolean opOk;
 896     if(aT1==TopAbs_SHELL && aT2==TopAbs_SHELL)
 897       opOk = Standard_True;
 898     else if(aT1==TopAbs_SOLID && aT2==TopAbs_SOLID)
 899       opOk = Standard_True;
 900     else if((aT1==TopAbs_SOLID && aT2==TopAbs_SHELL) ||
 901             (aT2==TopAbs_SOLID && aT1==TopAbs_SHELL))
 902       opOk = Standard_True;
 903     else if(aT1==TopAbs_WIRE && aT2==TopAbs_WIRE)
 904       opOk = Standard_True;
 905     else if((aT1==TopAbs_WIRE  && aT2==TopAbs_SHELL) ||
 906             (aT2==TopAbs_WIRE  && aT1==TopAbs_SHELL))
 907       opOk = Standard_True;
 908     else if((aT1==TopAbs_WIRE  && aT2==TopAbs_SOLID) ||
 909             (aT2==TopAbs_WIRE  && aT1==TopAbs_SOLID))
 910       opOk = Standard_True;
 911     else
 912       opOk = Standard_False;
 913
 914     if(!opOk) {
 915       return Standard_False;
 916     }
 917
 918     if((aT1==TopAbs_SHELL && aT2==TopAbs_SOLID) ||
 919        (aT2==TopAbs_SHELL && aT1==TopAbs_SOLID)) {
 920       if(!BOP_ShellSolid::CheckArgTypes(aT1,aT2,theOP)) {
 921         return Standard_False;
 922       }
 923     }
 924     if((aT1==TopAbs_WIRE && aT2==TopAbs_SOLID) ||
 925        (aT2==TopAbs_WIRE && aT1==TopAbs_SOLID)) {
 926       if(!BOP_WireSolid::CheckArgTypes(aT1,aT2,theOP)) {
 927         return Standard_False;
 928       }
 929     }
 930     if((aT1==TopAbs_WIRE && aT2==TopAbs_SHELL) ||
 931        (aT1==TopAbs_WIRE && aT2==TopAbs_SHELL)) {
 932       if(!BOP_WireShell::CheckArgTypes(aT1,aT2,theOP)) {
 933         return Standard_False;
 934       }
 935     }
 936   }
 937
 938   return Standard_True;
 939 }