#include "utilities.h"
-#include <TopoDS_Solid.hxx>
-#include <TopoDS_Shell.hxx>
-#include <BRepTools.hxx>
-#include <TopTools_ListIteratorOfListOfShape.hxx>
+#include <BRepAdaptor_Curve.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx>
+#include <BRepTools.hxx>
+#include <TopExp_Explorer.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Shell.hxx>
+#include <TopoDS_Solid.hxx>
#include <gp.hxx>
#include <gp_Pnt.hxx>
using namespace std;
-#define RETURN_BAD_RESULT(msg) { MESSAGE(msg); return false; }
+#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;
SMESH_Hypothesis::Hypothesis_Status& aStatus)
{
// check aShape that must have 2 shells
+/* PAL16229
if ( TAssocTool::Count( aShape, TopAbs_SOLID, 0 ) != 1 ||
TAssocTool::Count( aShape, TopAbs_SHELL, 0 ) != 2 )
{
aStatus = HYP_BAD_GEOMETRY;
return false;
}
-
+*/
myNbLayerHypo = 0;
myDistributionHypo = 0;
if ( !outerShell.IsSame( It.Value() ))
innerShell = It.Value();
if ( nbShells != 2 )
- RETURN_BAD_RESULT("Must be 2 shells");
+ return error(COMPERR_BAD_SHAPE, SMESH_Comment("Must be 2 shells but not ")<<nbShells);
// ----------------------------------
// Associate subshapes of the shells
if ( !TAssocTool::FindSubShapeAssociation( outerShell, &aMesh,
innerShell, &aMesh,
shape2ShapeMap) )
- RETURN_BAD_RESULT("FindSubShapeAssociation failed");
+ return error(COMPERR_BAD_SHAPE,"Topology of inner and outer shells seems different" );
// ------------------
// Make mesh
TopoDS_Face outFace = TopoDS::Face( exp.Current() );
TopoDS_Face inFace;
if ( !shape2ShapeMap.IsBound( outFace )) {
- RETURN_BAD_RESULT("Association not found for face " << meshDS->ShapeToIndex( outFace ));
+ return error(SMESH_Comment("Corresponding inner face not found for face #" )
+ << meshDS->ShapeToIndex( outFace ));
} else {
inFace = TopoDS::Face( shape2ShapeMap( outFace ));
}
TNodeNodeMap nodeIn2OutMap;
if ( ! TAssocTool::FindMatchingNodesOnFaces( inFace, &aMesh, outFace, &aMesh,
shape2ShapeMap, nodeIn2OutMap ))
- RETURN_BAD_RESULT("Different mesh on corresponding out and in faces: "
- << meshDS->ShapeToIndex( outFace ) << " and "
- << meshDS->ShapeToIndex( inFace ));
+ return error(COMPERR_BAD_INPUT_MESH,SMESH_Comment("Mesh on faces #")
+ << meshDS->ShapeToIndex( outFace ) << " and "
+ << meshDS->ShapeToIndex( inFace ) << " seems different" );
+
// Create volumes
SMDS_ElemIteratorPtr faceIt = meshDS->MeshElements( inFace )->GetElements();
vector< const TNodeColumn* > columns( nbNodes );
for ( int i = 0; i < nbNodes; ++i )
{
- const SMDS_MeshNode* n = face->GetNode( i );
- TNode2ColumnMap::iterator n_col = node2columnMap.find( n );
- if ( n_col != node2columnMap.end() )
+ const SMDS_MeshNode* nIn = face->GetNode( i );
+ TNode2ColumnMap::iterator n_col = node2columnMap.find( nIn );
+ if ( n_col != node2columnMap.end() ) {
columns[ i ] = & n_col->second;
- else
- columns[ i ] = makeNodeColumn( node2columnMap, n, nodeIn2OutMap[ n ] );
+ }
+ else {
+ TNodeNodeMap::iterator nInOut = nodeIn2OutMap.find( nIn );
+ if ( nInOut == nodeIn2OutMap.end() )
+ RETURN_BAD_RESULT("No matching node for "<< nIn->GetID() <<
+ " in face "<< face->GetID());
+ columns[ i ] = makeNodeColumn( node2columnMap, nIn, nInOut->second );
+ }
}
StdMeshers_Prism_3D::AddPrisms( columns, myHelper );
SMESHDS_Mesh * meshDS = myHelper->GetMeshDS();
int shapeID = myHelper->GetSubShapeID();
- if ( myLayerPositions.empty() )
- computeLayerPositions( gpXYZ( inNode ), gpXYZ( outNode ));
-
+ if ( myLayerPositions.empty() ) {
+ gp_Pnt pIn = gpXYZ( inNode ), pOut = gpXYZ( outNode );
+ computeLayerPositions( pIn, pOut );
+ }
int nbSegments = myLayerPositions.size() + 1;
TNode2ColumnMap::iterator n_col =
//================================================================================
//================================================================================
-class TNodeDistributor: private StdMeshers_Regular_1D
+class TNodeDistributor: public StdMeshers_Regular_1D
{
list <const SMESHDS_Hypothesis *> myUsedHyps;
public:
const StdMeshers_LayerDistribution* hyp)
{
double len = pIn.Distance( pOut );
- if ( len <= DBL_MIN ) RETURN_BAD_RESULT("Bad points");
+ if ( len <= DBL_MIN ) return error("Too close points of inner and outer shells");
if ( !hyp || !hyp->GetLayerDistribution() )
- RETURN_BAD_RESULT("Bad StdMeshers_LayerDistribution hypothesis");
+ return error( "Invalid LayerDistribution hypothesis");
myUsedHyps.clear();
myUsedHyps.push_back( hyp->GetLayerDistribution() );
TopoDS_Edge edge = BRepBuilderAPI_MakeEdge( pIn, pOut );
-
SMESH_Hypothesis::Hypothesis_Status aStatus;
if ( !StdMeshers_Regular_1D::CheckHypothesis( aMesh, edge, aStatus ))
- RETURN_BAD_RESULT("StdMeshers_Regular_1D::CheckHypothesis() failed with status "<<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( edge, params, false ))
- RETURN_BAD_RESULT("StdMeshers_Regular_1D::computeInternalParameters() failed");
+ if ( !StdMeshers_Regular_1D::computeInternalParameters( C3D, len, f, l, params, false ))
+ return error("StdMeshers_Regular_1D failed to compute layers distribution");
positions.clear();
positions.reserve( params.size() );
*/
//================================================================================
-bool StdMeshers_RadialPrism_3D::computeLayerPositions(gp_Pnt pIn, gp_Pnt pOut)
+bool StdMeshers_RadialPrism_3D::computeLayerPositions(const gp_Pnt& pIn,
+ const gp_Pnt& pOut)
{
if ( myNbLayerHypo )
{
}
if ( myDistributionHypo ) {
SMESH_Mesh * mesh = myHelper->GetMesh();
- return TNodeDistributor::GetDistributor(*mesh)->Compute( myLayerPositions, pIn, pOut,
- *mesh, myDistributionHypo );
+ if ( !TNodeDistributor::GetDistributor(*mesh)->Compute( myLayerPositions, pIn, pOut,
+ *mesh, myDistributionHypo ))
+ {
+ error( TNodeDistributor::GetDistributor(*mesh)->GetComputeError() );
+ return false;
+ }
}
- RETURN_BAD_RESULT("Bad hypothesis");
+ RETURN_BAD_RESULT("Bad hypothesis");
}
