* the path shape. The path shape can be a wire or an edge.
* \param theBase Base shape to be extruded.
* \param thePath Path shape to extrude the base shape along it.
- * \return New GEOM_Object, containing the created pipe.
+ * \param IsGenerateGroups flag that tells if it is necessary to
+ * return groups (true) or not (false).
+ * \return The list of objects. The first one is a result pipe,
+ * the other ones are the created groups. If \a IsGenerateGroups
+ * is not set the returned list contains a single object, which
+ * is the operation result.
*/
- GEOM_Object MakePipe (in GEOM_Object theBase, in GEOM_Object thePath);
+ ListOfGO MakePipe (in GEOM_Object theBase,
+ in GEOM_Object thePath,
+ in boolean IsGenerateGroups);
/*!
* \brief Create a shape by revolution of the base shape around the axis
* contact with the spine.
* \param theWithCorrection - defining that the section is rotated to be
* orthogonal to the spine tangent in the correspondent point
- * \return New GEOM_Object, containing the created pipe.
+ * \param IsGenerateGroups flag that tells if it is necessary to
+ * return groups (true) or not (false).
+ * \return The list of objects. The first one is a result pipe,
+ * the other ones are the created groups. If \a IsGenerateGroups
+ * is not set the returned list contains a single object, which
+ * is the operation result.
*/
- GEOM_Object MakePipeWithDifferentSections (in ListOfGO theSeqBases,
- in ListOfGO theLocations,
- in GEOM_Object thePath,
- in boolean theWithContact ,
- in boolean theWithCorrection );
+ ListOfGO MakePipeWithDifferentSections (in ListOfGO theSeqBases,
+ in ListOfGO theLocations,
+ in GEOM_Object thePath,
+ in boolean theWithContact ,
+ in boolean theWithCorrection,
+ in boolean IsGenerateGroups);
/*!
* \brief Create a shape by extrusion of the profile shape along
* contact with the spine.
* \param theWithCorrection - defining that the section is rotated to be
* orthogonal to the spine tangent in the correspondent point
- * \return New GEOM_Object, containing the created pipe.
- */
- GEOM_Object MakePipeWithShellSections (in ListOfGO theSeqBases,
- in ListOfGO theSeqSubBases,
- in ListOfGO theLocations,
- in GEOM_Object thePath,
- in boolean theWithContact ,
- in boolean theWithCorrection );
+ * \param IsGenerateGroups flag that tells if it is necessary to
+ * return groups (true) or not (false).
+ * \return The list of objects. The first one is a result pipe,
+ * the other ones are the created groups. If \a IsGenerateGroups
+ * is not set the returned list contains a single object, which
+ * is the operation result.
+ */
+ ListOfGO MakePipeWithShellSections (in ListOfGO theSeqBases,
+ in ListOfGO theSeqSubBases,
+ in ListOfGO theLocations,
+ in GEOM_Object thePath,
+ in boolean theWithContact,
+ in boolean theWithCorrection,
+ in boolean IsGenerateGroups);
/*!
* \brief Create solids between given sections
* \param theSeqBases - list of sections (shell or face).
* \param theLocations - list of corresponding vertexes
- * \return New GEOM_Object, containing the created solids.
+ * \param IsGenerateGroups flag that tells if it is necessary to
+ * return groups (true) or not (false).
+ * \return The list of objects. The first one is a result pipe,
+ * the other ones are the created groups. If \a IsGenerateGroups
+ * is not set the returned list contains a single object, which
+ * is the operation result.
*/
- GEOM_Object MakePipeShellsWithoutPath (in ListOfGO theSeqBases,
- in ListOfGO theLocations);
+ ListOfGO MakePipeShellsWithoutPath (in ListOfGO theSeqBases,
+ in ListOfGO theLocations,
+ in boolean IsGenerateGroups);
/*!
* \brief Create a shape by extrusion of the base shape along
* \param theVec Vector defines a constant binormal direction to keep the
* same angle beetween the Direction and the sections
* along the sweep surface.
- * \return New GEOM_Object, containing the created pipe.
- */
- GEOM_Object MakePipeBiNormalAlongVector (in GEOM_Object theBase,
- in GEOM_Object thePath,
- in GEOM_Object theVec);
+ * \param IsGenerateGroups flag that tells if it is necessary to
+ * return groups (true) or not (false).
+ * \return The list of objects. The first one is a result pipe,
+ * the other ones are the created groups. If \a IsGenerateGroups
+ * is not set the returned list contains a single object, which
+ * is the operation result.
+ */
+ ListOfGO MakePipeBiNormalAlongVector (in GEOM_Object theBase,
+ in GEOM_Object thePath,
+ in GEOM_Object theVec,
+ in boolean IsGenerateGroups);
/*!
* 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);
return NULL;
}
+ Handle(TColStd_HSequenceOfTransient) aSeq = new TColStd_HSequenceOfTransient;
+
+ aSeq->Append(aPipe);
//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;
}
* 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 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);
OCC_CATCH_SIGNALS;
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;
+ return NULL;
}
+ Handle(TColStd_HSequenceOfTransient) aSeq = new TColStd_HSequenceOfTransient;
+
+ aSeq->Append(aPipeDS);
//Make a Python command
GEOM::TPythonDump pyDump(aFunction);
- pyDump << aPipeDS << " = geompy.MakePipeWithDifferentSections([";
+
+ if (IsGenerateGroups) {
+ pyDump << aSeq;
+ } else {
+ pyDump << aPipeDS;
+ }
+
+ pyDump << " = geompy.MakePipeWithDifferentSections([";
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;
}
* 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);
OCC_CATCH_SIGNALS;
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;
+ return NULL;
}
+ Handle(TColStd_HSequenceOfTransient) aSeq = new TColStd_HSequenceOfTransient;
+
+ aSeq->Append(aPipeDS);
//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);
OCC_CATCH_SIGNALS;
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;
+ return NULL;
}
+ Handle(TColStd_HSequenceOfTransient) aSeq = new TColStd_HSequenceOfTransient;
+
+ aSeq->Append(aPipeDS);
//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);
return NULL;
}
+ Handle(TColStd_HSequenceOfTransient) aSeq = new TColStd_HSequenceOfTransient;
+
+ aSeq->Append(aPipe);
+
//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;
}
//=============================================================================
Standard_EXPORT Handle(GEOM_Object) MakeDraftPrism (Handle(GEOM_Object) theInitShape, Handle(GEOM_Object) theBase,
double theHeight, double theAngle, bool theFuse);
- Standard_EXPORT Handle(GEOM_Object) MakePipe (Handle(GEOM_Object) theBase,
- Handle(GEOM_Object) thePath);
+ Standard_EXPORT Handle(TColStd_HSequenceOfTransient) MakePipe
+ (const Handle(GEOM_Object) &theBase,
+ const Handle(GEOM_Object) &thePath,
+ const bool IsGenerateGroups);
Standard_EXPORT Handle(GEOM_Object) MakeRevolutionAxisAngle (Handle(GEOM_Object) theBase,
Handle(GEOM_Object) theAxis,
double thePreci,
bool theRuled);
- Standard_EXPORT Handle(GEOM_Object) MakePipeWithDifferentSections(
- const Handle(TColStd_HSequenceOfTransient)& theBases,
- const Handle(TColStd_HSequenceOfTransient)& theLocations,
- const Handle(GEOM_Object)& thePath,
- bool theWithContact,
- bool theWithCorrections);
-
- Standard_EXPORT Handle(GEOM_Object) 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);
-
- Standard_EXPORT Handle(GEOM_Object) MakePipeShellsWithoutPath
- (const Handle(TColStd_HSequenceOfTransient)& theBases,
- const Handle(TColStd_HSequenceOfTransient)& theLocations);
-
- Standard_EXPORT Handle(GEOM_Object) MakePipeBiNormalAlongVector (Handle(GEOM_Object) theBase,
- Handle(GEOM_Object) thePath,
- Handle(GEOM_Object) theVec);
+ Standard_EXPORT Handle(TColStd_HSequenceOfTransient)
+ MakePipeWithDifferentSections
+ (const Handle(TColStd_HSequenceOfTransient) &theBases,
+ const Handle(TColStd_HSequenceOfTransient) &theLocations,
+ const Handle(GEOM_Object) &thePath,
+ const bool theWithContact,
+ const bool theWithCorrections,
+ const bool IsGenerateGroups);
+
+ Standard_EXPORT Handle(TColStd_HSequenceOfTransient) 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);
+
+ Standard_EXPORT Handle(TColStd_HSequenceOfTransient) MakePipeShellsWithoutPath
+ (const Handle(TColStd_HSequenceOfTransient) &theBases,
+ const Handle(TColStd_HSequenceOfTransient) &theLocations,
+ const bool IsGenerateGroups);
+
+ Standard_EXPORT Handle(TColStd_HSequenceOfTransient) MakePipeBiNormalAlongVector
+ (const Handle(GEOM_Object) &theBase,
+ const Handle(GEOM_Object) &thePath,
+ const Handle(GEOM_Object) &theVec,
+ const bool IsGenerateGroups);
Standard_EXPORT Handle(GEOM_Object) MakeThickening
(Handle(GEOM_Object) theObject,
* MakePipe
*/
//=============================================================================
-GEOM::GEOM_Object_ptr GEOM_I3DPrimOperations_i::MakePipe
- (GEOM::GEOM_Object_ptr theBase, GEOM::GEOM_Object_ptr thePath)
+GEOM::ListOfGO *GEOM_I3DPrimOperations_i::MakePipe
+ (GEOM::GEOM_Object_ptr theBase,
+ GEOM::GEOM_Object_ptr thePath,
+ CORBA::Boolean IsGenerateGroups)
{
- GEOM::GEOM_Object_var aGEOMObject;
+ GEOM::ListOfGO_var aSeq = new GEOM::ListOfGO;
//Set a not done flag
GetOperations()->SetNotDone();
Handle(GEOM_Object) aBase = GetObjectImpl(theBase);
Handle(GEOM_Object) aPath = GetObjectImpl(thePath);
- if (aBase.IsNull() || aPath.IsNull()) return aGEOMObject._retn();
+ if (aBase.IsNull() || aPath.IsNull()) return aSeq._retn();
//Create the Pipe
- Handle(GEOM_Object) anObject =
- GetOperations()->MakePipe(aBase, aPath);
- if (!GetOperations()->IsDone() || anObject.IsNull())
- return aGEOMObject._retn();
+ Handle(TColStd_HSequenceOfTransient) aHSeq =
+ GetOperations()->MakePipe(aBase, aPath, IsGenerateGroups);
+ if (!GetOperations()->IsDone() || aHSeq.IsNull())
+ return aSeq._retn();
- return GetObject(anObject);
+ Standard_Integer aLength = aHSeq->Length();
+ aSeq->length(aLength);
+ for (Standard_Integer i = 1; i <= aLength; i++)
+ aSeq[i-1] = GetObject(Handle(GEOM_Object)::DownCast(aHSeq->Value(i)));
+
+ return aSeq._retn();
}
//=============================================================================
* MakePipeWithDifferentSections
*/
//=============================================================================
-GEOM::GEOM_Object_ptr GEOM_I3DPrimOperations_i::MakePipeWithDifferentSections
- (const GEOM::ListOfGO& theBases,
- const GEOM::ListOfGO& theLocations,
- GEOM::GEOM_Object_ptr thePath,
- CORBA::Boolean theWithContact,
- CORBA::Boolean theWithCorrections)
+GEOM::ListOfGO *GEOM_I3DPrimOperations_i::MakePipeWithDifferentSections
+ (const GEOM::ListOfGO &theBases,
+ const GEOM::ListOfGO &theLocations,
+ GEOM::GEOM_Object_ptr thePath,
+ CORBA::Boolean theWithContact,
+ CORBA::Boolean theWithCorrections,
+ CORBA::Boolean IsGenerateGroups)
{
- GEOM::GEOM_Object_var aGEOMObject;
+ GEOM::ListOfGO_var aSeq = new GEOM::ListOfGO;
//Set a not done flag
GetOperations()->SetNotDone();
aNbLocs = theLocations.length();
if (aNbLocs && aNbBases != aNbLocs)
- return aGEOMObject._retn();
+ return aSeq._retn();
Handle(GEOM_Object) aPath = GetObjectImpl(thePath);
if (aPath.IsNull())
- return aGEOMObject._retn();
+ return aSeq._retn();
for (ind = 0; ind < aNbBases; ind++) {
Handle(GEOM_Object) aBase = GetObjectImpl(theBases[ind]);
aSeqBases->Append(aBase);
}
if (!aSeqBases->Length())
- return aGEOMObject._retn();
+ return aSeq._retn();
// Make pipe
- Handle(GEOM_Object) anObject =
- GetOperations()->MakePipeWithDifferentSections(aSeqBases,aSeqLocations ,aPath,
- theWithContact,theWithCorrections);
- if (!GetOperations()->IsDone() || anObject.IsNull())
- return aGEOMObject._retn();
-
- return GetObject(anObject);
+ Handle(TColStd_HSequenceOfTransient) aHSeq =
+ GetOperations()->MakePipeWithDifferentSections
+ (aSeqBases, aSeqLocations,
+ aPath, theWithContact,
+ theWithCorrections, IsGenerateGroups);
+ if (!GetOperations()->IsDone() || aHSeq.IsNull())
+ return aSeq._retn();
+
+ Standard_Integer aLength = aHSeq->Length();
+ aSeq->length(aLength);
+ for (Standard_Integer i = 1; i <= aLength; i++)
+ aSeq[i-1] = GetObject(Handle(GEOM_Object)::DownCast(aHSeq->Value(i)));
+
+ return aSeq._retn();
}
* MakePipeWithShellSections
*/
//=============================================================================
-GEOM::GEOM_Object_ptr GEOM_I3DPrimOperations_i::MakePipeWithShellSections
- (const GEOM::ListOfGO& theBases,
- const GEOM::ListOfGO& theSubBases,
- const GEOM::ListOfGO& theLocations,
- GEOM::GEOM_Object_ptr thePath,
- CORBA::Boolean theWithContact,
- CORBA::Boolean theWithCorrections)
+GEOM::ListOfGO *GEOM_I3DPrimOperations_i::MakePipeWithShellSections
+ (const GEOM::ListOfGO &theBases,
+ const GEOM::ListOfGO &theSubBases,
+ const GEOM::ListOfGO &theLocations,
+ GEOM::GEOM_Object_ptr thePath,
+ CORBA::Boolean theWithContact,
+ CORBA::Boolean theWithCorrections,
+ CORBA::Boolean IsGenerateGroups)
{
- GEOM::GEOM_Object_var aGEOMObject;
+ GEOM::ListOfGO_var aSeq = new GEOM::ListOfGO;
//Set a not done flag
GetOperations()->SetNotDone();
aNbLocs = theLocations.length();
if (aNbLocs && aNbBases != aNbLocs)
- return aGEOMObject._retn();
+ return aSeq._retn();
Handle(GEOM_Object) aPath = GetObjectImpl(thePath);
if (aPath.IsNull())
- return aGEOMObject._retn();
+ return aSeq._retn();
for (ind = 0; ind < aNbBases; ind++) {
Handle(GEOM_Object) aBase = GetObjectImpl(theBases[ind]);
}
}
if (!aSeqBases->Length())
- return aGEOMObject._retn();
+ return aSeq._retn();
// Make pipe
- Handle(GEOM_Object) anObject =
- GetOperations()->MakePipeWithShellSections(aSeqBases, aSeqSubBases,
- aSeqLocations, aPath,
- theWithContact, theWithCorrections);
- if (!GetOperations()->IsDone() || anObject.IsNull())
- return aGEOMObject._retn();
-
- return GetObject(anObject);
+ Handle(TColStd_HSequenceOfTransient) aHSeq =
+ GetOperations()->MakePipeWithShellSections
+ (aSeqBases, aSeqSubBases,
+ aSeqLocations, aPath,
+ theWithContact, theWithCorrections, IsGenerateGroups);
+ if (!GetOperations()->IsDone() || aHSeq.IsNull())
+ return aSeq._retn();
+
+ Standard_Integer aLength = aHSeq->Length();
+ aSeq->length(aLength);
+ for (Standard_Integer i = 1; i <= aLength; i++)
+ aSeq[i-1] = GetObject(Handle(GEOM_Object)::DownCast(aHSeq->Value(i)));
+
+ return aSeq._retn();
}
* MakePipeShellsWithoutPath
*/
//=============================================================================
-GEOM::GEOM_Object_ptr GEOM_I3DPrimOperations_i::MakePipeShellsWithoutPath
- (const GEOM::ListOfGO& theBases,
- const GEOM::ListOfGO& theLocations)
+GEOM::ListOfGO *GEOM_I3DPrimOperations_i::MakePipeShellsWithoutPath
+ (const GEOM::ListOfGO &theBases,
+ const GEOM::ListOfGO &theLocations,
+ CORBA::Boolean IsGenerateGroups)
{
- GEOM::GEOM_Object_var aGEOMObject;
+ GEOM::ListOfGO_var aSeq = new GEOM::ListOfGO;
//Set a not done flag
GetOperations()->SetNotDone();
aNbLocs = theLocations.length();
if (aNbLocs && aNbBases != aNbLocs)
- return aGEOMObject._retn();
+ return aSeq._retn();
for (ind = 0; ind < aNbBases; ind++) {
Handle(GEOM_Object) aBase = GetObjectImpl(theBases[ind]);
}
if (!aSeqBases->Length())
- return aGEOMObject._retn();
+ return aSeq._retn();
// Make pipe
- Handle(GEOM_Object) anObject =
- GetOperations()->MakePipeShellsWithoutPath(aSeqBases,aSeqLocations);
+ Handle(TColStd_HSequenceOfTransient) aHSeq =
+ GetOperations()->MakePipeShellsWithoutPath
+ (aSeqBases, aSeqLocations, IsGenerateGroups);
- if (!GetOperations()->IsDone() || anObject.IsNull())
- return aGEOMObject._retn();
+ if (!GetOperations()->IsDone() || aHSeq.IsNull())
+ return aSeq._retn();
- return GetObject(anObject);
+ Standard_Integer aLength = aHSeq->Length();
+ aSeq->length(aLength);
+ for (Standard_Integer i = 1; i <= aLength; i++)
+ aSeq[i-1] = GetObject(Handle(GEOM_Object)::DownCast(aHSeq->Value(i)));
+
+ return aSeq._retn();
}
//=============================================================================
* MakePipeBiNormalAlongVector
*/
//=============================================================================
-GEOM::GEOM_Object_ptr GEOM_I3DPrimOperations_i::MakePipeBiNormalAlongVector
- (GEOM::GEOM_Object_ptr theBase,
- GEOM::GEOM_Object_ptr thePath,
- GEOM::GEOM_Object_ptr theVec)
+GEOM::ListOfGO *GEOM_I3DPrimOperations_i::MakePipeBiNormalAlongVector
+ (GEOM::GEOM_Object_ptr theBase,
+ GEOM::GEOM_Object_ptr thePath,
+ GEOM::GEOM_Object_ptr theVec,
+ CORBA::Boolean IsGenerateGroups)
{
- GEOM::GEOM_Object_var aGEOMObject;
+ GEOM::ListOfGO_var aSeq = new GEOM::ListOfGO;
//Set a not done flag
GetOperations()->SetNotDone();
Handle(GEOM_Object) aPath = GetObjectImpl(thePath);
Handle(GEOM_Object) aVec = GetObjectImpl(theVec);
- if (aBase.IsNull() || aPath.IsNull() || aVec.IsNull()) return aGEOMObject._retn();
+ if (aBase.IsNull() || aPath.IsNull() || aVec.IsNull()) return aSeq._retn();
//Create the Pipe
- Handle(GEOM_Object) anObject =
- GetOperations()->MakePipeBiNormalAlongVector(aBase, aPath, aVec);
- if (!GetOperations()->IsDone() || anObject.IsNull())
- return aGEOMObject._retn();
-
- return GetObject(anObject);
+ Handle(TColStd_HSequenceOfTransient) aHSeq =
+ GetOperations()->MakePipeBiNormalAlongVector
+ (aBase, aPath, aVec, IsGenerateGroups);
+ if (!GetOperations()->IsDone() || aHSeq.IsNull())
+ return aSeq._retn();
+
+ Standard_Integer aLength = aHSeq->Length();
+ aSeq->length(aLength);
+ for (Standard_Integer i = 1; i <= aLength; i++)
+ aSeq[i-1] = GetObject(Handle(GEOM_Object)::DownCast(aHSeq->Value(i)));
+
+ return aSeq._retn();
}
//=============================================================================
CORBA::Double theHeight,
CORBA::Double theAngle,
CORBA::Boolean theFuse);
-
- GEOM::GEOM_Object_ptr MakePipe (GEOM::GEOM_Object_ptr theBase,
- GEOM::GEOM_Object_ptr thePath);
+
+ GEOM::ListOfGO *MakePipe (GEOM::GEOM_Object_ptr theBase,
+ GEOM::GEOM_Object_ptr thePath,
+ CORBA::Boolean IsGenerateGroups);
GEOM::GEOM_Object_ptr MakeRevolutionAxisAngle (GEOM::GEOM_Object_ptr theBase,
GEOM::GEOM_Object_ptr theAxis,
CORBA::Boolean theModeSolid,
CORBA::Double thePreci,
CORBA::Boolean theRuled);
-
- GEOM::GEOM_Object_ptr MakePipeWithDifferentSections(const GEOM::ListOfGO& theBases,
- const GEOM::ListOfGO& theLocations,
- GEOM::GEOM_Object_ptr thePath,
- CORBA::Boolean theWithContact,
- CORBA::Boolean theWithCorrections);
-
- GEOM::GEOM_Object_ptr MakePipeWithShellSections(const GEOM::ListOfGO& theBases,
- const GEOM::ListOfGO& theSubBases,
- const GEOM::ListOfGO& theLocations,
- GEOM::GEOM_Object_ptr thePath,
- CORBA::Boolean theWithContact,
- CORBA::Boolean theWithCorrections);
-
- GEOM::GEOM_Object_ptr MakePipeShellsWithoutPath(const GEOM::ListOfGO& theBases,
- const GEOM::ListOfGO& theLocations);
-
- GEOM::GEOM_Object_ptr MakePipeBiNormalAlongVector (GEOM::GEOM_Object_ptr theBase,
- GEOM::GEOM_Object_ptr thePath,
- GEOM::GEOM_Object_ptr theVec);
-
+
+ GEOM::ListOfGO *MakePipeWithDifferentSections
+ (const GEOM::ListOfGO &theBases,
+ const GEOM::ListOfGO &theLocations,
+ GEOM::GEOM_Object_ptr thePath,
+ CORBA::Boolean theWithContact,
+ CORBA::Boolean theWithCorrections,
+ CORBA::Boolean IsGenerateGroups);
+
+ GEOM::ListOfGO *MakePipeWithShellSections
+ (const GEOM::ListOfGO &theBases,
+ const GEOM::ListOfGO &theSubBases,
+ const GEOM::ListOfGO &theLocations,
+ GEOM::GEOM_Object_ptr thePath,
+ CORBA::Boolean theWithContact,
+ CORBA::Boolean theWithCorrections,
+ CORBA::Boolean IsGenerateGroups);
+
+ GEOM::ListOfGO *MakePipeShellsWithoutPath
+ (const GEOM::ListOfGO &theBases,
+ const GEOM::ListOfGO &theLocations,
+ CORBA::Boolean IsGenerateGroups);
+
+ GEOM::ListOfGO *MakePipeBiNormalAlongVector
+ (GEOM::GEOM_Object_ptr theBase,
+ GEOM::GEOM_Object_ptr thePath,
+ GEOM::GEOM_Object_ptr theVec,
+ CORBA::Boolean IsGenerateGroups);
+
GEOM::GEOM_Object_ptr MakeThickening (GEOM::GEOM_Object_ptr theObject,
const GEOM::ListOfLong &theFacesIDs,
CORBA::Double theOffset,
beginService( " GEOM_Superv_i::MakePipe" );
MESSAGE("GEOM_Superv_i::MakePipe");
get3DPrimOp();
- GEOM::GEOM_Object_ptr anObj = my3DPrimOp->MakePipe(theBase, thePath);
+ GEOM::ListOfGO_var aList = my3DPrimOp->MakePipe(theBase, thePath, false);
endService( " GEOM_Superv_i::MakePipe" );
- return anObj;
+ return aList[0];
}
//=============================================================================
beginService( " GEOM_Superv_i::MakePipeWithDifferentSections" );
MESSAGE("GEOM_Superv_i::MakePipeWithDifferentSections");
get3DPrimOp();
- GEOM::GEOM_Object_ptr anObj = my3DPrimOp->MakePipeWithDifferentSections(theBases,theLocations, thePath,theWithContact,theWithCorrections);
+ GEOM::ListOfGO_var aList = my3DPrimOp->MakePipeWithDifferentSections(theBases,theLocations, thePath,theWithContact,theWithCorrections, false);
endService( " GEOM_Superv_i::MakePipeWithDifferentSections" );
- return anObj;
+ return aList[0];
}
beginService( " GEOM_Superv_i::MakePipeWithShellSections" );
MESSAGE("GEOM_Superv_i::MakePipeWithShellSections");
get3DPrimOp();
- GEOM::GEOM_Object_ptr anObj =
+ GEOM::ListOfGO_var aList =
my3DPrimOp->MakePipeWithShellSections(theBases, theSubBases,
theLocations, thePath,
- theWithContact, theWithCorrections);
+ theWithContact, theWithCorrections,
+ false);
endService( " GEOM_Superv_i::MakePipeWithShellSections" );
- return anObj;
+ return aList[0];
}
beginService( " GEOM_Superv_i::MakePipeShellsWithoutPath" );
MESSAGE("GEOM_Superv_i::MakePipeShellsWithoutPath");
get3DPrimOp();
- GEOM::GEOM_Object_ptr anObj =
- my3DPrimOp->MakePipeShellsWithoutPath(theBases,theLocations);
+ GEOM::ListOfGO_var aList =
+ my3DPrimOp->MakePipeShellsWithoutPath(theBases,theLocations, false);
endService( " GEOM_Superv_i::MakePipeShellsWithoutPath" );
- return anObj;
+ return aList[0];
}
beginService( " GEOM_Superv_i::MakePipeBiNormalAlongVector" );
MESSAGE("GEOM_Superv_i::MakePipeBiNormalAlongVector");
get3DPrimOp();
- GEOM::GEOM_Object_ptr anObj =
- my3DPrimOp->MakePipeBiNormalAlongVector(theBase, thePath, theVec);
+ GEOM::ListOfGO_var aList =
+ my3DPrimOp->MakePipeBiNormalAlongVector(theBase, thePath, theVec, false);
endService( " GEOM_Superv_i::MakePipeBiNormalAlongVector" );
- return anObj;
+ return aList[0];
}
return anObj
## Create a shape by extrusion of the base shape along
- # the path shape. The path shape can be a wire or an edge.
+ # the path shape. The path shape can be a wire or an edge. It is
+ # possible to generate groups along with the result by means of
+ # setting the flag \a IsGenerateGroups.<BR>
+ # If \a thePath is a closed edge or wire and \a IsGenerateGroups is
+ # set, an error is occured. If \a thePath is not closed edge/wire,
+ # the following groups are returned:
+ # - If \a theBase is unclosed edge or wire: "Down", "Up", "Side1",
+ # "Side2";
+ # - If \a theBase is closed edge or wire, face or shell: "Down", "Up",
+ # "Other".
+ # .
+ # "Down" and "Up" groups contain:
+ # - Edges if \a theBase is edge or wire;
+ # - Faces if \a theBase is face or shell.<BR>
+ # .
+ # "Side1" and "Side2" groups contain edges generated from the first
+ # and last vertices of \a theBase. The first and last vertices are
+ # determined taking into account edge/wire orientation.<BR>
+ # "Other" group represents faces generated from the bounding edges of
+ # \a theBase.
+ #
# @param theBase Base shape to be extruded.
# @param thePath Path shape to extrude the base shape along it.
+ # @param IsGenerateGroups flag that tells if it is necessary to
+ # create groups. It is equal to False by default.
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return New GEOM.GEOM_Object, containing the created pipe.
+ # @return New GEOM.GEOM_Object, containing the created pipe if
+ # \a IsGenerateGroups is not set. Otherwise it returns new
+ # GEOM.ListOfGO. Its first element is the created pipe, the
+ # remaining ones are created groups.
#
# @ref tui_creation_pipe "Example"
@ManageTransactions("PrimOp")
- def MakePipe(self, theBase, thePath, theName=None):
+ def MakePipe(self, theBase, thePath,
+ IsGenerateGroups=False, theName=None):
"""
Create a shape by extrusion of the base shape along
- the path shape. The path shape can be a wire or an edge.
+ the path shape. The path shape can be a wire or an edge. It is
+ possible to generate groups along with the result by means of
+ setting the flag IsGenerateGroups.
+ If thePath is a closed edge or wire and IsGenerateGroups is
+ set, an error is occured. If thePath is not closed edge/wire,
+ the following groups are returned:
+ - If theBase is unclosed edge or wire: "Down", "Up", "Side1",
+ "Side2";
+ - If theBase is closed edge or wire, face or shell: "Down", "Up",
+ "Other".
+ "Down" and "Up" groups contain:
+ - Edges if theBase is edge or wire;
+ - Faces if theBase is face or shell.
+ "Side1" and "Side2" groups contain edges generated from the first
+ and last vertices of theBase. The first and last vertices are
+ determined taking into account edge/wire orientation.
+ "Other" group represents faces generated from the bounding edges of
+ theBase.
Parameters:
theBase Base shape to be extruded.
thePath Path shape to extrude the base shape along it.
+ IsGenerateGroups flag that tells if it is necessary to
+ create groups. It is equal to False by default.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
Returns:
- New GEOM.GEOM_Object, containing the created pipe.
+ New GEOM.GEOM_Object, containing the created pipe if
+ IsGenerateGroups is not set. Otherwise it returns new
+ GEOM.ListOfGO. Its first element is the created pipe, the
+ remaining ones are created groups.
"""
# Example: see GEOM_TestAll.py
- anObj = self.PrimOp.MakePipe(theBase, thePath)
+ aList = self.PrimOp.MakePipe(theBase, thePath, IsGenerateGroups)
RaiseIfFailed("MakePipe", self.PrimOp)
- self._autoPublish(anObj, theName, "pipe")
- return anObj
+
+ if IsGenerateGroups:
+ self._autoPublish(aList, theName, "pipe")
+ return aList
+
+ self._autoPublish(aList[0], theName, "pipe")
+ return aList[0]
## Create a shape by extrusion of the profile shape along
# the path shape. The path shape can be a wire or an edge.
# the several profiles can be specified in the several locations of path.
+ # It is possible to generate groups along with the result by means of
+ # setting the flag \a IsGenerateGroups. For detailed information on
+ # groups that can be created please see the method MakePipe().
# @param theSeqBases - list of Bases shape to be extruded.
# @param theLocations - list of locations on the path corresponding
# specified list of the Bases shapes. Number of locations
# contact with the spine.
# @param theWithCorrection - defining that the section is rotated to be
# orthogonal to the spine tangent in the correspondent point
+ # @param IsGenerateGroups - flag that tells if it is necessary to
+ # create groups. It is equal to False by default.
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return New GEOM.GEOM_Object, containing the created pipe.
+ # @return New GEOM.GEOM_Object, containing the created pipe if
+ # \a IsGenerateGroups is not set. Otherwise it returns new
+ # GEOM.ListOfGO. Its first element is the created pipe, the
+ # remaining ones are created groups.
#
# @ref tui_creation_pipe_with_diff_sec "Example"
@ManageTransactions("PrimOp")
def MakePipeWithDifferentSections(self, theSeqBases,
theLocations, thePath,
- theWithContact, theWithCorrection, theName=None):
+ theWithContact, theWithCorrection,
+ IsGenerateGroups=False, theName=None):
"""
Create a shape by extrusion of the profile shape along
the path shape. The path shape can be a wire or an edge.
the several profiles can be specified in the several locations of path.
+ It is possible to generate groups along with the result by means of
+ setting the flag IsGenerateGroups. For detailed information on
+ groups that can be created please see the method geompy.MakePipe().
Parameters:
theSeqBases - list of Bases shape to be extruded.
contact with the spine(0/1)
theWithCorrection - defining that the section is rotated to be
orthogonal to the spine tangent in the correspondent point (0/1)
+ IsGenerateGroups - flag that tells if it is necessary to
+ create groups. It is equal to False by default.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
Returns:
- New GEOM.GEOM_Object, containing the created pipe.
+ New GEOM.GEOM_Object, containing the created pipe if
+ IsGenerateGroups is not set. Otherwise it returns new
+ GEOM.ListOfGO. Its first element is the created pipe, the
+ remaining ones are created groups.
"""
- anObj = self.PrimOp.MakePipeWithDifferentSections(theSeqBases,
+ aList = self.PrimOp.MakePipeWithDifferentSections(theSeqBases,
theLocations, thePath,
- theWithContact, theWithCorrection)
+ theWithContact, theWithCorrection,
+ IsGenerateGroups)
RaiseIfFailed("MakePipeWithDifferentSections", self.PrimOp)
- self._autoPublish(anObj, theName, "pipe")
- return anObj
+
+ if IsGenerateGroups:
+ self._autoPublish(aList, theName, "pipe")
+ return aList
+
+ self._autoPublish(aList[0], theName, "pipe")
+ return aList[0]
## Create a shape by extrusion of the profile shape along
- # the path shape. The path shape can be a wire or a edge.
+ # the path shape. The path shape can be a wire or an edge.
# the several profiles can be specified in the several locations of path.
+ # It is possible to generate groups along with the result by means of
+ # setting the flag \a IsGenerateGroups. For detailed information on
+ # groups that can be created please see the method MakePipe().
# @param theSeqBases - list of Bases shape to be extruded. Base shape must be
# shell or face. If number of faces in neighbour sections
# aren't coincided result solid between such sections will
# contact with the spine.
# @param theWithCorrection - defining that the section is rotated to be
# orthogonal to the spine tangent in the correspondent point
+ # @param IsGenerateGroups - flag that tells if it is necessary to
+ # create groups. It is equal to False by default.
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return New GEOM.GEOM_Object, containing the created solids.
+ # @return New GEOM.GEOM_Object, containing the created solids if
+ # \a IsGenerateGroups is not set. Otherwise it returns new
+ # GEOM.ListOfGO. Its first element is the created solids, the
+ # remaining ones are created groups.
#
# @ref tui_creation_pipe_with_shell_sec "Example"
@ManageTransactions("PrimOp")
def MakePipeWithShellSections(self, theSeqBases, theSeqSubBases,
theLocations, thePath,
- theWithContact, theWithCorrection, theName=None):
+ theWithContact, theWithCorrection,
+ IsGenerateGroups=False, theName=None):
"""
Create a shape by extrusion of the profile shape along
- the path shape. The path shape can be a wire or a edge.
+ the path shape. The path shape can be a wire or an edge.
the several profiles can be specified in the several locations of path.
+ It is possible to generate groups along with the result by means of
+ setting the flag IsGenerateGroups. For detailed information on
+ groups that can be created please see the method geompy.MakePipe().
Parameters:
theSeqBases - list of Bases shape to be extruded. Base shape must be
contact with the spine (0/1)
theWithCorrection - defining that the section is rotated to be
orthogonal to the spine tangent in the correspondent point (0/1)
+ IsGenerateGroups - flag that tells if it is necessary to
+ create groups. It is equal to False by default.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
Returns:
- New GEOM.GEOM_Object, containing the created solids.
+ New GEOM.GEOM_Object, containing the created solids if
+ IsGenerateGroups is not set. Otherwise it returns new
+ GEOM.ListOfGO. Its first element is the created solids, the
+ remaining ones are created groups.
"""
- anObj = self.PrimOp.MakePipeWithShellSections(theSeqBases, theSeqSubBases,
+ aList = self.PrimOp.MakePipeWithShellSections(theSeqBases, theSeqSubBases,
theLocations, thePath,
- theWithContact, theWithCorrection)
+ theWithContact, theWithCorrection,
+ IsGenerateGroups)
RaiseIfFailed("MakePipeWithShellSections", self.PrimOp)
- self._autoPublish(anObj, theName, "pipe")
- return anObj
+
+ if IsGenerateGroups:
+ self._autoPublish(aList, theName, "pipe")
+ return aList
+
+ self._autoPublish(aList[0], theName, "pipe")
+ return aList[0]
## Create a shape by extrusion of the profile shape along
# the path shape. This function is used only for debug pipe
@ManageTransactions("PrimOp")
def MakePipeWithShellSectionsBySteps(self, theSeqBases, theSeqSubBases,
theLocations, thePath,
- theWithContact, theWithCorrection, theName=None):
+ theWithContact, theWithCorrection,
+ IsGenerateGroups=False, theName=None):
"""
Create a shape by extrusion of the profile shape along
the path shape. This function is used only for debug pipe
tmpLocations = [ theLocations[i-1], theLocations[i] ]
tmpSeqSubBases = []
if nbsubsect>0: tmpSeqSubBases = [ theSeqSubBases[i-1], theSeqSubBases[i] ]
- anObj = self.PrimOp.MakePipeWithShellSections(tmpSeqBases, tmpSeqSubBases,
+ aList = self.PrimOp.MakePipeWithShellSections(tmpSeqBases, tmpSeqSubBases,
tmpLocations, thePath,
- theWithContact, theWithCorrection)
+ theWithContact, theWithCorrection,
+ IsGenerateGroups)
if self.PrimOp.IsDone() == 0:
print "Problems with pipe creation between ",i," and ",i+1," sections"
RaiseIfFailed("MakePipeWithShellSections", self.PrimOp)
break
else:
print "Pipe between ",i," and ",i+1," sections is OK"
- res.append(anObj)
+ res.append(aList[0])
pass
pass
self._autoPublish(resc, theName, "pipe")
return resc
- ## Create solids between given sections
+ ## Create solids between given sections.
+ # It is possible to generate groups along with the result by means of
+ # setting the flag \a IsGenerateGroups. For detailed information on
+ # groups that can be created please see the method MakePipe().
# @param theSeqBases - list of sections (shell or face).
# @param theLocations - list of corresponding vertexes
+ # @param IsGenerateGroups - flag that tells if it is necessary to
+ # create groups. It is equal to False by default.
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return New GEOM.GEOM_Object, containing the created solids.
+ # @return New GEOM.GEOM_Object, containing the created solids if
+ # \a IsGenerateGroups is not set. Otherwise it returns new
+ # GEOM.ListOfGO. Its first element is the created solids, the
+ # remaining ones are created groups.
#
# @ref tui_creation_pipe_without_path "Example"
@ManageTransactions("PrimOp")
- def MakePipeShellsWithoutPath(self, theSeqBases, theLocations, theName=None):
+ def MakePipeShellsWithoutPath(self, theSeqBases, theLocations,
+ IsGenerateGroups=False, theName=None):
"""
- Create solids between given sections
+ Create solids between given sections.
+ It is possible to generate groups along with the result by means of
+ setting the flag IsGenerateGroups. For detailed information on
+ groups that can be created please see the method geompy.MakePipe().
Parameters:
theSeqBases - list of sections (shell or face).
theLocations - list of corresponding vertexes
+ IsGenerateGroups - flag that tells if it is necessary to
+ create groups. It is equal to False by default.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
Returns:
- New GEOM.GEOM_Object, containing the created solids.
+ New GEOM.GEOM_Object, containing the created solids if
+ IsGenerateGroups is not set. Otherwise it returns new
+ GEOM.ListOfGO. Its first element is the created solids, the
+ remaining ones are created groups.
"""
- anObj = self.PrimOp.MakePipeShellsWithoutPath(theSeqBases, theLocations)
+ aList = self.PrimOp.MakePipeShellsWithoutPath(theSeqBases, theLocations,
+ IsGenerateGroups)
RaiseIfFailed("MakePipeShellsWithoutPath", self.PrimOp)
- self._autoPublish(anObj, theName, "pipe")
- return anObj
+
+ if IsGenerateGroups:
+ self._autoPublish(aList, theName, "pipe")
+ return aList
+
+ self._autoPublish(aList[0], theName, "pipe")
+ return aList[0]
## Create a shape by extrusion of the base shape along
# the path shape with constant bi-normal direction along the given vector.
# The path shape can be a wire or an edge.
+ # It is possible to generate groups along with the result by means of
+ # setting the flag \a IsGenerateGroups. For detailed information on
+ # groups that can be created please see the method MakePipe().
# @param theBase Base shape to be extruded.
# @param thePath Path shape to extrude the base shape along it.
# @param theVec Vector defines a constant binormal direction to keep the
# same angle beetween the direction and the sections
# along the sweep surface.
+ # @param IsGenerateGroups flag that tells if it is necessary to
+ # create groups. It is equal to False by default.
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return New GEOM.GEOM_Object, containing the created pipe.
+ # @return New GEOM.GEOM_Object, containing the created pipe if
+ # \a IsGenerateGroups is not set. Otherwise it returns new
+ # GEOM.ListOfGO. Its first element is the created pipe, the
+ # remaining ones are created groups.
#
# @ref tui_creation_pipe "Example"
@ManageTransactions("PrimOp")
- def MakePipeBiNormalAlongVector(self, theBase, thePath, theVec, theName=None):
+ def MakePipeBiNormalAlongVector(self, theBase, thePath, theVec,
+ IsGenerateGroups=False, theName=None):
"""
Create a shape by extrusion of the base shape along
the path shape with constant bi-normal direction along the given vector.
The path shape can be a wire or an edge.
+ It is possible to generate groups along with the result by means of
+ setting the flag IsGenerateGroups. For detailed information on
+ groups that can be created please see the method geompy.MakePipe().
Parameters:
theBase Base shape to be extruded.
theVec Vector defines a constant binormal direction to keep the
same angle beetween the direction and the sections
along the sweep surface.
+ IsGenerateGroups flag that tells if it is necessary to
+ create groups. It is equal to False by default.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
Returns:
- New GEOM.GEOM_Object, containing the created pipe.
+ New GEOM.GEOM_Object, containing the created pipe if
+ IsGenerateGroups is not set. Otherwise it returns new
+ GEOM.ListOfGO. Its first element is the created pipe, the
+ remaining ones are created groups.
"""
# Example: see GEOM_TestAll.py
- anObj = self.PrimOp.MakePipeBiNormalAlongVector(theBase, thePath, theVec)
+ aList = self.PrimOp.MakePipeBiNormalAlongVector(theBase, thePath,
+ theVec, IsGenerateGroups)
RaiseIfFailed("MakePipeBiNormalAlongVector", self.PrimOp)
- self._autoPublish(anObj, theName, "pipe")
- return anObj
+
+ if IsGenerateGroups:
+ self._autoPublish(aList, theName, "pipe")
+ return aList
+
+ self._autoPublish(aList[0], theName, "pipe")
+ return aList[0]
## Makes a thick solid from a shape. If the input is a surface shape
# (face or shell) the result is a thick solid. If an input shape is
//=================================================================================
bool GenerationGUI_PipeDlg::execute (ObjectList& objects)
{
- GEOM::GEOM_Object_var anObj;
+ GEOM::ListOfGO_var aList;
GEOM::GEOM_I3DPrimOperations_var anOper = GEOM::GEOM_I3DPrimOperations::_narrow(getOperation());
switch( getConstructorId() ) {
for (int i = 0; i < myBaseObjects.count(); i++) {
switch ( getConstructorId() ) {
case 0 :
- anObj = anOper->MakePipe(myBaseObjects[i].get(), myPath.get());
+ aList = anOper->MakePipe(myBaseObjects[i].get(), myPath.get(), false);
break;
case 1 :
- anObj = anOper->MakePipeBiNormalAlongVector(myBaseObjects[i].get(), myPath.get(), myVec.get());
+ aList = anOper->MakePipeBiNormalAlongVector(myBaseObjects[i].get(), myPath.get(), myVec.get(), false);
break;
}
-
- if (!anObj->_is_nil())
- objects.push_back(anObj._retn());
+
+ if (!aList[0]->_is_nil())
+ objects.push_back(aList[0]._retn());
}
break;
case 2:
for (int i = 0; i < myLocations.count(); i++) {
myLocationsGO[i] = myLocations[i].copy();
}
-
- anObj = anOper->MakePipeWithDifferentSections(myBaseGO.in(), myLocationsGO.in(), myPath.get(),
+
+ aList = anOper->MakePipeWithDifferentSections(myBaseGO.in(), myLocationsGO.in(), myPath.get(),
GroupMakePoints->CheckBox1->isChecked(),
- GroupMakePoints->CheckBox2->isChecked());
- if (!anObj->_is_nil())
- objects.push_back(anObj._retn());
+ GroupMakePoints->CheckBox2->isChecked(), false);
+ if (!aList[0]->_is_nil())
+ objects.push_back(aList[0]._retn());
}
break;
default:
