From 157b19ec7ff5d52b743b88d58cfd4195b5bfcb25 Mon Sep 17 00:00:00 2001 From: mzn Date: Mon, 17 Jan 2005 13:35:49 +0000 Subject: [PATCH] PAL7221 (DEVELOPMENT : Improve filter which find elements on Shape). Add "LyingOnGeom" filter. --- idl/SMESH_Filter.idl | 16 ++ src/SMESHGUI/SMESHGUI_FilterDlg.cxx | 28 +++- src/SMESHGUI/SMESH_msg_en.po | 3 + src/SMESH_I/SMESH_Filter_i.cxx | 241 +++++++++++++++++++++++++--- src/SMESH_I/SMESH_Filter_i.hxx | 59 +++++++ 5 files changed, 318 insertions(+), 29 deletions(-) diff --git a/idl/SMESH_Filter.idl b/idl/SMESH_Filter.idl index 367e53da2..c66a90ea0 100644 --- a/idl/SMESH_Filter.idl +++ b/idl/SMESH_Filter.idl @@ -60,6 +60,7 @@ module SMESH FT_BelongToGeom, FT_BelongToPlane, FT_BelongToCylinder, + FT_LyingOnGeom, FT_RangeOfIds, FT_LessThan, FT_MoreThan, @@ -180,6 +181,19 @@ module SMESH void SetCylinder( in GEOM::GEOM_Object theGeom, in ElementType theType ); }; + /*! + * Logical functor (predicate) "Lying On Geometry". + * Verify whether mesh element or node lying or partially lying on the pointed Geom Object + */ + interface LyingOnGeom: Predicate + { + void SetGeom( in GEOM::GEOM_Object theGeom ); + void SetElementType( in ElementType theType ); + + void SetShapeName( in string theName ); + string GetShapeName(); + }; + /*! * Logical functor (predicate) "Free borders". * Verify whether 1D mesh element is free ( i.e. connected to one face only ) @@ -362,6 +376,8 @@ module SMESH BelongToPlane CreateBelongToPlane(); BelongToCylinder CreateBelongToCylinder(); + LyingOnGeom CreateLyingOnGeom(); + FreeBorders CreateFreeBorders(); FreeEdges CreateFreeEdges(); diff --git a/src/SMESHGUI/SMESHGUI_FilterDlg.cxx b/src/SMESHGUI/SMESHGUI_FilterDlg.cxx index 46e57b451..f20b321ca 100755 --- a/src/SMESHGUI/SMESHGUI_FilterDlg.cxx +++ b/src/SMESHGUI/SMESHGUI_FilterDlg.cxx @@ -658,7 +658,8 @@ bool SMESHGUI_FilterTable::IsValid( const bool theMess, const int theEntityType if ( aCriterion == FT_RangeOfIds || aCriterion == FT_BelongToGeom || aCriterion == FT_BelongToPlane || - aCriterion == FT_BelongToCylinder ) + aCriterion == FT_BelongToCylinder || + aCriterion == FT_LyingOnGeom) { if ( aTable->text( i, 2 ).isEmpty() ) { @@ -772,7 +773,8 @@ void SMESHGUI_FilterTable::GetCriterion( const int theRow, if ( aCriterionType != FT_RangeOfIds && aCriterionType != FT_BelongToGeom && aCriterionType != FT_BelongToPlane && - aCriterionType != FT_BelongToCylinder ) + aCriterionType != FT_BelongToCylinder && + aCriterionType != FT_LyingOnGeom) { theCriterion.Compare = ( (ComboItem*)aTable->item( theRow, 1 ) )->GetValue(); theCriterion.Threshold = aTable->item( theRow, 2 )->text().toDouble(); @@ -817,7 +819,8 @@ void SMESHGUI_FilterTable::SetCriterion( const int theRow, if ( theCriterion.Type != FT_RangeOfIds && theCriterion.Type != FT_BelongToGeom && theCriterion.Type != FT_BelongToPlane && - theCriterion.Type != FT_BelongToCylinder ) + theCriterion.Type != FT_BelongToCylinder && + theCriterion.Type != FT_LyingOnGeom) aTable->setText( theRow, 2, QString( "%1" ).arg( theCriterion.Threshold, 0, 'g', 15 ) ); else aTable->setText( theRow, 2, QString( theCriterion.ThresholdStr ) ); @@ -968,6 +971,7 @@ void SMESHGUI_FilterTable::updateAdditionalWidget() ComboItem* anItem = ( (ComboItem*)aTable->item( aRow, 0 ) ); bool toEnable = ( (ComboItem*)aTable->item( aRow, 1 ) )->GetValue() == FT_EqualTo && GetCriterionType( aRow ) != FT_BelongToGeom && + GetCriterionType( aRow ) != FT_LyingOnGeom && GetCriterionType( aRow ) != FT_RangeOfIds && GetCriterionType( aRow ) != FT_FreeEdges; if ( !myAddWidgets.contains( anItem ) ) @@ -1050,7 +1054,8 @@ void SMESHGUI_FilterTable::onCriterionChanged( const int row, const int col, con else if ( aCriterionType == SMESH::FT_RangeOfIds || aCriterionType == SMESH::FT_BelongToGeom || aCriterionType == SMESH::FT_BelongToPlane || - aCriterionType == SMESH::FT_BelongToCylinder ) + aCriterionType == SMESH::FT_BelongToCylinder || + aCriterionType == SMESH::FT_LyingOnGeom) { QMap aMap; aMap[ FT_EqualTo ] = tr( "EQUAL_TO" ); @@ -1242,6 +1247,7 @@ const QMap& SMESHGUI_FilterTable::getCriteria( const int theType ) aCriteria[ SMESH::FT_BelongToGeom ] = tr( "BELONG_TO_GEOM" ); aCriteria[ SMESH::FT_BelongToPlane ] = tr( "BELONG_TO_PLANE" ); aCriteria[ SMESH::FT_BelongToCylinder ] = tr( "BELONG_TO_CYLINDER" ); + aCriteria[ SMESH::FT_LyingOnGeom ] = tr( "LYING_ON_GEOM" ); } return aCriteria; } @@ -1257,6 +1263,7 @@ const QMap& SMESHGUI_FilterTable::getCriteria( const int theType ) aCriteria[ SMESH::FT_BelongToGeom ] = tr( "BELONG_TO_GEOM" ); aCriteria[ SMESH::FT_BelongToPlane ] = tr( "BELONG_TO_PLANE" ); aCriteria[ SMESH::FT_BelongToCylinder ] = tr( "BELONG_TO_CYLINDER" ); + aCriteria[ SMESH::FT_LyingOnGeom ] = tr( "LYING_ON_GEOM" ); } return aCriteria; } @@ -1276,6 +1283,7 @@ const QMap& SMESHGUI_FilterTable::getCriteria( const int theType ) aCriteria[ SMESH::FT_BelongToGeom ] = tr( "BELONG_TO_GEOM" ); aCriteria[ SMESH::FT_BelongToPlane ] = tr( "BELONG_TO_PLANE" ); aCriteria[ SMESH::FT_BelongToCylinder ] = tr( "BELONG_TO_CYLINDER" ); + aCriteria[ SMESH::FT_LyingOnGeom ] = tr( "LYING_ON_GEOM" ); aCriteria[ SMESH::FT_Length2D ] = tr( "LENGTH2D" ); aCriteria[ SMESH::FT_MultiConnection2D] = tr( "MULTI2D_BORDERS" ); } @@ -1289,6 +1297,7 @@ const QMap& SMESHGUI_FilterTable::getCriteria( const int theType ) aCriteria[ SMESH::FT_AspectRatio3D] = tr( "ASPECT_RATIO_3D" ); aCriteria[ SMESH::FT_RangeOfIds ] = tr( "RANGE_OF_IDS" ); aCriteria[ SMESH::FT_BelongToGeom ] = tr( "BELONG_TO_GEOM" ); + aCriteria[ SMESH::FT_LyingOnGeom ] = tr( "LYING_ON_GEOM" ); } return aCriteria; } @@ -2002,7 +2011,8 @@ bool SMESHGUI_FilterDlg::isValid() const int aType = myTable->GetCriterionType( i ); if ( aType == FT_BelongToGeom || aType == FT_BelongToPlane || - aType == FT_BelongToCylinder ) + aType == FT_BelongToCylinder || + aType == FT_LyingOnGeom) { QString aName; myTable->GetThreshold( i, aName ); @@ -2421,7 +2431,8 @@ void SMESHGUI_FilterDlg::onSelectionDone() !myTable->CurrentCell( aRow, aCol ) || myTable->GetCriterionType( aRow ) != FT_BelongToGeom && myTable->GetCriterionType( aRow ) != FT_BelongToPlane && - myTable->GetCriterionType( aRow ) != FT_BelongToCylinder) + myTable->GetCriterionType( aRow ) != FT_BelongToCylinder && + myTable->GetCriterionType( aRow ) != FT_LyingOnGeom ) return; Handle(SALOME_InteractiveObject) anIO = mySelection->firstIObject() ; @@ -2464,9 +2475,10 @@ void SMESHGUI_FilterDlg::updateSelection() if ( myTable->CurrentCell( aRow, aCol ) && ( myTable->GetCriterionType( aRow ) == FT_BelongToGeom || myTable->GetCriterionType( aRow ) == FT_BelongToPlane || - myTable->GetCriterionType( aRow ) == FT_BelongToCylinder ) ) + myTable->GetCriterionType( aRow ) == FT_BelongToCylinder || + myTable->GetCriterionType( aRow ) == FT_LyingOnGeom) ) { - if ( myTable->GetCriterionType( aRow ) == FT_BelongToGeom ) + if ( myTable->GetCriterionType( aRow ) == FT_BelongToGeom || myTable->GetCriterionType( aRow ) == FT_LyingOnGeom ) mySelection->AddFilter( new SALOME_TypeFilter( "GEOM" ) ); else if ( myTable->GetCriterionType( aRow ) == FT_BelongToPlane ) mySelection->AddFilter( new GEOM_FaceFilter( StdSelect_Plane ) ); diff --git a/src/SMESHGUI/SMESH_msg_en.po b/src/SMESHGUI/SMESH_msg_en.po index 46e1ebe84..1608d04ca 100644 --- a/src/SMESHGUI/SMESH_msg_en.po +++ b/src/SMESHGUI/SMESH_msg_en.po @@ -1048,6 +1048,9 @@ msgstr "Belong to Plane" msgid "SMESHGUI_FilterTable::BELONG_TO_CYLINDER" msgstr "Belong to Cylinder" +msgid "SMESHGUI_FilterTable::LYING_ON_GEOM" +msgstr "Lying on Geom" + # -------------- SMESHGUI_FilterDlg -------------- msgid "SMESHGUI_FilterDlg::TLT" msgstr "Selection filter" diff --git a/src/SMESH_I/SMESH_Filter_i.cxx b/src/SMESH_I/SMESH_Filter_i.cxx index 4d98d80c3..a5c073f29 100644 --- a/src/SMESH_I/SMESH_Filter_i.cxx +++ b/src/SMESH_I/SMESH_Filter_i.cxx @@ -91,7 +91,7 @@ static bool IsContains( SMESHDS_Mesh* theMeshDS, TopAbs_ShapeEnum theAvoidShapeEnum = TopAbs_SHAPE ) { TopExp_Explorer anExp( theShape,theFindShapeEnum,theAvoidShapeEnum ); - + while( anExp.More() ) { const TopoDS_Shape& aShape = anExp.Current(); @@ -171,6 +171,143 @@ SMESHDS_Mesh* Controls::BelongToGeom::GetMeshDS() return myMeshDS; } +/* + Class : LyingOnGeom + Description : Predicate for verifying whether entiy lying or partially lying on + specified geometrical support +*/ + +Controls::LyingOnGeom::LyingOnGeom() +: myMeshDS(NULL), + myType(SMDSAbs_All) +{} + +void Controls::LyingOnGeom::SetMesh( SMDS_Mesh* theMesh ) +{ + myMeshDS = dynamic_cast(theMesh); +} + +void Controls::LyingOnGeom::SetGeom( const TopoDS_Shape& theShape ) +{ + myShape = theShape; +} + +bool Controls::LyingOnGeom::IsSatisfy( long theId ) +{ + if ( myMeshDS == 0 || myShape.IsNull() ) + return false; + + if( myType == SMDSAbs_Node ) + { + if( const SMDS_MeshNode* aNode = myMeshDS->FindNode( theId ) ) + { + const SMDS_PositionPtr& aPosition = aNode->GetPosition(); + SMDS_TypeOfPosition aTypeOfPosition = aPosition->GetTypeOfPosition(); + switch( aTypeOfPosition ) + { + case SMDS_TOP_VERTEX : return IsContains( myMeshDS,myShape,aNode,TopAbs_VERTEX ); + case SMDS_TOP_EDGE : return IsContains( myMeshDS,myShape,aNode,TopAbs_EDGE ); + case SMDS_TOP_FACE : return IsContains( myMeshDS,myShape,aNode,TopAbs_FACE ); + case SMDS_TOP_3DSPACE: return IsContains( myMeshDS,myShape,aNode,TopAbs_SHELL ); + } + } + } + else + { + if( const SMDS_MeshElement* anElem = myMeshDS->FindElement( theId ) ) + { + if( myType == SMDSAbs_All ) + { + return Contains( myMeshDS,myShape,anElem,TopAbs_EDGE ) || + Contains( myMeshDS,myShape,anElem,TopAbs_FACE ) || + Contains( myMeshDS,myShape,anElem,TopAbs_SHELL )|| + Contains( myMeshDS,myShape,anElem,TopAbs_SOLID ); + } + else if( myType == anElem->GetType() ) + { + switch( myType ) + { + case SMDSAbs_Edge : return Contains( myMeshDS,myShape,anElem,TopAbs_EDGE ); + case SMDSAbs_Face : return Contains( myMeshDS,myShape,anElem,TopAbs_FACE ); + case SMDSAbs_Volume: return Contains( myMeshDS,myShape,anElem,TopAbs_SHELL )|| + Contains( myMeshDS,myShape,anElem,TopAbs_SOLID ); + } + } + } + } + + return false; +} + +void Controls::LyingOnGeom::SetType( SMDSAbs_ElementType theType ) +{ + myType = theType; +} + +SMDSAbs_ElementType Controls::LyingOnGeom::GetType() const +{ + return myType; +} + +TopoDS_Shape Controls::LyingOnGeom::GetShape() +{ + return myShape; +} + +SMESHDS_Mesh* Controls::LyingOnGeom::GetMeshDS() +{ + return myMeshDS; +} + +bool Controls::LyingOnGeom::Contains( SMESHDS_Mesh* theMeshDS, + const TopoDS_Shape& theShape, + const SMDS_MeshElement* theElem, + TopAbs_ShapeEnum theFindShapeEnum, + TopAbs_ShapeEnum theAvoidShapeEnum ) +{ + if (IsContains(theMeshDS, theShape, theElem, theFindShapeEnum, theAvoidShapeEnum)) + return true; + + if ( SMESHDS_SubMesh* aSubMesh = theMeshDS->MeshElements( theShape ) ) + { + SMDS_NodeIteratorPtr aNodeIt = aSubMesh->GetNodes(); + while ( aNodeIt->more() ) + { + const SMDS_MeshNode* aNode = static_cast(aNodeIt->next()); + SMDS_ElemIteratorPtr anElemIt = aNode->GetInverseElementIterator(); + while ( anElemIt->more() ) + { + const SMDS_MeshElement* anElement = static_cast(anElemIt->next()); + if (anElement == theElem) + return true; + } + } + } + + TopExp_Explorer anExp( theShape,TopAbs_VERTEX,theAvoidShapeEnum ); + + while( anExp.More() ) + { + const TopoDS_Shape& aShape = anExp.Current(); + if( SMESHDS_SubMesh* aSubMesh = theMeshDS->MeshElements( aShape ) ){ + SMDS_NodeIteratorPtr aNodeIt = aSubMesh->GetNodes(); + while ( aNodeIt->more() ) + { + const SMDS_MeshNode* aNode = static_cast(aNodeIt->next()); + SMDS_ElemIteratorPtr anElemIt = aNode->GetInverseElementIterator(); + while ( anElemIt->more() ) + { + const SMDS_MeshElement* anElement = static_cast(anElemIt->next()); + if (anElement == theElem) + return true; + } + } + } + anExp.Next(); + } + return false; +} + /* AUXILIARY METHODS @@ -696,7 +833,57 @@ FunctorType BelongToCylinder_i::GetFunctorType() return FT_BelongToCylinder; } +/* + Class : LyingOnGeom_i + Description : Predicate for selection on geometrical support +*/ +LyingOnGeom_i::LyingOnGeom_i() +{ + myLyingOnGeomPtr.reset( new Controls::LyingOnGeom() ); + myFunctorPtr = myPredicatePtr = myLyingOnGeomPtr; + myShapeName = 0; +} +LyingOnGeom_i::~LyingOnGeom_i() +{ + delete myShapeName; +} + +void LyingOnGeom_i::SetGeom( GEOM::GEOM_Object_ptr theGeom ) +{ + if ( theGeom->_is_nil() ) + return; + SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen(); + GEOM::GEOM_Gen_var aGEOMGen = SMESH_Gen_i::GetGeomEngine(); + TopoDS_Shape aLocShape = aSMESHGen->GetShapeReader()->GetShape( aGEOMGen, theGeom ); + myLyingOnGeomPtr->SetGeom( aLocShape ); +} + +void LyingOnGeom_i::SetGeom( const TopoDS_Shape& theShape ) +{ + myLyingOnGeomPtr->SetGeom( theShape ); +} + +void LyingOnGeom_i::SetElementType(ElementType theType){ + myLyingOnGeomPtr->SetType(SMDSAbs_ElementType(theType)); +} + +FunctorType LyingOnGeom_i::GetFunctorType() +{ + return SMESH::FT_LyingOnGeom; +} + +void LyingOnGeom_i::SetShapeName( const char* theName ) +{ + delete myShapeName; + myShapeName = strdup( theName ); + myLyingOnGeomPtr->SetGeom( getShapeByName( myShapeName ) ); +} + +char* LyingOnGeom_i::GetShapeName() +{ + return CORBA::string_dup( myShapeName ); +} /* Class : FreeBorders_i @@ -1160,6 +1347,13 @@ BelongToCylinder_ptr FilterManager_i::CreateBelongToCylinder() return anObj._retn(); } +LyingOnGeom_ptr FilterManager_i::CreateLyingOnGeom() +{ + SMESH::LyingOnGeom_i* aServant = new SMESH::LyingOnGeom_i(); + SMESH::LyingOnGeom_var anObj = aServant->_this(); + return anObj._retn(); +} + FreeBorders_ptr FilterManager_i::CreateFreeBorders() { SMESH::FreeBorders_i* aServant = new SMESH::FreeBorders_i(); @@ -1400,6 +1594,21 @@ static inline bool getCriteria( Predicate_i* thePred, theCriteria[ i ].TypeOfElement = aPred->GetElementType(); theCriteria[ i ].Tolerance = aPred->GetTolerance(); + return true; + } + case FT_LyingOnGeom: + { + LyingOnGeom_i* aPred = dynamic_cast( thePred ); + + CORBA::ULong i = theCriteria->length(); + theCriteria->length( i + 1 ); + + theCriteria[ i ] = createCriterion(); + + theCriteria[ i ].Type = FT_LyingOnGeom; + theCriteria[ i ].ThresholdStr = aPred->GetShapeName(); + theCriteria[ i ].TypeOfElement = aPred->GetElementType(); + return true; } case FT_RangeOfIds: @@ -1576,6 +1785,14 @@ CORBA::Boolean Filter_i::SetCriteria( const SMESH::Filter::Criteria& theCriteria aPredicate = tmpPred; } break; + case SMESH::FT_LyingOnGeom: + { + SMESH::LyingOnGeom_ptr tmpPred = aFilterMgr->CreateLyingOnGeom(); + tmpPred->SetElementType( aTypeOfElem ); + tmpPred->SetShapeName( aThresholdStr ); + aPredicate = tmpPred; + } + break; case SMESH::FT_RangeOfIds: { SMESH::RangeOfIds_ptr tmpPred = aFilterMgr->CreateRangeOfIds(); @@ -1786,6 +2003,7 @@ static inline LDOMString toString( const long theType ) case FT_BelongToGeom : return "Belong to Geom"; case FT_BelongToPlane : return "Belong to Plane"; case FT_BelongToCylinder: return "Belong to Cylinder"; + case FT_LyingOnGeom : return "Lying on Geom"; case FT_RangeOfIds : return "Range of IDs"; case FT_FreeBorders : return "Free borders"; case FT_FreeEdges : return "Free edges"; @@ -1819,6 +2037,7 @@ static inline SMESH::FunctorType toFunctorType( const LDOMString& theStr ) else if ( theStr.equals( "Belong to Geom" ) ) return FT_BelongToGeom; else if ( theStr.equals( "Belong to Plane" ) ) return FT_BelongToPlane; else if ( theStr.equals( "Belong to Cylinder" ) ) return FT_BelongToCylinder; + else if ( theStr.equals( "Lying on Geom" ) ) return FT_LyingOnGeom; else if ( theStr.equals( "Free borders" ) ) return FT_FreeBorders; else if ( theStr.equals( "Free edges" ) ) return FT_FreeEdges; else if ( theStr.equals( "Borders at multi-connections" ) ) return FT_MultiConnection; @@ -2334,23 +2553,3 @@ string_array* FilterLibrary_i::GetAllNames() return aResArray._retn(); } - - - - - - - - - - - - - - - - - - - - diff --git a/src/SMESH_I/SMESH_Filter_i.hxx b/src/SMESH_I/SMESH_Filter_i.hxx index 4e884a416..ce3246602 100644 --- a/src/SMESH_I/SMESH_Filter_i.hxx +++ b/src/SMESH_I/SMESH_Filter_i.hxx @@ -72,6 +72,39 @@ private: SMDSAbs_ElementType myType; }; typedef boost::shared_ptr BelongToGeomPtr; + +/* + Class : LyingOnGeom + Description : Predicate for verifying whether entiy lying or partially lying on + specified geometrical support +*/ +class LyingOnGeom: public virtual Predicate +{ +public: + LyingOnGeom(); + + virtual void SetMesh( SMDS_Mesh* theMesh ); + virtual void SetGeom( const TopoDS_Shape& theShape ); + + virtual bool IsSatisfy( long theElementId ); + + virtual void SetType( SMDSAbs_ElementType theType ); + virtual SMDSAbs_ElementType GetType() const; + + TopoDS_Shape GetShape(); + SMESHDS_Mesh* GetMeshDS(); + + virtual bool Contains( SMESHDS_Mesh* theMeshDS, + const TopoDS_Shape& theShape, + const SMDS_MeshElement* theElem, + TopAbs_ShapeEnum theFindShapeEnum, + TopAbs_ShapeEnum theAvoidShapeEnum = TopAbs_SHAPE ); +private: + TopoDS_Shape myShape; + SMESHDS_Mesh* myMeshDS; + SMDSAbs_ElementType myType; +}; +typedef boost::shared_ptr LyingOnGeomPtr; } /* @@ -359,6 +392,30 @@ public: FunctorType GetFunctorType(); }; +/* + Class : LyingOnGeom_i + Description : Predicate for selection on geometrical support(lying or partially lying) +*/ +class LyingOnGeom_i: public virtual POA_SMESH::LyingOnGeom, + public virtual Predicate_i +{ +public: + LyingOnGeom_i(); + virtual ~LyingOnGeom_i(); + + void SetGeom( GEOM::GEOM_Object_ptr theGeom ); + void SetElementType( ElementType theType ); + FunctorType GetFunctorType(); + + void SetGeom( const TopoDS_Shape& theShape ); + + void SetShapeName( const char* theName ); + char* GetShapeName(); + +protected: + Controls::LyingOnGeomPtr myLyingOnGeomPtr; + char* myShapeName; +}; /* Class : FreeBorders_i @@ -642,6 +699,8 @@ public: BelongToPlane_ptr CreateBelongToPlane(); BelongToCylinder_ptr CreateBelongToCylinder(); + LyingOnGeom_ptr CreateLyingOnGeom(); + FreeBorders_ptr CreateFreeBorders(); FreeEdges_ptr CreateFreeEdges(); -- 2.39.2