src/GEOMImpl/GEOMImpl_IHealingOperations.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 #ifdef WIN32
  24 #pragma warning( disable:4786 )
  25 #endif
  26
  27 #include <Standard_Version.hxx>
  28 #include <Standard_Stream.hxx>
  29
  30 #include <GEOMImpl_IHealingOperations.hxx>
  31 #include <GEOM_PythonDump.hxx>
  32 #include <GEOMImpl_HealingDriver.hxx>
  33 #include <GEOMImpl_Types.hxx>
  34 #include <GEOMImpl_IHealing.hxx>
  35 #include <GEOMImpl_IVector.hxx>
  36 #include <GEOMImpl_VectorDriver.hxx>
  37 #include <GEOMImpl_CopyDriver.hxx>
  38
  39 #include <Basics_OCCTVersion.hxx>
  40
  41 #include <utilities.h>
  42 #include <OpUtil.hxx>
  43 #include <Utils_ExceptHandlers.hxx>
  44
  45 #include <BRep_Builder.hxx>
  46 #include <ShHealOper_ShapeProcess.hxx>
  47 #include <ShapeAnalysis_FreeBounds.hxx>
  48 #include <TColStd_HArray1OfExtendedString.hxx>
  49 #include <TColStd_HSequenceOfTransient.hxx>
  50 #include <TCollection_AsciiString.hxx>
  51 #include <TDF_Tool.hxx>
  52 #include <TopExp_Explorer.hxx>
  53 #include <TopTools_SequenceOfShape.hxx>
  54 #include <TopoDS_Compound.hxx>
  55
  56 #include <Standard_Failure.hxx>
  57 #include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
  58
  59 //=============================================================================
  60 /*!
  61  *   constructor:
  62  */
  63 //=============================================================================
  64 GEOMImpl_IHealingOperations::GEOMImpl_IHealingOperations (GEOM_Engine* theEngine, int theDocID)
  65 : GEOM_IOperations(theEngine, theDocID)
  66 {
  67   MESSAGE("GEOMImpl_IHealingOperations::GEOMImpl_IHealingOperations");
  68 }
  69
  70 //=============================================================================
  71 /*!
  72  *  destructor
  73  */
  74 //=============================================================================
  75 GEOMImpl_IHealingOperations::~GEOMImpl_IHealingOperations()
  76 {
  77   MESSAGE("GEOMImpl_IHealingOperations::~GEOMImpl_IHealingOperations");
  78 }
  79
  80
  81 //=============================================================================
  82 /*!
  83  *  ShapeProcess
  84  */
  85 //=============================================================================
  86 Handle(GEOM_Object) GEOMImpl_IHealingOperations::ShapeProcess (Handle(GEOM_Object) theObject,
  87                                   const Handle(TColStd_HArray1OfExtendedString)& theOperators,
  88                                   const Handle(TColStd_HArray1OfExtendedString)& theParams,
  89                                   const Handle(TColStd_HArray1OfExtendedString)& theValues)
  90 {
  91   // set error code, check parameters
  92   SetErrorCode(KO);
  93
  94   if (theObject.IsNull())
  95     return NULL;
  96
  97   if (theOperators.IsNull() || theOperators->Length() <= 0) {
  98     SetErrorCode("No operators requested");
  99     return NULL;
 100   }
 101
 102   Standard_Integer nbParams = 0, nbValues = 0;
 103   if (!theParams.IsNull()) {
 104     nbParams = theParams->Length();
 105   }
 106   if (!theValues.IsNull()) {
 107     nbValues = theValues->Length();
 108   }
 109
 110   if (nbParams != nbValues) {
 111     SetErrorCode("Number of parameter values must be equal to the number of parameters");
 112     return NULL;
 113   }
 114
 115   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
 116   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be processed
 117
 118   // Add a new object
 119   Handle(GEOM_Object) aNewObject = GetEngine()->AddObject( GetDocID(), GEOM_COPY );
 120
 121   //Add the function
 122   aFunction = aNewObject->AddFunction(GEOMImpl_HealingDriver::GetID(), SHAPE_PROCESS);
 123
 124   if (aFunction.IsNull()) return NULL;
 125
 126   //Check if the function is set correctly
 127   if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
 128
 129   // prepare "data container" class IHealing
 130   GEOMImpl_IHealing HI(aFunction);
 131   HI.SetOriginal(aLastFunction);
 132   HI.SetOperators( theOperators );
 133   if (nbParams > 0) {
 134     HI.SetParameters( theParams );
 135     HI.SetValues( theValues );
 136   }
 137
 138   //Compute the translation
 139   try {
 140     OCC_CATCH_SIGNALS;
 141     if (!GetSolver()->ComputeFunction(aFunction))
 142     {
 143       SetErrorCode("Shape Healing algorithm failed");
 144       return NULL;
 145     }
 146   }
 147   catch (Standard_Failure)
 148   {
 149     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 150     SetErrorCode(aFail->GetMessageString());
 151     return NULL;
 152   }
 153
 154   //Make a Python command
 155   GEOM::TPythonDump pd (aFunction);
 156   pd << aNewObject << " = geompy.ProcessShape(" << theObject << ", [";
 157
 158   // list of operators
 159   int i = theOperators->Lower(), nb = theOperators->Upper();
 160   for ( ; i <= nb; i++) {
 161     pd << "\"" << TCollection_AsciiString(theOperators->Value( i )).ToCString()
 162       << (( i < nb ) ? "\", " : "\"");
 163   }
 164   pd << "], [";
 165   // list of parameters
 166   i = theParams->Lower(); nb = theParams->Upper();
 167   for ( ; i <= nb; i++) {
 168     pd << "\"" << TCollection_AsciiString(theParams->Value( i )).ToCString()
 169       << (( i < nb ) ? "\", " : "\"");
 170   }
 171   pd << "], [";
 172   // list of values
 173   i = theValues->Lower(); nb = theValues->Upper();
 174   for ( ; i <= nb; i++) {
 175     pd << "\"" << TCollection_AsciiString(theValues->Value( i )).ToCString()
 176       << (( i < nb ) ? "\", " : "\"");
 177   }
 178   pd << "])";
 179
 180   SetErrorCode(OK);
 181   return aNewObject;
 182 }
 183
 184 //=============================================================================
 185 /*!
 186  *  ShapeProcess
 187  */
 188 //=============================================================================
 189 void GEOMImpl_IHealingOperations::GetShapeProcessParameters (std::list<std::string>& theOperations,
 190                                                              std::list<std::string>& theParams,
 191                                                              std::list<std::string>& theValues)
 192 {
 193   ShHealOper_ShapeProcess aHealer;
 194   TColStd_SequenceOfAsciiString anOperators;
 195   int nbOperatorErrors( 0 );
 196   if ( aHealer.GetOperators( anOperators ) )
 197   {
 198     for ( Standard_Integer i = 1; i <= anOperators.Length(); i++ )
 199     {
 200       std::string anOperation = anOperators.Value( i ).ToCString();
 201       if ( GetOperatorParameters( anOperation, theParams, theValues ) )
 202         theOperations.push_back( anOperation );
 203       else
 204         nbOperatorErrors++;
 205     }
 206   }
 207   else
 208   {
 209     SetErrorCode("ERROR retrieving operators (GEOMImpl_IHealingOperations)");
 210   }
 211
 212   if ( nbOperatorErrors ) {
 213     TCollection_AsciiString aMsg ("ERRORS retrieving ShapeProcess parameters (GEOMImpl_IHealingOperations): nbOperatorErrors = ");
 214     aMsg += TCollection_AsciiString( nbOperatorErrors );
 215     MESSAGE(aMsg.ToCString());
 216   }
 217 }
 218
 219 //=============================================================================
 220 /*!
 221  *  GetOperatorParameters
 222  */
 223 //=============================================================================
 224 bool GEOMImpl_IHealingOperations::GetOperatorParameters( const std::string &     theOperation,
 225                                                          std::list<std::string>& theParams,
 226                                                          std::list<std::string>& theValues )
 227 {
 228   ShHealOper_ShapeProcess aHealer;
 229   int nbParamValueErrors( 0 );
 230   std::list<std::string> aParams;
 231   if ( GetParameters( theOperation, aParams ) ) {
 232     for ( std::list<std::string>::iterator it = aParams.begin(); it != aParams.end(); ++it ) {
 233       TCollection_AsciiString aParam( (Standard_CString)(*it).c_str() );
 234       TCollection_AsciiString aValue;
 235       if ( aHealer.GetParameter( aParam, aValue ) ) {
 236         theParams.push_back( aParam.ToCString() );
 237         theValues.push_back( aValue.ToCString() );
 238       }
 239       else
 240         nbParamValueErrors++;
 241     }
 242   }
 243   else
 244     return false;
 245
 246   if ( nbParamValueErrors ) {
 247     TCollection_AsciiString aMsg ("ERRORS retrieving ShapeProcess parameter values (GEOMImpl_IHealingOperations): nbParamValueErrors = ");
 248     aMsg += TCollection_AsciiString( nbParamValueErrors );
 249     MESSAGE(aMsg.ToCString());
 250   }
 251
 252   return true;
 253 }
 254
 255 //=============================================================================
 256 /*!
 257  *  GetParameters
 258  */
 259 //=============================================================================
 260 bool GEOMImpl_IHealingOperations::GetParameters (const std::string theOperation,
 261                                                  std::list<std::string>& theParams)
 262 {
 263   if ( theOperation == "SplitAngle" ) {
 264     theParams.push_back( "SplitAngle.Angle" );
 265     theParams.push_back( "SplitAngle.MaxTolerance" );
 266
 267   } else if ( theOperation == "SplitClosedFaces" ) {
 268     theParams.push_back( "SplitClosedFaces.NbSplitPoints" );
 269
 270   } else if ( theOperation == "FixFaceSize" ) {
 271     theParams.push_back( "FixFaceSize.Tolerance" );
 272
 273   } else if( theOperation == "DropSmallEdges" ) {
 274     theParams.push_back( "DropSmallEdges.Tolerance3d" );
 275
 276   } else if( theOperation == "BSplineRestriction" ) {
 277     theParams.push_back( "BSplineRestriction.SurfaceMode" );
 278     theParams.push_back( "BSplineRestriction.Curve3dMode" );
 279     theParams.push_back( "BSplineRestriction.Curve2dMode" );
 280     theParams.push_back( "BSplineRestriction.Tolerance3d" );
 281     theParams.push_back( "BSplineRestriction.Tolerance2d" );
 282     theParams.push_back( "BSplineRestriction.RequiredDegree" );
 283     theParams.push_back( "BSplineRestriction.RequiredNbSegments" );
 284     theParams.push_back( "BSplineRestriction.Continuity3d" );
 285     theParams.push_back( "BSplineRestriction.Continuity2d" );
 286
 287   } else if( theOperation == "SplitContinuity" ) {
 288     theParams.push_back( "SplitContinuity.Tolerance3d" );
 289     theParams.push_back( "SplitContinuity.SurfaceContinuity" );
 290     theParams.push_back( "SplitContinuity.CurveContinuity" );
 291
 292   } else if( theOperation == "ToBezier" ) {
 293     theParams.push_back( "ToBezier.SurfaceMode" );
 294     theParams.push_back( "ToBezier.Curve3dMode" );
 295     theParams.push_back( "ToBezier.Curve2dMode" );
 296     theParams.push_back( "ToBezier.MaxTolerance" );
 297
 298   } else if( theOperation == "SameParameter" ) {
 299     theParams.push_back( "SameParameter.Tolerance3d" );
 300
 301   } else if( theOperation == "FixShape" ) {
 302     theParams.push_back( "FixShape.Tolerance3d" );
 303     theParams.push_back( "FixShape.MaxTolerance3d" );
 304
 305   } else {
 306     return false;
 307   }
 308
 309   return true;
 310 }
 311
 312 //=============================================================================
 313 /*!
 314  *  SuppressFaces
 315  */
 316 //=============================================================================
 317 Handle(GEOM_Object) GEOMImpl_IHealingOperations::SuppressFaces
 318        (Handle(GEOM_Object) theObject, const Handle(TColStd_HArray1OfInteger)& theFaces)
 319 {
 320   // set error code, check parameters
 321   SetErrorCode(KO);
 322
 323   if (theObject.IsNull()) // if theFaces.IsNull() - it's OK, it means that ALL faces must be removed..
 324     return NULL;
 325
 326   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
 327   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be processed
 328
 329   // Add a new object
 330   Handle(GEOM_Object) aNewObject = GetEngine()->AddObject(GetDocID(), GEOM_COPY);
 331
 332   //Add the function
 333   aFunction = aNewObject->AddFunction(GEOMImpl_HealingDriver::GetID(), SUPPRESS_FACES);
 334
 335   if (aFunction.IsNull()) return NULL;
 336
 337   //Check if the function is set correctly
 338   if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
 339
 340   // prepare "data container" class IHealing
 341   GEOMImpl_IHealing HI (aFunction);
 342   HI.SetFaces(theFaces);
 343   HI.SetOriginal(aLastFunction);
 344
 345   //Compute the translation
 346   try {
 347     OCC_CATCH_SIGNALS;
 348     if (!GetSolver()->ComputeFunction(aFunction))
 349     {
 350       SetErrorCode("Healing driver failed");
 351       return NULL;
 352     }
 353   }
 354   catch (Standard_Failure)
 355   {
 356     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 357     SetErrorCode(aFail->GetMessageString());
 358     return NULL;
 359   }
 360
 361   //Make a Python command
 362   GEOM::TPythonDump pd (aFunction);
 363   pd << aNewObject << " = geompy.SuppressFaces(" << theObject << ", [";
 364
 365   // list of face ids
 366   int i = theFaces->Lower(), nb = theFaces->Upper();
 367   for ( ; i <= nb; i++)
 368     pd << theFaces->Value( i ) << (( i < nb ) ? ", " : "])");
 369
 370   SetErrorCode(OK);
 371   return aNewObject;
 372 }
 373
 374 //=============================================================================
 375 /*!
 376  *  CloseContour
 377  */
 378 //=============================================================================
 379 Handle(GEOM_Object) GEOMImpl_IHealingOperations::CloseContour
 380                     (Handle(GEOM_Object) theObject,
 381                      const Handle(TColStd_HArray1OfInteger)& theWires,
 382                      bool isCommonVertex)
 383 {
 384   // set error code, check parameters
 385   SetErrorCode(KO);
 386
 387   if (theObject.IsNull())
 388   {
 389     SetErrorCode("NULL object given");
 390     return NULL;
 391   }
 392
 393   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
 394   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be processed
 395
 396   // Add a new object
 397   Handle(GEOM_Object) aNewObject = GetEngine()->AddObject( GetDocID(), GEOM_COPY );
 398
 399   //Add the function
 400   aFunction = aNewObject->AddFunction(GEOMImpl_HealingDriver::GetID(), CLOSE_CONTOUR);
 401
 402   if (aFunction.IsNull()) return NULL;
 403
 404   //Check if the function is set correctly
 405   if(aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
 406
 407   // prepare "data container" class IHealing
 408   GEOMImpl_IHealing HI(aFunction);
 409   HI.SetWires( theWires );
 410   HI.SetIsCommonVertex( isCommonVertex );
 411   HI.SetOriginal( aLastFunction );
 412
 413   //Compute the translation
 414   try {
 415     OCC_CATCH_SIGNALS;
 416     if (!GetSolver()->ComputeFunction(aFunction))
 417     {
 418       SetErrorCode("Healing driver failed");
 419       return NULL;
 420     }
 421   }
 422   catch (Standard_Failure)
 423   {
 424         Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 425     SetErrorCode(aFail->GetMessageString());
 426     return NULL;
 427   }
 428
 429   //Make a Python command
 430   GEOM::TPythonDump pd (aFunction);
 431   pd << aNewObject << " = geompy.CloseContour(" << theObject << ", [";
 432
 433   // list of wire ids
 434   if (!theWires.IsNull())
 435   {
 436     int i = theWires->Lower(), nb = theWires->Upper();
 437     pd << theWires->Value(i++);
 438     while (i <= nb)
 439       pd << ", " << theWires->Value(i++);
 440   }
 441   pd << "], " << (int)isCommonVertex << ")";
 442
 443   SetErrorCode(OK);
 444   return aNewObject;
 445 }
 446
 447 //=============================================================================
 448 /*!
 449  *  RemoveIntWires
 450  */
 451 //=============================================================================
 452 Handle(GEOM_Object) GEOMImpl_IHealingOperations::RemoveIntWires
 453        (Handle(GEOM_Object) theObject, const Handle(TColStd_HArray1OfInteger)& theWires)
 454 {
 455   // set error code, check parameters
 456   SetErrorCode(KO);
 457
 458   if (theObject.IsNull()) // if theWires is NULL it's OK, it means that ALL wires must be removed
 459     return NULL;
 460
 461   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
 462   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be processed
 463
 464   // Add a new object
 465   Handle(GEOM_Object) aNewObject = GetEngine()->AddObject( GetDocID(), GEOM_COPY );
 466
 467   //Add the function
 468   aFunction = aNewObject->AddFunction(GEOMImpl_HealingDriver::GetID(), REMOVE_INT_WIRES);
 469
 470   if (aFunction.IsNull()) return NULL;
 471
 472   //Check if the function is set correctly
 473   if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
 474
 475   // prepare "data container" class IHealing
 476   GEOMImpl_IHealing HI(aFunction);
 477   HI.SetWires( theWires );
 478   HI.SetOriginal( aLastFunction );
 479
 480   //Compute the translation
 481   try {
 482     OCC_CATCH_SIGNALS;
 483     if (!GetSolver()->ComputeFunction(aFunction))
 484     {
 485       SetErrorCode("Healing driver failed");
 486       return NULL;
 487     }
 488   }
 489   catch (Standard_Failure)
 490   {
 491     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 492     SetErrorCode(aFail->GetMessageString());
 493     return NULL;
 494   }
 495
 496   //Make a Python command
 497   GEOM::TPythonDump pd (aFunction);
 498   pd << aNewObject << " = geompy.SuppressInternalWires(" << theObject << ", [";
 499
 500   // list of wire ids
 501   if (!theWires.IsNull()) {
 502     int i = theWires->Lower(), nb = theWires->Upper();
 503     for ( ; i <= nb; i++)
 504       pd << theWires->Value( i ) << (( i < nb ) ? ", " : "])");
 505   } else {
 506     pd << "])";
 507   }
 508
 509   SetErrorCode(OK);
 510   return aNewObject;
 511 }
 512
 513 //=============================================================================
 514 /*!
 515  *  FillHoles
 516  */
 517 //=============================================================================
 518 Handle(GEOM_Object) GEOMImpl_IHealingOperations::FillHoles (Handle(GEOM_Object) theObject,
 519                                                             const Handle(TColStd_HArray1OfInteger)& theWires)
 520 {
 521   // set error code, check parameters
 522   SetErrorCode(KO);
 523
 524   if (theObject.IsNull()) // if theWires is NULL it's OK, it means that ALL holes must be removed
 525     return NULL;
 526
 527   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
 528   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be processed
 529
 530   // Add a new object
 531   Handle(GEOM_Object) aNewObject = GetEngine()->AddObject( GetDocID(), GEOM_COPY );
 532
 533   //Add the function
 534   aFunction = aNewObject->AddFunction(GEOMImpl_HealingDriver::GetID(), FILL_HOLES);
 535
 536   if (aFunction.IsNull()) return NULL;
 537
 538   //Check if the function is set correctly
 539   if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
 540
 541   // prepare "data container" class IHealing
 542   GEOMImpl_IHealing HI(aFunction);
 543   HI.SetWires( theWires );
 544   HI.SetOriginal( aLastFunction );
 545
 546   //Compute the translation
 547   try {
 548     OCC_CATCH_SIGNALS;
 549     if (!GetSolver()->ComputeFunction(aFunction))
 550     {
 551       SetErrorCode("Healing driver failed");
 552       return NULL;
 553     }
 554   }
 555   catch (Standard_Failure)
 556   {
 557         Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 558     SetErrorCode(aFail->GetMessageString());
 559     return NULL;
 560   }
 561
 562   //Make a Python command
 563   GEOM::TPythonDump pd (aFunction);
 564   pd << aNewObject << " = geompy.SuppressHoles(" << theObject << ", [";
 565
 566   // list of wire ids
 567   if ( theWires.IsNull() )
 568     pd << "])";
 569   else {
 570     int i = theWires->Lower(), nb = theWires->Upper();
 571     for ( ; i <= nb; i++)
 572       pd << theWires->Value( i ) << (( i < nb ) ? ", " : "])");
 573   }
 574
 575   SetErrorCode(OK);
 576   return aNewObject;
 577 }
 578
 579 //=============================================================================
 580 /*!
 581  *  Sew
 582  */
 583 //=============================================================================
 584 Handle(GEOM_Object)
 585 GEOMImpl_IHealingOperations::Sew (std::list<Handle(GEOM_Object)>& theObjects,
 586                                   double                          theTolerance,
 587                                   bool                            isAllowNonManifold)
 588 {
 589   // set error code, check parameters
 590   SetErrorCode(KO);
 591
 592   if (theObjects.empty())
 593     return NULL;
 594
 595   Handle(TColStd_HSequenceOfTransient) objects =
 596     GEOM_Object::GetLastFunctions( theObjects );
 597   if ( objects.IsNull() || objects->IsEmpty() ) {
 598     SetErrorCode("NULL argument shape");
 599     return NULL;
 600   }
 601
 602   // Add a new object
 603   Handle(GEOM_Object) aNewObject = GetEngine()->AddObject( GetDocID(), GEOM_COPY );
 604
 605   //Add the function
 606   int aFunctionType = (isAllowNonManifold ? SEWING_NON_MANIFOLD : SEWING);
 607   Handle(GEOM_Function) aFunction =
 608     aNewObject->AddFunction(GEOMImpl_HealingDriver::GetID(), aFunctionType);
 609   if (aFunction.IsNull()) return NULL;
 610
 611   //Check if the function is set correctly
 612   if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
 613
 614   // prepare "data container" class IHealing
 615   GEOMImpl_IHealing HI(aFunction);
 616   HI.SetTolerance( theTolerance );
 617   HI.SetOriginal( theObjects.front()->GetLastFunction() ); objects->Remove(1);
 618   HI.SetShapes( objects );
 619
 620   //Compute the result
 621   try {
 622     OCC_CATCH_SIGNALS;
 623     if (!GetSolver()->ComputeFunction(aFunction))
 624     {
 625       SetErrorCode("Healing driver failed");
 626       return NULL;
 627     }
 628   }
 629   catch (Standard_Failure) {
 630     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 631     SetErrorCode(aFail->GetMessageString());
 632     return NULL;
 633   }
 634
 635   //Make a Python command
 636   GEOM::TPythonDump pd(aFunction);
 637
 638   pd << aNewObject << " = geompy.Sew(" << theObjects << ", " << theTolerance;
 639
 640   if (isAllowNonManifold) {
 641     pd << ", True";
 642   }
 643
 644   pd << ")";
 645
 646   SetErrorCode(OK);
 647   return aNewObject;
 648 }
 649
 650 //=============================================================================
 651 /*!
 652  *  RemoveInternalFaces
 653  */
 654 //=============================================================================
 655 Handle(GEOM_Object)
 656 GEOMImpl_IHealingOperations::RemoveInternalFaces (std::list< Handle(GEOM_Object)> & theSolids)
 657 {
 658   // set error code, check parameters
 659   SetErrorCode(KO);
 660
 661   if (theSolids.empty())
 662     return NULL;
 663
 664   Handle(TColStd_HSequenceOfTransient) objects = GEOM_Object::GetLastFunctions( theSolids );
 665   if ( objects.IsNull() || objects->IsEmpty() ) {
 666     SetErrorCode("NULL argument shape");
 667     return NULL;
 668   }
 669
 670   // Add a new object
 671   Handle(GEOM_Object) aNewObject = GetEngine()->AddObject(GetDocID(), GEOM_COPY);
 672
 673   //Add the function
 674   Handle(GEOM_Function)
 675     aFunction = aNewObject->AddFunction(GEOMImpl_HealingDriver::GetID(), REMOVE_INTERNAL_FACES);
 676   if (aFunction.IsNull()) return NULL;
 677
 678   //Check if the function is set correctly
 679   if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
 680
 681   // prepare "data container" class IHealing
 682   GEOMImpl_IHealing HI (aFunction);
 683   HI.SetOriginal( theSolids.front()->GetLastFunction() ); objects->Remove(1);
 684   HI.SetShapes( objects );
 685
 686   //Compute the result
 687   try {
 688     OCC_CATCH_SIGNALS;
 689     if (!GetSolver()->ComputeFunction(aFunction))
 690     {
 691       SetErrorCode("Healing driver failed");
 692       return NULL;
 693     }
 694   }
 695   catch (Standard_Failure) {
 696     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 697     SetErrorCode(aFail->GetMessageString());
 698     return NULL;
 699   }
 700
 701   //Make a Python command
 702   GEOM::TPythonDump(aFunction) << aNewObject << " = geompy.RemoveInternalFaces(" << theSolids << ")";
 703
 704   SetErrorCode(OK);
 705   return aNewObject;
 706 }
 707
 708 //=============================================================================
 709 /*!
 710  *  DivideEdge
 711  */
 712 //=============================================================================
 713 Handle(GEOM_Object) GEOMImpl_IHealingOperations::DivideEdge (Handle(GEOM_Object) theObject,
 714                                                              int theIndex,
 715                                                              double theValue,
 716                                                              bool isByParameter)
 717 {
 718   // set error code, check parameters
 719   SetErrorCode(KO);
 720
 721   if (theObject.IsNull())
 722     return NULL;
 723
 724   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
 725   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be processed
 726
 727   // Add a new object
 728   Handle(GEOM_Object) aNewObject = GetEngine()->AddObject( GetDocID(), GEOM_COPY );
 729
 730   //Add the function
 731   aFunction = aNewObject->AddFunction(GEOMImpl_HealingDriver::GetID(), DIVIDE_EDGE);
 732
 733   if (aFunction.IsNull()) return NULL;
 734
 735   //Check if the function is set correctly
 736   if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
 737
 738   // prepare "data container" class IHealing
 739   GEOMImpl_IHealing HI(aFunction);
 740   HI.SetIndex( theIndex );
 741   HI.SetDevideEdgeValue( theValue );
 742   HI.SetIsByParameter( isByParameter );
 743   HI.SetOriginal( aLastFunction );
 744
 745   //Compute the translation
 746   try {
 747     OCC_CATCH_SIGNALS;
 748     if (!GetSolver()->ComputeFunction(aFunction)) {
 749       SetErrorCode("Healing driver failed");
 750       return NULL;
 751     }
 752   }
 753   catch (Standard_Failure) {
 754     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 755     SetErrorCode(aFail->GetMessageString());
 756     return NULL;
 757   }
 758
 759   //Make a Python command
 760   GEOM::TPythonDump(aFunction) << aNewObject << " = geompy.DivideEdge(" << theObject
 761     << ", " << theIndex << ", " << theValue << ", " << (int)isByParameter << ")";
 762
 763   SetErrorCode(OK);
 764   return aNewObject;
 765 }
 766
 767 //=============================================================================
 768 /*!
 769  *  DivideEdgeByPoint
 770  */
 771 //=============================================================================
 772 Handle(GEOM_Object)
 773 GEOMImpl_IHealingOperations::DivideEdgeByPoint (Handle(GEOM_Object) theObject,
 774                                                 int theIndex,
 775                                                 Handle(GEOM_Object) thePoint)
 776 {
 777   // set error code, check parameters
 778   SetErrorCode(KO);
 779
 780   if (theObject.IsNull() || thePoint.IsNull())
 781     return NULL;
 782
 783   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
 784   Handle(GEOM_Function) aPointFunc = thePoint->GetLastFunction();
 785   if (aLastFunction.IsNull() || aPointFunc.IsNull())
 786     return NULL; //There is no function which creates an object to be processed
 787
 788   // Add a new object
 789   Handle(GEOM_Object) aNewObject = GetEngine()->AddObject( GetDocID(), GEOM_COPY );
 790
 791   //Add the function
 792   aFunction = aNewObject->AddFunction(GEOMImpl_HealingDriver::GetID(), DIVIDE_EDGE_BY_POINT);
 793
 794   if (aFunction.IsNull()) return NULL;
 795
 796   //Check if the function is set correctly
 797   if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
 798
 799   // prepare "data container" class IHealing
 800   GEOMImpl_IHealing HI(aFunction);
 801   HI.SetIndex( theIndex );
 802   HI.SetOriginal( aLastFunction );
 803
 804   Handle(TColStd_HSequenceOfTransient) funSeq = new TColStd_HSequenceOfTransient;
 805   funSeq->Append( aPointFunc );
 806   HI.SetShapes( funSeq );
 807
 808   //Compute the translation
 809   try {
 810     OCC_CATCH_SIGNALS;
 811     if (!GetSolver()->ComputeFunction(aFunction)) {
 812       SetErrorCode("Healing driver failed");
 813       return NULL;
 814     }
 815   }
 816   catch (Standard_Failure) {
 817     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 818     SetErrorCode(aFail->GetMessageString());
 819     return NULL;
 820   }
 821
 822   //Make a Python command
 823   GEOM::TPythonDump(aFunction)
 824     << aNewObject << " = geompy.DivideEdgeByPoint(" << theObject
 825     << ", " << theIndex << ", " << thePoint << ")";
 826
 827   SetErrorCode(OK);
 828   return aNewObject;
 829 }
 830
 831 //=============================================================================
 832 /*!
 833  *  FuseCollinearEdgesWithinWire
 834  */
 835 //=============================================================================
 836 Handle(GEOM_Object) GEOMImpl_IHealingOperations::FuseCollinearEdgesWithinWire
 837                                    (Handle(GEOM_Object) theWire,
 838                                     std::list<Handle(GEOM_Object)> theVertices)
 839 {
 840   SetErrorCode(KO);
 841
 842   if (theWire.IsNull()) return NULL;
 843
 844   // Add a new object
 845   Handle(GEOM_Object) aRes = GetEngine()->AddObject(GetDocID(), theWire->GetType());
 846
 847   // Add a new function
 848   Handle(GEOM_Function) aFunction;
 849   aFunction = aRes->AddFunction(GEOMImpl_HealingDriver::GetID(), FUSE_COLLINEAR_EDGES);
 850   if (aFunction.IsNull()) return NULL;
 851
 852   // Check if the function is set correctly
 853   if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
 854
 855   GEOMImpl_IHealing aCI (aFunction);
 856
 857   Handle(GEOM_Function) aRefShape = theWire->GetLastFunction();
 858   if (aRefShape.IsNull()) return NULL;
 859   aCI.SetOriginal(aRefShape);
 860
 861   Handle(TColStd_HSequenceOfTransient) aVertices = new TColStd_HSequenceOfTransient;
 862   std::list<Handle(GEOM_Object)>::iterator it = theVertices.begin();
 863   for (; it != theVertices.end(); it++) {
 864     Handle(GEOM_Function) aRefSh = (*it)->GetLastFunction();
 865     if (aRefSh.IsNull()) {
 866       SetErrorCode("NULL argument shape for the shape construction");
 867       return NULL;
 868     }
 869     aVertices->Append(aRefSh);
 870   }
 871   aCI.SetShapes(aVertices);
 872
 873   // Compute the new wire
 874   try {
 875     OCC_CATCH_SIGNALS;
 876     if (!GetSolver()->ComputeFunction(aFunction)) {
 877       SetErrorCode("Healing driver failed");
 878       return NULL;
 879     }
 880   }
 881   catch (Standard_Failure) {
 882     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 883     SetErrorCode(aFail->GetMessageString());
 884     return NULL;
 885   }
 886
 887   // Make a Python command
 888   GEOM::TPythonDump pd (aFunction);
 889   pd << aRes << " = geompy.FuseCollinearEdgesWithinWire(" << theWire << ", [";
 890   // Vertices
 891   it = theVertices.begin();
 892   if (it != theVertices.end()) {
 893     pd << (*it++);
 894     while (it != theVertices.end()) {
 895       pd << ", " << (*it++);
 896     }
 897   }
 898   pd << "])";
 899
 900   SetErrorCode(OK);
 901   return aRes;
 902 }
 903
 904 //=============================================================================
 905 /*!
 906  *  GetFreeBoundary
 907  */
 908 //=============================================================================
 909 bool GEOMImpl_IHealingOperations::GetFreeBoundary (Handle(TColStd_HSequenceOfTransient)& theObjects,
 910                                                    Handle(TColStd_HSequenceOfTransient)& theClosed,
 911                                                    Handle(TColStd_HSequenceOfTransient)& theOpen )
 912 {
 913   // set error code, check parameters
 914   SetErrorCode(KO);
 915
 916   if ( theObjects.IsNull() || theObjects->Length() == 0 ||
 917        theClosed.IsNull()  || theOpen.IsNull() )
 918     return false;
 919
 920   TopoDS_Shape aShape;
 921   TopTools_SequenceOfShape shapes;
 922   for ( int ind = 1; ind <= theObjects->Length(); ind++)
 923   {
 924     Handle(GEOM_Object) aRefShape = Handle(GEOM_Object)::DownCast( theObjects->Value(ind));
 925     if ( aRefShape.IsNull() )
 926       return false;
 927     aShape = aRefShape->GetValue();
 928     if ( aShape.IsNull() )
 929       return false;
 930     shapes.Append( aShape );
 931   }
 932
 933   if ( shapes.Length() > 1 )
 934   {
 935     TopoDS_Compound compound;
 936     BRep_Builder builder;
 937     builder.MakeCompound( compound );
 938     for ( int i = 1; i <= shapes.Length(); ++i )
 939       builder.Add( compound, shapes( i ) );
 940
 941     aShape = compound;
 942   }
 943
 944   // get free boundary shapes
 945
 946   ShapeAnalysis_FreeBounds anAnalizer(aShape, Standard_False,
 947                                       Standard_True, Standard_True);
 948   TopoDS_Compound aClosed = anAnalizer.GetClosedWires();
 949   TopoDS_Compound anOpen = anAnalizer.GetOpenWires();
 950
 951   // iterate through shapes and append them to the return sequence
 952   Handle(GEOM_Object) anObj;
 953   Handle(GEOM_Function) aFunction;
 954   TopExp_Explorer anExp;
 955   for ( anExp.Init( aClosed, TopAbs_WIRE ); anExp.More(); anExp.Next() )
 956   {
 957     anObj = GetEngine()->AddObject( GetDocID(), GEOM_FREE_BOUNDS );
 958     aFunction = anObj->AddFunction( GEOMImpl_CopyDriver::GetID(), COPY_WITHOUT_REF );
 959     TopoDS_Shape aValueShape = anExp.Current();
 960     aFunction->SetValue( aValueShape );
 961     theClosed->Append(anObj);
 962   }
 963   for ( anExp.Init( anOpen, TopAbs_WIRE ); anExp.More(); anExp.Next() )
 964   {
 965     anObj = GetEngine()->AddObject( GetDocID(), GEOM_FREE_BOUNDS );
 966     aFunction = anObj->AddFunction( GEOMImpl_CopyDriver::GetID(), COPY_WITHOUT_REF );
 967     TopoDS_Shape aValueShape = anExp.Current();
 968     aFunction->SetValue( aValueShape );
 969     theOpen->Append(anObj);
 970   }
 971
 972   if(!aFunction.IsNull()) {
 973
 974     //Make a Python command
 975     GEOM::TPythonDump pd (aFunction);
 976
 977     Standard_Integer i, aLen = theClosed->Length();
 978     if (aLen > 0) {
 979       pd << "(isDone, [";
 980       for (i = 1; i <= aLen; i++) {
 981         Handle(GEOM_Object) anObj_i = Handle(GEOM_Object)::DownCast(theClosed->Value(i));
 982         pd << anObj_i << ((i < aLen) ? ", " : "");
 983       }
 984       pd << "], ";
 985     } else {
 986       pd << "(isDone, empty_list, ";
 987     }
 988
 989     aLen = theOpen->Length();
 990     if (aLen > 0) {
 991       pd << "[";
 992       for (i = 1; i <= aLen; i++) {
 993         Handle(GEOM_Object) anObj_i = Handle(GEOM_Object)::DownCast(theOpen->Value(i));
 994         pd << anObj_i << ((i < aLen) ? ", " : "");
 995       }
 996       pd << "]";
 997     } else {
 998       pd << "empty_list";
 999     }
1000
1001     pd << ") = geompy.GetFreeBoundary(" << theObjects << ")";
1002   }
1003
1004   SetErrorCode(OK);
1005   return true;
1006 }
1007
1008
1009 //=============================================================================
1010 /*!
1011  *  ChangeOrientation
1012  */
1013 //=============================================================================
1014 Handle(GEOM_Object) GEOMImpl_IHealingOperations::ChangeOrientation (Handle(GEOM_Object) theObject)
1015 {
1016   // set error code, check parameters
1017   SetErrorCode(KO);
1018
1019   if (theObject.IsNull())
1020     return NULL;
1021
1022   if (!theObject->IsMainShape()) {
1023     SetErrorCode("Sub-shape cannot be transformed - need to create a copy");
1024     return NULL;
1025   }
1026
1027   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
1028   if (aLastFunction.IsNull())
1029     return NULL; //There is no function which creates an object to be processed
1030
1031   if (theObject->GetType() == GEOM_VECTOR) { // Mantis issue 21066
1032     //Add the function
1033     aFunction = theObject->AddFunction(GEOMImpl_VectorDriver::GetID(), VECTOR_REVERSE);
1034
1035     //Check if the function is set correctly
1036     if (aFunction.IsNull()) return NULL;
1037     if (aFunction->GetDriverGUID() != GEOMImpl_VectorDriver::GetID()) return NULL;
1038
1039     // prepare "data container" class IVector
1040     GEOMImpl_IVector aVI (aFunction);
1041     aVI.SetCurve(aLastFunction);
1042   }
1043   else {
1044     //Add the function
1045     aFunction = theObject->AddFunction(GEOMImpl_HealingDriver::GetID(), CHANGE_ORIENTATION);
1046
1047     //Check if the function is set correctly
1048     if (aFunction.IsNull()) return NULL;
1049     if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
1050
1051     // prepare "data container" class IHealing
1052     GEOMImpl_IHealing HI (aFunction);
1053     HI.SetOriginal(aLastFunction);
1054   }
1055
1056   //Compute the translation
1057   try {
1058     OCC_CATCH_SIGNALS;
1059     if (!GetSolver()->ComputeFunction(aFunction)) {
1060       SetErrorCode("Healing driver failed");
1061       return NULL;
1062     }
1063   }
1064   catch (Standard_Failure) {
1065     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1066     SetErrorCode(aFail->GetMessageString());
1067     return NULL;
1068   }
1069
1070   //Make a Python command
1071   GEOM::TPythonDump(aFunction) << "geompy.ChangeOrientationShell("
1072                                << theObject << ")";
1073
1074   SetErrorCode(OK);
1075   return theObject;
1076 }
1077
1078 //=============================================================================
1079 /*!
1080  *  ChangeOrientationCopy
1081  */
1082 //=============================================================================
1083 Handle(GEOM_Object) GEOMImpl_IHealingOperations::ChangeOrientationCopy (Handle(GEOM_Object) theObject)
1084 {
1085   // set error code, check parameters
1086   SetErrorCode(KO);
1087
1088   if (theObject.IsNull())
1089     return NULL;
1090
1091   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
1092   if (aLastFunction.IsNull())
1093     return NULL; //There is no function which creates an object to be processed
1094
1095   // Add a new object
1096   Handle(GEOM_Object) aNewObject = GetEngine()->AddObject(GetDocID(), theObject->GetType());
1097
1098   if (theObject->GetType() == GEOM_VECTOR) { // Mantis issue 21066
1099     //Add the function
1100     aFunction = aNewObject->AddFunction(GEOMImpl_VectorDriver::GetID(), VECTOR_REVERSE);
1101
1102     //Check if the function is set correctly
1103     if (aFunction.IsNull()) return NULL;
1104     if (aFunction->GetDriverGUID() != GEOMImpl_VectorDriver::GetID()) return NULL;
1105
1106     // prepare "data container" class IVector
1107     GEOMImpl_IVector aVI (aFunction);
1108     aVI.SetCurve(aLastFunction);
1109   }
1110   else {
1111     //Add the function
1112     aFunction = aNewObject->AddFunction(GEOMImpl_HealingDriver::GetID(), CHANGE_ORIENTATION);
1113
1114     //Check if the function is set correctly
1115     if (aFunction.IsNull()) return NULL;
1116     if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
1117
1118     // prepare "data container" class IHealing
1119     GEOMImpl_IHealing aHI (aFunction);
1120     aHI.SetOriginal(aLastFunction);
1121   }
1122
1123   // Compute the result
1124   try {
1125     OCC_CATCH_SIGNALS;
1126     if (!GetSolver()->ComputeFunction(aFunction)) {
1127       SetErrorCode("Healing driver failed");
1128       return NULL;
1129     }
1130   }
1131   catch (Standard_Failure) {
1132     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1133     SetErrorCode(aFail->GetMessageString());
1134     return NULL;
1135   }
1136
1137   //Make a Python command
1138   GEOM::TPythonDump(aFunction) << aNewObject << " = geompy.ChangeOrientationShellCopy("
1139                                << theObject << ")";
1140
1141   SetErrorCode(OK);
1142   return aNewObject;
1143 }
1144
1145 //=============================================================================
1146 /*!
1147  *  LimitTolerance
1148  */
1149 //=============================================================================
1150 Handle(GEOM_Object) GEOMImpl_IHealingOperations::LimitTolerance (Handle(GEOM_Object) theObject,
1151                                                                  double theTolerance)
1152 {
1153   // Set error code, check parameters
1154   SetErrorCode(KO);
1155
1156   if (theObject.IsNull())
1157     return NULL;
1158
1159   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
1160   if (aLastFunction.IsNull())
1161     return NULL; // There is no function which creates an object to be processed
1162
1163   // Add a new object
1164   Handle(GEOM_Object) aNewObject = GetEngine()->AddObject(GetDocID(), theObject->GetType());
1165
1166   // Add the function
1167   aFunction = aNewObject->AddFunction(GEOMImpl_HealingDriver::GetID(), LIMIT_TOLERANCE);
1168
1169   if (aFunction.IsNull())
1170     return NULL;
1171
1172   // Check if the function is set correctly
1173   if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
1174
1175   // Prepare "data container" class IHealing
1176   GEOMImpl_IHealing HI (aFunction);
1177   HI.SetOriginal(aLastFunction);
1178   HI.SetTolerance(theTolerance);
1179
1180   // Compute
1181   try {
1182     OCC_CATCH_SIGNALS;
1183     if (!GetSolver()->ComputeFunction(aFunction)) {
1184       SetErrorCode("Healing driver failed");
1185       return NULL;
1186     }
1187   }
1188   catch (Standard_Failure) {
1189     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1190     SetErrorCode(aFail->GetMessageString());
1191     return NULL;
1192   }
1193
1194   // Make a Python command
1195   GEOM::TPythonDump(aFunction) << aNewObject << " = geompy.LimitTolerance("
1196                                << theObject << ", " << theTolerance << ")";
1197
1198   SetErrorCode(OK);
1199   return aNewObject;
1200 }