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 = new TColStd_HSequenceOfTransient;
 596   std::list<Handle(GEOM_Object)>::iterator it = theObjects.begin();
 597   for (; it != theObjects.end(); it++)
 598   {
 599     Handle(GEOM_Function) aRefSh = (*it)->GetLastFunction();
 600     if (aRefSh.IsNull()) {
 601       SetErrorCode("NULL argument shape");
 602       return NULL;
 603     }
 604     objects->Append(aRefSh);
 605   }
 606
 607   // Add a new object
 608   Handle(GEOM_Object) aNewObject = GetEngine()->AddObject( GetDocID(), GEOM_COPY );
 609
 610   //Add the function
 611   int aFunctionType = (isAllowNonManifold ? SEWING_NON_MANIFOLD : SEWING);
 612   Handle(GEOM_Function) aFunction =
 613     aNewObject->AddFunction(GEOMImpl_HealingDriver::GetID(), aFunctionType);
 614   if (aFunction.IsNull()) return NULL;
 615
 616   //Check if the function is set correctly
 617   if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
 618
 619   // prepare "data container" class IHealing
 620   GEOMImpl_IHealing HI(aFunction);
 621   HI.SetTolerance( theTolerance );
 622   HI.SetOriginal( theObjects.front()->GetLastFunction() ); objects->Remove(1);
 623   HI.SetShapes( objects );
 624
 625   //Compute the result
 626   try {
 627     OCC_CATCH_SIGNALS;
 628     if (!GetSolver()->ComputeFunction(aFunction))
 629     {
 630       SetErrorCode("Healing driver failed");
 631       return NULL;
 632     }
 633   }
 634   catch (Standard_Failure) {
 635     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 636     SetErrorCode(aFail->GetMessageString());
 637     return NULL;
 638   }
 639
 640   //Make a Python command
 641   GEOM::TPythonDump pd(aFunction);
 642
 643   pd << aNewObject << " = geompy.Sew(" << theObjects << ", " << theTolerance;
 644
 645   if (isAllowNonManifold) {
 646     pd << ", true";
 647   }
 648
 649   pd << ")";
 650
 651   SetErrorCode(OK);
 652   return aNewObject;
 653 }
 654
 655 //=============================================================================
 656 /*!
 657  *  RemoveInternalFaces
 658  */
 659 //=============================================================================
 660 Handle(GEOM_Object) GEOMImpl_IHealingOperations::RemoveInternalFaces (Handle(GEOM_Object) theObject)
 661 {
 662   // set error code, check parameters
 663   SetErrorCode(KO);
 664
 665   if (theObject.IsNull())
 666     return NULL;
 667
 668   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
 669   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be processed
 670
 671   // Add a new object
 672   Handle(GEOM_Object) aNewObject = GetEngine()->AddObject(GetDocID(), GEOM_COPY);
 673
 674   //Add the 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(aLastFunction);
 684
 685   //Compute the result
 686   try {
 687     OCC_CATCH_SIGNALS;
 688     if (!GetSolver()->ComputeFunction(aFunction))
 689     {
 690       SetErrorCode("Healing driver failed");
 691       return NULL;
 692     }
 693   }
 694   catch (Standard_Failure) {
 695     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 696     SetErrorCode(aFail->GetMessageString());
 697     return NULL;
 698   }
 699
 700   //Make a Python command
 701   GEOM::TPythonDump(aFunction) << aNewObject << " = geompy.RemoveInternalFaces(" << theObject << ")";
 702
 703   SetErrorCode(OK);
 704   return aNewObject;
 705 }
 706
 707 //=============================================================================
 708 /*!
 709  *  DivideEdge
 710  */
 711 //=============================================================================
 712 Handle(GEOM_Object) GEOMImpl_IHealingOperations::DivideEdge (Handle(GEOM_Object) theObject,
 713                                                              int theIndex,
 714                                                              double theValue,
 715                                                              bool isByParameter)
 716 {
 717   // set error code, check parameters
 718   SetErrorCode(KO);
 719
 720   if (theObject.IsNull())
 721     return NULL;
 722
 723   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
 724   if (aLastFunction.IsNull()) return NULL; //There is no function which creates an object to be processed
 725
 726   // Add a new object
 727   Handle(GEOM_Object) aNewObject = GetEngine()->AddObject( GetDocID(), GEOM_COPY );
 728
 729   //Add the function
 730   aFunction = aNewObject->AddFunction(GEOMImpl_HealingDriver::GetID(), DIVIDE_EDGE);
 731
 732   if (aFunction.IsNull()) return NULL;
 733
 734   //Check if the function is set correctly
 735   if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
 736
 737   // prepare "data container" class IHealing
 738   GEOMImpl_IHealing HI(aFunction);
 739   HI.SetIndex( theIndex );
 740   HI.SetDevideEdgeValue( theValue );
 741   HI.SetIsByParameter( isByParameter );
 742   HI.SetOriginal( aLastFunction );
 743
 744   //Compute the translation
 745   try {
 746     OCC_CATCH_SIGNALS;
 747     if (!GetSolver()->ComputeFunction(aFunction)) {
 748       SetErrorCode("Healing driver failed");
 749       return NULL;
 750     }
 751   }
 752   catch (Standard_Failure) {
 753     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 754     SetErrorCode(aFail->GetMessageString());
 755     return NULL;
 756   }
 757
 758   //Make a Python command
 759   GEOM::TPythonDump(aFunction) << aNewObject << " = geompy.DivideEdge(" << theObject
 760     << ", " << theIndex << ", " << theValue << ", " << (int)isByParameter << ")";
 761
 762   SetErrorCode(OK);
 763   return aNewObject;
 764 }
 765
 766 //=============================================================================
 767 /*!
 768  *  FuseCollinearEdgesWithinWire
 769  */
 770 //=============================================================================
 771 Handle(GEOM_Object) GEOMImpl_IHealingOperations::FuseCollinearEdgesWithinWire
 772                                    (Handle(GEOM_Object) theWire,
 773                                     std::list<Handle(GEOM_Object)> theVertices)
 774 {
 775   SetErrorCode(KO);
 776
 777   if (theWire.IsNull()) return NULL;
 778
 779   // Add a new object
 780   Handle(GEOM_Object) aRes = GetEngine()->AddObject(GetDocID(), theWire->GetType());
 781
 782   // Add a new function
 783   Handle(GEOM_Function) aFunction;
 784   aFunction = aRes->AddFunction(GEOMImpl_HealingDriver::GetID(), FUSE_COLLINEAR_EDGES);
 785   if (aFunction.IsNull()) return NULL;
 786
 787   // Check if the function is set correctly
 788   if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
 789
 790   GEOMImpl_IHealing aCI (aFunction);
 791
 792   Handle(GEOM_Function) aRefShape = theWire->GetLastFunction();
 793   if (aRefShape.IsNull()) return NULL;
 794   aCI.SetOriginal(aRefShape);
 795
 796   Handle(TColStd_HSequenceOfTransient) aVertices = new TColStd_HSequenceOfTransient;
 797   std::list<Handle(GEOM_Object)>::iterator it = theVertices.begin();
 798   for (; it != theVertices.end(); it++) {
 799     Handle(GEOM_Function) aRefSh = (*it)->GetLastFunction();
 800     if (aRefSh.IsNull()) {
 801       SetErrorCode("NULL argument shape for the shape construction");
 802       return NULL;
 803     }
 804     aVertices->Append(aRefSh);
 805   }
 806   aCI.SetShapes(aVertices);
 807
 808   // Compute the new wire
 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 pd (aFunction);
 824   pd << aRes << " = geompy.FuseCollinearEdgesWithinWire(" << theWire << ", [";
 825   // Vertices
 826   it = theVertices.begin();
 827   if (it != theVertices.end()) {
 828     pd << (*it++);
 829     while (it != theVertices.end()) {
 830       pd << ", " << (*it++);
 831     }
 832   }
 833   pd << "])";
 834
 835   SetErrorCode(OK);
 836   return aRes;
 837 }
 838
 839 //=============================================================================
 840 /*!
 841  *  GetFreeBoundary
 842  */
 843 //=============================================================================
 844 bool GEOMImpl_IHealingOperations::GetFreeBoundary (Handle(TColStd_HSequenceOfTransient)& theObjects,
 845                                                    Handle(TColStd_HSequenceOfTransient)& theClosed,
 846                                                    Handle(TColStd_HSequenceOfTransient)& theOpen )
 847 {
 848   // set error code, check parameters
 849   SetErrorCode(KO);
 850
 851   if ( theObjects.IsNull() || theObjects->Length() == 0 ||
 852        theClosed.IsNull()  || theOpen.IsNull() )
 853     return false;
 854
 855   TopoDS_Shape aShape;
 856   TopTools_SequenceOfShape shapes;
 857   for ( int ind = 1; ind <= theObjects->Length(); ind++)
 858   {
 859     Handle(GEOM_Object) aRefShape = Handle(GEOM_Object)::DownCast( theObjects->Value(ind));
 860     if ( aRefShape.IsNull() )
 861       return false;
 862     aShape = aRefShape->GetValue();
 863     if ( aShape.IsNull() )
 864       return false;
 865     shapes.Append( aShape );
 866   }
 867
 868   if ( shapes.Length() > 1 )
 869   {
 870     TopoDS_Compound compound;
 871     BRep_Builder builder;
 872     builder.MakeCompound( compound );
 873     for ( int i = 1; i <= shapes.Length(); ++i )
 874       builder.Add( compound, shapes( i ) );
 875
 876     aShape = compound;
 877   }
 878
 879   // get free boundary shapes
 880
 881   ShapeAnalysis_FreeBounds anAnalizer(aShape, Standard_False,
 882                                       Standard_True, Standard_True);
 883   TopoDS_Compound aClosed = anAnalizer.GetClosedWires();
 884   TopoDS_Compound anOpen = anAnalizer.GetOpenWires();
 885
 886   // iterate through shapes and append them to the return sequence
 887   Handle(GEOM_Object) anObj;
 888   Handle(GEOM_Function) aFunction;
 889   TopExp_Explorer anExp;
 890   for ( anExp.Init( aClosed, TopAbs_WIRE ); anExp.More(); anExp.Next() )
 891   {
 892     anObj = GetEngine()->AddObject( GetDocID(), GEOM_FREE_BOUNDS );
 893     aFunction = anObj->AddFunction( GEOMImpl_CopyDriver::GetID(), COPY_WITHOUT_REF );
 894     TopoDS_Shape aValueShape = anExp.Current();
 895     aFunction->SetValue( aValueShape );
 896     theClosed->Append(anObj);
 897   }
 898   for ( anExp.Init( anOpen, TopAbs_WIRE ); anExp.More(); anExp.Next() )
 899   {
 900     anObj = GetEngine()->AddObject( GetDocID(), GEOM_FREE_BOUNDS );
 901     aFunction = anObj->AddFunction( GEOMImpl_CopyDriver::GetID(), COPY_WITHOUT_REF );
 902     TopoDS_Shape aValueShape = anExp.Current();
 903     aFunction->SetValue( aValueShape );
 904     theOpen->Append(anObj);
 905   }
 906
 907   if(!aFunction.IsNull()) {
 908
 909     //Make a Python command
 910     GEOM::TPythonDump pd (aFunction);
 911
 912     Standard_Integer i, aLen = theClosed->Length();
 913     if (aLen > 0) {
 914       pd << "(isDone, [";
 915       for (i = 1; i <= aLen; i++) {
 916         Handle(GEOM_Object) anObj_i = Handle(GEOM_Object)::DownCast(theClosed->Value(i));
 917         pd << anObj_i << ((i < aLen) ? ", " : "");
 918       }
 919       pd << "], ";
 920     } else {
 921       pd << "(isDone, empty_list, ";
 922     }
 923
 924     aLen = theOpen->Length();
 925     if (aLen > 0) {
 926       pd << "[";
 927       for (i = 1; i <= aLen; i++) {
 928         Handle(GEOM_Object) anObj_i = Handle(GEOM_Object)::DownCast(theOpen->Value(i));
 929         pd << anObj_i << ((i < aLen) ? ", " : "");
 930       }
 931       pd << "]";
 932     } else {
 933       pd << "empty_list";
 934     }
 935
 936     pd << ") = geompy.GetFreeBoundary(" << theObjects << ")";
 937   }
 938
 939   SetErrorCode(OK);
 940   return true;
 941 }
 942
 943
 944 //=============================================================================
 945 /*!
 946  *  ChangeOrientation
 947  */
 948 //=============================================================================
 949 Handle(GEOM_Object) GEOMImpl_IHealingOperations::ChangeOrientation (Handle(GEOM_Object) theObject)
 950 {
 951   // set error code, check parameters
 952   SetErrorCode(KO);
 953
 954   if (theObject.IsNull())
 955     return NULL;
 956
 957   if (!theObject->IsMainShape()) {
 958     SetErrorCode("Sub-shape cannot be transformed - need to create a copy");
 959     return NULL;
 960   }
 961
 962   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
 963   if (aLastFunction.IsNull())
 964     return NULL; //There is no function which creates an object to be processed
 965
 966   if (theObject->GetType() == GEOM_VECTOR) { // Mantis issue 21066
 967     //Add the function
 968     aFunction = theObject->AddFunction(GEOMImpl_VectorDriver::GetID(), VECTOR_REVERSE);
 969
 970     //Check if the function is set correctly
 971     if (aFunction.IsNull()) return NULL;
 972     if (aFunction->GetDriverGUID() != GEOMImpl_VectorDriver::GetID()) return NULL;
 973
 974     // prepare "data container" class IVector
 975     GEOMImpl_IVector aVI (aFunction);
 976     aVI.SetCurve(aLastFunction);
 977   }
 978   else {
 979     //Add the function
 980     aFunction = theObject->AddFunction(GEOMImpl_HealingDriver::GetID(), CHANGE_ORIENTATION);
 981
 982     //Check if the function is set correctly
 983     if (aFunction.IsNull()) return NULL;
 984     if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
 985
 986     // prepare "data container" class IHealing
 987     GEOMImpl_IHealing HI (aFunction);
 988     HI.SetOriginal(aLastFunction);
 989   }
 990
 991   //Compute the translation
 992   try {
 993     OCC_CATCH_SIGNALS;
 994     if (!GetSolver()->ComputeFunction(aFunction)) {
 995       SetErrorCode("Healing driver failed");
 996       return NULL;
 997     }
 998   }
 999   catch (Standard_Failure) {
1000     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1001     SetErrorCode(aFail->GetMessageString());
1002     return NULL;
1003   }
1004
1005   //Make a Python command
1006   GEOM::TPythonDump(aFunction) << "geompy.ChangeOrientationShell("
1007                                << theObject << ")";
1008
1009   SetErrorCode(OK);
1010   return theObject;
1011 }
1012
1013 //=============================================================================
1014 /*!
1015  *  ChangeOrientationCopy
1016  */
1017 //=============================================================================
1018 Handle(GEOM_Object) GEOMImpl_IHealingOperations::ChangeOrientationCopy (Handle(GEOM_Object) theObject)
1019 {
1020   // set error code, check parameters
1021   SetErrorCode(KO);
1022
1023   if (theObject.IsNull())
1024     return NULL;
1025
1026   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
1027   if (aLastFunction.IsNull())
1028     return NULL; //There is no function which creates an object to be processed
1029
1030   // Add a new object
1031   Handle(GEOM_Object) aNewObject = GetEngine()->AddObject(GetDocID(), theObject->GetType());
1032
1033   if (theObject->GetType() == GEOM_VECTOR) { // Mantis issue 21066
1034     //Add the function
1035     aFunction = aNewObject->AddFunction(GEOMImpl_VectorDriver::GetID(), VECTOR_REVERSE);
1036
1037     //Check if the function is set correctly
1038     if (aFunction.IsNull()) return NULL;
1039     if (aFunction->GetDriverGUID() != GEOMImpl_VectorDriver::GetID()) return NULL;
1040
1041     // prepare "data container" class IVector
1042     GEOMImpl_IVector aVI (aFunction);
1043     aVI.SetCurve(aLastFunction);
1044   }
1045   else {
1046     //Add the function
1047     aFunction = aNewObject->AddFunction(GEOMImpl_HealingDriver::GetID(), CHANGE_ORIENTATION);
1048
1049     //Check if the function is set correctly
1050     if (aFunction.IsNull()) return NULL;
1051     if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
1052
1053     // prepare "data container" class IHealing
1054     GEOMImpl_IHealing aHI (aFunction);
1055     aHI.SetOriginal(aLastFunction);
1056   }
1057
1058   // Compute the result
1059   try {
1060     OCC_CATCH_SIGNALS;
1061     if (!GetSolver()->ComputeFunction(aFunction)) {
1062       SetErrorCode("Healing driver failed");
1063       return NULL;
1064     }
1065   }
1066   catch (Standard_Failure) {
1067     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1068     SetErrorCode(aFail->GetMessageString());
1069     return NULL;
1070   }
1071
1072   //Make a Python command
1073   GEOM::TPythonDump(aFunction) << aNewObject << " = geompy.ChangeOrientationShellCopy("
1074                                << theObject << ")";
1075
1076   SetErrorCode(OK);
1077   return aNewObject;
1078 }
1079
1080 //=============================================================================
1081 /*!
1082  *  LimitTolerance
1083  */
1084 //=============================================================================
1085 Handle(GEOM_Object) GEOMImpl_IHealingOperations::LimitTolerance (Handle(GEOM_Object) theObject,
1086                                                                  double theTolerance)
1087 {
1088   // Set error code, check parameters
1089   SetErrorCode(KO);
1090
1091   if (theObject.IsNull())
1092     return NULL;
1093
1094   Handle(GEOM_Function) aFunction, aLastFunction = theObject->GetLastFunction();
1095   if (aLastFunction.IsNull())
1096     return NULL; // There is no function which creates an object to be processed
1097
1098   // Add a new object
1099   Handle(GEOM_Object) aNewObject = GetEngine()->AddObject(GetDocID(), theObject->GetType());
1100
1101   // Add the function
1102   aFunction = aNewObject->AddFunction(GEOMImpl_HealingDriver::GetID(), LIMIT_TOLERANCE);
1103
1104   if (aFunction.IsNull())
1105     return NULL;
1106
1107   // Check if the function is set correctly
1108   if (aFunction->GetDriverGUID() != GEOMImpl_HealingDriver::GetID()) return NULL;
1109
1110   // Prepare "data container" class IHealing
1111   GEOMImpl_IHealing HI (aFunction);
1112   HI.SetOriginal(aLastFunction);
1113   HI.SetTolerance(theTolerance);
1114
1115   // Compute
1116   try {
1117     OCC_CATCH_SIGNALS;
1118     if (!GetSolver()->ComputeFunction(aFunction)) {
1119       SetErrorCode("Healing driver failed");
1120       return NULL;
1121     }
1122   }
1123   catch (Standard_Failure) {
1124     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1125     SetErrorCode(aFail->GetMessageString());
1126     return NULL;
1127   }
1128
1129   // Make a Python command
1130   GEOM::TPythonDump(aFunction) << aNewObject << " = geompy.LimitTolerance("
1131                                << theObject << ", " << theTolerance << ")";
1132
1133   SetErrorCode(OK);
1134   return aNewObject;
1135 }