#include "SMESH_MeshEditor_i.hxx"
-#include "DriverMED_R_SMESHDS_Mesh.h"
-#include "DriverMED_W_SMESHDS_Mesh.h"
#include "SMDS_EdgePosition.hxx"
#include "SMDS_ElemIterator.hxx"
#include "SMDS_FacePosition.hxx"
#include "SMDS_MeshVolume.hxx"
#include "SMDS_PolyhedralVolumeOfNodes.hxx"
#include "SMDS_SetIterator.hxx"
-#include "SMDS_SetIterator.hxx"
#include "SMDS_VolumeTool.hxx"
-#include "SMESHDS_Command.hxx"
-#include "SMESHDS_CommandType.hxx"
#include "SMESHDS_Group.hxx"
#include "SMESHDS_GroupOnGeom.hxx"
#include "SMESH_ControlsDef.hxx"
#include "SMESH_Filter_i.hxx"
-#include "SMESH_Filter_i.hxx"
-#include "SMESH_Gen_i.hxx"
#include "SMESH_Gen_i.hxx"
#include "SMESH_Group.hxx"
#include "SMESH_Group_i.hxx"
-#include "SMESH_Group_i.hxx"
-#include "SMESH_MEDMesh_i.hxx"
-#include "SMESH_MeshEditor.hxx"
#include "SMESH_MeshPartDS.hxx"
#include "SMESH_MesherHelper.hxx"
-#include "SMESH_PreMeshInfo.hxx"
-#include "SMESH_PythonDump.hxx"
#include "SMESH_PythonDump.hxx"
#include "SMESH_subMeshEventListener.hxx"
#include "SMESH_subMesh_i.hxx"
-#include "SMESH_subMesh_i.hxx"
-#include "utilities.h"
-#include "Utils_ExceptHandlers.hxx"
-#include "Utils_CorbaException.hxx"
+#include <utilities.h>
+#include <Utils_ExceptHandlers.hxx>
+#include <Utils_CorbaException.hxx>
+#include <SALOMEDS_wrap.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRep_Tool.hxx>
#include <sstream>
#include <limits>
+#include "SMESH_TryCatch.hxx" // include after OCCT headers!
+
#define cast2Node(elem) static_cast<const SMDS_MeshNode*>( elem )
using namespace std;
using SMESH::TPythonDump;
using SMESH::TVar;
-namespace {
+namespace MeshEditor_I {
//=============================================================================
/*!
SMDSAbs_ElementType myPreviewType; // type to show
//!< Constructor
TPreviewMesh(SMDSAbs_ElementType previewElements = SMDSAbs_All) {
- _isShapeToMesh = (_id =_studyId =_idDoc = 0);
+ _isShapeToMesh = (_id =_studyId = 0);
_myMeshDS = new SMESHDS_Mesh( _id, true );
myPreviewType = previewElements;
}
const SMDS_MeshElement * elem =
(aType == SMDSAbs_Node ? aMesh->FindNode(ind) : aMesh->FindElement(ind));
if ( elem && ( aType == SMDSAbs_All || elem->GetType() == aType ))
- aMap.insert( elem );
+ aMap.insert( aMap.end(), elem );
}
}
//================================================================================
return partIOR;
}
-}
+} // namespace MeshEditor_I
+
+using namespace MeshEditor_I;
//=============================================================================
/*!
myMesh_i( theMesh ),
myMesh( &theMesh->GetImpl() ),
myEditor( myMesh ),
- myPreviewMode ( isPreview )
+ myIsPreviewMode ( isPreview ),
+ myPreviewMesh( 0 ),
+ myPreviewEditor( 0 )
{
}
SMESH_MeshEditor_i::~SMESH_MeshEditor_i()
{
+ deleteAuxIDSources();
+ delete myPreviewMesh; myPreviewMesh = 0;
+ delete myPreviewEditor; myPreviewEditor = 0;
}
//================================================================================
void SMESH_MeshEditor_i::initData(bool deleteSearchers)
{
- if ( myPreviewMode ) {
- //myPreviewData = new SMESH::MeshPreviewStruct();
+ if ( myIsPreviewMode ) {
+ if ( myPreviewMesh ) myPreviewMesh->Clear();
}
else {
if ( deleteSearchers )
TSearchersDeleter::Delete();
}
- myEditor.GetError().reset();
+ getEditor().GetError().reset();
+ getEditor().CrearLastCreated();
+}
+//================================================================================
+/*!
+ * \brief Return either myEditor or myPreviewEditor depending on myIsPreviewMode.
+ * WARNING: in preview mode call getPreviewMesh() before getEditor()!
+ */
+//================================================================================
+
+::SMESH_MeshEditor& SMESH_MeshEditor_i::getEditor()
+{
+ if ( myIsPreviewMode && !myPreviewEditor ) {
+ if ( !myPreviewMesh ) getPreviewMesh();
+ myPreviewEditor = new ::SMESH_MeshEditor( myPreviewMesh );
+ }
+ return myIsPreviewMode ? *myPreviewEditor : myEditor;
}
//================================================================================
/*!
- * \brief Now does nothing
+ * \brief Initialize and return myPreviewMesh
+ * \param previewElements - type of elements to show in preview
+ *
+ * WARNING: call it once par a method!
*/
//================================================================================
-void SMESH_MeshEditor_i::storeResult(::SMESH_MeshEditor& )
+TPreviewMesh * SMESH_MeshEditor_i::getPreviewMesh(SMDSAbs_ElementType previewElements)
{
+ if ( !myPreviewMesh || myPreviewMesh->myPreviewType != previewElements )
+ {
+ delete myPreviewEditor;
+ myPreviewEditor = 0;
+ delete myPreviewMesh;
+ myPreviewMesh = new TPreviewMesh( previewElements );
+ }
+ myPreviewMesh->Clear();
+ return myPreviewMesh;
}
+//================================================================================
+/*!
+ * \brief Now does nothing
+ */
+//================================================================================
+
+// void SMESH_MeshEditor_i::storeResult(::SMESH_MeshEditor& )
+// {
+// }
+
//================================================================================
/*!
* Return data of mesh edition preview
SMESH::MeshPreviewStruct* SMESH_MeshEditor_i::GetPreviewData()
{
- const bool hasBadElems = ( myEditor.GetError() && myEditor.GetError()->HasBadElems() );
+ const bool hasBadElems = ( getEditor().GetError() && getEditor().GetError()->HasBadElems() );
- if ( myPreviewMode || hasBadElems ) { // --- MeshPreviewStruct filling ---
+ if ( myIsPreviewMode || hasBadElems ) { // --- MeshPreviewStruct filling ---
list<int> aNodesConnectivity;
typedef map<int, int> TNodesMap;
SMESHDS_Mesh* aMeshDS;
std::auto_ptr< SMESH_MeshPartDS > aMeshPartDS;
if ( hasBadElems ) {
- aMeshPartDS.reset( new SMESH_MeshPartDS( myEditor.GetError()->myBadElements ));
+ aMeshPartDS.reset( new SMESH_MeshPartDS( getEditor().GetError()->myBadElements ));
aMeshDS = aMeshPartDS.get();
}
else {
- aMeshDS = myEditor.GetMeshDS();
+ aMeshDS = getEditor().GetMeshDS();
}
- int nbEdges = aMeshDS->NbEdges();
- int nbFaces = aMeshDS->NbFaces();
- int nbVolum = aMeshDS->NbVolumes();
myPreviewData = new SMESH::MeshPreviewStruct();
myPreviewData->nodesXYZ.length(aMeshDS->NbNodes());
SMDSAbs_ElementType previewType = SMDSAbs_All;
if ( !hasBadElems )
- if (TPreviewMesh * aPreviewMesh = dynamic_cast< TPreviewMesh* >( myEditor.GetMesh() )) {
+ if (TPreviewMesh * aPreviewMesh = dynamic_cast< TPreviewMesh* >( getEditor().GetMesh() )) {
previewType = aPreviewMesh->myPreviewType;
switch ( previewType ) {
- case SMDSAbs_Edge : nbFaces = nbVolum = 0; break;
- case SMDSAbs_Face : nbEdges = nbVolum = 0; break;
- case SMDSAbs_Volume: nbEdges = nbFaces = 0; break;
+ case SMDSAbs_Edge : break;
+ case SMDSAbs_Face : break;
+ case SMDSAbs_Volume: break;
default:;
+ if ( aMeshDS->GetMeshInfo().NbElements() == 0 ) previewType = SMDSAbs_Node;
}
}
- myPreviewData->elementTypes.length(nbEdges + nbFaces + nbVolum);
+ myPreviewData->elementTypes.length( aMeshDS->GetMeshInfo().NbElements( previewType ));
int i = 0, j = 0;
- SMDS_ElemIteratorPtr itMeshElems = aMeshDS->elementsIterator();
+ SMDS_ElemIteratorPtr itMeshElems = aMeshDS->elementsIterator(previewType);
while ( itMeshElems->more() ) {
const SMDS_MeshElement* aMeshElem = itMeshElems->next();
- if ( previewType != SMDSAbs_All && aMeshElem->GetType() != previewType )
- continue;
-
SMDS_ElemIteratorPtr itElemNodes = aMeshElem->nodesIterator();
while ( itElemNodes->more() ) {
const SMDS_MeshNode* aMeshNode =
SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedNodes()
{
SMESH::long_array_var myLastCreatedNodes = new SMESH::long_array();
- const SMESH_SequenceOfElemPtr& aSeq = myEditor.GetLastCreatedNodes();
+ const SMESH_SequenceOfElemPtr& aSeq = getEditor().GetLastCreatedNodes();
myLastCreatedNodes->length( aSeq.Length() );
for (int i = 1; i <= aSeq.Length(); i++)
myLastCreatedNodes[i-1] = aSeq.Value(i)->GetID();
SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedElems()
{
SMESH::long_array_var myLastCreatedElems = new SMESH::long_array();
- const SMESH_SequenceOfElemPtr& aSeq = myEditor.GetLastCreatedElems();
+ const SMESH_SequenceOfElemPtr& aSeq = getEditor().GetLastCreatedElems();
myLastCreatedElems->length( aSeq.Length() );
for ( int i = 1; i <= aSeq.Length(); i++ )
myLastCreatedElems[i-1] = aSeq.Value(i)->GetID();
SMESH::ComputeError* SMESH_MeshEditor_i::GetLastError()
{
- SMESH::ComputeError* errOut = new SMESH::ComputeError;
- SMESH_ComputeErrorPtr& errIn = myEditor.GetError();
+ SMESH::ComputeError_var errOut = new SMESH::ComputeError;
+ SMESH_ComputeErrorPtr& errIn = getEditor().GetError();
if ( errIn && !errIn->IsOK() )
{
errOut->code = -( errIn->myName < 0 ? errIn->myName + 1: errIn->myName ); // -1 -> 0
errOut->subShapeID = -1;
errOut->hasBadMesh = !errIn->myBadElements.empty();
}
- return errOut;
+ else
+ {
+ errOut->code = 0;
+ errOut->subShapeID = -1;
+ errOut->hasBadMesh = false;
+ }
+ return errOut._retn();
}
//=======================================================================
//purpose : Wrap a sequence of ids in a SMESH_IDSource
//=======================================================================
-struct _IDSource : public POA_SMESH::SMESH_IDSource
+struct SMESH_MeshEditor_i::_IDSource : public POA_SMESH::SMESH_IDSource
{
SMESH::long_array _ids;
SMESH::ElementType _type;
SMESH::SMESH_IDSource_ptr SMESH_MeshEditor_i::MakeIDSource(const SMESH::long_array& ids,
SMESH::ElementType type)
{
- _IDSource* anIDSource = new _IDSource;
- anIDSource->_ids = ids;
- anIDSource->_type = type;
- anIDSource->_mesh = myMesh_i->_this();
- SMESH::SMESH_IDSource_var anIDSourceVar = anIDSource->_this();
+ if ( myAuxIDSources.size() > 10 )
+ deleteAuxIDSources();
+
+ _IDSource* idSrc = new _IDSource;
+ idSrc->_mesh = myMesh_i->_this();
+ idSrc->_ids = ids;
+ idSrc->_type = type;
+ myAuxIDSources.push_back( idSrc );
+
+ SMESH::SMESH_IDSource_var anIDSourceVar = idSrc->_this();
return anIDSourceVar._retn();
}
+bool SMESH_MeshEditor_i::IsTemporaryIDSource( SMESH::SMESH_IDSource_ptr& idSource )
+{
+ return SMESH::DownCast<SMESH_MeshEditor_i::_IDSource*>( idSource );
+}
+
+void SMESH_MeshEditor_i::deleteAuxIDSources()
+{
+ std::list< _IDSource* >::iterator idSrcIt = myAuxIDSources.begin();
+ for ( ; idSrcIt != myAuxIDSources.end(); ++idSrcIt )
+ delete *idSrcIt;
+ myAuxIDSources.clear();
+}
+
//=============================================================================
/*!
*
TPythonDump() << "isDone = " << this << ".RemoveElements( " << IDsOfElements << " )";
// Remove Elements
- bool ret = myEditor.Remove( IdList, false );
+ bool ret = getEditor().Remove( IdList, false );
myMesh->GetMeshDS()->Modified();
if ( IDsOfElements.length() )
myMesh->SetIsModified( true ); // issue 0020693
// Update Python script
TPythonDump() << "isDone = " << this << ".RemoveNodes( " << IDsOfNodes << " )";
- bool ret = myEditor.Remove( IdList, true );
+ bool ret = getEditor().Remove( IdList, true );
myMesh->GetMeshDS()->Modified();
if ( IDsOfNodes.length() )
myMesh->SetIsModified( true ); // issue 0020693
// Create filter to find all orphan nodes
SMESH::Controls::Filter::TIdSequence seq;
SMESH::Controls::PredicatePtr predicate( new SMESH::Controls::FreeNodes() );
- SMESH::Controls::Filter::GetElementsId( GetMeshDS(), predicate, seq );
+ SMESH::Controls::Filter::GetElementsId( getMeshDS(), predicate, seq );
// remove orphan nodes (if there are any)
list< int > IdList;
IdList.push_back( seq[i] );
int nbNodesBefore = myMesh->NbNodes();
- myEditor.Remove( IdList, true );
+ getEditor().Remove( IdList, true );
myMesh->GetMeshDS()->Modified();
if ( IdList.size() )
myMesh->SetIsModified( true );
{
initData();
- const SMDS_MeshNode* N = GetMeshDS()->AddNode(x, y, z);
+ const SMDS_MeshNode* N = getMeshDS()->AddNode(x, y, z);
// Update Python script
TPythonDump() << "nodeID = " << this << ".AddNode( "
{
initData();
- const SMDS_MeshNode* aNode = GetMeshDS()->FindNode(IDOfNode);
- SMDS_MeshElement* elem = GetMeshDS()->Add0DElement(aNode);
+ const SMDS_MeshNode* aNode = getMeshDS()->FindNode(IDOfNode);
+ SMDS_MeshElement* elem = getMeshDS()->Add0DElement(aNode);
// Update Python script
TPythonDump() << "elem0d = " << this << ".Add0DElement( " << IDOfNode <<" )";
if ( diameter < std::numeric_limits<double>::min() )
THROW_SALOME_CORBA_EXCEPTION("Invalid diameter", SALOME::BAD_PARAM);
- const SMDS_MeshNode* aNode = GetMeshDS()->FindNode(IDOfNode);
- SMDS_MeshElement* elem = GetMeshDS()->AddBall(aNode, diameter);
+ SMESH_TRY;
+
+ const SMDS_MeshNode* aNode = getMeshDS()->FindNode(IDOfNode);
+ SMDS_MeshElement* elem = getMeshDS()->AddBall(aNode, diameter);
// Update Python script
TPythonDump() << "ballElem = "
if (elem)
return elem->GetID();
+ SMESH_CATCH( SMESH::throwCorbaException );
+
return 0;
}
{
CORBA::Long index1 = IDsOfNodes[0];
CORBA::Long index2 = IDsOfNodes[1];
- elem = GetMeshDS()->AddEdge(GetMeshDS()->FindNode(index1), GetMeshDS()->FindNode(index2));
+ elem = getMeshDS()->AddEdge( getMeshDS()->FindNode(index1),
+ getMeshDS()->FindNode(index2));
// Update Python script
TPythonDump() << "edge = " << this << ".AddEdge([ "
CORBA::Long n1 = IDsOfNodes[0];
CORBA::Long n2 = IDsOfNodes[1];
CORBA::Long n12 = IDsOfNodes[2];
- elem = GetMeshDS()->AddEdge(GetMeshDS()->FindNode(n1),
- GetMeshDS()->FindNode(n2),
- GetMeshDS()->FindNode(n12));
+ elem = getMeshDS()->AddEdge( getMeshDS()->FindNode(n1),
+ getMeshDS()->FindNode(n2),
+ getMeshDS()->FindNode(n12));
// Update Python script
TPythonDump() << "edgeID = " << this << ".AddEdge([ "
<<n1<<", "<<n2<<", "<<n12<<" ])";
std::vector<const SMDS_MeshNode*> nodes (NbNodes);
for (int i = 0; i < NbNodes; i++)
- nodes[i] = GetMeshDS()->FindNode(IDsOfNodes[i]);
+ nodes[i] = getMeshDS()->FindNode(IDsOfNodes[i]);
SMDS_MeshElement* elem = 0;
if (NbNodes == 3) {
- elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2]);
+ elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2]);
}
else if (NbNodes == 4) {
- elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3]);
+ elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3]);
}
else if (NbNodes == 6) {
- elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
+ elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
nodes[4], nodes[5]);
}
else if (NbNodes == 8) {
- elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
+ elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
nodes[4], nodes[5], nodes[6], nodes[7]);
}
else if (NbNodes == 9) {
- elem = GetMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
+ elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
nodes[4], nodes[5], nodes[6], nodes[7], nodes[8] );
}
else if (NbNodes > 2) {
- elem = GetMeshDS()->AddPolygonalFace(nodes);
+ elem = getMeshDS()->AddPolygonalFace(nodes);
}
// Update Python script
int NbNodes = IDsOfNodes.length();
std::vector<const SMDS_MeshNode*> nodes (NbNodes);
for (int i = 0; i < NbNodes; i++)
- nodes[i] = GetMeshDS()->FindNode(IDsOfNodes[i]);
+ nodes[i] = getMeshDS()->FindNode(IDsOfNodes[i]);
- const SMDS_MeshElement* elem = GetMeshDS()->AddPolygonalFace(nodes);
+ const SMDS_MeshElement* elem = getMeshDS()->AddPolygonalFace(nodes);
// Update Python script
TPythonDump() <<"faceID = "<<this<<".AddPolygonalFace( "<<IDsOfNodes<<" )";
int NbNodes = IDsOfNodes.length();
vector< const SMDS_MeshNode*> n(NbNodes);
for(int i=0;i<NbNodes;i++)
- n[i]=GetMeshDS()->FindNode(IDsOfNodes[i]);
+ n[i]= getMeshDS()->FindNode(IDsOfNodes[i]);
SMDS_MeshElement* elem = 0;
switch(NbNodes)
{
- case 4 :elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3]); break;
- case 5 :elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4]); break;
- case 6 :elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5]); break;
- case 8 :elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7]); break;
- case 10:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],
+ case 4 :elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3]); break;
+ case 5 :elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4]); break;
+ case 6 :elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5]); break;
+ case 8 :elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7]); break;
+ case 10:elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],
n[6],n[7],n[8],n[9]);
break;
- case 12:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],
+ case 12:elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],
n[6],n[7],n[8],n[9],n[10],n[11]);
break;
- case 13:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],
+ case 13:elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],
n[7],n[8],n[9],n[10],n[11],n[12]);
break;
- case 15:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],n[8],
+ case 15:elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],n[8],
n[9],n[10],n[11],n[12],n[13],n[14]);
break;
- case 20:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],
+ case 20:elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],
n[8],n[9],n[10],n[11],n[12],n[13],n[14],
n[15],n[16],n[17],n[18],n[19]);
break;
- case 27:elem = GetMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],
+ case 27:elem = getMeshDS()->AddVolume(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],
n[8],n[9],n[10],n[11],n[12],n[13],n[14],
n[15],n[16],n[17],n[18],n[19],
n[20],n[21],n[22],n[23],n[24],n[25],n[26]);
std::vector<const SMDS_MeshNode*> n (NbNodes);
for (int i = 0; i < NbNodes; i++)
{
- const SMDS_MeshNode* aNode = GetMeshDS()->FindNode(IDsOfNodes[i]);
+ const SMDS_MeshNode* aNode = getMeshDS()->FindNode(IDsOfNodes[i]);
if (!aNode) return 0;
n[i] = aNode;
}
for (int j = 0; j < NbFaces; j++)
q[j] = Quantities[j];
- const SMDS_MeshElement* elem = GetMeshDS()->AddPolyhedralVolume(n, q);
+ const SMDS_MeshElement* elem = getMeshDS()->AddPolyhedralVolume(n, q);
// Update Python script
TPythonDump() << "volID = " << this << ".AddPolyhedralVolume( "
* AddPolyhedralVolumeByFaces
*/
//=============================================================================
+
CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolumeByFaces (const SMESH::long_array & IdsOfFaces)
{
initData();
std::vector<int> quantities (NbFaces);
for (int i = 0; i < NbFaces; i++) {
- const SMDS_MeshElement* aFace = GetMeshDS()->FindElement(IdsOfFaces[i]);
+ const SMDS_MeshElement* aFace = getMeshDS()->FindElement(IdsOfFaces[i]);
quantities[i] = aFace->NbNodes();
SMDS_ElemIteratorPtr It = aFace->nodesIterator();
}
}
- const SMDS_MeshElement* elem = GetMeshDS()->AddPolyhedralVolume(poly_nodes, quantities);
+ const SMDS_MeshElement* elem = getMeshDS()->AddPolyhedralVolume(poly_nodes, quantities);
// Update Python script
TPythonDump() << "volID = " << this << ".AddPolyhedralVolumeByFaces( "
return elem ? ( myMesh->SetIsModified( true ), elem->GetID()) : 0;
}
+//=============================================================================
+//
+// \brief Create 0D elements on all nodes of the given object except those
+// nodes on which a 0D element already exists.
+// \param theObject object on whose nodes 0D elements will be created.
+// \param theGroupName optional name of a group to add 0D elements created
+// and/or found on nodes of \a theObject.
+// \return an object (a new group or a temporary SMESH_IDSource) holding
+// ids of new and/or found 0D elements.
+//
+//=============================================================================
+
+SMESH::SMESH_IDSource_ptr
+SMESH_MeshEditor_i::Create0DElementsOnAllNodes(SMESH::SMESH_IDSource_ptr theObject,
+ const char* theGroupName)
+ throw (SALOME::SALOME_Exception)
+{
+ initData();
+
+ SMESH::SMESH_IDSource_var result;
+ TPythonDump pyDump;
+
+ SMESH_TRY;
+
+ TIDSortedElemSet elements, elems0D;
+ if ( idSourceToSet( theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
+ getEditor().Create0DElementsOnAllNodes( elements, elems0D );
+
+ SMESH::long_array_var newElems = new SMESH::long_array;
+ newElems->length( elems0D.size() );
+ TIDSortedElemSet::iterator eIt = elems0D.begin();
+ for ( size_t i = 0; i < elems0D.size(); ++i, ++eIt )
+ newElems[ i ] = (*eIt)->GetID();
+
+ SMESH::SMESH_GroupBase_var groupToFill;
+ if ( theGroupName && strlen( theGroupName ))
+ {
+ // Get existing group named theGroupName
+ SMESH::ListOfGroups_var groups = myMesh_i->GetGroups();
+ for (int i = 0, nbGroups = groups->length(); i < nbGroups; i++ ) {
+ SMESH::SMESH_GroupBase_var group = groups[i];
+ if ( !group->_is_nil() ) {
+ CORBA::String_var name = group->GetName();
+ if ( strcmp( name.in(), theGroupName ) == 0 && group->GetType() == SMESH::ELEM0D ) {
+ groupToFill = group;
+ break;
+ }
+ }
+ }
+ if ( groupToFill->_is_nil() )
+ groupToFill = myMesh_i->CreateGroup( SMESH::ELEM0D, theGroupName );
+ else if ( !SMESH::DownCast< SMESH_Group_i* > ( groupToFill ))
+ groupToFill = myMesh_i->ConvertToStandalone( groupToFill );
+ }
+
+ if ( SMESH_Group_i* group_i = SMESH::DownCast< SMESH_Group_i* > ( groupToFill ))
+ {
+ group_i->Add( newElems );
+ result = SMESH::SMESH_IDSource::_narrow( groupToFill );
+ pyDump << groupToFill;
+ }
+ else
+ {
+ result = MakeIDSource( newElems, SMESH::ELEM0D );
+ pyDump << "elem0DIDs";
+ }
+
+ pyDump << " = " << this << ".Create0DElementsOnAllNodes( "
+ << theObject << ", '" << theGroupName << "' )";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+
+ return result._retn();
+}
+
//=============================================================================
/*!
* \brief Bind a node to a vertex
{
Unexpect aCatch(SALOME_SalomeException);
- SMESHDS_Mesh * mesh = GetMeshDS();
+ SMESHDS_Mesh * mesh = getMeshDS();
SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
if ( !node )
THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);
{
Unexpect aCatch(SALOME_SalomeException);
- SMESHDS_Mesh * mesh = GetMeshDS();
+ SMESHDS_Mesh * mesh = getMeshDS();
SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
if ( !node )
THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);
{
Unexpect aCatch(SALOME_SalomeException);
- SMESHDS_Mesh * mesh = GetMeshDS();
+ SMESHDS_Mesh * mesh = getMeshDS();
SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
if ( !node )
THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);
{
Unexpect aCatch(SALOME_SalomeException);
- SMESHDS_Mesh * mesh = GetMeshDS();
+ SMESHDS_Mesh * mesh = getMeshDS();
SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( mesh->FindNode(NodeID) );
if ( !node )
THROW_SALOME_CORBA_EXCEPTION("Invalid NodeID", SALOME::BAD_PARAM);
{
Unexpect aCatch(SALOME_SalomeException);
- SMESHDS_Mesh * mesh = GetMeshDS();
+ SMESHDS_Mesh * mesh = getMeshDS();
SMDS_MeshElement* elem = const_cast<SMDS_MeshElement*>(mesh->FindElement(ElementID));
if ( !elem )
THROW_SALOME_CORBA_EXCEPTION("Invalid ElementID", SALOME::BAD_PARAM);
{
initData();
- const SMDS_MeshNode * n1 = GetMeshDS()->FindNode( NodeID1 );
- const SMDS_MeshNode * n2 = GetMeshDS()->FindNode( NodeID2 );
+ const SMDS_MeshNode * n1 = getMeshDS()->FindNode( NodeID1 );
+ const SMDS_MeshNode * n2 = getMeshDS()->FindNode( NodeID2 );
if ( !n1 || !n2 )
return false;
<< NodeID1 << ", " << NodeID2 << " )";
- int ret = myEditor.InverseDiag ( n1, n2 );
+ int ret = getEditor().InverseDiag ( n1, n2 );
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
return ret;
{
initData();
- const SMDS_MeshNode * n1 = GetMeshDS()->FindNode( NodeID1 );
- const SMDS_MeshNode * n2 = GetMeshDS()->FindNode( NodeID2 );
+ const SMDS_MeshNode * n1 = getMeshDS()->FindNode( NodeID1 );
+ const SMDS_MeshNode * n2 = getMeshDS()->FindNode( NodeID2 );
if ( !n1 || !n2 )
return false;
<< NodeID1 << ", " << NodeID2 << " )";
- bool stat = myEditor.DeleteDiag ( n1, n2 );
+ bool stat = getEditor().DeleteDiag ( n1, n2 );
myMesh->GetMeshDS()->Modified();
if ( stat )
myMesh->SetIsModified( true ); // issue 0020693
- storeResult(myEditor);
return stat;
}
for (int i = 0; i < IDsOfElements.length(); i++)
{
CORBA::Long index = IDsOfElements[i];
- const SMDS_MeshElement * elem = GetMeshDS()->FindElement(index);
+ const SMDS_MeshElement * elem = getMeshDS()->FindElement(index);
if ( elem )
- myEditor.Reorient( elem );
+ getEditor().Reorient( elem );
}
// Update Python script
TPythonDump() << "isDone = " << this << ".Reorient( " << IDsOfElements << " )";
initData(/*deleteSearchers=*/false);
TIDSortedElemSet elements;
- if ( !idSourceToSet( the2Dgroup, GetMeshDS(), elements, SMDSAbs_Face, /*emptyIfIsMesh=*/1))
+ if ( !idSourceToSet( the2Dgroup, getMeshDS(), elements, SMDSAbs_Face, /*emptyIfIsMesh=*/1))
THROW_SALOME_CORBA_EXCEPTION("No faces in given group", SALOME::BAD_PARAM);
const SMDS_MeshElement* face = 0;
if ( theFace > 0 )
{
- face = GetMeshDS()->FindElement( theFace );
+ face = getMeshDS()->FindElement( theFace );
if ( !face )
THROW_SALOME_CORBA_EXCEPTION("Inexistent face given", SALOME::BAD_PARAM);
if ( face->GetType() != SMDSAbs_Face )
if ( dirVec.Magnitude() < std::numeric_limits< double >::min() )
THROW_SALOME_CORBA_EXCEPTION("Zero size vector", SALOME::BAD_PARAM);
- int nbReori = myEditor.Reorient2D( elements, dirVec, face );
- storeResult(myEditor);
+ int nbReori = getEditor().Reorient2D( elements, dirVec, face );
if ( nbReori ) {
myMesh->SetIsModified( true );
{
initData();
- SMESHDS_Mesh* aMesh = GetMeshDS();
+ SMESHDS_Mesh* aMesh = getMeshDS();
TIDSortedElemSet faces;
arrayToSet(IDsOfElements, aMesh, faces, SMDSAbs_Face);
dynamic_cast<SMESH::NumericalFunctor_i*>( SMESH_Gen_i::GetServant( Criterion ).in() );
SMESH::Controls::NumericalFunctorPtr aCrit;
if ( !aNumericalFunctor )
- aCrit.reset( new SMESH::Controls::AspectRatio() );
+ aCrit.reset( new SMESH::Controls::MaxElementLength2D() );
else
aCrit = aNumericalFunctor->GetNumericalFunctor();
<< IDsOfElements << ", " << aNumericalFunctor << ", " << TVar( MaxAngle ) << " )";
- bool stat = myEditor.TriToQuad( faces, aCrit, MaxAngle );
+ bool stat = getEditor().TriToQuad( faces, aCrit, MaxAngle );
myMesh->GetMeshDS()->Modified();
if ( stat )
myMesh->SetIsModified( true ); // issue 0020693
- storeResult(myEditor);
return stat;
}
{
initData();
- SMESHDS_Mesh* aMesh = GetMeshDS();
+ SMESHDS_Mesh* aMesh = getMeshDS();
TIDSortedElemSet faces;
arrayToSet(IDsOfElements, aMesh, faces, SMDSAbs_Face);
// Update Python script
TPythonDump() << "isDone = " << this << ".QuadToTri( " << IDsOfElements << ", " << aNumericalFunctor << " )";
- CORBA::Boolean stat = myEditor.QuadToTri( faces, aCrit );
+ CORBA::Boolean stat = getEditor().QuadToTri( faces, aCrit );
myMesh->GetMeshDS()->Modified();
if ( stat )
myMesh->SetIsModified( true ); // issue 0020693
- storeResult(myEditor);
return stat;
}
{
initData();
- SMESHDS_Mesh* aMesh = GetMeshDS();
+ SMESHDS_Mesh* aMesh = getMeshDS();
TIDSortedElemSet faces;
arrayToSet(IDsOfElements, aMesh, faces, SMDSAbs_Face);
TPythonDump() << "isDone = " << this << ".SplitQuad( "
<< IDsOfElements << ", " << Diag13 << " )";
- CORBA::Boolean stat = myEditor.QuadToTri( faces, Diag13 );
+ CORBA::Boolean stat = getEditor().QuadToTri( faces, Diag13 );
myMesh->GetMeshDS()->Modified();
if ( stat )
myMesh->SetIsModified( true ); // issue 0020693
- storeResult(myEditor);
return stat;
}
{
initData();
- const SMDS_MeshElement* quad = GetMeshDS()->FindElement(IDOfQuad);
+ const SMDS_MeshElement* quad = getMeshDS()->FindElement(IDOfQuad);
if (quad && quad->GetType() == SMDSAbs_Face && quad->NbNodes() == 4)
{
SMESH::NumericalFunctor_i* aNumericalFunctor =
else
aCrit.reset(new SMESH::Controls::AspectRatio());
- return myEditor.BestSplit(quad, aCrit);
+ return getEditor().BestSplit(quad, aCrit);
}
return -1;
}
SMESH::long_array_var anElementsId = elems->GetIDs();
TIDSortedElemSet elemSet;
- arrayToSet( anElementsId, GetMeshDS(), elemSet, SMDSAbs_Volume );
+ arrayToSet( anElementsId, getMeshDS(), elemSet, SMDSAbs_Volume );
- myEditor.SplitVolumesIntoTetra( elemSet, int( methodFlags ));
+ getEditor().SplitVolumesIntoTetra( elemSet, int( methodFlags ));
myMesh->GetMeshDS()->Modified();
- storeResult(myEditor);
// if ( myLastCreatedElems.length() ) - it does not influence Compute()
// myMesh->SetIsModified( true ); // issue 0020693
{
initData();
- SMESHDS_Mesh* aMesh = GetMeshDS();
+ SMESHDS_Mesh* aMesh = getMeshDS();
TIDSortedElemSet elements;
arrayToSet(IDsOfElements, aMesh, elements, SMDSAbs_Face);
if ( Method != SMESH::SMESH_MeshEditor::LAPLACIAN_SMOOTH )
method = ::SMESH_MeshEditor::CENTROIDAL;
- myEditor.Smooth(elements, fixedNodes, method,
+ getEditor().Smooth(elements, fixedNodes, method,
MaxNbOfIterations, MaxAspectRatio, IsParametric );
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true ); // issue 0020693
- storeResult(myEditor);
// Update Python script
TPythonDump() << "isDone = " << this << "."
// Update Python script
TPythonDump() << this << ".RenumberNodes()";
- GetMeshDS()->Renumber( true );
+ getMeshDS()->Renumber( true );
}
// Update Python script
TPythonDump() << this << ".RenumberElements()";
- GetMeshDS()->Renumber( false );
+ getMeshDS()->Renumber( false );
}
//=======================================================================
initData();
TIDSortedElemSet inElements, copyElements;
- arrayToSet(theIDsOfElements, GetMeshDS(), inElements, theElementType);
+ arrayToSet(theIDsOfElements, getMeshDS(), inElements, theElementType);
TIDSortedElemSet* workElements = & inElements;
- TPreviewMesh tmpMesh( SMDSAbs_Face );
- SMESH_Mesh* mesh = 0;
bool makeWalls=true;
- if ( myPreviewMode )
+ if ( myIsPreviewMode )
{
SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
- tmpMesh.Copy( inElements, copyElements, select, avoid );
- mesh = &tmpMesh;
+ getPreviewMesh( SMDSAbs_Face )->Copy( inElements, copyElements, select, avoid );
workElements = & copyElements;
//makeWalls = false;
}
- else
- {
- mesh = myMesh;
- }
gp_Ax1 Ax1 (gp_Pnt( theAxis.x, theAxis.y, theAxis.z ),
gp_Vec( theAxis.vx, theAxis.vy, theAxis.vz ));
::SMESH_MeshEditor::PGroupIDs groupIds =
- myEditor.RotationSweep (*workElements, Ax1, theAngleInRadians,
- theNbOfSteps, theTolerance, theMakeGroups, makeWalls);
- storeResult(myEditor);
+ getEditor().RotationSweep (*workElements, Ax1, theAngleInRadians,
+ theNbOfSteps, theTolerance, theMakeGroups, makeWalls);
myMesh->GetMeshDS()->Modified();
// myMesh->SetIsModified( true ); -- it does not influence Compute()
CORBA::Long theNbOfSteps,
CORBA::Double theTolerance)
{
- if ( !myPreviewMode ) {
+ if ( !myIsPreviewMode ) {
TPythonDump() << this << ".RotationSweep( "
<< theIDsOfElements << ", "
<< theAxis << ", "
theNbOfSteps,
theTolerance,
true);
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".RotationSweepMakeGroups( "
<< theIDsOfElements << ", "
CORBA::Long theNbOfSteps,
CORBA::Double theTolerance)
{
- if ( !myPreviewMode ) {
+ if ( !myIsPreviewMode ) {
TPythonDump() << this << ".RotationSweepObject( "
<< theObject << ", "
<< theAxis << ", "
CORBA::Long theNbOfSteps,
CORBA::Double theTolerance)
{
- if ( !myPreviewMode ) {
+ if ( !myIsPreviewMode ) {
TPythonDump() << this << ".RotationSweepObject1D( "
<< theObject << ", "
<< theAxis << ", "
CORBA::Long theNbOfSteps,
CORBA::Double theTolerance)
{
- if ( !myPreviewMode ) {
+ if ( !myIsPreviewMode ) {
TPythonDump() << this << ".RotationSweepObject2D( "
<< theObject << ", "
<< theAxis << ", "
theNbOfSteps,
theTolerance,
true);
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".RotationSweepObjectMakeGroups( "
<< theObject << ", "
theTolerance,
true,
SMDSAbs_Edge);
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".RotationSweepObject1DMakeGroups( "
<< theObject << ", "
theTolerance,
true,
SMDSAbs_Face);
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".RotationSweepObject2DMakeGroups( "
<< theObject << ", "
OCC_CATCH_SIGNALS;
#endif
TIDSortedElemSet elements, copyElements;
- arrayToSet(theIDsOfElements, GetMeshDS(), elements, theElementType);
+ arrayToSet(theIDsOfElements, getMeshDS(), elements, theElementType);
const SMESH::PointStruct * P = &theStepVector.PS;
gp_Vec stepVec( P->x, P->y, P->z );
TIDSortedElemSet* workElements = & elements;
SMDSAbs_ElementType aType = SMDSAbs_Face;
- //::SMESH_MeshEditor::ExtrusionFlags aFlag = ::SMESH_MeshEditor::ExtrusionFlags::EXTRUSION_FLAG_BOUNDARY;
if (theElementType == SMDSAbs_Node)
{
aType = SMDSAbs_Edge;
- //aFlag = ::SMESH_MeshEditor::ExtrusionFlags::EXTRUSION_FLAG_SEW;
}
- TPreviewMesh tmpMesh( aType );
- SMESH_Mesh* mesh = myMesh;
-
- if ( myPreviewMode ) {
+ if ( myIsPreviewMode ) {
SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
- tmpMesh.Copy( elements, copyElements, select, avoid );
- mesh = &tmpMesh;
+ getPreviewMesh( aType )->Copy( elements, copyElements, select, avoid );
workElements = & copyElements;
theMakeGroups = false;
}
TElemOfElemListMap aHystory;
::SMESH_MeshEditor::PGroupIDs groupIds =
- myEditor.ExtrusionSweep (*workElements, stepVec, theNbOfSteps, aHystory, theMakeGroups);
+ getEditor().ExtrusionSweep (*workElements, stepVec, theNbOfSteps, aHystory, theMakeGroups);
myMesh->GetMeshDS()->Modified();
- storeResult(myEditor);
return theMakeGroups ? getGroups(groupIds.get()) : 0;
CORBA::Long theNbOfSteps)
{
extrusionSweep (theIDsOfElements, theStepVector, theNbOfSteps, false );
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
TPythonDump() << this << ".ExtrusionSweep( "
<< theIDsOfElements << ", " << theStepVector <<", " << TVar(theNbOfSteps) << " )";
}
CORBA::Long theNbOfSteps)
{
extrusionSweep (theIDsOfElements, theStepVector, theNbOfSteps, false, SMDSAbs_Node );
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
TPythonDump() << this << ".ExtrusionSweep0D( "
<< theIDsOfElements << ", " << theStepVector <<", " << TVar(theNbOfSteps)<< " )";
}
{
SMESH::long_array_var anElementsId = theObject->GetIDs();
extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false );
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
TPythonDump() << this << ".ExtrusionSweepObject( "
<< theObject << ", " << theStepVector << ", " << theNbOfSteps << " )";
}
{
SMESH::long_array_var anElementsId = theObject->GetIDs();
extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false, SMDSAbs_Node );
- if ( !myPreviewMode ) {
+ if ( !myIsPreviewMode ) {
TPythonDump() << this << ".ExtrusionSweepObject0D( "
<< theObject << ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
}
{
SMESH::long_array_var anElementsId = theObject->GetIDs();
extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false, SMDSAbs_Edge );
- if ( !myPreviewMode ) {
+ if ( !myIsPreviewMode ) {
TPythonDump() << this << ".ExtrusionSweepObject1D( "
<< theObject << ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
}
{
SMESH::long_array_var anElementsId = theObject->GetIDs();
extrusionSweep (anElementsId, theStepVector, theNbOfSteps, false, SMDSAbs_Face );
- if ( !myPreviewMode ) {
+ if ( !myIsPreviewMode ) {
TPythonDump() << this << ".ExtrusionSweepObject2D( "
<< theObject << ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
}
SMESH::ListOfGroups* aGroups = extrusionSweep(theIDsOfElements, theStepVector, theNbOfSteps, true);
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".ExtrusionSweepMakeGroups( " << theIDsOfElements
<< ", " << theStepVector <<", " << TVar( theNbOfSteps ) << " )";
SMESH::ListOfGroups* aGroups = extrusionSweep(theIDsOfElements, theStepVector, theNbOfSteps, true,SMDSAbs_Node);
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".ExtrusionSweepMakeGroups0D( " << theIDsOfElements
<< ", " << theStepVector <<", " << TVar( theNbOfSteps ) << " )";
SMESH::long_array_var anElementsId = theObject->GetIDs();
SMESH::ListOfGroups * aGroups = extrusionSweep(anElementsId, theStepVector, theNbOfSteps, true);
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".ExtrusionSweepObjectMakeGroups( " << theObject
<< ", " << theStepVector << ", " << theNbOfSteps << " )";
SMESH::long_array_var anElementsId = theObject->GetIDs();
SMESH::ListOfGroups * aGroups = extrusionSweep(anElementsId, theStepVector,
theNbOfSteps, true, SMDSAbs_Node);
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".ExtrusionSweepObject0DMakeGroups( " << theObject
<< ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
SMESH::long_array_var anElementsId = theObject->GetIDs();
SMESH::ListOfGroups * aGroups = extrusionSweep(anElementsId, theStepVector,
theNbOfSteps, true, SMDSAbs_Edge);
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".ExtrusionSweepObject1DMakeGroups( " << theObject
<< ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
SMESH::long_array_var anElementsId = theObject->GetIDs();
SMESH::ListOfGroups * aGroups = extrusionSweep(anElementsId, theStepVector,
theNbOfSteps, true, SMDSAbs_Face);
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".ExtrusionSweepObject2DMakeGroups( " << theObject
<< ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
initData();
TIDSortedElemSet elements;
- arrayToSet(theIDsOfElements, GetMeshDS(), elements);
+ arrayToSet(theIDsOfElements, getMeshDS(), elements);
const SMESH::PointStruct * P = &theStepVector.PS;
gp_Vec stepVec( P->x, P->y, P->z );
TElemOfElemListMap aHystory;
::SMESH_MeshEditor::PGroupIDs groupIds =
- myEditor.ExtrusionSweep (elements, stepVec, theNbOfSteps, aHystory,
- theMakeGroups, theExtrFlags, theSewTolerance);
- storeResult(myEditor);
+ getEditor().ExtrusionSweep (elements, stepVec, theNbOfSteps, aHystory,
+ theMakeGroups, theExtrFlags, theSewTolerance);
return theMakeGroups ? getGroups(groupIds.get()) : 0;
}
CORBA::Long theExtrFlags,
CORBA::Double theSewTolerance)
{
- if ( !myPreviewMode ) {
+ if ( !myIsPreviewMode ) {
TPythonDump() << "stepVector = " << theStepVector;
TPythonDump() << this << ".AdvancedExtrusion("
<< theIDsOfElements
CORBA::Long theExtrFlags,
CORBA::Double theSewTolerance)
{
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
TPythonDump() << "stepVector = " << theStepVector;
}
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
theSewTolerance,
true);
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".AdvancedExtrusionMakeGroups("
<< theIDsOfElements
}
TIDSortedElemSet elements;
- arrayToSet(theIDsOfElements, GetMeshDS(), elements, theElementType);
+ arrayToSet(theIDsOfElements, getMeshDS(), elements, theElementType);
list<double> angles;
for (int i = 0; i < theAngles.length(); i++) {
int nbOldGroups = myMesh->NbGroup();
::SMESH_MeshEditor::Extrusion_Error error =
- myEditor.ExtrusionAlongTrack( elements, aSubMesh, nodeStart,
+ getEditor().ExtrusionAlongTrack( elements, aSubMesh, nodeStart,
theHasAngles, angles, false,
theHasRefPoint, refPnt, theMakeGroups );
myMesh->GetMeshDS()->Modified();
- storeResult(myEditor);
theError = convExtrError( error );
if ( theMakeGroups ) {
}
TIDSortedElemSet elements, copyElements;
- arrayToSet(IDsOfElements, GetMeshDS(), elements, ElementType);
+ arrayToSet(IDsOfElements, getMeshDS(), elements, ElementType);
TIDSortedElemSet* workElements = &elements;
- TPreviewMesh tmpMesh( SMDSAbs_Face );
- SMESH_Mesh* mesh = myMesh;
- if ( myPreviewMode )
+ if ( myIsPreviewMode )
{
SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
- tmpMesh.Copy( elements, copyElements, select, avoid );
- mesh = &tmpMesh;
+ getPreviewMesh( SMDSAbs_Face )->Copy( elements, copyElements, select, avoid );
workElements = & copyElements;
MakeGroups = false;
}
Error = SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE;
return EmptyGr;
}
- error = myEditor.ExtrusionAlongTrack( *workElements, &(aMeshImp->GetImpl()), aNodeStart,
- HasAngles, angles, LinearVariation,
- HasRefPoint, refPnt, MakeGroups );
+ error = getEditor().ExtrusionAlongTrack( *workElements, &(aMeshImp->GetImpl()), aNodeStart,
+ HasAngles, angles, LinearVariation,
+ HasRefPoint, refPnt, MakeGroups );
myMesh->GetMeshDS()->Modified();
}
else if ( SMESH_subMesh_i* aSubMeshImp = SMESH::DownCast<SMESH_subMesh_i*>( Path ))
}
SMESH_subMesh* aSubMesh =
aMeshImp->GetImpl().GetSubMeshContaining(aSubMeshImp->GetId());
- error = myEditor.ExtrusionAlongTrack( *workElements, aSubMesh, aNodeStart,
- HasAngles, angles, LinearVariation,
- HasRefPoint, refPnt, MakeGroups );
+ error = getEditor().ExtrusionAlongTrack( *workElements, aSubMesh, aNodeStart,
+ HasAngles, angles, LinearVariation,
+ HasRefPoint, refPnt, MakeGroups );
myMesh->GetMeshDS()->Modified();
}
else if ( SMESH::DownCast<SMESH_Group_i*>( Path ))
return EmptyGr;
}
- storeResult(myEditor);
Error = convExtrError( error );
if ( MakeGroups ) {
const SMESH::PointStruct & theRefPoint)
{
MESSAGE("ExtrusionAlongPath");
- if ( !myPreviewMode ) {
+ if ( !myIsPreviewMode ) {
TPythonDump() << "error = " << this << ".ExtrusionAlongPath( "
<< theIDsOfElements << ", "
<< thePathMesh << ", "
CORBA::Boolean theHasRefPoint,
const SMESH::PointStruct & theRefPoint)
{
- if ( !myPreviewMode ) {
+ if ( !myIsPreviewMode ) {
TPythonDump() << "error = " << this << ".ExtrusionAlongPathObject( "
<< theObject << ", "
<< thePathMesh << ", "
CORBA::Boolean theHasRefPoint,
const SMESH::PointStruct & theRefPoint)
{
- if ( !myPreviewMode ) {
+ if ( !myIsPreviewMode ) {
TPythonDump() << "error = " << this << ".ExtrusionAlongPathObject1D( "
<< theObject << ", "
<< thePathMesh << ", "
CORBA::Boolean theHasRefPoint,
const SMESH::PointStruct & theRefPoint)
{
- if ( !myPreviewMode ) {
+ if ( !myIsPreviewMode ) {
TPythonDump() << "error = " << this << ".ExtrusionAlongPathObject2D( "
<< theObject << ", "
<< thePathMesh << ", "
theRefPoint,
true,
Error);
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
bool isDumpGroups = aGroups && aGroups->length() > 0;
if (isDumpGroups)
aPythonDump << "(" << aGroups << ", error)";
true,
Error);
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
bool isDumpGroups = aGroups && aGroups->length() > 0;
if (isDumpGroups)
aPythonDump << "(" << aGroups << ", error)";
Error,
SMDSAbs_Edge);
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
bool isDumpGroups = aGroups && aGroups->length() > 0;
if (isDumpGroups)
aPythonDump << "(" << aGroups << ", error)";
Error,
SMDSAbs_Face);
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
bool isDumpGroups = aGroups && aGroups->length() > 0;
if (isDumpGroups)
aPythonDump << "(" << aGroups << ", error)";
(SMDSAbs_ElementType)ElemType,
Error);
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
bool isDumpGroups = aGroups && aGroups->length() > 0;
if (isDumpGroups)
aPythonDump << "(" << *aGroups << ", error)";
(SMDSAbs_ElementType)ElemType,
Error);
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
bool isDumpGroups = aGroups && aGroups->length() > 0;
if (isDumpGroups)
aPythonDump << "(" << *aGroups << ", error)";
}
TIDSortedElemSet copyElements;
- TPreviewMesh tmpMesh;
TIDSortedElemSet* workElements = & theElements;
- SMESH_Mesh* mesh = myMesh;
- if ( myPreviewMode )
+ if ( myIsPreviewMode )
{
- tmpMesh.Copy( theElements, copyElements);
+ TPreviewMesh * tmpMesh = getPreviewMesh();
+ tmpMesh->Copy( theElements, copyElements);
if ( !theCopy && !theTargetMesh )
{
TIDSortedElemSet elemsAround, elemsAroundCopy;
- getElementsAround( theElements, GetMeshDS(), elemsAround );
- tmpMesh.Copy( elemsAround, elemsAroundCopy);
+ getElementsAround( theElements, getMeshDS(), elemsAround );
+ tmpMesh->Copy( elemsAround, elemsAroundCopy);
}
- mesh = &tmpMesh;
workElements = & copyElements;
theMakeGroups = false;
}
::SMESH_MeshEditor::PGroupIDs groupIds =
- myEditor.Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
+ getEditor().Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
- if(theCopy || myPreviewMode)
- storeResult(myEditor); // store preview data or new elements
-
- if ( !myPreviewMode )
+ if ( theCopy && !myIsPreviewMode)
{
if ( theTargetMesh )
{
SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
CORBA::Boolean theCopy)
{
- if ( !myPreviewMode ) {
+ if ( !myIsPreviewMode ) {
TPythonDump() << this << ".Mirror( "
<< theIDsOfElements << ", "
<< theAxis << ", "
if ( theIDsOfElements.length() > 0 )
{
TIDSortedElemSet elements;
- arrayToSet(theIDsOfElements, GetMeshDS(), elements);
+ arrayToSet(theIDsOfElements, getMeshDS(), elements);
mirror(elements, theAxis, theMirrorType, theCopy, false);
}
}
SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
CORBA::Boolean theCopy)
{
- if ( !myPreviewMode ) {
+ if ( !myIsPreviewMode ) {
TPythonDump() << this << ".MirrorObject( "
<< theObject << ", "
<< theAxis << ", "
}
TIDSortedElemSet elements;
- bool emptyIfIsMesh = myPreviewMode ? false : true;
+ bool emptyIfIsMesh = myIsPreviewMode ? false : true;
- if (idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
+ if (idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
mirror(elements, theAxis, theMirrorType, theCopy, false);
}
if ( theIDsOfElements.length() > 0 )
{
TIDSortedElemSet elements;
- arrayToSet(theIDsOfElements, GetMeshDS(), elements);
+ arrayToSet(theIDsOfElements, getMeshDS(), elements);
aGroups = mirror(elements, theMirror, theMirrorType, true, true);
}
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".MirrorMakeGroups( "
<< theIDsOfElements << ", "
SMESH::ListOfGroups * aGroups = 0;
TIDSortedElemSet elements;
- if ( idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
+ if ( idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
aGroups = mirror(elements, theMirror, theMirrorType, true, true);
- if (!myPreviewMode)
+ if (!myIsPreviewMode)
{
DumpGroupsList(aPythonDump,aGroups);
aPythonDump << this << ".MirrorObjectMakeGroups( "
if (mesh_i && theIDsOfElements.length() > 0 )
{
TIDSortedElemSet elements;
- arrayToSet(theIDsOfElements, GetMeshDS(), elements);
+ arrayToSet(theIDsOfElements, getMeshDS(), elements);
mirror(elements, theMirror, theMirrorType,
false, theCopyGroups, & mesh_i->GetImpl());
mesh_i->CreateGroupServants();
}
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
pydump << mesh << " = " << this << ".MirrorMakeMesh( "
<< theIDsOfElements << ", "
<< theMirror << ", "
}
//dump "GetGroups"
- if (!myPreviewMode && mesh_i)
+ if (!myIsPreviewMode && mesh_i)
mesh_i->GetGroups();
return mesh._retn();
mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
TIDSortedElemSet elements;
if ( mesh_i &&
- idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
+ idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
{
mirror(elements, theMirror, theMirrorType,
false, theCopyGroups, & mesh_i->GetImpl());
mesh_i->CreateGroupServants();
}
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
pydump << mesh << " = " << this << ".MirrorObjectMakeMesh( "
<< theObject << ", "
<< theMirror << ", "
}
//dump "GetGroups"
- if (!myPreviewMode && mesh_i)
+ if (!myIsPreviewMode && mesh_i)
mesh_i->GetGroups();
return mesh._retn();
TIDSortedElemSet copyElements;
TIDSortedElemSet* workElements = &theElements;
- TPreviewMesh tmpMesh;
- SMESH_Mesh* mesh = myMesh;
- if ( myPreviewMode )
+ if ( myIsPreviewMode )
{
- tmpMesh.Copy( theElements, copyElements);
+ TPreviewMesh * tmpMesh = getPreviewMesh();
+ tmpMesh->Copy( theElements, copyElements);
if ( !theCopy && !theTargetMesh )
{
TIDSortedElemSet elemsAround, elemsAroundCopy;
- getElementsAround( theElements, GetMeshDS(), elemsAround );
- tmpMesh.Copy( elemsAround, elemsAroundCopy);
+ getElementsAround( theElements, getMeshDS(), elemsAround );
+ tmpMesh->Copy( elemsAround, elemsAroundCopy);
}
- mesh = &tmpMesh;
workElements = & copyElements;
theMakeGroups = false;
}
::SMESH_MeshEditor::PGroupIDs groupIds =
- myEditor.Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
-
- if(theCopy || myPreviewMode)
- storeResult(myEditor);
+ getEditor().Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
- if ( !myPreviewMode )
+ if ( theCopy && !myIsPreviewMode )
{
if ( theTargetMesh )
{
const SMESH::DirStruct & theVector,
CORBA::Boolean theCopy)
{
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
TPythonDump() << this << ".Translate( "
<< theIDsOfElements << ", "
<< theVector << ", "
}
if (theIDsOfElements.length()) {
TIDSortedElemSet elements;
- arrayToSet(theIDsOfElements, GetMeshDS(), elements);
+ arrayToSet(theIDsOfElements, getMeshDS(), elements);
translate(elements, theVector, theCopy, false);
}
}
const SMESH::DirStruct & theVector,
CORBA::Boolean theCopy)
{
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
TPythonDump() << this << ".TranslateObject( "
<< theObject << ", "
<< theVector << ", "
}
TIDSortedElemSet elements;
- bool emptyIfIsMesh = myPreviewMode ? false : true;
+ bool emptyIfIsMesh = myIsPreviewMode ? false : true;
- if (idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
+ if (idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
translate(elements, theVector, theCopy, false);
}
SMESH::ListOfGroups * aGroups = 0;
if (theIDsOfElements.length()) {
TIDSortedElemSet elements;
- arrayToSet(theIDsOfElements, GetMeshDS(), elements);
+ arrayToSet(theIDsOfElements, getMeshDS(), elements);
aGroups = translate(elements,theVector,true,true);
}
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".TranslateMakeGroups( "
<< theIDsOfElements << ", "
SMESH::ListOfGroups * aGroups = 0;
TIDSortedElemSet elements;
- if (idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
+ if (idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
aGroups = translate(elements, theVector, true, true);
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".TranslateObjectMakeGroups( "
<< theObject << ", "
if ( mesh_i && theIDsOfElements.length() )
{
TIDSortedElemSet elements;
- arrayToSet(theIDsOfElements, GetMeshDS(), elements);
+ arrayToSet(theIDsOfElements, getMeshDS(), elements);
translate(elements, theVector, false, theCopyGroups, & mesh_i->GetImpl());
mesh_i->CreateGroupServants();
}
- if ( !myPreviewMode ) {
+ if ( !myIsPreviewMode ) {
pydump << mesh << " = " << this << ".TranslateMakeMesh( "
<< theIDsOfElements << ", "
<< theVector << ", "
}
//dump "GetGroups"
- if (!myPreviewMode && mesh_i)
+ if (!myIsPreviewMode && mesh_i)
mesh_i->GetGroups();
return mesh._retn();
TIDSortedElemSet elements;
if ( mesh_i &&
- idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
+ idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
{
translate(elements, theVector,false, theCopyGroups, & mesh_i->GetImpl());
mesh_i->CreateGroupServants();
}
- if ( !myPreviewMode ) {
+ if ( !myIsPreviewMode ) {
pydump << mesh << " = " << this << ".TranslateObjectMakeMesh( "
<< theObject << ", "
<< theVector << ", "
}
// dump "GetGroups"
- if (!myPreviewMode && mesh_i)
+ if (!myIsPreviewMode && mesh_i)
mesh_i->GetGroups();
return mesh._retn();
TIDSortedElemSet copyElements;
TIDSortedElemSet* workElements = &theElements;
- TPreviewMesh tmpMesh;
- SMESH_Mesh* mesh = myMesh;
-
- if ( myPreviewMode ) {
- tmpMesh.Copy( theElements, copyElements );
+ if ( myIsPreviewMode ) {
+ TPreviewMesh * tmpMesh = getPreviewMesh();
+ tmpMesh->Copy( theElements, copyElements );
if ( !theCopy && !theTargetMesh )
{
TIDSortedElemSet elemsAround, elemsAroundCopy;
- getElementsAround( theElements, GetMeshDS(), elemsAround );
- tmpMesh.Copy( elemsAround, elemsAroundCopy);
+ getElementsAround( theElements, getMeshDS(), elemsAround );
+ tmpMesh->Copy( elemsAround, elemsAroundCopy);
}
- mesh = &tmpMesh;
workElements = ©Elements;
theMakeGroups = false;
}
::SMESH_MeshEditor::PGroupIDs groupIds =
- myEditor.Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
-
- if(theCopy || myPreviewMode)
- storeResult(myEditor);
+ getEditor().Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
- if ( !myPreviewMode )
+ if ( theCopy && !myIsPreviewMode)
{
if ( theTargetMesh )
{
CORBA::Double theAngle,
CORBA::Boolean theCopy)
{
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
TPythonDump() << this << ".Rotate( "
<< theIDsOfElements << ", "
<< theAxis << ", "
if (theIDsOfElements.length() > 0)
{
TIDSortedElemSet elements;
- arrayToSet(theIDsOfElements, GetMeshDS(), elements);
+ arrayToSet(theIDsOfElements, getMeshDS(), elements);
rotate(elements,theAxis,theAngle,theCopy,false);
}
}
CORBA::Double theAngle,
CORBA::Boolean theCopy)
{
- if ( !myPreviewMode ) {
+ if ( !myIsPreviewMode ) {
TPythonDump() << this << ".RotateObject( "
<< theObject << ", "
<< theAxis << ", "
<< theCopy << " )";
}
TIDSortedElemSet elements;
- bool emptyIfIsMesh = myPreviewMode ? false : true;
- if (idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
+ bool emptyIfIsMesh = myIsPreviewMode ? false : true;
+ if (idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
rotate(elements,theAxis,theAngle,theCopy,false);
}
if (theIDsOfElements.length() > 0)
{
TIDSortedElemSet elements;
- arrayToSet(theIDsOfElements, GetMeshDS(), elements);
+ arrayToSet(theIDsOfElements, getMeshDS(), elements);
aGroups = rotate(elements,theAxis,theAngle,true,true);
}
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".RotateMakeGroups( "
<< theIDsOfElements << ", "
SMESH::ListOfGroups * aGroups = 0;
TIDSortedElemSet elements;
- if (idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
+ if (idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
aGroups = rotate(elements, theAxis, theAngle, true, true);
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".RotateObjectMakeGroups( "
<< theObject << ", "
if ( mesh_i && theIDsOfElements.length() > 0 )
{
TIDSortedElemSet elements;
- arrayToSet(theIDsOfElements, GetMeshDS(), elements);
+ arrayToSet(theIDsOfElements, getMeshDS(), elements);
rotate(elements, theAxis, theAngleInRadians,
false, theCopyGroups, & mesh_i->GetImpl());
mesh_i->CreateGroupServants();
}
- if ( !myPreviewMode ) {
+ if ( !myIsPreviewMode ) {
pydump << mesh << " = " << this << ".RotateMakeMesh( "
<< theIDsOfElements << ", "
<< theAxis << ", "
}
// dump "GetGroups"
- if (!myPreviewMode && mesh_i && theIDsOfElements.length() > 0 )
+ if (!myIsPreviewMode && mesh_i && theIDsOfElements.length() > 0 )
mesh_i->GetGroups();
return mesh._retn();
TIDSortedElemSet elements;
if (mesh_i &&
- idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
+ idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
{
rotate(elements, theAxis, theAngleInRadians,
false, theCopyGroups, & mesh_i->GetImpl());
mesh_i->CreateGroupServants();
}
- if ( !myPreviewMode ) {
+ if ( !myIsPreviewMode ) {
pydump << mesh << " = " << this << ".RotateObjectMakeMesh( "
<< theObject << ", "
<< theAxis << ", "
}
// dump "GetGroups"
- if (!myPreviewMode && mesh_i)
+ if (!myIsPreviewMode && mesh_i)
mesh_i->GetGroups();
return mesh._retn();
theCopy = false;
TIDSortedElemSet elements;
- bool emptyIfIsMesh = myPreviewMode ? false : true;
- if ( !idSourceToSet(theObject, GetMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
+ bool emptyIfIsMesh = myIsPreviewMode ? false : true;
+ if ( !idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
return 0;
double S[3] = {
0, 0, S[2], thePoint.z * (1-S[2]), tol, tol);
TIDSortedElemSet copyElements;
- TPreviewMesh tmpMesh;
TIDSortedElemSet* workElements = &elements;
- SMESH_Mesh* mesh = myMesh;
-
- if ( myPreviewMode )
+ if ( myIsPreviewMode )
{
- tmpMesh.Copy( elements, copyElements);
+ TPreviewMesh * tmpMesh = getPreviewMesh();
+ tmpMesh->Copy( elements, copyElements);
if ( !theCopy && !theTargetMesh )
{
TIDSortedElemSet elemsAround, elemsAroundCopy;
- getElementsAround( elements, GetMeshDS(), elemsAround );
- tmpMesh.Copy( elemsAround, elemsAroundCopy);
+ getElementsAround( elements, getMeshDS(), elemsAround );
+ tmpMesh->Copy( elemsAround, elemsAroundCopy);
}
- mesh = &tmpMesh;
workElements = & copyElements;
theMakeGroups = false;
}
::SMESH_MeshEditor::PGroupIDs groupIds =
- myEditor.Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
-
- if(theCopy || myPreviewMode )
- storeResult(myEditor);
+ getEditor().Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
- if ( !myPreviewMode )
+ if ( theCopy && !myIsPreviewMode )
{
if ( theTargetMesh )
{
const SMESH::double_array& theScaleFact,
CORBA::Boolean theCopy)
{
- if ( !myPreviewMode ) {
+ if ( !myIsPreviewMode ) {
TPythonDump() << this << ".Scale( "
<< theObject << ", "
<< thePoint << ", "
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
SMESH::ListOfGroups * aGroups = scale(theObject, thePoint, theScaleFact, true, true);
- if (!myPreviewMode) {
+ if (!myIsPreviewMode) {
DumpGroupsList(aPythonDump, aGroups);
aPythonDump << this << ".Scale("
<< theObject << ","
scale(theObject, thePoint, theScaleFact,false, theCopyGroups, & mesh_i->GetImpl());
mesh_i->CreateGroupServants();
}
- if ( !myPreviewMode )
+ if ( !myIsPreviewMode )
pydump << mesh << " = " << this << ".ScaleMakeMesh( "
<< theObject << ", "
<< thePoint << ", "
}
// dump "GetGroups"
- if (!myPreviewMode && mesh_i)
+ if (!myIsPreviewMode && mesh_i)
mesh_i->GetGroups();
return mesh._retn();
::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
TIDSortedNodeSet nodes; // no input nodes
- myEditor.FindCoincidentNodes( nodes, Tolerance, aListOfListOfNodes );
+ getEditor().FindCoincidentNodes( nodes, Tolerance, aListOfListOfNodes );
GroupsOfNodes = new SMESH::array_of_long_array;
GroupsOfNodes->length( aListOfListOfNodes.size() );
initData();
TIDSortedNodeSet nodes;
- idSourceToNodeSet( theObject, GetMeshDS(), nodes );
+ idSourceToNodeSet( theObject, getMeshDS(), nodes );
::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
if(!nodes.empty())
- myEditor.FindCoincidentNodes( nodes, Tolerance, aListOfListOfNodes );
+ getEditor().FindCoincidentNodes( nodes, Tolerance, aListOfListOfNodes );
GroupsOfNodes = new SMESH::array_of_long_array;
GroupsOfNodes->length( aListOfListOfNodes.size() );
initData();
TIDSortedNodeSet nodes;
- idSourceToNodeSet( theObject, GetMeshDS(), nodes );
+ idSourceToNodeSet( theObject, getMeshDS(), nodes );
for ( int i = 0; i < theExceptSubMeshOrGroups.length(); ++i )
{
TIDSortedNodeSet exceptNodes;
- idSourceToNodeSet( theExceptSubMeshOrGroups[i], GetMeshDS(), exceptNodes );
+ idSourceToNodeSet( theExceptSubMeshOrGroups[i], getMeshDS(), exceptNodes );
TIDSortedNodeSet::iterator avoidNode = exceptNodes.begin();
for ( ; avoidNode != exceptNodes.end(); ++avoidNode)
nodes.erase( *avoidNode );
}
::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
if(!nodes.empty())
- myEditor.FindCoincidentNodes( nodes, theTolerance, aListOfListOfNodes );
+ getEditor().FindCoincidentNodes( nodes, theTolerance, aListOfListOfNodes );
theGroupsOfNodes = new SMESH::array_of_long_array;
theGroupsOfNodes->length( aListOfListOfNodes.size() );
{
initData();
- SMESHDS_Mesh* aMesh = GetMeshDS();
+ SMESHDS_Mesh* aMesh = getMeshDS();
TPythonDump aTPythonDump;
aTPythonDump << this << ".MergeNodes([";
if ( i > 0 ) aTPythonDump << ", ";
aTPythonDump << aNodeGroup;
}
- myEditor.MergeNodes( aListOfListOfNodes );
+ getEditor().MergeNodes( aListOfListOfNodes );
aTPythonDump << "])";
myMesh->GetMeshDS()->Modified();
if ( !(!group->_is_nil() && group->GetType() == SMESH::NODE) )
{
TIDSortedElemSet elems;
- idSourceToSet( theObject, GetMeshDS(), elems, SMDSAbs_All, /*emptyIfIsMesh=*/true);
+ idSourceToSet( theObject, getMeshDS(), elems, SMDSAbs_All, /*emptyIfIsMesh=*/true);
::SMESH_MeshEditor::TListOfListOfElementsID aListOfListOfElementsID;
- myEditor.FindEqualElements( elems, aListOfListOfElementsID );
+ getEditor().FindEqualElements( elems, aListOfListOfElementsID );
GroupsOfElementsID = new SMESH::array_of_long_array;
GroupsOfElementsID->length( aListOfListOfElementsID.size() );
aTPythonDump << anElemsIDGroup;
}
- myEditor.MergeElements(aListOfListOfElementsID);
+ getEditor().MergeElements(aListOfListOfElementsID);
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
{
initData();
- myEditor.MergeEqualElements();
+ getEditor().MergeEqualElements();
myMesh->GetMeshDS()->Modified();
{
initData(/*deleteSearchers=*/false);
- const SMDS_MeshNode * node = GetMeshDS()->FindNode( NodeID );
+ const SMDS_MeshNode * node = getMeshDS()->FindNode( NodeID );
if ( !node )
return false;
if ( theNodeSearcher )
theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other
- if ( myPreviewMode ) // make preview data
+ if ( myIsPreviewMode ) // make preview data
{
// in a preview mesh, make edges linked to a node
- TPreviewMesh tmpMesh;
+ TPreviewMesh& tmpMesh = *getPreviewMesh();
TIDSortedElemSet linkedNodes;
::SMESH_MeshEditor::GetLinkedNodes( node, linkedNodes );
TIDSortedElemSet::iterator nIt = linkedNodes.begin();
if ( nodeCpy1 )
tmpMesh.GetMeshDS()->MoveNode(nodeCpy1, x, y, z);
// fill preview data
- storeResult( myEditor );
}
else if ( theNodeSearcher ) // move node and update theNodeSearcher data accordingly
theNodeSearcher->MoveNode(node, gp_Pnt( x,y,z ));
else
- GetMeshDS()->MoveNode(node, x, y, z);
+ getMeshDS()->MoveNode(node, x, y, z);
- if ( !myPreviewMode )
+ if ( !myIsPreviewMode )
{
// Update Python script
TPythonDump() << "isDone = " << this << ".MoveNode( "
theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other
int nodeID = theNodeID;
- const SMDS_MeshNode* node = GetMeshDS()->FindNode( nodeID );
+ const SMDS_MeshNode* node = getMeshDS()->FindNode( nodeID );
if ( !node ) // preview moving node
{
if ( !theNodeSearcher ) {
}
if ( node ) {
nodeID = node->GetID();
- if ( myPreviewMode ) // make preview data
+ if ( myIsPreviewMode ) // make preview data
{
// in a preview mesh, make edges linked to a node
- TPreviewMesh tmpMesh;
+ TPreviewMesh tmpMesh = *getPreviewMesh();
TIDSortedElemSet linkedNodes;
::SMESH_MeshEditor::GetLinkedNodes( node, linkedNodes );
TIDSortedElemSet::iterator nIt = linkedNodes.begin();
if ( node )
tmpMesh.GetMeshDS()->MoveNode(node, x, y, z);
// fill preview data
- storeResult( myEditor );
}
else if ( theNodeSearcher ) // move node and update theNodeSearcher data accordingly
{
}
else
{
- GetMeshDS()->MoveNode(node, x, y, z);
+ getMeshDS()->MoveNode(node, x, y, z);
}
}
- if ( !myPreviewMode )
+ if ( !myIsPreviewMode )
{
TPythonDump() << "nodeID = " << this
<< ".MoveClosestNodeToPoint( "<< x << ", " << y << ", " << z
for ( int i = 0; i < foundElems.size(); ++i )
res[i] = foundElems[i]->GetID();
- if ( !myPreviewMode ) // call from tui
+ if ( !myIsPreviewMode ) // call from tui
TPythonDump() << "res = " << this << ".FindElementsByPoint( "
<< x << ", "
<< y << ", "
for ( int i = 0; i < foundElems.size(); ++i )
res[i] = foundElems[i]->GetID();
- if ( !myPreviewMode ) // call from tui
+ if ( !myIsPreviewMode ) // call from tui
TPythonDump() << "res = " << this << ".FindAmongElementsByPoint( "
<< elementIDs << ", "
<< x << ", "
{
initData();
- SMESHDS_Mesh* aMesh = GetMeshDS();
+ SMESHDS_Mesh* aMesh = getMeshDS();
const SMDS_MeshNode* aBorderFirstNode = aMesh->FindNode( FirstNodeID1 );
const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeID1 );
<< CreatePolyedrs<< " )";
SMESH::SMESH_MeshEditor::Sew_Error error =
- convError( myEditor.SewFreeBorder (aBorderFirstNode,
+ convError( getEditor().SewFreeBorder (aBorderFirstNode,
aBorderSecondNode,
aBorderLastNode,
aSide2FirstNode,
CreatePolygons,
CreatePolyedrs) );
- storeResult(myEditor);
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
{
initData();
- SMESHDS_Mesh* aMesh = GetMeshDS();
+ SMESHDS_Mesh* aMesh = getMeshDS();
const SMDS_MeshNode* aBorderFirstNode = aMesh->FindNode( FirstNodeID1 );
const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeID1 );
<< SecondNodeID2 << " )";
SMESH::SMESH_MeshEditor::Sew_Error error =
- convError( myEditor.SewFreeBorder (aBorderFirstNode,
+ convError( getEditor().SewFreeBorder (aBorderFirstNode,
aBorderSecondNode,
aBorderLastNode,
aSide2FirstNode,
true,
false, false) );
- storeResult(myEditor);
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
{
initData();
- SMESHDS_Mesh* aMesh = GetMeshDS();
+ SMESHDS_Mesh* aMesh = getMeshDS();
const SMDS_MeshNode* aBorderFirstNode = aMesh->FindNode( FirstNodeIDOnFreeBorder );
const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeIDOnFreeBorder );
<< CreatePolyedrs << ") ";
SMESH::SMESH_MeshEditor::Sew_Error error =
- convError( myEditor.SewFreeBorder (aBorderFirstNode,
+ convError( getEditor().SewFreeBorder (aBorderFirstNode,
aBorderSecondNode,
aBorderLastNode,
aSide2FirstNode,
CreatePolygons,
CreatePolyedrs) );
- storeResult(myEditor);
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
{
initData();
- SMESHDS_Mesh* aMesh = GetMeshDS();
+ SMESHDS_Mesh* aMesh = getMeshDS();
const SMDS_MeshNode* aFirstNode1ToMerge = aMesh->FindNode( NodeID1OfSide1ToMerge );
const SMDS_MeshNode* aFirstNode2ToMerge = aMesh->FindNode( NodeID1OfSide2ToMerge );
<< NodeID2OfSide2ToMerge << ")";
SMESH::SMESH_MeshEditor::Sew_Error error =
- convError( myEditor.SewSideElements (aSide1Elems, aSide2Elems,
+ convError( getEditor().SewSideElements (aSide1Elems, aSide2Elems,
aFirstNode1ToMerge,
aFirstNode2ToMerge,
aSecondNode1ToMerge,
aSecondNode2ToMerge));
- storeResult(myEditor);
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
{
initData();
- const SMDS_MeshElement* elem = GetMeshDS()->FindElement(ide);
+ const SMDS_MeshElement* elem = getMeshDS()->FindElement(ide);
if(!elem) return false;
int nbn = newIDs.length();
vector<const SMDS_MeshNode*> aNodes(nbn);
int nbn1=-1;
for(; i<nbn; i++) {
- const SMDS_MeshNode* aNode = GetMeshDS()->FindNode(newIDs[i]);
+ const SMDS_MeshNode* aNode = getMeshDS()->FindNode(newIDs[i]);
if(aNode) {
nbn1++;
aNodes[nbn1] = aNode;
<< ide << ", " << newIDs << " )";
MESSAGE("ChangeElementNodes");
- bool res = GetMeshDS()->ChangeElementNodes( elem, & aNodes[0], nbn1+1 );
+ bool res = getMeshDS()->ChangeElementNodes( elem, & aNodes[0], nbn1+1 );
myMesh->GetMeshDS()->Modified();
if ( res )
void SMESH_MeshEditor_i::ConvertToQuadratic(CORBA::Boolean theForce3d)
{
- myEditor.ConvertToQuadratic(theForce3d);
+ getEditor().ConvertToQuadratic(theForce3d);
TPythonDump() << this << ".ConvertToQuadratic( " << theForce3d << " )";
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
CORBA::Boolean SMESH_MeshEditor_i::ConvertFromQuadratic()
{
- CORBA::Boolean isDone = myEditor.ConvertFromQuadratic();
+ CORBA::Boolean isDone = getEditor().ConvertFromQuadratic();
TPythonDump() << this << ".ConvertFromQuadratic()";
myMesh->GetMeshDS()->Modified();
if ( isDone )
Unexpect aCatch(SALOME_SalomeException);
TPythonDump pyDump;
TIDSortedElemSet elems;
- if ( idSourceToSet( theObject, GetMeshDS(), elems, SMDSAbs_All, /*emptyIfIsMesh=*/true ))
+ if ( idSourceToSet( theObject, getMeshDS(), elems, SMDSAbs_All, /*emptyIfIsMesh=*/true ))
{
if ( elems.empty() )
{
}
else
{
- myEditor.ConvertToQuadratic(theForce3d, elems);
+ getEditor().ConvertToQuadratic(theForce3d, elems);
}
}
myMesh->GetMeshDS()->Modified();
Unexpect aCatch(SALOME_SalomeException);
TPythonDump pyDump;
TIDSortedElemSet elems;
- if ( idSourceToSet( theObject, GetMeshDS(), elems, SMDSAbs_All, /*emptyIfIsMesh=*/true ))
+ if ( idSourceToSet( theObject, getMeshDS(), elems, SMDSAbs_All, /*emptyIfIsMesh=*/true ))
{
if ( elems.empty() )
{
}
else
{
- myEditor.ConvertFromQuadratic(elems);
+ getEditor().ConvertFromQuadratic(elems);
}
}
myMesh->GetMeshDS()->Modified();
SMESH::SMESH_Mesh_ptr SMESH_MeshEditor_i::makeMesh(const char* theMeshName)
{
- SMESH_Gen_i* gen = SMESH_Gen_i::GetSMESHGen();
- SMESH::SMESH_Mesh_var mesh = gen->CreateEmptyMesh();
- SALOMEDS::Study_var study = gen->GetCurrentStudy();
- SALOMEDS::SObject_var meshSO = gen->ObjectToSObject( study, mesh );
+ SMESH_Gen_i* gen = SMESH_Gen_i::GetSMESHGen();
+ SMESH::SMESH_Mesh_var mesh = gen->CreateEmptyMesh();
+ SALOMEDS::Study_var study = gen->GetCurrentStudy();
+ SALOMEDS::SObject_wrap meshSO = gen->ObjectToSObject( study, mesh );
gen->SetName( meshSO, theMeshName, "Mesh" );
gen->SetPixMap( meshSO, "ICON_SMESH_TREE_MESH_IMPORTED");
if (CORBA::is_nil(aGroup))
continue;
- groupNames.insert(aGroup->GetName());
+ CORBA::String_var name = aGroup->GetName();
+ groupNames.insert( name.in() );
}
// Find new name
string name = thePrefix;
int index = 0;
- while (!groupNames.insert(name).second) {
- if (index == 0) {
- name += "_1";
- }
- else {
- TCollection_AsciiString nbStr(index+1);
- name.resize( name.rfind('_')+1 );
- name += nbStr.ToCString();
- }
- ++index;
- }
+ while (!groupNames.insert(name).second)
+ name = SMESH_Comment( thePrefix ) << "_" << index;
return name;
}
for ( i = 0, n = theModifiedElems.length(); i < n; i++ )
aListOfElems.push_back( theModifiedElems[ i ] );
- bool aResult = myEditor.DoubleNodes( aListOfNodes, aListOfElems );
+ bool aResult = getEditor().DoubleNodes( aListOfNodes, aListOfElems );
myMesh->GetMeshDS()->Modified();
- storeResult( myEditor) ;
if ( aResult )
myMesh->SetIsModified( true );
}
}
- bool aResult = myEditor.DoubleNodes( aNodes, anElems );
+ bool aResult = getEditor().DoubleNodes( aNodes, anElems );
- storeResult( myEditor) ;
myMesh->GetMeshDS()->Modified();
if ( aResult )
initData();
- SMESHDS_Mesh* aMeshDS = GetMeshDS();
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
TIDSortedElemSet anElems, aNodes, anAffected;
arrayToSet(theElems, aMeshDS, anElems, SMDSAbs_All);
arrayToSet(theNodesNot, aMeshDS, aNodes, SMDSAbs_Node);
arrayToSet(theAffectedElems, aMeshDS, anAffected, SMDSAbs_All);
- bool aResult = myEditor.DoubleNodes( anElems, aNodes, anAffected );
+ bool aResult = getEditor().DoubleNodes( anElems, aNodes, anAffected );
- storeResult( myEditor) ;
myMesh->GetMeshDS()->Modified();
if ( aResult )
initData();
- SMESHDS_Mesh* aMeshDS = GetMeshDS();
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
TIDSortedElemSet anElems, aNodes;
arrayToSet(theElems, aMeshDS, anElems, SMDSAbs_All);
arrayToSet(theNodesNot, aMeshDS, aNodes, SMDSAbs_Node);
TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
- bool aResult = myEditor.DoubleNodesInRegion( anElems, aNodes, aShape );
+ bool aResult = getEditor().DoubleNodesInRegion( anElems, aNodes, aShape );
- storeResult( myEditor) ;
myMesh->GetMeshDS()->Modified();
if ( aResult )
initData();
- SMESHDS_Mesh* aMeshDS = GetMeshDS();
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
TIDSortedElemSet anElems, aNodes, anAffected;
idSourceToSet( theElems, aMeshDS, anElems, SMDSAbs_All );
idSourceToSet( theNodesNot, aMeshDS, aNodes, SMDSAbs_Node );
idSourceToSet( theAffectedElems, aMeshDS, anAffected, SMDSAbs_All );
- bool aResult = myEditor.DoubleNodes( anElems, aNodes, anAffected );
+ bool aResult = getEditor().DoubleNodes( anElems, aNodes, anAffected );
- storeResult( myEditor) ;
myMesh->GetMeshDS()->Modified();
if ( aResult )
initData();
- SMESHDS_Mesh* aMeshDS = GetMeshDS();
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
TIDSortedElemSet anElems, aNodes, anAffected;
idSourceToSet( theElems, aMeshDS, anElems, SMDSAbs_All );
idSourceToSet( theNodesNot, aMeshDS, aNodes, SMDSAbs_Node );
idSourceToSet( theAffectedElems, aMeshDS, anAffected, SMDSAbs_All );
- bool aResult = myEditor.DoubleNodes( anElems, aNodes, anAffected );
+ bool aResult = getEditor().DoubleNodes( anElems, aNodes, anAffected );
- storeResult( myEditor) ;
myMesh->GetMeshDS()->Modified();
TPythonDump pyDump;
// Create group with newly created elements
CORBA::String_var elemGroupName = theElems->GetName();
string aNewName = generateGroupName( string(elemGroupName.in()) + "_double");
- if ( !myEditor.GetLastCreatedElems().IsEmpty() && theElemGroupNeeded )
+ if ( !getEditor().GetLastCreatedElems().IsEmpty() && theElemGroupNeeded )
{
SMESH::long_array_var anIds = GetLastCreatedElems();
SMESH::ElementType aGroupType = myMesh_i->GetElementType(anIds[0], true);
aNewElemGroup = myMesh_i->CreateGroup(aGroupType, aNewName.c_str());
aNewElemGroup->Add(anIds);
}
- if ( !myEditor.GetLastCreatedNodes().IsEmpty() && theNodeGroupNeeded )
+ if ( !getEditor().GetLastCreatedNodes().IsEmpty() && theNodeGroupNeeded )
{
SMESH::long_array_var anIds = GetLastCreatedNodes();
aNewNodeGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
initData();
- SMESHDS_Mesh* aMeshDS = GetMeshDS();
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
TIDSortedElemSet anElems, aNodes, anAffected;
idSourceToSet( theElems, aMeshDS, anElems, SMDSAbs_All );
idSourceToSet( theNodesNot, aMeshDS, aNodes, SMDSAbs_Node );
TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
- bool aResult = myEditor.DoubleNodesInRegion( anElems, aNodes, aShape );
+ bool aResult = getEditor().DoubleNodesInRegion( anElems, aNodes, aShape );
- storeResult( myEditor) ;
myMesh->GetMeshDS()->Modified();
if ( aResult )
initData();
- SMESHDS_Mesh* aMeshDS = GetMeshDS();
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
TIDSortedElemSet anElems, aNodes, anAffected;
listOfGroupToSet(theElems, aMeshDS, anElems, false );
listOfGroupToSet(theNodesNot, aMeshDS, aNodes, true );
listOfGroupToSet(theAffectedElems, aMeshDS, anAffected, false );
- bool aResult = myEditor.DoubleNodes( anElems, aNodes, anAffected );
+ bool aResult = getEditor().DoubleNodes( anElems, aNodes, anAffected );
- storeResult( myEditor) ;
myMesh->GetMeshDS()->Modified();
if ( aResult )
initData();
- SMESHDS_Mesh* aMeshDS = GetMeshDS();
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
TIDSortedElemSet anElems, aNodes, anAffected;
listOfGroupToSet(theElems, aMeshDS, anElems, false );
listOfGroupToSet(theNodesNot, aMeshDS, aNodes, true );
listOfGroupToSet(theAffectedElems, aMeshDS, anAffected, false );
- bool aResult = myEditor.DoubleNodes( anElems, aNodes, anAffected );
+ bool aResult = getEditor().DoubleNodes( anElems, aNodes, anAffected );
- storeResult( myEditor) ;
myMesh->GetMeshDS()->Modified();
TPythonDump pyDump;
// Create group with newly created elements
CORBA::String_var elemGroupName = theElems[0]->GetName();
string aNewName = generateGroupName( string(elemGroupName.in()) + "_double");
- if ( !myEditor.GetLastCreatedElems().IsEmpty() && theElemGroupNeeded )
+ if ( !getEditor().GetLastCreatedElems().IsEmpty() && theElemGroupNeeded )
{
SMESH::long_array_var anIds = GetLastCreatedElems();
SMESH::ElementType aGroupType = myMesh_i->GetElementType(anIds[0], true);
aNewElemGroup = myMesh_i->CreateGroup(aGroupType, aNewName.c_str());
aNewElemGroup->Add(anIds);
}
- if ( !myEditor.GetLastCreatedNodes().IsEmpty() && theNodeGroupNeeded )
+ if ( !getEditor().GetLastCreatedNodes().IsEmpty() && theNodeGroupNeeded )
{
SMESH::long_array_var anIds = GetLastCreatedNodes();
aNewNodeGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
initData();
- SMESHDS_Mesh* aMeshDS = GetMeshDS();
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
TIDSortedElemSet anElems, aNodes;
listOfGroupToSet(theElems, aMeshDS, anElems,false );
listOfGroupToSet(theNodesNot, aMeshDS, aNodes, true );
TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
- bool aResult = myEditor.DoubleNodesInRegion( anElems, aNodes, aShape );
+ bool aResult = getEditor().DoubleNodesInRegion( anElems, aNodes, aShape );
- storeResult( myEditor) ;
myMesh->GetMeshDS()->Modified();
if ( aResult )
::SMESH_MeshEditor aMeshEditor(myMesh);
- SMESHDS_Mesh* aMeshDS = GetMeshDS();
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
TIDSortedElemSet anElems, aNodes;
listOfGroupToSet(theElems, aMeshDS, anElems, false);
listOfGroupToSet(theNodesNot, aMeshDS, aNodes, true);
TIDSortedElemSet anAffected;
bool aResult = aMeshEditor.AffectedElemGroupsInRegion(anElems, aNodes, aShape, anAffected);
- storeResult(aMeshEditor);
myMesh->GetMeshDS()->Modified();
TPythonDump pyDump;
{
initData();
- bool aResult = myEditor.Make2DMeshFrom3D();
- storeResult( myEditor) ;
+ bool aResult = getEditor().Make2DMeshFrom3D();
myMesh->GetMeshDS()->Modified();
TPythonDump() << "isDone = " << this << ".Make2DMeshFrom3D()";
return aResult;
CORBA::Boolean createJointElems )
throw (SALOME::SALOME_Exception)
{
- initData();
+ bool aResult = false;
+ SMESH_TRY;
+ initData();
- SMESHDS_Mesh* aMeshDS = GetMeshDS();
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
vector<TIDSortedElemSet> domains;
domains.clear();
}
}
- bool aResult = myEditor.DoubleNodesOnGroupBoundaries( domains, createJointElems );
+ aResult = getEditor().DoubleNodesOnGroupBoundaries( domains, createJointElems );
// TODO publish the groups of flat elements in study
- storeResult( myEditor) ;
myMesh->GetMeshDS()->Modified();
// Update Python script
TPythonDump() << "isDone = " << this << ".DoubleNodesOnGroupBoundaries( " << &theDomains
<< ", " << createJointElems << " )";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+
return aResult;
}
initData();
- SMESHDS_Mesh* aMeshDS = GetMeshDS();
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
vector<TIDSortedElemSet> faceGroups;
faceGroups.clear();
}
}
- bool aResult = myEditor.CreateFlatElementsOnFacesGroups( faceGroups );
+ bool aResult = getEditor().CreateFlatElementsOnFacesGroups( faceGroups );
// TODO publish the groups of flat elements in study
- storeResult( myEditor) ;
myMesh->GetMeshDS()->Modified();
// Update Python script
const char* groupName,
const SMESH::double_array& theNodesCoords,
SMESH::array_of_long_array_out GroupsOfNodes)
-throw (SALOME::SALOME_Exception)
+ throw (SALOME::SALOME_Exception)
{
+ SMESH_TRY;
+
initData();
std::vector<std::vector<int> > aListOfListOfNodes;
::SMESH_MeshEditor aMeshEditor( myMesh );
vector<double> nodesCoords;
for (int i = 0; i < theNodesCoords.length(); i++)
- {
- nodesCoords.push_back( theNodesCoords[i] );
+ {
+ nodesCoords.push_back( theNodesCoords[i] );
}
TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
- aMeshEditor.CreateHoleSkin(radius, aShape, theNodeSearcher, groupName, nodesCoords, aListOfListOfNodes);
+ aMeshEditor.CreateHoleSkin(radius, aShape, theNodeSearcher, groupName,
+ nodesCoords, aListOfListOfNodes);
GroupsOfNodes = new SMESH::array_of_long_array;
GroupsOfNodes->length( aListOfListOfNodes.size() );
std::vector<std::vector<int> >::iterator llIt = aListOfListOfNodes.begin();
for ( CORBA::Long i = 0; llIt != aListOfListOfNodes.end(); llIt++, i++ )
- {
- vector<int>& aListOfNodes = *llIt;
- vector<int>::iterator lIt = aListOfNodes.begin();;
- SMESH::long_array& aGroup = (*GroupsOfNodes)[ i ];
- aGroup.length( aListOfNodes.size() );
- for ( int j = 0; lIt != aListOfNodes.end(); lIt++, j++ )
- aGroup[ j ] = (*lIt);
- }
+ {
+ vector<int>& aListOfNodes = *llIt;
+ vector<int>::iterator lIt = aListOfNodes.begin();;
+ SMESH::long_array& aGroup = (*GroupsOfNodes)[ i ];
+ aGroup.length( aListOfNodes.size() );
+ for ( int j = 0; lIt != aListOfNodes.end(); lIt++, j++ )
+ aGroup[ j ] = (*lIt);
+ }
TPythonDump() << "lists_nodes = " << this << ".CreateHoleSkin( "
- << radius << ", " << theShape << ", " << ", " << groupName << ", " << theNodesCoords << " )";
+ << radius << ", "
+ << theShape
+ << ", '" << groupName << "', "
+ << theNodesCoords << " )";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
if ( dim > SMESH::BND_1DFROM2D )
THROW_SALOME_CORBA_EXCEPTION("Invalid boundary dimension", SALOME::BAD_PARAM);
- SMESHDS_Mesh* aMeshDS = GetMeshDS();
+ SMESHDS_Mesh* aMeshDS = getMeshDS();
SMESH::SMESH_Mesh_var mesh_var;
SMESH::SMESH_Group_var group_var;
}
// do it
- myEditor.MakeBoundaryMesh( elements,
+ getEditor().MakeBoundaryMesh( elements,
::SMESH_MeshEditor::Bnd_Dimension(dim),
smesh_group,
smesh_mesh,
toCopyElements,
toCopyExistingBondary);
- storeResult( myEditor );
if ( smesh_mesh )
smesh_mesh->GetMeshDS()->Modified();
{
SMESH::Bnd_Dimension bdim =
( elemType == SMDSAbs_Volume ) ? SMESH::BND_2DFROM3D : SMESH::BND_1DFROM2D;
- nbAdded += myEditor.MakeBoundaryMesh( elements,
+ nbAdded += getEditor().MakeBoundaryMesh( elements,
::SMESH_MeshEditor::Bnd_Dimension(bdim),
smesh_group,
tgtMesh,
/*toCopyExistingBondary=*/srcMesh != tgtMesh,
/*toAddExistingBondary=*/true,
/*aroundElements=*/true);
- storeResult( myEditor );
}
}
}
else
{
- nbAdded += myEditor.MakeBoundaryMesh( elements,
+ nbAdded += getEditor().MakeBoundaryMesh( elements,
::SMESH_MeshEditor::Bnd_Dimension(dim),
smesh_group,
tgtMesh,
/*toCopyElements=*/false,
/*toCopyExistingBondary=*/srcMesh != tgtMesh,
/*toAddExistingBondary=*/true);
- storeResult( myEditor );
}
tgtMesh->GetMeshDS()->Modified();