X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH%2FSMESH_Gen.cxx;h=d98bb8fc1dbb8734b20e3451ce40ac179de155a7;hp=127f7cc2bbcda550428d653a7adfe7aaf0e01f83;hb=6d32f944a0a115b6419184c50b57bf7c4eef5786;hpb=5cdebf6f365e0a101f55825efd8cf007e2a97647 diff --git a/src/SMESH/SMESH_Gen.cxx b/src/SMESH/SMESH_Gen.cxx index 127f7cc2b..d98bb8fc1 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-2019 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 @@ -20,7 +20,7 @@ // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // -// SMESH SMESH : implementaion of SMESH idl descriptions +// SMESH SMESH : implementation of SMESH idl descriptions // File : SMESH_Gen.cxx // Author : Paul RASCLE, EDF // Module : SMESH @@ -35,6 +35,7 @@ #include "SMDS_MeshNode.hxx" #include "SMESHDS_Document.hxx" #include "SMESH_HypoFilter.hxx" +#include "SMESH_Mesh.hxx" #include "SMESH_MesherHelper.hxx" #include "SMESH_subMesh.hxx" @@ -47,14 +48,13 @@ #include "memoire.h" -#ifdef WNT +#ifdef WIN32 #include #endif -using namespace std; - -//#include +#include +using namespace std; //============================================================================= /*! @@ -64,16 +64,25 @@ using namespace std; SMESH_Gen::SMESH_Gen() { - MESSAGE("SMESH_Gen::SMESH_Gen"); + _studyContext = new StudyContextStruct; + _studyContext->myDocument = new SMESHDS_Document(); _localId = 0; _hypId = 0; _segmentation = _nbSegments = 10; - SMDS_Mesh::_meshList.clear(); - MESSAGE(SMDS_Mesh::_meshList.size()); - //_counters = new counters(100); _compute_canceled = false; - _sm_current = NULL; - //vtkDebugLeaks::SetExitError(0); +} + +namespace +{ + // a structure used to nullify SMESH_Gen field of SMESH_Hypothesis, + // which is needed for SMESH_Hypothesis not deleted before ~SMESH_Gen() + struct _Hyp : public SMESH_Hypothesis + { + void NullifyGen() + { + _gen = 0; + } + }; } //============================================================================= @@ -84,13 +93,14 @@ SMESH_Gen::SMESH_Gen() SMESH_Gen::~SMESH_Gen() { - MESSAGE("SMESH_Gen::~SMESH_Gen"); - std::map < int, StudyContextStruct * >::iterator i_sc = _mapStudyContext.begin(); - for ( ; i_sc != _mapStudyContext.end(); ++i_sc ) - { - delete i_sc->second->myDocument; - delete i_sc->second; - } + std::map < int, SMESH_Hypothesis * >::iterator i_hyp = _studyContext->mapHypothesis.begin(); + for ( ; i_hyp != _studyContext->mapHypothesis.end(); ++i_hyp ) + { + if ( _Hyp* h = static_cast< _Hyp*>( i_hyp->second )) + h->NullifyGen(); + } + delete _studyContext->myDocument; + delete _studyContext; } //============================================================================= @@ -100,22 +110,17 @@ SMESH_Gen::~SMESH_Gen() */ //============================================================================= -SMESH_Mesh* SMESH_Gen::CreateMesh(int theStudyId, bool theIsEmbeddedMode) +SMESH_Mesh* SMESH_Gen::CreateMesh(bool theIsEmbeddedMode) throw(SALOME_Exception) { Unexpect aCatch(SalomeException); - MESSAGE("SMESH_Gen::CreateMesh"); - - // Get studyContext, create it if it does'nt exist, with a SMESHDS_Document - StudyContextStruct *aStudyContext = GetStudyContext(theStudyId); // create a new SMESH_mesh object SMESH_Mesh *aMesh = new SMESH_Mesh(_localId++, - theStudyId, this, theIsEmbeddedMode, - aStudyContext->myDocument); - aStudyContext->mapMesh[_localId-1] = aMesh; + _studyContext->myDocument); + _studyContext->mapMesh[_localId-1] = aMesh; return aMesh; } @@ -128,14 +133,16 @@ SMESH_Mesh* SMESH_Gen::CreateMesh(int theStudyId, bool theIsEmbeddedMode) bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape, - const bool aShapeOnly /*=false*/, - const bool anUpward /*=false*/, + const int aFlags /*= COMPACT_MESH*/, const ::MeshDimension aDim /*=::MeshDim_3D*/, TSetOfInt* aShapesId /*=0*/) { - MESSAGE("SMESH_Gen::Compute"); MEMOSTAT; + const bool aShapeOnly = aFlags & SHAPE_ONLY; + const bool anUpward = aFlags & UPWARD; + const bool aCompactMesh = aFlags & COMPACT_MESH; + bool ret = true; SMESH_subMesh *sm = aMesh.GetSubMesh(aShape); @@ -147,10 +154,12 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, SMESH_subMeshIteratorPtr smIt; // Fix of Issue 22150. Due to !BLSURF->OnlyUnaryInput(), BLSURF computes edges - // that must be computed by Projection 1D-2D when Projection asks to compute + // that must be computed by Projection 1D-2D while the Projection asks to compute // one face only. SMESH_subMesh::compute_event computeEvent = aShapeOnly ? SMESH_subMesh::COMPUTE_SUBMESH : SMESH_subMesh::COMPUTE; + if ( !aMesh.HasShapeToMesh() ) + computeEvent = SMESH_subMesh::COMPUTE_NOGEOM; // if several algos and no geometry if ( anUpward ) // is called from the below code in this method { @@ -182,9 +191,9 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, { if (_compute_canceled) return false; - _sm_current = smToCompute; + setCurrentSubMesh( smToCompute ); smToCompute->ComputeStateEngine( computeEvent ); - _sm_current = NULL; + setCurrentSubMesh( NULL ); } // we check all the sub-meshes here and detect if any of them failed to compute @@ -232,7 +241,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() ) @@ -269,9 +278,9 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, { if (_compute_canceled) return false; - _sm_current = smToCompute; + setCurrentSubMesh( smToCompute ); smToCompute->ComputeStateEngine( computeEvent ); - _sm_current = NULL; + setCurrentSubMesh( NULL ); if ( aShapesId ) aShapesId->insert( smToCompute->GetId() ); } @@ -288,27 +297,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 @@ -331,22 +340,23 @@ 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 )) // mesh a lower smToCompute starting from vertices - Compute( aMesh, aSubShape, aShapeOnly, /*anUpward=*/true, aDim, aShapesId ); + Compute( aMesh, aSubShape, aFlags | SHAPE_ONLY_UPWARD, aDim, aShapesId ); + // Compute( aMesh, aSubShape, aShapeOnly, /*anUpward=*/true, aDim, aShapesId ); } } } // -------------------------------- // 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 shapeType = sm->GetSubShape().ShapeType(); @@ -356,9 +366,9 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, if (_compute_canceled) return false; - _sm_current = sm; + setCurrentSubMesh( sm ); sm->ComputeStateEngine( computeEvent ); - _sm_current = NULL; + setCurrentSubMesh( NULL ); if ( aShapesId ) aShapesId->insert( sm->GetId() ); } @@ -368,18 +378,14 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, // ----------------------------------------------- // mesh the rest sub-shapes starting from vertices // ----------------------------------------------- - ret = Compute( aMesh, aShape, aShapeOnly, /*anUpward=*/true, aDim, aShapesId ); + ret = Compute( aMesh, aShape, aFlags | UPWARD, aDim, aShapesId ); } - MESSAGE( "VSR - SMESH_Gen::Compute() finished, OK = " << ret); MEMOSTAT; - SMESHDS_Mesh *myMesh = aMesh.GetMeshDS(); - MESSAGE("*** compactMesh after compute"); - myMesh->compactMesh(); - // fix quadratic mesh by bending iternal links near concave boundary - if ( aShape.IsSame( aMesh.GetShapeToMesh() ) && + if ( aCompactMesh && // a final compute + aShape.IsSame( aMesh.GetShapeToMesh() ) && !aShapesId && // not preview ret ) // everything is OK { @@ -389,11 +395,15 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh, aHelper.FixQuadraticElements( sm->GetComputeError() ); } } + + if ( aCompactMesh ) + { + aMesh.GetMeshDS()->Modified(); + aMesh.GetMeshDS()->CompactMesh(); + } return ret; } - -#ifdef WITH_SMESH_CANCEL_COMPUTE //============================================================================= /*! * Prepare Compute a mesh @@ -403,8 +413,9 @@ void SMESH_Gen::PrepareCompute(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape) { _compute_canceled = false; - _sm_current = NULL; + resetCurrentSubMesh(); } + //============================================================================= /*! * Cancel Compute a mesh @@ -414,12 +425,45 @@ void SMESH_Gen::CancelCompute(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape) { _compute_canceled = true; - if(_sm_current) - { - _sm_current->ComputeStateEngine( SMESH_subMesh::COMPUTE_CANCELED ); - } + if ( const SMESH_subMesh* sm = GetCurrentSubMesh() ) + { + const_cast< SMESH_subMesh* >( sm )->ComputeStateEngine( SMESH_subMesh::COMPUTE_CANCELED ); + } + resetCurrentSubMesh(); +} + +//================================================================================ +/*! + * \brief Returns a sub-mesh being currently computed + */ +//================================================================================ + +const SMESH_subMesh* SMESH_Gen::GetCurrentSubMesh() const +{ + return _sm_current.empty() ? 0 : _sm_current.back(); +} + +//================================================================================ +/*! + * \brief Sets a sub-mesh being currently computed. + * + * An algorithm can call Compute() for a sub-shape, hence we keep a stack of sub-meshes + */ +//================================================================================ + +void SMESH_Gen::setCurrentSubMesh(SMESH_subMesh* sm) +{ + if ( sm ) + _sm_current.push_back( sm ); + + else if ( !_sm_current.empty() ) + _sm_current.pop_back(); +} + +void SMESH_Gen::resetCurrentSubMesh() +{ + _sm_current.clear(); } -#endif //============================================================================= /*! @@ -433,8 +477,6 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh & aMesh, const bool anUpward, TSetOfInt* aShapesId) { - MESSAGE("SMESH_Gen::Evaluate"); - bool ret = true; SMESH_subMesh *sm = aMesh.GetSubMesh(aShape); @@ -481,7 +523,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 ); @@ -497,22 +539,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 @@ -529,7 +571,8 @@ bool SMESH_Gen::Evaluate(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 )) @@ -541,9 +584,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() ); @@ -555,7 +598,6 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh & aMesh, ret = Evaluate( aMesh, aShape, aResMap, /*anUpward=*/true, aShapesId ); } - MESSAGE( "VSR - SMESH_Gen::Evaluate() finished, OK = " << ret); return ret; } @@ -625,7 +667,7 @@ static bool checkConformIgnoredAlgos(SMESH_Mesh& aMesh, checkConform = false; // no more check conformity INFOS( "ERROR: Local <" << algo->GetName() << "> would produce not conform mesh: " - " hypotesis is missing"); + " hypothesis is missing"); theErrors.push_back( SMESH_Gen::TAlgoStateError() ); theErrors.back().Set( SMESH_Hypothesis::HYP_NOTCONFORM, algo, false ); } @@ -676,8 +718,6 @@ static bool checkMissing(SMESH_Gen* aGen, if ( aCheckedMap.count( aSubMesh )) return true; - //MESSAGE("=====checkMissing"); - int ret = true; SMESH_Algo* algo = 0; @@ -798,8 +838,6 @@ bool SMESH_Gen::GetAlgoState(SMESH_Mesh& theMesh, const TopoDS_Shape& theShape, list< TAlgoStateError > & theErrors) { - //MESSAGE("SMESH_Gen::CheckAlgoState"); - bool ret = true; bool hasAlgo = false; @@ -877,8 +915,6 @@ bool SMESH_Gen::GetAlgoState(SMESH_Mesh& theMesh, // well defined // ---------------------------------------------------------------- - //MESSAGE( "---info on missing hypothesis and find out if all needed algos are"); - // find max dim of global algo int aTopAlgoDim = 0; for (dim = 3; dim > 0; dim--) @@ -913,7 +949,7 @@ bool SMESH_Gen::GetAlgoState(SMESH_Mesh& theMesh, if ( !hasAlgo ) { ret = false; theErrors.push_back( TAlgoStateError() ); - theErrors.back().Set( SMESH_Hypothesis::HYP_MISSING, 1, true ); + theErrors.back().Set( SMESH_Hypothesis::HYP_MISSING, theMesh.HasShapeToMesh() ? 1 : 3, true ); } return ret; @@ -979,7 +1015,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,8 +1030,16 @@ std::vector< std::string > SMESH_Gen::GetPluginXMLPaths() xmlPath += tolower( pluginSubDir[pos] ); xmlPath += sep + plugin + ".xml"; bool fileOK; -#ifdef WNT - fileOK = (GetFileAttributes(xmlPath.c_str()) != INVALID_FILE_ATTRIBUTES); +#ifdef WIN32 +#ifdef UNICODE + const wchar_t* path = Kernel_Utils::decode_s(xmlPath); +#else + const char* path = xmlPath.c_str(); +#endif + fileOK = (GetFileAttributes(path) != INVALID_FILE_ATTRIBUTES); +#ifdef UNICODE + delete path; +#endif #else fileOK = (access(xmlPath.c_str(), F_OK) == 0); #endif @@ -1017,14 +1061,32 @@ 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 )); + if ( aMesh.HasShapeToMesh() ) + filter.And( filter.IsApplicableTo( aShape )); typedef SMESH_Algo::Features AlgoData; 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 +1101,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 @@ -1087,17 +1149,9 @@ SMESH_Algo *SMESH_Gen::GetAlgo(SMESH_Mesh & aMesh, */ //============================================================================= -StudyContextStruct *SMESH_Gen::GetStudyContext(int studyId) +StudyContextStruct *SMESH_Gen::GetStudyContext() { - // Get studyContext, create it if it does'nt exist, with a SMESHDS_Document - - if (_mapStudyContext.find(studyId) == _mapStudyContext.end()) - { - _mapStudyContext[studyId] = new StudyContextStruct; - _mapStudyContext[studyId]->myDocument = new SMESHDS_Document(studyId); - } - StudyContextStruct *myStudyContext = _mapStudyContext[studyId]; - return myStudyContext; + return _studyContext; } //================================================================================ @@ -1126,7 +1180,7 @@ int SMESH_Gen::GetShapeDim(const TopAbs_ShapeEnum & aShapeType) //============================================================================= /*! - * Genarate a new id unique withing this Gen + * Generate a new id unique within this Gen */ //=============================================================================