X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH%2FSMESH_Gen.cxx;h=864f50c21449346cb49b5ccccdfd2e718d5b4af9;hp=d515351393d12d2ad617c0f2e3be0162697c2e38;hb=52d825495306f72048c8754aa5c86c6a390f8262;hpb=e884e4cd7eaad1ea8139d278835c7722a9225176 diff --git a/src/SMESH/SMESH_Gen.cxx b/src/SMESH/SMESH_Gen.cxx index d51535139..864f50c21 100644 --- a/src/SMESH/SMESH_Gen.cxx +++ b/src/SMESH/SMESH_Gen.cxx @@ -1,4 +1,4 @@ -// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE +// 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 @@ -6,7 +6,7 @@ // 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. +// 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 @@ -43,10 +43,11 @@ #include "Utils_ExceptHandlers.hxx" #include +#include #include "memoire.h" -#ifdef WNT +#ifdef WIN32 #include #endif @@ -65,7 +66,7 @@ SMESH_Gen::SMESH_Gen() { MESSAGE("SMESH_Gen::SMESH_Gen"); _localId = 0; - _hypId = 0; + _hypId = 0; _segmentation = _nbSegments = 10; SMDS_Mesh::_meshList.clear(); MESSAGE(SMDS_Mesh::_meshList.size()); @@ -163,12 +164,13 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, SMESH_subMesh* smToCompute = smIt->next(); // do not mesh vertices of a pseudo shape - const TopAbs_ShapeEnum aShType = smToCompute->GetSubShape().ShapeType(); - if ( !aMesh.HasShapeToMesh() && aShType == TopAbs_VERTEX ) + const TopoDS_Shape& shape = smToCompute->GetSubShape(); + const TopAbs_ShapeEnum shapeType = shape.ShapeType(); + if ( !aMesh.HasShapeToMesh() && shapeType == TopAbs_VERTEX ) continue; // check for preview dimension limitations - if ( aShapesId && GetShapeDim( aShType ) > (int)aDim ) + if ( aShapesId && GetShapeDim( shapeType ) > (int)aDim ) { // clear compute state not to show previous compute errors // if preview invoked less dimension less than previous @@ -185,8 +187,9 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, _sm_current = NULL; } - // we check all the submeshes here and detect if any of them failed to compute - if (smToCompute->GetComputeState() == SMESH_subMesh::FAILED_TO_COMPUTE) + // we check all the sub-meshes here and detect if any of them failed to compute + if (smToCompute->GetComputeState() == SMESH_subMesh::FAILED_TO_COMPUTE && + ( shapeType != TopAbs_EDGE || !SMESH_Algo::isDegenerated( TopoDS::Edge( shape )))) ret = false; else if ( aShapesId ) aShapesId->insert( smToCompute->GetId() ); @@ -229,7 +232,7 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, if ( aShapesId && aShapeDim > (int)aDim ) continue; - SMESH_Algo* algo = GetAlgo( aMesh, aSubShape, &algoShape ); + SMESH_Algo* algo = GetAlgo( smToCompute, &algoShape ); if ( algo && !algo->NeedDiscreteBoundary() ) { if ( algo->SupportSubmeshes() ) @@ -285,27 +288,27 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, // Apply all-dimensional algorithms supporing sub-meshes // ====================================================== + std::vector< SMESH_subMesh* > smVec; for ( aShapeDim = 0; aShapeDim < 4; ++aShapeDim ) { // ------------------------------------------------ // sort list of sub-meshes according to mesh order // ------------------------------------------------ - aMesh.SortByMeshOrder( smWithAlgoSupportingSubmeshes[ aShapeDim ] ); + smVec.assign( smWithAlgoSupportingSubmeshes[ aShapeDim ].begin(), + smWithAlgoSupportingSubmeshes[ aShapeDim ].end() ); + aMesh.SortByMeshOrder( smVec ); // ------------------------------------------------------------ // compute sub-meshes with local uni-dimensional algos under // sub-meshes with all-dimensional algos // ------------------------------------------------------------ - list< SMESH_subMesh* >::iterator subIt, subEnd; - subIt = smWithAlgoSupportingSubmeshes[ aShapeDim ].begin(); - subEnd = smWithAlgoSupportingSubmeshes[ aShapeDim ].end(); // start from lower shapes - for ( ; subIt != subEnd; ++subIt ) + for ( size_t i = 0; i < smVec.size(); ++i ) { - sm = *subIt; + sm = smVec[i]; // get a shape the algo is assigned to - if ( !GetAlgo( aMesh, sm->GetSubShape(), & algoShape )) + if ( !GetAlgo( sm, & algoShape )) continue; // strange... // look for more local algos @@ -328,7 +331,8 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, .And( SMESH_HypoFilter::IsApplicableTo( aSubShape )) .And( SMESH_HypoFilter::IsMoreLocalThan( algoShape, aMesh )); - if ( SMESH_Algo* subAlgo = (SMESH_Algo*) aMesh.GetHypothesis( aSubShape, filter, true )) { + if ( SMESH_Algo* subAlgo = (SMESH_Algo*) aMesh.GetHypothesis( smToCompute, filter, true)) + { if ( ! subAlgo->NeedDiscreteBoundary() ) continue; SMESH_Hypothesis::Hypothesis_Status status; if ( subAlgo->CheckHypothesis( aMesh, aSubShape, status )) @@ -340,15 +344,14 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, // -------------------------------- // apply the all-dimensional algos // -------------------------------- - subIt = smWithAlgoSupportingSubmeshes[ aShapeDim ].begin(); - for ( ; subIt != subEnd; ++subIt ) + for ( size_t i = 0; i < smVec.size(); ++i ) { - sm = *subIt; + sm = smVec[i]; if ( sm->GetComputeState() == SMESH_subMesh::READY_TO_COMPUTE) { - const TopAbs_ShapeEnum aShType = sm->GetSubShape().ShapeType(); + const TopAbs_ShapeEnum shapeType = sm->GetSubShape().ShapeType(); // check for preview dimension limitations - if ( aShapesId && GetShapeDim( aShType ) > (int)aDim ) + if ( aShapesId && GetShapeDim( shapeType ) > (int)aDim ) continue; if (_compute_canceled) @@ -389,8 +392,6 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, return ret; } - -#ifdef WITH_SMESH_CANCEL_COMPUTE //============================================================================= /*! * Prepare Compute a mesh @@ -416,7 +417,6 @@ void SMESH_Gen::CancelCompute(SMESH_Mesh & aMesh, _sm_current->ComputeStateEngine( SMESH_subMesh::COMPUTE_CANCELED ); } } -#endif //============================================================================= /*! @@ -449,12 +449,12 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh & aMesh, SMESH_subMesh* smToCompute = smIt->next(); // do not mesh vertices of a pseudo shape - const TopAbs_ShapeEnum aShType = smToCompute->GetSubShape().ShapeType(); - //if ( !aMesh.HasShapeToMesh() && aShType == TopAbs_VERTEX ) + const TopAbs_ShapeEnum shapeType = smToCompute->GetSubShape().ShapeType(); + //if ( !aMesh.HasShapeToMesh() && shapeType == TopAbs_VERTEX ) // continue; if ( !aMesh.HasShapeToMesh() ) { - if( aShType == TopAbs_VERTEX || aShType == TopAbs_WIRE || - aShType == TopAbs_SHELL ) + if( shapeType == TopAbs_VERTEX || shapeType == TopAbs_WIRE || + shapeType == TopAbs_SHELL ) continue; } @@ -478,7 +478,7 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh & aMesh, const int aShapeDim = GetShapeDim( aSubShape ); if ( aShapeDim < 1 ) break; - SMESH_Algo* algo = GetAlgo( aMesh, aSubShape ); + SMESH_Algo* algo = GetAlgo( smToCompute ); if ( algo && !algo->NeedDiscreteBoundary() ) { if ( algo->SupportSubmeshes() ) { smWithAlgoSupportingSubmeshes.push_front( smToCompute ); @@ -494,22 +494,22 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh & aMesh, // ------------------------------------------------------------ // sort list of meshes according to mesh order // ------------------------------------------------------------ - aMesh.SortByMeshOrder( smWithAlgoSupportingSubmeshes ); + std::vector< SMESH_subMesh* > smVec( smWithAlgoSupportingSubmeshes.begin(), + smWithAlgoSupportingSubmeshes.end() ); + aMesh.SortByMeshOrder( smVec ); // ------------------------------------------------------------ // compute sub-meshes under shapes with algos that DO NOT require // Discreteized boundaries and DO support sub-meshes // ------------------------------------------------------------ - list< SMESH_subMesh* >::iterator subIt, subEnd; - subIt = smWithAlgoSupportingSubmeshes.begin(); - subEnd = smWithAlgoSupportingSubmeshes.end(); // start from lower shapes - for ( ; subIt != subEnd; ++subIt ) { - sm = *subIt; + for ( size_t i = 0; i < smVec.size(); ++i ) + { + sm = smVec[i]; // get a shape the algo is assigned to TopoDS_Shape algoShape; - if ( !GetAlgo( aMesh, sm->GetSubShape(), & algoShape )) + if ( !GetAlgo( sm, & algoShape )) continue; // strange... // look for more local algos @@ -521,14 +521,13 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh & aMesh, const int aShapeDim = GetShapeDim( aSubShape ); if ( aShapeDim < 1 ) continue; - //const TopAbs_ShapeEnum aShType = smToCompute->GetSubShape().ShapeType(); - SMESH_HypoFilter filter( SMESH_HypoFilter::IsAlgo() ); filter .And( SMESH_HypoFilter::IsApplicableTo( aSubShape )) .And( SMESH_HypoFilter::IsMoreLocalThan( algoShape, aMesh )); - if ( SMESH_Algo* subAlgo = (SMESH_Algo*) aMesh.GetHypothesis( aSubShape, filter, true )) { + if ( SMESH_Algo* subAlgo = (SMESH_Algo*) aMesh.GetHypothesis( smToCompute, filter, true )) + { if ( ! subAlgo->NeedDiscreteBoundary() ) continue; SMESH_Hypothesis::Hypothesis_Status status; if ( subAlgo->CheckHypothesis( aMesh, aSubShape, status )) @@ -540,9 +539,9 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh & aMesh, // ---------------------------------------------------------- // apply the algos that do not require Discreteized boundaries // ---------------------------------------------------------- - for ( subIt = smWithAlgoSupportingSubmeshes.begin(); subIt != subEnd; ++subIt ) + for ( size_t i = 0; i < smVec.size(); ++i ) { - sm = *subIt; + sm = smVec[i]; sm->Evaluate(aResMap); if ( aShapesId ) aShapesId->insert( sm->GetId() ); @@ -911,7 +910,6 @@ bool SMESH_Gen::GetAlgoState(SMESH_Mesh& theMesh, if ( !hasAlgo ) { ret = false; - INFOS( "None algorithm attached" ); theErrors.push_back( TAlgoStateError() ); theErrors.back().Set( SMESH_Hypothesis::HYP_MISSING, 1, true ); } @@ -979,7 +977,7 @@ std::vector< std::string > SMESH_Gen::GetPluginXMLPaths() sep = rootDir[pos]; break; } -#ifdef WNT +#ifdef WIN32 if (sep.empty() ) sep = "\\"; #else if (sep.empty() ) sep = "/"; @@ -994,7 +992,7 @@ std::vector< std::string > SMESH_Gen::GetPluginXMLPaths() xmlPath += tolower( pluginSubDir[pos] ); xmlPath += sep + plugin + ".xml"; bool fileOK; -#ifdef WNT +#ifdef WIN32 fileOK = (GetFileAttributes(xmlPath.c_str()) != INVALID_FILE_ATTRIBUTES); #else fileOK = (access(xmlPath.c_str(), F_OK) == 0); @@ -1017,6 +1015,23 @@ SMESH_Algo *SMESH_Gen::GetAlgo(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape, TopoDS_Shape* assignedTo) { + return GetAlgo( aMesh.GetSubMesh( aShape ), assignedTo ); +} + +//============================================================================= +/*! + * Finds algo to mesh a sub-mesh. Optionally returns a shape the found algo is bound to + */ +//============================================================================= + +SMESH_Algo *SMESH_Gen::GetAlgo(SMESH_subMesh * aSubMesh, + TopoDS_Shape* assignedTo) +{ + if ( !aSubMesh ) return 0; + + const TopoDS_Shape & aShape = aSubMesh->GetSubShape(); + SMESH_Mesh& aMesh = *aSubMesh->GetFather(); + SMESH_HypoFilter filter( SMESH_HypoFilter::IsAlgo() ); filter.And( filter.IsApplicableTo( aShape )); @@ -1024,7 +1039,7 @@ SMESH_Algo *SMESH_Gen::GetAlgo(SMESH_Mesh & aMesh, TopoDS_Shape assignedToShape; SMESH_Algo* algo = - (SMESH_Algo*) aMesh.GetHypothesis( aShape, filter, true, &assignedToShape ); + (SMESH_Algo*) aMesh.GetHypothesis( aSubMesh, filter, true, &assignedToShape ); if ( algo && aShape.ShapeType() == TopAbs_FACE && @@ -1039,7 +1054,7 @@ SMESH_Algo *SMESH_Gen::GetAlgo(SMESH_Mesh & aMesh, filter.AndNot( filter.Is( algo )); TopoDS_Shape assignedToShape2; SMESH_Algo* algo2 = - (SMESH_Algo*) aMesh.GetHypothesis( aShape, filter, true, &assignedToShape2 ); + (SMESH_Algo*) aMesh.GetHypothesis( aSubMesh, filter, true, &assignedToShape2 ); if ( algo2 && // algo found !assignedToShape2.IsSame( aMesh.GetShapeToMesh() ) && // algo is local ( SMESH_MesherHelper::GetGroupType( assignedToShape2 ) == // algo of the same level