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

0020279: [CEA 334] control the "random" use when using mesh algorithms

Browse Source 
1) delete temporary faces in destructor
   2) bind created pyramids to shape
   3) create quadratic pyramids when necessary
   4) sort faces by IDs
This commit is contained in:
eap 2009-05-19 15:40:53 +00:00
parent 58e6fd99b6
commit 318d07b4db
1 changed files with 84 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

176
src/StdMeshers/StdMeshers_QuadToTriaAdaptor.cxx
View File

@ -27,19 +27,18 @@
// //
#include "StdMeshers_QuadToTriaAdaptor.hxx" #include "StdMeshers_QuadToTriaAdaptor.hxx"
//#include <TColgp_HArray1OfPnt.hxx> #include <SMDS_FaceOfNodes.hxx>
//#include <TColgp_HArray1OfVec.hxx> #include <SMESH_Algo.hxx>
#include <SMESH_MesherHelper.hxx>
#include <IntAna_IntConicQuad.hxx>
#include <IntAna_Quadric.hxx>
#include <TColStd_SequenceOfInteger.hxx>
#include <TColgp_HSequenceOfPnt.hxx>
#include <TopExp_Explorer.hxx> #include <TopExp_Explorer.hxx>
#include <TopoDS.hxx> #include <TopoDS.hxx>
#include <SMESH_Algo.hxx>
#include <TColgp_HSequenceOfPnt.hxx>
#include <TColStd_MapOfInteger.hxx>
#include <TColStd_HSequenceOfInteger.hxx>
#include <IntAna_Quadric.hxx>
#include <IntAna_IntConicQuad.hxx>
#include <gp_Lin.hxx> #include <gp_Lin.hxx>
#include <gp_Pln.hxx> #include <gp_Pln.hxx>
#include <SMDS_FaceOfNodes.hxx>
#include <NCollection_Array1.hxx> #include <NCollection_Array1.hxx>
typedef NCollection_Array1<TColStd_SequenceOfInteger> StdMeshers_Array1OfSequenceOfInteger; typedef NCollection_Array1<TColStd_SequenceOfInteger> StdMeshers_Array1OfSequenceOfInteger;
@ -62,7 +61,23 @@ StdMeshers_QuadToTriaAdaptor::StdMeshers_QuadToTriaAdaptor()
//================================================================================ //================================================================================
StdMeshers_QuadToTriaAdaptor::~StdMeshers_QuadToTriaAdaptor() StdMeshers_QuadToTriaAdaptor::~StdMeshers_QuadToTriaAdaptor()
{} {
// delete temporary faces
map< const SMDS_MeshElement*, list<const SMDS_FaceOfNodes*> >::iterator
f_f = myResMap.begin(), ffEnd = myResMap.end();
for ( ; f_f != ffEnd; ++f_f )
{
list<const SMDS_FaceOfNodes*>& fList = f_f->second;
list<const SMDS_FaceOfNodes*>::iterator f = fList.begin(), fEnd = fList.end();
for ( ; f != fEnd; ++f )
delete *f;
}
myResMap.clear();
// TF2PyramMap::iterator itp = myMapFPyram.begin();
// for(; itp!=myMapFPyram.end(); itp++)
// cout << itp->second << endl;
}
//======================================================================= //=======================================================================
@ -285,18 +300,18 @@ static bool CompareTrias(const SMDS_MeshElement* F1,const SMDS_MeshElement* F2)
//function : IsDegenarate //function : IsDegenarate
//purpose : Auxilare for Preparation() //purpose : Auxilare for Preparation()
//======================================================================= //=======================================================================
static int IsDegenarate(const Handle(TColgp_HArray1OfPnt)& PN) // static int IsDegenarate(const Handle(TColgp_HArray1OfPnt)& PN)
{ // {
int i = 1; // int i = 1;
for(; i<4; i++) { // for(; i<4; i++) {
int j = i+1; // int j = i+1;
for(; j<=4; j++) { // for(; j<=4; j++) {
if( PN->Value(i).Distance(PN->Value(j)) < 1.e-6 ) // if( PN->Value(i).Distance(PN->Value(j)) < 1.e-6 )
return j; // return j;
} // }
} // }
return 0; // return 0;
} // }
//======================================================================= //=======================================================================
@ -307,8 +322,8 @@ static int IsDegenarate(const Handle(TColgp_HArray1OfPnt)& PN)
// 2 if given face is degenerate quad (two nodes are coincided) // 2 if given face is degenerate quad (two nodes are coincided)
//======================================================================= //=======================================================================
int StdMeshers_QuadToTriaAdaptor::Preparation(const SMDS_MeshElement* face, int StdMeshers_QuadToTriaAdaptor::Preparation(const SMDS_MeshElement* face,
Handle(TColgp_HArray1OfPnt) PN, Handle(TColgp_HArray1OfPnt)& PN,
Handle(TColgp_HArray1OfVec) VN, Handle(TColgp_HArray1OfVec)& VN,
std::vector<const SMDS_MeshNode*>& FNodes, std::vector<const SMDS_MeshNode*>& FNodes,
gp_Pnt& PC, gp_Vec& VNorm) gp_Pnt& PC, gp_Vec& VNorm)
{ {
@ -427,6 +442,9 @@ bool StdMeshers_QuadToTriaAdaptor::Compute(SMESH_Mesh& aMesh, const TopoDS_Shape
myMapFPyram.clear(); myMapFPyram.clear();
SMESHDS_Mesh * meshDS = aMesh.GetMeshDS(); SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
SMESH_MesherHelper helper(aMesh);
helper.IsQuadraticSubMesh(aShape);
helper.SetElementsOnShape( true );
for (TopExp_Explorer exp(aShape,TopAbs_FACE);exp.More();exp.Next()) { for (TopExp_Explorer exp(aShape,TopAbs_FACE);exp.More();exp.Next()) {
const TopoDS_Shape& aShapeFace = exp.Current(); const TopoDS_Shape& aShapeFace = exp.Current();
@ -481,9 +499,7 @@ bool StdMeshers_QuadToTriaAdaptor::Compute(SMESH_Mesh& aMesh, const TopoDS_Shape
double height = PCbest.Distance(PC); double height = PCbest.Distance(PC);
if(height<1.e-6) { if(height<1.e-6) {
// create new PCbest using a bit shift along VNorm // create new PCbest using a bit shift along VNorm
PCbest = gp_Pnt( PC.X() + VNorm.X()*0.001, PCbest = PC.XYZ() + VNorm.XYZ() * 0.001;
PC.Y() + VNorm.Y()*0.001,
PC.Z() + VNorm.Z()*0.001);
} }
else { else {
// check possible intersection with other faces // check possible intersection with other faces
@ -494,27 +510,23 @@ bool StdMeshers_QuadToTriaAdaptor::Compute(SMESH_Mesh& aMesh, const TopoDS_Shape
//cout<<" PCbest("<<PCbest.X()<<","<<PCbest.Y()<<","<<PCbest.Z()<<")"<<endl; //cout<<" PCbest("<<PCbest.X()<<","<<PCbest.Y()<<","<<PCbest.Z()<<")"<<endl;
double dist = PC.Distance(Pint)/3.; double dist = PC.Distance(Pint)/3.;
gp_Dir aDir(gp_Vec(PC,PCbest)); gp_Dir aDir(gp_Vec(PC,PCbest));
PCbest = gp_Pnt( PC.X() + aDir.X()*dist, PCbest = PC.XYZ() + aDir.XYZ() * dist;
PC.Y() + aDir.Y()*dist,
PC.Z() + aDir.Z()*dist );
} }
else { else {
gp_Vec VB(PC,PCbest); gp_Vec VB(PC,PCbest);
gp_Pnt PCbestTmp(PC.X()+VB.X()*3, PC.X()+VB.X()*3, PC.X()+VB.X()*3); gp_Pnt PCbestTmp = PC.XYZ() + VB.XYZ() * 3.0;
bool check = CheckIntersection(PCbestTmp, PC, Pint, aMesh, aShape, aShapeFace); bool check = CheckIntersection(PCbestTmp, PC, Pint, aMesh, aShape, aShapeFace);
if(check) { if(check) {
double dist = PC.Distance(Pint)/3.; double dist = PC.Distance(Pint)/3.;
if(dist<height) { if(dist<height) {
gp_Dir aDir(gp_Vec(PC,PCbest)); gp_Dir aDir(gp_Vec(PC,PCbest));
PCbest = gp_Pnt( PC.X() + aDir.X()*dist, PCbest = PC.XYZ() + aDir.XYZ() * dist;
PC.Y() + aDir.Y()*dist,
PC.Z() + aDir.Z()*dist );
} }
} }
} }
} }
// create node for PCbest // create node for PCbest
SMDS_MeshNode* NewNode = meshDS->AddNode( PCbest.X(), PCbest.Y(), PCbest.Z() ); SMDS_MeshNode* NewNode = helper.AddNode( PCbest.X(), PCbest.Y(), PCbest.Z() );
// add triangles to result map // add triangles to result map
std::list<const SMDS_FaceOfNodes*> aList; std::list<const SMDS_FaceOfNodes*> aList;
for(i=0; i<4; i++) { for(i=0; i<4; i++) {
@ -524,7 +536,7 @@ bool StdMeshers_QuadToTriaAdaptor::Compute(SMESH_Mesh& aMesh, const TopoDS_Shape
myResMap.insert(make_pair(face,aList)); myResMap.insert(make_pair(face,aList));
// create pyramid // create pyramid
SMDS_MeshVolume* aPyram = SMDS_MeshVolume* aPyram =
meshDS->AddVolume( FNodes[0], FNodes[1], FNodes[2], FNodes[3], NewNode ); helper.AddVolume( FNodes[0], FNodes[1], FNodes[2], FNodes[3], NewNode );
myMapFPyram.insert(make_pair(face,aPyram)); myMapFPyram.insert(make_pair(face,aPyram));
} // end loop on elements on a face } // end loop on elements on a face
} }
@ -543,13 +555,20 @@ bool StdMeshers_QuadToTriaAdaptor::Compute(SMESH_Mesh& aMesh)
{ {
myResMap.clear(); myResMap.clear();
myMapFPyram.clear(); myMapFPyram.clear();
SMESH_MesherHelper helper(aMesh);
helper.IsQuadraticSubMesh(aMesh.GetShapeToMesh());
helper.SetElementsOnShape( true );
SMESHDS_Mesh * meshDS = aMesh.GetMeshDS(); SMESHDS_Mesh * meshDS = aMesh.GetMeshDS();
SMDS_FaceIteratorPtr itFace = meshDS->facesIterator(); SMDS_FaceIteratorPtr fIt = meshDS->facesIterator();
TIDSortedElemSet sortedFaces; // 0020279: control the "random" use when using mesh algorithms
while( fIt->more()) sortedFaces.insert( fIt->next() );
while(itFace->more()) { TIDSortedElemSet::iterator itFace = sortedFaces.begin(), fEnd = sortedFaces.end();
const SMDS_MeshElement* face = itFace->next(); for ( ; itFace != fEnd; ++itFace )
{
const SMDS_MeshElement* face = *itFace;
if ( !face ) continue; if ( !face ) continue;
//cout<<endl<<"================= face->GetID() = "<<face->GetID()<<endl; //cout<<endl<<"================= face->GetID() = "<<face->GetID()<<endl;
// preparation step using face info // preparation step using face info
@ -572,13 +591,8 @@ bool StdMeshers_QuadToTriaAdaptor::Compute(SMESH_Mesh& aMesh)
double tmp = PN->Value(1).Distance(PN->Value(2)) + double tmp = PN->Value(1).Distance(PN->Value(2)) +
PN->Value(2).Distance(PN->Value(3)); PN->Value(2).Distance(PN->Value(3));
gp_Dir tmpDir(VNorm); gp_Pnt Ptmp1 = PC.XYZ() + VNorm.XYZ() * tmp * 1.e6;
gp_Pnt Ptmp1( PC.X() + tmpDir.X()*tmp*1.e6, gp_Pnt Ptmp2 = PC.XYZ() - VNorm.XYZ() * tmp * 1.e6;
PC.Y() + tmpDir.Y()*tmp*1.e6,
PC.Z() + tmpDir.Z()*tmp*1.e6 );
gp_Pnt Ptmp2( PC.X() + tmpDir.Reversed().X()*tmp*1.e6,
PC.Y() + tmpDir.Reversed().Y()*tmp*1.e6,
PC.Z() + tmpDir.Reversed().Z()*tmp*1.e6 );
// check intersection for Ptmp1 and Ptmp2 // check intersection for Ptmp1 and Ptmp2
bool IsRev = false; bool IsRev = false;
bool IsOK1 = false; bool IsOK1 = false;
@ -586,9 +600,8 @@ bool StdMeshers_QuadToTriaAdaptor::Compute(SMESH_Mesh& aMesh)
double dist1 = RealLast(); double dist1 = RealLast();
double dist2 = RealLast(); double dist2 = RealLast();
gp_Pnt Pres1,Pres2; gp_Pnt Pres1,Pres2;
SMDS_FaceIteratorPtr itf = meshDS->facesIterator(); for (TIDSortedElemSet::iterator itF = sortedFaces.begin(); itF != fEnd; ++itF ) {
while(itf->more()) { const SMDS_MeshElement* F = *itF;
const SMDS_MeshElement* F = itf->next();
if(F==face) continue; if(F==face) continue;
Handle(TColgp_HSequenceOfPnt) aContour = new TColgp_HSequenceOfPnt; Handle(TColgp_HSequenceOfPnt) aContour = new TColgp_HSequenceOfPnt;
SMDS_ElemIteratorPtr nodeIt = F->nodesIterator(); SMDS_ElemIteratorPtr nodeIt = F->nodesIterator();
@ -665,9 +678,7 @@ bool StdMeshers_QuadToTriaAdaptor::Compute(SMESH_Mesh& aMesh)
double height = PCbest.Distance(PC); double height = PCbest.Distance(PC);
if(height<1.e-6) { if(height<1.e-6) {
// create new PCbest using a bit shift along VNorm // create new PCbest using a bit shift along VNorm
PCbest = gp_Pnt( PC.X() + VNorm.X()*0.001, PCbest = PC.XYZ() + VNorm.XYZ() * 0.001;
PC.Y() + VNorm.Y()*0.001,
PC.Z() + VNorm.Z()*0.001);
height = PCbest.Distance(PC); height = PCbest.Distance(PC);
} }
//cout<<" PCbest("<<PCbest.X()<<","<<PCbest.Y()<<","<<PCbest.Z()<<")"<<endl; //cout<<" PCbest("<<PCbest.X()<<","<<PCbest.Y()<<","<<PCbest.Z()<<")"<<endl;
@ -676,12 +687,8 @@ bool StdMeshers_QuadToTriaAdaptor::Compute(SMESH_Mesh& aMesh)
double tmp = PN->Value(1).Distance(PN->Value(3)) + double tmp = PN->Value(1).Distance(PN->Value(3)) +
PN->Value(2).Distance(PN->Value(4)); PN->Value(2).Distance(PN->Value(4));
gp_Dir tmpDir(V1); gp_Dir tmpDir(V1);
gp_Pnt Ptmp1( PC.X() + tmpDir.X()*tmp*1.e6, gp_Pnt Ptmp1 = PC.XYZ() + tmpDir.XYZ() * tmp * 1.e6;
PC.Y() + tmpDir.Y()*tmp*1.e6, gp_Pnt Ptmp2 = PC.XYZ() - tmpDir.XYZ() * tmp * 1.e6;
PC.Z() + tmpDir.Z()*tmp*1.e6 );
gp_Pnt Ptmp2( PC.X() + tmpDir.Reversed().X()*tmp*1.e6,
PC.Y() + tmpDir.Reversed().Y()*tmp*1.e6,
PC.Z() + tmpDir.Reversed().Z()*tmp*1.e6 );
// check intersection for Ptmp1 and Ptmp2 // check intersection for Ptmp1 and Ptmp2
bool IsRev = false; bool IsRev = false;
bool IsOK1 = false; bool IsOK1 = false;
@ -689,9 +696,8 @@ bool StdMeshers_QuadToTriaAdaptor::Compute(SMESH_Mesh& aMesh)
double dist1 = RealLast(); double dist1 = RealLast();
double dist2 = RealLast(); double dist2 = RealLast();
gp_Pnt Pres1,Pres2; gp_Pnt Pres1,Pres2;
SMDS_FaceIteratorPtr itf = meshDS->facesIterator(); for (TIDSortedElemSet::iterator itF = sortedFaces.begin(); itF != fEnd; ++itF ) {
while(itf->more()) { const SMDS_MeshElement* F = *itF;
const SMDS_MeshElement* F = itf->next();
if(F==face) continue; if(F==face) continue;
Handle(TColgp_HSequenceOfPnt) aContour = new TColgp_HSequenceOfPnt; Handle(TColgp_HSequenceOfPnt) aContour = new TColgp_HSequenceOfPnt;
SMDS_ElemIteratorPtr nodeIt = F->nodesIterator(); SMDS_ElemIteratorPtr nodeIt = F->nodesIterator();
@ -734,9 +740,7 @@ bool StdMeshers_QuadToTriaAdaptor::Compute(SMESH_Mesh& aMesh)
double tmp = PC.Distance(Pres1)/3.; double tmp = PC.Distance(Pres1)/3.;
if( height > tmp ) { if( height > tmp ) {
height = tmp; height = tmp;
PCbest = gp_Pnt( PC.X() + tmpDir.X()*height, PCbest = PC.XYZ() + tmpDir.XYZ() * height;
PC.Y() + tmpDir.Y()*height,
PC.Z() + tmpDir.Z()*height );
} }
} }
else if( !IsOK1 && IsOK2 ) { else if( !IsOK1 && IsOK2 ) {
@ -744,9 +748,7 @@ bool StdMeshers_QuadToTriaAdaptor::Compute(SMESH_Mesh& aMesh)
IsRev = true; IsRev = true;
double tmp = PC.Distance(Pres2)/3.; double tmp = PC.Distance(Pres2)/3.;
if( height > tmp ) height = tmp; if( height > tmp ) height = tmp;
PCbest = gp_Pnt( PC.X() + tmpDir.Reversed().X()*height, PCbest = PC.XYZ() - tmpDir.XYZ() * height;
PC.Y() + tmpDir.Reversed().Y()*height,
PC.Z() + tmpDir.Reversed().Z()*height );
} }
else { // IsOK1 && IsOK2 else { // IsOK1 && IsOK2
double tmp1 = PC.Distance(Pres1)/3.; double tmp1 = PC.Distance(Pres1)/3.;
@ -755,23 +757,19 @@ bool StdMeshers_QuadToTriaAdaptor::Compute(SMESH_Mesh& aMesh)
// using existed direction // using existed direction
if( height > tmp1 ) { if( height > tmp1 ) {
height = tmp1; height = tmp1;
PCbest = gp_Pnt( PC.X() + tmpDir.X()*height, PCbest = PC.XYZ() + tmpDir.XYZ() * height;
PC.Y() + tmpDir.Y()*height,
PC.Z() + tmpDir.Z()*height );
} }
} }
else { else {
// using opposite direction // using opposite direction
IsRev = true; IsRev = true;
if( height > tmp2 ) height = tmp2; if( height > tmp2 ) height = tmp2;
PCbest = gp_Pnt( PC.X() + tmpDir.Reversed().X()*height, PCbest = PC.XYZ() - tmpDir.XYZ() * height;
PC.Y() + tmpDir.Reversed().Y()*height,
PC.Z() + tmpDir.Reversed().Z()*height );
} }
} }
// create node for PCbest // create node for PCbest
SMDS_MeshNode* NewNode = meshDS->AddNode( PCbest.X(), PCbest.Y(), PCbest.Z() ); SMDS_MeshNode* NewNode = helper.AddNode( PCbest.X(), PCbest.Y(), PCbest.Z() );
// add triangles to result map // add triangles to result map
std::list<const SMDS_FaceOfNodes*> aList; std::list<const SMDS_FaceOfNodes*> aList;
for(i=0; i<4; i++) { for(i=0; i<4; i++) {
@ -786,9 +784,9 @@ bool StdMeshers_QuadToTriaAdaptor::Compute(SMESH_Mesh& aMesh)
// create pyramid // create pyramid
SMDS_MeshVolume* aPyram; SMDS_MeshVolume* aPyram;
if(IsRev) if(IsRev)
aPyram = meshDS->AddVolume( FNodes[0], FNodes[1], FNodes[2], FNodes[3], NewNode ); aPyram = helper.AddVolume( FNodes[0], FNodes[1], FNodes[2], FNodes[3], NewNode );
else else
aPyram = meshDS->AddVolume( FNodes[0], FNodes[3], FNodes[2], FNodes[1], NewNode ); aPyram = helper.AddVolume( FNodes[0], FNodes[3], FNodes[2], FNodes[1], NewNode );
myMapFPyram.insert(make_pair(face,aPyram)); myMapFPyram.insert(make_pair(face,aPyram));
} // end loop on elements on a face } // end loop on elements on a face
@ -811,10 +809,9 @@ bool StdMeshers_QuadToTriaAdaptor::Compute2ndPart(SMESH_Mesh& aMesh)
if(NbPyram==0) if(NbPyram==0)
return true; return true;
std::vector< const SMDS_MeshElement* > Pyrams(NbPyram); vector< const SMDS_MeshElement* > Pyrams(NbPyram);
std::vector< const SMDS_MeshElement* > Faces(NbPyram); vector< const SMDS_MeshElement* > Faces(NbPyram);
std::map< const SMDS_MeshElement*, TF2PyramMap::iterator itp = myMapFPyram.begin();
const SMDS_MeshElement* >::iterator itp = myMapFPyram.begin();
int i = 0; int i = 0;
for(; itp!=myMapFPyram.end(); itp++, i++) { for(; itp!=myMapFPyram.end(); itp++, i++) {
Faces[i] = (*itp).first; Faces[i] = (*itp).first;
@ -845,7 +842,7 @@ bool StdMeshers_QuadToTriaAdaptor::Compute2ndPart(SMESH_Mesh& aMesh)
int nbI = aMergesI.Length(); int nbI = aMergesI.Length();
const TColStd_SequenceOfInteger& aMergesJ = MergesInfo.Value(j); const TColStd_SequenceOfInteger& aMergesJ = MergesInfo.Value(j);
int nbJ = aMergesJ.Length(); int nbJ = aMergesJ.Length();
// check if two pyramids already merged
int k = 2; int k = 2;
bool NeedCont = false; bool NeedCont = false;
for(; k<=nbI; k++) { for(; k<=nbI; k++) {
@ -854,7 +851,7 @@ bool StdMeshers_QuadToTriaAdaptor::Compute2ndPart(SMESH_Mesh& aMesh)
break; break;
} }
} }
if(NeedCont) continue; if(NeedCont) continue; // already merged
const SMDS_MeshElement* Prm2 = Pyrams[j]; const SMDS_MeshElement* Prm2 = Pyrams[j];
nIt = Prm2->nodesIterator(); nIt = Prm2->nodesIterator();
@ -872,9 +869,7 @@ bool StdMeshers_QuadToTriaAdaptor::Compute2ndPart(SMESH_Mesh& aMesh)
gp_Pnt Pint; gp_Pnt Pint;
for(k=0; k<4; k++) { for(k=0; k<4; k++) {
gp_Vec Vtmp(Ps1[k],Ps1[4]); gp_Vec Vtmp(Ps1[k],Ps1[4]);
gp_Pnt Pshift( Ps1[k].X() + Vtmp.X()*0.01, gp_Pnt Pshift = Ps1[k].XYZ() + Vtmp.XYZ() * 0.01;
Ps1[k].Y() + Vtmp.Y()*0.01,
Ps1[k].Z() + Vtmp.Z()*0.01 );
int m=0; int m=0;
for(; m<3; m++) { for(; m<3; m++) {
if( HasIntersection3( Pshift, Ps1[4], Pint, Ps2[m], Ps2[m+1], Ps2[4]) ) { if( HasIntersection3( Pshift, Ps1[4], Pint, Ps2[m], Ps2[m+1], Ps2[4]) ) {
@ -890,9 +885,7 @@ bool StdMeshers_QuadToTriaAdaptor::Compute2ndPart(SMESH_Mesh& aMesh)
if(!hasInt) { if(!hasInt) {
for(k=0; k<4; k++) { for(k=0; k<4; k++) {
gp_Vec Vtmp(Ps2[k],Ps2[4]); gp_Vec Vtmp(Ps2[k],Ps2[4]);
gp_Pnt Pshift( Ps2[k].X() + Vtmp.X()*0.01, gp_Pnt Pshift = Ps2[k].XYZ() + Vtmp.XYZ() * 0.01;
Ps2[k].Y() + Vtmp.Y()*0.01,
Ps2[k].Z() + Vtmp.Z()*0.01 );
int m=0; int m=0;
for(; m<3; m++) { for(; m<3; m++) {
if( HasIntersection3( Pshift, Ps2[4], Pint, Ps1[m], Ps1[m+1], Ps1[4]) ) { if( HasIntersection3( Pshift, Ps2[4], Pint, Ps1[m], Ps1[m+1], Ps1[4]) ) {
@ -1129,16 +1122,15 @@ bool StdMeshers_QuadToTriaAdaptor::Compute2ndPart(SMESH_Mesh& aMesh)
* \brief Return list of created triangles for given face * \brief Return list of created triangles for given face
*/ */
//================================================================================ //================================================================================
std::list<const SMDS_FaceOfNodes*> StdMeshers_QuadToTriaAdaptor::GetTriangles const std::list<const SMDS_FaceOfNodes*>* StdMeshers_QuadToTriaAdaptor::GetTriangles
(const SMDS_MeshElement* aFace) (const SMDS_MeshElement* aFace)
{ {
std::list<const SMDS_FaceOfNodes*> aRes;
std::map< const SMDS_MeshElement*, std::map< const SMDS_MeshElement*,
std::list<const SMDS_FaceOfNodes*> >::iterator it = myResMap.find(aFace); std::list<const SMDS_FaceOfNodes*> >::iterator it = myResMap.find(aFace);
if( it != myResMap.end() ) { if( it != myResMap.end() ) {
return it->second; return & it->second;
} }
return aRes; return 0;
} }