ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-11-11 16:19:16 +05:00
Code Issues Packages Projects Releases Wiki Activity

23586: [EDF] HYDRO: Copy mesh to new geometry

Browse Source
This commit is contained in:
eap 2018-09-17 22:24:36 +03:00
parent 37d2abfafb
commit 6df8817c1a
90 changed files with 2473 additions and 725 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
doc/salome/gui/SMESH/images/copy_mesh_dlg.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 23 KiB

After

Width:  |  Height:  |  Size: 26 KiB

12
doc/salome/gui/SMESH/input/copy_mesh.rst
View File

@ -4,7 +4,10 @@
Copy Mesh
*********
A mesh can be created by copying a part of or the whole other mesh.
A mesh can be created by copying a part of or the whole other mesh. There are two modes of the operation:
* copy mesh elements only;
* copy mesh definition to another geometry. This mode can be used only if the source mesh is based on geometry. It is supposed that the new geometry is a modified geometry of the source mesh.
*To make a copy of a mesh:*
@ -20,6 +23,7 @@ The following dialog box will appear:
In the dialog:
* select the mode of the operation.
* specify the part of mesh to copy:
* **Select whole mesh, sub-mesh or group** by mouse activating this checkbox; or
@ -28,12 +32,16 @@ In the dialog:
* apply Filters. **Set filter** button allows to apply a filter to the selection of elements. See more about filters in the :ref:`selection_filter_library_page` page.
* specify the **New Mesh Name**;
* select the **New Geometry**;
* specify the conditions of copying:
* activate **Generate groups** checkbox to copy the groups of the source mesh to the newly created mesh.
* activate **Generate groups** check-box to copy the groups of the source mesh to the newly created mesh. In the mode of copying to new geometry, standalone groups are copied only if **Copy Mesh Elements** is activated.
* activate **Reuse hypotheses** check-box to use hypotheses applied to the source mesh in the new mesh. Hypotheses having parameters defined as sub-shapes will be copied independently of this check-box state.
* activate **Copy Mesh Element** to copy mesh elements of sub-shapes that are not modified.
* Click **Apply** or **Apply and Close** button to confirm the operation.
When copying the mesh to the new geometry, it can happen that a sub-shape used to define a sub-mesh, group or hypotheses is not found in the new geometry. In this case a new object depending on the not found sub-shape is marked with red color in the Object Browser in order to allow identifying such objects and to fix them, either by modifying their definition or by removing. If a depending object is a group on geometry, a standalone group is created instead. You can't transform it to a group on geometry, it can only be removed and re-created anew.
**See Also** a sample script of :ref:`tui_copy_mesh`.

31
idl/SMESH_Gen.idl
View File

@ -280,6 +280,37 @@ module SMESH
in boolean toKeepIDs)
raises ( SALOME::SALOME_Exception );
/*!
* Create a mesh by copying definitions of another mesh to a given geometry
* \param sourceMesh - a mesh to copy
* \param newGeometry - a new geometry
* \param meshName - a name of the new mesh
* \param toCopyGroups - to create groups in the new mesh
* \param toReuseHypotheses - if True, existing hypothesis will be used by the new mesh,
* otherwise new hypotheses with the same parameters will be created for the new mesh.
* \param toCopyElements - to copy mesh elements of same sub-shapes of the two geometries
* \param newMesh - return a new mesh
* \param newGroups - return new groups
* \param newSubmeshes - return new sub-meshes
* \param newHypotheses - return new algorithms and hypotheses
* \param invalidEntries - return study entries of objects whose
* counterparts are not found in the newGeometry, followed by entries
* of mesh sub-objects that are invalid because they depend on a not found
* preceeding sub-shape
*/
boolean CopyMeshWithGeom( in SMESH_Mesh sourceMesh,
in GEOM::GEOM_Object newGeometry,
in string meshName,
in boolean toCopyGroups,
in boolean toReuseHypotheses,
in boolean toCopyElements,
out SMESH_Mesh newMesh,
out ListOfGroups newGroups,
out submesh_array newSubmeshes,
out ListOfHypothesis newHypotheses,
out string_array invalidEntries)
raises ( SALOME::SALOME_Exception );
/*!
* Concatenate the given meshes or groups into one mesh.
* Union groups with the same name and type if

1
resources/CMakeLists.txt
View File

@ -196,6 +196,7 @@ SET(SMESH_RESOURCES_FILES
mesh_tree_hypo_quadratic.png
mesh_build_compound.png
copy_mesh.png
copy_mesh_with_geom.png
mesh_node_to_point.png
mesh_tree_mesh_partial.png
mesh_extractGroup.png

BIN
resources/copy_mesh_with_geom.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 636 B

4
src/SMESH/SMESH_Mesh.cxx
View File

@ -1193,8 +1193,8 @@ void SMESH_Mesh::NotifySubMeshesHypothesisModification(const SMESH_Hypothesis* h
if ( !GetMeshDS()->IsUsedHypothesis( hyp ))
return;
if (_callUp)
_callUp->HypothesisModified();
if (_callUp && hyp)
_callUp->HypothesisModified( hyp->GetID() );
SMESH_Algo *algo;
const SMESH_HypoFilter* compatibleHypoKind;

2
src/SMESH/SMESH_Mesh.hxx
View File

@ -334,7 +334,7 @@ class SMESH_EXPORT SMESH_Mesh
struct TCallUp // callback from SMESH to SMESH_I level
{
virtual void RemoveGroup (const int theGroupID)=0;
virtual void HypothesisModified ()=0;
virtual void HypothesisModified (int theHypID)=0;
virtual void Load ()=0;
virtual ~TCallUp() {}
};

2
src/SMESH/SMESH_subMesh.cxx
View File

@ -365,7 +365,7 @@ int SMESH_subMesh::computeCost() const
*/
//=============================================================================
const map < int, SMESH_subMesh * >& SMESH_subMesh::DependsOn()
const std::map < int, SMESH_subMesh * >& SMESH_subMesh::DependsOn()
{
if ( _dependenceAnalysed || !_father->HasShapeToMesh() )
return _mapDepend;

289
src/SMESHGUI/SMESHGUI_CopyMeshDlg.cxx
View File

@ -24,32 +24,34 @@
#include "SMESHGUI_CopyMeshDlg.h"
#include "SMESHGUI.h"
#include "SMESHGUI_FilterDlg.h"
#include "SMESHGUI_GEOMGenUtils.h"
#include "SMESHGUI_IdValidator.h"
#include "SMESHGUI_MeshUtils.h"
#include "SMESHGUI_Selection.h"
#include "SMESHGUI_SpinBox.h"
#include "SMESHGUI_Utils.h"
#include "SMESHGUI_VTKUtils.h"
#include "SMESHGUI_MeshUtils.h"
#include "SMESHGUI_IdValidator.h"
#include "SMESHGUI_FilterDlg.h"
#include <SMESH_Actor.h>
#include <SMESH_TypeFilter.hxx>
#include <SMDS_Mesh.hxx>
// SALOME GUI includes
#include <SUIT_Desktop.h>
#include <SUIT_ResourceMgr.h>
#include <SUIT_Session.h>
#include <SUIT_MessageBox.h>
#include <SUIT_OverrideCursor.h>
#include <LightApp_Application.h>
#include <LightApp_SelectionMgr.h>
#include <SALOME_ListIO.hxx>
#include <SUIT_Desktop.h>
#include <SUIT_MessageBox.h>
#include <SUIT_OverrideCursor.h>
#include <SUIT_ResourceMgr.h>
#include <SUIT_Session.h>
#include <SVTK_ViewModel.h>
#include <SVTK_ViewWindow.h>
#include <SALOME_ListIO.hxx>
#include <SalomeApp_Tools.h>
// SALOME KERNEL includes
#include <SALOMEDSClient_Study.hxx>
#include <SALOMEDSClient_SObject.hxx>
// OCCT includes
@ -113,7 +115,8 @@ SMESHGUI_CopyMeshDlg::SMESHGUI_CopyMeshDlg( SMESHGUI* theModule )
myFilterDlg(0),
myIsApplyAndClose( false )
{
QPixmap image (SMESH::GetResourceMgr( mySMESHGUI )->loadPixmap("SMESH", tr("ICON_COPY_MESH")));
QPixmap image1 (SMESH::GetResourceMgr( mySMESHGUI )->loadPixmap("SMESH", tr("ICON_COPY_MESH")));
QPixmap image2 (SMESH::GetResourceMgr( mySMESHGUI )->loadPixmap("SMESH", tr("ICON_COPY_MESH_WG")));
setModal(false);
setAttribute(Qt::WA_DeleteOnClose, true);
@ -126,18 +129,21 @@ SMESHGUI_CopyMeshDlg::SMESHGUI_CopyMeshDlg( SMESHGUI* theModule )
/***************************************************************/
ConstructorsBox = new QGroupBox(tr("SMESH_COPY_MESH_TITLE"), this);
QButtonGroup* GroupConstructors = new QButtonGroup(this);
GroupConstructors = new QButtonGroup(this);
QHBoxLayout* ConstructorsBoxLayout = new QHBoxLayout(ConstructorsBox);
ConstructorsBoxLayout->setSpacing(SPACING);
ConstructorsBoxLayout->setMargin(MARGIN);
QRadioButton* RadioButton1= new QRadioButton(ConstructorsBox);
RadioButton1->setIcon(image);
RadioButton1->setIcon(image1);
GroupConstructors->addButton(RadioButton1, 0);
QRadioButton* RadioButton2= new QRadioButton(ConstructorsBox);
RadioButton2->setIcon(image2);
GroupConstructors->addButton(RadioButton2, 1);
ConstructorsBoxLayout->addWidget(RadioButton1);
ConstructorsBoxLayout->addWidget(RadioButton2);
RadioButton1->setChecked(true);
GroupConstructors->addButton(RadioButton1, 0);
/***************************************************************/
GroupArguments = new QGroupBox(tr("SMESH_ARGUMENTS"), this);
@ -164,13 +170,26 @@ SMESHGUI_CopyMeshDlg::SMESHGUI_CopyMeshDlg( SMESHGUI* theModule )
// CheckBox for copying groups
myCopyGroupsCheck = new QCheckBox(tr("SMESH_MAKE_GROUPS"), GroupArguments);
myCopyGroupsCheck->setChecked(false);
myCopyGroupsCheck->setChecked(true);
// CheckBox for keeping ids ( OBSOLETE )
myKeepIdsCheck = new QCheckBox(tr("SMESH_KEEP_IDS"), GroupArguments);
myKeepIdsCheck->setChecked(true);
myKeepIdsCheck->hide();
// New geometry
myGeomLabel = new QLabel( tr("NEW_GEOM"), GroupArguments );
myGeomNameEdit = new QLineEdit( GroupArguments );
myGeomNameEdit->setReadOnly(true);
// CheckBox to reuse hypotheses
myReuseHypCheck = new QCheckBox(tr("REUSE_HYPOTHESES"), GroupArguments);
myReuseHypCheck->setChecked(true);
// CheckBox to copy mesh elements
myCopyElementsCheck = new QCheckBox(tr("COPY_ELEMENTS"), GroupArguments);
myCopyElementsCheck->setChecked(true);
// layout
GroupArgumentsLayout->addWidget(myTextLabelElements, 0, 0);
GroupArgumentsLayout->addWidget(myLineEditElements, 0, 1, 1, 5);
@ -178,8 +197,13 @@ SMESHGUI_CopyMeshDlg::SMESHGUI_CopyMeshDlg( SMESHGUI* theModule )
GroupArgumentsLayout->addWidget(myIdSourceCheck, 1, 0, 1, 6);
GroupArgumentsLayout->addWidget(meshNameLabel, 2, 0);
GroupArgumentsLayout->addWidget(myMeshNameEdit, 2, 1, 1, 5);
GroupArgumentsLayout->addWidget(myCopyGroupsCheck, 3, 0, 1, 6);
// GroupArgumentsLayout->addWidget(myKeepIdsCheck, 4, 0, 1, 6);
GroupArgumentsLayout->addWidget(myGeomLabel, 3, 0);
GroupArgumentsLayout->addWidget(myGeomNameEdit, 3, 1, 1, 5);
GroupArgumentsLayout->addWidget(myCopyGroupsCheck, 4, 0, 1, 6);
GroupArgumentsLayout->addWidget(myReuseHypCheck, 5, 0, 1, 6);
GroupArgumentsLayout->addWidget(myCopyElementsCheck, 6, 0, 1, 6);
// GroupArgumentsLayout->addWidget(myKeepIdsCheck, 7, 0, 1, 6);
GroupArgumentsLayout->setRowStretch( 6, 1 );
/***************************************************************/
GroupButtons = new QGroupBox(this);
@ -243,6 +267,9 @@ SMESHGUI_CopyMeshDlg::SMESHGUI_CopyMeshDlg( SMESHGUI* theModule )
this, SLOT (onTextChange(const QString&)));
connect(myIdSourceCheck, SIGNAL(toggled(bool)),
this, SLOT (onSelectIdSource(bool)));
connect(GroupConstructors, SIGNAL(buttonClicked(int)),
this, SLOT (onConstructor(int)));
SelectionIntoArgument();
}
@ -275,11 +302,12 @@ void SMESHGUI_CopyMeshDlg::Init (bool ResetControls)
{
myBusy = false;
if ( !isWithGeomMode() )
myMeshNameEdit->setText( SMESH::UniqueMeshName("Mesh"));
if ( ResetControls )
{
myLineEditElements->clear();
//myElementsId = "";
myNbOkElements = 0;
buttonOk->setEnabled(false);
@ -289,13 +317,100 @@ void SMESHGUI_CopyMeshDlg::Init (bool ResetControls)
myMesh = SMESH::SMESH_Mesh::_nil();
myIdSourceCheck->setChecked(true);
myCopyGroupsCheck->setChecked(false);
myKeepIdsCheck->setChecked(false);
onSelectIdSource( myIdSourceCheck->isChecked() );
onConstructor( 0 );
}
}
//=======================================================================
//function : onConstructor
//purpose : switch operation mode
//=======================================================================
void SMESHGUI_CopyMeshDlg::onConstructor( int withGeom )
{
myGeomLabel ->setVisible( withGeom );
myGeomNameEdit ->setVisible( withGeom );
myReuseHypCheck ->setVisible( withGeom );
myCopyElementsCheck->setVisible( withGeom );
myFilterBtn ->setVisible( !withGeom );
myIdSourceCheck ->setVisible( !withGeom );
if ( !withGeom )
myMeshNameEdit->setText( SMESH::UniqueMeshName("Mesh"));
onSelectIdSource( /*toSelectMesh=*/ myIdSourceCheck->isChecked() || withGeom );
}
//=======================================================================
//function : getErrorMsg
//purpose : Return an error message and entries of invalid smesh object
//=======================================================================
QString SMESHGUI_CopyMeshDlg::getErrorMsg( SMESH::string_array_var theInvalidEntries,
QStringList & theEntriesToBrowse )
{
if ( theInvalidEntries->length() == 0 )
return tr("SMESH_OPERATION_FAILED");
// theInvalidEntries - SObject's that hold geometry objects whose
// counterparts are not found in the newGeometry, followed by SObject's
// holding mesh sub-objects that are invalid because they depend on a not found
// preceeding sub-shape
QString msg = tr("SUBSHAPES_NOT_FOUND_MSG") + "\n";
QString objString;
for ( CORBA::ULong i = 0; i < theInvalidEntries->length(); ++i )
{
_PTR(SObject) so = SMESH::getStudy()->FindObjectID( theInvalidEntries[i].in() );
int objType = SMESHGUI_Selection::type( theInvalidEntries[i].in() );
if ( objType < 0 ) // geom object
{
objString += "\n";
if ( so )
objString += so->GetName().c_str();
else
objString += theInvalidEntries[i].in(); // it's something like "FACE #2"
}
else // smesh object
{
theEntriesToBrowse.push_back( theInvalidEntries[i].in() );
objString += "\n ";
switch ( objType ) {
case SMESH::MESH:
objString += tr("SMESH_MESH"); break;
case SMESH::HYPOTHESIS:
objString += tr("SMESH_HYPOTHESIS"); break;
case SMESH::ALGORITHM:
objString += tr("SMESH_ALGORITHM"); break;
case SMESH::SUBMESH_VERTEX:
case SMESH::SUBMESH_EDGE:
case SMESH::SUBMESH_FACE:
case SMESH::SUBMESH_SOLID:
case SMESH::SUBMESH_COMPOUND:
case SMESH::SUBMESH:
objString += tr("SMESH_SUBMESH"); break;
case SMESH::GROUP:
objString += tr("SMESH_GROUP"); break;
default:;
}
objString += " \"";
if ( so )
objString += so->GetName().c_str();
objString += "\" (";
objString += theInvalidEntries[i].in();
objString += ")";
}
}
if ( !objString.isEmpty() )
msg += objString;
return msg;
}
//=================================================================================
// function : ClickOnApply()
// purpose :
@ -303,13 +418,14 @@ void SMESHGUI_CopyMeshDlg::Init (bool ResetControls)
bool SMESHGUI_CopyMeshDlg::ClickOnApply()
{
if (SMESHGUI::isStudyLocked())
if ( SMESHGUI::isStudyLocked() )
return false;
if( !isValid() )
return false;
QStringList anEntryList;
bool toShowObjects = isApplyAndClose();
try
{
SUIT_OverrideCursor aWaitCursor;
@ -333,16 +449,55 @@ bool SMESHGUI_CopyMeshDlg::ClickOnApply()
}
QByteArray meshName = myMeshNameEdit->text().toUtf8();
bool toCopyGroups = ( myCopyGroupsCheck->isChecked() );
bool toReuseHyps = ( myReuseHypCheck->isChecked() );
bool toCopyElems = ( myCopyElementsCheck->isChecked() );
bool toKeepIDs = ( myKeepIdsCheck->isChecked() );
SMESH::SMESH_Gen_var gen = SMESHGUI::GetSMESHGen();
SMESH::SMESH_Mesh_var newMesh =
gen->CopyMesh(aPartToCopy, meshName.constData(), toCopyGroups, toKeepIDs);
if( !newMesh->_is_nil() )
if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( newMesh ) )
anEntryList.append( aSObject->GetID().c_str() );
SMESH::SMESH_Mesh_var newMesh;
if ( isWithGeomMode() )
{
SMESH::SMESH_Mesh_var srcMesh = mySelectedObject->GetMesh();
SMESH::ListOfGroups_var newGroups;
SMESH::submesh_array_var newSubmeshes;
SMESH::ListOfHypothesis_var newHypotheses;
SMESH::string_array_var invalidEntries;
CORBA::Boolean ok = gen->CopyMeshWithGeom( srcMesh, myNewGeometry,
meshName.constData(),
toCopyGroups, toReuseHyps, toCopyElems,
newMesh.out(),
newGroups.out(),
newSubmeshes.out(),
newHypotheses.out(),
invalidEntries.out() );
if ( !ok )
{
if ( invalidEntries->length() > 0 )
toShowObjects = true;
SUIT_MessageBox::warning( this,
tr("SMESH_WRN_WARNING"),
getErrorMsg( invalidEntries, anEntryList ));
}
catch (...) {
}
else
{
newMesh = gen->CopyMesh(aPartToCopy, meshName.constData(), toCopyGroups, toKeepIDs);
}
if ( !newMesh->_is_nil() )
if ( _PTR(SObject) aSObject = SMESH::ObjectToSObject( newMesh ) )
{
anEntryList.append( aSObject->GetID().c_str() );
if ( isWithGeomMode() )
SMESH::SetName( aSObject, meshName );
}
}
catch(const SALOME::SALOME_Exception & S_ex)
{
SalomeApp_Tools::QtCatchCorbaException(S_ex);
}
catch (...)
{
}
mySMESHGUI->updateObjBrowser(true);
@ -350,7 +505,7 @@ bool SMESHGUI_CopyMeshDlg::ClickOnApply()
if( LightApp_Application* anApp =
dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
anApp->browseObjects( anEntryList, isApplyAndClose() );
anApp->browseObjects( anEntryList, toShowObjects );
Init(false);
mySelectedObject = SMESH::SMESH_IDSource::_nil();
@ -503,13 +658,12 @@ void SMESHGUI_CopyMeshDlg::SelectionIntoArgument()
myActor = 0;
QString aString = "";
myLineEditElements->setText(aString);
myNbOkElements = 0;
buttonOk->setEnabled(false);
buttonApply->setEnabled(false);
myFilterBtn->setEnabled(false);
// get selected mesh
// get selected mesh or geometry
SALOME_ListIO aList;
mySelectionMgr->selectedObjects(aList);
int nbSel = aList.Extent();
@ -517,19 +671,29 @@ void SMESHGUI_CopyMeshDlg::SelectionIntoArgument()
return;
Handle(SALOME_InteractiveObject) IO = aList.First();
mySelectedObject = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>( IO );
if ( mySelectedObject->_is_nil() )
return;
myMesh = SMESH::GetMeshByIO(IO);
if (myMesh->_is_nil())
return;
SMESH::SMESH_Mesh_var mesh = SMESH::GetMeshByIO(IO);
GEOM::GEOM_Object_var geom = SMESH::GetGeom(IO);
if ( !mesh->_is_nil() )
{
myMesh = mesh;
myActor = SMESH::FindActorByEntry(IO->getEntry());
if (!myActor)
myActor = SMESH::FindActorByObject(myMesh);
if (myIdSourceCheck->isChecked())
mySelectedObject = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>( IO );
if ( mySelectedObject->_is_nil() )
return;
}
else if ( !geom->_is_nil() )
{
myNewGeometry = geom;
}
else
return;
if (myIdSourceCheck->isChecked() || isWithGeomMode() )
{
SMESH::GetNameOfSelectedIObjects( mySelectionMgr, aString );
if ( aString.isEmpty() ) aString = " ";
@ -541,8 +705,23 @@ void SMESHGUI_CopyMeshDlg::SelectionIntoArgument()
myNbOkElements = aString.size();
myFilterBtn->setEnabled(true);
}
myLineEditElements->setText( aString );
bool ok = !aString.isEmpty();
if ( !mesh->_is_nil() )
{
myLineEditElements->setText( aString );
if ( isWithGeomMode() )
myMeshNameEdit->setText( aString );
}
else if ( !geom->_is_nil() )
{
myGeomNameEdit->setText( aString );
ok = ok && !myLineEditElements->text().isEmpty();
}
if ( ok && isWithGeomMode() && !myMesh->_is_nil() )
ok = myMesh->HasShapeToMesh();
buttonOk->setEnabled(ok);
buttonApply->setEnabled(ok);
@ -554,7 +733,9 @@ void SMESHGUI_CopyMeshDlg::SelectionIntoArgument()
//=======================================================================
void SMESHGUI_CopyMeshDlg::onSelectIdSource (bool toSelectMesh)
{
if (toSelectMesh)
if ( isWithGeomMode() )
myTextLabelElements->setText(tr("SMESH_MESH"));
else if ( toSelectMesh )
myTextLabelElements->setText(tr("OBJECT_NAME"));
else
myTextLabelElements->setText(tr("ELEM_IDS"));
@ -564,6 +745,7 @@ void SMESHGUI_CopyMeshDlg::onSelectIdSource (bool toSelectMesh)
}
mySelectionMgr->clearFilters();
if ( !isWithGeomMode() )
mySelectionMgr->installFilter(myIdSourceFilter);
SMESH::SetPointRepresentation(false);
@ -592,10 +774,29 @@ void SMESHGUI_CopyMeshDlg::onSelectIdSource (bool toSelectMesh)
bool SMESHGUI_CopyMeshDlg::isValid()
{
if ( myIdSourceCheck->isChecked() )
return !mySelectedObject->_is_nil();
bool ok = false;
if ( myIdSourceCheck->isChecked() || isWithGeomMode() )
{
ok = ( !mySelectedObject->_is_nil() );
if ( isWithGeomMode() )
ok = ok && ( !myNewGeometry->_is_nil() );
}
else
{
ok = ( myNbOkElements > 0 );
}
return myNbOkElements > 0;
return ok;
}
//=======================================================================
//function : isWithGeomMode
//purpose : Return true if the mode is "with geometry"
//=======================================================================
bool SMESHGUI_CopyMeshDlg::isWithGeomMode()
{
return ( GroupConstructors->checkedId() == 1 );
}
//=================================================================================

16
src/SMESHGUI/SMESHGUI_CopyMeshDlg.h
View File

@ -35,12 +35,14 @@
// IDL includes
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_Mesh)
#include CORBA_SERVER_HEADER(SMESH_Gen)
class QCheckBox;
class QGroupBox;
class QLabel;
class QLineEdit;
class QPushButton;
class QButtonGroup;
class SMESHGUI;
class SMESHGUI_IdValidator;
@ -59,7 +61,7 @@ class SMESHGUI_EXPORT SMESHGUI_CopyMeshDlg : public QDialog
{
Q_OBJECT
public:
public:
SMESHGUI_CopyMeshDlg( SMESHGUI* );
~SMESHGUI_CopyMeshDlg();
@ -67,10 +69,12 @@ private:
void Init( bool = true );
void enterEvent( QEvent* ); /* mouse enter the QWidget */
void keyPressEvent( QKeyEvent* );
int GetConstructorId();
void setNewMeshName();
QString getErrorMsg( SMESH::string_array_var invalidEntries,
QStringList & entriesToBrowse );
bool isValid();
bool isWithGeomMode();
void setIsApplyAndClose( const bool theFlag );
bool isApplyAndClose() const;
@ -84,11 +88,14 @@ private:
bool myBusy;
SMESH::SMESH_Mesh_var myMesh;
GEOM::GEOM_Object_var myNewGeometry;
SMESH_Actor* myActor;
SUIT_SelectionFilter* myIdSourceFilter;
SMESH::SMESH_IDSource_var mySelectedObject;
QButtonGroup* GroupConstructors;
QGroupBox* ConstructorsBox;
QGroupBox* GroupArguments;
QGroupBox* GroupButtons;
@ -99,10 +106,14 @@ private:
QPushButton* buttonHelp;
QLabel* myTextLabelElements;
QLabel* myGeomLabel;
QLineEdit* myLineEditElements;
QLineEdit* myMeshNameEdit;
QLineEdit* myGeomNameEdit;
QCheckBox* myIdSourceCheck;
QCheckBox* myCopyGroupsCheck;
QCheckBox* myReuseHypCheck;
QCheckBox* myCopyElementsCheck;
QCheckBox* myKeepIdsCheck;
QPushButton* myFilterBtn;
@ -122,6 +133,7 @@ private slots:
void SelectionIntoArgument();
void DeactivateActiveDialog();
void ActivateThisDialog();
void onConstructor( int );
void onTextChange( const QString& );
void onSelectIdSource( bool );
void setFilters();

11
src/SMESHGUI/SMESHGUI_GEOMGenUtils.cxx
View File

@ -111,6 +111,17 @@ namespace SMESH
return aMeshShape;
}
GEOM::GEOM_Object_var GetGeom( Handle(SALOME_InteractiveObject) io )
{
GEOM::GEOM_Object_var go;
if ( !io.IsNull() && io->hasEntry() )
{
_PTR(SObject) so = SMESH::getStudy()->FindObjectID( io->getEntry() );
go = GetGeom( so );
}
return go._retn();
}
SMESHGUI_EXPORT char* GetGeomName( _PTR(SObject) smeshSO )
{
if (!smeshSO)

2
src/SMESHGUI/SMESHGUI_GEOMGenUtils.h
View File

@ -51,6 +51,8 @@ namespace SMESH
SMESHGUI_EXPORT GEOM::GEOM_Object_var GetGeom( _PTR(SObject) );
SMESHGUI_EXPORT GEOM::GEOM_Object_var GetGeom( Handle(SALOME_InteractiveObject) io );
SMESHGUI_EXPORT char* GetGeomName( _PTR(SObject) smeshSO );
SMESHGUI_EXPORT GEOM::GEOM_Object_ptr GetSubShape( GEOM::GEOM_Object_ptr, long );

6
src/SMESHGUI/SMESHGUI_HypothesesUtils.cxx
View File

@ -526,10 +526,12 @@ namespace SMESH
LPTSTR path = new TCHAR[aClientLibName.length() + 1];
path[aClientLibName.toWCharArray(path)] = '\0';
#else
const char* path = aClientLibName.toUtf8().data();
QByteArray baPath = aClientLibName.toUtf8();
const char* path = baPath.data();
#endif
#else
char* path = aClientLibName.toUtf8().data();
QByteArray baPath = aClientLibName.toUtf8();
char* path = baPath.data();
#endif
LibHandle libHandle = LoadLib( path );
if (!libHandle) {

38
src/SMESHGUI/SMESHGUI_MeshOp.cxx
View File

@ -92,6 +92,7 @@ SMESHGUI_MeshOp::SMESHGUI_MeshOp( const bool theToCreate, const bool theIsMesh )
myShapeByMeshOp( 0 ),
myToCreate( theToCreate ),
myIsMesh( theIsMesh ),
myIsInvalidSubMesh( false ),
myHypoSet( 0 )
{
if ( GeometryGUI::GetGeomGen()->_is_nil() )// check that GEOM_Gen exists
@ -152,7 +153,7 @@ bool SMESHGUI_MeshOp::onApply()
QStringList anEntryList;
if ( myToCreate && myIsMesh )
aResult = createMesh( aMess, anEntryList );
if ( myToCreate && !myIsMesh )
if (( myToCreate && !myIsMesh ) || myIsInvalidSubMesh )
aResult = createSubMesh( aMess, anEntryList );
else if ( !myToCreate )
aResult = editMeshOrSubMesh( aMess );
@ -519,6 +520,7 @@ void SMESHGUI_MeshOp::selectionDone()
try
{
myIsOnGeometry = true;
myIsInvalidSubMesh = false;
//Check geometry for mesh
QString anObjEntry = myDlg->selectedObject(SMESHGUI_MeshDlg::Obj);
@ -638,11 +640,21 @@ void SMESHGUI_MeshOp::selectionDone()
SMESH::SMESH_subMesh_var submeshVar =
SMESH::SMESH_subMesh::_narrow( _CAST( SObject,pObj )->GetObject() );
myIsMesh = submeshVar->_is_nil();
myIsInvalidSubMesh = ( !myIsMesh && submeshVar->GetId() < 1 );
myDlg->setTitile( myToCreate, myIsMesh );
myDlg->setObjectShown( SMESHGUI_MeshDlg::Mesh, !submeshVar->_is_nil() );
myDlg->setObjectShown( SMESHGUI_MeshDlg::Geom, true );
myDlg->objectWg( SMESHGUI_MeshDlg::Mesh, SMESHGUI_MeshDlg::Btn )->hide();
if ( myIsInvalidSubMesh )
{
// it is necessary to select a new geometry
myDlg->objectWg( SMESHGUI_MeshDlg::Geom, SMESHGUI_MeshDlg::Btn )->show();
myDlg->activateObject( SMESHGUI_MeshDlg::Geom );
}
else
{
myDlg->objectWg( SMESHGUI_MeshDlg::Geom, SMESHGUI_MeshDlg::Btn )->hide();
}
myDlg->updateGeometry();
myDlg->adjustSize();
readMesh();
@ -1893,11 +1905,16 @@ bool SMESHGUI_MeshOp::createSubMesh( QString& theMess, QStringList& theEntryList
return false;
// get mesh object
QString aMeshEntry = myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh );
_PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( aMeshEntry.toUtf8().data() );
SMESH::SMESH_Mesh_var aMeshVar =
SMESH::SMESH_Mesh::_narrow( _CAST( SObject,pMesh )->GetObject() );
if (aMeshVar->_is_nil())
SMESH::EntryToInterface<SMESH::SMESH_Mesh>( myDlg->selectedObject( SMESHGUI_MeshDlg::Mesh ));
if ( aMeshVar->_is_nil() && myIsInvalidSubMesh )
{
SMESH::SMESH_subMesh_var aSMVar =
SMESH::EntryToInterface<SMESH::SMESH_subMesh>( myDlg->selectedObject( SMESHGUI_MeshDlg::Obj ));
if ( !aSMVar->_is_nil() )
aMeshVar = aSMVar->GetMesh();
}
if ( aMeshVar->_is_nil() )
return false;
// GEOM shape of the main mesh
@ -1971,8 +1988,14 @@ bool SMESHGUI_MeshOp::createSubMesh( QString& theMess, QStringList& theEntryList
SUIT_OverrideCursor aWaitCursor;
QString aNameOrID = aName;
if ( myIsInvalidSubMesh )
// pass a sub-mesh entry to mesh->GetSubMesh() to replace the invalid sub-mesh
// by a valid one in an existing SO
aNameOrID = myDlg->selectedObject(SMESHGUI_MeshDlg::Obj);
// create sub-mesh
SMESH::SMESH_subMesh_var aSubMeshVar = aMeshVar->GetSubMesh( aGeomVar, aName.toUtf8().data() );
SMESH::SMESH_subMesh_var aSubMeshVar = aMeshVar->GetSubMesh( aGeomVar, aNameOrID.toUtf8().data() );
_PTR(SObject) aSubMeshSO = SMESH::FindSObject( aSubMeshVar.in() );
if ( aSubMeshSO ) {
SMESH::SetName( aSubMeshSO, aName.toUtf8().data() );
@ -2249,11 +2272,14 @@ void SMESHGUI_MeshOp::readMesh()
myHasConcurrentSubBefore = checkSubMeshConcurrency( aMeshVar, aSubMeshVar );
}
if ( !myIsInvalidSubMesh )
{
// Get name of geometry object
CORBA::String_var name = SMESH::GetGeomName( pObj );
if ( name.in() )
myDlg->setObjectText( SMESHGUI_MeshDlg::Geom, name.in() );
}
}
// Get hypotheses and algorithms assigned to the mesh/sub-mesh
QStringList anExisting;

5
src/SMESHGUI/SMESHGUI_MeshOp.h
View File

@ -153,8 +153,11 @@ private:
SMESHGUI_ShapeByMeshOp* myShapeByMeshOp;
bool myToCreate;
bool myIsMesh;
bool myIsOnGeometry; //!< TRUE if edited mesh accotiated with geometrical object
bool myIsOnGeometry; //!< TRUE if edited mesh is based on geometry
bool myHasConcurrentSubBefore;
bool myIsInvalidSubMesh; //!< "invalid sub-mesh" is edited
// The geometry of "invalid sub-mesh" is not a sub-shape of the main shape;
// it is created for the case where a valid sub-shape not found by CopyMeshWithGeom()
TDim2Type2HypList myExistingHyps; //!< all hypothesis of SMESH module
TDim2Type2HypList myObjHyps; //!< hypothesis assigned to the current

6
src/SMESHGUI/SMESHGUI_Utils.cxx
View File

@ -226,6 +226,12 @@ namespace SMESH
return app->orb()->string_to_object(theIOR.toLatin1().data());
}
CORBA::Object_var EntryToObject( const QString& theEntry )
{
_PTR(SObject) anObj = getStudy()->FindObjectID( theEntry.toLatin1().data() );
return SObjectToObject(anObj);
}
int GetNameOfSelectedIObjects(LightApp_SelectionMgr* theMgr, QString& theName)
{
if (!theMgr)

12
src/SMESHGUI/SMESHGUI_Utils.h
View File

@ -152,6 +152,18 @@ SMESHGUI_EXPORT
return TInterface::_nil();
}
SMESHGUI_EXPORT
CORBA::Object_var EntryToObject( const QString& );
template<class TInterface> typename TInterface::_var_type
EntryToInterface( const QString& theEntry )
{
CORBA::Object_var anObj = EntryToObject( theEntry );
if ( !CORBA::is_nil( anObj ) )
return TInterface::_narrow( anObj );
return TInterface::_nil();
}
SMESHGUI_EXPORT
int GetNameOfSelectedIObjects( LightApp_SelectionMgr*, QString& );

4
src/SMESHGUI/SMESH_images.ts
View File

@ -35,6 +35,10 @@
<source>ICON_COPY_MESH</source>
<translation>copy_mesh.png</translation>
</message>
<message>
<source>ICON_COPY_MESH_WG</source>
<translation>copy_mesh_with_geom.png</translation>
</message>
<message>
<source>ICON_COMPUTE</source>
<translation>mesh_compute.png</translation>

27
src/SMESHGUI/SMESH_msg_en.ts
View File

@ -1938,6 +1938,14 @@ add the exported data to its contents?</translation>
<source>SMESH_HYPOTHESES</source>
<translation>Hypotheses</translation>
</message>
<message>
<source>SMESH_HYPOTHESIS</source>
<translation>Hypothesis</translation>
</message>
<message>
<source>SMESH_ALGORITHM</source>
<translation>Algorithm</translation>
</message>
<message>
<source>SMESH_HYP_1</source>
<translation>Algorithm misses a hypothesis</translation>
@ -8070,6 +8078,25 @@ as they are of improper type:
<source>NEW_NAME</source>
<translation>New Mesh Name</translation>
</message>
<message>
<source>NEW_GEOM</source>
<translation>New Geometry</translation>
</message>
<message>
<source>REUSE_HYPOTHESES</source>
<translation>Reuse Hypotheses</translation>
</message>
<message>
<source>COPY_ELEMENTS</source>
<translation>Copy Mesh Elements</translation>
</message>
<message>
<source>SUBSHAPES_NOT_FOUND_MSG</source>
<translation>
Some sub-shapes not found in the new geometry. They are listed
below along with dependent mesh objects that are marked with
with red in the Object Browser.</translation>
</message>
</context>
<context>
<name>SMESHGUI_MeasureDlg</name>

8
src/SMESH_I/SMESH_2smeshpy.cxx
View File

@ -1006,7 +1006,7 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand )
AddObject( mesh );
return;
}
if( method == "CreateMeshesFromMED" ||
if ( method == "CreateMeshesFromMED" ||
method == "CreateMeshesFromSAUV"||
method == "CreateMeshesFromCGNS" ||
method == "CreateMeshesFromGMF" ) // command result is ( [mesh1,mesh2], status )
@ -1027,6 +1027,12 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand )
theCommand->SetArg( 1, file );
}
}
if ( method == "CopyMeshWithGeom" )
{
std::list< _pyID > entries = theCommand->GetStudyEntries( theCommand->GetResultValue() );
Handle(_pyMesh) mesh = new _pyMesh( theCommand, entries.front() );
AddObject( mesh );
}
// CreateHypothesis()
if ( method == "CreateHypothesis" )

24
src/SMESH_I/SMESH_Algo_i.cxx
View File

@ -81,3 +81,27 @@ SMESH::ListOfHypothesisName* SMESH_Algo_i::GetCompatibleHypothesis()
}
return listOfHypothesis._retn();
}
//================================================================================
/*!
* Return geometry this hypothesis depends on. Return false if there is no geometry parameter
*/
//================================================================================
bool SMESH_Algo_i::getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const
{
return false;
}
//================================================================================
/*!
* \brief Set new geometry instead of that returned by getObjectsDependOn()
*/
//================================================================================
bool SMESH_Algo_i::setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray )
{
return true;
}

9
src/SMESH_I/SMESH_Algo_i.hxx
View File

@ -53,6 +53,15 @@ public:
// Gets list of compatible hypotheses
SMESH::ListOfHypothesisName* GetCompatibleHypothesis();
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const;
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray );
};
#endif

880
src/SMESH_I/SMESH_Gen_i.cxx
View File

@ -103,6 +103,9 @@
#include "SMESH_PreMeshInfo.hxx"
#include "SMESH_PythonDump.hxx"
#include "SMESH_ControlsDef.hxx"
// to pass CORBA exception through SMESH_TRY
#define SMY_OWN_CATCH catch( SALOME::SALOME_Exception& se ) { throw se; }
#include "SMESH_TryCatch.hxx" // to include after OCC headers!
#include CORBA_SERVER_HEADER(SMESH_Group)
@ -110,6 +113,7 @@
#include CORBA_SERVER_HEADER(SMESH_MeshEditor)
#include <GEOMImpl_Types.hxx>
#include <GEOM_Client.hxx>
#include <Basics_Utils.hxx>
@ -138,6 +142,7 @@
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <memory>
using namespace std;
using SMESH::TPythonDump;
@ -440,11 +445,11 @@ GenericHypothesisCreator_i* SMESH_Gen_i::getHypothesisCreator(const char* theHyp
// load plugin library
if(MYDEBUG) MESSAGE("Loading server meshers plugin library ...");
#ifdef WIN32
#ifdef UNICODE
#ifdef UNICODE
const wchar_t* path = Kernel_Utils::decode_s(aPlatformLibName);
#else
#else
const char* path = aPlatformLibName.c_str();
#endif
#endif
#else
const char* path = aPlatformLibName.c_str();
#endif
@ -1938,7 +1943,7 @@ CORBA::Boolean SMESH_Gen_i::Compute( SMESH::SMESH_Mesh_ptr theMesh,
try {
// get mesh servant
SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( theMesh ).in() );
SMESH_Mesh_i* meshServant = SMESH::DownCast<SMESH_Mesh_i*>( theMesh );
ASSERT( meshServant );
if ( meshServant ) {
meshServant->Load();
@ -1960,6 +1965,7 @@ CORBA::Boolean SMESH_Gen_i::Compute( SMESH::SMESH_Mesh_ptr theMesh,
meshServant->CreateGroupServants(); // algos can create groups (issue 0020918)
myLocMesh.GetMeshDS()->Modified();
UpdateIcons( theMesh );
HighLightInvalid( theMesh, /*isInvalid=*/!ok );
return ok;
}
}
@ -2724,10 +2730,12 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CopyMesh(SMESH::SMESH_IDSource_ptr meshPart,
const char* meshName,
CORBA::Boolean toCopyGroups,
CORBA::Boolean toKeepIDs)
throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
TPythonDump* pyDump = new TPythonDump; // prevent dump from CreateMesh()
std::unique_ptr<TPythonDump> pyDumpDeleter( pyDump );
// 1. Get source mesh
@ -2930,7 +2938,7 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CopyMesh(SMESH::SMESH_IDSource_ptr meshPart,
<< toCopyGroups << ", "
<< toKeepIDs << ")";
delete pyDump; pyDump = 0; // allow dump in GetGroups()
pyDumpDeleter.reset(); // allow dump in GetGroups()
if ( nbNewGroups > 0 ) // dump created groups
SMESH::ListOfGroups_var groups = newMesh->GetGroups();
@ -2938,6 +2946,868 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CopyMesh(SMESH::SMESH_IDSource_ptr meshPart,
return newMesh._retn();
}
namespace // utils for CopyMeshWithGeom()
{
typedef std::map< std::string, std::string > TStr2StrMap;
typedef std::map< std::string, std::set< std::string > > TStr2StrSetMap;
//================================================================================
/*!
* \brief Return a new sub-shape corresponding to an old one
*/
//================================================================================
struct ShapeMapper
{
SMESH_Mesh_i* mySrcMesh_i;
SMESH_Mesh_i* myNewMesh_i;
SMESH_Gen_i* myGen_i;
bool myToPublish;
bool myIsSameGeom;
TStr2StrMap myOld2NewEntryMap; // map of study entries
bool myGIPMapDone;
GEOM::ListOfListOfLong_var myGIPMap; // filled by GetInPlaceMap()
// not directly relating to shape search
TStr2StrSetMap myInvalidMap; // blame shape -> invalid objects
//================================================================================
/*!
* \brief Constructor
*/
ShapeMapper( SMESH_Mesh_i* srcMesh_i,
SMESH_Mesh_i* newMesh_i,
SMESH_Gen_i* smeshGen_i )
: mySrcMesh_i( srcMesh_i ),
myNewMesh_i( newMesh_i ),
myGen_i ( smeshGen_i ),
myToPublish( smeshGen_i->IsEnablePublish() ),
myGIPMapDone( false )
{
// retrieve from the study shape mapping made thanks to
// "Set presentation parameters and sub-shapes from arguments" option
GEOM::GEOM_Object_var mainShapeNew = myNewMesh_i->GetShapeToMesh();
GEOM::GEOM_Object_var mainShapeOld = mySrcMesh_i->GetShapeToMesh();
SALOMEDS::SObject_wrap oldSO = myGen_i->ObjectToSObject( mainShapeOld );
SALOMEDS::SObject_wrap newSO = myGen_i->ObjectToSObject( mainShapeNew );
if ( newSO->_is_nil() )
{
myToPublish = false;
return;
}
if (( myIsSameGeom = mainShapeNew->_is_equivalent( mainShapeOld )))
return;
CORBA::String_var oldEntry = oldSO->GetID();
CORBA::String_var newEntry = newSO->GetID();
myOld2NewEntryMap.insert( std::make_pair( std::string( oldEntry.in() ),
std::string( newEntry.in() )));
SALOMEDS::Study_var study = myGen_i->getStudyServant();
GEOM::GEOM_Gen_var geomGen = myGen_i->GetGeomEngine();
GEOM::GEOM_IShapesOperations_wrap op = geomGen->GetIShapesOperations();
GEOM::ListOfGO_var subShapes = op->GetExistingSubObjects( mainShapeNew,
/*groupsOnly=*/false );
for ( CORBA::ULong i = 0; i < subShapes->length(); ++i )
{
newSO = myGen_i->ObjectToSObject( subShapes[ i ]);
SALOMEDS::ChildIterator_wrap anIter = study->NewChildIterator( newSO );
for ( ; anIter->More(); anIter->Next() )
{
SALOMEDS::SObject_wrap so = anIter->Value();
if ( so->ReferencedObject( oldSO.inout() ))
{
oldEntry = oldSO->GetID();
newEntry = newSO->GetID();
myOld2NewEntryMap.insert( std::make_pair( std::string( oldEntry.in() ),
std::string( newEntry.in() )));
}
}
}
}
//================================================================================
/*!
* \brief Find a new sub-shape corresponding to an old one
*/
GEOM::GEOM_Object_ptr FindNew( GEOM::GEOM_Object_ptr oldShape )
{
if ( myIsSameGeom )
return GEOM::GEOM_Object::_duplicate( oldShape );
GEOM::GEOM_Object_var newShape;
if ( CORBA::is_nil( oldShape ))
return newShape._retn();
if ( !isChildOfOld( oldShape ))
return GEOM::GEOM_Object::_duplicate( oldShape ); // shape independent of the old shape
GEOM::GEOM_Object_var mainShapeNew = myNewMesh_i->GetShapeToMesh();
GEOM::GEOM_Gen_var geomGen = myGen_i->GetGeomEngine();
// try to find by entry
if ( myToPublish )
{
CORBA::String_var oldEntry = oldShape->GetStudyEntry();
TStr2StrMap::iterator o2nID = myOld2NewEntryMap.find( oldEntry.in() );
if ( o2nID != myOld2NewEntryMap.end() )
{
newShape = getShapeByEntry( o2nID->second );
}
}
if ( newShape->_is_nil() )
{
// try to construct a new sub-shape using myGIPMap
buildGIPMap();
std::vector< int > newIndices;
GEOM::ListOfLong_var oldIndices = oldShape->GetSubShapeIndices();
for ( CORBA::ULong i = 0; i < oldIndices->length(); ++i )
{
findNewIDs( oldIndices[i], newIndices );
}
if ( !newIndices.empty() )
{
try
{
if ( newIndices.size() > 1 || oldShape->GetType() == GEOM_GROUP )
{
int groupType = getShapeType( myNewMesh_i, newIndices[0] );
GEOM::GEOM_IGroupOperations_wrap grOp = geomGen->GetIGroupOperations();
newShape = grOp->CreateGroup( mainShapeNew, groupType );
GEOM::ListOfLong_var newIndicesList = new GEOM::ListOfLong();
newIndicesList->length( newIndices.size() );
for ( size_t i = 0; i < newIndices.size(); ++i )
newIndicesList[ i ] = newIndices[ i ];
grOp->UnionIDs( newShape, newIndicesList );
}
else
{
GEOM::GEOM_IShapesOperations_wrap shOp = geomGen->GetIShapesOperations();
newShape = shOp->GetSubShape( mainShapeNew, newIndices[0] );
}
}
catch (...)
{
}
}
}
if ( !newShape->_is_nil() && myToPublish )
{
CORBA::String_var oldEntry, newEntry = newShape->GetStudyEntry();
if ( !newEntry.in() || !newEntry.in()[0] )
{
CORBA::String_var name = oldShape->GetName();
SALOMEDS::SObject_wrap so = geomGen->AddInStudy( newShape, name, mainShapeNew );
newEntry = newShape->GetStudyEntry();
oldEntry = oldShape->GetStudyEntry();
myOld2NewEntryMap.insert( std::make_pair( std::string( oldEntry.in() ),
std::string( newEntry.in() )));
}
}
return newShape._retn();
}
//================================================================================
/*!
* \brief Return a study entry of a new shape by study entry of the old one
*/
std::string FindNew( const std::string & oldEntry )
{
if ( myIsSameGeom )
return oldEntry;
TStr2StrMap::iterator o2nID = myOld2NewEntryMap.find( oldEntry );
if ( o2nID != myOld2NewEntryMap.end() )
return o2nID->second;
GEOM::GEOM_Object_var oldShape = getShapeByEntry( oldEntry );
if ( oldShape->_is_nil() || !isChildOfOld( oldShape ))
return oldEntry;
GEOM::GEOM_Object_ptr newShape = FindNew( oldShape );
if ( newShape->_is_nil() )
return std::string();
CORBA::String_var newEntry = newShape->GetStudyEntry();
return newEntry.in();
}
//================================================================================
/*!
* \brief Return a sub-shape ID of a new shape by a sub-shape ID of the old one.
* Return zero if not found or there are more than one new ID
*/
int FindNew( int oldID )
{
if ( myIsSameGeom )
return oldID;
buildGIPMap();
int newID = 0;
if ( 0 < oldID && oldID < (int)myGIPMap->length() )
{
if ( myGIPMap[ oldID ].length() == 1 )
newID = myGIPMap[ oldID ][ 0 ];
}
return newID;
}
//================================================================================
/*!
* \brief Return a sub-shape ID of a new shape by an old sub-mesh.
* Return zero if the old shape is not kept as is in the new shape.
*/
int FindNewNotChanged( SMESH_subMesh* oldSM )
{
if ( myIsSameGeom )
return oldSM->GetId();
int newID = FindNew( oldSM->GetId() );
if ( !newID )
return 0;
SMESH_subMesh* newSM = myNewMesh_i->GetImpl().GetSubMeshContaining( newID );
if ( !newSM )
return 0;
// consider a sub-shape as not changed if all its sub-shapes are mapped into
// one new sub-shape of the same type.
if ( oldSM->DependsOn().size() !=
newSM->DependsOn().size() )
return 0;
SMESH_subMeshIteratorPtr srcSMIt = oldSM->getDependsOnIterator( /*includeSelf=*/true );
while ( srcSMIt->more() )
{
oldSM = srcSMIt->next();
int newSubID = FindNew( oldSM->GetId() );
if ( getShapeType( myNewMesh_i, newSubID ) !=
getShapeType( mySrcMesh_i, oldSM->GetId() ))
return 0;
}
return newID;
}
//================================================================================
/*!
* \brief Return shape by study entry
*/
GEOM::GEOM_Object_ptr getShapeByEntry( const std::string & entry )
{
GEOM::GEOM_Object_var shape;
SALOMEDS::SObject_wrap so = myGen_i->getStudyServant()->FindObjectID( entry.c_str() );
if ( !so->_is_nil() )
{
CORBA::Object_var obj = so->GetObject();
shape = GEOM::GEOM_Object::_narrow( obj );
}
return shape._retn();
}
//================================================================================
/*!
* \brief Fill myGIPMap by calling GetInPlaceMap()
*/
void buildGIPMap()
{
if ( !myGIPMapDone )
{
myGIPMapDone = true;
GEOM::GEOM_Object_var mainShapeNew = myNewMesh_i->GetShapeToMesh();
GEOM::GEOM_Object_var mainShapeOld = mySrcMesh_i->GetShapeToMesh();
GEOM::GEOM_Gen_var geomGen = myGen_i->GetGeomEngine();
GEOM::GEOM_IShapesOperations_wrap op = geomGen->GetIShapesOperations();
try
{
myGIPMap = op->GetInPlaceMap( mainShapeNew, mainShapeOld );
}
catch( ... )
{
myGIPMap = new GEOM::ListOfListOfLong();
}
}
}
//================================================================================
/*!
* \brief Find a new sub-shape indices by an old one in myGIPMap. Return
* number of found IDs
*/
int findNewIDs( int oldID, std::vector< int >& newIDs )
{
size_t prevNbIDs = newIDs.size();
if ( 0 < oldID && oldID < (int) myGIPMap->length() )
{
for ( CORBA::ULong i = 0; i < myGIPMap[ oldID ].length(); ++i )
newIDs.push_back( myGIPMap[ oldID ][ i ]);
}
return newIDs.size() - prevNbIDs;
}
//================================================================================
/*!
* \brief Check if an object relates to the old shape
*/
bool isChildOfOld( GEOM::GEOM_Object_ptr oldShape )
{
if ( CORBA::is_nil( oldShape ))
return false;
GEOM::GEOM_Object_var mainShapeOld1 = mySrcMesh_i->GetShapeToMesh();
GEOM::GEOM_Object_var mainShapeOld2 = oldShape->GetMainShape();
return ( mainShapeOld1->_is_equivalent( mainShapeOld2 ) ||
mainShapeOld1->_is_equivalent( oldShape ));
}
//================================================================================
/*!
* \brief Return shape type by shape ID
*/
TopAbs_ShapeEnum getShapeType( SMESH_Mesh_i* mesh_i, int shapeID )
{
SMESHDS_Mesh* meshDS = mesh_i->GetImpl().GetMeshDS();
const TopoDS_Shape& shape = meshDS->IndexToShape( shapeID );
return shape.IsNull() ? TopAbs_SHAPE : shape.ShapeType();
}
//================================================================================
/*!
* \brief Store a source sub-shape for which a counterpart not found and
* a smesh object invalid due to that
*/
void AddInvalid( GEOM::GEOM_Object_var srcShape,
SALOMEDS::SObject_wrap smeshSO )
{
CORBA::String_var geomEntry = srcShape->GetStudyEntry();
if ( geomEntry.in()[0] && !smeshSO->_is_nil() )
{
CORBA::String_var smeshEntry = smeshSO->GetID();
myInvalidMap[ geomEntry.in() ].insert( smeshEntry.in() );
}
}
//================================================================================
/*!
* \brief Store a source sub-shape for which a counterpart not found and
* a smesh object invalid due to that
*/
void AddInvalid( std::string geomEntry,
SALOMEDS::SObject_wrap smeshSO )
{
if ( !geomEntry.empty() )
{
CORBA::String_var smeshEntry = smeshSO->GetID();
myInvalidMap[ geomEntry ].insert( smeshEntry.in() );
}
}
//================================================================================
/*!
* \brief Store a source sub-shape for which a counterpart not found and
* a smesh object invalid due to that
*/
void AddInvalid( int oldGeomID,
SALOMEDS::SObject_wrap smeshSO )
{
int shapeType = getShapeType( mySrcMesh_i, oldGeomID );
if ( shapeType < 0 || shapeType > TopAbs_SHAPE )
return;
const char* typeName[] = { "COMPOUND","COMPSOLID","SOLID","SHELL",
"FACE","WIRE","EDGE","VERTEX","SHAPE" };
SMESH_Comment geomName( typeName[ shapeType ]);
geomName << " #" << oldGeomID;
CORBA::String_var smeshEntry = smeshSO->GetID();
myInvalidMap[ geomName ].insert( smeshEntry.in() );
}
//================================================================================
/*!
* \brief Return entries of a source sub-shape for which a counterpart not found and
* of smesh objects invalid due to that
*/
void GetInvalid( SMESH::string_array_out & theInvalidEntries,
std::vector< SALOMEDS::SObject_wrap > & theInvalidMeshSObjects)
{
int nbSO = 0;
TStr2StrSetMap::iterator entry2entrySet = myInvalidMap.begin();
for ( ; entry2entrySet != myInvalidMap.end(); ++entry2entrySet )
{
nbSO += 1 + entry2entrySet->second.size();
}
int iSO = theInvalidMeshSObjects.size(), iEntry = 0;
theInvalidEntries->length ( nbSO );
theInvalidMeshSObjects.resize( theInvalidMeshSObjects.size() + nbSO - myInvalidMap.size() );
entry2entrySet = myInvalidMap.begin();
for ( ; entry2entrySet != myInvalidMap.end(); ++entry2entrySet )
{
theInvalidEntries[ iEntry++ ] = entry2entrySet->first.c_str();
std::set< std::string > & entrySet = entry2entrySet->second;
std::set< std::string >::iterator entry = entrySet.begin();
for ( ; entry != entrySet.end(); ++entry )
{
theInvalidEntries[ iEntry++ ] = entry->c_str();
SALOMEDS::SObject_wrap so = myGen_i->getStudyServant()->FindObjectID( entry->c_str() );
if ( !so->_is_nil() )
theInvalidMeshSObjects[ iSO++ ] = so;
}
}
}
}; // struct ShapeMapper
//================================================================================
/*!
* \brief Append an item to a CORBA sequence
*/
template < class CORBA_seq, class ITEM >
void append( CORBA_seq& seq, ITEM item )
{
if ( !CORBA::is_nil( item ))
{
seq->length( 1 + seq->length() );
seq[ seq->length() - 1 ] = item;
}
}
}
//================================================================================
/*!
* \brief Create a mesh by copying definitions of another mesh to a given geometry
* \param [in] sourceMesh - a mesh to copy
* \param [in] newGeometry - a new geometry
* \param [in] toCopyGroups - to create groups in the new mesh
* \param [in] toReuseHypotheses - if True, existing hypothesis will be used by the new mesh,
* otherwise new hypotheses with the same parameters will be created for the new mesh.
* \param [in] toCopyElements - to copy mesh elements of same sub-shapes of the two geometries
* \param [out] newMesh - return a new mesh
* \param [out] newGroups - return new groups
* \param [out] newSubmeshes - return new sub-meshes
* \param [out] newHypotheses - return new algorithms and hypotheses
* \param [out] invalidEntries - return study entries of objects whose
* counterparts are not found in the newGeometry, followed by entries
* of mesh sub-objects that are invalid because they depend on a not found
* preceeding sub-shape
* \return CORBA::Boolean - is a success
*/
//================================================================================
CORBA::Boolean SMESH_Gen_i::CopyMeshWithGeom( SMESH::SMESH_Mesh_ptr theSourceMesh,
GEOM::GEOM_Object_ptr theNewGeometry,
const char* theMeshName,
CORBA::Boolean theToCopyGroups,
CORBA::Boolean theToReuseHypotheses,
CORBA::Boolean theToCopyElements,
SMESH::SMESH_Mesh_out theNewMesh,
SMESH::ListOfGroups_out theNewGroups,
SMESH::submesh_array_out theNewSubmeshes,
SMESH::ListOfHypothesis_out theNewHypotheses,
SMESH::string_array_out theInvalidEntries)
throw ( SALOME::SALOME_Exception )
{
if ( CORBA::is_nil( theSourceMesh ) ||
CORBA::is_nil( theNewGeometry ))
THROW_SALOME_CORBA_EXCEPTION( "NULL arguments", SALOME::BAD_PARAM );
if ( !theSourceMesh->HasShapeToMesh() )
THROW_SALOME_CORBA_EXCEPTION( "Source mesh not on geometry", SALOME::BAD_PARAM );
bool ok = true;
SMESH_TRY;
TPythonDump pyDump; // prevent dump from CreateMesh()
theNewMesh = CreateMesh( theNewGeometry );
theNewGroups = new SMESH::ListOfGroups();
theNewSubmeshes = new SMESH::submesh_array();
theNewHypotheses = new SMESH::ListOfHypothesis();
theInvalidEntries = new SMESH::string_array();
std::vector< SALOMEDS::SObject_wrap > invalidSObjects;
GEOM::GEOM_Object_var srcGeom = theSourceMesh->GetShapeToMesh();
GEOM::GEOM_Object_var geom, newGeom;
SALOMEDS::SObject_wrap so;
SMESH_Mesh_i* srcMesh_i = SMESH::DownCast<SMESH_Mesh_i*>( theSourceMesh );
SMESH_Mesh_i* newMesh_i = SMESH::DownCast<SMESH_Mesh_i*>( theNewMesh );
ShapeMapper shapeMapper( srcMesh_i, newMesh_i, this );
// treat hypotheses of mesh and sub-meshes
SMESH::submesh_array_var smList = theSourceMesh->GetSubMeshes();
for ( CORBA::ULong iSM = 0; iSM <= smList->length(); ++iSM )
{
bool isSubMesh = ( iSM < smList->length() );
if ( isSubMesh )
{
// create a new sub-mesh
SMESH::SMESH_subMesh_var newSM;
geom = smList[iSM]->GetSubShape();
so = ObjectToSObject( smList[iSM] );
CORBA::String_var name;
if ( !so->_is_nil() )
name = so->GetName();
newGeom = shapeMapper.FindNew( geom );
if ( newGeom->_is_nil() )
{
newSM = createInvalidSubMesh( theNewMesh, geom, name.in() );
shapeMapper.AddInvalid( geom, ObjectToSObject( newSM ));
ok = false;
}
else
{
newSM = theNewMesh->GetSubMesh( newGeom, name.in() );
}
append( theNewSubmeshes, newSM );
if ( newGeom->_is_nil() )
continue; // don't assign hypotheses
}
else
{
newGeom = GEOM::GEOM_Object::_duplicate( theNewGeometry );
geom = srcGeom;
so = ObjectToSObject( theNewMesh );
SetName( so, theMeshName, "Mesh" );
}
// assign hypotheses
SMESH::ListOfHypothesis_var hypList = theSourceMesh->GetHypothesisList( geom );
for ( CORBA::ULong iHyp = 0; iHyp < hypList->length(); ++iHyp )
{
SMESH::SMESH_Hypothesis_var hyp = hypList[ iHyp ];
SMESH_Hypothesis_i* hyp_i = SMESH::DownCast< SMESH_Hypothesis_i* >( hyp );
// get geometry hyp depends on
std::vector< std::string > entryArray;
std::vector< int > subIDArray;
bool dependsOnGeom = hyp_i->getObjectsDependOn( entryArray, subIDArray );
if ( !theToReuseHypotheses || dependsOnGeom )
{
// create a new hypothesis
CORBA::String_var type = hyp->GetName();
CORBA::String_var lib = hyp->GetLibName();
CORBA::String_var data = hyp_i->SaveTo();
if ( data.in()[0] )
{
hyp = CreateHypothesis( type, lib );
hyp_i = SMESH::DownCast< SMESH_Hypothesis_i* >( hyp );
hyp_i->LoadFrom( data.in() );
append( theNewHypotheses, hyp );
}
}
// update geometry hyp depends on
if ( dependsOnGeom )
{
for ( size_t iGeo = 0; iGeo < entryArray.size(); ++iGeo )
{
if ( !entryArray[ iGeo ].empty() )
{
std::string newEntry = shapeMapper.FindNew( entryArray[ iGeo ]);
if ( newEntry.empty() )
{
ok = false;
shapeMapper.AddInvalid( entryArray[ iGeo ], ObjectToSObject( hyp ));
shapeMapper.AddInvalid( entryArray[ iGeo ], so ); // sub-mesh
}
entryArray[ iGeo ] = newEntry;
}
}
for ( size_t iGeo = 0; iGeo < subIDArray.size(); ++iGeo )
{
if ( subIDArray[ iGeo ] > 0 )
{
int newID = shapeMapper.FindNew( subIDArray[ iGeo ]);
if ( newID < 1 )
{
ok = false;
shapeMapper.AddInvalid( subIDArray[ iGeo ], ObjectToSObject( hyp ));
shapeMapper.AddInvalid( subIDArray[ iGeo ], so ); // sub-mesh
}
subIDArray[ iGeo ] = newID;
}
}
if ( !hyp_i->setObjectsDependOn( entryArray, subIDArray ))
ok = false;
}
CORBA::String_var errorText;
theNewMesh->AddHypothesis( newGeom, hyp, errorText.out() );
if ( errorText.in()[0] )
ok = false;
} // loop on hypotheses
} // loop on sub-meshes and mesh
// copy mesh elements, keeping IDs
if ( theToCopyElements && theSourceMesh->NbNodes() > 0 )
{
SMESHDS_Mesh* newMeshDS = newMesh_i->GetImpl().GetMeshDS();
::SMESH_MeshEditor editor( &newMesh_i->GetImpl() );
::SMESH_MeshEditor::ElemFeatures elemData;
SMESH_subMesh* srcMainSM = srcMesh_i->GetImpl().GetSubMeshContaining( 1 );
SMESH_subMeshIteratorPtr srcSMIt = srcMainSM->getDependsOnIterator( /*includeSelf=*/true,
/*vertexLast=*/false);
while ( srcSMIt->more() )
{
SMESH_subMesh* srcSM = srcSMIt->next();
if ( srcSM->IsEmpty() )
continue; // not yet computed
int newID = shapeMapper.FindNewNotChanged( srcSM );
if ( newID < 1 )
continue;
SMESHDS_SubMesh* srcSMDS = srcSM->GetSubMeshDS();
SMDS_NodeIteratorPtr nIt = srcSMDS->GetNodes();
while ( nIt->more() )
{
SMESH_NodeXYZ node( nIt->next() );
const SMDS_MeshNode* newNode = newMeshDS->AddNodeWithID( node.X(), node.Y(), node.Z(),
node->GetID() );
const SMDS_PositionPtr pos = node->GetPosition();
const double* uv = pos->GetParameters();
switch ( pos->GetTypeOfPosition() )
{
case SMDS_TOP_3DSPACE: newMeshDS->SetNodeInVolume( newNode, newID ); break;
case SMDS_TOP_FACE: newMeshDS->SetNodeOnFace ( newNode, newID, uv[0], uv[1] ); break;
case SMDS_TOP_EDGE: newMeshDS->SetNodeOnEdge ( newNode, newID, uv[0] ); break;
case SMDS_TOP_VERTEX: newMeshDS->SetNodeOnVertex( newNode, newID ); break;
default: ;
}
}
SMDS_ElemIteratorPtr eIt = srcSMDS->GetElements();
while( eIt->more() )
{
const SMDS_MeshElement* e = eIt->next();
elemData.Init( e, /*basicOnly=*/false );
elemData.SetID( e->GetID() );
elemData.myNodes.resize( e->NbNodes() );
SMDS_NodeIteratorPtr nnIt = e->nodeIterator();
size_t iN;
for ( iN = 0; nnIt->more(); ++iN )
{
const SMDS_MeshNode* srcNode = nnIt->next();
elemData.myNodes[ iN ] = newMeshDS->FindNode( srcNode->GetID() );
if ( !elemData.myNodes[ iN ])
break;
}
if ( iN == elemData.myNodes.size() )
if ( const SMDS_MeshElement * newElem = editor.AddElement( elemData.myNodes, elemData ))
newMeshDS->SetMeshElementOnShape( newElem, newID );
}
if ( SMESH_subMesh* newSM = newMesh_i->GetImpl().GetSubMeshContaining( newID ))
newSM->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE );
}
}
// treat groups
TStr2StrMap old2newGroupMap;
SALOME::GenericObj_wrap< SMESH::FilterManager > filterMgr = CreateFilterManager();
SMESH::ListOfGroups_var groups = theSourceMesh->GetGroups();
CORBA::ULong nbGroups = groups->length(), nbAddedGroups = 0;
for ( CORBA::ULong i = 0; i < nbGroups + nbAddedGroups; ++i )
{
SMESH::SMESH_Group_var stdlGroup = SMESH::SMESH_Group::_narrow ( groups[ i ]);
SMESH::SMESH_GroupOnGeom_var geomGroup = SMESH::SMESH_GroupOnGeom::_narrow ( groups[ i ]);
SMESH::SMESH_GroupOnFilter_var fltrGroup = SMESH::SMESH_GroupOnFilter::_narrow( groups[ i ]);
CORBA::String_var name = groups[ i ]->GetName();
SMESH::ElementType elemType = groups[ i ]->GetType();
SMESH::SMESH_GroupBase_var newGroup;
if ( !stdlGroup->_is_nil() )
{
if ( theToCopyElements )
{
SMESH::long_array_var elemIDs = stdlGroup->GetIDs();
stdlGroup = theNewMesh->CreateGroup( elemType, name );
stdlGroup->Add( elemIDs );
newGroup = SMESH::SMESH_GroupBase::_narrow( stdlGroup );
}
}
else if ( !geomGroup->_is_nil() )
{
GEOM::GEOM_Object_var geom = geomGroup->GetShape();
GEOM::GEOM_Object_var newGeom = shapeMapper.FindNew( geom );
if ( newGeom->_is_nil() )
{
newGroup = theNewMesh->CreateGroup( elemType, name ); // just to notify the user
shapeMapper.AddInvalid( geom, ObjectToSObject( newGroup ));
ok = false;
}
else
{
newGroup = theNewMesh->CreateGroupFromGEOM( elemType, name, newGeom );
}
}
else if ( !fltrGroup->_is_nil() )
{
// replace geometry in a filter
SMESH::Filter_var filter = fltrGroup->GetFilter();
SMESH::Filter::Criteria_var criteria;
filter->GetCriteria( criteria.out() );
bool isMissingGroup = false;
std::vector< std::string > badEntries;
for ( CORBA::ULong iCr = 0; iCr < criteria->length(); ++iCr )
{
const char* thresholdID = criteria[ iCr ].ThresholdID.in();
switch ( criteria[ iCr ].Type )
{
case SMESH::FT_BelongToMeshGroup:
{
SALOME::GenericObj_wrap< SMESH::BelongToMeshGroup > btgg = filterMgr->CreateBelongToMeshGroup();
btgg->SetGroupID( thresholdID );
SMESH::SMESH_GroupBase_ptr refGroup = btgg->GetGroup();
SALOMEDS::SObject_wrap refGroupSO = ObjectToSObject( refGroup );
if ( refGroupSO->_is_nil() )
break;
CORBA::String_var refID = refGroupSO->GetID();
TStr2StrMap::iterator o2nID = old2newGroupMap.find( refID.in() );
if ( o2nID == old2newGroupMap.end() )
{
isMissingGroup = true; // corresponding new group not yet created
break;
}
criteria[ iCr ].ThresholdID = o2nID->second.c_str();
if ( o2nID->second.empty() ) // new referred group is invalid
badEntries.push_back( refID.in() );
break;
}
case SMESH::FT_BelongToGeom:
case SMESH::FT_BelongToPlane:
case SMESH::FT_BelongToCylinder:
case SMESH::FT_BelongToGenSurface:
case SMESH::FT_LyingOnGeom:
{
std::string newID = shapeMapper.FindNew( thresholdID );
criteria[ iCr ].ThresholdID = newID.c_str();
if ( newID.empty() )
badEntries.push_back( thresholdID );
break;
}
case SMESH::FT_ConnectedElements:
{
if ( thresholdID && thresholdID[0] )
{
std::string newID = shapeMapper.FindNew( thresholdID );
criteria[ iCr ].ThresholdID = newID.c_str();
if ( newID.empty() )
badEntries.push_back( thresholdID );
}
break;
}
default:;
}
} // loop on criteria
if ( isMissingGroup && i < nbGroups )
{
// to treat the group again
append( groups, SMESH::SMESH_GroupBase::_duplicate( groups[ i ]));
++nbAddedGroups;
continue;
}
SMESH::Filter_var newFilter = filterMgr->CreateFilter();
newFilter->SetCriteria( criteria );
newGroup = theNewMesh->CreateGroupFromFilter( elemType, name, newFilter );
newFilter->UnRegister();
SALOMEDS::SObject_wrap newSO = ObjectToSObject( newGroup );
for ( size_t iEnt = 0; iEnt < badEntries.size(); ++iEnt )
shapeMapper.AddInvalid( badEntries[ iEnt ], newSO );
if ( isMissingGroup ) // all groups treated but a referred groups still not found
{
invalidSObjects.push_back( ObjectToSObject( newGroup ));
ok = false;
}
if ( !badEntries.empty() )
ok = false;
} // treat a group on filter
append( theNewGroups, newGroup );
// fill old2newGroupMap
SALOMEDS::SObject_wrap srcSO = ObjectToSObject( groups[i] );
SALOMEDS::SObject_wrap newSO = ObjectToSObject( newGroup );
if ( !srcSO->_is_nil() )
{
CORBA::String_var srcID, newID;
srcID = srcSO->GetID();
if ( !newSO->_is_nil() )
newID = newSO->GetID();
old2newGroupMap.insert( std::make_pair( std::string( srcID.in() ),
std::string( newID.in() )));
}
if ( newGroup->_is_nil() )
ok = false;
} // loop on groups
// set mesh name
SALOMEDS::SObject_wrap soNew = ObjectToSObject( theNewMesh );
SALOMEDS::SObject_wrap soOld = ObjectToSObject( theSourceMesh );
CORBA::String_var oldName = soOld->GetName();
SetName( soNew, oldName.in(), "Mesh" );
// mark invalid objects
shapeMapper.GetInvalid( theInvalidEntries, invalidSObjects );
for ( size_t i = 0; i < invalidSObjects.size(); ++i )
highLightInvalid( invalidSObjects[i].in(), true );
pyDump << "ok, "
<< theNewMesh << ", "
<< theNewGroups << ", "
<< *theNewSubmeshes.ptr() << ", "
<< *theNewHypotheses.ptr() << ", "
<< "invalidEntries = " << this << ".CopyMeshWithGeom( "
<< theSourceMesh << ", "
<< theNewGeometry << ", "
<< "'" << theMeshName << "', "
<< theToCopyGroups << ", "
<< theToReuseHypotheses << ", "
<< theToCopyElements << " )";
SMESH_CATCH( SMESH::throwCorbaException );
return ok;
}
//================================================================================
/*!
* \brief Get version of MED format being used.

26
src/SMESH_I/SMESH_Gen_i.hxx
View File

@ -246,7 +246,22 @@ public:
SMESH::SMESH_Mesh_ptr CopyMesh(SMESH::SMESH_IDSource_ptr meshPart,
const char* meshName,
CORBA::Boolean toCopyGroups,
CORBA::Boolean toKeepIDs);
CORBA::Boolean toKeepIDs)
throw ( SALOME::SALOME_Exception );
// Create a mesh by copying definitions of another mesh to a given geometry
CORBA::Boolean CopyMeshWithGeom( SMESH::SMESH_Mesh_ptr sourceMesh,
GEOM::GEOM_Object_ptr newGeometry,
const char* meshName,
CORBA::Boolean toCopyGroups,
CORBA::Boolean toReuseHypotheses,
CORBA::Boolean toCopyElements,
SMESH::SMESH_Mesh_out newMesh,
SMESH::ListOfGroups_out newGroups,
SMESH::submesh_array_out newSubmeshes,
SMESH::ListOfHypothesis_out newHypotheses,
SMESH::string_array_out invalidEntries)
throw ( SALOME::SALOME_Exception );
// Compute mesh on a shape
CORBA::Boolean Compute( SMESH::SMESH_Mesh_ptr theMesh,
@ -504,6 +519,7 @@ public:
GEOM::GEOM_Object_ptr theShapeObject,
const char* theName = 0);
void UpdateIcons(SMESH::SMESH_Mesh_ptr theMesh);
void HighLightInvalid(CORBA::Object_ptr theObject, bool isInvalid);
bool AddHypothesisToShape(SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShapeObject,
SMESH::SMESH_Hypothesis_ptr theHyp);
@ -608,6 +624,14 @@ private:
SMESH::SMESH_Mesh_ptr createMesh()
throw ( SALOME::SALOME_Exception );
// Create a sub-mesh on a geometry that is not a sub-shape of the main shape
// for the case where a valid sub-shape not found by CopyMeshWithGeom()
SMESH::SMESH_subMesh_ptr createInvalidSubMesh( SMESH::SMESH_Mesh_ptr mesh,
GEOM::GEOM_Object_ptr strangerGeom,
const char* name );
void highLightInvalid( SALOMEDS::SObject_ptr theSObject, bool isInvalid );
static void loadGeomData( SALOMEDS::SComponent_ptr theCompRoot );
SMESH::mesh_array* CreateMeshesFromMEDorSAUV( const char* theFileName,

116
src/SMESH_I/SMESH_Gen_i_1.cxx
View File

@ -452,6 +452,9 @@ static void addReference (SALOMEDS::SObject_ptr theSObject,
aStudyBuilder->Addreference( aReferenceSO, aToObjSO );
// make the reference visible (invisible ref is created by createInvalidSubMesh())
aStudyBuilder->RemoveAttribute( aReferenceSO, "AttributeDrawable" );
// add reference to the use case tree
// (to support tree representation customization and drag-n-drop)
SALOMEDS::UseCaseBuilder_wrap useCaseBuilder = aStudy->GetUseCaseBuilder();
@ -689,6 +692,8 @@ SALOMEDS::SObject_ptr SMESH_Gen_i::PublishSubMesh (SMESH::SMESH_Mesh_ptr theM
if ( theMesh->_is_nil() || theSubMesh->_is_nil() || theShapeObject->_is_nil() )
return SALOMEDS::SObject::_nil();
std::string newName( theName ? theName : "" );
SALOMEDS::SObject_wrap aSubMeshSO = ObjectToSObject( theSubMesh );
if ( aSubMeshSO->_is_nil() )
{
@ -740,15 +745,37 @@ SALOMEDS::SObject_ptr SMESH_Gen_i::PublishSubMesh (SMESH::SMESH_Mesh_ptr theM
SetName( aRootSO, aRootName );
// Add new submesh to corresponding sub-tree
// Add new sub-mesh to corresponding sub-tree
int tag = 0; // to use a new SObject
if ( theName && theName[0] == '0' )
{
// theName can be an entry of an invalid sub-mesh which theSubMesh should replace
SALOMEDS::SObject_wrap aSObj = getStudyServant()->FindObjectID( theName );
if ( aSObj )
{
CORBA::String_var oldName = aSObj->GetName();
newName = oldName.in();
SALOMEDS::SObject_wrap aRootSO2 = aSObj->GetFather();
if ( aRootSO->Tag() == aRootSO2->Tag() ) // same parent
tag = aSObj->Tag(); // to use the same SObject
else
{
CORBA::Object_var anObj = SObjectToObject( aSObj );
SMESH::SMESH_subMesh_var sm = SMESH::SMESH_subMesh::_narrow( anObj );
theMesh->RemoveSubMesh( sm );
}
}
}
SMESH::array_of_ElementType_var elemTypes = theSubMesh->GetTypes();
const int isEmpty = ( elemTypes->length() == 0 );
const char* pm[2] = { "ICON_SMESH_TREE_MESH", "ICON_SMESH_TREE_MESH_WARN" };
aSubMeshSO = publish ( theSubMesh, aRootSO, 0, pm[isEmpty] );
aSubMeshSO = publish ( theSubMesh, aRootSO, tag, pm[isEmpty] );
if ( aSubMeshSO->_is_nil() )
return aSubMeshSO._retn();
highLightInvalid( aSubMeshSO, false ); // now it is valid
}
SetName( aSubMeshSO, theName, "SubMesh" );
SetName( aSubMeshSO, newName.c_str(), "SubMesh" );
// Add reference to theShapeObject
@ -757,7 +784,8 @@ SALOMEDS::SObject_ptr SMESH_Gen_i::PublishSubMesh (SMESH::SMESH_Mesh_ptr theM
// Publish hypothesis
SMESH::ListOfHypothesis_var hypList = theMesh->GetHypothesisList( theShapeObject );
for ( CORBA::ULong i = 0; i < hypList->length(); i++ ) {
for ( CORBA::ULong i = 0; i < hypList->length(); i++ )
{
SMESH::SMESH_Hypothesis_var aHyp = SMESH::SMESH_Hypothesis::_narrow( hypList[ i ]);
SALOMEDS::SObject_wrap so = PublishHypothesis( aHyp );
AddHypothesisToShape( theMesh, theShapeObject, aHyp );
@ -965,6 +993,42 @@ void SMESH_Gen_i::UpdateIcons( SMESH::SMESH_Mesh_ptr theMesh )
}
}
//=======================================================================
//function : HighLightInvalid
//purpose : change font color of a object in the Object Browser
//=======================================================================
void SMESH_Gen_i::HighLightInvalid( CORBA::Object_ptr theObject, bool isInvalid )
{
SALOMEDS::SObject_wrap so = ObjectToSObject(theObject);
highLightInvalid( so.in(), isInvalid );
}
//=======================================================================
//function : highLightInvalid
//purpose : change font color of a object in the Object Browser
//=======================================================================
void SMESH_Gen_i::highLightInvalid( SALOMEDS::SObject_ptr theSObject, bool isInvalid )
{
if ( !theSObject->_is_nil() )
{
SALOMEDS::StudyBuilder_var studyBuilder = getStudyServant()->NewBuilder();
if ( isInvalid )
{
SALOMEDS::Color red = { 178,34,34 }; // to differ from reference color
SALOMEDS::GenericAttribute_wrap attr =
studyBuilder->FindOrCreateAttribute( theSObject, "AttributeTextColor" );
SALOMEDS::AttributeTextColor_wrap colorAttr = attr;
colorAttr->SetTextColor( red );
}
else
{
studyBuilder->RemoveAttribute( theSObject, "AttributeTextColor" );
}
}
}
//=======================================================================
//function : GetMeshOrSubmeshByShape
//purpose :
@ -1339,6 +1403,50 @@ char* SMESH_Gen_i::GetParameters(CORBA::Object_ptr theObject)
return aResult._retn();
}
//================================================================================
/*!
* \brief Create a sub-mesh on a geometry that is not a sub-shape of the main shape
* for the case where a valid sub-shape not found by CopyMeshWithGeom().
* The invalid sub-mesh has GetId() < 0.
*/
//================================================================================
SMESH::SMESH_subMesh_ptr
SMESH_Gen_i::createInvalidSubMesh(SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theStrangerGeom,
const char* theName)
{
SMESH::SMESH_subMesh_var subMesh;
try
{
SMESH_Mesh_i* mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( theMesh );
subMesh = mesh_i->createSubMesh( theStrangerGeom );
if ( !subMesh->_is_nil() && CanPublishInStudy( subMesh ))
{
SALOMEDS::SObject_wrap so = PublishSubMesh( theMesh, subMesh, theStrangerGeom, theName );
// hide a reference to geometry
if ( !so->_is_nil() )
{
SALOMEDS::SObject_wrap refSO;
if ( so->FindSubObject( GetRefOnShapeTag(), refSO.inout() ))
{
SALOMEDS::StudyBuilder_var studyBuilder = getStudyServant()->NewBuilder();
SALOMEDS::GenericAttribute_wrap attr =
studyBuilder->FindOrCreateAttribute( refSO, "AttributeDrawable" );
SALOMEDS::AttributeDrawable_wrap ga = attr;
ga->SetDrawable( false );
}
}
}
}
catch (...) {
}
return subMesh._retn();
}
// ==============

8
src/SMESH_I/SMESH_Group_i.cxx
View File

@ -838,7 +838,13 @@ void SMESH_GroupOnFilter_i::SetFilter(SMESH::Filter_ptr theFilter)
Modified(); // notify dependent Filter with FT_BelongToMeshGroup criterion
}
TPythonDump()<< SMESH::SMESH_GroupOnFilter_var(_this()) <<".SetFilter( "<<theFilter<<" )";
SMESH::SMESH_GroupOnFilter_var me = _this();
// mark the group valid after edition
GetMeshServant()->GetGen()->HighLightInvalid( me, false );
TPythonDump()<< me <<".SetFilter( "<< theFilter <<" )";
}
//================================================================================

14
src/SMESH_I/SMESH_Hypothesis_i.hxx
View File

@ -40,6 +40,7 @@
#include <map>
#include <string>
#include <vector>
class TCollection_AsciiString;
@ -97,7 +98,18 @@ public:
// Persistence
virtual char* SaveTo();
virtual void LoadFrom( const char* theStream );
virtual void UpdateAsMeshesRestored(); // for hyps needing full data restored
virtual void UpdateAsMeshesRestored(); // for hyps needing full study data restored
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const = 0;
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) = 0;
protected:

45
src/SMESH_I/SMESH_Mesh_i.cxx
View File

@ -2460,9 +2460,25 @@ SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::createSubMesh( GEOM::GEOM_Object_ptr theS
if(MYDEBUG) MESSAGE( "createSubMesh" );
TopoDS_Shape myLocSubShape = _gen_i->GeomObjectToShape(theSubShapeObject);
::SMESH_subMesh * mySubMesh = _impl->GetSubMesh(myLocSubShape);
const int subMeshId = mySubMesh->GetId();
int subMeshId = 0;
SMESH_subMesh_i * subMeshServant;
if ( mySubMesh )
{
subMeshId = mySubMesh->GetId();
subMeshServant = new SMESH_subMesh_i(myPOA, _gen_i, this, subMeshId);
}
else // "invalid sub-mesh"
{
// The invalid sub-mesh is created for the case where a valid sub-shape not found
// by SMESH_Gen_i::CopyMeshWithGeom(). The invalid sub-mesh has GetId() < 0.
if ( _mapSubMesh.empty() )
subMeshId = -1;
else
subMeshId = _mapSubMesh.begin()->first - 1;
subMeshServant = new SMESH_Invalid_subMesh_i(myPOA, _gen_i, this, subMeshId, theSubShapeObject);
}
SMESH_subMesh_i * subMeshServant = new SMESH_subMesh_i(myPOA, _gen_i, this, subMeshId);
SMESH::SMESH_subMesh_var subMesh = subMeshServant->_this();
_mapSubMesh [subMeshId] = mySubMesh;
@ -2477,6 +2493,7 @@ SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::createSubMesh( GEOM::GEOM_Object_ptr theS
else { nextId = 0; } // avoid "unused variable" warning
// to track changes of GEOM groups
if ( subMeshId > 0 )
addGeomGroupData( theSubShapeObject, subMesh );
return subMesh._retn();
@ -2513,7 +2530,8 @@ bool SMESH_Mesh_i::removeSubMesh (SMESH::SMESH_subMesh_ptr theSubMesh,
if ( theSubShapeObject->_is_nil() ) // not published shape (IPAL13617)
{
if ( _mapSubMesh.find( subMeshId ) != _mapSubMesh.end())
if ( _mapSubMesh.find( subMeshId ) != _mapSubMesh.end() &&
_mapSubMesh[ subMeshId ])
{
TopoDS_Shape S = _mapSubMesh[ subMeshId ]->GetSubShape();
if ( !S.IsNull() )
@ -2735,7 +2753,7 @@ namespace
SMESH_Mesh_i* _mesh;
TCallUp_i(SMESH_Mesh_i* mesh):_mesh(mesh) {}
virtual void RemoveGroup (const int theGroupID) { _mesh->removeGroup( theGroupID ); }
virtual void HypothesisModified () { _mesh->onHypothesisModified(); }
virtual void HypothesisModified (int theHypID) { _mesh->onHypothesisModified( theHypID ); }
virtual void Load () { _mesh->Load(); }
};
}
@ -2746,13 +2764,30 @@ namespace
*/
//================================================================================
void SMESH_Mesh_i::onHypothesisModified()
void SMESH_Mesh_i::onHypothesisModified(int theHypID)
{
if ( _preMeshInfo )
_preMeshInfo->ForgetOrLoad();
SMESH::SMESH_Mesh_var mesh = _this();
_gen_i->UpdateIcons( mesh );
// mark a hypothesis as valid after edition
SALOMEDS::SComponent_wrap smeshComp = _gen_i->PublishComponent();
SALOMEDS::SObject_wrap hypRoot;
if ( !smeshComp->_is_nil() &&
smeshComp->FindSubObject( _gen_i->GetHypothesisRootTag(), hypRoot.inout() ))
{
SALOMEDS::ChildIterator_wrap anIter = _gen_i->getStudyServant()->NewChildIterator( hypRoot );
for ( ; anIter->More(); anIter->Next() )
{
SALOMEDS::SObject_wrap hypSO = anIter->Value();
CORBA::Object_var obj = _gen_i->SObjectToObject( hypSO );
SMESH::SMESH_Hypothesis_var hyp = SMESH::SMESH_Hypothesis::_narrow( obj );
if ( !hyp->_is_nil() && hyp->GetId() == theHypID )
_gen_i->HighLightInvalid( hyp, false );
}
}
}
//=============================================================================

2
src/SMESH_I/SMESH_Mesh_i.hxx
View File

@ -439,7 +439,7 @@ public:
const std::map<int, SMESH::SMESH_GroupBase_ptr>& getGroups() { return _mapGroups; }
// return existing group objects
void onHypothesisModified();
void onHypothesisModified(int theHypID);
// callback from _impl to forget not loaded mesh data (issue 0021208)
void checkMeshLoaded();

10
src/SMESH_I/SMESH_PythonDump.cxx
View File

@ -540,6 +540,16 @@ namespace SMESH
DumpArray( theList, *this );
return *this;
}
TPythonDump& TPythonDump::operator<<(const SMESH::submesh_array& theList)
{
DumpArray( theList, *this );
return *this;
}
TPythonDump& TPythonDump::operator<<(const SMESH::ListOfHypothesis& theList)
{
DumpArray( theList, *this );
return *this;
}
TPythonDump& TPythonDump::operator<<(const SMESH::CoincidentFreeBorders& theCFB)
{
// dump CoincidentFreeBorders as a list of lists, each enclosed list

6
src/SMESH_I/SMESH_PythonDump.hxx
View File

@ -227,6 +227,12 @@ namespace SMESH
TPythonDump&
operator<<(const SMESH::ListOfIDSources& theList);
TPythonDump&
operator<<(const SMESH::submesh_array& theList);
TPythonDump&
operator<<(const SMESH::ListOfHypothesis& theList);
TPythonDump&
operator<<(const SMESH::CoincidentFreeBorders& theCFB);

29
src/SMESH_I/SMESH_subMesh_i.cxx
View File

@ -96,6 +96,8 @@ typedef list<SMESHDS_SubMesh*> TListOfSubMeshes;
bool getSubMeshes(::SMESH_subMesh* theSubMesh,
TListOfSubMeshes& theSubMeshList)
{
if ( !theSubMesh )
return false; // "invalid sub-mesh" created by SMESH_Gen_i::CopyMeshWithGeom()
size_t size = theSubMeshList.size();
// check all child sub-meshes of one complexity,
@ -582,3 +584,30 @@ SALOMEDS::TMPFile* SMESH_subMesh_i::GetVtkUgStream()
SALOMEDS::TMPFile_var SeqFile;
return SeqFile._retn();
}
//=======================================================================
//function : SMESH_Invalid_subMesh_i
//purpose : constructor of "invalid sub-mesh" created by SMESH_Gen_i::CopyMeshWithGeom()
//=======================================================================
SMESH_Invalid_subMesh_i::SMESH_Invalid_subMesh_i( PortableServer::POA_ptr thePOA,
SMESH_Gen_i* gen_i,
SMESH_Mesh_i* mesh_i,
int localId,
GEOM::GEOM_Object_ptr shape )
: SALOME::GenericObj_i( thePOA ),
SMESH_subMesh_i( thePOA, gen_i, mesh_i, localId )
{
_geom = GEOM::GEOM_Object::_duplicate( shape );
}
//=======================================================================
//function : GetSubShape
//purpose : return geomtry which is not a sub-shape of the main shape
//=======================================================================
GEOM::GEOM_Object_ptr SMESH_Invalid_subMesh_i::GetSubShape()
throw (SALOME::SALOME_Exception)
{
return GEOM::GEOM_Object::_duplicate( _geom );
}

22
src/SMESH_I/SMESH_subMesh_i.hxx
View File

@ -130,4 +130,26 @@ protected:
friend class SMESH_PreMeshInfo;
};
class SMESH_I_EXPORT SMESH_Invalid_subMesh_i:
public virtual POA_SMESH::SMESH_subMesh,
public virtual SALOME::GenericObj_i,
public virtual SMESH_subMesh_i
{
public:
SMESH_Invalid_subMesh_i( PortableServer::POA_ptr thePOA,
SMESH_Gen_i* gen_i,
SMESH_Mesh_i* mesh_i,
int localId,
GEOM::GEOM_Object_ptr shape);
virtual GEOM::GEOM_Object_ptr GetSubShape()
throw (SALOME::SALOME_Exception);
protected:
GEOM::GEOM_Object_var _geom;
};
#endif

39
src/SMESH_SWIG/smeshBuilder.py
View File

@ -782,11 +782,46 @@ class smeshBuilder( SMESH._objref_SMESH_Gen, object ):
an instance of class :class:`Mesh`
"""
if (isinstance( meshPart, Mesh )):
if isinstance( meshPart, Mesh ):
meshPart = meshPart.GetMesh()
mesh = SMESH._objref_SMESH_Gen.CopyMesh( self,meshPart,meshName,toCopyGroups,toKeepIDs )
return Mesh(self, self.geompyD, mesh)
def CopyMeshWithGeom( self, sourceMesh, newGeom, meshName="", toCopyGroups=True,
toReuseHypotheses=True, toCopyElements=True):
"""
Create a mesh by copying a mesh definition (hypotheses and groups) to a new geometry.
It is supposed that the new geometry is a modified geometry of *sourceMesh*.
To facilitate and speed up the operation, consider using
"Set presentation parameters and sub-shapes from arguments" option in
a dialog of geometrical operation used to create the new geometry.
Parameters:
sourceMesh: the mesh to copy definition of.
newGeom: the new geomtry.
meshName: an optional name of the new mesh. If omitted, the mesh name is kept.
toCopyGroups: to create groups in the new mesh.
toReuseHypotheses: to reuse hypotheses of the *sourceMesh*.
toCopyElements: to copy mesh elements present on non-modified sub-shapes of
*sourceMesh*.
Returns:
tuple ( ok, newMesh, newGroups, newSubMeshes, newHypotheses, invalidEntries )
*invalidEntries* are study entries of objects whose
counterparts are not found in the *newGeom*, followed by entries
of mesh sub-objects that are invalid because they depend on a not found
preceeding sub-shape
"""
if isinstance( sourceMesh, Mesh ):
sourceMesh = sourceMesh.GetMesh()
ok, newMesh, newGroups, newSubMeshes, newHypotheses, invalidEntries = \
SMESH._objref_SMESH_Gen.CopyMeshWithGeom( self, sourceMesh, newGeom, meshName,
toCopyGroups,
toReuseHypotheses,
toCopyElements)
return ( ok, Mesh(self, self.geompyD, newMesh),
newGroups, newSubMeshes, newHypotheses, invalidEntries )
def GetSubShapesId( self, theMainObject, theListOfSubObjects ):
"""
Return IDs of sub-shapes
@ -6156,7 +6191,7 @@ class Mesh(metaclass = MeshMeta):
Fill with 2D elements a hole defined by a SMESH.FreeBorder.
Parameters:
FreeBorder: either a SMESH.FreeBorder or a list on node IDs. These nodes
holeNodes: either a SMESH.FreeBorder or a list on node IDs. These nodes
must describe all sequential nodes of the hole border. The first and the last
nodes must be the same. Use :meth:`FindFreeBorders` to get nodes of holes.
groupName (string): name of a group to add new faces

39
src/StdMeshers/StdMeshers_Arithmetic1D.cxx
View File

@ -49,7 +49,7 @@ using namespace std;
//=============================================================================
StdMeshers_Arithmetic1D::StdMeshers_Arithmetic1D(int hypId, SMESH_Gen * gen)
:SMESH_Hypothesis(hypId, gen)
:StdMeshers_Reversible1D(hypId, gen)
{
_begLength = 1.;
_endLength = 10.;
@ -105,21 +105,6 @@ double StdMeshers_Arithmetic1D::GetLength(bool isStartLength) const
*/
//=============================================================================
void StdMeshers_Arithmetic1D::SetReversedEdges( std::vector<int>& ids )
{
if ( ids != _edgeIDs ) {
_edgeIDs = ids;
NotifySubMeshesHypothesisModification();
}
}
//=============================================================================
/*!
*
*/
//=============================================================================
ostream & StdMeshers_Arithmetic1D::SaveTo(ostream & save)
{
int listSize = _edgeIDs.size();
@ -165,28 +150,6 @@ istream & StdMeshers_Arithmetic1D::LoadFrom(istream & load)
return load;
}
//=============================================================================
/*!
*
*/
//=============================================================================
ostream & operator <<(ostream & save, StdMeshers_Arithmetic1D & hyp)
{
return hyp.SaveTo( save );
}
//=============================================================================
/*!
*
*/
//=============================================================================
istream & operator >>(istream & load, StdMeshers_Arithmetic1D & hyp)
{
return hyp.LoadFrom( load );
}
//================================================================================
/*!
* \brief Initialize start and end length by the mesh built on the geometry

18
src/StdMeshers/StdMeshers_Arithmetic1D.hxx
View File

@ -32,13 +32,11 @@
#include "SMESH_StdMeshers.hxx"
#include "StdMeshers_Reversible1D.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include <vector>
class STDMESHERS_EXPORT StdMeshers_Arithmetic1D:
public SMESH_Hypothesis
class STDMESHERS_EXPORT StdMeshers_Arithmetic1D: public StdMeshers_Reversible1D
{
public:
StdMeshers_Arithmetic1D(int hypId, SMESH_Gen* gen);
@ -48,18 +46,8 @@ public:
double GetLength(bool isStartLength) const;
void SetReversedEdges( std::vector<int>& ids);
void SetObjectEntry( const char* entry ) { _objEntry = entry; }
const char* GetObjectEntry() { return _objEntry.c_str(); }
const std::vector<int>& GetReversedEdges() const { return _edgeIDs; }
virtual std::ostream & SaveTo(std::ostream & save);
virtual std::istream & LoadFrom(std::istream & load);
friend std::ostream& operator << (std::ostream & save, StdMeshers_Arithmetic1D & hyp);
friend std::istream& operator >> (std::istream & load, StdMeshers_Arithmetic1D & hyp);
/*!
* \brief Initialize start and end length by the mesh built on the geometry
@ -77,8 +65,6 @@ public:
protected:
double _begLength, _endLength;
std::vector<int> _edgeIDs;
std::string _objEntry;
};
#endif

26
src/StdMeshers/StdMeshers_FixedPoints1D.cxx
View File

@ -35,9 +35,8 @@ using namespace std;
*/
//=============================================================================
StdMeshers_FixedPoints1D::StdMeshers_FixedPoints1D(int hypId,
SMESH_Gen * gen)
:SMESH_Hypothesis(hypId, gen)
StdMeshers_FixedPoints1D::StdMeshers_FixedPoints1D(int hypId, SMESH_Gen * gen)
:StdMeshers_Reversible1D(hypId, gen)
{
_name = "FixedPoints1D";
_param_algo_dim = 1;
@ -81,27 +80,6 @@ void StdMeshers_FixedPoints1D::SetNbSegments(std::vector<int>& listNbSeg)
NotifySubMeshesHypothesisModification();
}
//=============================================================================
/*!
*
*/
//=============================================================================
void StdMeshers_FixedPoints1D::SetReversedEdges( std::vector<int>& ids )
{
if ( ids != _edgeIDs ) {
_edgeIDs = ids;
NotifySubMeshesHypothesisModification();
}
}
//=============================================================================
/*!
*
*/
//=============================================================================
ostream & StdMeshers_FixedPoints1D::SaveTo(ostream & save)
{
int listSize = _params.size();

14
src/StdMeshers/StdMeshers_FixedPoints1D.hxx
View File

@ -29,13 +29,13 @@
#include "SMESH_StdMeshers.hxx"
#include "StdMeshers_Reversible1D.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include <vector>
class STDMESHERS_EXPORT StdMeshers_FixedPoints1D:
public SMESH_Hypothesis
class STDMESHERS_EXPORT StdMeshers_FixedPoints1D: public StdMeshers_Reversible1D
{
public:
StdMeshers_FixedPoints1D(int hypId, SMESH_Gen* gen);
@ -51,14 +51,6 @@ public:
const std::vector<int>& GetNbSegments() const { return _nbsegs; }
void SetReversedEdges( std::vector<int>& ids);
void SetObjectEntry( const char* entry ) { _objEntry = entry; }
const char* GetObjectEntry() { return _objEntry.c_str(); }
const std::vector<int>& GetReversedEdges() const { return _edgeIDs; }
virtual std::ostream & SaveTo(std::ostream & save);
virtual std::istream & LoadFrom(std::istream & load);
@ -79,8 +71,6 @@ public:
protected:
std::vector<double> _params;
std::vector<int> _nbsegs;
std::vector<int> _edgeIDs;
std::string _objEntry;
};
#endif

18
src/StdMeshers/StdMeshers_NumberOfSegments.cxx
View File

@ -60,7 +60,7 @@ const double PRECISION = 1e-7;
StdMeshers_NumberOfSegments::StdMeshers_NumberOfSegments(int hypId,
SMESH_Gen * gen)
: SMESH_Hypothesis(hypId, gen),
: StdMeshers_Reversible1D(hypId, gen),
_numberOfSegments(15),//issue 19923
_distrType(DT_Regular),
_scaleFactor(1.),
@ -721,19 +721,3 @@ bool StdMeshers_NumberOfSegments::SetParametersByDefaults(const TDefaults& dflt
{
return (_numberOfSegments = dflts._nbSegments );
}
//=============================================================================
/*!
*
*/
//=============================================================================
void StdMeshers_NumberOfSegments::SetReversedEdges( std::vector<int>& ids )
{
if ( ids != _edgeIDs ) {
_edgeIDs = ids;
NotifySubMeshesHypothesisModification();
}
}

17
src/StdMeshers/StdMeshers_NumberOfSegments.hxx
View File

@ -29,10 +29,10 @@
#ifndef _SMESH_NUMBEROFSEGMENTS_HXX_
#define _SMESH_NUMBEROFSEGMENTS_HXX_
#include "SMESH_StdMeshers.hxx"
#include "StdMeshers_Reversible1D.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include <vector>
/*!
@ -41,8 +41,7 @@
* It provides parameters for subdivision an edge by various
* distribution types, considering the given number of resulting segments
*/
class STDMESHERS_EXPORT StdMeshers_NumberOfSegments:
public SMESH_Hypothesis
class STDMESHERS_EXPORT StdMeshers_NumberOfSegments: public StdMeshers_Reversible1D
{
public:
StdMeshers_NumberOfSegments(int hypId, SMESH_Gen* gen);
@ -171,14 +170,6 @@ public:
int ConversionMode() const
throw (SALOME_Exception);
void SetReversedEdges( std::vector<int>& ids);
void SetObjectEntry( const char* entry ) { _objEntry = entry; }
const char* GetObjectEntry() { return _objEntry.c_str(); }
const std::vector<int>& GetReversedEdges() const { return _edgeIDs; }
/*!
* \brief Initialize number of segments by the mesh built on the geometry
* \param theMesh - the built mesh
@ -205,8 +196,6 @@ protected:
std::vector<double> _table, _distr; //!< the table for DT_TabFunc, a sequence of pairs of numbers
std::string _func; //!< the expression of the function for DT_ExprFunc
int _convMode; //!< flag of conversion mode: 0=exponent, 1=cut negative
std::vector<int> _edgeIDs; //!< list of reversed edges ids
std::string _objEntry; //!< Entry of the main object to reverse edges
};
#endif

2
src/StdMeshers/StdMeshers_QuadrangleParams.hxx
View File

@ -51,7 +51,7 @@ public:
int GetTriaVertex() const { return _triaVertexID; }
void SetObjectEntry (const char* entry) { _objEntry = entry; }
const char* GetObjectEntry() { return _objEntry.c_str(); }
const char* GetObjectEntry() const { return _objEntry.c_str(); }
void SetQuadType (StdMeshers_QuadType type);
StdMeshers_QuadType GetQuadType() const { return _quadType; }

2
src/StdMeshers/StdMeshers_Reversible1D.hxx
View File

@ -44,7 +44,7 @@ public:
void SetObjectEntry( const char* entry ) { _objEntry = entry; }
const char* GetObjectEntry() { return _objEntry.c_str(); }
const char* GetObjectEntry() const { return _objEntry.c_str(); }
const std::vector<int>& GetReversedEdges() const { return _edgeIDs; }

42
src/StdMeshers/StdMeshers_StartEndLength.cxx
View File

@ -47,9 +47,8 @@ using namespace std;
*/
//=============================================================================
StdMeshers_StartEndLength::StdMeshers_StartEndLength(int hypId,
SMESH_Gen * gen)
:SMESH_Hypothesis(hypId, gen)
StdMeshers_StartEndLength::StdMeshers_StartEndLength( int hypId, SMESH_Gen* gen )
:StdMeshers_Reversible1D(hypId, gen)
{
_begLength = 1.;
_endLength = 10.;
@ -105,21 +104,6 @@ double StdMeshers_StartEndLength::GetLength(bool isStartLength) const
*/
//=============================================================================
void StdMeshers_StartEndLength::SetReversedEdges( std::vector<int>& ids )
{
if ( ids != _edgeIDs ) {
_edgeIDs = ids;
NotifySubMeshesHypothesisModification();
}
}
//=============================================================================
/*!
*
*/
//=============================================================================
ostream & StdMeshers_StartEndLength::SaveTo(ostream & save)
{
int listSize = _edgeIDs.size();
@ -166,28 +150,6 @@ istream & StdMeshers_StartEndLength::LoadFrom(istream & load)
return load;
}
//=============================================================================
/*!
*
*/
//=============================================================================
ostream & operator <<(ostream & save, StdMeshers_StartEndLength & hyp)
{
return hyp.SaveTo( save );
}
//=============================================================================
/*!
*
*/
//=============================================================================
istream & operator >>(istream & load, StdMeshers_StartEndLength & hyp)
{
return hyp.LoadFrom( load );
}
//================================================================================
/*!
* \brief Initialize start and end length by the mesh built on the geometry

16
src/StdMeshers/StdMeshers_StartEndLength.hxx
View File

@ -29,12 +29,13 @@
#include "SMESH_StdMeshers.hxx"
#include "StdMeshers_Reversible1D.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include <vector>
class STDMESHERS_EXPORT StdMeshers_StartEndLength:public SMESH_Hypothesis
class STDMESHERS_EXPORT StdMeshers_StartEndLength: public StdMeshers_Reversible1D
{
public:
StdMeshers_StartEndLength(int hypId, SMESH_Gen * gen);
@ -44,19 +45,8 @@ class STDMESHERS_EXPORT StdMeshers_StartEndLength:public SMESH_Hypothesis
double GetLength(bool isStartLength) const;
void SetReversedEdges( std::vector<int>& ids);
const std::vector<int>& GetReversedEdges() const { return _edgeIDs; }
void SetObjectEntry( const char* entry ) { _objEntry = entry; }
const char* GetObjectEntry() { return _objEntry.c_str(); }
virtual std::ostream & SaveTo(std::ostream & save);
virtual std::istream & LoadFrom(std::istream & load);
friend std::ostream & operator <<(std::ostream & save, StdMeshers_StartEndLength & hyp);
friend std::istream & operator >>(std::istream & load, StdMeshers_StartEndLength & hyp);
/*!
* \brief Initialize start and end length by the mesh built on the geometry
@ -74,8 +64,6 @@ class STDMESHERS_EXPORT StdMeshers_StartEndLength:public SMESH_Hypothesis
protected:
double _begLength, _endLength;
std::vector<int> _edgeIDs;
std::string _objEntry;
};
#endif

6
src/StdMeshers_I/StdMeshers_Adaptive1D_i.hxx
View File

@ -83,6 +83,12 @@ class STDMESHERS_I_EXPORT StdMeshers_Adaptive1D_i:
* Verify whether hypothesis supports given entity type (see SMESH::Dimension enumeration)
*/
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const { return false; }
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) { return true; }
};
#endif

122
src/StdMeshers_I/StdMeshers_Arithmetic1D_i.cxx
View File

@ -48,7 +48,8 @@ using namespace std;
StdMeshers_Arithmetic1D_i::StdMeshers_Arithmetic1D_i( PortableServer::POA_ptr thePOA,
::SMESH_Gen* theGenImpl )
: SALOME::GenericObj_i( thePOA ),
SMESH_Hypothesis_i( thePOA )
SMESH_Hypothesis_i( thePOA ),
StdMeshers_Reversible1D_i( this )
{
myBaseImpl = new ::StdMeshers_Arithmetic1D( theGenImpl->GetANewId(),
theGenImpl );
@ -131,98 +132,6 @@ CORBA::Double StdMeshers_Arithmetic1D_i::GetLength( CORBA::Boolean theIsStart)
return this->GetImpl()->GetLength( theIsStart );
}
//=============================================================================
/*!
* StdMeshers_Arithmetic1D_i::SetReversedEdges
*
* Set edges to reverse
*/
//=============================================================================
void StdMeshers_Arithmetic1D_i::SetReversedEdges( const SMESH::long_array& theIds )
{
ASSERT( myBaseImpl );
try {
std::vector<int> ids( theIds.length() );
CORBA::Long iEnd = theIds.length();
for ( CORBA::Long i = 0; i < iEnd; i++ )
ids[ i ] = theIds[ i ];
this->GetImpl()->SetReversedEdges( ids );
}
catch ( SALOME_Exception& S_ex ) {
THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
SALOME::BAD_PARAM );
}
// Update Python script
SMESH::TPythonDump() << _this() << ".SetReversedEdges( " << theIds << " )";
}
//=============================================================================
/*!
* StdMeshers_Arithmetic1D_i::SetObjectEntry
*
* Set the Entry for the Main Object
*/
//=============================================================================
void StdMeshers_Arithmetic1D_i::SetObjectEntry( const char* theEntry )
{
ASSERT( myBaseImpl );
string entry(theEntry); // actually needed as theEntry is spoiled by moment of dumping
try {
this->GetImpl()->SetObjectEntry( entry.c_str() );
// Update Python script
SMESH::TPythonDump() << _this() << ".SetObjectEntry( \"" << entry.c_str() << "\" )";
}
catch ( SALOME_Exception& S_ex ) {
THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),SALOME::BAD_PARAM );
}
}
//=============================================================================
/*!
* StdMeshers_Arithmetic1D_i::GetObjectEntry
*
* Set the Entry for the Main Object
*/
//=============================================================================
char* StdMeshers_Arithmetic1D_i::GetObjectEntry()
{
ASSERT( myBaseImpl );
const char* entry;
try {
entry = this->GetImpl()->GetObjectEntry();
}
catch ( SALOME_Exception& S_ex ) {
THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
SALOME::BAD_PARAM );
}
return CORBA::string_dup( entry );
}
//=============================================================================
/*!
* StdMeshers_Arithmetic1D_i::GetReversedEdges
*
* Get reversed edges
*/
//=============================================================================
SMESH::long_array* StdMeshers_Arithmetic1D_i::GetReversedEdges()
{
ASSERT( myBaseImpl );
SMESH::long_array_var anArray = new SMESH::long_array;
std::vector<int> ids = this->GetImpl()->GetReversedEdges();
anArray->length( ids.size() );
for ( CORBA::ULong i = 0; i < ids.size(); i++)
anArray [ i ] = ids [ i ];
return anArray._retn();
}
//=============================================================================
/*!
* StdMeshers_Arithmetic1D_i::GetImpl
@ -261,3 +170,30 @@ std::string StdMeshers_Arithmetic1D_i::getMethodOfParameter(const int paramIndex
{
return paramIndex == 0 ? "SetStartLength" : "SetEndLength";
}
//================================================================================
/*!
* \brief Return geometry this hypothesis depends on. Return false if there is no geometry parameter
*/
//================================================================================
bool
StdMeshers_Arithmetic1D_i::getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const
{
return StdMeshers_Reversible1D_i::getObjectsDependOn( entryArray, subIDArray );
}
//================================================================================
/*!
* \brief Set new geometry instead of that returned by getObjectsDependOn()
*/
//================================================================================
bool
StdMeshers_Arithmetic1D_i::setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray )
{
return StdMeshers_Reversible1D_i::setObjectsDependOn( entryArray, subIDArray );
}

28
src/StdMeshers_I/StdMeshers_Arithmetic1D_i.hxx
View File

@ -33,7 +33,7 @@
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
#include "SMESH_Hypothesis_i.hxx"
#include "StdMeshers_Reversible1D_i.hxx"
#include "StdMeshers_Arithmetic1D.hxx"
// ======================================================
@ -41,7 +41,8 @@
// ======================================================
class STDMESHERS_I_EXPORT StdMeshers_Arithmetic1D_i:
public virtual POA_StdMeshers::StdMeshers_Arithmetic1D,
public virtual SMESH_Hypothesis_i
public virtual SMESH_Hypothesis_i,
public virtual StdMeshers_Reversible1D_i
{
public:
// Constructor
@ -64,24 +65,23 @@ public:
// Get length
CORBA::Double GetLength(CORBA::Boolean theIsStart);
//Set Reversed Edges
void SetReversedEdges( const SMESH::long_array& theIDs);
//Get Reversed Edges
SMESH::long_array* GetReversedEdges();
//Set the Entry of the Object
void SetObjectEntry( const char* theEntry);
//Get Object Entry
char* GetObjectEntry();
// Get implementation
::StdMeshers_Arithmetic1D* GetImpl();
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const;
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray );
protected:
virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const;
};

6
src/StdMeshers_I/StdMeshers_AutomaticLength_i.hxx
View File

@ -66,6 +66,12 @@ public:
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const { return false; }
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) { return true; }
};
#endif

7
src/StdMeshers_I/StdMeshers_CartesianParameters3D_i.hxx
View File

@ -141,6 +141,13 @@ class STDMESHERS_I_EXPORT StdMeshers_CartesianParameters3D_i:
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const { return false; }
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) { return true; }
};
#endif

5
src/StdMeshers_I/StdMeshers_Deflection1D_i.hxx
View File

@ -65,6 +65,11 @@ public:
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const { return false; }
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) { return true; }
protected:
virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const;
};

120
src/StdMeshers_I/StdMeshers_FixedPoints1D_i.cxx
View File

@ -46,7 +46,8 @@ using namespace std;
StdMeshers_FixedPoints1D_i::StdMeshers_FixedPoints1D_i( PortableServer::POA_ptr thePOA,
::SMESH_Gen* theGenImpl )
: SALOME::GenericObj_i( thePOA ),
SMESH_Hypothesis_i( thePOA )
SMESH_Hypothesis_i( thePOA ),
StdMeshers_Reversible1D_i( this )
{
myBaseImpl = new ::StdMeshers_FixedPoints1D(theGenImpl->GetANewId(),
theGenImpl);
@ -156,98 +157,6 @@ SMESH::long_array* StdMeshers_FixedPoints1D_i::GetNbSegments()
return anArray._retn();
}
//=============================================================================
/*!
* StdMeshers_FixedPoints1D_i::SetReversedEdges
*
* Set edges to reverse
*/
//=============================================================================
void StdMeshers_FixedPoints1D_i::SetReversedEdges( const SMESH::long_array& theIds )
{
ASSERT( myBaseImpl );
try {
std::vector<int> ids( theIds.length() );
CORBA::Long iEnd = theIds.length();
for ( CORBA::Long i = 0; i < iEnd; i++ )
ids[ i ] = theIds[ i ];
this->GetImpl()->SetReversedEdges( ids );
}
catch ( SALOME_Exception& S_ex ) {
THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
SALOME::BAD_PARAM );
}
// Update Python script
SMESH::TPythonDump() << _this() << ".SetReversedEdges( " << theIds << " )";
}
//=============================================================================
/*!
* StdMeshers_FixedPoints1D_i::SetObjectEntry
*
* Set the Entry for the Main Object
*/
//=============================================================================
void StdMeshers_FixedPoints1D_i::SetObjectEntry( const char* theEntry )
{
ASSERT( myBaseImpl );
string entry(theEntry); // actually needed as theEntry is spoiled by moment of dumping
try {
this->GetImpl()->SetObjectEntry( entry.c_str() );
// Update Python script
SMESH::TPythonDump() << _this() << ".SetObjectEntry( \"" << entry.c_str() << "\" )";
}
catch ( SALOME_Exception& S_ex ) {
THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),SALOME::BAD_PARAM );
}
}
//=============================================================================
/*!
* StdMeshers_FixedPoints1D_i::GetObjectEntry
*
* Set the Entry for the Main Object
*/
//=============================================================================
char* StdMeshers_FixedPoints1D_i::GetObjectEntry()
{
ASSERT( myBaseImpl );
const char* entry;
try {
entry = this->GetImpl()->GetObjectEntry();
}
catch ( SALOME_Exception& S_ex ) {
THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
SALOME::BAD_PARAM );
}
return CORBA::string_dup( entry );
}
//=============================================================================
/*!
* StdMeshers_FixedPoints1D_i::GetReversedEdges
*
* Get reversed edges
*/
//=============================================================================
SMESH::long_array* StdMeshers_FixedPoints1D_i::GetReversedEdges()
{
ASSERT( myBaseImpl );
SMESH::long_array_var anArray = new SMESH::long_array;
std::vector<int> ids = this->GetImpl()->GetReversedEdges();
anArray->length( ids.size() );
for ( CORBA::ULong i = 0; i < ids.size(); i++)
anArray [ i ] = ids [ i ];
return anArray._retn();
}
//=============================================================================
/*!
* StdMeshers_FixedPoints1D_i::GetImpl
@ -275,3 +184,28 @@ CORBA::Boolean StdMeshers_FixedPoints1D_i::IsDimSupported( SMESH::Dimension type
return type == SMESH::DIM_1D;
}
//================================================================================
/*!
* \brief Return geometry this hypothesis depends on. Return false if there is no geometry parameter
*/
//================================================================================
bool
StdMeshers_FixedPoints1D_i::getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const
{
return StdMeshers_Reversible1D_i::getObjectsDependOn( entryArray, subIDArray );
}
//================================================================================
/*!
* \brief Set new geometry instead of that returned by getObjectsDependOn()
*/
//================================================================================
bool
StdMeshers_FixedPoints1D_i::setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray )
{
return StdMeshers_Reversible1D_i::setObjectsDependOn( entryArray, subIDArray );
}

28
src/StdMeshers_I/StdMeshers_FixedPoints1D_i.hxx
View File

@ -30,7 +30,7 @@
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
#include "SMESH_Hypothesis_i.hxx"
#include "StdMeshers_Reversible1D_i.hxx"
#include "StdMeshers_FixedPoints1D.hxx"
// ======================================================
@ -38,7 +38,8 @@
// ======================================================
class STDMESHERS_I_EXPORT StdMeshers_FixedPoints1D_i:
public virtual POA_StdMeshers::StdMeshers_FixedPoints1D,
public virtual SMESH_Hypothesis_i
public virtual SMESH_Hypothesis_i,
public virtual StdMeshers_Reversible1D_i
{
public:
// Constructor
@ -62,23 +63,22 @@ public:
// Returns list of numbers of segments
SMESH::long_array* GetNbSegments();
//Set Reversed Edges
void SetReversedEdges( const SMESH::long_array& theIDs);
//Get Reversed Edges
SMESH::long_array* GetReversedEdges();
//Set the Entry of the Object
void SetObjectEntry( const char* theEntry);
//Get Object Entry
char* GetObjectEntry();
// Get implementation
::StdMeshers_FixedPoints1D* GetImpl();
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const;
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray );
};
#endif

26
src/StdMeshers_I/StdMeshers_Geometric1D_i.cxx
View File

@ -139,3 +139,29 @@ CORBA::Boolean StdMeshers_Geometric1D_i::IsDimSupported(::SMESH::Dimension type)
{
return type == SMESH::DIM_1D;
}
//================================================================================
/*!
* \brief Return geometry this hypothesis depends on. Return false if there is no geometry parameter
*/
//================================================================================
bool
StdMeshers_Geometric1D_i::getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const
{
return StdMeshers_Reversible1D_i::getObjectsDependOn( entryArray, subIDArray );
}
//================================================================================
/*!
* \brief Set new geometry instead of that returned by getObjectsDependOn()
*/
//================================================================================
bool
StdMeshers_Geometric1D_i::setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray )
{
return StdMeshers_Reversible1D_i::setObjectsDependOn( entryArray, subIDArray );
}

12
src/StdMeshers_I/StdMeshers_Geometric1D_i.hxx
View File

@ -59,6 +59,18 @@ class STDMESHERS_I_EXPORT StdMeshers_Geometric1D_i:
// Get implementation
::StdMeshers_Geometric1D* GetImpl();
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const;
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray );
};
#endif

11
src/StdMeshers_I/StdMeshers_ImportSource1D_i.hxx
View File

@ -64,6 +64,17 @@ class STDMESHERS_I_EXPORT StdMeshers_ImportSource1D_i:
virtual void LoadFrom( const char* theStream );
virtual void UpdateAsMeshesRestored();
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) { return true; }
private:
SMESH::string_array_var _groupEntries;
std::vector< std::string > _groupIDs;

11
src/StdMeshers_I/StdMeshers_ImportSource2D_i.hxx
View File

@ -64,6 +64,17 @@ class STDMESHERS_I_EXPORT StdMeshers_ImportSource2D_i:
virtual void LoadFrom( const char* theStream );
virtual void UpdateAsMeshesRestored();
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) { return true; }
private:
SMESH::string_array_var _groupEntries;
std::vector< std::string > _groupIDs;

11
src/StdMeshers_I/StdMeshers_LayerDistribution2D_i.hxx
View File

@ -54,6 +54,17 @@ public:
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) { return true; }
};
#endif

11
src/StdMeshers_I/StdMeshers_LayerDistribution_i.hxx
View File

@ -77,6 +77,17 @@ public:
virtual char* SaveTo();
virtual void LoadFrom( const char* theStream );
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) { return true; }
protected:
// restore myMethod2VarParams by parameters stored in an old study
virtual void setOldParameters (const char* theParameters);

11
src/StdMeshers_I/StdMeshers_LengthFromEdges_i.hxx
View File

@ -66,6 +66,17 @@ public:
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) { return true; }
};
#endif

11
src/StdMeshers_I/StdMeshers_LocalLength_i.hxx
View File

@ -71,6 +71,17 @@ public:
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) { return true; }
protected:
virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const;
};

12
src/StdMeshers_I/StdMeshers_MaxElementArea_i.hxx
View File

@ -63,6 +63,18 @@ public:
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) { return true; }
protected:
virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const;
};

11
src/StdMeshers_I/StdMeshers_MaxElementVolume_i.hxx
View File

@ -63,6 +63,17 @@ public:
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) { return true; }
protected:
virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const;
};

11
src/StdMeshers_I/StdMeshers_MaxLength_i.hxx
View File

@ -77,6 +77,17 @@ public:
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) { return true; }
protected:
virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const;
};

11
src/StdMeshers_I/StdMeshers_NotConformAllowed_i.hxx
View File

@ -50,6 +50,17 @@ public:
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) { return true; }
protected:
::StdMeshers_NotConformAllowed* _impl;
};

11
src/StdMeshers_I/StdMeshers_NumberOfLayers2D_i.hxx
View File

@ -52,6 +52,17 @@ public:
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) { return true; }
};
#endif

11
src/StdMeshers_I/StdMeshers_NumberOfLayers_i.hxx
View File

@ -68,6 +68,17 @@ public:
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) { return true; }
protected:
virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const;
};

125
src/StdMeshers_I/StdMeshers_NumberOfSegments_i.cxx
View File

@ -36,7 +36,6 @@
#include <TCollection_AsciiString.hxx>
using namespace std;
//=============================================================================
/*!
* StdMeshers_NumberOfSegments_i::StdMeshers_NumberOfSegments_i
@ -48,7 +47,8 @@ using namespace std;
StdMeshers_NumberOfSegments_i::StdMeshers_NumberOfSegments_i( PortableServer::POA_ptr thePOA,
::SMESH_Gen* theGenImpl )
: SALOME::GenericObj_i( thePOA ),
SMESH_Hypothesis_i( thePOA )
SMESH_Hypothesis_i( thePOA ),
StdMeshers_Reversible1D_i( this )
{
myBaseImpl = new ::StdMeshers_NumberOfSegments( theGenImpl->GetANewId(),
theGenImpl );
@ -159,100 +159,6 @@ CORBA::Long StdMeshers_NumberOfSegments_i::GetNumberOfSegments()
return this->GetImpl()->GetNumberOfSegments();
}
//=============================================================================
/*!
* StdMeshers_NumberOfSegments_i::SetReversedEdges
*
* Set edges to reverse
*/
//=============================================================================
void StdMeshers_NumberOfSegments_i::SetReversedEdges( const SMESH::long_array& theIds )
{
ASSERT( myBaseImpl );
try {
std::vector<int> ids( theIds.length() );
CORBA::Long iEnd = theIds.length();
for ( CORBA::Long i = 0; i < iEnd; i++ )
ids[ i ] = theIds[ i ];
this->GetImpl()->SetReversedEdges( ids );
}
catch ( SALOME_Exception& S_ex ) {
THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
SALOME::BAD_PARAM );
}
// Update Python script
SMESH::TPythonDump() << _this() << ".SetReversedEdges( " << theIds << " )";
}
//=============================================================================
/*!
* StdMeshers_NumberOfSegments_i::SetObjectEntry
*
* Set the Entry for the Main Object
*/
//=============================================================================
void StdMeshers_NumberOfSegments_i::SetObjectEntry( const char* theEntry )
{
ASSERT( myBaseImpl );
string entry(theEntry); // actually needed as theEntry is spoiled by moment of dumping
try {
this->GetImpl()->SetObjectEntry( entry.c_str() );
}
catch ( SALOME_Exception& S_ex ) {
THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
SALOME::BAD_PARAM );
}
// Update Python script
SMESH::TPythonDump() << _this() << ".SetObjectEntry( \"" << entry.c_str() << "\" )";
}
//=============================================================================
/*!
* StdMeshers_NumberOfSegments_i::GetObjectEntry
*
* Set the Entry for the Main Object
*/
//=============================================================================
char* StdMeshers_NumberOfSegments_i::GetObjectEntry()
{
ASSERT( myBaseImpl );
const char* entry;
try {
entry = this->GetImpl()->GetObjectEntry();
}
catch ( SALOME_Exception& S_ex ) {
THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
SALOME::BAD_PARAM );
}
return CORBA::string_dup( entry );
}
//=============================================================================
/*!
* StdMeshers_NumberOfSegments_i::GetReversedEdges
*
* Get reversed edges
*/
//=============================================================================
SMESH::long_array* StdMeshers_NumberOfSegments_i::GetReversedEdges()
{
ASSERT( myBaseImpl );
SMESH::long_array_var anArray = new SMESH::long_array;
std::vector<int> ids = this->GetImpl()->GetReversedEdges();
anArray->length( ids.size() );
for ( size_t i = 0; i < ids.size(); i++)
anArray [ i ] = ids [ i ];
return anArray._retn();
}
//=============================================================================
/*!
*/
@ -497,3 +403,30 @@ std::string StdMeshers_NumberOfSegments_i::getMethodOfParameter(const int paramI
{
return paramIndex == 0 ? "SetNumberOfSegments" : "SetScaleFactor";
}
//================================================================================
/*!
* \brief Return geometry this hypothesis depends on. Return false if there is no geometry parameter
*/
//================================================================================
bool
StdMeshers_NumberOfSegments_i::getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const
{
return StdMeshers_Reversible1D_i::getObjectsDependOn( entryArray, subIDArray );
}
//================================================================================
/*!
* \brief Set new geometry instead of that returned by getObjectsDependOn()
*/
//================================================================================
bool
StdMeshers_NumberOfSegments_i::setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray )
{
return StdMeshers_Reversible1D_i::setObjectsDependOn( entryArray, subIDArray );
}

21
src/StdMeshers_I/StdMeshers_NumberOfSegments_i.hxx
View File

@ -35,7 +35,7 @@
#include CORBA_SERVER_HEADER(SMESH_Mesh)
#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
#include "SMESH_Hypothesis_i.hxx"
#include "StdMeshers_Reversible1D_i.hxx"
#include "StdMeshers_NumberOfSegments.hxx"
// ======================================================
@ -43,7 +43,8 @@
// ======================================================
class STDMESHERS_I_EXPORT StdMeshers_NumberOfSegments_i:
public virtual POA_StdMeshers::StdMeshers_NumberOfSegments,
public virtual SMESH_Hypothesis_i
public virtual SMESH_Hypothesis_i,
public virtual StdMeshers_Reversible1D_i
{
public:
// Constructor
@ -104,18 +105,16 @@ public:
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
//Set Reversed Edges
void SetReversedEdges( const SMESH::long_array& theIDs);
//Get Reversed Edges
SMESH::long_array* GetReversedEdges();
// Methods for copying mesh definition to other geometry
//Set Object Entry
void SetObjectEntry( const char* entry);
//Get Object Entry
char* GetObjectEntry();
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const;
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray );
protected:
virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const;
};

18
src/StdMeshers_I/StdMeshers_ObjRefUlils.cxx
View File

@ -162,3 +162,21 @@ void StdMeshers_ObjRefUlils::SaveToStream( const std::string& studyEntry,
else
stream << " " << studyEntry;
}
//=======================================================================
//function : EntryToShape
//purpose : Return TopoDS_Shape by a study entry
//=======================================================================
TopoDS_Shape StdMeshers_ObjRefUlils::EntryToShape(const std::string theEntry)
{
TopoDS_Shape shape;
if (SMESH_Gen_i* gen = SMESH_Gen_i::GetSMESHGen()) {
SALOMEDS::SObject_wrap sobj = SMESH_Gen_i::getStudyServant()->FindObjectID( theEntry.c_str() );
CORBA::Object_var obj = gen->SObjectToObject( sobj );
GEOM::GEOM_Object_var geom = GEOM::GEOM_Object::_narrow( obj );
shape = gen->GeomObjectToShape( geom.in() );
}
return shape;
}

7
src/StdMeshers_I/StdMeshers_ObjRefUlils.hxx
View File

@ -65,6 +65,13 @@ public:
return TopoDS_Shape();
}
/*!
* \brief Return TopoDS_Shape by a study entry
* \param theEntry - study entry
* \retval TopoDS_Shape - result TopoDS_Shape
*/
static TopoDS_Shape EntryToShape(const std::string theEntry);
/*!
* \brief Return study entry of GEOM Object
*/

43
src/StdMeshers_I/StdMeshers_ProjectionSource1D_i.cxx
View File

@ -298,3 +298,46 @@ void StdMeshers_ProjectionSource1D_i::LoadFrom( const char* theStream )
str >> myShapeEntries[ i ];
}
//================================================================================
/*!
* \brief Return geometry this hypothesis depends on. Return false if there is no geometry parameter
*/
//================================================================================
bool
StdMeshers_ProjectionSource1D_i::getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const
{
for ( int i = 0; i < NB_SHAPES; ++i )
entryArray.push_back( myShapeEntries[ i ]);
return true;
}
//================================================================================
/*!
* \brief Set new geometry instead of that returned by getObjectsDependOn()
*/
//================================================================================
bool
StdMeshers_ProjectionSource1D_i::setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray )
{
TopoDS_Shape shapes[ NB_SHAPES ];
for ( int i = 0; i < NB_SHAPES; ++i )
{
myShapeEntries[ i ] = entryArray[ i ];
shapes[ i ] = StdMeshers_ObjRefUlils::EntryToShape( entryArray[ i ]);
}
try {
GetImpl()->SetSourceEdge ( shapes[ SRC_EDGE ] );
GetImpl()->SetVertexAssociation( shapes[ SRC_VERTEX ],
shapes[ TGT_VERTEX ]);
}
catch (...) {
return false;
}
return true;
}

9
src/StdMeshers_I/StdMeshers_ProjectionSource1D_i.hxx
View File

@ -109,6 +109,15 @@ public:
virtual char* SaveTo();
virtual void LoadFrom( const char* theStream );
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const;
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray );
private:
// keep entries because the same shape can be published several times with
// different names and in this case a correct name can't be restored by a TopoDS_Shape

45
src/StdMeshers_I/StdMeshers_ProjectionSource2D_i.cxx
View File

@ -311,3 +311,48 @@ void StdMeshers_ProjectionSource2D_i::LoadFrom( const char* theStream )
str >> myShapeEntries[ i ];
}
//================================================================================
/*!
* \brief Return geometry this hypothesis depends on. Return false if there is no geometry parameter
*/
//================================================================================
bool
StdMeshers_ProjectionSource2D_i::getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const
{
for ( int i = 0; i < NB_SHAPES; ++i )
entryArray.push_back( myShapeEntries[ i ]);
return true;
}
//================================================================================
/*!
* \brief Set new geometry instead of that returned by getObjectsDependOn()
*/
//================================================================================
bool
StdMeshers_ProjectionSource2D_i::setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray )
{
TopoDS_Shape shapes[ NB_SHAPES ];
for ( int i = 0; i < NB_SHAPES; ++i )
{
myShapeEntries[ i ] = entryArray[ i ];
shapes[ i ] = StdMeshers_ObjRefUlils::EntryToShape( entryArray[ i ]);
}
try {
GetImpl()->SetSourceFace ( shapes[ SRC_FACE ] );
GetImpl()->SetVertexAssociation( shapes[ SRC_VERTEX1 ],
shapes[ SRC_VERTEX2 ],
shapes[ TGT_VERTEX1 ],
shapes[ TGT_VERTEX2 ]);
}
catch (...) {
return false;
}
return true;
}

10
src/StdMeshers_I/StdMeshers_ProjectionSource2D_i.hxx
View File

@ -113,6 +113,16 @@ public:
virtual char* SaveTo();
virtual void LoadFrom( const char* theStream );
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const;
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray );
private:
// keep entries because the same shape can be published several times with
// different names and in this case a correct name can't be restored by a TopoDS_Shape

45
src/StdMeshers_I/StdMeshers_ProjectionSource3D_i.cxx
View File

@ -312,3 +312,48 @@ void StdMeshers_ProjectionSource3D_i::LoadFrom( const char* theStream )
str >> myShapeEntries[ i ];
}
//================================================================================
/*!
* \brief Return geometry this hypothesis depends on. Return false if there is no geometry parameter
*/
//================================================================================
bool
StdMeshers_ProjectionSource3D_i::getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const
{
for ( int i = 0; i < NB_SHAPES; ++i )
entryArray.push_back( myShapeEntries[ i ]);
return true;
}
//================================================================================
/*!
* \brief Set new geometry instead of that returned by getObjectsDependOn()
*/
//================================================================================
bool
StdMeshers_ProjectionSource3D_i::setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray )
{
TopoDS_Shape shapes[ NB_SHAPES ];
for ( int i = 0; i < NB_SHAPES; ++i )
{
myShapeEntries[ i ] = entryArray[ i ];
shapes[ i ] = StdMeshers_ObjRefUlils::EntryToShape( entryArray[ i ]);
}
try {
GetImpl()->SetSource3DShape ( shapes[ SRC_SHAPE3D ] );
GetImpl()->SetVertexAssociation( shapes[ SRC_VERTEX1 ],
shapes[ SRC_VERTEX2 ],
shapes[ TGT_VERTEX1 ],
shapes[ TGT_VERTEX2 ]);
}
catch (...) {
return false;
}
return true;
}

12
src/StdMeshers_I/StdMeshers_ProjectionSource3D_i.hxx
View File

@ -114,6 +114,17 @@ public:
virtual char* SaveTo();
virtual void LoadFrom( const char* theStream );
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const;
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray );
private:
// keep entries because the same shape can be published several times with
// different names and in this case a correct name can't be restored by a TopoDS_Shape
@ -124,4 +135,3 @@ private:
};
#endif

12
src/StdMeshers_I/StdMeshers_Propagation_i.hxx
View File

@ -52,6 +52,12 @@ public:
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const { return false; }
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) { return true; }
};
// ======================================================
@ -69,6 +75,12 @@ public:
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const { return false; }
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) { return true; }
};
#endif

51
src/StdMeshers_I/StdMeshers_QuadrangleParams_i.cxx
View File

@ -378,3 +378,54 @@ void StdMeshers_QuadrangleParams_i::LoadFrom( const char* theStream )
myBaseImpl->LoadFrom( is );
}
//================================================================================
/*!
* \brief Return geometry this hypothesis depends on. Return false if there is no geometry parameter
*/
//================================================================================
bool
StdMeshers_QuadrangleParams_i::getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const
{
const ::StdMeshers_QuadrangleParams* impl =
static_cast<const ::StdMeshers_QuadrangleParams*>( myBaseImpl );
subIDArray.push_back( impl->GetTriaVertex() );
entryArray.push_back( impl->GetObjectEntry() );
entryArray.insert( entryArray.end(), myShapeEntries.begin(), myShapeEntries.end() );
return true;
}
//================================================================================
/*!
* \brief Set new geometry instead of that returned by getObjectsDependOn()
*/
//================================================================================
bool
StdMeshers_QuadrangleParams_i::setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray )
{
if ( !subIDArray.empty() )
GetImpl()->SetTriaVertex( subIDArray[0] );
GetImpl()->SetObjectEntry( entryArray[0].c_str() );
myShapeEntries.assign( ++entryArray.begin(), entryArray.end() );
std::vector< TopoDS_Shape > shapes;
std::vector< gp_Pnt > points;
this->GetImpl()->GetEnforcedNodes( shapes, points );
shapes.clear();
for ( size_t i = 0; i < myShapeEntries.size(); ++i )
shapes.push_back( StdMeshers_ObjRefUlils::EntryToShape( myShapeEntries[i] ));
this->GetImpl()->SetEnforcedNodes( shapes, points );
return true;
}

10
src/StdMeshers_I/StdMeshers_QuadrangleParams_i.hxx
View File

@ -84,6 +84,16 @@ public:
virtual char* SaveTo();
virtual void LoadFrom( const char* theStream );
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const;
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray );
protected:
std::vector<std::string> myShapeEntries;

6
src/StdMeshers_I/StdMeshers_QuadranglePreference_i.hxx
View File

@ -58,6 +58,12 @@ public:
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const { return false; }
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) { return true; }
};
#endif

6
src/StdMeshers_I/StdMeshers_QuadraticMesh_i.hxx
View File

@ -59,6 +59,12 @@ public:
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const { return false; }
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) { return true; }
};
#endif

43
src/StdMeshers_I/StdMeshers_Reversible1D_i.cxx
View File

@ -139,5 +139,46 @@ SMESH::long_array* StdMeshers_Reversible1D_i::GetReversedEdges()
::StdMeshers_Reversible1D* StdMeshers_Reversible1D_i::GetImpl()
{
return ( ::StdMeshers_Reversible1D* )myHyp->GetImpl();
return static_cast<::StdMeshers_Reversible1D* >( myHyp->GetImpl() );
}
//================================================================================
/*!
* \brief Return geometry this hypothesis depends on. Return false if there is no geometry parameter
*/
//================================================================================
bool
StdMeshers_Reversible1D_i::getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const
{
const ::StdMeshers_Reversible1D* impl = ( const ::StdMeshers_Reversible1D* ) myHyp->GetImpl();
subIDArray = impl->GetReversedEdges();
entryArray.push_back( impl->GetObjectEntry() );
return true;
}
//================================================================================
/*!
* \brief Set new geometry instead of that returned by getObjectsDependOn()
*/
//================================================================================
bool
StdMeshers_Reversible1D_i::setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray )
{
std::vector< int > newIDs;
newIDs.reserve( subIDArray.size() );
for ( size_t i = 0; i < subIDArray.size(); ++i )
if ( subIDArray[ i ] > 0 )
newIDs.push_back( subIDArray[ i ]);
GetImpl()->SetReversedEdges( newIDs );
if ( !entryArray.empty() )
GetImpl()->SetObjectEntry( entryArray[0].c_str() );
return true;
}

13
src/StdMeshers_I/StdMeshers_Reversible1D_i.hxx
View File

@ -36,7 +36,7 @@
#include "StdMeshers_Reversible1D.hxx"
// ======================================================
// Common metrhods of Reversible 1D hypotheses
// Common methods of Reversible 1D hypotheses
// ======================================================
class STDMESHERS_I_EXPORT StdMeshers_Reversible1D_i:
public virtual POA_StdMeshers::Reversible1D
@ -59,8 +59,17 @@ class STDMESHERS_I_EXPORT StdMeshers_Reversible1D_i:
// Get implementation
::StdMeshers_Reversible1D* GetImpl();
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const;
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray );
private:
SMESH_Hypothesis_i* myHyp;
};
#endif

10
src/StdMeshers_I/StdMeshers_SegmentLengthAroundVertex_i.hxx
View File

@ -63,6 +63,16 @@ public:
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const { return 0; }
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) { return true; }
protected:
virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const;
};

120
src/StdMeshers_I/StdMeshers_StartEndLength_i.cxx
View File

@ -49,7 +49,8 @@ using namespace std;
StdMeshers_StartEndLength_i::StdMeshers_StartEndLength_i( PortableServer::POA_ptr thePOA,
::SMESH_Gen* theGenImpl )
: SALOME::GenericObj_i( thePOA ),
SMESH_Hypothesis_i( thePOA )
SMESH_Hypothesis_i( thePOA ),
StdMeshers_Reversible1D_i( this )
{
myBaseImpl = new ::StdMeshers_StartEndLength( theGenImpl->GetANewId(),
theGenImpl );
@ -132,97 +133,6 @@ CORBA::Double StdMeshers_StartEndLength_i::GetLength( CORBA::Boolean theIsStart)
return this->GetImpl()->GetLength( theIsStart );
}
//=============================================================================
/*!
* StdMeshers_StartEndLength_i::SetReversedEdges
*
* Set edges to reverse
*/
//=============================================================================
void StdMeshers_StartEndLength_i::SetReversedEdges( const SMESH::long_array& theIds )
{
ASSERT( myBaseImpl );
try {
std::vector<int> ids( theIds.length() );
CORBA::Long iEnd = theIds.length();
for ( CORBA::Long i = 0; i < iEnd; i++ )
ids[ i ] = theIds[ i ];
this->GetImpl()->SetReversedEdges( ids );
}
catch ( SALOME_Exception& S_ex ) {
THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),
SALOME::BAD_PARAM );
}
// Update Python script
SMESH::TPythonDump() << _this() << ".SetReversedEdges( " << theIds << " )";
}
//=============================================================================
/*!
* StdMeshers_StartEndLength_i::SetObjectEntry
*
* Set the Entry for the Main Object
*/
//=============================================================================
void StdMeshers_StartEndLength_i::SetObjectEntry( const char* theEntry )
{
ASSERT( myBaseImpl );
string entry(theEntry); // actually needed as theEntry is spoiled by moment of dumping
try {
this->GetImpl()->SetObjectEntry( entry.c_str() );
// Update Python script
SMESH::TPythonDump() << _this() << ".SetObjectEntry( '" << entry.c_str() << "' )";
}
catch ( SALOME_Exception& S_ex ) {
THROW_SALOME_CORBA_EXCEPTION( S_ex.what(),SALOME::BAD_PARAM );
}
}
//=============================================================================
/*!
* StdMeshers_StartEndLength_i::GetObjectEntry
*
* Set the Entry for the Main Object
*/
//=============================================================================
char* StdMeshers_StartEndLength_i::GetObjectEntry()
{
ASSERT( myBaseImpl );
const char* entry;
try {
entry = this->GetImpl()->GetObjectEntry();
}
catch ( SALOME_Exception& S_ex ) {
THROW_SALOME_CORBA_EXCEPTION( S_ex.what(), SALOME::BAD_PARAM );
}
return CORBA::string_dup( entry );
}
//=============================================================================
/*!
* StdMeshers_StartEndLength_i::GetReversedEdges
*
* Get reversed edges
*/
//=============================================================================
SMESH::long_array* StdMeshers_StartEndLength_i::GetReversedEdges()
{
ASSERT( myBaseImpl );
SMESH::long_array_var anArray = new SMESH::long_array;
std::vector<int> ids = this->GetImpl()->GetReversedEdges();
anArray->length( ids.size() );
for ( CORBA::ULong i = 0; i < ids.size(); i++)
anArray [ i ] = ids [ i ];
return anArray._retn();
}
//=============================================================================
/*!
* StdMeshers_StartEndLength_i::GetImpl
@ -261,3 +171,29 @@ std::string StdMeshers_StartEndLength_i::getMethodOfParameter(const int paramInd
{
return paramIndex == 0 ? "SetStartLength" : "SetEndLength";
}
//================================================================================
/*!
* \brief Return geometry this hypothesis depends on. Return false if there is no geometry parameter
*/
//================================================================================
bool
StdMeshers_StartEndLength_i::getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const
{
return StdMeshers_Reversible1D_i::getObjectsDependOn( entryArray, subIDArray );
}
//================================================================================
/*!
* \brief Set new geometry instead of that returned by getObjectsDependOn()
*/
//================================================================================
bool
StdMeshers_StartEndLength_i::setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray )
{
return StdMeshers_Reversible1D_i::setObjectsDependOn( entryArray, subIDArray );
}

20
src/StdMeshers_I/StdMeshers_StartEndLength_i.hxx
View File

@ -34,7 +34,7 @@
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_BasicHypothesis)
#include "SMESH_Hypothesis_i.hxx"
#include "StdMeshers_Reversible1D_i.hxx"
#include "StdMeshers_StartEndLength.hxx"
class SMESH_Gen;
@ -44,7 +44,8 @@ class SMESH_Gen;
// ======================================================
class STDMESHERS_I_EXPORT StdMeshers_StartEndLength_i:
public virtual POA_StdMeshers::StdMeshers_StartEndLength,
public virtual SMESH_Hypothesis_i
public virtual SMESH_Hypothesis_i,
public virtual StdMeshers_Reversible1D_i
{
public:
// Constructor
@ -73,17 +74,16 @@ public:
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
//Set Reversed Edges
void SetReversedEdges( const SMESH::long_array& theIDs);
//Get Reversed Edges
SMESH::long_array* GetReversedEdges();
// Methods for copying mesh definition to other geometry
//Set Object Entry
void SetObjectEntry( const char* entry);
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const;
//Get Object Entry
char* GetObjectEntry();
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray );
protected:
virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const;

40
src/StdMeshers_I/StdMeshers_ViscousLayers2D_i.cxx
View File

@ -259,3 +259,43 @@ void StdMeshers_ViscousLayers2D_i::UpdateAsMeshesRestored()
{
GetImpl()->RestoreListeners();
}
//================================================================================
/*!
* \brief Return geometry this hypothesis depends on. Return false if there is no geometry parameter
*/
//================================================================================
bool
StdMeshers_ViscousLayers2D_i::getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const
{
const ::StdMeshers_ViscousLayers2D* impl =
static_cast<const ::StdMeshers_ViscousLayers2D*>( myBaseImpl );
subIDArray = impl->GetBndShapes();
return true;
}
//================================================================================
/*!
* \brief Set new geometry instead of that returned by getObjectsDependOn()
*/
//================================================================================
bool
StdMeshers_ViscousLayers2D_i::setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray )
{
std::vector< int > newIDs;
newIDs.reserve( subIDArray.size() );
for ( size_t i = 0; i < subIDArray.size(); ++i )
if ( subIDArray[ i ] > 0 )
newIDs.push_back( subIDArray[ i ]);
GetImpl()->SetBndShapes( newIDs, GetIsToIgnoreEdges() );
return true;
}

11
src/StdMeshers_I/StdMeshers_ViscousLayers2D_i.hxx
View File

@ -73,6 +73,17 @@ class STDMESHERS_I_EXPORT StdMeshers_ViscousLayers2D_i:
// Sets sub-mesh event listeners to clear sub-meshes of edges
// shrinked by viscous layers
virtual void UpdateAsMeshesRestored();
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const;
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray );
};
#endif

41
src/StdMeshers_I/StdMeshers_ViscousLayers_i.cxx
View File

@ -295,3 +295,44 @@ std::string StdMeshers_ViscousLayers_i::getMethodOfParameter(const int paramInde
}
return "";
}
//================================================================================
/*!
* \brief Return geometry this hypothesis depends on. Return false if there is no geometry parameter
*/
//================================================================================
bool
StdMeshers_ViscousLayers_i::getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const
{
const ::StdMeshers_ViscousLayers* impl =
static_cast<const ::StdMeshers_ViscousLayers*>( myBaseImpl );
subIDArray = impl->GetBndShapes();
return true;
}
//================================================================================
/*!
* \brief Set new geometry instead of that returned by getObjectsDependOn()
*/
//================================================================================
bool
StdMeshers_ViscousLayers_i::setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray )
{
std::vector< int > newIDs;
newIDs.reserve( subIDArray.size() );
for ( size_t i = 0; i < subIDArray.size(); ++i )
if ( subIDArray[ i ] > 0 )
newIDs.push_back( subIDArray[ i ]);
GetImpl()->SetBndShapes( newIDs, GetIsToIgnoreFaces() );
return true;
}

9
src/StdMeshers_I/StdMeshers_ViscousLayers_i.hxx
View File

@ -73,6 +73,15 @@ class STDMESHERS_I_EXPORT StdMeshers_ViscousLayers_i:
// Verify whether hypothesis supports given entity type
CORBA::Boolean IsDimSupported( SMESH::Dimension type );
// Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const;
// Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray );
protected:
virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const;
};