ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-01-02 21:00:34 +05:00
Code Issues Packages Projects Releases Wiki Activity

PAL16202,16203 (Propagation 1D on edges group)

Browse Source 
source shape can be a group
This commit is contained in:
eap 2007-11-07 10:01:36 +00:00
parent 42e8757bfc
commit 13e902c404
10 changed files with 562 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/StdMeshers/StdMeshers_ProjectionSource1D.cxx
View File

@ -79,12 +79,12 @@ void StdMeshers_ProjectionSource1D::SetSourceEdge(const TopoDS_Shape& edge)
if ( edge.IsNull() )
throw SALOME_Exception(LOCALIZED("Null edge is not allowed"));
if ( edge.ShapeType() != TopAbs_EDGE )
if ( edge.ShapeType() != TopAbs_EDGE && edge.ShapeType() != TopAbs_COMPOUND )
throw SALOME_Exception(LOCALIZED("Wrong shape type"));
if ( !_sourceEdge.IsSame( edge ) )
{
_sourceEdge = TopoDS::Edge( edge );
_sourceEdge = edge;
NotifySubMeshesHypothesisModification();
}
@ -224,7 +224,7 @@ void StdMeshers_ProjectionSource1D::RestoreParams(const TopoDS_Shape& s1,
const TopoDS_Shape& s3,
SMESH_Mesh* mesh)
{
_sourceEdge = TopoDS::Edge( s1 );
_sourceEdge = s1;
_sourceVertex = TopoDS::Vertex( s2 );
_targetVertex = TopoDS::Vertex( s3 );
_sourceMesh = mesh;

13
src/StdMeshers/StdMeshers_ProjectionSource1D.hxx
View File

@ -34,7 +34,6 @@
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include <TopoDS_Edge.hxx>
#include <TopoDS_Vertex.hxx>
class SMESH_Gen;
@ -62,9 +61,15 @@ public:
throw ( SALOME_Exception );
/*!
* Returns the source edge
* Returns the source edge or a group containing edges
*/
TopoDS_Edge GetSourceEdge() const { return _sourceEdge; }
TopoDS_Shape GetSourceEdge() const { return _sourceEdge; }
/*!
* Returns true the source edge is a group of edges
*/
bool IsCompoundSource() const
{ return !_sourceEdge.IsNull() && _sourceEdge.ShapeType() == TopAbs_COMPOUND; }
/*!
* Sets source <mesh> to take a mesh pattern from
@ -135,7 +140,7 @@ public:
protected:
TopoDS_Edge _sourceEdge;
TopoDS_Shape _sourceEdge;
SMESH_Mesh* _sourceMesh;
TopoDS_Vertex _sourceVertex;
TopoDS_Vertex _targetVertex;

8
src/StdMeshers/StdMeshers_ProjectionSource2D.cxx
View File

@ -79,12 +79,12 @@ void StdMeshers_ProjectionSource2D::SetSourceFace(const TopoDS_Shape& Face)
if ( Face.IsNull() )
throw SALOME_Exception(LOCALIZED("Null Face is not allowed"));
if ( Face.ShapeType() != TopAbs_FACE )
if ( Face.ShapeType() != TopAbs_FACE && Face.ShapeType() != TopAbs_COMPOUND )
throw SALOME_Exception(LOCALIZED("Wrong shape type"));
if ( !_sourceFace.IsSame( Face ) )
{
_sourceFace = TopoDS::Face( Face );
_sourceFace = Face;
NotifySubMeshesHypothesisModification();
}
@ -150,7 +150,7 @@ void StdMeshers_ProjectionSource2D::SetSourceMesh(SMESH_Mesh* mesh)
*/
//=============================================================================
TopoDS_Face StdMeshers_ProjectionSource2D::GetSourceFace() const
TopoDS_Shape StdMeshers_ProjectionSource2D::GetSourceFace() const
{
return _sourceFace;
}
@ -291,7 +291,7 @@ void StdMeshers_ProjectionSource2D::RestoreParams(const TopoDS_Shape& s1,
const TopoDS_Shape& s5,
SMESH_Mesh* mesh)
{
_sourceFace = TopoDS::Face( s1 );
_sourceFace = s1;
_sourceVertex1 = TopoDS::Vertex( s2 );
_sourceVertex2 = TopoDS::Vertex( s3 );
_targetVertex1 = TopoDS::Vertex( s4 );

13
src/StdMeshers/StdMeshers_ProjectionSource2D.hxx
View File

@ -34,7 +34,6 @@
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
#include <TopoDS_Face.hxx>
#include <TopoDS_Vertex.hxx>
class SMESH_Gen;
@ -62,9 +61,15 @@ public:
throw ( SALOME_Exception );
/*!
* Returns the source face
* Returns the source face or a group containing faces
*/
TopoDS_Face GetSourceFace() const;
TopoDS_Shape GetSourceFace() const;
/*!
* Returns true the source face is a group of faces
*/
bool IsCompoundSource() const
{ return !_sourceFace.IsNull() && _sourceFace.ShapeType() == TopAbs_COMPOUND; }
/*!
* Sets source <mesh> to take a mesh pattern from
@ -145,7 +150,7 @@ public:
protected:
TopoDS_Face _sourceFace;
TopoDS_Shape _sourceFace;
SMESH_Mesh* _sourceMesh;
TopoDS_Vertex _sourceVertex1;
TopoDS_Vertex _sourceVertex2;

489
src/StdMeshers/StdMeshers_ProjectionUtils.cxx
View File

@ -45,25 +45,28 @@
#include "utilities.h"
#include <BRepAdaptor_Curve.hxx>
#include <BRepTools.hxx>
#include <BRepTools_WireExplorer.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <Bnd_Box.hxx>
#include <TopAbs.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopTools_Array1OfShape.hxx>
#include <TopTools_DataMapOfShapeShape.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Compound.hxx>
#include <TopoDS_Shape.hxx>
#include <gp_Ax3.hxx>
#include <gp_Pnt.hxx>
#include <gp_Trsf.hxx>
#include <gp_Vec.hxx>
#include <TopTools_DataMapIteratorOfDataMapOfShapeShape.hxx>
#include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
#define RETURN_BAD_RESULT(msg) { MESSAGE(msg); return false; }
#define RETURN_BAD_RESULT(msg) { MESSAGE(")-: Error: " << msg); return false; }
#define SHOW_VERTEX(v,msg) // { \
// if ( v.IsNull() ) cout << msg << " NULL SHAPE" << endl; \
// else if (v.ShapeType() == TopAbs_VERTEX) {\
@ -168,6 +171,37 @@ namespace {
}
return false;
}
//================================================================================
/*!
* \brief Look for a group containing a target shape and similar to a source group
* \param tgtShape - target edge or face
* \param tgtMesh1 - target mesh
* \param srcGroup - source group
* \retval TopoDS_Shape - found target group
*/
//================================================================================
TopoDS_Shape FindGroupContaining(const TopoDS_Shape& tgtShape,
const SMESH_Mesh* tgtMesh1,
const TopoDS_Shape& srcGroup)
{
list<SMESH_subMesh*> subMeshes = tgtMesh1->GetGroupSubMeshesContaining(tgtShape);
list<SMESH_subMesh*>::iterator sm = subMeshes.begin();
int type, last = TopAbs_SHAPE;
StdMeshers_ProjectionUtils util;
for ( ; sm != subMeshes.end(); ++sm ) {
const TopoDS_Shape & group = (*sm)->GetSubShape();
// check if group is similar to srcGroup
for ( type = srcGroup.ShapeType(); type < last; ++type)
if ( util.Count( srcGroup, (TopAbs_ShapeEnum)type, 0) !=
util.Count( group, (TopAbs_ShapeEnum)type, 0))
break;
if ( type == last )
return group;
}
return TopoDS_Shape();
}
}
//=======================================================================
@ -189,15 +223,32 @@ bool StdMeshers_ProjectionUtils::FindSubShapeAssociation(const TopoDS_Shape& the
SMESH_Mesh* theMesh2,
TShapeShapeMap & theMap)
{
if ( theShape1.ShapeType() != theShape2.ShapeType() )
RETURN_BAD_RESULT("Different shape types");
if ( theShape1.ShapeType() != theShape2.ShapeType() ) {
// is it the case of a group member -> another group? (PAL16202, 16203)
TopoDS_Shape group1, group2;
if ( theShape1.ShapeType() == TopAbs_COMPOUND ) {
group1 = theShape1;
group2 = FindGroupContaining( theShape2, theMesh2, group1 );
}
else if ( theShape2.ShapeType() == TopAbs_COMPOUND ) {
group2 = theShape2;
group1 = FindGroupContaining( theShape1, theMesh1, group2 );
}
if ( group1.IsNull() || group2.IsNull() )
RETURN_BAD_RESULT("Different shape types");
// Associate compounds
return FindSubShapeAssociation(group1, theMesh1, group2, theMesh2, theMap );
}
bool bidirect = ( !theShape1.IsSame( theShape2 ));
if ( !theMap.IsEmpty())
if ( !theMap.IsEmpty() )
{
//======================================================================
// HAS initial vertex association
//======================================================================
switch ( theShape1.ShapeType() ) {
case TopAbs_EDGE: {
// ----------------------------------------------------------------------
case TopAbs_EDGE: { // TopAbs_EDGE
// ----------------------------------------------------------------------
if ( theMap.Extent() != 2 )
RETURN_BAD_RESULT("Wrong map extent " << theMap.Extent() );
@ -210,10 +261,11 @@ bool StdMeshers_ProjectionUtils::FindSubShapeAssociation(const TopoDS_Shape& the
if ( theMap.IsBound( VV1[ i1 ] )) i1 = 1;
if ( theMap.IsBound( VV2[ i2 ] )) i2 = 1;
InsertAssociation( VV1[ i1 ], VV2[ i2 ], theMap, bidirect);
InsertAssociation( theShape1, theShape2, theMap, bidirect );
return true;
}
case TopAbs_FACE: {
// ----------------------------------------------------------------------
case TopAbs_FACE: { // TopAbs_FACE
// ----------------------------------------------------------------------
TopoDS_Face face1 = TopoDS::Face( theShape1 );
TopoDS_Face face2 = TopoDS::Face( theShape2 );
@ -251,10 +303,11 @@ bool StdMeshers_ProjectionUtils::FindSubShapeAssociation(const TopoDS_Shape& the
VV2[0] = TopExp::FirstVertex( *eIt2, true );
InsertAssociation( VV1[0], VV2[0], theMap, bidirect);
}
InsertAssociation( theShape1, theShape2, theMap, bidirect );
return true;
}
case TopAbs_SHELL:
// ----------------------------------------------------------------------
case TopAbs_SHELL: // TopAbs_SHELL, TopAbs_SOLID
case TopAbs_SOLID: {
// ----------------------------------------------------------------------
TopoDS_Vertex VV1[2], VV2[2];
@ -276,22 +329,42 @@ bool StdMeshers_ProjectionUtils::FindSubShapeAssociation(const TopoDS_Shape& the
if ( edge2.IsNull() )
RETURN_BAD_RESULT("GetEdgeByVertices() failed");
// get a face sharing edge1
TopoDS_Shape F1, F2, FF2[2];
TopTools_ListIteratorOfListOfShape ancestIt = theMesh1->GetAncestors( edge1 );
for ( ; F1.IsNull() && ancestIt.More(); ancestIt.Next() )
if ( ancestIt.Value().ShapeType() == TopAbs_FACE )
F1 = ancestIt.Value().Oriented( TopAbs_FORWARD );
// build map of edge to faces if shapes are not subshapes of main ones
bool isSubOfMain = false;
if ( SMESHDS_SubMesh * sm = theMesh1->GetMeshDS()->MeshElements( theShape1 ))
isSubOfMain = !sm->IsComplexSubmesh();
else
isSubOfMain = theMesh1->GetMeshDS()->ShapeToIndex( theShape1 );
TAncestorMap e2f1, e2f2;
const TAncestorMap& edgeToFace1 = isSubOfMain ? theMesh1->GetAncestorMap() : e2f1;
const TAncestorMap& edgeToFace2 = isSubOfMain ? theMesh2->GetAncestorMap() : e2f2;
if (!isSubOfMain) {
TopExp::MapShapesAndAncestors( theShape1, TopAbs_EDGE, TopAbs_FACE, e2f1 );
TopExp::MapShapesAndAncestors( theShape2, TopAbs_EDGE, TopAbs_FACE, e2f2 );
if ( !edgeToFace1.Contains( edge1 ))
RETURN_BAD_RESULT("edge1 does not belong to theShape1");
if ( !edgeToFace2.Contains( edge2 ))
RETURN_BAD_RESULT("edge2 does not belong to theShape2");
}
//
// Look for 2 corresponing faces:
//
TopoDS_Shape F1, F2;
// get a face sharing edge1 (F1)
TopoDS_Shape FF2[2];
TopTools_ListIteratorOfListOfShape ancestIt1( edgeToFace1.FindFromKey( edge1 ));
for ( ; F1.IsNull() && ancestIt1.More(); ancestIt1.Next() )
if ( ancestIt1.Value().ShapeType() == TopAbs_FACE )
F1 = ancestIt1.Value().Oriented( TopAbs_FORWARD );
if ( F1.IsNull() )
RETURN_BAD_RESULT(" Face1 not found");
// get 2 faces sharing edge2
ancestIt = theMesh2->GetAncestors( edge2 );
for ( int i = 0; FF2[1].IsNull() && ancestIt.More(); ancestIt.Next() )
if ( ancestIt.Value().ShapeType() == TopAbs_FACE )
FF2[ i++ ] = ancestIt.Value().Oriented( TopAbs_FORWARD );
if ( FF2[1].IsNull() )
RETURN_BAD_RESULT("2 faces not found");
// get 2 faces sharing edge2 (one of them is F2)
TopTools_ListIteratorOfListOfShape ancestIt2( edgeToFace2.FindFromKey( edge2 ));
for ( int i = 0; FF2[1].IsNull() && ancestIt2.More(); ancestIt2.Next() )
if ( ancestIt2.Value().ShapeType() == TopAbs_FACE )
FF2[ i++ ] = ancestIt2.Value().Oriented( TopAbs_FORWARD );
// get oriented edge1 and edge2 from F1 and FF2[0]
for ( exp.Init( F1, TopAbs_EDGE ); exp.More(); exp.Next() )
@ -299,7 +372,6 @@ bool StdMeshers_ProjectionUtils::FindSubShapeAssociation(const TopoDS_Shape& the
edge1 = TopoDS::Edge( exp.Current() );
break;
}
for ( exp.Init( FF2[ 0 ], TopAbs_EDGE ); exp.More(); exp.Next() )
if ( edge2.IsSame( exp.Current() )) {
edge2 = TopoDS::Edge( exp.Current() );
@ -309,13 +381,16 @@ bool StdMeshers_ProjectionUtils::FindSubShapeAssociation(const TopoDS_Shape& the
// compare first vertices of edge1 and edge2
TopExp::Vertices( edge1, VV1[0], VV1[1], true );
TopExp::Vertices( edge2, VV2[0], VV2[1], true );
F2 = FF2[ 0 ];
F2 = FF2[ 0 ]; // (F2 !)
if ( !VV1[ 0 ].IsSame( theMap( VV2[ 0 ]))) {
F2 = FF2[ 1 ];
edge2.Reverse();
if ( FF2[ 1 ].IsNull() )
F2.Reverse();
else
F2 = FF2[ 1 ];
}
TopTools_MapOfShape boundEdges;
TopTools_MapOfShape boundEdges;
// association of face subshapes and neighbour faces
list< pair < TopoDS_Face, TopoDS_Edge > > FE1, FE2;
@ -352,27 +427,262 @@ bool StdMeshers_ProjectionUtils::FindSubShapeAssociation(const TopoDS_Shape& the
VV1[0] = TopExp::FirstVertex( *eIt1, true );
VV2[0] = TopExp::FirstVertex( *eIt2, true );
InsertAssociation( VV1[0], VV2[0], theMap, bidirect); // assoc vertices
MESSAGE("Assoc vertex " << theMesh1->GetMeshDS()->ShapeToIndex( VV1[0] )<<
" to " << theMesh2->GetMeshDS()->ShapeToIndex( VV2[0] ));
// add adjacent faces to process
TopoDS_Face nextFace1 = GetNextFace( theMesh1, *eIt1, face1 );
TopoDS_Face nextFace2 = GetNextFace( theMesh2, *eIt2, face2 );
TopoDS_Face nextFace1 = GetNextFace( edgeToFace1, *eIt1, face1 );
TopoDS_Face nextFace2 = GetNextFace( edgeToFace2, *eIt2, face2 );
if ( !nextFace1.IsNull() && !nextFace2.IsNull() ) {
FE1.push_back( make_pair( nextFace1, *eIt1 ));
FE2.push_back( make_pair( nextFace2, *eIt2 ));
}
}
}
InsertAssociation( theShape1, theShape2, theMap, bidirect );
return true;
}
// ----------------------------------------------------------------------
case TopAbs_COMPOUND: { // GROUP
// ----------------------------------------------------------------------
// Maybe groups contain only one member
TopoDS_Iterator it1( theShape1 ), it2( theShape2 );
TopAbs_ShapeEnum memberType = it1.Value().ShapeType();
int nbMembers = Count( theShape1, memberType, true );
if ( nbMembers == 0 ) return true;
if ( nbMembers == 1 ) {
return FindSubShapeAssociation( it1.Value(), theMesh1, it2.Value(), theMesh2, theMap );
}
// Try to make shells of faces
//
BRep_Builder builder;
TopoDS_Shell shell1, shell2;
builder.MakeShell(shell1); builder.MakeShell(shell2);
if ( memberType == TopAbs_FACE ) {
// just add faces of groups to shells
for (; it1.More(); it1.Next(), it2.Next() )
builder.Add( shell1, it1.Value() ), builder.Add( shell2, it2.Value() );
}
else if ( memberType == TopAbs_EDGE ) {
// Try to add faces sharing more than one edge of a group or
// sharing all its vertices with the group
TopTools_IndexedMapOfShape groupVertices[2];
TopExp::MapShapes( theShape1, TopAbs_VERTEX, groupVertices[0]);
TopExp::MapShapes( theShape2, TopAbs_VERTEX, groupVertices[1]);
//
TopTools_MapOfShape groupEdges[2], addedFaces[2];
bool hasInitAssoc = (!theMap.IsEmpty()), initAssocOK = !hasInitAssoc;
for (; it1.More(); it1.Next(), it2.Next() ) {
groupEdges[0].Add( it1.Value() );
groupEdges[1].Add( it2.Value() );
if ( !initAssocOK ) {
// for shell association there must be an edge with both vertices bound
TopoDS_Vertex v1, v2;
TopExp::Vertices( TopoDS::Edge( it1.Value()), v1, v2 );
initAssocOK = ( theMap.IsBound( v1 ) && theMap.IsBound( v2 ));
}
}
for (int is2ndGroup = 0; initAssocOK && is2ndGroup < 2; ++is2ndGroup) {
const TopoDS_Shape& group = is2ndGroup ? theShape2: theShape1;
SMESH_Mesh* mesh = is2ndGroup ? theMesh2 : theMesh1;
TopoDS_Shell& shell = is2ndGroup ? shell2 : shell1;
for ( TopoDS_Iterator it( group ); it.More(); it.Next() ) {
const TopoDS_Edge& edge = TopoDS::Edge( it.Value() );
TopoDS_Face face;
for ( int iF = 0; iF < 2; ++iF ) { // loop on 2 faces sharing edge
face = GetNextFace(mesh->GetAncestorMap(), edge, face);
if ( !face.IsNull() ) {
int nbGroupEdges = 0;
for ( TopExp_Explorer f( face, TopAbs_EDGE ); f.More(); f.Next())
if ( groupEdges[ is2ndGroup ].Contains( f.Current() ))
if ( ++nbGroupEdges > 1 )
break;
bool add = (nbGroupEdges > 1 || Count( face, TopAbs_EDGE, true ) == 1 );
if ( !add ) {
add = true;
for ( TopExp_Explorer v( face, TopAbs_VERTEX ); add && v.More(); v.Next())
add = groupVertices[ is2ndGroup ].Contains( v.Current() );
}
if ( add && addedFaces[ is2ndGroup ].Add( face ))
builder.Add( shell, face );
}
}
}
}
} else {
RETURN_BAD_RESULT("Unexpected group type");
}
// Associate shells
//
int nbFaces1 = Count( shell1, TopAbs_FACE, 0 );
int nbFaces2 = Count( shell2, TopAbs_FACE, 0 );
if ( nbFaces1 != nbFaces2 )
RETURN_BAD_RESULT("Different nb of faces found for shells");
if ( nbFaces1 > 0 ) {
bool ok = false;
if ( nbFaces1 == 1 ) {
TopoDS_Shape F1 = TopoDS_Iterator( shell1 ).Value();
TopoDS_Shape F2 = TopoDS_Iterator( shell2 ).Value();
ok = FindSubShapeAssociation( F1, theMesh1, F2, theMesh2, theMap );
}
else {
ok = FindSubShapeAssociation(shell1, theMesh1, shell2, theMesh2, theMap );
}
// Check if all members are mapped
if ( ok ) {
TopTools_MapOfShape boundMembers[2];
TopoDS_Iterator mIt;
for ( mIt.Initialize( theShape1 ); mIt.More(); mIt.Next())
if ( theMap.IsBound( mIt.Value() )) {
boundMembers[0].Add( mIt.Value() );
boundMembers[1].Add( theMap( mIt.Value() ));
}
if ( boundMembers[0].Extent() != nbMembers ) {
// make compounds of not bound members
TopoDS_Compound comp[2];
for ( int is2ndGroup = 0; is2ndGroup < 2; ++is2ndGroup ) {
builder.MakeCompound( comp[is2ndGroup] );
for ( mIt.Initialize( is2ndGroup ? theShape2:theShape1 ); mIt.More(); mIt.Next())
if ( ! boundMembers[ is2ndGroup ].Contains( mIt.Value() ))
builder.Add( comp[ is2ndGroup ], mIt.Value() );
}
// check if theMap contains initial association for the comp's
bool hasInitialAssoc = false;
if ( memberType == TopAbs_EDGE ) {
for ( TopExp_Explorer v( comp[0], TopAbs_VERTEX ); v.More(); v.Next())
if ( theMap.IsBound( v.Current() )) {
hasInitialAssoc = true;
break;
}
}
if ( hasInitialAssoc == bool( !theMap.IsEmpty() ))
ok = FindSubShapeAssociation( comp[0], theMesh1, comp[1], theMesh2, theMap );
else {
TShapeShapeMap tmpMap;
ok = FindSubShapeAssociation( comp[0], theMesh1, comp[1], theMesh2, tmpMap );
if ( ok ) {
TopTools_DataMapIteratorOfDataMapOfShapeShape mapIt( tmpMap );
for ( ; mapIt.More(); mapIt.Next() )
theMap.Bind( mapIt.Key(), mapIt.Value());
}
}
}
}
return ok;
}
// Each edge of an edge group is shared by own faces
// ------------------------------------------------------------------
//
// map vertices to edges sharing them, avoid doubling edges in lists
TopTools_DataMapOfShapeListOfShape v2e[2];
for (int isFirst = 0; isFirst < 2; ++isFirst ) {
const TopoDS_Shape& group = isFirst ? theShape1 : theShape2;
TopTools_DataMapOfShapeListOfShape& veMap = v2e[ isFirst ? 0 : 1 ];
TopTools_MapOfShape addedEdges;
for ( TopExp_Explorer e( group, TopAbs_EDGE ); e.More(); e.Next() ) {
const TopoDS_Shape& edge = e.Current();
if ( addedEdges.Add( edge )) {
for ( TopExp_Explorer v( edge, TopAbs_VERTEX ); v.More(); v.Next()) {
const TopoDS_Shape& vertex = v.Current();
if ( !veMap.IsBound( vertex )) {
TopTools_ListOfShape l;
veMap.Bind( vertex, l );
}
veMap( vertex ).Append( edge );
}
}
}
}
while ( !v2e[0].IsEmpty() )
{
// find a bound vertex
TopoDS_Vertex V[2];
TopTools_DataMapIteratorOfDataMapOfShapeListOfShape v2eIt( v2e[0] );
for ( ; v2eIt.More(); v2eIt.Next())
if ( theMap.IsBound( v2eIt.Key() )) {
V[0] = TopoDS::Vertex( v2eIt.Key() );
V[1] = TopoDS::Vertex( theMap( V[0] ));
break;
}
if ( V[0].IsNull() )
RETURN_BAD_RESULT("No more bound vertices");
while ( !V[0].IsNull() && v2e[0].IsBound( V[0] )) {
TopTools_ListOfShape& edges0 = v2e[0]( V[0] );
TopTools_ListOfShape& edges1 = v2e[1]( V[1] );
int nbE0 = edges0.Extent(), nbE1 = edges1.Extent();
if ( nbE0 != nbE1 )
RETURN_BAD_RESULT("Different nb of edges: "<< nbE0 << " != " << nbE1);
if ( nbE0 == 1 )
{
TopoDS_Edge e0 = TopoDS::Edge( edges0.First() );
TopoDS_Edge e1 = TopoDS::Edge( edges1.First() );
v2e[0].UnBind( V[0] );
v2e[1].UnBind( V[1] );
InsertAssociation( e0, e1, theMap, bidirect );
MESSAGE("Assoc edge " << theMesh1->GetMeshDS()->ShapeToIndex( e0 )<<
" to " << theMesh2->GetMeshDS()->ShapeToIndex( e1 ));
V[0] = GetNextVertex( e0, V[0] );
V[1] = GetNextVertex( e1, V[1] );
if ( !V[0].IsNull() ) {
InsertAssociation( V[0], V[1], theMap, bidirect );
MESSAGE("Assoc vertex " << theMesh1->GetMeshDS()->ShapeToIndex( V[0] )<<
" to " << theMesh2->GetMeshDS()->ShapeToIndex( V[1] ));
}
}
else if ( nbE0 == 2 )
{
// one of edges must have both ends bound
TopoDS_Vertex v0e0 = GetNextVertex( TopoDS::Edge( edges0.First() ), V[0] );
TopoDS_Vertex v1e0 = GetNextVertex( TopoDS::Edge( edges0.Last() ), V[0] );
TopoDS_Vertex v0e1 = GetNextVertex( TopoDS::Edge( edges1.First() ), V[1] );
TopoDS_Vertex v1e1 = GetNextVertex( TopoDS::Edge( edges1.Last() ), V[1] );
TopoDS_Shape e0b, e1b, e0n, e1n, v1b; // bound and not-bound
TopoDS_Vertex v0n, v1n;
if ( theMap.IsBound( v0e0 )) {
v0n = v1e0; e0b = edges0.First(); e0n = edges0.Last(); v1b = theMap( v0e0 );
} else if ( theMap.IsBound( v1e0 )) {
v0n = v0e0; e0n = edges0.First(); e0b = edges0.Last(); v1b = theMap( v1e0 );
} else {
RETURN_BAD_RESULT("None of vertices bound");
}
if ( v1b.IsSame( v1e1 )) {
v1n = v0e1; e1n = edges1.First(); e1b = edges1.Last();
} else {
v1n = v1e1; e1b = edges1.First(); e1n = edges1.Last();
}
InsertAssociation( e0b, e1b, theMap, bidirect );
InsertAssociation( e0n, e1n, theMap, bidirect );
InsertAssociation( v0n, v1n, theMap, bidirect );
MESSAGE("Assoc edge " << theMesh1->GetMeshDS()->ShapeToIndex( e0b )<<
" to " << theMesh2->GetMeshDS()->ShapeToIndex( e1b ));
MESSAGE("Assoc edge " << theMesh1->GetMeshDS()->ShapeToIndex( e0n )<<
" to " << theMesh2->GetMeshDS()->ShapeToIndex( e1n ));
MESSAGE("Assoc vertex " << theMesh1->GetMeshDS()->ShapeToIndex( v0n )<<
" to " << theMesh2->GetMeshDS()->ShapeToIndex( v1n ));
v2e[0].UnBind( V[0] );
v2e[1].UnBind( V[1] );
V[0] = v0n;
V[1] = v1n;
}
else {
RETURN_BAD_RESULT("Not implemented");
}
}
} //while ( !v2e[0].IsEmpty() )
return true;
}
default:
RETURN_BAD_RESULT("Unexpected shape type");
} // end switch by shape type
} // end case of available initial vertex association
//----------------------------------------------------------------------
//======================================================================
// NO INITIAL VERTEX ASSOCIATION
//----------------------------------------------------------------------
//======================================================================
switch ( theShape1.ShapeType() ) {
@ -395,6 +705,7 @@ bool StdMeshers_ProjectionUtils::FindSubShapeAssociation(const TopoDS_Shape& the
{
InsertAssociation( edge1, prpEdge, theMap, bidirect); // insert with a proper orientation
}
InsertAssociation( theShape1, theShape2, theMap, bidirect );
return true; // done
}
}
@ -404,6 +715,7 @@ bool StdMeshers_ProjectionUtils::FindSubShapeAssociation(const TopoDS_Shape& the
InsertAssociation( edge1, edge2, theMap, bidirect); // insert with a proper orientation
InsertAssociation( TopExp::FirstVertex(edge1), TopExp::FirstVertex(edge2),
theMap, bidirect);
InsertAssociation( theShape1, theShape2, theMap, bidirect );
return true; // done
}
break; // try by vertex closeness
@ -454,6 +766,7 @@ bool StdMeshers_ProjectionUtils::FindSubShapeAssociation(const TopoDS_Shape& the
VV2[0] = TopExp::FirstVertex( *eIt2, true );
InsertAssociation( VV1[0], VV2[0], theMap, bidirect);
}
InsertAssociation( theShape1, theShape2, theMap, bidirect );
return true;
}
}
@ -474,8 +787,10 @@ bool StdMeshers_ProjectionUtils::FindSubShapeAssociation(const TopoDS_Shape& the
if ( vMap1.Extent() == 1 ) {
InsertAssociation( vMap1(1), vMap2(1), theMap, bidirect);
if ( theShape1.ShapeType() == TopAbs_EDGE )
if ( theShape1.ShapeType() == TopAbs_EDGE ) {
InsertAssociation( theShape1, theShape2, theMap, bidirect );
return true;
}
return FindSubShapeAssociation( theShape1, theMesh1, theShape2, theMesh2, theMap);
}
@ -504,14 +819,21 @@ bool StdMeshers_ProjectionUtils::FindSubShapeAssociation(const TopoDS_Shape& the
// get 2 linked vertices of shape 1 not belonging to an inner wire of a face
TopoDS_Shape edge = theShape1;
TopExp_Explorer expF( theShape1, TopAbs_FACE ), expE;
for ( ; expF.More(); expF.Next() ) {
if ( expF.More() ) {
for ( ; expF.More(); expF.Next() ) {
edge.Nullify();
TopoDS_Shape wire = OuterShape( TopoDS::Face( expF.Current() ), TopAbs_WIRE );
for ( expE.Init( wire, TopAbs_EDGE ); edge.IsNull() && expE.More(); expE.Next() )
if ( !IsClosedEdge( TopoDS::Edge( expE.Current() )))
edge = expE.Current();
if ( !edge.IsNull() )
break;
}
} else if (edge.ShapeType() != TopAbs_EDGE) { // no faces
edge.Nullify();
TopoDS_Shape wire = OuterShape( TopoDS::Face( expF.Current() ), TopAbs_WIRE );
for ( expE.Init( wire, TopAbs_EDGE ); edge.IsNull() && expE.More(); expE.Next() )
for ( expE.Init( theShape1, TopAbs_EDGE ); edge.IsNull() && expE.More(); expE.Next() )
if ( !IsClosedEdge( TopoDS::Edge( expE.Current() )))
edge = expE.Current();
if ( !edge.IsNull() )
break;
}
if ( edge.IsNull() || edge.ShapeType() != TopAbs_EDGE )
RETURN_BAD_RESULT("Edge not found");
@ -538,10 +860,16 @@ bool StdMeshers_ProjectionUtils::FindSubShapeAssociation(const TopoDS_Shape& the
}
}
InsertAssociation( VV1[ 0 ], VV2 [ 0 ], theMap, bidirect);
InsertAssociation( VV1[ 1 ], VV2 [ 1 ], theMap, bidirect);
if ( theShape1.ShapeType() == TopAbs_EDGE )
InsertAssociation( VV1[ 0 ], VV2[ 0 ], theMap, bidirect);
InsertAssociation( VV1[ 1 ], VV2[ 1 ], theMap, bidirect);
MESSAGE("Initial assoc VERT " << theMesh1->GetMeshDS()->ShapeToIndex( VV1[ 0 ] )<<
" to " << theMesh2->GetMeshDS()->ShapeToIndex( VV2[ 0 ] )<<
"\nand VERT " << theMesh1->GetMeshDS()->ShapeToIndex( VV1[ 1 ] )<<
" to " << theMesh2->GetMeshDS()->ShapeToIndex( VV2[ 1 ] ));
if ( theShape1.ShapeType() == TopAbs_EDGE ) {
InsertAssociation( theShape1, theShape2, theMap, bidirect );
return true;
}
return FindSubShapeAssociation( theShape1, theMesh1, theShape2, theMesh2, theMap );
}
@ -629,15 +957,15 @@ int StdMeshers_ProjectionUtils::FindFaceAssociation(const TopoDS_Face& face1,
//=======================================================================
void StdMeshers_ProjectionUtils::InitVertexAssociation( const SMESH_Hypothesis* theHyp,
TShapeShapeMap & theAssociationMap)
TShapeShapeMap & theAssociationMap,
const TopoDS_Shape& theTargetShape)
{
string hypName = theHyp->GetName();
if ( hypName == "ProjectionSource1D" ) {
const StdMeshers_ProjectionSource1D * hyp =
static_cast<const StdMeshers_ProjectionSource1D*>( theHyp );
if ( hyp->HasVertexAssociation() ) {
if ( hyp->HasVertexAssociation() )
InsertAssociation( hyp->GetSourceVertex(),hyp->GetTargetVertex(),theAssociationMap);
}
}
else if ( hypName == "ProjectionSource2D" ) {
const StdMeshers_ProjectionSource2D * hyp =
@ -680,6 +1008,9 @@ bool StdMeshers_ProjectionUtils::InsertAssociation( const TopoDS_Shape& theShape
theAssociationMap.Bind( theShape2, theShape1 );
return isNew;
}
else {
throw SALOME_Exception("StdMeshers_ProjectionUtils: attempt to associate NULL shape");
}
return false;
}
@ -693,7 +1024,10 @@ bool StdMeshers_ProjectionUtils::IsSubShape( const TopoDS_Shape& shape,
{
if ( shape.IsNull() || !aMesh )
return false;
return aMesh->GetMeshDS()->ShapeToIndex( shape );
return
aMesh->GetMeshDS()->ShapeToIndex( shape ) ||
// PAL16202
shape.ShapeType() == TopAbs_COMPOUND && aMesh->GetMeshDS()->IsGroupOfSubShapes( shape );
}
//=======================================================================
@ -749,27 +1083,43 @@ TopoDS_Edge StdMeshers_ProjectionUtils::GetEdgeByVertices( SMESH_Mesh*
//================================================================================
/*!
* \brief Return another face sharing an edge
* \param aMesh - mesh
* \param edgeToFaces - data map of descendants to ancestors
* \param edge - edge
* \param face - face
* \retval TopoDS_Face - found face
*/
//================================================================================
TopoDS_Face StdMeshers_ProjectionUtils::GetNextFace( SMESH_Mesh* mesh,
const TopoDS_Edge& edge,
const TopoDS_Face& face)
TopoDS_Face StdMeshers_ProjectionUtils::GetNextFace( const TAncestorMap& edgeToFaces,
const TopoDS_Edge& edge,
const TopoDS_Face& face)
{
if ( mesh && !edge.IsNull() && !face.IsNull() )
// if ( !edge.IsNull() && !face.IsNull() && edgeToFaces.Contains( edge ))
if ( !edge.IsNull() && edgeToFaces.Contains( edge )) // PAL16202
{
TopTools_ListIteratorOfListOfShape ancestorIt( mesh->GetAncestors( edge ));
TopTools_ListIteratorOfListOfShape ancestorIt( edgeToFaces.FindFromKey( edge ));
for ( ; ancestorIt.More(); ancestorIt.Next() )
if ( ancestorIt.Value().ShapeType() == TopAbs_FACE &&
!face.IsSame( ancestorIt.Value() ))
return TopoDS::Face( ancestorIt.Value() );
}
return TopoDS_Face();
}
//================================================================================
/*!
* \brief Return other vertex of an edge
*/
//================================================================================
TopoDS_Vertex StdMeshers_ProjectionUtils::GetNextVertex(const TopoDS_Edge& edge,
const TopoDS_Vertex& vertex)
{
TopoDS_Vertex vF,vL;
TopExp::Vertices(edge,vF,vL);
if ( vF.IsSame( vL ))
return TopoDS_Vertex();
return vertex.IsSame( vF ) ? vL : vF;
}
//================================================================================
@ -1362,9 +1712,30 @@ void StdMeshers_ProjectionUtils::SetEventListener(SMESH_subMesh* subMesh,
SMESH_subMesh* srcShapeSM = srcMesh->GetSubMesh( srcShape );
if ( srcShapeSM != subMesh )
subMesh->SetEventListener( GetSrcSubMeshListener(),
SMESH_subMeshEventListenerData::MakeData( subMesh ),
srcShapeSM );
if ( srcShapeSM != subMesh ) {
if ( srcShapeSM->GetSubMeshDS() &&
srcShapeSM->GetSubMeshDS()->IsComplexSubmesh() )
{ // source shape is a group
TopExp_Explorer it(srcShapeSM->GetSubShape(), // explore the group into subshapes...
subMesh->GetSubShape().ShapeType()); // ...of target shape type
for (; it.More(); it.Next())
{
SMESH_subMesh* srcSM = srcMesh->GetSubMesh( it.Current() );
SMESH_subMeshEventListenerData* data =
srcSM->GetEventListenerData(GetSrcSubMeshListener());
if ( data )
data->mySubMeshes.push_back( subMesh );
else
data = SMESH_subMeshEventListenerData::MakeData( subMesh );
subMesh->SetEventListener ( GetSrcSubMeshListener(), data, srcSM );
}
}
else
{
subMesh->SetEventListener( GetSrcSubMeshListener(),
SMESH_subMeshEventListenerData::MakeData( subMesh ),
srcShapeSM );
}
}
}
}

29
src/StdMeshers/StdMeshers_ProjectionUtils.hxx
View File

@ -44,15 +44,17 @@ class SMDS_MeshNode;
class SMESH_Mesh;
class SMESH_Hypothesis;
class SMESH_subMesh;
class TopTools_IndexedDataMapOfShapeListOfShape;
/*!
* \brief Class encapsulating methods common to Projection algorithms
*/
class STDMESHERS_EXPORT StdMeshers_ProjectionUtils
class StdMeshers_ProjectionUtils
{
public:
typedef TopTools_DataMapOfShapeShape TShapeShapeMap;
typedef TopTools_IndexedDataMapOfShapeListOfShape TAncestorMap;
typedef std::map<const SMDS_MeshNode*, const SMDS_MeshNode*> TNodeNodeMap;
/*!
@ -92,9 +94,11 @@ class STDMESHERS_EXPORT StdMeshers_ProjectionUtils
* \brief Insert vertex association defined by a hypothesis into a map
* \param theHyp - hypothesis
* \param theAssociationMap - association map
* \param theTargetShape - the shape theHyp assigned to
*/
static void InitVertexAssociation( const SMESH_Hypothesis* theHyp,
TShapeShapeMap & theAssociationMap);
TShapeShapeMap & theAssociationMap,
const TopoDS_Shape& theTargetShape);
/*!
* \brief Inserts association theShape1 <-> theShape2 to TShapeShapeMap
@ -115,10 +119,6 @@ class STDMESHERS_EXPORT StdMeshers_ProjectionUtils
/*!
* \brief Finds an edge by its vertices in a main shape of the mesh
* \param aMesh - the mesh
* \param V1 - vertex 1
* \param V2 - vertex 2
* \retval TopoDS_Edge - found edge
*/
static TopoDS_Edge GetEdgeByVertices( SMESH_Mesh* aMesh,
const TopoDS_Vertex& V1,
@ -126,14 +126,16 @@ class STDMESHERS_EXPORT StdMeshers_ProjectionUtils
/*!
* \brief Return another face sharing an edge
* \param aMesh - mesh
* \param edge - edge
* \param face - face
* \retval TopoDS_Face - found face
* \param edgeToFaces - data map of descendants to ancestors
*/
static TopoDS_Face GetNextFace( SMESH_Mesh* aMesh,
const TopoDS_Edge& edge,
const TopoDS_Face& face);
static TopoDS_Face GetNextFace( const TAncestorMap& edgeToFaces,
const TopoDS_Edge& edge,
const TopoDS_Face& face);
/*!
* \brief Return other vertex of an edge
*/
static TopoDS_Vertex GetNextVertex(const TopoDS_Edge& edge,
const TopoDS_Vertex& vertex);
/*!
* \brief Return an oriented propagation edge
@ -205,6 +207,7 @@ class STDMESHERS_EXPORT StdMeshers_ProjectionUtils
static void SetEventListener(SMESH_subMesh* subMesh,
TopoDS_Shape srcShape,
SMESH_Mesh* srcMesh);
};
#endif

79
src/StdMeshers/StdMeshers_Projection_1D.cxx
View File

@ -46,15 +46,17 @@
#include <BRepAdaptor_Curve.hxx>
#include <BRep_Tool.hxx>
#include <GCPnts_AbscissaPoint.hxx>
#include <TopExp.hxx>
#include <TopoDS.hxx>
#include <gp_Pnt.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include "utilities.h"
using namespace std;
#define RETURN_BAD_RESULT(msg) { MESSAGE(msg); return false; }
#define RETURN_BAD_RESULT(msg) { MESSAGE(")-: Error: " << msg); return false; }
typedef StdMeshers_ProjectionUtils TAssocTool;
@ -97,13 +99,13 @@ bool StdMeshers_Projection_1D::CheckHypothesis(SMESH_Mesh&
const list <const SMESHDS_Hypothesis * >&hyps = GetUsedHypothesis(aMesh, aShape);
if ( hyps.size() == 0 )
{
aStatus = SMESH_Hypothesis::HYP_MISSING;
aStatus = HYP_MISSING;
return false; // can't work with no hypothesis
}
if ( hyps.size() > 1 )
{
aStatus = SMESH_Hypothesis::HYP_ALREADY_EXIST;
aStatus = HYP_ALREADY_EXIST;
return false;
}
@ -111,7 +113,7 @@ bool StdMeshers_Projection_1D::CheckHypothesis(SMESH_Mesh&
string hypName = theHyp->GetName();
aStatus = SMESH_Hypothesis::HYP_OK;
aStatus = HYP_OK;
if (hypName == "ProjectionSource1D")
{
@ -130,17 +132,49 @@ bool StdMeshers_Projection_1D::CheckHypothesis(SMESH_Mesh&
// source and target vertices
if ( !TAssocTool::IsSubShape( _sourceHypo->GetSourceVertex(), srcMesh ) ||
!TAssocTool::IsSubShape( _sourceHypo->GetTargetVertex(), tgtMesh ) ||
!TAssocTool::IsSubShape( _sourceHypo->GetTargetVertex(), aShape ) ||
!TAssocTool::IsSubShape( _sourceHypo->GetSourceVertex(),
_sourceHypo->GetSourceEdge() ))
{
aStatus = SMESH_Hypothesis::HYP_BAD_PARAMETER;
aStatus = HYP_BAD_PARAMETER;
SCRUTE((TAssocTool::IsSubShape( _sourceHypo->GetSourceVertex(), srcMesh )));
SCRUTE((TAssocTool::IsSubShape( _sourceHypo->GetTargetVertex(), tgtMesh )));
SCRUTE((TAssocTool::IsSubShape( _sourceHypo->GetTargetVertex(), aShape ) ));
SCRUTE((TAssocTool::IsSubShape( _sourceHypo->GetSourceVertex(),
_sourceHypo->GetSourceEdge() )));
}
// PAL16202
else
{
bool isSub = TAssocTool::IsSubShape( _sourceHypo->GetTargetVertex(), aShape );
if ( !_sourceHypo->IsCompoundSource() ) {
if ( !isSub ) {
aStatus = HYP_BAD_PARAMETER;
SCRUTE((TAssocTool::IsSubShape( _sourceHypo->GetTargetVertex(), aShape)));
}
}
else if ( isSub ) {
// is Ok provided that source vertex is shared only by one edge
// of the source group
TopoDS_Shape sharingEdge;
TopTools_ListIteratorOfListOfShape ancestIt
( aMesh.GetAncestors( _sourceHypo->GetSourceVertex() ));
for ( ; ancestIt.More(); ancestIt.Next() )
{
const TopoDS_Shape& ancestor = ancestIt.Value();
if ( ancestor.ShapeType() == TopAbs_EDGE &&
TAssocTool::IsSubShape( ancestor, _sourceHypo->GetSourceEdge() ))
{
if ( sharingEdge.IsNull() || ancestor.IsSame( sharingEdge ))
sharingEdge = ancestor;
else {
// the second encountered
aStatus = HYP_BAD_PARAMETER;
MESSAGE("Source vertex is shared by several edges of a group");
break;
}
}
}
}
}
}
// check source edge
if ( !TAssocTool::IsSubShape( _sourceHypo->GetSourceEdge(), srcMesh ) ||
@ -154,7 +188,7 @@ bool StdMeshers_Projection_1D::CheckHypothesis(SMESH_Mesh&
}
else
{
aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE;
aStatus = HYP_INCOMPATIBLE;
}
return ( aStatus == HYP_OK );
}
@ -169,13 +203,6 @@ bool StdMeshers_Projection_1D::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape&
if ( !_sourceHypo )
return false;
TopoDS_Edge tgtEdge = TopoDS::Edge( theShape.Oriented(TopAbs_FORWARD));
TopoDS_Edge srcEdge = TopoDS::Edge( _sourceHypo->GetSourceEdge().Oriented(TopAbs_FORWARD));
TopoDS_Vertex tgtV[2], srcV[2];
TopExp::Vertices( tgtEdge, tgtV[0], tgtV[1] );
TopExp::Vertices( srcEdge, srcV[0], srcV[1] );
SMESH_Mesh * srcMesh = _sourceHypo->GetSourceMesh();
SMESH_Mesh * tgtMesh = & theMesh;
if ( !srcMesh )
@ -187,11 +214,23 @@ bool StdMeshers_Projection_1D::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape&
// Make subshapes association
// ---------------------------
TopoDS_Edge srcEdge, tgtEdge = TopoDS::Edge( theShape.Oriented(TopAbs_FORWARD));
TopoDS_Shape srcShape = _sourceHypo->GetSourceEdge().Oriented(TopAbs_FORWARD);
TAssocTool::TShapeShapeMap shape2ShapeMap;
TAssocTool::InitVertexAssociation( _sourceHypo, shape2ShapeMap );
if ( !TAssocTool::FindSubShapeAssociation( tgtEdge, tgtMesh, srcEdge, srcMesh,
shape2ShapeMap) )
return error(SMESH_Comment("Vertices association failed" ));
TAssocTool::InitVertexAssociation( _sourceHypo, shape2ShapeMap, tgtEdge );
if ( !TAssocTool::FindSubShapeAssociation( tgtEdge, tgtMesh, srcShape, srcMesh,
shape2ShapeMap) ||
!shape2ShapeMap.IsBound( tgtEdge ))
return error("Vertices association failed" );
srcEdge = TopoDS::Edge( shape2ShapeMap( tgtEdge ).Oriented(TopAbs_FORWARD));
// cout << " srcEdge #" << srcMesh->GetMeshDS()->ShapeToIndex( srcEdge )
// << " tgtEdge #" << tgtMesh->GetMeshDS()->ShapeToIndex( tgtEdge ) << endl;
TopoDS_Vertex tgtV[2], srcV[2];
TopExp::Vertices( tgtEdge, tgtV[0], tgtV[1] );
TopExp::Vertices( srcEdge, srcV[0], srcV[1] );
// ----------------------------------------------
// Assure that mesh on a source edge is computed
@ -236,7 +275,7 @@ bool StdMeshers_Projection_1D::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape&
}
bool reverse = ( srcV[0].IsSame( shape2ShapeMap( tgtV[1] )));
if ( shape2ShapeMap.IsBound( tgtEdge )) // case of closed edge
if ( tgtV[0].IsSame( tgtV[1] )) // case of closed edge
reverse = ( shape2ShapeMap( tgtEdge ).Orientation() == TopAbs_REVERSED );
if ( reverse ) // reverse lengths of segments
std::reverse( lengths.begin(), lengths.end() );

44
src/StdMeshers/StdMeshers_Projection_2D.cxx
View File

@ -46,16 +46,16 @@
#include "utilities.h"
#include <TopExp.hxx>
#include <TopoDS.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <BRep_Tool.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopoDS.hxx>
using namespace std;
#define RETURN_BAD_RESULT(msg) { MESSAGE(msg); return false; }
#define RETURN_BAD_RESULT(msg) { MESSAGE(")-: Error: " << msg); return false; }
typedef StdMeshers_ProjectionUtils TAssocTool;
@ -144,13 +144,17 @@ bool StdMeshers_Projection_2D::CheckHypothesis(SMESH_Mesh&
// target vertices
edge = TAssocTool::GetEdgeByVertices
( tgtMesh, _sourceHypo->GetTargetVertex(1), _sourceHypo->GetTargetVertex(2) );
if ( edge.IsNull() ||
!TAssocTool::IsSubShape( edge, tgtMesh ) ||
!TAssocTool::IsSubShape( edge, theShape ))
if ( edge.IsNull() || !TAssocTool::IsSubShape( edge, tgtMesh ))
{
theStatus = HYP_BAD_PARAMETER;
SCRUTE((edge.IsNull()));
SCRUTE((TAssocTool::IsSubShape( edge, tgtMesh )));
}
// PAL16203
else if ( !_sourceHypo->IsCompoundSource() &&
!TAssocTool::IsSubShape( edge, theShape ))
{
theStatus = HYP_BAD_PARAMETER;
SCRUTE((TAssocTool::IsSubShape( edge, theShape )));
}
}
@ -365,9 +369,6 @@ bool StdMeshers_Projection_2D::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape&
if ( !_sourceHypo )
return false;
TopoDS_Face tgtFace = TopoDS::Face( theShape.Oriented(TopAbs_FORWARD));
TopoDS_Face srcFace = TopoDS::Face( _sourceHypo->GetSourceFace().Oriented(TopAbs_FORWARD));
SMESH_Mesh * srcMesh = _sourceHypo->GetSourceMesh();
SMESH_Mesh * tgtMesh = & theMesh;
if ( !srcMesh )
@ -375,19 +376,22 @@ bool StdMeshers_Projection_2D::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape&
SMESHDS_Mesh * meshDS = theMesh.GetMeshDS();
SMESH_MesherHelper helper( theMesh );
helper.SetSubShape( tgtFace );
// ---------------------------
// Make subshapes association
// ---------------------------
TopoDS_Face tgtFace = TopoDS::Face( theShape.Oriented(TopAbs_FORWARD));
TopoDS_Shape srcShape = _sourceHypo->GetSourceFace().Oriented(TopAbs_FORWARD);
TAssocTool::TShapeShapeMap shape2ShapeMap;
TAssocTool::InitVertexAssociation( _sourceHypo, shape2ShapeMap );
if ( !TAssocTool::FindSubShapeAssociation( tgtFace, tgtMesh, srcFace, srcMesh,
shape2ShapeMap) )
TAssocTool::InitVertexAssociation( _sourceHypo, shape2ShapeMap, tgtFace );
if ( !TAssocTool::FindSubShapeAssociation( tgtFace, tgtMesh, srcShape, srcMesh,
shape2ShapeMap) ||
!shape2ShapeMap.IsBound( tgtFace ))
return error(COMPERR_BAD_SHAPE,"Topology of source and target faces seems different" );
TopoDS_Face srcFace = TopoDS::Face( shape2ShapeMap( tgtFace ).Oriented(TopAbs_FORWARD));
// ----------------------------------------------
// Assure that mesh on a source Face is computed
// ----------------------------------------------
@ -438,7 +442,8 @@ bool StdMeshers_Projection_2D::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape&
if ( nbEdgesInWires.front() > 1 ) // possible to find out
{
TopoDS_Edge srcE1 = srcEdges.front(), tgtE1 = tgtEdges.front();
reverse = ( ! srcE1.IsSame( shape2ShapeMap( tgtE1 )));
TopoDS_Shape srcE1bis = shape2ShapeMap( tgtE1 );
reverse = ( ! srcE1.IsSame( srcE1bis ));
}
else if ( nbEdgesInWires.front() == 1 )
{
@ -479,6 +484,9 @@ bool StdMeshers_Projection_2D::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape&
SMESH_MeshEditor editor( tgtMesh );
SMESH_MeshEditor::TListOfListOfNodes groupsOfNodes;
SMESH_MesherHelper helper( theMesh );
helper.SetSubShape( tgtFace );
// Make groups of nodes to merge
// loop on edge and vertex submeshes of a target face

8
src/StdMeshers_I/StdMeshers_ProjectionSource1D_i.cxx
View File

@ -26,6 +26,8 @@
// Module : SMESH
// $Header$
using namespace std;
#include "StdMeshers_ProjectionSource1D_i.hxx"
#include "SMESH_Gen_i.hxx"
@ -37,8 +39,6 @@
#include "StdMeshers_ObjRefUlils.hxx"
using namespace std;
//=============================================================================
/*!
* StdMeshers_ProjectionSource1D_i::StdMeshers_ProjectionSource1D_i
@ -74,7 +74,7 @@ StdMeshers_ProjectionSource1D_i::~StdMeshers_ProjectionSource1D_i()
//=============================================================================
/*!
* Sets source <edge> to take a mesh pattern from
* Sets source <edge> or a group containing edges to take a mesh pattern from
*/
//=============================================================================
@ -165,7 +165,7 @@ SMESH::SMESH_Mesh_ptr StdMeshers_ProjectionSource1D_i::GetSourceMesh()
//=============================================================================
/*!
* Returns the source edge
* Returns the source edge or a group containing edge
*/
//=============================================================================

4
src/StdMeshers_I/StdMeshers_ProjectionSource1D_i.hxx
View File

@ -59,13 +59,13 @@ public:
virtual ~StdMeshers_ProjectionSource1D_i();
/*!
* Sets source <edge> to take a mesh pattern from
* Sets source <edge> or a group containing edges to take a mesh pattern from
*/
void SetSourceEdge(GEOM::GEOM_Object_ptr edge)
throw ( SALOME::SALOME_Exception );
/*!
* Returns the source edge
* Returns the source edge or a group containing edges
*/
GEOM::GEOM_Object_ptr GetSourceEdge();