X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FStdMeshers%2FStdMeshers_RadialQuadrangle_1D2D.cxx;h=d93c64eb6638af49c6231f6d124e0ffe0e9e89eb;hb=d4a710ce52f6e76786a7b3845e2f7975dc9a00b1;hp=8d21195dbcebf9f0e134f2647215287fa16d7089;hpb=2daa321efae3d0c6ce41199fa5a2482630d505d9;p=modules%2Fsmesh.git diff --git a/src/StdMeshers/StdMeshers_RadialQuadrangle_1D2D.cxx b/src/StdMeshers/StdMeshers_RadialQuadrangle_1D2D.cxx index 8d21195db..d93c64eb6 100644 --- a/src/StdMeshers/StdMeshers_RadialQuadrangle_1D2D.cxx +++ b/src/StdMeshers/StdMeshers_RadialQuadrangle_1D2D.cxx @@ -1,41 +1,39 @@ -// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE +// Copyright (C) 2007-2012 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 +// 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. // -// 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. +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. // -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -// Lesser General Public License for more details. +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // -// You should have received a copy of the GNU Lesser General Public -// License along with this library; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -// -// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // + // SMESH SMESH : implementaion of SMESH idl descriptions // File : StdMeshers_RadialQuadrangle_1D2D.cxx // Module : SMESH // Created : Fri Oct 20 11:37:07 2006 // Author : Edward AGAPOV (eap) -// + #include "StdMeshers_RadialQuadrangle_1D2D.hxx" -//#include "StdMeshers_ProjectionUtils.hxx" #include "StdMeshers_NumberOfLayers.hxx" #include "StdMeshers_LayerDistribution.hxx" -//#include "StdMeshers_Prism_3D.hxx" #include "StdMeshers_Regular_1D.hxx" +#include "StdMeshers_NumberOfSegments.hxx" #include "SMDS_MeshNode.hxx" #include "SMESHDS_SubMesh.hxx" #include "SMESH_Gen.hxx" +#include "SMESH_HypoFilter.hxx" #include "SMESH_Mesh.hxx" #include "SMESH_MesherHelper.hxx" #include "SMESH_subMesh.hxx" @@ -52,7 +50,9 @@ #include #include #include +#include #include +#include #include @@ -61,8 +61,6 @@ using namespace std; #define RETURN_BAD_RESULT(msg) { MESSAGE(")-: Error: " << msg); return false; } #define gpXYZ(n) gp_XYZ(n->X(),n->Y(),n->Z()) -//typedef StdMeshers_ProjectionUtils TAssocTool; - //======================================================================= //function : StdMeshers_RadialQuadrangle_1D2D @@ -81,7 +79,8 @@ StdMeshers_RadialQuadrangle_1D2D::StdMeshers_RadialQuadrangle_1D2D(int hypId, _compatibleHypothesis.push_back("NumberOfLayers2D"); myNbLayerHypo = 0; myDistributionHypo = 0; - _requireDescretBoundary = false; + _requireDiscreteBoundary = false; + _supportSubmeshes = true; } @@ -113,8 +112,8 @@ bool StdMeshers_RadialQuadrangle_1D2D::CheckHypothesis const list &hyps = GetUsedHypothesis(aMesh, aShape); if ( hyps.size() == 0 ) { - aStatus = SMESH_Hypothesis::HYP_MISSING; - return false; // can't work with no hypothesis + aStatus = SMESH_Hypothesis::HYP_OK; + return true; // can work with no hypothesis } if ( hyps.size() > 1 ) { @@ -146,27 +145,43 @@ namespace /*! * \brief Listener used to mark edges meshed by StdMeshers_RadialQuadrangle_1D2D */ - class TLinEdgeMarker : public SMESH_subMeshEventListener + class TEdgeMarker : public SMESH_subMeshEventListener { - TLinEdgeMarker(): SMESH_subMeshEventListener(/*isDeletable=*/false) {} + TEdgeMarker(): SMESH_subMeshEventListener(/*isDeletable=*/false, + "StdMeshers_RadialQuadrangle_1D2D::TEdgeMarker") {} public: + //!< Return static listener static SMESH_subMeshEventListener* getListener() { - static TLinEdgeMarker theEdgeMarker; + static TEdgeMarker theEdgeMarker; return &theEdgeMarker; } + //! Clear face sumbesh if something happens on edges + void ProcessEvent(const int event, + const int eventType, + SMESH_subMesh* edgeSubMesh, + EventListenerData* data, + const SMESH_Hypothesis* /*hyp*/) + { + if ( data && !data->mySubMeshes.empty() && eventType == SMESH_subMesh::ALGO_EVENT) + { + ASSERT( data->mySubMeshes.front() != edgeSubMesh ); + SMESH_subMesh* faceSubMesh = data->mySubMeshes.front(); + faceSubMesh->ComputeStateEngine( SMESH_subMesh::CLEAN ); + } + } }; - + // ------------------------------------------------------------------------------ /*! * \brief Mark an edge as computed by StdMeshers_RadialQuadrangle_1D2D */ - void markLinEdgeAsComputedByMe(const TopoDS_Edge& edge, SMESH_subMesh* faceSubMesh) + void markEdgeAsComputedByMe(const TopoDS_Edge& edge, SMESH_subMesh* faceSubMesh) { if ( SMESH_subMesh* edgeSM = faceSubMesh->GetFather()->GetSubMeshContaining( edge )) { - if ( !edgeSM->GetEventListenerData( TLinEdgeMarker::getListener() )) - faceSubMesh->SetEventListener( TLinEdgeMarker::getListener(), + if ( !edgeSM->GetEventListenerData( TEdgeMarker::getListener() )) + faceSubMesh->SetEventListener( TEdgeMarker::getListener(), SMESH_subMeshEventListenerData::MakeData(faceSubMesh), edgeSM); } @@ -176,38 +191,30 @@ namespace * \brief Return true if a radial edge was meshed with StdMeshers_RadialQuadrangle_1D2D with * the same radial distribution */ - bool isEdgeCompitaballyMeshed(const TopoDS_Edge& edge, SMESH_subMesh* faceSubMesh) - { - if ( SMESH_subMesh* edgeSM = faceSubMesh->GetFather()->GetSubMeshContaining( edge )) - { - if ( SMESH_subMeshEventListenerData* otherFaceData = - edgeSM->GetEventListenerData( TLinEdgeMarker::getListener() )) - { - // compare hypothesis aplied to two disk faces sharing radial edges - SMESH_Mesh& mesh = *faceSubMesh->GetFather(); - SMESH_Algo* radialQuadAlgo = mesh.GetGen()->GetAlgo(mesh, faceSubMesh->GetSubShape() ); - SMESH_subMesh* otherFaceSubMesh = otherFaceData->mySubMeshes.front(); - const list & hyps1 = - radialQuadAlgo->GetUsedHypothesis( mesh, faceSubMesh->GetSubShape()); - const list & hyps2 = - radialQuadAlgo->GetUsedHypothesis( mesh, otherFaceSubMesh->GetSubShape()); - if( hyps1.empty() && hyps2.empty() ) - return true; // defaul hyps - if ( hyps1.size() != hyps2.size() || - strcmp( hyps1.front()->GetName(), hyps2.front()->GetName() )) - return false; - ostringstream hypDump1, hypDump2; - list ::const_iterator hyp1 = hyps1.begin(); - for ( ; hyp1 != hyps1.end(); ++hyp1 ) - const_cast(*hyp1)->SaveTo( hypDump1 ); - list ::const_iterator hyp2 = hyps2.begin(); - for ( ; hyp2 != hyps2.end(); ++hyp2 ) - const_cast(*hyp2)->SaveTo( hypDump2 ); - return hypDump1.str() == hypDump2.str(); - } - } - return false; - } +// bool isEdgeCompatiballyMeshed(const TopoDS_Edge& edge, SMESH_subMesh* faceSubMesh) +// { +// if ( SMESH_subMesh* edgeSM = faceSubMesh->GetFather()->GetSubMeshContaining( edge )) +// { +// if ( SMESH_subMeshEventListenerData* otherFaceData = +// edgeSM->GetEventListenerData( TEdgeMarker::getListener() )) +// { +// // compare hypothesis aplied to two disk faces sharing radial edges +// SMESH_Mesh& mesh = *faceSubMesh->GetFather(); +// SMESH_Algo* radialQuadAlgo = mesh.GetGen()->GetAlgo(mesh, faceSubMesh->GetSubShape() ); +// SMESH_subMesh* otherFaceSubMesh = otherFaceData->mySubMeshes.front(); +// list hyps1 = +// radialQuadAlgo->GetUsedHypothesis( mesh, faceSubMesh->GetSubShape()); +// list hyps2 = +// radialQuadAlgo->GetUsedHypothesis( mesh, otherFaceSubMesh->GetSubShape()); +// if( hyps1.empty() && hyps2.empty() ) +// return true; // defaul hyps +// if ( hyps1.size() != hyps2.size() ) +// return false; +// return *hyps1.front() == *hyps2.front(); +// } +// } +// return false; +// } //================================================================================ /*! @@ -273,6 +280,123 @@ namespace } return nbe; } + +//================================================================================ +//================================================================================ +/*! + * \brief Class computing layers distribution using data of + * StdMeshers_LayerDistribution hypothesis + */ +//================================================================================ +//================================================================================ + +class TNodeDistributor: public StdMeshers_Regular_1D +{ + list myUsedHyps; +public: + // ----------------------------------------------------------------------------- + static TNodeDistributor* GetDistributor(SMESH_Mesh& aMesh) + { + const int myID = -1000; + map < int, SMESH_1D_Algo * > & algoMap = aMesh.GetGen()->_map1D_Algo; + map < int, SMESH_1D_Algo * >::iterator id_algo = algoMap.find( myID ); + if ( id_algo == algoMap.end() ) + return new TNodeDistributor( myID, 0, aMesh.GetGen() ); + return static_cast< TNodeDistributor* >( id_algo->second ); + } + // ----------------------------------------------------------------------------- + //! Computes distribution of nodes on a straight line ending at pIn and pOut + bool Compute( vector< double > & positions, + gp_Pnt pIn, + gp_Pnt pOut, + SMESH_Mesh& aMesh, + const SMESH_Hypothesis* hyp1d) + { + if ( !hyp1d ) return error( "Invalid LayerDistribution hypothesis"); + + double len = pIn.Distance( pOut ); + if ( len <= DBL_MIN ) return error("Too close points of inner and outer shells"); + + myUsedHyps.clear(); + myUsedHyps.push_back( hyp1d ); + + TopoDS_Edge edge = BRepBuilderAPI_MakeEdge( pIn, pOut ); + SMESH_Hypothesis::Hypothesis_Status aStatus; + if ( !StdMeshers_Regular_1D::CheckHypothesis( aMesh, edge, aStatus )) + return error( "StdMeshers_Regular_1D::CheckHypothesis() failed " + "with LayerDistribution hypothesis"); + + BRepAdaptor_Curve C3D(edge); + double f = C3D.FirstParameter(), l = C3D.LastParameter(); + list< double > params; + if ( !StdMeshers_Regular_1D::computeInternalParameters( aMesh, C3D, len, f, l, params, false )) + return error("StdMeshers_Regular_1D failed to compute layers distribution"); + + positions.clear(); + positions.reserve( params.size() ); + for (list::iterator itU = params.begin(); itU != params.end(); itU++) + positions.push_back( *itU / len ); + return true; + } + // ----------------------------------------------------------------------------- + //! Make mesh on an adge using assigned 1d hyp or defaut nb of segments + bool ComputeCircularEdge(SMESH_Mesh& aMesh, + const TopoDS_Edge& anEdge) + { + _gen->Compute( aMesh, anEdge); + SMESH_subMesh *sm = aMesh.GetSubMesh(anEdge); + if ( sm->GetComputeState() != SMESH_subMesh::COMPUTE_OK) + { + // find any 1d hyp assigned (there can be a hyp w/o algo) + myUsedHyps = SMESH_Algo::GetUsedHypothesis(aMesh, anEdge, /*ignoreAux=*/true); + Hypothesis_Status aStatus; + if ( !StdMeshers_Regular_1D::CheckHypothesis( aMesh, anEdge, aStatus )) + { + // no valid 1d hyp assigned, use default nb of segments + _hypType = NB_SEGMENTS; + _ivalue[ DISTR_TYPE_IND ] = StdMeshers_NumberOfSegments::DT_Regular; + _ivalue[ NB_SEGMENTS_IND ] = _gen->GetDefaultNbSegments(); + } + return StdMeshers_Regular_1D::Compute( aMesh, anEdge ); + } + return true; + } + // ----------------------------------------------------------------------------- + //! Make mesh on an adge using assigned 1d hyp or defaut nb of segments + bool EvaluateCircularEdge(SMESH_Mesh& aMesh, + const TopoDS_Edge& anEdge, + MapShapeNbElems& aResMap) + { + _gen->Evaluate( aMesh, anEdge, aResMap ); + if ( aResMap.count( aMesh.GetSubMesh( anEdge ))) + return true; + + // find any 1d hyp assigned + myUsedHyps = SMESH_Algo::GetUsedHypothesis(aMesh, anEdge, /*ignoreAux=*/true); + Hypothesis_Status aStatus; + if ( !StdMeshers_Regular_1D::CheckHypothesis( aMesh, anEdge, aStatus )) + { + // no valid 1d hyp assigned, use default nb of segments + _hypType = NB_SEGMENTS; + _ivalue[ DISTR_TYPE_IND ] = StdMeshers_NumberOfSegments::DT_Regular; + _ivalue[ NB_SEGMENTS_IND ] = _gen->GetDefaultNbSegments(); + } + return StdMeshers_Regular_1D::Evaluate( aMesh, anEdge, aResMap ); + } +protected: + // ----------------------------------------------------------------------------- + TNodeDistributor( int hypId, int studyId, SMESH_Gen* gen) + : StdMeshers_Regular_1D( hypId, studyId, gen) + { + } + // ----------------------------------------------------------------------------- + virtual const list & + GetUsedHypothesis(SMESH_Mesh &, const TopoDS_Shape &, const bool) + { + return myUsedHyps; + } + // ----------------------------------------------------------------------------- +}; } //======================================================================= @@ -280,7 +404,7 @@ namespace * \brief Allow algo to do something after persistent restoration * \param subMesh - restored submesh * - * call markLinEdgeAsComputedByMe() + * call markEdgeAsComputedByMe() */ //======================================================================= @@ -290,8 +414,9 @@ void StdMeshers_RadialQuadrangle_1D2D::SubmeshRestored(SMESH_subMesh* faceSubMes { TopoDS_Edge CircEdge, LinEdge1, LinEdge2; analyseFace( faceSubMesh->GetSubShape(), CircEdge, LinEdge1, LinEdge2 ); - if ( !LinEdge1.IsNull() ) markLinEdgeAsComputedByMe( LinEdge1, faceSubMesh ); - if ( !LinEdge2.IsNull() ) markLinEdgeAsComputedByMe( LinEdge2, faceSubMesh ); + if ( !CircEdge.IsNull() ) markEdgeAsComputedByMe( CircEdge, faceSubMesh ); + if ( !LinEdge1.IsNull() ) markEdgeAsComputedByMe( LinEdge1, faceSubMesh ); + if ( !LinEdge2.IsNull() ) markEdgeAsComputedByMe( LinEdge2, faceSubMesh ); } } @@ -303,7 +428,6 @@ void StdMeshers_RadialQuadrangle_1D2D::SubmeshRestored(SMESH_subMesh* faceSubMes bool StdMeshers_RadialQuadrangle_1D2D::Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape) { - TopExp_Explorer exp; SMESHDS_Mesh * meshDS = aMesh.GetMeshDS(); myHelper = new SMESH_MesherHelper( aMesh ); @@ -311,14 +435,15 @@ bool StdMeshers_RadialQuadrangle_1D2D::Compute(SMESH_Mesh& aMesh, // to delete helper at exit from Compute() auto_ptr helperDeleter( myHelper ); - myLayerPositions.clear(); + TNodeDistributor* algo1d = TNodeDistributor::GetDistributor(aMesh); TopoDS_Edge CircEdge, LinEdge1, LinEdge2; int nbe = analyseFace( aShape, CircEdge, LinEdge1, LinEdge2 ); - if( nbe>3 || nbe < 1 || CircEdge.IsNull() ) - return error(COMPERR_BAD_SHAPE); + Handle(Geom_Circle) aCirc = Handle(Geom_Circle)::DownCast( getCurve( CircEdge )); + if( nbe>3 || nbe < 1 || aCirc.IsNull() ) + return error("The face must be a full circle or a part of circle (i.e. the number of edges is less or equal to 3 and one of them is a circle curve)"); - gp_Pnt P0,P1; + gp_Pnt P0, P1; // points for rotation TColgp_SequenceOfPnt Points; // angles for rotation @@ -335,15 +460,14 @@ bool StdMeshers_RadialQuadrangle_1D2D::Compute(SMESH_Mesh& aMesh, TopoDS_Face F = TopoDS::Face(aShape); Handle(Geom_Surface) S = BRep_Tool::Surface(F); + if(nbe==1) { - Handle(Geom_Circle) aCirc = Handle(Geom_Circle)::DownCast( getCurve( CircEdge )); - - bool ok = _gen->Compute( aMesh, CircEdge ); - if( !ok ) return false; + if (!algo1d->ComputeCircularEdge( aMesh, CircEdge )) + return error( algo1d->GetComputeError() ); map< double, const SMDS_MeshNode* > theNodes; - ok = GetSortedNodesOnEdge(aMesh.GetMeshDS(),CircEdge,true,theNodes); - if( !ok ) return false; + if ( !GetSortedNodesOnEdge(aMesh.GetMeshDS(),CircEdge,true,theNodes)) + return error("Circular edge is incorrectly meshed"); CNodes.clear(); map< double, const SMDS_MeshNode* >::iterator itn = theNodes.begin(); @@ -355,19 +479,18 @@ bool StdMeshers_RadialQuadrangle_1D2D::Compute(SMESH_Mesh& aMesh, for(; itn != theNodes.end(); itn++ ) { CNodes.push_back( (*itn).second ); double ang = (*itn).first - fang; - if( ang>PI ) ang = ang - 2*PI; - if( ang<-PI ) ang = ang + 2*PI; + if( ang>M_PI ) ang = ang - 2.*M_PI; + if( ang<-M_PI ) ang = ang + 2.*M_PI; Angles.Append( ang ); } } P1 = gp_Pnt( NF->X(), NF->Y(), NF->Z() ); P0 = aCirc->Location(); - myLayerPositions.clear(); - computeLayerPositions(P0,P1); + if ( !computeLayerPositions(P0,P1)) + return false; - exp.Init( CircEdge, TopAbs_VERTEX ); - TopoDS_Vertex V1 = TopoDS::Vertex( exp.Current() ); + TopoDS_Vertex V1 = myHelper->IthVertex(0, CircEdge ); gp_Pnt2d p2dV = BRep_Tool::Parameters( V1, TopoDS::Face(aShape) ); NC = meshDS->AddNode(P0.X(), P0.Y(), P0.Z()); @@ -404,7 +527,7 @@ bool StdMeshers_RadialQuadrangle_1D2D::Compute(SMESH_Mesh& aMesh, // a segment of line double fp, lp; Handle(Geom_Circle) aCirc = Handle(Geom_Circle)::DownCast( getCurve( CircEdge, &fp, &lp )); - if( fabs(fabs(lp-fp)-PI) > Precision::Confusion() ) { + if( fabs(fabs(lp-fp)-M_PI) > Precision::Confusion() ) { // not half of circle return error(COMPERR_BAD_SHAPE); } @@ -413,46 +536,42 @@ bool StdMeshers_RadialQuadrangle_1D2D::Compute(SMESH_Mesh& aMesh, // other curve not line return error(COMPERR_BAD_SHAPE); } - bool linEdgeComputed = false; - if( SMESH_subMesh* sm1 = aMesh.GetSubMesh(LinEdge1) ) { - if( !sm1->IsEmpty() ) - if( isEdgeCompitaballyMeshed( LinEdge1, aMesh.GetSubMesh(F) )) - linEdgeComputed = true; - else - return error("Invalid set of hypotheses"); - } - bool ok = _gen->Compute( aMesh, CircEdge ); - if( !ok ) return false; + if ( !algo1d->ComputeCircularEdge( aMesh, CircEdge )) + return error( algo1d->GetComputeError() ); map< double, const SMDS_MeshNode* > theNodes; - GetSortedNodesOnEdge(aMesh.GetMeshDS(),CircEdge,true,theNodes); + if ( !GetSortedNodesOnEdge(aMesh.GetMeshDS(),CircEdge,true,theNodes) ) + return error("Circular edge is incorrectly meshed"); - CNodes.clear(); map< double, const SMDS_MeshNode* >::iterator itn = theNodes.begin(); + CNodes.clear(); + CNodes.push_back( itn->second ); double fang = (*itn).first; itn++; for(; itn != theNodes.end(); itn++ ) { CNodes.push_back( (*itn).second ); double ang = (*itn).first - fang; - if( ang>PI ) ang = ang - 2*PI; - if( ang<-PI ) ang = ang + 2*PI; + if( ang>M_PI ) ang = ang - 2.*M_PI; + if( ang<-M_PI ) ang = ang + 2.*M_PI; Angles.Append( ang ); } const SMDS_MeshNode* NF = theNodes.begin()->second; const SMDS_MeshNode* NL = theNodes.rbegin()->second; - CNodes.push_back( NF ); P1 = gp_Pnt( NF->X(), NF->Y(), NF->Z() ); gp_Pnt P2( NL->X(), NL->Y(), NL->Z() ); P0 = aCirc->Location(); - myLayerPositions.clear(); - computeLayerPositions(P0,P1); + bool linEdgeComputed; + if ( !computeLayerPositions(P0,P1,LinEdge1,&linEdgeComputed)) + return false; if ( linEdgeComputed ) { if (!GetSortedNodesOnEdge(aMesh.GetMeshDS(),LinEdge1,true,theNodes)) return error("Invalid mesh on a straight edge"); + Nodes1.resize( myLayerPositions.size()+1 ); + Nodes2.resize( myLayerPositions.size()+1 ); vector< const SMDS_MeshNode* > *pNodes1 = &Nodes1, *pNodes2 = &Nodes2; bool nodesFromP0ToP1 = ( theNodes.rbegin()->second == NF ); if ( !nodesFromP0ToP1 ) std::swap( pNodes1, pNodes2 ); @@ -463,8 +582,8 @@ bool StdMeshers_RadialQuadrangle_1D2D::Compute(SMESH_Mesh& aMesh, { (*pNodes1)[i] = ritn->second; (*pNodes2)[i] = itn->second; - Points.Append( gpXYZ( Nodes1[i])); - Pnts2d1.Append( myHelper->GetNodeUV( F, Nodes1[i])); + Points.Prepend( gpXYZ( Nodes1[i])); + Pnts2d1.Prepend( myHelper->GetNodeUV( F, Nodes1[i])); } NC = const_cast( itn->second ); Points.Remove( Nodes1.size() ); @@ -537,7 +656,7 @@ bool StdMeshers_RadialQuadrangle_1D2D::Compute(SMESH_Mesh& aMesh, SMDS_MeshEdge* ME = myHelper->AddEdge( tmpNodes[i-1], tmpNodes[i] ); if(ME) meshDS->SetMeshElementOnShape(ME, edgeID); } - markLinEdgeAsComputedByMe( LinEdge1, aMesh.GetSubMesh( F )); + markEdgeAsComputedByMe( LinEdge1, aMesh.GetSubMesh( F )); } } else // nbe==3 or ( nbe==2 && linEdge is INTERNAL ) @@ -549,33 +668,16 @@ bool StdMeshers_RadialQuadrangle_1D2D::Compute(SMESH_Mesh& aMesh, // segments of line double fp, lp; Handle(Geom_Circle) aCirc = Handle(Geom_Circle)::DownCast( getCurve( CircEdge )); - Handle(Geom_Line) aLine1 = Handle(Geom_Line)::DownCast( getCurve( LinEdge1 )); - Handle(Geom_Line) aLine2 = Handle(Geom_Line)::DownCast( getCurve( LinEdge2 )); - if( aLine1.IsNull() || aLine2.IsNull() ) { - // other curve not line + Handle(Geom_Line) aLine1 = Handle(Geom_Line)::DownCast( getCurve( LinEdge1 )); + Handle(Geom_Line) aLine2 = Handle(Geom_Line)::DownCast( getCurve( LinEdge2 )); + if( aCirc.IsNull() || aLine1.IsNull() || aLine2.IsNull() ) return error(COMPERR_BAD_SHAPE); - } - - bool linEdge1Computed = false; - if ( SMESH_subMesh* sm1 = aMesh.GetSubMesh(LinEdge1)) - if( !sm1->IsEmpty() ) - if( isEdgeCompitaballyMeshed( LinEdge1, aMesh.GetSubMesh(F) )) - linEdge1Computed = true; - else - return error("Invalid set of hypotheses"); - - bool linEdge2Computed = false; - if ( SMESH_subMesh* sm2 = aMesh.GetSubMesh(LinEdge2)) - if( !sm2->IsEmpty() ) - if( isEdgeCompitaballyMeshed( LinEdge2, aMesh.GetSubMesh(F) )) - linEdge2Computed = true; - else - return error("Invalid set of hypotheses"); - bool ok = _gen->Compute( aMesh, CircEdge ); - if( !ok ) return false; + if ( !algo1d->ComputeCircularEdge( aMesh, CircEdge )) + return error( algo1d->GetComputeError() ); map< double, const SMDS_MeshNode* > theNodes; - GetSortedNodesOnEdge(aMesh.GetMeshDS(),CircEdge,true,theNodes); + if ( !GetSortedNodesOnEdge(aMesh.GetMeshDS(),CircEdge,true,theNodes)) + return error("Circular edge is incorrectly meshed"); const SMDS_MeshNode* NF = theNodes.begin()->second; const SMDS_MeshNode* NL = theNodes.rbegin()->second; @@ -587,32 +689,37 @@ bool StdMeshers_RadialQuadrangle_1D2D::Compute(SMESH_Mesh& aMesh, for(; itn != theNodes.end(); itn++ ) { CNodes.push_back( (*itn).second ); double ang = (*itn).first - fang; - if( ang>PI ) ang = ang - 2*PI; - if( ang<-PI ) ang = ang + 2*PI; + if( ang>M_PI ) ang = ang - 2.*M_PI; + if( ang<-M_PI ) ang = ang + 2.*M_PI; Angles.Append( ang ); } P1 = gp_Pnt( NF->X(), NF->Y(), NF->Z() ); gp_Pnt P2( NL->X(), NL->Y(), NL->Z() ); P0 = aCirc->Location(); - myLayerPositions.clear(); - computeLayerPositions(P0,P1); - - Nodes1.resize( myLayerPositions.size()+1 ); - Nodes2.resize( myLayerPositions.size()+1 ); - - exp.Init( LinEdge1, TopAbs_VERTEX ); - TopoDS_Vertex V1 = TopoDS::Vertex( exp.Current() ); - exp.Next(); - TopoDS_Vertex V2 = TopoDS::Vertex( exp.Current() ); + // make P1 belong to LinEdge1 + TopoDS_Vertex V1 = myHelper->IthVertex( 0, LinEdge1 ); + TopoDS_Vertex V2 = myHelper->IthVertex( 1, LinEdge1 ); gp_Pnt PE1 = BRep_Tool::Pnt(V1); gp_Pnt PE2 = BRep_Tool::Pnt(V2); if( ( P1.Distance(PE1) > Precision::Confusion() ) && ( P1.Distance(PE2) > Precision::Confusion() ) ) - { std::swap( LinEdge1, LinEdge2 ); - std::swap( linEdge1Computed, linEdge2Computed ); - } + + bool linEdge1Computed, linEdge2Computed; + if ( !computeLayerPositions(P0,P1,LinEdge1,&linEdge1Computed)) + return false; + + Nodes1.resize( myLayerPositions.size()+1 ); + Nodes2.resize( myLayerPositions.size()+1 ); + + // check that both linear edges have same hypotheses + if ( !computeLayerPositions(P0,P2,LinEdge2, &linEdge2Computed)) + return false; + if ( Nodes1.size() != myLayerPositions.size()+1 ) + return error("Different hypotheses apply to radial edges"); + + // find the central vertex TopoDS_Vertex VC = V2; if( ( P1.Distance(PE1) > Precision::Confusion() ) && ( P2.Distance(PE1) > Precision::Confusion() ) ) @@ -701,7 +808,7 @@ bool StdMeshers_RadialQuadrangle_1D2D::Compute(SMESH_Mesh& aMesh, if (nbe==2 && LinEdge1.Orientation() == TopAbs_INTERNAL ) Nodes2 = Nodes1; } - markLinEdgeAsComputedByMe( LinEdge1, aMesh.GetSubMesh( F )); + markEdgeAsComputedByMe( LinEdge1, aMesh.GetSubMesh( F )); // LinEdge2 if ( linEdge2Computed ) @@ -765,8 +872,9 @@ bool StdMeshers_RadialQuadrangle_1D2D::Compute(SMESH_Mesh& aMesh, if(ME) meshDS->SetMeshElementOnShape(ME, edgeID); } } - markLinEdgeAsComputedByMe( LinEdge2, aMesh.GetSubMesh( F )); + markEdgeAsComputedByMe( LinEdge2, aMesh.GetSubMesh( F )); } + markEdgeAsComputedByMe( CircEdge, aMesh.GetSubMesh( F )); // orientation bool IsForward = ( CircEdge.Orientation()==TopAbs_FORWARD ); @@ -850,106 +958,122 @@ bool StdMeshers_RadialQuadrangle_1D2D::Compute(SMESH_Mesh& aMesh, return true; } - -//================================================================================ //================================================================================ /*! - * \brief Class computing layers distribution using data of - * StdMeshers_LayerDistribution hypothesis + * \brief Compute positions of nodes on the radial edge + * \retval bool - is a success */ //================================================================================ -//================================================================================ -class TNodeDistributor: public StdMeshers_Regular_1D +bool StdMeshers_RadialQuadrangle_1D2D::computeLayerPositions(const gp_Pnt& p1, + const gp_Pnt& p2, + const TopoDS_Edge& linEdge, + bool* linEdgeComputed) { - list myUsedHyps; -public: - // ----------------------------------------------------------------------------- - static TNodeDistributor* GetDistributor(SMESH_Mesh& aMesh) - { - const int myID = -1000; - map < int, SMESH_1D_Algo * > & algoMap = aMesh.GetGen()->_map1D_Algo; - map < int, SMESH_1D_Algo * >::iterator id_algo = algoMap.find( myID ); - if ( id_algo == algoMap.end() ) - return new TNodeDistributor( myID, 0, aMesh.GetGen() ); - return static_cast< TNodeDistributor* >( id_algo->second ); - } - // ----------------------------------------------------------------------------- - bool Compute( vector< double > & positions, - gp_Pnt pIn, - gp_Pnt pOut, - SMESH_Mesh& aMesh, - const StdMeshers_LayerDistribution* hyp) - { - double len = pIn.Distance( pOut ); - if ( len <= DBL_MIN ) return error("Too close points of inner and outer shells"); + // First, try to compute positions of layers - if ( !hyp || !hyp->GetLayerDistribution() ) - return error( "Invalid LayerDistribution hypothesis"); - myUsedHyps.clear(); - myUsedHyps.push_back( hyp->GetLayerDistribution() ); + myLayerPositions.clear(); - TopoDS_Edge edge = BRepBuilderAPI_MakeEdge( pIn, pOut ); - SMESH_Hypothesis::Hypothesis_Status aStatus; - if ( !StdMeshers_Regular_1D::CheckHypothesis( aMesh, edge, aStatus )) - return error( "StdMeshers_Regular_1D::CheckHypothesis() failed " - "with LayerDistribution hypothesis"); + SMESH_Mesh * mesh = myHelper->GetMesh(); - BRepAdaptor_Curve C3D(edge); - double f = C3D.FirstParameter(), l = C3D.LastParameter(); - list< double > params; - if ( !StdMeshers_Regular_1D::computeInternalParameters( aMesh, C3D, len, f, l, params, false )) - return error("StdMeshers_Regular_1D failed to compute layers distribution"); + const SMESH_Hypothesis* hyp1D = myDistributionHypo ? myDistributionHypo->GetLayerDistribution() : 0; + int nbLayers = myNbLayerHypo ? myNbLayerHypo->GetNumberOfLayers() : 0; - positions.clear(); - positions.reserve( params.size() ); - for (list::iterator itU = params.begin(); itU != params.end(); itU++) - positions.push_back( *itU / len ); - return true; + if ( !hyp1D && !nbLayers ) + { + // No own algo hypotheses assigned, so first try to find any 1D hypothesis. + // We need some edge + TopoDS_Shape edge = linEdge; + if ( edge.IsNull() && !myHelper->GetSubShape().IsNull()) + for ( TopExp_Explorer e(myHelper->GetSubShape(), TopAbs_EDGE); e.More(); e.Next()) + edge = e.Current(); + if ( !edge.IsNull() ) + { + // find a hyp usable by TNodeDistributor + SMESH_HypoFilter hypKind; + TNodeDistributor::GetDistributor(*mesh)->InitCompatibleHypoFilter(hypKind,/*ignoreAux=*/1); + hyp1D = mesh->GetHypothesis( edge, hypKind, /*fromAncestors=*/true); + } } -protected: - // ----------------------------------------------------------------------------- - TNodeDistributor( int hypId, int studyId, SMESH_Gen* gen) - : StdMeshers_Regular_1D( hypId, studyId, gen) + if ( hyp1D ) // try to compute with hyp1D { + if ( !TNodeDistributor::GetDistributor(*mesh)->Compute( myLayerPositions,p1,p2,*mesh,hyp1D )) { + if ( myDistributionHypo ) { // bad hyp assigned + return error( TNodeDistributor::GetDistributor(*mesh)->GetComputeError() ); + } + else { + // bad hyp found, its Ok, lets try with default nb of segnents + } + } } - // ----------------------------------------------------------------------------- - virtual const list & - GetUsedHypothesis(SMESH_Mesh &, const TopoDS_Shape &, const bool) + + if ( myLayerPositions.empty() ) // try to use nb of layers { - return myUsedHyps; + if ( !nbLayers ) + nbLayers = _gen->GetDefaultNbSegments(); + + if ( nbLayers ) + { + myLayerPositions.resize( nbLayers - 1 ); + for ( int z = 1; z < nbLayers; ++z ) + myLayerPositions[ z - 1 ] = double( z )/ double( nbLayers ); + } } - // ----------------------------------------------------------------------------- -}; -//================================================================================ -/*! - * \brief Compute positions of nodes between the internal and the external surfaces - * \retval bool - is a success - */ -//================================================================================ + // Second, check presence of a mesh built by other algo on linEdge + // and mesh conformity to my hypothesis -bool StdMeshers_RadialQuadrangle_1D2D::computeLayerPositions(const gp_Pnt& pIn, - const gp_Pnt& pOut) -{ - if ( myNbLayerHypo ) + bool meshComputed = (!linEdge.IsNull() && !mesh->GetSubMesh(linEdge)->IsEmpty() ); + if ( linEdgeComputed ) *linEdgeComputed = meshComputed; + + if ( meshComputed ) { - int nbSegments = myNbLayerHypo->GetNumberOfLayers(); - myLayerPositions.resize( nbSegments - 1 ); - for ( int z = 1; z < nbSegments; ++z ) - myLayerPositions[ z - 1 ] = double( z )/ double( nbSegments ); - return true; - } - if ( myDistributionHypo ) { - SMESH_Mesh * mesh = myHelper->GetMesh(); - if ( !TNodeDistributor::GetDistributor(*mesh)->Compute( myLayerPositions, pIn, pOut, - *mesh, myDistributionHypo )) + vector< double > nodeParams; + GetNodeParamOnEdge( mesh->GetMeshDS(), linEdge, nodeParams ); + + // nb of present nodes must be different in cases of 1 and 2 straight edges + + TopoDS_Vertex VV[2]; + TopExp::Vertices( linEdge, VV[0], VV[1]); + const gp_Pnt* points[] = { &p1, &p2 }; + gp_Pnt vPoints[] = { BRep_Tool::Pnt(VV[0]), BRep_Tool::Pnt(VV[1]) }; + const double tol[] = { BRep_Tool::Tolerance(VV[0]), BRep_Tool::Tolerance(VV[1]) }; + bool pointsAreOnVertices = true; + for ( int iP = 0; iP < 2 && pointsAreOnVertices; ++iP ) + pointsAreOnVertices = ( points[iP]->Distance( vPoints[0] ) < tol[0] || + points[iP]->Distance( vPoints[1] ) < tol[1] ); + + int nbNodes = nodeParams.size() - 2; // 2 straight edges + if ( !pointsAreOnVertices ) + nbNodes = ( nodeParams.size() - 3 ) / 2; // 1 straight edge + + if ( myLayerPositions.empty() ) { - error( TNodeDistributor::GetDistributor(*mesh)->GetComputeError() ); - return false; + myLayerPositions.resize( nbNodes ); + } + else if ( myDistributionHypo || myNbLayerHypo ) + { + // linEdge is computed by other algo. Check if there is a meshed face + // using nodes on linEdge + bool nodesAreUsed = false; + TopTools_ListIteratorOfListOfShape ancestIt = mesh->GetAncestors( linEdge ); + for ( ; ancestIt.More() && !nodesAreUsed; ancestIt.Next() ) + if ( ancestIt.Value().ShapeType() == TopAbs_FACE ) + nodesAreUsed = (!mesh->GetSubMesh( ancestIt.Value() )->IsEmpty()); + if ( !nodesAreUsed ) { + // rebuild them + mesh->GetSubMesh( linEdge )->ComputeStateEngine( SMESH_subMesh::CLEAN ); + if ( linEdgeComputed ) *linEdgeComputed = false; + } + else { + + if ( myLayerPositions.size() != nbNodes ) + return error("Radial edge is meshed by other algorithm"); + } } } - RETURN_BAD_RESULT("Bad hypothesis"); + + return !myLayerPositions.empty(); } @@ -965,113 +1089,82 @@ bool StdMeshers_RadialQuadrangle_1D2D::Evaluate(SMESH_Mesh& aMesh, if( aShape.ShapeType() != TopAbs_FACE ) { return false; } - SMESH_subMesh * smf = aMesh.GetSubMesh(aShape); - MapShapeNbElemsItr anIt = aResMap.find(smf); - if( anIt != aResMap.end() ) { + SMESH_subMesh * sm = aMesh.GetSubMesh(aShape); + if( aResMap.count(sm) ) return false; - } - myLayerPositions.clear(); - gp_Pnt P0(0,0,0); - gp_Pnt P1(100,0,0); - computeLayerPositions(P0,P1); - - TopoDS_Edge E1,E2,E3; - Handle(Geom_Curve) C1,C2,C3; - double f1,l1,f2,l2,f3,l3; - int nbe = 0; - TopExp_Explorer exp; - for ( exp.Init( aShape, TopAbs_EDGE ); exp.More(); exp.Next() ) { - nbe++; - TopoDS_Edge E = TopoDS::Edge( exp.Current() ); - if(nbe==1) { - E1 = E; - C1 = BRep_Tool::Curve(E,f1,l1); - } - else if(nbe==2) { - E2 = E; - C2 = BRep_Tool::Curve(E,f2,l2); - } - else if(nbe==3) { - E3 = E; - C3 = BRep_Tool::Curve(E,f3,l3); - } - } + vector& aResVec = + aResMap.insert( make_pair(sm, vector(SMDSEntity_Last,0))).first->second; + + myHelper = new SMESH_MesherHelper( aMesh ); + myHelper->SetSubShape( aShape ); + auto_ptr helperDeleter( myHelper ); + + TNodeDistributor* algo1d = TNodeDistributor::GetDistributor(aMesh); TopoDS_Edge CircEdge, LinEdge1, LinEdge2; + int nbe = analyseFace( aShape, CircEdge, LinEdge1, LinEdge2 ); + if( nbe>3 || nbe < 1 || CircEdge.IsNull() ) + return false; + + Handle(Geom_Circle) aCirc = Handle(Geom_Circle)::DownCast( getCurve( CircEdge )); + if( aCirc.IsNull() ) + return error(COMPERR_BAD_SHAPE); + + gp_Pnt P0 = aCirc->Location(); + gp_Pnt P1 = aCirc->Value(0.); + computeLayerPositions( P0, P1, LinEdge1 ); + int nb0d=0, nb2d_tria=0, nb2d_quad=0; - bool isQuadratic = false; - if(nbe==1) { + bool isQuadratic = false, ok = true; + if(nbe==1) + { // C1 must be a circle - Handle(Geom_Circle) aCirc = Handle(Geom_Circle)::DownCast(C1); - if( !aCirc.IsNull() ) { - bool ok = _gen->Evaluate( aMesh, CircEdge, aResMap ); - if(ok) { - SMESH_subMesh * sm = aMesh.GetSubMesh(CircEdge); - MapShapeNbElemsItr anIt = aResMap.find(sm); - vector aVec = (*anIt).second; - isQuadratic = aVec[SMDSEntity_Quad_Edge]>aVec[SMDSEntity_Edge]; - if(isQuadratic) { - // main nodes - nb0d = (aVec[SMDSEntity_Node]+1) * myLayerPositions.size(); - // radial medium nodes - nb0d += (aVec[SMDSEntity_Node]+1) * (myLayerPositions.size()+1); - // other medium nodes - nb0d += (aVec[SMDSEntity_Node]+1) * myLayerPositions.size(); - } - else { - nb0d = (aVec[SMDSEntity_Node]+1) * myLayerPositions.size(); - } - nb2d_tria = aVec[SMDSEntity_Node] + 1; - nb2d_quad = nb0d; + ok = algo1d->EvaluateCircularEdge( aMesh, CircEdge, aResMap ); + if(ok) { + const vector& aVec = aResMap[aMesh.GetSubMesh(CircEdge)]; + isQuadratic = aVec[SMDSEntity_Quad_Edge]>aVec[SMDSEntity_Edge]; + if(isQuadratic) { + // main nodes + nb0d = (aVec[SMDSEntity_Node]+1) * myLayerPositions.size(); + // radial medium nodes + nb0d += (aVec[SMDSEntity_Node]+1) * (myLayerPositions.size()+1); + // other medium nodes + nb0d += (aVec[SMDSEntity_Node]+1) * myLayerPositions.size(); + } + else { + nb0d = (aVec[SMDSEntity_Node]+1) * myLayerPositions.size(); } + nb2d_tria = aVec[SMDSEntity_Node] + 1; + nb2d_quad = nb0d; } } - else if(nbe==2) { + else if(nbe==2 && LinEdge1.Orientation() != TopAbs_INTERNAL) + { // one curve must be a half of circle and other curve must be // a segment of line - Handle(Geom_TrimmedCurve) tc = Handle(Geom_TrimmedCurve)::DownCast(C1); - while( !tc.IsNull() ) { - C1 = tc->BasisCurve(); - tc = Handle(Geom_TrimmedCurve)::DownCast(C1); - } - tc = Handle(Geom_TrimmedCurve)::DownCast(C2); - while( !tc.IsNull() ) { - C2 = tc->BasisCurve(); - tc = Handle(Geom_TrimmedCurve)::DownCast(C2); - } - Handle(Geom_Circle) aCirc = Handle(Geom_Circle)::DownCast(C1); - Handle(Geom_Line) aLine = Handle(Geom_Line)::DownCast(C2); - CircEdge = E1; - LinEdge1 = E2; - double fp = f1; - double lp = l1; - if( aCirc.IsNull() ) { - aCirc = Handle(Geom_Circle)::DownCast(C2); - CircEdge = E2; - LinEdge1 = E1; - fp = f2; - lp = l2; - aLine = Handle(Geom_Line)::DownCast(C3); - } - bool ok = !aCirc.IsNull() && !aLine.IsNull(); - if( fabs(fabs(lp-fp)-PI) > Precision::Confusion() ) { + double fp, lp; + Handle(Geom_Circle) aCirc = Handle(Geom_Circle)::DownCast( getCurve( CircEdge, &fp, &lp )); + if( fabs(fabs(lp-fp)-M_PI) > Precision::Confusion() ) { // not half of circle - ok = false; + return error(COMPERR_BAD_SHAPE); + } + Handle(Geom_Line) aLine = Handle(Geom_Line)::DownCast( getCurve( LinEdge1 )); + if( aLine.IsNull() ) { + // other curve not line + return error(COMPERR_BAD_SHAPE); } - SMESH_subMesh* sm1 = aMesh.GetSubMesh(LinEdge1); - MapShapeNbElemsItr anIt = aResMap.find(sm1); - if( anIt!=aResMap.end() ) { - ok = false; + ok = !aResMap.count( aMesh.GetSubMesh(LinEdge1) ); + if ( !ok ) { + const vector& aVec = aResMap[ aMesh.GetSubMesh(LinEdge1) ]; + ok = ( aVec[SMDSEntity_Node] == myLayerPositions.size() ); } if(ok) { - ok = _gen->Evaluate( aMesh, CircEdge, aResMap ); + ok = algo1d->EvaluateCircularEdge( aMesh, CircEdge, aResMap ); } if(ok) { - SMESH_subMesh * sm = aMesh.GetSubMesh(CircEdge); - MapShapeNbElemsItr anIt = aResMap.find(sm); - vector aVec = (*anIt).second; - isQuadratic = aVec[SMDSEntity_Quad_Edge]>aVec[SMDSEntity_Edge]; + const vector& aVec = aResMap[ aMesh.GetSubMesh(CircEdge) ]; + isQuadratic = aVec[SMDSEntity_Quad_Edge] > aVec[SMDSEntity_Edge]; if(isQuadratic) { // main nodes nb0d = aVec[SMDSEntity_Node] * myLayerPositions.size(); @@ -1086,8 +1179,7 @@ bool StdMeshers_RadialQuadrangle_1D2D::Evaluate(SMESH_Mesh& aMesh, nb2d_tria = aVec[SMDSEntity_Node] + 1; nb2d_quad = nb2d_tria * myLayerPositions.size(); // add evaluation for edges - vector aResVec(SMDSEntity_Last); - for(int i=SMDSEntity_Node; i aResVec(SMDSEntity_Last,0); if(isQuadratic) { aResVec[SMDSEntity_Node] = 4*myLayerPositions.size() + 3; aResVec[SMDSEntity_Quad_Edge] = 2*myLayerPositions.size() + 2; @@ -1096,74 +1188,49 @@ bool StdMeshers_RadialQuadrangle_1D2D::Evaluate(SMESH_Mesh& aMesh, aResVec[SMDSEntity_Node] = 2*myLayerPositions.size() + 1; aResVec[SMDSEntity_Edge] = 2*myLayerPositions.size() + 2; } - sm = aMesh.GetSubMesh(LinEdge1); - aResMap.insert(make_pair(sm,aResVec)); + aResMap[ aMesh.GetSubMesh(LinEdge1) ] = aResVec; } } - else { // nbe==3 + else // nbe==3 or ( nbe==2 && linEdge is INTERNAL ) + { + if (nbe==2 && LinEdge1.Orientation() == TopAbs_INTERNAL ) + LinEdge2 = LinEdge1; + // one curve must be a part of circle and other curves must be // segments of line - Handle(Geom_TrimmedCurve) tc = Handle(Geom_TrimmedCurve)::DownCast(C1); - while( !tc.IsNull() ) { - C1 = tc->BasisCurve(); - tc = Handle(Geom_TrimmedCurve)::DownCast(C1); - } - tc = Handle(Geom_TrimmedCurve)::DownCast(C2); - while( !tc.IsNull() ) { - C2 = tc->BasisCurve(); - tc = Handle(Geom_TrimmedCurve)::DownCast(C2); - } - tc = Handle(Geom_TrimmedCurve)::DownCast(C3); - while( !tc.IsNull() ) { - C3 = tc->BasisCurve(); - tc = Handle(Geom_TrimmedCurve)::DownCast(C3); + Handle(Geom_Line) aLine1 = Handle(Geom_Line)::DownCast( getCurve( LinEdge1 )); + Handle(Geom_Line) aLine2 = Handle(Geom_Line)::DownCast( getCurve( LinEdge2 )); + if( aLine1.IsNull() || aLine2.IsNull() ) { + // other curve not line + return error(COMPERR_BAD_SHAPE); } - Handle(Geom_Circle) aCirc = Handle(Geom_Circle)::DownCast(C1); - Handle(Geom_Line) aLine1 = Handle(Geom_Line)::DownCast(C2); - Handle(Geom_Line) aLine2 = Handle(Geom_Line)::DownCast(C3); - CircEdge = E1; - LinEdge1 = E2; - LinEdge2 = E3; - double fp = f1; - double lp = l1; - if( aCirc.IsNull() ) { - aCirc = Handle(Geom_Circle)::DownCast(C2); - CircEdge = E2; - LinEdge1 = E3; - LinEdge2 = E1; - fp = f2; - lp = l2; - aLine1 = Handle(Geom_Line)::DownCast(C3); - aLine2 = Handle(Geom_Line)::DownCast(C1); - if( aCirc.IsNull() ) { - aCirc = Handle(Geom_Circle)::DownCast(C3); - CircEdge = E3; - LinEdge1 = E1; - LinEdge2 = E2; - fp = f3; - lp = l3; - aLine1 = Handle(Geom_Line)::DownCast(C1); - aLine2 = Handle(Geom_Line)::DownCast(C2); + int nbLayers = myLayerPositions.size(); + computeLayerPositions( P0, P1, LinEdge2 ); + if ( nbLayers != myLayerPositions.size() ) + return error("Different hypotheses apply to radial edges"); + + bool ok = !aResMap.count( aMesh.GetSubMesh(LinEdge1)); + if ( !ok ) { + if ( myDistributionHypo || myNbLayerHypo ) + ok = true; // override other 1d hyps + else { + const vector& aVec = aResMap[ aMesh.GetSubMesh(LinEdge1) ]; + ok = ( aVec[SMDSEntity_Node] == myLayerPositions.size() ); } } - bool ok = !aCirc.IsNull() && !aLine1.IsNull() && !aLine1.IsNull(); - SMESH_subMesh* sm = aMesh.GetSubMesh(LinEdge1); - MapShapeNbElemsItr anIt = aResMap.find(sm); - if( anIt!=aResMap.end() ) { - ok = false; - } - sm = aMesh.GetSubMesh(LinEdge2); - anIt = aResMap.find(sm); - if( anIt!=aResMap.end() ) { - ok = false; + if( ok && aResMap.count( aMesh.GetSubMesh(LinEdge2) )) { + if ( myDistributionHypo || myNbLayerHypo ) + ok = true; // override other 1d hyps + else { + const vector& aVec = aResMap[ aMesh.GetSubMesh(LinEdge2) ]; + ok = ( aVec[SMDSEntity_Node] == myLayerPositions.size() ); + } } if(ok) { - ok = _gen->Evaluate( aMesh, CircEdge, aResMap ); + ok = algo1d->EvaluateCircularEdge( aMesh, CircEdge, aResMap ); } if(ok) { - SMESH_subMesh * sm = aMesh.GetSubMesh(CircEdge); - MapShapeNbElemsItr anIt = aResMap.find(sm); - vector aVec = (*anIt).second; + const vector& aVec = aResMap[ aMesh.GetSubMesh(CircEdge) ]; isQuadratic = aVec[SMDSEntity_Quad_Edge]>aVec[SMDSEntity_Edge]; if(isQuadratic) { // main nodes @@ -1179,8 +1246,7 @@ bool StdMeshers_RadialQuadrangle_1D2D::Evaluate(SMESH_Mesh& aMesh, nb2d_tria = aVec[SMDSEntity_Node] + 1; nb2d_quad = nb2d_tria * myLayerPositions.size(); // add evaluation for edges - vector aResVec(SMDSEntity_Last); - for(int i=SMDSEntity_Node; i aResVec(SMDSEntity_Last, 0); if(isQuadratic) { aResVec[SMDSEntity_Node] = 2*myLayerPositions.size() + 1; aResVec[SMDSEntity_Quad_Edge] = myLayerPositions.size() + 1; @@ -1190,17 +1256,12 @@ bool StdMeshers_RadialQuadrangle_1D2D::Evaluate(SMESH_Mesh& aMesh, aResVec[SMDSEntity_Edge] = myLayerPositions.size() + 1; } sm = aMesh.GetSubMesh(LinEdge1); - aResMap.insert(make_pair(sm,aResVec)); + aResMap[sm] = aResVec; sm = aMesh.GetSubMesh(LinEdge2); - aResMap.insert(make_pair(sm,aResVec)); + aResMap[sm] = aResVec; } } - vector aResVec(SMDSEntity_Last); - for(int i=SMDSEntity_Node; i