ForkMaster/geom
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/geom.git synced 2025-01-12 17:50:35 +05:00
Code Issues Packages Projects Releases Wiki Activity

0022869: EDF 7482 GEOM: Automatically create groups with the generation operations

Browse Source
This commit is contained in:
skv 2015-03-23 13:02:48 +03:00 committed by vsr
parent 3275e00630
commit d02f4dc567
32 changed files with 2147 additions and 528 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
doc/salome/gui/GEOM/images/gen_group_disabled.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 28 KiB

BIN
doc/salome/gui/GEOM/images/gen_group_dlg.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 23 KiB

BIN
doc/salome/gui/GEOM/images/gen_group_other.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 8.8 KiB

BIN
doc/salome/gui/GEOM/images/gen_group_sides.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 10 KiB

BIN
doc/salome/gui/GEOM/images/gen_group_tree.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 4.7 KiB

BIN
doc/salome/gui/GEOM/images/pipe.png Executable file → Normal file
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 18 KiB

After

Width:  |  Height:  |  Size: 26 KiB

BIN
doc/salome/gui/GEOM/images/pipe2.png Executable file → Normal file
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 20 KiB

After

Width:  |  Height:  |  Size: 28 KiB

BIN
doc/salome/gui/GEOM/images/pipe3.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 20 KiB

After

Width:  |  Height:  |  Size: 28 KiB

11
doc/salome/gui/GEOM/input/creating_complex_obj.doc
View File

@ -3,23 +3,26 @@
\page create_complex_obj_page Creating Complex Objects
<b>New entity -> Generation</b> sub-menu allows creating new geometric
objects by modification and multiplication of the existing objects:
objects by modification and multiplication of the existing objects:
<ul>
<li>\subpage create_extrusion_page "Extrude" a 2D object by vector,
creating a 3D object. </li>
creating a 3D object. </li>
<li>\subpage create_revolution_page "Revolve" an object around an
axis, creating a body of revolution.</li>
<li>\subpage create_filling_page "Create a surface" from a set of edges.</li>
<li>\subpage create_extrusion_alongpath_page "Extrude an object along a path",
<li>\subpage create_extrusion_alongpath_page "Extrude an object along a path",
creating a more complex trajectory object.</li>
<li>\subpage create_pipe_path_page "Restore Path" of a pipe-like shape.</li>
<li>\subpage create_thickness_page "Thickness" operation that allows to add a thickness to objects.</li>
<li>\subpage create_groups_page "Generate Groups".
This cross-operation functionality allows creation of groups for certain generation operations.</li>
</ul>
<b> New entity -> Advanced </b> sub-menu allows creating new geometric
objects using advanced algorithms:
objects using advanced algorithms:
<ul>
<li>\subpage create_smoothingsurface_page "Smoothing surface" from a

25
doc/salome/gui/GEOM/input/creating_extrusion_alongpath.doc
View File

@ -14,13 +14,17 @@ is created so that the <b>angle between the normal vector</b> to
the base shape <b>and the tangent to the path</b> wire remains constant at any point of the
given path.
\n <b>Select unpublished edges</b> checkbox - if checked, allows to select an edge of any other shape as the path object.
\n <b>Generate groups</b> checkbox - if checked allows to create groups of
sub-shapes. For more details on groups creation please refer to
\ref create_groups_page "this description".
\n The \b Result of the operation will be a GEOM_Object (edge, face, shell,
solid or compsolid).
\n <b>TUI Command:</b> <em>geompy.MakePipe(baseShape, pathShape)</em>
\n <b>TUI Command:</b> <em>geompy.MakePipe(baseShape, pathShape,
IsGenerateGroups=False)</em>
\n <b>Arguments:</b> Name + 1 shape (vertex, edge, planar wire, face or
shell) serving as base object + 1 shape (edge or wire) for
definition of the path.
definition of the path + 1 boolean parameter (IsGenerateGroups).
\n <b>Advanced options</b> \ref preview_anchor "Preview"
\image html pipe.png
@ -39,14 +43,19 @@ wire).
to preserve the constant <b>angle between the normal vector</b> to the base
shape <b>and the BiNormal vector</b> given as the third argument.
\n <b>Select unpublished edges</b> checkbox - if checked, allows to select an edge of any other shape as the path object.
\n <b>Generate groups</b> checkbox - if checked allows to create groups of
sub-shapes. For more details on groups creation please refer to
\ref create_groups_page "this description".
\n The \b Result of the operation will be a GEOM_Object (edge, face, shell,
solid or compsolid).
\n <b>TUI Command:</b> <em>geompy.MakePipeBiNormalAlongVector(baseShape, pathShape, binormalShape)</em>
\n <b>TUI Command:</b> <em>geompy.MakePipeBiNormalAlongVector(baseShape, pathShape, binormalShape,
IsGenerateGroups=False)</em>
\n <b>Arguments:</b> Name + 1 shape (edge, planar wire or face)
serving as base object + 1 shape (edge or wire) for
definition of the path + 1 shape (edge or wire) to set a fixed
BiNormal direction to perform the extrusion.
BiNormal direction to perform the extrusion + 1 boolean parameter
(IsGenerateGroups).
\image html pipe2.png
@ -64,13 +73,17 @@ Additional controls:
- If <b>With correction</b> is checked, the section is rotated to be orthogonal to the spine
tangent in the corresponding point.
<b>Generate groups</b> checkbox - if checked allows to create groups of
sub-shapes. For more details on groups creation please refer to
\ref create_groups_page "this description".
\n The \b Result of the operation will be a shell or a solid.
\n <b>TUI Command:</b> <em>geompy.MakePipeWithDifferentSections(baseShape, locations, pathShape, withContact, withCorrection)</em>
\n <b>TUI Command:</b> <em>geompy.MakePipeWithDifferentSections(baseShape, locations, pathShape, withContact, withCorrection,
IsGenerateGroups=False)</em>
\n <b>Arguments:</b> Name + list of shapes (edges, planar wires, faces or shells) serving as base object +
list of locations (vertices) on the path corresponding specified list of the shapes +
1 shape (edge or wire) for definition of the path +
2 Boolean parameters (withContact, withCorrection).
3 Boolean parameters (withContact, withCorrection, IsGenerateGroups).
\n <b>Advanced options</b> \ref preview_anchor "Preview"
\image html pipe3.png

76
doc/salome/gui/GEOM/input/creating_groups.doc Normal file
View File

@ -0,0 +1,76 @@
/*!
\page create_groups_page Generation of Groups
This option is available in some dialogs. To activate it please check
<b>Generate Groups</b> check box. When it is checked, it is possible to define
the prefix for generated groups names using <b>Group Names Prefix</b> input
field.
\image html gen_group_dlg.png "Generate groups option in a dialog"
The groups are created along with the result of the operation when
\b Apply or <b>Apply and Close</b> button is clicked. Each generated group
represents a set of sub-shapes of the result that satisfies certain conditions.
The groups of the following types can be generated:
- \b Down - sub-shapes starting the result, e.g. bottom lid
for the pipe creation operation.
- \b Up - sub-shapes ending the result, e.g. top lid
for the pipe creation operation.
- \b Side1, \b Side2 - sub-shapes corresponding to each side
of the result.
- \b Other - faces generated from the bounding edges of
\b Down group.
The groups are named according to the following naming rule:
If <b>Group Names Prefix</b> is set <b><Prefix>_<Type></b>, otherwise
the name is \b <Type>. The following figure shows group names created with
the prefix \b Group:
\image html gen_group_tree.png "Group_Down, Group_Up, Group_Side1 and Group_Side2 are generated"
The general behavior of this functionality is the following:
<ul>
<li>If <b>Generate Groups</b> option is not set, the groups are not generated.</li>
<li>If starting and ending sub-shapes of the result are the same, e.g. if there is
a closed path for pipe construction, <b>Generate Groups</b> option is disabled
in the dialog box:</li>
\image html gen_group_disabled.png "Disabled option in the Pipe Construction dialog if the path is closed"
\n
<li>Otherwise If the path is not closed edge/wire, the groups are created depending
on the profile:</li>
<ul>
<li>Profile is unclosed edge or wire: \b Down, \b Up, \b Side1, \b Side2:</li>
\image html gen_group_sides.png "Pipe with created groups Down(Red), Up(Green), Side1(Blue) and Side2(Yellow)"
\n
<li>Profile is closed edge or wire, face or shell: \b Down, \b Up, \b Other:</li>
\image html gen_group_other.png "Created groups Down(Red), Up(Green) and Other(Yellow)"
</ul>
</ul>
\b Down and \b Up groups contain:
- Edges if the profile is edge or wire;
- Faces if the profile is face or shell.
\b Side1 and \b Side2 groups contain edges generated from the first and
last vertices of the profile edge or wire correspondingly. The first and
last vertices are determined taking into account edge/wire orientation.
\b Other group represents faces generated from the bounding edges of profile.
The behavior in TUI is the following:
- Each Python function that supports groups generation has a flag
\b IsGenerateGroups which is equal to \b False by default.
- If \b IsGenerateGroups is not set the groups are not created; the returned
value is GEOM_Object that represents a result of the operation.
- If \b IsGenerateGroups is set the operation returns a list of GEOM_Object.
Its first element is a result, the remaining ones are the groups in the order:
\b Down, \b Up, \b Side1, \b Side2 for opened profile or \b Down, \b Up,
\b Other for closed profile.
- If \b IsGenerateGroups is set and the path is closed an error occurs.
*/

75
idl/GEOM_Gen.idl
View File

@ -1726,9 +1726,16 @@ module GEOM
* 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
@ -1796,13 +1803,19 @@ module GEOM
* 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
@ -1820,23 +1833,35 @@ module GEOM
* 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 MakePipeWithShellSections (in ListOfGO theSeqBases,
in ListOfGO theSeqSubBases,
in ListOfGO theLocations,
in GEOM_Object thePath,
in boolean theWithContact ,
in boolean theWithCorrection );
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
@ -1848,11 +1873,17 @@ module GEOM
* \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.
* \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 MakePipeBiNormalAlongVector (in GEOM_Object theBase,
in GEOM_Object thePath,
in GEOM_Object theVec);
ListOfGO MakePipeBiNormalAlongVector (in GEOM_Object theBase,
in GEOM_Object thePath,
in GEOM_Object theVec,
in boolean IsGenerateGroups);
/*!

28
src/GEOMGUI/GEOM_msg_en.ts
View File

@ -1412,6 +1412,14 @@ Please, select face, shell or solid and try again</translation>
<source>GEOM_SELECT_UNPUBLISHED_EDGES</source>
<translation>Select unpublished edges</translation>
</message>
<message>
<source>GEOM_GENERATE_GROUPS</source>
<translation>Generate Groups</translation>
</message>
<message>
<source>GEOM_GROUP_NAME_PREFIX</source>
<translation>Group Names Prefix</translation>
</message>
<message>
<source>GEOM_PLANE</source>
<translation>Plane</translation>
@ -2420,6 +2428,26 @@ Please, select face, shell or solid and try again</translation>
<source>WRN_NULL_OBJECT_OR_SHAPE</source>
<translation>Shape %1 for solid creation is null</translation>
</message>
<message>
<source>GROUP_DOWN</source>
<translation>Down</translation>
</message>
<message>
<source>GROUP_UP</source>
<translation>Up</translation>
</message>
<message>
<source>GROUP_SIDE1</source>
<translation>Side1</translation>
</message>
<message>
<source>GROUP_SIDE2</source>
<translation>Side2</translation>
</message>
<message>
<source>GROUP_OTHER</source>
<translation>Other</translation>
</message>
<message>
<source>GEOM_X</source>
<translation>X :</translation>

28
src/GEOMImpl/GEOMImpl_GlueDriver.cxx
View File

@ -323,9 +323,11 @@ TopoDS_Shape GEOMImpl_GlueDriver::GlueFacesByList (const TopoDS_Shape& theShape,
//function : GlueFaces
//purpose :
//=======================================================================
TopoDS_Shape GEOMImpl_GlueDriver::GlueFaces (const TopoDS_Shape& theShape,
const Standard_Real theTolerance,
const Standard_Boolean doKeepNonSolids)
TopoDS_Shape GEOMImpl_GlueDriver::GlueFaces
(const TopoDS_Shape &theShape,
const Standard_Real theTolerance,
const Standard_Boolean doKeepNonSolids,
TopTools_DataMapOfShapeListOfShape *pMapModif)
{
TopoDS_Shape aRes;
@ -409,6 +411,26 @@ TopoDS_Shape GEOMImpl_GlueDriver::GlueFaces (const TopoDS_Shape& theShape,
// 5. Result
aRes = aGA.Shape();
if (pMapModif) {
// Fill the map of modified shapes.
TopTools_IndexedMapOfShape aMapSubShapes;
TopExp::MapShapes(theShape, aMapSubShapes);
pMapModif->Clear();
const Standard_Integer aNbShapes = aMapSubShapes.Extent();
Standard_Integer i;
for (i = 1; i <= aNbShapes; ++i) {
const TopoDS_Shape &aSubShape = aMapSubShapes.FindKey(i);
const TopTools_ListOfShape &aModif = aGA.Modified(aSubShape);
if (!aModif.IsEmpty()) {
pMapModif->Bind(aSubShape, aModif);
}
}
}
return aRes;
}

9
src/GEOMImpl/GEOMImpl_GlueDriver.hxx
View File

@ -63,6 +63,7 @@
#include <TCollection_AsciiString.hxx>
class TColStd_SequenceOfExtendedString;
class TopTools_DataMapOfShapeListOfShape;
#include "GEOM_BaseDriver.hxx"
@ -86,9 +87,11 @@ Standard_EXPORT ~GEOMImpl_GlueDriver() {};
bool GetCreationInformation(std::string& theOperationName,
std::vector<GEOM_Param>& params);
Standard_EXPORT static TopoDS_Shape GlueFaces (const TopoDS_Shape& theShape,
const Standard_Real theTolerance,
const Standard_Boolean doKeepNonSolids = Standard_True);
Standard_EXPORT static TopoDS_Shape GlueFaces
(const TopoDS_Shape &theShape,
const Standard_Real theTolerance,
const Standard_Boolean doKeepNonSolids = Standard_True,
TopTools_DataMapOfShapeListOfShape *pMapModif = NULL);
/*
Standard_EXPORT TopoDS_Shape GlueFacesWithWarnings (const TopoDS_Shape& theShape,
const Standard_Real theTolerance,

357
src/GEOMImpl/GEOMImpl_I3DPrimOperations.cxx
View File

@ -61,6 +61,7 @@
#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>
@ -75,6 +76,8 @@
#include <GEOMImpl_IPipePath.hxx>
#include <Precision.hxx>
#include <TopExp.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <Standard_Failure.hxx>
#include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
@ -88,6 +91,7 @@ GEOMImpl_I3DPrimOperations::GEOMImpl_I3DPrimOperations (GEOM_Engine* theEngine,
: GEOM_IOperations(theEngine, theDocID)
{
MESSAGE("GEOMImpl_I3DPrimOperations::GEOMImpl_I3DPrimOperations");
myGroupOperations = new GEOMImpl_IGroupOperations(GetEngine(), GetDocID());
}
//=============================================================================
@ -98,6 +102,7 @@ GEOMImpl_I3DPrimOperations::GEOMImpl_I3DPrimOperations (GEOM_Engine* theEngine,
GEOMImpl_I3DPrimOperations::~GEOMImpl_I3DPrimOperations()
{
MESSAGE("GEOMImpl_I3DPrimOperations::~GEOMImpl_I3DPrimOperations");
delete myGroupOperations;
}
@ -1451,8 +1456,10 @@ Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeDraftPrism
* 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);
@ -1478,6 +1485,7 @@ Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePipe (Handle(GEOM_Object) th
aCI.SetBase(aRefBase);
aCI.SetPath(aRefPath);
aCI.SetGenerateGroups(IsGenerateGroups);
//Compute the Pipe value
try {
@ -1493,12 +1501,31 @@ Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePipe (Handle(GEOM_Object) th
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;
}
@ -1794,22 +1821,23 @@ Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakeThruSections(
* 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
@ -1819,16 +1847,16 @@ Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePipeWithDifferentSections(
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;
@ -1864,31 +1892,45 @@ Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePipeWithDifferentSections(
}
if(!aSeqBases->Length())
return anObj;
return NULL;
aCI.SetBases(aSeqBases);
aCI.SetLocations(aSeqLocs);
aCI.SetPath(aRefPath);
aCI.SetWithContactMode(theWithContact);
aCI.SetWithCorrectionMode(theWithCorrections);
aCI.SetGenerateGroups(IsGenerateGroups);
//Compute the Pipe value
try {
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;
}
// 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;
}
pyDump << " = geompy.MakePipeWithDifferentSections([";
for(i =1 ; i <= nbBases; i++) {
@ -1920,10 +1962,16 @@ Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePipeWithDifferentSections(
}
}
pyDump<< "], "<<thePath<<","<<theWithContact << "," << theWithCorrections<<")";
pyDump<< "], "<<thePath<<","<<theWithContact << "," << theWithCorrections;
if (IsGenerateGroups) {
pyDump << ", True";
}
pyDump << ")";
SetErrorCode(OK);
return aPipeDS;
return aSeq;
}
@ -1932,23 +1980,24 @@ Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePipeWithDifferentSections(
* 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());
@ -1961,17 +2010,17 @@ Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePipeWithShellSections(
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;
@ -2020,7 +2069,7 @@ Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePipeWithShellSections(
}
if(!aSeqBases->Length())
return anObj;
return NULL;
aCI.SetBases(aSeqBases);
aCI.SetSubBases(aSeqSubBases);
@ -2028,24 +2077,38 @@ Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePipeWithShellSections(
aCI.SetPath(aRefPath);
aCI.SetWithContactMode(theWithContact);
aCI.SetWithCorrectionMode(theWithCorrections);
aCI.SetGenerateGroups(IsGenerateGroups);
//Compute the Pipe value
try {
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;
}
// 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++) {
@ -2093,10 +2156,16 @@ Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePipeWithShellSections(
}
}
pyDump<< "], "<<thePath<<","<<theWithContact << "," << theWithCorrections<<")";
pyDump<< "], "<<thePath<<","<<theWithContact << "," << theWithCorrections;
if (IsGenerateGroups) {
pyDump << ", True";
}
pyDump << ")";
SetErrorCode(OK);
return aPipeDS;
return aSeq;
}
@ -2106,19 +2175,20 @@ Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePipeWithShellSections(
* 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());
@ -2129,10 +2199,10 @@ Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePipeShellsWithoutPath(
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);
@ -2169,28 +2239,42 @@ Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePipeShellsWithoutPath(
}
if(!aSeqBases->Length())
return anObj;
return NULL;
aCI.SetBases(aSeqBases);
aCI.SetLocations(aSeqLocs);
aCI.SetGenerateGroups(IsGenerateGroups);
//Compute the Pipe value
try {
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;
}
// 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++) {
@ -2222,10 +2306,16 @@ Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePipeShellsWithoutPath(
}
}
pyDump<< "])";
pyDump<< "]";
if (IsGenerateGroups) {
pyDump << ", True";
}
pyDump << ")";
SetErrorCode(OK);
return aPipeDS;
return aSeq;
}
@ -2234,9 +2324,12 @@ Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePipeShellsWithoutPath(
* 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);
@ -2264,6 +2357,7 @@ Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePipeBiNormalAlongVector (Han
aCI.SetBase(aRefBase);
aCI.SetPath(aRefPath);
aCI.SetVector(aRefVec);
aCI.SetGenerateGroups(IsGenerateGroups);
//Compute the Pipe value
try {
@ -2279,12 +2373,32 @@ Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::MakePipeBiNormalAlongVector (Han
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;
}
//=============================================================================
@ -2546,3 +2660,122 @@ Handle(GEOM_Object) GEOMImpl_I3DPrimOperations::RestorePath
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]);
}
}
}

72
src/GEOMImpl/GEOMImpl_I3DPrimOperations.hxx
View File

@ -30,6 +30,11 @@
#include <TDocStd_Document.hxx>
#include <TColStd_HSequenceOfTransient.hxx>
class GEOMImpl_IGroupOperations;
class GEOMImpl_IPipe;
class TopTools_IndexedMapOfShape;
class GEOMImpl_I3DPrimOperations : public GEOM_IOperations {
public:
Standard_EXPORT GEOMImpl_I3DPrimOperations(GEOM_Engine* theEngine, int theDocID);
@ -98,8 +103,10 @@ class GEOMImpl_I3DPrimOperations : public GEOM_IOperations {
Standard_EXPORT Handle(GEOM_Object) MakeDraftPrism (Handle(GEOM_Object) theInitShape, Handle(GEOM_Object) theBase,
double theHeight, double theAngle, bool theFuse, bool theInvert = false );
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,
@ -121,28 +128,34 @@ class GEOMImpl_I3DPrimOperations : public GEOM_IOperations {
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(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(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(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(GEOM_Object) MakePipeShellsWithoutPath
(const Handle(TColStd_HSequenceOfTransient)& theBases,
const Handle(TColStd_HSequenceOfTransient)& theLocations);
Standard_EXPORT Handle(TColStd_HSequenceOfTransient) MakePipeShellsWithoutPath
(const Handle(TColStd_HSequenceOfTransient) &theBases,
const Handle(TColStd_HSequenceOfTransient) &theLocations,
const bool IsGenerateGroups);
Standard_EXPORT Handle(GEOM_Object) MakePipeBiNormalAlongVector (Handle(GEOM_Object) theBase,
Handle(GEOM_Object) thePath,
Handle(GEOM_Object) theVec);
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,
@ -158,6 +171,23 @@ class GEOMImpl_I3DPrimOperations : public GEOM_IOperations {
Standard_EXPORT Handle(GEOM_Object) RestorePath (Handle(GEOM_Object) theShape,
const Handle(TColStd_HSequenceOfTransient)& theBase1,
const Handle(TColStd_HSequenceOfTransient)& theBase2);
private:
Handle(GEOM_Object) createGroup
(const Handle(GEOM_Object) &theBaseObject,
const Handle(TColStd_HArray1OfInteger) &theGroupIDs,
const TCollection_AsciiString &theName,
const TopTools_IndexedMapOfShape &theIndices);
void createGroups(const Handle(GEOM_Object) &theBaseObject,
GEOMImpl_IPipe *thePipe,
Handle(TColStd_HSequenceOfTransient) &theSequence);
private:
GEOMImpl_IGroupOperations *myGroupOperations;
};
#endif

53
src/GEOMImpl/GEOMImpl_IPipe.hxx
View File

@ -27,20 +27,69 @@
#include "GEOM_Function.hxx"
#define PIPE_ARG_BASE 1
#define PIPE_ARG_PATH 2
#include <TColStd_HArray1OfInteger.hxx>
// ---- GEOMImpl_IPipe
#define PIPE_ARG_BASE 1
#define PIPE_ARG_PATH 2
// ---- GEOMImpl_IPipeBiNormal
#define PIPE_ARG_VEC 3
// ---- GEOMImpl_IPipeDiffSect
#define PIPEDS_LIST_BASES 1
//#define PIPEDS_ARG_PATH 2
#define PIPEDS_LIST_LOCATIONS 3
#define PIPEDS_ARG_WITHCONTACT 4
#define PIPEDS_ARG_WITHCORRECT 5
// ---- GEOMImpl_IPipeShellSect
#define PIPEDS_LIST_SUBBASES 6
// ---- Generate groups block (common)
#define PIPE_GENERATE_GROUPS 7
#define PIPE_GROUP_DOWN 8
#define PIPE_GROUP_UP 9
#define PIPE_GROUP_SIDE1 10
#define PIPE_GROUP_SIDE2 11
#define PIPE_GROUP_OTHER 12
class GEOMImpl_IPipe
{
public:
GEOMImpl_IPipe(Handle(GEOM_Function) theFunction): _func(theFunction) {}
virtual ~GEOMImpl_IPipe() {}
void SetBase (Handle(GEOM_Function) theBase) { _func->SetReference(PIPE_ARG_BASE, theBase); }
void SetPath (Handle(GEOM_Function) thePath) { _func->SetReference(PIPE_ARG_PATH, thePath); }
void SetGenerateGroups (int theGenerateGroups)
{ _func->SetInteger(PIPE_GENERATE_GROUPS, theGenerateGroups); }
void SetGroupDown (const Handle(TColStd_HArray1OfInteger) &theGroup)
{ _func->SetIntegerArray(PIPE_GROUP_DOWN, theGroup); }
void SetGroupUp (const Handle(TColStd_HArray1OfInteger) &theGroup)
{ _func->SetIntegerArray(PIPE_GROUP_UP, theGroup); }
void SetGroupSide1 (const Handle(TColStd_HArray1OfInteger) &theGroup)
{ _func->SetIntegerArray(PIPE_GROUP_SIDE1, theGroup); }
void SetGroupSide2 (const Handle(TColStd_HArray1OfInteger) &theGroup)
{ _func->SetIntegerArray(PIPE_GROUP_SIDE2, theGroup); }
void SetGroupOther (const Handle(TColStd_HArray1OfInteger) &theGroup)
{ _func->SetIntegerArray(PIPE_GROUP_OTHER, theGroup); }
Handle(GEOM_Function) GetBase() { return _func->GetReference(PIPE_ARG_BASE); }
Handle(GEOM_Function) GetPath() { return _func->GetReference(PIPE_ARG_PATH); }
int GetGenerateGroups () { return _func->GetInteger(PIPE_GENERATE_GROUPS); }
Handle(TColStd_HArray1OfInteger) GetGroupDown ()
{ return _func->GetIntegerArray(PIPE_GROUP_DOWN); }
Handle(TColStd_HArray1OfInteger) GetGroupUp ()
{ return _func->GetIntegerArray(PIPE_GROUP_UP); }
Handle(TColStd_HArray1OfInteger) GetGroupSide1 ()
{ return _func->GetIntegerArray(PIPE_GROUP_SIDE1); }
Handle(TColStd_HArray1OfInteger) GetGroupSide2 ()
{ return _func->GetIntegerArray(PIPE_GROUP_SIDE2); }
Handle(TColStd_HArray1OfInteger) GetGroupOther ()
{ return _func->GetIntegerArray(PIPE_GROUP_OTHER); }
protected:

7
src/GEOMImpl/GEOMImpl_IPipeBiNormal.hxx
View File

@ -22,15 +22,10 @@
#ifndef _GEOMImpl_IPIPEBINORMAL_HXX_
#define _GEOMImpl_IPIPEBINORMAL_HXX_
#include "GEOM_Function.hxx"
#ifndef _GEOMImpl_IPIPE_HXX_
#include "GEOMImpl_IPipe.hxx"
#endif
#define PIPE_ARG_BASE 1
#define PIPE_ARG_PATH 2
#define PIPE_ARG_VEC 3
// Position definitions are declared in the base class.
class GEOMImpl_IPipeBiNormal : public GEOMImpl_IPipe
{

13
src/GEOMImpl/GEOMImpl_IPipeDiffSect.hxx
View File

@ -25,20 +25,11 @@
#ifndef _GEOMImpl_IPIPEDIFFSECT_HXX_
#define _GEOMImpl_IPIPEDIFFSECT_HXX_
#include "GEOM_Function.hxx"
#include "GEOMImpl_IPipe.hxx"
#include <TColStd_HSequenceOfTransient.hxx>
#ifndef _GEOMImpl_IPIPE_HXX_
#include "GEOMImpl_IPipe.hxx"
#endif
#define PIPEDS_LIST_BASES 1
#define PIPEDS_LIST_LOCATIONS 3
//#define PIPEDS_ARG_PATH 2
#define PIPEDS_ARG_WITHCONTACT 4
#define PIPEDS_ARG_WITHCORRECT 5
// Position definitions are declared in the base class.
class GEOMImpl_IPipeDiffSect : public GEOMImpl_IPipe
{

8
src/GEOMImpl/GEOMImpl_IPipeShellSect.hxx
View File

@ -22,16 +22,12 @@
#ifndef _GEOMImpl_IPIPESHELLSECT_HXX_
#define _GEOMImpl_IPIPESHELLSECT_HXX_
#include "GEOM_Function.hxx"
#ifndef _GEOMImpl_IPIPEDIFFSECT_HXX_
#include "GEOMImpl_IPipeDiffSect.hxx"
#endif
#include "GEOM_Function.hxx"
#include <TColStd_HSequenceOfTransient.hxx>
#define PIPEDS_LIST_SUBBASES 6
// Position definitions are declared in the base class GEOMImpl_IPipe.
class GEOMImpl_IPipeShellSect : public GEOMImpl_IPipeDiffSect
{

1061
src/GEOMImpl/GEOMImpl_PipeDriver.cxx
View File

File diff suppressed because it is too large Load Diff

11
src/GEOMImpl/GEOMImpl_PipeDriver.hxx
View File

@ -83,11 +83,12 @@ public:
Standard_EXPORT ~GEOMImpl_PipeDriver() {};
Standard_EXPORT static TopoDS_Shape CreatePipeWithDifferentSections
(const TopoDS_Wire& theWirePath,
const Handle(TopTools_HSequenceOfShape) theBases,
const Handle(TopTools_HSequenceOfShape) theLocs,
const Standard_Boolean theWithContact,
const Standard_Boolean theWithCorrect);
(const TopoDS_Wire &theWirePath,
const Handle(TopTools_HSequenceOfShape) theBases,
const Handle(TopTools_HSequenceOfShape) theLocs,
const Standard_Boolean theWithContact,
const Standard_Boolean theWithCorrect,
Handle(TColStd_HArray1OfInteger) *theGroups = NULL);
Standard_EXPORT virtual
bool GetCreationInformation(std::string& theOperationName,

51
src/GEOMUtils/GEOMUtils.cxx
View File

@ -1236,3 +1236,54 @@ double GEOMUtils::DefaultDeflection()
{
return 0.001;
}
//=======================================================================
//function : IsOpenPath
//purpose :
//=======================================================================
bool GEOMUtils::IsOpenPath(const TopoDS_Shape &theShape)
{
bool isOpen = true;
if (theShape.IsNull() == Standard_False) {
if (theShape.Closed()) {
// The shape is closed
isOpen = false;
} else {
const TopAbs_ShapeEnum aType = theShape.ShapeType();
if (aType == TopAbs_EDGE || aType == TopAbs_WIRE) {
// Check if path ends are coinsident.
TopoDS_Vertex aV[2];
if (aType == TopAbs_EDGE) {
// Edge
TopExp::Vertices(TopoDS::Edge(theShape), aV[0], aV[1]);
} else {
// Wire
TopExp::Vertices(TopoDS::Wire(theShape), aV[0], aV[1]);
}
if (aV[0].IsNull() == Standard_False &&
aV[1].IsNull() == Standard_False) {
if (aV[0].IsSame(aV[1])) {
// The shape is closed
isOpen = false;
} else {
const Standard_Real aTol1 = BRep_Tool::Tolerance(aV[0]);
const Standard_Real aTol2 = BRep_Tool::Tolerance(aV[1]);
const gp_Pnt aPnt1 = BRep_Tool::Pnt(aV[0]);
const gp_Pnt aPnt2 = BRep_Tool::Pnt(aV[1]);
if (aPnt1.Distance(aPnt2) <= aTol1 + aTol2) {
// The shape is closed
isOpen = false;
}
}
}
}
}
}
return isOpen;
}

13
src/GEOMUtils/GEOMUtils.hxx
View File

@ -328,6 +328,19 @@ namespace GEOMUtils
* \return default deflection value
*/
Standard_EXPORT double DefaultDeflection();
/**
* \brief Check if the shape is not a closed wire or edge.
*
* This function is used for pipe creation algorithm to test if
* the pipe path is not closed. It returns false if theShape is a wire or
* an edge with coincident end vertices. Otherwise it returns true.
*
* \param theShape the shape to be tested.
* \return true if theShape is not a closed wire or edge.
*/
Standard_EXPORT bool IsOpenPath(const TopoDS_Shape &theShape);
};
#endif

166
src/GEOM_I/GEOM_I3DPrimOperations_i.cc
View File

@ -794,10 +794,12 @@ GEOM::GEOM_Object_ptr GEOM_I3DPrimOperations_i::MakeDraftPrism
* 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();
@ -806,15 +808,20 @@ GEOM::GEOM_Object_ptr GEOM_I3DPrimOperations_i::MakePipe
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();
}
//=============================================================================
@ -974,14 +981,15 @@ GEOM::GEOM_Object_ptr GEOM_I3DPrimOperations_i::MakeThruSections(const GEOM::Lis
* 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();
@ -994,11 +1002,11 @@ GEOM::GEOM_Object_ptr GEOM_I3DPrimOperations_i::MakePipeWithDifferentSections
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]);
@ -1014,16 +1022,23 @@ GEOM::GEOM_Object_ptr GEOM_I3DPrimOperations_i::MakePipeWithDifferentSections
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();
Handle(TColStd_HSequenceOfTransient) aHSeq =
GetOperations()->MakePipeWithDifferentSections
(aSeqBases, aSeqLocations,
aPath, theWithContact,
theWithCorrections, 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();
}
@ -1032,15 +1047,16 @@ GEOM::GEOM_Object_ptr GEOM_I3DPrimOperations_i::MakePipeWithDifferentSections
* 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();
@ -1055,11 +1071,11 @@ GEOM::GEOM_Object_ptr GEOM_I3DPrimOperations_i::MakePipeWithShellSections
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]);
@ -1084,17 +1100,23 @@ GEOM::GEOM_Object_ptr GEOM_I3DPrimOperations_i::MakePipeWithShellSections
}
}
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();
Handle(TColStd_HSequenceOfTransient) aHSeq =
GetOperations()->MakePipeWithShellSections
(aSeqBases, aSeqSubBases,
aSeqLocations, aPath,
theWithContact, theWithCorrections, 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();
}
@ -1103,11 +1125,12 @@ GEOM::GEOM_Object_ptr GEOM_I3DPrimOperations_i::MakePipeWithShellSections
* 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();
@ -1120,7 +1143,7 @@ GEOM::GEOM_Object_ptr GEOM_I3DPrimOperations_i::MakePipeShellsWithoutPath
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]);
@ -1136,16 +1159,22 @@ GEOM::GEOM_Object_ptr GEOM_I3DPrimOperations_i::MakePipeShellsWithoutPath
}
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();
}
//=============================================================================
@ -1153,12 +1182,13 @@ GEOM::GEOM_Object_ptr GEOM_I3DPrimOperations_i::MakePipeShellsWithoutPath
* 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();
@ -1168,15 +1198,21 @@ GEOM::GEOM_Object_ptr GEOM_I3DPrimOperations_i::MakePipeBiNormalAlongVector
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();
Handle(TColStd_HSequenceOfTransient) aHSeq =
GetOperations()->MakePipeBiNormalAlongVector
(aBase, aPath, aVec, 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();
}
//=============================================================================

51
src/GEOM_I/GEOM_I3DPrimOperations_i.hh
View File

@ -155,9 +155,10 @@ class GEOM_I_EXPORT GEOM_I3DPrimOperations_i :
CORBA::Double theAngle,
CORBA::Boolean theFuse,
CORBA::Boolean theInvert);
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,
@ -178,27 +179,35 @@ class GEOM_I_EXPORT GEOM_I3DPrimOperations_i :
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::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::GEOM_Object_ptr MakePipeShellsWithoutPath(const GEOM::ListOfGO& theBases,
const GEOM::ListOfGO& theLocations);
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 MakePipeBiNormalAlongVector (GEOM::GEOM_Object_ptr theBase,
GEOM::GEOM_Object_ptr thePath,
GEOM::GEOM_Object_ptr theVec);
GEOM::GEOM_Object_ptr MakeThickening (GEOM::GEOM_Object_ptr theObject,
const GEOM::ListOfLong &theFacesIDs,
CORBA::Double theOffset,

27
src/GEOM_I_Superv/GEOM_Superv_i.cc
View File

@ -1403,9 +1403,9 @@ GEOM::GEOM_Object_ptr GEOM_Superv_i::MakePipe (GEOM::GEOM_Object_ptr theBase,
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];
}
//=============================================================================
@ -1512,9 +1512,9 @@ GEOM::GEOM_Object_ptr GEOM_Superv_i::MakePipeWithDifferentSections
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];
}
@ -1532,12 +1532,13 @@ GEOM::GEOM_Object_ptr GEOM_Superv_i::MakePipeWithShellSections
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];
}
@ -1551,10 +1552,10 @@ GEOM::GEOM_Object_ptr GEOM_Superv_i::MakePipeShellsWithoutPath
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];
}
@ -1569,10 +1570,10 @@ GEOM::GEOM_Object_ptr GEOM_Superv_i::MakePipeBiNormalAlongVector
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];
}

231
src/GEOM_SWIG/geomBuilder.py
View File

@ -3869,41 +3869,97 @@ class geomBuilder(object, GEOM._objref_GEOM_Gen):
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
@ -3913,21 +3969,30 @@ class geomBuilder(object, GEOM._objref_GEOM_Gen):
# 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.
@ -3939,23 +4004,37 @@ class geomBuilder(object, GEOM._objref_GEOM_Gen):
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
@ -3974,21 +4053,30 @@ class geomBuilder(object, GEOM._objref_GEOM_Gen):
# 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
@ -4009,19 +4097,30 @@ class geomBuilder(object, GEOM._objref_GEOM_Gen):
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
@ -4031,7 +4130,8 @@ class geomBuilder(object, GEOM._objref_GEOM_Gen):
@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
@ -4050,16 +4150,17 @@ class geomBuilder(object, GEOM._objref_GEOM_Gen):
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
@ -4069,57 +4170,92 @@ class geomBuilder(object, GEOM._objref_GEOM_Gen):
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.
@ -4127,18 +4263,29 @@ class geomBuilder(object, GEOM._objref_GEOM_Gen):
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

2
src/GenerationGUI/CMakeLists.txt
View File

@ -37,6 +37,7 @@ INCLUDE_DIRECTORIES(
${PROJECT_SOURCE_DIR}/src/GEOMImpl
${PROJECT_SOURCE_DIR}/src/GEOMGUI
${PROJECT_SOURCE_DIR}/src/GEOMBase
${PROJECT_SOURCE_DIR}/src/GEOMUtils
${PROJECT_SOURCE_DIR}/src/DlgRef
${PROJECT_BINARY_DIR}/src/DlgRef
${CMAKE_CURRENT_SOURCE_DIR}
@ -55,6 +56,7 @@ SET(_link_LIBRARIES
GEOMClient
GEOMImpl
GEOMBase
GEOMUtils
GEOM
DlgRef
)

280
src/GenerationGUI/GenerationGUI_PipeDlg.cxx
View File

@ -29,6 +29,7 @@
#include <DlgRef.h>
#include <GeometryGUI.h>
#include <GEOMBase.h>
#include <GEOMUtils.hxx>
#include <SUIT_Session.h>
#include <SUIT_ResourceMgr.h>
@ -36,10 +37,6 @@
#include <LightApp_SelectionMgr.h>
#include <TopoDS_Shape.hxx>
#include <TopoDS.hxx>
#include <TopExp.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TColStd_IndexedMapOfInteger.hxx>
#include <TColStd_MapOfInteger.hxx>
#include <GEOMImpl_Types.hxx>
@ -53,7 +50,13 @@
//=================================================================================
GenerationGUI_PipeDlg::GenerationGUI_PipeDlg (GeometryGUI* theGeometryGUI, QWidget* parent,
bool modal, Qt::WindowFlags fl)
: GEOMBase_Skeleton(theGeometryGUI, parent, modal, fl)
: GEOMBase_Skeleton (theGeometryGUI, parent, modal, fl),
myGenGroupCheckGP (0),
myPrefixLblGP (0),
myPrefixEditGP (0),
myGenGroupCheckGMP (0),
myPrefixLblGMP (0),
myPrefixEditGMP (0)
{
QPixmap image0 (SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_DLG_PIPE")));
QPixmap image1 (SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_SELECT")));
@ -81,6 +84,19 @@ GenerationGUI_PipeDlg::GenerationGUI_PipeDlg (GeometryGUI* theGeometryGUI, QWidg
GroupPoints->PushButton3->setIcon(image1);
GroupPoints->CheckButton1->setText(tr("GEOM_SELECT_UNPUBLISHED_EDGES"));
// Add widgets for group generation
QGridLayout *aLayoutGP = (QGridLayout *)GroupPoints->GroupBox1->layout();
myGenGroupCheckGP =
new QCheckBox(tr("GEOM_GENERATE_GROUPS"), GroupPoints->GroupBox1);
myPrefixLblGP =
new QLabel (tr("GEOM_GROUP_NAME_PREFIX"), GroupPoints->GroupBox1);
myPrefixEditGP = new QLineEdit(GroupPoints->GroupBox1);
aLayoutGP->addWidget(myGenGroupCheckGP, 4, 0, 1, 3);
aLayoutGP->addWidget(myPrefixLblGP, 5, 0, 1, 2);
aLayoutGP->addWidget(myPrefixEditGP, 5, 2);
GroupMakePoints = new DlgRef_3Sel2Check3Spin(centralWidget());
GroupMakePoints->GroupBox1->setTitle(tr("GEOM_ARGUMENTS"));
@ -92,6 +108,12 @@ GenerationGUI_PipeDlg::GenerationGUI_PipeDlg (GeometryGUI* theGeometryGUI, QWidg
GroupMakePoints->PushButton3->setIcon(image1);
GroupMakePoints->CheckBox1->setText(tr("GEOM_WITH_CONTACT"));
GroupMakePoints->CheckBox2->setText(tr("GEOM_WITH_CORRECTION"));
GroupMakePoints->SpinBox1->setAttribute(Qt::WA_DeleteOnClose);
GroupMakePoints->SpinBox2->setAttribute(Qt::WA_DeleteOnClose);
GroupMakePoints->SpinBox3->setAttribute(Qt::WA_DeleteOnClose);
GroupMakePoints->TextLabel4->setAttribute(Qt::WA_DeleteOnClose);
GroupMakePoints->TextLabel5->setAttribute(Qt::WA_DeleteOnClose);
GroupMakePoints->TextLabel6->setAttribute(Qt::WA_DeleteOnClose);
GroupMakePoints->SpinBox1->close();
GroupMakePoints->SpinBox2->close();
GroupMakePoints->SpinBox3->close();
@ -99,6 +121,19 @@ GenerationGUI_PipeDlg::GenerationGUI_PipeDlg (GeometryGUI* theGeometryGUI, QWidg
GroupMakePoints->TextLabel5->close();
GroupMakePoints->TextLabel6->close();
// Add widgets for group generation
QGridLayout *aLayoutGMP = (QGridLayout *)GroupMakePoints->GroupBox1->layout();
myGenGroupCheckGMP =
new QCheckBox(tr("GEOM_GENERATE_GROUPS"), GroupMakePoints->GroupBox1);
myPrefixLblGMP =
new QLabel (tr("GEOM_GROUP_NAME_PREFIX"), GroupMakePoints->GroupBox1);
myPrefixEditGMP = new QLineEdit(GroupMakePoints->GroupBox1);
aLayoutGMP->addWidget(myGenGroupCheckGMP, 8, 0, 1, 3);
aLayoutGMP->addWidget(myPrefixLblGMP, 9, 0, 1, 2);
aLayoutGMP->addWidget(myPrefixEditGMP, 9, 2);
QVBoxLayout* layout = new QVBoxLayout(centralWidget());
layout->setMargin(0); layout->setSpacing(6);
layout->addWidget(GroupPoints);
@ -166,6 +201,8 @@ void GenerationGUI_PipeDlg::Init()
connect(GroupMakePoints->PushButton3, SIGNAL(clicked()), this, SLOT(SetEditCurrentArgument()));
connect(GroupMakePoints->CheckBox1, SIGNAL(clicked()), this, SLOT(processPreview()));
connect(GroupMakePoints->CheckBox2, SIGNAL(clicked()), this, SLOT(processPreview()));
connect(myGenGroupCheckGP, SIGNAL(toggled(bool)), this, SLOT(GenGroupClicked(bool)));
connect(myGenGroupCheckGMP, SIGNAL(toggled(bool)), this, SLOT(GenGroupClicked(bool)));
initName(tr("GEOM_PIPE"));
resize(100,100);
@ -177,6 +214,7 @@ void GenerationGUI_PipeDlg::Init()
GroupPoints->PushButton1->click();
SelectionIntoArgument();
updateGenGroup();
}
//=================================================================================
@ -195,6 +233,8 @@ void GenerationGUI_PipeDlg::ConstructorsClicked( int constructorId )
GroupPoints->PushButton3->hide();
GroupPoints->LineEdit3->hide();
GroupPoints->PushButton1->click();
myGenGroupCheckGP->setChecked(false);
resetGenGroup(myGenGroupCheckGP, false, true);
break;
case 1:
GroupMakePoints->hide();
@ -203,11 +243,15 @@ void GenerationGUI_PipeDlg::ConstructorsClicked( int constructorId )
GroupPoints->PushButton3->show();
GroupPoints->LineEdit3->show();
GroupPoints->PushButton1->click();
myGenGroupCheckGP->setChecked(false);
resetGenGroup(myGenGroupCheckGP, false, true);
break;
case 2:
GroupPoints->hide();
GroupMakePoints->show();
GroupMakePoints->PushButton1->click();
myGenGroupCheckGMP->setChecked(false);
resetGenGroup(myGenGroupCheckGMP, false, true);
break;
default:
break;
@ -240,6 +284,7 @@ void GenerationGUI_PipeDlg::SelectionTypeButtonClicked()
if ( myEditCurrentArgument == GroupPoints->LineEdit2 ) {
myEditCurrentArgument->setText("");
myPath.nullify();
updateGenGroup();
}
processPreview();
}
@ -306,6 +351,7 @@ void GenerationGUI_PipeDlg::SelectionIntoArgument()
else if ( myBaseObjects.isEmpty() )
GroupPoints->PushButton1->click();
}
updateGenGroup();
}
else if (myEditCurrentArgument == GroupPoints->LineEdit3) {
myVec = getSelected( TopAbs_EDGE );
@ -345,6 +391,7 @@ void GenerationGUI_PipeDlg::SelectionIntoArgument()
QString aName = GEOMBase::GetName( myPath.get() );
myEditCurrentArgument->setText( aName );
}
updateGenGroup();
}
processPreview();
@ -480,24 +527,42 @@ bool GenerationGUI_PipeDlg::isValid (QString&)
//=================================================================================
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());
bool doGroups = !IsPreview();
myGroupObjectsMap.clear();
switch( getConstructorId() ) {
case 0:
case 1:
if (doGroups) {
doGroups = myGenGroupCheckGP->isEnabled() &&
myGenGroupCheckGP->isChecked();
}
for (int i = 0; i < myBaseObjects.count(); i++) {
switch ( getConstructorId() ) {
case 0 :
anObj = anOper->MakePipe(myBaseObjects[i].get(), myPath.get());
break;
aList = anOper->MakePipe(myBaseObjects[i].get(),
myPath.get(), doGroups);
break;
case 1 :
anObj = anOper->MakePipeBiNormalAlongVector(myBaseObjects[i].get(), myPath.get(), myVec.get());
break;
aList = anOper->MakePipeBiNormalAlongVector
(myBaseObjects[i].get(), myPath.get(), myVec.get(), doGroups);
break;
}
if (aList->length() > 0) {
if (doGroups) {
addGroups(aList);
}
if (!aList[0]->_is_nil()) {
objects.push_back(aList[0]._retn());
}
}
if (!anObj->_is_nil())
objects.push_back(anObj._retn());
}
break;
case 2:
@ -507,17 +572,31 @@ bool GenerationGUI_PipeDlg::execute (ObjectList& objects)
myBaseGO->length( myBaseObjects.count() );
myLocationsGO->length( myLocations.count() );
for (int i = 0; i < myBaseObjects.count(); i++) {
myBaseGO[i] = myBaseObjects[i].copy();
myBaseGO[i] = myBaseObjects[i].copy();
}
for (int i = 0; i < myLocations.count(); i++) {
myLocationsGO[i] = myLocations[i].copy();
myLocationsGO[i] = myLocations[i].copy();
}
if (doGroups) {
doGroups = myGenGroupCheckGMP->isEnabled() &&
myGenGroupCheckGMP->isChecked();
}
aList = anOper->MakePipeWithDifferentSections
(myBaseGO.in(), myLocationsGO.in(), myPath.get(),
GroupMakePoints->CheckBox1->isChecked(),
GroupMakePoints->CheckBox2->isChecked(), doGroups);
if (aList->length() > 0) {
if (doGroups) {
addGroups(aList);
}
if (!aList[0]->_is_nil()) {
objects.push_back(aList[0]._retn());
}
}
anObj = anOper->MakePipeWithDifferentSections(myBaseGO.in(), myLocationsGO.in(), myPath.get(),
GroupMakePoints->CheckBox1->isChecked(),
GroupMakePoints->CheckBox2->isChecked());
if (!anObj->_is_nil())
objects.push_back(anObj._retn());
}
break;
default:
@ -545,6 +624,66 @@ bool GenerationGUI_PipeDlg::extractPrefix() const
return myBaseObjects.count() > 1;
}
//=================================================================================
// function : restoreSubShapes
// purpose : virtual method to restore tree of argument's sub-shapes under
// the resulting shape. Redefined from GEOMBase_Helper class.
//=================================================================================
void GenerationGUI_PipeDlg::restoreSubShapes
(SALOMEDS::Study_ptr theStudy, SALOMEDS::SObject_ptr theSObject)
{
QCheckBox *aGenGroupCheck = NULL;
QLineEdit *aPrefixEdit = NULL;
switch (getConstructorId()) {
case 0 :
case 1 :
aGenGroupCheck = myGenGroupCheckGP;
aPrefixEdit = myPrefixEditGP;
break;
case 2 :
aGenGroupCheck = myGenGroupCheckGMP;
aPrefixEdit = myPrefixEditGMP;
break;
default:
break;
}
if (aGenGroupCheck == NULL || !aGenGroupCheck->isChecked()) {
return;
}
// get Object from SObject
GEOM::GEOM_Object_var aFather = GEOM::GEOM_Object::_narrow
(theSObject->GetObject());
if (CORBA::is_nil(aFather)) {
return;
}
ObjectMap::const_iterator anIter =
myGroupObjectsMap.find(aFather->GetEntry());
QString aPrefix = aPrefixEdit->text();
bool hasPrefix = !aPrefix.isEmpty();
if (anIter != myGroupObjectsMap.end()) {
QList<GEOM::GeomObjPtr>::const_iterator it = anIter->second.begin();
for (; it != anIter->second.end(); it++) {
// Compose the name
QString aName;
if (hasPrefix) {
aName = aPrefix + "_";
}
aName += tr((*it)->GetName());
getGeomEngine()->AddInStudy(theStudy, (*it).get(),
aName.toStdString().c_str(), aFather);
}
}
}
//=================================================================================
// function : getSourceObjects
// purpose : virtual method to get source objects
@ -557,3 +696,102 @@ QList<GEOM::GeomObjPtr> GenerationGUI_PipeDlg::getSourceObjects()
res << myLocations[i];
return res;
}
//=================================================================================
// function : GenGroupClicked
// purpose : Slot to treat checking "Generate groups" check box.
//=================================================================================
void GenerationGUI_PipeDlg::GenGroupClicked(bool isChecked)
{
resetGenGroup((QCheckBox *)sender(), isChecked, false);
}
//=================================================================================
// function : updateGenGroup
// purpose : Update "Generate groups" widgets depending on the path.
//=================================================================================
void GenerationGUI_PipeDlg::updateGenGroup()
{
bool isEnable = true;
if (myPath) {
// Check if the path is closed.
TopoDS_Shape aShapePath;
if (GEOMBase::GetShape(myPath.get(), aShapePath)) {
isEnable = GEOMUtils::IsOpenPath(aShapePath);
}
}
QCheckBox *aGenGroupCheck = NULL;
switch (getConstructorId()) {
case 0 :
case 1 :
aGenGroupCheck = myGenGroupCheckGP;
break;
case 2 :
aGenGroupCheck = myGenGroupCheckGMP;
break;
default:
break;
}
if (aGenGroupCheck != NULL) {
const bool isChecked = aGenGroupCheck->isChecked();
aGenGroupCheck->setEnabled(isEnable);
resetGenGroup(aGenGroupCheck, isEnable && isChecked, false);
}
}
//=================================================================================
// function : resetGenGroup
// purpose : Resets data of "Generate groups" widgets.
//=================================================================================
void GenerationGUI_PipeDlg::resetGenGroup(QCheckBox *theGenGroup,
const bool isChecked,
const bool isClearPrefix)
{
QLabel *aPrefixLbl = NULL;
QLineEdit *aPrefixEdit = NULL;
if (theGenGroup == myGenGroupCheckGP) {
aPrefixLbl = myPrefixLblGP;
aPrefixEdit = myPrefixEditGP;
} else if (theGenGroup == myGenGroupCheckGMP) {
aPrefixLbl = myPrefixLblGMP;
aPrefixEdit = myPrefixEditGMP;
}
if (aPrefixLbl != NULL) {
aPrefixLbl->setEnabled(isChecked);
aPrefixEdit->setEnabled(isChecked);
if (isClearPrefix) {
aPrefixEdit->setText("");
}
}
}
//=================================================================================
// function : addGroups
// purpose : Add result groups to the list of groups.
//=================================================================================
void GenerationGUI_PipeDlg::addGroups(GEOM::ListOfGO_var &theResult)
{
const int aNbObj = theResult->length();
if (aNbObj > 0) {
if (!theResult[0]->_is_nil()) {
QString anEntry = theResult[0]->GetEntry();
int i;
for (i = 1; i < aNbObj; ++i) {
if (!theResult[i]->_is_nil()) {
myGroupObjectsMap[anEntry].append(GEOM::GeomObjPtr(theResult[i]));
}
}
}
}
}

20
src/GenerationGUI/GenerationGUI_PipeDlg.h
View File

@ -30,6 +30,9 @@
#include "GEOMBase_Skeleton.h"
#include "GEOM_GenericObjPtr.h"
typedef std::map<QString, QList<GEOM::GeomObjPtr> > ObjectMap;
class DlgRef_3Sel1Check;
class DlgRef_3Sel2Check3Spin;
@ -52,11 +55,20 @@ protected:
virtual bool execute( ObjectList& );
virtual void addSubshapesToStudy();
virtual bool extractPrefix() const;
virtual void restoreSubShapes
(SALOMEDS::Study_ptr, SALOMEDS::SObject_ptr);
virtual QList<GEOM::GeomObjPtr> getSourceObjects();
private:
void Init();
void enterEvent( QEvent* );
void updateGenGroup();
void resetGenGroup
(QCheckBox *theGenGroup,
const bool isChecked,
const bool isClearPrefix);
void addGroups
(GEOM::ListOfGO_var &theResult);
private:
QList<GEOM::GeomObjPtr> myBaseObjects; /* Base shapes */
@ -66,6 +78,13 @@ private:
DlgRef_3Sel1Check* GroupPoints;
DlgRef_3Sel2Check3Spin* GroupMakePoints;
QCheckBox *myGenGroupCheckGP;
QLabel *myPrefixLblGP;
QLineEdit *myPrefixEditGP;
QCheckBox *myGenGroupCheckGMP;
QLabel *myPrefixLblGMP;
QLineEdit *myPrefixEditGMP;
ObjectMap myGroupObjectsMap;
private slots:
void ClickOnOk();
@ -75,6 +94,7 @@ private slots:
void SetEditCurrentArgument();
void ConstructorsClicked( int );
void SelectionTypeButtonClicked();
void GenGroupClicked(bool);
};
#endif // GENERATIONGUI_PIPEDLG_H