mirror of
https://git.salome-platform.org/gitpub/modules/smesh.git
synced 2024-11-17 19:18:33 +05:00
7480 lines
275 KiB
C++
7480 lines
275 KiB
C++
// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
|
|
//
|
|
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
|
|
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
|
|
//
|
|
// This library is free software; you can redistribute it and/or
|
|
// modify it under the terms of the GNU Lesser General Public
|
|
// License as published by the Free Software Foundation; either
|
|
// version 2.1 of the License, or (at your option) any later version.
|
|
//
|
|
// This library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
// Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public
|
|
// License along with this library; if not, write to the Free Software
|
|
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
//
|
|
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
|
|
//
|
|
// File : SMESH_MeshEditor_i.cxx
|
|
// Author : Nicolas REJNERI
|
|
// Module : SMESH
|
|
|
|
#ifdef WIN32
|
|
#define NOMINMAX
|
|
#endif
|
|
|
|
// A macro used in SMESH_TryCatch.hxx,
|
|
// it re-raises a CORBA SALOME exception thrown by SMESH_MeshEditor_i and caught by SMESH_CATCH
|
|
#define SMY_OWN_CATCH \
|
|
catch ( SALOME::SALOME_Exception & e ) { throw e; }
|
|
|
|
#include "SMESH_MeshEditor_i.hxx"
|
|
|
|
#include "SMDS_EdgePosition.hxx"
|
|
#include "SMDS_ElemIterator.hxx"
|
|
#include "SMDS_FacePosition.hxx"
|
|
#include "SMDS_IteratorOnIterators.hxx"
|
|
#include "SMDS_LinearEdge.hxx"
|
|
#include "SMDS_Mesh0DElement.hxx"
|
|
#include "SMDS_MeshFace.hxx"
|
|
#include "SMDS_MeshVolume.hxx"
|
|
#include "SMDS_PolyhedralVolumeOfNodes.hxx"
|
|
#include "SMDS_SetIterator.hxx"
|
|
#include "SMDS_VolumeTool.hxx"
|
|
#include "SMESHDS_Group.hxx"
|
|
#include "SMESHDS_GroupOnGeom.hxx"
|
|
#include "SMESH_ControlsDef.hxx"
|
|
#include "SMESH_Filter_i.hxx"
|
|
#include "SMESH_Gen_i.hxx"
|
|
#include "SMESH_Group.hxx"
|
|
#include "SMESH_Group_i.hxx"
|
|
#include "SMESH_MeshAlgos.hxx"
|
|
#include "SMESH_MeshPartDS.hxx"
|
|
#include "SMESH_MesherHelper.hxx"
|
|
#include "SMESH_PythonDump.hxx"
|
|
#include "SMESH_subMeshEventListener.hxx"
|
|
#include "SMESH_subMesh_i.hxx"
|
|
|
|
#include <utilities.h>
|
|
#include <Utils_ExceptHandlers.hxx>
|
|
#include <Utils_CorbaException.hxx>
|
|
#include <SALOMEDS_wrap.hxx>
|
|
#include <SALOME_GenericObj_i.hh>
|
|
#include <Basics_OCCTVersion.hxx>
|
|
|
|
#include <BRepAdaptor_Surface.hxx>
|
|
#include <BRep_Tool.hxx>
|
|
#include <TopExp_Explorer.hxx>
|
|
#include <TopoDS.hxx>
|
|
#include <TopoDS_Edge.hxx>
|
|
#include <TopoDS_Face.hxx>
|
|
#include <gp_Ax1.hxx>
|
|
#include <gp_Ax2.hxx>
|
|
#include <gp_Vec.hxx>
|
|
|
|
#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
|
|
#define NO_CAS_CATCH
|
|
#endif
|
|
|
|
#include <Standard_Failure.hxx>
|
|
|
|
#ifdef NO_CAS_CATCH
|
|
#include <Standard_ErrorHandler.hxx>
|
|
#endif
|
|
|
|
#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 MeshEditor_I {
|
|
|
|
//=============================================================================
|
|
/*!
|
|
* \brief Mesh to apply modifications for preview purposes
|
|
*/
|
|
//=============================================================================
|
|
|
|
struct TPreviewMesh: public SMESH_Mesh
|
|
{
|
|
SMDSAbs_ElementType myPreviewType; // type to show
|
|
//!< Constructor
|
|
TPreviewMesh(SMDSAbs_ElementType previewElements = SMDSAbs_All) {
|
|
_isShapeToMesh = (_id =_studyId = 0);
|
|
_myMeshDS = new SMESHDS_Mesh( _id, true );
|
|
myPreviewType = previewElements;
|
|
}
|
|
//!< Destructor
|
|
virtual ~TPreviewMesh() { delete _myMeshDS; _myMeshDS = 0; }
|
|
//!< Copy a set of elements
|
|
void Copy(const TIDSortedElemSet & theElements,
|
|
TIDSortedElemSet& theCopyElements,
|
|
SMDSAbs_ElementType theSelectType = SMDSAbs_All,
|
|
SMDSAbs_ElementType theAvoidType = SMDSAbs_All)
|
|
{
|
|
// loop on theIDsOfElements
|
|
TIDSortedElemSet::const_iterator eIt = theElements.begin();
|
|
for ( ; eIt != theElements.end(); ++eIt )
|
|
{
|
|
const SMDS_MeshElement* anElem = *eIt;
|
|
if ( !anElem ) continue;
|
|
SMDSAbs_ElementType type = anElem->GetType();
|
|
if ( type == theAvoidType ||
|
|
( theSelectType != SMDSAbs_All && type != theSelectType ))
|
|
continue;
|
|
const SMDS_MeshElement* anElemCopy;
|
|
if ( type == SMDSAbs_Node)
|
|
anElemCopy = Copy( cast2Node(anElem) );
|
|
else
|
|
anElemCopy = Copy( anElem );
|
|
if ( anElemCopy )
|
|
theCopyElements.insert( theCopyElements.end(), anElemCopy );
|
|
}
|
|
}
|
|
//!< Copy an element
|
|
SMDS_MeshElement* Copy( const SMDS_MeshElement* anElem )
|
|
{
|
|
// copy element nodes
|
|
int anElemNbNodes = anElem->NbNodes();
|
|
vector< int > anElemNodesID( anElemNbNodes ) ;
|
|
SMDS_ElemIteratorPtr itElemNodes = anElem->nodesIterator();
|
|
for ( int i = 0; itElemNodes->more(); i++)
|
|
{
|
|
const SMDS_MeshNode* anElemNode = cast2Node( itElemNodes->next() );
|
|
Copy( anElemNode );
|
|
anElemNodesID[i] = anElemNode->GetID();
|
|
}
|
|
|
|
// creates a corresponding element on copied nodes
|
|
SMDS_MeshElement* anElemCopy = 0;
|
|
if ( anElem->IsPoly() && anElem->GetType() == SMDSAbs_Volume )
|
|
{
|
|
const SMDS_VtkVolume* ph =
|
|
dynamic_cast<const SMDS_VtkVolume*> (anElem);
|
|
if ( ph )
|
|
anElemCopy = _myMeshDS->AddPolyhedralVolumeWithID
|
|
(anElemNodesID, ph->GetQuantities(),anElem->GetID());
|
|
}
|
|
else {
|
|
anElemCopy = ::SMESH_MeshEditor(this).AddElement( anElemNodesID,
|
|
anElem->GetType(),
|
|
anElem->IsPoly() );
|
|
}
|
|
return anElemCopy;
|
|
}
|
|
//!< Copy a node
|
|
SMDS_MeshNode* Copy( const SMDS_MeshNode* anElemNode )
|
|
{
|
|
return _myMeshDS->AddNodeWithID(anElemNode->X(), anElemNode->Y(), anElemNode->Z(),
|
|
anElemNode->GetID());
|
|
}
|
|
void RemoveAll()
|
|
{
|
|
GetMeshDS()->ClearMesh();
|
|
}
|
|
};// struct TPreviewMesh
|
|
|
|
static SMESH_NodeSearcher * theNodeSearcher = 0;
|
|
static SMESH_ElementSearcher * theElementSearcher = 0;
|
|
|
|
//=============================================================================
|
|
/*!
|
|
* \brief Deleter of theNodeSearcher at any compute event occured
|
|
*/
|
|
//=============================================================================
|
|
|
|
struct TSearchersDeleter : public SMESH_subMeshEventListener
|
|
{
|
|
SMESH_Mesh* myMesh;
|
|
string myMeshPartIOR;
|
|
//!< Constructor
|
|
TSearchersDeleter(): SMESH_subMeshEventListener( false, // won't be deleted by submesh
|
|
"SMESH_MeshEditor_i::TSearchersDeleter"),
|
|
myMesh(0) {}
|
|
//!< Delete theNodeSearcher
|
|
static void Delete()
|
|
{
|
|
if ( theNodeSearcher ) delete theNodeSearcher; theNodeSearcher = 0;
|
|
if ( theElementSearcher ) delete theElementSearcher; theElementSearcher = 0;
|
|
}
|
|
typedef map < int, SMESH_subMesh * > TDependsOnMap;
|
|
//!< The meshod called by submesh: do my main job
|
|
void ProcessEvent(const int, const int eventType, SMESH_subMesh* sm,
|
|
SMESH_subMeshEventListenerData*,const SMESH_Hypothesis*)
|
|
{
|
|
if ( eventType == SMESH_subMesh::COMPUTE_EVENT ) {
|
|
Delete();
|
|
Unset( sm->GetFather() );
|
|
}
|
|
}
|
|
//!< set self on all submeshes and delete theNodeSearcher if other mesh is set
|
|
void Set(SMESH_Mesh* mesh, const string& meshPartIOR = string())
|
|
{
|
|
if ( myMesh != mesh || myMeshPartIOR != meshPartIOR)
|
|
{
|
|
if ( myMesh ) {
|
|
Delete();
|
|
Unset( myMesh );
|
|
}
|
|
myMesh = mesh;
|
|
myMeshPartIOR = meshPartIOR;
|
|
SMESH_subMesh* sm = mesh->GetSubMesh( mesh->GetShapeToMesh() );
|
|
SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator( /*includeSelf=*/true );
|
|
while ( smIt->more() )
|
|
{
|
|
sm = smIt->next();
|
|
sm->SetEventListener( this, 0, sm );
|
|
}
|
|
}
|
|
}
|
|
//!< delete self from all submeshes
|
|
void Unset(SMESH_Mesh* mesh)
|
|
{
|
|
if ( SMESH_subMesh* sm = mesh->GetSubMeshContaining(1) ) {
|
|
SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator( /*includeSelf=*/true );
|
|
while ( smIt->more() )
|
|
smIt->next()->DeleteEventListener( this );
|
|
}
|
|
myMesh = 0;
|
|
}
|
|
|
|
} theSearchersDeleter;
|
|
|
|
TCollection_AsciiString mirrorTypeName( SMESH::SMESH_MeshEditor::MirrorType theMirrorType )
|
|
{
|
|
TCollection_AsciiString typeStr;
|
|
switch ( theMirrorType ) {
|
|
case SMESH::SMESH_MeshEditor::POINT:
|
|
typeStr = "SMESH.SMESH_MeshEditor.POINT";
|
|
break;
|
|
case SMESH::SMESH_MeshEditor::AXIS:
|
|
typeStr = "SMESH.SMESH_MeshEditor.AXIS";
|
|
break;
|
|
default:
|
|
typeStr = "SMESH.SMESH_MeshEditor.PLANE";
|
|
}
|
|
return typeStr;
|
|
}
|
|
//================================================================================
|
|
/*!
|
|
* \brief function for conversion of long_array to TIDSortedElemSet
|
|
* \param IDs - array of IDs
|
|
* \param aMesh - mesh
|
|
* \param aMap - collection to fill
|
|
* \param aType - element type
|
|
*/
|
|
//================================================================================
|
|
|
|
void arrayToSet(const SMESH::long_array & IDs,
|
|
const SMESHDS_Mesh* aMesh,
|
|
TIDSortedElemSet& aMap,
|
|
const SMDSAbs_ElementType aType = SMDSAbs_All,
|
|
SMDS_MeshElement::Filter* aFilter = NULL)
|
|
{
|
|
SMDS_MeshElement::NonNullFilter filter1;
|
|
SMDS_MeshElement::TypeFilter filter2( aType );
|
|
|
|
if ( aFilter == NULL )
|
|
aFilter = ( aType == SMDSAbs_All ) ? (SMDS_MeshElement::Filter*) &filter1 : (SMDS_MeshElement::Filter*) &filter2;
|
|
|
|
SMDS_MeshElement::Filter & filter = *aFilter;
|
|
|
|
if ( aType == SMDSAbs_Node )
|
|
for (int i=0; i<IDs.length(); i++) {
|
|
const SMDS_MeshElement * elem = aMesh->FindNode( IDs[i] );
|
|
if ( filter( elem ))
|
|
aMap.insert( aMap.end(), elem );
|
|
}
|
|
else
|
|
for (int i=0; i<IDs.length(); i++) {
|
|
const SMDS_MeshElement * elem = aMesh->FindElement( IDs[i] );
|
|
if ( filter( elem ))
|
|
aMap.insert( aMap.end(), elem );
|
|
}
|
|
}
|
|
//================================================================================
|
|
/*!
|
|
* \brief Retrieve elements of given type from SMESH_IDSource
|
|
*/
|
|
//================================================================================
|
|
|
|
enum IDSource_Error { IDSource_OK, IDSource_INVALID, IDSource_EMPTY };
|
|
|
|
bool idSourceToSet(SMESH::SMESH_IDSource_ptr theIDSource,
|
|
const SMESHDS_Mesh* theMeshDS,
|
|
TIDSortedElemSet& theElemSet,
|
|
const SMDSAbs_ElementType theType,
|
|
const bool emptyIfIsMesh = false,
|
|
IDSource_Error* error = 0)
|
|
|
|
{
|
|
if ( error ) *error = IDSource_OK;
|
|
|
|
if ( CORBA::is_nil( theIDSource ) )
|
|
{
|
|
if ( error ) *error = IDSource_INVALID;
|
|
return false;
|
|
}
|
|
if ( emptyIfIsMesh && SMESH::DownCast<SMESH_Mesh_i*>( theIDSource ))
|
|
{
|
|
if ( error && theMeshDS->GetMeshInfo().NbElements( theType ) == 0 )
|
|
*error = IDSource_EMPTY;
|
|
return true;
|
|
}
|
|
SMESH::long_array_var anIDs = theIDSource->GetIDs();
|
|
if ( anIDs->length() == 0 )
|
|
{
|
|
if ( error ) *error = IDSource_EMPTY;
|
|
return false;
|
|
}
|
|
SMESH::array_of_ElementType_var types = theIDSource->GetTypes();
|
|
if ( types->length() == 1 && types[0] == SMESH::NODE ) // group of nodes
|
|
{
|
|
if ( theType == SMDSAbs_All || theType == SMDSAbs_Node )
|
|
{
|
|
arrayToSet( anIDs, theMeshDS, theElemSet, SMDSAbs_Node );
|
|
}
|
|
else
|
|
{
|
|
if ( error ) *error = IDSource_INVALID;
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
arrayToSet( anIDs, theMeshDS, theElemSet, theType);
|
|
if ( bool(anIDs->length()) != bool(theElemSet.size()))
|
|
{
|
|
if ( error ) *error = IDSource_INVALID;
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
//================================================================================
|
|
/*!
|
|
* \brief Retrieve nodes from SMESH_IDSource
|
|
*/
|
|
//================================================================================
|
|
|
|
void idSourceToNodeSet(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESHDS_Mesh* theMeshDS,
|
|
TIDSortedNodeSet& theNodeSet)
|
|
|
|
{
|
|
if ( CORBA::is_nil( theObject ) )
|
|
return;
|
|
SMESH::array_of_ElementType_var types = theObject->GetTypes();
|
|
SMESH::long_array_var aElementsId = theObject->GetIDs();
|
|
if ( types->length() == 1 && types[0] == SMESH::NODE)
|
|
{
|
|
for(int i = 0; i < aElementsId->length(); i++)
|
|
if ( const SMDS_MeshNode * n = theMeshDS->FindNode( aElementsId[i] ))
|
|
theNodeSet.insert( theNodeSet.end(), n);
|
|
}
|
|
else if ( SMESH::DownCast<SMESH_Mesh_i*>( theObject ))
|
|
{
|
|
SMDS_NodeIteratorPtr nIt = theMeshDS->nodesIterator();
|
|
while ( nIt->more( ))
|
|
if( const SMDS_MeshElement * elem = nIt->next() )
|
|
theNodeSet.insert( elem->begin_nodes(), elem->end_nodes());
|
|
}
|
|
else
|
|
{
|
|
for(int i = 0; i < aElementsId->length(); i++)
|
|
if( const SMDS_MeshElement * elem = theMeshDS->FindElement( aElementsId[i] ))
|
|
theNodeSet.insert( elem->begin_nodes(), elem->end_nodes());
|
|
}
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Returns elements connected to the given elements
|
|
*/
|
|
//================================================================================
|
|
|
|
void getElementsAround(const TIDSortedElemSet& theElements,
|
|
const SMESHDS_Mesh* theMeshDS,
|
|
TIDSortedElemSet& theElementsAround)
|
|
{
|
|
if ( theElements.empty() ) return;
|
|
|
|
SMDSAbs_ElementType elemType = (*theElements.begin())->GetType();
|
|
bool sameElemType = ( elemType == (*theElements.rbegin())->GetType() );
|
|
if ( sameElemType &&
|
|
theMeshDS->GetMeshInfo().NbElements( elemType ) == theElements.size() )
|
|
return; // all the elements are in theElements
|
|
|
|
if ( !sameElemType )
|
|
elemType = SMDSAbs_All;
|
|
|
|
vector<bool> isNodeChecked( theMeshDS->NbNodes(), false );
|
|
|
|
TIDSortedElemSet::const_iterator elemIt = theElements.begin();
|
|
for ( ; elemIt != theElements.end(); ++elemIt )
|
|
{
|
|
const SMDS_MeshElement* e = *elemIt;
|
|
int i = e->NbCornerNodes();
|
|
while ( --i != -1 )
|
|
{
|
|
const SMDS_MeshNode* n = e->GetNode( i );
|
|
if ( !isNodeChecked[ n->GetID() ])
|
|
{
|
|
isNodeChecked[ n->GetID() ] = true;
|
|
SMDS_ElemIteratorPtr invIt = n->GetInverseElementIterator(elemType);
|
|
while ( invIt->more() )
|
|
{
|
|
const SMDS_MeshElement* elemAround = invIt->next();
|
|
if ( !theElements.count( elemAround ))
|
|
theElementsAround.insert( elemAround );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Return a string used to detect change of mesh part on which theElementSearcher
|
|
* is going to be used
|
|
*/
|
|
//================================================================================
|
|
|
|
string getPartIOR( SMESH::SMESH_IDSource_ptr theMeshPart, SMESH::ElementType type)
|
|
{
|
|
string partIOR = SMESH_Gen_i::GetORB()->object_to_string( theMeshPart );
|
|
if ( SMESH_Group_i* group_i = SMESH::DownCast<SMESH_Group_i*>( theMeshPart ))
|
|
// take into account passible group modification
|
|
partIOR += SMESH_Comment( ((SMESHDS_Group*)group_i->GetGroupDS())->SMDSGroup().Tic() );
|
|
partIOR += SMESH_Comment( type );
|
|
return partIOR;
|
|
}
|
|
|
|
} // namespace MeshEditor_I
|
|
|
|
using namespace MeshEditor_I;
|
|
|
|
//=============================================================================
|
|
/*!
|
|
*
|
|
*/
|
|
//=============================================================================
|
|
|
|
SMESH_MeshEditor_i::SMESH_MeshEditor_i(SMESH_Mesh_i* theMesh, bool isPreview):
|
|
myMesh_i( theMesh ),
|
|
myMesh( &theMesh->GetImpl() ),
|
|
myEditor( myMesh ),
|
|
myIsPreviewMode ( isPreview ),
|
|
myPreviewMesh( 0 ),
|
|
myPreviewEditor( 0 )
|
|
{
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Destructor
|
|
*/
|
|
//================================================================================
|
|
|
|
SMESH_MeshEditor_i::~SMESH_MeshEditor_i()
|
|
{
|
|
PortableServer::POA_var poa = SMESH_Gen_i::GetPOA();
|
|
PortableServer::ObjectId_var anObjectId = poa->servant_to_id(this);
|
|
poa->deactivate_object(anObjectId.in());
|
|
|
|
//deleteAuxIDSources();
|
|
delete myPreviewMesh; myPreviewMesh = 0;
|
|
delete myPreviewEditor; myPreviewEditor = 0;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Clear members
|
|
*/
|
|
//================================================================================
|
|
|
|
void SMESH_MeshEditor_i::initData(bool deleteSearchers)
|
|
{
|
|
if ( myIsPreviewMode ) {
|
|
if ( myPreviewMesh ) myPreviewMesh->RemoveAll();
|
|
}
|
|
else {
|
|
if ( deleteSearchers )
|
|
TSearchersDeleter::Delete();
|
|
}
|
|
getEditor().GetError().reset();
|
|
getEditor().CrearLastCreated();
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Increment mesh modif time and optionally record that the performed
|
|
* modification may influence futher mesh re-compute.
|
|
* \param [in] isReComputeSafe - true if the modification does not infulence
|
|
* futher mesh re-compute
|
|
*/
|
|
//================================================================================
|
|
|
|
void SMESH_MeshEditor_i::declareMeshModified( bool isReComputeSafe )
|
|
{
|
|
myMesh->GetMeshDS()->Modified();
|
|
if ( !isReComputeSafe )
|
|
myMesh->SetIsModified( true );
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \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 Initialize and return myPreviewMesh
|
|
* \param previewElements - type of elements to show in preview
|
|
*
|
|
* WARNING: call it once par a method!
|
|
*/
|
|
//================================================================================
|
|
|
|
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;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* Return data of mesh edition preview
|
|
*/
|
|
//================================================================================
|
|
|
|
SMESH::MeshPreviewStruct* SMESH_MeshEditor_i::GetPreviewData()
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
const bool hasBadElems = ( getEditor().GetError() && getEditor().GetError()->HasBadElems() );
|
|
|
|
if ( myIsPreviewMode || hasBadElems ) { // --- MeshPreviewStruct filling ---
|
|
|
|
list<int> aNodesConnectivity;
|
|
typedef map<int, int> TNodesMap;
|
|
TNodesMap nodesMap;
|
|
|
|
SMESHDS_Mesh* aMeshDS;
|
|
std::auto_ptr< SMESH_MeshPartDS > aMeshPartDS;
|
|
if ( hasBadElems ) {
|
|
aMeshPartDS.reset( new SMESH_MeshPartDS( getEditor().GetError()->myBadElements ));
|
|
aMeshDS = aMeshPartDS.get();
|
|
}
|
|
else {
|
|
aMeshDS = getEditor().GetMeshDS();
|
|
}
|
|
myPreviewData = new SMESH::MeshPreviewStruct();
|
|
myPreviewData->nodesXYZ.length(aMeshDS->NbNodes());
|
|
|
|
|
|
SMDSAbs_ElementType previewType = SMDSAbs_All;
|
|
if ( !hasBadElems )
|
|
if (TPreviewMesh * aPreviewMesh = dynamic_cast< TPreviewMesh* >( getEditor().GetMesh() )) {
|
|
previewType = aPreviewMesh->myPreviewType;
|
|
switch ( previewType ) {
|
|
case SMDSAbs_Edge : break;
|
|
case SMDSAbs_Face : break;
|
|
case SMDSAbs_Volume: break;
|
|
default:;
|
|
if ( aMeshDS->GetMeshInfo().NbElements() == 0 ) previewType = SMDSAbs_Node;
|
|
}
|
|
}
|
|
|
|
myPreviewData->elementTypes.length( aMeshDS->GetMeshInfo().NbElements( previewType ));
|
|
int i = 0, j = 0;
|
|
SMDS_ElemIteratorPtr itMeshElems = aMeshDS->elementsIterator(previewType);
|
|
|
|
while ( itMeshElems->more() ) {
|
|
const SMDS_MeshElement* aMeshElem = itMeshElems->next();
|
|
SMDS_NodeIteratorPtr itElemNodes = aMeshElem->nodeIterator();
|
|
while ( itElemNodes->more() ) {
|
|
const SMDS_MeshNode* aMeshNode = itElemNodes->next();
|
|
int aNodeID = aMeshNode->GetID();
|
|
TNodesMap::iterator anIter = nodesMap.find(aNodeID);
|
|
if ( anIter == nodesMap.end() ) {
|
|
// filling the nodes coordinates
|
|
myPreviewData->nodesXYZ[j].x = aMeshNode->X();
|
|
myPreviewData->nodesXYZ[j].y = aMeshNode->Y();
|
|
myPreviewData->nodesXYZ[j].z = aMeshNode->Z();
|
|
anIter = nodesMap.insert( make_pair(aNodeID, j) ).first;
|
|
j++;
|
|
}
|
|
aNodesConnectivity.push_back(anIter->second);
|
|
}
|
|
|
|
// filling the elements types
|
|
SMDSAbs_ElementType aType = aMeshElem->GetType();
|
|
bool isPoly = aMeshElem->IsPoly();
|
|
myPreviewData->elementTypes[i].SMDS_ElementType = (SMESH::ElementType) aType;
|
|
myPreviewData->elementTypes[i].isPoly = isPoly;
|
|
myPreviewData->elementTypes[i].nbNodesInElement = aMeshElem->NbNodes();
|
|
i++;
|
|
}
|
|
myPreviewData->nodesXYZ.length( j );
|
|
|
|
// filling the elements connectivities
|
|
list<int>::iterator aConnIter = aNodesConnectivity.begin();
|
|
myPreviewData->elementConnectivities.length(aNodesConnectivity.size());
|
|
for( int i = 0; aConnIter != aNodesConnectivity.end(); aConnIter++, i++ )
|
|
myPreviewData->elementConnectivities[i] = *aConnIter;
|
|
}
|
|
return myPreviewData._retn();
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Returns list of it's IDs of created nodes
|
|
* \retval SMESH::long_array* - list of node ID
|
|
*/
|
|
//================================================================================
|
|
|
|
SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedNodes()
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
SMESH::long_array_var myLastCreatedNodes = new SMESH::long_array();
|
|
|
|
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();
|
|
|
|
return myLastCreatedNodes._retn();
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Returns list of it's IDs of created elements
|
|
* \retval SMESH::long_array* - list of elements' ID
|
|
*/
|
|
//================================================================================
|
|
|
|
SMESH::long_array* SMESH_MeshEditor_i::GetLastCreatedElems()
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
SMESH::long_array_var myLastCreatedElems = new SMESH::long_array();
|
|
|
|
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();
|
|
|
|
return myLastCreatedElems._retn();
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ClearLastCreated
|
|
//purpose : Clears sequences of last created elements and nodes
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::ClearLastCreated() throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
getEditor().CrearLastCreated();
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
}
|
|
|
|
//=======================================================================
|
|
/*
|
|
* Returns description of an error/warning occured during the last operation
|
|
* WARNING: ComputeError.code >= 100 and no corresponding enum in IDL API
|
|
*/
|
|
//=======================================================================
|
|
|
|
SMESH::ComputeError* SMESH_MeshEditor_i::GetLastError()
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
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->comment = errIn->myComment.c_str();
|
|
errOut->subShapeID = -1;
|
|
errOut->hasBadMesh = !errIn->myBadElements.empty();
|
|
}
|
|
else
|
|
{
|
|
errOut->code = 0;
|
|
errOut->subShapeID = -1;
|
|
errOut->hasBadMesh = false;
|
|
}
|
|
|
|
return errOut._retn();
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : MakeIDSource
|
|
//purpose : Wrap a sequence of ids in a SMESH_IDSource.
|
|
// Call UnRegister() as you fininsh using it!!
|
|
//=======================================================================
|
|
|
|
struct SMESH_MeshEditor_i::_IDSource : public virtual POA_SMESH::SMESH_IDSource,
|
|
public virtual SALOME::GenericObj_i
|
|
{
|
|
SMESH::long_array _ids;
|
|
SMESH::ElementType _type;
|
|
SMESH::SMESH_Mesh_ptr _mesh;
|
|
SMESH::long_array* GetIDs() { return new SMESH::long_array( _ids ); }
|
|
SMESH::long_array* GetMeshInfo() { return 0; }
|
|
SMESH::long_array* GetNbElementsByType()
|
|
{
|
|
SMESH::long_array_var aRes = new SMESH::long_array();
|
|
aRes->length(SMESH::NB_ELEMENT_TYPES);
|
|
for (int i = 0; i < SMESH::NB_ELEMENT_TYPES; i++)
|
|
aRes[ i ] = ( i == _type ) ? _ids.length() : 0;
|
|
return aRes._retn();
|
|
}
|
|
SMESH::SMESH_Mesh_ptr GetMesh() { return SMESH::SMESH_Mesh::_duplicate( _mesh ); }
|
|
bool IsMeshInfoCorrect() { return true; }
|
|
SMESH::array_of_ElementType* GetTypes()
|
|
{
|
|
SMESH::array_of_ElementType_var types = new SMESH::array_of_ElementType;
|
|
if ( _ids.length() > 0 ) {
|
|
types->length( 1 );
|
|
types[0] = _type;
|
|
}
|
|
return types._retn();
|
|
}
|
|
SALOMEDS::TMPFile* GetVtkUgStream()
|
|
{
|
|
SALOMEDS::TMPFile_var SeqFile;
|
|
return SeqFile._retn();
|
|
}
|
|
};
|
|
|
|
SMESH::SMESH_IDSource_ptr SMESH_MeshEditor_i::MakeIDSource(const SMESH::long_array& ids,
|
|
SMESH::ElementType type)
|
|
{
|
|
_IDSource* idSrc = new _IDSource;
|
|
idSrc->_mesh = myMesh_i->_this();
|
|
idSrc->_ids = ids;
|
|
idSrc->_type = type;
|
|
if ( type == SMESH::ALL && ids.length() > 0 )
|
|
idSrc->_type = myMesh_i->GetElementType( ids[0], true );
|
|
|
|
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 );
|
|
}
|
|
|
|
CORBA::Long* SMESH_MeshEditor_i::GetTemporaryIDs( SMESH::SMESH_IDSource_ptr& idSource,
|
|
int& nbIds)
|
|
{
|
|
if ( _IDSource* tmpIdSource = SMESH::DownCast<SMESH_MeshEditor_i::_IDSource*>( idSource ))
|
|
{
|
|
nbIds = (int) tmpIdSource->_ids.length();
|
|
return & tmpIdSource->_ids[0];
|
|
}
|
|
nbIds = 0;
|
|
return 0;
|
|
}
|
|
|
|
// void SMESH_MeshEditor_i::deleteAuxIDSources()
|
|
// {
|
|
// std::list< _IDSource* >::iterator idSrcIt = myAuxIDSources.begin();
|
|
// for ( ; idSrcIt != myAuxIDSources.end(); ++idSrcIt )
|
|
// delete *idSrcIt;
|
|
// myAuxIDSources.clear();
|
|
// }
|
|
|
|
//=============================================================================
|
|
/*!
|
|
*
|
|
*/
|
|
//=============================================================================
|
|
|
|
CORBA::Boolean
|
|
SMESH_MeshEditor_i::RemoveElements(const SMESH::long_array & IDsOfElements)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
list< int > IdList;
|
|
|
|
for (int i = 0; i < IDsOfElements.length(); i++)
|
|
IdList.push_back( IDsOfElements[i] );
|
|
|
|
// Update Python script
|
|
TPythonDump() << "isDone = " << this << ".RemoveElements( " << IDsOfElements << " )";
|
|
|
|
// Remove Elements
|
|
bool ret = getEditor().Remove( IdList, false );
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/ IDsOfElements.length() == 0 ); // issue 0020693
|
|
return ret;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
*
|
|
*/
|
|
//=============================================================================
|
|
|
|
CORBA::Boolean SMESH_MeshEditor_i::RemoveNodes(const SMESH::long_array & IDsOfNodes)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
list< int > IdList;
|
|
for (int i = 0; i < IDsOfNodes.length(); i++)
|
|
IdList.push_back( IDsOfNodes[i] );
|
|
|
|
// Update Python script
|
|
TPythonDump() << "isDone = " << this << ".RemoveNodes( " << IDsOfNodes << " )";
|
|
|
|
bool ret = getEditor().Remove( IdList, true );
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/ !ret ); // issue 0020693
|
|
return ret;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
*
|
|
*/
|
|
//=============================================================================
|
|
|
|
CORBA::Long SMESH_MeshEditor_i::RemoveOrphanNodes()
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
// Update Python script
|
|
TPythonDump() << "nbRemoved = " << this << ".RemoveOrphanNodes()";
|
|
|
|
// 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 );
|
|
|
|
// remove orphan nodes (if there are any)
|
|
list< int > IdList;
|
|
for ( int i = 0; i < seq.size(); i++ )
|
|
IdList.push_back( seq[i] );
|
|
|
|
int nbNodesBefore = myMesh->NbNodes();
|
|
getEditor().Remove( IdList, true );
|
|
int nbNodesAfter = myMesh->NbNodes();
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/ IdList.size() == 0 ); // issue 0020693
|
|
return nbNodesBefore - nbNodesAfter;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
* Add a new node.
|
|
*/
|
|
//=============================================================================
|
|
|
|
CORBA::Long SMESH_MeshEditor_i::AddNode(CORBA::Double x,CORBA::Double y, CORBA::Double z)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
const SMDS_MeshNode* N = getMeshDS()->AddNode(x, y, z);
|
|
|
|
// Update Python script
|
|
TPythonDump() << "nodeID = " << this << ".AddNode( "
|
|
<< TVar( x ) << ", " << TVar( y ) << ", " << TVar( z )<< " )";
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
return N->GetID();
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
* Create 0D element on the given node.
|
|
*/
|
|
//=============================================================================
|
|
|
|
CORBA::Long SMESH_MeshEditor_i::Add0DElement(CORBA::Long IDOfNode)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
const SMDS_MeshNode* aNode = getMeshDS()->FindNode(IDOfNode);
|
|
SMDS_MeshElement* elem = getMeshDS()->Add0DElement(aNode);
|
|
|
|
// Update Python script
|
|
TPythonDump() << "elem0d = " << this << ".Add0DElement( " << IDOfNode <<" )";
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
|
|
return elem ? elem->GetID() : 0;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
* Create a ball element on the given node.
|
|
*/
|
|
//=============================================================================
|
|
|
|
CORBA::Long SMESH_MeshEditor_i::AddBall(CORBA::Long IDOfNode, CORBA::Double diameter)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
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);
|
|
|
|
// Update Python script
|
|
TPythonDump() << "ballElem = "
|
|
<< this << ".AddBall( " << IDOfNode << ", " << diameter <<" )";
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
return elem ? elem->GetID() : 0;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
* Create an edge, either linear and quadratic (this is determed
|
|
* by number of given nodes, two or three)
|
|
*/
|
|
//=============================================================================
|
|
|
|
CORBA::Long SMESH_MeshEditor_i::AddEdge(const SMESH::long_array & IDsOfNodes)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
int NbNodes = IDsOfNodes.length();
|
|
SMDS_MeshElement* elem = 0;
|
|
if (NbNodes == 2)
|
|
{
|
|
CORBA::Long index1 = IDsOfNodes[0];
|
|
CORBA::Long index2 = IDsOfNodes[1];
|
|
elem = getMeshDS()->AddEdge( getMeshDS()->FindNode(index1),
|
|
getMeshDS()->FindNode(index2));
|
|
|
|
// Update Python script
|
|
TPythonDump() << "edge = " << this << ".AddEdge([ "
|
|
<< index1 << ", " << index2 <<" ])";
|
|
}
|
|
if (NbNodes == 3) {
|
|
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));
|
|
// Update Python script
|
|
TPythonDump() << "edgeID = " << this << ".AddEdge([ "
|
|
<<n1<<", "<<n2<<", "<<n12<<" ])";
|
|
}
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
return elem ? elem->GetID() : 0;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
* AddFace
|
|
*/
|
|
//=============================================================================
|
|
|
|
CORBA::Long SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
int NbNodes = IDsOfNodes.length();
|
|
if (NbNodes < 3)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
std::vector<const SMDS_MeshNode*> nodes (NbNodes);
|
|
for (int i = 0; i < NbNodes; i++)
|
|
nodes[i] = getMeshDS()->FindNode(IDsOfNodes[i]);
|
|
|
|
SMDS_MeshElement* elem = 0;
|
|
switch (NbNodes) {
|
|
case 3: elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2]); break;
|
|
case 4: elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3]); break;
|
|
case 6: elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
|
|
nodes[4], nodes[5]); break;
|
|
case 7: elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
|
|
nodes[4], nodes[5], nodes[6]); break;
|
|
case 8: elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
|
|
nodes[4], nodes[5], nodes[6], nodes[7]); break;
|
|
case 9: elem = getMeshDS()->AddFace(nodes[0], nodes[1], nodes[2], nodes[3],
|
|
nodes[4], nodes[5], nodes[6], nodes[7],
|
|
nodes[8] ); break;
|
|
default: elem = getMeshDS()->AddPolygonalFace(nodes);
|
|
}
|
|
|
|
// Update Python script
|
|
TPythonDump() << "faceID = " << this << ".AddFace( " << IDsOfNodes << " )";
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
|
|
return elem ? elem->GetID() : 0;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
* AddPolygonalFace
|
|
*/
|
|
//=============================================================================
|
|
CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace (const SMESH::long_array & IDsOfNodes)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
int NbNodes = IDsOfNodes.length();
|
|
std::vector<const SMDS_MeshNode*> nodes (NbNodes);
|
|
for (int i = 0; i < NbNodes; i++)
|
|
nodes[i] = getMeshDS()->FindNode(IDsOfNodes[i]);
|
|
|
|
const SMDS_MeshElement* elem = getMeshDS()->AddPolygonalFace(nodes);
|
|
|
|
// Update Python script
|
|
TPythonDump() <<"faceID = "<<this<<".AddPolygonalFace( "<<IDsOfNodes<<" )";
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
return elem ? elem->GetID() : 0;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
* Create volume, either linear and quadratic (this is determed
|
|
* by number of given nodes)
|
|
*/
|
|
//=============================================================================
|
|
|
|
CORBA::Long SMESH_MeshEditor_i::AddVolume(const SMESH::long_array & IDsOfNodes)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
int NbNodes = IDsOfNodes.length();
|
|
vector< const SMDS_MeshNode*> n(NbNodes);
|
|
for(int i=0;i<NbNodes;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],
|
|
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],
|
|
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],
|
|
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],
|
|
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],
|
|
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],
|
|
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]);
|
|
break;
|
|
}
|
|
|
|
// Update Python script
|
|
TPythonDump() << "volID = " << this << ".AddVolume( " << IDsOfNodes << " )";
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
return elem ? elem->GetID() : 0;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
* AddPolyhedralVolume
|
|
*/
|
|
//=============================================================================
|
|
CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolume (const SMESH::long_array & IDsOfNodes,
|
|
const SMESH::long_array & Quantities)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
int NbNodes = IDsOfNodes.length();
|
|
std::vector<const SMDS_MeshNode*> n (NbNodes);
|
|
for (int i = 0; i < NbNodes; i++)
|
|
{
|
|
const SMDS_MeshNode* aNode = getMeshDS()->FindNode(IDsOfNodes[i]);
|
|
if (!aNode) return 0;
|
|
n[i] = aNode;
|
|
}
|
|
|
|
int NbFaces = Quantities.length();
|
|
std::vector<int> q (NbFaces);
|
|
for (int j = 0; j < NbFaces; j++)
|
|
q[j] = Quantities[j];
|
|
|
|
const SMDS_MeshElement* elem = getMeshDS()->AddPolyhedralVolume(n, q);
|
|
|
|
// Update Python script
|
|
TPythonDump() << "volID = " << this << ".AddPolyhedralVolume( "
|
|
<< IDsOfNodes << ", " << Quantities << " )";
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
return elem ? elem->GetID() : 0;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
* AddPolyhedralVolumeByFaces
|
|
*/
|
|
//=============================================================================
|
|
|
|
CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolumeByFaces (const SMESH::long_array & IdsOfFaces)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
int NbFaces = IdsOfFaces.length();
|
|
std::vector<const SMDS_MeshNode*> poly_nodes;
|
|
std::vector<int> quantities (NbFaces);
|
|
|
|
for (int i = 0; i < NbFaces; i++) {
|
|
const SMDS_MeshElement* aFace = getMeshDS()->FindElement(IdsOfFaces[i]);
|
|
quantities[i] = aFace->NbNodes();
|
|
|
|
SMDS_ElemIteratorPtr It = aFace->nodesIterator();
|
|
while (It->more()) {
|
|
poly_nodes.push_back(static_cast<const SMDS_MeshNode *>(It->next()));
|
|
}
|
|
}
|
|
|
|
const SMDS_MeshElement* elem = getMeshDS()->AddPolyhedralVolume(poly_nodes, quantities);
|
|
|
|
// Update Python script
|
|
TPythonDump() << "volID = " << this << ".AddPolyhedralVolumeByFaces( "
|
|
<< IdsOfFaces << " )";
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
return elem ? elem->GetID() : 0;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 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)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
SMESH::SMESH_IDSource_var result;
|
|
TPythonDump pyDump;
|
|
|
|
TIDSortedElemSet elements, elems0D;
|
|
prepareIdSource( theObject );
|
|
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 << "' )";
|
|
|
|
return result._retn();
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
* \brief Bind a node to a vertex
|
|
* \param NodeID - node ID
|
|
* \param VertexID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
|
|
* \retval boolean - false if NodeID or VertexID is invalid
|
|
*/
|
|
//=============================================================================
|
|
|
|
void SMESH_MeshEditor_i::SetNodeOnVertex(CORBA::Long NodeID, CORBA::Long VertexID)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
|
|
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);
|
|
|
|
if ( mesh->MaxShapeIndex() < VertexID )
|
|
THROW_SALOME_CORBA_EXCEPTION("Invalid VertexID", SALOME::BAD_PARAM);
|
|
|
|
TopoDS_Shape shape = mesh->IndexToShape( VertexID );
|
|
if ( shape.ShapeType() != TopAbs_VERTEX )
|
|
THROW_SALOME_CORBA_EXCEPTION("Invalid VertexID", SALOME::BAD_PARAM);
|
|
|
|
mesh->SetNodeOnVertex( node, VertexID );
|
|
|
|
myMesh->SetIsModified( true );
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
* \brief Store node position on an edge
|
|
* \param NodeID - node ID
|
|
* \param EdgeID - edge ID available through GEOM_Object.GetSubShapeIndices()[0]
|
|
* \param paramOnEdge - parameter on edge where the node is located
|
|
* \retval boolean - false if any parameter is invalid
|
|
*/
|
|
//=============================================================================
|
|
|
|
void SMESH_MeshEditor_i::SetNodeOnEdge(CORBA::Long NodeID, CORBA::Long EdgeID,
|
|
CORBA::Double paramOnEdge)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
|
|
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);
|
|
|
|
if ( mesh->MaxShapeIndex() < EdgeID )
|
|
THROW_SALOME_CORBA_EXCEPTION("Invalid EdgeID", SALOME::BAD_PARAM);
|
|
|
|
TopoDS_Shape shape = mesh->IndexToShape( EdgeID );
|
|
if ( shape.ShapeType() != TopAbs_EDGE )
|
|
THROW_SALOME_CORBA_EXCEPTION("Invalid EdgeID", SALOME::BAD_PARAM);
|
|
|
|
Standard_Real f,l;
|
|
BRep_Tool::Range( TopoDS::Edge( shape ), f,l);
|
|
if ( paramOnEdge < f || paramOnEdge > l )
|
|
THROW_SALOME_CORBA_EXCEPTION("Invalid paramOnEdge", SALOME::BAD_PARAM);
|
|
|
|
mesh->SetNodeOnEdge( node, EdgeID, paramOnEdge );
|
|
|
|
myMesh->SetIsModified( true );
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
* \brief Store node position on a face
|
|
* \param NodeID - node ID
|
|
* \param FaceID - face ID available through GEOM_Object.GetSubShapeIndices()[0]
|
|
* \param u - U parameter on face where the node is located
|
|
* \param v - V parameter on face where the node is located
|
|
* \retval boolean - false if any parameter is invalid
|
|
*/
|
|
//=============================================================================
|
|
|
|
void SMESH_MeshEditor_i::SetNodeOnFace(CORBA::Long NodeID, CORBA::Long FaceID,
|
|
CORBA::Double u, CORBA::Double v)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
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);
|
|
|
|
if ( mesh->MaxShapeIndex() < FaceID )
|
|
THROW_SALOME_CORBA_EXCEPTION("Invalid FaceID", SALOME::BAD_PARAM);
|
|
|
|
TopoDS_Shape shape = mesh->IndexToShape( FaceID );
|
|
if ( shape.ShapeType() != TopAbs_FACE )
|
|
THROW_SALOME_CORBA_EXCEPTION("Invalid FaceID", SALOME::BAD_PARAM);
|
|
|
|
BRepAdaptor_Surface surf( TopoDS::Face( shape ));
|
|
bool isOut = ( u < surf.FirstUParameter() ||
|
|
u > surf.LastUParameter() ||
|
|
v < surf.FirstVParameter() ||
|
|
v > surf.LastVParameter() );
|
|
|
|
if ( isOut ) {
|
|
#ifdef _DEBUG_
|
|
MESSAGE ( "FACE " << FaceID << " (" << u << "," << v << ") out of "
|
|
<< " u( " << surf.FirstUParameter()
|
|
<< "," << surf.LastUParameter()
|
|
<< ") v( " << surf.FirstVParameter()
|
|
<< "," << surf.LastVParameter() << ")" );
|
|
#endif
|
|
THROW_SALOME_CORBA_EXCEPTION("Invalid UV", SALOME::BAD_PARAM);
|
|
}
|
|
|
|
mesh->SetNodeOnFace( node, FaceID, u, v );
|
|
myMesh->SetIsModified( true );
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
* \brief Bind a node to a solid
|
|
* \param NodeID - node ID
|
|
* \param SolidID - vertex ID available through GEOM_Object.GetSubShapeIndices()[0]
|
|
* \retval boolean - false if NodeID or SolidID is invalid
|
|
*/
|
|
//=============================================================================
|
|
|
|
void SMESH_MeshEditor_i::SetNodeInVolume(CORBA::Long NodeID, CORBA::Long SolidID)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
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);
|
|
|
|
if ( mesh->MaxShapeIndex() < SolidID )
|
|
THROW_SALOME_CORBA_EXCEPTION("Invalid SolidID", SALOME::BAD_PARAM);
|
|
|
|
TopoDS_Shape shape = mesh->IndexToShape( SolidID );
|
|
if ( shape.ShapeType() != TopAbs_SOLID &&
|
|
shape.ShapeType() != TopAbs_SHELL)
|
|
THROW_SALOME_CORBA_EXCEPTION("Invalid SolidID", SALOME::BAD_PARAM);
|
|
|
|
mesh->SetNodeInVolume( node, SolidID );
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
* \brief Bind an element to a shape
|
|
* \param ElementID - element ID
|
|
* \param ShapeID - shape ID available through GEOM_Object.GetSubShapeIndices()[0]
|
|
*/
|
|
//=============================================================================
|
|
|
|
void SMESH_MeshEditor_i::SetMeshElementOnShape(CORBA::Long ElementID,
|
|
CORBA::Long ShapeID)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
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);
|
|
|
|
if ( mesh->MaxShapeIndex() < ShapeID || ShapeID < 1 )
|
|
THROW_SALOME_CORBA_EXCEPTION("Invalid ShapeID", SALOME::BAD_PARAM);
|
|
|
|
TopoDS_Shape shape = mesh->IndexToShape( ShapeID );
|
|
if ( shape.ShapeType() != TopAbs_EDGE &&
|
|
shape.ShapeType() != TopAbs_FACE &&
|
|
shape.ShapeType() != TopAbs_SOLID &&
|
|
shape.ShapeType() != TopAbs_SHELL )
|
|
THROW_SALOME_CORBA_EXCEPTION("Invalid shape type", SALOME::BAD_PARAM);
|
|
|
|
mesh->SetMeshElementOnShape( elem, ShapeID );
|
|
|
|
myMesh->SetIsModified( true );
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
*
|
|
*/
|
|
//=============================================================================
|
|
|
|
CORBA::Boolean SMESH_MeshEditor_i::InverseDiag(CORBA::Long NodeID1,
|
|
CORBA::Long NodeID2)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
const SMDS_MeshNode * n1 = getMeshDS()->FindNode( NodeID1 );
|
|
const SMDS_MeshNode * n2 = getMeshDS()->FindNode( NodeID2 );
|
|
if ( !n1 || !n2 )
|
|
return false;
|
|
|
|
// Update Python script
|
|
TPythonDump() << "isDone = " << this << ".InverseDiag( "
|
|
<< NodeID1 << ", " << NodeID2 << " )";
|
|
|
|
int ret = getEditor().InverseDiag ( n1, n2 );
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
return ret;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
*
|
|
*/
|
|
//=============================================================================
|
|
|
|
CORBA::Boolean SMESH_MeshEditor_i::DeleteDiag(CORBA::Long NodeID1,
|
|
CORBA::Long NodeID2)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
const SMDS_MeshNode * n1 = getMeshDS()->FindNode( NodeID1 );
|
|
const SMDS_MeshNode * n2 = getMeshDS()->FindNode( NodeID2 );
|
|
if ( !n1 || !n2 )
|
|
return false;
|
|
|
|
// Update Python script
|
|
TPythonDump() << "isDone = " << this << ".DeleteDiag( "
|
|
<< NodeID1 << ", " << NodeID2 << " )";
|
|
|
|
|
|
bool stat = getEditor().DeleteDiag ( n1, n2 );
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/!stat );
|
|
|
|
return stat;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
*
|
|
*/
|
|
//=============================================================================
|
|
|
|
CORBA::Boolean SMESH_MeshEditor_i::Reorient(const SMESH::long_array & IDsOfElements)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
for (int i = 0; i < IDsOfElements.length(); i++)
|
|
{
|
|
CORBA::Long index = IDsOfElements[i];
|
|
const SMDS_MeshElement * elem = getMeshDS()->FindElement(index);
|
|
if ( elem )
|
|
getEditor().Reorient( elem );
|
|
}
|
|
// Update Python script
|
|
TPythonDump() << "isDone = " << this << ".Reorient( " << IDsOfElements << " )";
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/ IDsOfElements.length() == 0 );
|
|
return true;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
*
|
|
*/
|
|
//=============================================================================
|
|
|
|
CORBA::Boolean SMESH_MeshEditor_i::ReorientObject(SMESH::SMESH_IDSource_ptr theObject)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
TPythonDump aTPythonDump; // suppress dump in Reorient()
|
|
|
|
prepareIdSource( theObject );
|
|
|
|
SMESH::long_array_var anElementsId = theObject->GetIDs();
|
|
CORBA::Boolean isDone = Reorient(anElementsId);
|
|
|
|
// Update Python script
|
|
aTPythonDump << "isDone = " << this << ".ReorientObject( " << theObject << " )";
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/ anElementsId->length() == 0 );
|
|
return isDone;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : Reorient2D
|
|
//purpose : Reorient faces contained in \a the2Dgroup.
|
|
// the2Dgroup - the mesh or its part to reorient
|
|
// theDirection - desired direction of normal of \a theFace
|
|
// theFace - ID of face whose orientation is checked.
|
|
// It can be < 1 then \a thePoint is used to find a face.
|
|
// thePoint - is used to find a face if \a theFace < 1.
|
|
// return number of reoriented elements.
|
|
//=======================================================================
|
|
|
|
CORBA::Long SMESH_MeshEditor_i::Reorient2D(SMESH::SMESH_IDSource_ptr the2Dgroup,
|
|
const SMESH::DirStruct& theDirection,
|
|
CORBA::Long theFace,
|
|
const SMESH::PointStruct& thePoint)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData(/*deleteSearchers=*/false);
|
|
|
|
TIDSortedElemSet elements;
|
|
prepareIdSource( the2Dgroup );
|
|
IDSource_Error error;
|
|
idSourceToSet( the2Dgroup, getMeshDS(), elements, SMDSAbs_Face, /*emptyIfIsMesh=*/1, &error );
|
|
if ( error == IDSource_EMPTY )
|
|
return 0;
|
|
if ( error == IDSource_INVALID )
|
|
THROW_SALOME_CORBA_EXCEPTION("No faces in given group", SALOME::BAD_PARAM);
|
|
|
|
|
|
const SMDS_MeshElement* face = 0;
|
|
if ( theFace > 0 )
|
|
{
|
|
face = getMeshDS()->FindElement( theFace );
|
|
if ( !face )
|
|
THROW_SALOME_CORBA_EXCEPTION("Inexistent face given", SALOME::BAD_PARAM);
|
|
if ( face->GetType() != SMDSAbs_Face )
|
|
THROW_SALOME_CORBA_EXCEPTION("Wrong element type", SALOME::BAD_PARAM);
|
|
}
|
|
else
|
|
{
|
|
// create theElementSearcher if needed
|
|
theSearchersDeleter.Set( myMesh, getPartIOR( the2Dgroup, SMESH::FACE ));
|
|
if ( !theElementSearcher )
|
|
{
|
|
if ( elements.empty() ) // search in the whole mesh
|
|
{
|
|
if ( myMesh->NbFaces() == 0 )
|
|
THROW_SALOME_CORBA_EXCEPTION("No faces in the mesh", SALOME::BAD_PARAM);
|
|
|
|
theElementSearcher = SMESH_MeshAlgos::GetElementSearcher( *getMeshDS() );
|
|
}
|
|
else
|
|
{
|
|
typedef SMDS_SetIterator<const SMDS_MeshElement*, TIDSortedElemSet::const_iterator > TIter;
|
|
SMDS_ElemIteratorPtr elemsIt( new TIter( elements.begin(), elements.end() ));
|
|
|
|
theElementSearcher = SMESH_MeshAlgos::GetElementSearcher( *getMeshDS(), elemsIt);
|
|
}
|
|
}
|
|
// find a face
|
|
gp_Pnt p( thePoint.x, thePoint.y, thePoint.z );
|
|
face = theElementSearcher->FindClosestTo( p, SMDSAbs_Face );
|
|
|
|
if ( !face )
|
|
THROW_SALOME_CORBA_EXCEPTION("No face found by point", SALOME::INTERNAL_ERROR );
|
|
if ( !elements.empty() && !elements.count( face ))
|
|
THROW_SALOME_CORBA_EXCEPTION("Found face is not in the group", SALOME::BAD_PARAM );
|
|
}
|
|
|
|
const SMESH::PointStruct * P = &theDirection.PS;
|
|
gp_Vec dirVec( P->x, P->y, P->z );
|
|
if ( dirVec.Magnitude() < std::numeric_limits< double >::min() )
|
|
THROW_SALOME_CORBA_EXCEPTION("Zero size vector", SALOME::BAD_PARAM);
|
|
|
|
int nbReori = getEditor().Reorient2D( elements, dirVec, face );
|
|
|
|
if ( nbReori ) {
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
}
|
|
TPythonDump() << this << ".Reorient2D( "
|
|
<< the2Dgroup << ", "
|
|
<< theDirection << ", "
|
|
<< theFace << ", "
|
|
<< thePoint << " )";
|
|
|
|
return nbReori;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : Reorient2DBy3D
|
|
//purpose : Reorient faces basing on orientation of adjacent volumes.
|
|
//=======================================================================
|
|
|
|
CORBA::Long SMESH_MeshEditor_i::Reorient2DBy3D(const SMESH::ListOfIDSources& faceGroups,
|
|
SMESH::SMESH_IDSource_ptr volumeGroup,
|
|
CORBA::Boolean outsideNormal)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
TIDSortedElemSet volumes;
|
|
prepareIdSource( volumeGroup );
|
|
IDSource_Error volsError;
|
|
idSourceToSet( volumeGroup, getMeshDS(), volumes, SMDSAbs_Volume, /*emptyIfMesh=*/1, &volsError);
|
|
|
|
int nbReori = 0;
|
|
for ( size_t i = 0; i < faceGroups.length(); ++i )
|
|
{
|
|
SMESH::SMESH_IDSource_ptr faceGrp = faceGroups[i].in();
|
|
prepareIdSource( faceGrp );
|
|
|
|
TIDSortedElemSet faces;
|
|
IDSource_Error error;
|
|
idSourceToSet( faceGrp, getMeshDS(), faces, SMDSAbs_Face, /*emptyIfIsMesh=*/1, &error );
|
|
if ( error == IDSource_INVALID && faceGroups.length() == 1 )
|
|
THROW_SALOME_CORBA_EXCEPTION("No faces in a given object", SALOME::BAD_PARAM);
|
|
if ( error == IDSource_OK && volsError != IDSource_OK )
|
|
THROW_SALOME_CORBA_EXCEPTION("No volumes in a given object", SALOME::BAD_PARAM);
|
|
|
|
nbReori += getEditor().Reorient2DBy3D( faces, volumes, outsideNormal );
|
|
|
|
if ( error != IDSource_EMPTY && faces.empty() ) // all faces in the mesh treated
|
|
break;
|
|
}
|
|
|
|
if ( nbReori ) {
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
}
|
|
TPythonDump() << this << ".Reorient2DBy3D( "
|
|
<< faceGroups << ", "
|
|
<< volumeGroup << ", "
|
|
<< outsideNormal << " )";
|
|
|
|
return nbReori;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
* \brief Fuse neighbour triangles into quadrangles.
|
|
*/
|
|
//=============================================================================
|
|
|
|
CORBA::Boolean SMESH_MeshEditor_i::TriToQuad (const SMESH::long_array & IDsOfElements,
|
|
SMESH::NumericalFunctor_ptr Criterion,
|
|
CORBA::Double MaxAngle)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
SMESHDS_Mesh* aMesh = getMeshDS();
|
|
TIDSortedElemSet faces,copyFaces;
|
|
SMDS_MeshElement::GeomFilter triaFilter(SMDSGeom_TRIANGLE);
|
|
arrayToSet(IDsOfElements, aMesh, faces, SMDSAbs_Face, & triaFilter);
|
|
TIDSortedElemSet* workElements = & faces;
|
|
|
|
if ( myIsPreviewMode ) {
|
|
SMDSAbs_ElementType select = SMDSAbs_Face;
|
|
getPreviewMesh( SMDSAbs_Face )->Copy( faces, copyFaces, select );
|
|
workElements = & copyFaces;
|
|
}
|
|
|
|
SMESH::NumericalFunctor_i* aNumericalFunctor =
|
|
dynamic_cast<SMESH::NumericalFunctor_i*>( SMESH_Gen_i::GetServant( Criterion ).in() );
|
|
SMESH::Controls::NumericalFunctorPtr aCrit;
|
|
if ( !aNumericalFunctor )
|
|
aCrit.reset( new SMESH::Controls::MaxElementLength2D() );
|
|
else
|
|
aCrit = aNumericalFunctor->GetNumericalFunctor();
|
|
|
|
if ( !myIsPreviewMode ) {
|
|
// Update Python script
|
|
TPythonDump() << "isDone = " << this << ".TriToQuad( "
|
|
<< IDsOfElements << ", " << aNumericalFunctor << ", " << TVar( MaxAngle ) << " )";
|
|
}
|
|
|
|
bool stat = getEditor().TriToQuad( *workElements, aCrit, MaxAngle );
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/!stat );
|
|
return stat;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
* \brief Fuse neighbour triangles into quadrangles.
|
|
*/
|
|
//=============================================================================
|
|
|
|
CORBA::Boolean SMESH_MeshEditor_i::TriToQuadObject (SMESH::SMESH_IDSource_ptr theObject,
|
|
SMESH::NumericalFunctor_ptr Criterion,
|
|
CORBA::Double MaxAngle)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
TPythonDump aTPythonDump; // suppress dump in TriToQuad()
|
|
|
|
prepareIdSource( theObject );
|
|
SMESH::long_array_var anElementsId = theObject->GetIDs();
|
|
CORBA::Boolean isDone = TriToQuad(anElementsId, Criterion, MaxAngle);
|
|
|
|
if ( !myIsPreviewMode ) {
|
|
SMESH::NumericalFunctor_i* aNumericalFunctor =
|
|
SMESH::DownCast<SMESH::NumericalFunctor_i*>( Criterion );
|
|
|
|
// Update Python script
|
|
aTPythonDump << "isDone = " << this << ".TriToQuadObject("
|
|
<< theObject << ", " << aNumericalFunctor << ", " << TVar( MaxAngle ) << " )";
|
|
}
|
|
|
|
return isDone;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
* \brief Split quadrangles into triangles.
|
|
*/
|
|
//=============================================================================
|
|
|
|
CORBA::Boolean SMESH_MeshEditor_i::QuadToTri (const SMESH::long_array & IDsOfElements,
|
|
SMESH::NumericalFunctor_ptr Criterion)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
SMESHDS_Mesh* aMesh = getMeshDS();
|
|
TIDSortedElemSet faces;
|
|
arrayToSet(IDsOfElements, aMesh, faces, SMDSAbs_Face);
|
|
|
|
SMESH::NumericalFunctor_i* aNumericalFunctor =
|
|
dynamic_cast<SMESH::NumericalFunctor_i*>( SMESH_Gen_i::GetServant( Criterion ).in() );
|
|
SMESH::Controls::NumericalFunctorPtr aCrit;
|
|
if ( !aNumericalFunctor )
|
|
aCrit.reset( new SMESH::Controls::AspectRatio() );
|
|
else
|
|
aCrit = aNumericalFunctor->GetNumericalFunctor();
|
|
|
|
|
|
// Update Python script
|
|
TPythonDump() << "isDone = " << this << ".QuadToTri( " << IDsOfElements << ", " << aNumericalFunctor << " )";
|
|
|
|
CORBA::Boolean stat = getEditor().QuadToTri( faces, aCrit );
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
return stat;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
* \brief Split quadrangles into triangles.
|
|
*/
|
|
//=============================================================================
|
|
|
|
CORBA::Boolean SMESH_MeshEditor_i::QuadToTriObject (SMESH::SMESH_IDSource_ptr theObject,
|
|
SMESH::NumericalFunctor_ptr Criterion)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
TPythonDump aTPythonDump; // suppress dump in QuadToTri()
|
|
|
|
prepareIdSource( theObject );
|
|
SMESH::long_array_var anElementsId = theObject->GetIDs();
|
|
CORBA::Boolean isDone = QuadToTri(anElementsId, Criterion);
|
|
|
|
SMESH::NumericalFunctor_i* aNumericalFunctor =
|
|
SMESH::DownCast<SMESH::NumericalFunctor_i*>( Criterion );
|
|
|
|
// Update Python script
|
|
aTPythonDump << "isDone = " << this << ".QuadToTriObject( " << theObject << ", " << aNumericalFunctor << " )";
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
return isDone;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Split each of quadrangles into 4 triangles.
|
|
* \param [in] theObject - theQuads Container of quadrangles to split.
|
|
*/
|
|
//================================================================================
|
|
|
|
void SMESH_MeshEditor_i::QuadTo4Tri (SMESH::SMESH_IDSource_ptr theObject)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
TIDSortedElemSet faces;
|
|
prepareIdSource( theObject );
|
|
if ( !idSourceToSet( theObject, getMeshDS(), faces, SMDSAbs_Face, /*emptyIfIsMesh=*/true ) &&
|
|
faces.empty() )
|
|
THROW_SALOME_CORBA_EXCEPTION("No faces given", SALOME::BAD_PARAM);
|
|
|
|
getEditor().QuadTo4Tri( faces );
|
|
TPythonDump() << this << ".QuadTo4Tri( " << theObject << " )";
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
* \brief Split quadrangles into triangles.
|
|
*/
|
|
//=============================================================================
|
|
|
|
CORBA::Boolean SMESH_MeshEditor_i::SplitQuad (const SMESH::long_array & IDsOfElements,
|
|
CORBA::Boolean Diag13)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
SMESHDS_Mesh* aMesh = getMeshDS();
|
|
TIDSortedElemSet faces;
|
|
arrayToSet(IDsOfElements, aMesh, faces, SMDSAbs_Face);
|
|
|
|
// Update Python script
|
|
TPythonDump() << "isDone = " << this << ".SplitQuad( "
|
|
<< IDsOfElements << ", " << Diag13 << " )";
|
|
|
|
CORBA::Boolean stat = getEditor().QuadToTri( faces, Diag13 );
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/ !stat );
|
|
return stat;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
* \brief Split quadrangles into triangles.
|
|
*/
|
|
//=============================================================================
|
|
|
|
CORBA::Boolean SMESH_MeshEditor_i::SplitQuadObject (SMESH::SMESH_IDSource_ptr theObject,
|
|
CORBA::Boolean Diag13)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
TPythonDump aTPythonDump; // suppress dump in SplitQuad()
|
|
|
|
prepareIdSource( theObject );
|
|
SMESH::long_array_var anElementsId = theObject->GetIDs();
|
|
CORBA::Boolean isDone = SplitQuad(anElementsId, Diag13);
|
|
|
|
// Update Python script
|
|
aTPythonDump << "isDone = " << this << ".SplitQuadObject( "
|
|
<< theObject << ", " << Diag13 << " )";
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/!isDone );
|
|
return isDone;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
|
|
//=============================================================================
|
|
/*!
|
|
* Find better splitting of the given quadrangle.
|
|
* \param IDOfQuad ID of the quadrangle to be splitted.
|
|
* \param Criterion A criterion to choose a diagonal for splitting.
|
|
* \return 1 if 1-3 diagonal is better, 2 if 2-4
|
|
* diagonal is better, 0 if error occurs.
|
|
*/
|
|
//=============================================================================
|
|
|
|
CORBA::Long SMESH_MeshEditor_i::BestSplit (CORBA::Long IDOfQuad,
|
|
SMESH::NumericalFunctor_ptr Criterion)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
const SMDS_MeshElement* quad = getMeshDS()->FindElement(IDOfQuad);
|
|
if (quad && quad->GetType() == SMDSAbs_Face && quad->NbNodes() == 4)
|
|
{
|
|
SMESH::NumericalFunctor_i* aNumericalFunctor =
|
|
dynamic_cast<SMESH::NumericalFunctor_i*>(SMESH_Gen_i::GetServant(Criterion).in());
|
|
SMESH::Controls::NumericalFunctorPtr aCrit;
|
|
if (aNumericalFunctor)
|
|
aCrit = aNumericalFunctor->GetNumericalFunctor();
|
|
else
|
|
aCrit.reset(new SMESH::Controls::AspectRatio());
|
|
|
|
int id = getEditor().BestSplit(quad, aCrit);
|
|
declareMeshModified( /*isReComputeSafe=*/ id < 1 );
|
|
return id;
|
|
}
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Split volumic elements into tetrahedrons
|
|
*/
|
|
//================================================================================
|
|
|
|
void SMESH_MeshEditor_i::SplitVolumesIntoTetra (SMESH::SMESH_IDSource_ptr elems,
|
|
CORBA::Short methodFlags)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
prepareIdSource( elems );
|
|
|
|
::SMESH_MeshEditor::TFacetOfElem elemSet;
|
|
const int noneFacet = -1;
|
|
SMDS_ElemIteratorPtr volIt = myMesh_i->GetElements( elems, SMESH::VOLUME );
|
|
while( volIt->more() )
|
|
elemSet.insert( elemSet.end(), make_pair( volIt->next(), noneFacet ));
|
|
|
|
getEditor().SplitVolumes( elemSet, int( methodFlags ));
|
|
declareMeshModified( /*isReComputeSafe=*/true ); // it does not influence Compute()
|
|
|
|
TPythonDump() << this << ".SplitVolumesIntoTetra( "
|
|
<< elems << ", " << methodFlags << " )";
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Split hexahedra into triangular prisms
|
|
* \param elems - elements to split
|
|
* \param facetToSplitNormal - normal used to find a facet of hexahedron
|
|
* to split into triangles
|
|
* \param methodFlags - flags passing splitting method:
|
|
* 1 - split the hexahedron into 2 prisms
|
|
* 2 - split the hexahedron into 4 prisms
|
|
*/
|
|
//================================================================================
|
|
|
|
void SMESH_MeshEditor_i::SplitHexahedraIntoPrisms (SMESH::SMESH_IDSource_ptr elems,
|
|
const SMESH::PointStruct & startHexPoint,
|
|
const SMESH::DirStruct& facetToSplitNormal,
|
|
CORBA::Short methodFlags,
|
|
CORBA::Boolean allDomains)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
prepareIdSource( elems );
|
|
|
|
gp_Ax1 facetNorm( gp_Pnt( startHexPoint.x,
|
|
startHexPoint.y,
|
|
startHexPoint.z ),
|
|
gp_Dir( facetToSplitNormal.PS.x,
|
|
facetToSplitNormal.PS.y,
|
|
facetToSplitNormal.PS.z ));
|
|
TIDSortedElemSet elemSet;
|
|
SMESH::long_array_var anElementsId = elems->GetIDs();
|
|
SMDS_MeshElement::GeomFilter filter( SMDSGeom_HEXA );
|
|
arrayToSet( anElementsId, getMeshDS(), elemSet, SMDSAbs_Volume, &filter );
|
|
|
|
::SMESH_MeshEditor::TFacetOfElem elemFacets;
|
|
while ( !elemSet.empty() )
|
|
{
|
|
getEditor().GetHexaFacetsToSplit( elemSet, facetNorm, elemFacets );
|
|
if ( !allDomains )
|
|
break;
|
|
|
|
::SMESH_MeshEditor::TFacetOfElem::iterator ef = elemFacets.begin();
|
|
for ( ; ef != elemFacets.end(); ++ef )
|
|
elemSet.erase( ef->first );
|
|
}
|
|
|
|
if ( methodFlags == 2 )
|
|
methodFlags = int( ::SMESH_MeshEditor::HEXA_TO_4_PRISMS );
|
|
else
|
|
methodFlags = int( ::SMESH_MeshEditor::HEXA_TO_2_PRISMS );
|
|
|
|
getEditor().SplitVolumes( elemFacets, int( methodFlags ));
|
|
declareMeshModified( /*isReComputeSafe=*/true ); // it does not influence Compute()
|
|
|
|
TPythonDump() << this << ".SplitHexahedraIntoPrisms( "
|
|
<< elems << ", "
|
|
<< startHexPoint << ", "
|
|
<< facetToSplitNormal<< ", "
|
|
<< methodFlags<< ", "
|
|
<< allDomains << " )";
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : Smooth
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
CORBA::Boolean
|
|
SMESH_MeshEditor_i::Smooth(const SMESH::long_array & IDsOfElements,
|
|
const SMESH::long_array & IDsOfFixedNodes,
|
|
CORBA::Long MaxNbOfIterations,
|
|
CORBA::Double MaxAspectRatio,
|
|
SMESH::SMESH_MeshEditor::Smooth_Method Method)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
|
|
MaxAspectRatio, Method, false );
|
|
}
|
|
|
|
|
|
//=======================================================================
|
|
//function : SmoothParametric
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
CORBA::Boolean
|
|
SMESH_MeshEditor_i::SmoothParametric(const SMESH::long_array & IDsOfElements,
|
|
const SMESH::long_array & IDsOfFixedNodes,
|
|
CORBA::Long MaxNbOfIterations,
|
|
CORBA::Double MaxAspectRatio,
|
|
SMESH::SMESH_MeshEditor::Smooth_Method Method)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
return smooth( IDsOfElements, IDsOfFixedNodes, MaxNbOfIterations,
|
|
MaxAspectRatio, Method, true );
|
|
}
|
|
|
|
|
|
//=======================================================================
|
|
//function : SmoothObject
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
CORBA::Boolean
|
|
SMESH_MeshEditor_i::SmoothObject(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::long_array & IDsOfFixedNodes,
|
|
CORBA::Long MaxNbOfIterations,
|
|
CORBA::Double MaxAspectRatio,
|
|
SMESH::SMESH_MeshEditor::Smooth_Method Method)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
|
|
MaxAspectRatio, Method, false);
|
|
}
|
|
|
|
|
|
//=======================================================================
|
|
//function : SmoothParametricObject
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
CORBA::Boolean
|
|
SMESH_MeshEditor_i::SmoothParametricObject(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::long_array & IDsOfFixedNodes,
|
|
CORBA::Long MaxNbOfIterations,
|
|
CORBA::Double MaxAspectRatio,
|
|
SMESH::SMESH_MeshEditor::Smooth_Method Method)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
return smoothObject (theObject, IDsOfFixedNodes, MaxNbOfIterations,
|
|
MaxAspectRatio, Method, true);
|
|
}
|
|
|
|
|
|
//=============================================================================
|
|
/*!
|
|
*
|
|
*/
|
|
//=============================================================================
|
|
|
|
CORBA::Boolean
|
|
SMESH_MeshEditor_i::smooth(const SMESH::long_array & IDsOfElements,
|
|
const SMESH::long_array & IDsOfFixedNodes,
|
|
CORBA::Long MaxNbOfIterations,
|
|
CORBA::Double MaxAspectRatio,
|
|
SMESH::SMESH_MeshEditor::Smooth_Method Method,
|
|
bool IsParametric)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
SMESHDS_Mesh* aMesh = getMeshDS();
|
|
|
|
TIDSortedElemSet elements;
|
|
arrayToSet(IDsOfElements, aMesh, elements, SMDSAbs_Face);
|
|
|
|
set<const SMDS_MeshNode*> fixedNodes;
|
|
for (int i = 0; i < IDsOfFixedNodes.length(); i++) {
|
|
CORBA::Long index = IDsOfFixedNodes[i];
|
|
const SMDS_MeshNode * node = aMesh->FindNode(index);
|
|
if ( node )
|
|
fixedNodes.insert( node );
|
|
}
|
|
::SMESH_MeshEditor::SmoothMethod method = ::SMESH_MeshEditor::LAPLACIAN;
|
|
if ( Method != SMESH::SMESH_MeshEditor::LAPLACIAN_SMOOTH )
|
|
method = ::SMESH_MeshEditor::CENTROIDAL;
|
|
|
|
getEditor().Smooth(elements, fixedNodes, method,
|
|
MaxNbOfIterations, MaxAspectRatio, IsParametric );
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/true ); // does not prevent re-compute
|
|
|
|
// Update Python script
|
|
TPythonDump() << "isDone = " << this << "."
|
|
<< (IsParametric ? "SmoothParametric( " : "Smooth( ")
|
|
<< IDsOfElements << ", " << IDsOfFixedNodes << ", "
|
|
<< TVar( MaxNbOfIterations ) << ", " << TVar( MaxAspectRatio ) << ", "
|
|
<< "SMESH.SMESH_MeshEditor."
|
|
<< ( Method == SMESH::SMESH_MeshEditor::CENTROIDAL_SMOOTH ?
|
|
"CENTROIDAL_SMOOTH )" : "LAPLACIAN_SMOOTH )");
|
|
|
|
return true;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
*
|
|
*/
|
|
//=============================================================================
|
|
|
|
CORBA::Boolean
|
|
SMESH_MeshEditor_i::smoothObject(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::long_array & IDsOfFixedNodes,
|
|
CORBA::Long MaxNbOfIterations,
|
|
CORBA::Double MaxAspectRatio,
|
|
SMESH::SMESH_MeshEditor::Smooth_Method Method,
|
|
bool IsParametric)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
TPythonDump aTPythonDump; // suppress dump in smooth()
|
|
|
|
prepareIdSource( theObject );
|
|
SMESH::long_array_var anElementsId = theObject->GetIDs();
|
|
CORBA::Boolean isDone = smooth (anElementsId, IDsOfFixedNodes, MaxNbOfIterations,
|
|
MaxAspectRatio, Method, IsParametric);
|
|
|
|
// Update Python script
|
|
aTPythonDump << "isDone = " << this << "."
|
|
<< (IsParametric ? "SmoothParametricObject( " : "SmoothObject( ")
|
|
<< theObject << ", " << IDsOfFixedNodes << ", "
|
|
<< TVar( MaxNbOfIterations ) << ", " << TVar( MaxAspectRatio ) << ", "
|
|
<< "SMESH.SMESH_MeshEditor."
|
|
<< ( Method == SMESH::SMESH_MeshEditor::CENTROIDAL_SMOOTH ?
|
|
"CENTROIDAL_SMOOTH )" : "LAPLACIAN_SMOOTH )");
|
|
|
|
return isDone;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
*
|
|
*/
|
|
//=============================================================================
|
|
|
|
void SMESH_MeshEditor_i::RenumberNodes()
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
// Update Python script
|
|
TPythonDump() << this << ".RenumberNodes()";
|
|
|
|
getMeshDS()->Renumber( true );
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
*
|
|
*/
|
|
//=============================================================================
|
|
|
|
void SMESH_MeshEditor_i::RenumberElements()
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
// Update Python script
|
|
TPythonDump() << this << ".RenumberElements()";
|
|
|
|
getMeshDS()->Renumber( false );
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
}
|
|
|
|
//=======================================================================
|
|
/*!
|
|
* \brief Return groups by their IDs
|
|
*/
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups* SMESH_MeshEditor_i::getGroups(const std::list<int>* groupIDs)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
if ( !groupIDs )
|
|
return 0;
|
|
myMesh_i->CreateGroupServants();
|
|
return myMesh_i->GetGroups( *groupIDs );
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : rotationSweep
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::rotationSweep(const SMESH::long_array & theIDsOfElements,
|
|
const SMESH::AxisStruct & theAxis,
|
|
CORBA::Double theAngleInRadians,
|
|
CORBA::Long theNbOfSteps,
|
|
CORBA::Double theTolerance,
|
|
const bool theMakeGroups,
|
|
const SMDSAbs_ElementType theElementType)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
TIDSortedElemSet inElements, copyElements;
|
|
arrayToSet(theIDsOfElements, getMeshDS(), inElements, theElementType);
|
|
|
|
TIDSortedElemSet* workElements = & inElements;
|
|
bool makeWalls=true;
|
|
if ( myIsPreviewMode )
|
|
{
|
|
SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
|
|
getPreviewMesh( SMDSAbs_Face )->Copy( inElements, copyElements, select, avoid );
|
|
workElements = & copyElements;
|
|
//makeWalls = false;
|
|
}
|
|
|
|
gp_Ax1 Ax1 (gp_Pnt( theAxis.x, theAxis.y, theAxis.z ),
|
|
gp_Vec( theAxis.vx, theAxis.vy, theAxis.vz ));
|
|
|
|
::SMESH_MeshEditor::PGroupIDs groupIds =
|
|
getEditor().RotationSweep (*workElements, Ax1, theAngleInRadians,
|
|
theNbOfSteps, theTolerance, theMakeGroups, makeWalls);
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/true ); // does not influence Compute()
|
|
|
|
return theMakeGroups ? getGroups(groupIds.get()) : 0;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : RotationSweep
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::RotationSweep(const SMESH::long_array & theIDsOfElements,
|
|
const SMESH::AxisStruct & theAxis,
|
|
CORBA::Double theAngleInRadians,
|
|
CORBA::Long theNbOfSteps,
|
|
CORBA::Double theTolerance)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
if ( !myIsPreviewMode ) {
|
|
TPythonDump() << this << ".RotationSweep( "
|
|
<< theIDsOfElements << ", "
|
|
<< theAxis << ", "
|
|
<< TVar( theAngleInRadians ) << ", "
|
|
<< TVar( theNbOfSteps ) << ", "
|
|
<< TVar( theTolerance ) << " )";
|
|
}
|
|
rotationSweep(theIDsOfElements,
|
|
theAxis,
|
|
theAngleInRadians,
|
|
theNbOfSteps,
|
|
theTolerance,
|
|
false);
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : RotationSweepMakeGroups
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::RotationSweepMakeGroups(const SMESH::long_array& theIDsOfElements,
|
|
const SMESH::AxisStruct& theAxis,
|
|
CORBA::Double theAngleInRadians,
|
|
CORBA::Long theNbOfSteps,
|
|
CORBA::Double theTolerance)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
|
|
|
|
SMESH::ListOfGroups *aGroups = rotationSweep(theIDsOfElements,
|
|
theAxis,
|
|
theAngleInRadians,
|
|
theNbOfSteps,
|
|
theTolerance,
|
|
true);
|
|
if (!myIsPreviewMode) {
|
|
dumpGroupsList(aPythonDump, aGroups);
|
|
aPythonDump << this << ".RotationSweepMakeGroups( "
|
|
<< theIDsOfElements << ", "
|
|
<< theAxis << ", "
|
|
<< TVar( theAngleInRadians ) << ", "
|
|
<< TVar( theNbOfSteps ) << ", "
|
|
<< TVar( theTolerance ) << " )";
|
|
}
|
|
return aGroups;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : RotationSweepObject
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::RotationSweepObject(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::AxisStruct & theAxis,
|
|
CORBA::Double theAngleInRadians,
|
|
CORBA::Long theNbOfSteps,
|
|
CORBA::Double theTolerance)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
if ( !myIsPreviewMode ) {
|
|
TPythonDump() << this << ".RotationSweepObject( "
|
|
<< theObject << ", "
|
|
<< theAxis << ", "
|
|
<< theAngleInRadians << ", "
|
|
<< theNbOfSteps << ", "
|
|
<< theTolerance << " )";
|
|
}
|
|
prepareIdSource( theObject );
|
|
SMESH::long_array_var anElementsId = theObject->GetIDs();
|
|
rotationSweep(anElementsId,
|
|
theAxis,
|
|
theAngleInRadians,
|
|
theNbOfSteps,
|
|
theTolerance,
|
|
false);
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : RotationSweepObject1D
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::RotationSweepObject1D(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::AxisStruct & theAxis,
|
|
CORBA::Double theAngleInRadians,
|
|
CORBA::Long theNbOfSteps,
|
|
CORBA::Double theTolerance)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
if ( !myIsPreviewMode ) {
|
|
TPythonDump() << this << ".RotationSweepObject1D( "
|
|
<< theObject << ", "
|
|
<< theAxis << ", "
|
|
<< TVar( theAngleInRadians ) << ", "
|
|
<< TVar( theNbOfSteps ) << ", "
|
|
<< TVar( theTolerance ) << " )";
|
|
}
|
|
prepareIdSource( theObject );
|
|
SMESH::long_array_var anElementsId = theObject->GetIDs();
|
|
rotationSweep(anElementsId,
|
|
theAxis,
|
|
theAngleInRadians,
|
|
theNbOfSteps,
|
|
theTolerance,
|
|
false,
|
|
SMDSAbs_Edge);
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : RotationSweepObject2D
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::RotationSweepObject2D(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::AxisStruct & theAxis,
|
|
CORBA::Double theAngleInRadians,
|
|
CORBA::Long theNbOfSteps,
|
|
CORBA::Double theTolerance)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
if ( !myIsPreviewMode ) {
|
|
TPythonDump() << this << ".RotationSweepObject2D( "
|
|
<< theObject << ", "
|
|
<< theAxis << ", "
|
|
<< TVar( theAngleInRadians ) << ", "
|
|
<< TVar( theNbOfSteps ) << ", "
|
|
<< TVar( theTolerance ) << " )";
|
|
}
|
|
prepareIdSource( theObject );
|
|
SMESH::long_array_var anElementsId = theObject->GetIDs();
|
|
rotationSweep(anElementsId,
|
|
theAxis,
|
|
theAngleInRadians,
|
|
theNbOfSteps,
|
|
theTolerance,
|
|
false,
|
|
SMDSAbs_Face);
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : RotationSweepObjectMakeGroups
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::RotationSweepObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::AxisStruct& theAxis,
|
|
CORBA::Double theAngleInRadians,
|
|
CORBA::Long theNbOfSteps,
|
|
CORBA::Double theTolerance)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
|
|
|
|
prepareIdSource( theObject );
|
|
SMESH::long_array_var anElementsId = theObject->GetIDs();
|
|
SMESH::ListOfGroups *aGroups = rotationSweep(anElementsId,
|
|
theAxis,
|
|
theAngleInRadians,
|
|
theNbOfSteps,
|
|
theTolerance,
|
|
true);
|
|
if (!myIsPreviewMode) {
|
|
dumpGroupsList(aPythonDump, aGroups);
|
|
aPythonDump << this << ".RotationSweepObjectMakeGroups( "
|
|
<< theObject << ", "
|
|
<< theAxis << ", "
|
|
<< theAngleInRadians << ", "
|
|
<< theNbOfSteps << ", "
|
|
<< theTolerance << " )";
|
|
}
|
|
return aGroups;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : RotationSweepObject1DMakeGroups
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::RotationSweepObject1DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::AxisStruct& theAxis,
|
|
CORBA::Double theAngleInRadians,
|
|
CORBA::Long theNbOfSteps,
|
|
CORBA::Double theTolerance)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
|
|
|
|
prepareIdSource( theObject );
|
|
SMESH::long_array_var anElementsId = theObject->GetIDs();
|
|
SMESH::ListOfGroups *aGroups = rotationSweep(anElementsId,
|
|
theAxis,
|
|
theAngleInRadians,
|
|
theNbOfSteps,
|
|
theTolerance,
|
|
true,
|
|
SMDSAbs_Edge);
|
|
if (!myIsPreviewMode) {
|
|
dumpGroupsList(aPythonDump, aGroups);
|
|
aPythonDump << this << ".RotationSweepObject1DMakeGroups( "
|
|
<< theObject << ", "
|
|
<< theAxis << ", "
|
|
<< TVar( theAngleInRadians ) << ", "
|
|
<< TVar( theNbOfSteps ) << ", "
|
|
<< TVar( theTolerance ) << " )";
|
|
}
|
|
return aGroups;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : RotationSweepObject2DMakeGroups
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::RotationSweepObject2DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::AxisStruct& theAxis,
|
|
CORBA::Double theAngleInRadians,
|
|
CORBA::Long theNbOfSteps,
|
|
CORBA::Double theTolerance)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
|
|
|
|
prepareIdSource( theObject );
|
|
SMESH::long_array_var anElementsId = theObject->GetIDs();
|
|
SMESH::ListOfGroups *aGroups = rotationSweep(anElementsId,
|
|
theAxis,
|
|
theAngleInRadians,
|
|
theNbOfSteps,
|
|
theTolerance,
|
|
true,
|
|
SMDSAbs_Face);
|
|
if (!myIsPreviewMode) {
|
|
dumpGroupsList(aPythonDump, aGroups);
|
|
aPythonDump << this << ".RotationSweepObject2DMakeGroups( "
|
|
<< theObject << ", "
|
|
<< theAxis << ", "
|
|
<< TVar( theAngleInRadians ) << ", "
|
|
<< TVar( theNbOfSteps ) << ", "
|
|
<< TVar( theTolerance ) << " )";
|
|
}
|
|
return aGroups;
|
|
}
|
|
|
|
namespace MeshEditor_I
|
|
{
|
|
/*!
|
|
* \brief Structure used to pass extrusion parameters to ::SMESH_MeshEditor
|
|
*/
|
|
struct ExtrusionParams : public ::SMESH_MeshEditor::ExtrusParam
|
|
{
|
|
bool myIsExtrusionByNormal;
|
|
|
|
static int makeFlags( CORBA::Boolean MakeGroups,
|
|
CORBA::Boolean ByAverageNormal = false,
|
|
CORBA::Boolean UseInputElemsOnly = false,
|
|
CORBA::Long Flags = 0,
|
|
CORBA::Boolean MakeBoundary = true )
|
|
{
|
|
if ( MakeGroups ) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_GROUPS;
|
|
if ( ByAverageNormal ) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_BY_AVG_NORMAL;
|
|
if ( UseInputElemsOnly) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_USE_INPUT_ELEMS_ONLY;
|
|
if ( MakeBoundary ) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_BOUNDARY;
|
|
return Flags;
|
|
}
|
|
// standard params
|
|
ExtrusionParams(const SMESH::DirStruct & theDir,
|
|
CORBA::Long theNbOfSteps,
|
|
CORBA::Boolean theMakeGroups):
|
|
::SMESH_MeshEditor::ExtrusParam ( gp_Vec( theDir.PS.x,
|
|
theDir.PS.y,
|
|
theDir.PS.z ),
|
|
theNbOfSteps,
|
|
makeFlags( theMakeGroups )),
|
|
myIsExtrusionByNormal( false )
|
|
{
|
|
}
|
|
// advanced params
|
|
ExtrusionParams(const SMESH::DirStruct & theDir,
|
|
CORBA::Long theNbOfSteps,
|
|
CORBA::Boolean theMakeGroups,
|
|
CORBA::Long theExtrFlags,
|
|
CORBA::Double theSewTolerance):
|
|
::SMESH_MeshEditor::ExtrusParam ( gp_Vec( theDir.PS.x,
|
|
theDir.PS.y,
|
|
theDir.PS.z ),
|
|
theNbOfSteps,
|
|
makeFlags( theMakeGroups, false, false,
|
|
theExtrFlags, false ),
|
|
theSewTolerance ),
|
|
myIsExtrusionByNormal( false )
|
|
{
|
|
}
|
|
// params for extrusion by normal
|
|
ExtrusionParams(CORBA::Double theStepSize,
|
|
CORBA::Long theNbOfSteps,
|
|
CORBA::Short theDim,
|
|
CORBA::Boolean theUseInputElemsOnly,
|
|
CORBA::Boolean theByAverageNormal,
|
|
CORBA::Boolean theMakeGroups ):
|
|
::SMESH_MeshEditor::ExtrusParam ( theStepSize,
|
|
theNbOfSteps,
|
|
makeFlags( theMakeGroups,
|
|
theByAverageNormal, theUseInputElemsOnly ),
|
|
theDim),
|
|
myIsExtrusionByNormal( true )
|
|
{
|
|
}
|
|
|
|
void SetNoGroups()
|
|
{
|
|
Flags() &= ~(::SMESH_MeshEditor::EXTRUSION_FLAG_GROUPS);
|
|
}
|
|
};
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : extrusionSweep
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::extrusionSweep(const SMESH::long_array & theIDsOfElements,
|
|
MeshEditor_I::ExtrusionParams& theParams,
|
|
const SMDSAbs_ElementType theElementType)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
TIDSortedElemSet elements, copyElements;
|
|
arrayToSet( theIDsOfElements, getMeshDS(), elements, theElementType );
|
|
|
|
TIDSortedElemSet* workElements = & elements;
|
|
|
|
if ( myIsPreviewMode )
|
|
{
|
|
SMDSAbs_ElementType previewType = SMDSAbs_Face;
|
|
if (theElementType == SMDSAbs_Node)
|
|
previewType = SMDSAbs_Edge;
|
|
|
|
SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
|
|
getPreviewMesh( previewType )->Copy( elements, copyElements, select, avoid );
|
|
workElements = & copyElements;
|
|
theParams.SetNoGroups();
|
|
|
|
if ( theParams.myIsExtrusionByNormal && !theParams.ToUseInpElemsOnly() )
|
|
{
|
|
TIDSortedElemSet elemsAround, elemsAroundCopy;
|
|
getElementsAround( elements, getMeshDS(), elemsAround );
|
|
getPreviewMesh( previewType )->Copy( elemsAround, elemsAroundCopy, select, avoid );
|
|
}
|
|
}
|
|
|
|
::SMESH_MeshEditor::TTElemOfElemListMap aHystory;
|
|
::SMESH_MeshEditor::PGroupIDs groupIds =
|
|
getEditor().ExtrusionSweep (*workElements, theParams, aHystory );
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/true ); // does not influence Compute()
|
|
|
|
return theParams.ToMakeGroups() ? getGroups(groupIds.get()) : 0;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ExtrusionSweep
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::ExtrusionSweep(const SMESH::long_array & theIDsOfElements,
|
|
const SMESH::DirStruct & theStepVector,
|
|
CORBA::Long theNbOfSteps)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
ExtrusionParams params( theStepVector, theNbOfSteps, false );
|
|
extrusionSweep( theIDsOfElements, params );
|
|
if (!myIsPreviewMode) {
|
|
TPythonDump() << this << ".ExtrusionSweep( "
|
|
<< theIDsOfElements << ", " << theStepVector <<", " << TVar(theNbOfSteps) << " )";
|
|
}
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ExtrusionSweep0D
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::ExtrusionSweep0D(const SMESH::long_array & theIDsOfElements,
|
|
const SMESH::DirStruct & theStepVector,
|
|
CORBA::Long theNbOfSteps)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
ExtrusionParams params( theStepVector, theNbOfSteps, false );
|
|
extrusionSweep( theIDsOfElements, params, SMDSAbs_Node );
|
|
if (!myIsPreviewMode) {
|
|
TPythonDump() << this << ".ExtrusionSweep0D( "
|
|
<< theIDsOfElements << ", " << theStepVector <<", " << TVar(theNbOfSteps)<< " )";
|
|
}
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ExtrusionSweepObject
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::ExtrusionSweepObject(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::DirStruct & theStepVector,
|
|
CORBA::Long theNbOfSteps)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
prepareIdSource( theObject );
|
|
SMESH::long_array_var anElementsId = theObject->GetIDs();
|
|
ExtrusionParams params( theStepVector, theNbOfSteps, false );
|
|
extrusionSweep( anElementsId, params );
|
|
if (!myIsPreviewMode) {
|
|
TPythonDump() << this << ".ExtrusionSweepObject( "
|
|
<< theObject << ", " << theStepVector << ", " << theNbOfSteps << " )";
|
|
}
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ExtrusionSweepObject0D
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::ExtrusionSweepObject0D(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::DirStruct & theStepVector,
|
|
CORBA::Long theNbOfSteps)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
prepareIdSource( theObject );
|
|
SMESH::long_array_var anElementsId = theObject->GetIDs();
|
|
if ( anElementsId->length() == 0 )
|
|
if ( SMESH_Mesh_i* mesh = SMESH::DownCast<SMESH_Mesh_i*>( theObject ))
|
|
anElementsId = mesh->GetNodesId();
|
|
|
|
ExtrusionParams params( theStepVector, theNbOfSteps, false );
|
|
extrusionSweep( anElementsId, params, SMDSAbs_Node );
|
|
if ( !myIsPreviewMode ) {
|
|
TPythonDump() << this << ".ExtrusionSweepObject0D( "
|
|
<< theObject << ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
|
|
}
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ExtrusionSweepObject1D
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::ExtrusionSweepObject1D(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::DirStruct & theStepVector,
|
|
CORBA::Long theNbOfSteps)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
prepareIdSource( theObject );
|
|
SMESH::long_array_var anElementsId = theObject->GetIDs();
|
|
ExtrusionParams params( theStepVector, theNbOfSteps, false );
|
|
extrusionSweep( anElementsId, params, SMDSAbs_Edge );
|
|
if ( !myIsPreviewMode ) {
|
|
TPythonDump() << this << ".ExtrusionSweepObject1D( "
|
|
<< theObject << ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
|
|
}
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ExtrusionSweepObject2D
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::ExtrusionSweepObject2D(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::DirStruct & theStepVector,
|
|
CORBA::Long theNbOfSteps)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
prepareIdSource( theObject );
|
|
SMESH::long_array_var anElementsId = theObject->GetIDs();
|
|
ExtrusionParams params( theStepVector, theNbOfSteps, false );
|
|
extrusionSweep( anElementsId, params, SMDSAbs_Face );
|
|
if ( !myIsPreviewMode ) {
|
|
TPythonDump() << this << ".ExtrusionSweepObject2D( "
|
|
<< theObject << ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
|
|
}
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ExtrusionSweepMakeGroups
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::ExtrusionSweepMakeGroups(const SMESH::long_array& theIDsOfElements,
|
|
const SMESH::DirStruct& theStepVector,
|
|
CORBA::Long theNbOfSteps)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
|
|
|
|
ExtrusionParams params( theStepVector, theNbOfSteps, true );
|
|
SMESH::ListOfGroups* aGroups = extrusionSweep( theIDsOfElements, params );
|
|
|
|
if (!myIsPreviewMode) {
|
|
dumpGroupsList(aPythonDump, aGroups);
|
|
aPythonDump << this << ".ExtrusionSweepMakeGroups( " << theIDsOfElements
|
|
<< ", " << theStepVector <<", " << TVar( theNbOfSteps ) << " )";
|
|
}
|
|
return aGroups;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ExtrusionSweepMakeGroups0D
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::ExtrusionSweepMakeGroups0D(const SMESH::long_array& theIDsOfElements,
|
|
const SMESH::DirStruct& theStepVector,
|
|
CORBA::Long theNbOfSteps)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
|
|
|
|
ExtrusionParams params( theStepVector, theNbOfSteps, true );
|
|
SMESH::ListOfGroups* aGroups = extrusionSweep( theIDsOfElements, params, SMDSAbs_Node );
|
|
|
|
if (!myIsPreviewMode) {
|
|
dumpGroupsList(aPythonDump, aGroups);
|
|
aPythonDump << this << ".ExtrusionSweepMakeGroups0D( " << theIDsOfElements
|
|
<< ", " << theStepVector <<", " << TVar( theNbOfSteps ) << " )";
|
|
}
|
|
return aGroups;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ExtrusionSweepObjectMakeGroups
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::ExtrusionSweepObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::DirStruct& theStepVector,
|
|
CORBA::Long theNbOfSteps)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
|
|
|
|
prepareIdSource( theObject );
|
|
SMESH::long_array_var anElementsId = theObject->GetIDs();
|
|
ExtrusionParams params( theStepVector, theNbOfSteps, true );
|
|
SMESH::ListOfGroups* aGroups = extrusionSweep( anElementsId, params );
|
|
|
|
if (!myIsPreviewMode) {
|
|
dumpGroupsList(aPythonDump, aGroups);
|
|
aPythonDump << this << ".ExtrusionSweepObjectMakeGroups( " << theObject
|
|
<< ", " << theStepVector << ", " << theNbOfSteps << " )";
|
|
}
|
|
return aGroups;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ExtrusionSweepObject0DMakeGroups
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::ExtrusionSweepObject0DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::DirStruct& theStepVector,
|
|
CORBA::Long theNbOfSteps)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
|
|
|
|
prepareIdSource( theObject );
|
|
SMESH::long_array_var anElementsId = theObject->GetIDs();
|
|
ExtrusionParams params( theStepVector, theNbOfSteps, true );
|
|
SMESH::ListOfGroups* aGroups = extrusionSweep( anElementsId, params, SMDSAbs_Node );
|
|
|
|
if (!myIsPreviewMode) {
|
|
dumpGroupsList(aPythonDump, aGroups);
|
|
aPythonDump << this << ".ExtrusionSweepObject0DMakeGroups( " << theObject
|
|
<< ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
|
|
}
|
|
return aGroups;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ExtrusionSweepObject1DMakeGroups
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::ExtrusionSweepObject1DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::DirStruct& theStepVector,
|
|
CORBA::Long theNbOfSteps)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
|
|
|
|
prepareIdSource( theObject );
|
|
SMESH::long_array_var anElementsId = theObject->GetIDs();
|
|
ExtrusionParams params( theStepVector, theNbOfSteps, true );
|
|
SMESH::ListOfGroups* aGroups = extrusionSweep( anElementsId, params, SMDSAbs_Edge );
|
|
|
|
if (!myIsPreviewMode) {
|
|
dumpGroupsList(aPythonDump, aGroups);
|
|
aPythonDump << this << ".ExtrusionSweepObject1DMakeGroups( " << theObject
|
|
<< ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
|
|
}
|
|
return aGroups;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ExtrusionSweepObject2DMakeGroups
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::ExtrusionSweepObject2DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::DirStruct& theStepVector,
|
|
CORBA::Long theNbOfSteps)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
|
|
|
|
prepareIdSource( theObject );
|
|
SMESH::long_array_var anElementsId = theObject->GetIDs();
|
|
ExtrusionParams params( theStepVector, theNbOfSteps, true );
|
|
SMESH::ListOfGroups* aGroups = extrusionSweep( anElementsId, params, SMDSAbs_Face );
|
|
|
|
if (!myIsPreviewMode) {
|
|
dumpGroupsList(aPythonDump, aGroups);
|
|
aPythonDump << this << ".ExtrusionSweepObject2DMakeGroups( " << theObject
|
|
<< ", " << theStepVector << ", " << TVar( theNbOfSteps ) << " )";
|
|
}
|
|
return aGroups;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ExtrusionByNormal
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::ExtrusionByNormal(SMESH::SMESH_IDSource_ptr object,
|
|
CORBA::Double stepSize,
|
|
CORBA::Long nbOfSteps,
|
|
CORBA::Boolean byAverageNormal,
|
|
CORBA::Boolean useInputElemsOnly,
|
|
CORBA::Boolean makeGroups,
|
|
CORBA::Short dim)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
|
|
|
|
ExtrusionParams params( stepSize, nbOfSteps, dim,
|
|
byAverageNormal, useInputElemsOnly, makeGroups );
|
|
|
|
SMDSAbs_ElementType elemType = ( dim == 1 ? SMDSAbs_Edge : SMDSAbs_Face );
|
|
if ( !SMESH::DownCast<SMESH_Mesh_i*>( object ))
|
|
{
|
|
SMESH::array_of_ElementType_var elemTypes = object->GetTypes();
|
|
if (( elemTypes->length() == 1 ) &&
|
|
( elemTypes[0] == SMESH::EDGE || elemTypes[0] == SMESH::FACE ))
|
|
elemType = ( SMDSAbs_ElementType ) elemTypes[0];
|
|
}
|
|
prepareIdSource( object );
|
|
SMESH::long_array_var anElementsId = object->GetIDs();
|
|
SMESH::ListOfGroups* aGroups = extrusionSweep( anElementsId, params, elemType );
|
|
|
|
if (!myIsPreviewMode) {
|
|
dumpGroupsList(aPythonDump, aGroups);
|
|
aPythonDump << this << ".ExtrusionByNormal( " << object
|
|
<< ", " << TVar( stepSize )
|
|
<< ", " << TVar( nbOfSteps )
|
|
<< ", " << byAverageNormal
|
|
<< ", " << makeGroups
|
|
<< ", " << dim
|
|
<< " )";
|
|
}
|
|
return aGroups ? aGroups : new SMESH::ListOfGroups;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : AdvancedExtrusion
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::AdvancedExtrusion(const SMESH::long_array & theIDsOfElements,
|
|
const SMESH::DirStruct & theStepVector,
|
|
CORBA::Long theNbOfSteps,
|
|
CORBA::Long theExtrFlags,
|
|
CORBA::Double theSewTolerance)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
ExtrusionParams params( theStepVector, theNbOfSteps, false, theExtrFlags, theSewTolerance);
|
|
extrusionSweep( theIDsOfElements, params );
|
|
|
|
if ( !myIsPreviewMode ) {
|
|
TPythonDump() << "stepVector = " << theStepVector;
|
|
TPythonDump() << this << ".AdvancedExtrusion("
|
|
<< theIDsOfElements
|
|
<< ", stepVector, "
|
|
<< theNbOfSteps << ","
|
|
<< theExtrFlags << ", "
|
|
<< theSewTolerance << " )";
|
|
}
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : AdvancedExtrusionMakeGroups
|
|
//purpose :
|
|
//=======================================================================
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::AdvancedExtrusionMakeGroups(const SMESH::long_array& theIDsOfElements,
|
|
const SMESH::DirStruct& theStepVector,
|
|
CORBA::Long theNbOfSteps,
|
|
CORBA::Long theExtrFlags,
|
|
CORBA::Double theSewTolerance)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
if (!myIsPreviewMode) {
|
|
TPythonDump() << "stepVector = " << theStepVector;
|
|
}
|
|
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
|
|
|
|
ExtrusionParams params( theStepVector, theNbOfSteps, true, theExtrFlags, theSewTolerance);
|
|
SMESH::ListOfGroups * aGroups = extrusionSweep( theIDsOfElements, params );
|
|
|
|
if (!myIsPreviewMode) {
|
|
dumpGroupsList(aPythonDump, aGroups);
|
|
aPythonDump << this << ".AdvancedExtrusionMakeGroups("
|
|
<< theIDsOfElements
|
|
<< ", stepVector, "
|
|
<< theNbOfSteps << ","
|
|
<< theExtrFlags << ", "
|
|
<< theSewTolerance << " )";
|
|
}
|
|
return aGroups;
|
|
}
|
|
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Convert extrusion error to IDL enum
|
|
*/
|
|
//================================================================================
|
|
|
|
#define RETCASE(enm) case ::SMESH_MeshEditor::enm: return SMESH::SMESH_MeshEditor::enm;
|
|
|
|
static SMESH::SMESH_MeshEditor::Extrusion_Error convExtrError( const::SMESH_MeshEditor::Extrusion_Error e )
|
|
{
|
|
switch ( e ) {
|
|
RETCASE( EXTR_OK );
|
|
RETCASE( EXTR_NO_ELEMENTS );
|
|
RETCASE( EXTR_PATH_NOT_EDGE );
|
|
RETCASE( EXTR_BAD_PATH_SHAPE );
|
|
RETCASE( EXTR_BAD_STARTING_NODE );
|
|
RETCASE( EXTR_BAD_ANGLES_NUMBER );
|
|
RETCASE( EXTR_CANT_GET_TANGENT );
|
|
}
|
|
return SMESH::SMESH_MeshEditor::EXTR_OK;
|
|
}
|
|
|
|
|
|
//=======================================================================
|
|
//function : extrusionAlongPath
|
|
//purpose :
|
|
//=======================================================================
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::extrusionAlongPath(const SMESH::long_array & theIDsOfElements,
|
|
SMESH::SMESH_Mesh_ptr thePathMesh,
|
|
GEOM::GEOM_Object_ptr thePathShape,
|
|
CORBA::Long theNodeStart,
|
|
CORBA::Boolean theHasAngles,
|
|
const SMESH::double_array & theAngles,
|
|
CORBA::Boolean theHasRefPoint,
|
|
const SMESH::PointStruct & theRefPoint,
|
|
const bool theMakeGroups,
|
|
SMESH::SMESH_MeshEditor::Extrusion_Error & theError,
|
|
const SMDSAbs_ElementType theElementType)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
MESSAGE("extrusionAlongPath");
|
|
initData();
|
|
|
|
if ( thePathMesh->_is_nil() || thePathShape->_is_nil() ) {
|
|
theError = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
|
|
return 0;
|
|
}
|
|
SMESH_Mesh_i* aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( thePathMesh );
|
|
|
|
TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( thePathShape );
|
|
SMESH_subMesh* aSubMesh = aMeshImp->GetImpl().GetSubMesh( aShape );
|
|
|
|
if ( !aSubMesh || !aSubMesh->GetSubMeshDS()) {
|
|
theError = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
|
|
return 0;
|
|
}
|
|
|
|
SMDS_MeshNode* nodeStart = (SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(theNodeStart);
|
|
if ( !nodeStart ) {
|
|
theError = SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE;
|
|
return 0;
|
|
}
|
|
|
|
TIDSortedElemSet elements;
|
|
arrayToSet(theIDsOfElements, getMeshDS(), elements, theElementType);
|
|
|
|
list<double> angles;
|
|
for (int i = 0; i < theAngles.length(); i++) {
|
|
angles.push_back( theAngles[i] );
|
|
}
|
|
|
|
gp_Pnt refPnt( theRefPoint.x, theRefPoint.y, theRefPoint.z );
|
|
|
|
int nbOldGroups = myMesh->NbGroup();
|
|
|
|
::SMESH_MeshEditor::Extrusion_Error error =
|
|
getEditor().ExtrusionAlongTrack( elements, aSubMesh, nodeStart,
|
|
theHasAngles, angles, false,
|
|
theHasRefPoint, refPnt, theMakeGroups );
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/true );
|
|
theError = convExtrError( error );
|
|
|
|
if ( theMakeGroups ) {
|
|
list<int> groupIDs = myMesh->GetGroupIds();
|
|
list<int>::iterator newBegin = groupIDs.begin();
|
|
std::advance( newBegin, nbOldGroups ); // skip old groups
|
|
groupIDs.erase( groupIDs.begin(), newBegin );
|
|
return getGroups( & groupIDs );
|
|
}
|
|
return 0;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : extrusionAlongPathX
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::extrusionAlongPathX(const SMESH::long_array & IDsOfElements,
|
|
SMESH::SMESH_IDSource_ptr Path,
|
|
CORBA::Long NodeStart,
|
|
CORBA::Boolean HasAngles,
|
|
const SMESH::double_array& Angles,
|
|
CORBA::Boolean LinearVariation,
|
|
CORBA::Boolean HasRefPoint,
|
|
const SMESH::PointStruct& RefPoint,
|
|
bool MakeGroups,
|
|
const SMDSAbs_ElementType ElementType,
|
|
SMESH::SMESH_MeshEditor::Extrusion_Error & Error)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
SMESH::ListOfGroups* EmptyGr = new SMESH::ListOfGroups;
|
|
|
|
initData();
|
|
|
|
list<double> angles;
|
|
for (int i = 0; i < Angles.length(); i++) {
|
|
angles.push_back( Angles[i] );
|
|
}
|
|
gp_Pnt refPnt( RefPoint.x, RefPoint.y, RefPoint.z );
|
|
int nbOldGroups = myMesh->NbGroup();
|
|
|
|
if ( Path->_is_nil() ) {
|
|
Error = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
|
|
return EmptyGr;
|
|
}
|
|
|
|
TIDSortedElemSet elements, copyElements;
|
|
arrayToSet(IDsOfElements, getMeshDS(), elements, ElementType);
|
|
|
|
TIDSortedElemSet* workElements = &elements;
|
|
|
|
if ( myIsPreviewMode )
|
|
{
|
|
SMDSAbs_ElementType select = SMDSAbs_All, avoid = SMDSAbs_Volume;
|
|
getPreviewMesh( SMDSAbs_Face )->Copy( elements, copyElements, select, avoid );
|
|
workElements = & copyElements;
|
|
MakeGroups = false;
|
|
}
|
|
|
|
::SMESH_MeshEditor::Extrusion_Error error;
|
|
|
|
if ( SMESH_Mesh_i* aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( Path ))
|
|
{
|
|
// path as mesh
|
|
SMDS_MeshNode* aNodeStart =
|
|
(SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(NodeStart);
|
|
if ( !aNodeStart ) {
|
|
Error = SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE;
|
|
return EmptyGr;
|
|
}
|
|
error = getEditor().ExtrusionAlongTrack( *workElements, &(aMeshImp->GetImpl()), aNodeStart,
|
|
HasAngles, angles, LinearVariation,
|
|
HasRefPoint, refPnt, MakeGroups );
|
|
declareMeshModified( /*isReComputeSafe=*/true );
|
|
}
|
|
else if ( SMESH_subMesh_i* aSubMeshImp = SMESH::DownCast<SMESH_subMesh_i*>( Path ))
|
|
{
|
|
// path as submesh
|
|
SMESH::SMESH_Mesh_ptr aPathMesh = aSubMeshImp->GetFather();
|
|
aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( aPathMesh );
|
|
SMDS_MeshNode* aNodeStart =
|
|
(SMDS_MeshNode*)aMeshImp->GetImpl().GetMeshDS()->FindNode(NodeStart);
|
|
if ( !aNodeStart ) {
|
|
Error = SMESH::SMESH_MeshEditor::EXTR_BAD_STARTING_NODE;
|
|
return EmptyGr;
|
|
}
|
|
SMESH_subMesh* aSubMesh =
|
|
aMeshImp->GetImpl().GetSubMeshContaining(aSubMeshImp->GetId());
|
|
error = getEditor().ExtrusionAlongTrack( *workElements, aSubMesh, aNodeStart,
|
|
HasAngles, angles, LinearVariation,
|
|
HasRefPoint, refPnt, MakeGroups );
|
|
declareMeshModified( /*isReComputeSafe=*/true );
|
|
}
|
|
else if ( SMESH::DownCast<SMESH_Group_i*>( Path ))
|
|
{
|
|
// path as group of 1D elements
|
|
// ????????
|
|
}
|
|
else
|
|
{
|
|
// invalid path
|
|
Error = SMESH::SMESH_MeshEditor::EXTR_BAD_PATH_SHAPE;
|
|
return EmptyGr;
|
|
}
|
|
|
|
Error = convExtrError( error );
|
|
|
|
if ( MakeGroups ) {
|
|
list<int> groupIDs = myMesh->GetGroupIds();
|
|
list<int>::iterator newBegin = groupIDs.begin();
|
|
std::advance( newBegin, nbOldGroups ); // skip old groups
|
|
groupIDs.erase( groupIDs.begin(), newBegin );
|
|
return getGroups( & groupIDs );
|
|
}
|
|
return EmptyGr;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ExtrusionAlongPath
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::SMESH_MeshEditor::Extrusion_Error
|
|
SMESH_MeshEditor_i::ExtrusionAlongPath(const SMESH::long_array & theIDsOfElements,
|
|
SMESH::SMESH_Mesh_ptr thePathMesh,
|
|
GEOM::GEOM_Object_ptr thePathShape,
|
|
CORBA::Long theNodeStart,
|
|
CORBA::Boolean theHasAngles,
|
|
const SMESH::double_array & theAngles,
|
|
CORBA::Boolean theHasRefPoint,
|
|
const SMESH::PointStruct & theRefPoint)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
MESSAGE("ExtrusionAlongPath");
|
|
if ( !myIsPreviewMode ) {
|
|
TPythonDump() << "error = " << this << ".ExtrusionAlongPath( "
|
|
<< theIDsOfElements << ", "
|
|
<< thePathMesh << ", "
|
|
<< thePathShape << ", "
|
|
<< theNodeStart << ", "
|
|
<< theHasAngles << ", "
|
|
<< theAngles << ", "
|
|
<< theHasRefPoint << ", "
|
|
<< "SMESH.PointStruct( "
|
|
<< ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
|
|
<< ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
|
|
<< ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
|
|
}
|
|
SMESH::SMESH_MeshEditor::Extrusion_Error anError;
|
|
extrusionAlongPath( theIDsOfElements,
|
|
thePathMesh,
|
|
thePathShape,
|
|
theNodeStart,
|
|
theHasAngles,
|
|
theAngles,
|
|
theHasRefPoint,
|
|
theRefPoint,
|
|
false,
|
|
anError);
|
|
return anError;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ExtrusionAlongPathObject
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::SMESH_MeshEditor::Extrusion_Error
|
|
SMESH_MeshEditor_i::ExtrusionAlongPathObject(SMESH::SMESH_IDSource_ptr theObject,
|
|
SMESH::SMESH_Mesh_ptr thePathMesh,
|
|
GEOM::GEOM_Object_ptr thePathShape,
|
|
CORBA::Long theNodeStart,
|
|
CORBA::Boolean theHasAngles,
|
|
const SMESH::double_array & theAngles,
|
|
CORBA::Boolean theHasRefPoint,
|
|
const SMESH::PointStruct & theRefPoint)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
if ( !myIsPreviewMode ) {
|
|
TPythonDump() << "error = " << this << ".ExtrusionAlongPathObject( "
|
|
<< theObject << ", "
|
|
<< thePathMesh << ", "
|
|
<< thePathShape << ", "
|
|
<< theNodeStart << ", "
|
|
<< theHasAngles << ", "
|
|
<< theAngles << ", "
|
|
<< theHasRefPoint << ", "
|
|
<< "SMESH.PointStruct( "
|
|
<< ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
|
|
<< ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
|
|
<< ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
|
|
}
|
|
SMESH::SMESH_MeshEditor::Extrusion_Error anError;
|
|
prepareIdSource( theObject );
|
|
SMESH::long_array_var anElementsId = theObject->GetIDs();
|
|
extrusionAlongPath( anElementsId,
|
|
thePathMesh,
|
|
thePathShape,
|
|
theNodeStart,
|
|
theHasAngles,
|
|
theAngles,
|
|
theHasRefPoint,
|
|
theRefPoint,
|
|
false,
|
|
anError);
|
|
return anError;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ExtrusionAlongPathObject1D
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::SMESH_MeshEditor::Extrusion_Error
|
|
SMESH_MeshEditor_i::ExtrusionAlongPathObject1D(SMESH::SMESH_IDSource_ptr theObject,
|
|
SMESH::SMESH_Mesh_ptr thePathMesh,
|
|
GEOM::GEOM_Object_ptr thePathShape,
|
|
CORBA::Long theNodeStart,
|
|
CORBA::Boolean theHasAngles,
|
|
const SMESH::double_array & theAngles,
|
|
CORBA::Boolean theHasRefPoint,
|
|
const SMESH::PointStruct & theRefPoint)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
if ( !myIsPreviewMode ) {
|
|
TPythonDump() << "error = " << this << ".ExtrusionAlongPathObject1D( "
|
|
<< theObject << ", "
|
|
<< thePathMesh << ", "
|
|
<< thePathShape << ", "
|
|
<< theNodeStart << ", "
|
|
<< theHasAngles << ", "
|
|
<< theAngles << ", "
|
|
<< theHasRefPoint << ", "
|
|
<< "SMESH.PointStruct( "
|
|
<< ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
|
|
<< ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
|
|
<< ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
|
|
}
|
|
SMESH::SMESH_MeshEditor::Extrusion_Error anError;
|
|
prepareIdSource( theObject );
|
|
SMESH::long_array_var anElementsId = theObject->GetIDs();
|
|
extrusionAlongPath( anElementsId,
|
|
thePathMesh,
|
|
thePathShape,
|
|
theNodeStart,
|
|
theHasAngles,
|
|
theAngles,
|
|
theHasRefPoint,
|
|
theRefPoint,
|
|
false,
|
|
anError,
|
|
SMDSAbs_Edge);
|
|
return anError;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ExtrusionAlongPathObject2D
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::SMESH_MeshEditor::Extrusion_Error
|
|
SMESH_MeshEditor_i::ExtrusionAlongPathObject2D(SMESH::SMESH_IDSource_ptr theObject,
|
|
SMESH::SMESH_Mesh_ptr thePathMesh,
|
|
GEOM::GEOM_Object_ptr thePathShape,
|
|
CORBA::Long theNodeStart,
|
|
CORBA::Boolean theHasAngles,
|
|
const SMESH::double_array & theAngles,
|
|
CORBA::Boolean theHasRefPoint,
|
|
const SMESH::PointStruct & theRefPoint)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
if ( !myIsPreviewMode ) {
|
|
TPythonDump() << "error = " << this << ".ExtrusionAlongPathObject2D( "
|
|
<< theObject << ", "
|
|
<< thePathMesh << ", "
|
|
<< thePathShape << ", "
|
|
<< theNodeStart << ", "
|
|
<< theHasAngles << ", "
|
|
<< theAngles << ", "
|
|
<< theHasRefPoint << ", "
|
|
<< "SMESH.PointStruct( "
|
|
<< ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
|
|
<< ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
|
|
<< ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
|
|
}
|
|
SMESH::SMESH_MeshEditor::Extrusion_Error anError;
|
|
prepareIdSource( theObject );
|
|
SMESH::long_array_var anElementsId = theObject->GetIDs();
|
|
extrusionAlongPath( anElementsId,
|
|
thePathMesh,
|
|
thePathShape,
|
|
theNodeStart,
|
|
theHasAngles,
|
|
theAngles,
|
|
theHasRefPoint,
|
|
theRefPoint,
|
|
false,
|
|
anError,
|
|
SMDSAbs_Face);
|
|
return anError;
|
|
}
|
|
|
|
|
|
//=======================================================================
|
|
//function : ExtrusionAlongPathMakeGroups
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::ExtrusionAlongPathMakeGroups(const SMESH::long_array& theIDsOfElements,
|
|
SMESH::SMESH_Mesh_ptr thePathMesh,
|
|
GEOM::GEOM_Object_ptr thePathShape,
|
|
CORBA::Long theNodeStart,
|
|
CORBA::Boolean theHasAngles,
|
|
const SMESH::double_array& theAngles,
|
|
CORBA::Boolean theHasRefPoint,
|
|
const SMESH::PointStruct& theRefPoint,
|
|
SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
|
|
|
|
SMESH::ListOfGroups * aGroups = extrusionAlongPath( theIDsOfElements,
|
|
thePathMesh,
|
|
thePathShape,
|
|
theNodeStart,
|
|
theHasAngles,
|
|
theAngles,
|
|
theHasRefPoint,
|
|
theRefPoint,
|
|
true,
|
|
Error);
|
|
if (!myIsPreviewMode) {
|
|
bool isDumpGroups = aGroups && aGroups->length() > 0;
|
|
if (isDumpGroups)
|
|
aPythonDump << "(" << aGroups << ", error)";
|
|
else
|
|
aPythonDump <<"error";
|
|
|
|
aPythonDump<<" = "<< this << ".ExtrusionAlongPathMakeGroups( "
|
|
<< theIDsOfElements << ", "
|
|
<< thePathMesh << ", "
|
|
<< thePathShape << ", "
|
|
<< theNodeStart << ", "
|
|
<< theHasAngles << ", "
|
|
<< theAngles << ", "
|
|
<< theHasRefPoint << ", "
|
|
<< "SMESH.PointStruct( "
|
|
<< ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
|
|
<< ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
|
|
<< ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
|
|
}
|
|
return aGroups;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ExtrusionAlongPathObjectMakeGroups
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups* SMESH_MeshEditor_i::
|
|
ExtrusionAlongPathObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
|
|
SMESH::SMESH_Mesh_ptr thePathMesh,
|
|
GEOM::GEOM_Object_ptr thePathShape,
|
|
CORBA::Long theNodeStart,
|
|
CORBA::Boolean theHasAngles,
|
|
const SMESH::double_array& theAngles,
|
|
CORBA::Boolean theHasRefPoint,
|
|
const SMESH::PointStruct& theRefPoint,
|
|
SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
|
|
|
|
prepareIdSource( theObject );
|
|
SMESH::long_array_var anElementsId = theObject->GetIDs();
|
|
SMESH::ListOfGroups * aGroups = extrusionAlongPath( anElementsId,
|
|
thePathMesh,
|
|
thePathShape,
|
|
theNodeStart,
|
|
theHasAngles,
|
|
theAngles,
|
|
theHasRefPoint,
|
|
theRefPoint,
|
|
true,
|
|
Error);
|
|
|
|
if (!myIsPreviewMode) {
|
|
bool isDumpGroups = aGroups && aGroups->length() > 0;
|
|
if (isDumpGroups)
|
|
aPythonDump << "(" << aGroups << ", error)";
|
|
else
|
|
aPythonDump <<"error";
|
|
|
|
aPythonDump << " = " << this << ".ExtrusionAlongPathObjectMakeGroups( "
|
|
<< theObject << ", "
|
|
<< thePathMesh << ", "
|
|
<< thePathShape << ", "
|
|
<< theNodeStart << ", "
|
|
<< theHasAngles << ", "
|
|
<< theAngles << ", "
|
|
<< theHasRefPoint << ", "
|
|
<< "SMESH.PointStruct( "
|
|
<< ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
|
|
<< ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
|
|
<< ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
|
|
}
|
|
return aGroups;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ExtrusionAlongPathObject1DMakeGroups
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups* SMESH_MeshEditor_i::
|
|
ExtrusionAlongPathObject1DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
|
|
SMESH::SMESH_Mesh_ptr thePathMesh,
|
|
GEOM::GEOM_Object_ptr thePathShape,
|
|
CORBA::Long theNodeStart,
|
|
CORBA::Boolean theHasAngles,
|
|
const SMESH::double_array& theAngles,
|
|
CORBA::Boolean theHasRefPoint,
|
|
const SMESH::PointStruct& theRefPoint,
|
|
SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
|
|
|
|
prepareIdSource( theObject );
|
|
SMESH::long_array_var anElementsId = theObject->GetIDs();
|
|
SMESH::ListOfGroups * aGroups = extrusionAlongPath( anElementsId,
|
|
thePathMesh,
|
|
thePathShape,
|
|
theNodeStart,
|
|
theHasAngles,
|
|
theAngles,
|
|
theHasRefPoint,
|
|
theRefPoint,
|
|
true,
|
|
Error,
|
|
SMDSAbs_Edge);
|
|
|
|
if (!myIsPreviewMode) {
|
|
bool isDumpGroups = aGroups && aGroups->length() > 0;
|
|
if (isDumpGroups)
|
|
aPythonDump << "(" << aGroups << ", error)";
|
|
else
|
|
aPythonDump << "error";
|
|
|
|
aPythonDump << " = " << this << ".ExtrusionAlongPathObject1DMakeGroups( "
|
|
<< theObject << ", "
|
|
<< thePathMesh << ", "
|
|
<< thePathShape << ", "
|
|
<< theNodeStart << ", "
|
|
<< theHasAngles << ", "
|
|
<< theAngles << ", "
|
|
<< theHasRefPoint << ", "
|
|
<< "SMESH.PointStruct( "
|
|
<< ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
|
|
<< ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
|
|
<< ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
|
|
}
|
|
return aGroups;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ExtrusionAlongPathObject2DMakeGroups
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups* SMESH_MeshEditor_i::
|
|
ExtrusionAlongPathObject2DMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
|
|
SMESH::SMESH_Mesh_ptr thePathMesh,
|
|
GEOM::GEOM_Object_ptr thePathShape,
|
|
CORBA::Long theNodeStart,
|
|
CORBA::Boolean theHasAngles,
|
|
const SMESH::double_array& theAngles,
|
|
CORBA::Boolean theHasRefPoint,
|
|
const SMESH::PointStruct& theRefPoint,
|
|
SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
|
|
|
|
prepareIdSource( theObject );
|
|
SMESH::long_array_var anElementsId = theObject->GetIDs();
|
|
SMESH::ListOfGroups * aGroups = extrusionAlongPath( anElementsId,
|
|
thePathMesh,
|
|
thePathShape,
|
|
theNodeStart,
|
|
theHasAngles,
|
|
theAngles,
|
|
theHasRefPoint,
|
|
theRefPoint,
|
|
true,
|
|
Error,
|
|
SMDSAbs_Face);
|
|
|
|
if (!myIsPreviewMode) {
|
|
bool isDumpGroups = aGroups && aGroups->length() > 0;
|
|
if (isDumpGroups)
|
|
aPythonDump << "(" << aGroups << ", error)";
|
|
else
|
|
aPythonDump << "error";
|
|
|
|
aPythonDump << " = " << this << ".ExtrusionAlongPathObject2DMakeGroups( "
|
|
<< theObject << ", "
|
|
<< thePathMesh << ", "
|
|
<< thePathShape << ", "
|
|
<< theNodeStart << ", "
|
|
<< theHasAngles << ", "
|
|
<< theAngles << ", "
|
|
<< theHasRefPoint << ", "
|
|
<< "SMESH.PointStruct( "
|
|
<< ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
|
|
<< ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
|
|
<< ( theHasRefPoint ? theRefPoint.z : 0 ) << " ) )";
|
|
}
|
|
return aGroups;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ExtrusionAlongPathObjX
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups* SMESH_MeshEditor_i::
|
|
ExtrusionAlongPathObjX(SMESH::SMESH_IDSource_ptr Object,
|
|
SMESH::SMESH_IDSource_ptr Path,
|
|
CORBA::Long NodeStart,
|
|
CORBA::Boolean HasAngles,
|
|
const SMESH::double_array& Angles,
|
|
CORBA::Boolean LinearVariation,
|
|
CORBA::Boolean HasRefPoint,
|
|
const SMESH::PointStruct& RefPoint,
|
|
CORBA::Boolean MakeGroups,
|
|
SMESH::ElementType ElemType,
|
|
SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
|
|
|
|
prepareIdSource( Object );
|
|
SMESH::long_array_var anElementsId = Object->GetIDs();
|
|
SMESH::ListOfGroups * aGroups = extrusionAlongPathX(anElementsId,
|
|
Path,
|
|
NodeStart,
|
|
HasAngles,
|
|
Angles,
|
|
LinearVariation,
|
|
HasRefPoint,
|
|
RefPoint,
|
|
MakeGroups,
|
|
(SMDSAbs_ElementType)ElemType,
|
|
Error);
|
|
|
|
if (!myIsPreviewMode) {
|
|
bool isDumpGroups = aGroups && aGroups->length() > 0;
|
|
if (isDumpGroups)
|
|
aPythonDump << "(" << *aGroups << ", error)";
|
|
else
|
|
aPythonDump << "error";
|
|
|
|
aPythonDump << " = " << this << ".ExtrusionAlongPathObjX( "
|
|
<< Object << ", "
|
|
<< Path << ", "
|
|
<< NodeStart << ", "
|
|
<< HasAngles << ", "
|
|
<< TVar( Angles ) << ", "
|
|
<< LinearVariation << ", "
|
|
<< HasRefPoint << ", "
|
|
<< "SMESH.PointStruct( "
|
|
<< TVar( HasRefPoint ? RefPoint.x : 0 ) << ", "
|
|
<< TVar( HasRefPoint ? RefPoint.y : 0 ) << ", "
|
|
<< TVar( HasRefPoint ? RefPoint.z : 0 ) << " ), "
|
|
<< MakeGroups << ", "
|
|
<< ElemType << " )";
|
|
}
|
|
return aGroups;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ExtrusionAlongPathX
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups* SMESH_MeshEditor_i::
|
|
ExtrusionAlongPathX(const SMESH::long_array& IDsOfElements,
|
|
SMESH::SMESH_IDSource_ptr Path,
|
|
CORBA::Long NodeStart,
|
|
CORBA::Boolean HasAngles,
|
|
const SMESH::double_array& Angles,
|
|
CORBA::Boolean LinearVariation,
|
|
CORBA::Boolean HasRefPoint,
|
|
const SMESH::PointStruct& RefPoint,
|
|
CORBA::Boolean MakeGroups,
|
|
SMESH::ElementType ElemType,
|
|
SMESH::SMESH_MeshEditor::Extrusion_Error& Error)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
|
|
|
|
SMESH::ListOfGroups * aGroups = extrusionAlongPathX(IDsOfElements,
|
|
Path,
|
|
NodeStart,
|
|
HasAngles,
|
|
Angles,
|
|
LinearVariation,
|
|
HasRefPoint,
|
|
RefPoint,
|
|
MakeGroups,
|
|
(SMDSAbs_ElementType)ElemType,
|
|
Error);
|
|
|
|
if (!myIsPreviewMode) {
|
|
bool isDumpGroups = aGroups && aGroups->length() > 0;
|
|
if (isDumpGroups)
|
|
aPythonDump << "(" << *aGroups << ", error)";
|
|
else
|
|
aPythonDump <<"error";
|
|
|
|
aPythonDump << " = " << this << ".ExtrusionAlongPathX( "
|
|
<< IDsOfElements << ", "
|
|
<< Path << ", "
|
|
<< NodeStart << ", "
|
|
<< HasAngles << ", "
|
|
<< TVar( Angles ) << ", "
|
|
<< LinearVariation << ", "
|
|
<< HasRefPoint << ", "
|
|
<< "SMESH.PointStruct( "
|
|
<< TVar( HasRefPoint ? RefPoint.x : 0 ) << ", "
|
|
<< TVar( HasRefPoint ? RefPoint.y : 0 ) << ", "
|
|
<< TVar( HasRefPoint ? RefPoint.z : 0 ) << " ), "
|
|
<< MakeGroups << ", "
|
|
<< ElemType << " )";
|
|
}
|
|
return aGroups;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Compute rotation angles for ExtrusionAlongPath as linear variation
|
|
* of given angles along path steps
|
|
* \param PathMesh mesh containing a 1D sub-mesh on the edge, along
|
|
* which proceeds the extrusion
|
|
* \param PathShape is shape(edge); as the mesh can be complex, the edge
|
|
* is used to define the sub-mesh for the path
|
|
*/
|
|
//================================================================================
|
|
|
|
SMESH::double_array*
|
|
SMESH_MeshEditor_i::LinearAnglesVariation(SMESH::SMESH_Mesh_ptr thePathMesh,
|
|
GEOM::GEOM_Object_ptr thePathShape,
|
|
const SMESH::double_array & theAngles)
|
|
{
|
|
SMESH::double_array_var aResult = new SMESH::double_array();
|
|
int nbAngles = theAngles.length();
|
|
if ( nbAngles > 0 && !thePathMesh->_is_nil() && !thePathShape->_is_nil() )
|
|
{
|
|
SMESH_Mesh_i* aMeshImp = SMESH::DownCast<SMESH_Mesh_i*>( thePathMesh );
|
|
TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( thePathShape );
|
|
SMESH_subMesh* aSubMesh = aMeshImp->GetImpl().GetSubMesh( aShape );
|
|
if ( !aSubMesh || !aSubMesh->GetSubMeshDS())
|
|
return aResult._retn();
|
|
int nbSteps = aSubMesh->GetSubMeshDS()->NbElements();
|
|
if ( nbSteps == nbAngles )
|
|
{
|
|
aResult.inout() = theAngles;
|
|
}
|
|
else
|
|
{
|
|
aResult->length( nbSteps );
|
|
double rAn2St = double( nbAngles ) / double( nbSteps );
|
|
double angPrev = 0, angle;
|
|
for ( int iSt = 0; iSt < nbSteps; ++iSt )
|
|
{
|
|
double angCur = rAn2St * ( iSt+1 );
|
|
double angCurFloor = floor( angCur );
|
|
double angPrevFloor = floor( angPrev );
|
|
if ( angPrevFloor == angCurFloor )
|
|
angle = rAn2St * theAngles[ int( angCurFloor ) ];
|
|
else
|
|
{
|
|
int iP = int( angPrevFloor );
|
|
double angPrevCeil = ceil(angPrev);
|
|
angle = ( angPrevCeil - angPrev ) * theAngles[ iP ];
|
|
|
|
int iC = int( angCurFloor );
|
|
if ( iC < nbAngles )
|
|
angle += ( angCur - angCurFloor ) * theAngles[ iC ];
|
|
|
|
iP = int( angPrevCeil );
|
|
while ( iC-- > iP )
|
|
angle += theAngles[ iC ];
|
|
}
|
|
aResult[ iSt ] = angle;
|
|
angPrev = angCur;
|
|
}
|
|
}
|
|
}
|
|
// Update Python script
|
|
TPythonDump() << "rotAngles = " << theAngles;
|
|
TPythonDump() << "rotAngles = " << this << ".LinearAnglesVariation( "
|
|
<< thePathMesh << ", "
|
|
<< thePathShape << ", "
|
|
<< "rotAngles )";
|
|
|
|
return aResult._retn();
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : mirror
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::mirror(TIDSortedElemSet & theElements,
|
|
const SMESH::AxisStruct & theAxis,
|
|
SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
|
|
CORBA::Boolean theCopy,
|
|
bool theMakeGroups,
|
|
::SMESH_Mesh* theTargetMesh)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
gp_Pnt P ( theAxis.x, theAxis.y, theAxis.z );
|
|
gp_Vec V ( theAxis.vx, theAxis.vy, theAxis.vz );
|
|
|
|
if ( theTargetMesh )
|
|
theCopy = false;
|
|
|
|
gp_Trsf aTrsf;
|
|
switch ( theMirrorType ) {
|
|
case SMESH::SMESH_MeshEditor::POINT:
|
|
aTrsf.SetMirror( P );
|
|
break;
|
|
case SMESH::SMESH_MeshEditor::AXIS:
|
|
aTrsf.SetMirror( gp_Ax1( P, V ));
|
|
break;
|
|
default:
|
|
aTrsf.SetMirror( gp_Ax2( P, V ));
|
|
}
|
|
|
|
TIDSortedElemSet copyElements;
|
|
TIDSortedElemSet* workElements = & theElements;
|
|
|
|
if ( myIsPreviewMode )
|
|
{
|
|
TPreviewMesh * tmpMesh = getPreviewMesh();
|
|
tmpMesh->Copy( theElements, copyElements);
|
|
if ( !theCopy && !theTargetMesh )
|
|
{
|
|
TIDSortedElemSet elemsAround, elemsAroundCopy;
|
|
getElementsAround( theElements, getMeshDS(), elemsAround );
|
|
tmpMesh->Copy( elemsAround, elemsAroundCopy);
|
|
}
|
|
workElements = & copyElements;
|
|
theMakeGroups = false;
|
|
}
|
|
|
|
::SMESH_MeshEditor::PGroupIDs groupIds =
|
|
getEditor().Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
|
|
|
|
if ( theCopy && !myIsPreviewMode)
|
|
{
|
|
if ( theTargetMesh )
|
|
{
|
|
theTargetMesh->GetMeshDS()->Modified();
|
|
}
|
|
else
|
|
{
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
}
|
|
}
|
|
return theMakeGroups ? getGroups(groupIds.get()) : 0;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : Mirror
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::Mirror(const SMESH::long_array & theIDsOfElements,
|
|
const SMESH::AxisStruct & theAxis,
|
|
SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
|
|
CORBA::Boolean theCopy)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
if ( !myIsPreviewMode ) {
|
|
TPythonDump() << this << ".Mirror( "
|
|
<< theIDsOfElements << ", "
|
|
<< theAxis << ", "
|
|
<< mirrorTypeName(theMirrorType) << ", "
|
|
<< theCopy << " )";
|
|
}
|
|
if ( theIDsOfElements.length() > 0 )
|
|
{
|
|
TIDSortedElemSet elements;
|
|
arrayToSet(theIDsOfElements, getMeshDS(), elements);
|
|
mirror(elements, theAxis, theMirrorType, theCopy, false);
|
|
}
|
|
}
|
|
|
|
|
|
//=======================================================================
|
|
//function : MirrorObject
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::MirrorObject(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::AxisStruct & theAxis,
|
|
SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
|
|
CORBA::Boolean theCopy)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
if ( !myIsPreviewMode ) {
|
|
TPythonDump() << this << ".MirrorObject( "
|
|
<< theObject << ", "
|
|
<< theAxis << ", "
|
|
<< mirrorTypeName(theMirrorType) << ", "
|
|
<< theCopy << " )";
|
|
}
|
|
TIDSortedElemSet elements;
|
|
|
|
bool emptyIfIsMesh = myIsPreviewMode ? false : true;
|
|
|
|
prepareIdSource( theObject );
|
|
if (idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
|
|
mirror(elements, theAxis, theMirrorType, theCopy, false);
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : MirrorMakeGroups
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::MirrorMakeGroups(const SMESH::long_array& theIDsOfElements,
|
|
const SMESH::AxisStruct& theMirror,
|
|
SMESH::SMESH_MeshEditor::MirrorType theMirrorType)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
|
|
|
|
SMESH::ListOfGroups * aGroups = 0;
|
|
if ( theIDsOfElements.length() > 0 )
|
|
{
|
|
TIDSortedElemSet elements;
|
|
arrayToSet(theIDsOfElements, getMeshDS(), elements);
|
|
aGroups = mirror(elements, theMirror, theMirrorType, true, true);
|
|
}
|
|
if (!myIsPreviewMode) {
|
|
dumpGroupsList(aPythonDump, aGroups);
|
|
aPythonDump << this << ".MirrorMakeGroups( "
|
|
<< theIDsOfElements << ", "
|
|
<< theMirror << ", "
|
|
<< mirrorTypeName(theMirrorType) << " )";
|
|
}
|
|
return aGroups;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : MirrorObjectMakeGroups
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::MirrorObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::AxisStruct& theMirror,
|
|
SMESH::SMESH_MeshEditor::MirrorType theMirrorType)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
|
|
|
|
SMESH::ListOfGroups * aGroups = 0;
|
|
TIDSortedElemSet elements;
|
|
prepareIdSource( theObject );
|
|
if ( idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
|
|
aGroups = mirror(elements, theMirror, theMirrorType, true, true);
|
|
|
|
if (!myIsPreviewMode)
|
|
{
|
|
dumpGroupsList(aPythonDump,aGroups);
|
|
aPythonDump << this << ".MirrorObjectMakeGroups( "
|
|
<< theObject << ", "
|
|
<< theMirror << ", "
|
|
<< mirrorTypeName(theMirrorType) << " )";
|
|
}
|
|
return aGroups;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : MirrorMakeMesh
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::SMESH_Mesh_ptr
|
|
SMESH_MeshEditor_i::MirrorMakeMesh(const SMESH::long_array& theIDsOfElements,
|
|
const SMESH::AxisStruct& theMirror,
|
|
SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
|
|
CORBA::Boolean theCopyGroups,
|
|
const char* theMeshName)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_Mesh_i* mesh_i;
|
|
SMESH::SMESH_Mesh_var mesh;
|
|
{ // open new scope to dump "MakeMesh" command
|
|
// and then "GetGroups" using SMESH_Mesh::GetGroups()
|
|
|
|
TPythonDump pydump; // to prevent dump at mesh creation
|
|
|
|
mesh = makeMesh( theMeshName );
|
|
mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
|
|
if (mesh_i && theIDsOfElements.length() > 0 )
|
|
{
|
|
TIDSortedElemSet elements;
|
|
arrayToSet(theIDsOfElements, getMeshDS(), elements);
|
|
mirror(elements, theMirror, theMirrorType,
|
|
false, theCopyGroups, & mesh_i->GetImpl());
|
|
mesh_i->CreateGroupServants();
|
|
}
|
|
|
|
if (!myIsPreviewMode) {
|
|
pydump << mesh << " = " << this << ".MirrorMakeMesh( "
|
|
<< theIDsOfElements << ", "
|
|
<< theMirror << ", "
|
|
<< mirrorTypeName(theMirrorType) << ", "
|
|
<< theCopyGroups << ", '"
|
|
<< theMeshName << "' )";
|
|
}
|
|
}
|
|
|
|
//dump "GetGroups"
|
|
if (!myIsPreviewMode && mesh_i)
|
|
mesh_i->GetGroups();
|
|
|
|
return mesh._retn();
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : MirrorObjectMakeMesh
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::SMESH_Mesh_ptr
|
|
SMESH_MeshEditor_i::MirrorObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::AxisStruct& theMirror,
|
|
SMESH::SMESH_MeshEditor::MirrorType theMirrorType,
|
|
CORBA::Boolean theCopyGroups,
|
|
const char* theMeshName)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_Mesh_i* mesh_i;
|
|
SMESH::SMESH_Mesh_var mesh;
|
|
{ // open new scope to dump "MakeMesh" command
|
|
// and then "GetGroups" using SMESH_Mesh::GetGroups()
|
|
|
|
TPythonDump pydump; // to prevent dump at mesh creation
|
|
|
|
mesh = makeMesh( theMeshName );
|
|
mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
|
|
TIDSortedElemSet elements;
|
|
prepareIdSource( theObject );
|
|
if ( mesh_i &&
|
|
idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
|
|
{
|
|
mirror(elements, theMirror, theMirrorType,
|
|
false, theCopyGroups, & mesh_i->GetImpl());
|
|
mesh_i->CreateGroupServants();
|
|
}
|
|
if (!myIsPreviewMode) {
|
|
pydump << mesh << " = " << this << ".MirrorObjectMakeMesh( "
|
|
<< theObject << ", "
|
|
<< theMirror << ", "
|
|
<< mirrorTypeName(theMirrorType) << ", "
|
|
<< theCopyGroups << ", '"
|
|
<< theMeshName << "' )";
|
|
}
|
|
}
|
|
|
|
//dump "GetGroups"
|
|
if (!myIsPreviewMode && mesh_i)
|
|
mesh_i->GetGroups();
|
|
|
|
return mesh._retn();
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : translate
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::translate(TIDSortedElemSet & theElements,
|
|
const SMESH::DirStruct & theVector,
|
|
CORBA::Boolean theCopy,
|
|
bool theMakeGroups,
|
|
::SMESH_Mesh* theTargetMesh)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
if ( theTargetMesh )
|
|
theCopy = false;
|
|
|
|
gp_Trsf aTrsf;
|
|
const SMESH::PointStruct * P = &theVector.PS;
|
|
aTrsf.SetTranslation( gp_Vec( P->x, P->y, P->z ));
|
|
|
|
TIDSortedElemSet copyElements;
|
|
TIDSortedElemSet* workElements = &theElements;
|
|
|
|
if ( myIsPreviewMode )
|
|
{
|
|
TPreviewMesh * tmpMesh = getPreviewMesh();
|
|
tmpMesh->Copy( theElements, copyElements);
|
|
if ( !theCopy && !theTargetMesh )
|
|
{
|
|
TIDSortedElemSet elemsAround, elemsAroundCopy;
|
|
getElementsAround( theElements, getMeshDS(), elemsAround );
|
|
tmpMesh->Copy( elemsAround, elemsAroundCopy);
|
|
}
|
|
workElements = & copyElements;
|
|
theMakeGroups = false;
|
|
}
|
|
|
|
::SMESH_MeshEditor::PGroupIDs groupIds =
|
|
getEditor().Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
|
|
|
|
if ( theCopy && !myIsPreviewMode )
|
|
{
|
|
if ( theTargetMesh )
|
|
{
|
|
theTargetMesh->GetMeshDS()->Modified();
|
|
}
|
|
else
|
|
{
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
}
|
|
}
|
|
|
|
return theMakeGroups ? getGroups(groupIds.get()) : 0;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : Translate
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::Translate(const SMESH::long_array & theIDsOfElements,
|
|
const SMESH::DirStruct & theVector,
|
|
CORBA::Boolean theCopy)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
if (!myIsPreviewMode) {
|
|
TPythonDump() << this << ".Translate( "
|
|
<< theIDsOfElements << ", "
|
|
<< theVector << ", "
|
|
<< theCopy << " )";
|
|
}
|
|
if (theIDsOfElements.length()) {
|
|
TIDSortedElemSet elements;
|
|
arrayToSet(theIDsOfElements, getMeshDS(), elements);
|
|
translate(elements, theVector, theCopy, false);
|
|
}
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : TranslateObject
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::TranslateObject(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::DirStruct & theVector,
|
|
CORBA::Boolean theCopy)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
if (!myIsPreviewMode) {
|
|
TPythonDump() << this << ".TranslateObject( "
|
|
<< theObject << ", "
|
|
<< theVector << ", "
|
|
<< theCopy << " )";
|
|
}
|
|
TIDSortedElemSet elements;
|
|
|
|
bool emptyIfIsMesh = myIsPreviewMode ? false : true;
|
|
|
|
prepareIdSource( theObject );
|
|
if (idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
|
|
translate(elements, theVector, theCopy, false);
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : TranslateMakeGroups
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::TranslateMakeGroups(const SMESH::long_array& theIDsOfElements,
|
|
const SMESH::DirStruct& theVector)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
|
|
|
|
SMESH::ListOfGroups * aGroups = 0;
|
|
if (theIDsOfElements.length()) {
|
|
TIDSortedElemSet elements;
|
|
arrayToSet(theIDsOfElements, getMeshDS(), elements);
|
|
aGroups = translate(elements,theVector,true,true);
|
|
}
|
|
if (!myIsPreviewMode) {
|
|
dumpGroupsList(aPythonDump, aGroups);
|
|
aPythonDump << this << ".TranslateMakeGroups( "
|
|
<< theIDsOfElements << ", "
|
|
<< theVector << " )";
|
|
}
|
|
return aGroups;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : TranslateObjectMakeGroups
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::TranslateObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::DirStruct& theVector)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
|
|
|
|
SMESH::ListOfGroups * aGroups = 0;
|
|
TIDSortedElemSet elements;
|
|
prepareIdSource( theObject );
|
|
if (idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
|
|
aGroups = translate(elements, theVector, true, true);
|
|
|
|
if (!myIsPreviewMode) {
|
|
dumpGroupsList(aPythonDump, aGroups);
|
|
aPythonDump << this << ".TranslateObjectMakeGroups( "
|
|
<< theObject << ", "
|
|
<< theVector << " )";
|
|
}
|
|
return aGroups;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : TranslateMakeMesh
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::SMESH_Mesh_ptr
|
|
SMESH_MeshEditor_i::TranslateMakeMesh(const SMESH::long_array& theIDsOfElements,
|
|
const SMESH::DirStruct& theVector,
|
|
CORBA::Boolean theCopyGroups,
|
|
const char* theMeshName)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_Mesh_i* mesh_i;
|
|
SMESH::SMESH_Mesh_var mesh;
|
|
|
|
{ // open new scope to dump "MakeMesh" command
|
|
// and then "GetGroups" using SMESH_Mesh::GetGroups()
|
|
|
|
TPythonDump pydump; // to prevent dump at mesh creation
|
|
|
|
mesh = makeMesh( theMeshName );
|
|
mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
|
|
|
|
if ( mesh_i && theIDsOfElements.length() )
|
|
{
|
|
TIDSortedElemSet elements;
|
|
arrayToSet(theIDsOfElements, getMeshDS(), elements);
|
|
translate(elements, theVector, false, theCopyGroups, & mesh_i->GetImpl());
|
|
mesh_i->CreateGroupServants();
|
|
}
|
|
|
|
if ( !myIsPreviewMode ) {
|
|
pydump << mesh << " = " << this << ".TranslateMakeMesh( "
|
|
<< theIDsOfElements << ", "
|
|
<< theVector << ", "
|
|
<< theCopyGroups << ", '"
|
|
<< theMeshName << "' )";
|
|
}
|
|
}
|
|
|
|
//dump "GetGroups"
|
|
if (!myIsPreviewMode && mesh_i)
|
|
mesh_i->GetGroups();
|
|
|
|
return mesh._retn();
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : TranslateObjectMakeMesh
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::SMESH_Mesh_ptr
|
|
SMESH_MeshEditor_i::TranslateObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::DirStruct& theVector,
|
|
CORBA::Boolean theCopyGroups,
|
|
const char* theMeshName)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
SMESH_Mesh_i* mesh_i;
|
|
SMESH::SMESH_Mesh_var mesh;
|
|
{ // open new scope to dump "MakeMesh" command
|
|
// and then "GetGroups" using SMESH_Mesh::GetGroups()
|
|
|
|
TPythonDump pydump; // to prevent dump at mesh creation
|
|
mesh = makeMesh( theMeshName );
|
|
mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
|
|
|
|
TIDSortedElemSet elements;
|
|
prepareIdSource( theObject );
|
|
if ( mesh_i &&
|
|
idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
|
|
{
|
|
translate(elements, theVector,false, theCopyGroups, & mesh_i->GetImpl());
|
|
mesh_i->CreateGroupServants();
|
|
}
|
|
if ( !myIsPreviewMode ) {
|
|
pydump << mesh << " = " << this << ".TranslateObjectMakeMesh( "
|
|
<< theObject << ", "
|
|
<< theVector << ", "
|
|
<< theCopyGroups << ", '"
|
|
<< theMeshName << "' )";
|
|
}
|
|
}
|
|
|
|
// dump "GetGroups"
|
|
if (!myIsPreviewMode && mesh_i)
|
|
mesh_i->GetGroups();
|
|
|
|
return mesh._retn();
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : rotate
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::rotate(TIDSortedElemSet & theElements,
|
|
const SMESH::AxisStruct & theAxis,
|
|
CORBA::Double theAngle,
|
|
CORBA::Boolean theCopy,
|
|
bool theMakeGroups,
|
|
::SMESH_Mesh* theTargetMesh)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
if ( theTargetMesh )
|
|
theCopy = false;
|
|
|
|
gp_Pnt P ( theAxis.x, theAxis.y, theAxis.z );
|
|
gp_Vec V ( theAxis.vx, theAxis.vy, theAxis.vz );
|
|
|
|
gp_Trsf aTrsf;
|
|
aTrsf.SetRotation( gp_Ax1( P, V ), theAngle);
|
|
|
|
TIDSortedElemSet copyElements;
|
|
TIDSortedElemSet* workElements = &theElements;
|
|
if ( myIsPreviewMode ) {
|
|
TPreviewMesh * tmpMesh = getPreviewMesh();
|
|
tmpMesh->Copy( theElements, copyElements );
|
|
if ( !theCopy && !theTargetMesh )
|
|
{
|
|
TIDSortedElemSet elemsAround, elemsAroundCopy;
|
|
getElementsAround( theElements, getMeshDS(), elemsAround );
|
|
tmpMesh->Copy( elemsAround, elemsAroundCopy);
|
|
}
|
|
workElements = ©Elements;
|
|
theMakeGroups = false;
|
|
}
|
|
|
|
::SMESH_MeshEditor::PGroupIDs groupIds =
|
|
getEditor().Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
|
|
|
|
if ( theCopy && !myIsPreviewMode)
|
|
{
|
|
if ( theTargetMesh ) theTargetMesh->GetMeshDS()->Modified();
|
|
else declareMeshModified( /*isReComputeSafe=*/false );
|
|
}
|
|
|
|
return theMakeGroups ? getGroups(groupIds.get()) : 0;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : Rotate
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::Rotate(const SMESH::long_array & theIDsOfElements,
|
|
const SMESH::AxisStruct & theAxis,
|
|
CORBA::Double theAngle,
|
|
CORBA::Boolean theCopy)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
if (!myIsPreviewMode) {
|
|
TPythonDump() << this << ".Rotate( "
|
|
<< theIDsOfElements << ", "
|
|
<< theAxis << ", "
|
|
<< TVar( theAngle ) << ", "
|
|
<< theCopy << " )";
|
|
}
|
|
if (theIDsOfElements.length() > 0)
|
|
{
|
|
TIDSortedElemSet elements;
|
|
arrayToSet(theIDsOfElements, getMeshDS(), elements);
|
|
rotate(elements,theAxis,theAngle,theCopy,false);
|
|
}
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : RotateObject
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::RotateObject(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::AxisStruct & theAxis,
|
|
CORBA::Double theAngle,
|
|
CORBA::Boolean theCopy)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
if ( !myIsPreviewMode ) {
|
|
TPythonDump() << this << ".RotateObject( "
|
|
<< theObject << ", "
|
|
<< theAxis << ", "
|
|
<< TVar( theAngle ) << ", "
|
|
<< theCopy << " )";
|
|
}
|
|
TIDSortedElemSet elements;
|
|
bool emptyIfIsMesh = myIsPreviewMode ? false : true;
|
|
prepareIdSource( theObject );
|
|
if (idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
|
|
rotate(elements,theAxis,theAngle,theCopy,false);
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : RotateMakeGroups
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::RotateMakeGroups(const SMESH::long_array& theIDsOfElements,
|
|
const SMESH::AxisStruct& theAxis,
|
|
CORBA::Double theAngle)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
|
|
|
|
SMESH::ListOfGroups * aGroups = 0;
|
|
if (theIDsOfElements.length() > 0)
|
|
{
|
|
TIDSortedElemSet elements;
|
|
arrayToSet(theIDsOfElements, getMeshDS(), elements);
|
|
aGroups = rotate(elements,theAxis,theAngle,true,true);
|
|
}
|
|
if (!myIsPreviewMode) {
|
|
dumpGroupsList(aPythonDump, aGroups);
|
|
aPythonDump << this << ".RotateMakeGroups( "
|
|
<< theIDsOfElements << ", "
|
|
<< theAxis << ", "
|
|
<< TVar( theAngle ) << " )";
|
|
}
|
|
return aGroups;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : RotateObjectMakeGroups
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::RotateObjectMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::AxisStruct& theAxis,
|
|
CORBA::Double theAngle)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
|
|
|
|
SMESH::ListOfGroups * aGroups = 0;
|
|
TIDSortedElemSet elements;
|
|
prepareIdSource( theObject );
|
|
if (idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
|
|
aGroups = rotate(elements, theAxis, theAngle, true, true);
|
|
|
|
if (!myIsPreviewMode) {
|
|
dumpGroupsList(aPythonDump, aGroups);
|
|
aPythonDump << this << ".RotateObjectMakeGroups( "
|
|
<< theObject << ", "
|
|
<< theAxis << ", "
|
|
<< TVar( theAngle ) << " )";
|
|
}
|
|
return aGroups;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : RotateMakeMesh
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::SMESH_Mesh_ptr
|
|
SMESH_MeshEditor_i::RotateMakeMesh(const SMESH::long_array& theIDsOfElements,
|
|
const SMESH::AxisStruct& theAxis,
|
|
CORBA::Double theAngleInRadians,
|
|
CORBA::Boolean theCopyGroups,
|
|
const char* theMeshName)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
SMESH::SMESH_Mesh_var mesh;
|
|
SMESH_Mesh_i* mesh_i;
|
|
|
|
{ // open new scope to dump "MakeMesh" command
|
|
// and then "GetGroups" using SMESH_Mesh::GetGroups()
|
|
|
|
TPythonDump pydump; // to prevent dump at mesh creation
|
|
|
|
mesh = makeMesh( theMeshName );
|
|
mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
|
|
|
|
if ( mesh_i && theIDsOfElements.length() > 0 )
|
|
{
|
|
TIDSortedElemSet elements;
|
|
arrayToSet(theIDsOfElements, getMeshDS(), elements);
|
|
rotate(elements, theAxis, theAngleInRadians,
|
|
false, theCopyGroups, & mesh_i->GetImpl());
|
|
mesh_i->CreateGroupServants();
|
|
}
|
|
if ( !myIsPreviewMode ) {
|
|
pydump << mesh << " = " << this << ".RotateMakeMesh( "
|
|
<< theIDsOfElements << ", "
|
|
<< theAxis << ", "
|
|
<< TVar( theAngleInRadians ) << ", "
|
|
<< theCopyGroups << ", '"
|
|
<< theMeshName << "' )";
|
|
}
|
|
}
|
|
|
|
// dump "GetGroups"
|
|
if (!myIsPreviewMode && mesh_i && theIDsOfElements.length() > 0 )
|
|
mesh_i->GetGroups();
|
|
|
|
return mesh._retn();
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : RotateObjectMakeMesh
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::SMESH_Mesh_ptr
|
|
SMESH_MeshEditor_i::RotateObjectMakeMesh(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::AxisStruct& theAxis,
|
|
CORBA::Double theAngleInRadians,
|
|
CORBA::Boolean theCopyGroups,
|
|
const char* theMeshName)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
SMESH::SMESH_Mesh_var mesh;
|
|
SMESH_Mesh_i* mesh_i;
|
|
|
|
{// open new scope to dump "MakeMesh" command
|
|
// and then "GetGroups" using SMESH_Mesh::GetGroups()
|
|
|
|
TPythonDump pydump; // to prevent dump at mesh creation
|
|
mesh = makeMesh( theMeshName );
|
|
mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
|
|
|
|
TIDSortedElemSet elements;
|
|
prepareIdSource( theObject );
|
|
if (mesh_i &&
|
|
idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
|
|
{
|
|
rotate(elements, theAxis, theAngleInRadians,
|
|
false, theCopyGroups, & mesh_i->GetImpl());
|
|
mesh_i->CreateGroupServants();
|
|
}
|
|
if ( !myIsPreviewMode ) {
|
|
pydump << mesh << " = " << this << ".RotateObjectMakeMesh( "
|
|
<< theObject << ", "
|
|
<< theAxis << ", "
|
|
<< TVar( theAngleInRadians ) << ", "
|
|
<< theCopyGroups << ", '"
|
|
<< theMeshName << "' )";
|
|
}
|
|
}
|
|
|
|
// dump "GetGroups"
|
|
if (!myIsPreviewMode && mesh_i)
|
|
mesh_i->GetGroups();
|
|
|
|
return mesh._retn();
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : scale
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::scale(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::PointStruct& thePoint,
|
|
const SMESH::double_array& theScaleFact,
|
|
CORBA::Boolean theCopy,
|
|
bool theMakeGroups,
|
|
::SMESH_Mesh* theTargetMesh)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
if ( theScaleFact.length() < 1 )
|
|
THROW_SALOME_CORBA_EXCEPTION("Scale factor not given", SALOME::BAD_PARAM);
|
|
if ( theScaleFact.length() == 2 )
|
|
THROW_SALOME_CORBA_EXCEPTION("Invalid nb of scale factors : 2", SALOME::BAD_PARAM);
|
|
|
|
if ( theTargetMesh )
|
|
theCopy = false;
|
|
|
|
TIDSortedElemSet elements;
|
|
prepareIdSource( theObject );
|
|
bool emptyIfIsMesh = myIsPreviewMode ? false : true;
|
|
if ( !idSourceToSet(theObject, getMeshDS(), elements, SMDSAbs_All, emptyIfIsMesh))
|
|
return 0;
|
|
|
|
double S[3] = {
|
|
theScaleFact[0],
|
|
(theScaleFact.length() == 1) ? theScaleFact[0] : theScaleFact[1],
|
|
(theScaleFact.length() == 1) ? theScaleFact[0] : theScaleFact[2],
|
|
};
|
|
double tol = std::numeric_limits<double>::max();
|
|
gp_Trsf aTrsf;
|
|
|
|
#if OCC_VERSION_LARGE > 0x06070100
|
|
aTrsf.SetValues( S[0], 0, 0, thePoint.x * (1-S[0]),
|
|
0, S[1], 0, thePoint.y * (1-S[1]),
|
|
0, 0, S[2], thePoint.z * (1-S[2]) );
|
|
#else
|
|
aTrsf.SetValues( S[0], 0, 0, thePoint.x * (1-S[0]),
|
|
0, S[1], 0, thePoint.y * (1-S[1]),
|
|
0, 0, S[2], thePoint.z * (1-S[2]), tol, tol);
|
|
#endif
|
|
|
|
TIDSortedElemSet copyElements;
|
|
TIDSortedElemSet* workElements = &elements;
|
|
if ( myIsPreviewMode )
|
|
{
|
|
TPreviewMesh * tmpMesh = getPreviewMesh();
|
|
tmpMesh->Copy( elements, copyElements);
|
|
if ( !theCopy && !theTargetMesh )
|
|
{
|
|
TIDSortedElemSet elemsAround, elemsAroundCopy;
|
|
getElementsAround( elements, getMeshDS(), elemsAround );
|
|
tmpMesh->Copy( elemsAround, elemsAroundCopy);
|
|
}
|
|
workElements = & copyElements;
|
|
theMakeGroups = false;
|
|
}
|
|
|
|
::SMESH_MeshEditor::PGroupIDs groupIds =
|
|
getEditor().Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
|
|
|
|
if ( theCopy && !myIsPreviewMode )
|
|
{
|
|
if ( theTargetMesh ) theTargetMesh->GetMeshDS()->Modified();
|
|
else declareMeshModified( /*isReComputeSafe=*/false );
|
|
}
|
|
return theMakeGroups ? getGroups(groupIds.get()) : 0;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : Scale
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::Scale(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::PointStruct& thePoint,
|
|
const SMESH::double_array& theScaleFact,
|
|
CORBA::Boolean theCopy)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
if ( !myIsPreviewMode ) {
|
|
TPythonDump() << this << ".Scale( "
|
|
<< theObject << ", "
|
|
<< thePoint << ", "
|
|
<< TVar( theScaleFact ) << ", "
|
|
<< theCopy << " )";
|
|
}
|
|
scale(theObject, thePoint, theScaleFact, theCopy, false);
|
|
}
|
|
|
|
|
|
//=======================================================================
|
|
//function : ScaleMakeGroups
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::ScaleMakeGroups(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::PointStruct& thePoint,
|
|
const SMESH::double_array& theScaleFact)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump aPythonDump; // it is here to prevent dump of GetGroups()
|
|
|
|
SMESH::ListOfGroups * aGroups = scale(theObject, thePoint, theScaleFact, true, true);
|
|
if (!myIsPreviewMode) {
|
|
dumpGroupsList(aPythonDump, aGroups);
|
|
aPythonDump << this << ".Scale("
|
|
<< theObject << ","
|
|
<< thePoint << ","
|
|
<< TVar( theScaleFact ) << ",True,True)";
|
|
}
|
|
return aGroups;
|
|
}
|
|
|
|
|
|
//=======================================================================
|
|
//function : ScaleMakeMesh
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::SMESH_Mesh_ptr
|
|
SMESH_MeshEditor_i::ScaleMakeMesh(SMESH::SMESH_IDSource_ptr theObject,
|
|
const SMESH::PointStruct& thePoint,
|
|
const SMESH::double_array& theScaleFact,
|
|
CORBA::Boolean theCopyGroups,
|
|
const char* theMeshName)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_Mesh_i* mesh_i;
|
|
SMESH::SMESH_Mesh_var mesh;
|
|
{ // open new scope to dump "MakeMesh" command
|
|
// and then "GetGroups" using SMESH_Mesh::GetGroups()
|
|
|
|
TPythonDump pydump; // to prevent dump at mesh creation
|
|
mesh = makeMesh( theMeshName );
|
|
mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
|
|
|
|
if ( mesh_i )
|
|
{
|
|
scale(theObject, thePoint, theScaleFact,false, theCopyGroups, & mesh_i->GetImpl());
|
|
mesh_i->CreateGroupServants();
|
|
}
|
|
if ( !myIsPreviewMode )
|
|
pydump << mesh << " = " << this << ".ScaleMakeMesh( "
|
|
<< theObject << ", "
|
|
<< thePoint << ", "
|
|
<< TVar( theScaleFact ) << ", "
|
|
<< theCopyGroups << ", '"
|
|
<< theMeshName << "' )";
|
|
}
|
|
|
|
// dump "GetGroups"
|
|
if (!myIsPreviewMode && mesh_i)
|
|
mesh_i->GetGroups();
|
|
|
|
return mesh._retn();
|
|
}
|
|
|
|
|
|
//=======================================================================
|
|
//function : FindCoincidentNodes
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::FindCoincidentNodes (CORBA::Double Tolerance,
|
|
SMESH::array_of_long_array_out GroupsOfNodes)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
|
|
TIDSortedNodeSet nodes; // no input nodes
|
|
getEditor().FindCoincidentNodes( nodes, Tolerance, aListOfListOfNodes );
|
|
|
|
GroupsOfNodes = new SMESH::array_of_long_array;
|
|
GroupsOfNodes->length( aListOfListOfNodes.size() );
|
|
::SMESH_MeshEditor::TListOfListOfNodes::iterator llIt = aListOfListOfNodes.begin();
|
|
for ( CORBA::Long i = 0; llIt != aListOfListOfNodes.end(); llIt++, i++ ) {
|
|
list< const SMDS_MeshNode* >& aListOfNodes = *llIt;
|
|
list< const SMDS_MeshNode* >::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)->GetID();
|
|
}
|
|
TPythonDump() << "coincident_nodes = " << this << ".FindCoincidentNodes( "
|
|
<< Tolerance << " )";
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : FindCoincidentNodesOnPart
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::FindCoincidentNodesOnPart(SMESH::SMESH_IDSource_ptr theObject,
|
|
CORBA::Double Tolerance,
|
|
SMESH::array_of_long_array_out GroupsOfNodes)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
TIDSortedNodeSet nodes;
|
|
prepareIdSource( theObject );
|
|
idSourceToNodeSet( theObject, getMeshDS(), nodes );
|
|
|
|
::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
|
|
if(!nodes.empty())
|
|
getEditor().FindCoincidentNodes( nodes, Tolerance, aListOfListOfNodes );
|
|
|
|
GroupsOfNodes = new SMESH::array_of_long_array;
|
|
GroupsOfNodes->length( aListOfListOfNodes.size() );
|
|
::SMESH_MeshEditor::TListOfListOfNodes::iterator llIt = aListOfListOfNodes.begin();
|
|
for ( CORBA::Long i = 0; llIt != aListOfListOfNodes.end(); llIt++, i++ )
|
|
{
|
|
list< const SMDS_MeshNode* >& aListOfNodes = *llIt;
|
|
list< const SMDS_MeshNode* >::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)->GetID();
|
|
}
|
|
TPythonDump() << "coincident_nodes_on_part = " << this << ".FindCoincidentNodesOnPart( "
|
|
<<theObject<<", "
|
|
<< Tolerance << " )";
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Finds nodes coinsident with Tolerance within Object excluding nodes within
|
|
* ExceptSubMeshOrGroups
|
|
*/
|
|
//================================================================================
|
|
|
|
void SMESH_MeshEditor_i::
|
|
FindCoincidentNodesOnPartBut(SMESH::SMESH_IDSource_ptr theObject,
|
|
CORBA::Double theTolerance,
|
|
SMESH::array_of_long_array_out theGroupsOfNodes,
|
|
const SMESH::ListOfIDSources& theExceptSubMeshOrGroups)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
TIDSortedNodeSet nodes;
|
|
prepareIdSource( theObject );
|
|
idSourceToNodeSet( theObject, getMeshDS(), nodes );
|
|
|
|
for ( int i = 0; i < theExceptSubMeshOrGroups.length(); ++i )
|
|
{
|
|
TIDSortedNodeSet 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())
|
|
getEditor().FindCoincidentNodes( nodes, theTolerance, aListOfListOfNodes );
|
|
|
|
theGroupsOfNodes = new SMESH::array_of_long_array;
|
|
theGroupsOfNodes->length( aListOfListOfNodes.size() );
|
|
::SMESH_MeshEditor::TListOfListOfNodes::iterator llIt = aListOfListOfNodes.begin();
|
|
for ( CORBA::Long i = 0; llIt != aListOfListOfNodes.end(); llIt++, i++ )
|
|
{
|
|
list< const SMDS_MeshNode* >& aListOfNodes = *llIt;
|
|
list< const SMDS_MeshNode* >::iterator lIt = aListOfNodes.begin();;
|
|
SMESH::long_array& aGroup = (*theGroupsOfNodes)[ i ];
|
|
aGroup.length( aListOfNodes.size() );
|
|
for ( int j = 0; lIt != aListOfNodes.end(); lIt++, j++ )
|
|
aGroup[ j ] = (*lIt)->GetID();
|
|
}
|
|
TPythonDump() << "coincident_nodes_on_part = " << this << ".FindCoincidentNodesOnPartBut( "
|
|
<< theObject<<", "
|
|
<< theTolerance << ", "
|
|
<< theExceptSubMeshOrGroups << " )";
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : MergeNodes
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
SMESHDS_Mesh* aMesh = getMeshDS();
|
|
|
|
TPythonDump aTPythonDump;
|
|
aTPythonDump << this << ".MergeNodes([";
|
|
::SMESH_MeshEditor::TListOfListOfNodes aListOfListOfNodes;
|
|
for (int i = 0; i < GroupsOfNodes.length(); i++)
|
|
{
|
|
const SMESH::long_array& aNodeGroup = GroupsOfNodes[ i ];
|
|
aListOfListOfNodes.push_back( list< const SMDS_MeshNode* >() );
|
|
list< const SMDS_MeshNode* >& aListOfNodes = aListOfListOfNodes.back();
|
|
for ( int j = 0; j < aNodeGroup.length(); j++ )
|
|
{
|
|
CORBA::Long index = aNodeGroup[ j ];
|
|
const SMDS_MeshNode * node = aMesh->FindNode(index);
|
|
if ( node )
|
|
aListOfNodes.push_back( node );
|
|
}
|
|
if ( aListOfNodes.size() < 2 )
|
|
aListOfListOfNodes.pop_back();
|
|
|
|
if ( i > 0 ) aTPythonDump << ", ";
|
|
aTPythonDump << aNodeGroup;
|
|
}
|
|
getEditor().MergeNodes( aListOfListOfNodes );
|
|
|
|
aTPythonDump << "])";
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : FindEqualElements
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::FindEqualElements(SMESH::SMESH_IDSource_ptr theObject,
|
|
SMESH::array_of_long_array_out GroupsOfElementsID)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
SMESH::SMESH_GroupBase_var group = SMESH::SMESH_GroupBase::_narrow(theObject);
|
|
if ( !(!group->_is_nil() && group->GetType() == SMESH::NODE) )
|
|
{
|
|
TIDSortedElemSet elems;
|
|
prepareIdSource( theObject );
|
|
idSourceToSet( theObject, getMeshDS(), elems, SMDSAbs_All, /*emptyIfIsMesh=*/true);
|
|
|
|
::SMESH_MeshEditor::TListOfListOfElementsID aListOfListOfElementsID;
|
|
getEditor().FindEqualElements( elems, aListOfListOfElementsID );
|
|
|
|
GroupsOfElementsID = new SMESH::array_of_long_array;
|
|
GroupsOfElementsID->length( aListOfListOfElementsID.size() );
|
|
|
|
::SMESH_MeshEditor::TListOfListOfElementsID::iterator arraysIt =
|
|
aListOfListOfElementsID.begin();
|
|
for (CORBA::Long j = 0; arraysIt != aListOfListOfElementsID.end(); ++arraysIt, ++j)
|
|
{
|
|
SMESH::long_array& aGroup = (*GroupsOfElementsID)[ j ];
|
|
list<int>& listOfIDs = *arraysIt;
|
|
aGroup.length( listOfIDs.size() );
|
|
list<int>::iterator idIt = listOfIDs.begin();
|
|
for (int k = 0; idIt != listOfIDs.end(); ++idIt, ++k )
|
|
aGroup[ k ] = *idIt;
|
|
}
|
|
|
|
TPythonDump() << "equal_elements = " << this << ".FindEqualElements( "
|
|
<<theObject<<" )";
|
|
}
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : MergeElements
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::MergeElements(const SMESH::array_of_long_array& GroupsOfElementsID)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
TPythonDump aTPythonDump;
|
|
aTPythonDump << this << ".MergeElements( [";
|
|
|
|
::SMESH_MeshEditor::TListOfListOfElementsID aListOfListOfElementsID;
|
|
|
|
for (int i = 0; i < GroupsOfElementsID.length(); i++) {
|
|
const SMESH::long_array& anElemsIDGroup = GroupsOfElementsID[ i ];
|
|
aListOfListOfElementsID.push_back( list< int >() );
|
|
list< int >& aListOfElemsID = aListOfListOfElementsID.back();
|
|
for ( int j = 0; j < anElemsIDGroup.length(); j++ ) {
|
|
CORBA::Long id = anElemsIDGroup[ j ];
|
|
aListOfElemsID.push_back( id );
|
|
}
|
|
if ( aListOfElemsID.size() < 2 )
|
|
aListOfListOfElementsID.pop_back();
|
|
if ( i > 0 ) aTPythonDump << ", ";
|
|
aTPythonDump << anElemsIDGroup;
|
|
}
|
|
|
|
getEditor().MergeElements(aListOfListOfElementsID);
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/true );
|
|
|
|
aTPythonDump << "] )";
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : MergeEqualElements
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::MergeEqualElements()
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
getEditor().MergeEqualElements();
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/true );
|
|
|
|
TPythonDump() << this << ".MergeEqualElements()";
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
}
|
|
|
|
//=============================================================================
|
|
/*!
|
|
* Move the node to a given point
|
|
*/
|
|
//=============================================================================
|
|
|
|
CORBA::Boolean SMESH_MeshEditor_i::MoveNode(CORBA::Long NodeID,
|
|
CORBA::Double x,
|
|
CORBA::Double y,
|
|
CORBA::Double z)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData(/*deleteSearchers=*/false);
|
|
|
|
const SMDS_MeshNode * node = getMeshDS()->FindNode( NodeID );
|
|
if ( !node )
|
|
return false;
|
|
|
|
if ( theNodeSearcher )
|
|
theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other
|
|
|
|
if ( myIsPreviewMode ) // make preview data
|
|
{
|
|
// in a preview mesh, make edges linked to a node
|
|
TPreviewMesh& tmpMesh = *getPreviewMesh();
|
|
TIDSortedElemSet linkedNodes;
|
|
::SMESH_MeshEditor::GetLinkedNodes( node, linkedNodes );
|
|
TIDSortedElemSet::iterator nIt = linkedNodes.begin();
|
|
SMDS_MeshNode *nodeCpy1 = tmpMesh.Copy(node);
|
|
for ( ; nIt != linkedNodes.end(); ++nIt )
|
|
{
|
|
SMDS_MeshNode *nodeCpy2 = tmpMesh.Copy ( cast2Node( *nIt ));
|
|
tmpMesh.GetMeshDS()->AddEdge(nodeCpy1, nodeCpy2);
|
|
}
|
|
// move copied node
|
|
if ( nodeCpy1 )
|
|
tmpMesh.GetMeshDS()->MoveNode(nodeCpy1, x, y, z);
|
|
// fill preview data
|
|
}
|
|
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);
|
|
|
|
if ( !myIsPreviewMode )
|
|
{
|
|
// Update Python script
|
|
TPythonDump() << "isDone = " << this << ".MoveNode( "
|
|
<< NodeID << ", " << TVar(x) << ", " << TVar(y) << ", " << TVar(z) << " )";
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
}
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
|
|
return true;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Return ID of node closest to a given point
|
|
*/
|
|
//================================================================================
|
|
|
|
CORBA::Long SMESH_MeshEditor_i::FindNodeClosestTo(CORBA::Double x,
|
|
CORBA::Double y,
|
|
CORBA::Double z)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other
|
|
|
|
if ( !theNodeSearcher ) {
|
|
theNodeSearcher = SMESH_MeshAlgos::GetNodeSearcher( *getMeshDS() );
|
|
}
|
|
gp_Pnt p( x,y,z );
|
|
if ( const SMDS_MeshNode* node = theNodeSearcher->FindClosestTo( p ))
|
|
return node->GetID();
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief If the given ID is a valid node ID (nodeID > 0), just move this node, else
|
|
* move the node closest to the point to point's location and return ID of the node
|
|
*/
|
|
//================================================================================
|
|
|
|
CORBA::Long SMESH_MeshEditor_i::MoveClosestNodeToPoint(CORBA::Double x,
|
|
CORBA::Double y,
|
|
CORBA::Double z,
|
|
CORBA::Long theNodeID)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
// We keep theNodeSearcher until any mesh modification:
|
|
// 1) initData() deletes theNodeSearcher at any edition,
|
|
// 2) TSearchersDeleter - at any mesh compute event and mesh change
|
|
|
|
initData(/*deleteSearchers=*/false);
|
|
|
|
theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other
|
|
|
|
int nodeID = theNodeID;
|
|
const SMDS_MeshNode* node = getMeshDS()->FindNode( nodeID );
|
|
if ( !node ) // preview moving node
|
|
{
|
|
if ( !theNodeSearcher ) {
|
|
theNodeSearcher = SMESH_MeshAlgos::GetNodeSearcher( *getMeshDS() );
|
|
}
|
|
gp_Pnt p( x,y,z );
|
|
node = theNodeSearcher->FindClosestTo( p );
|
|
}
|
|
if ( node ) {
|
|
nodeID = node->GetID();
|
|
if ( myIsPreviewMode ) // make preview data
|
|
{
|
|
// in a preview mesh, make edges linked to a node
|
|
TPreviewMesh tmpMesh = *getPreviewMesh();
|
|
TIDSortedElemSet linkedNodes;
|
|
::SMESH_MeshEditor::GetLinkedNodes( node, linkedNodes );
|
|
TIDSortedElemSet::iterator nIt = linkedNodes.begin();
|
|
for ( ; nIt != linkedNodes.end(); ++nIt )
|
|
{
|
|
SMDS_LinearEdge edge( node, cast2Node( *nIt ));
|
|
tmpMesh.Copy( &edge );
|
|
}
|
|
// move copied node
|
|
node = tmpMesh.GetMeshDS()->FindNode( nodeID );
|
|
if ( node )
|
|
tmpMesh.GetMeshDS()->MoveNode(node, x, y, z);
|
|
// fill preview data
|
|
}
|
|
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);
|
|
}
|
|
}
|
|
|
|
if ( !myIsPreviewMode )
|
|
{
|
|
TPythonDump() << "nodeID = " << this
|
|
<< ".MoveClosestNodeToPoint( "<< x << ", " << y << ", " << z
|
|
<< ", " << nodeID << " )";
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
}
|
|
|
|
return nodeID;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=======================================================================
|
|
/*!
|
|
* Return elements of given type where the given point is IN or ON.
|
|
*
|
|
* 'ALL' type means elements of any type excluding nodes
|
|
*/
|
|
//=======================================================================
|
|
|
|
SMESH::long_array* SMESH_MeshEditor_i::FindElementsByPoint(CORBA::Double x,
|
|
CORBA::Double y,
|
|
CORBA::Double z,
|
|
SMESH::ElementType type)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
SMESH::long_array_var res = new SMESH::long_array;
|
|
vector< const SMDS_MeshElement* > foundElems;
|
|
|
|
theSearchersDeleter.Set( myMesh );
|
|
if ( !theElementSearcher ) {
|
|
theElementSearcher = SMESH_MeshAlgos::GetElementSearcher( *getMeshDS() );
|
|
}
|
|
theElementSearcher->FindElementsByPoint( gp_Pnt( x,y,z ),
|
|
SMDSAbs_ElementType( type ),
|
|
foundElems);
|
|
res->length( foundElems.size() );
|
|
for ( int i = 0; i < foundElems.size(); ++i )
|
|
res[i] = foundElems[i]->GetID();
|
|
|
|
return res._retn();
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : FindAmongElementsByPoint
|
|
//purpose : Searching among the given elements, return elements of given type
|
|
// where the given point is IN or ON.
|
|
// 'ALL' type means elements of any type excluding nodes
|
|
//=======================================================================
|
|
|
|
SMESH::long_array*
|
|
SMESH_MeshEditor_i::FindAmongElementsByPoint(SMESH::SMESH_IDSource_ptr elementIDs,
|
|
CORBA::Double x,
|
|
CORBA::Double y,
|
|
CORBA::Double z,
|
|
SMESH::ElementType type)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
SMESH::long_array_var res = new SMESH::long_array;
|
|
|
|
SMESH::array_of_ElementType_var types = elementIDs->GetTypes();
|
|
if ( types->length() == 1 && // a part contains only nodes or 0D elements
|
|
( types[0] == SMESH::NODE || types[0] == SMESH::ELEM0D || types[0] == SMESH::BALL) &&
|
|
type != types[0] ) // but search of elements of dim > 0
|
|
return res._retn();
|
|
|
|
if ( SMESH::DownCast<SMESH_Mesh_i*>( elementIDs )) // elementIDs is the whole mesh
|
|
return FindElementsByPoint( x,y,z, type );
|
|
|
|
TIDSortedElemSet elements; // elems should live until FindElementsByPoint() finishes
|
|
|
|
theSearchersDeleter.Set( myMesh, getPartIOR( elementIDs, type ));
|
|
if ( !theElementSearcher )
|
|
{
|
|
// create a searcher from elementIDs
|
|
SMESH::SMESH_Mesh_var mesh = elementIDs->GetMesh();
|
|
SMESHDS_Mesh* meshDS = SMESH::DownCast<SMESH_Mesh_i*>( mesh )->GetImpl().GetMeshDS();
|
|
|
|
if ( !idSourceToSet( elementIDs, meshDS, elements,
|
|
SMDSAbs_ElementType(type), /*emptyIfIsMesh=*/true))
|
|
return res._retn();
|
|
|
|
typedef SMDS_SetIterator<const SMDS_MeshElement*, TIDSortedElemSet::const_iterator > TIter;
|
|
SMDS_ElemIteratorPtr elemsIt( new TIter( elements.begin(), elements.end() ));
|
|
|
|
theElementSearcher = SMESH_MeshAlgos::GetElementSearcher( *getMeshDS(), elemsIt );
|
|
}
|
|
|
|
vector< const SMDS_MeshElement* > foundElems;
|
|
|
|
theElementSearcher->FindElementsByPoint( gp_Pnt( x,y,z ),
|
|
SMDSAbs_ElementType( type ),
|
|
foundElems);
|
|
res->length( foundElems.size() );
|
|
for ( int i = 0; i < foundElems.size(); ++i )
|
|
res[i] = foundElems[i]->GetID();
|
|
|
|
return res._retn();
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : GetPointState
|
|
//purpose : 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.
|
|
//=======================================================================
|
|
|
|
CORBA::Short SMESH_MeshEditor_i::GetPointState(CORBA::Double x,
|
|
CORBA::Double y,
|
|
CORBA::Double z)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
theSearchersDeleter.Set( myMesh );
|
|
if ( !theElementSearcher ) {
|
|
theElementSearcher = SMESH_MeshAlgos::GetElementSearcher( *getMeshDS() );
|
|
}
|
|
return CORBA::Short( theElementSearcher->GetPointState( gp_Pnt( x,y,z )));
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : convError
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
#define RETCASE(enm) case ::SMESH_MeshEditor::enm: return SMESH::SMESH_MeshEditor::enm;
|
|
|
|
static SMESH::SMESH_MeshEditor::Sew_Error convError( const::SMESH_MeshEditor::Sew_Error e )
|
|
{
|
|
switch ( e ) {
|
|
RETCASE( SEW_OK );
|
|
RETCASE( SEW_BORDER1_NOT_FOUND );
|
|
RETCASE( SEW_BORDER2_NOT_FOUND );
|
|
RETCASE( SEW_BOTH_BORDERS_NOT_FOUND );
|
|
RETCASE( SEW_BAD_SIDE_NODES );
|
|
RETCASE( SEW_VOLUMES_TO_SPLIT );
|
|
RETCASE( SEW_DIFF_NB_OF_ELEMENTS );
|
|
RETCASE( SEW_TOPO_DIFF_SETS_OF_ELEMENTS );
|
|
RETCASE( SEW_BAD_SIDE1_NODES );
|
|
RETCASE( SEW_BAD_SIDE2_NODES );
|
|
}
|
|
return SMESH::SMESH_MeshEditor::SEW_OK;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : SewFreeBorders
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::SMESH_MeshEditor::Sew_Error
|
|
SMESH_MeshEditor_i::SewFreeBorders(CORBA::Long FirstNodeID1,
|
|
CORBA::Long SecondNodeID1,
|
|
CORBA::Long LastNodeID1,
|
|
CORBA::Long FirstNodeID2,
|
|
CORBA::Long SecondNodeID2,
|
|
CORBA::Long LastNodeID2,
|
|
CORBA::Boolean CreatePolygons,
|
|
CORBA::Boolean CreatePolyedrs)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
SMESHDS_Mesh* aMesh = getMeshDS();
|
|
|
|
const SMDS_MeshNode* aBorderFirstNode = aMesh->FindNode( FirstNodeID1 );
|
|
const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeID1 );
|
|
const SMDS_MeshNode* aBorderLastNode = aMesh->FindNode( LastNodeID1 );
|
|
const SMDS_MeshNode* aSide2FirstNode = aMesh->FindNode( FirstNodeID2 );
|
|
const SMDS_MeshNode* aSide2SecondNode = aMesh->FindNode( SecondNodeID2 );
|
|
const SMDS_MeshNode* aSide2ThirdNode = aMesh->FindNode( LastNodeID2 );
|
|
|
|
if (!aBorderFirstNode ||
|
|
!aBorderSecondNode||
|
|
!aBorderLastNode)
|
|
return SMESH::SMESH_MeshEditor::SEW_BORDER1_NOT_FOUND;
|
|
if (!aSide2FirstNode ||
|
|
!aSide2SecondNode ||
|
|
!aSide2ThirdNode)
|
|
return SMESH::SMESH_MeshEditor::SEW_BORDER2_NOT_FOUND;
|
|
|
|
TPythonDump() << "error = " << this << ".SewFreeBorders( "
|
|
<< FirstNodeID1 << ", "
|
|
<< SecondNodeID1 << ", "
|
|
<< LastNodeID1 << ", "
|
|
<< FirstNodeID2 << ", "
|
|
<< SecondNodeID2 << ", "
|
|
<< LastNodeID2 << ", "
|
|
<< CreatePolygons<< ", "
|
|
<< CreatePolyedrs<< " )";
|
|
|
|
SMESH::SMESH_MeshEditor::Sew_Error error =
|
|
convError( getEditor().SewFreeBorder (aBorderFirstNode,
|
|
aBorderSecondNode,
|
|
aBorderLastNode,
|
|
aSide2FirstNode,
|
|
aSide2SecondNode,
|
|
aSide2ThirdNode,
|
|
true,
|
|
CreatePolygons,
|
|
CreatePolyedrs) );
|
|
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
return error;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return SMESH::SMESH_MeshEditor::Sew_Error(0);
|
|
}
|
|
|
|
|
|
//=======================================================================
|
|
//function : SewConformFreeBorders
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::SMESH_MeshEditor::Sew_Error
|
|
SMESH_MeshEditor_i::SewConformFreeBorders(CORBA::Long FirstNodeID1,
|
|
CORBA::Long SecondNodeID1,
|
|
CORBA::Long LastNodeID1,
|
|
CORBA::Long FirstNodeID2,
|
|
CORBA::Long SecondNodeID2)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
SMESHDS_Mesh* aMesh = getMeshDS();
|
|
|
|
const SMDS_MeshNode* aBorderFirstNode = aMesh->FindNode( FirstNodeID1 );
|
|
const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeID1 );
|
|
const SMDS_MeshNode* aBorderLastNode = aMesh->FindNode( LastNodeID1 );
|
|
const SMDS_MeshNode* aSide2FirstNode = aMesh->FindNode( FirstNodeID2 );
|
|
const SMDS_MeshNode* aSide2SecondNode = aMesh->FindNode( SecondNodeID2 );
|
|
const SMDS_MeshNode* aSide2ThirdNode = 0;
|
|
|
|
if (!aBorderFirstNode ||
|
|
!aBorderSecondNode||
|
|
!aBorderLastNode )
|
|
return SMESH::SMESH_MeshEditor::SEW_BORDER1_NOT_FOUND;
|
|
if (!aSide2FirstNode ||
|
|
!aSide2SecondNode)
|
|
return SMESH::SMESH_MeshEditor::SEW_BORDER2_NOT_FOUND;
|
|
|
|
TPythonDump() << "error = " << this << ".SewConformFreeBorders( "
|
|
<< FirstNodeID1 << ", "
|
|
<< SecondNodeID1 << ", "
|
|
<< LastNodeID1 << ", "
|
|
<< FirstNodeID2 << ", "
|
|
<< SecondNodeID2 << " )";
|
|
|
|
SMESH::SMESH_MeshEditor::Sew_Error error =
|
|
convError( getEditor().SewFreeBorder (aBorderFirstNode,
|
|
aBorderSecondNode,
|
|
aBorderLastNode,
|
|
aSide2FirstNode,
|
|
aSide2SecondNode,
|
|
aSide2ThirdNode,
|
|
true,
|
|
false, false) );
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
return error;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return SMESH::SMESH_MeshEditor::Sew_Error(0);
|
|
}
|
|
|
|
|
|
//=======================================================================
|
|
//function : SewBorderToSide
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::SMESH_MeshEditor::Sew_Error
|
|
SMESH_MeshEditor_i::SewBorderToSide(CORBA::Long FirstNodeIDOnFreeBorder,
|
|
CORBA::Long SecondNodeIDOnFreeBorder,
|
|
CORBA::Long LastNodeIDOnFreeBorder,
|
|
CORBA::Long FirstNodeIDOnSide,
|
|
CORBA::Long LastNodeIDOnSide,
|
|
CORBA::Boolean CreatePolygons,
|
|
CORBA::Boolean CreatePolyedrs)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
SMESHDS_Mesh* aMesh = getMeshDS();
|
|
|
|
const SMDS_MeshNode* aBorderFirstNode = aMesh->FindNode( FirstNodeIDOnFreeBorder );
|
|
const SMDS_MeshNode* aBorderSecondNode = aMesh->FindNode( SecondNodeIDOnFreeBorder );
|
|
const SMDS_MeshNode* aBorderLastNode = aMesh->FindNode( LastNodeIDOnFreeBorder );
|
|
const SMDS_MeshNode* aSide2FirstNode = aMesh->FindNode( FirstNodeIDOnSide );
|
|
const SMDS_MeshNode* aSide2SecondNode = aMesh->FindNode( LastNodeIDOnSide );
|
|
const SMDS_MeshNode* aSide2ThirdNode = 0;
|
|
|
|
if (!aBorderFirstNode ||
|
|
!aBorderSecondNode||
|
|
!aBorderLastNode )
|
|
return SMESH::SMESH_MeshEditor::SEW_BORDER1_NOT_FOUND;
|
|
if (!aSide2FirstNode ||
|
|
!aSide2SecondNode)
|
|
return SMESH::SMESH_MeshEditor::SEW_BAD_SIDE_NODES;
|
|
|
|
TPythonDump() << "error = " << this << ".SewBorderToSide( "
|
|
<< FirstNodeIDOnFreeBorder << ", "
|
|
<< SecondNodeIDOnFreeBorder << ", "
|
|
<< LastNodeIDOnFreeBorder << ", "
|
|
<< FirstNodeIDOnSide << ", "
|
|
<< LastNodeIDOnSide << ", "
|
|
<< CreatePolygons << ", "
|
|
<< CreatePolyedrs << ") ";
|
|
|
|
SMESH::SMESH_MeshEditor::Sew_Error error =
|
|
convError( getEditor().SewFreeBorder (aBorderFirstNode,
|
|
aBorderSecondNode,
|
|
aBorderLastNode,
|
|
aSide2FirstNode,
|
|
aSide2SecondNode,
|
|
aSide2ThirdNode,
|
|
false,
|
|
CreatePolygons,
|
|
CreatePolyedrs) );
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
return error;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return SMESH::SMESH_MeshEditor::Sew_Error(0);
|
|
}
|
|
|
|
|
|
//=======================================================================
|
|
//function : SewSideElements
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
SMESH::SMESH_MeshEditor::Sew_Error
|
|
SMESH_MeshEditor_i::SewSideElements(const SMESH::long_array& IDsOfSide1Elements,
|
|
const SMESH::long_array& IDsOfSide2Elements,
|
|
CORBA::Long NodeID1OfSide1ToMerge,
|
|
CORBA::Long NodeID1OfSide2ToMerge,
|
|
CORBA::Long NodeID2OfSide1ToMerge,
|
|
CORBA::Long NodeID2OfSide2ToMerge)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
SMESHDS_Mesh* aMesh = getMeshDS();
|
|
|
|
const SMDS_MeshNode* aFirstNode1ToMerge = aMesh->FindNode( NodeID1OfSide1ToMerge );
|
|
const SMDS_MeshNode* aFirstNode2ToMerge = aMesh->FindNode( NodeID1OfSide2ToMerge );
|
|
const SMDS_MeshNode* aSecondNode1ToMerge = aMesh->FindNode( NodeID2OfSide1ToMerge );
|
|
const SMDS_MeshNode* aSecondNode2ToMerge = aMesh->FindNode( NodeID2OfSide2ToMerge );
|
|
|
|
if (!aFirstNode1ToMerge ||
|
|
!aFirstNode2ToMerge )
|
|
return SMESH::SMESH_MeshEditor::SEW_BAD_SIDE1_NODES;
|
|
if (!aSecondNode1ToMerge||
|
|
!aSecondNode2ToMerge)
|
|
return SMESH::SMESH_MeshEditor::SEW_BAD_SIDE2_NODES;
|
|
|
|
TIDSortedElemSet aSide1Elems, aSide2Elems;
|
|
arrayToSet(IDsOfSide1Elements, aMesh, aSide1Elems);
|
|
arrayToSet(IDsOfSide2Elements, aMesh, aSide2Elems);
|
|
|
|
TPythonDump() << "error = " << this << ".SewSideElements( "
|
|
<< IDsOfSide1Elements << ", "
|
|
<< IDsOfSide2Elements << ", "
|
|
<< NodeID1OfSide1ToMerge << ", "
|
|
<< NodeID1OfSide2ToMerge << ", "
|
|
<< NodeID2OfSide1ToMerge << ", "
|
|
<< NodeID2OfSide2ToMerge << ")";
|
|
|
|
SMESH::SMESH_MeshEditor::Sew_Error error =
|
|
convError( getEditor().SewSideElements (aSide1Elems, aSide2Elems,
|
|
aFirstNode1ToMerge,
|
|
aFirstNode2ToMerge,
|
|
aSecondNode1ToMerge,
|
|
aSecondNode2ToMerge));
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
return error;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return SMESH::SMESH_MeshEditor::Sew_Error(0);
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Set new nodes for given element
|
|
* \param ide - element id
|
|
* \param newIDs - new node ids
|
|
* \retval CORBA::Boolean - true if result is OK
|
|
*/
|
|
//================================================================================
|
|
|
|
CORBA::Boolean SMESH_MeshEditor_i::ChangeElemNodes(CORBA::Long ide,
|
|
const SMESH::long_array& newIDs)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
const SMDS_MeshElement* elem = getMeshDS()->FindElement(ide);
|
|
if(!elem) return false;
|
|
|
|
int nbn = newIDs.length();
|
|
int i=0;
|
|
vector<const SMDS_MeshNode*> aNodes(nbn);
|
|
int nbn1=-1;
|
|
for(; i<nbn; i++) {
|
|
const SMDS_MeshNode* aNode = getMeshDS()->FindNode(newIDs[i]);
|
|
if(aNode) {
|
|
nbn1++;
|
|
aNodes[nbn1] = aNode;
|
|
}
|
|
}
|
|
TPythonDump() << "isDone = " << this << ".ChangeElemNodes( "
|
|
<< ide << ", " << newIDs << " )";
|
|
|
|
MESSAGE("ChangeElementNodes");
|
|
bool res = getMeshDS()->ChangeElementNodes( elem, & aNodes[0], nbn1+1 );
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/ !res );
|
|
|
|
return res;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//=======================================================================
|
|
/*!
|
|
* \brief Makes a part of the mesh quadratic or bi-quadratic
|
|
*/
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::convertToQuadratic(CORBA::Boolean theForce3d,
|
|
CORBA::Boolean theToBiQuad,
|
|
SMESH::SMESH_IDSource_ptr theObject)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
TIDSortedElemSet elems;
|
|
bool elemsOK;
|
|
if ( !( elemsOK = CORBA::is_nil( theObject )))
|
|
{
|
|
prepareIdSource( theObject );
|
|
elemsOK = idSourceToSet( theObject, getMeshDS(), elems,
|
|
SMDSAbs_All, /*emptyIfIsMesh=*/true );
|
|
}
|
|
if ( elemsOK )
|
|
{
|
|
if ( !elems.empty() && (*elems.begin())->GetType() == SMDSAbs_Node )
|
|
THROW_SALOME_CORBA_EXCEPTION("Group of nodes is not allowed", SALOME::BAD_PARAM);
|
|
|
|
if ( elems.empty() ) getEditor().ConvertToQuadratic(theForce3d, theToBiQuad);
|
|
else getEditor().ConvertToQuadratic(theForce3d, elems, theToBiQuad);
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
}
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ConvertFromQuadratic
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
CORBA::Boolean SMESH_MeshEditor_i::ConvertFromQuadratic()
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
CORBA::Boolean isDone = getEditor().ConvertFromQuadratic();
|
|
TPythonDump() << this << ".ConvertFromQuadratic()";
|
|
declareMeshModified( /*isReComputeSafe=*/!isDone );
|
|
return isDone;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ConvertToQuadratic
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::ConvertToQuadratic(CORBA::Boolean theForce3d)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
convertToQuadratic( theForce3d, false );
|
|
TPythonDump() << this << ".ConvertToQuadratic("<<theForce3d<<")";
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Makes a part of the mesh quadratic
|
|
*/
|
|
//================================================================================
|
|
|
|
void SMESH_MeshEditor_i::ConvertToQuadraticObject(CORBA::Boolean theForce3d,
|
|
SMESH::SMESH_IDSource_ptr theObject)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
convertToQuadratic( theForce3d, false, theObject );
|
|
TPythonDump() << this << ".ConvertToQuadraticObject("<<theForce3d<<", "<<theObject<<")";
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Makes a part of the mesh bi-quadratic
|
|
*/
|
|
//================================================================================
|
|
|
|
void SMESH_MeshEditor_i::ConvertToBiQuadratic(CORBA::Boolean theForce3d,
|
|
SMESH::SMESH_IDSource_ptr theObject)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
convertToQuadratic( theForce3d, true, theObject );
|
|
TPythonDump() << this << ".ConvertToBiQuadratic("<<theForce3d<<", "<<theObject<<")";
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Makes a part of the mesh linear
|
|
*/
|
|
//================================================================================
|
|
|
|
void SMESH_MeshEditor_i::ConvertFromQuadraticObject(SMESH::SMESH_IDSource_ptr theObject)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
|
|
TPythonDump pyDump;
|
|
|
|
TIDSortedElemSet elems;
|
|
prepareIdSource( theObject );
|
|
if ( idSourceToSet( theObject, getMeshDS(), elems, SMDSAbs_All, /*emptyIfIsMesh=*/true ))
|
|
{
|
|
if ( elems.empty() )
|
|
{
|
|
ConvertFromQuadratic();
|
|
}
|
|
else if ( (*elems.begin())->GetType() == SMDSAbs_Node )
|
|
{
|
|
THROW_SALOME_CORBA_EXCEPTION("Group of nodes is not allowed", SALOME::BAD_PARAM);
|
|
}
|
|
else
|
|
{
|
|
getEditor().ConvertFromQuadratic(elems);
|
|
}
|
|
}
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
|
|
pyDump << this << ".ConvertFromQuadraticObject( "<<theObject<<" )";
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : makeMesh
|
|
//purpose : create a named imported mesh
|
|
//=======================================================================
|
|
|
|
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_wrap meshSO = gen->ObjectToSObject( study, mesh );
|
|
gen->SetName( meshSO, theMeshName, "Mesh" );
|
|
gen->SetPixMap( meshSO, "ICON_SMESH_TREE_MESH_IMPORTED");
|
|
|
|
return mesh._retn();
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : dumpGroupsList
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
void SMESH_MeshEditor_i::dumpGroupsList(TPythonDump & theDumpPython,
|
|
const SMESH::ListOfGroups * theGroupList)
|
|
{
|
|
bool isDumpGroupList = ( theGroupList && theGroupList->length() > 0 );
|
|
if ( isDumpGroupList )
|
|
theDumpPython << theGroupList << " = ";
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
\brief Generates the unique group name.
|
|
\param thePrefix name prefix
|
|
\return unique name
|
|
*/
|
|
//================================================================================
|
|
|
|
string SMESH_MeshEditor_i::generateGroupName(const string& thePrefix)
|
|
{
|
|
SMESH::ListOfGroups_var groups = myMesh_i->GetGroups();
|
|
set<string> groupNames;
|
|
|
|
// Get existing group names
|
|
for (int i = 0, nbGroups = groups->length(); i < nbGroups; i++ ) {
|
|
SMESH::SMESH_GroupBase_var aGroup = groups[i];
|
|
if (CORBA::is_nil(aGroup))
|
|
continue;
|
|
|
|
CORBA::String_var name = aGroup->GetName();
|
|
groupNames.insert( name.in() );
|
|
}
|
|
|
|
// Find new name
|
|
string name = thePrefix;
|
|
int index = 0;
|
|
|
|
while (!groupNames.insert(name).second)
|
|
name = SMESH_Comment( thePrefix ) << "_" << index++;
|
|
|
|
return name;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Prepare SMESH_IDSource for work
|
|
*/
|
|
//================================================================================
|
|
|
|
void SMESH_MeshEditor_i::prepareIdSource(SMESH::SMESH_IDSource_ptr theObject)
|
|
{
|
|
if ( SMESH::Filter_i* filter = SMESH::DownCast<SMESH::Filter_i*>( theObject ))
|
|
{
|
|
SMESH::SMESH_Mesh_var mesh = myMesh_i->_this();
|
|
filter->SetMesh( mesh );
|
|
}
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Duplicates given elements, i.e. creates new elements based on the
|
|
* same nodes as the given ones.
|
|
* \param theElements - container of elements to duplicate.
|
|
* \param theGroupName - a name of group to contain the generated elements.
|
|
* If a group with such a name already exists, the new elements
|
|
* are added to the existng group, else a new group is created.
|
|
* If \a theGroupName is empty, new elements are not added
|
|
* in any group.
|
|
* \return a group where the new elements are added. NULL if theGroupName == "".
|
|
* \sa DoubleNode()
|
|
*/
|
|
//================================================================================
|
|
|
|
SMESH::SMESH_Group_ptr
|
|
SMESH_MeshEditor_i::DoubleElements(SMESH::SMESH_IDSource_ptr theElements,
|
|
const char* theGroupName)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH::SMESH_Group_var newGroup;
|
|
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
TPythonDump pyDump;
|
|
|
|
TIDSortedElemSet elems;
|
|
prepareIdSource( theElements );
|
|
if ( idSourceToSet( theElements, getMeshDS(), elems, SMDSAbs_All, /*emptyIfIsMesh=*/true))
|
|
{
|
|
getEditor().DoubleElements( elems );
|
|
|
|
if ( strlen( theGroupName ) && !getEditor().GetLastCreatedElems().IsEmpty() )
|
|
{
|
|
// group type
|
|
SMESH::ElementType type =
|
|
SMESH::ElementType( getEditor().GetLastCreatedElems().Value(1)->GetType() );
|
|
// find existing group
|
|
SMESH::ListOfGroups_var groups = myMesh_i->GetGroups();
|
|
for ( size_t i = 0; i < groups->length(); ++i )
|
|
if ( groups[i]->GetType() == type )
|
|
{
|
|
CORBA::String_var name = groups[i]->GetName();
|
|
if ( strcmp( name, theGroupName ) == 0 ) {
|
|
newGroup = SMESH::SMESH_Group::_narrow( groups[i] );
|
|
break;
|
|
}
|
|
}
|
|
// create a new group
|
|
if ( newGroup->_is_nil() )
|
|
newGroup = myMesh_i->CreateGroup( type, theGroupName );
|
|
// fill newGroup
|
|
if ( SMESH_Group_i* group_i = SMESH::DownCast< SMESH_Group_i* >( newGroup ))
|
|
{
|
|
SMESHDS_Group* groupDS = static_cast< SMESHDS_Group* >( group_i->GetGroupDS() );
|
|
const SMESH_SequenceOfElemPtr& aSeq = getEditor().GetLastCreatedElems();
|
|
for ( int i = 1; i <= aSeq.Length(); i++ )
|
|
groupDS->SMDSGroup().Add( aSeq(i) );
|
|
}
|
|
}
|
|
}
|
|
// python dump
|
|
if ( !newGroup->_is_nil() )
|
|
pyDump << newGroup << " = ";
|
|
pyDump << this << ".DoubleElements( "
|
|
<< theElements << ", " << "'" << theGroupName <<"')";
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
|
|
return newGroup._retn();
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
\brief Creates a hole in a mesh by doubling the nodes of some particular elements
|
|
\param theNodes - identifiers of nodes to be doubled
|
|
\param theModifiedElems - identifiers of elements to be updated by the new (doubled)
|
|
nodes. If list of element identifiers is empty then nodes are doubled but
|
|
they not assigned to elements
|
|
\return TRUE if operation has been completed successfully, FALSE otherwise
|
|
\sa DoubleNode(), DoubleNodeGroup(), DoubleNodeGroups()
|
|
*/
|
|
//================================================================================
|
|
|
|
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theNodes,
|
|
const SMESH::long_array& theModifiedElems )
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
list< int > aListOfNodes;
|
|
int i, n;
|
|
for ( i = 0, n = theNodes.length(); i < n; i++ )
|
|
aListOfNodes.push_back( theNodes[ i ] );
|
|
|
|
list< int > aListOfElems;
|
|
for ( i = 0, n = theModifiedElems.length(); i < n; i++ )
|
|
aListOfElems.push_back( theModifiedElems[ i ] );
|
|
|
|
bool aResult = getEditor().DoubleNodes( aListOfNodes, aListOfElems );
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/ !aResult );
|
|
|
|
// Update Python script
|
|
TPythonDump() << this << ".DoubleNodes( " << theNodes << ", "<< theModifiedElems << " )";
|
|
|
|
return aResult;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
\brief Creates a hole in a mesh by doubling the nodes of some particular elements
|
|
This method provided for convenience works as DoubleNodes() described above.
|
|
\param theNodeId - identifier of node to be doubled.
|
|
\param theModifiedElems - identifiers of elements to be updated.
|
|
\return TRUE if operation has been completed successfully, FALSE otherwise
|
|
\sa DoubleNodes(), DoubleNodeGroup(), DoubleNodeGroups()
|
|
*/
|
|
//================================================================================
|
|
|
|
CORBA::Boolean SMESH_MeshEditor_i::DoubleNode( CORBA::Long theNodeId,
|
|
const SMESH::long_array& theModifiedElems )
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
SMESH::long_array_var aNodes = new SMESH::long_array;
|
|
aNodes->length( 1 );
|
|
aNodes[ 0 ] = theNodeId;
|
|
|
|
TPythonDump pyDump; // suppress dump by the next line
|
|
|
|
CORBA::Boolean done = DoubleNodes( aNodes, theModifiedElems );
|
|
|
|
pyDump << this << ".DoubleNode( " << theNodeId << ", " << theModifiedElems << " )";
|
|
|
|
return done;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
\brief Creates a hole in a mesh by doubling the nodes of some particular elements
|
|
This method provided for convenience works as DoubleNodes() described above.
|
|
\param theNodes - group of nodes to be doubled.
|
|
\param theModifiedElems - group of elements to be updated.
|
|
\return TRUE if operation has been completed successfully, FALSE otherwise
|
|
\sa DoubleNode(), DoubleNodes(), DoubleNodeGroups()
|
|
*/
|
|
//================================================================================
|
|
|
|
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroup(SMESH::SMESH_GroupBase_ptr theNodes,
|
|
SMESH::SMESH_GroupBase_ptr theModifiedElems )
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
if ( CORBA::is_nil( theNodes ) && theNodes->GetType() != SMESH::NODE )
|
|
return false;
|
|
|
|
SMESH::long_array_var aNodes = theNodes->GetListOfID();
|
|
SMESH::long_array_var aModifiedElems;
|
|
if ( !CORBA::is_nil( theModifiedElems ) )
|
|
aModifiedElems = theModifiedElems->GetListOfID();
|
|
else
|
|
{
|
|
aModifiedElems = new SMESH::long_array;
|
|
aModifiedElems->length( 0 );
|
|
}
|
|
|
|
TPythonDump pyDump; // suppress dump by the next line
|
|
|
|
bool done = DoubleNodes( aNodes, aModifiedElems );
|
|
|
|
pyDump << this << ".DoubleNodeGroup( " << theNodes << ", " << theModifiedElems << " )";
|
|
|
|
return done;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
|
|
* Works as DoubleNodeGroup(), but returns a new group with newly created nodes.
|
|
* \param theNodes - group of nodes to be doubled.
|
|
* \param theModifiedElems - group of elements to be updated.
|
|
* \return a new group with newly created nodes
|
|
* \sa DoubleNodeGroup()
|
|
*/
|
|
//================================================================================
|
|
|
|
SMESH::SMESH_Group_ptr
|
|
SMESH_MeshEditor_i::DoubleNodeGroupNew( SMESH::SMESH_GroupBase_ptr theNodes,
|
|
SMESH::SMESH_GroupBase_ptr theModifiedElems )
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
SMESH::SMESH_Group_var aNewGroup;
|
|
|
|
if ( CORBA::is_nil( theNodes ) && theNodes->GetType() != SMESH::NODE )
|
|
return aNewGroup._retn();
|
|
|
|
// Duplicate nodes
|
|
SMESH::long_array_var aNodes = theNodes->GetListOfID();
|
|
SMESH::long_array_var aModifiedElems;
|
|
if ( !CORBA::is_nil( theModifiedElems ) )
|
|
aModifiedElems = theModifiedElems->GetListOfID();
|
|
else {
|
|
aModifiedElems = new SMESH::long_array;
|
|
aModifiedElems->length( 0 );
|
|
}
|
|
|
|
TPythonDump pyDump; // suppress dump by the next line
|
|
|
|
bool aResult = DoubleNodes( aNodes, aModifiedElems );
|
|
if ( aResult )
|
|
{
|
|
// Create group with newly created nodes
|
|
SMESH::long_array_var anIds = GetLastCreatedNodes();
|
|
if (anIds->length() > 0) {
|
|
string anUnindexedName (theNodes->GetName());
|
|
string aNewName = generateGroupName(anUnindexedName + "_double");
|
|
aNewGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
|
|
aNewGroup->Add(anIds);
|
|
pyDump << aNewGroup << " = ";
|
|
}
|
|
}
|
|
|
|
pyDump << this << ".DoubleNodeGroupNew( " << theNodes << ", "
|
|
<< theModifiedElems << " )";
|
|
|
|
return aNewGroup._retn();
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
\brief Creates a hole in a mesh by doubling the nodes of some particular elements
|
|
This method provided for convenience works as DoubleNodes() described above.
|
|
\param theNodes - list of groups of nodes to be doubled
|
|
\param theModifiedElems - list of groups of elements to be updated.
|
|
\return TRUE if operation has been completed successfully, FALSE otherwise
|
|
\sa DoubleNode(), DoubleNodeGroup(), DoubleNodes()
|
|
*/
|
|
//================================================================================
|
|
|
|
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups(const SMESH::ListOfGroups& theNodes,
|
|
const SMESH::ListOfGroups& theModifiedElems )
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
std::list< int > aNodes;
|
|
int i, n, j, m;
|
|
for ( i = 0, n = theNodes.length(); i < n; i++ )
|
|
{
|
|
SMESH::SMESH_GroupBase_var aGrp = theNodes[ i ];
|
|
if ( !CORBA::is_nil( aGrp ) && aGrp->GetType() == SMESH::NODE )
|
|
{
|
|
SMESH::long_array_var aCurr = aGrp->GetListOfID();
|
|
for ( j = 0, m = aCurr->length(); j < m; j++ )
|
|
aNodes.push_back( aCurr[ j ] );
|
|
}
|
|
}
|
|
|
|
std::list< int > anElems;
|
|
for ( i = 0, n = theModifiedElems.length(); i < n; i++ )
|
|
{
|
|
SMESH::SMESH_GroupBase_var aGrp = theModifiedElems[ i ];
|
|
if ( !CORBA::is_nil( aGrp ) && aGrp->GetType() != SMESH::NODE )
|
|
{
|
|
SMESH::long_array_var aCurr = aGrp->GetListOfID();
|
|
for ( j = 0, m = aCurr->length(); j < m; j++ )
|
|
anElems.push_back( aCurr[ j ] );
|
|
}
|
|
}
|
|
|
|
bool aResult = getEditor().DoubleNodes( aNodes, anElems );
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
|
|
TPythonDump() << this << ".DoubleNodeGroups( " << theNodes << ", " << theModifiedElems << " )";
|
|
|
|
return aResult;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements.
|
|
* Works as DoubleNodeGroups(), but returns a new group with newly created nodes.
|
|
* \param theNodes - group of nodes to be doubled.
|
|
* \param theModifiedElems - group of elements to be updated.
|
|
* \return a new group with newly created nodes
|
|
* \sa DoubleNodeGroups()
|
|
*/
|
|
//================================================================================
|
|
|
|
SMESH::SMESH_Group_ptr
|
|
SMESH_MeshEditor_i::DoubleNodeGroupsNew( const SMESH::ListOfGroups& theNodes,
|
|
const SMESH::ListOfGroups& theModifiedElems )
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH::SMESH_Group_var aNewGroup;
|
|
|
|
TPythonDump pyDump; // suppress dump by the next line
|
|
|
|
bool aResult = DoubleNodeGroups( theNodes, theModifiedElems );
|
|
|
|
if ( aResult )
|
|
{
|
|
// Create group with newly created nodes
|
|
SMESH::long_array_var anIds = GetLastCreatedNodes();
|
|
if (anIds->length() > 0) {
|
|
string anUnindexedName (theNodes[0]->GetName());
|
|
string aNewName = generateGroupName(anUnindexedName + "_double");
|
|
aNewGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
|
|
aNewGroup->Add(anIds);
|
|
pyDump << aNewGroup << " = ";
|
|
}
|
|
}
|
|
|
|
pyDump << this << ".DoubleNodeGroupsNew( " << theNodes << ", "
|
|
<< theModifiedElems << " )";
|
|
|
|
return aNewGroup._retn();
|
|
}
|
|
|
|
|
|
//================================================================================
|
|
/*!
|
|
\brief Creates a hole in a mesh by doubling the nodes of some particular elements
|
|
\param theElems - the list of elements (edges or faces) to be replicated
|
|
The nodes for duplication could be found from these elements
|
|
\param theNodesNot - list of nodes to NOT replicate
|
|
\param theAffectedElems - the list of elements (cells and edges) to which the
|
|
replicated nodes should be associated to.
|
|
\return TRUE if operation has been completed successfully, FALSE otherwise
|
|
\sa DoubleNodeGroup(), DoubleNodeGroups()
|
|
*/
|
|
//================================================================================
|
|
|
|
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElem( const SMESH::long_array& theElems,
|
|
const SMESH::long_array& theNodesNot,
|
|
const SMESH::long_array& theAffectedElems )
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
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 = getEditor().DoubleNodes( anElems, aNodes, anAffected );
|
|
|
|
// Update Python script
|
|
TPythonDump() << this << ".DoubleNodeElem( " << theElems << ", "
|
|
<< theNodesNot << ", " << theAffectedElems << " )";
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
return aResult;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
\brief Creates a hole in a mesh by doubling the nodes of some particular elements
|
|
\param theElems - the list of elements (edges or faces) to be replicated
|
|
The nodes for duplication could be found from these elements
|
|
\param theNodesNot - list of nodes to NOT replicate
|
|
\param theShape - shape to detect affected elements (element which geometric center
|
|
located on or inside shape).
|
|
The replicated nodes should be associated to affected elements.
|
|
\return TRUE if operation has been completed successfully, FALSE otherwise
|
|
\sa DoubleNodeGroupInRegion(), DoubleNodeGroupsInRegion()
|
|
*/
|
|
//================================================================================
|
|
|
|
CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemInRegion ( const SMESH::long_array& theElems,
|
|
const SMESH::long_array& theNodesNot,
|
|
GEOM::GEOM_Object_ptr theShape )
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
|
|
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 = getEditor().DoubleNodesInRegion( anElems, aNodes, aShape );
|
|
|
|
// Update Python script
|
|
TPythonDump() << "isDone = " << this << ".DoubleNodeElemInRegion( " << theElems << ", "
|
|
<< theNodesNot << ", " << theShape << " )";
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
return aResult;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
\brief Creates a hole in a mesh by doubling the nodes of some particular elements
|
|
\param theElems - group of of elements (edges or faces) to be replicated
|
|
\param theNodesNot - group of nodes not to replicated
|
|
\param theAffectedElems - group of elements to which the replicated nodes
|
|
should be associated to.
|
|
\return TRUE if operation has been completed successfully, FALSE otherwise
|
|
\sa DoubleNodes(), DoubleNodeGroups()
|
|
*/
|
|
//================================================================================
|
|
|
|
CORBA::Boolean
|
|
SMESH_MeshEditor_i::DoubleNodeElemGroup(SMESH::SMESH_GroupBase_ptr theElems,
|
|
SMESH::SMESH_GroupBase_ptr theNodesNot,
|
|
SMESH::SMESH_GroupBase_ptr theAffectedElems)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE )
|
|
return false;
|
|
|
|
initData();
|
|
|
|
|
|
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 = getEditor().DoubleNodes( anElems, aNodes, anAffected );
|
|
|
|
// Update Python script
|
|
TPythonDump() << "isDone = " << this << ".DoubleNodeElemGroup( " << theElems << ", "
|
|
<< theNodesNot << ", " << theAffectedElems << " )";
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
return aResult;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements
|
|
* Works as DoubleNodeElemGroup(), but returns a new group with newly created elements.
|
|
* \param theElems - group of of elements (edges or faces) to be replicated
|
|
* \param theNodesNot - group of nodes not to replicated
|
|
* \param theAffectedElems - group of elements to which the replicated nodes
|
|
* should be associated to.
|
|
* \return a new group with newly created elements
|
|
* \sa DoubleNodeElemGroup()
|
|
*/
|
|
//================================================================================
|
|
|
|
SMESH::SMESH_Group_ptr
|
|
SMESH_MeshEditor_i::DoubleNodeElemGroupNew(SMESH::SMESH_GroupBase_ptr theElems,
|
|
SMESH::SMESH_GroupBase_ptr theNodesNot,
|
|
SMESH::SMESH_GroupBase_ptr theAffectedElems)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump pyDump;
|
|
SMESH::ListOfGroups_var twoGroups = DoubleNodeElemGroup2New( theElems,
|
|
theNodesNot,
|
|
theAffectedElems,
|
|
true, false );
|
|
SMESH::SMESH_GroupBase_var baseGroup = twoGroups[0].in();
|
|
SMESH::SMESH_Group_var elemGroup = SMESH::SMESH_Group::_narrow( baseGroup );
|
|
|
|
pyDump << elemGroup << " = " << this << ".DoubleNodeElemGroupNew( "
|
|
<< theElems << ", "
|
|
<< theNodesNot << ", "
|
|
<< theAffectedElems << " )";
|
|
|
|
return elemGroup._retn();
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements
|
|
* Works as DoubleNodeElemGroup(), but returns a new group with newly created elements.
|
|
* \param theElems - group of of elements (edges or faces) to be replicated
|
|
* \param theNodesNot - group of nodes not to replicated
|
|
* \param theAffectedElems - group of elements to which the replicated nodes
|
|
* should be associated to.
|
|
* \return a new group with newly created elements
|
|
* \sa DoubleNodeElemGroup()
|
|
*/
|
|
//================================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::DoubleNodeElemGroup2New(SMESH::SMESH_GroupBase_ptr theElems,
|
|
SMESH::SMESH_GroupBase_ptr theNodesNot,
|
|
SMESH::SMESH_GroupBase_ptr theAffectedElems,
|
|
CORBA::Boolean theElemGroupNeeded,
|
|
CORBA::Boolean theNodeGroupNeeded)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
SMESH::SMESH_Group_var aNewElemGroup, aNewNodeGroup;
|
|
SMESH::ListOfGroups_var aTwoGroups = new SMESH::ListOfGroups();
|
|
aTwoGroups->length( 2 );
|
|
|
|
if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE )
|
|
return aTwoGroups._retn();
|
|
|
|
initData();
|
|
|
|
|
|
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 = getEditor().DoubleNodes( anElems, aNodes, anAffected );
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/ !aResult );
|
|
|
|
TPythonDump pyDump;
|
|
|
|
if ( aResult )
|
|
{
|
|
// Create group with newly created elements
|
|
CORBA::String_var elemGroupName = theElems->GetName();
|
|
string aNewName = generateGroupName( string(elemGroupName.in()) + "_double");
|
|
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 ( !getEditor().GetLastCreatedNodes().IsEmpty() && theNodeGroupNeeded )
|
|
{
|
|
SMESH::long_array_var anIds = GetLastCreatedNodes();
|
|
aNewNodeGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
|
|
aNewNodeGroup->Add(anIds);
|
|
}
|
|
}
|
|
|
|
// Update Python script
|
|
|
|
pyDump << "[ ";
|
|
if ( aNewElemGroup->_is_nil() ) pyDump << "nothing, ";
|
|
else pyDump << aNewElemGroup << ", ";
|
|
if ( aNewNodeGroup->_is_nil() ) pyDump << "nothing ] = ";
|
|
else pyDump << aNewNodeGroup << " ] = ";
|
|
|
|
pyDump << this << ".DoubleNodeElemGroup2New( " << theElems << ", "
|
|
<< theNodesNot << ", "
|
|
<< theAffectedElems << ", "
|
|
<< theElemGroupNeeded << ", "
|
|
<< theNodeGroupNeeded <<" )";
|
|
|
|
aTwoGroups[0] = aNewElemGroup._retn();
|
|
aTwoGroups[1] = aNewNodeGroup._retn();
|
|
return aTwoGroups._retn();
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
\brief Creates a hole in a mesh by doubling the nodes of some particular elements
|
|
\param theElems - group of of elements (edges or faces) to be replicated
|
|
\param theNodesNot - group of nodes not to replicated
|
|
\param theShape - shape to detect affected elements (element which geometric center
|
|
located on or inside shape).
|
|
The replicated nodes should be associated to affected elements.
|
|
\return TRUE if operation has been completed successfully, FALSE otherwise
|
|
\sa DoubleNodesInRegion(), DoubleNodeGroupsInRegion()
|
|
*/
|
|
//================================================================================
|
|
|
|
CORBA::Boolean
|
|
SMESH_MeshEditor_i::DoubleNodeElemGroupInRegion(SMESH::SMESH_GroupBase_ptr theElems,
|
|
SMESH::SMESH_GroupBase_ptr theNodesNot,
|
|
GEOM::GEOM_Object_ptr theShape )
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
if ( CORBA::is_nil( theElems ) && theElems->GetType() == SMESH::NODE )
|
|
return false;
|
|
|
|
initData();
|
|
|
|
|
|
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 = getEditor().DoubleNodesInRegion( anElems, aNodes, aShape );
|
|
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/ !aResult );
|
|
|
|
// Update Python script
|
|
TPythonDump() << "isDone = " << this << ".DoubleNodeElemGroupInRegion( " << theElems << ", "
|
|
<< theNodesNot << ", " << theShape << " )";
|
|
return aResult;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Re-load elements from a list of groups into a TIDSortedElemSet
|
|
* \param [in] theGrpList - groups
|
|
* \param [in] theMeshDS - mesh
|
|
* \param [out] theElemSet - set of elements
|
|
* \param [in] theIsNodeGrp - is \a theGrpList includes goups of nodes
|
|
*/
|
|
//================================================================================
|
|
|
|
static void listOfGroupToSet(const SMESH::ListOfGroups& theGrpList,
|
|
SMESHDS_Mesh* theMeshDS,
|
|
TIDSortedElemSet& theElemSet,
|
|
const bool theIsNodeGrp)
|
|
{
|
|
for ( int i = 0, n = theGrpList.length(); i < n; i++ )
|
|
{
|
|
SMESH::SMESH_GroupBase_var aGrp = theGrpList[ i ];
|
|
if ( !CORBA::is_nil( aGrp ) && (theIsNodeGrp ? aGrp->GetType() == SMESH::NODE
|
|
: aGrp->GetType() != SMESH::NODE ) )
|
|
{
|
|
SMESH::long_array_var anIDs = aGrp->GetIDs();
|
|
arrayToSet( anIDs, theMeshDS, theElemSet, theIsNodeGrp ? SMDSAbs_Node : SMDSAbs_All );
|
|
}
|
|
}
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
\brief Creates a hole in a mesh by doubling the nodes of some particular elements.
|
|
This method provided for convenience works as DoubleNodes() described above.
|
|
\param theElems - list of groups of elements (edges or faces) to be replicated
|
|
\param theNodesNot - list of groups of nodes not to replicated
|
|
\param theAffectedElems - group of elements to which the replicated nodes
|
|
should be associated to.
|
|
\return TRUE if operation has been completed successfully, FALSE otherwise
|
|
\sa DoubleNodeGroup(), DoubleNodes(), DoubleNodeElemGroupsNew()
|
|
*/
|
|
//================================================================================
|
|
|
|
CORBA::Boolean
|
|
SMESH_MeshEditor_i::DoubleNodeElemGroups(const SMESH::ListOfGroups& theElems,
|
|
const SMESH::ListOfGroups& theNodesNot,
|
|
const SMESH::ListOfGroups& theAffectedElems)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
|
|
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 = getEditor().DoubleNodes( anElems, aNodes, anAffected );
|
|
|
|
// Update Python script
|
|
TPythonDump() << "isDone = " << this << ".DoubleNodeElemGroups( " << &theElems << ", "
|
|
<< &theNodesNot << ", " << &theAffectedElems << " )";
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/false );
|
|
return aResult;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements
|
|
* Works as DoubleNodeElemGroups(), but returns a new group with newly created elements.
|
|
\param theElems - list of groups of elements (edges or faces) to be replicated
|
|
\param theNodesNot - list of groups of nodes not to replicated
|
|
\param theAffectedElems - group of elements to which the replicated nodes
|
|
should be associated to.
|
|
* \return a new group with newly created elements
|
|
* \sa DoubleNodeElemGroups()
|
|
*/
|
|
//================================================================================
|
|
|
|
SMESH::SMESH_Group_ptr
|
|
SMESH_MeshEditor_i::DoubleNodeElemGroupsNew(const SMESH::ListOfGroups& theElems,
|
|
const SMESH::ListOfGroups& theNodesNot,
|
|
const SMESH::ListOfGroups& theAffectedElems)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
TPythonDump pyDump;
|
|
SMESH::ListOfGroups_var twoGroups = DoubleNodeElemGroups2New( theElems,
|
|
theNodesNot,
|
|
theAffectedElems,
|
|
true, false );
|
|
SMESH::SMESH_GroupBase_var baseGroup = twoGroups[0].in();
|
|
SMESH::SMESH_Group_var elemGroup = SMESH::SMESH_Group::_narrow( baseGroup );
|
|
|
|
pyDump << elemGroup << " = " << this << ".DoubleNodeElemGroupsNew( "
|
|
<< theElems << ", "
|
|
<< theNodesNot << ", "
|
|
<< theAffectedElems << " )";
|
|
|
|
return elemGroup._retn();
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Creates a hole in a mesh by doubling the nodes of some particular elements
|
|
* Works as DoubleNodeElemGroups(), but returns a new group with newly created elements.
|
|
\param theElems - list of groups of elements (edges or faces) to be replicated
|
|
\param theNodesNot - list of groups of nodes not to replicated
|
|
\param theAffectedElems - group of elements to which the replicated nodes
|
|
should be associated to.
|
|
* \return a new group with newly created elements
|
|
* \sa DoubleNodeElemGroups()
|
|
*/
|
|
//================================================================================
|
|
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::DoubleNodeElemGroups2New(const SMESH::ListOfGroups& theElems,
|
|
const SMESH::ListOfGroups& theNodesNot,
|
|
const SMESH::ListOfGroups& theAffectedElems,
|
|
CORBA::Boolean theElemGroupNeeded,
|
|
CORBA::Boolean theNodeGroupNeeded)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
SMESH::SMESH_Group_var aNewElemGroup, aNewNodeGroup;
|
|
SMESH::ListOfGroups_var aTwoGroups = new SMESH::ListOfGroups();
|
|
aTwoGroups->length( 2 );
|
|
|
|
initData();
|
|
|
|
|
|
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 = getEditor().DoubleNodes( anElems, aNodes, anAffected );
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/ !aResult );
|
|
|
|
TPythonDump pyDump;
|
|
if ( aResult )
|
|
{
|
|
// Create group with newly created elements
|
|
CORBA::String_var elemGroupName = theElems[0]->GetName();
|
|
string aNewName = generateGroupName( string(elemGroupName.in()) + "_double");
|
|
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 ( !getEditor().GetLastCreatedNodes().IsEmpty() && theNodeGroupNeeded )
|
|
{
|
|
SMESH::long_array_var anIds = GetLastCreatedNodes();
|
|
aNewNodeGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
|
|
aNewNodeGroup->Add(anIds);
|
|
}
|
|
}
|
|
|
|
// Update Python script
|
|
|
|
pyDump << "[ ";
|
|
if ( aNewElemGroup->_is_nil() ) pyDump << "nothing, ";
|
|
else pyDump << aNewElemGroup << ", ";
|
|
if ( aNewNodeGroup->_is_nil() ) pyDump << "nothing ] = ";
|
|
else pyDump << aNewNodeGroup << " ] = ";
|
|
|
|
pyDump << this << ".DoubleNodeElemGroups2New( " << &theElems << ", "
|
|
<< &theNodesNot << ", "
|
|
<< &theAffectedElems << ", "
|
|
<< theElemGroupNeeded << ", "
|
|
<< theNodeGroupNeeded << " )";
|
|
|
|
aTwoGroups[0] = aNewElemGroup._retn();
|
|
aTwoGroups[1] = aNewNodeGroup._retn();
|
|
return aTwoGroups._retn();
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
\brief Creates a hole in a mesh by doubling the nodes of some particular elements
|
|
This method provided for convenience works as DoubleNodes() described above.
|
|
\param theElems - list of groups of elements (edges or faces) to be replicated
|
|
\param theNodesNot - list of groups of nodes not to replicated
|
|
\param theShape - shape to detect affected elements (element which geometric center
|
|
located on or inside shape).
|
|
The replicated nodes should be associated to affected elements.
|
|
\return TRUE if operation has been completed successfully, FALSE otherwise
|
|
\sa DoubleNodeGroupInRegion(), DoubleNodesInRegion()
|
|
*/
|
|
//================================================================================
|
|
|
|
CORBA::Boolean
|
|
SMESH_MeshEditor_i::DoubleNodeElemGroupsInRegion(const SMESH::ListOfGroups& theElems,
|
|
const SMESH::ListOfGroups& theNodesNot,
|
|
GEOM::GEOM_Object_ptr theShape )
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
|
|
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 = getEditor().DoubleNodesInRegion( anElems, aNodes, aShape );
|
|
|
|
// Update Python script
|
|
TPythonDump() << "isDone = " << this << ".DoubleNodeElemGroupsInRegion( " << &theElems << ", "
|
|
<< &theNodesNot << ", " << theShape << " )";
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/ !aResult );
|
|
return aResult;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
\brief Identify the elements that will be affected by node duplication (actual
|
|
duplication is not performed.
|
|
This method is the first step of DoubleNodeElemGroupsInRegion.
|
|
\param theElems - list of groups of elements (edges or faces) to be replicated
|
|
\param theNodesNot - list of groups of nodes not to replicated
|
|
\param theShape - shape to detect affected elements (element which geometric center
|
|
located on or inside shape).
|
|
The replicated nodes should be associated to affected elements.
|
|
\return groups of affected elements
|
|
\sa DoubleNodeElemGroupsInRegion()
|
|
*/
|
|
//================================================================================
|
|
SMESH::ListOfGroups*
|
|
SMESH_MeshEditor_i::AffectedElemGroupsInRegion( const SMESH::ListOfGroups& theElems,
|
|
const SMESH::ListOfGroups& theNodesNot,
|
|
GEOM::GEOM_Object_ptr theShape )
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
MESSAGE("AffectedElemGroupsInRegion");
|
|
SMESH::ListOfGroups_var aListOfGroups = new SMESH::ListOfGroups();
|
|
bool isEdgeGroup = false;
|
|
bool isFaceGroup = false;
|
|
bool isVolumeGroup = false;
|
|
SMESH::SMESH_Group_var aNewEdgeGroup = myMesh_i->CreateGroup(SMESH::EDGE, "affectedEdges");
|
|
SMESH::SMESH_Group_var aNewFaceGroup = myMesh_i->CreateGroup(SMESH::FACE, "affectedFaces");
|
|
SMESH::SMESH_Group_var aNewVolumeGroup = myMesh_i->CreateGroup(SMESH::VOLUME, "affectedVolumes");
|
|
|
|
initData();
|
|
|
|
::SMESH_MeshEditor aMeshEditor(myMesh);
|
|
|
|
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);
|
|
TIDSortedElemSet anAffected;
|
|
bool aResult = aMeshEditor.AffectedElemGroupsInRegion(anElems, aNodes, aShape, anAffected);
|
|
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/ !aResult );
|
|
|
|
TPythonDump pyDump;
|
|
if (aResult)
|
|
{
|
|
int lg = anAffected.size();
|
|
MESSAGE("lg="<< lg);
|
|
SMESH::long_array_var volumeIds = new SMESH::long_array;
|
|
volumeIds->length(lg);
|
|
SMESH::long_array_var faceIds = new SMESH::long_array;
|
|
faceIds->length(lg);
|
|
SMESH::long_array_var edgeIds = new SMESH::long_array;
|
|
edgeIds->length(lg);
|
|
int ivol = 0;
|
|
int iface = 0;
|
|
int iedge = 0;
|
|
|
|
TIDSortedElemSet::const_iterator eIt = anAffected.begin();
|
|
for (; eIt != anAffected.end(); ++eIt)
|
|
{
|
|
const SMDS_MeshElement* anElem = *eIt;
|
|
if (!anElem)
|
|
continue;
|
|
int elemId = anElem->GetID();
|
|
if (myMesh->GetElementType(elemId, true) == SMDSAbs_Volume)
|
|
volumeIds[ivol++] = elemId;
|
|
else if (myMesh->GetElementType(elemId, true) == SMDSAbs_Face)
|
|
faceIds[iface++] = elemId;
|
|
else if (myMesh->GetElementType(elemId, true) == SMDSAbs_Edge)
|
|
edgeIds[iedge++] = elemId;
|
|
}
|
|
volumeIds->length(ivol);
|
|
faceIds->length(iface);
|
|
edgeIds->length(iedge);
|
|
|
|
aNewVolumeGroup->Add(volumeIds);
|
|
aNewFaceGroup->Add(faceIds);
|
|
aNewEdgeGroup->Add(edgeIds);
|
|
isVolumeGroup = (aNewVolumeGroup->Size() > 0);
|
|
isFaceGroup = (aNewFaceGroup->Size() > 0);
|
|
isEdgeGroup = (aNewEdgeGroup->Size() > 0);
|
|
}
|
|
|
|
int nbGroups = 0;
|
|
if (isEdgeGroup) nbGroups++;
|
|
if (isFaceGroup) nbGroups++;
|
|
if (isVolumeGroup) nbGroups++;
|
|
aListOfGroups->length(nbGroups);
|
|
|
|
int i = 0;
|
|
if (isEdgeGroup) aListOfGroups[i++] = aNewEdgeGroup._retn();
|
|
if (isFaceGroup) aListOfGroups[i++] = aNewFaceGroup._retn();
|
|
if (isVolumeGroup) aListOfGroups[i++] = aNewVolumeGroup._retn();
|
|
|
|
// Update Python script
|
|
|
|
pyDump << "[ ";
|
|
if (isEdgeGroup) pyDump << aNewEdgeGroup << ", ";
|
|
if (isFaceGroup) pyDump << aNewFaceGroup << ", ";
|
|
if (isVolumeGroup) pyDump << aNewVolumeGroup << ", ";
|
|
pyDump << "] = ";
|
|
pyDump << this << ".AffectedElemGroupsInRegion( "
|
|
<< &theElems << ", " << &theNodesNot << ", " << theShape << " )";
|
|
|
|
return aListOfGroups._retn();
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
\brief Generated skin mesh (containing 2D cells) from 3D mesh
|
|
The created 2D mesh elements based on nodes of free faces of boundary volumes
|
|
\return TRUE if operation has been completed successfully, FALSE otherwise
|
|
*/
|
|
//================================================================================
|
|
|
|
CORBA::Boolean SMESH_MeshEditor_i::Make2DMeshFrom3D()
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
bool aResult = getEditor().Make2DMeshFrom3D();
|
|
|
|
TPythonDump() << "isDone = " << this << ".Make2DMeshFrom3D()";
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/ !aResult );
|
|
return aResult;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return false;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Double nodes on shared faces between groups of volumes and create flat elements on demand.
|
|
* The list of groups must contain at least two groups. The groups have to be disjoint:
|
|
* no common element into two different groups.
|
|
* The nodes of the internal faces at the boundaries of the groups are doubled.
|
|
* Optionally, the internal faces are replaced by flat elements.
|
|
* Triangles are transformed into prisms, and quadrangles into hexahedrons.
|
|
* The flat elements are stored in groups of volumes.
|
|
* These groups are named according to the position of the group in the list:
|
|
* the group j_n_p is the group of the flat elements that are built between the group #n and the group #p in the list.
|
|
* If there is no shared faces between the group #n and the group #p in the list, the group j_n_p is not created.
|
|
* All the flat elements are gathered into the group named "joints3D" (or "joints2D" in 2D situation).
|
|
* The flat element of the multiple junctions between the simple junction are stored in a group named "jointsMultiples".
|
|
* \param theDomains - list of groups of volumes
|
|
* \param createJointElems - if TRUE, create the elements
|
|
* \param onAllBoundaries - if TRUE, the nodes and elements are also created on
|
|
* the boundary between \a theDomains and the rest mesh
|
|
* \return TRUE if operation has been completed successfully, FALSE otherwise
|
|
*/
|
|
//================================================================================
|
|
|
|
CORBA::Boolean
|
|
SMESH_MeshEditor_i::DoubleNodesOnGroupBoundaries( const SMESH::ListOfGroups& theDomains,
|
|
CORBA::Boolean createJointElems,
|
|
CORBA::Boolean onAllBoundaries )
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
bool isOK = false;
|
|
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
SMESHDS_Mesh* aMeshDS = getMeshDS();
|
|
|
|
// MESSAGE("theDomains.length = "<<theDomains.length());
|
|
if ( theDomains.length() <= 1 && !onAllBoundaries )
|
|
THROW_SALOME_CORBA_EXCEPTION("At least 2 groups are required.", SALOME::BAD_PARAM);
|
|
|
|
vector<TIDSortedElemSet> domains;
|
|
domains.resize( theDomains.length() );
|
|
|
|
for ( int i = 0, n = theDomains.length(); i < n; i++ )
|
|
{
|
|
SMESH::SMESH_GroupBase_var aGrp = theDomains[ i ];
|
|
if ( !CORBA::is_nil( aGrp ) /*&& ( aGrp->GetType() != SMESH::NODE )*/ )
|
|
{
|
|
// if ( aGrp->GetType() != SMESH::VOLUME )
|
|
// THROW_SALOME_CORBA_EXCEPTION("Not a volume group", SALOME::BAD_PARAM);
|
|
SMESH::long_array_var anIDs = aGrp->GetIDs();
|
|
arrayToSet( anIDs, aMeshDS, domains[ i ], SMDSAbs_All );
|
|
}
|
|
}
|
|
|
|
isOK = getEditor().DoubleNodesOnGroupBoundaries( domains, createJointElems, onAllBoundaries );
|
|
// TODO publish the groups of flat elements in study
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/ !isOK );
|
|
|
|
// Update Python script
|
|
TPythonDump() << "isDone = " << this << ".DoubleNodesOnGroupBoundaries( " << &theDomains
|
|
<< ", " << createJointElems << ", " << onAllBoundaries << " )";
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
|
|
myMesh_i->CreateGroupServants(); // publish created groups if any
|
|
|
|
return isOK;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Double nodes on some external faces and create flat elements.
|
|
* Flat elements are mainly used by some types of mechanic calculations.
|
|
*
|
|
* Each group of the list must be constituted of faces.
|
|
* Triangles are transformed in prisms, and quadrangles in hexahedrons.
|
|
* @param theGroupsOfFaces - list of groups of faces
|
|
* @return TRUE if operation has been completed successfully, FALSE otherwise
|
|
*/
|
|
//================================================================================
|
|
|
|
CORBA::Boolean
|
|
SMESH_MeshEditor_i::CreateFlatElementsOnFacesGroups( const SMESH::ListOfGroups& theGroupsOfFaces )
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
SMESHDS_Mesh* aMeshDS = getMeshDS();
|
|
|
|
vector<TIDSortedElemSet> faceGroups;
|
|
faceGroups.clear();
|
|
|
|
for ( int i = 0, n = theGroupsOfFaces.length(); i < n; i++ )
|
|
{
|
|
SMESH::SMESH_GroupBase_var aGrp = theGroupsOfFaces[ i ];
|
|
if ( !CORBA::is_nil( aGrp ) && ( aGrp->GetType() != SMESH::NODE ) )
|
|
{
|
|
TIDSortedElemSet faceGroup;
|
|
faceGroup.clear();
|
|
faceGroups.push_back(faceGroup);
|
|
SMESH::long_array_var anIDs = aGrp->GetIDs();
|
|
arrayToSet( anIDs, aMeshDS, faceGroups[ i ], SMDSAbs_All );
|
|
}
|
|
}
|
|
|
|
bool aResult = getEditor().CreateFlatElementsOnFacesGroups( faceGroups );
|
|
// TODO publish the groups of flat elements in study
|
|
|
|
declareMeshModified( /*isReComputeSafe=*/ !aResult );
|
|
|
|
// Update Python script
|
|
TPythonDump() << this << ".CreateFlatElementsOnFacesGroups( " << &theGroupsOfFaces << " )";
|
|
return aResult;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return false;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Identify all the elements around a geom shape, get the faces delimiting
|
|
* the hole.
|
|
*
|
|
* Build groups of volume to remove, groups of faces to replace on the skin of the
|
|
* object, groups of faces to remove inside the object, (idem edges).
|
|
* Build ordered list of nodes at the border of each group of faces to replace
|
|
* (to be used to build a geom subshape).
|
|
*/
|
|
//================================================================================
|
|
|
|
void SMESH_MeshEditor_i::CreateHoleSkin(CORBA::Double radius,
|
|
GEOM::GEOM_Object_ptr theShape,
|
|
const char* groupName,
|
|
const SMESH::double_array& theNodesCoords,
|
|
SMESH::array_of_long_array_out GroupsOfNodes)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
|
|
initData();
|
|
std::vector<std::vector<int> > aListOfListOfNodes;
|
|
::SMESH_MeshEditor aMeshEditor( myMesh );
|
|
|
|
theSearchersDeleter.Set( myMesh ); // remove theNodeSearcher if mesh is other
|
|
if ( !theNodeSearcher )
|
|
theNodeSearcher = SMESH_MeshAlgos::GetNodeSearcher( *getMeshDS() );
|
|
|
|
vector<double> nodesCoords;
|
|
for (int i = 0; i < theNodesCoords.length(); i++)
|
|
{
|
|
nodesCoords.push_back( theNodesCoords[i] );
|
|
}
|
|
|
|
TopoDS_Shape aShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theShape );
|
|
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);
|
|
}
|
|
TPythonDump() << "lists_nodes = " << this << ".CreateHoleSkin( "
|
|
<< radius << ", "
|
|
<< theShape
|
|
<< ", '" << groupName << "', "
|
|
<< theNodesCoords << " )";
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
}
|
|
|
|
// issue 20749 ===================================================================
|
|
/*!
|
|
* \brief Creates missing boundary elements
|
|
* \param elements - elements whose boundary is to be checked
|
|
* \param dimension - defines type of boundary elements to create
|
|
* \param groupName - a name of group to store created boundary elements in,
|
|
* "" means not to create the group
|
|
* \param meshName - a name of new mesh to store created boundary elements in,
|
|
* "" means not to create the new mesh
|
|
* \param toCopyElements - if true, the checked elements will be copied into the new mesh
|
|
* \param toCopyExistingBondary - if true, not only new but also pre-existing
|
|
* boundary elements will be copied into the new mesh
|
|
* \param group - returns the create group, if any
|
|
* \retval SMESH::SMESH_Mesh - the mesh where elements were added to
|
|
*/
|
|
// ================================================================================
|
|
|
|
SMESH::SMESH_Mesh_ptr
|
|
SMESH_MeshEditor_i::MakeBoundaryMesh(SMESH::SMESH_IDSource_ptr idSource,
|
|
SMESH::Bnd_Dimension dim,
|
|
const char* groupName,
|
|
const char* meshName,
|
|
CORBA::Boolean toCopyElements,
|
|
CORBA::Boolean toCopyExistingBondary,
|
|
SMESH::SMESH_Group_out group)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
if ( dim > SMESH::BND_1DFROM2D )
|
|
THROW_SALOME_CORBA_EXCEPTION("Invalid boundary dimension", SALOME::BAD_PARAM);
|
|
|
|
SMESHDS_Mesh* aMeshDS = getMeshDS();
|
|
|
|
SMESH::SMESH_Mesh_var mesh_var;
|
|
SMESH::SMESH_Group_var group_var;
|
|
|
|
TPythonDump pyDump;
|
|
|
|
TIDSortedElemSet elements;
|
|
SMDSAbs_ElementType elemType = (dim == SMESH::BND_1DFROM2D) ? SMDSAbs_Face : SMDSAbs_Volume;
|
|
prepareIdSource( idSource );
|
|
if ( idSourceToSet( idSource, aMeshDS, elements, elemType,/*emptyIfIsMesh=*/true ))
|
|
{
|
|
// mesh to fill in
|
|
mesh_var =
|
|
strlen(meshName) ? makeMesh(meshName) : SMESH::SMESH_Mesh::_duplicate(myMesh_i->_this());
|
|
SMESH_Mesh_i* mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh_var );
|
|
// other mesh
|
|
SMESH_Mesh* smesh_mesh = (mesh_i==myMesh_i) ? (SMESH_Mesh*)0 : &mesh_i->GetImpl();
|
|
|
|
// group of new boundary elements
|
|
SMESH_Group* smesh_group = 0;
|
|
if ( strlen(groupName) )
|
|
{
|
|
group_var = mesh_i->CreateGroup( SMESH::ElementType(int(elemType)-1),groupName);
|
|
if ( SMESH_GroupBase_i* group_i = SMESH::DownCast<SMESH_GroupBase_i*>( group_var ))
|
|
smesh_group = group_i->GetSmeshGroup();
|
|
}
|
|
|
|
// do it
|
|
getEditor().MakeBoundaryMesh( elements,
|
|
::SMESH_MeshEditor::Bnd_Dimension(dim),
|
|
smesh_group,
|
|
smesh_mesh,
|
|
toCopyElements,
|
|
toCopyExistingBondary);
|
|
|
|
if ( smesh_mesh )
|
|
smesh_mesh->GetMeshDS()->Modified();
|
|
}
|
|
|
|
const char* dimName[] = { "BND_2DFROM3D", "BND_1DFROM3D", "BND_1DFROM2D" };
|
|
|
|
// result of MakeBoundaryMesh() is a tuple (mesh, group)
|
|
if ( mesh_var->_is_nil() )
|
|
pyDump << myMesh_i->_this() << ", ";
|
|
else
|
|
pyDump << mesh_var << ", ";
|
|
if ( group_var->_is_nil() )
|
|
pyDump << "_NoneGroup = "; // assignment to None is forbiden
|
|
else
|
|
pyDump << group_var << " = ";
|
|
pyDump << this << ".MakeBoundaryMesh( "
|
|
<< idSource << ", "
|
|
<< "SMESH." << dimName[int(dim)] << ", "
|
|
<< "'" << groupName << "', "
|
|
<< "'" << meshName<< "', "
|
|
<< toCopyElements << ", "
|
|
<< toCopyExistingBondary << ")";
|
|
|
|
group = group_var._retn();
|
|
return mesh_var._retn();
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return SMESH::SMESH_Mesh::_nil();
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Creates missing boundary elements
|
|
* \param dimension - defines type of boundary elements to create
|
|
* \param groupName - a name of group to store all boundary elements in,
|
|
* "" means not to create the group
|
|
* \param meshName - a name of a new mesh, which is a copy of the initial
|
|
* mesh + created boundary elements; "" means not to create the new mesh
|
|
* \param toCopyAll - if true, the whole initial mesh will be copied into
|
|
* the new mesh else only boundary elements will be copied into the new mesh
|
|
* \param groups - optional groups of elements to make boundary around
|
|
* \param mesh - returns the mesh where elements were added to
|
|
* \param group - returns the created group, if any
|
|
* \retval long - number of added boundary elements
|
|
*/
|
|
//================================================================================
|
|
|
|
CORBA::Long SMESH_MeshEditor_i::MakeBoundaryElements(SMESH::Bnd_Dimension dim,
|
|
const char* groupName,
|
|
const char* meshName,
|
|
CORBA::Boolean toCopyAll,
|
|
const SMESH::ListOfIDSources& groups,
|
|
SMESH::SMESH_Mesh_out mesh,
|
|
SMESH::SMESH_Group_out group)
|
|
throw (SALOME::SALOME_Exception)
|
|
{
|
|
SMESH_TRY;
|
|
initData();
|
|
|
|
if ( dim > SMESH::BND_1DFROM2D )
|
|
THROW_SALOME_CORBA_EXCEPTION("Invalid boundary dimension", SALOME::BAD_PARAM);
|
|
|
|
// separate groups belonging to this and other mesh
|
|
SMESH::ListOfIDSources_var groupsOfThisMesh = new SMESH::ListOfIDSources;
|
|
SMESH::ListOfIDSources_var groupsOfOtherMesh = new SMESH::ListOfIDSources;
|
|
groupsOfThisMesh->length( groups.length() );
|
|
groupsOfOtherMesh->length( groups.length() );
|
|
int nbGroups = 0, nbGroupsOfOtherMesh = 0;
|
|
for ( int i = 0; i < groups.length(); ++i )
|
|
{
|
|
SMESH::SMESH_Mesh_var m = groups[i]->GetMesh();
|
|
if ( myMesh_i != SMESH::DownCast<SMESH_Mesh_i*>( m ))
|
|
groupsOfOtherMesh[ nbGroupsOfOtherMesh++ ] = groups[i];
|
|
else
|
|
groupsOfThisMesh[ nbGroups++ ] = groups[i];
|
|
if ( SMESH::DownCast<SMESH_Mesh_i*>( groups[i] ))
|
|
THROW_SALOME_CORBA_EXCEPTION("expect a group but recieve a mesh", SALOME::BAD_PARAM);
|
|
}
|
|
groupsOfThisMesh->length( nbGroups );
|
|
groupsOfOtherMesh->length( nbGroupsOfOtherMesh );
|
|
|
|
int nbAdded = 0;
|
|
TPythonDump pyDump;
|
|
|
|
if ( nbGroupsOfOtherMesh > 0 )
|
|
{
|
|
// process groups belonging to another mesh
|
|
SMESH::SMESH_Mesh_var otherMesh = groupsOfOtherMesh[0]->GetMesh();
|
|
SMESH::SMESH_MeshEditor_var editor = otherMesh->GetMeshEditor();
|
|
nbAdded += editor->MakeBoundaryElements( dim, groupName, meshName, toCopyAll,
|
|
groupsOfOtherMesh, mesh, group );
|
|
}
|
|
|
|
SMESH::SMESH_Mesh_var mesh_var;
|
|
SMESH::SMESH_Group_var group_var;
|
|
|
|
// get mesh to fill
|
|
mesh_var = SMESH::SMESH_Mesh::_duplicate( myMesh_i->_this() );
|
|
const bool toCopyMesh = ( strlen( meshName ) > 0 );
|
|
if ( toCopyMesh )
|
|
{
|
|
if ( toCopyAll )
|
|
mesh_var = SMESH_Gen_i::GetSMESHGen()->CopyMesh(mesh_var,
|
|
meshName,
|
|
/*toCopyGroups=*/false,
|
|
/*toKeepIDs=*/true);
|
|
else
|
|
mesh_var = makeMesh(meshName);
|
|
}
|
|
SMESH_Mesh_i* mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh_var );
|
|
SMESH_Mesh* tgtMesh = &mesh_i->GetImpl();
|
|
|
|
// source mesh
|
|
SMESH_Mesh* srcMesh = ( toCopyMesh && !toCopyAll ) ? myMesh : tgtMesh;
|
|
SMESHDS_Mesh* srcMeshDS = srcMesh->GetMeshDS();
|
|
|
|
// group of boundary elements
|
|
SMESH_Group* smesh_group = 0;
|
|
SMDSAbs_ElementType elemType = (dim == SMESH::BND_2DFROM3D) ? SMDSAbs_Volume : SMDSAbs_Face;
|
|
if ( strlen(groupName) )
|
|
{
|
|
SMESH::ElementType groupType = SMESH::ElementType( int(elemType)-1 );
|
|
group_var = mesh_i->CreateGroup( groupType, groupName );
|
|
if ( SMESH_GroupBase_i* group_i = SMESH::DownCast<SMESH_GroupBase_i*>( group_var ))
|
|
smesh_group = group_i->GetSmeshGroup();
|
|
}
|
|
|
|
TIDSortedElemSet elements;
|
|
|
|
if ( groups.length() > 0 )
|
|
{
|
|
for ( int i = 0; i < nbGroups; ++i )
|
|
{
|
|
elements.clear();
|
|
if ( idSourceToSet( groupsOfThisMesh[i], srcMeshDS, elements, elemType,/*emptyIfIsMesh=*/0 ))
|
|
{
|
|
SMESH::Bnd_Dimension bdim =
|
|
( elemType == SMDSAbs_Volume ) ? SMESH::BND_2DFROM3D : SMESH::BND_1DFROM2D;
|
|
nbAdded += getEditor().MakeBoundaryMesh( elements,
|
|
::SMESH_MeshEditor::Bnd_Dimension(bdim),
|
|
smesh_group,
|
|
tgtMesh,
|
|
/*toCopyElements=*/false,
|
|
/*toCopyExistingBondary=*/srcMesh != tgtMesh,
|
|
/*toAddExistingBondary=*/true,
|
|
/*aroundElements=*/true);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nbAdded += getEditor().MakeBoundaryMesh( elements,
|
|
::SMESH_MeshEditor::Bnd_Dimension(dim),
|
|
smesh_group,
|
|
tgtMesh,
|
|
/*toCopyElements=*/false,
|
|
/*toCopyExistingBondary=*/srcMesh != tgtMesh,
|
|
/*toAddExistingBondary=*/true);
|
|
}
|
|
tgtMesh->GetMeshDS()->Modified();
|
|
|
|
const char* dimName[] = { "BND_2DFROM3D", "BND_1DFROM3D", "BND_1DFROM2D" };
|
|
|
|
// result of MakeBoundaryElements() is a tuple (nb, mesh, group)
|
|
pyDump << "nbAdded, ";
|
|
if ( mesh_var->_is_nil() )
|
|
pyDump << myMesh_i->_this() << ", ";
|
|
else
|
|
pyDump << mesh_var << ", ";
|
|
if ( group_var->_is_nil() )
|
|
pyDump << "_NoneGroup = "; // assignment to None is forbiden
|
|
else
|
|
pyDump << group_var << " = ";
|
|
pyDump << this << ".MakeBoundaryElements( "
|
|
<< "SMESH." << dimName[int(dim)] << ", "
|
|
<< "'" << groupName << "', "
|
|
<< "'" << meshName<< "', "
|
|
<< toCopyAll << ", "
|
|
<< groups << ")";
|
|
|
|
mesh = mesh_var._retn();
|
|
group = group_var._retn();
|
|
return nbAdded;
|
|
|
|
SMESH_CATCH( SMESH::throwCorbaException );
|
|
return 0;
|
|
}
|