-// Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2016 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
//=============================================================================
/*!
- * \brief Deleter of theNodeSearcher at any compute event occured
+ * \brief Deleter of theNodeSearcher at any compute event occurred
*/
//=============================================================================
//================================================================================
/*!
* \brief Increment mesh modif time and optionally record that the performed
- * modification may influence futher mesh re-compute.
+ * modification may influence further mesh re-compute.
* \param [in] isReComputeSafe - true if the modification does not influence
- * futher mesh re-compute
+ * further mesh re-compute
*/
//================================================================================
* \brief Initialize and return myPreviewMesh
* \param previewElements - type of elements to show in preview
*
- * WARNING: call it once par a method!
+ * WARNING: call it once per method!
*/
//================================================================================
//=======================================================================
/*
- * Returns description of an error/warning occured during the last operation
+ * Returns description of an error/warning occurred during the last operation
* WARNING: ComputeError.code >= 100 and no corresponding enum in IDL API
*/
//=======================================================================
*/
//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::Add0DElement(CORBA::Long IDOfNode)
+CORBA::Long SMESH_MeshEditor_i::Add0DElement(CORBA::Long IDOfNode,
+ CORBA::Boolean DuplicateElements)
throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
const SMDS_MeshNode* aNode = getMeshDS()->FindNode(IDOfNode);
- SMDS_MeshElement* elem = getMeshDS()->Add0DElement(aNode);
+ SMDS_ElemIteratorPtr it0D = aNode->GetInverseElementIterator( SMDSAbs_0DElement );
+
+ SMDS_MeshElement* elem = 0;
+ if ( DuplicateElements || !it0D->more() )
+ elem = getMeshDS()->Add0DElement(aNode);
// Update Python script
TPythonDump() << "elem0d = " << this << ".Add0DElement( " << IDOfNode <<" )";
//=============================================================================
//
-// \brief Create 0D elements on all nodes of the given object except those
-// nodes on which a 0D element already exists.
+// \brief Create 0D elements on all nodes of the given object.
// \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.
+// \param DuplicateElements to add one more 0D element to a node or not.
// \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)
+ const char* theGroupName,
+ CORBA::Boolean theDuplicateElements)
throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
TIDSortedElemSet elements, elems0D;
if ( idSourceToSet( theObject, getMeshDS(), elements, SMDSAbs_All, /*emptyIfIsMesh=*/1))
- getEditor().Create0DElementsOnAllNodes( elements, elems0D );
+ getEditor().Create0DElementsOnAllNodes( elements, elems0D, theDuplicateElements );
SMESH::long_array_var newElems = new SMESH::long_array;
newElems->length( elems0D.size() );
bool myIsExtrusionByNormal;
static int makeFlags( CORBA::Boolean MakeGroups,
+ CORBA::Boolean LinearVariation = false,
CORBA::Boolean ByAverageNormal = false,
CORBA::Boolean UseInputElemsOnly = false,
CORBA::Long Flags = 0,
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 ( LinearVariation ) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_SCALE_LINEAR_VARIATION;
if ( MakeBoundary ) Flags |= ::SMESH_MeshEditor::EXTRUSION_FLAG_BOUNDARY;
return Flags;
}
// standard params
- ExtrusionParams(const SMESH::DirStruct & theDir,
- CORBA::Long theNbOfSteps,
- CORBA::Boolean theMakeGroups):
+ ExtrusionParams(const SMESH::DirStruct & theDir,
+ CORBA::Long theNbOfSteps,
+ const SMESH::double_array & theScaleFactors,
+ CORBA::Boolean theLinearVariation,
+ const SMESH::double_array & theBasePoint,
+ CORBA::Boolean theMakeGroups):
::SMESH_MeshEditor::ExtrusParam ( gp_Vec( theDir.PS.x,
theDir.PS.y,
theDir.PS.z ),
theNbOfSteps,
- makeFlags( theMakeGroups )),
+ toList( theScaleFactors ),
+ TBasePoint( theBasePoint ),
+ makeFlags( theMakeGroups, theLinearVariation )),
myIsExtrusionByNormal( false )
{
}
theDir.PS.y,
theDir.PS.z ),
theNbOfSteps,
- makeFlags( theMakeGroups, false, false,
+ std::list<double>(),
+ 0,
+ makeFlags( theMakeGroups, false, false, false,
theExtrFlags, false ),
theSewTolerance ),
myIsExtrusionByNormal( false )
CORBA::Boolean theMakeGroups ):
::SMESH_MeshEditor::ExtrusParam ( theStepSize,
theNbOfSteps,
- makeFlags( theMakeGroups,
+ makeFlags( theMakeGroups, false,
theByAverageNormal, theUseInputElemsOnly ),
theDim),
myIsExtrusionByNormal( true )
{
Flags() &= ~(::SMESH_MeshEditor::EXTRUSION_FLAG_GROUPS);
}
+
+ private:
+
+ static std::list<double> toList( const SMESH::double_array & theScaleFactors )
+ {
+ std::list<double> scales;
+ for ( CORBA::ULong i = 0; i < theScaleFactors.length(); ++i )
+ scales.push_back( theScaleFactors[i] );
+ return scales;
+ }
+
+ // structure used to convert SMESH::double_array to gp_XYZ*
+ struct TBasePoint
+ {
+ gp_XYZ *pp, p;
+ TBasePoint( const SMESH::double_array & theBasePoint )
+ {
+ pp = 0;
+ if ( theBasePoint.length() == 3 )
+ {
+ p.SetCoord( theBasePoint[0], theBasePoint[1], theBasePoint[2] );
+ pp = &p;
+ }
+ }
+ operator const gp_XYZ*() const { return pp; }
+ };
};
}
const SMESH::ListOfIDSources & theFaces,
const SMESH::DirStruct & theStepVector,
CORBA::Long theNbOfSteps,
+ const SMESH::double_array & theScaleFactors,
+ CORBA::Boolean theLinearVariation,
+ const SMESH::double_array & theBasePoint,
CORBA::Boolean theToMakeGroups)
throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
initData();
- ExtrusionParams params( theStepVector, theNbOfSteps, theToMakeGroups );
+ ExtrusionParams params( theStepVector, theNbOfSteps, theScaleFactors,
+ theLinearVariation, theBasePoint, theToMakeGroups );
TIDSortedElemSet elemsNodes[2];
for ( int i = 0, nb = theNodes.length(); i < nb; ++i ) {
}
if ( !myIsPreviewMode ) {
- aPythonDump << "(" << aGroups << ", error) = "
- << this << ".ExtrusionAlongPathObjects( "
+ if ( aGroups->length() > 0 ) aPythonDump << "(" << aGroups << ", error) = ";
+ else aPythonDump << "(_noGroups, error) = ";
+ aPythonDump << this << ".ExtrusionAlongPathObjects( "
<< theNodes << ", "
<< theEdges << ", "
<< theFaces << ", "
<< thePathShape << ", "
<< theNodeStart << ", "
<< theHasAngles << ", "
- << theAngles << ", "
+ << TVar( theAngles ) << ", "
<< theLinearVariation << ", "
<< theHasRefPoint << ", "
<< "SMESH.PointStruct( "
- << ( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
- << ( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
- << ( theHasRefPoint ? theRefPoint.z : 0 ) << " ), "
+ << TVar( theHasRefPoint ? theRefPoint.x : 0 ) << ", "
+ << TVar( theHasRefPoint ? theRefPoint.y : 0 ) << ", "
+ << TVar( theHasRefPoint ? theRefPoint.z : 0 ) << " ), "
<< theMakeGroups << " )";
}
else
::SMESH_MeshEditor::PGroupIDs groupIds =
getEditor().Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
- if ( theCopy && !myIsPreviewMode)
+ if ( !myIsPreviewMode )
{
if ( theTargetMesh )
- {
theTargetMesh->GetMeshDS()->Modified();
- }
else
- {
declareMeshModified( /*isReComputeSafe=*/false );
- }
}
+
return theMakeGroups ? getGroups(groupIds.get()) : 0;
SMESH_CATCH( SMESH::throwCorbaException );
::SMESH_MeshEditor::PGroupIDs groupIds =
getEditor().Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
- if ( theCopy && !myIsPreviewMode )
+ if ( !myIsPreviewMode )
{
if ( theTargetMesh )
- {
theTargetMesh->GetMeshDS()->Modified();
- }
else
- {
declareMeshModified( /*isReComputeSafe=*/false );
- }
}
return theMakeGroups ? getGroups(groupIds.get()) : 0;
::SMESH_MeshEditor::PGroupIDs groupIds =
getEditor().Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
- if ( theCopy && !myIsPreviewMode)
+ if ( !myIsPreviewMode)
{
if ( theTargetMesh ) theTargetMesh->GetMeshDS()->Modified();
else declareMeshModified( /*isReComputeSafe=*/false );
::SMESH_MeshEditor::PGroupIDs groupIds =
getEditor().Transform (*workElements, aTrsf, theCopy, theMakeGroups, theTargetMesh);
- if ( theCopy && !myIsPreviewMode )
+ if ( !myIsPreviewMode )
{
if ( theTargetMesh ) theTargetMesh->GetMeshDS()->Modified();
else declareMeshModified( /*isReComputeSafe=*/false );
//=======================================================================
void SMESH_MeshEditor_i::MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes,
- const SMESH::ListOfIDSources& NodesToKeep)
+ const SMESH::ListOfIDSources& NodesToKeep,
+ CORBA::Boolean AvoidMakingHoles)
throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
aTPythonDump << aNodeGroup;
}
- getEditor().MergeNodes( aListOfListOfNodes );
+ getEditor().MergeNodes( aListOfListOfNodes, AvoidMakingHoles );
- aTPythonDump << "], " << NodesToKeep << ")";
+ aTPythonDump << "], " << NodesToKeep << ", " << AvoidMakingHoles << ")";
declareMeshModified( /*isReComputeSafe=*/false );
{
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 ( type != SMESH::NODE )
+ {
+ 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 );
SMESHDS_Mesh* meshDS = SMESH::DownCast<SMESH_Mesh_i*>( mesh )->GetImpl().GetMeshDS();
if ( !idSourceToSet( elementIDs, meshDS, elements,
- SMDSAbs_ElementType(type), /*emptyIfIsMesh=*/true))
+ ( type == SMESH::NODE ? SMDSAbs_All : (SMDSAbs_ElementType) type ),
+ /*emptyIfIsMesh=*/true))
return res._retn();
typedef SMDS_SetIterator<const SMDS_MeshElement*, TIDSortedElemSet::const_iterator > TIter;
TPythonDump() << "isDone = " << this << ".ChangeElemNodes( "
<< ide << ", " << newIDs << " )";
- MESSAGE("ChangeElementNodes");
bool res = getMeshDS()->ChangeElementNodes( elem, & aNodes[0], nbn1+1 );
declareMeshModified( /*isReComputeSafe=*/ !res );
*/
//================================================================================
-string SMESH_MeshEditor_i::generateGroupName(const string& thePrefix)
+std::string SMESH_MeshEditor_i::generateGroupName(const std::string& thePrefix)
{
SMESH::ListOfGroups_var groups = myMesh_i->GetGroups();
- set<string> groupNames;
+ set<std::string> groupNames;
// Get existing group names
for (int i = 0, nbGroups = groups->length(); i < nbGroups; i++ ) {
}
// Find new name
- string name = thePrefix;
+ std::string name = thePrefix;
int index = 0;
while (!groupNames.insert(name).second)
// 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");
+ std::string anUnindexedName (theNodes->GetName());
+ std::string aNewName = generateGroupName(anUnindexedName + "_double");
aNewGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
aNewGroup->Add(anIds);
pyDump << aNewGroup << " = ";
// 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");
+ std::string anUnindexedName (theNodes[0]->GetName());
+ std::string aNewName = generateGroupName(anUnindexedName + "_double");
aNewGroup = myMesh_i->CreateGroup(SMESH::NODE, aNewName.c_str());
aNewGroup->Add(anIds);
pyDump << aNewGroup << " = ";
{
// Create group with newly created elements
CORBA::String_var elemGroupName = theElems->GetName();
- string aNewName = generateGroupName( string(elemGroupName.in()) + "_double");
+ std::string aNewName = generateGroupName( std::string(elemGroupName.in()) + "_double");
if ( !getEditor().GetLastCreatedElems().IsEmpty() && theElemGroupNeeded )
{
SMESH::long_array_var anIds = GetLastCreatedElems();
{
// Create group with newly created elements
CORBA::String_var elemGroupName = theElems[0]->GetName();
- string aNewName = generateGroupName( string(elemGroupName.in()) + "_double");
+ std::string aNewName = generateGroupName( std::string(elemGroupName.in()) + "_double");
if ( !getEditor().GetLastCreatedElems().IsEmpty() && theElemGroupNeeded )
{
SMESH::long_array_var anIds = GetLastCreatedElems();
throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
- MESSAGE("AffectedElemGroupsInRegion");
SMESH::ListOfGroups_var aListOfGroups = new SMESH::ListOfGroups();
bool isEdgeGroup = false;
bool isFaceGroup = false;
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;
else
pyDump << mesh_var << ", ";
if ( group_var->_is_nil() )
- pyDump << "_NoneGroup = "; // assignment to None is forbiden
+ pyDump << "_NoneGroup = "; // assignment to None is forbidden
else
pyDump << group_var << " = ";
pyDump << this << ".MakeBoundaryMesh( "
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);
+ THROW_SALOME_CORBA_EXCEPTION("expected a group but received a mesh", SALOME::BAD_PARAM);
}
groupsOfThisMesh->length( nbGroups );
groupsOfOtherMesh->length( nbGroupsOfOtherMesh );
else
pyDump << mesh_var << ", ";
if ( group_var->_is_nil() )
- pyDump << "_NoneGroup = "; // assignment to None is forbiden
+ pyDump << "_NoneGroup = "; // assignment to None is forbidden
else
pyDump << group_var << " = ";
pyDump << this << ".MakeBoundaryElements( "
