src/GEOMImpl/GEOMImpl_HealingDriver.cxx

   1 // Copyright (C) 2007-2014  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 #include <Standard_Stream.hxx>
  24
  25 #include <GEOMImpl_HealingDriver.hxx>
  26 #include <GEOMImpl_Types.hxx>
  27 #include <GEOMImpl_IHealing.hxx>
  28 #include <GEOM_Function.hxx>
  29
  30 #include <GEOMImpl_GlueDriver.hxx>
  31 #include <GEOMImpl_ShapeDriver.hxx>
  32
  33 #include <GEOMUtils.hxx>
  34 #include <GEOMAlgo_RemoverWebs.hxx>
  35
  36 #include <ShHealOper_ShapeProcess.hxx>
  37 #include <ShHealOper_RemoveFace.hxx>
  38 #include <ShHealOper_CloseContour.hxx>
  39 #include <ShHealOper_RemoveInternalWires.hxx>
  40 #include <ShHealOper_FillHoles.hxx>
  41 #include <ShHealOper_Sewing.hxx>
  42 #include <ShHealOper_EdgeDivide.hxx>
  43 #include <ShHealOper_ChangeOrientation.hxx>
  44
  45 #include <TNaming_CopyShape.hxx>
  46
  47 #include <ShapeFix_ShapeTolerance.hxx>
  48 #include <ShapeFix_Shape.hxx>
  49
  50 #include <BRep_Builder.hxx>
  51 #include <BRepAdaptor_Curve.hxx>
  52 #include <BRepCheck_Analyzer.hxx>
  53 #include <BRepTools_WireExplorer.hxx>
  54
  55 #include <TopExp.hxx>
  56 #include <TopExp_Explorer.hxx>
  57 #include <TopoDS.hxx>
  58 #include <TopoDS_Iterator.hxx>
  59 #include <TopTools_IndexedMapOfShape.hxx>
  60 #include <TopTools_ListOfShape.hxx>
  61 #include <TopTools_ListIteratorOfListOfShape.hxx>
  62
  63 #include <TColStd_IndexedDataMapOfTransientTransient.hxx>
  64
  65 #include <Precision.hxx>
  66
  67 #include <StdFail_NotDone.hxx>
  68 #include <Standard_NullObject.hxx>
  69
  70 //=======================================================================
  71 //function :  raiseNotDoneExeption
  72 //purpose  :  global function: forms error message and raises exeption
  73 //=======================================================================
  74 void raiseNotDoneExeption( const int theErrorStatus )
  75 {
  76   switch ( theErrorStatus )
  77   {
  78   case ShHealOper_NotError:           StdFail_NotDone::Raise( "ShHealOper_NotError_msg" );
  79   case ShHealOper_InvalidParameters:  StdFail_NotDone::Raise( "ShHealOper_InvalidParameters_msg" );
  80   case ShHealOper_ErrorExecution:
  81   default:                            StdFail_NotDone::Raise( "ShHealOper_ErrorExecution_msg" );
  82   }
  83 }
  84
  85 //=======================================================================
  86 //function : GetID
  87 //purpose  :
  88 //=======================================================================
  89 const Standard_GUID& GEOMImpl_HealingDriver::GetID()
  90 {
  91   static Standard_GUID aHealingDriver("FF1BBB61-5D14-4df2-980B-3A668264EA16");
  92   return aHealingDriver;
  93 }
  94
  95 //=======================================================================
  96 //function : GEOMImpl_HealingDriver
  97 //purpose  :
  98 //=======================================================================
  99 GEOMImpl_HealingDriver::GEOMImpl_HealingDriver()
 100 {
 101 }
 102
 103 //=======================================================================
 104 //function : Execute
 105 //purpose  :
 106 //=======================================================================
 107 Standard_Integer GEOMImpl_HealingDriver::Execute(TFunction_Logbook& log) const
 108 {
 109   if (Label().IsNull()) return 0;
 110   Handle(GEOM_Function) aFunction = GEOM_Function::GetFunction(Label());
 111
 112   if (aFunction.IsNull()) return 0;
 113
 114   GEOMImpl_IHealing HI (aFunction);
 115   Standard_Integer aType = aFunction->GetType();
 116   Handle(GEOM_Function) anOriginalFunction = HI.GetOriginal();
 117   if (anOriginalFunction.IsNull()) return 0;
 118   TopoDS_Shape aShape, anOriginalShape = anOriginalFunction->GetValue();
 119   if (anOriginalShape.IsNull()) return 0;
 120
 121   switch (aType)
 122   {
 123   case SHAPE_PROCESS:
 124     ShapeProcess(&HI, anOriginalShape, aShape);
 125     break;
 126   case SUPPRESS_FACES:
 127     SuppressFaces(&HI, anOriginalShape, aShape);
 128     break;
 129   case CLOSE_CONTOUR:
 130     CloseContour(&HI, anOriginalShape, aShape);
 131     break;
 132   case REMOVE_INT_WIRES:
 133     RemoveIntWires(&HI, anOriginalShape, aShape);
 134     break;
 135   case FILL_HOLES:
 136     RemoveHoles(&HI, anOriginalShape, aShape);
 137     break;
 138   case SEWING:
 139     Sew(&HI, anOriginalShape, aShape, false);
 140     break;
 141   case SEWING_NON_MANIFOLD:
 142     Sew(&HI, anOriginalShape, aShape, true);
 143     break;
 144   case REMOVE_INTERNAL_FACES:
 145     RemoveInternalFaces(&HI, anOriginalShape, aShape);
 146     break;
 147   case DIVIDE_EDGE:
 148     AddPointOnEdge(&HI, anOriginalShape, aShape);
 149     break;
 150   case CHANGE_ORIENTATION:
 151     ChangeOrientation(&HI, anOriginalShape, aShape);
 152     break;
 153   case LIMIT_TOLERANCE:
 154     LimitTolerance(&HI, anOriginalShape, aShape);
 155     break;
 156   case FUSE_COLLINEAR_EDGES:
 157     {
 158       Handle(TColStd_HSequenceOfTransient) aVerts = HI.GetShapes();
 159       FuseCollinearEdges(anOriginalShape, aVerts, aShape);
 160     }
 161     break;
 162   default:
 163     return 0;
 164   }
 165
 166   if (aShape.IsNull())
 167     raiseNotDoneExeption( ShHealOper_ErrorExecution );
 168
 169   aFunction->SetValue(aShape);
 170
 171   log.SetTouched(Label());
 172   return 1;
 173 }
 174
 175 //=======================================================================
 176 //function :  ShapeProcess
 177 //purpose  :
 178 //=======================================================================
 179 Standard_Boolean GEOMImpl_HealingDriver::ShapeProcess (GEOMImpl_IHealing* theHI,
 180                                                        const TopoDS_Shape& theOriginalShape,
 181                                                        TopoDS_Shape& theOutShape) const
 182 {
 183   Handle(TColStd_HArray1OfExtendedString) anOperators = theHI->GetOperators();
 184   Handle(TColStd_HArray1OfExtendedString) aParams = theHI->GetParameters();
 185   Handle(TColStd_HArray1OfExtendedString) aValues = theHI->GetValues();
 186
 187   if (anOperators.IsNull() || anOperators->Length() <= 0)
 188     return Standard_False;
 189
 190   Standard_Integer nbParams = 0, nbValues = 0;
 191   if (!aParams.IsNull()) {
 192     nbParams = aParams->Length();
 193   }
 194   if (!aValues.IsNull()) {
 195     nbValues = aValues->Length();
 196   }
 197   if (nbParams != nbValues)
 198     return Standard_False;
 199
 200   ShHealOper_ShapeProcess aHealer;
 201   TColStd_SequenceOfAsciiString anOperatorsAS, aParamsAS, aValuesAS;
 202   int i;
 203   for (i = 1; i <= anOperators->Length(); i++)
 204     anOperatorsAS.Append(TCollection_AsciiString(anOperators->Value(i)));
 205
 206   aHealer.SetOperators(anOperatorsAS);
 207
 208   for (i = 1; i <= nbParams; i++) {
 209     aHealer.SetParameter(TCollection_AsciiString(aParams->Value(i)),
 210                          TCollection_AsciiString(aValues->Value(i)));
 211   }
 212
 213   aHealer.Perform(theOriginalShape, theOutShape);
 214
 215   if (!aHealer.isDone())
 216     raiseNotDoneExeption( ShHealOper_NotError );
 217
 218   return Standard_True;
 219 }
 220
 221 //=======================================================================
 222 //function :  SupressFaces
 223 //purpose  :
 224 //=======================================================================
 225 void SuppressFacesRec (const TopTools_SequenceOfShape& theShapesFaces,
 226                        const TopoDS_Shape&             theOriginalShape,
 227                        TopoDS_Shape&                   theOutShape)
 228 {
 229   if ((theOriginalShape.ShapeType() != TopAbs_COMPOUND &&
 230        theOriginalShape.ShapeType() != TopAbs_COMPSOLID))
 231   {
 232     ShHealOper_RemoveFace aHealer (theOriginalShape);
 233     Standard_Boolean aResult = aHealer.Perform(theShapesFaces);
 234
 235     if (aResult)
 236       theOutShape = aHealer.GetResultShape();
 237     else
 238       raiseNotDoneExeption(aHealer.GetErrorStatus());
 239   }
 240   else
 241   {
 242     BRep_Builder BB;
 243     TopoDS_Compound CC;
 244     BB.MakeCompound(CC);
 245
 246     TopTools_MapOfShape mapShape;
 247     TopoDS_Iterator It (theOriginalShape, Standard_True, Standard_True);
 248
 249     for (; It.More(); It.Next()) {
 250       TopoDS_Shape aShape_i = It.Value();
 251       if (mapShape.Add(aShape_i)) {
 252         // check, if current shape contains at least one of faces to be removed
 253         bool isFound = false;
 254         TopTools_IndexedMapOfShape aShapes_i;
 255         TopExp::MapShapes(aShape_i, aShapes_i);
 256         for (int i = 1; i <= theShapesFaces.Length() && !isFound; i++) {
 257           const TopoDS_Shape& aFace_i = theShapesFaces.Value(i);
 258           if (aShapes_i.Contains(aFace_i)) isFound = true;
 259         }
 260         if (isFound) {
 261           TopoDS_Shape anOutSh_i;
 262           SuppressFacesRec(theShapesFaces, aShape_i, anOutSh_i);
 263           if ( !anOutSh_i.IsNull() )
 264             BB.Add(CC, anOutSh_i);
 265         }
 266         else {
 267           // nothing to do
 268           BB.Add(CC, aShape_i);
 269         }
 270       }
 271     }
 272     theOutShape = CC;
 273   }
 274 }
 275
 276 Standard_Boolean GEOMImpl_HealingDriver::SuppressFaces (GEOMImpl_IHealing* theHI,
 277                                                         const TopoDS_Shape& theOriginalShape,
 278                                                         TopoDS_Shape& theOutShape) const
 279 {
 280   Handle(TColStd_HArray1OfInteger) aFaces = theHI->GetFaces();
 281
 282   Standard_Boolean aResult = Standard_False;
 283
 284   if (aFaces.IsNull()) {
 285     ShHealOper_RemoveFace aHealer (theOriginalShape);
 286     aResult = aHealer.Perform();
 287
 288     if (aResult)
 289       theOutShape = aHealer.GetResultShape();
 290     else
 291       raiseNotDoneExeption(aHealer.GetErrorStatus());
 292   }
 293   else {
 294     TopTools_SequenceOfShape aShapesFaces;
 295     TopTools_IndexedMapOfShape aShapes;
 296     TopExp::MapShapes(theOriginalShape, aShapes);
 297     for (int i = 1; i <= aFaces->Length(); i++) {
 298       int indexOfFace = aFaces->Value(i);
 299       TopoDS_Shape aFace = aShapes.FindKey(indexOfFace);
 300       aShapesFaces.Append(aFace);
 301     }
 302     SuppressFacesRec(aShapesFaces, theOriginalShape, theOutShape);
 303     if ((theOriginalShape.ShapeType() == TopAbs_COMPOUND ||
 304          theOriginalShape.ShapeType() == TopAbs_COMPSOLID)) {
 305       TopoDS_Shape aSh = theOutShape;
 306       theOutShape = GEOMImpl_GlueDriver::GlueFaces(aSh, Precision::Confusion(), Standard_True);
 307     }
 308   }
 309
 310   return Standard_True;
 311 }
 312
 313 //=======================================================================
 314 //function :  CloseContour
 315 //purpose  :
 316 //=======================================================================
 317 Standard_Boolean GEOMImpl_HealingDriver::CloseContour (GEOMImpl_IHealing* theHI,
 318                                                        const TopoDS_Shape& theOriginalShape,
 319                                                        TopoDS_Shape& theOutShape) const
 320 {
 321   Standard_Boolean isByVertex = theHI->GetIsCommonVertex();
 322   Handle(TColStd_HArray1OfInteger) aWires = theHI->GetWires();
 323
 324   ShHealOper_CloseContour aHealer (theOriginalShape);
 325
 326   Standard_Boolean aResult = Standard_False;
 327   if ( aWires.IsNull() ) {
 328     if ( theOriginalShape.ShapeType() == TopAbs_WIRE )
 329       aResult = aHealer.Perform(TopoDS::Wire(theOriginalShape), isByVertex, !isByVertex);
 330   }
 331   else {
 332     TopTools_SequenceOfShape aShapesWires;
 333     TopTools_IndexedMapOfShape aShapes;
 334     TopExp::MapShapes(theOriginalShape, aShapes);
 335     for (int i = 1; i <= aWires->Length(); i++) {
 336       int indexOfWire = aWires->Value(i);
 337       TopoDS_Shape aWire = aShapes.FindKey(indexOfWire);
 338       aShapesWires.Append(aWire);
 339     }
 340
 341     aResult = aHealer.Perform( aShapesWires, isByVertex, !isByVertex );
 342   }
 343
 344   if (aResult)
 345     theOutShape = aHealer.GetResultShape();
 346   else
 347     raiseNotDoneExeption( aHealer.GetErrorStatus() );
 348
 349   return aResult;
 350 }
 351
 352 //=======================================================================
 353 //function :  RemoveIntWires
 354 //purpose  :
 355 //=======================================================================
 356 Standard_Boolean GEOMImpl_HealingDriver::RemoveIntWires (GEOMImpl_IHealing* theHI,
 357                                                          const TopoDS_Shape& theOriginalShape,
 358                                                          TopoDS_Shape& theOutShape) const
 359 {
 360   Handle(TColStd_HArray1OfInteger) aWires = theHI->GetWires();
 361
 362   ShHealOper_RemoveInternalWires aHealer(theOriginalShape);
 363
 364   Standard_Boolean aResult = Standard_False;
 365   if (aWires.IsNull()) { // remove all faces
 366     aResult = aHealer.Remove();
 367   } else {
 368     TopTools_SequenceOfShape aShapesWires;
 369     TopTools_IndexedMapOfShape aShapes;
 370     TopExp::MapShapes(theOriginalShape, aShapes);
 371     for (int i = 1; i <= aWires->Length(); i++) {
 372       int indexOfWire = aWires->Value(i);
 373       TopoDS_Shape aWire = aShapes.FindKey(indexOfWire);
 374       aShapesWires.Append(aWire);
 375     }
 376
 377     aResult = aHealer.Remove(aShapesWires);
 378   }
 379
 380   if (aResult)
 381     theOutShape = aHealer.GetResultShape();
 382   else
 383     raiseNotDoneExeption( aHealer.GetErrorStatus() );
 384
 385   return aResult;
 386 }
 387
 388 //=======================================================================
 389 //function :  RemoveHoles
 390 //purpose  :
 391 //=======================================================================
 392 Standard_Boolean GEOMImpl_HealingDriver::RemoveHoles (GEOMImpl_IHealing* theHI,
 393                                                       const TopoDS_Shape& theOriginalShape,
 394                                                       TopoDS_Shape& theOutShape) const
 395 {
 396   Handle(TColStd_HArray1OfInteger) aWires = theHI->GetWires();
 397
 398   ShHealOper_FillHoles aHealer (theOriginalShape);
 399
 400   Standard_Boolean aResult = Standard_False;
 401   if (aWires.IsNull()) { // remove all faces
 402     aResult = aHealer.Fill();
 403   } else {
 404     TopTools_SequenceOfShape aShapesWires;
 405     TopTools_IndexedMapOfShape aShapes;
 406     TopExp::MapShapes(theOriginalShape, aShapes);
 407     for (int i = 1; i <= aWires->Length(); i++) {
 408       int indexOfWire = aWires->Value(i);
 409       TopoDS_Shape aWire = aShapes.FindKey(indexOfWire);
 410       aShapesWires.Append(aWire);
 411     }
 412
 413     aResult = aHealer.Fill(aShapesWires);
 414   }
 415
 416   if (aResult)
 417     theOutShape = aHealer.GetResultShape();
 418   else
 419     raiseNotDoneExeption( aHealer.GetErrorStatus() );
 420
 421   return aResult;
 422 }
 423
 424 //=======================================================================
 425 //function :  Sew
 426 //purpose  :
 427 //=======================================================================
 428 Standard_Boolean GEOMImpl_HealingDriver::Sew (GEOMImpl_IHealing*  theHI,
 429                                               const TopoDS_Shape& theOriginalShape,
 430                                               TopoDS_Shape&       theOutShape,
 431                                               Standard_Boolean    isAllowNonManifold) const
 432 {
 433   Standard_Real aTol = theHI->GetTolerance();
 434
 435   TopoDS_Compound faceCompound;
 436   BRep_Builder builder;
 437   builder.MakeCompound( faceCompound );
 438
 439   TopExp_Explorer faceExp( theOriginalShape, TopAbs_FACE );
 440   for ( ; faceExp.More(); faceExp.Next() )
 441     builder.Add( faceCompound, faceExp.Current() );
 442
 443   Handle(TColStd_HSequenceOfTransient) otherObjs = theHI->GetShapes();
 444   for ( int ind = 1; ind <= otherObjs->Length(); ind++)
 445   {
 446     Handle(GEOM_Function) aRefShape = Handle(GEOM_Function)::DownCast(otherObjs->Value(ind));
 447     TopoDS_Shape aShape = aRefShape->GetValue();
 448     if (aShape.IsNull())
 449       Standard_NullObject::Raise("Null object given");
 450     for ( faceExp.Init( aShape, TopAbs_FACE ); faceExp.More(); faceExp.Next() )
 451       builder.Add( faceCompound, faceExp.Current() );
 452   }
 453
 454   ShHealOper_Sewing aHealer (faceCompound, aTol);
 455
 456   // Set non-manifold mode.
 457   aHealer.SetNonManifoldMode(isAllowNonManifold);
 458
 459   Standard_Boolean aResult = aHealer.Perform();
 460
 461   if (aResult)
 462     theOutShape = aHealer.GetResultShape();
 463   else
 464     raiseNotDoneExeption( aHealer.GetErrorStatus() );
 465
 466   return aResult;
 467 }
 468
 469 //=======================================================================
 470 //function : RemoveInternalFaces
 471 //purpose  :
 472 //=======================================================================
 473 Standard_Boolean
 474 GEOMImpl_HealingDriver::RemoveInternalFaces (GEOMImpl_IHealing*  theHI,
 475                                              const TopoDS_Shape& theOriginalShape,
 476                                              TopoDS_Shape&       theOutShape) const
 477 {
 478   // get all input shapes
 479   TopTools_SequenceOfShape shapeSeq;
 480   shapeSeq.Append( theOriginalShape );
 481   Handle(TColStd_HSequenceOfTransient) otherObjs = theHI->GetShapes();
 482   if ( !otherObjs.IsNull() )
 483     for ( int ind = 1; ind <= otherObjs->Length(); ind++)
 484     {
 485       Handle(GEOM_Function) aRefShape = Handle(GEOM_Function)::DownCast(otherObjs->Value(ind));
 486       TopoDS_Shape aShape = aRefShape->GetValue();
 487       if (aShape.IsNull())
 488         Standard_NullObject::Raise("Null object given");
 489       shapeSeq.Append( aShape );
 490     }
 491
 492   // pass input shapes to the algorithm
 493   GEOMAlgo_RemoverWebs aTool;
 494   if ( shapeSeq.Length() == 1 )
 495   {
 496     aTool.SetShape( shapeSeq.First() );
 497   }
 498   else
 499   {
 500     TopoDS_Compound solidCompound;
 501     BRep_Builder builder;
 502     builder.MakeCompound( solidCompound );
 503     for ( int ind = 1; ind <= shapeSeq.Length(); ++ind )
 504       for ( TopExp_Explorer so( shapeSeq( ind ), TopAbs_SOLID ); so.More(); so.Next() )
 505         builder.Add( solidCompound, so.Current() );
 506
 507     aTool.SetShape( solidCompound );
 508   }
 509
 510   // run the algorithm
 511   aTool.Perform();
 512
 513   if (aTool.ErrorStatus() == 0) { // OK
 514     theOutShape = aTool.Result();
 515
 516     // as GEOMAlgo_RemoverWebs always produces compound, lets simplify it
 517     // for the case, if it contains only one sub-shape
 518     TopTools_ListOfShape listShapeRes;
 519     GEOMUtils::AddSimpleShapes(theOutShape, listShapeRes);
 520     if (listShapeRes.Extent() == 1) {
 521       theOutShape = listShapeRes.First();
 522     }
 523   }
 524   else if (aTool.ErrorStatus() == 11) // invalid argument (contains non-solids), do nothing
 525     theOutShape = theOriginalShape;
 526   else // error
 527     StdFail_NotDone::Raise("GEOMAlgo_RemoverWebs failed!");
 528
 529   return Standard_True;
 530 }
 531
 532 //=======================================================================
 533 //function :  AddPointOnEdge
 534 //purpose  :
 535 //=======================================================================
 536 Standard_Boolean GEOMImpl_HealingDriver::AddPointOnEdge (GEOMImpl_IHealing* theHI,
 537                                                          const TopoDS_Shape& theOriginalShape,
 538                                                          TopoDS_Shape& theOutShape) const
 539 {
 540   Standard_Boolean isByParameter = theHI->GetIsByParameter();
 541   Standard_Integer anIndex = theHI->GetIndex();
 542   Standard_Real aValue = theHI->GetDevideEdgeValue();
 543
 544   ShHealOper_EdgeDivide aHealer (theOriginalShape);
 545
 546   Standard_Boolean aResult = Standard_False;
 547   if (anIndex == -1) { // apply algorythm for the whole shape which is EDGE
 548     if (theOriginalShape.ShapeType() == TopAbs_EDGE)
 549       aResult = aHealer.Perform(TopoDS::Edge(theOriginalShape), aValue, isByParameter);
 550   } else {
 551     TopTools_IndexedMapOfShape aShapes;
 552     TopExp::MapShapes(theOriginalShape, aShapes);
 553     TopoDS_Shape aEdgeShape = aShapes.FindKey(anIndex);
 554     if (aEdgeShape.ShapeType() == TopAbs_EDGE)
 555       aResult = aHealer.Perform(TopoDS::Edge(aEdgeShape), aValue, isByParameter);
 556   }
 557
 558   if (aResult)
 559     theOutShape = aHealer.GetResultShape();
 560   else
 561     raiseNotDoneExeption( aHealer.GetErrorStatus() );
 562
 563   return aResult;
 564 }
 565
 566
 567 //=======================================================================
 568 //function :  ChangeOrientation
 569 //purpose  :
 570 //=======================================================================
 571 Standard_Boolean GEOMImpl_HealingDriver::ChangeOrientation (GEOMImpl_IHealing* theHI,
 572                                                             const TopoDS_Shape& theOriginalShape,
 573                                                             TopoDS_Shape& theOutShape) const
 574 {
 575   ShHealOper_ChangeOrientation aHealer (theOriginalShape);
 576
 577   Standard_Boolean aResult = aHealer.Perform();
 578
 579   if (aResult)
 580     theOutShape = aHealer.GetResultShape();
 581   else
 582     raiseNotDoneExeption( aHealer.GetErrorStatus() );
 583
 584   return aResult;
 585 }
 586
 587 //=======================================================================
 588 //function : LimitTolerance
 589 //purpose  :
 590 //=======================================================================
 591 void GEOMImpl_HealingDriver::LimitTolerance (GEOMImpl_IHealing* theHI,
 592                                              const TopoDS_Shape& theOriginalShape,
 593                                              TopoDS_Shape& theOutShape) const
 594 {
 595   Standard_Real aTol = theHI->GetTolerance();
 596   if (aTol < Precision::Confusion())
 597     aTol = Precision::Confusion();
 598
 599   // 1. Make a copy to prevent the original shape changes.
 600   TopoDS_Shape aShapeCopy;
 601   TColStd_IndexedDataMapOfTransientTransient aMapTShapes;
 602   TNaming_CopyShape::CopyTool(theOriginalShape, aMapTShapes, aShapeCopy);
 603
 604   // 2. Limit tolerance.
 605   ShapeFix_ShapeTolerance aSFT;
 606   aSFT.LimitTolerance(aShapeCopy, aTol, aTol, TopAbs_SHAPE);
 607
 608   // 3. Fix obtained shape.
 609   Handle(ShapeFix_Shape) aSfs = new ShapeFix_Shape (aShapeCopy);
 610   aSfs->Perform();
 611   theOutShape = aSfs->Shape();
 612
 613   BRepCheck_Analyzer ana (theOutShape, Standard_True);
 614   if (!ana.IsValid())
 615     StdFail_NotDone::Raise("Non valid shape result");
 616 }
 617
 618 //=======================================================================
 619 //function : FuseCollinearEdges
 620 //purpose  :
 621 //=======================================================================
 622 void GEOMImpl_HealingDriver::FuseCollinearEdges (const TopoDS_Shape& theOriginalShape,
 623                                                  const Handle(TColStd_HSequenceOfTransient)& aVerts,
 624                                                  TopoDS_Shape& theOutShape)
 625 {
 626   if (theOriginalShape.ShapeType() != TopAbs_WIRE)
 627     Standard_TypeMismatch::Raise("Not a wire is given");
 628
 629   // Tolerances
 630   Standard_Real AngTol = Precision::Angular();
 631   Standard_Real LinTol = Precision::Confusion();
 632   Standard_Real tol;
 633   for (TopExp_Explorer ExV (theOriginalShape, TopAbs_VERTEX); ExV.More(); ExV.Next()) {
 634     TopoDS_Vertex Vertex = TopoDS::Vertex(ExV.Current());
 635     tol = BRep_Tool::Tolerance(Vertex);
 636     if (tol > LinTol)
 637       LinTol = tol;
 638   }
 639
 640   // 1. Make a copy to prevent the original shape changes.
 641   TopoDS_Shape aWire;
 642   TColStd_IndexedDataMapOfTransientTransient aMapTShapes;
 643   TNaming_CopyShape::CopyTool(theOriginalShape, aMapTShapes, aWire);
 644   TopoDS_Wire theWire = TopoDS::Wire(aWire);
 645
 646   // 2. Sub-shapes of the wire
 647   TopTools_MapOfShape aMapToRemove;
 648
 649   TopTools_IndexedMapOfShape anOldIndices;
 650   TopExp::MapShapes(theOriginalShape, anOldIndices);
 651
 652   TopTools_IndexedMapOfShape aNewIndices;
 653   TopExp::MapShapes(theWire, aNewIndices);
 654
 655   // 3. Collect vertices of the wire, same or equal to the given vertices
 656   bool removeAll = false;
 657   if (aVerts.IsNull() || aVerts->Length() < 1)
 658     removeAll = true;
 659
 660   if (!removeAll) {
 661     for ( int ind = 1; ind <= aVerts->Length(); ind++) {
 662       Handle(GEOM_Function) aRefShape = Handle(GEOM_Function)::DownCast(aVerts->Value(ind));
 663       TopoDS_Shape aShape_i = aRefShape->GetValue();
 664       if (aShape_i.IsNull())
 665         Standard_NullObject::Raise("Null vertex given");
 666       if (aShape_i.ShapeType() != TopAbs_VERTEX)
 667         Standard_TypeMismatch::Raise("Shape to suppress is not a vertex");
 668
 669       // find vertices shared with the initial wire
 670       if (anOldIndices.Contains(aShape_i)) {
 671         aMapToRemove.Add(aNewIndices.FindKey(anOldIndices.FindIndex(aShape_i)));
 672       } else {
 673         // try to find by coords in the new wire
 674         TopoDS_Vertex aVert = TopoDS::Vertex(aShape_i);
 675         gp_Pnt aP = BRep_Tool::Pnt(aVert);
 676
 677         bool isFound = false;
 678         TopTools_MapOfShape mapShape;
 679         TopExp_Explorer exp (theWire, TopAbs_VERTEX);
 680         for (; exp.More() && !isFound; exp.Next()) {
 681           if (mapShape.Add(exp.Current())) {
 682             TopoDS_Vertex aVi = TopoDS::Vertex(exp.Current());
 683             gp_Pnt aPi = BRep_Tool::Pnt(aVi);
 684             if (aPi.Distance(aP) < LinTol) {
 685               aMapToRemove.Add(aVi);
 686               isFound = true;
 687             }
 688           }
 689         }
 690       }
 691     }
 692   }
 693
 694   /*
 695   BRepLib::BuildCurves3d(theWire);
 696   Handle(ShapeFix_Shape) Fixer = new ShapeFix_Shape(theWire);
 697   Fixer->SetPrecision(LinTol);
 698   Fixer->SetMaxTolerance(LinTol);
 699   Fixer->Perform();
 700   theWire = TopoDS::Wire(Fixer->Shape());
 701   */
 702
 703   TopoDS_Edge prevEdge;
 704   TopTools_ListOfShape finalList, currChain;
 705
 706   BRepTools_WireExplorer wexp (theWire);
 707   if (wexp.More()) {
 708     prevEdge = wexp.Current();
 709     currChain.Append(prevEdge);
 710     wexp.Next();
 711   }
 712   else {
 713     Standard_NullObject::Raise("Empty wire given");
 714   }
 715
 716   for (; wexp.More(); wexp.Next()) {
 717     TopoDS_Edge anEdge = wexp.Current();
 718     TopoDS_Vertex CurVertex = wexp.CurrentVertex();
 719
 720     bool continueChain = false;
 721     if (aMapToRemove.Contains(CurVertex) || removeAll) {
 722       // if C1 -> continue chain
 723       if (AreEdgesC1(prevEdge, anEdge)) {
 724         continueChain = true;
 725       }
 726     }
 727
 728     if (!continueChain) {
 729       if (currChain.Extent() == 1) {
 730         // add one edge to the final list
 731         finalList.Append(currChain.First());
 732       }
 733       else {
 734         // make wire from the list of edges
 735         BRep_Builder B;
 736         TopoDS_Wire aCurrWire;
 737         B.MakeWire(aCurrWire);
 738         TopTools_ListIteratorOfListOfShape itEdges (currChain);
 739         for (; itEdges.More(); itEdges.Next()) {
 740           TopoDS_Shape aValue = itEdges.Value();
 741           B.Add(aCurrWire, TopoDS::Edge(aValue));
 742         }
 743
 744         // make edge from the wire
 745         TopoDS_Edge anEdge = GEOMImpl_ShapeDriver::MakeEdgeFromWire(aCurrWire, LinTol, AngTol);
 746
 747         // add this new edge to the final list
 748         finalList.Append(anEdge);
 749       }
 750       currChain.Clear();
 751     }
 752
 753     // add one edge to the chain
 754     currChain.Append(anEdge);
 755     prevEdge = anEdge;
 756   }
 757
 758   if (currChain.Extent() == 1) {
 759     // add one edge to the final list
 760     finalList.Append(currChain.First());
 761   }
 762   else {
 763     // make wire from the list of edges
 764     BRep_Builder B;
 765     TopoDS_Wire aCurrWire;
 766     B.MakeWire(aCurrWire);
 767     TopTools_ListIteratorOfListOfShape itEdges (currChain);
 768     for (; itEdges.More(); itEdges.Next()) {
 769       TopoDS_Shape aValue = itEdges.Value();
 770       B.Add(aCurrWire, TopoDS::Edge(aValue));
 771     }
 772
 773     // make edge from the wire
 774     TopoDS_Edge anEdge = GEOMImpl_ShapeDriver::MakeEdgeFromWire(aCurrWire, LinTol, AngTol);
 775
 776     // add this new edge to the final list
 777     finalList.Append(anEdge);
 778   }
 779
 780   BRep_Builder B;
 781   TopoDS_Wire aFinalWire;
 782   B.MakeWire(aFinalWire);
 783   TopTools_ListIteratorOfListOfShape itEdges (finalList);
 784   for (; itEdges.More(); itEdges.Next()) {
 785     TopoDS_Shape aValue = itEdges.Value();
 786     B.Add(aFinalWire, TopoDS::Edge(aValue));
 787   }
 788   theOutShape = aFinalWire;
 789
 790   BRepCheck_Analyzer ana (theOutShape, Standard_True);
 791   if (!ana.IsValid())
 792     StdFail_NotDone::Raise("Non valid shape result");
 793 }
 794
 795 //=======================================================================
 796 //function : AreEdgesC1
 797 //purpose  :
 798 //=======================================================================
 799 Standard_Boolean GEOMImpl_HealingDriver::AreEdgesC1 (const TopoDS_Edge& E1, const TopoDS_Edge& E2)
 800 {
 801   BRepAdaptor_Curve aCurve1 (E1);
 802   BRepAdaptor_Curve aCurve2 (E2);
 803
 804   if (aCurve1.Continuity() == GeomAbs_C0 || aCurve2.Continuity() == GeomAbs_C0)
 805     return Standard_False;
 806
 807   Standard_Real tol, tolMax = Precision::Confusion();
 808   for (TopExp_Explorer ExV1 (E1, TopAbs_VERTEX); ExV1.More(); ExV1.Next()) {
 809     TopoDS_Vertex Vertex = TopoDS::Vertex(ExV1.Current());
 810     tol = BRep_Tool::Tolerance(Vertex);
 811       if (tol > tolMax)
 812         tolMax = tol;
 813   }
 814   for (TopExp_Explorer ExV2 (E2, TopAbs_VERTEX); ExV2.More(); ExV2.Next()) {
 815     TopoDS_Vertex Vertex = TopoDS::Vertex(ExV2.Current());
 816     tol = BRep_Tool::Tolerance(Vertex);
 817       if (tol > tolMax)
 818         tolMax = tol;
 819   }
 820
 821   Standard_Real f1, l1, f2, l2;
 822   f1 = aCurve1.FirstParameter();
 823   l1 = aCurve1.LastParameter();
 824   f2 = aCurve2.FirstParameter();
 825   l2 = aCurve2.LastParameter();
 826
 827   if (f1 > l1) {
 828     Standard_Real tmp = f1;
 829     f1 = l1;
 830     l1 = tmp;
 831   }
 832
 833   if (f2 > l2) {
 834     Standard_Real tmp = f2;
 835     f2 = l2;
 836     l2 = tmp;
 837   }
 838
 839   gp_Pnt pf1, pl1, pf2, pl2;
 840   gp_Vec vf1, vl1, vf2, vl2;
 841   aCurve1.D1(f1, pf1, vf1);
 842   aCurve1.D1(l1, pl1, vl1);
 843   aCurve2.D1(f2, pf2, vf2);
 844   aCurve2.D1(l2, pl2, vl2);
 845
 846   // pf1--->---pl1.pf2--->---pl2
 847   if (pl1.SquareDistance(pf2) < tolMax*tolMax) {
 848     if (vl1.Angle(vf2) < Precision::Angular())
 849       return Standard_True;
 850   }
 851   // pl1---<---pf1.pf2--->---pl2
 852   else if (pf1.SquareDistance(pf2) < tolMax*tolMax) {
 853     if (vf1.Angle(-vf2) < Precision::Angular())
 854       return Standard_True;
 855   }
 856   // pf1--->---pl1.pl2---<---pf2
 857   else if (pl1.SquareDistance(pl2) < tolMax*tolMax) {
 858     if (vl1.Angle(-vl2) < Precision::Angular())
 859       return Standard_True;
 860   }
 861   // pl1---<---pf1.pl2---<---pf2
 862   else {
 863     if (vf1.Angle(vl2) < Precision::Angular())
 864       return Standard_True;
 865   }
 866
 867   return Standard_False;
 868 }
 869
 870 //================================================================================
 871 /*!
 872  * \brief Returns a name of creation operation and names and values of creation parameters
 873  */
 874 //================================================================================
 875
 876 bool GEOMImpl_HealingDriver::
 877 GetCreationInformation(std::string&             theOperationName,
 878                        std::vector<GEOM_Param>& theParams)
 879 {
 880   if (Label().IsNull()) return 0;
 881   Handle(GEOM_Function) function = GEOM_Function::GetFunction(Label());
 882
 883   GEOMImpl_IHealing aCI( function );
 884   Standard_Integer aType = function->GetType();
 885
 886   switch ( aType ) {
 887   case SHAPE_PROCESS:
 888   {
 889     theOperationName = "SHAPE_PROCESS";
 890     AddParam( theParams, "Object", aCI.GetOriginal() );
 891     Handle(TColStd_HArray1OfExtendedString) anOperators = aCI.GetOperators();
 892     Handle(TColStd_HArray1OfExtendedString) aParams     = aCI.GetParameters();
 893     Handle(TColStd_HArray1OfExtendedString) aValues     = aCI.GetValues();
 894     for ( int i = anOperators->Lower(), nb = anOperators->Upper(); i <= nb; ++i )
 895     {
 896       const TCollection_ExtendedString& op = anOperators->Value(i);
 897       AddParam( theParams, "Operation", op );
 898       for ( int iP = aParams->Lower(), nbP = aParams->Upper(); iP <= nbP; ++iP )
 899       {
 900         const TCollection_ExtendedString& par = aParams->Value(i);
 901         TCollection_AsciiString parAscii( par );
 902         if ( par.Search( op ) == 1 && parAscii.Value( op.Length() + 1 ) == '.' )
 903         {
 904           GEOM_Param& p = AddParam( theParams, parAscii.ToCString() );
 905           if ( iP <= aValues->Upper() )
 906             p << aValues->Value( iP );
 907         }
 908       }
 909     }
 910     break;
 911   }
 912   case SUPPRESS_FACES:
 913     theOperationName = "SUPPRESS_FACES";
 914     AddParam( theParams, "Selected Shape", aCI.GetOriginal() );
 915     AddParam( theParams, "Faces to remove", aCI.GetFaces() );
 916     break;
 917   case CLOSE_CONTOUR:
 918     theOperationName = "CLOSE_CONTOUR";
 919     AddParam( theParams, "Selected Shape", aCI.GetOriginal() );
 920     AddParam( theParams, "Contour to close", aCI.GetWires() );
 921     AddParam( theParams, "Close by common vertex", aCI.GetIsCommonVertex() );
 922     break;
 923   case REMOVE_INT_WIRES:
 924     theOperationName = "SUPPRESS_INT_WIRES";
 925     AddParam( theParams, "Selected face", aCI.GetOriginal() );
 926     AddParam( theParams, "Wires to remove", aCI.GetWires(), "all" );
 927     break;
 928   case FILL_HOLES:
 929     theOperationName = "SUPPERSS_HOLES";
 930     AddParam( theParams, "Selected shape", aCI.GetOriginal() );
 931     AddParam( theParams, "Wires to remove", aCI.GetWires(), "all" );
 932     break;
 933   case SEWING:
 934   case SEWING_NON_MANIFOLD:
 935     theOperationName = "SEWING";
 936     AddParam( theParams, "Selected shapes", aCI.GetOriginalAndShapes() );
 937     AddParam( theParams, "Allow Non Manifold", ( aType == SEWING_NON_MANIFOLD ));
 938     AddParam( theParams, "Tolerance", aCI.GetTolerance() );
 939     break;
 940   case DIVIDE_EDGE:
 941     theOperationName = "POINT_ON_EDGE";
 942     if ( aCI.GetIndex() > 0 )
 943       AddParam( theParams, "Edge", "#" ) << aCI.GetIndex() << " of " << aCI.GetOriginal();
 944     else
 945       AddParam( theParams, "Edge", aCI.GetOriginal() );
 946     AddParam( theParams, "By parameter", aCI.GetIsByParameter() );
 947     AddParam( theParams, "Value", aCI.GetDevideEdgeValue() );
 948     break;
 949   case CHANGE_ORIENTATION:
 950     theOperationName = "CHANGE_ORIENTATION";
 951     AddParam( theParams, "Selected shape", aCI.GetOriginal() );
 952     break;
 953   case LIMIT_TOLERANCE:
 954     theOperationName = "LIMIT_TOLERANCE";
 955     AddParam( theParams, "Selected shape", aCI.GetOriginal() );
 956     AddParam( theParams, "Tolerance", aCI.GetTolerance() );
 957     break;
 958   case FUSE_COLLINEAR_EDGES:
 959     theOperationName = "FUSE_EDGES";
 960     AddParam( theParams, "Wire", aCI.GetOriginal() );
 961     AddParam( theParams, "Vertexes", aCI.GetShapes() );
 962     break;
 963   case REMOVE_INTERNAL_FACES:
 964     theOperationName = "REMOVE_WEBS";
 965     AddParam( theParams, "Selected shapes", aCI.GetOriginalAndShapes() );
 966     break;
 967   default:
 968     return false;
 969   }
 970
 971   return true;
 972 }
 973 IMPLEMENT_STANDARD_HANDLE (GEOMImpl_HealingDriver,GEOM_BaseDriver);
 974
 975 IMPLEMENT_STANDARD_RTTIEXT (GEOMImpl_HealingDriver,GEOM_BaseDriver);