src/GEOMImpl/GEOMImpl_I3DPrimOperations.cxx

   1 // Copyright (C) 2007-2016  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 <Basics_OCCTVersion.hxx>
  26
  27 #include <GEOMImpl_I3DPrimOperations.hxx>
  28
  29 #include "utilities.h"
  30 #include <OpUtil.hxx>
  31 #include <Utils_ExceptHandlers.hxx>
  32
  33 #include <TFunction_DriverTable.hxx>
  34 #include <TFunction_Driver.hxx>
  35 #include <TDF_Tool.hxx>
  36
  37 #include <GEOM_Function.hxx>
  38 #include <GEOM_PythonDump.hxx>
  39
  40 #include <GEOMImpl_Types.hxx>
  41
  42 #include <GEOMImpl_BoxDriver.hxx>
  43 #include <GEOMImpl_FaceDriver.hxx>
  44 #include <GEOMImpl_DiskDriver.hxx>
  45 #include <GEOMImpl_CylinderDriver.hxx>
  46 #include <GEOMImpl_ConeDriver.hxx>
  47 #include <GEOMImpl_SphereDriver.hxx>
  48 #include <GEOMImpl_TorusDriver.hxx>
  49 #include <GEOMImpl_PrismDriver.hxx>
  50 #include <GEOMImpl_PipeDriver.hxx>
  51 #include <GEOMImpl_PipePathDriver.hxx>
  52 #include <GEOMImpl_RevolutionDriver.hxx>
  53 #include <GEOMImpl_ShapeDriver.hxx>
  54 #include <GEOMImpl_FillingDriver.hxx>
  55 #include <GEOMImpl_ThruSectionsDriver.hxx>
  56 #include <GEOMImpl_OffsetDriver.hxx>
  57
  58 #include <GEOMImpl_IBox.hxx>
  59 #include <GEOMImpl_IFace.hxx>
  60 #include <GEOMImpl_IDisk.hxx>
  61 #include <GEOMImpl_ICylinder.hxx>
  62 #include <GEOMImpl_ICone.hxx>
  63 #include <GEOMImpl_IGroupOperations.hxx>
  64 #include <GEOMImpl_ISphere.hxx>
  65 #include <GEOMImpl_ITorus.hxx>
  66 #include <GEOMImpl_IPrism.hxx>
  67 #include <GEOMImpl_IPipe.hxx>
  68 #include <GEOMImpl_IRevolution.hxx>
  69 #include <GEOMImpl_IFilling.hxx>
  70 #include <GEOMImpl_IThruSections.hxx>
  71 #include <GEOMImpl_IPipeDiffSect.hxx>
  72 #include <GEOMImpl_IPipeShellSect.hxx>
  73 #include <GEOMImpl_IPipeBiNormal.hxx>
  74 #include <GEOMImpl_IOffset.hxx>
  75 #include <GEOMImpl_IPipePath.hxx>
  76
  77 #include <Precision.hxx>
  78 #include <TopExp.hxx>
  79
  80 #include <Standard_Failure.hxx>
  81 #include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
  82
  83 //=============================================================================
  84 /*!
  85  *   constructor:
  86  */
  87 //=============================================================================
  88 GEOMImpl_I3DPrimOperations::GEOMImpl_I3DPrimOperations (GEOM_Engine* theEngine, int theDocID)
  89 : GEOM_IOperations(theEngine, theDocID)
  90 {
  91   MESSAGE("GEOMImpl_I3DPrimOperations::GEOMImpl_I3DPrimOperations");
  92   myGroupOperations = new GEOMImpl_IGroupOperations(GetEngine(), GetDocID());
  93 }
  94
  95 //=============================================================================
  96 /*!
  97  *  destructor
  98  */
  99 //=============================================================================
 100 GEOMImpl_I3DPrimOperations::~GEOMImpl_I3DPrimOperations()
 101 {
 102   MESSAGE("GEOMImpl_I3DPrimOperations::~GEOMImpl_I3DPrimOperations");
 103   delete myGroupOperations;
 104 }
 105
 106
 107 //=============================================================================
 108 /*!
 109  *  MakeBoxDXDYDZ
 110  */
 111 //=============================================================================
 112 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeBoxDXDYDZ (double theDX, double theDY, double theDZ)
 113 {
 114   SetErrorCode(KO);
 115
 116   //Add a new Box object
 117   Handle(GEOM_Object) aBox = GetEngine()->AddObject(GetDocID(), GEOM_BOX);
 118
 119   //Add a new Box function with DX_DY_DZ parameters
 120   Handle(GEOM_Function) aFunction = aBox->AddFunction(GEOMImpl_BoxDriver::GetID(), BOX_DX_DY_DZ);
 121   if (aFunction.IsNull()) return NULL;
 122
 123   //Check if the function is set correctly
 124   if (aFunction->GetDriverGUID() != GEOMImpl_BoxDriver::GetID()) return NULL;
 125
 126   GEOMImpl_IBox aBI (aFunction);
 127
 128   aBI.SetDX(theDX);
 129   aBI.SetDY(theDY);
 130   aBI.SetDZ(theDZ);
 131
 132   //Compute the box value
 133   try {
 134     OCC_CATCH_SIGNALS;
 135     if (!GetSolver()->ComputeFunction(aFunction)) {
 136       SetErrorCode("Box driver failed");
 137       return NULL;
 138     }
 139   }
 140   catch (Standard_Failure) {
 141     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 142     SetErrorCode(aFail->GetMessageString());
 143     return NULL;
 144   }
 145
 146   //Make a Python command
 147   GEOM::TPythonDump(aFunction) << aBox << " = geompy.MakeBoxDXDYDZ("
 148     << theDX << ", " << theDY << ", " << theDZ << ")";
 149
 150   SetErrorCode(OK);
 151   return aBox;
 152 }
 153
 154
 155 //=============================================================================
 156 /*!
 157  *  MakeBoxTwoPnt
 158  */
 159 //=============================================================================
 160 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeBoxTwoPnt (Handle(GEOM_Object) thePnt1,
 161                                                                Handle(GEOM_Object) thePnt2)
 162 {
 163   SetErrorCode(KO);
 164
 165   if (thePnt1.IsNull() || thePnt2.IsNull()) return NULL;
 166
 167   //Add a new Box object
 168   Handle(GEOM_Object) aBox = GetEngine()->AddObject(GetDocID(), GEOM_BOX);
 169
 170   //Add a new Box function for creation a box relatively to two points
 171   Handle(GEOM_Function) aFunction = aBox->AddFunction(GEOMImpl_BoxDriver::GetID(), BOX_TWO_PNT);
 172   if (aFunction.IsNull()) return NULL;
 173
 174   //Check if the function is set correctly
 175   if (aFunction->GetDriverGUID() != GEOMImpl_BoxDriver::GetID()) return aBox;
 176
 177   GEOMImpl_IBox aBI (aFunction);
 178
 179   Handle(GEOM_Function) aRefFunction1 = thePnt1->GetLastFunction();
 180   Handle(GEOM_Function) aRefFunction2 = thePnt2->GetLastFunction();
 181
 182   if (aRefFunction1.IsNull() || aRefFunction2.IsNull()) return aBox;
 183
 184   aBI.SetRef1(aRefFunction1);
 185   aBI.SetRef2(aRefFunction2);
 186
 187   //Compute the Box value
 188   try {
 189     OCC_CATCH_SIGNALS;
 190     if (!GetSolver()->ComputeFunction(aFunction)) {
 191       SetErrorCode("Box driver failed");
 192       return NULL;
 193     }
 194   }
 195   catch (Standard_Failure) {
 196     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 197     SetErrorCode(aFail->GetMessageString());
 198     return NULL;
 199   }
 200
 201   //Make a Python command
 202   GEOM::TPythonDump(aFunction) << aBox << " = geompy.MakeBoxTwoPnt("
 203     << thePnt1 << ", " << thePnt2 << ")";
 204
 205   SetErrorCode(OK);
 206   return aBox;
 207 }
 208
 209 //=============================================================================
 210 /*!
 211  *  MakeFaceHW
 212  */
 213 //=============================================================================
 214 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeFaceHW (double theH, double theW, int theOrientation)
 215 {
 216   SetErrorCode(KO);
 217
 218   if (theH == 0 || theW == 0) return NULL;
 219
 220   //Add a new Face object
 221   Handle(GEOM_Object) aFace = GetEngine()->AddObject(GetDocID(), GEOM_FACE);
 222
 223   //Add a new Box function for creation a box relatively to two points
 224   Handle(GEOM_Function) aFunction = aFace->AddFunction(GEOMImpl_FaceDriver::GetID(), FACE_H_W);
 225   if (aFunction.IsNull()) return NULL;
 226
 227   //Check if the function is set correctly
 228   if (aFunction->GetDriverGUID() != GEOMImpl_FaceDriver::GetID()) return aFace;
 229
 230   GEOMImpl_IFace aFI (aFunction);
 231
 232   aFI.SetH(theH);
 233   aFI.SetW(theW);
 234   aFI.SetOrientation(theOrientation);
 235
 236   //Compute the Face
 237   try {
 238     OCC_CATCH_SIGNALS;
 239     if (!GetSolver()->ComputeFunction(aFunction)) {
 240       SetErrorCode("Face driver failed");
 241       return NULL;
 242     }
 243   }
 244   catch (Standard_Failure) {
 245     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 246     SetErrorCode(aFail->GetMessageString());
 247     return NULL;
 248   }
 249
 250   //Make a Python command
 251   GEOM::TPythonDump(aFunction) << aFace << " = geompy.MakeFaceHW("
 252     << theH << ", " << theW << ", " << theOrientation << ")";
 253
 254   SetErrorCode(OK);
 255   return aFace;
 256 }
 257
 258 //=============================================================================
 259 /*!
 260  *  MakeFaceObjHW
 261  */
 262 //=============================================================================
 263 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeFaceObjHW (Handle(GEOM_Object) theObj,
 264                                                                double theH, double theW)
 265 {
 266   SetErrorCode(KO);
 267
 268   if (theObj.IsNull()) return NULL;
 269
 270   //Add a new Face object
 271   Handle(GEOM_Object) aFace = GetEngine()->AddObject(GetDocID(), GEOM_FACE);
 272
 273   //Add a new Box function for creation a box relatively to two points
 274   Handle(GEOM_Function) aFunction = aFace->AddFunction(GEOMImpl_FaceDriver::GetID(), FACE_OBJ_H_W);
 275   if (aFunction.IsNull()) return NULL;
 276
 277   //Check if the function is set correctly
 278   if (aFunction->GetDriverGUID() != GEOMImpl_FaceDriver::GetID()) return aFace;
 279
 280   GEOMImpl_IFace aFI (aFunction);
 281
 282   Handle(GEOM_Function) aRefFunction1 = theObj->GetLastFunction();
 283
 284   if (aRefFunction1.IsNull())
 285     return aFace;
 286
 287   aFI.SetRef1(aRefFunction1);
 288   aFI.SetH(theH);
 289   aFI.SetW(theW);
 290
 291   //Compute the Face
 292   try {
 293     OCC_CATCH_SIGNALS;
 294     if (!GetSolver()->ComputeFunction(aFunction)) {
 295       SetErrorCode("Face driver failed");
 296       return NULL;
 297     }
 298   }
 299   catch (Standard_Failure) {
 300     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 301     SetErrorCode(aFail->GetMessageString());
 302     return NULL;
 303   }
 304
 305   //Make a Python command
 306   GEOM::TPythonDump(aFunction) << aFace << " = geompy.MakeFaceObjHW("
 307     << theObj << ", " << theH << ", " << theW << ")";
 308
 309   SetErrorCode(OK);
 310   return aFace;
 311 }
 312
 313 //=============================================================================
 314 /*!
 315  *  MakeDiskPntVecR
 316  */
 317 //=============================================================================
 318 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeDiskPntVecR
 319       (Handle(GEOM_Object) thePnt, Handle(GEOM_Object) theVec, double theR)
 320 {
 321   SetErrorCode(KO);
 322
 323   if (thePnt.IsNull() || theVec.IsNull()) return NULL;
 324
 325   //Add a new Disk object
 326   Handle(GEOM_Object) aDisk = GetEngine()->AddObject(GetDocID(), GEOM_FACE);
 327
 328   //Add a new Disk function for creation a disk relatively to point and vector
 329   Handle(GEOM_Function) aFunction =
 330     aDisk->AddFunction(GEOMImpl_DiskDriver::GetID(), DISK_PNT_VEC_R);
 331   if (aFunction.IsNull()) return NULL;
 332
 333   //Check if the function is set correctly
 334   if (aFunction->GetDriverGUID() != GEOMImpl_DiskDriver::GetID()) return NULL;
 335
 336   GEOMImpl_IDisk aCI (aFunction);
 337
 338   Handle(GEOM_Function) aRefPnt = thePnt->GetLastFunction();
 339   Handle(GEOM_Function) aRefVec = theVec->GetLastFunction();
 340
 341   if (aRefPnt.IsNull() || aRefVec.IsNull()) return NULL;
 342
 343   aCI.SetCenter(aRefPnt);
 344   aCI.SetVector(aRefVec);
 345   aCI.SetRadius(theR);
 346
 347   //Compute the Disk value
 348   try {
 349     OCC_CATCH_SIGNALS;
 350     if (!GetSolver()->ComputeFunction(aFunction)) {
 351       SetErrorCode("Disk driver failed");
 352       return NULL;
 353     }
 354   }
 355   catch (Standard_Failure) {
 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(aFunction) << aDisk << " = geompy.MakeDiskPntVecR("
 363     << thePnt << ", " << theVec << ", " << theR << ")";
 364
 365   SetErrorCode(OK);
 366   return aDisk;
 367 }
 368
 369 //=============================================================================
 370 /*!
 371  *  MakeDiskThreePnt
 372  */
 373 //=============================================================================
 374 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeDiskThreePnt (Handle(GEOM_Object) thePnt1,
 375                                                                   Handle(GEOM_Object) thePnt2,
 376                                                                   Handle(GEOM_Object) thePnt3)
 377 {
 378   SetErrorCode(KO);
 379
 380   if (thePnt1.IsNull() || thePnt2.IsNull() || thePnt3.IsNull()) return NULL;
 381
 382   //Add a new Disk object
 383   Handle(GEOM_Object) aDisk = GetEngine()->AddObject(GetDocID(), GEOM_FACE);
 384
 385   //Add a new Disk function for creation a disk relatively to three points
 386   Handle(GEOM_Function) aFunction =
 387     aDisk->AddFunction(GEOMImpl_DiskDriver::GetID(), DISK_THREE_PNT);
 388   if (aFunction.IsNull()) return NULL;
 389
 390   //Check if the function is set correctly
 391   if (aFunction->GetDriverGUID() != GEOMImpl_DiskDriver::GetID()) return NULL;
 392
 393   GEOMImpl_IDisk aCI (aFunction);
 394
 395   Handle(GEOM_Function) aRefPnt1 = thePnt1->GetLastFunction();
 396   Handle(GEOM_Function) aRefPnt2 = thePnt2->GetLastFunction();
 397   Handle(GEOM_Function) aRefPnt3 = thePnt3->GetLastFunction();
 398
 399   if (aRefPnt1.IsNull() || aRefPnt2.IsNull() || aRefPnt3.IsNull()) return NULL;
 400
 401   aCI.SetPoint1(aRefPnt1);
 402   aCI.SetPoint2(aRefPnt2);
 403   aCI.SetPoint3(aRefPnt3);
 404
 405   //Compute the Disk value
 406   try {
 407     OCC_CATCH_SIGNALS;
 408     if (!GetSolver()->ComputeFunction(aFunction)) {
 409       SetErrorCode("Disk driver failed");
 410       return NULL;
 411     }
 412   }
 413   catch (Standard_Failure) {
 414     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 415     SetErrorCode(aFail->GetMessageString());
 416     return NULL;
 417   }
 418
 419   //Make a Python command
 420   GEOM::TPythonDump(aFunction) << aDisk << " = geompy.MakeDiskThreePnt("
 421     << thePnt1 << ", " << thePnt2 << ", " << thePnt3 << ")";
 422
 423   SetErrorCode(OK);
 424   return aDisk;
 425 }
 426
 427 //=============================================================================
 428 /*!
 429  *  MakeDiskR
 430  */
 431 //=============================================================================
 432 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeDiskR (double theR, int theOrientation)
 433 {
 434   SetErrorCode(KO);
 435
 436   if (theR == 0 ) return NULL;
 437
 438   //Add a new Disk object
 439   Handle(GEOM_Object) aDisk = GetEngine()->AddObject(GetDocID(), GEOM_FACE);
 440
 441   //Add a new Box function for creation a box relatively to two points
 442   Handle(GEOM_Function) aFunction = aDisk->AddFunction(GEOMImpl_DiskDriver::GetID(), DISK_R);
 443   if (aFunction.IsNull()) return NULL;
 444
 445   //Check if the function is set correctly
 446   if (aFunction->GetDriverGUID() != GEOMImpl_DiskDriver::GetID()) return aDisk;
 447
 448   GEOMImpl_IDisk aDI (aFunction);
 449
 450   aDI.SetRadius(theR);
 451   aDI.SetOrientation(theOrientation);
 452
 453   //Compute the Disk
 454   try {
 455     OCC_CATCH_SIGNALS;
 456     if (!GetSolver()->ComputeFunction(aFunction)) {
 457       SetErrorCode("Disk driver failed");
 458       return NULL;
 459     }
 460   }
 461   catch (Standard_Failure) {
 462     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 463     SetErrorCode(aFail->GetMessageString());
 464     return NULL;
 465   }
 466
 467   //Make a Python command
 468   GEOM::TPythonDump(aFunction) << aDisk << " = geompy.MakeDiskR("
 469     << theR << ", " << theOrientation << ")";
 470
 471   SetErrorCode(OK);
 472   return aDisk;
 473 }
 474
 475 //=============================================================================
 476 /*!
 477  *  MakeCylinderRH
 478  */
 479 //=============================================================================
 480 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeCylinderRH (double theR, double theH)
 481 {
 482   SetErrorCode(KO);
 483
 484   //Add a new Cylinder object
 485   Handle(GEOM_Object) aCylinder = GetEngine()->AddObject(GetDocID(), GEOM_CYLINDER);
 486
 487   //Add a new Cylinder function with R and H parameters
 488   Handle(GEOM_Function) aFunction = aCylinder->AddFunction(GEOMImpl_CylinderDriver::GetID(), CYLINDER_R_H);
 489   if (aFunction.IsNull()) return NULL;
 490
 491   //Check if the function is set correctly
 492   if (aFunction->GetDriverGUID() != GEOMImpl_CylinderDriver::GetID()) return NULL;
 493
 494   GEOMImpl_ICylinder aCI (aFunction);
 495
 496   aCI.SetR(theR);
 497   aCI.SetH(theH);
 498
 499   //Compute the Cylinder value
 500   try {
 501     OCC_CATCH_SIGNALS;
 502     if (!GetSolver()->ComputeFunction(aFunction)) {
 503       SetErrorCode("Cylinder driver failed");
 504       return NULL;
 505     }
 506   }
 507   catch (Standard_Failure) {
 508     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 509     SetErrorCode(aFail->GetMessageString());
 510     return NULL;
 511   }
 512
 513   //Make a Python command
 514   GEOM::TPythonDump(aFunction) << aCylinder
 515     << " = geompy.MakeCylinderRH(" << theR << ", " << theH << ")";
 516
 517   SetErrorCode(OK);
 518   return aCylinder;
 519 }
 520
 521 //=============================================================================
 522 /*!
 523  *  MakeCylinderRHA
 524  */
 525 //=============================================================================
 526 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeCylinderRHA (double theR, double theH, double theA)
 527 {
 528   SetErrorCode(KO);
 529
 530   //Add a new Cylinder object
 531   Handle(GEOM_Object) aCylinder = GetEngine()->AddObject(GetDocID(), GEOM_CYLINDER);
 532
 533   //Add a new Cylinder function with R and H parameters
 534   Handle(GEOM_Function) aFunction = aCylinder->AddFunction(GEOMImpl_CylinderDriver::GetID(), CYLINDER_R_H_A);
 535   if (aFunction.IsNull()) return NULL;
 536
 537   //Check if the function is set correctly
 538   if (aFunction->GetDriverGUID() != GEOMImpl_CylinderDriver::GetID()) return NULL;
 539
 540   GEOMImpl_ICylinder aCI (aFunction);
 541
 542   aCI.SetR(theR);
 543   aCI.SetH(theH);
 544   aCI.SetA(theA);
 545
 546   //Compute the Cylinder value
 547   try {
 548     OCC_CATCH_SIGNALS;
 549     if (!GetSolver()->ComputeFunction(aFunction)) {
 550       SetErrorCode("Cylinder driver failed");
 551       return NULL;
 552     }
 553   }
 554   catch (Standard_Failure) {
 555     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 556     SetErrorCode(aFail->GetMessageString());
 557     return NULL;
 558   }
 559
 560   //Make a Python command
 561   GEOM::TPythonDump(aFunction) << aCylinder
 562     << " = geompy.MakeCylinderRHA(" << theR << ", " << theH << ", " << theA*180./M_PI << "*math.pi/180.)";
 563
 564   SetErrorCode(OK);
 565   return aCylinder;
 566 }
 567
 568 //=============================================================================
 569 /*!
 570  *  MakeCylinderPntVecRH
 571  */
 572 //=============================================================================
 573 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeCylinderPntVecRH (Handle(GEOM_Object) thePnt,
 574                                                                       Handle(GEOM_Object) theVec,
 575                                                                       double theR, double theH)
 576 {
 577   SetErrorCode(KO);
 578
 579   if (thePnt.IsNull() || theVec.IsNull()) return NULL;
 580
 581   //Add a new Cylinder object
 582   Handle(GEOM_Object) aCylinder = GetEngine()->AddObject(GetDocID(), GEOM_CYLINDER);
 583
 584   //Add a new Cylinder function for creation a cylinder relatively to point and vector
 585   Handle(GEOM_Function) aFunction =
 586     aCylinder->AddFunction(GEOMImpl_CylinderDriver::GetID(), CYLINDER_PNT_VEC_R_H);
 587   if (aFunction.IsNull()) return NULL;
 588
 589   //Check if the function is set correctly
 590   if (aFunction->GetDriverGUID() != GEOMImpl_CylinderDriver::GetID()) return NULL;
 591
 592   GEOMImpl_ICylinder aCI (aFunction);
 593
 594   Handle(GEOM_Function) aRefPnt = thePnt->GetLastFunction();
 595   Handle(GEOM_Function) aRefVec = theVec->GetLastFunction();
 596
 597   if (aRefPnt.IsNull() || aRefVec.IsNull()) return NULL;
 598
 599   aCI.SetPoint(aRefPnt);
 600   aCI.SetVector(aRefVec);
 601   aCI.SetR(theR);
 602   aCI.SetH(theH);
 603
 604   //Compute the Cylinder value
 605   try {
 606     OCC_CATCH_SIGNALS;
 607     if (!GetSolver()->ComputeFunction(aFunction)) {
 608       SetErrorCode("Cylinder driver failed");
 609       return NULL;
 610     }
 611   }
 612   catch (Standard_Failure) {
 613     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 614     SetErrorCode(aFail->GetMessageString());
 615     return NULL;
 616   }
 617
 618   //Make a Python command
 619   GEOM::TPythonDump(aFunction) << aCylinder << " = geompy.MakeCylinder("
 620     << thePnt << ", " << theVec << ", " << theR << ", " << theH << ")";
 621
 622   SetErrorCode(OK);
 623   return aCylinder;
 624 }
 625
 626 //=============================================================================
 627 /*!
 628  *  MakeCylinderPntVecRHA
 629  */
 630 //=============================================================================
 631 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeCylinderPntVecRHA (Handle(GEOM_Object) thePnt,
 632                                                                        Handle(GEOM_Object) theVec,
 633                                                                        double theR, double theH, double theA)
 634 {
 635   SetErrorCode(KO);
 636
 637   if (thePnt.IsNull() || theVec.IsNull()) return NULL;
 638
 639   //Add a new Cylinder object
 640   Handle(GEOM_Object) aCylinder = GetEngine()->AddObject(GetDocID(), GEOM_CYLINDER);
 641
 642   //Add a new Cylinder function for creation a cylinder relatively to point and vector
 643   Handle(GEOM_Function) aFunction =
 644     aCylinder->AddFunction(GEOMImpl_CylinderDriver::GetID(), CYLINDER_PNT_VEC_R_H_A);
 645   if (aFunction.IsNull()) return NULL;
 646
 647   //Check if the function is set correctly
 648   if (aFunction->GetDriverGUID() != GEOMImpl_CylinderDriver::GetID()) return NULL;
 649
 650   GEOMImpl_ICylinder aCI (aFunction);
 651
 652   Handle(GEOM_Function) aRefPnt = thePnt->GetLastFunction();
 653   Handle(GEOM_Function) aRefVec = theVec->GetLastFunction();
 654
 655   if (aRefPnt.IsNull() || aRefVec.IsNull()) return NULL;
 656
 657   aCI.SetPoint(aRefPnt);
 658   aCI.SetVector(aRefVec);
 659   aCI.SetR(theR);
 660   aCI.SetH(theH);
 661   aCI.SetA(theA);
 662
 663   //Compute the Cylinder value
 664   try {
 665     OCC_CATCH_SIGNALS;
 666     if (!GetSolver()->ComputeFunction(aFunction)) {
 667       SetErrorCode("Cylinder driver failed");
 668       return NULL;
 669     }
 670   }
 671   catch (Standard_Failure) {
 672     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 673     SetErrorCode(aFail->GetMessageString());
 674     return NULL;
 675   }
 676
 677   //Make a Python command
 678   GEOM::TPythonDump(aFunction) << aCylinder << " = geompy.MakeCylinderA("
 679     << thePnt << ", " << theVec << ", " << theR << ", " << theH << ", " << theA*180./M_PI << "*math.pi/180.)";
 680
 681   SetErrorCode(OK);
 682   return aCylinder;
 683 }
 684
 685
 686 //=============================================================================
 687 /*!
 688  *  MakeConeR1R2H
 689  */
 690 //=============================================================================
 691 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeConeR1R2H (double theR1, double theR2,
 692                                                                double theH)
 693 {
 694   SetErrorCode(KO);
 695
 696   //Add a new Cone object
 697   Handle(GEOM_Object) aCone = GetEngine()->AddObject(GetDocID(), GEOM_CONE);
 698
 699   //Add a new Cone function with R and H parameters
 700   Handle(GEOM_Function) aFunction =
 701     aCone->AddFunction(GEOMImpl_ConeDriver::GetID(), CONE_R1_R2_H);
 702   if (aFunction.IsNull()) return NULL;
 703
 704   //Check if the function is set correctly
 705   if (aFunction->GetDriverGUID() != GEOMImpl_ConeDriver::GetID()) return NULL;
 706
 707   GEOMImpl_ICone aCI (aFunction);
 708
 709   aCI.SetR1(theR1);
 710   aCI.SetR2(theR2);
 711   aCI.SetH(theH);
 712
 713   //Compute the Cone value
 714   try {
 715     OCC_CATCH_SIGNALS;
 716     if (!GetSolver()->ComputeFunction(aFunction)) {
 717       SetErrorCode("Cone driver failed");
 718       return NULL;
 719     }
 720   }
 721   catch (Standard_Failure) {
 722     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 723     SetErrorCode(aFail->GetMessageString());
 724     return NULL;
 725   }
 726
 727   //Make a Python command
 728   GEOM::TPythonDump(aFunction) << aCone << " = geompy.MakeConeR1R2H("
 729     << theR1 << ", " << theR2 << ", " << theH << ")";
 730
 731   SetErrorCode(OK);
 732   return aCone;
 733 }
 734
 735
 736 //=============================================================================
 737 /*!
 738  *  MakeConePntVecR1R2H
 739  */
 740 //=============================================================================
 741 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeConePntVecR1R2H (Handle(GEOM_Object) thePnt,
 742                                                                      Handle(GEOM_Object) theVec,
 743                                                                      double theR1, double theR2,
 744                                                                      double theH)
 745 {
 746   SetErrorCode(KO);
 747
 748   if (thePnt.IsNull() || theVec.IsNull()) return NULL;
 749
 750   //Add a new Cone object
 751   Handle(GEOM_Object) aCone = GetEngine()->AddObject(GetDocID(), GEOM_CONE);
 752
 753   //Add a new Cone function for creation a cone relatively to point and vector
 754   Handle(GEOM_Function) aFunction =
 755     aCone->AddFunction(GEOMImpl_ConeDriver::GetID(), CONE_PNT_VEC_R1_R2_H);
 756   if (aFunction.IsNull()) return NULL;
 757
 758   //Check if the function is set correctly
 759   if (aFunction->GetDriverGUID() != GEOMImpl_ConeDriver::GetID()) return NULL;
 760
 761   GEOMImpl_ICone aCI (aFunction);
 762
 763   Handle(GEOM_Function) aRefPnt = thePnt->GetLastFunction();
 764   Handle(GEOM_Function) aRefVec = theVec->GetLastFunction();
 765
 766   if (aRefPnt.IsNull() || aRefVec.IsNull()) return NULL;
 767
 768   aCI.SetPoint(aRefPnt);
 769   aCI.SetVector(aRefVec);
 770   aCI.SetR1(theR1);
 771   aCI.SetR2(theR2);
 772   aCI.SetH(theH);
 773
 774   //Compute the Cone value
 775   try {
 776     OCC_CATCH_SIGNALS;
 777     if (!GetSolver()->ComputeFunction(aFunction)) {
 778       SetErrorCode("Cone driver failed");
 779       return NULL;
 780     }
 781   }
 782   catch (Standard_Failure) {
 783     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 784     SetErrorCode(aFail->GetMessageString());
 785     return NULL;
 786   }
 787
 788   //Make a Python command
 789   GEOM::TPythonDump(aFunction) << aCone << " = geompy.MakeCone(" << thePnt
 790     << ", " << theVec << ", " << theR1 << ", " << theR2 << ", " << theH << ")";
 791
 792   SetErrorCode(OK);
 793   return aCone;
 794 }
 795
 796
 797 //=============================================================================
 798 /*!
 799  *  MakeSphereR
 800  */
 801 //=============================================================================
 802 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeSphereR (double theR)
 803 {
 804   SetErrorCode(KO);
 805
 806   //Add a new Sphere object
 807   Handle(GEOM_Object) aSphere = GetEngine()->AddObject(GetDocID(), GEOM_SPHERE);
 808
 809   //Add a new Sphere function with R parameter
 810   Handle(GEOM_Function) aFunction = aSphere->AddFunction(GEOMImpl_SphereDriver::GetID(), SPHERE_R);
 811   if (aFunction.IsNull()) return NULL;
 812
 813   //Check if the function is set correctly
 814   if (aFunction->GetDriverGUID() != GEOMImpl_SphereDriver::GetID()) return NULL;
 815
 816   GEOMImpl_ISphere aCI (aFunction);
 817
 818   aCI.SetR(theR);
 819
 820   //Compute the Sphere value
 821   try {
 822     OCC_CATCH_SIGNALS;
 823     if (!GetSolver()->ComputeFunction(aFunction)) {
 824       SetErrorCode("Sphere driver failed");
 825       return NULL;
 826     }
 827   }
 828   catch (Standard_Failure) {
 829     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 830     SetErrorCode(aFail->GetMessageString());
 831     return NULL;
 832   }
 833
 834   //Make a Python command
 835   GEOM::TPythonDump(aFunction) << aSphere << " = geompy.MakeSphereR(" << theR << ")";
 836
 837   SetErrorCode(OK);
 838   return aSphere;
 839 }
 840
 841
 842 //=============================================================================
 843 /*!
 844  *  MakeSpherePntR
 845  */
 846 //=============================================================================
 847 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeSpherePntR (Handle(GEOM_Object) thePnt,
 848                                                                 double theR)
 849 {
 850   SetErrorCode(KO);
 851
 852   if (thePnt.IsNull()) return NULL;
 853
 854   //Add a new Point object
 855   Handle(GEOM_Object) aSphere = GetEngine()->AddObject(GetDocID(), GEOM_SPHERE);
 856
 857   //Add a new Sphere function for creation a sphere relatively to point
 858   Handle(GEOM_Function) aFunction = aSphere->AddFunction(GEOMImpl_SphereDriver::GetID(), SPHERE_PNT_R);
 859   if (aFunction.IsNull()) return NULL;
 860
 861   //Check if the function is set correctly
 862   if (aFunction->GetDriverGUID() != GEOMImpl_SphereDriver::GetID()) return NULL;
 863
 864   GEOMImpl_ISphere aCI (aFunction);
 865
 866   Handle(GEOM_Function) aRefPnt = thePnt->GetLastFunction();
 867
 868   if (aRefPnt.IsNull()) return NULL;
 869
 870   aCI.SetPoint(aRefPnt);
 871   aCI.SetR(theR);
 872
 873   //Compute the Sphere value
 874   try {
 875     OCC_CATCH_SIGNALS;
 876     if (!GetSolver()->ComputeFunction(aFunction)) {
 877       SetErrorCode("Sphere 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(aFunction) << aSphere
 889     << " = geompy.MakeSpherePntR(" << thePnt << ", " << theR << ")";
 890
 891   SetErrorCode(OK);
 892   return aSphere;
 893 }
 894
 895
 896 //=============================================================================
 897 /*!
 898  *  MakeTorusRR
 899  */
 900 //=============================================================================
 901 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeTorusRR
 902                                            (double theRMajor, double theRMinor)
 903 {
 904   SetErrorCode(KO);
 905
 906   //Add a new Torus object
 907   Handle(GEOM_Object) anEll = GetEngine()->AddObject(GetDocID(), GEOM_TORUS);
 908
 909   //Add a new Torus function
 910   Handle(GEOM_Function) aFunction =
 911     anEll->AddFunction(GEOMImpl_TorusDriver::GetID(), TORUS_RR);
 912   if (aFunction.IsNull()) return NULL;
 913
 914   //Check if the function is set correctly
 915   if (aFunction->GetDriverGUID() != GEOMImpl_TorusDriver::GetID()) return NULL;
 916
 917   GEOMImpl_ITorus aCI (aFunction);
 918
 919   aCI.SetRMajor(theRMajor);
 920   aCI.SetRMinor(theRMinor);
 921
 922   //Compute the Torus value
 923   try {
 924     OCC_CATCH_SIGNALS;
 925     if (!GetSolver()->ComputeFunction(aFunction)) {
 926       SetErrorCode("Torus driver failed");
 927       return NULL;
 928     }
 929   }
 930   catch (Standard_Failure) {
 931     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 932     SetErrorCode(aFail->GetMessageString());
 933     return NULL;
 934   }
 935
 936   //Make a Python command
 937   GEOM::TPythonDump(aFunction) << anEll << " = geompy.MakeTorusRR("
 938     << theRMajor << ", " << theRMinor << ")";
 939
 940   SetErrorCode(OK);
 941   return anEll;
 942 }
 943
 944 //=============================================================================
 945 /*!
 946  *  MakeTorusPntVecRR
 947  */
 948 //=============================================================================
 949 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeTorusPntVecRR
 950                        (Handle(GEOM_Object) thePnt, Handle(GEOM_Object) theVec,
 951                         double theRMajor, double theRMinor)
 952 {
 953   SetErrorCode(KO);
 954
 955   if (thePnt.IsNull() || theVec.IsNull()) return NULL;
 956
 957   //Add a new Torus object
 958   Handle(GEOM_Object) anEll = GetEngine()->AddObject(GetDocID(), GEOM_TORUS);
 959
 960   //Add a new Torus function
 961   Handle(GEOM_Function) aFunction =
 962     anEll->AddFunction(GEOMImpl_TorusDriver::GetID(), TORUS_PNT_VEC_RR);
 963   if (aFunction.IsNull()) return NULL;
 964
 965   //Check if the function is set correctly
 966   if (aFunction->GetDriverGUID() != GEOMImpl_TorusDriver::GetID()) return NULL;
 967
 968   GEOMImpl_ITorus aCI (aFunction);
 969
 970   Handle(GEOM_Function) aRefPnt = thePnt->GetLastFunction();
 971   Handle(GEOM_Function) aRefVec = theVec->GetLastFunction();
 972
 973   if (aRefPnt.IsNull() || aRefVec.IsNull()) return NULL;
 974
 975   aCI.SetCenter(aRefPnt);
 976   aCI.SetVector(aRefVec);
 977   aCI.SetRMajor(theRMajor);
 978   aCI.SetRMinor(theRMinor);
 979
 980   //Compute the Torus value
 981   try {
 982     OCC_CATCH_SIGNALS;
 983     if (!GetSolver()->ComputeFunction(aFunction)) {
 984       SetErrorCode("Torus driver failed");
 985       return NULL;
 986     }
 987   }
 988   catch (Standard_Failure) {
 989     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 990     SetErrorCode(aFail->GetMessageString());
 991     return NULL;
 992   }
 993
 994   //Make a Python command
 995   GEOM::TPythonDump(aFunction) << anEll << " = geompy.MakeTorus(" << thePnt
 996     << ", " << theVec << ", " << theRMajor << ", " << theRMinor << ")";
 997
 998   SetErrorCode(OK);
 999   return anEll;
1000 }
1001
1002
1003 //=============================================================================
1004 /*!
1005  *  MakePrismVecH
1006  */
1007 //=============================================================================
1008 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePrismVecH (Handle(GEOM_Object) theBase,
1009                                                                Handle(GEOM_Object) theVec,
1010                                                                double theH, double theScaleFactor)
1011 {
1012   SetErrorCode(KO);
1013
1014   if (theBase.IsNull() || theVec.IsNull()) return NULL;
1015
1016   //Add a new Prism object
1017   Handle(GEOM_Object) aPrism = GetEngine()->AddObject(GetDocID(), GEOM_PRISM);
1018
1019   //Add a new Prism function for creation a Prism relatively to vector
1020   Handle(GEOM_Function) aFunction =
1021     aPrism->AddFunction(GEOMImpl_PrismDriver::GetID(), PRISM_BASE_VEC_H);
1022   if (aFunction.IsNull()) return NULL;
1023
1024   //Check if the function is set correctly
1025   if (aFunction->GetDriverGUID() != GEOMImpl_PrismDriver::GetID()) return NULL;
1026
1027   GEOMImpl_IPrism aCI (aFunction);
1028
1029   Handle(GEOM_Function) aRefBase = theBase->GetLastFunction();
1030   Handle(GEOM_Function) aRefVec  = theVec->GetLastFunction();
1031
1032   if (aRefBase.IsNull() || aRefVec.IsNull()) return NULL;
1033
1034   aCI.SetBase(aRefBase);
1035   aCI.SetVector(aRefVec);
1036   aCI.SetH(theH);
1037   aCI.SetScale(theScaleFactor);
1038
1039   //Compute the Prism value
1040   try {
1041     OCC_CATCH_SIGNALS;
1042     if (!GetSolver()->ComputeFunction(aFunction)) {
1043       //SetErrorCode("Prism driver failed");
1044       SetErrorCode("Extrusion can not be created, check input data");
1045       return NULL;
1046     }
1047   }
1048   catch (Standard_Failure) {
1049     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1050     SetErrorCode(aFail->GetMessageString());
1051     return NULL;
1052   }
1053
1054   //Make a Python command
1055   GEOM::TPythonDump pd (aFunction);
1056   pd << aPrism << " = geompy.MakePrismVecH(" << theBase << ", " << theVec << ", " << theH;
1057   if (theScaleFactor > Precision::Confusion())
1058     pd << ", " << theScaleFactor << ")";
1059   else
1060     pd << ")";
1061
1062   SetErrorCode(OK);
1063   return aPrism;
1064 }
1065
1066 //=============================================================================
1067 /*!
1068  *  MakePrismVecH2Ways
1069  */
1070 //=============================================================================
1071 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePrismVecH2Ways (Handle(GEOM_Object) theBase,
1072                                                                     Handle(GEOM_Object) theVec,
1073                                                                     double theH)
1074 {
1075   SetErrorCode(KO);
1076
1077   if (theBase.IsNull() || theVec.IsNull()) return NULL;
1078
1079   //Add a new Prism object
1080   Handle(GEOM_Object) aPrism = GetEngine()->AddObject(GetDocID(), GEOM_PRISM);
1081
1082   //Add a new Prism function for creation a Prism relatively to vector
1083   Handle(GEOM_Function) aFunction =
1084     aPrism->AddFunction(GEOMImpl_PrismDriver::GetID(), PRISM_BASE_VEC_H_2WAYS);
1085   if (aFunction.IsNull()) return NULL;
1086
1087   //Check if the function is set correctly
1088   if (aFunction->GetDriverGUID() != GEOMImpl_PrismDriver::GetID()) return NULL;
1089
1090   GEOMImpl_IPrism aCI (aFunction);
1091
1092   Handle(GEOM_Function) aRefBase = theBase->GetLastFunction();
1093   Handle(GEOM_Function) aRefVec  = theVec->GetLastFunction();
1094
1095   if (aRefBase.IsNull() || aRefVec.IsNull()) return NULL;
1096
1097   aCI.SetBase(aRefBase);
1098   aCI.SetVector(aRefVec);
1099   aCI.SetH(theH);
1100
1101   //Compute the Prism value
1102   try {
1103     OCC_CATCH_SIGNALS;
1104     if (!GetSolver()->ComputeFunction(aFunction)) {
1105       //SetErrorCode("Prism driver failed");
1106       SetErrorCode("Extrusion can not be created, check input data");
1107       return NULL;
1108     }
1109   }
1110   catch (Standard_Failure) {
1111     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1112     SetErrorCode(aFail->GetMessageString());
1113     return NULL;
1114   }
1115
1116   //Make a Python command
1117   GEOM::TPythonDump(aFunction) << aPrism << " = geompy.MakePrismVecH2Ways("
1118     << theBase << ", " << theVec << ", " << theH << ")";
1119
1120   SetErrorCode(OK);
1121   return aPrism;
1122 }
1123
1124 //=============================================================================
1125 /*!
1126  *  MakePrismTwoPnt
1127  */
1128 //=============================================================================
1129 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePrismTwoPnt
1130        (Handle(GEOM_Object) theBase,
1131         Handle(GEOM_Object) thePoint1, Handle(GEOM_Object) thePoint2,
1132         double theScaleFactor)
1133 {
1134   SetErrorCode(KO);
1135
1136   if (theBase.IsNull() || thePoint1.IsNull() || thePoint2.IsNull()) return NULL;
1137
1138   //Add a new Prism object
1139   Handle(GEOM_Object) aPrism = GetEngine()->AddObject(GetDocID(), GEOM_PRISM);
1140
1141   //Add a new Prism function for creation a Prism relatively to two points
1142   Handle(GEOM_Function) aFunction =
1143     aPrism->AddFunction(GEOMImpl_PrismDriver::GetID(), PRISM_BASE_TWO_PNT);
1144   if (aFunction.IsNull()) return NULL;
1145
1146   //Check if the function is set correctly
1147   if (aFunction->GetDriverGUID() != GEOMImpl_PrismDriver::GetID()) return NULL;
1148
1149   GEOMImpl_IPrism aCI (aFunction);
1150
1151   Handle(GEOM_Function) aRefBase = theBase->GetLastFunction();
1152   Handle(GEOM_Function) aRefPnt1 = thePoint1->GetLastFunction();
1153   Handle(GEOM_Function) aRefPnt2 = thePoint2->GetLastFunction();
1154
1155   if (aRefBase.IsNull() || aRefPnt1.IsNull() || aRefPnt2.IsNull()) return NULL;
1156
1157   aCI.SetBase(aRefBase);
1158   aCI.SetFirstPoint(aRefPnt1);
1159   aCI.SetLastPoint(aRefPnt2);
1160   aCI.SetScale(theScaleFactor);
1161
1162   //Compute the Prism value
1163   try {
1164     OCC_CATCH_SIGNALS;
1165     if (!GetSolver()->ComputeFunction(aFunction)) {
1166       //SetErrorCode("Prism driver failed");
1167       SetErrorCode("Extrusion can not be created, check input data");
1168       return NULL;
1169     }
1170   }
1171   catch (Standard_Failure) {
1172     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1173     SetErrorCode(aFail->GetMessageString());
1174     return NULL;
1175   }
1176
1177   //Make a Python command
1178   GEOM::TPythonDump pd (aFunction);
1179   pd << aPrism << " = geompy.MakePrism(" << theBase << ", " << thePoint1 << ", " << thePoint2;
1180   if (theScaleFactor > Precision::Confusion())
1181     pd << ", " << theScaleFactor << ")";
1182   else
1183     pd << ")";
1184
1185   SetErrorCode(OK);
1186   return aPrism;
1187 }
1188
1189 //=============================================================================
1190 /*!
1191  *  MakePrismTwoPnt2Ways
1192  */
1193 //=============================================================================
1194 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePrismTwoPnt2Ways
1195        (Handle(GEOM_Object) theBase,
1196         Handle(GEOM_Object) thePoint1, Handle(GEOM_Object) thePoint2)
1197 {
1198   SetErrorCode(KO);
1199
1200   if (theBase.IsNull() || thePoint1.IsNull() || thePoint2.IsNull()) return NULL;
1201
1202   //Add a new Prism object
1203   Handle(GEOM_Object) aPrism = GetEngine()->AddObject(GetDocID(), GEOM_PRISM);
1204
1205   //Add a new Prism function for creation a Prism relatively to two points
1206   Handle(GEOM_Function) aFunction =
1207     aPrism->AddFunction(GEOMImpl_PrismDriver::GetID(), PRISM_BASE_TWO_PNT_2WAYS);
1208   if (aFunction.IsNull()) return NULL;
1209
1210   //Check if the function is set correctly
1211   if (aFunction->GetDriverGUID() != GEOMImpl_PrismDriver::GetID()) return NULL;
1212
1213   GEOMImpl_IPrism aCI (aFunction);
1214
1215   Handle(GEOM_Function) aRefBase = theBase->GetLastFunction();
1216   Handle(GEOM_Function) aRefPnt1 = thePoint1->GetLastFunction();
1217   Handle(GEOM_Function) aRefPnt2 = thePoint2->GetLastFunction();
1218
1219   if (aRefBase.IsNull() || aRefPnt1.IsNull() || aRefPnt2.IsNull()) return NULL;
1220
1221   aCI.SetBase(aRefBase);
1222   aCI.SetFirstPoint(aRefPnt1);
1223   aCI.SetLastPoint(aRefPnt2);
1224
1225   //Compute the Prism value
1226   try {
1227     OCC_CATCH_SIGNALS;
1228     if (!GetSolver()->ComputeFunction(aFunction)) {
1229       //SetErrorCode("Prism driver failed");
1230       SetErrorCode("Extrusion can not be created, check input data");
1231       return NULL;
1232     }
1233   }
1234   catch (Standard_Failure) {
1235     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1236     SetErrorCode(aFail->GetMessageString());
1237     return NULL;
1238   }
1239
1240   //Make a Python command
1241   GEOM::TPythonDump(aFunction) << aPrism << " = geompy.MakePrism2Ways("
1242     << theBase << ", " << thePoint1 << ", " << thePoint2 << ")";
1243
1244   SetErrorCode(OK);
1245   return aPrism;
1246 }
1247
1248 //=============================================================================
1249 /*!
1250  *  MakePrismDXDYDZ
1251  */
1252 //=============================================================================
1253 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePrismDXDYDZ
1254        (Handle(GEOM_Object) theBase, double theDX, double theDY, double theDZ,
1255         double theScaleFactor)
1256 {
1257   SetErrorCode(KO);
1258
1259   if (theBase.IsNull()) return NULL;
1260
1261   //Add a new Prism object
1262   Handle(GEOM_Object) aPrism = GetEngine()->AddObject(GetDocID(), GEOM_PRISM);
1263
1264   //Add a new Prism function for creation a Prism by DXDYDZ
1265   Handle(GEOM_Function) aFunction =
1266     aPrism->AddFunction(GEOMImpl_PrismDriver::GetID(), PRISM_BASE_DXDYDZ);
1267   if (aFunction.IsNull()) return NULL;
1268
1269   //Check if the function is set correctly
1270   if (aFunction->GetDriverGUID() != GEOMImpl_PrismDriver::GetID()) return NULL;
1271
1272   GEOMImpl_IPrism aCI (aFunction);
1273
1274   Handle(GEOM_Function) aRefBase = theBase->GetLastFunction();
1275
1276   if (aRefBase.IsNull()) return NULL;
1277
1278   aCI.SetBase(aRefBase);
1279   aCI.SetDX(theDX);
1280   aCI.SetDY(theDY);
1281   aCI.SetDZ(theDZ);
1282   aCI.SetScale(theScaleFactor);
1283
1284   //Compute the Prism value
1285   try {
1286     OCC_CATCH_SIGNALS;
1287     if (!GetSolver()->ComputeFunction(aFunction)) {
1288       SetErrorCode("Extrusion can not be created, check input data");
1289       return NULL;
1290     }
1291   }
1292   catch (Standard_Failure) {
1293     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1294     SetErrorCode(aFail->GetMessageString());
1295     return NULL;
1296   }
1297
1298   //Make a Python command
1299   GEOM::TPythonDump pd (aFunction);
1300   pd << aPrism << " = geompy.MakePrismDXDYDZ("
1301      << theBase << ", " << theDX << ", " << theDY << ", " << theDZ;
1302   if (theScaleFactor > Precision::Confusion())
1303     pd << ", " << theScaleFactor << ")";
1304   else
1305     pd << ")";
1306
1307   SetErrorCode(OK);
1308   return aPrism;
1309 }
1310
1311 //=============================================================================
1312 /*!
1313  *  MakePrismDXDYDZ_2WAYS
1314  */
1315 //=============================================================================
1316 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePrismDXDYDZ2Ways
1317        (Handle(GEOM_Object) theBase, double theDX, double theDY, double theDZ)
1318 {
1319   SetErrorCode(KO);
1320
1321   if (theBase.IsNull()) return NULL;
1322
1323   //Add a new Prism object
1324   Handle(GEOM_Object) aPrism = GetEngine()->AddObject(GetDocID(), GEOM_PRISM);
1325
1326   //Add a new Prism function for creation a Prism by DXDYDZ
1327   Handle(GEOM_Function) aFunction =
1328     aPrism->AddFunction(GEOMImpl_PrismDriver::GetID(), PRISM_BASE_DXDYDZ_2WAYS);
1329   if (aFunction.IsNull()) return NULL;
1330
1331   //Check if the function is set correctly
1332   if (aFunction->GetDriverGUID() != GEOMImpl_PrismDriver::GetID()) return NULL;
1333
1334   GEOMImpl_IPrism aCI (aFunction);
1335
1336   Handle(GEOM_Function) aRefBase = theBase->GetLastFunction();
1337
1338   if (aRefBase.IsNull()) return NULL;
1339
1340   aCI.SetBase(aRefBase);
1341   aCI.SetDX(theDX);
1342   aCI.SetDY(theDY);
1343   aCI.SetDZ(theDZ);
1344
1345   //Compute the Prism value
1346   try {
1347     OCC_CATCH_SIGNALS;
1348     if (!GetSolver()->ComputeFunction(aFunction)) {
1349       SetErrorCode("Extrusion can not be created, check input data");
1350       return NULL;
1351     }
1352   }
1353   catch (Standard_Failure) {
1354     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1355     SetErrorCode(aFail->GetMessageString());
1356     return NULL;
1357   }
1358
1359   //Make a Python command
1360   GEOM::TPythonDump(aFunction) << aPrism << " = geompy.MakePrismDXDYDZ2Ways("
1361     << theBase << ", " << theDX << ", " << theDY << ", " << theDZ << ")";
1362
1363   SetErrorCode(OK);
1364   return aPrism;
1365 }
1366
1367 //=============================================================================
1368 /*!
1369  *  MakeDraftPrism
1370  */
1371 //=============================================================================
1372 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeDraftPrism
1373        (Handle(GEOM_Object) theInitShape ,Handle(GEOM_Object) theBase, double theHeight, double theAngle, bool theFuse, bool theInvert)
1374 {
1375   SetErrorCode(KO);
1376
1377   if (theBase.IsNull() || theInitShape.IsNull()) return NULL;
1378
1379   Handle(GEOM_Object) aPrism = NULL;
1380
1381   if ( theFuse )
1382   {
1383     //Add a new Extruded Boss object
1384     aPrism = GetEngine()->AddObject(GetDocID(), GEOM_EXTRUDED_BOSS);
1385   }
1386   else
1387   {
1388     //Add a new Extruded Cut object
1389     aPrism = GetEngine()->AddObject(GetDocID(), GEOM_EXTRUDED_CUT);
1390   }
1391
1392   //Add a new Prism function for the creation of a Draft Prism feature
1393   Handle(GEOM_Function) aFunction =
1394     aPrism->AddFunction(GEOMImpl_PrismDriver::GetID(), DRAFT_PRISM_FEATURE);
1395   if (aFunction.IsNull()) return NULL;
1396
1397   //Check if the function is set correctly
1398   if (aFunction->GetDriverGUID() != GEOMImpl_PrismDriver::GetID()) return NULL;
1399
1400   GEOMImpl_IPrism aCI (aFunction);
1401
1402   Handle(GEOM_Function) aRefInit = theInitShape->GetLastFunction();
1403   Handle(GEOM_Function) aRefBase = theBase->GetLastFunction();
1404
1405   if (aRefBase.IsNull() || aRefInit.IsNull()) return NULL;
1406
1407   // Set parameters
1408   aCI.SetBase(aRefBase);
1409   aCI.SetInitShape(aRefInit);
1410   aCI.SetH(theHeight);
1411   aCI.SetDraftAngle(theAngle);
1412   if ( theFuse )
1413     aCI.SetFuseFlag(1);
1414   else
1415     aCI.SetFuseFlag(0);
1416   aCI.SetInvertFlag(theInvert);
1417
1418   //Compute the Draft Prism Feature value
1419   try {
1420     OCC_CATCH_SIGNALS;
1421     if (!GetSolver()->ComputeFunction(aFunction)) {
1422       SetErrorCode("Extrusion can not be created, check input data");
1423       return NULL;
1424     }
1425   }
1426   catch (Standard_Failure) {
1427     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1428     SetErrorCode(aFail->GetMessageString());
1429     return NULL;
1430   }
1431
1432   //Make a Python command
1433   GEOM::TPythonDump pd (aFunction);
1434   if(theFuse)
1435   {
1436     pd << aPrism << " = geompy.MakeExtrudedBoss(" << theInitShape << ", " << theBase << ", "
1437       << theHeight << ", " << theAngle;
1438   }
1439   else
1440   {
1441     pd << aPrism << " = geompy.MakeExtrudedCut(" << theInitShape << ", " << theBase << ", "
1442       << theHeight << ", " << theAngle;
1443   }
1444   if (theInvert)
1445     pd << ", " << theInvert;
1446   pd << ")";
1447
1448   SetErrorCode(OK);
1449   return aPrism;
1450 }
1451
1452 //=============================================================================
1453 /*!
1454  *  MakePipe
1455  */
1456 //=============================================================================
1457 Handle(TColStd_HSequenceOfTransient) GEOMImpl_I3DPrimOperations::MakePipe
1458                             (const Handle(GEOM_Object) &theBase,
1459                              const Handle(GEOM_Object) &thePath,
1460                              const bool                 IsGenerateGroups)
1461 {
1462   SetErrorCode(KO);
1463
1464   if (theBase.IsNull() || thePath.IsNull()) return NULL;
1465
1466   //Add a new Pipe object
1467   Handle(GEOM_Object) aPipe = GetEngine()->AddObject(GetDocID(), GEOM_PIPE);
1468
1469   //Add a new Pipe function
1470   Handle(GEOM_Function) aFunction =
1471     aPipe->AddFunction(GEOMImpl_PipeDriver::GetID(), PIPE_BASE_PATH);
1472   if (aFunction.IsNull()) return NULL;
1473
1474   //Check if the function is set correctly
1475   if (aFunction->GetDriverGUID() != GEOMImpl_PipeDriver::GetID()) return NULL;
1476
1477   GEOMImpl_IPipe aCI (aFunction);
1478
1479   Handle(GEOM_Function) aRefBase = theBase->GetLastFunction();
1480   Handle(GEOM_Function) aRefPath = thePath->GetLastFunction();
1481
1482   if (aRefBase.IsNull() || aRefPath.IsNull()) return NULL;
1483
1484   aCI.SetBase(aRefBase);
1485   aCI.SetPath(aRefPath);
1486   aCI.SetGenerateGroups(IsGenerateGroups);
1487
1488   //Compute the Pipe value
1489   try {
1490     OCC_CATCH_SIGNALS;
1491     if (!GetSolver()->ComputeFunction(aFunction)) {
1492       SetErrorCode("Pipe driver failed");
1493       return NULL;
1494     }
1495   }
1496   catch (Standard_Failure) {
1497     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1498     SetErrorCode(aFail->GetMessageString());
1499     return NULL;
1500   }
1501
1502   // Create the sequence of objects.
1503   Handle(TColStd_HSequenceOfTransient) aSeq = new TColStd_HSequenceOfTransient;
1504
1505   aSeq->Append(aPipe);
1506   createGroups(aPipe, &aCI, aSeq);
1507
1508   //Make a Python command
1509   GEOM::TPythonDump pyDump(aFunction);
1510
1511   if (IsGenerateGroups) {
1512     pyDump << aSeq;
1513   } else {
1514     pyDump << aPipe;
1515   }
1516
1517   pyDump << " = geompy.MakePipe(" << theBase << ", " << thePath;
1518
1519   if (IsGenerateGroups) {
1520     pyDump << ", True";
1521   }
1522
1523   pyDump << ")";
1524
1525   SetErrorCode(OK);
1526   return aSeq;
1527 }
1528
1529
1530 //=============================================================================
1531 /*!
1532  *  MakeRevolutionAxisAngle
1533  */
1534 //=============================================================================
1535 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeRevolutionAxisAngle (Handle(GEOM_Object) theBase,
1536                                                                          Handle(GEOM_Object) theAxis,
1537                                                                          double theAngle)
1538 {
1539   SetErrorCode(KO);
1540
1541   if (theBase.IsNull() || theAxis.IsNull()) return NULL;
1542
1543   //Add a new Revolution object
1544   Handle(GEOM_Object) aRevolution = GetEngine()->AddObject(GetDocID(), GEOM_REVOLUTION);
1545
1546   //Add a new Revolution function for creation a revolution relatively to axis
1547   Handle(GEOM_Function) aFunction =
1548     aRevolution->AddFunction(GEOMImpl_RevolutionDriver::GetID(), REVOLUTION_BASE_AXIS_ANGLE);
1549   if (aFunction.IsNull()) return NULL;
1550
1551   //Check if the function is set correctly
1552   if (aFunction->GetDriverGUID() != GEOMImpl_RevolutionDriver::GetID()) return NULL;
1553
1554   GEOMImpl_IRevolution aCI (aFunction);
1555
1556   Handle(GEOM_Function) aRefBase = theBase->GetLastFunction();
1557   Handle(GEOM_Function) aRefAxis = theAxis->GetLastFunction();
1558
1559   if (aRefBase.IsNull() || aRefAxis.IsNull()) return NULL;
1560
1561   aCI.SetBase(aRefBase);
1562   aCI.SetAxis(aRefAxis);
1563   aCI.SetAngle(theAngle);
1564
1565   //Compute the Revolution value
1566   try {
1567     OCC_CATCH_SIGNALS;
1568     if (!GetSolver()->ComputeFunction(aFunction)) {
1569       SetErrorCode("Revolution driver failed");
1570       return NULL;
1571     }
1572   }
1573   catch (Standard_Failure) {
1574     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1575     SetErrorCode(aFail->GetMessageString());
1576     return NULL;
1577   }
1578
1579   //Make a Python command
1580   GEOM::TPythonDump(aFunction) << aRevolution << " = geompy.MakeRevolution("
1581     << theBase << ", " << theAxis << ", " << theAngle * 180.0 / M_PI << "*math.pi/180.0)";
1582
1583   SetErrorCode(OK);
1584   return aRevolution;
1585 }
1586
1587 //=============================================================================
1588 /*!
1589  *  MakeRevolutionAxisAngle2Ways
1590  */
1591 //=============================================================================
1592 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeRevolutionAxisAngle2Ways
1593                    (Handle(GEOM_Object) theBase, Handle(GEOM_Object) theAxis, double theAngle)
1594 {
1595   SetErrorCode(KO);
1596
1597   if (theBase.IsNull() || theAxis.IsNull()) return NULL;
1598
1599   //Add a new Revolution object
1600   Handle(GEOM_Object) aRevolution = GetEngine()->AddObject(GetDocID(), GEOM_REVOLUTION);
1601
1602   //Add a new Revolution function for creation a revolution relatively to axis
1603   Handle(GEOM_Function) aFunction =
1604     aRevolution->AddFunction(GEOMImpl_RevolutionDriver::GetID(), REVOLUTION_BASE_AXIS_ANGLE_2WAYS);
1605   if (aFunction.IsNull()) return NULL;
1606
1607   //Check if the function is set correctly
1608   if (aFunction->GetDriverGUID() != GEOMImpl_RevolutionDriver::GetID()) return NULL;
1609
1610   GEOMImpl_IRevolution aCI (aFunction);
1611
1612   Handle(GEOM_Function) aRefBase = theBase->GetLastFunction();
1613   Handle(GEOM_Function) aRefAxis = theAxis->GetLastFunction();
1614
1615   if (aRefBase.IsNull() || aRefAxis.IsNull()) return NULL;
1616
1617   aCI.SetBase(aRefBase);
1618   aCI.SetAxis(aRefAxis);
1619   aCI.SetAngle(theAngle);
1620
1621   //Compute the Revolution value
1622   try {
1623     OCC_CATCH_SIGNALS;
1624     if (!GetSolver()->ComputeFunction(aFunction)) {
1625       SetErrorCode("Revolution driver failed");
1626       return NULL;
1627     }
1628   }
1629   catch (Standard_Failure) {
1630     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1631     SetErrorCode(aFail->GetMessageString());
1632     return NULL;
1633   }
1634
1635   //Make a Python command
1636   GEOM::TPythonDump(aFunction) << aRevolution << " = geompy.MakeRevolution2Ways("
1637     << theBase << ", " << theAxis << ", " << theAngle * 180.0 / M_PI << "*math.pi/180.0)";
1638
1639   SetErrorCode(OK);
1640   return aRevolution;
1641 }
1642
1643 //=============================================================================
1644 /*!
1645  *  MakeFilling
1646  */
1647 //=============================================================================
1648 Handle(GEOM_Object)
1649 GEOMImpl_I3DPrimOperations::MakeFilling (std::list< Handle(GEOM_Object)> & theContours,
1650                                          int theMinDeg, int theMaxDeg,
1651                                          double theTol2D, double theTol3D, int theNbIter,
1652                                          int theMethod, bool isApprox)
1653 {
1654   SetErrorCode(KO);
1655
1656   Handle(TColStd_HSequenceOfTransient) contours = GEOM_Object::GetLastFunctions( theContours );
1657   if ( contours.IsNull() || contours->IsEmpty() ) {
1658     SetErrorCode("NULL argument shape");
1659     return NULL;
1660   }
1661   //Add a new Filling object
1662   Handle(GEOM_Object) aFilling = GetEngine()->AddObject(GetDocID(), GEOM_FILLING);
1663
1664   //Add a new Filling function for creation a filling  from a compound
1665   Handle(GEOM_Function) aFunction = aFilling->AddFunction(GEOMImpl_FillingDriver::GetID(), BASIC_FILLING);
1666   if (aFunction.IsNull()) return NULL;
1667
1668   //Check if the function is set correctly
1669   if (aFunction->GetDriverGUID() != GEOMImpl_FillingDriver::GetID()) return NULL;
1670
1671   GEOMImpl_IFilling aFI (aFunction);
1672   aFI.SetShapes(contours);
1673   aFI.SetMinDeg(theMinDeg);
1674   aFI.SetMaxDeg(theMaxDeg);
1675   aFI.SetTol2D(theTol2D);
1676   aFI.SetTol3D(theTol3D);
1677   aFI.SetNbIter(theNbIter);
1678   aFI.SetApprox(isApprox);
1679   aFI.SetMethod(theMethod);
1680
1681   //Compute the Solid value
1682   try {
1683     OCC_CATCH_SIGNALS;
1684     if (!GetSolver()->ComputeFunction(aFunction)) {
1685       SetErrorCode("Filling driver failed");
1686       return NULL;
1687     }
1688   }
1689   catch (Standard_Failure) {
1690     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1691     if (strcmp(aFail->GetMessageString(), "Geom_BSplineSurface") == 0)
1692       SetErrorCode("B-Spline surface construction failed");
1693     else
1694       SetErrorCode(aFail->GetMessageString());
1695     return NULL;
1696   }
1697
1698   //Make a Python command
1699   GEOM::TPythonDump pd (aFunction);
1700   pd << aFilling << " = geompy.MakeFilling(" << theContours ;
1701   if ( theMinDeg != 2 )   pd << ", theMinDeg=" << theMinDeg ;
1702   if ( theMaxDeg != 5 )   pd << ", theMaxDeg=" << theMaxDeg ;
1703   if ( fabs(theTol2D-0.0001) > Precision::Confusion() )
1704   {                       pd << ", theTol2D=" << theTol2D ; }
1705   if ( fabs(theTol3D-0.0001) > Precision::Confusion() )
1706   {                       pd << ", theTol3D=" << theTol3D ; }
1707   if ( theNbIter != 0 )   pd << ", theNbIter=" << theNbIter ;
1708   if ( theMethod==1 )     pd << ", theMethod=GEOM.FOM_UseOri";
1709   else if( theMethod==2 ) pd << ", theMethod=GEOM.FOM_AutoCorrect";
1710   if ( isApprox )         pd << ", isApprox=" << isApprox ;
1711   pd << ")";
1712
1713   SetErrorCode(OK);
1714   return aFilling;
1715 }
1716
1717 //=============================================================================
1718 /*!
1719  *  MakeThruSections
1720  */
1721 //=============================================================================
1722 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeThruSections(
1723                                                 const Handle(TColStd_HSequenceOfTransient)& theSeqSections,
1724                                                 bool theModeSolid,
1725                                                 double thePreci,
1726                                                 bool theRuled)
1727 {
1728   Handle(GEOM_Object) anObj;
1729   SetErrorCode(KO);
1730   if(theSeqSections.IsNull())
1731     return anObj;
1732
1733   Standard_Integer nbObj = theSeqSections->Length();
1734   if (!nbObj)
1735     return anObj;
1736
1737   //Add a new ThruSections object
1738   Handle(GEOM_Object) aThruSect = GetEngine()->AddObject(GetDocID(), GEOM_THRUSECTIONS);
1739
1740
1741   //Add a new ThruSections function
1742
1743   int aTypeFunc = (theRuled ? THRUSECTIONS_RULED : THRUSECTIONS_SMOOTHED);
1744   Handle(GEOM_Function) aFunction =
1745     aThruSect->AddFunction(GEOMImpl_ThruSectionsDriver::GetID(), aTypeFunc);
1746   if (aFunction.IsNull()) return anObj;
1747
1748   //Check if the function is set correctly
1749   if (aFunction->GetDriverGUID() != GEOMImpl_ThruSectionsDriver::GetID()) return NULL;
1750
1751   GEOMImpl_IThruSections aCI (aFunction);
1752
1753   Handle(TColStd_HSequenceOfTransient) aSeqSections = new TColStd_HSequenceOfTransient;
1754
1755   Standard_Integer i =1;
1756   for( ; i <= nbObj; i++) {
1757
1758     Handle(Standard_Transient) anItem = theSeqSections->Value(i);
1759     if(anItem.IsNull())
1760       continue;
1761
1762     Handle(GEOM_Object) aSectObj = Handle(GEOM_Object)::DownCast(anItem);
1763     if(!aSectObj.IsNull())
1764     {
1765       Handle(GEOM_Function) aRefSect = aSectObj->GetLastFunction();
1766       if(!aRefSect.IsNull())
1767         aSeqSections->Append(aRefSect);
1768     }
1769   }
1770
1771   if(!aSeqSections->Length())
1772     return anObj;
1773
1774   aCI.SetSections(aSeqSections);
1775   aCI.SetSolidMode(theModeSolid);
1776   aCI.SetPrecision(thePreci);
1777
1778   //Compute the ThruSections value
1779   try {
1780     OCC_CATCH_SIGNALS;
1781     if (!GetSolver()->ComputeFunction(aFunction)) {
1782       SetErrorCode("ThruSections driver failed");
1783       return anObj;
1784     }
1785   }
1786   catch (Standard_Failure) {
1787     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1788     SetErrorCode(aFail->GetMessageString());
1789     return anObj;
1790   }
1791
1792   //Make a Python command
1793   GEOM::TPythonDump pyDump(aFunction);
1794   pyDump << aThruSect << " = geompy.MakeThruSections([";
1795
1796   for(i =1 ; i <= nbObj; i++) {
1797
1798     Handle(Standard_Transient) anItem = theSeqSections->Value(i);
1799     if(anItem.IsNull())
1800       continue;
1801
1802     Handle(GEOM_Object) aSectObj = Handle(GEOM_Object)::DownCast(anItem);
1803     if(!aSectObj.IsNull()) {
1804       pyDump<< aSectObj;
1805       if(i < nbObj)
1806         pyDump<<", ";
1807     }
1808   }
1809
1810   pyDump<< "],"<<theModeSolid << "," << thePreci <<","<< theRuled <<")";
1811
1812   SetErrorCode(OK);
1813   return aThruSect;
1814 }
1815
1816
1817 //=============================================================================
1818 /*!
1819  *  MakePipeWithDifferentSections
1820  */
1821 //=============================================================================
1822 Handle(TColStd_HSequenceOfTransient)
1823   GEOMImpl_I3DPrimOperations::MakePipeWithDifferentSections
1824               (const Handle(TColStd_HSequenceOfTransient) &theBases,
1825                const Handle(TColStd_HSequenceOfTransient) &theLocations,
1826                const Handle(GEOM_Object)                  &thePath,
1827                const bool                                  theWithContact,
1828                const bool                                  theWithCorrections,
1829                const bool                                  IsBySteps,
1830                const bool                                  IsGenerateGroups)
1831 {
1832   SetErrorCode(KO);
1833   if(theBases.IsNull())
1834     return NULL;
1835
1836   Standard_Integer nbBases = theBases->Length();
1837
1838   if (!nbBases)
1839     return NULL;
1840
1841   Standard_Integer nbLocs =  (theLocations.IsNull() ? 0 :theLocations->Length());
1842   //Add a new Pipe object
1843   Handle(GEOM_Object) aPipeDS = GetEngine()->AddObject(GetDocID(), GEOM_PIPE);
1844
1845   //Add a new Pipe function
1846
1847   Handle(GEOM_Function) aFunction =
1848     aPipeDS->AddFunction(GEOMImpl_PipeDriver::GetID(), PIPE_DIFFERENT_SECTIONS);
1849   if (aFunction.IsNull()) return NULL;
1850
1851   //Check if the function is set correctly
1852   if (aFunction->GetDriverGUID() != GEOMImpl_PipeDriver::GetID()) return NULL;
1853
1854   GEOMImpl_IPipeDiffSect aCI (aFunction);
1855
1856   Handle(GEOM_Function) aRefPath = thePath->GetLastFunction();
1857   if(aRefPath.IsNull())
1858     return NULL;
1859
1860   Handle(TColStd_HSequenceOfTransient) aSeqBases = new TColStd_HSequenceOfTransient;
1861   Handle(TColStd_HSequenceOfTransient) aSeqLocs = new TColStd_HSequenceOfTransient;
1862
1863   Standard_Integer i =1;
1864   for( ; i <= nbBases; i++) {
1865
1866     Handle(Standard_Transient) anItem = theBases->Value(i);
1867     if(anItem.IsNull())
1868       continue;
1869
1870     Handle(GEOM_Object) aBase = Handle(GEOM_Object)::DownCast(anItem);
1871     if(aBase.IsNull())
1872       continue;
1873     Handle(GEOM_Function) aRefBase = aBase->GetLastFunction();
1874     if(aRefBase.IsNull())
1875       continue;
1876     if(nbLocs)
1877     {
1878       Handle(Standard_Transient) anItemLoc = theLocations->Value(i);
1879       if(anItemLoc.IsNull())
1880         continue;
1881
1882       Handle(GEOM_Object) aLoc = Handle(GEOM_Object)::DownCast(anItemLoc);
1883       if(aLoc.IsNull())
1884         continue;
1885       Handle(GEOM_Function) aRefLoc = aLoc->GetLastFunction();
1886       if(aRefLoc.IsNull())
1887         continue;
1888       aSeqLocs->Append(aRefLoc);
1889     }
1890     aSeqBases->Append(aRefBase);
1891   }
1892
1893   if(!aSeqBases->Length())
1894     return NULL;
1895
1896   aCI.SetBases(aSeqBases);
1897   aCI.SetLocations(aSeqLocs);
1898   aCI.SetPath(aRefPath);
1899
1900   if (!IsBySteps) {
1901     aCI.SetWithContactMode(theWithContact);
1902     aCI.SetWithCorrectionMode(theWithCorrections);
1903   }
1904
1905   aCI.SetIsBySteps(IsBySteps);
1906   aCI.SetGenerateGroups(IsGenerateGroups);
1907
1908   //Compute the Pipe value
1909   try {
1910     OCC_CATCH_SIGNALS;
1911     if (!GetSolver()->ComputeFunction(aFunction)) {
1912       SetErrorCode("Pipe with defferent section driver failed");
1913       return NULL;
1914     }
1915   }
1916   catch (Standard_Failure) {
1917     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
1918     SetErrorCode(aFail->GetMessageString());
1919     return NULL;
1920   }
1921
1922   // Create the sequence of objects.
1923   Handle(TColStd_HSequenceOfTransient) aSeq = new TColStd_HSequenceOfTransient;
1924
1925   aSeq->Append(aPipeDS);
1926   createGroups(aPipeDS, &aCI, aSeq);
1927
1928   //Make a Python command
1929   GEOM::TPythonDump pyDump(aFunction);
1930
1931   if (IsGenerateGroups) {
1932     pyDump << aSeq;
1933   } else {
1934     pyDump << aPipeDS;
1935   }
1936
1937   if (IsBySteps) {
1938     pyDump << " = geompy.MakePipeWithDifferentSectionsBySteps([";
1939   } else {
1940     pyDump << " = geompy.MakePipeWithDifferentSections([";
1941   }
1942
1943   for(i =1 ; i <= nbBases; i++) {
1944
1945     Handle(Standard_Transient) anItem = theBases->Value(i);
1946     if(anItem.IsNull())
1947       continue;
1948
1949     Handle(GEOM_Object) anObj = Handle(GEOM_Object)::DownCast(anItem);
1950     if(!anObj.IsNull()) {
1951       pyDump<< anObj;
1952       if(i < nbBases)
1953         pyDump<<", ";
1954     }
1955   }
1956
1957   pyDump<< "], [";
1958
1959   for(i =1 ; i <= nbLocs; i++) {
1960
1961     Handle(Standard_Transient) anItem = theLocations->Value(i);
1962     if(anItem.IsNull())
1963       continue;
1964
1965     Handle(GEOM_Object) anObj = Handle(GEOM_Object)::DownCast(anItem);
1966     if(!anObj.IsNull()) {
1967       pyDump<< anObj;
1968       if(i < nbLocs)
1969         pyDump<<", ";
1970     }
1971   }
1972
1973   pyDump<< "], "<<thePath;
1974
1975   if (!IsBySteps) {
1976     pyDump<<","<<theWithContact << "," << theWithCorrections;
1977   }
1978
1979   if (IsGenerateGroups) {
1980     pyDump << ", True";
1981   }
1982
1983   pyDump << ")";
1984
1985   SetErrorCode(OK);
1986   return aSeq;
1987 }
1988
1989
1990 //=============================================================================
1991 /*!
1992  *  MakePipeWithShellSections
1993  */
1994 //=============================================================================
1995 Handle(TColStd_HSequenceOfTransient)
1996       GEOMImpl_I3DPrimOperations::MakePipeWithShellSections
1997               (const Handle(TColStd_HSequenceOfTransient) &theBases,
1998                const Handle(TColStd_HSequenceOfTransient) &theSubBases,
1999                const Handle(TColStd_HSequenceOfTransient) &theLocations,
2000                const Handle(GEOM_Object)                  &thePath,
2001                const bool                                  theWithContact,
2002                const bool                                  theWithCorrections,
2003                const bool                                  IsGenerateGroups)
2004 {
2005   SetErrorCode(KO);
2006   if(theBases.IsNull())
2007     return NULL;
2008
2009   Standard_Integer nbBases = theBases->Length();
2010
2011   if (!nbBases)
2012     return NULL;
2013
2014   Standard_Integer nbSubBases =  (theSubBases.IsNull() ? 0 :theSubBases->Length());
2015
2016   Standard_Integer nbLocs =  (theLocations.IsNull() ? 0 :theLocations->Length());
2017
2018   //Add a new Pipe object
2019   Handle(GEOM_Object) aPipeDS = GetEngine()->AddObject(GetDocID(), GEOM_PIPE);
2020
2021   //Add a new Pipe function
2022
2023   Handle(GEOM_Function) aFunction =
2024     aPipeDS->AddFunction(GEOMImpl_PipeDriver::GetID(), PIPE_SHELL_SECTIONS);
2025   if (aFunction.IsNull()) return NULL;
2026
2027   //Check if the function is set correctly
2028   if (aFunction->GetDriverGUID() != GEOMImpl_PipeDriver::GetID()) return NULL;
2029
2030   //GEOMImpl_IPipeDiffSect aCI (aFunction);
2031   GEOMImpl_IPipeShellSect aCI (aFunction);
2032
2033   Handle(GEOM_Function) aRefPath = thePath->GetLastFunction();
2034   if(aRefPath.IsNull())
2035     return NULL;
2036
2037   Handle(TColStd_HSequenceOfTransient) aSeqBases = new TColStd_HSequenceOfTransient;
2038   Handle(TColStd_HSequenceOfTransient) aSeqSubBases = new TColStd_HSequenceOfTransient;
2039   Handle(TColStd_HSequenceOfTransient) aSeqLocs = new TColStd_HSequenceOfTransient;
2040
2041   Standard_Integer i =1;
2042   for( ; i <= nbBases; i++) {
2043
2044     Handle(Standard_Transient) anItem = theBases->Value(i);
2045     if(anItem.IsNull())
2046       continue;
2047     Handle(GEOM_Object) aBase = Handle(GEOM_Object)::DownCast(anItem);
2048     if(aBase.IsNull())
2049       continue;
2050     Handle(GEOM_Function) aRefBase = aBase->GetLastFunction();
2051     if(aRefBase.IsNull())
2052       continue;
2053
2054     if( nbSubBases >= nbBases ) {
2055       Handle(Standard_Transient) aSubItem = theSubBases->Value(i);
2056       if(aSubItem.IsNull())
2057         continue;
2058       Handle(GEOM_Object) aSubBase = Handle(GEOM_Object)::DownCast(aSubItem);
2059       if(aSubBase.IsNull())
2060         continue;
2061       Handle(GEOM_Function) aRefSubBase = aSubBase->GetLastFunction();
2062       if(aRefSubBase.IsNull())
2063         continue;
2064       aSeqSubBases->Append(aRefSubBase);
2065     }
2066
2067     if(nbLocs) {
2068       Handle(Standard_Transient) anItemLoc = theLocations->Value(i);
2069       if(anItemLoc.IsNull())
2070         continue;
2071       Handle(GEOM_Object) aLoc = Handle(GEOM_Object)::DownCast(anItemLoc);
2072       if(aLoc.IsNull())
2073         continue;
2074       Handle(GEOM_Function) aRefLoc = aLoc->GetLastFunction();
2075       if(aRefLoc.IsNull())
2076         continue;
2077       aSeqLocs->Append(aRefLoc);
2078     }
2079
2080     aSeqBases->Append(aRefBase);
2081   }
2082
2083   if(!aSeqBases->Length())
2084     return NULL;
2085
2086   aCI.SetBases(aSeqBases);
2087   aCI.SetSubBases(aSeqSubBases);
2088   aCI.SetLocations(aSeqLocs);
2089   aCI.SetPath(aRefPath);
2090   aCI.SetWithContactMode(theWithContact);
2091   aCI.SetWithCorrectionMode(theWithCorrections);
2092   aCI.SetGenerateGroups(IsGenerateGroups);
2093
2094   //Compute the Pipe value
2095   try {
2096     OCC_CATCH_SIGNALS;
2097     if (!GetSolver()->ComputeFunction(aFunction)) {
2098       SetErrorCode("Pipe with shell sections driver failed");
2099       return NULL;
2100     }
2101   }
2102   catch (Standard_Failure) {
2103     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2104     SetErrorCode(aFail->GetMessageString());
2105     return NULL;
2106   }
2107
2108   // Create the sequence of objects.
2109   Handle(TColStd_HSequenceOfTransient) aSeq = new TColStd_HSequenceOfTransient;
2110
2111   aSeq->Append(aPipeDS);
2112   createGroups(aPipeDS, &aCI, aSeq);
2113
2114   //Make a Python command
2115   GEOM::TPythonDump pyDump(aFunction);
2116
2117   if (IsGenerateGroups) {
2118     pyDump << aSeq;
2119   } else {
2120     pyDump << aPipeDS;
2121   }
2122
2123   pyDump << " = geompy.MakePipeWithShellSections([";
2124
2125   for(i =1 ; i <= nbBases; i++) {
2126
2127     Handle(Standard_Transient) anItem = theBases->Value(i);
2128     if(anItem.IsNull())
2129       continue;
2130
2131     Handle(GEOM_Object) anObj = Handle(GEOM_Object)::DownCast(anItem);
2132     if(!anObj.IsNull()) {
2133       pyDump<< anObj;
2134       if(i < nbBases)
2135         pyDump<<", ";
2136     }
2137   }
2138
2139   pyDump<< "], [";
2140
2141   for(i =1 ; i <= nbSubBases; i++) {
2142
2143     Handle(Standard_Transient) anItem = theSubBases->Value(i);
2144     if(anItem.IsNull())
2145       continue;
2146
2147     Handle(GEOM_Object) anObj = Handle(GEOM_Object)::DownCast(anItem);
2148     if(!anObj.IsNull()) {
2149       pyDump<< anObj;
2150       if(i < nbBases)
2151         pyDump<<", ";
2152     }
2153   }
2154
2155   pyDump<< "], [";
2156
2157   for(i =1 ; i <= nbLocs; i++) {
2158
2159     Handle(Standard_Transient) anItem = theLocations->Value(i);
2160     if(anItem.IsNull())
2161       continue;
2162
2163     Handle(GEOM_Object) anObj = Handle(GEOM_Object)::DownCast(anItem);
2164     if(!anObj.IsNull()) {
2165       pyDump<< anObj;
2166       if(i < nbLocs)
2167         pyDump<<", ";
2168     }
2169   }
2170
2171   pyDump<< "], "<<thePath<<","<<theWithContact << "," << theWithCorrections;
2172
2173   if (IsGenerateGroups) {
2174     pyDump << ", True";
2175   }
2176
2177   pyDump << ")";
2178
2179   SetErrorCode(OK);
2180   return aSeq;
2181
2182 }
2183
2184
2185 //=============================================================================
2186 /*!
2187  *  MakePipeShellsWithoutPath
2188  */
2189 //=============================================================================
2190 Handle(TColStd_HSequenceOfTransient)
2191       GEOMImpl_I3DPrimOperations::MakePipeShellsWithoutPath
2192               (const Handle(TColStd_HSequenceOfTransient) &theBases,
2193                const Handle(TColStd_HSequenceOfTransient) &theLocations,
2194                const bool                                  IsGenerateGroups)
2195 {
2196   SetErrorCode(KO);
2197   if(theBases.IsNull())
2198     return NULL;
2199
2200   Standard_Integer nbBases = theBases->Length();
2201
2202   if (!nbBases)
2203     return NULL;
2204
2205   Standard_Integer nbLocs =  (theLocations.IsNull() ? 0 :theLocations->Length());
2206
2207   //Add a new Pipe object
2208   Handle(GEOM_Object) aPipeDS = GetEngine()->AddObject(GetDocID(), GEOM_PIPE);
2209
2210   //Add a new Pipe function
2211
2212   Handle(GEOM_Function) aFunction =
2213     aPipeDS->AddFunction(GEOMImpl_PipeDriver::GetID(), PIPE_SHELLS_WITHOUT_PATH);
2214   if (aFunction.IsNull()) return NULL;
2215
2216   //Check if the function is set correctly
2217   if (aFunction->GetDriverGUID() != GEOMImpl_PipeDriver::GetID()) return NULL;
2218
2219   GEOMImpl_IPipeShellSect aCI (aFunction);
2220
2221   Handle(TColStd_HSequenceOfTransient) aSeqBases = new TColStd_HSequenceOfTransient;
2222   Handle(TColStd_HSequenceOfTransient) aSeqLocs = new TColStd_HSequenceOfTransient;
2223
2224   Standard_Integer i =1;
2225   for( ; i <= nbBases; i++) {
2226
2227     Handle(Standard_Transient) anItem = theBases->Value(i);
2228     if(anItem.IsNull())
2229       continue;
2230     Handle(GEOM_Object) aBase = Handle(GEOM_Object)::DownCast(anItem);
2231     if(aBase.IsNull())
2232       continue;
2233     Handle(GEOM_Function) aRefBase = aBase->GetLastFunction();
2234     if(aRefBase.IsNull())
2235       continue;
2236
2237     if(nbLocs) {
2238       Handle(Standard_Transient) anItemLoc = theLocations->Value(i);
2239       if(anItemLoc.IsNull())
2240         continue;
2241       Handle(GEOM_Object) aLoc = Handle(GEOM_Object)::DownCast(anItemLoc);
2242       if(aLoc.IsNull())
2243         continue;
2244       Handle(GEOM_Function) aRefLoc = aLoc->GetLastFunction();
2245       if(aRefLoc.IsNull())
2246         continue;
2247       aSeqLocs->Append(aRefLoc);
2248     }
2249
2250     aSeqBases->Append(aRefBase);
2251   }
2252
2253   if(!aSeqBases->Length())
2254     return NULL;
2255
2256   aCI.SetBases(aSeqBases);
2257   aCI.SetLocations(aSeqLocs);
2258   aCI.SetGenerateGroups(IsGenerateGroups);
2259
2260   //Compute the Pipe value
2261   try {
2262     OCC_CATCH_SIGNALS;
2263     if (!GetSolver()->ComputeFunction(aFunction)) {
2264       SetErrorCode("Pipe with shell sections without path driver failed");
2265       return NULL;
2266     }
2267   }
2268   catch (Standard_Failure) {
2269     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2270     SetErrorCode(aFail->GetMessageString());
2271     return NULL;
2272   }
2273
2274   // Create the sequence of objects.
2275   Handle(TColStd_HSequenceOfTransient) aSeq = new TColStd_HSequenceOfTransient;
2276
2277   aSeq->Append(aPipeDS);
2278   createGroups(aPipeDS, &aCI, aSeq);
2279
2280   //Make a Python command
2281   GEOM::TPythonDump pyDump(aFunction);
2282
2283   if (IsGenerateGroups) {
2284     pyDump << aSeq;
2285   } else {
2286     pyDump << aPipeDS;
2287   }
2288
2289   pyDump << " = geompy.MakePipeShellsWithoutPath([";
2290
2291   for(i =1 ; i <= nbBases; i++) {
2292
2293     Handle(Standard_Transient) anItem = theBases->Value(i);
2294     if(anItem.IsNull())
2295       continue;
2296
2297     Handle(GEOM_Object) anObj = Handle(GEOM_Object)::DownCast(anItem);
2298     if(!anObj.IsNull()) {
2299       pyDump<< anObj;
2300       if(i < nbBases)
2301         pyDump<<", ";
2302     }
2303   }
2304
2305   pyDump<< "], [";
2306
2307   for(i =1 ; i <= nbLocs; i++) {
2308
2309     Handle(Standard_Transient) anItem = theLocations->Value(i);
2310     if(anItem.IsNull())
2311       continue;
2312
2313     Handle(GEOM_Object) anObj = Handle(GEOM_Object)::DownCast(anItem);
2314     if(!anObj.IsNull()) {
2315       pyDump<< anObj;
2316       if(i < nbLocs)
2317         pyDump<<", ";
2318     }
2319   }
2320
2321   pyDump<< "]";
2322
2323   if (IsGenerateGroups) {
2324     pyDump << ", True";
2325   }
2326
2327   pyDump << ")";
2328
2329   SetErrorCode(OK);
2330   return aSeq;
2331
2332 }
2333
2334 //=============================================================================
2335 /*!
2336  *  MakePipeBiNormalAlongVector
2337  */
2338 //=============================================================================
2339 Handle(TColStd_HSequenceOfTransient)
2340   GEOMImpl_I3DPrimOperations::MakePipeBiNormalAlongVector
2341                 (const Handle(GEOM_Object) &theBase,
2342                  const Handle(GEOM_Object) &thePath,
2343                  const Handle(GEOM_Object) &theVec,
2344                  const bool                 IsGenerateGroups)
2345 {
2346   SetErrorCode(KO);
2347
2348   if (theBase.IsNull() || thePath.IsNull() || theVec.IsNull()) return NULL;
2349
2350   //Add a new Pipe object
2351   Handle(GEOM_Object) aPipe = GetEngine()->AddObject(GetDocID(), GEOM_PIPE);
2352
2353   //Add a new Pipe function
2354   Handle(GEOM_Function) aFunction =
2355     aPipe->AddFunction(GEOMImpl_PipeDriver::GetID(), PIPE_BI_NORMAL_ALONG_VECTOR);
2356   if (aFunction.IsNull()) return NULL;
2357
2358   //Check if the function is set correctly
2359   if (aFunction->GetDriverGUID() != GEOMImpl_PipeDriver::GetID()) return NULL;
2360
2361   GEOMImpl_IPipeBiNormal aCI (aFunction);
2362
2363   Handle(GEOM_Function) aRefBase = theBase->GetLastFunction();
2364   Handle(GEOM_Function) aRefPath = thePath->GetLastFunction();
2365   Handle(GEOM_Function) aRefVec  = theVec->GetLastFunction();
2366
2367   if (aRefBase.IsNull() || aRefPath.IsNull() || aRefVec.IsNull()) return NULL;
2368
2369   aCI.SetBase(aRefBase);
2370   aCI.SetPath(aRefPath);
2371   aCI.SetVector(aRefVec);
2372   aCI.SetGenerateGroups(IsGenerateGroups);
2373
2374   //Compute the Pipe value
2375   try {
2376     OCC_CATCH_SIGNALS;
2377     if (!GetSolver()->ComputeFunction(aFunction)) {
2378       SetErrorCode("Pipe driver failed");
2379       return NULL;
2380     }
2381   }
2382   catch (Standard_Failure) {
2383     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2384     SetErrorCode(aFail->GetMessageString());
2385     return NULL;
2386   }
2387
2388   // Create the sequence of objects.
2389   Handle(TColStd_HSequenceOfTransient) aSeq = new TColStd_HSequenceOfTransient;
2390
2391   aSeq->Append(aPipe);
2392   createGroups(aPipe, &aCI, aSeq);
2393
2394   //Make a Python command
2395   GEOM::TPythonDump pyDump(aFunction);
2396
2397   if (IsGenerateGroups) {
2398     pyDump << aSeq;
2399   } else {
2400     pyDump << aPipe;
2401   }
2402
2403   pyDump << " = geompy.MakePipeBiNormalAlongVector("
2404          << theBase << ", " << thePath << ", " << theVec;
2405
2406   if (IsGenerateGroups) {
2407     pyDump << ", True";
2408   }
2409
2410   pyDump << ")";
2411
2412   SetErrorCode(OK);
2413   return aSeq;
2414 }
2415
2416 //=============================================================================
2417 /*!
2418  *  MakeThickening
2419  */
2420 //=============================================================================
2421 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeThickening
2422                 (Handle(GEOM_Object)                     theObject,
2423                  const Handle(TColStd_HArray1OfInteger) &theFacesIDs,
2424                  double                                  theOffset,
2425                  bool                                    isCopy,
2426                  bool                                    theInside)
2427 {
2428   SetErrorCode(KO);
2429
2430   if (theObject.IsNull()) return NULL;
2431
2432   Handle(GEOM_Function) anOriginal = theObject->GetLastFunction();
2433   if (anOriginal.IsNull()) return NULL; //There is no function which creates an object to be offset
2434
2435   //Add a new Offset function
2436   Handle(GEOM_Function) aFunction;
2437   Handle(GEOM_Object) aCopy;
2438   if (isCopy)
2439   {
2440     //Add a new Copy object
2441     aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
2442     aFunction = aCopy->AddFunction(GEOMImpl_OffsetDriver::GetID(), OFFSET_THICKENING_COPY);
2443   }
2444   else
2445     aFunction = theObject->AddFunction(GEOMImpl_OffsetDriver::GetID(), OFFSET_THICKENING);
2446
2447   if (aFunction.IsNull()) return NULL;
2448
2449   //Check if the function is set correctly
2450   if (aFunction->GetDriverGUID() != GEOMImpl_OffsetDriver::GetID()) return NULL;
2451
2452   GEOMImpl_IOffset aTI (aFunction);
2453   aTI.SetShape(anOriginal);
2454   aTI.SetValue(theOffset);
2455   aTI.SetParam(theInside);
2456
2457   if (theFacesIDs.IsNull() == Standard_False) {
2458     aTI.SetFaceIDs(theFacesIDs);
2459   }
2460
2461   //Compute the offset
2462   try {
2463     OCC_CATCH_SIGNALS;
2464     if (!GetSolver()->ComputeFunction(aFunction)) {
2465       SetErrorCode("Offset driver failed");
2466       return NULL;
2467     }
2468   }
2469   catch (Standard_Failure) {
2470     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2471     SetErrorCode(aFail->GetMessageString());
2472     return NULL;
2473   }
2474
2475   //Make a Python command
2476   GEOM::TPythonDump   pd (aFunction);
2477   Handle(GEOM_Object) aResult;
2478
2479   if (isCopy) {
2480     pd << aCopy << " = geompy.MakeThickSolid("
2481        << theObject << ", " << theOffset;
2482     aResult = aCopy;
2483   } else {
2484     pd << "geompy.Thicken(" << theObject << ", " << theOffset;
2485     aResult = theObject;
2486   }
2487
2488   pd << ", [";
2489   if (theFacesIDs.IsNull() == Standard_False) {
2490     // Dump faces IDs.
2491     Standard_Integer i;
2492
2493     for (i = theFacesIDs->Lower(); i < theFacesIDs->Upper(); ++i) {
2494       pd << theFacesIDs->Value(i) << ", ";
2495     }
2496     // Dump the last value.
2497     pd << theFacesIDs->Value(i);
2498   }
2499   pd << "]";
2500
2501   if (theInside)
2502     pd << ", " << theInside;
2503
2504   pd << ")";
2505   SetErrorCode(OK);
2506
2507   return aResult;
2508 }
2509
2510 //=============================================================================
2511 /*!
2512  *  RestorePath
2513  */
2514 //=============================================================================
2515 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::RestorePath (Handle(GEOM_Object) theShape,
2516                                                              Handle(GEOM_Object) theBase1,
2517                                                              Handle(GEOM_Object) theBase2)
2518 {
2519   SetErrorCode(KO);
2520
2521   if (theShape.IsNull() || theBase1.IsNull() || theBase2.IsNull()) return NULL;
2522
2523   // Add a new Path object
2524   Handle(GEOM_Object) aPath = GetEngine()->AddObject(GetDocID(), GEOM_PIPE_PATH);
2525
2526   // Add a new Path function
2527   Handle(GEOM_Function) aFunction =
2528     aPath->AddFunction(GEOMImpl_PipePathDriver::GetID(), PIPE_PATH_TWO_BASES);
2529   if (aFunction.IsNull()) return NULL;
2530
2531   // Check if the function is set correctly
2532   if (aFunction->GetDriverGUID() != GEOMImpl_PipePathDriver::GetID()) return NULL;
2533
2534   GEOMImpl_IPipePath aCI (aFunction);
2535
2536   Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
2537   Handle(GEOM_Function) aRefBase1 = theBase1->GetLastFunction();
2538   Handle(GEOM_Function) aRefBase2 = theBase2->GetLastFunction();
2539
2540   if (aRefShape.IsNull() || aRefBase1.IsNull() || aRefBase2.IsNull()) return NULL;
2541
2542   aCI.SetShape(aRefShape);
2543   aCI.SetBase1(aRefBase1);
2544   aCI.SetBase2(aRefBase2);
2545
2546   // Compute the Path value
2547   try {
2548     OCC_CATCH_SIGNALS;
2549     if (!GetSolver()->ComputeFunction(aFunction)) {
2550       SetErrorCode("PipePath driver failed");
2551       return NULL;
2552     }
2553   }
2554   catch (Standard_Failure) {
2555     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2556     SetErrorCode("RestorePath: inappropriate arguments given");
2557     return NULL;
2558   }
2559
2560   // Make a Python command
2561   GEOM::TPythonDump(aFunction) << aPath << " = geompy.RestorePath("
2562     << theShape << ", " << theBase1 << ", " << theBase2 << ")";
2563
2564   SetErrorCode(OK);
2565   return aPath;
2566 }
2567
2568 //=============================================================================
2569 /*!
2570  *  RestorePath
2571  */
2572 //=============================================================================
2573 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::RestorePath
2574                          (Handle(GEOM_Object) theShape,
2575                           const Handle(TColStd_HSequenceOfTransient)& theBase1,
2576                           const Handle(TColStd_HSequenceOfTransient)& theBase2)
2577 {
2578   SetErrorCode(KO);
2579
2580   if (theShape.IsNull() || theBase1.IsNull() || theBase2.IsNull()) return NULL;
2581
2582   Standard_Integer nbBases1 = theBase1->Length();
2583   Standard_Integer nbBases2 = theBase2->Length();
2584
2585   if (!nbBases1 || !nbBases2)
2586     return NULL;
2587
2588   // Add a new Path object
2589   Handle(GEOM_Object) aPath = GetEngine()->AddObject(GetDocID(), GEOM_PIPE_PATH);
2590
2591   // Add a new Path function
2592   Handle(GEOM_Function) aFunction =
2593     aPath->AddFunction(GEOMImpl_PipePathDriver::GetID(), PIPE_PATH_TWO_SEQS);
2594   if (aFunction.IsNull()) return NULL;
2595
2596   // Check if the function is set correctly
2597   if (aFunction->GetDriverGUID() != GEOMImpl_PipePathDriver::GetID()) return NULL;
2598
2599   GEOMImpl_IPipePath aCI (aFunction);
2600
2601   Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
2602   if (aRefShape.IsNull()) return NULL;
2603
2604   Handle(TColStd_HSequenceOfTransient) aSeqBases1 = new TColStd_HSequenceOfTransient;
2605   Handle(TColStd_HSequenceOfTransient) aSeqBases2 = new TColStd_HSequenceOfTransient;
2606
2607   Standard_Integer i;
2608   for (i = 1; i <= nbBases1; i++) {
2609     Handle(Standard_Transient) anItem = theBase1->Value(i);
2610     if (!anItem.IsNull()) {
2611       Handle(GEOM_Object) aBase = Handle(GEOM_Object)::DownCast(anItem);
2612       if (!aBase.IsNull()) {
2613         Handle(GEOM_Function) aRefBase = aBase->GetLastFunction();
2614         if (!aRefBase.IsNull())
2615           aSeqBases1->Append(aRefBase);
2616       }
2617     }
2618   }
2619   for (i = 1; i <= nbBases2; i++) {
2620     Handle(Standard_Transient) anItem = theBase2->Value(i);
2621     if (!anItem.IsNull()) {
2622       Handle(GEOM_Object) aBase = Handle(GEOM_Object)::DownCast(anItem);
2623       if (!aBase.IsNull()) {
2624         Handle(GEOM_Function) aRefBase = aBase->GetLastFunction();
2625         if (!aRefBase.IsNull())
2626           aSeqBases2->Append(aRefBase);
2627       }
2628     }
2629   }
2630   if (!aSeqBases1->Length() || !aSeqBases2->Length()) return NULL;
2631
2632   aCI.SetShape(aRefShape);
2633   aCI.SetBaseSeq1(aSeqBases1);
2634   aCI.SetBaseSeq2(aSeqBases2);
2635
2636   // Compute the Path value
2637   try {
2638     OCC_CATCH_SIGNALS;
2639     if (!GetSolver()->ComputeFunction(aFunction)) {
2640       SetErrorCode("PipePath driver failed");
2641       return NULL;
2642     }
2643   }
2644   catch (Standard_Failure) {
2645     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
2646     SetErrorCode("RestorePath: inappropriate arguments given");
2647     return NULL;
2648   }
2649
2650   // Make a Python command
2651   GEOM::TPythonDump pyDump (aFunction);
2652   pyDump << aPath << " = geompy.RestorePathEdges(" << theShape << ", [";
2653   for (i = 1; i <= nbBases1; i++) {
2654     Handle(GEOM_Object) anObj = Handle(GEOM_Object)::DownCast(theBase1->Value(i));
2655     if (!anObj.IsNull()) {
2656       pyDump << anObj;
2657       if (i < nbBases1)
2658         pyDump << ", ";
2659     }
2660   }
2661   pyDump<< "], [";
2662   for (i = 1; i <= nbBases2; i++) {
2663     Handle(GEOM_Object) anObj = Handle(GEOM_Object)::DownCast(theBase2->Value(i));
2664     if (!anObj.IsNull()) {
2665       pyDump << anObj;
2666       if (i < nbBases2)
2667         pyDump << ", ";
2668     }
2669   }
2670   pyDump << "])";
2671
2672   SetErrorCode(OK);
2673   return aPath;
2674 }
2675
2676 //=============================================================================
2677 /*!
2678  *  createGroup
2679  */
2680 //=============================================================================
2681 Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::createGroup
2682                   (const Handle(GEOM_Object)              &theBaseObject,
2683                    const Handle(TColStd_HArray1OfInteger) &theGroupIDs,
2684                    const TCollection_AsciiString          &theName,
2685                    const TopTools_IndexedMapOfShape       &theIndices)
2686 {
2687   if (theBaseObject.IsNull() || theGroupIDs.IsNull()) {
2688     return NULL;
2689   }
2690
2691   // Get the Shape type.
2692   const Standard_Integer anID      = theGroupIDs->Value(theGroupIDs->Lower());
2693   const Standard_Integer aNbShapes = theIndices.Extent();
2694
2695   if (anID < 1 || anID > aNbShapes) {
2696     return NULL;
2697   }
2698
2699   const TopoDS_Shape aSubShape = theIndices.FindKey(anID);
2700
2701   if (aSubShape.IsNull()) {
2702     return NULL;
2703   }
2704
2705   // Create a group.
2706   const TopAbs_ShapeEnum aGroupType = aSubShape.ShapeType();
2707   Handle(GEOM_Object)    aGroup     =
2708     myGroupOperations->CreateGroup(theBaseObject, aGroupType);
2709
2710   if (aGroup.IsNull() == Standard_False) {
2711     aGroup->GetLastFunction()->SetDescription("");
2712     aGroup->SetName(theName.ToCString());
2713
2714     Handle(TColStd_HSequenceOfInteger) aSeqIDs = new TColStd_HSequenceOfInteger;
2715     Standard_Integer                   i;
2716
2717     for (i = theGroupIDs->Lower(); i <= theGroupIDs->Upper(); ++i) {
2718       // Get and check the index.
2719       const Standard_Integer anIndex = theGroupIDs->Value(i);
2720
2721       if (anIndex < 1 || anIndex > aNbShapes) {
2722         return NULL;
2723       }
2724
2725       // Get and check the sub-shape.
2726       const TopoDS_Shape aSubShape = theIndices.FindKey(anIndex);
2727
2728       if (aSubShape.IsNull()) {
2729         return NULL;
2730       }
2731
2732       // Check the shape type.
2733       if (aSubShape.ShapeType() != aGroupType) {
2734         return NULL;
2735       }
2736
2737       aSeqIDs->Append(anIndex);
2738     }
2739
2740     myGroupOperations->UnionIDs(aGroup, aSeqIDs);
2741     aGroup->GetLastFunction()->SetDescription("");
2742   }
2743
2744   return aGroup;
2745 }
2746
2747 //=============================================================================
2748 /*!
2749  *  createGroups
2750  */
2751 //=============================================================================
2752 void GEOMImpl_I3DPrimOperations::createGroups
2753                    (const Handle(GEOM_Object)                  &theBaseObject,
2754                           GEOMImpl_IPipe                       *thePipe,
2755                           Handle(TColStd_HSequenceOfTransient) &theSequence)
2756 {
2757   if (theBaseObject.IsNull() || thePipe == NULL || theSequence.IsNull()) {
2758     return;
2759   }
2760
2761   TopoDS_Shape aShape = theBaseObject->GetValue();
2762
2763   if (aShape.IsNull()) {
2764     return;
2765   }
2766
2767   TopTools_IndexedMapOfShape       anIndices;
2768   Handle(TColStd_HArray1OfInteger) aGroupIDs;
2769   TopoDS_Shape                     aShapeType;
2770   const Standard_Integer           aNbGroups = 5;
2771   Handle(GEOM_Object)              aGrps[aNbGroups];
2772   Standard_Integer                 i;
2773
2774   TopExp::MapShapes(aShape, anIndices);
2775
2776   // Create groups.
2777   aGroupIDs = thePipe->GetGroupDown();
2778   aGrps[0]  = createGroup(theBaseObject, aGroupIDs, "GROUP_DOWN", anIndices);
2779   aGroupIDs = thePipe->GetGroupUp();
2780   aGrps[1]  = createGroup(theBaseObject, aGroupIDs, "GROUP_UP", anIndices);
2781   aGroupIDs = thePipe->GetGroupSide1();
2782   aGrps[2]  = createGroup(theBaseObject, aGroupIDs, "GROUP_SIDE1", anIndices);
2783   aGroupIDs = thePipe->GetGroupSide2();
2784   aGrps[3]  = createGroup(theBaseObject, aGroupIDs, "GROUP_SIDE2", anIndices);
2785   aGroupIDs = thePipe->GetGroupOther();
2786   aGrps[4]  = createGroup(theBaseObject, aGroupIDs, "GROUP_OTHER", anIndices);
2787
2788   for (i = 0; i < aNbGroups; ++i) {
2789     if (aGrps[i].IsNull() == Standard_False) {
2790       theSequence->Append(aGrps[i]);
2791     }
2792   }
2793 }