-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2021 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
if ( theName != 0 )
{
SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
- SALOMEDS::Study::ListOfSObject_var aList = SMESH_Gen_i::getStudyServant()->FindObjectByName( theName, "GEOM" );
+ SALOMEDS::Study::ListOfSObject_var aList = SMESH_Gen_i::GetSMESHGen()->getStudyServant()->FindObjectByName( theName, "GEOM" );
+ if ( aList->length() == 0 )
+ aList = SMESH_Gen_i::GetSMESHGen()->getStudyServant()->FindObjectByName( theName, "SHAPERSTUDY" );
if ( aList->length() > 0 )
{
CORBA::Object_var anObj = aList[ 0 ]->GetObject();
{
if ( theID && strlen( theID ) > 0 ) {
SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
- SALOMEDS::SObject_wrap aSObj = SMESH_Gen_i::getStudyServant()->FindObjectID(theID);
+ SALOMEDS::SObject_wrap aSObj = SMESH_Gen_i::GetSMESHGen()->getStudyServant()->FindObjectID(theID);
if ( !aSObj->_is_nil() ) {
CORBA::Object_var obj = aSObj->GetObject();
GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow(obj);
Class : NumericalFunctor_i
Description : Base class for numerical functors
*/
-CORBA::Double NumericalFunctor_i::GetValue( CORBA::Long theId )
+CORBA::Double NumericalFunctor_i::GetValue( SMESH::smIdType theId )
{
return myNumericalFunctorPtr->GetValue( theId );
}
+CORBA::Boolean NumericalFunctor_i::IsApplicable( SMESH::smIdType theElementId )
+{
+ return myNumericalFunctorPtr->IsApplicable( theElementId );
+}
+
SMESH::Histogram* NumericalFunctor_i::GetHistogram(CORBA::Short nbIntervals, CORBA::Boolean isLogarithmic)
{
std::vector<int> nbEvents;
std::vector<double> funValues;
- std::vector<int> elements;
+ std::vector<SMESH::smIdType> elements;
myNumericalFunctorPtr->GetHistogram(nbIntervals,nbEvents,funValues,elements,0,isLogarithmic);
SMESH::Histogram_var histogram = new SMESH::Histogram;
{
SMESH::Histogram_var histogram = new SMESH::Histogram;
- std::vector<int> nbEvents;
- std::vector<double> funValues;
- std::vector<int> elements;
+ std::vector<int> nbEvents;
+ std::vector<double> funValues;
+ std::vector<SMESH::smIdType> elements;
SMDS_ElemIteratorPtr elemIt;
if ( SMESH::DownCast< SMESH_GroupOnFilter_i* >( object ) ||
}
else
{
- SMESH::SMESH_Mesh_var mesh = object->GetMesh();
- SMESH::long_array_var objNbElems = object->GetNbElementsByType();
- SMESH::long_array_var meshNbElems = mesh-> GetNbElementsByType();
+ SMESH::SMESH_Mesh_var mesh = object->GetMesh();
+ SMESH::smIdType_array_var objNbElems = object->GetNbElementsByType();
+ SMESH::smIdType_array_var meshNbElems = mesh-> GetNbElementsByType();
if ( meshNbElems[ GetElementType() ] !=
objNbElems [ GetElementType() ] )
{
return aResult._retn();
}
+
+/*
+ Class : Length3D_i
+ Description : Functor for calculating length of edge
+*/
+Length3D_i::Length3D_i()
+{
+ myNumericalFunctorPtr.reset( new Controls::Length3D() );
+ myFunctorPtr = myNumericalFunctorPtr;
+}
+
+FunctorType Length3D_i::GetFunctorType()
+{
+ return SMESH::FT_Length3D;
+}
+
+// SMESH::Length3D::Values* Length3D_i::GetValues()
+// {
+// SMESH::Controls::Length3D::TValues aValues;
+// (dynamic_cast<SMESH::Controls::Length3D*>(myFunctorPtr.get()))->GetValues( aValues );
+
+// long i = 0, iEnd = aValues.size();
+
+// SMESH::Length3D::Values_var aResult = new SMESH::Length3D::Values(iEnd);
+// aResult->length(iEnd);
+
+// SMESH::Controls::Length3D::TValues::const_iterator anIter;
+// for ( anIter = aValues.begin() ; anIter != aValues.end(); anIter++, i++ )
+// {
+// const SMESH::Controls::Length3D::Value& aVal = *anIter;
+// SMESH::Length3D::Value &aValue = aResult[ i ];
+
+// aValue.myLength = aVal.myLength;
+// aValue.myPnt1 = aVal.myPntId[ 0 ];
+// aValue.myPnt2 = aVal.myPntId[ 1 ];
+// }
+
+// return aResult._retn();
+// }
+
/*
Class : Deflection2D_i
Description : Functor for calculating distance between a face and geometry
{
Controls::PredicatePtr control( new Controls::BadOrientedVolume() );
myFunctorPtr = myPredicatePtr = control;
-};
+}
FunctorType BadOrientedVolume_i::GetFunctorType()
{
{
Controls::PredicatePtr control( new Controls::BareBorderVolume() );
myFunctorPtr = myPredicatePtr = control;
-};
+}
FunctorType BareBorderVolume_i::GetFunctorType()
{
{
Controls::PredicatePtr control( new Controls::BareBorderFace() );
myFunctorPtr = myPredicatePtr = control;
-};
+}
FunctorType BareBorderFace_i::GetFunctorType()
{
{
Controls::PredicatePtr control( new Controls::OverConstrainedVolume() );
myFunctorPtr = myPredicatePtr = control;
-};
+}
FunctorType OverConstrainedVolume_i::GetFunctorType()
{
{
Controls::PredicatePtr control( new Controls::OverConstrainedFace() );
myFunctorPtr = myPredicatePtr = control;
-};
+}
FunctorType OverConstrainedFace_i::GetFunctorType()
{
}
else if ( strncmp( "0:", myID.c_str(), 2 ) == 0 ) // transient mode + GUI
{
- SALOMEDS::SObject_wrap aSObj = SMESH_Gen_i::getStudyServant()->FindObjectID( myID.c_str() );
+ SALOMEDS::SObject_wrap aSObj = SMESH_Gen_i::GetSMESHGen()->getStudyServant()->FindObjectID( myID.c_str() );
if ( !aSObj->_is_nil() ) {
CORBA::Object_var obj = aSObj->GetObject();
SetGroup( SMESH::SMESH_GroupBase::_narrow( obj ));
std::string BelongToMeshGroup_i::GetGroupID()
{
if ( myGroup->_is_nil() )
- SMESH::SMESH_GroupBase_var( GetGroup() );
+ SMESH::SMESH_GroupBase_var( GetGroup() ); // decref the returned pointer
if ( !myGroup->_is_nil() )
myID = SMESH_Gen_i::GetORB()->object_to_string( myGroup );
{
if ( theGeom->_is_nil() )
return;
- SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
- GEOM::GEOM_Gen_ptr aGEOMGen = SMESH_Gen_i::GetGeomEngine();
- TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom );
+ TopoDS_Shape aLocShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theGeom );
myBelongToGeomPtr->SetGeom( aLocShape );
TPythonDump()<<this<<".SetGeom("<<theGeom<<")";
}
{
if ( theGeom->_is_nil() )
return;
- SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
- GEOM::GEOM_Gen_ptr aGEOMGen = SMESH_Gen_i::GetGeomEngine();
- TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom );
+ TopoDS_Shape aLocShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theGeom );
if ( aLocShape.ShapeType() == TopAbs_FACE )
{
{
if ( theGeom->_is_nil() )
return;
- SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
- GEOM::GEOM_Gen_ptr aGEOMGen = SMESH_Gen_i::GetGeomEngine();
- TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom );
+ TopoDS_Shape aLocShape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( theGeom );
myLyingOnGeomPtr->SetGeom( aLocShape );
TPythonDump()<<this<<".SetGeom("<<theGeom<<")";
}
myFunctorPtr = myPredicatePtr = myRangeOfIdsPtr;
}
-void RangeOfIds_i::SetRange( const SMESH::long_array& theIds )
+void RangeOfIds_i::SetRange( const SMESH::smIdType_array& theIds )
{
- CORBA::Long iEnd = theIds.length();
- for ( CORBA::Long i = 0; i < iEnd; i++ )
+ SMESH::smIdType iEnd = theIds.length();
+ for ( SMESH::smIdType i = 0; i < iEnd; i++ )
myRangeOfIdsPtr->AddToRange( theIds[ i ] );
TPythonDump()<<this<<".SetRange("<<theIds<<")";
}
}
void ConnectedElements_i::SetVertex( GEOM::GEOM_Object_ptr vertex )
- throw (SALOME::SALOME_Exception)
{
TopoDS_Shape shape = SMESH_Gen_i::GetSMESHGen()->GeomObjectToShape( vertex );
if ( shape.IsNull() )
TPythonDump() << this << ".SetVertex( " << vertex << " )";
}
-void ConnectedElements_i::SetNode ( CORBA::Long nodeID )
- throw (SALOME::SALOME_Exception)
+void ConnectedElements_i::SetNode ( SMESH::smIdType nodeID )
{
if ( nodeID < 1 )
THROW_SALOME_CORBA_EXCEPTION( "ConnectedElements_i::SetNode(): nodeID must be > 0",
*/
void ConnectedElements_i::SetThreshold ( const char* threshold,
SMESH::ConnectedElements::ThresholdType type )
- throw (SALOME::SALOME_Exception)
{
if ( !threshold )
THROW_SALOME_CORBA_EXCEPTION( "ConnectedElements_i::SetThreshold(): NULL threshold",
}
case SMESH::ConnectedElements::VERTEX: // get a VERTEX by its entry /////////////////
{
- SALOMEDS::SObject_wrap sobj = SMESH_Gen_i::getStudyServant()->FindObjectID( threshold );
+ SALOMEDS::SObject_wrap sobj = SMESH_Gen_i::GetSMESHGen()->getStudyServant()->FindObjectID( threshold );
if ( sobj->_is_nil() )
THROW_SALOME_CORBA_EXCEPTION
( "ConnectedElements_i::SetThreshold(): invalid vertex study entry", SALOME::BAD_PARAM );
return anObj._retn();
}
+Length3D_ptr FilterManager_i::CreateLength3D()
+{
+ SMESH::Length3D_i* aServant = new SMESH::Length3D_i();
+ SMESH::Length3D_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateLength3D()";
+ return anObj._retn();
+}
+
Deflection2D_ptr FilterManager_i::CreateDeflection2D()
{
SMESH::Deflection2D_i* aServant = new SMESH::Deflection2D_i();
SMESH::Deflection2D_var anObj = aServant->_this();
- TPythonDump()<<aServant<<" = "<<this<<".CreateLength2D()";
+ TPythonDump()<<aServant<<" = "<<this<<".CreateDeflection2D()";
return anObj._retn();
}
myPredicate->GetPredicate()->SetMesh( aMesh );
}
-SMESH::long_array*
+SMESH::smIdType_array*
Filter_i::
GetIDs()
{
Controls::Filter::GetElementsId(aMesh,thePredicate->GetPredicate(),theSequence);
}
-SMESH::long_array*
+SMESH::smIdType_array*
Filter_i::
GetElementsId( SMESH_Mesh_ptr theMesh )
{
- SMESH::long_array_var anArray = new SMESH::long_array;
+ SMESH::smIdType_array_var anArray = new SMESH::smIdType_array;
if(!CORBA::is_nil(theMesh) && myPredicate){
theMesh->Load();
Controls::Filter::TIdSequence aSequence;
return anArray._retn();
}
+SMESH::smIdType_array*
+Filter_i::
+GetElementsIdFromParts( const ListOfIDSources& theParts )
+{
+ SMESH::smIdType_array_var array = new SMESH::smIdType_array;
+ if ( theParts.length() > 0 && myPredicate )
+ {
+ SMESH_Mesh_ptr mesh = theParts[0]->GetMesh();
+ mesh->Load();
+ const SMDS_Mesh* meshDS = MeshPtr2SMDSMesh( mesh );
+ Controls::Filter::TIdSequence totalSequence;
+ for ( CORBA::ULong i = 0; i < theParts.length(); ++i )
+ {
+ if ( SMESH::Filter_i* filter = SMESH::DownCast<SMESH::Filter_i*>( theParts[i] ))
+ filter->SetMesh( mesh );
+ SMDS_ElemIteratorPtr iter = SMESH_Mesh_i::GetElements( theParts[i], GetElementType() );
+ if ( iter && meshDS )
+ {
+ Controls::Filter::TIdSequence sequence;
+ Controls::Filter::GetElementsId( meshDS, myPredicate->GetPredicate(), sequence, iter );
+ totalSequence.insert( totalSequence.end(), sequence.begin(), sequence.end() );
+ }
+ }
+ array->length( totalSequence.size() );
+ for ( size_t i = 0; i < totalSequence.size(); ++i )
+ array[ i ] = totalSequence[ i ];
+ }
+ return array._retn();
+}
+
//=============================================================================
/*!
* \brief Returns number of mesh elements per each \a EntityType
*/
//=============================================================================
-SMESH::long_array* ::Filter_i::GetMeshInfo()
+SMESH::smIdType_array* ::Filter_i::GetMeshInfo()
{
- SMESH::long_array_var aRes = new SMESH::long_array();
+ SMESH::smIdType_array_var aRes = new SMESH::smIdType_array();
aRes->length(SMESH::Entity_Last);
for (int i = 0; i < SMESH::Entity_Last; i++)
aRes[i] = 0;
*/
//=============================================================================
-SMESH::long_array* ::Filter_i::GetNbElementsByType()
+SMESH::smIdType_array* ::Filter_i::GetNbElementsByType()
{
- SMESH::long_array_var aRes = new SMESH::long_array();
+ SMESH::smIdType_array_var aRes = new SMESH::smIdType_array();
aRes->length(SMESH::NB_ELEMENT_TYPES);
for (int i = 0; i < SMESH::NB_ELEMENT_TYPES; i++)
aRes[i] = 0;
if ( !CORBA::is_nil(myMesh) && myPredicate ) {
const SMDS_Mesh* aMesh = MeshPtr2SMDSMesh(myMesh);
SMDS_ElemIteratorPtr it = aMesh->elementsIterator( SMDSAbs_ElementType( GetElementType() ));
- CORBA::Long& nbElems = aRes[ GetElementType() ];
+ SMESH::smIdType& nbElems = aRes[ GetElementType() ];
while ( it->more() )
{
const SMDS_MeshElement* anElem = it->next();
case SMESH::FT_Length2D:
aFunctor = aFilterMgr->CreateLength2D();
break;
+ case SMESH::FT_Length3D:
+ aFunctor = aFilterMgr->CreateLength3D();
+ break;
case SMESH::FT_Deflection2D:
aFunctor = aFilterMgr->CreateDeflection2D();
break;
case FT_MultiConnection2D : return "Borders at multi-connections 2D";
case FT_Length : return "Length";
case FT_Length2D : return "Length 2D";
+ case FT_Length3D : return "Length 3D";
case FT_Deflection2D : return "Deflection 2D";
case FT_LessThan : return "Less than";
case FT_MoreThan : return "More than";
// else if ( theStr.equals( "Borders at multi-connections 2D" ) ) return FT_MultiConnection2D;
else if ( theStr.equals( "Length" ) ) return FT_Length;
// else if ( theStr.equals( "Length2D" ) ) return FT_Length2D;
+ // else if ( theStr.equals( "Length3D" ) ) return FT_Length3D;
else if ( theStr.equals( "Deflection" ) ) return FT_Deflection2D;
else if ( theStr.equals( "Range of IDs" ) ) return FT_RangeOfIds;
else if ( theStr.equals( "Bad Oriented Volume" ) ) return FT_BadOrientedVolume;
"FT_MultiConnection2D",
"FT_Length",
"FT_Length2D",
+ "FT_Length3D",
"FT_Deflection2D",
"FT_NodeConnectivityNumber",
"FT_BelongToMeshGroup",
