Back to index

salome-smesh  6.5.0
SMESH_HypoFilter.cxx
Go to the documentation of this file.
00001 // Copyright (C) 2007-2012  CEA/DEN, EDF R&D, OPEN CASCADE
00002 //
00003 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
00004 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
00005 //
00006 // This library is free software; you can redistribute it and/or
00007 // modify it under the terms of the GNU Lesser General Public
00008 // License as published by the Free Software Foundation; either
00009 // version 2.1 of the License.
00010 //
00011 // This library is distributed in the hope that it will be useful,
00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014 // Lesser General Public License for more details.
00015 //
00016 // You should have received a copy of the GNU Lesser General Public
00017 // License along with this library; if not, write to the Free Software
00018 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
00019 //
00020 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
00021 //
00022 
00023 //  SMESH SMESH : implementaion of SMESH idl descriptions
00024 //  File   : SMESH_HypoFilter.cxx
00025 //  Module : SMESH
00026 //
00027 #include "SMESH_HypoFilter.hxx"
00028 
00029 #include "SMESH_Gen.hxx"
00030 #include "SMESH_Hypothesis.hxx"
00031 #include "SMESH_MesherHelper.hxx"
00032 #include "SMESH_subMesh.hxx"
00033 
00034 #include <TopExp_Explorer.hxx>
00035 
00036 using namespace std;
00037 
00038 
00039 //=======================================================================
00040 //function : NamePredicate::Value
00041 //purpose  : 
00042 //=======================================================================
00043 
00044 bool SMESH_HypoFilter::NamePredicate::IsOk (const SMESH_Hypothesis* aHyp,
00045                                             const TopoDS_Shape&     /*aShape*/ ) const
00046 {
00047   return ( _name == aHyp->GetName() );
00048 }
00049 
00050 //=======================================================================
00051 //function : TypePredicate::Value
00052 //purpose  : 
00053 //=======================================================================
00054 
00055 int SMESH_HypoFilter::TypePredicate::Value( const SMESH_Hypothesis* aHyp ) const
00056 {
00057   return aHyp->GetType();
00058 };
00059 
00060 //=======================================================================
00061 //function : DimPredicate::Value
00062 //purpose  : 
00063 //=======================================================================
00064 
00065 int SMESH_HypoFilter::DimPredicate::Value( const SMESH_Hypothesis* aHyp ) const
00066 {
00067   return aHyp->GetDim();
00068 }
00069 
00070 //=======================================================================
00071 //function : ApplicablePredicate::IsOk
00072 //purpose  : 
00073 //=======================================================================
00074 
00075 bool SMESH_HypoFilter::ApplicablePredicate::IsOk(const SMESH_Hypothesis* aHyp,
00076                                                  const TopoDS_Shape&     /*aShape*/) const
00077 {
00078   return SMESH_subMesh::IsApplicableHypotesis( aHyp, (TopAbs_ShapeEnum)_shapeType );
00079 };
00080 
00081 //=======================================================================
00082 //function : IsAuxiliaryPredicate::IsOk
00083 //purpose  : 
00084 //=======================================================================
00085 
00086 bool SMESH_HypoFilter::IsAuxiliaryPredicate::IsOk(const SMESH_Hypothesis* aHyp,
00087                                                   const TopoDS_Shape&     /*aShape*/) const
00088 {
00089   return aHyp->IsAuxiliary();
00090 };
00091 
00092 //=======================================================================
00093 //function : ApplicablePredicate::ApplicablePredicate
00094 //purpose  : 
00095 //=======================================================================
00096 
00097 SMESH_HypoFilter::ApplicablePredicate::ApplicablePredicate( const TopoDS_Shape& theShape )
00098 {
00099   _shapeType = ( theShape.IsNull() ? TopAbs_SHAPE : theShape.ShapeType());
00100 }
00101 
00102 //=======================================================================
00103 //function : InstancePredicate::IsOk
00104 //purpose  : 
00105 //=======================================================================
00106 
00107 bool SMESH_HypoFilter::InstancePredicate::IsOk(const SMESH_Hypothesis* aHyp,
00108                                                const TopoDS_Shape&     /*aShape*/) const
00109 {
00110   return _hypo == aHyp;
00111 }
00112 
00113 //=======================================================================
00114 //function : IsAssignedToPredicate::IsOk
00115 //purpose  : 
00116 //=======================================================================
00117 
00118 bool SMESH_HypoFilter::IsAssignedToPredicate::IsOk(const SMESH_Hypothesis* aHyp,
00119                                                    const TopoDS_Shape&     aShape) const
00120 {
00121   return ( !_mainShape.IsNull() && !aShape.IsNull() && _mainShape.IsSame( aShape ));
00122 }
00123 
00124 //================================================================================
00128 //================================================================================
00129 
00130 void SMESH_HypoFilter::IsMoreLocalThanPredicate::findPreferable()
00131 {
00132   const int shapeID = _mesh.GetMeshDS()->ShapeToIndex( _shape );
00133   const TListOfListOfInt& listOfShapeIDList = _mesh.GetMeshOrder();
00134   TListOfListOfInt::const_iterator listsIt = listOfShapeIDList.begin();
00135   for ( ; listsIt != listOfShapeIDList.end(); ++listsIt )
00136   {
00137     const TListOfInt& idList  = *listsIt;
00138     TListOfInt::const_iterator idIt =
00139       std::find( idList.begin(), idList.end(), shapeID );
00140     if ( idIt != idList.end() && *idIt != idList.front() )
00141     {
00142       for ( ; idIt != idList.end(); --idIt )
00143       {
00144         const TopoDS_Shape& shape = _mesh.GetMeshDS()->IndexToShape( *idIt );
00145         if ( !shape.IsNull())
00146           _preferableShapes.Add( shape );
00147       }
00148     }
00149   }
00150 }
00151 
00152 //=======================================================================
00153 //function : IsMoreLocalThanPredicate::IsOk
00154 //purpose  : 
00155 //=======================================================================
00156 
00157 bool SMESH_HypoFilter::IsMoreLocalThanPredicate::IsOk(const SMESH_Hypothesis* aHyp,
00158                                                       const TopoDS_Shape&     aShape) const
00159 {
00160   if ( aShape.IsSame( _mesh.GetShapeToMesh() ))
00161     return false; // aHyp is global
00162 
00163   if ( SMESH_MesherHelper::IsSubShape( aShape, /*mainShape=*/_shape ))
00164     return true;
00165 
00166   if ( aShape.ShapeType() == TopAbs_COMPOUND && 
00167        !SMESH_MesherHelper::IsSubShape( _shape, /*mainShape=*/aShape)) // issue 0020963
00168   {
00169     for ( int type = TopAbs_SOLID; type < TopAbs_SHAPE; ++type )
00170       if ( aHyp->GetDim() == SMESH_Gen::GetShapeDim( TopAbs_ShapeEnum( type )))
00171         for ( TopExp_Explorer exp( aShape, TopAbs_ShapeEnum( type )); exp.More(); exp.Next())
00172           if ( SMESH_MesherHelper::IsSubShape( exp.Current(), /*mainShape=*/_shape ))
00173             return true;
00174   }
00175 
00176   if ( _preferableShapes.Contains( aShape ))
00177     return true; // issue 21559, Mesh_6
00178 
00179   return false;
00180 }
00181 
00182 //=======================================================================
00183 //function : SMESH_HypoFilter
00184 //purpose  : 
00185 //=======================================================================
00186 
00187 SMESH_HypoFilter::SMESH_HypoFilter()
00188 {
00189 }
00190 
00191 //=======================================================================
00192 //function : SMESH_HypoFilter
00193 //purpose  : 
00194 //=======================================================================
00195 
00196 SMESH_HypoFilter::SMESH_HypoFilter( SMESH_HypoPredicate* aPredicate, bool notNagate )
00197 {
00198   add( notNagate ? AND : AND_NOT, aPredicate );
00199 }
00200 
00201 //=======================================================================
00202 //function : And
00203 //purpose  : 
00204 //=======================================================================
00205 
00206 SMESH_HypoFilter & SMESH_HypoFilter::And( SMESH_HypoPredicate* aPredicate )
00207 {
00208   add( AND, aPredicate );
00209   return *this;
00210 }
00211 
00212 //=======================================================================
00213 //function : AndNot
00214 //purpose  : 
00215 //=======================================================================
00216 
00217 SMESH_HypoFilter & SMESH_HypoFilter::AndNot( SMESH_HypoPredicate* aPredicate )
00218 {
00219   add( AND_NOT, aPredicate );
00220   return *this;
00221 }
00222 
00223 //=======================================================================
00224 //function : Or
00225 //purpose  : 
00226 //=======================================================================
00227 
00228 SMESH_HypoFilter & SMESH_HypoFilter::Or( SMESH_HypoPredicate* aPredicate )
00229 {
00230   add( OR, aPredicate );
00231   return *this;
00232 }
00233 
00234 //=======================================================================
00235 //function : OrNot
00236 //purpose  : Return predicates
00237 //=======================================================================
00238 
00239 SMESH_HypoFilter & SMESH_HypoFilter::OrNot( SMESH_HypoPredicate* aPredicate )
00240 {
00241   add( OR_NOT, aPredicate );
00242   return *this;
00243 }
00244 
00245 //=======================================================================
00246 //function : Is
00247 //purpose  : 
00248 //=======================================================================
00249 
00250 SMESH_HypoPredicate* SMESH_HypoFilter::Is(const SMESH_Hypothesis* theHypo)
00251 {
00252   return new InstancePredicate( theHypo );
00253 }
00254 
00255 //=======================================================================
00256 //function : IsAlgo
00257 //purpose  : 
00258 //=======================================================================
00259 
00260 SMESH_HypoPredicate* SMESH_HypoFilter::IsAlgo()
00261 {
00262   return new TypePredicate( MORE, SMESHDS_Hypothesis::PARAM_ALGO );
00263 }
00264 
00265 //=======================================================================
00266 //function : IsAuxiliary
00267 //purpose  : 
00268 //=======================================================================
00269 
00270 SMESH_HypoPredicate* SMESH_HypoFilter::IsAuxiliary()
00271 {
00272   return new IsAuxiliaryPredicate();
00273 }
00274 
00275 
00276 //=======================================================================
00277 //function : IsGlobal
00278 //purpose  : 
00279 //=======================================================================
00280 
00281  SMESH_HypoPredicate* SMESH_HypoFilter::IsGlobal(const TopoDS_Shape& theMainShape)
00282 {
00283   return new IsAssignedToPredicate( theMainShape );
00284 }
00285 
00286 //=======================================================================
00287 //function : IsAssignedTo
00288 //purpose  : 
00289 //=======================================================================
00290 
00291  SMESH_HypoPredicate* SMESH_HypoFilter::IsAssignedTo(const TopoDS_Shape& theShape)
00292 {
00293   return new IsAssignedToPredicate( theShape );
00294 }
00295 
00296 //=======================================================================
00297 //function : HasName
00298 //purpose  : 
00299 //=======================================================================
00300 
00301 SMESH_HypoPredicate* SMESH_HypoFilter::HasName(const string & theName)
00302 {
00303   return new NamePredicate( theName );
00304 }
00305 
00306 //=======================================================================
00307 //function : HasDim
00308 //purpose  : 
00309 //=======================================================================
00310 
00311 SMESH_HypoPredicate* SMESH_HypoFilter::HasDim(const int theDim)
00312 {
00313   return new DimPredicate( EQUAL, theDim );
00314 }
00315 
00316 //=======================================================================
00317 //function : IsApplicableTo
00318 //purpose  : 
00319 //=======================================================================
00320 
00321 SMESH_HypoPredicate* SMESH_HypoFilter::IsApplicableTo(const TopoDS_Shape& theShape)
00322 {
00323   return new ApplicablePredicate( theShape );
00324 }
00325 
00326 //=======================================================================
00327 //function : IsMoreLocalThan
00328 //purpose  : 
00329 //=======================================================================
00330 
00331 SMESH_HypoPredicate* SMESH_HypoFilter::IsMoreLocalThan(const TopoDS_Shape& theShape,
00332                                                        const SMESH_Mesh&   theMesh)
00333 {
00334   return new IsMoreLocalThanPredicate( theShape, theMesh );
00335 }
00336 
00337 //=======================================================================
00338 //function : HasType
00339 //purpose  : 
00340 //=======================================================================
00341 
00342 SMESH_HypoPredicate* SMESH_HypoFilter::HasType(const int theHypType)
00343 {
00344   return new TypePredicate( EQUAL, theHypType );
00345 }
00346 
00347 //=======================================================================
00348 //function : IsOk
00349 //purpose  : 
00350 //=======================================================================
00351 
00352 bool SMESH_HypoFilter::IsOk (const SMESH_Hypothesis* aHyp,
00353                              const TopoDS_Shape&     aShape) const
00354 {
00355   if ( myPredicates.empty() )
00356     return true;
00357 
00358   bool ok = ( myPredicates.front()->_logical_op <= AND_NOT );
00359   list<SMESH_HypoPredicate*>::const_iterator pred = myPredicates.begin();
00360   for ( ; pred != myPredicates.end(); ++pred )
00361   {
00362     bool ok2 = (*pred)->IsOk( aHyp, aShape );
00363     switch ( (*pred)->_logical_op ) {
00364     case AND:     ok = ok && ok2; break;
00365     case AND_NOT: ok = ok && !ok2; break;
00366     case OR:      ok = ok || ok2; break;
00367     case OR_NOT:  ok = ok || !ok2; break;
00368     default:;
00369     }
00370   }
00371   return ok;
00372 }
00373 
00374 //=======================================================================
00375 //function : Init
00376 //purpose  : 
00377 //=======================================================================
00378 
00379 SMESH_HypoFilter & SMESH_HypoFilter::Init  ( SMESH_HypoPredicate* aPredicate, bool notNagate )
00380 {
00381   list<SMESH_HypoPredicate*>::const_iterator pred = myPredicates.begin();
00382   for ( ; pred != myPredicates.end(); ++pred )
00383     delete *pred;
00384   myPredicates.clear();
00385 
00386   add( notNagate ? AND : AND_NOT, aPredicate );
00387   return *this;
00388 }
00389 
00390 
00391 //=======================================================================
00392 //function : IsOk
00393 //purpose  : 
00394 //=======================================================================
00395 
00396 SMESH_HypoFilter::~SMESH_HypoFilter()
00397 {
00398   Init(0);
00399 }
00400 
00401 
00402