ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-03-15 21:01:26 +05:00
Code Issues Packages Projects Releases Wiki Activity

fight warnings, c++17. additional corrections

Browse Source
This commit is contained in:
vsr 2020-10-13 14:07:34 +03:00
parent a9f7e28cba
commit 9b08e00e6a
86 changed files with 540 additions and 1159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/MEDWrapper/MED_Algorithm.hxx
View File

@ -53,7 +53,7 @@ namespace MED
//! Get set of TElemInfo by its geometrical type and corresponding MED ENTITY //! Get set of TElemInfo by its geometrical type and corresponding MED ENTITY
MEDWRAPPER_EXPORT MEDWRAPPER_EXPORT
TEntity2TGeom2ElemInfo TEntity2TGeom2ElemInfo
GetEntity2TGeom2ElemInfo(const PWrapper& /*theWrapper*/, GetEntity2TGeom2ElemInfo(const PWrapper& theWrapper,
const PMeshInfo& theMeshInfo, const PMeshInfo& theMeshInfo,
const MED::TEntityInfo& theEntityInfo); const MED::TEntityInfo& theEntityInfo);

2
src/SMDS/SMDS_MeshVolume.cxx
View File

@ -201,7 +201,7 @@ int SMDS_MeshVolume::GetNodeIndex( const SMDS_MeshNode* node ) const
} }
return -1; return -1;
} }
bool SMDS_MeshVolume::ChangeNodes(const SMDS_MeshNode* /*nodes[]*/, const int /*nbNodes*/) bool SMDS_MeshVolume::ChangeNodes(const SMDS_MeshNode* /*nodes*/[], const int /*nbNodes*/)
{ {
return false; return false;
} }

2
src/SMDS/SMDS_MeshVolume.hxx
View File

@ -52,7 +52,7 @@ class SMDS_EXPORT SMDS_MeshVolume : public SMDS_MeshCell
virtual int NbFaces() const; virtual int NbFaces() const;
virtual int NbEdges() const; virtual int NbEdges() const;
virtual int GetNodeIndex( const SMDS_MeshNode* node ) const; virtual int GetNodeIndex( const SMDS_MeshNode* node ) const;
virtual bool ChangeNodes(const SMDS_MeshNode* /*nodes[]*/, const int /*nbNodes*/); virtual bool ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes);
virtual bool IsMediumNode(const SMDS_MeshNode* node) const; virtual bool IsMediumNode(const SMDS_MeshNode* node) const;
virtual int NbCornerNodes() const; virtual int NbCornerNodes() const;

4
src/SMDS/SMDS_UnstructuredGrid.hxx
View File

@ -85,7 +85,7 @@ public:
int CellIdToDownId(int vtkCellId); int CellIdToDownId(int vtkCellId);
void setCellIdToDownId(int vtkCellId, int downId); void setCellIdToDownId(int vtkCellId, int downId);
void CleanDownwardConnectivity(); void CleanDownwardConnectivity();
void BuildDownwardConnectivity(bool /*withEdges*/); void BuildDownwardConnectivity(bool withEdges);
int GetNeighbors(int* neighborsVtkIds, int* downIds, unsigned char* downTypes, int vtkId, bool getSkin=false); int GetNeighbors(int* neighborsVtkIds, int* downIds, unsigned char* downTypes, int vtkId, bool getSkin=false);
int GetParentVolumes(int* volVtkIds, int vtkId); int GetParentVolumes(int* volVtkIds, int vtkId);
int GetParentVolumes(int* volVtkIds, int downId, unsigned char downType); int GetParentVolumes(int* volVtkIds, int downId, unsigned char downType);
@ -115,7 +115,7 @@ public:
protected: protected:
SMDS_UnstructuredGrid(); SMDS_UnstructuredGrid();
~SMDS_UnstructuredGrid(); ~SMDS_UnstructuredGrid();
void copyNodes(vtkPoints *newPoints, std::vector<int>& /*idNodesOldToNew*/, int& alreadyCopied, int start, int end); void copyNodes(vtkPoints *newPoints, std::vector<int>& idNodesOldToNew, int& alreadyCopied, int start, int end);
void copyBloc(vtkUnsignedCharArray *newTypes, void copyBloc(vtkUnsignedCharArray *newTypes,
const std::vector<int>& idCellsOldToNew, const std::vector<int>& idCellsOldToNew,
const std::vector<int>& idNodesOldToNew, const std::vector<int>& idNodesOldToNew,

8
src/SMESH/SMESH_Algo.hxx
View File

@ -173,7 +173,7 @@ class SMESH_EXPORT SMESH_Algo : public SMESH_Hypothesis
* else, returns OK if at least one shape is OK * else, returns OK if at least one shape is OK
* \retval bool - \c true by default * \retval bool - \c true by default
*/ */
virtual bool IsApplicableToShape(const TopoDS_Shape & /*shape*/, bool /*toCheckAll*/) const; virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const;
/*! /*!
* \brief Sets _computeCanceled to true. It's usage depends on * \brief Sets _computeCanceled to true. It's usage depends on
@ -480,7 +480,7 @@ public:
* else, returns OK if at least one shape is OK * else, returns OK if at least one shape is OK
* \retval bool - \c true by default * \retval bool - \c true by default
*/ */
virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const; virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const;
}; };
class SMESH_EXPORT SMESH_2D_Algo: public SMESH_Algo class SMESH_EXPORT SMESH_2D_Algo: public SMESH_Algo
@ -494,7 +494,7 @@ public:
* else, returns OK if at least one shape is OK * else, returns OK if at least one shape is OK
* \retval bool - \c true by default * \retval bool - \c true by default
*/ */
virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const; virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const;
/*! /*!
* \brief Method in which an algorithm generating a structured mesh * \brief Method in which an algorithm generating a structured mesh
* fixes positions of in-face nodes after there movement * fixes positions of in-face nodes after there movement
@ -515,7 +515,7 @@ public:
* else, returns OK if at least one shape is OK * else, returns OK if at least one shape is OK
* \retval bool - \c true by default * \retval bool - \c true by default
*/ */
virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const; virtual bool IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const;
}; };
#endif #endif

11
src/SMESH/SMESH_Gen.hxx
View File

@ -66,8 +66,7 @@ public:
SMESH_Gen(); SMESH_Gen();
~SMESH_Gen(); ~SMESH_Gen();
SMESH_Mesh* CreateMesh(bool theIsEmbeddedMode) SMESH_Mesh* CreateMesh(bool theIsEmbeddedMode);
;
enum ComputeFlags enum ComputeFlags
{ {
@ -91,10 +90,10 @@ public:
const ::MeshDimension aDim=::MeshDim_3D, const ::MeshDimension aDim=::MeshDim_3D,
TSetOfInt* aShapesId=0); TSetOfInt* aShapesId=0);
void PrepareCompute(::SMESH_Mesh & /*aMesh*/, void PrepareCompute(::SMESH_Mesh & aMesh,
const TopoDS_Shape & /*aShape*/); const TopoDS_Shape & aShape);
void CancelCompute(::SMESH_Mesh & /*aMesh*/, void CancelCompute(::SMESH_Mesh & aMesh,
const TopoDS_Shape & /*aShape*/); const TopoDS_Shape & aShape);
const SMESH_subMesh* GetCurrentSubMesh() const; const SMESH_subMesh* GetCurrentSubMesh() const;

8
src/SMESH/SMESH_Mesh.cxx
View File

@ -784,7 +784,6 @@ SMESH_Mesh::RemoveHypothesis(const TopoDS_Shape & aSubShape,
const std::list<const SMESHDS_Hypothesis*>& const std::list<const SMESHDS_Hypothesis*>&
SMESH_Mesh::GetHypothesisList(const TopoDS_Shape & aSubShape) const SMESH_Mesh::GetHypothesisList(const TopoDS_Shape & aSubShape) const
{ {
return _myMeshDS->GetHypothesis(aSubShape); return _myMeshDS->GetHypothesis(aSubShape);
} }
@ -1017,7 +1016,6 @@ void SMESH_Mesh::ClearLog()
//============================================================================= //=============================================================================
SMESH_subMesh * SMESH_Mesh::GetSubMesh(const TopoDS_Shape & aSubShape) SMESH_subMesh * SMESH_Mesh::GetSubMesh(const TopoDS_Shape & aSubShape)
{ {
int index = _myMeshDS->ShapeToIndex(aSubShape); int index = _myMeshDS->ShapeToIndex(aSubShape);
if ( !index && aSubShape.IsNull() ) if ( !index && aSubShape.IsNull() )
@ -1070,7 +1068,6 @@ SMESH_subMesh * SMESH_Mesh::GetSubMesh(const TopoDS_Shape & aSubShape)
//============================================================================= //=============================================================================
SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const TopoDS_Shape & aSubShape) const SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const TopoDS_Shape & aSubShape) const
{ {
int index = _myMeshDS->ShapeToIndex(aSubShape); int index = _myMeshDS->ShapeToIndex(aSubShape);
return GetSubMeshContaining( index ); return GetSubMeshContaining( index );
@ -1084,10 +1081,8 @@ SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const TopoDS_Shape & aSubShape)
//============================================================================= //=============================================================================
SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const int aShapeID) const SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const int aShapeID) const
{ {
SMESH_subMesh *aSubMesh = _subMeshHolder->Get( aShapeID ); SMESH_subMesh *aSubMesh = _subMeshHolder->Get( aShapeID );
return aSubMesh; return aSubMesh;
} }
@ -1099,7 +1094,6 @@ SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const int aShapeID) const
std::list<SMESH_subMesh*> std::list<SMESH_subMesh*>
SMESH_Mesh::GetGroupSubMeshesContaining(const TopoDS_Shape & aSubShape) const SMESH_Mesh::GetGroupSubMeshesContaining(const TopoDS_Shape & aSubShape) const
{ {
std::list<SMESH_subMesh*> found; std::list<SMESH_subMesh*> found;
@ -1434,7 +1428,6 @@ void SMESH_Mesh::ExportMED(const char * file,
bool theAddODOnVertices, bool theAddODOnVertices,
double theZTolerance, double theZTolerance,
bool theAllElemsToGroup) bool theAllElemsToGroup)
{ {
MESSAGE("MED_VERSION:"<< theVersion); MESSAGE("MED_VERSION:"<< theVersion);
SMESH_TRY; SMESH_TRY;
@ -1505,7 +1498,6 @@ void SMESH_Mesh::ExportMED(const char * file,
void SMESH_Mesh::ExportSAUV(const char *file, void SMESH_Mesh::ExportSAUV(const char *file,
const char* theMeshName, const char* theMeshName,
bool theAutoGroups) bool theAutoGroups)
{ {
std::string medfilename(file); std::string medfilename(file);
medfilename += ".med"; medfilename += ".med";

84
src/SMESH/SMESH_Mesh.hxx
View File

@ -132,16 +132,13 @@ class SMESH_EXPORT SMESH_Mesh
bool theMakeRequiredGroups = true ); bool theMakeRequiredGroups = true );
SMESH_Hypothesis::Hypothesis_Status SMESH_Hypothesis::Hypothesis_Status
AddHypothesis(const TopoDS_Shape & aSubShape, int anHypId, std::string* error=0) AddHypothesis(const TopoDS_Shape & aSubShape, int anHypId, std::string* error=0);
;
SMESH_Hypothesis::Hypothesis_Status SMESH_Hypothesis::Hypothesis_Status
RemoveHypothesis(const TopoDS_Shape & aSubShape, int anHypId) RemoveHypothesis(const TopoDS_Shape & aSubShape, int anHypId);
;
const std::list <const SMESHDS_Hypothesis * >& const std::list <const SMESHDS_Hypothesis * >&
GetHypothesisList(const TopoDS_Shape & aSubShape) const GetHypothesisList(const TopoDS_Shape & aSubShape) const;
;
const SMESH_Hypothesis * GetHypothesis(const TopoDS_Shape & aSubShape, const SMESH_Hypothesis * GetHypothesis(const TopoDS_Shape & aSubShape,
const SMESH_HypoFilter& aFilter, const SMESH_HypoFilter& aFilter,
@ -167,9 +164,9 @@ class SMESH_EXPORT SMESH_Mesh
SMESH_Hypothesis * GetHypothesis(const int aHypID) const; SMESH_Hypothesis * GetHypothesis(const int aHypID) const;
const std::list<SMESHDS_Command*> & GetLog() ; const std::list<SMESHDS_Command*> & GetLog();
void ClearLog() ; void ClearLog();
int GetId() const { return _id; } int GetId() const { return _id; }
@ -183,19 +180,15 @@ class SMESH_EXPORT SMESH_Mesh
SMESH_Gen *GetGen() { return _gen; } SMESH_Gen *GetGen() { return _gen; }
SMESH_subMesh *GetSubMesh(const TopoDS_Shape & aSubShape) SMESH_subMesh *GetSubMesh(const TopoDS_Shape & aSubShape);
;
SMESH_subMesh *GetSubMeshContaining(const TopoDS_Shape & aSubShape) const SMESH_subMesh *GetSubMeshContaining(const TopoDS_Shape & aSubShape) const;
;
SMESH_subMesh *GetSubMeshContaining(const int aShapeID) const SMESH_subMesh *GetSubMeshContaining(const int aShapeID) const;
;
/*! /*!
* \brief Return submeshes of groups containing the given subshape * \brief Return submeshes of groups containing the given subshape
*/ */
std::list<SMESH_subMesh*> GetGroupSubMeshesContaining(const TopoDS_Shape & shape) const std::list<SMESH_subMesh*> GetGroupSubMeshesContaining(const TopoDS_Shape & shape) const;
;
/*! /*!
* \brief Say all submeshes that theChangedHyp has been modified * \brief Say all submeshes that theChangedHyp has been modified
*/ */
@ -220,9 +213,9 @@ class SMESH_EXPORT SMESH_Mesh
*/ */
const TopTools_ListOfShape& GetAncestors(const TopoDS_Shape& theSubShape) const; const TopTools_ListOfShape& GetAncestors(const TopoDS_Shape& theSubShape) const;
void SetAutoColor(bool theAutoColor) ; void SetAutoColor(bool theAutoColor);
bool GetAutoColor() ; bool GetAutoColor();
/*! /*!
* \brief Set the flag meaning that the mesh has been edited "manually". * \brief Set the flag meaning that the mesh has been edited "manually".
@ -263,17 +256,16 @@ class SMESH_EXPORT SMESH_Mesh
bool theAutoDimension = false, bool theAutoDimension = false,
bool theAddODOnVertices = false, bool theAddODOnVertices = false,
double theZTolerance = -1., double theZTolerance = -1.,
bool theAllElemsToGroup = false) bool theAllElemsToGroup = false);
;
void ExportDAT(const char * file, void ExportDAT(const char * file,
const SMESHDS_Mesh* meshPart = 0) ; const SMESHDS_Mesh* meshPart = 0);
void ExportUNV(const char * file, void ExportUNV(const char * file,
const SMESHDS_Mesh* meshPart = 0) ; const SMESHDS_Mesh* meshPart = 0);
void ExportSTL(const char * file, void ExportSTL(const char * file,
const bool isascii, const bool isascii,
const char * name = 0, const char * name = 0,
const SMESHDS_Mesh* meshPart = 0) ; const SMESHDS_Mesh* meshPart = 0);
void ExportCGNS(const char * file, void ExportCGNS(const char * file,
const SMESHDS_Mesh* mesh, const SMESHDS_Mesh* mesh,
const char * meshName = 0, const char * meshName = 0,
@ -283,35 +275,35 @@ class SMESH_EXPORT SMESH_Mesh
bool withRequiredGroups = true ); bool withRequiredGroups = true );
void ExportSAUV(const char *file, void ExportSAUV(const char *file,
const char* theMeshName = NULL, const char* theMeshName = NULL,
bool theAutoGroups = true) ; bool theAutoGroups = true);
double GetComputeProgress() const; double GetComputeProgress() const;
int NbNodes() const ; int NbNodes() const;
int Nb0DElements() const ; int Nb0DElements() const;
int NbBalls() const ; int NbBalls() const;
int NbEdges(SMDSAbs_ElementOrder order = ORDER_ANY) const ; int NbEdges(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbFaces(SMDSAbs_ElementOrder order = ORDER_ANY) const ; int NbFaces(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbTriangles(SMDSAbs_ElementOrder order = ORDER_ANY) const ; int NbTriangles(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbQuadrangles(SMDSAbs_ElementOrder order = ORDER_ANY) const ; int NbQuadrangles(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbBiQuadQuadrangles() const ; int NbBiQuadQuadrangles() const;
int NbBiQuadTriangles() const ; int NbBiQuadTriangles() const;
int NbPolygons(SMDSAbs_ElementOrder order = ORDER_ANY) const ; int NbPolygons(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbVolumes(SMDSAbs_ElementOrder order = ORDER_ANY) const ; int NbVolumes(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbTetras(SMDSAbs_ElementOrder order = ORDER_ANY) const ; int NbTetras(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbHexas(SMDSAbs_ElementOrder order = ORDER_ANY) const ; int NbHexas(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbTriQuadraticHexas() const ; int NbTriQuadraticHexas() const;
int NbPyramids(SMDSAbs_ElementOrder order = ORDER_ANY) const ; int NbPyramids(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) const ; int NbPrisms(SMDSAbs_ElementOrder order = ORDER_ANY) const;
int NbQuadPrisms() const ; int NbQuadPrisms() const;
int NbBiQuadPrisms() const ; int NbBiQuadPrisms() const;
int NbHexagonalPrisms() const ; int NbHexagonalPrisms() const;
int NbPolyhedrons() const ; int NbPolyhedrons() const;
int NbSubMesh() const ; int NbSubMesh() const;
int NbGroup() const { return _mapGroup.size(); } int NbGroup() const { return _mapGroup.size(); }
@ -323,7 +315,7 @@ class SMESH_EXPORT SMESH_Mesh
const TopoDS_Shape& theShape = TopoDS_Shape(), const TopoDS_Shape& theShape = TopoDS_Shape(),
const SMESH_PredicatePtr& thePredicate = SMESH_PredicatePtr()); const SMESH_PredicatePtr& thePredicate = SMESH_PredicatePtr());
SMESH_Group* AddGroup (SMESHDS_GroupBase* groupDS) ; SMESH_Group* AddGroup (SMESHDS_GroupBase* groupDS);
typedef boost::shared_ptr< SMDS_Iterator<SMESH_Group*> > GroupIteratorPtr; typedef boost::shared_ptr< SMDS_Iterator<SMESH_Group*> > GroupIteratorPtr;
GroupIteratorPtr GetGroups() const; GroupIteratorPtr GetGroups() const;

10
src/SMESH/SMESH_MeshEditor.hxx
View File

@ -395,10 +395,10 @@ public:
const SMDS_MeshNode* srcNode, const SMDS_MeshNode* srcNode,
std::list<const SMDS_MeshNode*> & newNodes, std::list<const SMDS_MeshNode*> & newNodes,
const bool makeMediumNodes); const bool makeMediumNodes);
int makeNodesByNormal1D( SMESHDS_Mesh* /*mesh*/, int makeNodesByNormal1D( SMESHDS_Mesh* mesh,
const SMDS_MeshNode* /*srcNode*/, const SMDS_MeshNode* srcNode,
std::list<const SMDS_MeshNode*> & /*newNodes*/, std::list<const SMDS_MeshNode*> & newNodes,
const bool /*makeMediumNodes*/); const bool makeMediumNodes);
int makeNodesAlongTrack( SMESHDS_Mesh* mesh, int makeNodesAlongTrack( SMESHDS_Mesh* mesh,
const SMDS_MeshNode* srcNode, const SMDS_MeshNode* srcNode,
std::list<const SMDS_MeshNode*> & newNodes, std::list<const SMDS_MeshNode*> & newNodes,
@ -747,7 +747,7 @@ public:
*/ */
int removeQuadElem( SMESHDS_SubMesh * theSm, int removeQuadElem( SMESHDS_SubMesh * theSm,
SMDS_ElemIteratorPtr theItr, SMDS_ElemIteratorPtr theItr,
const int /*theShapeID*/); const int theShapeID);
/*! /*!
* \brief Create groups of elements made during transformation * \brief Create groups of elements made during transformation
* \param nodeGens - nodes making corresponding myLastCreatedNodes * \param nodeGens - nodes making corresponding myLastCreatedNodes

2
src/SMESH/SMESH_subMesh.hxx
View File

@ -294,7 +294,7 @@ protected:
* \brief Return a shape containing all sub-shapes of the MainShape that can be * \brief Return a shape containing all sub-shapes of the MainShape that can be
* meshed at once along with _subShape * meshed at once along with _subShape
*/ */
TopoDS_Shape getCollection(SMESH_Gen * /*theGen*/, TopoDS_Shape getCollection(SMESH_Gen * theGen,
SMESH_Algo* theAlgo, SMESH_Algo* theAlgo,
bool & theSubComputed, bool & theSubComputed,
bool & theSubFailed, bool & theSubFailed,

2
src/SMESHGUI/SMESHGUI.h
View File

@ -202,7 +202,7 @@ protected:
static void ProcessEvents( vtkObject* theObject, static void ProcessEvents( vtkObject* theObject,
unsigned long theEvent, unsigned long theEvent,
void* theClientData, void* theClientData,
void* /*theCallData*/ ); void* theCallData );
private: private:
void OnEditDelete(); void OnEditDelete();

2
src/SMESHGUI/SMESHGUI_FieldSelectorWdg.h
View File

@ -50,7 +50,7 @@ class SMESHGUI_EXPORT SMESHGUI_FieldSelectorWdg : public QGroupBox
private slots: private slots:
void onItemCheck(QTreeWidgetItem * item, int /*column*/); void onItemCheck(QTreeWidgetItem * item, int column);
private: private:

1
src/SMESHGUI/SMESHGUI_MultiEditDlg.cxx
View File

@ -369,7 +369,6 @@ SMESH::NumericalFunctor_ptr SMESHGUI_MultiEditDlg::getNumericalFunctor()
aNF = aFilterMgr->CreateMultiConnection2D(); aNF = aFilterMgr->CreateMultiConnection2D();
else if (myComboBoxFunctor->currentText() == tr("MIN_DIAG_ELEMENTS")) else if (myComboBoxFunctor->currentText() == tr("MIN_DIAG_ELEMENTS"))
aNF = aFilterMgr->CreateMaxElementLength2D(); aNF = aFilterMgr->CreateMaxElementLength2D();
//else;
return aNF._retn(); return aNF._retn();
} }

4
src/SMESH_I/SMESH_2smeshpy.hxx
View File

@ -260,7 +260,7 @@ public:
void SetCommandBefore( Handle(_pyCommand) theCmd, Handle(_pyCommand) theBeforeCmd ); void SetCommandBefore( Handle(_pyCommand) theCmd, Handle(_pyCommand) theBeforeCmd );
Handle(_pyCommand)& GetLastCommand(); Handle(_pyCommand)& GetLastCommand();
std::list< Handle(_pyCommand) >& GetCommands() { return myCommands; } std::list< Handle(_pyCommand) >& GetCommands() { return myCommands; }
void PlaceSubmeshAfterItsCreation( Handle(_pyCommand) /*theCmdUsingSubmesh*/ ) const; void PlaceSubmeshAfterItsCreation( Handle(_pyCommand) theCmdUsingSubmesh ) const;
_pyID GenerateNewID( const _pyID& theID ); _pyID GenerateNewID( const _pyID& theID );
bool AddObject( Handle(_pyObject)& theObj ); bool AddObject( Handle(_pyObject)& theObj );
@ -600,7 +600,7 @@ public:
virtual Handle(_pyMesh) GetMesh() { return myMesh; } virtual Handle(_pyMesh) GetMesh() { return myMesh; }
virtual void Free() { myCreator.Nullify(); myMesh.Nullify(); } virtual void Free() { myCreator.Nullify(); myMesh.Nullify(); }
void SetCreator( const Handle(_pyObject)& theCreator ) { myCreator = theCreator; } void SetCreator( const Handle(_pyObject)& theCreator ) { myCreator = theCreator; }
static bool CanBeArgOfMethod(const _AString& /*theMethodName*/); static bool CanBeArgOfMethod(const _AString& theMethodName);
DEFINE_STANDARD_RTTIEXT(_pySubMesh,_pyObject) DEFINE_STANDARD_RTTIEXT(_pySubMesh,_pyObject)
}; };

8
src/SMESH_I/SMESH_Algo_i.hxx
View File

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

9
src/SMESH_I/SMESH_Filter_i.hxx
View File

@ -822,13 +822,10 @@ namespace SMESH
void SetElementType( ElementType theType ); void SetElementType( ElementType theType );
void SetPoint( CORBA::Double x, CORBA::Double y, CORBA::Double z ); void SetPoint( CORBA::Double x, CORBA::Double y, CORBA::Double z );
void SetVertex( GEOM::GEOM_Object_ptr vertex ) void SetVertex( GEOM::GEOM_Object_ptr vertex );
; void SetNode ( CORBA::Long nodeID );
void SetNode ( CORBA::Long nodeID )
;
void SetThreshold ( const char* threshold, void SetThreshold ( const char* threshold,
SMESH::ConnectedElements::ThresholdType type ) SMESH::ConnectedElements::ThresholdType type );
;
char* GetThreshold ( SMESH::ConnectedElements::ThresholdType& type ); char* GetThreshold ( SMESH::ConnectedElements::ThresholdType& type );
private: private:

31
src/SMESH_I/SMESH_Gen_i.cxx
View File

@ -414,7 +414,6 @@ SMESH_Gen_i::~SMESH_Gen_i()
GenericHypothesisCreator_i* SMESH_Gen_i::getHypothesisCreator(const char* theHypName, GenericHypothesisCreator_i* SMESH_Gen_i::getHypothesisCreator(const char* theHypName,
const char* theLibName, const char* theLibName,
std::string& thePlatformLibName) std::string& thePlatformLibName)
{ {
std::string aPlatformLibName; std::string aPlatformLibName;
/* It's Need to translate lib name for WIN32 or X platform */ /* It's Need to translate lib name for WIN32 or X platform */
@ -565,7 +564,6 @@ SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::createHypothesis(const char* theHypName
//============================================================================= //=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::createMesh() SMESH::SMESH_Mesh_ptr SMESH_Gen_i::createMesh()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::createMesh" ); if(MYDEBUG) MESSAGE( "SMESH_Gen_i::createMesh" );
@ -814,7 +812,6 @@ StudyContext* SMESH_Gen_i::GetStudyContext()
SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::CreateHypothesis( const char* theHypName, SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::CreateHypothesis( const char* theHypName,
const char* theLibName ) const char* theLibName )
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
// Create hypothesis/algorithm // Create hypothesis/algorithm
@ -849,7 +846,6 @@ SMESH_Gen_i::CreateHypothesisByAverageLength( const char* theHypType,
const char* theLibName, const char* theLibName,
CORBA::Double theAverageLength, CORBA::Double theAverageLength,
CORBA::Boolean theQuadDominated) CORBA::Boolean theQuadDominated)
{ {
SMESH::HypInitParams initParams = { ::SMESH_Hypothesis::BY_AVERAGE_LENGTH, SMESH::HypInitParams initParams = { ::SMESH_Hypothesis::BY_AVERAGE_LENGTH,
theAverageLength, theQuadDominated }; theAverageLength, theQuadDominated };
@ -890,7 +886,6 @@ SMESH_Gen_i::GetHypothesisParameterValues( const char* theHypTyp
SMESH::SMESH_Mesh_ptr theMesh, SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theGeom, GEOM::GEOM_Object_ptr theGeom,
const SMESH::HypInitParams& theParams) const SMESH::HypInitParams& theParams)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
@ -1080,7 +1075,6 @@ CORBA::Boolean SMESH_Gen_i::GetSoleSubMeshUsingHyp( SMESH::SMESH_Hypothesis_ptr
//============================================================================= //=============================================================================
void SMESH_Gen_i::SetBoundaryBoxSegmentation( CORBA::Long theNbSegments ) void SMESH_Gen_i::SetBoundaryBoxSegmentation( CORBA::Long theNbSegments )
{ {
if ( theNbSegments > 0 ) if ( theNbSegments > 0 )
myGen.SetBoundaryBoxSegmentation( int( theNbSegments )); myGen.SetBoundaryBoxSegmentation( int( theNbSegments ));
@ -1095,7 +1089,6 @@ void SMESH_Gen_i::SetBoundaryBoxSegmentation( CORBA::Long theNbSegments )
//============================================================================= //=============================================================================
void SMESH_Gen_i::SetDefaultNbSegments(CORBA::Long theNbSegments) void SMESH_Gen_i::SetDefaultNbSegments(CORBA::Long theNbSegments)
{ {
if ( theNbSegments > 0 ) if ( theNbSegments > 0 )
myGen.SetDefaultNbSegments( int(theNbSegments) ); myGen.SetDefaultNbSegments( int(theNbSegments) );
@ -1201,7 +1194,6 @@ char* SMESH_Gen_i::GetOption(const char* name)
//============================================================================= //=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMesh( GEOM::GEOM_Object_ptr theShapeObject ) SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMesh( GEOM::GEOM_Object_ptr theShapeObject )
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" ); if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" );
@ -1236,7 +1228,6 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMesh( GEOM::GEOM_Object_ptr theShapeObj
//============================================================================= //=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateEmptyMesh() SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateEmptyMesh()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" ); if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" );
@ -1290,7 +1281,6 @@ namespace
//============================================================================= //=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromUNV( const char* theFileName ) SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromUNV( const char* theFileName )
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
@ -1421,7 +1411,6 @@ SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMEDorSAUV( const char* theFileNa
SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMED( const char* theFileName, SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMED( const char* theFileName,
SMESH::DriverMED_ReadStatus& theStatus) SMESH::DriverMED_ReadStatus& theStatus)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName ); checkFileReadable( theFileName );
@ -1441,7 +1430,6 @@ SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMED( const char*
SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromSAUV( const char* theFileName, SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromSAUV( const char* theFileName,
SMESH::DriverMED_ReadStatus& theStatus) SMESH::DriverMED_ReadStatus& theStatus)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName ); checkFileReadable( theFileName );
@ -1484,7 +1472,6 @@ SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromSAUV( const char*
//============================================================================= //=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromSTL( const char* theFileName ) SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromSTL( const char* theFileName )
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName ); checkFileReadable( theFileName );
@ -1525,7 +1512,6 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromSTL( const char* theFileName
SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromCGNS( const char* theFileName, SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromCGNS( const char* theFileName,
SMESH::DriverMED_ReadStatus& theStatus) SMESH::DriverMED_ReadStatus& theStatus)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName ); checkFileReadable( theFileName );
@ -1613,7 +1599,6 @@ SMESH::SMESH_Mesh_ptr
SMESH_Gen_i::CreateMeshesFromGMF( const char* theFileName, SMESH_Gen_i::CreateMeshesFromGMF( const char* theFileName,
CORBA::Boolean theMakeRequiredGroups, CORBA::Boolean theMakeRequiredGroups,
SMESH::ComputeError_out theError) SMESH::ComputeError_out theError)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName ); checkFileReadable( theFileName );
@ -1657,7 +1642,6 @@ SMESH_Gen_i::CreateMeshesFromGMF( const char* theFileName,
CORBA::Boolean SMESH_Gen_i::IsReadyToCompute( SMESH::SMESH_Mesh_ptr theMesh, CORBA::Boolean SMESH_Gen_i::IsReadyToCompute( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShapeObject ) GEOM::GEOM_Object_ptr theShapeObject )
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::IsReadyToCompute" ); if(MYDEBUG) MESSAGE( "SMESH_Gen_i::IsReadyToCompute" );
@ -1732,7 +1716,6 @@ SALOMEDS::SObject_ptr SMESH_Gen_i::GetAlgoSO(const ::SMESH_Algo* algo)
SMESH::compute_error_array* SMESH_Gen_i::GetComputeErrors( SMESH::SMESH_Mesh_ptr theMesh, SMESH::compute_error_array* SMESH_Gen_i::GetComputeErrors( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theSubObject ) GEOM::GEOM_Object_ptr theSubObject )
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetComputeErrors()" ); if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetComputeErrors()" );
@ -1807,7 +1790,6 @@ SMESH::compute_error_array* SMESH_Gen_i::GetComputeErrors( SMESH::SMESH_Mesh_ptr
SMESH::MeshPreviewStruct* SMESH::MeshPreviewStruct*
SMESH_Gen_i::GetBadInputElements( SMESH::SMESH_Mesh_ptr theMesh, SMESH_Gen_i::GetBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Short theSubShapeID ) CORBA::Short theSubShapeID )
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetBadInputElements()" ); if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetBadInputElements()" );
@ -1895,7 +1877,6 @@ SMESH::ListOfGroups*
SMESH_Gen_i::MakeGroupsOfBadInputElements( SMESH::SMESH_Mesh_ptr theMesh, SMESH_Gen_i::MakeGroupsOfBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Short theSubShapeID, CORBA::Short theSubShapeID,
const char* theGroupName ) const char* theGroupName )
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
@ -1930,7 +1911,6 @@ SMESH_Gen_i::MakeGroupsOfBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
SMESH::algo_error_array* SMESH_Gen_i::GetAlgoState( SMESH::SMESH_Mesh_ptr theMesh, SMESH::algo_error_array* SMESH_Gen_i::GetAlgoState( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theSubObject ) GEOM::GEOM_Object_ptr theSubObject )
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetAlgoState()" ); if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetAlgoState()" );
@ -1992,7 +1972,6 @@ SMESH::algo_error_array* SMESH_Gen_i::GetAlgoState( SMESH::SMESH_Mesh_ptr theMes
SMESH::long_array* SMESH::long_array*
SMESH_Gen_i::GetSubShapesId( GEOM::GEOM_Object_ptr theMainShapeObject, SMESH_Gen_i::GetSubShapesId( GEOM::GEOM_Object_ptr theMainShapeObject,
const SMESH::object_array& theListOfSubShapeObject ) const SMESH::object_array& theListOfSubShapeObject )
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetSubShapesId" ); if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetSubShapesId" );
@ -2066,7 +2045,6 @@ SMESH_Gen_i::GetSubShapesId( GEOM::GEOM_Object_ptr theMainShapeObject,
CORBA::Boolean SMESH_Gen_i::Compute( SMESH::SMESH_Mesh_ptr theMesh, CORBA::Boolean SMESH_Gen_i::Compute( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShapeObject ) GEOM::GEOM_Object_ptr theShapeObject )
{ {
//MEMOSTAT; //MEMOSTAT;
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
@ -2163,7 +2141,6 @@ SMESH::MeshPreviewStruct* SMESH_Gen_i::Precompute( SMESH::SMESH_Mesh_ptr theMesh
GEOM::GEOM_Object_ptr theShapeObject, GEOM::GEOM_Object_ptr theShapeObject,
SMESH::Dimension theDimension, SMESH::Dimension theDimension,
SMESH::long_array& theShapesId) SMESH::long_array& theShapesId)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Precompute" ); if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Precompute" );
@ -2351,7 +2328,6 @@ SMESH::MeshPreviewStruct* SMESH_Gen_i::Precompute( SMESH::SMESH_Mesh_ptr theMesh
SMESH::long_array* SMESH_Gen_i::Evaluate(SMESH::SMESH_Mesh_ptr theMesh, SMESH::long_array* SMESH_Gen_i::Evaluate(SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShapeObject) GEOM::GEOM_Object_ptr theShapeObject)
// SMESH::long_array& theNbElems) // SMESH::long_array& theNbElems)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Evaluate" ); if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Evaluate" );
@ -2439,7 +2415,6 @@ GEOM::GEOM_Object_ptr
SMESH_Gen_i::GetGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh, SMESH_Gen_i::GetGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Long theElementID, CORBA::Long theElementID,
const char* theGeomName) const char* theGeomName)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
@ -2503,7 +2478,6 @@ SMESH_Gen_i::GetGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr GEOM::GEOM_Object_ptr
SMESH_Gen_i::FindGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh, SMESH_Gen_i::FindGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Long theElementID) CORBA::Long theElementID)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( CORBA::is_nil( theMesh ) ) if ( CORBA::is_nil( theMesh ) )
@ -2579,7 +2553,6 @@ SMESH_Gen_i::Concatenate(const SMESH::ListOfIDSources& theMeshesArray,
CORBA::Boolean theMergeNodesAndElements, CORBA::Boolean theMergeNodesAndElements,
CORBA::Double theMergeTolerance, CORBA::Double theMergeTolerance,
SMESH::SMESH_Mesh_ptr theMeshToAppendTo) SMESH::SMESH_Mesh_ptr theMeshToAppendTo)
{ {
return ConcatenateCommon(theMeshesArray, return ConcatenateCommon(theMeshesArray,
theUniteIdenticalGroups, theUniteIdenticalGroups,
@ -2604,7 +2577,6 @@ SMESH_Gen_i::ConcatenateWithGroups(const SMESH::ListOfIDSources& theMeshesArray,
CORBA::Boolean theMergeNodesAndElements, CORBA::Boolean theMergeNodesAndElements,
CORBA::Double theMergeTolerance, CORBA::Double theMergeTolerance,
SMESH::SMESH_Mesh_ptr theMeshToAppendTo) SMESH::SMESH_Mesh_ptr theMeshToAppendTo)
{ {
return ConcatenateCommon(theMeshesArray, return ConcatenateCommon(theMeshesArray,
theUniteIdenticalGroups, theUniteIdenticalGroups,
@ -2629,7 +2601,6 @@ SMESH_Gen_i::ConcatenateCommon(const SMESH::ListOfIDSources& theMeshesArray,
CORBA::Double theMergeTolerance, CORBA::Double theMergeTolerance,
CORBA::Boolean theCommonGroups, CORBA::Boolean theCommonGroups,
SMESH::SMESH_Mesh_ptr theMeshToAppendTo) SMESH::SMESH_Mesh_ptr theMeshToAppendTo)
{ {
std::unique_ptr< TPythonDump > pPythonDump( new TPythonDump ); std::unique_ptr< TPythonDump > pPythonDump( new TPythonDump );
TPythonDump& pythonDump = *pPythonDump; // prevent dump of called methods TPythonDump& pythonDump = *pPythonDump; // prevent dump of called methods
@ -2909,7 +2880,6 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CopyMesh(SMESH::SMESH_IDSource_ptr meshPart,
const char* meshName, const char* meshName,
CORBA::Boolean toCopyGroups, CORBA::Boolean toCopyGroups,
CORBA::Boolean toKeepIDs) CORBA::Boolean toKeepIDs)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
@ -3684,7 +3654,6 @@ CORBA::Boolean SMESH_Gen_i::CopyMeshWithGeom( SMESH::SMESH_Mesh_ptr theSou
SMESH::submesh_array_out theNewSubmeshes, SMESH::submesh_array_out theNewSubmeshes,
SMESH::ListOfHypothesis_out theNewHypotheses, SMESH::ListOfHypothesis_out theNewHypotheses,
SMESH::string_array_out theInvalidEntries) SMESH::string_array_out theInvalidEntries)
{ {
if ( CORBA::is_nil( theSourceMesh ) || if ( CORBA::is_nil( theSourceMesh ) ||
CORBA::is_nil( theNewGeometry )) CORBA::is_nil( theNewGeometry ))

94
src/SMESH_I/SMESH_Gen_i.hxx
View File

@ -167,14 +167,12 @@ public:
// Create hypothesis/algorithm of given type // Create hypothesis/algorithm of given type
SMESH::SMESH_Hypothesis_ptr CreateHypothesis (const char* theHypType, SMESH::SMESH_Hypothesis_ptr CreateHypothesis (const char* theHypType,
const char* theLibName) const char* theLibName);
;
SMESH::SMESH_Hypothesis_ptr CreateHypothesisByAverageLength( const char* theHypType, SMESH::SMESH_Hypothesis_ptr CreateHypothesisByAverageLength( const char* theHypType,
const char* theLibName, const char* theLibName,
CORBA::Double theAverageLength, CORBA::Double theAverageLength,
CORBA::Boolean theQuadDominated) CORBA::Boolean theQuadDominated);
;
// Return hypothesis of given type holding parameter values of the existing mesh // Return hypothesis of given type holding parameter values of the existing mesh
SMESH::SMESH_Hypothesis_ptr SMESH::SMESH_Hypothesis_ptr
@ -182,8 +180,7 @@ public:
const char* theLibName, const char* theLibName,
SMESH::SMESH_Mesh_ptr theMesh, SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theGeom, GEOM::GEOM_Object_ptr theGeom,
const SMESH::HypInitParams& theWay) const SMESH::HypInitParams& theWay);
;
/* /*
* Returns True if a hypothesis is assigned to a sole sub-mesh in a current Study * Returns True if a hypothesis is assigned to a sole sub-mesh in a current Study
@ -198,11 +195,11 @@ public:
* Sets number of segments per diagonal of boundary box of geometry by which * Sets number of segments per diagonal of boundary box of geometry by which
* default segment length of appropriate 1D hypotheses is defined * default segment length of appropriate 1D hypotheses is defined
*/ */
void SetBoundaryBoxSegmentation( CORBA::Long theNbSegments ) ; void SetBoundaryBoxSegmentation( CORBA::Long theNbSegments );
/*! /*!
* \brief Sets default number of segments per edge * \brief Sets default number of segments per edge
*/ */
void SetDefaultNbSegments(CORBA::Long theNbSegments) ; void SetDefaultNbSegments(CORBA::Long theNbSegments);
/*! /*!
Set an option value Set an option value
@ -220,48 +217,39 @@ public:
// Create empty mesh on a shape // Create empty mesh on a shape
SMESH::SMESH_Mesh_ptr CreateMesh( GEOM::GEOM_Object_ptr theShapeObject ) SMESH::SMESH_Mesh_ptr CreateMesh( GEOM::GEOM_Object_ptr theShapeObject );
;
// Create empty mesh // Create empty mesh
SMESH::SMESH_Mesh_ptr CreateEmptyMesh() SMESH::SMESH_Mesh_ptr CreateEmptyMesh();
;
// Create a mesh and import data from an UNV file // Create a mesh and import data from an UNV file
SMESH::SMESH_Mesh_ptr CreateMeshesFromUNV( const char* theFileName ) SMESH::SMESH_Mesh_ptr CreateMeshesFromUNV( const char* theFileName );
;
// Create mesh(es) and import data from MED file // Create mesh(es) and import data from MED file
SMESH::mesh_array* CreateMeshesFromMED( const char* theFileName, SMESH::mesh_array* CreateMeshesFromMED( const char* theFileName,
SMESH::DriverMED_ReadStatus& theStatus ) SMESH::DriverMED_ReadStatus& theStatus );
;
// Create mesh(es) and import data from MED file // Create mesh(es) and import data from MED file
SMESH::mesh_array* CreateMeshesFromSAUV( const char* theFileName, SMESH::mesh_array* CreateMeshesFromSAUV( const char* theFileName,
SMESH::DriverMED_ReadStatus& theStatus ) SMESH::DriverMED_ReadStatus& theStatus );
;
// Create a mesh and import data from a STL file // Create a mesh and import data from a STL file
SMESH::SMESH_Mesh_ptr CreateMeshesFromSTL( const char* theFileName ) SMESH::SMESH_Mesh_ptr CreateMeshesFromSTL( const char* theFileName );
;
// Create mesh(es) and import data from CGNS file // Create mesh(es) and import data from CGNS file
SMESH::mesh_array* CreateMeshesFromCGNS( const char* theFileName, SMESH::mesh_array* CreateMeshesFromCGNS( const char* theFileName,
SMESH::DriverMED_ReadStatus& theStatus ) SMESH::DriverMED_ReadStatus& theStatus );
;
// Create a mesh and import data from a GMF file // Create a mesh and import data from a GMF file
SMESH::SMESH_Mesh_ptr CreateMeshesFromGMF( const char* theFileName, SMESH::SMESH_Mesh_ptr CreateMeshesFromGMF( const char* theFileName,
CORBA::Boolean theMakeRequiredGroups, CORBA::Boolean theMakeRequiredGroups,
SMESH::ComputeError_out theError) SMESH::ComputeError_out theError);
;
// Copy a part of mesh // Copy a part of mesh
SMESH::SMESH_Mesh_ptr CopyMesh(SMESH::SMESH_IDSource_ptr meshPart, SMESH::SMESH_Mesh_ptr CopyMesh(SMESH::SMESH_IDSource_ptr meshPart,
const char* meshName, const char* meshName,
CORBA::Boolean toCopyGroups, CORBA::Boolean toCopyGroups,
CORBA::Boolean toKeepIDs) CORBA::Boolean toKeepIDs);
;
// Create a mesh by copying definitions of another mesh to a given geometry // Create a mesh by copying definitions of another mesh to a given geometry
CORBA::Boolean CopyMeshWithGeom( SMESH::SMESH_Mesh_ptr sourceMesh, CORBA::Boolean CopyMeshWithGeom( SMESH::SMESH_Mesh_ptr sourceMesh,
@ -274,13 +262,11 @@ public:
SMESH::ListOfGroups_out newGroups, SMESH::ListOfGroups_out newGroups,
SMESH::submesh_array_out newSubmeshes, SMESH::submesh_array_out newSubmeshes,
SMESH::ListOfHypothesis_out newHypotheses, SMESH::ListOfHypothesis_out newHypotheses,
SMESH::string_array_out invalidEntries) SMESH::string_array_out invalidEntries);
;
// Compute mesh on a shape // Compute mesh on a shape
CORBA::Boolean Compute( SMESH::SMESH_Mesh_ptr theMesh, CORBA::Boolean Compute( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShapeObject ) GEOM::GEOM_Object_ptr theShapeObject );
;
// Cancel Compute mesh on a shape // Cancel Compute mesh on a shape
void CancelCompute( SMESH::SMESH_Mesh_ptr theMesh, void CancelCompute( SMESH::SMESH_Mesh_ptr theMesh,
@ -290,8 +276,7 @@ public:
* \brief Return errors of mesh computation * \brief Return errors of mesh computation
*/ */
SMESH::compute_error_array* GetComputeErrors(SMESH::SMESH_Mesh_ptr theMesh, SMESH::compute_error_array* GetComputeErrors(SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShapeObject ) GEOM::GEOM_Object_ptr theShapeObject );
;
/*! /*!
* Evaluate mesh on a shape and * Evaluate mesh on a shape and
@ -299,13 +284,11 @@ public:
* Result array of number enityties * Result array of number enityties
*/ */
SMESH::long_array* Evaluate(SMESH::SMESH_Mesh_ptr theMesh, SMESH::long_array* Evaluate(SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShapeObject) GEOM::GEOM_Object_ptr theShapeObject);
;
// Returns true if mesh contains enough data to be computed // Returns true if mesh contains enough data to be computed
CORBA::Boolean IsReadyToCompute( SMESH::SMESH_Mesh_ptr theMesh, CORBA::Boolean IsReadyToCompute( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShapeObject ) GEOM::GEOM_Object_ptr theShapeObject );
;
/*! /*!
* Calculate Mesh as preview till indicated dimension on shape * Calculate Mesh as preview till indicated dimension on shape
@ -315,40 +298,33 @@ public:
SMESH::MeshPreviewStruct* Precompute( SMESH::SMESH_Mesh_ptr theMesh, SMESH::MeshPreviewStruct* Precompute( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theSubObject, GEOM::GEOM_Object_ptr theSubObject,
SMESH::Dimension theDimension, SMESH::Dimension theDimension,
SMESH::long_array& theShapesId ) SMESH::long_array& theShapesId );
;
// Returns errors of hypotheses definition // Returns errors of hypotheses definition
SMESH::algo_error_array* GetAlgoState( SMESH::SMESH_Mesh_ptr theMesh, SMESH::algo_error_array* GetAlgoState( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theSubObject ) GEOM::GEOM_Object_ptr theSubObject );
;
// Return mesh elements preventing computation of a subshape // Return mesh elements preventing computation of a subshape
SMESH::MeshPreviewStruct* GetBadInputElements( SMESH::SMESH_Mesh_ptr theMesh, SMESH::MeshPreviewStruct* GetBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Short theSubShapeID ) CORBA::Short theSubShapeID );
;
// Create groups of elements preventing computation of a sub-shape // Create groups of elements preventing computation of a sub-shape
SMESH::ListOfGroups* MakeGroupsOfBadInputElements( SMESH::SMESH_Mesh_ptr theMesh, SMESH::ListOfGroups* MakeGroupsOfBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Short theSubShapeID, CORBA::Short theSubShapeID,
const char* theGroupName) const char* theGroupName);
;
// Get sub-shapes unique ID's list // Get sub-shapes unique ID's list
SMESH::long_array* GetSubShapesId( GEOM::GEOM_Object_ptr theMainShapeObject, SMESH::long_array* GetSubShapesId( GEOM::GEOM_Object_ptr theMainShapeObject,
const SMESH::object_array& theListOfSubShape ) const SMESH::object_array& theListOfSubShape );
;
// Return geometrical object the given element is built on. Publish it in study. // Return geometrical object the given element is built on. Publish it in study.
GEOM::GEOM_Object_ptr GetGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh, GEOM::GEOM_Object_ptr GetGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Long theElementID, CORBA::Long theElementID,
const char* theGeomName) const char* theGeomName);
;
// Return geometrical object the given element is built on. Don't publish it in study. // Return geometrical object the given element is built on. Don't publish it in study.
GEOM::GEOM_Object_ptr FindGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh, GEOM::GEOM_Object_ptr FindGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Long theElementID) CORBA::Long theElementID);
;
// Concatenate the given meshes into one mesh // Concatenate the given meshes into one mesh
SMESH::SMESH_Mesh_ptr ConcatenateCommon(const SMESH::ListOfIDSources& meshesArray, SMESH::SMESH_Mesh_ptr ConcatenateCommon(const SMESH::ListOfIDSources& meshesArray,
@ -356,16 +332,14 @@ public:
CORBA::Boolean mergeNodesAndElements, CORBA::Boolean mergeNodesAndElements,
CORBA::Double mergeTolerance, CORBA::Double mergeTolerance,
CORBA::Boolean commonGroups, CORBA::Boolean commonGroups,
SMESH::SMESH_Mesh_ptr meshToAppendTo) SMESH::SMESH_Mesh_ptr meshToAppendTo);
;
// Concatenate the given meshes into one mesh // Concatenate the given meshes into one mesh
SMESH::SMESH_Mesh_ptr Concatenate(const SMESH::ListOfIDSources& meshesArray, SMESH::SMESH_Mesh_ptr Concatenate(const SMESH::ListOfIDSources& meshesArray,
CORBA::Boolean uniteIdenticalGroups, CORBA::Boolean uniteIdenticalGroups,
CORBA::Boolean mergeNodesAndElements, CORBA::Boolean mergeNodesAndElements,
CORBA::Double mergeTolerance, CORBA::Double mergeTolerance,
SMESH::SMESH_Mesh_ptr meshToAppendTo) SMESH::SMESH_Mesh_ptr meshToAppendTo);
;
// Concatenate the given meshes into one mesh // Concatenate the given meshes into one mesh
// Create the groups of all elements from initial meshes // Create the groups of all elements from initial meshes
@ -373,8 +347,7 @@ public:
CORBA::Boolean uniteIdenticalGroups, CORBA::Boolean uniteIdenticalGroups,
CORBA::Boolean mergeNodesAndElements, CORBA::Boolean mergeNodesAndElements,
CORBA::Double mergeTolerance, CORBA::Double mergeTolerance,
SMESH::SMESH_Mesh_ptr meshToAppendTo) SMESH::SMESH_Mesh_ptr meshToAppendTo);
;
// Get version of MED format being used. // Get version of MED format being used.
char* GetMEDFileVersion(); char* GetMEDFileVersion();
@ -445,8 +418,7 @@ public:
// Publish object in the study // Publish object in the study
SALOMEDS::SObject_ptr PublishInStudy( SALOMEDS::SObject_ptr theSObject, SALOMEDS::SObject_ptr PublishInStudy( SALOMEDS::SObject_ptr theSObject,
CORBA::Object_ptr theObject, CORBA::Object_ptr theObject,
const char* theName ) const char* theName );
;
// Copy-paste methods - returns true if object can be copied to the clipboard // Copy-paste methods - returns true if object can be copied to the clipboard
CORBA::Boolean CanCopy( SALOMEDS::SObject_ptr /*theObject*/ ) { return false; } CORBA::Boolean CanCopy( SALOMEDS::SObject_ptr /*theObject*/ ) { return false; }
@ -635,14 +607,12 @@ private:
// Get hypothesis creator // Get hypothesis creator
GenericHypothesisCreator_i* getHypothesisCreator( const char* theHypName, GenericHypothesisCreator_i* getHypothesisCreator( const char* theHypName,
const char* theLibName, const char* theLibName,
std::string& thePlatformLibName) std::string& thePlatformLibName);
;
// Create hypothesis of given type // Create hypothesis of given type
SMESH::SMESH_Hypothesis_ptr createHypothesis( const char* theHypName, SMESH::SMESH_Hypothesis_ptr createHypothesis( const char* theHypName,
const char* theLibName); const char* theLibName);
// Create empty mesh on shape // Create empty mesh on shape
SMESH::SMESH_Mesh_ptr createMesh() SMESH::SMESH_Mesh_ptr createMesh();
;
// Check mesh icon // Check mesh icon
bool isGeomModifIcon( SMESH::SMESH_Mesh_ptr mesh ); bool isGeomModifIcon( SMESH::SMESH_Mesh_ptr mesh );

4
src/SMESH_I/SMESH_Group_i.hxx
View File

@ -196,7 +196,7 @@ class SMESH_I_EXPORT SMESH_GroupOnFilter_i:
static SMESH_PredicatePtr GetPredicate( SMESH::Filter_ptr ); static SMESH_PredicatePtr GetPredicate( SMESH::Filter_ptr );
// CORBA interface implementation // CORBA interface implementation
void SetFilter(SMESH::Filter_ptr theFilter) ; void SetFilter(SMESH::Filter_ptr theFilter);
SMESH::Filter_ptr GetFilter(); SMESH::Filter_ptr GetFilter();
virtual CORBA::Boolean IsUpToDate(); virtual CORBA::Boolean IsUpToDate();
virtual SMESH::long_array* GetListOfID(); virtual SMESH::long_array* GetListOfID();
@ -206,7 +206,7 @@ class SMESH_I_EXPORT SMESH_GroupOnFilter_i:
virtual bool IsMeshInfoCorrect(); virtual bool IsMeshInfoCorrect();
// method of SMESH::NotifyerAndWaiter to update self when myFilter changes // method of SMESH::NotifyerAndWaiter to update self when myFilter changes
virtual void OnBaseObjModified(NotifyerAndWaiter* /*filter*/, bool); virtual void OnBaseObjModified(NotifyerAndWaiter* filter, bool);
private: private:
SMESH::Filter_var myFilter; SMESH::Filter_var myFilter;

137
src/SMESH_I/SMESH_MeshEditor_i.cxx
View File

@ -523,7 +523,6 @@ TPreviewMesh * SMESH_MeshEditor_i::getPreviewMesh(SMDSAbs_ElementType previewEle
//================================================================================ //================================================================================
SMESH::MeshPreviewStruct* SMESH_MeshEditor_i::GetPreviewData() SMESH::MeshPreviewStruct* SMESH_MeshEditor_i::GetPreviewData()
{ {
SMESH_TRY; SMESH_TRY;
const bool hasBadElems = ( getEditor().GetError() && getEditor().GetError()->HasBadElems() ); const bool hasBadElems = ( getEditor().GetError() && getEditor().GetError()->HasBadElems() );
@ -617,7 +616,6 @@ SMESH::MeshPreviewStruct* SMESH_MeshEditor_i::GetPreviewData()
//================================================================================ //================================================================================
SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedNodes() SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedNodes()
{ {
SMESH_TRY; SMESH_TRY;
SMESH::long_array_var myLastCreatedNodes = new SMESH::long_array(); SMESH::long_array_var myLastCreatedNodes = new SMESH::long_array();
@ -640,7 +638,6 @@ SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedNodes()
//================================================================================ //================================================================================
SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedElems() SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedElems()
{ {
SMESH_TRY; SMESH_TRY;
SMESH::long_array_var myLastCreatedElems = new SMESH::long_array(); SMESH::long_array_var myLastCreatedElems = new SMESH::long_array();
@ -675,7 +672,6 @@ void SMESH_MeshEditor_i::ClearLastCreated()
//======================================================================= //=======================================================================
SMESH::ComputeError* SMESH_MeshEditor_i::GetLastError() SMESH::ComputeError* SMESH_MeshEditor_i::GetLastError()
{ {
SMESH_TRY; SMESH_TRY;
SMESH::ComputeError_var errOut = new SMESH::ComputeError; SMESH::ComputeError_var errOut = new SMESH::ComputeError;
@ -787,7 +783,6 @@ CORBA::Long* SMESH_MeshEditor_i::GetTemporaryIDs( SMESH::SMESH_IDSource_ptr& idS
CORBA::Boolean CORBA::Boolean
SMESH_MeshEditor_i::RemoveElements(const SMESH::long_array & IDsOfElements) SMESH_MeshEditor_i::RemoveElements(const SMESH::long_array & IDsOfElements)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -817,7 +812,6 @@ SMESH_MeshEditor_i::RemoveElements(const SMESH::long_array & IDsOfElements)
//============================================================================= //=============================================================================
CORBA::Boolean SMESH_MeshEditor_i::RemoveNodes(const SMESH::long_array & IDsOfNodes) CORBA::Boolean SMESH_MeshEditor_i::RemoveNodes(const SMESH::long_array & IDsOfNodes)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -845,7 +839,6 @@ CORBA::Boolean SMESH_MeshEditor_i::RemoveNodes(const SMESH::long_array & IDsOfNo
//============================================================================= //=============================================================================
CORBA::Long SMESH_MeshEditor_i::RemoveOrphanNodes() CORBA::Long SMESH_MeshEditor_i::RemoveOrphanNodes()
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -879,7 +872,6 @@ CORBA::Long SMESH_MeshEditor_i::RemoveOrphanNodes()
//============================================================================= //=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddNode(CORBA::Double x,CORBA::Double y, CORBA::Double z) CORBA::Long SMESH_MeshEditor_i::AddNode(CORBA::Double x,CORBA::Double y, CORBA::Double z)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -905,7 +897,6 @@ CORBA::Long SMESH_MeshEditor_i::AddNode(CORBA::Double x,CORBA::Double y, CORBA::
CORBA::Long SMESH_MeshEditor_i::Add0DElement(CORBA::Long IDOfNode, CORBA::Long SMESH_MeshEditor_i::Add0DElement(CORBA::Long IDOfNode,
CORBA::Boolean DuplicateElements) CORBA::Boolean DuplicateElements)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -935,7 +926,6 @@ CORBA::Long SMESH_MeshEditor_i::Add0DElement(CORBA::Long IDOfNode,
//============================================================================= //=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddBall(CORBA::Long IDOfNode, CORBA::Double diameter) CORBA::Long SMESH_MeshEditor_i::AddBall(CORBA::Long IDOfNode, CORBA::Double diameter)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -965,7 +955,6 @@ CORBA::Long SMESH_MeshEditor_i::AddBall(CORBA::Long IDOfNode, CORBA::Double diam
//============================================================================= //=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddEdge(const SMESH::long_array & IDsOfNodes) CORBA::Long SMESH_MeshEditor_i::AddEdge(const SMESH::long_array & IDsOfNodes)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -1009,7 +998,6 @@ CORBA::Long SMESH_MeshEditor_i::AddEdge(const SMESH::long_array & IDsOfNodes)
//============================================================================= //=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes) CORBA::Long SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -1058,7 +1046,6 @@ CORBA::Long SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes)
//============================================================================= //=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace (const SMESH::long_array & IDsOfNodes) CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace (const SMESH::long_array & IDsOfNodes)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -1094,7 +1081,6 @@ CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace (const SMESH::long_array & IDsO
//============================================================================= //=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddQuadPolygonalFace (const SMESH::long_array & IDsOfNodes) CORBA::Long SMESH_MeshEditor_i::AddQuadPolygonalFace (const SMESH::long_array & IDsOfNodes)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -1130,7 +1116,6 @@ CORBA::Long SMESH_MeshEditor_i::AddQuadPolygonalFace (const SMESH::long_array &
//============================================================================= //=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddVolume(const SMESH::long_array & IDsOfNodes) CORBA::Long SMESH_MeshEditor_i::AddVolume(const SMESH::long_array & IDsOfNodes)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -1191,7 +1176,6 @@ CORBA::Long SMESH_MeshEditor_i::AddVolume(const SMESH::long_array & IDsOfNodes)
//============================================================================= //=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolume (const SMESH::long_array & IDsOfNodes, CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolume (const SMESH::long_array & IDsOfNodes,
const SMESH::long_array & Quantities) const SMESH::long_array & Quantities)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -1230,7 +1214,6 @@ CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolume (const SMESH::long_array & I
//============================================================================= //=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolumeByFaces (const SMESH::long_array & IdsOfFaces) CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolumeByFaces (const SMESH::long_array & IdsOfFaces)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -1278,7 +1261,6 @@ SMESH::SMESH_IDSource_ptr
SMESH_MeshEditor_i::Create0DElementsOnAllNodes(SMESH::SMESH_IDSource_ptr theObject, SMESH_MeshEditor_i::Create0DElementsOnAllNodes(SMESH::SMESH_IDSource_ptr theObject,
const char* theGroupName, const char* theGroupName,
CORBA::Boolean theDuplicateElements) CORBA::Boolean theDuplicateElements)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -1348,7 +1330,6 @@ SMESH_MeshEditor_i::Create0DElementsOnAllNodes(SMESH::SMESH_IDSource_ptr theObje
//============================================================================= //=============================================================================
void SMESH_MeshEditor_i::SetNodeOnVertex(CORBA::Long NodeID, CORBA::Long VertexID) void SMESH_MeshEditor_i::SetNodeOnVertex(CORBA::Long NodeID, CORBA::Long VertexID)
{ {
SMESH_TRY; SMESH_TRY;
@ -1383,7 +1364,6 @@ void SMESH_MeshEditor_i::SetNodeOnVertex(CORBA::Long NodeID, CORBA::Long VertexI
void SMESH_MeshEditor_i::SetNodeOnEdge(CORBA::Long NodeID, CORBA::Long EdgeID, void SMESH_MeshEditor_i::SetNodeOnEdge(CORBA::Long NodeID, CORBA::Long EdgeID,
CORBA::Double paramOnEdge) CORBA::Double paramOnEdge)
{ {
SMESH_TRY; SMESH_TRY;
@ -1427,7 +1407,6 @@ void SMESH_MeshEditor_i::SetNodeOnEdge(CORBA::Long NodeID, CORBA::Long EdgeID,
void SMESH_MeshEditor_i::SetNodeOnFace(CORBA::Long NodeID, CORBA::Long FaceID, void SMESH_MeshEditor_i::SetNodeOnFace(CORBA::Long NodeID, CORBA::Long FaceID,
CORBA::Double u, CORBA::Double v) CORBA::Double u, CORBA::Double v)
{ {
SMESH_TRY; SMESH_TRY;
SMESHDS_Mesh * mesh = getMeshDS(); SMESHDS_Mesh * mesh = getMeshDS();
@ -1472,7 +1451,6 @@ void SMESH_MeshEditor_i::SetNodeOnFace(CORBA::Long NodeID, CORBA::Long FaceID,
//============================================================================= //=============================================================================
void SMESH_MeshEditor_i::SetNodeInVolume(CORBA::Long NodeID, CORBA::Long SolidID) void SMESH_MeshEditor_i::SetNodeInVolume(CORBA::Long NodeID, CORBA::Long SolidID)
{ {
SMESH_TRY; SMESH_TRY;
SMESHDS_Mesh * mesh = getMeshDS(); SMESHDS_Mesh * mesh = getMeshDS();
@ -1503,7 +1481,6 @@ void SMESH_MeshEditor_i::SetNodeInVolume(CORBA::Long NodeID, CORBA::Long SolidID
void SMESH_MeshEditor_i::SetMeshElementOnShape(CORBA::Long ElementID, void SMESH_MeshEditor_i::SetMeshElementOnShape(CORBA::Long ElementID,
CORBA::Long ShapeID) CORBA::Long ShapeID)
{ {
SMESH_TRY; SMESH_TRY;
SMESHDS_Mesh * mesh = getMeshDS(); SMESHDS_Mesh * mesh = getMeshDS();
@ -1536,7 +1513,6 @@ void SMESH_MeshEditor_i::SetMeshElementOnShape(CORBA::Long ElementID,
CORBA::Boolean SMESH_MeshEditor_i::InverseDiag(CORBA::Long NodeID1, CORBA::Boolean SMESH_MeshEditor_i::InverseDiag(CORBA::Long NodeID1,
CORBA::Long NodeID2) CORBA::Long NodeID2)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -1567,7 +1543,6 @@ CORBA::Boolean SMESH_MeshEditor_i::InverseDiag(CORBA::Long NodeID1,
CORBA::Boolean SMESH_MeshEditor_i::DeleteDiag(CORBA::Long NodeID1, CORBA::Boolean SMESH_MeshEditor_i::DeleteDiag(CORBA::Long NodeID1,
CORBA::Long NodeID2) CORBA::Long NodeID2)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -1599,7 +1574,6 @@ CORBA::Boolean SMESH_MeshEditor_i::DeleteDiag(CORBA::Long NodeID1,
//============================================================================= //=============================================================================
CORBA::Boolean SMESH_MeshEditor_i::Reorient(const SMESH::long_array & IDsOfElements) CORBA::Boolean SMESH_MeshEditor_i::Reorient(const SMESH::long_array & IDsOfElements)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -1628,7 +1602,6 @@ CORBA::Boolean SMESH_MeshEditor_i::Reorient(const SMESH::long_array & IDsOfEleme
//============================================================================= //=============================================================================
CORBA::Boolean SMESH_MeshEditor_i::ReorientObject(SMESH::SMESH_IDSource_ptr theObject) CORBA::Boolean SMESH_MeshEditor_i::ReorientObject(SMESH::SMESH_IDSource_ptr theObject)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -1665,7 +1638,6 @@ CORBA::Long SMESH_MeshEditor_i::Reorient2D(SMESH::SMESH_IDSource_ptr the2Dgroup,
const SMESH::DirStruct& theDirection, const SMESH::DirStruct& theDirection,
CORBA::Long theFace, CORBA::Long theFace,
const SMESH::PointStruct& thePoint) const SMESH::PointStruct& thePoint)
{ {
SMESH_TRY; SMESH_TRY;
initData(/*deleteSearchers=*/false); initData(/*deleteSearchers=*/false);
@ -1749,7 +1721,6 @@ CORBA::Long SMESH_MeshEditor_i::Reorient2D(SMESH::SMESH_IDSource_ptr the2Dgroup,
CORBA::Long SMESH_MeshEditor_i::Reorient2DBy3D(const SMESH::ListOfIDSources& faceGroups, CORBA::Long SMESH_MeshEditor_i::Reorient2DBy3D(const SMESH::ListOfIDSources& faceGroups,
SMESH::SMESH_IDSource_ptr volumeGroup, SMESH::SMESH_IDSource_ptr volumeGroup,
CORBA::Boolean outsideNormal) CORBA::Boolean outsideNormal)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -1800,7 +1771,6 @@ CORBA::Long SMESH_MeshEditor_i::Reorient2DBy3D(const SMESH::ListOfIDSources& fac
CORBA::Boolean SMESH_MeshEditor_i::TriToQuad (const SMESH::long_array & IDsOfElements, CORBA::Boolean SMESH_MeshEditor_i::TriToQuad (const SMESH::long_array & IDsOfElements,
SMESH::NumericalFunctor_ptr Criterion, SMESH::NumericalFunctor_ptr Criterion,
CORBA::Double MaxAngle) CORBA::Double MaxAngle)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -1849,7 +1819,6 @@ CORBA::Boolean SMESH_MeshEditor_i::TriToQuad (const SMESH::long_array & IDsOfE
CORBA::Boolean SMESH_MeshEditor_i::TriToQuadObject (SMESH::SMESH_IDSource_ptr theObject, CORBA::Boolean SMESH_MeshEditor_i::TriToQuadObject (SMESH::SMESH_IDSource_ptr theObject,
SMESH::NumericalFunctor_ptr Criterion, SMESH::NumericalFunctor_ptr Criterion,
CORBA::Double MaxAngle) CORBA::Double MaxAngle)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -1883,7 +1852,6 @@ CORBA::Boolean SMESH_MeshEditor_i::TriToQuadObject (SMESH::SMESH_IDSource_ptr
CORBA::Boolean SMESH_MeshEditor_i::QuadToTri (const SMESH::long_array & IDsOfElements, CORBA::Boolean SMESH_MeshEditor_i::QuadToTri (const SMESH::long_array & IDsOfElements,
SMESH::NumericalFunctor_ptr Criterion) SMESH::NumericalFunctor_ptr Criterion)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -1921,7 +1889,6 @@ CORBA::Boolean SMESH_MeshEditor_i::QuadToTri (const SMESH::long_array & IDsOfE
CORBA::Boolean SMESH_MeshEditor_i::QuadToTriObject (SMESH::SMESH_IDSource_ptr theObject, CORBA::Boolean SMESH_MeshEditor_i::QuadToTriObject (SMESH::SMESH_IDSource_ptr theObject,
SMESH::NumericalFunctor_ptr Criterion) SMESH::NumericalFunctor_ptr Criterion)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -1953,7 +1920,6 @@ CORBA::Boolean SMESH_MeshEditor_i::QuadToTriObject (SMESH::SMESH_IDSource_ptr
//================================================================================ //================================================================================
void SMESH_MeshEditor_i::QuadTo4Tri (SMESH::SMESH_IDSource_ptr theObject) void SMESH_MeshEditor_i::QuadTo4Tri (SMESH::SMESH_IDSource_ptr theObject)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -1977,7 +1943,6 @@ void SMESH_MeshEditor_i::QuadTo4Tri (SMESH::SMESH_IDSource_ptr theObject)
CORBA::Boolean SMESH_MeshEditor_i::SplitQuad (const SMESH::long_array & IDsOfElements, CORBA::Boolean SMESH_MeshEditor_i::SplitQuad (const SMESH::long_array & IDsOfElements,
CORBA::Boolean Diag13) CORBA::Boolean Diag13)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -2007,7 +1972,6 @@ CORBA::Boolean SMESH_MeshEditor_i::SplitQuad (const SMESH::long_array & IDsOfEle
CORBA::Boolean SMESH_MeshEditor_i::SplitQuadObject (SMESH::SMESH_IDSource_ptr theObject, CORBA::Boolean SMESH_MeshEditor_i::SplitQuadObject (SMESH::SMESH_IDSource_ptr theObject,
CORBA::Boolean Diag13) CORBA::Boolean Diag13)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -2042,7 +2006,6 @@ CORBA::Boolean SMESH_MeshEditor_i::SplitQuadObject (SMESH::SMESH_IDSource_ptr th
CORBA::Long SMESH_MeshEditor_i::BestSplit (CORBA::Long IDOfQuad, CORBA::Long SMESH_MeshEditor_i::BestSplit (CORBA::Long IDOfQuad,
SMESH::NumericalFunctor_ptr Criterion) SMESH::NumericalFunctor_ptr Criterion)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -2075,7 +2038,6 @@ CORBA::Long SMESH_MeshEditor_i::BestSplit (CORBA::Long IDOfQuad,
void SMESH_MeshEditor_i::SplitVolumesIntoTetra (SMESH::SMESH_IDSource_ptr elems, void SMESH_MeshEditor_i::SplitVolumesIntoTetra (SMESH::SMESH_IDSource_ptr elems,
CORBA::Short methodFlags) CORBA::Short methodFlags)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -2113,7 +2075,6 @@ void SMESH_MeshEditor_i::SplitHexahedraIntoPrisms( SMESH::SMESH_IDSource_ptr el
const SMESH::DirStruct& facetToSplitNormal, const SMESH::DirStruct& facetToSplitNormal,
CORBA::Short methodFlags, CORBA::Short methodFlags,
CORBA::Boolean allDomains) CORBA::Boolean allDomains)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -2174,7 +2135,6 @@ void SMESH_MeshEditor_i::SplitHexahedraIntoPrisms( SMESH::SMESH_IDSource_ptr el
//================================================================================ //================================================================================
void SMESH_MeshEditor_i::SplitBiQuadraticIntoLinear(const SMESH::ListOfIDSources& theElems) void SMESH_MeshEditor_i::SplitBiQuadraticIntoLinear(const SMESH::ListOfIDSources& theElems)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -2210,7 +2170,6 @@ SMESH_MeshEditor_i::Smooth(const SMESH::long_array & IDsOfElements,
CORBA::Long MaxNbOfIterations, CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio, CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method) SMESH::SMESH_MeshEditor::Smooth_Method Method)
{ {
return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations, return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
MaxAspectRatio, Method, false ); MaxAspectRatio, Method, false );
@ -2228,7 +2187,6 @@ SMESH_MeshEditor_i::SmoothParametric(const SMESH::long_array & IDsO
CORBA::Long MaxNbOfIterations, CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio, CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method) SMESH::SMESH_MeshEditor::Smooth_Method Method)
{ {
return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations, return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
MaxAspectRatio, Method, true ); MaxAspectRatio, Method, true );
@ -2246,7 +2204,6 @@ SMESH_MeshEditor_i::SmoothObject(SMESH::SMESH_IDSource_ptr theObjec
CORBA::Long MaxNbOfIterations, CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio, CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method) SMESH::SMESH_MeshEditor::Smooth_Method Method)
{ {
return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations, return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
MaxAspectRatio, Method, false); MaxAspectRatio, Method, false);
@ -2264,7 +2221,6 @@ SMESH_MeshEditor_i::SmoothParametricObject(SMESH::SMESH_IDSource_ptr
CORBA::Long MaxNbOfIterations, CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio, CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method) SMESH::SMESH_MeshEditor::Smooth_Method Method)
{ {
return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations, return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
MaxAspectRatio, Method, true); MaxAspectRatio, Method, true);
@ -2284,7 +2240,6 @@ SMESH_MeshEditor_i::smooth(const SMESH::long_array & IDsOfElements,
CORBA::Double MaxAspectRatio, CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method, SMESH::SMESH_MeshEditor::Smooth_Method Method,
bool IsParametric) bool IsParametric)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -2338,7 +2293,6 @@ SMESH_MeshEditor_i::smoothObject(SMESH::SMESH_IDSource_ptr theObjec
CORBA::Double MaxAspectRatio, CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method, SMESH::SMESH_MeshEditor::Smooth_Method Method,
bool IsParametric) bool IsParametric)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -2372,7 +2326,6 @@ SMESH_MeshEditor_i::smoothObject(SMESH::SMESH_IDSource_ptr theObjec
//============================================================================= //=============================================================================
void SMESH_MeshEditor_i::RenumberNodes() void SMESH_MeshEditor_i::RenumberNodes()
{ {
SMESH_TRY; SMESH_TRY;
// Update Python script // Update Python script
@ -2390,7 +2343,6 @@ void SMESH_MeshEditor_i::RenumberNodes()
//============================================================================= //=============================================================================
void SMESH_MeshEditor_i::RenumberElements() void SMESH_MeshEditor_i::RenumberElements()
{ {
SMESH_TRY; SMESH_TRY;
// Update Python script // Update Python script
@ -2408,7 +2360,6 @@ void SMESH_MeshEditor_i::RenumberElements()
//======================================================================= //=======================================================================
SMESH::ListOfGroups* SMESH_MeshEditor_i::getGroups(const std::list<int>* groupIDs) SMESH::ListOfGroups* SMESH_MeshEditor_i::getGroups(const std::list<int>* groupIDs)
{ {
SMESH_TRY; SMESH_TRY;
if ( !groupIDs ) if ( !groupIDs )
@ -2434,7 +2385,6 @@ SMESH_MeshEditor_i::RotationSweepObjects(const SMESH::ListOfIDSources & theNodes
CORBA::Long theNbOfSteps, CORBA::Long theNbOfSteps,
CORBA::Double theTolerance, CORBA::Double theTolerance,
const bool theMakeGroups) const bool theMakeGroups)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -2637,7 +2587,6 @@ SMESH_MeshEditor_i::ExtrusionSweepObjects(const SMESH::ListOfIDSources & theNode
const SMESH::double_array & theBasePoint, const SMESH::double_array & theBasePoint,
const SMESH::double_array & theAngles, const SMESH::double_array & theAngles,
CORBA::Boolean theAnglesVariation) CORBA::Boolean theAnglesVariation)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -2720,7 +2669,6 @@ SMESH_MeshEditor_i::ExtrusionByNormal(const SMESH::ListOfIDSources& objects,
CORBA::Boolean useInputElemsOnly, CORBA::Boolean useInputElemsOnly,
CORBA::Boolean makeGroups, CORBA::Boolean makeGroups,
CORBA::Short dim) CORBA::Short dim)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -2797,7 +2745,6 @@ SMESH_MeshEditor_i::AdvancedExtrusion(const SMESH::long_array & theIDsOfElements
CORBA::Long theExtrFlags, CORBA::Long theExtrFlags,
CORBA::Double theSewTolerance, CORBA::Double theSewTolerance,
CORBA::Boolean theMakeGroups) CORBA::Boolean theMakeGroups)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -2884,7 +2831,6 @@ SMESH_MeshEditor_i::ExtrusionAlongPathObjects(const SMESH::ListOfIDSources & the
const SMESH::double_array & theScaleFactors, const SMESH::double_array & theScaleFactors,
CORBA::Boolean theScalesVariation, CORBA::Boolean theScalesVariation,
SMESH::SMESH_MeshEditor::Extrusion_Error& theError) SMESH::SMESH_MeshEditor::Extrusion_Error& theError)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -3109,7 +3055,6 @@ SMESH_MeshEditor_i::mirror(TIDSortedElemSet & theElements,
CORBA::Boolean theCopy, CORBA::Boolean theCopy,
bool theMakeGroups, bool theMakeGroups,
::SMESH_Mesh* theTargetMesh) ::SMESH_Mesh* theTargetMesh)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -3175,7 +3120,6 @@ void SMESH_MeshEditor_i::Mirror(const SMESH::long_array & theIDsOfElem
const SMESH::AxisStruct & theAxis, const SMESH::AxisStruct & theAxis,
SMESH::SMESH_MeshEditor::MirrorType theMirrorType, SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
CORBA::Boolean theCopy) CORBA::Boolean theCopy)
{ {
if ( !myIsPreviewMode ) { if ( !myIsPreviewMode ) {
TPythonDump() << this << ".Mirror( " TPythonDump() << this << ".Mirror( "
@ -3202,7 +3146,6 @@ void SMESH_MeshEditor_i::MirrorObject(SMESH::SMESH_IDSource_ptr theObj
const SMESH::AxisStruct & theAxis, const SMESH::AxisStruct & theAxis,
SMESH::SMESH_MeshEditor::MirrorType theMirrorType, SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
CORBA::Boolean theCopy) CORBA::Boolean theCopy)
{ {
if ( !myIsPreviewMode ) { if ( !myIsPreviewMode ) {
TPythonDump() << this << ".MirrorObject( " TPythonDump() << this << ".MirrorObject( "
@ -3228,7 +3171,6 @@ SMESH::ListOfGroups*
SMESH_MeshEditor_i::MirrorMakeGroups(const SMESH::long_array& theIDsOfElements, SMESH_MeshEditor_i::MirrorMakeGroups(const SMESH::long_array& theIDsOfElements,
const SMESH::AxisStruct& theMirror, const SMESH::AxisStruct& theMirror,
SMESH::SMESH_MeshEditor::MirrorType theMirrorType) SMESH::SMESH_MeshEditor::MirrorType theMirrorType)
{ {
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups() TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
@ -3258,7 +3200,6 @@ SMESH::ListOfGroups*
SMESH_MeshEditor_i::MirrorObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject, SMESH_MeshEditor_i::MirrorObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct& theMirror, const SMESH::AxisStruct& theMirror,
SMESH::SMESH_MeshEditor::MirrorType theMirrorType) SMESH::SMESH_MeshEditor::MirrorType theMirrorType)
{ {
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups() TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
@ -3289,7 +3230,6 @@ SMESH_MeshEditor_i::MirrorMakeMesh(const SMESH::long_array& theIDsOfE
SMESH::SMESH_MeshEditor::MirrorType theMirrorType, SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
CORBA::Boolean theCopyGroups, CORBA::Boolean theCopyGroups,
const char* theMeshName) const char* theMeshName)
{ {
SMESH_Mesh_i* mesh_i; SMESH_Mesh_i* mesh_i;
SMESH::SMESH_Mesh_var mesh; SMESH::SMESH_Mesh_var mesh;
@ -3337,7 +3277,6 @@ SMESH_MeshEditor_i::MirrorObjectMakeMesh(SMESH::SMESH_IDSource_ptr the
SMESH::SMESH_MeshEditor::MirrorType theMirrorType, SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
CORBA::Boolean theCopyGroups, CORBA::Boolean theCopyGroups,
const char* theMeshName) const char* theMeshName)
{ {
SMESH_Mesh_i* mesh_i; SMESH_Mesh_i* mesh_i;
SMESH::SMESH_Mesh_var mesh; SMESH::SMESH_Mesh_var mesh;
@ -3384,7 +3323,6 @@ SMESH_MeshEditor_i::translate(TIDSortedElemSet & theElements,
CORBA::Boolean theCopy, CORBA::Boolean theCopy,
bool theMakeGroups, bool theMakeGroups,
::SMESH_Mesh* theTargetMesh) ::SMESH_Mesh* theTargetMesh)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -3438,7 +3376,6 @@ SMESH_MeshEditor_i::translate(TIDSortedElemSet & theElements,
void SMESH_MeshEditor_i::Translate(const SMESH::long_array & theIDsOfElements, void SMESH_MeshEditor_i::Translate(const SMESH::long_array & theIDsOfElements,
const SMESH::DirStruct & theVector, const SMESH::DirStruct & theVector,
CORBA::Boolean theCopy) CORBA::Boolean theCopy)
{ {
if (!myIsPreviewMode) { if (!myIsPreviewMode) {
TPythonDump() << this << ".Translate( " TPythonDump() << this << ".Translate( "
@ -3461,7 +3398,6 @@ void SMESH_MeshEditor_i::Translate(const SMESH::long_array & theIDsOfElements,
void SMESH_MeshEditor_i::TranslateObject(SMESH::SMESH_IDSource_ptr theObject, void SMESH_MeshEditor_i::TranslateObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & theVector, const SMESH::DirStruct & theVector,
CORBA::Boolean theCopy) CORBA::Boolean theCopy)
{ {
if (!myIsPreviewMode) { if (!myIsPreviewMode) {
TPythonDump() << this << ".TranslateObject( " TPythonDump() << this << ".TranslateObject( "
@ -3485,7 +3421,6 @@ void SMESH_MeshEditor_i::TranslateObject(SMESH::SMESH_IDSource_ptr theObject,
SMESH::ListOfGroups* SMESH::ListOfGroups*
SMESH_MeshEditor_i::TranslateMakeGroups(const SMESH::long_array& theIDsOfElements, SMESH_MeshEditor_i::TranslateMakeGroups(const SMESH::long_array& theIDsOfElements,
const SMESH::DirStruct& theVector) const SMESH::DirStruct& theVector)
{ {
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups() TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
@ -3512,7 +3447,6 @@ SMESH_MeshEditor_i::TranslateMakeGroups(const SMESH::long_array& theIDsOfElement
SMESH::ListOfGroups* SMESH::ListOfGroups*
SMESH_MeshEditor_i::TranslateObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject, SMESH_MeshEditor_i::TranslateObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct& theVector) const SMESH::DirStruct& theVector)
{ {
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups() TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
@ -3540,7 +3474,6 @@ SMESH_MeshEditor_i::TranslateMakeMesh(const SMESH::long_array& theIDsOfElements,
const SMESH::DirStruct& theVector, const SMESH::DirStruct& theVector,
CORBA::Boolean theCopyGroups, CORBA::Boolean theCopyGroups,
const char* theMeshName) const char* theMeshName)
{ {
SMESH_Mesh_i* mesh_i; SMESH_Mesh_i* mesh_i;
SMESH::SMESH_Mesh_var mesh; SMESH::SMESH_Mesh_var mesh;
@ -3587,7 +3520,6 @@ SMESH_MeshEditor_i::TranslateObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct& theVector, const SMESH::DirStruct& theVector,
CORBA::Boolean theCopyGroups, CORBA::Boolean theCopyGroups,
const char* theMeshName) const char* theMeshName)
{ {
SMESH_TRY; SMESH_TRY;
SMESH_Mesh_i* mesh_i; SMESH_Mesh_i* mesh_i;
@ -3637,7 +3569,6 @@ SMESH_MeshEditor_i::rotate(TIDSortedElemSet & theElements,
CORBA::Boolean theCopy, CORBA::Boolean theCopy,
bool theMakeGroups, bool theMakeGroups,
::SMESH_Mesh* theTargetMesh) ::SMESH_Mesh* theTargetMesh)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -3690,7 +3621,6 @@ void SMESH_MeshEditor_i::Rotate(const SMESH::long_array & theIDsOfElements,
const SMESH::AxisStruct & theAxis, const SMESH::AxisStruct & theAxis,
CORBA::Double theAngle, CORBA::Double theAngle,
CORBA::Boolean theCopy) CORBA::Boolean theCopy)
{ {
if (!myIsPreviewMode) { if (!myIsPreviewMode) {
TPythonDump() << this << ".Rotate( " TPythonDump() << this << ".Rotate( "
@ -3716,7 +3646,6 @@ void SMESH_MeshEditor_i::RotateObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct & theAxis, const SMESH::AxisStruct & theAxis,
CORBA::Double theAngle, CORBA::Double theAngle,
CORBA::Boolean theCopy) CORBA::Boolean theCopy)
{ {
if ( !myIsPreviewMode ) { if ( !myIsPreviewMode ) {
TPythonDump() << this << ".RotateObject( " TPythonDump() << this << ".RotateObject( "
@ -3740,7 +3669,6 @@ SMESH::ListOfGroups*
SMESH_MeshEditor_i::RotateMakeGroups(const SMESH::long_array& theIDsOfElements, SMESH_MeshEditor_i::RotateMakeGroups(const SMESH::long_array& theIDsOfElements,
const SMESH::AxisStruct& theAxis, const SMESH::AxisStruct& theAxis,
CORBA::Double theAngle) CORBA::Double theAngle)
{ {
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups() TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
@ -3770,7 +3698,6 @@ SMESH::ListOfGroups*
SMESH_MeshEditor_i::RotateObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject, SMESH_MeshEditor_i::RotateObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct& theAxis, const SMESH::AxisStruct& theAxis,
CORBA::Double theAngle) CORBA::Double theAngle)
{ {
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups() TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
@ -3800,7 +3727,6 @@ SMESH_MeshEditor_i::RotateMakeMesh(const SMESH::long_array& theIDsOfElements,
CORBA::Double theAngleInRadians, CORBA::Double theAngleInRadians,
CORBA::Boolean theCopyGroups, CORBA::Boolean theCopyGroups,
const char* theMeshName) const char* theMeshName)
{ {
SMESH_TRY; SMESH_TRY;
SMESH::SMESH_Mesh_var mesh; SMESH::SMESH_Mesh_var mesh;
@ -3853,7 +3779,6 @@ SMESH_MeshEditor_i::RotateObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject,
CORBA::Double theAngleInRadians, CORBA::Double theAngleInRadians,
CORBA::Boolean theCopyGroups, CORBA::Boolean theCopyGroups,
const char* theMeshName) const char* theMeshName)
{ {
SMESH_TRY; SMESH_TRY;
SMESH::SMESH_Mesh_var mesh; SMESH::SMESH_Mesh_var mesh;
@ -3906,7 +3831,6 @@ SMESH_MeshEditor_i::scale(SMESH::SMESH_IDSource_ptr theObject,
CORBA::Boolean theCopy, CORBA::Boolean theCopy,
bool theMakeGroups, bool theMakeGroups,
::SMESH_Mesh* theTargetMesh) ::SMESH_Mesh* theTargetMesh)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -4003,7 +3927,6 @@ SMESH::ListOfGroups*
SMESH_MeshEditor_i::ScaleMakeGroups(SMESH::SMESH_IDSource_ptr theObject, SMESH_MeshEditor_i::ScaleMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::PointStruct& thePoint, const SMESH::PointStruct& thePoint,
const SMESH::double_array& theScaleFact) const SMESH::double_array& theScaleFact)
{ {
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups() TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
@ -4030,7 +3953,6 @@ SMESH_MeshEditor_i::ScaleMakeMesh(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::double_array& theScaleFact, const SMESH::double_array& theScaleFact,
CORBA::Boolean theCopyGroups, CORBA::Boolean theCopyGroups,
const char* theMeshName) const char* theMeshName)
{ {
SMESH_Mesh_i* mesh_i; SMESH_Mesh_i* mesh_i;
SMESH::SMESH_Mesh_var mesh; SMESH::SMESH_Mesh_var mesh;
@ -4081,7 +4003,6 @@ SMESH::SMESH_Mesh_ptr SMESH_MeshEditor_i::Offset( SMESH::SMESH_IDSource_ptr theO
CORBA::Boolean theCopyElements, CORBA::Boolean theCopyElements,
const char* theMeshName, const char* theMeshName,
SMESH::ListOfGroups_out theGroups) SMESH::ListOfGroups_out theGroups)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -4195,7 +4116,6 @@ void SMESH_MeshEditor_i::
FindCoincidentNodes (CORBA::Double Tolerance, FindCoincidentNodes (CORBA::Double Tolerance,
SMESH::array_of_long_array_out GroupsOfNodes, SMESH::array_of_long_array_out GroupsOfNodes,
CORBA::Boolean SeparateCornersAndMedium) CORBA::Boolean SeparateCornersAndMedium)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -4220,7 +4140,6 @@ FindCoincidentNodesOnPart(SMESH::SMESH_IDSource_ptr theObject,
CORBA::Double Tolerance, CORBA::Double Tolerance,
SMESH::array_of_long_array_out GroupsOfNodes, SMESH::array_of_long_array_out GroupsOfNodes,
CORBA::Boolean SeparateCornersAndMedium) CORBA::Boolean SeparateCornersAndMedium)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -4252,7 +4171,6 @@ FindCoincidentNodesOnPartBut(const SMESH::ListOfIDSources& theObjects,
SMESH::array_of_long_array_out theGroupsOfNodes, SMESH::array_of_long_array_out theGroupsOfNodes,
const SMESH::ListOfIDSources& theExceptSubMeshOrGroups, const SMESH::ListOfIDSources& theExceptSubMeshOrGroups,
CORBA::Boolean theSeparateCornersAndMedium) CORBA::Boolean theSeparateCornersAndMedium)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -4289,7 +4207,6 @@ FindCoincidentNodesOnPartBut(const SMESH::ListOfIDSources& theObjects,
void SMESH_MeshEditor_i::MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes, void SMESH_MeshEditor_i::MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes,
const SMESH::ListOfIDSources& NodesToKeep, const SMESH::ListOfIDSources& NodesToKeep,
CORBA::Boolean AvoidMakingHoles) CORBA::Boolean AvoidMakingHoles)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -4349,7 +4266,6 @@ void SMESH_MeshEditor_i::MergeNodes (const SMESH::array_of_long_array& GroupsOfN
void SMESH_MeshEditor_i::FindEqualElements(const SMESH::ListOfIDSources& theObjects, void SMESH_MeshEditor_i::FindEqualElements(const SMESH::ListOfIDSources& theObjects,
const SMESH::ListOfIDSources& theExceptObjects, const SMESH::ListOfIDSources& theExceptObjects,
SMESH::array_of_long_array_out theGroupsOfElementsID) SMESH::array_of_long_array_out theGroupsOfElementsID)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -4409,7 +4325,6 @@ void SMESH_MeshEditor_i::FindEqualElements(const SMESH::ListOfIDSources& theObj
void SMESH_MeshEditor_i::MergeElements(const SMESH::array_of_long_array& theGroupsOfElementsID, void SMESH_MeshEditor_i::MergeElements(const SMESH::array_of_long_array& theGroupsOfElementsID,
const SMESH::ListOfIDSources& theElementsToKeep) const SMESH::ListOfIDSources& theElementsToKeep)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -4464,7 +4379,6 @@ void SMESH_MeshEditor_i::MergeElements(const SMESH::array_of_long_array& theGrou
//======================================================================= //=======================================================================
void SMESH_MeshEditor_i::MergeEqualElements() void SMESH_MeshEditor_i::MergeEqualElements()
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -4488,7 +4402,6 @@ CORBA::Boolean SMESH_MeshEditor_i::MoveNode(CORBA::Long NodeID,
CORBA::Double x, CORBA::Double x,
CORBA::Double y, CORBA::Double y,
CORBA::Double z) CORBA::Double z)
{ {
SMESH_TRY; SMESH_TRY;
initData(/*deleteSearchers=*/false); initData(/*deleteSearchers=*/false);
@ -4545,7 +4458,6 @@ CORBA::Boolean SMESH_MeshEditor_i::MoveNode(CORBA::Long NodeID,
CORBA::Long SMESH_MeshEditor_i::FindNodeClosestTo(CORBA::Double x, CORBA::Long SMESH_MeshEditor_i::FindNodeClosestTo(CORBA::Double x,
CORBA::Double y, CORBA::Double y,
CORBA::Double z) CORBA::Double z)
{ {
SMESH_TRY; SMESH_TRY;
theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other
@ -4572,7 +4484,6 @@ CORBA::Long SMESH_MeshEditor_i::MoveClosestNodeToPoint(CORBA::Double x,
CORBA::Double y, CORBA::Double y,
CORBA::Double z, CORBA::Double z,
CORBA::Long theNodeID) CORBA::Long theNodeID)
{ {
SMESH_TRY; SMESH_TRY;
// We keep theNodeSearcher until any mesh modification: // We keep theNodeSearcher until any mesh modification:
@ -4650,7 +4561,6 @@ SMESH::long_array* SMESH_MeshEditor_i::FindElementsByPoint(CORBA::Double x,
CORBA::Double y, CORBA::Double y,
CORBA::Double z, CORBA::Double z,
SMESH::ElementType type) SMESH::ElementType type)
{ {
SMESH_TRY; SMESH_TRY;
SMESH::long_array_var res = new SMESH::long_array; SMESH::long_array_var res = new SMESH::long_array;
@ -4686,7 +4596,6 @@ SMESH_MeshEditor_i::FindAmongElementsByPoint(SMESH::SMESH_IDSource_ptr elementID
CORBA::Double y, CORBA::Double y,
CORBA::Double z, CORBA::Double z,
SMESH::ElementType type) SMESH::ElementType type)
{ {
SMESH_TRY; SMESH_TRY;
SMESH::long_array_var res = new SMESH::long_array; SMESH::long_array_var res = new SMESH::long_array;
@ -4759,7 +4668,6 @@ CORBA::Long SMESH_MeshEditor_i::ProjectPoint(CORBA::Double x,
SMESH::ElementType type, SMESH::ElementType type,
SMESH::SMESH_IDSource_ptr meshObject, SMESH::SMESH_IDSource_ptr meshObject,
SMESH::double_array_out projecton) SMESH::double_array_out projecton)
{ {
if ( CORBA::is_nil( meshObject )) if ( CORBA::is_nil( meshObject ))
THROW_SALOME_CORBA_EXCEPTION("NULL meshObject", SALOME::BAD_PARAM); THROW_SALOME_CORBA_EXCEPTION("NULL meshObject", SALOME::BAD_PARAM);
@ -4820,7 +4728,6 @@ CORBA::Long SMESH_MeshEditor_i::ProjectPoint(CORBA::Double x,
CORBA::Short SMESH_MeshEditor_i::GetPointState(CORBA::Double x, CORBA::Short SMESH_MeshEditor_i::GetPointState(CORBA::Double x,
CORBA::Double y, CORBA::Double y,
CORBA::Double z) CORBA::Double z)
{ {
SMESH_TRY; SMESH_TRY;
theSearchersDeleter.Set( myMesh ); theSearchersDeleter.Set( myMesh );
@ -4839,7 +4746,6 @@ CORBA::Short SMESH_MeshEditor_i::GetPointState(CORBA::Double x,
//======================================================================= //=======================================================================
CORBA::Boolean SMESH_MeshEditor_i::IsManifold() CORBA::Boolean SMESH_MeshEditor_i::IsManifold()
{ {
bool isManifold = true; bool isManifold = true;
@ -4860,7 +4766,6 @@ CORBA::Boolean SMESH_MeshEditor_i::IsManifold()
//======================================================================= //=======================================================================
CORBA::Boolean SMESH_MeshEditor_i::IsCoherentOrientation2D() CORBA::Boolean SMESH_MeshEditor_i::IsCoherentOrientation2D()
{ {
bool isGoodOri = true; bool isGoodOri = true;
@ -4889,7 +4794,6 @@ SMESH::array_of_long_array*
SMESH_MeshEditor_i::Get1DBranches( SMESH::SMESH_IDSource_ptr theEdges, SMESH_MeshEditor_i::Get1DBranches( SMESH::SMESH_IDSource_ptr theEdges,
CORBA::Long theStartNode, CORBA::Long theStartNode,
SMESH::array_of_long_array_out theNodeGroups ) SMESH::array_of_long_array_out theNodeGroups )
{ {
if ( CORBA::is_nil( theEdges )) if ( CORBA::is_nil( theEdges ))
THROW_SALOME_CORBA_EXCEPTION("Get1DBranches(): NULL group given", SALOME::BAD_PARAM); THROW_SALOME_CORBA_EXCEPTION("Get1DBranches(): NULL group given", SALOME::BAD_PARAM);
@ -4936,7 +4840,6 @@ SMESH_MeshEditor_i::Get1DBranches( SMESH::SMESH_IDSource_ptr theEdges,
SMESH::ListOfEdges* SMESH_MeshEditor_i::FindSharpEdges(CORBA::Double theAngle, SMESH::ListOfEdges* SMESH_MeshEditor_i::FindSharpEdges(CORBA::Double theAngle,
CORBA::Boolean theAddExisting) CORBA::Boolean theAddExisting)
{ {
SMESH::ListOfEdges_var resultEdges = new SMESH::ListOfEdges; SMESH::ListOfEdges_var resultEdges = new SMESH::ListOfEdges;
SMESH_TRY; SMESH_TRY;
@ -4987,7 +4890,6 @@ SMESH::ListOfEdges* SMESH_MeshEditor_i::FindSharpEdges(CORBA::Double theAngle,
//======================================================================= //=======================================================================
SMESH::ListOfFreeBorders* SMESH_MeshEditor_i::FindFreeBorders(CORBA::Boolean closedOnly) SMESH::ListOfFreeBorders* SMESH_MeshEditor_i::FindFreeBorders(CORBA::Boolean closedOnly)
{ {
SMESH::ListOfFreeBorders_var resBorders = new SMESH::ListOfFreeBorders; SMESH::ListOfFreeBorders_var resBorders = new SMESH::ListOfFreeBorders;
SMESH_TRY; SMESH_TRY;
@ -5018,7 +4920,6 @@ SMESH::ListOfFreeBorders* SMESH_MeshEditor_i::FindFreeBorders(CORBA::Boolean clo
SMESH::SMESH_Group_ptr SMESH::SMESH_Group_ptr
SMESH_MeshEditor_i::FillHole(const SMESH::FreeBorder& theHole, SMESH_MeshEditor_i::FillHole(const SMESH::FreeBorder& theHole,
const char* theGroupName) const char* theGroupName)
{ {
initData(); initData();
@ -5214,7 +5115,6 @@ CORBA::Short SMESH_MeshEditor_i::
SewCoincidentFreeBorders(const SMESH::CoincidentFreeBorders& freeBorders, SewCoincidentFreeBorders(const SMESH::CoincidentFreeBorders& freeBorders,
CORBA::Boolean createPolygons, CORBA::Boolean createPolygons,
CORBA::Boolean createPolyhedra) CORBA::Boolean createPolyhedra)
{ {
CORBA::Short nbSewed = 0; CORBA::Short nbSewed = 0;
@ -5383,7 +5283,6 @@ SMESH_MeshEditor_i::SewFreeBorders(CORBA::Long FirstNodeID1,
CORBA::Long LastNodeID2, CORBA::Long LastNodeID2,
CORBA::Boolean CreatePolygons, CORBA::Boolean CreatePolygons,
CORBA::Boolean CreatePolyedrs) CORBA::Boolean CreatePolyedrs)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -5447,7 +5346,6 @@ SMESH_MeshEditor_i::SewConformFreeBorders(CORBA::Long FirstNodeID1,
CORBA::Long LastNodeID1, CORBA::Long LastNodeID1,
CORBA::Long FirstNodeID2, CORBA::Long FirstNodeID2,
CORBA::Long SecondNodeID2) CORBA::Long SecondNodeID2)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -5507,7 +5405,6 @@ SMESH_MeshEditor_i::SewBorderToSide(CORBA::Long FirstNodeIDOnFreeBorder,
CORBA::Long LastNodeIDOnSide, CORBA::Long LastNodeIDOnSide,
CORBA::Boolean CreatePolygons, CORBA::Boolean CreatePolygons,
CORBA::Boolean CreatePolyedrs) CORBA::Boolean CreatePolyedrs)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -5569,7 +5466,6 @@ SMESH_MeshEditor_i::SewSideElements(const SMESH::long_array& IDsOfSide1Elements,
CORBA::Long NodeID1OfSide2ToMerge, CORBA::Long NodeID1OfSide2ToMerge,
CORBA::Long NodeID2OfSide1ToMerge, CORBA::Long NodeID2OfSide1ToMerge,
CORBA::Long NodeID2OfSide2ToMerge) CORBA::Long NodeID2OfSide2ToMerge)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -5625,7 +5521,6 @@ SMESH_MeshEditor_i::SewSideElements(const SMESH::long_array& IDsOfSide1Elements,
CORBA::Boolean SMESH_MeshEditor_i::ChangeElemNodes(CORBA::Long ide, CORBA::Boolean SMESH_MeshEditor_i::ChangeElemNodes(CORBA::Long ide,
const SMESH::long_array& newIDs) const SMESH::long_array& newIDs)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -5663,7 +5558,6 @@ CORBA::Boolean SMESH_MeshEditor_i::ChangeElemNodes(CORBA::Long ide,
void SMESH_MeshEditor_i::convertToQuadratic(CORBA::Boolean theForce3d, void SMESH_MeshEditor_i::convertToQuadratic(CORBA::Boolean theForce3d,
CORBA::Boolean theToBiQuad, CORBA::Boolean theToBiQuad,
SMESH::SMESH_IDSource_ptr theObject) SMESH::SMESH_IDSource_ptr theObject)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -5695,7 +5589,6 @@ void SMESH_MeshEditor_i::convertToQuadratic(CORBA::Boolean theForce3d
//======================================================================= //=======================================================================
CORBA::Boolean SMESH_MeshEditor_i::ConvertFromQuadratic() CORBA::Boolean SMESH_MeshEditor_i::ConvertFromQuadratic()
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -5715,7 +5608,6 @@ CORBA::Boolean SMESH_MeshEditor_i::ConvertFromQuadratic()
//======================================================================= //=======================================================================
void SMESH_MeshEditor_i::ConvertToQuadratic(CORBA::Boolean theForce3d) void SMESH_MeshEditor_i::ConvertToQuadratic(CORBA::Boolean theForce3d)
{ {
convertToQuadratic( theForce3d, false ); convertToQuadratic( theForce3d, false );
TPythonDump() << this << ".ConvertToQuadratic("<<theForce3d<<")"; TPythonDump() << this << ".ConvertToQuadratic("<<theForce3d<<")";
@ -5729,7 +5621,6 @@ void SMESH_MeshEditor_i::ConvertToQuadratic(CORBA::Boolean theForce3d)
void SMESH_MeshEditor_i::ConvertToQuadraticObject(CORBA::Boolean theForce3d, void SMESH_MeshEditor_i::ConvertToQuadraticObject(CORBA::Boolean theForce3d,
SMESH::SMESH_IDSource_ptr theObject) SMESH::SMESH_IDSource_ptr theObject)
{ {
convertToQuadratic( theForce3d, false, theObject ); convertToQuadratic( theForce3d, false, theObject );
TPythonDump() << this << ".ConvertToQuadraticObject("<<theForce3d<<", "<<theObject<<")"; TPythonDump() << this << ".ConvertToQuadraticObject("<<theForce3d<<", "<<theObject<<")";
@ -5743,7 +5634,6 @@ void SMESH_MeshEditor_i::ConvertToQuadraticObject(CORBA::Boolean theF
void SMESH_MeshEditor_i::ConvertToBiQuadratic(CORBA::Boolean theForce3d, void SMESH_MeshEditor_i::ConvertToBiQuadratic(CORBA::Boolean theForce3d,
SMESH::SMESH_IDSource_ptr theObject) SMESH::SMESH_IDSource_ptr theObject)
{ {
convertToQuadratic( theForce3d, true, theObject ); convertToQuadratic( theForce3d, true, theObject );
TPythonDump() << this << ".ConvertToBiQuadratic("<<theForce3d<<", "<<theObject<<")"; TPythonDump() << this << ".ConvertToBiQuadratic("<<theForce3d<<", "<<theObject<<")";
@ -5756,7 +5646,6 @@ void SMESH_MeshEditor_i::ConvertToBiQuadratic(CORBA::Boolean theForce
//================================================================================ //================================================================================
void SMESH_MeshEditor_i::ConvertFromQuadraticObject(SMESH::SMESH_IDSource_ptr theObject) void SMESH_MeshEditor_i::ConvertFromQuadraticObject(SMESH::SMESH_IDSource_ptr theObject)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -5950,7 +5839,6 @@ bool SMESH_MeshEditor_i::idSourceToSet(SMESH::SMESH_IDSource_ptr theIDSource,
SMESH::SMESH_Group_ptr SMESH::SMESH_Group_ptr
SMESH_MeshEditor_i::DoubleElements(SMESH::SMESH_IDSource_ptr theElements, SMESH_MeshEditor_i::DoubleElements(SMESH::SMESH_IDSource_ptr theElements,
const char* theGroupName) const char* theGroupName)
{ {
SMESH::SMESH_Group_var newGroup; SMESH::SMESH_Group_var newGroup;
@ -6018,7 +5906,6 @@ SMESH_MeshEditor_i::DoubleElements(SMESH::SMESH_IDSource_ptr theElements,
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theNodes, CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theNodes,
const SMESH::long_array& theModifiedElems ) const SMESH::long_array& theModifiedElems )
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -6058,7 +5945,6 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theNode
CORBA::Boolean SMESH_MeshEditor_i::DoubleNode( CORBA::Long theNodeId, CORBA::Boolean SMESH_MeshEditor_i::DoubleNode( CORBA::Long theNodeId,
const SMESH::long_array& theModifiedElems ) const SMESH::long_array& theModifiedElems )
{ {
SMESH_TRY; SMESH_TRY;
SMESH::long_array_var aNodes = new SMESH::long_array; SMESH::long_array_var aNodes = new SMESH::long_array;
@ -6090,7 +5976,6 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNode( CORBA::Long theNodeI
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroup(SMESH::SMESH_GroupBase_ptr theNodes, CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroup(SMESH::SMESH_GroupBase_ptr theNodes,
SMESH::SMESH_GroupBase_ptr theModifiedElems ) SMESH::SMESH_GroupBase_ptr theModifiedElems )
{ {
SMESH_TRY; SMESH_TRY;
if ( CORBA::is_nil( theNodes ) && theNodes->GetType() != SMESH::NODE ) if ( CORBA::is_nil( theNodes ) && theNodes->GetType() != SMESH::NODE )
@ -6129,7 +6014,6 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroup(SMESH::SMESH_GroupBase_ptr th
SMESH::SMESH_Group_ptr SMESH::SMESH_Group_ptr
SMESH_MeshEditor_i::DoubleNodeGroupNew( SMESH::SMESH_GroupBase_ptr theNodes, SMESH_MeshEditor_i::DoubleNodeGroupNew( SMESH::SMESH_GroupBase_ptr theNodes,
SMESH::SMESH_GroupBase_ptr theModifiedElems ) SMESH::SMESH_GroupBase_ptr theModifiedElems )
{ {
SMESH_TRY; SMESH_TRY;
SMESH::SMESH_Group_var aNewGroup; SMESH::SMESH_Group_var aNewGroup;
@ -6185,7 +6069,6 @@ SMESH_MeshEditor_i::DoubleNodeGroupNew( SMESH::SMESH_GroupBase_ptr theNodes,
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups(const SMESH::ListOfGroups& theNodes, CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups(const SMESH::ListOfGroups& theNodes,
const SMESH::ListOfGroups& theModifiedElems ) const SMESH::ListOfGroups& theModifiedElems )
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -6241,7 +6124,6 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups(const SMESH::ListOfGroups& t
SMESH::SMESH_Group_ptr SMESH::SMESH_Group_ptr
SMESH_MeshEditor_i::DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes, SMESH_MeshEditor_i::DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes,
const SMESH::ListOfGroups& theModifiedElems ) const SMESH::ListOfGroups& theModifiedElems )
{ {
SMESH::SMESH_Group_var aNewGroup; SMESH::SMESH_Group_var aNewGroup;
@ -6285,7 +6167,6 @@ SMESH_MeshEditor_i::DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes,
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElem( const SMESH::long_array& theElems, CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElem( const SMESH::long_array& theElems,
const SMESH::long_array& theNodesNot, const SMESH::long_array& theNodesNot,
const SMESH::long_array& theAffectedElems ) const SMESH::long_array& theAffectedElems )
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -6326,7 +6207,6 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElem( const SMESH::long_array& theE
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemInRegion ( const SMESH::long_array& theElems, CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemInRegion ( const SMESH::long_array& theElems,
const SMESH::long_array& theNodesNot, const SMESH::long_array& theNodesNot,
GEOM::GEOM_Object_ptr theShape ) GEOM::GEOM_Object_ptr theShape )
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -6367,7 +6247,6 @@ CORBA::Boolean
SMESH_MeshEditor_i::DoubleNodeElemGroup(SMESH::SMESH_GroupBase_ptr theElems, SMESH_MeshEditor_i::DoubleNodeElemGroup(SMESH::SMESH_GroupBase_ptr theElems,
SMESH::SMESH_GroupBase_ptr theNodesNot, SMESH::SMESH_GroupBase_ptr theNodesNot,
SMESH::SMESH_GroupBase_ptr theAffectedElems) SMESH::SMESH_GroupBase_ptr theAffectedElems)
{ {
SMESH_TRY; SMESH_TRY;
if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE ) if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE )
@ -6412,7 +6291,6 @@ SMESH::SMESH_Group_ptr
SMESH_MeshEditor_i::DoubleNodeElemGroupNew(SMESH::SMESH_GroupBase_ptr theElems, SMESH_MeshEditor_i::DoubleNodeElemGroupNew(SMESH::SMESH_GroupBase_ptr theElems,
SMESH::SMESH_GroupBase_ptr theNodesNot, SMESH::SMESH_GroupBase_ptr theNodesNot,
SMESH::SMESH_GroupBase_ptr theAffectedElems) SMESH::SMESH_GroupBase_ptr theAffectedElems)
{ {
TPythonDump pyDump; TPythonDump pyDump;
SMESH::ListOfGroups_var twoGroups = DoubleNodeElemGroup2New( theElems, SMESH::ListOfGroups_var twoGroups = DoubleNodeElemGroup2New( theElems,
@ -6449,7 +6327,6 @@ SMESH_MeshEditor_i::DoubleNodeElemGroup2New(SMESH::SMESH_GroupBase_ptr theElems,
SMESH::SMESH_GroupBase_ptr theAffectedElems, SMESH::SMESH_GroupBase_ptr theAffectedElems,
CORBA::Boolean theElemGroupNeeded, CORBA::Boolean theElemGroupNeeded,
CORBA::Boolean theNodeGroupNeeded) CORBA::Boolean theNodeGroupNeeded)
{ {
SMESH_TRY; SMESH_TRY;
SMESH::SMESH_Group_var aNewElemGroup, aNewNodeGroup; SMESH::SMESH_Group_var aNewElemGroup, aNewNodeGroup;
@ -6534,7 +6411,6 @@ CORBA::Boolean
SMESH_MeshEditor_i::DoubleNodeElemGroupInRegion(SMESH::SMESH_GroupBase_ptr theElems, SMESH_MeshEditor_i::DoubleNodeElemGroupInRegion(SMESH::SMESH_GroupBase_ptr theElems,
SMESH::SMESH_GroupBase_ptr theNodesNot, SMESH::SMESH_GroupBase_ptr theNodesNot,
GEOM::GEOM_Object_ptr theShape ) GEOM::GEOM_Object_ptr theShape )
{ {
SMESH_TRY; SMESH_TRY;
if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE ) if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE )
@ -6607,7 +6483,6 @@ CORBA::Boolean
SMESH_MeshEditor_i::DoubleNodeElemGroups(const SMESH::ListOfGroups& theElems, SMESH_MeshEditor_i::DoubleNodeElemGroups(const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot, const SMESH::ListOfGroups& theNodesNot,
const SMESH::ListOfGroups& theAffectedElems) const SMESH::ListOfGroups& theAffectedElems)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -6649,7 +6524,6 @@ SMESH::SMESH_Group_ptr
SMESH_MeshEditor_i::DoubleNodeElemGroupsNew(const SMESH::ListOfGroups& theElems, SMESH_MeshEditor_i::DoubleNodeElemGroupsNew(const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot, const SMESH::ListOfGroups& theNodesNot,
const SMESH::ListOfGroups& theAffectedElems) const SMESH::ListOfGroups& theAffectedElems)
{ {
TPythonDump pyDump; TPythonDump pyDump;
SMESH::ListOfGroups_var twoGroups = DoubleNodeElemGroups2New( theElems, SMESH::ListOfGroups_var twoGroups = DoubleNodeElemGroups2New( theElems,
@ -6686,7 +6560,6 @@ SMESH_MeshEditor_i::DoubleNodeElemGroups2New(const SMESH::ListOfGroups& theElems
const SMESH::ListOfGroups& theAffectedElems, const SMESH::ListOfGroups& theAffectedElems,
CORBA::Boolean theElemGroupNeeded, CORBA::Boolean theElemGroupNeeded,
CORBA::Boolean theNodeGroupNeeded) CORBA::Boolean theNodeGroupNeeded)
{ {
SMESH_TRY; SMESH_TRY;
SMESH::SMESH_Group_var aNewElemGroup, aNewNodeGroup; SMESH::SMESH_Group_var aNewElemGroup, aNewNodeGroup;
@ -6767,7 +6640,6 @@ CORBA::Boolean
SMESH_MeshEditor_i::DoubleNodeElemGroupsInRegion(const SMESH::ListOfGroups& theElems, SMESH_MeshEditor_i::DoubleNodeElemGroupsInRegion(const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot, const SMESH::ListOfGroups& theNodesNot,
GEOM::GEOM_Object_ptr theShape ) GEOM::GEOM_Object_ptr theShape )
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -6810,7 +6682,6 @@ SMESH::ListOfGroups*
SMESH_MeshEditor_i::AffectedElemGroupsInRegion( const SMESH::ListOfGroups& theElems, SMESH_MeshEditor_i::AffectedElemGroupsInRegion( const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot, const SMESH::ListOfGroups& theNodesNot,
GEOM::GEOM_Object_ptr theShape ) GEOM::GEOM_Object_ptr theShape )
{ {
SMESH_TRY; SMESH_TRY;
SMESH::ListOfGroups_var aListOfGroups = new SMESH::ListOfGroups(); SMESH::ListOfGroups_var aListOfGroups = new SMESH::ListOfGroups();
@ -6910,7 +6781,6 @@ SMESH_MeshEditor_i::AffectedElemGroupsInRegion( const SMESH::ListOfGroups& theEl
//================================================================================ //================================================================================
CORBA::Boolean SMESH_MeshEditor_i::Make2DMeshFrom3D() CORBA::Boolean SMESH_MeshEditor_i::Make2DMeshFrom3D()
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -6952,7 +6822,6 @@ CORBA::Boolean
SMESH_MeshEditor_i::DoubleNodesOnGroupBoundaries( const SMESH::ListOfGroups& theDomains, SMESH_MeshEditor_i::DoubleNodesOnGroupBoundaries( const SMESH::ListOfGroups& theDomains,
CORBA::Boolean createJointElems, CORBA::Boolean createJointElems,
CORBA::Boolean onAllBoundaries ) CORBA::Boolean onAllBoundaries )
{ {
bool isOK = false; bool isOK = false;
@ -7010,7 +6879,6 @@ SMESH_MeshEditor_i::DoubleNodesOnGroupBoundaries( const SMESH::ListOfGroups& the
CORBA::Boolean CORBA::Boolean
SMESH_MeshEditor_i::CreateFlatElementsOnFacesGroups( const SMESH::ListOfGroups& theGroupsOfFaces ) SMESH_MeshEditor_i::CreateFlatElementsOnFacesGroups( const SMESH::ListOfGroups& theGroupsOfFaces )
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -7063,7 +6931,6 @@ void SMESH_MeshEditor_i::CreateHoleSkin(CORBA::Double radius,
const char* groupName, const char* groupName,
const SMESH::double_array& theNodesCoords, const SMESH::double_array& theNodesCoords,
SMESH::array_of_long_array_out GroupsOfNodes) SMESH::array_of_long_array_out GroupsOfNodes)
{ {
SMESH_TRY; SMESH_TRY;
@ -7131,7 +6998,6 @@ SMESH_MeshEditor_i::MakeBoundaryMesh(SMESH::SMESH_IDSource_ptr idSource,
CORBA::Boolean toCopyElements, CORBA::Boolean toCopyElements,
CORBA::Boolean toCopyExistingBondary, CORBA::Boolean toCopyExistingBondary,
SMESH::SMESH_Group_out group) SMESH::SMESH_Group_out group)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -7228,7 +7094,6 @@ CORBA::Long SMESH_MeshEditor_i::MakeBoundaryElements(SMESH::Bnd_Dimension dim,
const SMESH::ListOfIDSources& groups, const SMESH::ListOfIDSources& groups,
SMESH::SMESH_Mesh_out mesh, SMESH::SMESH_Mesh_out mesh,
SMESH::SMESH_Group_out group) SMESH::SMESH_Group_out group)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -7383,7 +7248,6 @@ CORBA::Long SMESH_MeshEditor_i::MakeBoundaryElements(SMESH::Bnd_Dimension dim,
void SMESH_MeshEditor_i::MakePolyLine(SMESH::ListOfPolySegments& theSegments, void SMESH_MeshEditor_i::MakePolyLine(SMESH::ListOfPolySegments& theSegments,
const char* theGroupName) const char* theGroupName)
{ {
if ( theSegments.length() == 0 ) if ( theSegments.length() == 0 )
THROW_SALOME_CORBA_EXCEPTION("No segments given", SALOME::BAD_PARAM ); THROW_SALOME_CORBA_EXCEPTION("No segments given", SALOME::BAD_PARAM );
@ -7509,7 +7373,6 @@ void SMESH_MeshEditor_i::MakePolyLine(SMESH::ListOfPolySegments& theSegments,
SMESH::ListOfEdges* SMESH_MeshEditor_i::MakeSlot(SMESH::SMESH_GroupBase_ptr theSegments, SMESH::ListOfEdges* SMESH_MeshEditor_i::MakeSlot(SMESH::SMESH_GroupBase_ptr theSegments,
CORBA::Double theWidth) CORBA::Double theWidth)
{ {
if ( CORBA::is_nil( theSegments ) || if ( CORBA::is_nil( theSegments ) ||
theSegments->GetType() != SMESH::EDGE ) theSegments->GetType() != SMESH::EDGE )

405
src/SMESH_I/SMESH_MeshEditor_i.hxx
View File

@ -65,27 +65,27 @@ public:
/*! /*!
* Return data of mesh edition preview * Return data of mesh edition preview
*/ */
SMESH::MeshPreviewStruct* GetPreviewData() ; SMESH::MeshPreviewStruct* GetPreviewData();
/*! /*!
* If during last operation of MeshEditor some nodes were * If during last operation of MeshEditor some nodes were
* created this method returns list of their IDs, if new nodes * created this method returns list of their IDs, if new nodes
* not created - returns an empty list * not created - returns an empty list
*/ */
SMESH::long_array* GetLastCreatedNodes() ; SMESH::long_array* GetLastCreatedNodes();
/*! /*!
* If during last operation of MeshEditor some elements were * If during last operation of MeshEditor some elements were
* created this method returns list of their IDs, if new elements * created this method returns list of their IDs, if new elements
* not created - returns an empty list * not created - returns an empty list
*/ */
SMESH::long_array* GetLastCreatedElems() ; SMESH::long_array* GetLastCreatedElems();
/*! /*!
* \brief Clears sequences of last created elements and nodes * \brief Clears sequences of last created elements and nodes
*/ */
void ClearLastCreated() ; void ClearLastCreated();
/*! /*!
* \brief Returns description of an error/warning occurred during the last operation * \brief Returns description of an error/warning occurred during the last operation
*/ */
SMESH::ComputeError* GetLastError() ; SMESH::ComputeError* GetLastError();
/*! /*!
* \brief Wrap a sequence of ids in a SMESH_IDSource * \brief Wrap a sequence of ids in a SMESH_IDSource
@ -100,38 +100,25 @@ public:
*/ */
std::string GenerateGroupName(const std::string& thePrefix); std::string GenerateGroupName(const std::string& thePrefix);
CORBA::Boolean RemoveElements(const SMESH::long_array & IDsOfElements) CORBA::Boolean RemoveElements(const SMESH::long_array & IDsOfElements);
; CORBA::Boolean RemoveNodes (const SMESH::long_array & IDsOfNodes);
CORBA::Boolean RemoveNodes (const SMESH::long_array & IDsOfNodes) CORBA::Long RemoveOrphanNodes();
;
CORBA::Long RemoveOrphanNodes()
;
/*! /*!
* Methods for creation new elements. * Methods for creation new elements.
* Returns ID of created element or 0 if element not created * Returns ID of created element or 0 if element not created
*/ */
CORBA::Long AddNode(CORBA::Double x, CORBA::Double y, CORBA::Double z) CORBA::Long AddNode(CORBA::Double x, CORBA::Double y, CORBA::Double z);
; CORBA::Long Add0DElement(CORBA::Long IDOfNode, CORBA::Boolean DuplicateElements);
CORBA::Long Add0DElement(CORBA::Long IDOfNode, CORBA::Boolean DuplicateElements) CORBA::Long AddBall(CORBA::Long IDOfNodem, CORBA::Double diameter);
; CORBA::Long AddEdge(const SMESH::long_array & IDsOfNodes);
CORBA::Long AddBall(CORBA::Long IDOfNodem, CORBA::Double diameter) CORBA::Long AddFace(const SMESH::long_array & IDsOfNodes);
; CORBA::Long AddPolygonalFace(const SMESH::long_array & IDsOfNodes);
CORBA::Long AddEdge(const SMESH::long_array & IDsOfNodes) CORBA::Long AddQuadPolygonalFace(const SMESH::long_array & IDsOfNodes);
; CORBA::Long AddVolume(const SMESH::long_array & IDsOfNodes);
CORBA::Long AddFace(const SMESH::long_array & IDsOfNodes)
;
CORBA::Long AddPolygonalFace(const SMESH::long_array & IDsOfNodes)
;
CORBA::Long AddQuadPolygonalFace(const SMESH::long_array & IDsOfNodes)
;
CORBA::Long AddVolume(const SMESH::long_array & IDsOfNodes)
;
CORBA::Long AddPolyhedralVolume(const SMESH::long_array & IDsOfNodes, CORBA::Long AddPolyhedralVolume(const SMESH::long_array & IDsOfNodes,
const SMESH::long_array & Quantities) const SMESH::long_array & Quantities);
; CORBA::Long AddPolyhedralVolumeByFaces(const SMESH::long_array & IdsOfFaces);
CORBA::Long AddPolyhedralVolumeByFaces(const SMESH::long_array & IdsOfFaces)
;
/*! /*!
* \brief Create 0D elements on all nodes of the given object except those * \brief Create 0D elements on all nodes of the given object except those
@ -145,16 +132,14 @@ public:
*/ */
SMESH::SMESH_IDSource_ptr Create0DElementsOnAllNodes(SMESH::SMESH_IDSource_ptr theObject, SMESH::SMESH_IDSource_ptr Create0DElementsOnAllNodes(SMESH::SMESH_IDSource_ptr theObject,
const char* theGroupName, const char* theGroupName,
CORBA::Boolean theDuplicateElements) CORBA::Boolean theDuplicateElements);
;
/*! /*!
* \brief Bind a node to a vertex * \brief Bind a node to a vertex
* \param NodeID - node ID * \param NodeID - node ID
* \param VertexID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0] * \param VertexID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
*/ */
void SetNodeOnVertex(CORBA::Long NodeID, CORBA::Long VertexID) void SetNodeOnVertex(CORBA::Long NodeID, CORBA::Long VertexID);
;
/*! /*!
* \brief Store node position on an edge * \brief Store node position on an edge
* \param NodeID - node ID * \param NodeID - node ID
@ -162,8 +147,7 @@ public:
* \param paramOnEdge - parameter on edge where the node is located * \param paramOnEdge - parameter on edge where the node is located
*/ */
void SetNodeOnEdge(CORBA::Long NodeID, CORBA::Long EdgeID, void SetNodeOnEdge(CORBA::Long NodeID, CORBA::Long EdgeID,
CORBA::Double paramOnEdge) CORBA::Double paramOnEdge);
;
/*! /*!
* \brief Store node position on a face * \brief Store node position on a face
* \param NodeID - node ID * \param NodeID - node ID
@ -172,36 +156,28 @@ public:
* \param v - V parameter on face where the node is located * \param v - V parameter on face where the node is located
*/ */
void SetNodeOnFace(CORBA::Long NodeID, CORBA::Long FaceID, void SetNodeOnFace(CORBA::Long NodeID, CORBA::Long FaceID,
CORBA::Double u, CORBA::Double v) CORBA::Double u, CORBA::Double v);
;
/*! /*!
* \brief Bind a node to a solid * \brief Bind a node to a solid
* \param NodeID - node ID * \param NodeID - node ID
* \param SolidID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0] * \param SolidID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
*/ */
void SetNodeInVolume(CORBA::Long NodeID, CORBA::Long SolidID) void SetNodeInVolume(CORBA::Long NodeID, CORBA::Long SolidID);
;
/*! /*!
* \brief Bind an element to a shape * \brief Bind an element to a shape
* \param ElementID - element ID * \param ElementID - element ID
* \param ShapeID - shape ID available through GEOM_Object.GetSubShapeIndices()[0] * \param ShapeID - shape ID available through GEOM_Object.GetSubShapeIndices()[0]
*/ */
void SetMeshElementOnShape(CORBA::Long ElementID, CORBA::Long ShapeID) void SetMeshElementOnShape(CORBA::Long ElementID, CORBA::Long ShapeID);
;
CORBA::Boolean MoveNode(CORBA::Long NodeID, CORBA::Boolean MoveNode(CORBA::Long NodeID,
CORBA::Double x, CORBA::Double y, CORBA::Double z) CORBA::Double x, CORBA::Double y, CORBA::Double z);
;
CORBA::Boolean InverseDiag(CORBA::Long NodeID1, CORBA::Long NodeID2) CORBA::Boolean InverseDiag(CORBA::Long NodeID1, CORBA::Long NodeID2);
; CORBA::Boolean DeleteDiag(CORBA::Long NodeID1, CORBA::Long NodeID2);
CORBA::Boolean DeleteDiag(CORBA::Long NodeID1, CORBA::Long NodeID2) CORBA::Boolean Reorient(const SMESH::long_array & IDsOfElements);
; CORBA::Boolean ReorientObject(SMESH::SMESH_IDSource_ptr theObject);
CORBA::Boolean Reorient(const SMESH::long_array & IDsOfElements)
;
CORBA::Boolean ReorientObject(SMESH::SMESH_IDSource_ptr theObject)
;
/*! /*!
* \brief Reorient faces contained in \a the2Dgroup. * \brief Reorient faces contained in \a the2Dgroup.
@ -215,7 +191,7 @@ public:
CORBA::Long Reorient2D(SMESH::SMESH_IDSource_ptr the2Dgroup, CORBA::Long Reorient2D(SMESH::SMESH_IDSource_ptr the2Dgroup,
const SMESH::DirStruct& theDirection, const SMESH::DirStruct& theDirection,
CORBA::Long theFace, CORBA::Long theFace,
const SMESH::PointStruct& thePoint) ; const SMESH::PointStruct& thePoint);
/*! /*!
* \brief Reorient faces basing on orientation of adjacent volumes. * \brief Reorient faces basing on orientation of adjacent volumes.
* \param faces - a list of objects containing face to reorient * \param faces - a list of objects containing face to reorient
@ -226,101 +202,78 @@ public:
*/ */
CORBA::Long Reorient2DBy3D(const SMESH::ListOfIDSources & faces, CORBA::Long Reorient2DBy3D(const SMESH::ListOfIDSources & faces,
SMESH::SMESH_IDSource_ptr volumes, SMESH::SMESH_IDSource_ptr volumes,
CORBA::Boolean outsideNormal) CORBA::Boolean outsideNormal);
;
// Split/Join // Split/Join
CORBA::Boolean TriToQuad (const SMESH::long_array & IDsOfElements, CORBA::Boolean TriToQuad (const SMESH::long_array & IDsOfElements,
SMESH::NumericalFunctor_ptr Criterion, SMESH::NumericalFunctor_ptr Criterion,
CORBA::Double MaxAngle) CORBA::Double MaxAngle);
;
CORBA::Boolean TriToQuadObject (SMESH::SMESH_IDSource_ptr theObject, CORBA::Boolean TriToQuadObject (SMESH::SMESH_IDSource_ptr theObject,
SMESH::NumericalFunctor_ptr Criterion, SMESH::NumericalFunctor_ptr Criterion,
CORBA::Double MaxAngle) CORBA::Double MaxAngle);
;
CORBA::Boolean QuadToTri (const SMESH::long_array & IDsOfElements, CORBA::Boolean QuadToTri (const SMESH::long_array & IDsOfElements,
SMESH::NumericalFunctor_ptr Criterion) SMESH::NumericalFunctor_ptr Criterion);
;
CORBA::Boolean QuadToTriObject (SMESH::SMESH_IDSource_ptr theObject, CORBA::Boolean QuadToTriObject (SMESH::SMESH_IDSource_ptr theObject,
SMESH::NumericalFunctor_ptr Criterion) SMESH::NumericalFunctor_ptr Criterion);
; void QuadTo4Tri (SMESH::SMESH_IDSource_ptr theObject);
void QuadTo4Tri (SMESH::SMESH_IDSource_ptr theObject)
;
CORBA::Boolean SplitQuad (const SMESH::long_array & IDsOfElements, CORBA::Boolean SplitQuad (const SMESH::long_array & IDsOfElements,
CORBA::Boolean Diag13) CORBA::Boolean Diag13);
;
CORBA::Boolean SplitQuadObject (SMESH::SMESH_IDSource_ptr theObject, CORBA::Boolean SplitQuadObject (SMESH::SMESH_IDSource_ptr theObject,
CORBA::Boolean Diag13) CORBA::Boolean Diag13);
;
CORBA::Long BestSplit (CORBA::Long IDOfQuad, CORBA::Long BestSplit (CORBA::Long IDOfQuad,
SMESH::NumericalFunctor_ptr Criterion) SMESH::NumericalFunctor_ptr Criterion);
;
void SplitVolumesIntoTetra(SMESH::SMESH_IDSource_ptr elems, void SplitVolumesIntoTetra(SMESH::SMESH_IDSource_ptr elems,
CORBA::Short methodFlags) CORBA::Short methodFlags);
;
void SplitHexahedraIntoPrisms(SMESH::SMESH_IDSource_ptr elems, void SplitHexahedraIntoPrisms(SMESH::SMESH_IDSource_ptr elems,
const SMESH::PointStruct & startHexPoint, const SMESH::PointStruct & startHexPoint,
const SMESH::DirStruct& facetToSplitNormal, const SMESH::DirStruct& facetToSplitNormal,
CORBA::Short methodFlags, CORBA::Short methodFlags,
CORBA::Boolean allDomains) CORBA::Boolean allDomains);
; void SplitBiQuadraticIntoLinear(const SMESH::ListOfIDSources& elems);
void SplitBiQuadraticIntoLinear(const SMESH::ListOfIDSources& elems)
;
CORBA::Boolean Smooth(const SMESH::long_array & IDsOfElements, CORBA::Boolean Smooth(const SMESH::long_array & IDsOfElements,
const SMESH::long_array & IDsOfFixedNodes, const SMESH::long_array & IDsOfFixedNodes,
CORBA::Long MaxNbOfIterations, CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio, CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method) SMESH::SMESH_MeshEditor::Smooth_Method Method);
;
CORBA::Boolean SmoothObject(SMESH::SMESH_IDSource_ptr theObject, CORBA::Boolean SmoothObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::long_array & IDsOfFixedNodes, const SMESH::long_array & IDsOfFixedNodes,
CORBA::Long MaxNbOfIterations, CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio, CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method) SMESH::SMESH_MeshEditor::Smooth_Method Method);
;
CORBA::Boolean SmoothParametric(const SMESH::long_array & IDsOfElements, CORBA::Boolean SmoothParametric(const SMESH::long_array & IDsOfElements,
const SMESH::long_array & IDsOfFixedNodes, const SMESH::long_array & IDsOfFixedNodes,
CORBA::Long MaxNbOfIterations, CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio, CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method) SMESH::SMESH_MeshEditor::Smooth_Method Method) ;
;
CORBA::Boolean SmoothParametricObject(SMESH::SMESH_IDSource_ptr theObject, CORBA::Boolean SmoothParametricObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::long_array & IDsOfFixedNodes, const SMESH::long_array & IDsOfFixedNodes,
CORBA::Long MaxNbOfIterations, CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio, CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method) SMESH::SMESH_MeshEditor::Smooth_Method Method);
;
CORBA::Boolean smooth(const SMESH::long_array & IDsOfElements, CORBA::Boolean smooth(const SMESH::long_array & IDsOfElements,
const SMESH::long_array & IDsOfFixedNodes, const SMESH::long_array & IDsOfFixedNodes,
CORBA::Long MaxNbOfIterations, CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio, CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method, SMESH::SMESH_MeshEditor::Smooth_Method Method,
bool IsParametric) bool IsParametric);
;
CORBA::Boolean smoothObject(SMESH::SMESH_IDSource_ptr theObject, CORBA::Boolean smoothObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::long_array & IDsOfFixedNodes, const SMESH::long_array & IDsOfFixedNodes,
CORBA::Long MaxNbOfIterations, CORBA::Long MaxNbOfIterations,
CORBA::Double MaxAspectRatio, CORBA::Double MaxAspectRatio,
SMESH::SMESH_MeshEditor::Smooth_Method Method, SMESH::SMESH_MeshEditor::Smooth_Method Method,
bool IsParametric) bool IsParametric);
;
CORBA::Boolean ConvertFromQuadratic() CORBA::Boolean ConvertFromQuadratic();
; void ConvertFromQuadraticObject(SMESH::SMESH_IDSource_ptr theObject);
void ConvertFromQuadraticObject(SMESH::SMESH_IDSource_ptr theObject) void ConvertToQuadratic(CORBA::Boolean Force3d);
;
void ConvertToQuadratic(CORBA::Boolean Force3d)
;
void ConvertToQuadraticObject(CORBA::Boolean theForce3d, void ConvertToQuadraticObject(CORBA::Boolean theForce3d,
SMESH::SMESH_IDSource_ptr theObject) SMESH::SMESH_IDSource_ptr theObject);
;
void ConvertToBiQuadratic(CORBA::Boolean theForce3d, void ConvertToBiQuadratic(CORBA::Boolean theForce3d,
SMESH::SMESH_IDSource_ptr theObject) SMESH::SMESH_IDSource_ptr theObject);
;
void RenumberNodes() ; void RenumberNodes();
void RenumberElements() ; void RenumberElements();
SMESH::ListOfGroups* RotationSweepObjects(const SMESH::ListOfIDSources & Nodes, SMESH::ListOfGroups* RotationSweepObjects(const SMESH::ListOfIDSources & Nodes,
const SMESH::ListOfIDSources & Edges, const SMESH::ListOfIDSources & Edges,
@ -329,8 +282,7 @@ public:
CORBA::Double AngleInRadians, CORBA::Double AngleInRadians,
CORBA::Long NbOfSteps, CORBA::Long NbOfSteps,
CORBA::Double Tolerance, CORBA::Double Tolerance,
CORBA::Boolean ToMakeGroups) CORBA::Boolean ToMakeGroups);
;
SMESH::ListOfGroups* ExtrusionSweepObjects(const SMESH::ListOfIDSources & Nodes, SMESH::ListOfGroups* ExtrusionSweepObjects(const SMESH::ListOfIDSources & Nodes,
const SMESH::ListOfIDSources & Edges, const SMESH::ListOfIDSources & Edges,
@ -342,8 +294,7 @@ public:
CORBA::Boolean ScalesVariation, CORBA::Boolean ScalesVariation,
const SMESH::double_array & BasePoint, const SMESH::double_array & BasePoint,
const SMESH::double_array & Angles, const SMESH::double_array & Angles,
CORBA::Boolean AnglesVariation) CORBA::Boolean AnglesVariation);
;
SMESH::ListOfGroups* ExtrusionByNormal(const SMESH::ListOfIDSources& objects, SMESH::ListOfGroups* ExtrusionByNormal(const SMESH::ListOfIDSources& objects,
CORBA::Double stepSize, CORBA::Double stepSize,
@ -351,15 +302,13 @@ public:
CORBA::Boolean byAverageNormal, CORBA::Boolean byAverageNormal,
CORBA::Boolean useInputElemsOnly, CORBA::Boolean useInputElemsOnly,
CORBA::Boolean makeGroups, CORBA::Boolean makeGroups,
CORBA::Short dim) CORBA::Short dim);
;
SMESH::ListOfGroups* AdvancedExtrusion(const SMESH::long_array & theIDsOfElements, SMESH::ListOfGroups* AdvancedExtrusion(const SMESH::long_array & theIDsOfElements,
const SMESH::DirStruct & theStepVector, const SMESH::DirStruct & theStepVector,
CORBA::Long theNbOfSteps, CORBA::Long theNbOfSteps,
CORBA::Long theExtrFlags, CORBA::Long theExtrFlags,
CORBA::Double theSewTolerance, CORBA::Double theSewTolerance,
CORBA::Boolean theMakeGroups) CORBA::Boolean theMakeGroups);
;
SMESH::ListOfGroups* SMESH::ListOfGroups*
ExtrusionAlongPathObjects(const SMESH::ListOfIDSources & Nodes, ExtrusionAlongPathObjects(const SMESH::ListOfIDSources & Nodes,
@ -376,8 +325,7 @@ public:
bool MakeGroups, bool MakeGroups,
const SMESH::double_array & ScaleFactors, const SMESH::double_array & ScaleFactors,
CORBA::Boolean ScalesVariation, CORBA::Boolean ScalesVariation,
SMESH::SMESH_MeshEditor::Extrusion_Error& Error) SMESH::SMESH_MeshEditor::Extrusion_Error& Error);
;
SMESH::double_array* LinearAnglesVariation(SMESH::SMESH_Mesh_ptr PathMesh, SMESH::double_array* LinearAnglesVariation(SMESH::SMESH_Mesh_ptr PathMesh,
GEOM::GEOM_Object_ptr PathShape, GEOM::GEOM_Object_ptr PathShape,
@ -386,156 +334,125 @@ public:
void Mirror(const SMESH::long_array & IDsOfElements, void Mirror(const SMESH::long_array & IDsOfElements,
const SMESH::AxisStruct & Axis, const SMESH::AxisStruct & Axis,
SMESH::SMESH_MeshEditor::MirrorType MirrorType, SMESH::SMESH_MeshEditor::MirrorType MirrorType,
CORBA::Boolean Copy) CORBA::Boolean Copy);
;
void MirrorObject(SMESH::SMESH_IDSource_ptr theObject, void MirrorObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct & Axis, const SMESH::AxisStruct & Axis,
SMESH::SMESH_MeshEditor::MirrorType MirrorType, SMESH::SMESH_MeshEditor::MirrorType MirrorType,
CORBA::Boolean Copy) CORBA::Boolean Copy);
;
void Translate(const SMESH::long_array & IDsOfElements, void Translate(const SMESH::long_array & IDsOfElements,
const SMESH::DirStruct & Vector, const SMESH::DirStruct & Vector,
CORBA::Boolean Copy) CORBA::Boolean Copy);
;
void TranslateObject(SMESH::SMESH_IDSource_ptr theObject, void TranslateObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::DirStruct & Vector, const SMESH::DirStruct & Vector,
CORBA::Boolean Copy) CORBA::Boolean Copy);
;
void Rotate(const SMESH::long_array & IDsOfElements, void Rotate(const SMESH::long_array & IDsOfElements,
const SMESH::AxisStruct & Axis, const SMESH::AxisStruct & Axis,
CORBA::Double Angle, CORBA::Double Angle,
CORBA::Boolean Copy) CORBA::Boolean Copy);
;
void RotateObject(SMESH::SMESH_IDSource_ptr theObject, void RotateObject(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::AxisStruct & Axis, const SMESH::AxisStruct & Axis,
CORBA::Double Angle, CORBA::Double Angle,
CORBA::Boolean Copy) CORBA::Boolean Copy);
;
SMESH::ListOfGroups* MirrorMakeGroups(const SMESH::long_array& IDsOfElements, SMESH::ListOfGroups* MirrorMakeGroups(const SMESH::long_array& IDsOfElements,
const SMESH::AxisStruct& Mirror, const SMESH::AxisStruct& Mirror,
SMESH::SMESH_MeshEditor::MirrorType MirrorType) SMESH::SMESH_MeshEditor::MirrorType MirrorType);
;
SMESH::ListOfGroups* MirrorObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object, SMESH::ListOfGroups* MirrorObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Mirror, const SMESH::AxisStruct& Mirror,
SMESH::SMESH_MeshEditor::MirrorType MirrorType) SMESH::SMESH_MeshEditor::MirrorType MirrorType);
;
SMESH::ListOfGroups* TranslateMakeGroups(const SMESH::long_array& IDsOfElements, SMESH::ListOfGroups* TranslateMakeGroups(const SMESH::long_array& IDsOfElements,
const SMESH::DirStruct& Vector) const SMESH::DirStruct& Vector);
;
SMESH::ListOfGroups* TranslateObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object, SMESH::ListOfGroups* TranslateObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::DirStruct& Vector) const SMESH::DirStruct& Vector);
;
SMESH::ListOfGroups* RotateMakeGroups(const SMESH::long_array& IDsOfElements, SMESH::ListOfGroups* RotateMakeGroups(const SMESH::long_array& IDsOfElements,
const SMESH::AxisStruct& Axis, const SMESH::AxisStruct& Axis,
CORBA::Double AngleInRadians) CORBA::Double AngleInRadians);
;
SMESH::ListOfGroups* RotateObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object, SMESH::ListOfGroups* RotateObjectMakeGroups(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Axis, const SMESH::AxisStruct& Axis,
CORBA::Double AngleInRadians) CORBA::Double AngleInRadians);
;
SMESH::SMESH_Mesh_ptr MirrorMakeMesh(const SMESH::long_array& IDsOfElements, SMESH::SMESH_Mesh_ptr MirrorMakeMesh(const SMESH::long_array& IDsOfElements,
const SMESH::AxisStruct& Mirror, const SMESH::AxisStruct& Mirror,
SMESH::SMESH_MeshEditor::MirrorType MirrorType, SMESH::SMESH_MeshEditor::MirrorType MirrorType,
CORBA::Boolean CopyGroups, CORBA::Boolean CopyGroups,
const char* MeshName) const char* MeshName);
;
SMESH::SMESH_Mesh_ptr MirrorObjectMakeMesh(SMESH::SMESH_IDSource_ptr Object, SMESH::SMESH_Mesh_ptr MirrorObjectMakeMesh(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Mirror, const SMESH::AxisStruct& Mirror,
SMESH::SMESH_MeshEditor::MirrorType MirrorType, SMESH::SMESH_MeshEditor::MirrorType MirrorType,
CORBA::Boolean CopyGroups, CORBA::Boolean CopyGroups,
const char* MeshName) const char* MeshName);
;
SMESH::SMESH_Mesh_ptr TranslateMakeMesh(const SMESH::long_array& IDsOfElements, SMESH::SMESH_Mesh_ptr TranslateMakeMesh(const SMESH::long_array& IDsOfElements,
const SMESH::DirStruct& Vector, const SMESH::DirStruct& Vector,
CORBA::Boolean CopyGroups, CORBA::Boolean CopyGroups,
const char* MeshName) const char* MeshName);
;
SMESH::SMESH_Mesh_ptr TranslateObjectMakeMesh(SMESH::SMESH_IDSource_ptr Object, SMESH::SMESH_Mesh_ptr TranslateObjectMakeMesh(SMESH::SMESH_IDSource_ptr Object,
const SMESH::DirStruct& Vector, const SMESH::DirStruct& Vector,
CORBA::Boolean CopyGroups, CORBA::Boolean CopyGroups,
const char* MeshName) const char* MeshName);
;
SMESH::SMESH_Mesh_ptr RotateMakeMesh(const SMESH::long_array& IDsOfElements, SMESH::SMESH_Mesh_ptr RotateMakeMesh(const SMESH::long_array& IDsOfElements,
const SMESH::AxisStruct& Axis, const SMESH::AxisStruct& Axis,
CORBA::Double AngleInRadians, CORBA::Double AngleInRadians,
CORBA::Boolean CopyGroups, CORBA::Boolean CopyGroups,
const char* MeshName) const char* MeshName);
;
SMESH::SMESH_Mesh_ptr RotateObjectMakeMesh(SMESH::SMESH_IDSource_ptr Object, SMESH::SMESH_Mesh_ptr RotateObjectMakeMesh(SMESH::SMESH_IDSource_ptr Object,
const SMESH::AxisStruct& Axis, const SMESH::AxisStruct& Axis,
CORBA::Double AngleInRadians, CORBA::Double AngleInRadians,
CORBA::Boolean CopyGroups, CORBA::Boolean CopyGroups,
const char* MeshName) const char* MeshName);
;
void Scale(SMESH::SMESH_IDSource_ptr theObject, void Scale(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::PointStruct& thePoint, const SMESH::PointStruct& thePoint,
const SMESH::double_array& theScaleFact, const SMESH::double_array& theScaleFact,
CORBA::Boolean theCopy) CORBA::Boolean theCopy);
;
SMESH::ListOfGroups* ScaleMakeGroups(SMESH::SMESH_IDSource_ptr theObject, SMESH::ListOfGroups* ScaleMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::PointStruct& thePoint, const SMESH::PointStruct& thePoint,
const SMESH::double_array& theScaleFact) const SMESH::double_array& theScaleFact);
;
SMESH::SMESH_Mesh_ptr ScaleMakeMesh(SMESH::SMESH_IDSource_ptr Object, SMESH::SMESH_Mesh_ptr ScaleMakeMesh(SMESH::SMESH_IDSource_ptr Object,
const SMESH::PointStruct& Point, const SMESH::PointStruct& Point,
const SMESH::double_array& theScaleFact, const SMESH::double_array& theScaleFact,
CORBA::Boolean CopyGroups, CORBA::Boolean CopyGroups,
const char* MeshName) const char* MeshName);
;
SMESH::SMESH_Mesh_ptr Offset( SMESH::SMESH_IDSource_ptr theObject, SMESH::SMESH_Mesh_ptr Offset( SMESH::SMESH_IDSource_ptr theObject,
CORBA::Double Value, CORBA::Double Value,
CORBA::Boolean CopyGroups, CORBA::Boolean CopyGroups,
CORBA::Boolean CopyElements, CORBA::Boolean CopyElements,
const char* MeshName, const char* MeshName,
SMESH::ListOfGroups_out Groups) SMESH::ListOfGroups_out Groups);
;
void FindCoincidentNodes (CORBA::Double Tolerance, void FindCoincidentNodes (CORBA::Double Tolerance,
SMESH::array_of_long_array_out GroupsOfNodes, SMESH::array_of_long_array_out GroupsOfNodes,
CORBA::Boolean SeparateCornersAndMedium) CORBA::Boolean SeparateCornersAndMedium);
;
void FindCoincidentNodesOnPart(SMESH::SMESH_IDSource_ptr Object, void FindCoincidentNodesOnPart(SMESH::SMESH_IDSource_ptr Object,
CORBA::Double Tolerance, CORBA::Double Tolerance,
SMESH::array_of_long_array_out GroupsOfNodes, SMESH::array_of_long_array_out GroupsOfNodes,
CORBA::Boolean SeparateCornersAndMedium) CORBA::Boolean SeparateCornersAndMedium);
;
void FindCoincidentNodesOnPartBut(const SMESH::ListOfIDSources& Objects, void FindCoincidentNodesOnPartBut(const SMESH::ListOfIDSources& Objects,
CORBA::Double Tolerance, CORBA::Double Tolerance,
SMESH::array_of_long_array_out GroupsOfNodes, SMESH::array_of_long_array_out GroupsOfNodes,
const SMESH::ListOfIDSources& ExceptSubMeshOrGroups, const SMESH::ListOfIDSources& ExceptSubMeshOrGroups,
CORBA::Boolean SeparateCornersAndMedium) CORBA::Boolean SeparateCornersAndMedium);
;
void MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes, void MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes,
const SMESH::ListOfIDSources& NodesToKeep, const SMESH::ListOfIDSources& NodesToKeep,
CORBA::Boolean AvoidMakingHoles ) CORBA::Boolean AvoidMakingHoles );
;
void FindEqualElements(const SMESH::ListOfIDSources& Objects, void FindEqualElements(const SMESH::ListOfIDSources& Objects,
const SMESH::ListOfIDSources& ExceptSubMeshOrGroups, const SMESH::ListOfIDSources& ExceptSubMeshOrGroups,
SMESH::array_of_long_array_out GroupsOfElementsID) SMESH::array_of_long_array_out GroupsOfElementsID);
;
void MergeElements(const SMESH::array_of_long_array& GroupsOfElementsID, void MergeElements(const SMESH::array_of_long_array& GroupsOfElementsID,
const SMESH::ListOfIDSources& ElementsToKeep) const SMESH::ListOfIDSources& ElementsToKeep);
; void MergeEqualElements();
void MergeEqualElements()
;
CORBA::Long MoveClosestNodeToPoint(CORBA::Double x, CORBA::Long MoveClosestNodeToPoint(CORBA::Double x,
CORBA::Double y, CORBA::Double y,
CORBA::Double z, CORBA::Double z,
CORBA::Long nodeID) CORBA::Long nodeID);
;
/*! /*!
* \brief Return ID of node closest to a given point * \brief Return ID of node closest to a given point
*/ */
CORBA::Long FindNodeClosestTo(CORBA::Double x, CORBA::Long FindNodeClosestTo(CORBA::Double x,
CORBA::Double y, CORBA::Double y,
CORBA::Double z) CORBA::Double z);
;
/*! /*!
* Return elements of given type where the given point is IN or ON. * Return elements of given type where the given point is IN or ON.
* 'ALL' type means elements of any type excluding nodes * 'ALL' type means elements of any type excluding nodes
@ -543,8 +460,7 @@ public:
SMESH::long_array* FindElementsByPoint(CORBA::Double x, SMESH::long_array* FindElementsByPoint(CORBA::Double x,
CORBA::Double y, CORBA::Double y,
CORBA::Double z, CORBA::Double z,
SMESH::ElementType type) SMESH::ElementType type);
;
/*! /*!
* Searching among the given elements, return elements of given type * Searching among the given elements, return elements of given type
* where the given point is IN or ON. * where the given point is IN or ON.
@ -554,8 +470,7 @@ public:
CORBA::Double x, CORBA::Double x,
CORBA::Double y, CORBA::Double y,
CORBA::Double z, CORBA::Double z,
SMESH::ElementType type) SMESH::ElementType type);
;
/*! /*!
* Project a point to a mesh object. * Project a point to a mesh object.
@ -568,27 +483,23 @@ public:
CORBA::Double z, CORBA::Double z,
SMESH::ElementType type, SMESH::ElementType type,
SMESH::SMESH_IDSource_ptr meshObject, SMESH::SMESH_IDSource_ptr meshObject,
SMESH::double_array_out projecton) SMESH::double_array_out projecton);
;
/*! /*!
* Return point state in a closed 2D mesh in terms of TopAbs_State enumeration. * Return point state in a closed 2D mesh in terms of TopAbs_State enumeration.
* TopAbs_UNKNOWN state means that either mesh is wrong or the analysis fails. * TopAbs_UNKNOWN state means that either mesh is wrong or the analysis fails.
*/ */
CORBA::Short GetPointState(CORBA::Double x, CORBA::Double y, CORBA::Double z) CORBA::Short GetPointState(CORBA::Double x, CORBA::Double y, CORBA::Double z);
;
/*! /*!
* Check if a 2D mesh is manifold * Check if a 2D mesh is manifold
*/ */
CORBA::Boolean IsManifold() CORBA::Boolean IsManifold();
;
/*! /*!
* Check if orientation of 2D elements is coherent * Check if orientation of 2D elements is coherent
*/ */
CORBA::Boolean IsCoherentOrientation2D() CORBA::Boolean IsCoherentOrientation2D();
;
/*! /*!
* Partition given 1D elements into groups of contiguous edges. * Partition given 1D elements into groups of contiguous edges.
@ -599,34 +510,29 @@ public:
*/ */
SMESH::array_of_long_array* Get1DBranches( SMESH::SMESH_IDSource_ptr edges, SMESH::array_of_long_array* Get1DBranches( SMESH::SMESH_IDSource_ptr edges,
CORBA::Long startNode, CORBA::Long startNode,
SMESH::array_of_long_array_out nodeGroups) SMESH::array_of_long_array_out nodeGroups);
;
/*! /*!
* Return sharp edges of faces and non-manifold ones. Optionally adds existing edges. * Return sharp edges of faces and non-manifold ones. Optionally adds existing edges.
*/ */
SMESH::ListOfEdges* FindSharpEdges(CORBA::Double angle, CORBA::Boolean addExisting) SMESH::ListOfEdges* FindSharpEdges(CORBA::Double angle, CORBA::Boolean addExisting);
;
/*! /*!
* Returns all or only closed FreeBorder's. * Returns all or only closed FreeBorder's.
*/ */
SMESH::ListOfFreeBorders* FindFreeBorders(CORBA::Boolean closedOnly) SMESH::ListOfFreeBorders* FindFreeBorders(CORBA::Boolean closedOnly);
;
/*! /*!
* Fill with 2D elements a hole defined by a FreeBorder. * Fill with 2D elements a hole defined by a FreeBorder.
* Optionally add new faces to a given group, which is returned * Optionally add new faces to a given group, which is returned
*/ */
SMESH::SMESH_Group_ptr FillHole(const SMESH::FreeBorder& hole, SMESH::SMESH_Group_ptr FillHole(const SMESH::FreeBorder& hole,
const char* groupName) const char* groupName);
;
SMESH::CoincidentFreeBorders* FindCoincidentFreeBorders(CORBA::Double tolerance); SMESH::CoincidentFreeBorders* FindCoincidentFreeBorders(CORBA::Double tolerance);
CORBA::Short SewCoincidentFreeBorders(const SMESH::CoincidentFreeBorders& freeBorders, CORBA::Short SewCoincidentFreeBorders(const SMESH::CoincidentFreeBorders& freeBorders,
CORBA::Boolean createPolygons, CORBA::Boolean createPolygons,
CORBA::Boolean createPolyedrs) CORBA::Boolean createPolyedrs);
;
SMESH::SMESH_MeshEditor::Sew_Error SMESH::SMESH_MeshEditor::Sew_Error
SewFreeBorders(CORBA::Long FirstNodeID1, SewFreeBorders(CORBA::Long FirstNodeID1,
@ -636,13 +542,13 @@ public:
CORBA::Long SecondNodeID2, CORBA::Long SecondNodeID2,
CORBA::Long LastNodeID2, CORBA::Long LastNodeID2,
CORBA::Boolean CreatePolygons, CORBA::Boolean CreatePolygons,
CORBA::Boolean CreatePolyedrs) ; CORBA::Boolean CreatePolyedrs);
SMESH::SMESH_MeshEditor::Sew_Error SMESH::SMESH_MeshEditor::Sew_Error
SewConformFreeBorders(CORBA::Long FirstNodeID1, SewConformFreeBorders(CORBA::Long FirstNodeID1,
CORBA::Long SecondNodeID1, CORBA::Long SecondNodeID1,
CORBA::Long LastNodeID1, CORBA::Long LastNodeID1,
CORBA::Long FirstNodeID2, CORBA::Long FirstNodeID2,
CORBA::Long SecondNodeID2) ; CORBA::Long SecondNodeID2);
SMESH::SMESH_MeshEditor::Sew_Error SMESH::SMESH_MeshEditor::Sew_Error
SewBorderToSide(CORBA::Long FirstNodeIDOnFreeBorder, SewBorderToSide(CORBA::Long FirstNodeIDOnFreeBorder,
CORBA::Long SecondNodeIDOnFreeBorder, CORBA::Long SecondNodeIDOnFreeBorder,
@ -650,38 +556,33 @@ public:
CORBA::Long FirstNodeIDOnSide, CORBA::Long FirstNodeIDOnSide,
CORBA::Long LastNodeIDOnSide, CORBA::Long LastNodeIDOnSide,
CORBA::Boolean CreatePolygons, CORBA::Boolean CreatePolygons,
CORBA::Boolean CreatePolyedrs) ; CORBA::Boolean CreatePolyedrs);
SMESH::SMESH_MeshEditor::Sew_Error SMESH::SMESH_MeshEditor::Sew_Error
SewSideElements(const SMESH::long_array& IDsOfSide1Elements, SewSideElements(const SMESH::long_array& IDsOfSide1Elements,
const SMESH::long_array& IDsOfSide2Elements, const SMESH::long_array& IDsOfSide2Elements,
CORBA::Long NodeID1OfSide1ToMerge, CORBA::Long NodeID1OfSide1ToMerge,
CORBA::Long NodeID1OfSide2ToMerge, CORBA::Long NodeID1OfSide2ToMerge,
CORBA::Long NodeID2OfSide1ToMerge, CORBA::Long NodeID2OfSide1ToMerge,
CORBA::Long NodeID2OfSide2ToMerge) ; CORBA::Long NodeID2OfSide2ToMerge);
/*! /*!
* Set new nodes for given element. * Set new nodes for given element.
* If number of nodes is not corresponded to type of * If number of nodes is not corresponded to type of
* element - returns false * element - returns false
*/ */
CORBA::Boolean ChangeElemNodes(CORBA::Long ide, const SMESH::long_array& newIDs) CORBA::Boolean ChangeElemNodes(CORBA::Long ide, const SMESH::long_array& newIDs);
;
SMESH::SMESH_Group_ptr DoubleElements(SMESH::SMESH_IDSource_ptr theElements, SMESH::SMESH_Group_ptr DoubleElements(SMESH::SMESH_IDSource_ptr theElements,
const char* theGroupName) const char* theGroupName);
;
CORBA::Boolean DoubleNodes( const SMESH::long_array& theNodes, CORBA::Boolean DoubleNodes( const SMESH::long_array& theNodes,
const SMESH::long_array& theModifiedElems ) const SMESH::long_array& theModifiedElems );
;
CORBA::Boolean DoubleNode( CORBA::Long theNodeId, CORBA::Boolean DoubleNode( CORBA::Long theNodeId,
const SMESH::long_array& theModifiedElems ) const SMESH::long_array& theModifiedElems );
;
CORBA::Boolean DoubleNodeGroup( SMESH::SMESH_GroupBase_ptr theNodes, CORBA::Boolean DoubleNodeGroup( SMESH::SMESH_GroupBase_ptr theNodes,
SMESH::SMESH_GroupBase_ptr theModifiedElems ) SMESH::SMESH_GroupBase_ptr theModifiedElems );
;
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements. * \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
@ -692,16 +593,13 @@ public:
* \sa DoubleNodeGroup() * \sa DoubleNodeGroup()
*/ */
SMESH::SMESH_Group_ptr DoubleNodeGroupNew( SMESH::SMESH_GroupBase_ptr theNodes, SMESH::SMESH_Group_ptr DoubleNodeGroupNew( SMESH::SMESH_GroupBase_ptr theNodes,
SMESH::SMESH_GroupBase_ptr theModifiedElems ) SMESH::SMESH_GroupBase_ptr theModifiedElems );
;
CORBA::Boolean DoubleNodeGroups( const SMESH::ListOfGroups& theNodes, CORBA::Boolean DoubleNodeGroups( const SMESH::ListOfGroups& theNodes,
const SMESH::ListOfGroups& theModifiedElems ) const SMESH::ListOfGroups& theModifiedElems );
;
SMESH::SMESH_Group_ptr DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes, SMESH::SMESH_Group_ptr DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes,
const SMESH::ListOfGroups& theModifiedElems ) const SMESH::ListOfGroups& theModifiedElems );
;
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -715,8 +613,7 @@ public:
*/ */
CORBA::Boolean DoubleNodeElem( const SMESH::long_array& theElems, CORBA::Boolean DoubleNodeElem( const SMESH::long_array& theElems,
const SMESH::long_array& theNodesNot, const SMESH::long_array& theNodesNot,
const SMESH::long_array& theAffectedElems ) const SMESH::long_array& theAffectedElems );
;
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -731,8 +628,7 @@ public:
*/ */
CORBA::Boolean DoubleNodeElemInRegion( const SMESH::long_array& theElems, CORBA::Boolean DoubleNodeElemInRegion( const SMESH::long_array& theElems,
const SMESH::long_array& theNodesNot, const SMESH::long_array& theNodesNot,
GEOM::GEOM_Object_ptr theShape ) GEOM::GEOM_Object_ptr theShape );
;
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -745,8 +641,7 @@ public:
*/ */
CORBA::Boolean DoubleNodeElemGroup( SMESH::SMESH_GroupBase_ptr theElems, CORBA::Boolean DoubleNodeElemGroup( SMESH::SMESH_GroupBase_ptr theElems,
SMESH::SMESH_GroupBase_ptr theNodesNot, SMESH::SMESH_GroupBase_ptr theNodesNot,
SMESH::SMESH_GroupBase_ptr theAffectedElems ) SMESH::SMESH_GroupBase_ptr theAffectedElems );
;
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -760,15 +655,13 @@ public:
*/ */
SMESH::SMESH_Group_ptr DoubleNodeElemGroupNew( SMESH::SMESH_GroupBase_ptr theElems, SMESH::SMESH_Group_ptr DoubleNodeElemGroupNew( SMESH::SMESH_GroupBase_ptr theElems,
SMESH::SMESH_GroupBase_ptr theNodesNot, SMESH::SMESH_GroupBase_ptr theNodesNot,
SMESH::SMESH_GroupBase_ptr theAffectedElems ) SMESH::SMESH_GroupBase_ptr theAffectedElems );
;
SMESH::ListOfGroups* DoubleNodeElemGroup2New(SMESH::SMESH_GroupBase_ptr theElems, SMESH::ListOfGroups* DoubleNodeElemGroup2New(SMESH::SMESH_GroupBase_ptr theElems,
SMESH::SMESH_GroupBase_ptr theNodesNot, SMESH::SMESH_GroupBase_ptr theNodesNot,
SMESH::SMESH_GroupBase_ptr theAffectedElems, SMESH::SMESH_GroupBase_ptr theAffectedElems,
CORBA::Boolean theElemGroupNeeded, CORBA::Boolean theElemGroupNeeded,
CORBA::Boolean theNodeGroupNeeded) CORBA::Boolean theNodeGroupNeeded);
;
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -782,8 +675,7 @@ public:
*/ */
CORBA::Boolean DoubleNodeElemGroupInRegion( SMESH::SMESH_GroupBase_ptr theElems, CORBA::Boolean DoubleNodeElemGroupInRegion( SMESH::SMESH_GroupBase_ptr theElems,
SMESH::SMESH_GroupBase_ptr theNodesNot, SMESH::SMESH_GroupBase_ptr theNodesNot,
GEOM::GEOM_Object_ptr theShape ) GEOM::GEOM_Object_ptr theShape );
;
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -797,8 +689,7 @@ public:
*/ */
CORBA::Boolean DoubleNodeElemGroups( const SMESH::ListOfGroups& theElems, CORBA::Boolean DoubleNodeElemGroups( const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot, const SMESH::ListOfGroups& theNodesNot,
const SMESH::ListOfGroups& theAffectedElems ) const SMESH::ListOfGroups& theAffectedElems );
;
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -812,15 +703,13 @@ public:
*/ */
SMESH::SMESH_Group_ptr DoubleNodeElemGroupsNew( const SMESH::ListOfGroups& theElems, SMESH::SMESH_Group_ptr DoubleNodeElemGroupsNew( const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot, const SMESH::ListOfGroups& theNodesNot,
const SMESH::ListOfGroups& theAffectedElems ) const SMESH::ListOfGroups& theAffectedElems );
;
SMESH::ListOfGroups* DoubleNodeElemGroups2New(const SMESH::ListOfGroups& theElems, SMESH::ListOfGroups* DoubleNodeElemGroups2New(const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot, const SMESH::ListOfGroups& theNodesNot,
const SMESH::ListOfGroups& theAffectedElems, const SMESH::ListOfGroups& theAffectedElems,
CORBA::Boolean theElemGroupNeeded, CORBA::Boolean theElemGroupNeeded,
CORBA::Boolean theNodeGroupNeeded) CORBA::Boolean theNodeGroupNeeded);
;
/*! /*!
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements * \brief Creates a hole in a mesh by doubling the nodes of some particular elements
@ -835,8 +724,7 @@ public:
*/ */
CORBA::Boolean DoubleNodeElemGroupsInRegion( const SMESH::ListOfGroups& theElems, CORBA::Boolean DoubleNodeElemGroupsInRegion( const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot, const SMESH::ListOfGroups& theNodesNot,
GEOM::GEOM_Object_ptr theShape ) GEOM::GEOM_Object_ptr theShape );
;
/*! /*!
* \brief Identify the elements that will be affected by node duplication (actual duplication is not performed. * \brief Identify the elements that will be affected by node duplication (actual duplication is not performed.
@ -851,8 +739,7 @@ public:
*/ */
SMESH::ListOfGroups* AffectedElemGroupsInRegion( const SMESH::ListOfGroups& theElems, SMESH::ListOfGroups* AffectedElemGroupsInRegion( const SMESH::ListOfGroups& theElems,
const SMESH::ListOfGroups& theNodesNot, const SMESH::ListOfGroups& theNodesNot,
GEOM::GEOM_Object_ptr theShape ) GEOM::GEOM_Object_ptr theShape );
;
/*! /*!
* \brief Double nodes on shared faces between groups of volumes and create flat elements on demand. * \brief Double nodes on shared faces between groups of volumes and create flat elements on demand.
@ -868,8 +755,7 @@ public:
*/ */
CORBA::Boolean DoubleNodesOnGroupBoundaries( const SMESH::ListOfGroups& theDomains, CORBA::Boolean DoubleNodesOnGroupBoundaries( const SMESH::ListOfGroups& theDomains,
CORBA::Boolean createJointElems, CORBA::Boolean createJointElems,
CORBA::Boolean onAllBoundaries ) CORBA::Boolean onAllBoundaries );
;
/*! /*!
* \brief Double nodes on some external faces and create flat elements. * \brief Double nodes on some external faces and create flat elements.
* Flat elements are mainly used by some types of mechanic calculations. * Flat elements are mainly used by some types of mechanic calculations.
@ -879,8 +765,7 @@ public:
* @param theGroupsOfFaces - list of groups of faces * @param theGroupsOfFaces - list of groups of faces
* @return TRUE if operation has been completed successfully, FALSE otherwise * @return TRUE if operation has been completed successfully, FALSE otherwise
*/ */
CORBA::Boolean CreateFlatElementsOnFacesGroups( const SMESH::ListOfGroups& theGroupsOfFaces ) CORBA::Boolean CreateFlatElementsOnFacesGroups( const SMESH::ListOfGroups& theGroupsOfFaces );
;
/*! /*!
* \brief identify all the elements around a geom shape, get the faces delimiting the hole * \brief identify all the elements around a geom shape, get the faces delimiting the hole
@ -892,16 +777,14 @@ public:
GEOM::GEOM_Object_ptr theShape, GEOM::GEOM_Object_ptr theShape,
const char* groupName, const char* groupName,
const SMESH::double_array& theNodesCoords, const SMESH::double_array& theNodesCoords,
SMESH::array_of_long_array_out GroupsOfNodes) SMESH::array_of_long_array_out GroupsOfNodes);
;
/*! /*!
* \brief Generated skin mesh (containing 2D cells) from 3D mesh * \brief Generated skin mesh (containing 2D cells) from 3D mesh
* The created 2D mesh elements based on nodes of free faces of boundary volumes * The created 2D mesh elements based on nodes of free faces of boundary volumes
* \return TRUE if operation has been completed successfully, FALSE otherwise * \return TRUE if operation has been completed successfully, FALSE otherwise
*/ */
CORBA::Boolean Make2DMeshFrom3D() CORBA::Boolean Make2DMeshFrom3D();
;
SMESH::SMESH_Mesh_ptr MakeBoundaryMesh(SMESH::SMESH_IDSource_ptr elements, SMESH::SMESH_Mesh_ptr MakeBoundaryMesh(SMESH::SMESH_IDSource_ptr elements,
SMESH::Bnd_Dimension dimension, SMESH::Bnd_Dimension dimension,
@ -909,8 +792,7 @@ public:
const char* meshName, const char* meshName,
CORBA::Boolean toCopyElements, CORBA::Boolean toCopyElements,
CORBA::Boolean toCopyMissingBondary, CORBA::Boolean toCopyMissingBondary,
SMESH::SMESH_Group_out group) SMESH::SMESH_Group_out group);
;
CORBA::Long MakeBoundaryElements(SMESH::Bnd_Dimension dimension, CORBA::Long MakeBoundaryElements(SMESH::Bnd_Dimension dimension,
const char* groupName, const char* groupName,
@ -918,8 +800,7 @@ public:
CORBA::Boolean toCopyAll, CORBA::Boolean toCopyAll,
const SMESH::ListOfIDSources& groups, const SMESH::ListOfIDSources& groups,
SMESH::SMESH_Mesh_out mesh, SMESH::SMESH_Mesh_out mesh,
SMESH::SMESH_Group_out group) SMESH::SMESH_Group_out group);
;
/*! /*!
* \brief Create a polyline consisting of 1D mesh elements each lying on a 2D element of * \brief Create a polyline consisting of 1D mesh elements each lying on a 2D element of
@ -938,8 +819,7 @@ public:
* be added. * be added.
*/ */
void MakePolyLine(SMESH::ListOfPolySegments& segments, void MakePolyLine(SMESH::ListOfPolySegments& segments,
const char* groupName) const char* groupName);
;
/*! /*!
* \brief Create a slot of given width around given 1D elements lying on a triangle mesh. * \brief Create a slot of given width around given 1D elements lying on a triangle mesh.
@ -948,8 +828,7 @@ public:
* \return Edges located at the slot boundary * \return Edges located at the slot boundary
*/ */
SMESH::ListOfEdges* MakeSlot(SMESH::SMESH_GroupBase_ptr segments, SMESH::ListOfEdges* MakeSlot(SMESH::SMESH_GroupBase_ptr segments,
CORBA::Double width) CORBA::Double width);
;
private: //!< private methods private: //!< private methods
@ -970,42 +849,36 @@ public:
/*! /*!
* \brief Return groups by their IDs * \brief Return groups by their IDs
*/ */
SMESH::ListOfGroups* getGroups(const std::list<int>* groupIDs) SMESH::ListOfGroups* getGroups(const std::list<int>* groupIDs);
;
SMESH::ListOfGroups* mirror(TIDSortedElemSet & IDsOfElements, SMESH::ListOfGroups* mirror(TIDSortedElemSet & IDsOfElements,
const SMESH::AxisStruct & Axis, const SMESH::AxisStruct & Axis,
SMESH::SMESH_MeshEditor::MirrorType MirrorType, SMESH::SMESH_MeshEditor::MirrorType MirrorType,
CORBA::Boolean Copy, CORBA::Boolean Copy,
bool MakeGroups, bool MakeGroups,
::SMESH_Mesh* TargetMesh=0) ::SMESH_Mesh* TargetMesh=0);
;
SMESH::ListOfGroups* translate(TIDSortedElemSet & IDsOfElements, SMESH::ListOfGroups* translate(TIDSortedElemSet & IDsOfElements,
const SMESH::DirStruct & Vector, const SMESH::DirStruct & Vector,
CORBA::Boolean Copy, CORBA::Boolean Copy,
bool MakeGroups, bool MakeGroups,
::SMESH_Mesh* TargetMesh=0) ::SMESH_Mesh* TargetMesh=0);
;
SMESH::ListOfGroups* rotate(TIDSortedElemSet & IDsOfElements, SMESH::ListOfGroups* rotate(TIDSortedElemSet & IDsOfElements,
const SMESH::AxisStruct & Axis, const SMESH::AxisStruct & Axis,
CORBA::Double Angle, CORBA::Double Angle,
CORBA::Boolean Copy, CORBA::Boolean Copy,
bool MakeGroups, bool MakeGroups,
::SMESH_Mesh* TargetMesh=0) ::SMESH_Mesh* TargetMesh=0);
;
SMESH::ListOfGroups* scale(SMESH::SMESH_IDSource_ptr theObject, SMESH::ListOfGroups* scale(SMESH::SMESH_IDSource_ptr theObject,
const SMESH::PointStruct& thePoint, const SMESH::PointStruct& thePoint,
const SMESH::double_array& theScaleFact, const SMESH::double_array& theScaleFact,
CORBA::Boolean theCopy, CORBA::Boolean theCopy,
bool theMakeGroups, bool theMakeGroups,
::SMESH_Mesh* theTargetMesh=0) ::SMESH_Mesh* theTargetMesh=0);
;
void convertToQuadratic(CORBA::Boolean theForce3d, void convertToQuadratic(CORBA::Boolean theForce3d,
CORBA::Boolean theToBiQuad, CORBA::Boolean theToBiQuad,
SMESH::SMESH_IDSource_ptr theObject = SMESH::SMESH_IDSource::_nil()) SMESH::SMESH_IDSource_ptr theObject = SMESH::SMESH_IDSource::_nil());
;
SMESH::SMESH_Mesh_ptr makeMesh(const char* theMeshName); SMESH::SMESH_Mesh_ptr makeMesh(const char* theMeshName);

61
src/SMESH_I/SMESH_Mesh_i.cxx
View File

@ -183,7 +183,6 @@ SMESH_Mesh_i::~SMESH_Mesh_i()
//============================================================================= //=============================================================================
void SMESH_Mesh_i::SetShape( GEOM::GEOM_Object_ptr theShapeObject ) void SMESH_Mesh_i::SetShape( GEOM::GEOM_Object_ptr theShapeObject )
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
try { try {
@ -206,7 +205,6 @@ void SMESH_Mesh_i::SetShape( GEOM::GEOM_Object_ptr theShapeObject )
//================================================================================ //================================================================================
CORBA::Boolean SMESH_Mesh_i::HasShapeToMesh() CORBA::Boolean SMESH_Mesh_i::HasShapeToMesh()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
bool res = false; bool res = false;
@ -226,7 +224,6 @@ CORBA::Boolean SMESH_Mesh_i::HasShapeToMesh()
//================================================================================ //================================================================================
GEOM::GEOM_Object_ptr SMESH_Mesh_i::GetShapeToMesh() GEOM::GEOM_Object_ptr SMESH_Mesh_i::GetShapeToMesh()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
GEOM::GEOM_Object_var aShapeObj; GEOM::GEOM_Object_var aShapeObj;
@ -315,7 +312,6 @@ void SMESH_Mesh_i::Clear()
//================================================================================ //================================================================================
void SMESH_Mesh_i::ClearSubMesh(CORBA::Long ShapeID) void SMESH_Mesh_i::ClearSubMesh(CORBA::Long ShapeID)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -432,7 +428,6 @@ SMESH_Mesh_i::ImportMEDFile( const char* theFileName, const char* theMeshName )
SMESH::DriverMED_ReadStatus SMESH_Mesh_i::ImportCGNSFile( const char* theFileName, SMESH::DriverMED_ReadStatus SMESH_Mesh_i::ImportCGNSFile( const char* theFileName,
const int theMeshIndex, const int theMeshIndex,
std::string& theMeshName ) std::string& theMeshName )
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
int status; int status;
@ -498,7 +493,6 @@ SMESH::long_array* SMESH_Mesh_i::GetMEDVersionsCompatibleForAppend()
//============================================================================= //=============================================================================
int SMESH_Mesh_i::ImportUNVFile( const char* theFileName ) int SMESH_Mesh_i::ImportUNVFile( const char* theFileName )
{ {
SMESH_TRY; SMESH_TRY;
@ -528,7 +522,6 @@ int SMESH_Mesh_i::ImportUNVFile( const char* theFileName )
//============================================================================= //=============================================================================
int SMESH_Mesh_i::ImportSTLFile( const char* theFileName ) int SMESH_Mesh_i::ImportSTLFile( const char* theFileName )
{ {
SMESH_TRY; SMESH_TRY;
@ -573,7 +566,6 @@ namespace
SMESH::ComputeError* SMESH_Mesh_i::ImportGMFFile( const char* theFileName, SMESH::ComputeError* SMESH_Mesh_i::ImportGMFFile( const char* theFileName,
bool theMakeRequiredGroups ) bool theMakeRequiredGroups )
{ {
SMESH_ComputeErrorPtr error; SMESH_ComputeErrorPtr error;
@ -645,7 +637,6 @@ SMESH::Hypothesis_Status
SMESH_Mesh_i::AddHypothesis(GEOM::GEOM_Object_ptr aSubShape, SMESH_Mesh_i::AddHypothesis(GEOM::GEOM_Object_ptr aSubShape,
SMESH::SMESH_Hypothesis_ptr anHyp, SMESH::SMESH_Hypothesis_ptr anHyp,
CORBA::String_out anErrorText) CORBA::String_out anErrorText)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -738,7 +729,6 @@ SMESH_Mesh_i::addHypothesis(GEOM::GEOM_Object_ptr aSubShape,
SMESH::Hypothesis_Status SMESH_Mesh_i::RemoveHypothesis(GEOM::GEOM_Object_ptr aSubShape, SMESH::Hypothesis_Status SMESH_Mesh_i::RemoveHypothesis(GEOM::GEOM_Object_ptr aSubShape,
SMESH::SMESH_Hypothesis_ptr anHyp) SMESH::SMESH_Hypothesis_ptr anHyp)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -817,7 +807,6 @@ SMESH_Mesh_i::removeHypothesis(GEOM::GEOM_Object_ptr aSubShape,
SMESH::ListOfHypothesis * SMESH::ListOfHypothesis *
SMESH_Mesh_i::GetHypothesisList(GEOM::GEOM_Object_ptr aSubShape) SMESH_Mesh_i::GetHypothesisList(GEOM::GEOM_Object_ptr aSubShape)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if (MYDEBUG) MESSAGE("GetHypothesisList"); if (MYDEBUG) MESSAGE("GetHypothesisList");
@ -901,7 +890,6 @@ SMESH::submesh_array* SMESH_Mesh_i::GetSubMeshes()
SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetSubMesh(GEOM::GEOM_Object_ptr aSubShape, SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetSubMesh(GEOM::GEOM_Object_ptr aSubShape,
const char* theName ) const char* theName )
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if (CORBA::is_nil(aSubShape)) if (CORBA::is_nil(aSubShape))
@ -953,7 +941,6 @@ SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetSubMesh(GEOM::GEOM_Object_ptr aSubShap
//================================================================================ //================================================================================
void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh ) void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh )
{ {
SMESH_TRY; SMESH_TRY;
@ -997,7 +984,6 @@ void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh )
SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateGroup( SMESH::ElementType theElemType, SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateGroup( SMESH::ElementType theElemType,
const char* theName ) const char* theName )
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -1029,7 +1015,6 @@ SMESH::SMESH_GroupOnGeom_ptr
SMESH_Mesh_i::CreateGroupFromGEOM (SMESH::ElementType theElemType, SMESH_Mesh_i::CreateGroupFromGEOM (SMESH::ElementType theElemType,
const char* theName, const char* theName,
GEOM::GEOM_Object_ptr theGeomObj) GEOM::GEOM_Object_ptr theGeomObj)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -1071,7 +1056,6 @@ SMESH::SMESH_GroupOnFilter_ptr
SMESH_Mesh_i::CreateGroupFromFilter(SMESH::ElementType theElemType, SMESH_Mesh_i::CreateGroupFromFilter(SMESH::ElementType theElemType,
const char* theName, const char* theName,
SMESH::Filter_ptr theFilter ) SMESH::Filter_ptr theFilter )
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -1111,7 +1095,6 @@ SMESH_Mesh_i::CreateGroupFromFilter(SMESH::ElementType theElemType,
//================================================================================ //================================================================================
void SMESH_Mesh_i::RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup ) void SMESH_Mesh_i::RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup )
{ {
if ( theGroup->_is_nil() ) if ( theGroup->_is_nil() )
return; return;
@ -1151,7 +1134,6 @@ void SMESH_Mesh_i::RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup )
//============================================================================= //=============================================================================
void SMESH_Mesh_i::RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup ) void SMESH_Mesh_i::RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup )
{ {
SMESH_TRY; SMESH_TRY;
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -1279,7 +1261,6 @@ CORBA::Long SMESH_Mesh_i::NbGroups()
SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionGroups( SMESH::SMESH_GroupBase_ptr theGroup1, SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2, SMESH::SMESH_GroupBase_ptr theGroup2,
const char* theName ) const char* theName )
{ {
SMESH::SMESH_Group_var aResGrp; SMESH::SMESH_Group_var aResGrp;
@ -1323,7 +1304,6 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionGroups( SMESH::SMESH_GroupBase_ptr the
SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionListOfGroups(const SMESH::ListOfGroups& theGroups, SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionListOfGroups(const SMESH::ListOfGroups& theGroups,
const char* theName ) const char* theName )
{ {
SMESH::SMESH_Group_var aResGrp; SMESH::SMESH_Group_var aResGrp;
@ -1386,7 +1366,6 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionListOfGroups(const SMESH::ListOfGroups
SMESH::SMESH_Group_ptr SMESH_Mesh_i::IntersectGroups( SMESH::SMESH_GroupBase_ptr theGroup1, SMESH::SMESH_Group_ptr SMESH_Mesh_i::IntersectGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2, SMESH::SMESH_GroupBase_ptr theGroup2,
const char* theName ) const char* theName )
{ {
SMESH::SMESH_Group_var aResGrp; SMESH::SMESH_Group_var aResGrp;
@ -1452,7 +1431,6 @@ SMESH::SMESH_Group_ptr SMESH_Mesh_i::IntersectGroups( SMESH::SMESH_GroupBase_ptr
SMESH::SMESH_Group_ptr SMESH::SMESH_Group_ptr
SMESH_Mesh_i::IntersectListOfGroups(const SMESH::ListOfGroups& theGroups, SMESH_Mesh_i::IntersectListOfGroups(const SMESH::ListOfGroups& theGroups,
const char* theName ) const char* theName )
{ {
SMESH::SMESH_Group_var aResGrp; SMESH::SMESH_Group_var aResGrp;
@ -1536,7 +1514,6 @@ SMESH_Mesh_i::IntersectListOfGroups(const SMESH::ListOfGroups& theGroups,
SMESH::SMESH_Group_ptr SMESH_Mesh_i::CutGroups( SMESH::SMESH_GroupBase_ptr theGroup1, SMESH::SMESH_Group_ptr SMESH_Mesh_i::CutGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2, SMESH::SMESH_GroupBase_ptr theGroup2,
const char* theName ) const char* theName )
{ {
SMESH::SMESH_Group_var aResGrp; SMESH::SMESH_Group_var aResGrp;
@ -1603,7 +1580,6 @@ SMESH::SMESH_Group_ptr
SMESH_Mesh_i::CutListOfGroups(const SMESH::ListOfGroups& theMainGroups, SMESH_Mesh_i::CutListOfGroups(const SMESH::ListOfGroups& theMainGroups,
const SMESH::ListOfGroups& theToolGroups, const SMESH::ListOfGroups& theToolGroups,
const char* theName ) const char* theName )
{ {
SMESH::SMESH_Group_var aResGrp; SMESH::SMESH_Group_var aResGrp;
@ -1736,7 +1712,6 @@ SMESH_Mesh_i::CreateDimGroup(const SMESH::ListOfIDSources& theGroups,
const char* theName, const char* theName,
SMESH::NB_COMMON_NODES_ENUM theNbCommonNodes, SMESH::NB_COMMON_NODES_ENUM theNbCommonNodes,
CORBA::Boolean theUnderlyingOnly) CORBA::Boolean theUnderlyingOnly)
{ {
SMESH::SMESH_Group_var aResGrp; SMESH::SMESH_Group_var aResGrp;
@ -1917,7 +1892,6 @@ SMESH::ListOfGroups*
SMESH_Mesh_i::FaceGroupsSeparatedByEdges( CORBA::Double theSharpAngle, SMESH_Mesh_i::FaceGroupsSeparatedByEdges( CORBA::Double theSharpAngle,
CORBA::Boolean theCreateEdges, CORBA::Boolean theCreateEdges,
CORBA::Boolean theUseExistingEdges ) CORBA::Boolean theUseExistingEdges )
{ {
if ( theSharpAngle < 0 || theSharpAngle > 180 ) if ( theSharpAngle < 0 || theSharpAngle > 180 )
THROW_SALOME_CORBA_EXCEPTION("Invalid sharp angle, it must be between 0 and 180 degrees", THROW_SALOME_CORBA_EXCEPTION("Invalid sharp angle, it must be between 0 and 180 degrees",
@ -2045,7 +2019,6 @@ void SMESH_Mesh_i::removeGeomGroupData(CORBA::Object_ptr theSmeshObj)
//================================================================================ //================================================================================
void SMESH_Mesh_i::ReplaceShape(GEOM::GEOM_Object_ptr theNewGeom) void SMESH_Mesh_i::ReplaceShape(GEOM::GEOM_Object_ptr theNewGeom)
{ {
// check if geometry changed // check if geometry changed
bool geomChanged = true; bool geomChanged = true;
@ -3040,7 +3013,6 @@ void SMESH_Mesh_i::CheckGeomGroupModif()
//============================================================================= //=============================================================================
SMESH::SMESH_Group_ptr SMESH_Mesh_i::ConvertToStandalone( SMESH::SMESH_GroupBase_ptr theGroup ) SMESH::SMESH_Group_ptr SMESH_Mesh_i::ConvertToStandalone( SMESH::SMESH_GroupBase_ptr theGroup )
{ {
SMESH::SMESH_Group_var aGroup; SMESH::SMESH_Group_var aGroup;
@ -3342,7 +3314,6 @@ void SMESH_Mesh_i::removeGroup( const int theId )
//================================================================================ //================================================================================
SMESH::log_array * SMESH_Mesh_i::GetLog(CORBA::Boolean clearAfterGet) SMESH::log_array * SMESH_Mesh_i::GetLog(CORBA::Boolean clearAfterGet)
{ {
SMESH::log_array_var aLog; SMESH::log_array_var aLog;
@ -3509,7 +3480,6 @@ void SMESH_Mesh_i::SetImpl(::SMESH_Mesh * impl)
//============================================================================= //=============================================================================
SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditor() SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditor()
{ {
SMESH::SMESH_MeshEditor_var aMeshEdVar; SMESH::SMESH_MeshEditor_var aMeshEdVar;
@ -3538,7 +3508,6 @@ SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditor()
//============================================================================= //=============================================================================
SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditPreviewer() SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditPreviewer()
{ {
SMESH::SMESH_MeshEditor_var aMeshEdVar; SMESH::SMESH_MeshEditor_var aMeshEdVar;
@ -3751,7 +3720,6 @@ void SMESH_Mesh_i::ExportMED(const char* file,
CORBA::Long version, CORBA::Long version,
CORBA::Boolean overwrite, CORBA::Boolean overwrite,
CORBA::Boolean autoDimension) CORBA::Boolean autoDimension)
{ {
//MESSAGE("MED minor version: "<< minor); //MESSAGE("MED minor version: "<< minor);
SMESH_TRY; SMESH_TRY;
@ -3780,7 +3748,6 @@ void SMESH_Mesh_i::ExportMED(const char* file,
void SMESH_Mesh_i::ExportSAUV (const char* file, void SMESH_Mesh_i::ExportSAUV (const char* file,
CORBA::Boolean auto_groups) CORBA::Boolean auto_groups)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -3800,7 +3767,6 @@ void SMESH_Mesh_i::ExportSAUV (const char* file,
//================================================================================ //================================================================================
void SMESH_Mesh_i::ExportDAT (const char *file) void SMESH_Mesh_i::ExportDAT (const char *file)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -3823,7 +3789,6 @@ void SMESH_Mesh_i::ExportDAT (const char *file)
//================================================================================ //================================================================================
void SMESH_Mesh_i::ExportUNV (const char *file) void SMESH_Mesh_i::ExportUNV (const char *file)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -3846,7 +3811,6 @@ void SMESH_Mesh_i::ExportUNV (const char *file)
//================================================================================ //================================================================================
void SMESH_Mesh_i::ExportSTL (const char *file, const bool isascii) void SMESH_Mesh_i::ExportSTL (const char *file, const bool isascii)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -3883,7 +3847,6 @@ void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
const GEOM::ListOfFields& fields, const GEOM::ListOfFields& fields,
const char* geomAssocFields, const char* geomAssocFields,
CORBA::Double ZTolerance) CORBA::Double ZTolerance)
{ {
MESSAGE("MED version: "<< version); MESSAGE("MED version: "<< version);
SMESH_TRY; SMESH_TRY;
@ -4268,7 +4231,6 @@ void SMESH_Mesh_i::exportMEDFields( DriverMED_W_Field& fieldWriter,
void SMESH_Mesh_i::ExportPartToDAT(::SMESH::SMESH_IDSource_ptr meshPart, void SMESH_Mesh_i::ExportPartToDAT(::SMESH::SMESH_IDSource_ptr meshPart,
const char* file) const char* file)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4290,7 +4252,6 @@ void SMESH_Mesh_i::ExportPartToDAT(::SMESH::SMESH_IDSource_ptr meshPart,
void SMESH_Mesh_i::ExportPartToUNV(::SMESH::SMESH_IDSource_ptr meshPart, void SMESH_Mesh_i::ExportPartToUNV(::SMESH::SMESH_IDSource_ptr meshPart,
const char* file) const char* file)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4313,7 +4274,6 @@ void SMESH_Mesh_i::ExportPartToUNV(::SMESH::SMESH_IDSource_ptr meshPart,
void SMESH_Mesh_i::ExportPartToSTL(::SMESH::SMESH_IDSource_ptr meshPart, void SMESH_Mesh_i::ExportPartToSTL(::SMESH::SMESH_IDSource_ptr meshPart,
const char* file, const char* file,
::CORBA::Boolean isascii) ::CORBA::Boolean isascii)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4343,7 +4303,6 @@ void SMESH_Mesh_i::ExportCGNS(::SMESH::SMESH_IDSource_ptr meshPart,
const char* file, const char* file,
CORBA::Boolean overwrite, CORBA::Boolean overwrite,
CORBA::Boolean groupElemsByType) CORBA::Boolean groupElemsByType)
{ {
#ifdef WITH_CGNS #ifdef WITH_CGNS
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
@ -4382,7 +4341,6 @@ void SMESH_Mesh_i::ExportCGNS(::SMESH::SMESH_IDSource_ptr meshPart,
void SMESH_Mesh_i::ExportGMF(::SMESH::SMESH_IDSource_ptr meshPart, void SMESH_Mesh_i::ExportGMF(::SMESH::SMESH_IDSource_ptr meshPart,
const char* file, const char* file,
bool withRequiredGroups) bool withRequiredGroups)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4497,7 +4455,6 @@ CORBA::Long SMESH_Mesh_i::NbEdges()
//================================================================================ //================================================================================
CORBA::Long SMESH_Mesh_i::NbEdgesOfOrder(SMESH::ElementOrder order) CORBA::Long SMESH_Mesh_i::NbEdgesOfOrder(SMESH::ElementOrder order)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4588,7 +4545,6 @@ CORBA::Long SMESH_Mesh_i::NbPolygonsOfOrder(SMESH::ElementOrder order)
} }
CORBA::Long SMESH_Mesh_i::NbFacesOfOrder(SMESH::ElementOrder order) CORBA::Long SMESH_Mesh_i::NbFacesOfOrder(SMESH::ElementOrder order)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4598,7 +4554,6 @@ CORBA::Long SMESH_Mesh_i::NbFacesOfOrder(SMESH::ElementOrder order)
} }
CORBA::Long SMESH_Mesh_i::NbTrianglesOfOrder(SMESH::ElementOrder order) CORBA::Long SMESH_Mesh_i::NbTrianglesOfOrder(SMESH::ElementOrder order)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4608,7 +4563,6 @@ CORBA::Long SMESH_Mesh_i::NbTrianglesOfOrder(SMESH::ElementOrder order)
} }
CORBA::Long SMESH_Mesh_i::NbQuadranglesOfOrder(SMESH::ElementOrder order) CORBA::Long SMESH_Mesh_i::NbQuadranglesOfOrder(SMESH::ElementOrder order)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4692,7 +4646,6 @@ CORBA::Long SMESH_Mesh_i::NbPolyhedrons()
} }
CORBA::Long SMESH_Mesh_i::NbVolumesOfOrder(SMESH::ElementOrder order) CORBA::Long SMESH_Mesh_i::NbVolumesOfOrder(SMESH::ElementOrder order)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4702,7 +4655,6 @@ CORBA::Long SMESH_Mesh_i::NbVolumesOfOrder(SMESH::ElementOrder order)
} }
CORBA::Long SMESH_Mesh_i::NbTetrasOfOrder(SMESH::ElementOrder order) CORBA::Long SMESH_Mesh_i::NbTetrasOfOrder(SMESH::ElementOrder order)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4712,7 +4664,6 @@ CORBA::Long SMESH_Mesh_i::NbTetrasOfOrder(SMESH::ElementOrder order)
} }
CORBA::Long SMESH_Mesh_i::NbHexasOfOrder(SMESH::ElementOrder order) CORBA::Long SMESH_Mesh_i::NbHexasOfOrder(SMESH::ElementOrder order)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4722,7 +4673,6 @@ CORBA::Long SMESH_Mesh_i::NbHexasOfOrder(SMESH::ElementOrder order)
} }
CORBA::Long SMESH_Mesh_i::NbPyramidsOfOrder(SMESH::ElementOrder order) CORBA::Long SMESH_Mesh_i::NbPyramidsOfOrder(SMESH::ElementOrder order)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4732,7 +4682,6 @@ CORBA::Long SMESH_Mesh_i::NbPyramidsOfOrder(SMESH::ElementOrder order)
} }
CORBA::Long SMESH_Mesh_i::NbPrismsOfOrder(SMESH::ElementOrder order) CORBA::Long SMESH_Mesh_i::NbPrismsOfOrder(SMESH::ElementOrder order)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4784,7 +4733,6 @@ SMESH::long_array* SMESH_Mesh_i::GetIDs()
//============================================================================= //=============================================================================
SMESH::long_array* SMESH_Mesh_i::GetElementsId() SMESH::long_array* SMESH_Mesh_i::GetElementsId()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4813,7 +4761,6 @@ SMESH::long_array* SMESH_Mesh_i::GetElementsId()
//============================================================================= //=============================================================================
SMESH::long_array* SMESH_Mesh_i::GetElementsByType( SMESH::ElementType theElemType ) SMESH::long_array* SMESH_Mesh_i::GetElementsByType( SMESH::ElementType theElemType )
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4853,7 +4800,6 @@ SMESH::long_array* SMESH_Mesh_i::GetElementsByType( SMESH::ElementType theElemTy
//============================================================================= //=============================================================================
SMESH::long_array* SMESH_Mesh_i::GetNodesId() SMESH::long_array* SMESH_Mesh_i::GetNodesId()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4881,7 +4827,6 @@ SMESH::long_array* SMESH_Mesh_i::GetNodesId()
//============================================================================= //=============================================================================
SMESH::ElementType SMESH_Mesh_i::GetElementType( const CORBA::Long id, const bool iselem ) SMESH::ElementType SMESH_Mesh_i::GetElementType( const CORBA::Long id, const bool iselem )
{ {
SMESH::ElementType type = SMESH::ALL; SMESH::ElementType type = SMESH::ALL;
SMESH_TRY; SMESH_TRY;
@ -4903,7 +4848,6 @@ SMESH::ElementType SMESH_Mesh_i::GetElementType( const CORBA::Long id, const boo
//============================================================================= //=============================================================================
SMESH::EntityType SMESH_Mesh_i::GetElementGeomType( const CORBA::Long id ) SMESH::EntityType SMESH_Mesh_i::GetElementGeomType( const CORBA::Long id )
{ {
if ( _preMeshInfo ) if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile(); _preMeshInfo->FullLoadFromFile();
@ -4922,7 +4866,6 @@ SMESH::EntityType SMESH_Mesh_i::GetElementGeomType( const CORBA::Long id )
//============================================================================= //=============================================================================
SMESH::GeometryType SMESH_Mesh_i::GetElementShape( const CORBA::Long id ) SMESH::GeometryType SMESH_Mesh_i::GetElementShape( const CORBA::Long id )
{ {
if ( _preMeshInfo ) if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile(); _preMeshInfo->FullLoadFromFile();
@ -4941,7 +4884,6 @@ SMESH::GeometryType SMESH_Mesh_i::GetElementShape( const CORBA::Long id )
//============================================================================= //=============================================================================
SMESH::long_array* SMESH_Mesh_i::GetSubMeshElementsId(const CORBA::Long ShapeID) SMESH::long_array* SMESH_Mesh_i::GetSubMeshElementsId(const CORBA::Long ShapeID)
{ {
SMESH::long_array_var aResult = new SMESH::long_array(); SMESH::long_array_var aResult = new SMESH::long_array();
@ -4978,7 +4920,6 @@ SMESH::long_array* SMESH_Mesh_i::GetSubMeshElementsId(const CORBA::Long ShapeID)
SMESH::long_array* SMESH_Mesh_i::GetSubMeshNodesId(const CORBA::Long ShapeID, SMESH::long_array* SMESH_Mesh_i::GetSubMeshNodesId(const CORBA::Long ShapeID,
CORBA::Boolean all) CORBA::Boolean all)
{ {
SMESH::long_array_var aResult = new SMESH::long_array(); SMESH::long_array_var aResult = new SMESH::long_array();
@ -5030,7 +4971,6 @@ SMESH::long_array* SMESH_Mesh_i::GetSubMeshNodesId(const CORBA::Long ShapeID,
//============================================================================= //=============================================================================
SMESH::ElementType SMESH_Mesh_i::GetSubMeshElementType(const CORBA::Long ShapeID) SMESH::ElementType SMESH_Mesh_i::GetSubMeshElementType(const CORBA::Long ShapeID)
{ {
SMESH::ElementType type = SMESH::ALL; SMESH::ElementType type = SMESH::ALL;
@ -5690,7 +5630,6 @@ SMESH::double_array* SMESH_Mesh_i::BaryCenter(const CORBA::Long id)
SMESH::ListOfGroups* SMESH::ListOfGroups*
SMESH_Mesh_i::MakeGroupsOfBadInputElements( int theSubShapeID, SMESH_Mesh_i::MakeGroupsOfBadInputElements( int theSubShapeID,
const char* theGroupName ) const char* theGroupName )
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);

266
src/SMESH_I/SMESH_Mesh_i.hxx
View File

@ -65,131 +65,100 @@ public:
// --- CORBA // --- CORBA
void SetShape( GEOM::GEOM_Object_ptr theShapeObject ) void SetShape( GEOM::GEOM_Object_ptr theShapeObject );
;
CORBA::Boolean HasShapeToMesh() CORBA::Boolean HasShapeToMesh();
;
GEOM::GEOM_Object_ptr GetShapeToMesh() GEOM::GEOM_Object_ptr GetShapeToMesh();
;
virtual void ReplaceShape(GEOM::GEOM_Object_ptr theNewGeom) virtual void ReplaceShape(GEOM::GEOM_Object_ptr theNewGeom);
;
CORBA::Boolean IsLoaded() CORBA::Boolean IsLoaded();
;
void Load() void Load();
;
void Clear() void Clear();
;
void ClearSubMesh(CORBA::Long ShapeID) void ClearSubMesh(CORBA::Long ShapeID);
;
SMESH::Hypothesis_Status AddHypothesis(GEOM::GEOM_Object_ptr aSubShape, SMESH::Hypothesis_Status AddHypothesis(GEOM::GEOM_Object_ptr aSubShape,
SMESH::SMESH_Hypothesis_ptr anHyp, SMESH::SMESH_Hypothesis_ptr anHyp,
CORBA::String_out anErrorText) CORBA::String_out anErrorText);
;
SMESH::Hypothesis_Status RemoveHypothesis(GEOM::GEOM_Object_ptr aSubShape, SMESH::Hypothesis_Status RemoveHypothesis(GEOM::GEOM_Object_ptr aSubShape,
SMESH::SMESH_Hypothesis_ptr anHyp) SMESH::SMESH_Hypothesis_ptr anHyp);
;
SMESH::ListOfHypothesis* GetHypothesisList(GEOM::GEOM_Object_ptr aSubShape) SMESH::ListOfHypothesis* GetHypothesisList(GEOM::GEOM_Object_ptr aSubShape);
;
SMESH::submesh_array* GetSubMeshes() SMESH::submesh_array* GetSubMeshes();
;
SMESH::SMESH_subMesh_ptr GetSubMesh(GEOM::GEOM_Object_ptr aSubShape, const char* theName) SMESH::SMESH_subMesh_ptr GetSubMesh(GEOM::GEOM_Object_ptr aSubShape, const char* theName);
;
void RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh ) void RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh );
;
SMESH::SMESH_Group_ptr CreateGroup( SMESH::ElementType theElemType, const char* theName ) SMESH::SMESH_Group_ptr CreateGroup( SMESH::ElementType theElemType, const char* theName );
;
SMESH::SMESH_GroupOnGeom_ptr CreateGroupFromGEOM(SMESH::ElementType theElemType, SMESH::SMESH_GroupOnGeom_ptr CreateGroupFromGEOM(SMESH::ElementType theElemType,
const char* theName, const char* theName,
GEOM::GEOM_Object_ptr theGeomObj ) GEOM::GEOM_Object_ptr theGeomObj );
;
SMESH::SMESH_GroupOnFilter_ptr CreateGroupFromFilter(SMESH::ElementType theElemType, SMESH::SMESH_GroupOnFilter_ptr CreateGroupFromFilter(SMESH::ElementType theElemType,
const char* theName, const char* theName,
SMESH::Filter_ptr theFilter ) SMESH::Filter_ptr theFilter );
;
void RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup ) void RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup );
;
void RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup ) void RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup );
;
SMESH::ListOfGroups* GetGroups() SMESH::ListOfGroups* GetGroups();
;
CORBA::Long NbGroups() CORBA::Long NbGroups();
;
SMESH::SMESH_Group_ptr UnionGroups( SMESH::SMESH_GroupBase_ptr theGroup1, SMESH::SMESH_Group_ptr UnionGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2, SMESH::SMESH_GroupBase_ptr theGroup2,
const char* theName ) const char* theName );
;
SMESH::SMESH_Group_ptr UnionListOfGroups( const SMESH::ListOfGroups& theGroups, SMESH::SMESH_Group_ptr UnionListOfGroups( const SMESH::ListOfGroups& theGroups,
const char* theName) const char* theName);
;
SMESH::SMESH_Group_ptr IntersectGroups( SMESH::SMESH_GroupBase_ptr theGroup1, SMESH::SMESH_Group_ptr IntersectGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2, SMESH::SMESH_GroupBase_ptr theGroup2,
const char* theName ) const char* theName );
;
SMESH::SMESH_Group_ptr IntersectListOfGroups( const SMESH::ListOfGroups& theGroups, SMESH::SMESH_Group_ptr IntersectListOfGroups( const SMESH::ListOfGroups& theGroups,
const char* theName ) const char* theName );
;
SMESH::SMESH_Group_ptr CutGroups( SMESH::SMESH_GroupBase_ptr theGroup1, SMESH::SMESH_Group_ptr CutGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2, SMESH::SMESH_GroupBase_ptr theGroup2,
const char* theName ) const char* theName );
;
SMESH::SMESH_Group_ptr CutListOfGroups( const SMESH::ListOfGroups& theMainGroups, SMESH::SMESH_Group_ptr CutListOfGroups( const SMESH::ListOfGroups& theMainGroups,
const SMESH::ListOfGroups& theToolGroups, const SMESH::ListOfGroups& theToolGroups,
const char* theName ) const char* theName );
;
SMESH::SMESH_Group_ptr CreateDimGroup( const SMESH::ListOfIDSources& theGroups, SMESH::SMESH_Group_ptr CreateDimGroup( const SMESH::ListOfIDSources& theGroups,
SMESH::ElementType theElemType, SMESH::ElementType theElemType,
const char* theName, const char* theName,
SMESH::NB_COMMON_NODES_ENUM theNbCommonNodes, SMESH::NB_COMMON_NODES_ENUM theNbCommonNodes,
CORBA::Boolean theUnderlyingOnly ) CORBA::Boolean theUnderlyingOnly );
;
SMESH::ListOfGroups* FaceGroupsSeparatedByEdges( CORBA::Double theSharpAngle, SMESH::ListOfGroups* FaceGroupsSeparatedByEdges( CORBA::Double theSharpAngle,
CORBA::Boolean theCreateEdges, CORBA::Boolean theCreateEdges,
CORBA::Boolean theUseExistingEdges ) CORBA::Boolean theUseExistingEdges );
;
SMESH::SMESH_Group_ptr ConvertToStandalone( SMESH::SMESH_GroupBase_ptr theGroupOn ) SMESH::SMESH_Group_ptr ConvertToStandalone( SMESH::SMESH_GroupBase_ptr theGroupOn );
;
SMESH::log_array* GetLog(CORBA::Boolean clearAfterGet) SMESH::log_array* GetLog(CORBA::Boolean clearAfterGet);
;
SMESH::SMESH_MeshEditor_ptr GetMeshEditor() ; SMESH::SMESH_MeshEditor_ptr GetMeshEditor();
SMESH::SMESH_MeshEditor_ptr GetMeshEditPreviewer() ; SMESH::SMESH_MeshEditor_ptr GetMeshEditPreviewer();
CORBA::Boolean HasModificationsToDiscard() ; CORBA::Boolean HasModificationsToDiscard();
void ClearLog() ; void ClearLog();
CORBA::Long GetId() ; CORBA::Long GetId();
// --- C++ interface // --- C++ interface
@ -198,35 +167,28 @@ public:
SMESH_Gen_i* GetGen() { return _gen_i; } SMESH_Gen_i* GetGen() { return _gen_i; }
int ImportUNVFile( const char* theFileName ) int ImportUNVFile( const char* theFileName );
;
int ImportSTLFile( const char* theFileName ) int ImportSTLFile( const char* theFileName );
;
SMESH::ComputeError* ImportGMFFile( const char* theFileName, SMESH::ComputeError* ImportGMFFile( const char* theFileName,
bool theMakeRequiredGroups) bool theMakeRequiredGroups);
;
/*! /*!
* consult DriverMED_R_SMESHDS_Mesh::ReadStatus for returned value * consult DriverMED_R_SMESHDS_Mesh::ReadStatus for returned value
*/ */
SMESH::DriverMED_ReadStatus ImportMEDFile( const char* theFileName, const char* theMeshName ) SMESH::DriverMED_ReadStatus ImportMEDFile( const char* theFileName, const char* theMeshName );
;
SMESH::DriverMED_ReadStatus ImportCGNSFile( const char* theFileName, SMESH::DriverMED_ReadStatus ImportCGNSFile( const char* theFileName,
const int theMeshIndex, const int theMeshIndex,
std::string& theMeshName) std::string& theMeshName);
;
/*! /*!
* Auto color * Auto color
*/ */
void SetAutoColor(CORBA::Boolean theAutoColor) void SetAutoColor(CORBA::Boolean theAutoColor);
;
CORBA::Boolean GetAutoColor() CORBA::Boolean GetAutoColor();
;
/*! Check group names for duplications. /*! Check group names for duplications.
* Consider maximum group name length stored in MED file. * Consider maximum group name length stored in MED file.
@ -248,20 +210,20 @@ public:
CORBA::Boolean auto_groups, CORBA::Boolean auto_groups,
CORBA::Long version, CORBA::Long version,
CORBA::Boolean overwrite, CORBA::Boolean overwrite,
CORBA::Boolean autoDimension = true) ; CORBA::Boolean autoDimension = true);
void ExportSAUV( const char* file, CORBA::Boolean auto_groups ) ; void ExportSAUV( const char* file, CORBA::Boolean auto_groups );
void ExportDAT( const char* file ) ; void ExportDAT( const char* file );
void ExportUNV( const char* file ) ; void ExportUNV( const char* file );
void ExportSTL( const char* file, bool isascii ) ; void ExportSTL( const char* file, bool isascii );
void ExportCGNS(SMESH::SMESH_IDSource_ptr meshPart, void ExportCGNS(SMESH::SMESH_IDSource_ptr meshPart,
const char* file, const char* file,
CORBA::Boolean overwrite, CORBA::Boolean overwrite,
CORBA::Boolean groupElemsByType) ; CORBA::Boolean groupElemsByType);
void ExportGMF(SMESH::SMESH_IDSource_ptr meshPart, void ExportGMF(SMESH::SMESH_IDSource_ptr meshPart,
const char* file, const char* file,
CORBA::Boolean withRequiredGroups) ; CORBA::Boolean withRequiredGroups);
void ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart, void ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
const char* file, const char* file,
@ -271,151 +233,111 @@ public:
CORBA::Boolean autoDim, CORBA::Boolean autoDim,
const GEOM::ListOfFields& fields, const GEOM::ListOfFields& fields,
const char* geomAssocFields, const char* geomAssocFields,
CORBA::Double ZTolerance) ; CORBA::Double ZTolerance);
void ExportPartToDAT(SMESH::SMESH_IDSource_ptr meshPart, void ExportPartToDAT(SMESH::SMESH_IDSource_ptr meshPart,
const char* file) ; const char* file);
void ExportPartToUNV(SMESH::SMESH_IDSource_ptr meshPart, void ExportPartToUNV(SMESH::SMESH_IDSource_ptr meshPart,
const char* file) ; const char* file);
void ExportPartToSTL(SMESH::SMESH_IDSource_ptr meshPart, void ExportPartToSTL(SMESH::SMESH_IDSource_ptr meshPart,
const char* file, const char* file,
CORBA::Boolean isascii) ; CORBA::Boolean isascii);
CORBA::Double GetComputeProgress(); CORBA::Double GetComputeProgress();
CORBA::Long NbNodes() CORBA::Long NbNodes();
;
CORBA::Long NbElements() CORBA::Long NbElements();
;
CORBA::Long Nb0DElements() CORBA::Long Nb0DElements();
;
CORBA::Long NbBalls() CORBA::Long NbBalls();
;
CORBA::Long NbEdges() CORBA::Long NbEdges();
;
CORBA::Long NbEdgesOfOrder(SMESH::ElementOrder order) CORBA::Long NbEdgesOfOrder(SMESH::ElementOrder order);
;
CORBA::Long NbFaces() CORBA::Long NbFaces();
;
CORBA::Long NbFacesOfOrder(SMESH::ElementOrder order) CORBA::Long NbFacesOfOrder(SMESH::ElementOrder order);
;
CORBA::Long NbTriangles() CORBA::Long NbTriangles();
;
CORBA::Long NbTrianglesOfOrder(SMESH::ElementOrder order) CORBA::Long NbTrianglesOfOrder(SMESH::ElementOrder order);
;
CORBA::Long NbBiQuadTriangles() CORBA::Long NbBiQuadTriangles();
;
CORBA::Long NbQuadrangles() CORBA::Long NbQuadrangles();
;
CORBA::Long NbQuadranglesOfOrder(SMESH::ElementOrder order) CORBA::Long NbQuadranglesOfOrder(SMESH::ElementOrder order);
;
CORBA::Long NbBiQuadQuadrangles() CORBA::Long NbBiQuadQuadrangles();
;
CORBA::Long NbPolygons() CORBA::Long NbPolygons();
;
CORBA::Long NbPolygonsOfOrder(SMESH::ElementOrder order = SMESH::ORDER_ANY) CORBA::Long NbPolygonsOfOrder(SMESH::ElementOrder order = SMESH::ORDER_ANY);
;
CORBA::Long NbVolumes() CORBA::Long NbVolumes();
;
CORBA::Long NbVolumesOfOrder(SMESH::ElementOrder order) CORBA::Long NbVolumesOfOrder(SMESH::ElementOrder order);
;
CORBA::Long NbTetras() CORBA::Long NbTetras();
;
CORBA::Long NbTetrasOfOrder(SMESH::ElementOrder order) CORBA::Long NbTetrasOfOrder(SMESH::ElementOrder order);
;
CORBA::Long NbHexas() CORBA::Long NbHexas();
;
CORBA::Long NbHexasOfOrder(SMESH::ElementOrder order) CORBA::Long NbHexasOfOrder(SMESH::ElementOrder order);
;
CORBA::Long NbTriQuadraticHexas() CORBA::Long NbTriQuadraticHexas();
;
CORBA::Long NbPyramids() CORBA::Long NbPyramids();
;
CORBA::Long NbPyramidsOfOrder(SMESH::ElementOrder order) CORBA::Long NbPyramidsOfOrder(SMESH::ElementOrder order);
;
CORBA::Long NbPrisms() CORBA::Long NbPrisms();
;
CORBA::Long NbPrismsOfOrder(SMESH::ElementOrder order) CORBA::Long NbPrismsOfOrder(SMESH::ElementOrder order);
;
CORBA::Long NbHexagonalPrisms() CORBA::Long NbHexagonalPrisms();
;
CORBA::Long NbPolyhedrons() CORBA::Long NbPolyhedrons();
;
CORBA::Long NbSubMesh() CORBA::Long NbSubMesh();
;
SMESH::long_array* GetElementsId() SMESH::long_array* GetElementsId();
;
SMESH::long_array* GetElementsByType( SMESH::ElementType theElemType ) SMESH::long_array* GetElementsByType( SMESH::ElementType theElemType );
;
SMESH::long_array* GetNodesId() SMESH::long_array* GetNodesId();
;
SMESH::ElementType GetElementType( CORBA::Long id, bool iselem ) SMESH::ElementType GetElementType( CORBA::Long id, bool iselem );
;
SMESH::EntityType GetElementGeomType( CORBA::Long id ) SMESH::EntityType GetElementGeomType( CORBA::Long id );
;
SMESH::GeometryType GetElementShape( CORBA::Long id ) SMESH::GeometryType GetElementShape( CORBA::Long id );
;
/*! /*!
* Returns ID of elements for given submesh * Returns ID of elements for given submesh
*/ */
SMESH::long_array* GetSubMeshElementsId(CORBA::Long ShapeID) SMESH::long_array* GetSubMeshElementsId(CORBA::Long ShapeID);
;
/*! /*!
* Returns ID of nodes for given submesh * Returns ID of nodes for given submesh
* If param all==true - returns all nodes, else - * If param all==true - returns all nodes, else -
* returns only nodes on shapes. * returns only nodes on shapes.
*/ */
SMESH::long_array* GetSubMeshNodesId(CORBA::Long ShapeID, CORBA::Boolean all) SMESH::long_array* GetSubMeshNodesId(CORBA::Long ShapeID, CORBA::Boolean all);
;
/*! /*!
* Returns type of elements for given submesh * Returns type of elements for given submesh
*/ */
SMESH::ElementType GetSubMeshElementType(CORBA::Long ShapeID) SMESH::ElementType GetSubMeshElementType(CORBA::Long ShapeID);
;
char* Dump(); char* Dump();
// Create groups of elements preventing computation of a sub-shape // Create groups of elements preventing computation of a sub-shape
SMESH::ListOfGroups* MakeGroupsOfBadInputElements( int theSubShapeID, SMESH::ListOfGroups* MakeGroupsOfBadInputElements( int theSubShapeID,
const char* theGroupName) const char* theGroupName);
;
// =================================================== // ===================================================
// Internal methods not available through CORBA // Internal methods not available through CORBA

9
src/SMESH_I/SMESH_subMesh_i.cxx
View File

@ -141,7 +141,6 @@ bool getSubMeshes(::SMESH_subMesh* theSubMesh,
//============================================================================= //=============================================================================
CORBA::Long SMESH_subMesh_i::GetNumberOfElements() CORBA::Long SMESH_subMesh_i::GetNumberOfElements()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
@ -172,7 +171,6 @@ CORBA::Long SMESH_subMesh_i::GetNumberOfElements()
//============================================================================= //=============================================================================
CORBA::Long SMESH_subMesh_i::GetNumberOfNodes(CORBA::Boolean all) CORBA::Long SMESH_subMesh_i::GetNumberOfNodes(CORBA::Boolean all)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
@ -220,7 +218,6 @@ CORBA::Long SMESH_subMesh_i::GetNumberOfNodes(CORBA::Boolean all)
//============================================================================= //=============================================================================
SMESH::long_array* SMESH_subMesh_i::GetElementsId() SMESH::long_array* SMESH_subMesh_i::GetElementsId()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
@ -265,7 +262,6 @@ SMESH::long_array* SMESH_subMesh_i::GetElementsId()
//============================================================================= //=============================================================================
SMESH::long_array* SMESH_subMesh_i::GetElementsByType( SMESH::ElementType theElemType ) SMESH::long_array* SMESH_subMesh_i::GetElementsByType( SMESH::ElementType theElemType )
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
@ -351,7 +347,6 @@ SMESH::long_array* SMESH_subMesh_i::GetElementsByType( SMESH::ElementType theEle
//============================================================================= //=============================================================================
SMESH::long_array* SMESH_subMesh_i::GetNodesId() SMESH::long_array* SMESH_subMesh_i::GetNodesId()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
@ -366,7 +361,6 @@ SMESH::long_array* SMESH_subMesh_i::GetNodesId()
//============================================================================= //=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_subMesh_i::GetFather() SMESH::SMESH_Mesh_ptr SMESH_subMesh_i::GetFather()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
return _mesh_i->_this(); return _mesh_i->_this();
@ -389,7 +383,6 @@ CORBA::Long SMESH_subMesh_i::GetId()
//======================================================================= //=======================================================================
GEOM::GEOM_Object_ptr SMESH_subMesh_i::GetSubShape() GEOM::GEOM_Object_ptr SMESH_subMesh_i::GetSubShape()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
GEOM::GEOM_Object_var aShapeObj; GEOM::GEOM_Object_var aShapeObj;
@ -428,7 +421,6 @@ SMESH::long_array* SMESH_subMesh_i::GetIDs()
*/ */
//============================================================================= //=============================================================================
SMESH::ElementType SMESH_subMesh_i::GetElementType( const CORBA::Long id, const bool iselem ) SMESH::ElementType SMESH_subMesh_i::GetElementType( const CORBA::Long id, const bool iselem )
{ {
if ( _preMeshInfo ) if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile(); _preMeshInfo->FullLoadFromFile();
@ -607,7 +599,6 @@ SMESH_Invalid_subMesh_i::SMESH_Invalid_subMesh_i( PortableServer::POA_ptr thePOA
//======================================================================= //=======================================================================
GEOM::GEOM_Object_ptr SMESH_Invalid_subMesh_i::GetSubShape() GEOM::GEOM_Object_ptr SMESH_Invalid_subMesh_i::GetSubShape()
{ {
return GEOM::GEOM_Object::_duplicate( _geom ); return GEOM::GEOM_Object::_duplicate( _geom );
} }

27
src/SMESH_I/SMESH_subMesh_i.hxx
View File

@ -53,29 +53,21 @@ public:
int localId ); int localId );
~SMESH_subMesh_i(); ~SMESH_subMesh_i();
CORBA::Long GetNumberOfElements() CORBA::Long GetNumberOfElements();
;
CORBA::Long GetNumberOfNodes( CORBA::Boolean all ) CORBA::Long GetNumberOfNodes( CORBA::Boolean all );
;
SMESH::long_array* GetElementsId() SMESH::long_array* GetElementsId();
;
SMESH::long_array* GetElementsByType( SMESH::ElementType theElemType ) SMESH::long_array* GetElementsByType( SMESH::ElementType theElemType );
;
SMESH::ElementType GetElementType( CORBA::Long id, bool iselem ) SMESH::ElementType GetElementType( CORBA::Long id, bool iselem );
;
SMESH::long_array* GetNodesId() SMESH::long_array* GetNodesId();
;
SMESH::SMESH_Mesh_ptr GetFather() SMESH::SMESH_Mesh_ptr GetFather();
;
GEOM::GEOM_Object_ptr GetSubShape() GEOM::GEOM_Object_ptr GetSubShape();
;
CORBA::Long GetId(); CORBA::Long GetId();
@ -144,8 +136,7 @@ class SMESH_I_EXPORT SMESH_Invalid_subMesh_i:
int localId, int localId,
GEOM::GEOM_Object_ptr shape); GEOM::GEOM_Object_ptr shape);
virtual GEOM::GEOM_Object_ptr GetSubShape() virtual GEOM::GEOM_Object_ptr GetSubShape();
;
protected: protected:

6
src/StdMeshers/StdMeshers_Adaptive1D.hxx
View File

@ -43,20 +43,20 @@ class STDMESHERS_EXPORT StdMeshers_Adaptive1D : public SMESH_Hypothesis
/*! /*!
* Sets minimal allowed segment length * Sets minimal allowed segment length
*/ */
void SetMinSize( double minSegLen ) ; void SetMinSize( double minSegLen );
double GetMinSize() const { return myMinSize; } double GetMinSize() const { return myMinSize; }
/*! /*!
* Sets maximal allowed segment length * Sets maximal allowed segment length
*/ */
void SetMaxSize( double maxSegLen ) ; void SetMaxSize( double maxSegLen );
double GetMaxSize() const { return myMaxSize; } double GetMaxSize() const { return myMaxSize; }
/*! /*!
* Sets <deflection> parameter value, * Sets <deflection> parameter value,
* i.e. a maximal allowed distance between a segment and an edge. * i.e. a maximal allowed distance between a segment and an edge.
*/ */
void SetDeflection(double value) ; void SetDeflection(double value);
double GetDeflection() const { return myDeflection; } double GetDeflection() const { return myDeflection; }
virtual std::ostream & SaveTo(std::ostream & save); virtual std::ostream & SaveTo(std::ostream & save);

2
src/StdMeshers/StdMeshers_Arithmetic1D.hxx
View File

@ -42,7 +42,7 @@ public:
StdMeshers_Arithmetic1D(int hypId, SMESH_Gen* gen); StdMeshers_Arithmetic1D(int hypId, SMESH_Gen* gen);
virtual ~StdMeshers_Arithmetic1D(); virtual ~StdMeshers_Arithmetic1D();
void SetLength(double length, bool isStartLength) ; void SetLength(double length, bool isStartLength);
double GetLength(bool isStartLength) const; double GetLength(bool isStartLength) const;

3
src/StdMeshers/StdMeshers_AutomaticLength.cxx
View File

@ -84,7 +84,6 @@ const double theCoarseConst = 0.5;
const double theFineConst = 4.5; const double theFineConst = 4.5;
void StdMeshers_AutomaticLength::SetFineness(double theFineness) void StdMeshers_AutomaticLength::SetFineness(double theFineness)
{ {
if ( theFineness < 0.0 || theFineness > 1.0 ) if ( theFineness < 0.0 || theFineness > 1.0 )
throw SALOME_Exception(LOCALIZED("theFineness is out of range [0.0-1.0]")); throw SALOME_Exception(LOCALIZED("theFineness is out of range [0.0-1.0]"));
@ -239,7 +238,6 @@ namespace {
double StdMeshers_AutomaticLength::GetLength(const SMESH_Mesh* theMesh, double StdMeshers_AutomaticLength::GetLength(const SMESH_Mesh* theMesh,
const double theEdgeLength) const double theEdgeLength)
{ {
if ( !theMesh ) throw SALOME_Exception(LOCALIZED("NULL Mesh")); if ( !theMesh ) throw SALOME_Exception(LOCALIZED("NULL Mesh"));
@ -261,7 +259,6 @@ double StdMeshers_AutomaticLength::GetLength(const SMESH_Mesh* theMesh,
double StdMeshers_AutomaticLength::GetLength(const SMESH_Mesh* theMesh, double StdMeshers_AutomaticLength::GetLength(const SMESH_Mesh* theMesh,
const TopoDS_Shape& anEdge) const TopoDS_Shape& anEdge)
{ {
if ( !theMesh ) throw SALOME_Exception(LOCALIZED("NULL Mesh")); if ( !theMesh ) throw SALOME_Exception(LOCALIZED("NULL Mesh"));

9
src/StdMeshers/StdMeshers_AutomaticLength.hxx
View File

@ -55,14 +55,12 @@ public:
/*! /*!
* \brief Computes segment for a given edge * \brief Computes segment for a given edge
*/ */
double GetLength(const SMESH_Mesh* aMesh, const TopoDS_Shape& anEdge) double GetLength(const SMESH_Mesh* aMesh, const TopoDS_Shape& anEdge);
;
/*! /*!
* \brief Computes segment length for an edge of given length * \brief Computes segment length for an edge of given length
*/ */
double GetLength(const SMESH_Mesh* aMesh, const double edgeLength) double GetLength(const SMESH_Mesh* aMesh, const double edgeLength);
;
/*! /*!
* \brief Set Fineness * \brief Set Fineness
@ -74,8 +72,7 @@ public:
* The "Initial Number of Elements on the Shortest Edge" (S0) * The "Initial Number of Elements on the Shortest Edge" (S0)
* is divided by (0.5 + 4.5 x theFineness) * is divided by (0.5 + 4.5 x theFineness)
*/ */
void SetFineness(double theFineness) void SetFineness(double theFineness);
;
/*! /*!
* \brief Return mesh Fineness * \brief Return mesh Fineness

10
src/StdMeshers/StdMeshers_CartesianParameters3D.cxx
View File

@ -133,7 +133,6 @@ namespace
void checkGridSpacing(std::vector<std::string>& spaceFunctions, void checkGridSpacing(std::vector<std::string>& spaceFunctions,
std::vector<double>& internalPoints, std::vector<double>& internalPoints,
const std::string& axis) const std::string& axis)
{ {
if ( spaceFunctions.empty() ) if ( spaceFunctions.empty() )
throw SALOME_Exception(SMESH_Comment("Empty space function for ") << axis ); throw SALOME_Exception(SMESH_Comment("Empty space function for ") << axis );
@ -170,7 +169,6 @@ namespace
//======================================================================= //=======================================================================
void StdMeshers_CartesianParameters3D::SetGrid(std::vector<double>& coords, int axis) void StdMeshers_CartesianParameters3D::SetGrid(std::vector<double>& coords, int axis)
{ {
checkAxis( axis ); checkAxis( axis );
@ -198,7 +196,6 @@ void StdMeshers_CartesianParameters3D::SetGrid(std::vector<double>& coords, int
void StdMeshers_CartesianParameters3D::SetGridSpacing(std::vector<string>& xSpaceFuns, void StdMeshers_CartesianParameters3D::SetGridSpacing(std::vector<string>& xSpaceFuns,
std::vector<double>& xInternalPoints, std::vector<double>& xInternalPoints,
const int axis) const int axis)
{ {
checkAxis( axis ); checkAxis( axis );
@ -252,7 +249,6 @@ bool StdMeshers_CartesianParameters3D::GetFixedPoint(double p[3]) const
//======================================================================= //=======================================================================
void StdMeshers_CartesianParameters3D::SetSizeThreshold(const double threshold) void StdMeshers_CartesianParameters3D::SetSizeThreshold(const double threshold)
{ {
if ( threshold <= 1.0 ) if ( threshold <= 1.0 )
throw SALOME_Exception(LOCALIZED("threshold must be > 1.0")); throw SALOME_Exception(LOCALIZED("threshold must be > 1.0"));
@ -272,7 +268,6 @@ void StdMeshers_CartesianParameters3D::SetSizeThreshold(const double threshold)
void StdMeshers_CartesianParameters3D::GetGridSpacing(std::vector<std::string>& spaceFunctions, void StdMeshers_CartesianParameters3D::GetGridSpacing(std::vector<std::string>& spaceFunctions,
std::vector<double>& internalPoints, std::vector<double>& internalPoints,
const int axis) const const int axis) const
{ {
if ( !IsGridBySpacing(axis) ) if ( !IsGridBySpacing(axis) )
throw SALOME_Exception(LOCALIZED("The grid is defined by coordinates and not by spacing")); throw SALOME_Exception(LOCALIZED("The grid is defined by coordinates and not by spacing"));
@ -286,7 +281,6 @@ void StdMeshers_CartesianParameters3D::GetGridSpacing(std::vector<std::string>&
//======================================================================= //=======================================================================
bool StdMeshers_CartesianParameters3D::IsGridBySpacing(const int axis) const bool StdMeshers_CartesianParameters3D::IsGridBySpacing(const int axis) const
{ {
checkAxis(axis); checkAxis(axis);
return !_spaceFunctions[axis].empty(); return !_spaceFunctions[axis].empty();
@ -305,7 +299,6 @@ void StdMeshers_CartesianParameters3D::ComputeCoordinates(const double x0,
vector<double>& coords, vector<double>& coords,
const string& axis, const string& axis,
const double* xForced ) const double* xForced )
{ {
checkGridSpacing( theSpaceFuns, thePoints, axis ); checkGridSpacing( theSpaceFuns, thePoints, axis );
@ -404,7 +397,6 @@ void StdMeshers_CartesianParameters3D::GetCoordinates(std::vector<double>& xNode
std::vector<double>& yNodes, std::vector<double>& yNodes,
std::vector<double>& zNodes, std::vector<double>& zNodes,
const Bnd_Box& bndBox) const const Bnd_Box& bndBox) const
{ {
double x0,y0,z0, x1,y1,z1; double x0,y0,z0, x1,y1,z1;
if ( IsGridBySpacing(0) || IsGridBySpacing(1) || IsGridBySpacing(2)) if ( IsGridBySpacing(0) || IsGridBySpacing(1) || IsGridBySpacing(2))
@ -655,7 +647,6 @@ ComputeOptimalAxesDirs(const TopoDS_Shape& shape,
//======================================================================= //=======================================================================
void StdMeshers_CartesianParameters3D::SetAxisDirs(const double* the9DirComps) void StdMeshers_CartesianParameters3D::SetAxisDirs(const double* the9DirComps)
{ {
gp_Vec x( the9DirComps[0], gp_Vec x( the9DirComps[0],
the9DirComps[1], the9DirComps[1],
@ -697,7 +688,6 @@ void StdMeshers_CartesianParameters3D::SetAxisDirs(const double* the9DirComps)
//======================================================================= //=======================================================================
void StdMeshers_CartesianParameters3D::GetGrid(std::vector<double>& coords, int axis) const void StdMeshers_CartesianParameters3D::GetGrid(std::vector<double>& coords, int axis) const
{ {
if ( IsGridBySpacing(axis) ) if ( IsGridBySpacing(axis) )
throw SALOME_Exception(LOCALIZED("The grid is defined by spacing and not by coordinates")); throw SALOME_Exception(LOCALIZED("The grid is defined by spacing and not by coordinates"));

18
src/StdMeshers/StdMeshers_CartesianParameters3D.hxx
View File

@ -54,11 +54,11 @@ public:
/*! /*!
* Sets coordinates of node positions along an axis (countered from 0) * Sets coordinates of node positions along an axis (countered from 0)
*/ */
void SetGrid(std::vector<double>& xNodes, int axis) ; void SetGrid(std::vector<double>& xNodes, int axis);
/*! /*!
* Return coordinates of node positions along the three axes * Return coordinates of node positions along the three axes
*/ */
void GetGrid(std::vector<double>& xNodes, int axis) const ; void GetGrid(std::vector<double>& xNodes, int axis) const;
/*! /*!
* \brief Set grid spacing along the three axes * \brief Set grid spacing along the three axes
@ -70,13 +70,13 @@ public:
*/ */
void SetGridSpacing(std::vector<std::string>& spaceFunctions, void SetGridSpacing(std::vector<std::string>& spaceFunctions,
std::vector<double>& internalPoints, std::vector<double>& internalPoints,
const int axis) ; const int axis);
void GetGridSpacing(std::vector<std::string>& spaceFunctions, void GetGridSpacing(std::vector<std::string>& spaceFunctions,
std::vector<double>& internalPoints, std::vector<double>& internalPoints,
const int axis) const ; const int axis) const;
bool IsGridBySpacing(const int axis) const ; bool IsGridBySpacing(const int axis) const;
/*! /*!
* Set/unset a fixed point, at which a node will be created provided that grid * Set/unset a fixed point, at which a node will be created provided that grid
@ -99,7 +99,7 @@ public:
std::vector<double>& points, std::vector<double>& points,
std::vector<double>& coords, std::vector<double>& coords,
const std::string& axis, const std::string& axis,
const double* xForced=0) ; const double* xForced=0);
/*! /*!
* Return coordinates of node positions along the three axes. * Return coordinates of node positions along the three axes.
* If the grid is defined by spacing functions, the coordinates are computed * If the grid is defined by spacing functions, the coordinates are computed
@ -107,12 +107,12 @@ public:
void GetCoordinates(std::vector<double>& xNodes, void GetCoordinates(std::vector<double>& xNodes,
std::vector<double>& yNodes, std::vector<double>& yNodes,
std::vector<double>& zNodes, std::vector<double>& zNodes,
const Bnd_Box& bndBox) const ; const Bnd_Box& bndBox) const;
/*! /*!
* \brief Set custom direction of axes * \brief Set custom direction of axes
*/ */
void SetAxisDirs(const double* the9DirComps) ; void SetAxisDirs(const double* the9DirComps);
const double* GetAxisDirs() const { return _axisDirs; } const double* GetAxisDirs() const { return _axisDirs; }
/*! /*!
* \brief Returns axes at which number of hexahedra is maximal * \brief Returns axes at which number of hexahedra is maximal
@ -125,7 +125,7 @@ public:
* hexahedron by geometry boundary is considered small and is removed if * hexahedron by geometry boundary is considered small and is removed if
* it's size is \athreshold times less than the size of the initial hexahedron. * it's size is \athreshold times less than the size of the initial hexahedron.
*/ */
void SetSizeThreshold(const double threshold) ; void SetSizeThreshold(const double threshold);
/*! /*!
* \brief Return size threshold * \brief Return size threshold
*/ */

2
src/StdMeshers/StdMeshers_Deflection1D.hxx
View File

@ -38,7 +38,7 @@ class STDMESHERS_EXPORT StdMeshers_Deflection1D:public SMESH_Hypothesis
StdMeshers_Deflection1D(int hypId, SMESH_Gen * gen); StdMeshers_Deflection1D(int hypId, SMESH_Gen * gen);
virtual ~ StdMeshers_Deflection1D(); virtual ~ StdMeshers_Deflection1D();
void SetDeflection(double value) ; void SetDeflection(double value);
double GetDeflection() const; double GetDeflection() const;

2
src/StdMeshers/StdMeshers_FixedPoints1D.cxx
View File

@ -61,7 +61,6 @@ StdMeshers_FixedPoints1D::~StdMeshers_FixedPoints1D()
//============================================================================= //=============================================================================
void StdMeshers_FixedPoints1D::SetPoints(const std::vector<double>& listParams) void StdMeshers_FixedPoints1D::SetPoints(const std::vector<double>& listParams)
{ {
_params = listParams; _params = listParams;
NotifySubMeshesHypothesisModification(); NotifySubMeshesHypothesisModification();
@ -74,7 +73,6 @@ void StdMeshers_FixedPoints1D::SetPoints(const std::vector<double>& listParams)
//============================================================================= //=============================================================================
void StdMeshers_FixedPoints1D::SetNbSegments(const std::vector<int>& listNbSeg) void StdMeshers_FixedPoints1D::SetNbSegments(const std::vector<int>& listNbSeg)
{ {
_nbsegs = listNbSeg; _nbsegs = listNbSeg;
NotifySubMeshesHypothesisModification(); NotifySubMeshesHypothesisModification();

6
src/StdMeshers/StdMeshers_FixedPoints1D.hxx
View File

@ -41,11 +41,9 @@ public:
StdMeshers_FixedPoints1D(int hypId, SMESH_Gen* gen); StdMeshers_FixedPoints1D(int hypId, SMESH_Gen* gen);
virtual ~StdMeshers_FixedPoints1D(); virtual ~StdMeshers_FixedPoints1D();
void SetPoints(const std::vector<double>& listParams) void SetPoints(const std::vector<double>& listParams);
;
void SetNbSegments(const std::vector<int>& listNbSeg) void SetNbSegments(const std::vector<int>& listNbSeg) ;
;
const std::vector<double>& GetPoints() const { return _params; } const std::vector<double>& GetPoints() const { return _params; }

4
src/StdMeshers/StdMeshers_Geometric1D.hxx
View File

@ -37,8 +37,8 @@ class STDMESHERS_EXPORT StdMeshers_Geometric1D: public StdMeshers_Reversible1D
public: public:
StdMeshers_Geometric1D(int hypId, SMESH_Gen* gen); StdMeshers_Geometric1D(int hypId, SMESH_Gen* gen);
void SetStartLength(double length) ; void SetStartLength(double length);
void SetCommonRatio(double factor) ; void SetCommonRatio(double factor);
double GetStartLength() const; double GetStartLength() const;
double GetCommonRatio() const; double GetCommonRatio() const;

3
src/StdMeshers/StdMeshers_LayerDistribution.hxx
View File

@ -59,8 +59,7 @@ public:
* \brief Sets 1D hypothesis specifying distribution of layers * \brief Sets 1D hypothesis specifying distribution of layers
* \param hyp1D - 1D hypothesis * \param hyp1D - 1D hypothesis
*/ */
void SetLayerDistribution(SMESH_Hypothesis* hyp1D) void SetLayerDistribution(SMESH_Hypothesis* hyp1D);
;
/*! /*!
* \brief Returns 1D hypothesis specifying distribution of layers * \brief Returns 1D hypothesis specifying distribution of layers

4
src/StdMeshers/StdMeshers_LocalLength.hxx
View File

@ -40,8 +40,8 @@ class STDMESHERS_EXPORT StdMeshers_LocalLength: public SMESH_Hypothesis
StdMeshers_LocalLength(int hypId, SMESH_Gen * gen); StdMeshers_LocalLength(int hypId, SMESH_Gen * gen);
virtual ~ StdMeshers_LocalLength(); virtual ~ StdMeshers_LocalLength();
void SetLength(double length) ; void SetLength(double length);
void SetPrecision(double precision) ; void SetPrecision(double precision);
double GetLength() const; double GetLength() const;
double GetPrecision() const; double GetPrecision() const;

2
src/StdMeshers/StdMeshers_MEFISTO_2D.hxx
View File

@ -68,7 +68,7 @@ public:
std::vector< const SMDS_MeshNode*>& mefistoToDS, std::vector< const SMDS_MeshNode*>& mefistoToDS,
double scalex, double scaley); double scalex, double scaley);
void ComputeScaleOnFace(SMESH_Mesh& /*aMesh*/, void ComputeScaleOnFace(SMESH_Mesh& aMesh,
const TopoDS_Face& aFace, const TopoDS_Face& aFace,
double& scalex, double& scalex,
double& scaley); double& scaley);

2
src/StdMeshers/StdMeshers_MaxLength.hxx
View File

@ -35,7 +35,7 @@ class STDMESHERS_EXPORT StdMeshers_MaxLength: public SMESH_Hypothesis
StdMeshers_MaxLength(int hypId, SMESH_Gen * gen); StdMeshers_MaxLength(int hypId, SMESH_Gen * gen);
virtual ~ StdMeshers_MaxLength(); virtual ~ StdMeshers_MaxLength();
void SetLength(double length) ; void SetLength(double length);
double GetLength() const; double GetLength() const;
bool HavePreestimatedLength() const { return _preestimated > 0.; } bool HavePreestimatedLength() const { return _preestimated > 0.; }

4
src/StdMeshers/StdMeshers_NotConformAllowed.hxx
View File

@ -42,8 +42,8 @@ public:
virtual std::ostream & SaveTo(std::ostream & save); virtual std::ostream & SaveTo(std::ostream & save);
virtual std::istream & LoadFrom(std::istream & load); virtual std::istream & LoadFrom(std::istream & load);
friend std::ostream & operator << (std::ostream & save, StdMeshers_NotConformAllowed & /*hyp*/); friend std::ostream & operator << (std::ostream & save, StdMeshers_NotConformAllowed & hyp);
friend std::istream & operator >> (std::istream & load, StdMeshers_NotConformAllowed & /*hyp*/); friend std::istream & operator >> (std::istream & load, StdMeshers_NotConformAllowed & hyp);
/*! /*!
* \brief Initialize my parameter values by the mesh built on the geometry * \brief Initialize my parameter values by the mesh built on the geometry

2
src/StdMeshers/StdMeshers_NumberOfLayers.hxx
View File

@ -54,7 +54,7 @@ public:
virtual ~StdMeshers_NumberOfLayers(); virtual ~StdMeshers_NumberOfLayers();
// Sets <number of segments> parameter value // Sets <number of segments> parameter value
void SetNumberOfLayers(int numberOfLayers) ; void SetNumberOfLayers(int numberOfLayers);
// Returns <number of layers> parameter value // Returns <number of layers> parameter value
int GetNumberOfLayers() const; int GetNumberOfLayers() const;

13
src/StdMeshers/StdMeshers_NumberOfSegments.cxx
View File

@ -87,7 +87,6 @@ StdMeshers_NumberOfSegments::~StdMeshers_NumberOfSegments()
//============================================================================= //=============================================================================
const vector<double>& const vector<double>&
StdMeshers_NumberOfSegments::BuildDistributionExpr( const char* expr,int nbSeg,int conv ) StdMeshers_NumberOfSegments::BuildDistributionExpr( const char* expr,int nbSeg,int conv )
{ {
if( !buildDistribution( TCollection_AsciiString( ( Standard_CString )expr ), conv, 0.0, 1.0, nbSeg, _distr, 1E-4 ) ) if( !buildDistribution( TCollection_AsciiString( ( Standard_CString )expr ), conv, 0.0, 1.0, nbSeg, _distr, 1E-4 ) )
_distr.resize( 0 ); _distr.resize( 0 );
@ -98,7 +97,6 @@ const vector<double>&
StdMeshers_NumberOfSegments::BuildDistributionTab( const vector<double>& tab, StdMeshers_NumberOfSegments::BuildDistributionTab( const vector<double>& tab,
int nbSeg, int nbSeg,
int conv ) int conv )
{ {
if( !buildDistribution( tab, conv, 0.0, 1.0, nbSeg, _distr, 1E-4 ) ) if( !buildDistribution( tab, conv, 0.0, 1.0, nbSeg, _distr, 1E-4 ) )
_distr.resize( 0 ); _distr.resize( 0 );
@ -112,7 +110,6 @@ StdMeshers_NumberOfSegments::BuildDistributionTab( const vector<double>& tab,
//============================================================================= //=============================================================================
void StdMeshers_NumberOfSegments::SetNumberOfSegments(int segmentsNumber) void StdMeshers_NumberOfSegments::SetNumberOfSegments(int segmentsNumber)
{ {
int oldNumberOfSegments = _numberOfSegments; int oldNumberOfSegments = _numberOfSegments;
if (segmentsNumber <= 0) if (segmentsNumber <= 0)
@ -141,7 +138,6 @@ int StdMeshers_NumberOfSegments::GetNumberOfSegments() const
//================================================================================ //================================================================================
void StdMeshers_NumberOfSegments::SetDistrType(DistrType typ) void StdMeshers_NumberOfSegments::SetDistrType(DistrType typ)
{ {
if (typ < DT_Regular || typ > DT_ExprFunc) if (typ < DT_Regular || typ > DT_ExprFunc)
throw SALOME_Exception(LOCALIZED("distribution type is out of range")); throw SALOME_Exception(LOCALIZED("distribution type is out of range"));
@ -171,7 +167,6 @@ StdMeshers_NumberOfSegments::DistrType StdMeshers_NumberOfSegments::GetDistrType
//================================================================================ //================================================================================
void StdMeshers_NumberOfSegments::SetScaleFactor(double scaleFactor) void StdMeshers_NumberOfSegments::SetScaleFactor(double scaleFactor)
{ {
if (scaleFactor < PRECISION) if (scaleFactor < PRECISION)
throw SALOME_Exception(LOCALIZED("scale factor must be positive")); throw SALOME_Exception(LOCALIZED("scale factor must be positive"));
@ -197,7 +192,6 @@ void StdMeshers_NumberOfSegments::SetScaleFactor(double scaleFactor)
//================================================================================ //================================================================================
double StdMeshers_NumberOfSegments::GetScaleFactor() const double StdMeshers_NumberOfSegments::GetScaleFactor() const
{ {
if (_distrType != DT_Scale) if (_distrType != DT_Scale)
throw SALOME_Exception(LOCALIZED("not a scale distribution")); throw SALOME_Exception(LOCALIZED("not a scale distribution"));
@ -211,7 +205,6 @@ double StdMeshers_NumberOfSegments::GetScaleFactor() const
//================================================================================ //================================================================================
void StdMeshers_NumberOfSegments::SetTableFunction(const vector<double>& table) void StdMeshers_NumberOfSegments::SetTableFunction(const vector<double>& table)
{ {
if (_distrType != DT_TabFunc) if (_distrType != DT_TabFunc)
_distrType = DT_TabFunc; _distrType = DT_TabFunc;
@ -276,7 +269,6 @@ void StdMeshers_NumberOfSegments::SetTableFunction(const vector<double>& table)
//================================================================================ //================================================================================
const vector<double>& StdMeshers_NumberOfSegments::GetTableFunction() const const vector<double>& StdMeshers_NumberOfSegments::GetTableFunction() const
{ {
if (_distrType != DT_TabFunc) if (_distrType != DT_TabFunc)
throw SALOME_Exception(LOCALIZED("not a table function distribution")); throw SALOME_Exception(LOCALIZED("not a table function distribution"));
@ -380,7 +372,6 @@ bool process( const TCollection_AsciiString& str, int convMode,
//================================================================================ //================================================================================
void StdMeshers_NumberOfSegments::SetExpressionFunction(const char* expr) void StdMeshers_NumberOfSegments::SetExpressionFunction(const char* expr)
{ {
if (_distrType != DT_ExprFunc) if (_distrType != DT_ExprFunc)
_distrType = DT_ExprFunc; _distrType = DT_ExprFunc;
@ -402,7 +393,6 @@ void StdMeshers_NumberOfSegments::SetExpressionFunction(const char* expr)
std::string std::string
StdMeshers_NumberOfSegments::CheckExpressionFunction( const std::string& expr, StdMeshers_NumberOfSegments::CheckExpressionFunction( const std::string& expr,
const int convMode) const int convMode)
{ {
// remove white spaces // remove white spaces
TCollection_AsciiString str((Standard_CString)expr.c_str()); TCollection_AsciiString str((Standard_CString)expr.c_str());
@ -442,7 +432,6 @@ StdMeshers_NumberOfSegments::CheckExpressionFunction( const std::string& expr,
//================================================================================ //================================================================================
const char* StdMeshers_NumberOfSegments::GetExpressionFunction() const const char* StdMeshers_NumberOfSegments::GetExpressionFunction() const
{ {
if (_distrType != DT_ExprFunc) if (_distrType != DT_ExprFunc)
throw SALOME_Exception(LOCALIZED("not an expression function distribution")); throw SALOME_Exception(LOCALIZED("not an expression function distribution"));
@ -456,7 +445,6 @@ const char* StdMeshers_NumberOfSegments::GetExpressionFunction() const
//================================================================================ //================================================================================
void StdMeshers_NumberOfSegments::SetConversionMode( int conv ) void StdMeshers_NumberOfSegments::SetConversionMode( int conv )
{ {
// if (_distrType != DT_TabFunc && _distrType != DT_ExprFunc) // if (_distrType != DT_TabFunc && _distrType != DT_ExprFunc)
// throw SALOME_Exception(LOCALIZED("not a functional distribution")); // throw SALOME_Exception(LOCALIZED("not a functional distribution"));
@ -475,7 +463,6 @@ void StdMeshers_NumberOfSegments::SetConversionMode( int conv )
//================================================================================ //================================================================================
int StdMeshers_NumberOfSegments::ConversionMode() const int StdMeshers_NumberOfSegments::ConversionMode() const
{ {
// if (_distrType != DT_TabFunc && _distrType != DT_ExprFunc) // if (_distrType != DT_TabFunc && _distrType != DT_ExprFunc)
// throw SALOME_Exception(LOCALIZED("not a functional distribution")); // throw SALOME_Exception(LOCALIZED("not a functional distribution"));

37
src/StdMeshers/StdMeshers_NumberOfSegments.hxx
View File

@ -48,15 +48,14 @@ public:
virtual ~StdMeshers_NumberOfSegments(); virtual ~StdMeshers_NumberOfSegments();
// Builds point distribution according to passed function // Builds point distribution according to passed function
const std::vector<double>& BuildDistributionExpr( const char*, int, int ) ; const std::vector<double>& BuildDistributionExpr( const char*, int, int );
const std::vector<double>& BuildDistributionTab( const std::vector<double>&, int, int ) ; const std::vector<double>& BuildDistributionTab( const std::vector<double>&, int, int );
/*! /*!
* \brief Set the number of segments * \brief Set the number of segments
* \param segmentsNumber - must be greater than zero * \param segmentsNumber - must be greater than zero
*/ */
void SetNumberOfSegments(int segmentsNumber) void SetNumberOfSegments(int segmentsNumber);
;
/*! /*!
* \brief Get the number of segments * \brief Get the number of segments
@ -77,8 +76,7 @@ public:
/*! /*!
* \brief Set distribution type * \brief Set distribution type
*/ */
void SetDistrType(DistrType typ) void SetDistrType(DistrType typ);
;
/*! /*!
* \brief Get distribution type * \brief Get distribution type
@ -92,16 +90,14 @@ public:
* Throws SALOME_Exception if distribution type is not DT_Scale, * Throws SALOME_Exception if distribution type is not DT_Scale,
* or scaleFactor is not a positive value different from 1 * or scaleFactor is not a positive value different from 1
*/ */
virtual void SetScaleFactor(double scaleFactor) virtual void SetScaleFactor(double scaleFactor);
;
/*! /*!
* \brief Get scale factor for scale distribution * \brief Get scale factor for scale distribution
* *
* Throws SALOME_Exception if distribution type is not DT_Scale * Throws SALOME_Exception if distribution type is not DT_Scale
*/ */
double GetScaleFactor() const double GetScaleFactor() const;
;
/*! /*!
* \brief Set table function for distribution DT_TabFunc * \brief Set table function for distribution DT_TabFunc
@ -112,16 +108,14 @@ public:
* *
* Throws SALOME_Exception if distribution type is not DT_TabFunc * Throws SALOME_Exception if distribution type is not DT_TabFunc
*/ */
void SetTableFunction(const std::vector<double>& table) void SetTableFunction(const std::vector<double>& table);
;
/*! /*!
* \brief Get table function for distribution DT_TabFunc * \brief Get table function for distribution DT_TabFunc
* *
* Throws SALOME_Exception if distribution type is not DT_TabFunc * Throws SALOME_Exception if distribution type is not DT_TabFunc
*/ */
const std::vector<double>& GetTableFunction() const const std::vector<double>& GetTableFunction() const;
;
/*! /*!
* \brief Set expression function for distribution DT_ExprFunc * \brief Set expression function for distribution DT_ExprFunc
@ -130,16 +124,14 @@ public:
* *
* Throws SALOME_Exception if distribution type is not DT_ExprFunc * Throws SALOME_Exception if distribution type is not DT_ExprFunc
*/ */
void SetExpressionFunction( const char* expr) void SetExpressionFunction( const char* expr);
;
/*! /*!
* \brief Get expression function for distribution DT_ExprFunc * \brief Get expression function for distribution DT_ExprFunc
* *
* Throws SALOME_Exception if distribution type is not DT_ExprFunc * Throws SALOME_Exception if distribution type is not DT_ExprFunc
*/ */
const char* GetExpressionFunction() const const char* GetExpressionFunction() const;
;
/*! /*!
* \brief Checks validity of the expression of the function f(t), e.g. "sin(t)". * \brief Checks validity of the expression of the function f(t), e.g. "sin(t)".
@ -147,8 +139,7 @@ public:
* \param convMode - 0 for "Exponent mode", 1 for "Cut negative mode" * \param convMode - 0 for "Exponent mode", 1 for "Cut negative mode"
*/ */
static std::string CheckExpressionFunction( const std::string& expr, static std::string CheckExpressionFunction( const std::string& expr,
const int convMode) const int convMode);
;
/*! /*!
* \brief Set conversion mode. When it is 0, it means "exponent mode": * \brief Set conversion mode. When it is 0, it means "exponent mode":
@ -159,16 +150,14 @@ public:
* *
* Throws SALOME_Exception if distribution type is not functional * Throws SALOME_Exception if distribution type is not functional
*/ */
void SetConversionMode( int conv ) void SetConversionMode( int conv );
;
/*! /*!
* \brief Returns conversion mode * \brief Returns conversion mode
* *
* Throws SALOME_Exception if distribution type is not functional * Throws SALOME_Exception if distribution type is not functional
*/ */
int ConversionMode() const int ConversionMode() const;
;
/*! /*!
* \brief Initialize number of segments by the mesh built on the geometry * \brief Initialize number of segments by the mesh built on the geometry

4
src/StdMeshers/StdMeshers_PolygonPerFace_2D.hxx
View File

@ -34,8 +34,8 @@ class STDMESHERS_EXPORT StdMeshers_PolygonPerFace_2D: public SMESH_2D_Algo
public: public:
StdMeshers_PolygonPerFace_2D(int hypId, SMESH_Gen* gen); StdMeshers_PolygonPerFace_2D(int hypId, SMESH_Gen* gen);
virtual bool CheckHypothesis(SMESH_Mesh& /*aMesh*/, virtual bool CheckHypothesis(SMESH_Mesh& aMesh,
const TopoDS_Shape& /*aShape*/, const TopoDS_Shape& aShape,
SMESH_Hypothesis::Hypothesis_Status& aStatus); SMESH_Hypothesis::Hypothesis_Status& aStatus);
virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape); virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);

4
src/StdMeshers/StdMeshers_Prism_3D.hxx
View File

@ -482,8 +482,8 @@ public:
StdMeshers_Prism_3D(int hypId, SMESH_Gen* gen); StdMeshers_Prism_3D(int hypId, SMESH_Gen* gen);
virtual ~StdMeshers_Prism_3D(); virtual ~StdMeshers_Prism_3D();
virtual bool CheckHypothesis(SMESH_Mesh& /*aMesh*/, virtual bool CheckHypothesis(SMESH_Mesh& aMesh,
const TopoDS_Shape& /*aShape*/, const TopoDS_Shape& aShape,
SMESH_Hypothesis::Hypothesis_Status& aStatus); SMESH_Hypothesis::Hypothesis_Status& aStatus);
virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape); virtual bool Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape);

6
src/StdMeshers/StdMeshers_ProjectionSource1D.hxx
View File

@ -56,8 +56,7 @@ public:
/*! /*!
* Sets source <edge> to take a mesh pattern from * Sets source <edge> to take a mesh pattern from
*/ */
void SetSourceEdge(const TopoDS_Shape& edge) void SetSourceEdge(const TopoDS_Shape& edge);
;
/*! /*!
* Returns the source edge or a group containing edges * Returns the source edge or a group containing edges
@ -85,8 +84,7 @@ public:
* This parameter is optional * This parameter is optional
*/ */
void SetVertexAssociation(const TopoDS_Shape& sourceVertex, void SetVertexAssociation(const TopoDS_Shape& sourceVertex,
const TopoDS_Shape& targetVertex) const TopoDS_Shape& targetVertex);
;
/*! /*!
* Returns the vertex associated with the target vertex. * Returns the vertex associated with the target vertex.

10
src/StdMeshers/StdMeshers_ProjectionSource2D.hxx
View File

@ -56,8 +56,7 @@ public:
/*! /*!
* Sets a source <face> to take a mesh pattern from * Sets a source <face> to take a mesh pattern from
*/ */
void SetSourceFace(const TopoDS_Shape& face) void SetSourceFace(const TopoDS_Shape& face);
;
/*! /*!
* Returns the source face or a group containing faces * Returns the source face or a group containing faces
@ -88,22 +87,21 @@ public:
void SetVertexAssociation(const TopoDS_Shape& sourceVertex1, void SetVertexAssociation(const TopoDS_Shape& sourceVertex1,
const TopoDS_Shape& sourceVertex2, const TopoDS_Shape& sourceVertex2,
const TopoDS_Shape& targetVertex1, const TopoDS_Shape& targetVertex1,
const TopoDS_Shape& targetVertex2) const TopoDS_Shape& targetVertex2);
;
/*! /*!
* Returns the <i>-th source vertex associated with the <i>-th target vertex. * Returns the <i>-th source vertex associated with the <i>-th target vertex.
* Result may be nil if association not set. * Result may be nil if association not set.
* Valid indices are 1 and 2 * Valid indices are 1 and 2
*/ */
TopoDS_Vertex GetSourceVertex(int i) const ; TopoDS_Vertex GetSourceVertex(int i) const;
/*! /*!
* Returns the <i>-th target vertex associated with the <i>-th source vertex. * Returns the <i>-th target vertex associated with the <i>-th source vertex.
* Result may be nil if association not set. * Result may be nil if association not set.
* Valid indices are 1 and 2 * Valid indices are 1 and 2
*/ */
TopoDS_Vertex GetTargetVertex(int i) const ; TopoDS_Vertex GetTargetVertex(int i) const;
/*! /*!
* \brief Test if vertex association defined * \brief Test if vertex association defined

10
src/StdMeshers/StdMeshers_ProjectionSource3D.hxx
View File

@ -56,8 +56,7 @@ public:
/*! /*!
* Sets a source <shape> to take a mesh pattern from * Sets a source <shape> to take a mesh pattern from
*/ */
void SetSource3DShape(const TopoDS_Shape& shape) void SetSource3DShape(const TopoDS_Shape& shape);
;
/*! /*!
* Returns the source shape * Returns the source shape
@ -82,20 +81,19 @@ public:
void SetVertexAssociation(const TopoDS_Shape& sourceVertex1, void SetVertexAssociation(const TopoDS_Shape& sourceVertex1,
const TopoDS_Shape& sourceVertex2, const TopoDS_Shape& sourceVertex2,
const TopoDS_Shape& targetVertex1, const TopoDS_Shape& targetVertex1,
const TopoDS_Shape& targetVertex2) const TopoDS_Shape& targetVertex2);
;
/*! /*!
* Returns the <i>-th source vertex associated with the <i>-th target vertex. * Returns the <i>-th source vertex associated with the <i>-th target vertex.
* Result may be nil if association not set. * Result may be nil if association not set.
*/ */
TopoDS_Vertex GetSourceVertex(int i) const ; TopoDS_Vertex GetSourceVertex(int i) const;
/*! /*!
* Returns the <i>-th target vertex associated with the <i>-th source vertex. * Returns the <i>-th target vertex associated with the <i>-th source vertex.
* Result may be nil if association not set. * Result may be nil if association not set.
*/ */
TopoDS_Vertex GetTargetVertex(int i) const ; TopoDS_Vertex GetTargetVertex(int i) const;
/*! /*!
* \brief Test if vertex association defined * \brief Test if vertex association defined

4
src/StdMeshers/StdMeshers_Quadrangle_2D.hxx
View File

@ -174,8 +174,8 @@ class STDMESHERS_EXPORT StdMeshers_Quadrangle_2D: public SMESH_2D_Algo
bool setNormalizedGrid(FaceQuadStruct::Ptr quad); bool setNormalizedGrid(FaceQuadStruct::Ptr quad);
void splitQuadFace(SMESHDS_Mesh * /*theMeshDS*/, void splitQuadFace(SMESHDS_Mesh * theMeshDS,
const int /*theFaceID*/, const int theFaceID,
const SMDS_MeshNode* theNode1, const SMDS_MeshNode* theNode1,
const SMDS_MeshNode* theNode2, const SMDS_MeshNode* theNode2,
const SMDS_MeshNode* theNode3, const SMDS_MeshNode* theNode3,

2
src/StdMeshers/StdMeshers_SegmentLengthAroundVertex.hxx
View File

@ -43,7 +43,7 @@ class STDMESHERS_EXPORT StdMeshers_SegmentLengthAroundVertex:public SMESH_Hypoth
StdMeshers_SegmentLengthAroundVertex(int hypId, SMESH_Gen * gen); StdMeshers_SegmentLengthAroundVertex(int hypId, SMESH_Gen * gen);
virtual ~ StdMeshers_SegmentLengthAroundVertex(); virtual ~ StdMeshers_SegmentLengthAroundVertex();
void SetLength(double length) ; void SetLength(double length);
double GetLength() const; double GetLength() const;

2
src/StdMeshers/StdMeshers_StartEndLength.hxx
View File

@ -41,7 +41,7 @@ class STDMESHERS_EXPORT StdMeshers_StartEndLength: public StdMeshers_Reversible1
StdMeshers_StartEndLength(int hypId, SMESH_Gen * gen); StdMeshers_StartEndLength(int hypId, SMESH_Gen * gen);
virtual ~ StdMeshers_StartEndLength(); virtual ~ StdMeshers_StartEndLength();
void SetLength(double length, bool isStartLength) ; void SetLength(double length, bool isStartLength);
double GetLength(bool isStartLength) const; double GetLength(bool isStartLength) const;

20
src/StdMeshers/StdMeshers_ViscousLayers.cxx
View File

@ -440,7 +440,7 @@ namespace VISCOUS_3D
std::string DumpFlags() const; // debug std::string DumpFlags() const; // debug
void SetNewLength( double len, _EdgesOnShape& eos, SMESH_MesherHelper& helper ); void SetNewLength( double len, _EdgesOnShape& eos, SMESH_MesherHelper& helper );
bool SetNewLength2d( Handle(Geom_Surface)& /*surface*/, bool SetNewLength2d( Handle(Geom_Surface)& surface,
const TopoDS_Face& F, const TopoDS_Face& F,
_EdgesOnShape& eos, _EdgesOnShape& eos,
SMESH_MesherHelper& helper ); SMESH_MesherHelper& helper );
@ -451,7 +451,7 @@ namespace VISCOUS_3D
void Block( _SolidData& data ); void Block( _SolidData& data );
void InvalidateStep( size_t curStep, const _EdgesOnShape& eos, bool restoreLength=false ); void InvalidateStep( size_t curStep, const _EdgesOnShape& eos, bool restoreLength=false );
void ChooseSmooFunction(const set< TGeomID >& concaveVertices, void ChooseSmooFunction(const set< TGeomID >& concaveVertices,
const TNode2Edge& /*n2eMap*/); const TNode2Edge& n2eMap);
void SmoothPos( const vector< double >& segLen, const double tol ); void SmoothPos( const vector< double >& segLen, const double tol );
int GetSmoothedPos( const double tol ); int GetSmoothedPos( const double tol );
int Smooth(const int step, const bool isConcaveFace, bool findBest); int Smooth(const int step, const bool isConcaveFace, bool findBest);
@ -937,7 +937,7 @@ namespace VISCOUS_3D
bool shiftInside=false); bool shiftInside=false);
bool getFaceNormalAtSingularity(const gp_XY& uv, bool getFaceNormalAtSingularity(const gp_XY& uv,
const TopoDS_Face& face, const TopoDS_Face& face,
SMESH_MesherHelper& /*helper*/, SMESH_MesherHelper& helper,
gp_Dir& normal ); gp_Dir& normal );
gp_XYZ getWeigthedNormal( const _LayerEdge* edge ); gp_XYZ getWeigthedNormal( const _LayerEdge* edge );
gp_XYZ getNormalByOffset( _LayerEdge* edge, gp_XYZ getNormalByOffset( _LayerEdge* edge,
@ -975,15 +975,15 @@ namespace VISCOUS_3D
SMESH_MesherHelper& helper ); SMESH_MesherHelper& helper );
void limitMaxLenByCurvature( _SolidData& data, SMESH_MesherHelper& helper ); void limitMaxLenByCurvature( _SolidData& data, SMESH_MesherHelper& helper );
void limitMaxLenByCurvature( _LayerEdge* e1, _LayerEdge* e2, void limitMaxLenByCurvature( _LayerEdge* e1, _LayerEdge* e2,
_EdgesOnShape& /*eos1*/, _EdgesOnShape& /*eos2*/, _EdgesOnShape& eos1, _EdgesOnShape& eos2,
const bool /*isSmoothable*/ ); const bool isSmoothable );
bool updateNormals( _SolidData& data, SMESH_MesherHelper& helper, int stepNb, double /*stepSize*/ ); bool updateNormals( _SolidData& data, SMESH_MesherHelper& helper, int stepNb, double stepSize );
bool updateNormalsOfConvexFaces( _SolidData& data, bool updateNormalsOfConvexFaces( _SolidData& data,
SMESH_MesherHelper& helper, SMESH_MesherHelper& helper,
int stepNb ); int stepNb );
void updateNormalsOfC1Vertices( _SolidData& data ); void updateNormalsOfC1Vertices( _SolidData& data );
bool updateNormalsOfSmoothed( _SolidData& data, bool updateNormalsOfSmoothed( _SolidData& data,
SMESH_MesherHelper& /*helper*/, SMESH_MesherHelper& helper,
const int nbSteps, const int nbSteps,
const double stepSize ); const double stepSize );
bool isNewNormalOk( _SolidData& data, bool isNewNormalOk( _SolidData& data,
@ -993,7 +993,7 @@ namespace VISCOUS_3D
bool shrink(_SolidData& data); bool shrink(_SolidData& data);
bool prepareEdgeToShrink( _LayerEdge& edge, _EdgesOnShape& eos, bool prepareEdgeToShrink( _LayerEdge& edge, _EdgesOnShape& eos,
SMESH_MesherHelper& helper, SMESH_MesherHelper& helper,
const SMESHDS_SubMesh* /*faceSubMesh*/ ); const SMESHDS_SubMesh* faceSubMesh );
void restoreNoShrink( _LayerEdge& edge ) const; void restoreNoShrink( _LayerEdge& edge ) const;
void fixBadFaces(const TopoDS_Face& F, void fixBadFaces(const TopoDS_Face& F,
SMESH_MesherHelper& helper, SMESH_MesherHelper& helper,
@ -1091,10 +1091,10 @@ namespace VISCOUS_3D
Handle(ShapeAnalysis_Surface)& surface, Handle(ShapeAnalysis_Surface)& surface,
const TopoDS_Face& F, const TopoDS_Face& F,
SMESH_MesherHelper& helper); SMESH_MesherHelper& helper);
bool smoothComplexEdge( _SolidData& /*data*/, bool smoothComplexEdge( _SolidData& data,
Handle(ShapeAnalysis_Surface)& surface, Handle(ShapeAnalysis_Surface)& surface,
const TopoDS_Face& F, const TopoDS_Face& F,
SMESH_MesherHelper& /*helper*/); SMESH_MesherHelper& helper);
gp_XYZ getNormalNormal( const gp_XYZ & normal, gp_XYZ getNormalNormal( const gp_XYZ & normal,
const gp_XYZ& edgeDir); const gp_XYZ& edgeDir);
_LayerEdge* getLEdgeOnV( bool is2nd ) _LayerEdge* getLEdgeOnV( bool is2nd )

2
src/StdMeshers/StdMeshers_ViscousLayers.hxx
View File

@ -106,7 +106,7 @@ public:
* \param theShape - the geometry of interest * \param theShape - the geometry of interest
* \retval bool - true if parameter values have been successfully defined * \retval bool - true if parameter values have been successfully defined
*/ */
virtual bool SetParametersByMesh(const SMESH_Mesh* /*theMesh*/, const TopoDS_Shape& /*theShape*/); virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
/*! /*!
* \brief Initialize my parameter values by default parameters. * \brief Initialize my parameter values by default parameters.

4
src/StdMeshers/StdMeshers_ViscousLayers2D.hxx
View File

@ -62,13 +62,13 @@ public:
* *
* Just return false as this hypothesis does not have parameters values * Just return false as this hypothesis does not have parameters values
*/ */
virtual bool SetParametersByMesh(const SMESH_Mesh* /*theMesh*/, const TopoDS_Shape& /*theShape*/); virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
/*! /*!
* \brief Initialize my parameter values by default parameters. * \brief Initialize my parameter values by default parameters.
* \retval bool - true if parameter values have been successfully defined * \retval bool - true if parameter values have been successfully defined
*/ */
virtual bool SetParametersByDefaults(const TDefaults& /*dflts*/, const SMESH_Mesh* theMesh=0) virtual bool SetParametersByDefaults(const TDefaults& /*dflts*/, const SMESH_Mesh* /*theMesh*/=0)
{ return false; } { return false; }
static const char* GetHypType() { return "ViscousLayers2D"; } static const char* GetHypType() { return "ViscousLayers2D"; }

2
src/StdMeshersGUI/StdMeshersGUI_StdHypothesisCreator.h
View File

@ -63,7 +63,7 @@ protected:
virtual void onReject(); virtual void onReject();
virtual void valueChanged( QWidget* ); virtual void valueChanged( QWidget* );
bool initVariableName(SMESH::SMESH_Hypothesis_var /*theHyp*/, StdParam& theParams, const char* theMethod) const; bool initVariableName(SMESH::SMESH_Hypothesis_var theHyp, StdParam& theParams, const char* theMethod) const;
QWidget* makeReverseEdgesWdg( SMESH::long_array_var edgeIDs, QWidget* makeReverseEdgesWdg( SMESH::long_array_var edgeIDs,
CORBA::String_var shapeEntry) const; CORBA::String_var shapeEntry) const;
void removeOldGroup(const char* oldName, void removeOldGroup(const char* oldName,

2
src/StdMeshers_I/StdMeshers_Arithmetic1D_i.hxx
View File

@ -82,7 +82,7 @@ public:
std::vector< int > & subIDArray ); std::vector< int > & subIDArray );
protected: protected:
virtual std::string getMethodOfParameter(const int paramIndex, int /*nbVars*/) const; virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const;
}; };
#endif #endif

17
src/StdMeshers_I/StdMeshers_CartesianParameters3D_i.hxx
View File

@ -56,15 +56,15 @@ class STDMESHERS_I_EXPORT StdMeshers_CartesianParameters3D_i:
* it's size is \athreshold times less than the size of the initial hexahedron. * it's size is \athreshold times less than the size of the initial hexahedron.
* threshold must be > 1.0 * threshold must be > 1.0
*/ */
void SetSizeThreshold(CORBA::Double threshold) ; void SetSizeThreshold(CORBA::Double threshold);
CORBA::Double GetSizeThreshold(); CORBA::Double GetSizeThreshold();
/*! /*!
* \brief Set node coordinates along an axis (counterd from zero) * \brief Set node coordinates along an axis (counterd from zero)
*/ */
void SetGrid(const SMESH::double_array& coords, void SetGrid(const SMESH::double_array& coords,
CORBA::Short axis) ; CORBA::Short axis);
SMESH::double_array* GetGrid(CORBA::Short axis) ; SMESH::double_array* GetGrid(CORBA::Short axis);
/*! /*!
* \brief Set grid spacing along an axis * \brief Set grid spacing along an axis
@ -77,17 +77,17 @@ class STDMESHERS_I_EXPORT StdMeshers_CartesianParameters3D_i:
*/ */
void SetGridSpacing(const SMESH::string_array& spaceFunctions, void SetGridSpacing(const SMESH::string_array& spaceFunctions,
const SMESH::double_array& internalPoints, const SMESH::double_array& internalPoints,
CORBA::Short axis) ; CORBA::Short axis);
void GetGridSpacing(SMESH::string_array_out xSpaceFunctions, void GetGridSpacing(SMESH::string_array_out xSpaceFunctions,
SMESH::double_array_out xInternalPoints, SMESH::double_array_out xInternalPoints,
CORBA::Short axis) ; CORBA::Short axis);
/*! /*!
* Set custom direction of axes * Set custom direction of axes
*/ */
void SetAxesDirs(const SMESH::DirStruct& x, void SetAxesDirs(const SMESH::DirStruct& x,
const SMESH::DirStruct& y, const SMESH::DirStruct& y,
const SMESH::DirStruct& z) ; const SMESH::DirStruct& z);
void GetAxesDirs(SMESH::DirStruct& x, void GetAxesDirs(SMESH::DirStruct& x,
SMESH::DirStruct& y, SMESH::DirStruct& y,
SMESH::DirStruct& z); SMESH::DirStruct& z);
@ -139,7 +139,7 @@ class STDMESHERS_I_EXPORT StdMeshers_CartesianParameters3D_i:
CORBA::Boolean isOrthogonal, CORBA::Boolean isOrthogonal,
SMESH::DirStruct& x, SMESH::DirStruct& x,
SMESH::DirStruct& y, SMESH::DirStruct& y,
SMESH::DirStruct& z) ; SMESH::DirStruct& z);
/*! /*!
* \brief Compute node coordinates by spacing functions * \brief Compute node coordinates by spacing functions
* \param x0 - lower coordinate * \param x0 - lower coordinate
@ -152,8 +152,7 @@ class STDMESHERS_I_EXPORT StdMeshers_CartesianParameters3D_i:
CORBA::Double x1, CORBA::Double x1,
const SMESH::string_array& spaceFuns, const SMESH::string_array& spaceFuns,
const SMESH::double_array& points, const SMESH::double_array& points,
const char* axisName ) const char* axisName );
;
// Get implementation // Get implementation
::StdMeshers_CartesianParameters3D* GetImpl(); ::StdMeshers_CartesianParameters3D* GetImpl();

3
src/StdMeshers_I/StdMeshers_Deflection1D_i.hxx
View File

@ -54,8 +54,7 @@ public:
virtual ~StdMeshers_Deflection1D_i(); virtual ~StdMeshers_Deflection1D_i();
// Set deflection // Set deflection
void SetDeflection( CORBA::Double theLength ) void SetDeflection( CORBA::Double theLength );
;
// Get deflection // Get deflection
CORBA::Double GetDeflection(); CORBA::Double GetDeflection();

6
src/StdMeshers_I/StdMeshers_FixedPoints1D_i.hxx
View File

@ -52,10 +52,8 @@ public:
// (additionally it is neecessary to check orientation of edges and // (additionally it is neecessary to check orientation of edges and
// create list of reversed edges if it is needed) and sets numbers // create list of reversed edges if it is needed) and sets numbers
// of segments between given points (default values are equals 1) // of segments between given points (default values are equals 1)
void SetPoints(const SMESH::double_array& listParams) void SetPoints(const SMESH::double_array& listParams);
; void SetNbSegments(const SMESH::long_array& listNbSeg);
void SetNbSegments(const SMESH::long_array& listNbSeg)
;
// Returns list of point's parameters // Returns list of point's parameters
SMESH::double_array* GetPoints(); SMESH::double_array* GetPoints();

4
src/StdMeshers_I/StdMeshers_Geometric1D_i.hxx
View File

@ -49,8 +49,8 @@ class STDMESHERS_I_EXPORT StdMeshers_Geometric1D_i:
StdMeshers_Geometric1D_i( PortableServer::POA_ptr thePOA, StdMeshers_Geometric1D_i( PortableServer::POA_ptr thePOA,
::SMESH_Gen* theGenImpl ); ::SMESH_Gen* theGenImpl );
void SetStartLength(CORBA::Double length) ; void SetStartLength(CORBA::Double length);
void SetCommonRatio(CORBA::Double factor) ; void SetCommonRatio(CORBA::Double factor);
CORBA::Double GetStartLength(); CORBA::Double GetStartLength();
CORBA::Double GetCommonRatio(); CORBA::Double GetCommonRatio();

6
src/StdMeshers_I/StdMeshers_LocalLength_i.hxx
View File

@ -54,11 +54,9 @@ public:
virtual ~StdMeshers_LocalLength_i(); virtual ~StdMeshers_LocalLength_i();
// Set length // Set length
void SetLength( CORBA::Double theLength ) void SetLength( CORBA::Double theLength );
;
// Set precision // Set precision
void SetPrecision( CORBA::Double thePrecision ) void SetPrecision( CORBA::Double thePrecision );
;
// Get length // Get length
CORBA::Double GetLength(); CORBA::Double GetLength();

3
src/StdMeshers_I/StdMeshers_MaxElementArea_i.hxx
View File

@ -52,8 +52,7 @@ public:
virtual ~StdMeshers_MaxElementArea_i(); virtual ~StdMeshers_MaxElementArea_i();
// Set maximum element area // Set maximum element area
void SetMaxElementArea( CORBA::Double theArea ) void SetMaxElementArea( CORBA::Double theArea );
;
// Get maximum element area // Get maximum element area
CORBA::Double GetMaxElementArea(); CORBA::Double GetMaxElementArea();

6
src/StdMeshers_I/StdMeshers_MaxLength_i.hxx
View File

@ -49,13 +49,11 @@ public:
virtual ~StdMeshers_MaxLength_i(); virtual ~StdMeshers_MaxLength_i();
// Set length // Set length
void SetLength( CORBA::Double theLength ) void SetLength( CORBA::Double theLength );
;
// Set precision // Set precision
// Sets preestimation flag // Sets preestimation flag
void SetUsePreestimatedLength( CORBA::Boolean toUse) void SetUsePreestimatedLength( CORBA::Boolean toUse);
;
// Get length // Get length
CORBA::Double GetLength(); CORBA::Double GetLength();

3
src/StdMeshers_I/StdMeshers_NumberOfLayers_i.hxx
View File

@ -56,8 +56,7 @@ public:
virtual ~StdMeshers_NumberOfLayers_i(); virtual ~StdMeshers_NumberOfLayers_i();
// Sets <number of segments> parameter value // Sets <number of segments> parameter value
void SetNumberOfLayers(CORBA::Long numberOfLayers) void SetNumberOfLayers(CORBA::Long numberOfLayers);
;
// Returns <number of layers> parameter value // Returns <number of layers> parameter value
CORBA::Long GetNumberOfLayers(); CORBA::Long GetNumberOfLayers();

12
src/StdMeshers_I/StdMeshers_NumberOfSegments_i.cxx
View File

@ -76,7 +76,6 @@ StdMeshers_NumberOfSegments_i::~StdMeshers_NumberOfSegments_i()
SMESH::double_array* StdMeshers_NumberOfSegments_i::BuildDistributionExpr( const char* func, SMESH::double_array* StdMeshers_NumberOfSegments_i::BuildDistributionExpr( const char* func,
CORBA::Long nbSeg, CORBA::Long nbSeg,
CORBA::Long conv ) CORBA::Long conv )
{ {
ASSERT( myBaseImpl ); ASSERT( myBaseImpl );
try try
@ -98,7 +97,6 @@ SMESH::double_array*
StdMeshers_NumberOfSegments_i::BuildDistributionTab( const SMESH::double_array& func, StdMeshers_NumberOfSegments_i::BuildDistributionTab( const SMESH::double_array& func,
CORBA::Long nbSeg, CORBA::Long nbSeg,
CORBA::Long conv ) CORBA::Long conv )
{ {
ASSERT( myBaseImpl ); ASSERT( myBaseImpl );
@ -130,7 +128,6 @@ StdMeshers_NumberOfSegments_i::BuildDistributionTab( const SMESH::double_array&
//============================================================================= //=============================================================================
void StdMeshers_NumberOfSegments_i::SetNumberOfSegments( CORBA::Long theSegmentsNumber ) void StdMeshers_NumberOfSegments_i::SetNumberOfSegments( CORBA::Long theSegmentsNumber )
{ {
ASSERT( myBaseImpl ); ASSERT( myBaseImpl );
try { try {
@ -165,7 +162,6 @@ CORBA::Long StdMeshers_NumberOfSegments_i::GetNumberOfSegments()
//============================================================================= //=============================================================================
void StdMeshers_NumberOfSegments_i::SetDistrType(CORBA::Long typ) void StdMeshers_NumberOfSegments_i::SetDistrType(CORBA::Long typ)
{ {
ASSERT( myBaseImpl ); ASSERT( myBaseImpl );
try { try {
@ -203,7 +199,6 @@ CORBA::Long StdMeshers_NumberOfSegments_i::GetDistrType()
//============================================================================= //=============================================================================
void StdMeshers_NumberOfSegments_i::SetScaleFactor( CORBA::Double theScaleFactor ) void StdMeshers_NumberOfSegments_i::SetScaleFactor( CORBA::Double theScaleFactor )
{ {
ASSERT( myBaseImpl ); ASSERT( myBaseImpl );
try { try {
@ -226,7 +221,6 @@ void StdMeshers_NumberOfSegments_i::SetScaleFactor( CORBA::Double theScaleFactor
//============================================================================= //=============================================================================
CORBA::Double StdMeshers_NumberOfSegments_i::GetScaleFactor() CORBA::Double StdMeshers_NumberOfSegments_i::GetScaleFactor()
{ {
ASSERT( myBaseImpl ); ASSERT( myBaseImpl );
double scale; double scale;
@ -246,7 +240,6 @@ CORBA::Double StdMeshers_NumberOfSegments_i::GetScaleFactor()
//============================================================================= //=============================================================================
void StdMeshers_NumberOfSegments_i::SetTableFunction(const SMESH::double_array& table) void StdMeshers_NumberOfSegments_i::SetTableFunction(const SMESH::double_array& table)
{ {
ASSERT( myBaseImpl ); ASSERT( myBaseImpl );
std::vector<double> tbl( table.length() ); std::vector<double> tbl( table.length() );
@ -269,7 +262,6 @@ void StdMeshers_NumberOfSegments_i::SetTableFunction(const SMESH::double_array&
//============================================================================= //=============================================================================
SMESH::double_array* StdMeshers_NumberOfSegments_i::GetTableFunction() SMESH::double_array* StdMeshers_NumberOfSegments_i::GetTableFunction()
{ {
ASSERT( myBaseImpl ); ASSERT( myBaseImpl );
const std::vector<double>* tbl; const std::vector<double>* tbl;
@ -292,7 +284,6 @@ SMESH::double_array* StdMeshers_NumberOfSegments_i::GetTableFunction()
//============================================================================= //=============================================================================
void StdMeshers_NumberOfSegments_i::SetExpressionFunction(const char* expr) void StdMeshers_NumberOfSegments_i::SetExpressionFunction(const char* expr)
{ {
ASSERT( myBaseImpl ); ASSERT( myBaseImpl );
try { try {
@ -312,7 +303,6 @@ void StdMeshers_NumberOfSegments_i::SetExpressionFunction(const char* expr)
//============================================================================= //=============================================================================
char* StdMeshers_NumberOfSegments_i::GetExpressionFunction() char* StdMeshers_NumberOfSegments_i::GetExpressionFunction()
{ {
ASSERT( myBaseImpl ); ASSERT( myBaseImpl );
const char* expr; const char* expr;
@ -332,7 +322,6 @@ char* StdMeshers_NumberOfSegments_i::GetExpressionFunction()
//============================================================================= //=============================================================================
void StdMeshers_NumberOfSegments_i::SetConversionMode(CORBA::Long conv ) void StdMeshers_NumberOfSegments_i::SetConversionMode(CORBA::Long conv )
{ {
ASSERT( myBaseImpl ); ASSERT( myBaseImpl );
try { try {
@ -352,7 +341,6 @@ void StdMeshers_NumberOfSegments_i::SetConversionMode(CORBA::Long conv )
//============================================================================= //=============================================================================
CORBA::Long StdMeshers_NumberOfSegments_i::ConversionMode() CORBA::Long StdMeshers_NumberOfSegments_i::ConversionMode()
{ {
ASSERT( myBaseImpl ); ASSERT( myBaseImpl );
int conv; int conv;

36
src/StdMeshers_I/StdMeshers_NumberOfSegments_i.hxx
View File

@ -54,50 +54,38 @@ public:
virtual ~StdMeshers_NumberOfSegments_i(); virtual ~StdMeshers_NumberOfSegments_i();
// Builds point distribution according to passed function // Builds point distribution according to passed function
SMESH::double_array* BuildDistributionExpr( const char*, CORBA::Long, CORBA::Long ) SMESH::double_array* BuildDistributionExpr( const char*, CORBA::Long, CORBA::Long );
; SMESH::double_array* BuildDistributionTab( const SMESH::double_array&, CORBA::Long, CORBA::Long );
SMESH::double_array* BuildDistributionTab( const SMESH::double_array&, CORBA::Long, CORBA::Long )
;
// Set number of segments // Set number of segments
void SetNumberOfSegments( CORBA::Long theSegmentsNumber ) void SetNumberOfSegments( CORBA::Long theSegmentsNumber );
;
// Get number of segments // Get number of segments
CORBA::Long GetNumberOfSegments(); CORBA::Long GetNumberOfSegments();
// Set distribution type // Set distribution type
void SetDistrType(CORBA::Long typ) void SetDistrType(CORBA::Long typ);
;
// Get distribution type // Get distribution type
CORBA::Long GetDistrType(); CORBA::Long GetDistrType();
// Set scalar factor // Set scalar factor
void SetScaleFactor( CORBA::Double theScaleFactor ) void SetScaleFactor( CORBA::Double theScaleFactor );
;
// Get scalar factor // Get scalar factor
CORBA::Double GetScaleFactor() CORBA::Double GetScaleFactor();
;
// Set table function for distribution DT_TabFunc // Set table function for distribution DT_TabFunc
void SetTableFunction(const SMESH::double_array& table) void SetTableFunction(const SMESH::double_array& table);
;
// Get table function for distribution DT_TabFunc // Get table function for distribution DT_TabFunc
SMESH::double_array* GetTableFunction() SMESH::double_array* GetTableFunction();
;
// Set expression function for distribution DT_ExprFunc // Set expression function for distribution DT_ExprFunc
void SetExpressionFunction(const char* expr) void SetExpressionFunction(const char* expr);
;
// Get expression function for distribution DT_ExprFunc // Get expression function for distribution DT_ExprFunc
char* GetExpressionFunction() char* GetExpressionFunction();
;
// Set the exponent mode on/off // Set the exponent mode on/off
void SetConversionMode( CORBA::Long conv ) void SetConversionMode( CORBA::Long conv );
;
// Returns true if the exponent mode is set // Returns true if the exponent mode is set
CORBA::Long ConversionMode() CORBA::Long ConversionMode();
;
// Get implementation // Get implementation
::StdMeshers_NumberOfSegments* GetImpl(); ::StdMeshers_NumberOfSegments* GetImpl();

2
src/StdMeshers_I/StdMeshers_Prism_3D_i.hxx
View File

@ -79,7 +79,7 @@ public:
::StdMeshers_RadialPrism_3D* GetImpl(); ::StdMeshers_RadialPrism_3D* GetImpl();
// Return true if the algorithm is applicable to a shape // Return true if the algorithm is applicable to a shape
static bool IsApplicable(const TopoDS_Shape &S, bool toCheckAll, int /*dim*/); static bool IsApplicable(const TopoDS_Shape &S, bool toCheckAll, int dim);
}; };

3
src/StdMeshers_I/StdMeshers_ProjectionSource1D_i.cxx
View File

@ -74,7 +74,6 @@ StdMeshers_ProjectionSource1D_i::~StdMeshers_ProjectionSource1D_i()
//============================================================================= //=============================================================================
void StdMeshers_ProjectionSource1D_i::SetSourceEdge(GEOM::GEOM_Object_ptr edge) void StdMeshers_ProjectionSource1D_i::SetSourceEdge(GEOM::GEOM_Object_ptr edge)
{ {
ASSERT( myBaseImpl ); ASSERT( myBaseImpl );
try { try {
@ -98,7 +97,6 @@ void StdMeshers_ProjectionSource1D_i::SetSourceEdge(GEOM::GEOM_Object_ptr edge)
void StdMeshers_ProjectionSource1D_i::SetVertexAssociation(GEOM::GEOM_Object_ptr sourceVertex, void StdMeshers_ProjectionSource1D_i::SetVertexAssociation(GEOM::GEOM_Object_ptr sourceVertex,
GEOM::GEOM_Object_ptr targetVertex) GEOM::GEOM_Object_ptr targetVertex)
{ {
ASSERT( myBaseImpl ); ASSERT( myBaseImpl );
try { try {
@ -124,7 +122,6 @@ void StdMeshers_ProjectionSource1D_i::SetVertexAssociation(GEOM::GEOM_Object_ptr
//============================================================================= //=============================================================================
void StdMeshers_ProjectionSource1D_i::SetSourceMesh(SMESH::SMESH_Mesh_ptr theMesh) void StdMeshers_ProjectionSource1D_i::SetSourceMesh(SMESH::SMESH_Mesh_ptr theMesh)
{ {
ASSERT( myBaseImpl ); ASSERT( myBaseImpl );

13
src/StdMeshers_I/StdMeshers_ProjectionSource1D_i.hxx
View File

@ -59,8 +59,7 @@ public:
/*! /*!
* Sets source <edge> or a group containing edges to take a mesh pattern from * Sets source <edge> or a group containing edges to take a mesh pattern from
*/ */
void SetSourceEdge(GEOM::GEOM_Object_ptr edge) void SetSourceEdge(GEOM::GEOM_Object_ptr edge);
;
/*! /*!
* Returns the source edge or a group containing edges * Returns the source edge or a group containing edges
@ -70,8 +69,7 @@ public:
/*! /*!
* Sets source <mesh> to take a mesh pattern from * Sets source <mesh> to take a mesh pattern from
*/ */
void SetSourceMesh(SMESH::SMESH_Mesh_ptr mesh) void SetSourceMesh(SMESH::SMESH_Mesh_ptr mesh);
;
/*! /*!
* Return source mesh * Return source mesh
@ -83,8 +81,7 @@ public:
* This parameter is optional * This parameter is optional
*/ */
void SetVertexAssociation(GEOM::GEOM_Object_ptr sourceVertex, void SetVertexAssociation(GEOM::GEOM_Object_ptr sourceVertex,
GEOM::GEOM_Object_ptr targetVertex) GEOM::GEOM_Object_ptr targetVertex);
;
/*! /*!
* Returns the vertex associated with the target vertex. * Returns the vertex associated with the target vertex.
@ -113,11 +110,11 @@ public:
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter // Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray, virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & /*subIDArray*/ ) const; std::vector< int > & subIDArray ) const;
// Set new geometry instead of that returned by getObjectsDependOn() // Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray, virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & /*subIDArray*/ ); std::vector< int > & subIDArray );
private: private:
// keep entries because the same shape can be published several times with // 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 // different names and in this case a correct name can't be restored by a TopoDS_Shape

3
src/StdMeshers_I/StdMeshers_ProjectionSource2D_i.cxx
View File

@ -74,7 +74,6 @@ StdMeshers_ProjectionSource2D_i::~StdMeshers_ProjectionSource2D_i()
//============================================================================= //=============================================================================
void StdMeshers_ProjectionSource2D_i::SetSourceFace(GEOM::GEOM_Object_ptr face) void StdMeshers_ProjectionSource2D_i::SetSourceFace(GEOM::GEOM_Object_ptr face)
{ {
ASSERT( myBaseImpl ); ASSERT( myBaseImpl );
try { try {
@ -96,7 +95,6 @@ void StdMeshers_ProjectionSource2D_i::SetSourceFace(GEOM::GEOM_Object_ptr face)
//============================================================================= //=============================================================================
void StdMeshers_ProjectionSource2D_i::SetSourceMesh(SMESH::SMESH_Mesh_ptr theMesh) void StdMeshers_ProjectionSource2D_i::SetSourceMesh(SMESH::SMESH_Mesh_ptr theMesh)
{ {
ASSERT( myBaseImpl ); ASSERT( myBaseImpl );
@ -147,7 +145,6 @@ void StdMeshers_ProjectionSource2D_i::SetVertexAssociation(GEOM::GEOM_Object_ptr
GEOM::GEOM_Object_ptr sourceVertex2, GEOM::GEOM_Object_ptr sourceVertex2,
GEOM::GEOM_Object_ptr targetVertex1, GEOM::GEOM_Object_ptr targetVertex1,
GEOM::GEOM_Object_ptr targetVertex2) GEOM::GEOM_Object_ptr targetVertex2)
{ {
ASSERT( myBaseImpl ); ASSERT( myBaseImpl );
try { try {

13
src/StdMeshers_I/StdMeshers_ProjectionSource2D_i.hxx
View File

@ -59,8 +59,7 @@ public:
/*! /*!
* Sets a source <face> to take a mesh pattern from * Sets a source <face> to take a mesh pattern from
*/ */
void SetSourceFace(GEOM::GEOM_Object_ptr face) void SetSourceFace(GEOM::GEOM_Object_ptr face);
;
/*! /*!
* Returns the source face * Returns the source face
@ -70,8 +69,7 @@ public:
/*! /*!
* Sets source <mesh> to take a mesh pattern from * Sets source <mesh> to take a mesh pattern from
*/ */
void SetSourceMesh(SMESH::SMESH_Mesh_ptr mesh) void SetSourceMesh(SMESH::SMESH_Mesh_ptr mesh);
;
/*! /*!
* Return source mesh * Return source mesh
@ -86,8 +84,7 @@ public:
void SetVertexAssociation(GEOM::GEOM_Object_ptr sourceVertex1, void SetVertexAssociation(GEOM::GEOM_Object_ptr sourceVertex1,
GEOM::GEOM_Object_ptr sourceVertex2, GEOM::GEOM_Object_ptr sourceVertex2,
GEOM::GEOM_Object_ptr targetVertex1, GEOM::GEOM_Object_ptr targetVertex1,
GEOM::GEOM_Object_ptr targetVertex2) GEOM::GEOM_Object_ptr targetVertex2);
;
/*! /*!
* Returns the <i>-th source vertex associated with the <i>-th target vertex. * Returns the <i>-th source vertex associated with the <i>-th target vertex.
@ -118,11 +115,11 @@ public:
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter // Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray, virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & /*subIDArray*/ ) const; std::vector< int > & subIDArray ) const;
// Set new geometry instead of that returned by getObjectsDependOn() // Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray, virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & /*subIDArray*/ ); std::vector< int > & subIDArray );
private: private:
// keep entries because the same shape can be published several times with // 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 // different names and in this case a correct name can't be restored by a TopoDS_Shape

3
src/StdMeshers_I/StdMeshers_ProjectionSource3D_i.cxx
View File

@ -74,7 +74,6 @@ StdMeshers_ProjectionSource3D_i::~StdMeshers_ProjectionSource3D_i()
//============================================================================= //=============================================================================
void StdMeshers_ProjectionSource3D_i::SetSource3DShape(GEOM::GEOM_Object_ptr shape) void StdMeshers_ProjectionSource3D_i::SetSource3DShape(GEOM::GEOM_Object_ptr shape)
{ {
ASSERT( myBaseImpl ); ASSERT( myBaseImpl );
try { try {
@ -97,7 +96,6 @@ void StdMeshers_ProjectionSource3D_i::SetSource3DShape(GEOM::GEOM_Object_ptr sha
//============================================================================= //=============================================================================
void StdMeshers_ProjectionSource3D_i::SetSourceMesh(SMESH::SMESH_Mesh_ptr theMesh) void StdMeshers_ProjectionSource3D_i::SetSourceMesh(SMESH::SMESH_Mesh_ptr theMesh)
{ {
ASSERT( myBaseImpl ); ASSERT( myBaseImpl );
@ -148,7 +146,6 @@ void StdMeshers_ProjectionSource3D_i::SetVertexAssociation(GEOM::GEOM_Object_ptr
GEOM::GEOM_Object_ptr sourceVertex2, GEOM::GEOM_Object_ptr sourceVertex2,
GEOM::GEOM_Object_ptr targetVertex1, GEOM::GEOM_Object_ptr targetVertex1,
GEOM::GEOM_Object_ptr targetVertex2) GEOM::GEOM_Object_ptr targetVertex2)
{ {
ASSERT( myBaseImpl ); ASSERT( myBaseImpl );
try { try {

13
src/StdMeshers_I/StdMeshers_ProjectionSource3D_i.hxx
View File

@ -60,8 +60,7 @@ public:
/*! /*!
* Sets a source <shape> to take a mesh pattern from * Sets a source <shape> to take a mesh pattern from
*/ */
void SetSource3DShape(GEOM::GEOM_Object_ptr shape) void SetSource3DShape(GEOM::GEOM_Object_ptr shape);
;
/*! /*!
* Returns the source shape * Returns the source shape
@ -71,8 +70,7 @@ public:
/*! /*!
* Sets source <mesh> to take a mesh pattern from * Sets source <mesh> to take a mesh pattern from
*/ */
void SetSourceMesh(SMESH::SMESH_Mesh_ptr mesh) void SetSourceMesh(SMESH::SMESH_Mesh_ptr mesh);
;
/*! /*!
* Return source mesh * Return source mesh
@ -87,8 +85,7 @@ public:
void SetVertexAssociation(GEOM::GEOM_Object_ptr sourceVertex1, void SetVertexAssociation(GEOM::GEOM_Object_ptr sourceVertex1,
GEOM::GEOM_Object_ptr sourceVertex2, GEOM::GEOM_Object_ptr sourceVertex2,
GEOM::GEOM_Object_ptr targetVertex1, GEOM::GEOM_Object_ptr targetVertex1,
GEOM::GEOM_Object_ptr targetVertex2) GEOM::GEOM_Object_ptr targetVertex2);
;
/*! /*!
* Returns the <i>-th source vertex associated with the <i>-th target vertex. * Returns the <i>-th source vertex associated with the <i>-th target vertex.
@ -119,11 +116,11 @@ public:
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter // Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & entryArray, virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & /*subIDArray*/ ) const; std::vector< int > & subIDArray ) const;
// Set new geometry instead of that returned by getObjectsDependOn() // Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & entryArray, virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & /*subIDArray*/ ); std::vector< int > & subIDArray );
private: private:
// keep entries because the same shape can be published several times with // keep entries because the same shape can be published several times with

2
src/StdMeshers_I/StdMeshers_Projection_1D_2D_3D_i.hxx
View File

@ -59,7 +59,7 @@ public:
::StdMeshers_Projection_3D* GetImpl(); ::StdMeshers_Projection_3D* GetImpl();
// Return true if the algorithm is applicable to a shape // Return true if the algorithm is applicable to a shape
static bool IsApplicable(const TopoDS_Shape &S, bool toCheckAll, int /*dim*/); static bool IsApplicable(const TopoDS_Shape &S, bool toCheckAll, int dim);
}; };
// ====================================================== // ======================================================

3
src/StdMeshers_I/StdMeshers_SegmentLengthAroundVertex_i.hxx
View File

@ -51,8 +51,7 @@ public:
virtual ~StdMeshers_SegmentLengthAroundVertex_i(); virtual ~StdMeshers_SegmentLengthAroundVertex_i();
// Set length // Set length
void SetLength( CORBA::Double theLength ) void SetLength( CORBA::Double theLength );
;
// Get length // Get length
CORBA::Double GetLength(); CORBA::Double GetLength();

7
src/StdMeshers_I/StdMeshers_StartEndLength_i.hxx
View File

@ -56,14 +56,13 @@ public:
// Set length // Set length
// * OBSOLETE *. Avoid such a way of interface design // * OBSOLETE *. Avoid such a way of interface design
void SetLength( CORBA::Double theLength, CORBA::Boolean theIsStart ) void SetLength( CORBA::Double theLength, CORBA::Boolean theIsStart );
;
// Sets <start segment length> parameter value // Sets <start segment length> parameter value
void SetStartLength( CORBA::Double length) ; void SetStartLength( CORBA::Double length);
// Sets <end segment length> parameter value // Sets <end segment length> parameter value
void SetEndLength( CORBA::Double length) ; void SetEndLength( CORBA::Double length);
// Get length // Get length
CORBA::Double GetLength(CORBA::Boolean theIsStart); CORBA::Double GetLength(CORBA::Boolean theIsStart);

4
src/StdMeshers_I/StdMeshers_ViscousLayers2D_i.cxx
View File

@ -93,7 +93,6 @@ void StdMeshers_ViscousLayers2D_i::SetEdges(const ::SMESH::long_array& edgeIDs,
//================================================================================ //================================================================================
void StdMeshers_ViscousLayers2D_i::SetIgnoreEdges(const ::SMESH::long_array& edgeIDs) void StdMeshers_ViscousLayers2D_i::SetIgnoreEdges(const ::SMESH::long_array& edgeIDs)
{ {
SMESH::TPythonDump pyDump; SMESH::TPythonDump pyDump;
this->SetEdges( edgeIDs, true ); this->SetEdges( edgeIDs, true );
@ -147,7 +146,6 @@ CORBA::Boolean StdMeshers_ViscousLayers2D_i::GetIsToIgnoreEdges()
//================================================================================ //================================================================================
void StdMeshers_ViscousLayers2D_i::SetTotalThickness(::CORBA::Double thickness) void StdMeshers_ViscousLayers2D_i::SetTotalThickness(::CORBA::Double thickness)
{ {
if ( thickness < 1e-100 ) if ( thickness < 1e-100 )
THROW_SALOME_CORBA_EXCEPTION( "Invalid thickness", SALOME::BAD_PARAM ); THROW_SALOME_CORBA_EXCEPTION( "Invalid thickness", SALOME::BAD_PARAM );
@ -174,7 +172,6 @@ void StdMeshers_ViscousLayers2D_i::SetTotalThickness(::CORBA::Double thickness)
//================================================================================ //================================================================================
void StdMeshers_ViscousLayers2D_i::SetNumberLayers(::CORBA::Short nb) void StdMeshers_ViscousLayers2D_i::SetNumberLayers(::CORBA::Short nb)
{ {
if ( nb < 1 ) if ( nb < 1 )
THROW_SALOME_CORBA_EXCEPTION( "Invalid number of layers", SALOME::BAD_PARAM ); THROW_SALOME_CORBA_EXCEPTION( "Invalid number of layers", SALOME::BAD_PARAM );
@ -201,7 +198,6 @@ void StdMeshers_ViscousLayers2D_i::SetNumberLayers(::CORBA::Short nb)
//================================================================================ //================================================================================
void StdMeshers_ViscousLayers2D_i::SetStretchFactor(::CORBA::Double factor) void StdMeshers_ViscousLayers2D_i::SetStretchFactor(::CORBA::Double factor)
{ {
if ( factor < 1 ) if ( factor < 1 )
THROW_SALOME_CORBA_EXCEPTION( "Invalid stretch factor, it must be >= 1.0", SALOME::BAD_PARAM ); THROW_SALOME_CORBA_EXCEPTION( "Invalid stretch factor, it must be >= 1.0", SALOME::BAD_PARAM );

12
src/StdMeshers_I/StdMeshers_ViscousLayers2D_i.hxx
View File

@ -47,7 +47,7 @@ class STDMESHERS_I_EXPORT StdMeshers_ViscousLayers2D_i:
// Destructor // Destructor
virtual ~StdMeshers_ViscousLayers2D_i(); virtual ~StdMeshers_ViscousLayers2D_i();
void SetIgnoreEdges(const SMESH::long_array& edgeIDs) ; void SetIgnoreEdges(const SMESH::long_array& edgeIDs);
SMESH::long_array* GetIgnoreEdges(); SMESH::long_array* GetIgnoreEdges();
void SetEdges(const SMESH::long_array& edgeIDs, void SetEdges(const SMESH::long_array& edgeIDs,
@ -55,13 +55,13 @@ class STDMESHERS_I_EXPORT StdMeshers_ViscousLayers2D_i:
SMESH::long_array* GetEdges(); SMESH::long_array* GetEdges();
CORBA::Boolean GetIsToIgnoreEdges(); CORBA::Boolean GetIsToIgnoreEdges();
void SetTotalThickness(::CORBA::Double thickness) ; void SetTotalThickness(::CORBA::Double thickness);
::CORBA::Double GetTotalThickness(); ::CORBA::Double GetTotalThickness();
void SetNumberLayers(::CORBA::Short nb) ; void SetNumberLayers(::CORBA::Short nb);
::CORBA::Short GetNumberLayers(); ::CORBA::Short GetNumberLayers();
void SetStretchFactor(::CORBA::Double factor) ; void SetStretchFactor(::CORBA::Double factor);
::CORBA::Double GetStretchFactor(); ::CORBA::Double GetStretchFactor();
void SetGroupName(const char* name); void SetGroupName(const char* name);
@ -82,11 +82,11 @@ class STDMESHERS_I_EXPORT StdMeshers_ViscousLayers2D_i:
// Methods for copying mesh definition to other geometry // Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter // Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/, virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const; std::vector< int > & subIDArray ) const;
// Set new geometry instead of that returned by getObjectsDependOn() // Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/, virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ); std::vector< int > & subIDArray );
}; };

5
src/StdMeshers_I/StdMeshers_ViscousLayers_i.cxx
View File

@ -76,7 +76,6 @@ StdMeshers_ViscousLayers_i::~StdMeshers_ViscousLayers_i()
void StdMeshers_ViscousLayers_i::SetFaces(const ::SMESH::long_array& faceIDs, void StdMeshers_ViscousLayers_i::SetFaces(const ::SMESH::long_array& faceIDs,
CORBA::Boolean toIgnore) CORBA::Boolean toIgnore)
{ {
vector<int> ids( faceIDs.length() ); vector<int> ids( faceIDs.length() );
for ( unsigned i = 0; i < ids.size(); ++i ) for ( unsigned i = 0; i < ids.size(); ++i )
@ -135,7 +134,6 @@ CORBA::Boolean StdMeshers_ViscousLayers_i::GetIsToIgnoreFaces()
//================================================================================ //================================================================================
void StdMeshers_ViscousLayers_i::SetIgnoreFaces(const ::SMESH::long_array& faceIDs) void StdMeshers_ViscousLayers_i::SetIgnoreFaces(const ::SMESH::long_array& faceIDs)
{ {
vector<int> ids( faceIDs.length() ); vector<int> ids( faceIDs.length() );
for ( unsigned i = 0; i < ids.size(); ++i ) for ( unsigned i = 0; i < ids.size(); ++i )
@ -152,7 +150,6 @@ void StdMeshers_ViscousLayers_i::SetIgnoreFaces(const ::SMESH::long_array& faceI
//================================================================================ //================================================================================
void StdMeshers_ViscousLayers_i::SetTotalThickness(::CORBA::Double thickness) void StdMeshers_ViscousLayers_i::SetTotalThickness(::CORBA::Double thickness)
{ {
if ( thickness < 1e-100 ) if ( thickness < 1e-100 )
THROW_SALOME_CORBA_EXCEPTION( "Invalid thickness", SALOME::BAD_PARAM ); THROW_SALOME_CORBA_EXCEPTION( "Invalid thickness", SALOME::BAD_PARAM );
@ -179,7 +176,6 @@ void StdMeshers_ViscousLayers_i::SetTotalThickness(::CORBA::Double thickness)
//================================================================================ //================================================================================
void StdMeshers_ViscousLayers_i::SetNumberLayers(::CORBA::Short nb) void StdMeshers_ViscousLayers_i::SetNumberLayers(::CORBA::Short nb)
{ {
if ( nb < 1 ) if ( nb < 1 )
THROW_SALOME_CORBA_EXCEPTION( "Invalid number of layers", SALOME::BAD_PARAM ); THROW_SALOME_CORBA_EXCEPTION( "Invalid number of layers", SALOME::BAD_PARAM );
@ -206,7 +202,6 @@ void StdMeshers_ViscousLayers_i::SetNumberLayers(::CORBA::Short nb)
//================================================================================ //================================================================================
void StdMeshers_ViscousLayers_i::SetStretchFactor(::CORBA::Double factor) void StdMeshers_ViscousLayers_i::SetStretchFactor(::CORBA::Double factor)
{ {
if ( factor < 1 ) if ( factor < 1 )
THROW_SALOME_CORBA_EXCEPTION( "Invalid stretch factor, it must be >= 1.0", SALOME::BAD_PARAM ); THROW_SALOME_CORBA_EXCEPTION( "Invalid stretch factor, it must be >= 1.0", SALOME::BAD_PARAM );

14
src/StdMeshers_I/StdMeshers_ViscousLayers_i.hxx
View File

@ -47,21 +47,21 @@ class STDMESHERS_I_EXPORT StdMeshers_ViscousLayers_i:
// Destructor // Destructor
virtual ~StdMeshers_ViscousLayers_i(); virtual ~StdMeshers_ViscousLayers_i();
void SetIgnoreFaces(const ::SMESH::long_array& faceIDs) ; void SetIgnoreFaces(const ::SMESH::long_array& faceIDs);
SMESH::long_array* GetIgnoreFaces(); SMESH::long_array* GetIgnoreFaces();
void SetFaces(const SMESH::long_array& faceIDs, void SetFaces(const SMESH::long_array& faceIDs,
CORBA::Boolean toIgnore) ; CORBA::Boolean toIgnore);
SMESH::long_array* GetFaces(); SMESH::long_array* GetFaces();
CORBA::Boolean GetIsToIgnoreFaces(); CORBA::Boolean GetIsToIgnoreFaces();
void SetTotalThickness(::CORBA::Double thickness) ; void SetTotalThickness(::CORBA::Double thickness);
::CORBA::Double GetTotalThickness(); ::CORBA::Double GetTotalThickness();
void SetNumberLayers(::CORBA::Short nb) ; void SetNumberLayers(::CORBA::Short nb);
::CORBA::Short GetNumberLayers(); ::CORBA::Short GetNumberLayers();
void SetStretchFactor(::CORBA::Double factor) ; void SetStretchFactor(::CORBA::Double factor);
::CORBA::Double GetStretchFactor(); ::CORBA::Double GetStretchFactor();
void SetMethod( ::StdMeshers::VLExtrusionMethod how ); void SetMethod( ::StdMeshers::VLExtrusionMethod how );
@ -80,11 +80,11 @@ class STDMESHERS_I_EXPORT StdMeshers_ViscousLayers_i:
// Methods for copying mesh definition to other geometry // Methods for copying mesh definition to other geometry
// Return geometry this hypothesis depends on. Return false if there is no geometry parameter // Return geometry this hypothesis depends on. Return false if there is no geometry parameter
virtual bool getObjectsDependOn( std::vector< std::string > & /*entryArray*/, virtual bool getObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ) const; std::vector< int > & subIDArray ) const;
// Set new geometry instead of that returned by getObjectsDependOn() // Set new geometry instead of that returned by getObjectsDependOn()
virtual bool setObjectsDependOn( std::vector< std::string > & /*entryArray*/, virtual bool setObjectsDependOn( std::vector< std::string > & entryArray,
std::vector< int > & subIDArray ); std::vector< int > & subIDArray );
protected: protected:
virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const; virtual std::string getMethodOfParameter(const int paramIndex, int nbVars) const;

1
src/StdMeshers_I/StdMeshers_i.cxx
View File

@ -253,7 +253,6 @@ STDMESHERS_I_EXPORT
aCreator = new StdHypothesisCreator_i<StdMeshers_PolygonPerFace_2D_i>; aCreator = new StdHypothesisCreator_i<StdMeshers_PolygonPerFace_2D_i>;
else if (strcmp(aHypName, "PolyhedronPerSolid_3D") == 0) else if (strcmp(aHypName, "PolyhedronPerSolid_3D") == 0)
aCreator = new StdHypothesisCreator_i<StdMeshers_PolyhedronPerSolid_3D_i>; aCreator = new StdHypothesisCreator_i<StdMeshers_PolyhedronPerSolid_3D_i>;
//else ;
return aCreator; return aCreator;
} }

7
src/Tools/MeshCut/MeshCut_Maillage.hxx
View File

@ -95,7 +95,7 @@ namespace MESHCUT
void creationGMtype(TYPE_MAILLE tm, std::string nomGMtype); void creationGMtype(TYPE_MAILLE tm, std::string nomGMtype);
void afficheMailles(TYPE_MAILLE tm); void afficheMailles(TYPE_MAILLE tm);
void listeMaillesType(TYPE_MAILLE /*tm*/); void listeMaillesType(TYPE_MAILLE tm);
void listeMaillesTousTypes(); void listeMaillesTousTypes();
void listeMaillesParGM(); void listeMaillesParGM();
void listeMaillesGM(std::string nomGM); void listeMaillesGM(std::string nomGM);
@ -120,13 +120,12 @@ namespace MESHCUT
// std::string vrmlType(TYPE_MAILLE tm, char *renduAretes, char *renduFaces, float transparence); // std::string vrmlType(TYPE_MAILLE tm, char *renduAretes, char *renduFaces, float transparence);
// void Maillage::creationGMtype(TYPE_MAILLE tm, std::vector<int> CON_TYPE); // void Maillage::creationGMtype(TYPE_MAILLE tm, std::vector<int> CON_TYPE);
int NGLOBAL(TYPE_MAILLE typeMaille, int nlocal); int NGLOBAL(TYPE_MAILLE typeMaille, int nlocal);
int NLOCAL(int nglobal, TYPE_MAILLE /*tm*/); int NLOCAL(int nglobal, TYPE_MAILLE tm);
TYPE_MAILLE TYPE(int nglobal); TYPE_MAILLE TYPE(int nglobal);
void eliminationMailles(TYPE_MAILLE typeMaille, std::vector<int> listeMaillesSuppr); void eliminationMailles(TYPE_MAILLE typeMaille, std::vector<int> listeMaillesSuppr);
// acquisitionTYPE_inputMED appelée par inputMED // acquisitionTYPE_inputMED appelée par inputMED
void void acquisitionTYPE_inputMED(TYPE_MAILLE TYPE, int nTYPE, med_idt fid, char maa[MED_NAME_SIZE + 1], med_int mdim);
acquisitionTYPE_inputMED(TYPE_MAILLE TYPE, int nTYPE, med_idt fid, char maa[MED_NAME_SIZE + 1], med_int /*mdim*/);
// void infoChamps(std::string type, med_entity_type MEM, med_geometry_type MGE, med_idt fid, char *maa, // void infoChamps(std::string type, med_entity_type MEM, med_geometry_type MGE, med_idt fid, char *maa,
// char *nomChamp, med_field_type typeChamp, med_int nCompChamp, std::map<std::string, int> REFGAUSS); // char *nomChamp, med_field_type typeChamp, med_int nCompChamp, std::map<std::string, int> REFGAUSS);