-// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
+// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
#include <Standard_Stream.hxx>
-#include <Basics_OCCTVersion.hxx>
-
#include <GEOMImpl_I3DPrimOperations.hxx>
#include "utilities.h"
#include <TFunction_DriverTable.hxx>
#include <TFunction_Driver.hxx>
-#include <TFunction_Logbook.hxx>
#include <TDF_Tool.hxx>
#include <GEOM_Function.hxx>
#include <GEOMImpl_IDisk.hxx>
#include <GEOMImpl_ICylinder.hxx>
#include <GEOMImpl_ICone.hxx>
+#include <GEOMImpl_IGroupOperations.hxx>
#include <GEOMImpl_ISphere.hxx>
#include <GEOMImpl_ITorus.hxx>
#include <GEOMImpl_IPrism.hxx>
#include <GEOMImpl_IPipePath.hxx>
#include <Precision.hxx>
+#include <TopExp.hxx>
#include <Standard_Failure.hxx>
#include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
: GEOM_IOperations(theEngine, theDocID)
{
MESSAGE("GEOMImpl_I3DPrimOperations::GEOMImpl_I3DPrimOperations");
+ myGroupOperations = new GEOMImpl_IGroupOperations(GetEngine(), GetDocID());
}
//=============================================================================
GEOMImpl_I3DPrimOperations::~GEOMImpl_I3DPrimOperations()
{
MESSAGE("GEOMImpl_I3DPrimOperations::~GEOMImpl_I3DPrimOperations");
+ delete myGroupOperations;
}
//Compute the box value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Box driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
//Compute the Box value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Box driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
//Compute the Face
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Face driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
//Compute the Face
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Face driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
//Compute the Disk value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Disk driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
//Compute the Disk value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Disk driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
//Compute the Disk
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Disk driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
//Compute the Cylinder value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Cylinder driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
return aCylinder;
}
+//=============================================================================
+/*!
+ * MakeCylinderRHA
+ */
+//=============================================================================
+Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeCylinderRHA (double theR, double theH, double theA)
+{
+ SetErrorCode(KO);
+
+ //Add a new Cylinder object
+ Handle(GEOM_Object) aCylinder = GetEngine()->AddObject(GetDocID(), GEOM_CYLINDER);
+
+ //Add a new Cylinder function with R and H parameters
+ Handle(GEOM_Function) aFunction = aCylinder->AddFunction(GEOMImpl_CylinderDriver::GetID(), CYLINDER_R_H_A);
+ if (aFunction.IsNull()) return NULL;
+
+ //Check if the function is set correctly
+ if (aFunction->GetDriverGUID() != GEOMImpl_CylinderDriver::GetID()) return NULL;
+
+ GEOMImpl_ICylinder aCI (aFunction);
+
+ aCI.SetR(theR);
+ aCI.SetH(theH);
+ aCI.SetA(theA);
+
+ //Compute the Cylinder value
+ try {
+ OCC_CATCH_SIGNALS;
+ if (!GetSolver()->ComputeFunction(aFunction)) {
+ SetErrorCode("Cylinder driver failed");
+ return NULL;
+ }
+ }
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
+ return NULL;
+ }
+
+ //Make a Python command
+ GEOM::TPythonDump(aFunction) << aCylinder
+ << " = geompy.MakeCylinderRHA(" << theR << ", " << theH << ", " << theA*180./M_PI << "*math.pi/180.)";
+
+ SetErrorCode(OK);
+ return aCylinder;
+}
//=============================================================================
/*!
//Compute the Cylinder value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Cylinder driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
return aCylinder;
}
+//=============================================================================
+/*!
+ * MakeCylinderPntVecRHA
+ */
+//=============================================================================
+Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeCylinderPntVecRHA (Handle(GEOM_Object) thePnt,
+ Handle(GEOM_Object) theVec,
+ double theR, double theH, double theA)
+{
+ SetErrorCode(KO);
+
+ if (thePnt.IsNull() || theVec.IsNull()) return NULL;
+
+ //Add a new Cylinder object
+ Handle(GEOM_Object) aCylinder = GetEngine()->AddObject(GetDocID(), GEOM_CYLINDER);
+
+ //Add a new Cylinder function for creation a cylinder relatively to point and vector
+ Handle(GEOM_Function) aFunction =
+ aCylinder->AddFunction(GEOMImpl_CylinderDriver::GetID(), CYLINDER_PNT_VEC_R_H_A);
+ if (aFunction.IsNull()) return NULL;
+
+ //Check if the function is set correctly
+ if (aFunction->GetDriverGUID() != GEOMImpl_CylinderDriver::GetID()) return NULL;
+
+ GEOMImpl_ICylinder aCI (aFunction);
+
+ Handle(GEOM_Function) aRefPnt = thePnt->GetLastFunction();
+ Handle(GEOM_Function) aRefVec = theVec->GetLastFunction();
+
+ if (aRefPnt.IsNull() || aRefVec.IsNull()) return NULL;
+
+ aCI.SetPoint(aRefPnt);
+ aCI.SetVector(aRefVec);
+ aCI.SetR(theR);
+ aCI.SetH(theH);
+ aCI.SetA(theA);
+
+ //Compute the Cylinder value
+ try {
+ OCC_CATCH_SIGNALS;
+ if (!GetSolver()->ComputeFunction(aFunction)) {
+ SetErrorCode("Cylinder driver failed");
+ return NULL;
+ }
+ }
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
+ return NULL;
+ }
+
+ //Make a Python command
+ GEOM::TPythonDump(aFunction) << aCylinder << " = geompy.MakeCylinderA("
+ << thePnt << ", " << theVec << ", " << theR << ", " << theH << ", " << theA*180./M_PI << "*math.pi/180.)";
+
+ SetErrorCode(OK);
+ return aCylinder;
+}
+
//=============================================================================
/*!
//Compute the Cone value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Cone driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
//Compute the Cone value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Cone driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
//Compute the Sphere value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Sphere driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
//Compute the Sphere value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Sphere driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
//Compute the Torus value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Torus driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
//Compute the Torus value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Torus driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
//Compute the Prism value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
//SetErrorCode("Prism driver failed");
SetErrorCode("Extrusion can not be created, check input data");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
//Compute the Prism value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
//SetErrorCode("Prism driver failed");
SetErrorCode("Extrusion can not be created, check input data");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
//Compute the Prism value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
//SetErrorCode("Prism driver failed");
SetErrorCode("Extrusion can not be created, check input data");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
//Compute the Prism value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
//SetErrorCode("Prism driver failed");
SetErrorCode("Extrusion can not be created, check input data");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
//Compute the Prism value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Extrusion can not be created, check input data");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
//Compute the Prism value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Extrusion can not be created, check input data");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
*/
//=============================================================================
Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeDraftPrism
- (Handle(GEOM_Object) theInitShape ,Handle(GEOM_Object) theBase, double theHeight, double theAngle, bool theFuse)
+ (Handle(GEOM_Object) theInitShape ,Handle(GEOM_Object) theBase, double theHeight, double theAngle, bool theFuse, bool theInvert)
{
SetErrorCode(KO);
aCI.SetFuseFlag(1);
else
aCI.SetFuseFlag(0);
+ aCI.SetInvertFlag(theInvert);
//Compute the Draft Prism Feature value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Extrusion can not be created, check input data");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
//Make a Python command
+ GEOM::TPythonDump pd (aFunction);
if(theFuse)
{
- GEOM::TPythonDump(aFunction) << aPrism << " = geompy.MakeExtrudedBoss("
- << theInitShape << ", " << theBase << ", " << theHeight << ", " << theAngle << ")";
+ pd << aPrism << " = geompy.MakeExtrudedBoss(" << theInitShape << ", " << theBase << ", "
+ << theHeight << ", " << theAngle;
}
else
{
- GEOM::TPythonDump(aFunction) << aPrism << " = geompy.MakeExtrudedCut("
- << theInitShape << ", " << theBase << ", " << theHeight << ", " << theAngle << ")";
+ pd << aPrism << " = geompy.MakeExtrudedCut(" << theInitShape << ", " << theBase << ", "
+ << theHeight << ", " << theAngle;
}
+ if (theInvert)
+ pd << ", " << theInvert;
+ pd << ")";
SetErrorCode(OK);
return aPrism;
* MakePipe
*/
//=============================================================================
-Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePipe (Handle(GEOM_Object) theBase,
- Handle(GEOM_Object) thePath)
+Handle(TColStd_HSequenceOfTransient) GEOMImpl_I3DPrimOperations::MakePipe
+ (const Handle(GEOM_Object) &theBase,
+ const Handle(GEOM_Object) &thePath,
+ const bool IsGenerateGroups)
{
SetErrorCode(KO);
aCI.SetBase(aRefBase);
aCI.SetPath(aRefPath);
+ aCI.SetGenerateGroups(IsGenerateGroups);
//Compute the Pipe value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Pipe driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
+ // Create the sequence of objects.
+ Handle(TColStd_HSequenceOfTransient) aSeq = new TColStd_HSequenceOfTransient;
+
+ aSeq->Append(aPipe);
+ createGroups(aPipe, &aCI, aSeq);
+
//Make a Python command
- GEOM::TPythonDump(aFunction) << aPipe << " = geompy.MakePipe("
- << theBase << ", " << thePath << ")";
+ GEOM::TPythonDump pyDump(aFunction);
+
+ if (IsGenerateGroups) {
+ pyDump << aSeq;
+ } else {
+ pyDump << aPipe;
+ }
+
+ pyDump << " = geompy.MakePipe(" << theBase << ", " << thePath;
+
+ if (IsGenerateGroups) {
+ pyDump << ", True";
+ }
+
+ pyDump << ")";
SetErrorCode(OK);
- return aPipe;
+ return aSeq;
}
//Compute the Revolution value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Revolution driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
//Compute the Revolution value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Revolution driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
* MakeFilling
*/
//=============================================================================
-Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeFilling
- (Handle(GEOM_Object) theShape, int theMinDeg, int theMaxDeg,
- double theTol2D, double theTol3D, int theNbIter,
- int theMethod, bool isApprox)
+Handle(GEOM_Object)
+GEOMImpl_I3DPrimOperations::MakeFilling (std::list< Handle(GEOM_Object)> & theContours,
+ int theMinDeg, int theMaxDeg,
+ double theTol2D, double theTol3D, int theNbIter,
+ int theMethod, bool isApprox)
{
SetErrorCode(KO);
- if (theShape.IsNull()) return NULL;
-
+ Handle(TColStd_HSequenceOfTransient) contours = GEOM_Object::GetLastFunctions( theContours );
+ if ( contours.IsNull() || contours->IsEmpty() ) {
+ SetErrorCode("NULL argument shape");
+ return NULL;
+ }
//Add a new Filling object
Handle(GEOM_Object) aFilling = GetEngine()->AddObject(GetDocID(), GEOM_FILLING);
if (aFunction->GetDriverGUID() != GEOMImpl_FillingDriver::GetID()) return NULL;
GEOMImpl_IFilling aFI (aFunction);
-
- Handle(GEOM_Function) aRefShape = theShape->GetLastFunction();
-
- if (aRefShape.IsNull()) return NULL;
-
- aFI.SetShape(aRefShape);
+ aFI.SetShapes(contours);
aFI.SetMinDeg(theMinDeg);
aFI.SetMaxDeg(theMaxDeg);
aFI.SetTol2D(theTol2D);
//Compute the Solid value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Filling driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- if (strcmp(aFail->GetMessageString(), "Geom_BSplineSurface") == 0)
+ catch (Standard_Failure& aFail) {
+ if (strcmp(aFail.GetMessageString(), "Geom_BSplineSurface") == 0)
SetErrorCode("B-Spline surface construction failed");
else
- SetErrorCode(aFail->GetMessageString());
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
//Make a Python command
GEOM::TPythonDump pd (aFunction);
- pd << aFilling << " = geompy.MakeFilling(" << theShape ;
+ pd << aFilling << " = geompy.MakeFilling(" << theContours ;
if ( theMinDeg != 2 ) pd << ", theMinDeg=" << theMinDeg ;
if ( theMaxDeg != 5 ) pd << ", theMaxDeg=" << theMaxDeg ;
if ( fabs(theTol2D-0.0001) > Precision::Confusion() )
- pd << ", theTol2D=" << theTol2D ;
+ { pd << ", theTol2D=" << theTol2D ; }
if ( fabs(theTol3D-0.0001) > Precision::Confusion() )
- pd << ", theTol3D=" << theTol3D ;
+ { pd << ", theTol3D=" << theTol3D ; }
if ( theNbIter != 0 ) pd << ", theNbIter=" << theNbIter ;
if ( theMethod==1 ) pd << ", theMethod=GEOM.FOM_UseOri";
else if( theMethod==2 ) pd << ", theMethod=GEOM.FOM_AutoCorrect";
- if(isApprox) pd << ", isApprox=" << isApprox ;
+ if ( isApprox ) pd << ", isApprox=" << isApprox ;
pd << ")";
SetErrorCode(OK);
//Compute the ThruSections value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("ThruSections driver failed");
return anObj;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return anObj;
}
* MakePipeWithDifferentSections
*/
//=============================================================================
-Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePipeWithDifferentSections(
- const Handle(TColStd_HSequenceOfTransient)& theBases,
- const Handle(TColStd_HSequenceOfTransient)& theLocations,
- const Handle(GEOM_Object)& thePath,
- bool theWithContact,
- bool theWithCorrections)
+Handle(TColStd_HSequenceOfTransient)
+ GEOMImpl_I3DPrimOperations::MakePipeWithDifferentSections
+ (const Handle(TColStd_HSequenceOfTransient) &theBases,
+ const Handle(TColStd_HSequenceOfTransient) &theLocations,
+ const Handle(GEOM_Object) &thePath,
+ const bool theWithContact,
+ const bool theWithCorrections,
+ const bool IsBySteps,
+ const bool IsGenerateGroups)
{
- Handle(GEOM_Object) anObj;
SetErrorCode(KO);
if(theBases.IsNull())
- return anObj;
+ return NULL;
Standard_Integer nbBases = theBases->Length();
if (!nbBases)
- return anObj;
+ return NULL;
Standard_Integer nbLocs = (theLocations.IsNull() ? 0 :theLocations->Length());
//Add a new Pipe object
Handle(GEOM_Function) aFunction =
aPipeDS->AddFunction(GEOMImpl_PipeDriver::GetID(), PIPE_DIFFERENT_SECTIONS);
- if (aFunction.IsNull()) return anObj;
+ if (aFunction.IsNull()) return NULL;
//Check if the function is set correctly
- if (aFunction->GetDriverGUID() != GEOMImpl_PipeDriver::GetID()) return anObj;
+ if (aFunction->GetDriverGUID() != GEOMImpl_PipeDriver::GetID()) return NULL;
GEOMImpl_IPipeDiffSect aCI (aFunction);
Handle(GEOM_Function) aRefPath = thePath->GetLastFunction();
if(aRefPath.IsNull())
- return anObj;
+ return NULL;
Handle(TColStd_HSequenceOfTransient) aSeqBases = new TColStd_HSequenceOfTransient;
Handle(TColStd_HSequenceOfTransient) aSeqLocs = new TColStd_HSequenceOfTransient;
}
if(!aSeqBases->Length())
- return anObj;
+ return NULL;
aCI.SetBases(aSeqBases);
aCI.SetLocations(aSeqLocs);
aCI.SetPath(aRefPath);
- aCI.SetWithContactMode(theWithContact);
- aCI.SetWithCorrectionMode(theWithCorrections);
+
+ if (!IsBySteps) {
+ aCI.SetWithContactMode(theWithContact);
+ aCI.SetWithCorrectionMode(theWithCorrections);
+ }
+
+ aCI.SetIsBySteps(IsBySteps);
+ aCI.SetGenerateGroups(IsGenerateGroups);
//Compute the Pipe value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Pipe with defferent section driver failed");
- return anObj;
+ return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
- return anObj;
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
+ return NULL;
}
+ // Create the sequence of objects.
+ Handle(TColStd_HSequenceOfTransient) aSeq = new TColStd_HSequenceOfTransient;
+
+ aSeq->Append(aPipeDS);
+ createGroups(aPipeDS, &aCI, aSeq);
+
//Make a Python command
GEOM::TPythonDump pyDump(aFunction);
- pyDump << aPipeDS << " = geompy.MakePipeWithDifferentSections([";
+
+ if (IsGenerateGroups) {
+ pyDump << aSeq;
+ } else {
+ pyDump << aPipeDS;
+ }
+
+ if (IsBySteps) {
+ pyDump << " = geompy.MakePipeWithDifferentSectionsBySteps([";
+ } else {
+ pyDump << " = geompy.MakePipeWithDifferentSections([";
+ }
for(i =1 ; i <= nbBases; i++) {
}
}
- pyDump<< "], "<<thePath<<","<<theWithContact << "," << theWithCorrections<<")";
+ pyDump<< "], "<<thePath;
+
+ if (!IsBySteps) {
+ pyDump<<","<<theWithContact << "," << theWithCorrections;
+ }
+
+ if (IsGenerateGroups) {
+ pyDump << ", True";
+ }
+
+ pyDump << ")";
SetErrorCode(OK);
- return aPipeDS;
+ return aSeq;
}
* MakePipeWithShellSections
*/
//=============================================================================
-Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePipeWithShellSections(
- const Handle(TColStd_HSequenceOfTransient)& theBases,
- const Handle(TColStd_HSequenceOfTransient)& theSubBases,
- const Handle(TColStd_HSequenceOfTransient)& theLocations,
- const Handle(GEOM_Object)& thePath,
- bool theWithContact,
- bool theWithCorrections)
+Handle(TColStd_HSequenceOfTransient)
+ GEOMImpl_I3DPrimOperations::MakePipeWithShellSections
+ (const Handle(TColStd_HSequenceOfTransient) &theBases,
+ const Handle(TColStd_HSequenceOfTransient) &theSubBases,
+ const Handle(TColStd_HSequenceOfTransient) &theLocations,
+ const Handle(GEOM_Object) &thePath,
+ const bool theWithContact,
+ const bool theWithCorrections,
+ const bool IsGenerateGroups)
{
- Handle(GEOM_Object) anObj;
SetErrorCode(KO);
if(theBases.IsNull())
- return anObj;
+ return NULL;
Standard_Integer nbBases = theBases->Length();
if (!nbBases)
- return anObj;
+ return NULL;
Standard_Integer nbSubBases = (theSubBases.IsNull() ? 0 :theSubBases->Length());
Handle(GEOM_Function) aFunction =
aPipeDS->AddFunction(GEOMImpl_PipeDriver::GetID(), PIPE_SHELL_SECTIONS);
- if (aFunction.IsNull()) return anObj;
+ if (aFunction.IsNull()) return NULL;
//Check if the function is set correctly
- if (aFunction->GetDriverGUID() != GEOMImpl_PipeDriver::GetID()) return anObj;
+ if (aFunction->GetDriverGUID() != GEOMImpl_PipeDriver::GetID()) return NULL;
//GEOMImpl_IPipeDiffSect aCI (aFunction);
GEOMImpl_IPipeShellSect aCI (aFunction);
Handle(GEOM_Function) aRefPath = thePath->GetLastFunction();
if(aRefPath.IsNull())
- return anObj;
+ return NULL;
Handle(TColStd_HSequenceOfTransient) aSeqBases = new TColStd_HSequenceOfTransient;
Handle(TColStd_HSequenceOfTransient) aSeqSubBases = new TColStd_HSequenceOfTransient;
}
if(!aSeqBases->Length())
- return anObj;
+ return NULL;
aCI.SetBases(aSeqBases);
aCI.SetSubBases(aSeqSubBases);
aCI.SetPath(aRefPath);
aCI.SetWithContactMode(theWithContact);
aCI.SetWithCorrectionMode(theWithCorrections);
+ aCI.SetGenerateGroups(IsGenerateGroups);
//Compute the Pipe value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Pipe with shell sections driver failed");
- return anObj;
+ return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
- return anObj;
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
+ return NULL;
}
+ // Create the sequence of objects.
+ Handle(TColStd_HSequenceOfTransient) aSeq = new TColStd_HSequenceOfTransient;
+
+ aSeq->Append(aPipeDS);
+ createGroups(aPipeDS, &aCI, aSeq);
+
//Make a Python command
GEOM::TPythonDump pyDump(aFunction);
- pyDump << aPipeDS << " = geompy.MakePipeWithShellSections([";
+
+ if (IsGenerateGroups) {
+ pyDump << aSeq;
+ } else {
+ pyDump << aPipeDS;
+ }
+
+ pyDump << " = geompy.MakePipeWithShellSections([";
for(i =1 ; i <= nbBases; i++) {
}
}
- pyDump<< "], "<<thePath<<","<<theWithContact << "," << theWithCorrections<<")";
+ pyDump<< "], "<<thePath<<","<<theWithContact << "," << theWithCorrections;
+
+ if (IsGenerateGroups) {
+ pyDump << ", True";
+ }
+
+ pyDump << ")";
SetErrorCode(OK);
- return aPipeDS;
+ return aSeq;
}
* MakePipeShellsWithoutPath
*/
//=============================================================================
-Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePipeShellsWithoutPath(
- const Handle(TColStd_HSequenceOfTransient)& theBases,
- const Handle(TColStd_HSequenceOfTransient)& theLocations)
+Handle(TColStd_HSequenceOfTransient)
+ GEOMImpl_I3DPrimOperations::MakePipeShellsWithoutPath
+ (const Handle(TColStd_HSequenceOfTransient) &theBases,
+ const Handle(TColStd_HSequenceOfTransient) &theLocations,
+ const bool IsGenerateGroups)
{
- Handle(GEOM_Object) anObj;
SetErrorCode(KO);
if(theBases.IsNull())
- return anObj;
+ return NULL;
Standard_Integer nbBases = theBases->Length();
if (!nbBases)
- return anObj;
+ return NULL;
Standard_Integer nbLocs = (theLocations.IsNull() ? 0 :theLocations->Length());
Handle(GEOM_Function) aFunction =
aPipeDS->AddFunction(GEOMImpl_PipeDriver::GetID(), PIPE_SHELLS_WITHOUT_PATH);
- if (aFunction.IsNull()) return anObj;
+ if (aFunction.IsNull()) return NULL;
//Check if the function is set correctly
- if (aFunction->GetDriverGUID() != GEOMImpl_PipeDriver::GetID()) return anObj;
+ if (aFunction->GetDriverGUID() != GEOMImpl_PipeDriver::GetID()) return NULL;
GEOMImpl_IPipeShellSect aCI (aFunction);
}
if(!aSeqBases->Length())
- return anObj;
+ return NULL;
aCI.SetBases(aSeqBases);
aCI.SetLocations(aSeqLocs);
+ aCI.SetGenerateGroups(IsGenerateGroups);
//Compute the Pipe value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Pipe with shell sections without path driver failed");
- return anObj;
+ return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
- return anObj;
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
+ return NULL;
}
+ // Create the sequence of objects.
+ Handle(TColStd_HSequenceOfTransient) aSeq = new TColStd_HSequenceOfTransient;
+
+ aSeq->Append(aPipeDS);
+ createGroups(aPipeDS, &aCI, aSeq);
+
//Make a Python command
GEOM::TPythonDump pyDump(aFunction);
- pyDump << aPipeDS << " = geompy.MakePipeShellsWithoutPath([";
+
+ if (IsGenerateGroups) {
+ pyDump << aSeq;
+ } else {
+ pyDump << aPipeDS;
+ }
+
+ pyDump << " = geompy.MakePipeShellsWithoutPath([";
for(i =1 ; i <= nbBases; i++) {
}
}
- pyDump<< "])";
+ pyDump<< "]";
+
+ if (IsGenerateGroups) {
+ pyDump << ", True";
+ }
+
+ pyDump << ")";
SetErrorCode(OK);
- return aPipeDS;
+ return aSeq;
}
* MakePipeBiNormalAlongVector
*/
//=============================================================================
-Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePipeBiNormalAlongVector (Handle(GEOM_Object) theBase,
- Handle(GEOM_Object) thePath,
- Handle(GEOM_Object) theVec)
+Handle(TColStd_HSequenceOfTransient)
+ GEOMImpl_I3DPrimOperations::MakePipeBiNormalAlongVector
+ (const Handle(GEOM_Object) &theBase,
+ const Handle(GEOM_Object) &thePath,
+ const Handle(GEOM_Object) &theVec,
+ const bool IsGenerateGroups)
{
SetErrorCode(KO);
aCI.SetBase(aRefBase);
aCI.SetPath(aRefPath);
aCI.SetVector(aRefVec);
+ aCI.SetGenerateGroups(IsGenerateGroups);
//Compute the Pipe value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Pipe driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
+ // Create the sequence of objects.
+ Handle(TColStd_HSequenceOfTransient) aSeq = new TColStd_HSequenceOfTransient;
+
+ aSeq->Append(aPipe);
+ createGroups(aPipe, &aCI, aSeq);
+
//Make a Python command
- GEOM::TPythonDump(aFunction) << aPipe << " = geompy.MakePipeBiNormalAlongVector("
- << theBase << ", " << thePath << ", " << theVec << ")";
+ GEOM::TPythonDump pyDump(aFunction);
+
+ if (IsGenerateGroups) {
+ pyDump << aSeq;
+ } else {
+ pyDump << aPipe;
+ }
+
+ pyDump << " = geompy.MakePipeBiNormalAlongVector("
+ << theBase << ", " << thePath << ", " << theVec;
+
+ if (IsGenerateGroups) {
+ pyDump << ", True";
+ }
+
+ pyDump << ")";
SetErrorCode(OK);
- return aPipe;
+ return aSeq;
}
//=============================================================================
* MakeThickening
*/
//=============================================================================
-Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeThickening(Handle(GEOM_Object) theObject,
- double theOffset,
- bool copy = true)
+Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeThickening
+ (Handle(GEOM_Object) theObject,
+ const Handle(TColStd_HArray1OfInteger) &theFacesIDs,
+ double theOffset,
+ bool isCopy,
+ bool theInside)
{
SetErrorCode(KO);
//Add a new Offset function
Handle(GEOM_Function) aFunction;
Handle(GEOM_Object) aCopy;
- if (copy)
+ if (isCopy)
{
//Add a new Copy object
aCopy = GetEngine()->AddObject(GetDocID(), theObject->GetType());
GEOMImpl_IOffset aTI (aFunction);
aTI.SetShape(anOriginal);
aTI.SetValue(theOffset);
+ aTI.SetParam(theInside);
+
+ if (theFacesIDs.IsNull() == Standard_False) {
+ aTI.SetFaceIDs(theFacesIDs);
+ }
//Compute the offset
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("Offset driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
//Make a Python command
- if(copy)
- {
- GEOM::TPythonDump(aFunction) << aCopy << " = geompy.MakeThickSolid("
- << theObject << ", " << theOffset << ")";
- SetErrorCode(OK);
- return aCopy;
+ GEOM::TPythonDump pd (aFunction);
+ Handle(GEOM_Object) aResult;
+
+ if (isCopy) {
+ pd << aCopy << " = geompy.MakeThickSolid("
+ << theObject << ", " << theOffset;
+ aResult = aCopy;
+ } else {
+ pd << "geompy.Thicken(" << theObject << ", " << theOffset;
+ aResult = theObject;
}
- else
- {
- GEOM::TPythonDump(aFunction) << "geompy.Thicken("
- << theObject << ", " << theOffset << ")";
- SetErrorCode(OK);
- return theObject;
+
+ pd << ", [";
+ if (theFacesIDs.IsNull() == Standard_False) {
+ // Dump faces IDs.
+ Standard_Integer i;
+
+ for (i = theFacesIDs->Lower(); i < theFacesIDs->Upper(); ++i) {
+ pd << theFacesIDs->Value(i) << ", ";
+ }
+ // Dump the last value.
+ pd << theFacesIDs->Value(i);
}
+ pd << "]";
+
+ if (theInside)
+ pd << ", " << theInside;
+
+ pd << ")";
+ SetErrorCode(OK);
+
+ return aResult;
}
//=============================================================================
// Compute the Path value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("PipePath driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
+ catch (Standard_Failure& aFail) {
SetErrorCode("RestorePath: inappropriate arguments given");
return NULL;
}
// Compute the Path value
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
if (!GetSolver()->ComputeFunction(aFunction)) {
SetErrorCode("PipePath driver failed");
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
+ catch (Standard_Failure& aFail) {
SetErrorCode("RestorePath: inappropriate arguments given");
return NULL;
}
SetErrorCode(OK);
return aPath;
}
+
+//=============================================================================
+/*!
+ * createGroup
+ */
+//=============================================================================
+Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::createGroup
+ (const Handle(GEOM_Object) &theBaseObject,
+ const Handle(TColStd_HArray1OfInteger) &theGroupIDs,
+ const TCollection_AsciiString &theName,
+ const TopTools_IndexedMapOfShape &theIndices)
+{
+ if (theBaseObject.IsNull() || theGroupIDs.IsNull()) {
+ return NULL;
+ }
+
+ // Get the Shape type.
+ const Standard_Integer anID = theGroupIDs->Value(theGroupIDs->Lower());
+ const Standard_Integer aNbShapes = theIndices.Extent();
+
+ if (anID < 1 || anID > aNbShapes) {
+ return NULL;
+ }
+
+ const TopoDS_Shape aSubShape = theIndices.FindKey(anID);
+
+ if (aSubShape.IsNull()) {
+ return NULL;
+ }
+
+ // Create a group.
+ const TopAbs_ShapeEnum aGroupType = aSubShape.ShapeType();
+ Handle(GEOM_Object) aGroup =
+ myGroupOperations->CreateGroup(theBaseObject, aGroupType);
+
+ if (aGroup.IsNull() == Standard_False) {
+ aGroup->GetLastFunction()->SetDescription("");
+ aGroup->SetName(theName.ToCString());
+
+ Handle(TColStd_HSequenceOfInteger) aSeqIDs = new TColStd_HSequenceOfInteger;
+ Standard_Integer i;
+
+ for (i = theGroupIDs->Lower(); i <= theGroupIDs->Upper(); ++i) {
+ // Get and check the index.
+ const Standard_Integer anIndex = theGroupIDs->Value(i);
+
+ if (anIndex < 1 || anIndex > aNbShapes) {
+ return NULL;
+ }
+
+ // Get and check the sub-shape.
+ const TopoDS_Shape aSubShape = theIndices.FindKey(anIndex);
+
+ if (aSubShape.IsNull()) {
+ return NULL;
+ }
+
+ // Check the shape type.
+ if (aSubShape.ShapeType() != aGroupType) {
+ return NULL;
+ }
+
+ aSeqIDs->Append(anIndex);
+ }
+
+ myGroupOperations->UnionIDs(aGroup, aSeqIDs);
+ aGroup->GetLastFunction()->SetDescription("");
+ }
+
+ return aGroup;
+}
+
+//=============================================================================
+/*!
+ * createGroups
+ */
+//=============================================================================
+void GEOMImpl_I3DPrimOperations::createGroups
+ (const Handle(GEOM_Object) &theBaseObject,
+ GEOMImpl_IPipe *thePipe,
+ Handle(TColStd_HSequenceOfTransient) &theSequence)
+{
+ if (theBaseObject.IsNull() || thePipe == NULL || theSequence.IsNull()) {
+ return;
+ }
+
+ TopoDS_Shape aShape = theBaseObject->GetValue();
+
+ if (aShape.IsNull()) {
+ return;
+ }
+
+ TopTools_IndexedMapOfShape anIndices;
+ Handle(TColStd_HArray1OfInteger) aGroupIDs;
+ TopoDS_Shape aShapeType;
+ const Standard_Integer aNbGroups = 5;
+ Handle(GEOM_Object) aGrps[aNbGroups];
+ Standard_Integer i;
+
+ TopExp::MapShapes(aShape, anIndices);
+
+ // Create groups.
+ aGroupIDs = thePipe->GetGroupDown();
+ aGrps[0] = createGroup(theBaseObject, aGroupIDs, "GROUP_DOWN", anIndices);
+ aGroupIDs = thePipe->GetGroupUp();
+ aGrps[1] = createGroup(theBaseObject, aGroupIDs, "GROUP_UP", anIndices);
+ aGroupIDs = thePipe->GetGroupSide1();
+ aGrps[2] = createGroup(theBaseObject, aGroupIDs, "GROUP_SIDE1", anIndices);
+ aGroupIDs = thePipe->GetGroupSide2();
+ aGrps[3] = createGroup(theBaseObject, aGroupIDs, "GROUP_SIDE2", anIndices);
+ aGroupIDs = thePipe->GetGroupOther();
+ aGrps[4] = createGroup(theBaseObject, aGroupIDs, "GROUP_OTHER", anIndices);
+
+ for (i = 0; i < aNbGroups; ++i) {
+ if (aGrps[i].IsNull() == Standard_False) {
+ theSequence->Append(aGrps[i]);
+ }
+ }
+}
